tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'net-sched-sch_cake-annotate-data-races-in-cake_dump_stats-series'

Eric Dumazet says:

====================
net/sched: sch_cake: annotate data-races in cake_dump_stats() (series)

cake_dump_stats() runs without qdisc spinlock being held.

This mini series adds missing READ_ONCE()/WRITE_ONCE() annotations.

Original patch was too big, splitting it eases code review.
====================

Link: https://patch.msgid.link/20260427083606.459355-1-edumazet@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

Jakub Kicinski 403e7e34 aa6c6d9e

+113 -104
+113 -104
net/sched/sch_cake.c
··· 813 813 i++, k = (k + 1) % CAKE_SET_WAYS) { 814 814 if (q->tags[outer_hash + k] == flow_hash) { 815 815 if (i) 816 - q->way_hits++; 816 + WRITE_ONCE(q->way_hits, q->way_hits + 1); 817 817 818 818 if (!q->flows[outer_hash + k].set) { 819 819 /* need to increment host refcnts */ ··· 831 831 for (i = 0; i < CAKE_SET_WAYS; 832 832 i++, k = (k + 1) % CAKE_SET_WAYS) { 833 833 if (!q->flows[outer_hash + k].set) { 834 - q->way_misses++; 834 + WRITE_ONCE(q->way_misses, q->way_misses + 1); 835 835 allocate_src = cake_dsrc(flow_mode); 836 836 allocate_dst = cake_ddst(flow_mode); 837 837 goto found; ··· 841 841 /* With no empty queues, default to the original 842 842 * queue, accept the collision, update the host tags. 843 843 */ 844 - q->way_collisions++; 844 + WRITE_ONCE(q->way_collisions, q->way_collisions + 1); 845 845 allocate_src = cake_dsrc(flow_mode); 846 846 allocate_dst = cake_ddst(flow_mode); 847 847 ··· 1379 1379 len -= off; 1380 1380 1381 1381 if (qd->max_netlen < len) 1382 - qd->max_netlen = len; 1382 + WRITE_ONCE(qd->max_netlen, len); 1383 1383 if (qd->min_netlen > len) 1384 - qd->min_netlen = len; 1384 + WRITE_ONCE(qd->min_netlen, len); 1385 1385 1386 1386 len += q->rate_overhead; 1387 1387 ··· 1401 1401 } 1402 1402 1403 1403 if (qd->max_adjlen < len) 1404 - qd->max_adjlen = len; 1404 + WRITE_ONCE(qd->max_adjlen, len); 1405 1405 if (qd->min_adjlen > len) 1406 - qd->min_adjlen = len; 1406 + WRITE_ONCE(qd->min_adjlen, len); 1407 1407 1408 1408 return len; 1409 1409 } ··· 1416 1416 u16 segs = qdisc_pkt_segs(skb); 1417 1417 u32 len = qdisc_pkt_len(skb); 1418 1418 1419 - q->avg_netoff = cake_ewma(q->avg_netoff, off << 16, 8); 1419 + WRITE_ONCE(q->avg_netoff, cake_ewma(q->avg_netoff, off << 16, 8)); 1420 1420 1421 1421 if (segs == 1) 1422 1422 return cake_calc_overhead(q, len, off); ··· 1590 1590 } 1591 1591 1592 1592 if (cobalt_queue_full(&flow->cvars, &b->cparams, now)) 1593 - b->unresponsive_flow_count++; 1593 + WRITE_ONCE(b->unresponsive_flow_count, 1594 + b->unresponsive_flow_count + 1); 1594 1595 1595 1596 len = qdisc_pkt_len(skb); 1596 1597 q->buffer_used -= skb->truesize; 1597 1598 b->backlogs[idx] -= len; 1598 - b->tin_backlog -= len; 1599 + WRITE_ONCE(b->tin_backlog, b->tin_backlog - len); 1599 1600 sch->qstats.backlog -= len; 1600 1601 1601 1602 flow->dropped++; 1602 - b->tin_dropped++; 1603 + WRITE_ONCE(b->tin_dropped, b->tin_dropped + 1); 1603 1604 1604 1605 if (q->config->rate_flags & CAKE_FLAG_INGRESS) 1605 1606 cake_advance_shaper(q, b, skb, now, true); ··· 1796 1795 } 1797 1796 1798 1797 if (unlikely(len > b->max_skblen)) 1799 - b->max_skblen = len; 1798 + WRITE_ONCE(b->max_skblen, len); 1800 1799 1801 1800 if (qdisc_pkt_segs(skb) > 1 && q->config->rate_flags & CAKE_FLAG_SPLIT_GSO) { 1802 1801 struct sk_buff *segs, *nskb; ··· 1820 1819 numsegs++; 1821 1820 slen += segs->len; 1822 1821 q->buffer_used += segs->truesize; 1823 - b->packets++; 1822 + WRITE_ONCE(b->packets, b->packets + 1); 1824 1823 } 1825 1824 1826 1825 /* stats */ 1827 - b->bytes += slen; 1828 1826 b->backlogs[idx] += slen; 1829 - b->tin_backlog += slen; 1830 1827 sch->qstats.backlog += slen; 1831 1828 q->avg_window_bytes += slen; 1829 + WRITE_ONCE(b->bytes, b->bytes + slen); 1830 + WRITE_ONCE(b->tin_backlog, b->tin_backlog + slen); 1832 1831 1833 1832 qdisc_tree_reduce_backlog(sch, 1-numsegs, len-slen); 1834 1833 consume_skb(skb); ··· 1844 1843 ack = cake_ack_filter(q, flow); 1845 1844 1846 1845 if (ack) { 1847 - b->ack_drops++; 1846 + WRITE_ONCE(b->ack_drops, b->ack_drops + 1); 1848 1847 sch->qstats.drops++; 1849 1848 ack_pkt_len = qdisc_pkt_len(ack); 1850 - b->bytes += ack_pkt_len; 1849 + WRITE_ONCE(b->bytes, b->bytes + ack_pkt_len); 1851 1850 q->buffer_used += skb->truesize - ack->truesize; 1852 1851 if (q->config->rate_flags & CAKE_FLAG_INGRESS) 1853 1852 cake_advance_shaper(q, b, ack, now, true); ··· 1860 1859 } 1861 1860 1862 1861 /* stats */ 1863 - b->packets++; 1864 - b->bytes += len - ack_pkt_len; 1862 + WRITE_ONCE(b->packets, b->packets + 1); 1865 1863 b->backlogs[idx] += len - ack_pkt_len; 1866 - b->tin_backlog += len - ack_pkt_len; 1867 1864 sch->qstats.backlog += len - ack_pkt_len; 1868 1865 q->avg_window_bytes += len - ack_pkt_len; 1866 + WRITE_ONCE(b->bytes, b->bytes + len - ack_pkt_len); 1867 + WRITE_ONCE(b->tin_backlog, b->tin_backlog + len - ack_pkt_len); 1869 1868 } 1870 1869 1871 1870 if (q->overflow_timeout) ··· 1895 1894 u64 b = q->avg_window_bytes * (u64)NSEC_PER_SEC; 1896 1895 1897 1896 b = div64_u64(b, window_interval); 1898 - q->avg_peak_bandwidth = 1899 - cake_ewma(q->avg_peak_bandwidth, b, 1900 - b > q->avg_peak_bandwidth ? 2 : 8); 1897 + WRITE_ONCE(q->avg_peak_bandwidth, 1898 + cake_ewma(q->avg_peak_bandwidth, b, 1899 + b > q->avg_peak_bandwidth ? 2 : 8)); 1901 1900 q->avg_window_bytes = 0; 1902 1901 q->avg_window_begin = now; 1903 1902 ··· 1918 1917 if (!flow->set) { 1919 1918 list_add_tail(&flow->flowchain, &b->new_flows); 1920 1919 } else { 1921 - b->decaying_flow_count--; 1920 + WRITE_ONCE(b->decaying_flow_count, b->decaying_flow_count - 1); 1922 1921 list_move_tail(&flow->flowchain, &b->new_flows); 1923 1922 } 1924 1923 flow->set = CAKE_SET_SPARSE; 1925 - b->sparse_flow_count++; 1924 + WRITE_ONCE(b->sparse_flow_count, b->sparse_flow_count + 1); 1926 1925 1927 1926 flow->deficit = cake_get_flow_quantum(b, flow, q->config->flow_mode); 1928 1927 } else if (flow->set == CAKE_SET_SPARSE_WAIT) { ··· 1930 1929 * in the bulk rotation. 1931 1930 */ 1932 1931 flow->set = CAKE_SET_BULK; 1933 - b->sparse_flow_count--; 1934 - b->bulk_flow_count++; 1932 + WRITE_ONCE(b->sparse_flow_count, b->sparse_flow_count - 1); 1933 + WRITE_ONCE(b->bulk_flow_count, b->bulk_flow_count + 1); 1935 1934 1936 1935 cake_inc_srchost_bulk_flow_count(b, flow, q->config->flow_mode); 1937 1936 cake_inc_dsthost_bulk_flow_count(b, flow, q->config->flow_mode); 1938 1937 } 1939 1938 1940 1939 if (q->buffer_used > q->buffer_max_used) 1941 - q->buffer_max_used = q->buffer_used; 1940 + WRITE_ONCE(q->buffer_max_used, q->buffer_used); 1942 1941 1943 1942 if (q->buffer_used <= q->buffer_limit) 1944 1943 return NET_XMIT_SUCCESS; ··· 1978 1977 skb = dequeue_head(flow); 1979 1978 len = qdisc_pkt_len(skb); 1980 1979 b->backlogs[q->cur_flow] -= len; 1981 - b->tin_backlog -= len; 1980 + WRITE_ONCE(b->tin_backlog, b->tin_backlog - len); 1982 1981 sch->qstats.backlog -= len; 1983 1982 q->buffer_used -= skb->truesize; 1984 1983 sch->q.qlen--; ··· 2043 2042 2044 2043 cake_configure_rates(sch, new_rate, true); 2045 2044 q->last_checked_active = now; 2046 - q->active_queues = num_active_qs; 2045 + WRITE_ONCE(q->active_queues, num_active_qs); 2047 2046 } 2048 2047 2049 2048 begin: ··· 2150 2149 */ 2151 2150 if (flow->set == CAKE_SET_SPARSE) { 2152 2151 if (flow->head) { 2153 - b->sparse_flow_count--; 2154 - b->bulk_flow_count++; 2152 + WRITE_ONCE(b->sparse_flow_count, b->sparse_flow_count - 1); 2153 + WRITE_ONCE(b->bulk_flow_count, b->bulk_flow_count + 1); 2155 2154 2156 2155 cake_inc_srchost_bulk_flow_count(b, flow, q->config->flow_mode); 2157 2156 cake_inc_dsthost_bulk_flow_count(b, flow, q->config->flow_mode); ··· 2178 2177 if (!skb) { 2179 2178 /* this queue was actually empty */ 2180 2179 if (cobalt_queue_empty(&flow->cvars, &b->cparams, now)) 2181 - b->unresponsive_flow_count--; 2180 + WRITE_ONCE(b->unresponsive_flow_count, 2181 + b->unresponsive_flow_count - 1); 2182 2182 2183 2183 if (flow->cvars.p_drop || flow->cvars.count || 2184 2184 ktime_before(now, flow->cvars.drop_next)) { ··· 2189 2187 list_move_tail(&flow->flowchain, 2190 2188 &b->decaying_flows); 2191 2189 if (flow->set == CAKE_SET_BULK) { 2192 - b->bulk_flow_count--; 2190 + WRITE_ONCE(b->bulk_flow_count, b->bulk_flow_count - 1); 2193 2191 2194 2192 cake_dec_srchost_bulk_flow_count(b, flow, q->config->flow_mode); 2195 2193 cake_dec_dsthost_bulk_flow_count(b, flow, q->config->flow_mode); 2196 2194 2197 - b->decaying_flow_count++; 2195 + WRITE_ONCE(b->decaying_flow_count, b->decaying_flow_count + 1); 2198 2196 } else if (flow->set == CAKE_SET_SPARSE || 2199 2197 flow->set == CAKE_SET_SPARSE_WAIT) { 2200 - b->sparse_flow_count--; 2201 - b->decaying_flow_count++; 2198 + WRITE_ONCE(b->sparse_flow_count, b->sparse_flow_count - 1); 2199 + WRITE_ONCE(b->decaying_flow_count, b->decaying_flow_count + 1); 2202 2200 } 2203 2201 flow->set = CAKE_SET_DECAYING; 2204 2202 } else { 2205 2203 /* remove empty queue from the flowchain */ 2206 2204 list_del_init(&flow->flowchain); 2207 2205 if (flow->set == CAKE_SET_SPARSE || 2208 - flow->set == CAKE_SET_SPARSE_WAIT) 2209 - b->sparse_flow_count--; 2210 - else if (flow->set == CAKE_SET_BULK) { 2211 - b->bulk_flow_count--; 2206 + flow->set == CAKE_SET_SPARSE_WAIT) { 2207 + WRITE_ONCE(b->sparse_flow_count, b->sparse_flow_count - 1); 2208 + } else if (flow->set == CAKE_SET_BULK) { 2209 + WRITE_ONCE(b->bulk_flow_count, b->bulk_flow_count - 1); 2212 2210 2213 2211 cake_dec_srchost_bulk_flow_count(b, flow, q->config->flow_mode); 2214 2212 cake_dec_dsthost_bulk_flow_count(b, flow, q->config->flow_mode); 2215 - } else 2216 - b->decaying_flow_count--; 2217 - 2213 + } else { 2214 + WRITE_ONCE(b->decaying_flow_count, b->decaying_flow_count - 1); 2215 + } 2218 2216 flow->set = CAKE_SET_NONE; 2219 2217 } 2220 2218 goto begin; ··· 2236 2234 b->tin_deficit -= len; 2237 2235 } 2238 2236 flow->dropped++; 2239 - b->tin_dropped++; 2237 + WRITE_ONCE(b->tin_dropped, b->tin_dropped + 1); 2240 2238 qdisc_tree_reduce_backlog(sch, 1, qdisc_pkt_len(skb)); 2241 2239 qdisc_qstats_drop(sch); 2242 2240 qdisc_dequeue_drop(sch, skb, reason); ··· 2244 2242 goto retry; 2245 2243 } 2246 2244 2247 - b->tin_ecn_mark += !!flow->cvars.ecn_marked; 2245 + WRITE_ONCE(b->tin_ecn_mark, b->tin_ecn_mark + !!flow->cvars.ecn_marked); 2248 2246 qdisc_bstats_update(sch, skb); 2249 2247 WRITE_ONCE(q->last_active, now); 2250 2248 2251 2249 /* collect delay stats */ 2252 2250 delay = ktime_to_ns(ktime_sub(now, cobalt_get_enqueue_time(skb))); 2253 - b->avge_delay = cake_ewma(b->avge_delay, delay, 8); 2254 - b->peak_delay = cake_ewma(b->peak_delay, delay, 2255 - delay > b->peak_delay ? 2 : 8); 2256 - b->base_delay = cake_ewma(b->base_delay, delay, 2257 - delay < b->base_delay ? 2 : 8); 2251 + WRITE_ONCE(b->avge_delay, cake_ewma(b->avge_delay, delay, 8)); 2252 + WRITE_ONCE(b->peak_delay, 2253 + cake_ewma(b->peak_delay, delay, 2254 + delay > b->peak_delay ? 2 : 8)); 2255 + WRITE_ONCE(b->base_delay, 2256 + cake_ewma(b->base_delay, delay, 2257 + delay < b->base_delay ? 2 : 8)); 2258 2258 2259 2259 len = cake_advance_shaper(q, b, skb, now, false); 2260 2260 flow->deficit -= len; ··· 2333 2329 u8 rate_shft = 0; 2334 2330 u64 rate_ns = 0; 2335 2331 2336 - b->flow_quantum = 1514; 2337 2332 if (rate) { 2338 - b->flow_quantum = max(min(rate >> 12, 1514ULL), 300ULL); 2333 + WRITE_ONCE(b->flow_quantum, 2334 + max(min(rate >> 12, 1514ULL), 300ULL)); 2339 2335 rate_shft = 34; 2340 2336 rate_ns = ((u64)NSEC_PER_SEC) << rate_shft; 2341 2337 rate_ns = div64_u64(rate_ns, max(MIN_RATE, rate)); ··· 2343 2339 rate_ns >>= 1; 2344 2340 rate_shft--; 2345 2341 } 2346 - } /* else unlimited, ie. zero delay */ 2347 - 2348 - b->tin_rate_bps = rate; 2342 + } else { 2343 + /* else unlimited, ie. zero delay */ 2344 + WRITE_ONCE(b->flow_quantum, 1514); 2345 + } 2346 + WRITE_ONCE(b->tin_rate_bps, rate); 2349 2347 b->tin_rate_ns = rate_ns; 2350 2348 b->tin_rate_shft = rate_shft; 2351 2349 ··· 2356 2350 2357 2351 byte_target_ns = (byte_target * rate_ns) >> rate_shft; 2358 2352 2359 - b->cparams.target = max((byte_target_ns * 3) / 2, target_ns); 2360 - b->cparams.interval = max(rtt_est_ns + 2361 - b->cparams.target - target_ns, 2362 - b->cparams.target * 2); 2353 + WRITE_ONCE(b->cparams.target, 2354 + max((byte_target_ns * 3) / 2, target_ns)); 2355 + WRITE_ONCE(b->cparams.interval, 2356 + max(rtt_est_ns + b->cparams.target - target_ns, 2357 + b->cparams.target * 2)); 2363 2358 b->cparams.mtu_time = byte_target_ns; 2364 2359 b->cparams.p_inc = 1 << 24; /* 1/256 */ 2365 2360 b->cparams.p_dec = 1 << 20; /* 1/4096 */ ··· 2618 2611 { 2619 2612 struct cake_sched_data *qd = qdisc_priv(sch); 2620 2613 struct cake_sched_config *q = qd->config; 2614 + u32 buffer_limit; 2621 2615 2622 2616 cake_configure_rates(sch, qd->config->rate_bps, false); 2623 2617 2624 2618 if (q->buffer_config_limit) { 2625 - qd->buffer_limit = q->buffer_config_limit; 2619 + buffer_limit = q->buffer_config_limit; 2626 2620 } else if (q->rate_bps) { 2627 2621 u64 t = q->rate_bps * q->interval; 2628 2622 2629 2623 do_div(t, USEC_PER_SEC / 4); 2630 - qd->buffer_limit = max_t(u32, t, 4U << 20); 2624 + buffer_limit = max_t(u32, t, 4U << 20); 2631 2625 } else { 2632 - qd->buffer_limit = ~0; 2626 + buffer_limit = ~0; 2633 2627 } 2634 2628 2635 2629 sch->flags &= ~TCQ_F_CAN_BYPASS; 2636 2630 2637 - qd->buffer_limit = min(qd->buffer_limit, 2638 - max(sch->limit * psched_mtu(qdisc_dev(sch)), 2639 - q->buffer_config_limit)); 2631 + WRITE_ONCE(qd->buffer_limit, 2632 + min(buffer_limit, 2633 + max(sch->limit * psched_mtu(qdisc_dev(sch)), 2634 + q->buffer_config_limit))); 2640 2635 } 2641 2636 2642 2637 static int cake_config_change(struct cake_sched_config *q, struct nlattr *opt, ··· 2783 2774 return ret; 2784 2775 2785 2776 if (overhead_changed) { 2786 - qd->max_netlen = 0; 2787 - qd->max_adjlen = 0; 2788 - qd->min_netlen = ~0; 2789 - qd->min_adjlen = ~0; 2777 + WRITE_ONCE(qd->max_netlen, 0); 2778 + WRITE_ONCE(qd->max_adjlen, 0); 2779 + WRITE_ONCE(qd->min_netlen, ~0); 2780 + WRITE_ONCE(qd->min_adjlen, ~0); 2790 2781 } 2791 2782 2792 2783 if (qd->tins) { ··· 3004 2995 goto nla_put_failure; \ 3005 2996 } while (0) 3006 2997 3007 - PUT_STAT_U64(CAPACITY_ESTIMATE64, q->avg_peak_bandwidth); 3008 - PUT_STAT_U32(MEMORY_LIMIT, q->buffer_limit); 3009 - PUT_STAT_U32(MEMORY_USED, q->buffer_max_used); 3010 - PUT_STAT_U32(AVG_NETOFF, ((q->avg_netoff + 0x8000) >> 16)); 3011 - PUT_STAT_U32(MAX_NETLEN, q->max_netlen); 3012 - PUT_STAT_U32(MAX_ADJLEN, q->max_adjlen); 3013 - PUT_STAT_U32(MIN_NETLEN, q->min_netlen); 3014 - PUT_STAT_U32(MIN_ADJLEN, q->min_adjlen); 3015 - PUT_STAT_U32(ACTIVE_QUEUES, q->active_queues); 2998 + PUT_STAT_U64(CAPACITY_ESTIMATE64, READ_ONCE(q->avg_peak_bandwidth)); 2999 + PUT_STAT_U32(MEMORY_LIMIT, READ_ONCE(q->buffer_limit)); 3000 + PUT_STAT_U32(MEMORY_USED, READ_ONCE(q->buffer_max_used)); 3001 + PUT_STAT_U32(AVG_NETOFF, ((READ_ONCE(q->avg_netoff) + 0x8000) >> 16)); 3002 + PUT_STAT_U32(MAX_NETLEN, READ_ONCE(q->max_netlen)); 3003 + PUT_STAT_U32(MAX_ADJLEN, READ_ONCE(q->max_adjlen)); 3004 + PUT_STAT_U32(MIN_NETLEN, READ_ONCE(q->min_netlen)); 3005 + PUT_STAT_U32(MIN_ADJLEN, READ_ONCE(q->min_adjlen)); 3006 + PUT_STAT_U32(ACTIVE_QUEUES, READ_ONCE(q->active_queues)); 3016 3007 3017 3008 #undef PUT_STAT_U32 3018 3009 #undef PUT_STAT_U64 ··· 3038 3029 if (!ts) 3039 3030 goto nla_put_failure; 3040 3031 3041 - PUT_TSTAT_U64(THRESHOLD_RATE64, b->tin_rate_bps); 3042 - PUT_TSTAT_U64(SENT_BYTES64, b->bytes); 3043 - PUT_TSTAT_U32(BACKLOG_BYTES, b->tin_backlog); 3032 + PUT_TSTAT_U64(THRESHOLD_RATE64, READ_ONCE(b->tin_rate_bps)); 3033 + PUT_TSTAT_U64(SENT_BYTES64, READ_ONCE(b->bytes)); 3034 + PUT_TSTAT_U32(BACKLOG_BYTES, READ_ONCE(b->tin_backlog)); 3044 3035 3045 3036 PUT_TSTAT_U32(TARGET_US, 3046 - ktime_to_us(ns_to_ktime(b->cparams.target))); 3037 + ktime_to_us(ns_to_ktime(READ_ONCE(b->cparams.target)))); 3047 3038 PUT_TSTAT_U32(INTERVAL_US, 3048 - ktime_to_us(ns_to_ktime(b->cparams.interval))); 3039 + ktime_to_us(ns_to_ktime(READ_ONCE(b->cparams.interval)))); 3049 3040 3050 - PUT_TSTAT_U32(SENT_PACKETS, b->packets); 3051 - PUT_TSTAT_U32(DROPPED_PACKETS, b->tin_dropped); 3052 - PUT_TSTAT_U32(ECN_MARKED_PACKETS, b->tin_ecn_mark); 3053 - PUT_TSTAT_U32(ACKS_DROPPED_PACKETS, b->ack_drops); 3041 + PUT_TSTAT_U32(SENT_PACKETS, READ_ONCE(b->packets)); 3042 + PUT_TSTAT_U32(DROPPED_PACKETS, READ_ONCE(b->tin_dropped)); 3043 + PUT_TSTAT_U32(ECN_MARKED_PACKETS, READ_ONCE(b->tin_ecn_mark)); 3044 + PUT_TSTAT_U32(ACKS_DROPPED_PACKETS, READ_ONCE(b->ack_drops)); 3054 3045 3055 3046 PUT_TSTAT_U32(PEAK_DELAY_US, 3056 - ktime_to_us(ns_to_ktime(b->peak_delay))); 3047 + ktime_to_us(ns_to_ktime(READ_ONCE(b->peak_delay)))); 3057 3048 PUT_TSTAT_U32(AVG_DELAY_US, 3058 - ktime_to_us(ns_to_ktime(b->avge_delay))); 3049 + ktime_to_us(ns_to_ktime(READ_ONCE(b->avge_delay)))); 3059 3050 PUT_TSTAT_U32(BASE_DELAY_US, 3060 - ktime_to_us(ns_to_ktime(b->base_delay))); 3051 + ktime_to_us(ns_to_ktime(READ_ONCE(b->base_delay)))); 3061 3052 3062 - PUT_TSTAT_U32(WAY_INDIRECT_HITS, b->way_hits); 3063 - PUT_TSTAT_U32(WAY_MISSES, b->way_misses); 3064 - PUT_TSTAT_U32(WAY_COLLISIONS, b->way_collisions); 3053 + PUT_TSTAT_U32(WAY_INDIRECT_HITS, READ_ONCE(b->way_hits)); 3054 + PUT_TSTAT_U32(WAY_MISSES, READ_ONCE(b->way_misses)); 3055 + PUT_TSTAT_U32(WAY_COLLISIONS, READ_ONCE(b->way_collisions)); 3065 3056 3066 - PUT_TSTAT_U32(SPARSE_FLOWS, b->sparse_flow_count + 3067 - b->decaying_flow_count); 3068 - PUT_TSTAT_U32(BULK_FLOWS, b->bulk_flow_count); 3069 - PUT_TSTAT_U32(UNRESPONSIVE_FLOWS, b->unresponsive_flow_count); 3070 - PUT_TSTAT_U32(MAX_SKBLEN, b->max_skblen); 3057 + PUT_TSTAT_U32(SPARSE_FLOWS, READ_ONCE(b->sparse_flow_count) + 3058 + READ_ONCE(b->decaying_flow_count)); 3059 + PUT_TSTAT_U32(BULK_FLOWS, READ_ONCE(b->bulk_flow_count)); 3060 + PUT_TSTAT_U32(UNRESPONSIVE_FLOWS, READ_ONCE(b->unresponsive_flow_count)); 3061 + PUT_TSTAT_U32(MAX_SKBLEN, READ_ONCE(b->max_skblen)); 3071 3062 3072 - PUT_TSTAT_U32(FLOW_QUANTUM, b->flow_quantum); 3063 + PUT_TSTAT_U32(FLOW_QUANTUM, READ_ONCE(b->flow_quantum)); 3073 3064 nla_nest_end(d->skb, ts); 3074 3065 } 3075 3066 ··· 3307 3298 struct cake_sched_data *qd = qdisc_priv(chld); 3308 3299 3309 3300 if (overhead_changed) { 3310 - qd->max_netlen = 0; 3311 - qd->max_adjlen = 0; 3312 - qd->min_netlen = ~0; 3313 - qd->min_adjlen = ~0; 3301 + WRITE_ONCE(qd->max_netlen, 0); 3302 + WRITE_ONCE(qd->max_adjlen, 0); 3303 + WRITE_ONCE(qd->min_netlen, ~0); 3304 + WRITE_ONCE(qd->min_adjlen, ~0); 3314 3305 } 3315 3306 3316 3307 if (qd->tins) {