bpf: sockmap: add locking annotations to iterator

[kernel-patches-bot]

Pull request for series with
subject: bpf: sockmap: add locking annotations to iterator
version: 1
url: https://patchwork.kernel.org/project/netdevbpf/list/?series=363071

[kernel-patches-bot]

Master branch: 28802e7
series: https://patchwork.kernel.org/project/netdevbpf/list/?series=363071
version: 1

Pull request is NOT updated. Failed to apply https://patchwork.kernel.org/project/netdevbpf/list/?series=363071
error message:

Cmd('git') failed due to: exit code(128)
  cmdline: git am -3
  stdout: 'Applying: bpf: sockmap: add locking annotations to iterator
Using index info to reconstruct a base tree...
M	net/core/sock_map.c
Falling back to patching base and 3-way merge...
Auto-merging net/core/sock_map.c
CONFLICT (content): Merge conflict in net/core/sock_map.c
Patch failed at 0001 bpf: sockmap: add locking annotations to iterator
When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".'
  stderr: 'error: Failed to merge in the changes.
hint: Use 'git am --show-current-patch' to see the failed patch'

conflict:

diff --cc net/core/sock_map.c
index 119f52a99dc1,203900a6ca5f..000000000000
--- a/net/core/sock_map.c
+++ b/net/core/sock_map.c
@@@ -681,8 -716,116 +681,118 @@@ const struct bpf_func_proto bpf_msg_red
  	.arg4_type      = ARG_ANYTHING,
  };
  
++<<<<<<< HEAD
++=======
+ struct sock_map_seq_info {
+ 	struct bpf_map *map;
+ 	struct sock *sk;
+ 	u32 index;
+ };
+ 
+ struct bpf_iter__sockmap {
+ 	__bpf_md_ptr(struct bpf_iter_meta *, meta);
+ 	__bpf_md_ptr(struct bpf_map *, map);
+ 	__bpf_md_ptr(void *, key);
+ 	__bpf_md_ptr(struct sock *, sk);
+ };
+ 
+ DEFINE_BPF_ITER_FUNC(sockmap, struct bpf_iter_meta *meta,
+ 		     struct bpf_map *map, void *key,
+ 		     struct sock *sk)
+ 
+ static void *sock_map_seq_lookup_elem(struct sock_map_seq_info *info)
+ {
+ 	if (unlikely(info->index >= info->map->max_entries))
+ 		return NULL;
+ 
+ 	info->sk = __sock_map_lookup_elem(info->map, info->index);
+ 
+ 	/* can't return sk directly, since that might be NULL */
+ 	return info;
+ }
+ 
+ static void *sock_map_seq_start(struct seq_file *seq, loff_t *pos)
+ 	__acquires(rcu)
+ {
+ 	struct sock_map_seq_info *info = seq->private;
+ 
+ 	if (*pos == 0)
+ 		++*pos;
+ 
+ 	/* pairs with sock_map_seq_stop */
+ 	rcu_read_lock();
+ 	return sock_map_seq_lookup_elem(info);
+ }
+ 
+ static void *sock_map_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+ 	__must_hold(rcu)
+ {
+ 	struct sock_map_seq_info *info = seq->private;
+ 
+ 	++*pos;
+ 	++info->index;
+ 
+ 	return sock_map_seq_lookup_elem(info);
+ }
+ 
+ static int sock_map_seq_show(struct seq_file *seq, void *v)
+ 	__must_hold(rcu)
+ {
+ 	struct sock_map_seq_info *info = seq->private;
+ 	struct bpf_iter__sockmap ctx = {};
+ 	struct bpf_iter_meta meta;
+ 	struct bpf_prog *prog;
+ 
+ 	meta.seq = seq;
+ 	prog = bpf_iter_get_info(&meta, !v);
+ 	if (!prog)
+ 		return 0;
+ 
+ 	ctx.meta = &meta;
+ 	ctx.map = info->map;
+ 	if (v) {
+ 		ctx.key = &info->index;
+ 		ctx.sk = info->sk;
+ 	}
+ 
+ 	return bpf_iter_run_prog(prog, &ctx);
+ }
+ 
+ static void sock_map_seq_stop(struct seq_file *seq, void *v)
+ 	__releases(rcu)
+ {
+ 	if (!v)
+ 		(void)sock_map_seq_show(seq, NULL);
+ 
+ 	/* pairs with sock_map_seq_start */
+ 	rcu_read_unlock();
+ }
+ 
+ static const struct seq_operations sock_map_seq_ops = {
+ 	.start	= sock_map_seq_start,
+ 	.next	= sock_map_seq_next,
+ 	.stop	= sock_map_seq_stop,
+ 	.show	= sock_map_seq_show,
+ };
+ 
+ static int sock_map_init_seq_private(void *priv_data,
+ 				     struct bpf_iter_aux_info *aux)
+ {
+ 	struct sock_map_seq_info *info = priv_data;
+ 
+ 	info->map = aux->map;
+ 	return 0;
+ }
+ 
+ static const struct bpf_iter_seq_info sock_map_iter_seq_info = {
+ 	.seq_ops		= &sock_map_seq_ops,
+ 	.init_seq_private	= sock_map_init_seq_private,
+ 	.seq_priv_size		= sizeof(struct sock_map_seq_info),
+ };
+ 
++>>>>>>> bpf: sockmap: add locking annotations to iterator
  static int sock_map_btf_id;
  const struct bpf_map_ops sock_map_ops = {
 -	.map_meta_equal		= bpf_map_meta_equal,
  	.map_alloc		= sock_map_alloc,
  	.map_free		= sock_map_free,
  	.map_get_next_key	= sock_map_get_next_key,
@@@ -1217,8 -1320,124 +1327,126 @@@ const struct bpf_func_proto bpf_msg_red
  	.arg4_type      = ARG_ANYTHING,
  };
  
++<<<<<<< HEAD
++=======
+ struct sock_hash_seq_info {
+ 	struct bpf_map *map;
+ 	struct bpf_shtab *htab;
+ 	u32 bucket_id;
+ };
+ 
+ static void *sock_hash_seq_find_next(struct sock_hash_seq_info *info,
+ 				     struct bpf_shtab_elem *prev_elem)
+ {
+ 	const struct bpf_shtab *htab = info->htab;
+ 	struct bpf_shtab_bucket *bucket;
+ 	struct bpf_shtab_elem *elem;
+ 	struct hlist_node *node;
+ 
+ 	/* try to find next elem in the same bucket */
+ 	if (prev_elem) {
+ 		node = rcu_dereference(hlist_next_rcu(&prev_elem->node));
+ 		elem = hlist_entry_safe(node, struct bpf_shtab_elem, node);
+ 		if (elem)
+ 			return elem;
+ 
+ 		/* no more elements, continue in the next bucket */
+ 		info->bucket_id++;
+ 	}
+ 
+ 	for (; info->bucket_id < htab->buckets_num; info->bucket_id++) {
+ 		bucket = &htab->buckets[info->bucket_id];
+ 		node = rcu_dereference(hlist_first_rcu(&bucket->head));
+ 		elem = hlist_entry_safe(node, struct bpf_shtab_elem, node);
+ 		if (elem)
+ 			return elem;
+ 	}
+ 
+ 	return NULL;
+ }
+ 
+ static void *sock_hash_seq_start(struct seq_file *seq, loff_t *pos)
+ 	__acquires(rcu)
+ {
+ 	struct sock_hash_seq_info *info = seq->private;
+ 
+ 	if (*pos == 0)
+ 		++*pos;
+ 
+ 	/* pairs with sock_hash_seq_stop */
+ 	rcu_read_lock();
+ 	return sock_hash_seq_find_next(info, NULL);
+ }
+ 
+ static void *sock_hash_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+ 	__must_hold(rcu)
+ {
+ 	struct sock_hash_seq_info *info = seq->private;
+ 
+ 	++*pos;
+ 	return sock_hash_seq_find_next(info, v);
+ }
+ 
+ static int sock_hash_seq_show(struct seq_file *seq, void *v)
+ 	__must_hold(rcu)
+ {
+ 	struct sock_hash_seq_info *info = seq->private;
+ 	struct bpf_iter__sockmap ctx = {};
+ 	struct bpf_shtab_elem *elem = v;
+ 	struct bpf_iter_meta meta;
+ 	struct bpf_prog *prog;
+ 
+ 	meta.seq = seq;
+ 	prog = bpf_iter_get_info(&meta, !elem);
+ 	if (!prog)
+ 		return 0;
+ 
+ 	ctx.meta = &meta;
+ 	ctx.map = info->map;
+ 	if (elem) {
+ 		ctx.key = elem->key;
+ 		ctx.sk = elem->sk;
+ 	}
+ 
+ 	return bpf_iter_run_prog(prog, &ctx);
+ }
+ 
+ static void sock_hash_seq_stop(struct seq_file *seq, void *v)
+ 	__releases(rcu)
+ {
+ 	if (!v)
+ 		(void)sock_hash_seq_show(seq, NULL);
+ 
+ 	/* pairs with sock_hash_seq_start */
+ 	rcu_read_unlock();
+ }
+ 
+ static const struct seq_operations sock_hash_seq_ops = {
+ 	.start	= sock_hash_seq_start,
+ 	.next	= sock_hash_seq_next,
+ 	.stop	= sock_hash_seq_stop,
+ 	.show	= sock_hash_seq_show,
+ };
+ 
+ static int sock_hash_init_seq_private(void *priv_data,
+ 				     struct bpf_iter_aux_info *aux)
+ {
+ 	struct sock_hash_seq_info *info = priv_data;
+ 
+ 	info->map = aux->map;
+ 	info->htab = container_of(aux->map, struct bpf_shtab, map);
+ 	return 0;
+ }
+ 
+ static const struct bpf_iter_seq_info sock_hash_iter_seq_info = {
+ 	.seq_ops		= &sock_hash_seq_ops,
+ 	.init_seq_private	= sock_hash_init_seq_private,
+ 	.seq_priv_size		= sizeof(struct sock_hash_seq_info),
+ };
+ 
++>>>>>>> bpf: sockmap: add locking annotations to iterator
  static int sock_hash_map_btf_id;
  const struct bpf_map_ops sock_hash_ops = {
 -	.map_meta_equal		= bpf_map_meta_equal,
  	.map_alloc		= sock_hash_alloc,
  	.map_free		= sock_hash_free,
  	.map_get_next_key	= sock_hash_get_next_key,

[kernel-patches-bot]

At least one diff in series https://patchwork.kernel.org/project/netdevbpf/list/?series=363071 irrelevant now. Closing PR.