seq_file: add RCU versions of new hlist/list iterators (v2)
Subsystems (6)
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH 1/2 seq_file: add RCU versions of new hlist/list iterators (v2)
Many usages of seq_file use RCU protected lists, so non RCU iterators will not work safely. Needed to make __hlist_for_each_rcu macro (like __list_for_each_rcu).
Also indented prototypes to match existing style.
--- fs/seq_file.c | 88 +++++++++++++++++++++++++++++++++++++++++++++++ include/linux/rculist.h | 5 ++ include/linux/seq_file.h | 27 +++++++++----- 3 files changed, 111 insertions(+), 9 deletions(-)
fs/seq_file.c +88 -0
@@ -695,6 +695,38 @@ struct list_head *seq_list_next(void *v, }EXPORT_SYMBOL (seq_list_next); +struct list_head *seq_list_start_rcu (struct list_head *head,loff_t pos) +{ +struct list_head *lh; + +__list_for_each_rcu (lh, head) +if (pos-- ==0 ) +return lh; + +return NULL ; +} +EXPORT_SYMBOL (seq_list_start_rcu); + +struct list_head *seq_list_start_head_rcu (struct list_head *head,loff_t pos) +{ +if (!pos) +return head; + +return seq_list_start_rcu (head, pos -1 ); +} +EXPORT_SYMBOL (seq_list_start_head_rcu); + +struct list_head *seq_list_next_rcu (void *v,struct list_head *head, +loff_t *ppos) +{ +struct list_head *lh = v; + + lh =rcu_dereference (lh->next); + ++*ppos; +return lh == head ?NULL : lh; +} +EXPORT_SYMBOL (seq_list_next_rcu); +/** * seq_hlist_start - start an iteration of a hlist * @head: the head of the hlist
@@ -750,3 +782,59 @@ struct hlist_node *seq_hlist_next(void *return node->next; }EXPORT_SYMBOL (seq_hlist_next); + +/** +* seq_hlist_start_rcu - start an iteration of a hlist protected by RCU +* @head: the head of the hlist +* @pos: the start position of the sequence +* +* Called at seq_file->op->start(). +*/ +struct hlist_node *seq_hlist_start_rcu (struct hlist_head *head,loff_t pos) +{ +struct hlist_node *node; + +__hlist_for_each_rcu (node, head) +if (pos-- ==0 ) +return node; +return NULL ; +} +EXPORT_SYMBOL (seq_hlist_start_rcu); + +/** +* seq_hlist_start_head_rcu - start an iteration of a hlist protected by RCU +* @head: the head of the hlist +* @pos: the start position of the sequence +* +* Called at seq_file->op->start(). Call this function if you want to +* print a header at the top of the output. +*/ +struct hlist_node *seq_hlist_start_head_rcu (struct hlist_head *head,loff_t pos) +{ +if (!pos) +return SEQ_START_TOKEN ; + +return seq_hlist_start_rcu (head, pos -1 ); +} +EXPORT_SYMBOL (seq_hlist_start_head_rcu); + +/** +* seq_hlist_next_rcu - move to the next position of the hlist protected by RCU +* @v: the current iterator +* @head: the head of the hlist +* @pos: the current posision +* +* Called at seq_file->op->next(). +*/ +struct hlist_node *seq_hlist_next_rcu (void *v,struct hlist_head *head, +loff_t *ppos) +{ +struct hlist_node *node = v; + + ++*ppos; +if (v ==SEQ_START_TOKEN ) +return rcu_dereference (head->first); +else +return rcu_dereference (node->next); +} +EXPORT_SYMBOL (seq_hlist_next_rcu);
include/linux/seq_file.h +18 -9
@@ -127,23 +127,32 @@ int seq_release_private(struct inode *,/* * Helpers for iteration over list_head-s in seq_files */ -extern struct list_head *seq_list_start (struct list_head *head, -loff_t pos); +loff_t pos);extern struct list_head *seq_list_start_head (struct list_head *head, -loff_t pos); +loff_t pos);extern struct list_head *seq_list_next (void *v,struct list_head *head, -loff_t *ppos); - +loff_t *ppos); +extern struct list_head *seq_list_start_rcu (struct list_head *head, +loff_t pos); +extern struct list_head *seq_list_start_head_rcu (struct list_head *head, +loff_t pos); +extern struct list_head *seq_list_next_rcu (void *v,struct list_head *head, +loff_t *ppos);/* * Helpers for iteration over hlist_head-s in seq_files */ -extern struct hlist_node *seq_hlist_start (struct hlist_head *head, -loff_t pos); +loff_t pos);extern struct hlist_node *seq_hlist_start_head (struct hlist_head *head, -loff_t pos); +loff_t pos);extern struct hlist_node *seq_hlist_next (void *v,struct hlist_head *head, -loff_t *ppos); +loff_t *ppos); +extern struct hlist_node *seq_hlist_start_rcu (struct hlist_head *head, +loff_t pos); +extern struct hlist_node *seq_hlist_start_head_rcu (struct hlist_head *head, +loff_t pos); +extern struct hlist_node *seq_hlist_next_rcu (void *v,struct hlist_head *head, +loff_t *ppos);#endif
include/linux/rculist.h +5 -0
@@ -406,6 +406,11 @@ static inline void hlist_add_after_rcu(s n->next->pprev = &n->next; } +#define __hlist_for_each_rcu (pos, head) \ + for (pos = rcu_dereference((head)->first); \ + pos && ({ prefetch(pos->next); 1; }); \ + pos = rcu_dereference(pos->next)) +/** * hlist_for_each_entry_rcu - iterate over rcu list of given type * @tpos: the type * to use as a loop cursor.
PATCH 2/2 packet: convert socket list to RCU
In reply to a message not in the archiveConvert AF_PACKET to use RCU, eliminating one more reader/writer lock.
I needed to create some minor additional socket list RCU infrastructure to make this work. Note: there is no need for a real sk_del_node_init_rcu(), because sk_del_node_init is doing the equivalent thing to hlst_del_init_rcu already; but added some comments to try and make that obvious.
--- include/net/netns/packet.h | 4 ++-- include/net/sock.h | 10 ++++++++++ net/packet/af_packet.c | 42 ++++++++++++++++++++---------------------- 3 files changed, 32 insertions(+), 24 deletions(-)
include/net/netns/packet.h +2 -2
@@ -4,11 +4,11 @@#ifndef __NETNS_PACKET_H__#define __NETNS_PACKET_H__ -#include <linux/list.h> +#include <linux/rculist.h> #include <linux/spinlock.h> struct netns_packet { -rwlock_t sklist_lock; +spinlock_t sklist_lock;struct hlist_head sklist; };
net/packet/af_packet.c +20 -22
94 lines not on this page · raw message
include/net/sock.h +10 -0
@@ -381,6 +381,7 @@ static __inline__ void __sk_del_node(str__hlist_del (&sk->sk_node); } +/* NB: equivalent to hlist_del_init_rcu */ static __inline__int __sk_del_node_init (struct sock *sk) {if (sk_hashed (sk)) {
@@ -421,6 +422,7 @@ static __inline__ int sk_del_node_init(s }return rc; } +#define sk_del_node_init_rcu (sk) sk_del_node_init(sk)static __inline__int __sk_nulls_del_node_init_rcu (struct sock *sk) {
@@ -454,6 +456,12 @@ static __inline__ void sk_add_node(struc__sk_add_node (sk, list); } +static __inline__void sk_add_node_rcu (struct sock *sk,struct hlist_head *list) +{ +sock_hold (sk); +hlist_add_head_rcu (&sk->sk_node, list); +} +static __inline__void __sk_nulls_add_node_rcu (struct sock *sk,struct hlist_nulls_head *list) {hlist_nulls_add_head_rcu (&sk->sk_nulls_node, list);
@@ -478,6 +486,8 @@ static __inline__ void sk_add_bind_node(#define sk_for_each (__sk, node, list) \ hlist_for_each_entry(__sk, node, list, sk_node) +#define sk_for_each_rcu (__sk, node, list) \ + hlist_for_each_entry_rcu(__sk, node, list, sk_node)#define sk_nulls_for_each (__sk, node, list) \ hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_node)#define sk_nulls_for_each_rcu (__sk, node, list) \
Re: [PATCH 2/2] packet: convert socket list to RCU
Quoted 9 lines · Stephen Hemminger
Convert
AF_PACKETto use RCU, eliminating one more reader/writer lock.I needed to create some minor additional socket list RCU infrastructure to make this work. Note: there is no need for a real
sk_del_node_init_rcu(), becausesk_del_node_initis doing the equivalent thing tohlst_del_init_rcualready; but added some comments to try and make that obvious.Signed-off-by Stephen Hemminger <[email protected]>
Stephen, I am a bit worried by the interaction between packet_release() and packet_notifier()
With your version, packet_notifier() can run and let another cpu run packet_release() un-contented. Both cpus could manipulate same po (and particularly po->running)
Before your patch, the read_lock() done in packet_notifier() was preventing packet_release() runnning at the same time.
Maybe packet_release() should lock po->bind_lock before manipulating po->running, avoiding a refcount error.
Something like this preliminary patch :
[PATCH] packet: fix a race in packet_release
packet_release() has a potential race with packet_notifier(NETDEV_DOWN), leading to a double __sock_put(). (dev_remove_pack() is safe)
Fix is to always use po->bind_lock before accessing po->running
---
net/packet/af_packet.c +6 -6
@@ -1271,15 +1271,15 @@ static int packet_release(struct socket *sock)* Unhook packet receive handler. */ +spin_lock (&po->bind_lock);if (po->running) { -/* -* Remove the protocol hook -*/ -dev_remove_pack (&po->prot_hook); +__sock_put (sk); po->running =0 ; po->num =0 ; -__sock_put (sk); - } +spin_unlock (&po->bind_lock); +dev_remove_pack (&po->prot_hook); + }else +spin_unlock (&po->bind_lock);packet_flush_mclist (sk);