bpf: safeguard hashtab locking in NMI context
Subsystems (3)
cover bpf: safeguard hashtab locking in NMI context
LOCKDEP NMI warning highlighted potential deadlock of hashtab in NMI context:
[ 74.828971] ================================
[ 74.828972] WARNING: inconsistent lock state
[ 74.828973] 5.9.0-rc8+ #275 Not tainted
[ 74.828974] --------------------------------
[ 74.828975] inconsistent {INITIAL USE} -> {IN-NMI} usage.
[ 74.828976] taskset/1174 [HC2[2]:SC0[0]:HE0:SE1] takes:
[...]
[ 74.828999] Possible unsafe locking scenario:
[ 74.828999]
[ 74.829000] CPU0
[ 74.829001] ----
[ 74.829001] lock(&htab->buckets[i].raw_lock);
[ 74.829003] <Interrupt>
[ 74.829004] lock(&htab->buckets[i].raw_lock);Please refer to patch 1/2 for full trace.
This warning is a false alert, as "INITIAL USE" and "IN-NMI" in the tests are from different hashtab. On the other hand, in theory, it is possible to deadlock when a hashtab is access from both non-NMI and NMI context. Patch 1/2 fixes this false alert by assigning separate lockdep class to each hashtab. Patch 2/2 introduces map_locked counters, which is similar to bpf_prog_active counter, to avoid hashtab deadlock in NMI context.
Song Liu (2):
bpf: use separate lockdep class for each hashtab
bpf: Avoid hashtab deadlock with map_locked
kernel/bpf/hashtab.c | 126 +++++++++++++++++++++++++++++++------------ 1 file changed, 92 insertions(+), 34 deletions(-)
--
2.24.1
PATCH 1/2 bpf: use separate lockdep class for each hashtab
If a hashtab is accessed in both NMI and non-NMI contexts, it may cause deadlock in bucket->lock. LOCKDEP NMI warning highlighted this issue:
./test_progs -t stacktrace
[ 74.828970]
[ 74.828971] ================================
[ 74.828972] WARNING: inconsistent lock state
[ 74.828973] 5.9.0-rc8+ #275 Not tainted
[ 74.828974] --------------------------------
[ 74.828975] inconsistent {INITIAL USE} -> {IN-NMI} usage.
[ 74.828976] taskset/1174 [HC2[2]:SC0[0]:HE0:SE1] takes:
[ 74.828977] ffffc90000ee96b0 (&htab->buckets[i].raw_lock){....}-{2:2}, at: htab_map_update_elem+0x271/0x5a0
[ 74.828981] {INITIAL USE} state was registered at:
[ 74.828982] lock_acquire+0x137/0x510
[ 74.828983] _raw_spin_lock_irqsave+0x43/0x90
[ 74.828984] htab_map_update_elem+0x271/0x5a0
[ 74.828984] 0xffffffffa0040b34
[ 74.828985] trace_call_bpf+0x159/0x310
[ 74.828986] perf_trace_run_bpf_submit+0x5f/0xd0
[ 74.828987] perf_trace_urandom_read+0x1be/0x220
[ 74.828988] urandom_read_nowarn.isra.0+0x26f/0x380
[ 74.828989] vfs_read+0xf8/0x280
[ 74.828989] ksys_read+0xc9/0x160
[ 74.828990] do_syscall_64+0x33/0x40
[ 74.828991] entry_SYSCALL_64_after_hwframe+0x44/0xa9
[ 74.828992] irq event stamp: 1766
[ 74.828993] hardirqs last enabled at (1765): [<ffffffff82800ace>] asm_exc_page_fault+0x1e/0x30
[ 74.828994] hardirqs last disabled at (1766): [<ffffffff8267df87>] irqentry_enter+0x37/0x60
[ 74.828995] softirqs last enabled at (856): [<ffffffff81043e7c>] fpu__clear+0xac/0x120
[ 74.828996] softirqs last disabled at (854): [<ffffffff81043df0>] fpu__clear+0x20/0x120
[ 74.828997]
[ 74.828998] other info that might help us debug this:
[ 74.828999] Possible unsafe locking scenario:
[ 74.828999]
[ 74.829000] CPU0
[ 74.829001] ----
[ 74.829001] lock(&htab->buckets[i].raw_lock);
[ 74.829003] <Interrupt>
[ 74.829004] lock(&htab->buckets[i].raw_lock);
[ 74.829006]
[ 74.829006] *** DEADLOCK ***
[ 74.829007]
[ 74.829008] 1 lock held by taskset/1174:
[ 74.829008] #0: ffff8883ec3fd020 (&cpuctx_lock){-...}-{2:2}, at: perf_event_task_tick+0x101/0x650
[ 74.829012]
[ 74.829013] stack backtrace:
[ 74.829014] CPU: 0 PID: 1174 Comm: taskset Not tainted 5.9.0-rc8+ #275
[ 74.829015] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.11.0-2.el7 04/01/2014
[ 74.829016] Call Trace:
[ 74.829016] <NMI>
[ 74.829017] dump_stack+0x9a/0xd0
[ 74.829018] lock_acquire+0x461/0x510
[ 74.829019] ? lock_release+0x6b0/0x6b0
[ 74.829020] ? stack_map_get_build_id_offset+0x45e/0x800
[ 74.829021] ? htab_map_update_elem+0x271/0x5a0
[ 74.829022] ? rcu_read_lock_held_common+0x1a/0x50
[ 74.829022] ? rcu_read_lock_held+0x5f/0xb0
[ 74.829023] _raw_spin_lock_irqsave+0x43/0x90
[ 74.829024] ? htab_map_update_elem+0x271/0x5a0
[ 74.829025] htab_map_update_elem+0x271/0x5a0
[ 74.829026] bpf_prog_1fd9e30e1438d3c5_oncpu+0x9c/0xe88
[ 74.829027] bpf_overflow_handler+0x127/0x320
[ 74.829028] ? perf_event_text_poke_output+0x4d0/0x4d0
[ 74.829029] ? sched_clock_cpu+0x18/0x130
[ 74.829030] __perf_event_overflow+0xae/0x190
[ 74.829030] handle_pmi_common+0x34c/0x470
[ 74.829031] ? intel_pmu_save_and_restart+0x90/0x90
[ 74.829032] ? lock_acquire+0x3f8/0x510
[ 74.829033] ? lock_release+0x6b0/0x6b0
[ 74.829034] intel_pmu_handle_irq+0x11e/0x240
[ 74.829034] perf_event_nmi_handler+0x40/0x60
[ 74.829035] nmi_handle+0x110/0x360
[ 74.829036] ? __intel_pmu_enable_all.constprop.0+0x72/0xf0
[ 74.829037] default_do_nmi+0x6b/0x170
[ 74.829038] exc_nmi+0x106/0x130
[ 74.829038] end_repeat_nmi+0x16/0x55
[ 74.829039] RIP: 0010:__intel_pmu_enable_all.constprop.0+0x72/0xf0
[ 74.829042] Code: 2f 1f 03 48 8d bb b8 0c 00 00 e8 29 09 41 00 48 ...
[ 74.829043] RSP: 0000:ffff8880a604fc90 EFLAGS: 00000002
[ 74.829044] RAX: 000000070000000f RBX: ffff8883ec2195a0 RCX: 000000000000038f
[ 74.829045] RDX: 0000000000000007 RSI: ffffffff82e72c20 RDI: ffff8883ec21a258
[ 74.829046] RBP: 000000070000000f R08: ffffffff8101b013 R09: fffffbfff0a7982d
[ 74.829047] R10: ffffffff853cc167 R11: fffffbfff0a7982c R12: 0000000000000000
[ 74.829049] R13: ffff8883ec3f0af0 R14: ffff8883ec3fd120 R15: ffff8883e9c92098
[ 74.829049] ? intel_pmu_lbr_enable_all+0x43/0x240
[ 74.829050] ? __intel_pmu_enable_all.constprop.0+0x72/0xf0
[ 74.829051] ? __intel_pmu_enable_all.constprop.0+0x72/0xf0
[ 74.829052] </NMI>
[ 74.829053] perf_event_task_tick+0x48d/0x650
[ 74.829054] scheduler_tick+0x129/0x210
[ 74.829054] update_process_times+0x37/0x70
[ 74.829055] tick_sched_handle.isra.0+0x35/0x90
[ 74.829056] tick_sched_timer+0x8f/0xb0
[ 74.829057] __hrtimer_run_queues+0x364/0x7d0
[ 74.829058] ? tick_sched_do_timer+0xa0/0xa0
[ 74.829058] ? enqueue_hrtimer+0x1e0/0x1e0
[ 74.829059] ? recalibrate_cpu_khz+0x10/0x10
[ 74.829060] ? ktime_get_update_offsets_now+0x1a3/0x360
[ 74.829061] hrtimer_interrupt+0x1bb/0x360
[ 74.829062] ? rcu_read_lock_sched_held+0xa1/0xd0
[ 74.829063] __sysvec_apic_timer_interrupt+0xed/0x3d0
[ 74.829064] sysvec_apic_timer_interrupt+0x3f/0xd0
[ 74.829064] ? asm_sysvec_apic_timer_interrupt+0xa/0x20
[ 74.829065] asm_sysvec_apic_timer_interrupt+0x12/0x20
[ 74.829066] RIP: 0033:0x7fba18d579b4
[ 74.829068] Code: 74 54 44 0f b6 4a 04 41 83 e1 0f 41 80 f9 ...
[ 74.829069] RSP: 002b:00007ffc9ba69570 EFLAGS: 00000206
[ 74.829071] RAX: 00007fba192084c0 RBX: 00007fba18c24d28 RCX: 00000000000007a4
[ 74.829072] RDX: 00007fba18c30488 RSI: 0000000000000000 RDI: 000000000000037b
[ 74.829073] RBP: 00007fba18ca5760 R08: 00007fba18c248fc R09: 00007fba18c94c30
[ 74.829074] R10: 000000000000002f R11: 0000000000073c30 R12: 00007ffc9ba695e0
[ 74.829075] R13: 00000000000003f3 R14: 00007fba18c21ac8 R15: 00000000000058d6However, such warning should not apply across multiple hashtabs. The system will not deadlock if one hashtab is used in NMI, while another hashtab is used in non-NMI.
Use separate lockdep class for each hashtab, so that we don't get this false alert.
--- kernel/bpf/hashtab.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)
kernel/bpf/hashtab.c +10 -2
@@ -99,6 +99,7 @@ struct bpf_htab {u32 n_buckets;/* number of hash buckets */ u32 elem_size;/* size of each element in bytes */ u32 hashrnd; +struct lock_class_key lockdep_key; };/* each htab element is struct htab_elem + key + value */
@@ -136,12 +137,18 @@ static void htab_init_buckets(struct bpf_htab *htab) {unsigned i; +lockdep_register_key (&htab->lockdep_key);for (i =0 ; i < htab->n_buckets; i++) {INIT_HLIST_NULLS_HEAD (&htab->buckets[i].head, i); -if (htab_use_raw_lock (htab)) +if (htab_use_raw_lock (htab)) {raw_spin_lock_init (&htab->buckets[i].raw_lock); -else +lockdep_set_class (&htab->buckets[i].raw_lock, + &htab->lockdep_key); + }else {spin_lock_init (&htab->buckets[i].lock); +lockdep_set_class (&htab->buckets[i].lock, + &htab->lockdep_key); + } } }
@@ -1312,6 +1319,7 @@ static void htab_map_free(struct bpf_map *map)free_percpu (htab->extra_elems);bpf_map_area_free (htab->buckets); +lockdep_unregister_key (&htab->lockdep_key);kfree (htab); }
Signature · 1 line
2.24.1
PATCH 2/2 bpf: Avoid hashtab deadlock with map_locked
In reply to Song LiuIf a hashtab is accessed in both non-NMI and NMI context, the system may deadlock on bucket->lock. Fix this issue with percpu counter map_locked. map_locked rejects concurrent access to the same bucket from the same CPU. To reduce memory overhead, map_locked is not added per bucket. Instead, 8 percpu counters are added to each hashtab. buckets are assigned to these counters based on the lower bits of its hash.
--- kernel/bpf/hashtab.c | 114 +++++++++++++++++++++++++++++++------------ 1 file changed, 82 insertions(+), 32 deletions(-)
kernel/bpf/hashtab.c +82 -32
@@ -86,6 +86,9 @@ struct bucket { }; }; +#define HASHTAB_MAP_LOCK_COUNT 8 +#define HASHTAB_MAP_LOCK_MASK (HASHTAB_MAP_LOCK_COUNT - 1) +struct bpf_htab {struct bpf_map map;struct bucket *buckets;
@@ -100,6 +103,7 @@ struct bpf_htab {u32 elem_size;/* size of each element in bytes */ u32 hashrnd;struct lock_class_key lockdep_key; +int __percpu *map_locked[HASHTAB_MAP_LOCK_COUNT ]; };/* each htab element is struct htab_elem + key + value */
@@ -152,26 +156,41 @@ static void htab_init_buckets(struct bpf_htab *htab) } } -static inline unsigned long htab_lock_bucket (const struct bpf_htab *htab, -struct bucket *b) +static inline int htab_lock_bucket (const struct bpf_htab *htab, +struct bucket *b,u32 hash, +unsigned long *pflags) {unsigned long flags; + hash = hash &HASHTAB_MAP_LOCK_MASK ; + +migrate_disable (); +if (unlikely (__this_cpu_inc_return (*(htab->map_locked[hash])) !=1 )) { +__this_cpu_dec (*(htab->map_locked[hash])); +migrate_enable (); +return -EBUSY ; + } +if (htab_use_raw_lock (htab))raw_spin_lock_irqsave (&b->raw_lock, flags);else spin_lock_irqsave (&b->lock, flags); -return flags; + *pflags = flags; + +return 0 ; }static inline void htab_unlock_bucket (const struct bpf_htab *htab, -struct bucket *b, +struct bucket *b,u32 hash,unsigned long flags) { + hash = hash &HASHTAB_MAP_LOCK_MASK ;if (htab_use_raw_lock (htab))raw_spin_unlock_irqrestore (&b->raw_lock, flags);else spin_unlock_irqrestore (&b->lock, flags); +__this_cpu_dec (*(htab->map_locked[hash])); +migrate_enable (); }static bool htab_lru_map_delete_node (void *arg,struct bpf_lru_node *node);
@@ -429,8 +448,8 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)bool percpu_lru = (attr->map_flags &BPF_F_NO_COMMON_LRU );bool prealloc = !(attr->map_flags &BPF_F_NO_PREALLOC );struct bpf_htab *htab; +int err, i;u64 cost; -int err; htab =kzalloc (sizeof (*htab),GFP_USER );if (!htab)
@@ -487,6 +506,13 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)if (!htab->buckets) goto free_charge; +for (i =0 ; i <HASHTAB_MAP_LOCK_COUNT ; i++) { + htab->map_locked[i] =__alloc_percpu_gfp (sizeof (int ), +sizeof (int ),GFP_USER ); +if (!htab->map_locked[i]) + goto free_map_locked; + } +if (htab->map.map_flags &BPF_F_ZERO_SEED ) htab->hashrnd =0 ;else
@@ -497,7 +523,7 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr)if (prealloc) { err =prealloc_init (htab);if (err) - goto free_buckets; + goto free_map_locked;if (!percpu && !lru) {/* lru itself can remove the least used element, so
@@ -513,7 +539,9 @@ static struct bpf_map *htab_map_alloc(union bpf_attr *attr) free_prealloc:prealloc_destroy (htab); -free_buckets: +free_map_locked: +for (i =0 ; i <HASHTAB_MAP_LOCK_COUNT ; i++) +free_percpu (htab->map_locked[i]);bpf_map_area_free (htab->buckets); free_charge:bpf_map_charge_finish (&htab->map.memory);
@@ -694,12 +722,15 @@ static bool htab_lru_map_delete_node(void *arg, struct bpf_lru_node *node)struct hlist_nulls_node *n;unsigned long flags;struct bucket *b; +int ret; tgt_l = container_of(node, struct htab_elem, lru_node); b =__select_bucket (htab, tgt_l->hash); head = &b->head; - flags =htab_lock_bucket (htab, b); + ret =htab_lock_bucket (htab, b, tgt_l->hash, &flags); +if (ret) +return false;hlist_nulls_for_each_entry_rcu (l, n, head, hash_node)if (l == tgt_l) {
@@ -707,7 +738,7 @@ static bool htab_lru_map_delete_node(void *arg, struct bpf_lru_node *node)break ; } -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, tgt_l->hash, flags);return l == tgt_l; }
@@ -979,7 +1010,9 @@ static int htab_map_update_elem(struct bpf_map *map, void *key, void *value,*/ } - flags =htab_lock_bucket (htab, b); + ret =htab_lock_bucket (htab, b, hash, &flags); +if (ret) +return ret; l_old =lookup_elem_raw (head, hash, key, key_size);
@@ -1020,7 +1053,7 @@ static int htab_map_update_elem(struct bpf_map *map, void *key, void *value, } ret =0 ; err: -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, hash, flags);return ret; }
@@ -1058,7 +1091,9 @@ static int htab_lru_map_update_elem(struct bpf_map *map, void *key, void *value,return -ENOMEM ;memcpy (l_new->key +round_up (map->key_size,8 ), value, map->value_size); - flags =htab_lock_bucket (htab, b); + ret =htab_lock_bucket (htab, b, hash, &flags); +if (ret) +return ret; l_old =lookup_elem_raw (head, hash, key, key_size);
@@ -1077,7 +1112,7 @@ static int htab_lru_map_update_elem(struct bpf_map *map, void *key, void *value, ret =0 ; err: -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, hash, flags);if (ret)bpf_lru_push_free (&htab->lru, &l_new->lru_node);
@@ -1112,7 +1147,9 @@ static int __htab_percpu_map_update_elem(struct bpf_map *map, void *key, b =__select_bucket (htab, hash); head = &b->head; - flags =htab_lock_bucket (htab, b); + ret =htab_lock_bucket (htab, b, hash, &flags); +if (ret) +return ret; l_old =lookup_elem_raw (head, hash, key, key_size);
@@ -1135,7 +1172,7 @@ static int __htab_percpu_map_update_elem(struct bpf_map *map, void *key, } ret =0 ; err: -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, hash, flags);return ret; }
@@ -1175,7 +1212,9 @@ static int __htab_lru_percpu_map_update_elem(struct bpf_map *map, void *key,return -ENOMEM ; } - flags =htab_lock_bucket (htab, b); + ret =htab_lock_bucket (htab, b, hash, &flags); +if (ret) +return ret; l_old =lookup_elem_raw (head, hash, key, key_size);
@@ -1197,7 +1236,7 @@ static int __htab_lru_percpu_map_update_elem(struct bpf_map *map, void *key, } ret =0 ; err: -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, hash, flags);if (l_new)bpf_lru_push_free (&htab->lru, &l_new->lru_node);return ret;
@@ -1225,7 +1264,7 @@ static int htab_map_delete_elem(struct bpf_map *map, void *key)struct htab_elem *l;unsigned long flags;u32 hash, key_size; -int ret = -ENOENT ; +int ret;WARN_ON_ONCE (!rcu_read_lock_held () && !rcu_read_lock_trace_held ());
@@ -1235,17 +1274,20 @@ static int htab_map_delete_elem(struct bpf_map *map, void *key) b =__select_bucket (htab, hash); head = &b->head; - flags =htab_lock_bucket (htab, b); + ret =htab_lock_bucket (htab, b, hash, &flags); +if (ret) +return ret; l =lookup_elem_raw (head, hash, key, key_size);if (l) {hlist_nulls_del_rcu (&l->hash_node);free_htab_elem (htab, l); - ret =0 ; + }else { + ret = -ENOENT ; } -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, hash, flags);return ret; }
@@ -1257,7 +1299,7 @@ static int htab_lru_map_delete_elem(struct bpf_map *map, void *key)struct htab_elem *l;unsigned long flags;u32 hash, key_size; -int ret = -ENOENT ; +int ret;WARN_ON_ONCE (!rcu_read_lock_held () && !rcu_read_lock_trace_held ());
@@ -1267,16 +1309,18 @@ static int htab_lru_map_delete_elem(struct bpf_map *map, void *key) b =__select_bucket (htab, hash); head = &b->head; - flags =htab_lock_bucket (htab, b); + ret =htab_lock_bucket (htab, b, hash, &flags); +if (ret) +return ret; l =lookup_elem_raw (head, hash, key, key_size); -if (l) { +if (l)hlist_nulls_del_rcu (&l->hash_node); - ret =0 ; - } +else + ret = -ENOENT ; -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, hash, flags);if (l)bpf_lru_push_free (&htab->lru, &l->lru_node);return ret;
@@ -1302,6 +1346,7 @@ static void delete_all_elements(struct bpf_htab *htab)static void htab_map_free (struct bpf_map *map) { struct bpf_htab *htab = container_of(map, struct bpf_htab, map); +int i;/* bpf_free_used_maps() or close(map_fd) will trigger this map_free callback. * bpf_free_used_maps() is called after bpf prog is no longer executing.
@@ -1320,6 +1365,8 @@ static void htab_map_free(struct bpf_map *map)free_percpu (htab->extra_elems);bpf_map_area_free (htab->buckets);lockdep_unregister_key (&htab->lockdep_key); +for (i =0 ; i <HASHTAB_MAP_LOCK_COUNT ; i++) +free_percpu (htab->map_locked[i]);kfree (htab); }
@@ -1423,8 +1470,11 @@ __htab_map_lookup_and_delete_batch(struct bpf_map *map, b = &htab->buckets[batch]; head = &b->head;/* do not grab the lock unless need it (bucket_cnt > 0). */ -if (locked) - flags =htab_lock_bucket (htab, b); +if (locked) { + ret =htab_lock_bucket (htab, b, batch, &flags); +if (ret) + goto next_batch; + } bucket_cnt =0 ;hlist_nulls_for_each_entry_rcu (l, n, head, hash_node)
@@ -1441,7 +1491,7 @@ __htab_map_lookup_and_delete_batch(struct bpf_map *map,/* Note that since bucket_cnt > 0 here, it is implicit * that the locked was grabbed, so release it. */ -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, batch, flags);rcu_read_unlock ();bpf_enable_instrumentation (); goto after_loop;
@@ -1452,7 +1502,7 @@ __htab_map_lookup_and_delete_batch(struct bpf_map *map,/* Note that since bucket_cnt > 0 here, it is implicit * that the locked was grabbed, so release it. */ -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, batch, flags);rcu_read_unlock ();bpf_enable_instrumentation ();kvfree (keys);
@@ -1505,7 +1555,7 @@ __htab_map_lookup_and_delete_batch(struct bpf_map *map, dst_val += value_size; } -htab_unlock_bucket (htab, b, flags); +htab_unlock_bucket (htab, b, batch, flags); locked = false;while (node_to_free) {
Signature · 1 line
2.24.1
This series was applied to bpf/bpf-next.git (refs/heads/master):
Hello:
This series was applied to bpf/bpf-next.git (refs/heads/master):
Quoted 18 lines · On Thu, 29 Oct 2020 00:19:23 -0700 you wrote:
LOCKDEP NMI warning highlighted potential deadlock of hashtab in NMI context:
[ 74.828971] ================================ [ 74.828972] WARNING: inconsistent lock state [ 74.828973] 5.9.0-rc8+ #275 Not tainted [ 74.828974] -------------------------------- [ 74.828975] inconsistent {INITIAL USE} -> {IN-NMI} usage. [ 74.828976] taskset/1174 [HC2[2]:SC0[0]:HE0:SE1] takes: [...] [ 74.828999] Possible unsafe locking scenario: [ 74.828999] [ 74.829000] CPU0 [ 74.829001] ---- [ 74.829001] lock(&htab->buckets[i].raw_lock); [ 74.829003] <Interrupt> [ 74.829004] lock(&htab->buckets[i].raw_lock);
Quoted 1 line
[...]
Here is the summary with links:
- [bpf-next,1/2] bpf: use separate lockdep class for each hashtab
https://git.kernel.org/bpf/bpf-next/c/c50eb518e262 - [bpf-next,2/2] bpf: Avoid hashtab deadlock with map_locked https://git.kernel.org/bpf/bpf-next/c/20b6cc34ea74
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html