IPMI: fix some RCU problems
PATCH 1/1 IPMI: fix some RCU problems
Fix some RCU problem pointed out by Paul McKenney of IBM. These are:
The wholesale move of the command receivers list into a new list was not safe because the list will point to the new tail during a traversal, so the traversal will never end on a reader if this happens during a read.
Memory barriers were needed to handle proper ordering of the setting of the IPMI interface as valid. Readers might not see proper ordering of data otherwise.
In ipmi_smi_watcher_register(), the use of the _rcu suffix on the list is unnecessary.
drivers/char/ipmi/ipmi_msghandler.c +28 -6
@@ -406,13 +406,31 @@ static void clean_up_interface_data(ipmifree_smi_msg_list (&intf->waiting_msgs);free_recv_msg_list (&intf->waiting_events); -/* Wholesale remove all the entries from the list in the -* interface and wait for RCU to know that none are in use. */ +/* +* Wholesale remove all the entries from the list in the +* interface and wait for RCU to know that none are in use. +*/ mutex_lock (&intf->cmd_rcvrs_mutex); -list_add_rcu (&list, &intf->cmd_rcvrs); -list_del_rcu (&intf->cmd_rcvrs); +if (list_empty (&intf->cmd_rcvrs)) +INIT_LIST_HEAD (&list); +else { + list.next = intf->cmd_rcvrs.next; + list.prev = intf->cmd_rcvrs.prev; +INIT_LIST_HEAD (&intf->cmd_rcvrs); + +/* +* At this point the list body still points to +* intf->cmd_rcvrs. Wait for any readers to finish +* using the list before we switch the list body over +* to the new list. +*/ +synchronize_rcu (); + +/* Ready the list for use. */ + list.next->prev = &list; + list.prev->next = &list; + }mutex_unlock (&intf->cmd_rcvrs_mutex); -synchronize_rcu ();list_for_each_entry_safe (rcvr, rcvr2, &list, link)kfree (rcvr);
@@ -451,7 +469,7 @@ int ipmi_smi_watcher_register(struct ipmmutex_lock (&ipmi_interfaces_mutex);/* Build a list of things to deliver. */ -list_for_each_entry_rcu (intf, &ipmi_interfaces, link) { +list_for_each_entry (intf, &ipmi_interfaces, link) {if (intf->intf_num ==-1 )continue ; e =kmalloc (sizeof (*e),GFP_KERNEL );
@@ -838,6 +856,7 @@ int ipmi_create_user(unsigned int goto out_kfree; found: +smp_rmb ();/* Note that each existing user holds a refcount to the interface. */ kref_get (&intf->refcount);
@@ -2761,6 +2780,7 @@ int ipmi_register_smi(struct ipmi_smi_hakref_put (&intf->refcount, intf_free); }else {/* After this point the interface is legal to use. */ +smp_wmb ();/* Keep memory order straight for RCU readers. */ intf->intf_num = i;mutex_unlock (&ipmi_interfaces_mutex);call_smi_watchers (i, intf->si_dev);
@@ -3924,6 +3944,8 @@ static void send_panic_events(char *str)/* Interface was not ready yet. */ continue ; +smp_rmb (); +/* First job here is to figure out where to send the OEM events. There's no way in IPMI to send OEM events using an event send command, so we have to
Quoted 9 lines
drivers/char/ipmi/ipmi_msghandler.c +9
-0+if (list_empty (&intf->cmd_rcvrs)) +INIT_LIST_HEAD (&list); +else { + list.next = intf->cmd_rcvrs.next; + list.prev = intf->cmd_rcvrs.prev; +INIT_LIST_HEAD (&intf->cmd_rcvrs); + +/* +* At this point the list body still points to
drivers/char/ipmi/ipmi_msghandler.c static void clean_up_interface_data(ipmi · line 432
Quoted 10 lines
drivers/char/ipmi/ipmi_msghandler.c +10
-0+* intf->cmd_rcvrs. Wait for any readers to finish +* using the list before we switch the list body over +* to the new list. +*/ +synchronize_rcu (); + +/* Ready the list for use. */ + list.next->prev = &list; + list.prev->next = &list; + }
This kind of thing must not be opencoded in drivers. Please add a new list_splice_rcu helper to list.h
Quoted 14 lines · Christoph Hellwig
Quoted 14 lines
(quoted diff) +14
-0+ if (list_empty(&intf->cmd_rcvrs)) + INIT_LIST_HEAD(&list); + else { + list.next = intf->cmd_rcvrs.next; + list.prev = intf->cmd_rcvrs.prev; + INIT_LIST_HEAD(&intf->cmd_rcvrs); + + /* + * At this point the list body still points to + * intf->cmd_rcvrs. Wait for any readers to finish + * using the list before we switch the list body over + * to the new list. + */ + synchronize_rcu();
Quoted 8 lines
Review
Quoted 5 lines
(quoted diff) +5
-0+ + /* Ready the list for use. */ + list.next->prev = &list; + list.prev->next = &list; + }This kind of thing must not be opencoded in drivers. Please add a new
list_splice_rcuhelper tolist.h
I must admit that this sounds better than list_privatize_rcu(). But since the source list gets initialized, so how about list_splice_init_rcu()? Patch below, untested, probably does not compile. This takes the sync function as an argument, so one would do something like:
INIT_LIST_HEAD(&list); list_splice_init_rcu(&intf->cmdrcvrs, &list, synchronize_rcu);
The idea being to keep the RCU API proliferation down to a dull roar.
Thoughts?
---
list.h | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+)
include/linux/list.h +58 -0
@@ -360,6 +360,64 @@ static inline void list_splice_init(stru }/** +* list_splice_init_rcu - splice an RCU-protected list into an existing list. +* @list the RCU-protected list to splice +* @head the place in the list to splice the first list into +* @sync function to sync: synchronize_rcu(), synchronize_sched(), ... +* +* @head can be RCU-read traversed concurrently with this function. +* +* Note that this function blocks. +* +* Important note: the caller must take whatever action is necessary to +* prevent any other updates to @head. In principle, it is possible +* to modify the list as soon as sync() begins execution. +* If this sort of thing becomes necessary, an alternative version +* based on call_rcu() could be created. But only if -really- +* needed -- there is no shortage of RCU API members. +*/ +static inline void list_splice_init_rcu (struct list_head *list, +struct list_head *head, +void (*sync)(void )) +{ +struct list_head *first = list->next; +struct list_head *last = list->prev; +struct list_head *at = head->next; + +might_sleep (); +if (list_empty (head)) { +return ; + } + +/* "first" and "last" tracking list, so initialize it. */ + +INIT_LIST_HEAD (list); + +/* +* At this point, the list body still points to the source list. +* Wait for any readers to finish using the list before splicing +* the list body into the new list. Any new readers will see +* an empty list. +*/ + +sync (); + +/* +* Readers are finished with the source list, so perform splice. +* The order is important if the new list is global and accessible +* to concurrent RCU readers. Note that RCU readers are not +* permitted to traverse the prev pointers without excluding +* this function. +*/ + + last->next = at; +smp_wmb (); + head->next = first; + first->prev = head; + at->prev = last; +} + +/** * list_entry - get the struct for this entry * @ptr: the &struct list_head pointer. * @type: the type of the struct this is embedded in.
Quoted 7 lines · On Thu, 28 Dec 2006 11:55:04 -0800 Paul E. McKenney wrote:
list.h | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+)diff -urpNa -X dontdiff
linux-2.6.19/include/linux/list.hlinux-2.6.19-lpr/include/linux/list.h
include/linux/list.h static inline void list_splice_init(stru · line 366
Quoted 7 lines
include/linux/list.h +4
-0@@ -360,6 +360,64 @@ static inline void list_splice_init(stru }/** +* list_splice_init_rcu - splice an RCU-protected list into an existing list. +* @list the RCU-protected list to splice +* @head the place in the list to splice the first list into +* @sync function to sync: synchronize_rcu(), synchronize_sched(), ...
@parameter: is kernel-doc syntax.
I.e., please add a colon after each one of those.
---
~Randy
Quoted 11 lines · Randy Dunlap
Quoted 9 lines · On Thu, 28 Dec 2006 11:55:04 -0800 Paul E. McKenney wrote:
list.h | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+)diff -urpNa -X dontdiff
linux-2.6.19/include/linux/list.hlinux-2.6.19-lpr/include/linux/list.hinclude/linux/list.h +0
-0@@ -360,6 +360,64 @@ static inline void list_splice_init(stru }
Quoted 8 lines
include/linux/list.h static inline void list_splice_init(stru · line 366
Quoted 5 lines
include/linux/list.h +4
-0/** +* list_splice_init_rcu - splice an RCU-protected list into an existing list. +* @list the RCU-protected list to splice +* @head the place in the list to splice the first list into +* @sync function to sync: synchronize_rcu(), synchronize_sched(), ... @parameter: is kernel-doc syntax.
I.e., please add a colon after each one of those.
Good point! :-/
Fixed below.
---
list.h | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+)
include/linux/list.h +58 -0
@@ -360,6 +360,64 @@ static inline void list_splice_init(stru }/** +* list_splice_init_rcu - splice an RCU-protected list into an existing list. +* @list: the RCU-protected list to splice +* @head: the place in the list to splice the first list into +* @sync: function to sync: synchronize_rcu(), synchronize_sched(), ... +* +* @head can be RCU-read traversed concurrently with this function. +* +* Note that this function blocks. +* +* Important note: the caller must take whatever action is necessary to +* prevent any other updates to @head. In principle, it is possible +* to modify the list as soon as sync() begins execution. +* If this sort of thing becomes necessary, an alternative version +* based on call_rcu() could be created. But only if -really- +* needed -- there is no shortage of RCU API members. +*/ +static inline void list_splice_init_rcu (struct list_head *list, +struct list_head *head, +void (*sync)(void )) +{ +struct list_head *first = list->next; +struct list_head *last = list->prev; +struct list_head *at = head->next; + +might_sleep (); +if (list_empty (head)) { +return ; + } + +/* "first" and "last" tracking list, so initialize it. */ + +INIT_LIST_HEAD (list); + +/* +* At this point, the list body still points to the source list. +* Wait for any readers to finish using the list before splicing +* the list body into the new list. Any new readers will see +* an empty list. +*/ + +sync (); + +/* +* Readers are finished with the source list, so perform splice. +* The order is important if the new list is global and accessible +* to concurrent RCU readers. Note that RCU readers are not +* permitted to traverse the prev pointers without excluding +* this function. +*/ + + last->next = at; +smp_wmb (); + head->next = first; + first->prev = head; + at->prev = last; +} + +/** * list_entry - get the struct for this entry * @ptr: the &struct list_head pointer. * @type: the type of the struct this is embedded in.