Commit e86ee2d4 authored by Corey Minyard's avatar Corey Minyard

ipmi: Rework locking and shutdown for hot remove

To handle hot remove of interfaces, a lot of rework had to be
done to the locking.  Several things were switched over to srcu
and shutdown for users and interfaces was added for cleaner
shutdown.
Signed-off-by: default avatarCorey Minyard <cminyard@mvista.com>
parent ac93bd0c
......@@ -197,8 +197,12 @@ MODULE_PARM_DESC(default_max_retries,
struct ipmi_user {
struct list_head link;
/* Set to false when the user is destroyed. */
bool valid;
/*
* Set to NULL when the user is destroyed, a pointer to myself
* so srcu_dereference can be used on it.
*/
struct ipmi_user *self;
struct srcu_struct release_barrier;
struct kref refcount;
......@@ -213,6 +217,23 @@ struct ipmi_user {
bool gets_events;
};
static struct ipmi_user *acquire_ipmi_user(struct ipmi_user *user, int *index)
__acquires(user->release_barrier)
{
struct ipmi_user *ruser;
*index = srcu_read_lock(&user->release_barrier);
ruser = srcu_dereference(user->self, &user->release_barrier);
if (!ruser)
srcu_read_unlock(&user->release_barrier, *index);
return ruser;
}
static void release_ipmi_user(struct ipmi_user *user, int index)
{
srcu_read_unlock(&user->release_barrier, index);
}
struct cmd_rcvr {
struct list_head link;
......@@ -444,10 +465,11 @@ struct ipmi_smi {
struct list_head link;
/*
* The list of upper layers that are using me. seq_lock
* protects this.
* The list of upper layers that are using me. seq_lock write
* protects this. Read protection is with srcu.
*/
struct list_head users;
struct srcu_struct users_srcu;
/* Used for wake ups at startup. */
wait_queue_head_t waitq;
......@@ -467,12 +489,6 @@ struct ipmi_smi {
bool in_bmc_register; /* Handle recursive situations. Yuck. */
struct work_struct bmc_reg_work;
/*
* This is the lower-layer's sender routine. Note that you
* must either be holding the ipmi_interfaces_mutex or be in
* an umpreemptible region to use this. You must fetch the
* value into a local variable and make sure it is not NULL.
*/
const struct ipmi_smi_handlers *handlers;
void *send_info;
......@@ -615,6 +631,7 @@ static DEFINE_MUTEX(ipmidriver_mutex);
static LIST_HEAD(ipmi_interfaces);
static DEFINE_MUTEX(ipmi_interfaces_mutex);
DEFINE_STATIC_SRCU(ipmi_interfaces_srcu);
/*
* List of watchers that want to know when smi's are added and deleted.
......@@ -722,51 +739,25 @@ struct watcher_entry {
int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher)
{
struct ipmi_smi *intf;
LIST_HEAD(to_deliver);
struct watcher_entry *e, *e2;
int index;
mutex_lock(&smi_watchers_mutex);
mutex_lock(&ipmi_interfaces_mutex);
/* Build a list of things to deliver. */
list_for_each_entry(intf, &ipmi_interfaces, link) {
if (intf->intf_num == -1)
continue;
e = kmalloc(sizeof(*e), GFP_KERNEL);
if (!e)
goto out_err;
kref_get(&intf->refcount);
e->intf = intf;
e->intf_num = intf->intf_num;
list_add_tail(&e->link, &to_deliver);
}
/* We will succeed, so add it to the list. */
list_add(&watcher->link, &smi_watchers);
mutex_unlock(&ipmi_interfaces_mutex);
index = srcu_read_lock(&ipmi_interfaces_srcu);
list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
int intf_num = READ_ONCE(intf->intf_num);
list_for_each_entry_safe(e, e2, &to_deliver, link) {
list_del(&e->link);
watcher->new_smi(e->intf_num, e->intf->si_dev);
kref_put(&e->intf->refcount, intf_free);
kfree(e);
if (intf_num == -1)
continue;
watcher->new_smi(intf_num, intf->si_dev);
}
srcu_read_unlock(&ipmi_interfaces_srcu, index);
mutex_unlock(&smi_watchers_mutex);
return 0;
out_err:
mutex_unlock(&ipmi_interfaces_mutex);
mutex_unlock(&smi_watchers_mutex);
list_for_each_entry_safe(e, e2, &to_deliver, link) {
list_del(&e->link);
kref_put(&e->intf->refcount, intf_free);
kfree(e);
}
return -ENOMEM;
}
EXPORT_SYMBOL(ipmi_smi_watcher_register);
......@@ -787,12 +778,14 @@ call_smi_watchers(int i, struct device *dev)
{
struct ipmi_smi_watcher *w;
mutex_lock(&smi_watchers_mutex);
list_for_each_entry(w, &smi_watchers, link) {
if (try_module_get(w->owner)) {
w->new_smi(i, dev);
module_put(w->owner);
}
}
mutex_unlock(&smi_watchers_mutex);
}
static int
......@@ -905,9 +898,17 @@ static int deliver_response(struct ipmi_smi *intf, struct ipmi_recv_msg *msg)
* receive handler doesn't much meaning and has a deadlock
* risk. At this moment, simply skip it in that case.
*/
int index;
struct ipmi_user *user = acquire_ipmi_user(msg->user, &index);
struct ipmi_user *user = msg->user;
if (user) {
user->handler->ipmi_recv_hndl(msg, user->handler_data);
release_ipmi_user(msg->user, index);
} else {
/* User went away, give up. */
ipmi_free_recv_msg(msg);
rv = -EINVAL;
}
}
return rv;
......@@ -1094,7 +1095,7 @@ int ipmi_create_user(unsigned int if_num,
{
unsigned long flags;
struct ipmi_user *new_user;
int rv = 0;
int rv = 0, index;
struct ipmi_smi *intf;
/*
......@@ -1129,7 +1130,7 @@ int ipmi_create_user(unsigned int if_num,
if (!new_user)
return -ENOMEM;
mutex_lock(&ipmi_interfaces_mutex);
index = srcu_read_lock(&ipmi_interfaces_srcu);
list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
if (intf->intf_num == if_num)
goto found;
......@@ -1139,6 +1140,10 @@ int ipmi_create_user(unsigned int if_num,
goto out_kfree;
found:
rv = init_srcu_struct(&new_user->release_barrier);
if (rv)
goto out_kfree;
/* Note that each existing user holds a refcount to the interface. */
kref_get(&intf->refcount);
......@@ -1148,26 +1153,7 @@ int ipmi_create_user(unsigned int if_num,
new_user->intf = intf;
new_user->gets_events = false;
if (!try_module_get(intf->handlers->owner)) {
rv = -ENODEV;
goto out_kref;
}
if (intf->handlers->inc_usecount) {
rv = intf->handlers->inc_usecount(intf->send_info);
if (rv) {
module_put(intf->handlers->owner);
goto out_kref;
}
}
/*
* Hold the lock so intf->handlers is guaranteed to be good
* until now
*/
mutex_unlock(&ipmi_interfaces_mutex);
new_user->valid = true;
rcu_assign_pointer(new_user->self, new_user);
spin_lock_irqsave(&intf->seq_lock, flags);
list_add_rcu(&new_user->link, &intf->users);
spin_unlock_irqrestore(&intf->seq_lock, flags);
......@@ -1176,13 +1162,12 @@ int ipmi_create_user(unsigned int if_num,
if (atomic_inc_return(&intf->event_waiters) == 1)
need_waiter(intf);
}
srcu_read_unlock(&ipmi_interfaces_srcu, index);
*user = new_user;
return 0;
out_kref:
kref_put(&intf->refcount, intf_free);
out_kfree:
mutex_unlock(&ipmi_interfaces_mutex);
srcu_read_unlock(&ipmi_interfaces_srcu, index);
kfree(new_user);
return rv;
}
......@@ -1190,26 +1175,25 @@ EXPORT_SYMBOL(ipmi_create_user);
int ipmi_get_smi_info(int if_num, struct ipmi_smi_info *data)
{
int rv = 0;
int rv, index;
struct ipmi_smi *intf;
const struct ipmi_smi_handlers *handlers;
mutex_lock(&ipmi_interfaces_mutex);
index = srcu_read_lock(&ipmi_interfaces_srcu);
list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
if (intf->intf_num == if_num)
goto found;
}
srcu_read_unlock(&ipmi_interfaces_srcu, index);
/* Not found, return an error */
rv = -EINVAL;
mutex_unlock(&ipmi_interfaces_mutex);
return rv;
return -EINVAL;
found:
handlers = intf->handlers;
rv = -ENOSYS;
if (handlers->get_smi_info)
rv = handlers->get_smi_info(intf->send_info, data);
mutex_unlock(&ipmi_interfaces_mutex);
if (!intf->handlers->get_smi_info)
rv = -ENOTTY;
else
rv = intf->handlers->get_smi_info(intf->send_info, data);
srcu_read_unlock(&ipmi_interfaces_srcu, index);
return rv;
}
......@@ -1221,7 +1205,7 @@ static void free_user(struct kref *ref)
kfree(user);
}
int ipmi_destroy_user(struct ipmi_user *user)
static void _ipmi_destroy_user(struct ipmi_user *user)
{
struct ipmi_smi *intf = user->intf;
int i;
......@@ -1229,7 +1213,22 @@ int ipmi_destroy_user(struct ipmi_user *user)
struct cmd_rcvr *rcvr;
struct cmd_rcvr *rcvrs = NULL;
user->valid = false;
if (!acquire_ipmi_user(user, &i)) {
/*
* The user has already been cleaned up, just make sure
* nothing is using it and return.
*/
synchronize_srcu(&user->release_barrier);
return;
}
rcu_assign_pointer(user->self, NULL);
release_ipmi_user(user, i);
synchronize_srcu(&user->release_barrier);
if (user->handler->shutdown)
user->handler->shutdown(user->handler_data);
if (user->handler->ipmi_watchdog_pretimeout)
atomic_dec(&intf->event_waiters);
......@@ -1254,7 +1253,7 @@ int ipmi_destroy_user(struct ipmi_user *user)
* Remove the user from the command receiver's table. First
* we build a list of everything (not using the standard link,
* since other things may be using it till we do
* synchronize_rcu()) then free everything in that list.
* synchronize_srcu()) then free everything in that list.
*/
mutex_lock(&intf->cmd_rcvrs_mutex);
list_for_each_entry_rcu(rcvr, &intf->cmd_rcvrs, link) {
......@@ -1272,16 +1271,14 @@ int ipmi_destroy_user(struct ipmi_user *user)
kfree(rcvr);
}
mutex_lock(&ipmi_interfaces_mutex);
if (intf->handlers) {
module_put(intf->handlers->owner);
if (intf->handlers->dec_usecount)
intf->handlers->dec_usecount(intf->send_info);
}
mutex_unlock(&ipmi_interfaces_mutex);
kref_put(&intf->refcount, intf_free);
}
int ipmi_destroy_user(struct ipmi_user *user)
{
_ipmi_destroy_user(user);
cleanup_srcu_struct(&user->release_barrier);
kref_put(&user->refcount, free_user);
return 0;
......@@ -1293,16 +1290,20 @@ int ipmi_get_version(struct ipmi_user *user,
unsigned char *minor)
{
struct ipmi_device_id id;
int rv;
int rv, index;
rv = bmc_get_device_id(user->intf, NULL, &id, NULL, NULL);
if (rv)
return rv;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
rv = bmc_get_device_id(user->intf, NULL, &id, NULL, NULL);
if (!rv) {
*major = ipmi_version_major(&id);
*minor = ipmi_version_minor(&id);
}
release_ipmi_user(user, index);
return 0;
return rv;
}
EXPORT_SYMBOL(ipmi_get_version);
......@@ -1310,9 +1311,17 @@ int ipmi_set_my_address(struct ipmi_user *user,
unsigned int channel,
unsigned char address)
{
int index;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
if (channel >= IPMI_MAX_CHANNELS)
return -EINVAL;
user->intf->addrinfo[channel].address = address;
release_ipmi_user(user, index);
return 0;
}
EXPORT_SYMBOL(ipmi_set_my_address);
......@@ -1321,9 +1330,17 @@ int ipmi_get_my_address(struct ipmi_user *user,
unsigned int channel,
unsigned char *address)
{
int index;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
if (channel >= IPMI_MAX_CHANNELS)
return -EINVAL;
*address = user->intf->addrinfo[channel].address;
release_ipmi_user(user, index);
return 0;
}
EXPORT_SYMBOL(ipmi_get_my_address);
......@@ -1332,9 +1349,17 @@ int ipmi_set_my_LUN(struct ipmi_user *user,
unsigned int channel,
unsigned char LUN)
{
int index;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
if (channel >= IPMI_MAX_CHANNELS)
return -EINVAL;
user->intf->addrinfo[channel].lun = LUN & 0x3;
release_ipmi_user(user, index);
return 0;
}
EXPORT_SYMBOL(ipmi_set_my_LUN);
......@@ -1343,21 +1368,34 @@ int ipmi_get_my_LUN(struct ipmi_user *user,
unsigned int channel,
unsigned char *address)
{
int index;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
if (channel >= IPMI_MAX_CHANNELS)
return -EINVAL;
*address = user->intf->addrinfo[channel].lun;
release_ipmi_user(user, index);
return 0;
}
EXPORT_SYMBOL(ipmi_get_my_LUN);
int ipmi_get_maintenance_mode(struct ipmi_user *user)
{
int mode;
int mode, index;
unsigned long flags;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
spin_lock_irqsave(&user->intf->maintenance_mode_lock, flags);
mode = user->intf->maintenance_mode;
spin_unlock_irqrestore(&user->intf->maintenance_mode_lock, flags);
release_ipmi_user(user, index);
return mode;
}
......@@ -1372,10 +1410,14 @@ static void maintenance_mode_update(struct ipmi_smi *intf)
int ipmi_set_maintenance_mode(struct ipmi_user *user, int mode)
{
int rv = 0;
int rv = 0, index;
unsigned long flags;
struct ipmi_smi *intf = user->intf;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
spin_lock_irqsave(&intf->maintenance_mode_lock, flags);
if (intf->maintenance_mode != mode) {
switch (mode) {
......@@ -1402,6 +1444,7 @@ int ipmi_set_maintenance_mode(struct ipmi_user *user, int mode)
}
out_unlock:
spin_unlock_irqrestore(&intf->maintenance_mode_lock, flags);
release_ipmi_user(user, index);
return rv;
}
......@@ -1413,6 +1456,11 @@ int ipmi_set_gets_events(struct ipmi_user *user, bool val)
struct ipmi_smi *intf = user->intf;
struct ipmi_recv_msg *msg, *msg2;
struct list_head msgs;
int index;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
INIT_LIST_HEAD(&msgs);
......@@ -1462,6 +1510,7 @@ int ipmi_set_gets_events(struct ipmi_user *user, bool val)
out:
spin_unlock_irqrestore(&intf->events_lock, flags);
release_ipmi_user(user, index);
return 0;
}
......@@ -1504,8 +1553,11 @@ int ipmi_register_for_cmd(struct ipmi_user *user,
{
struct ipmi_smi *intf = user->intf;
struct cmd_rcvr *rcvr;
int rv = 0;
int rv = 0, index;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
rcvr = kmalloc(sizeof(*rcvr), GFP_KERNEL);
if (!rcvr)
......@@ -1531,6 +1583,7 @@ int ipmi_register_for_cmd(struct ipmi_user *user,
mutex_unlock(&intf->cmd_rcvrs_mutex);
if (rv)
kfree(rcvr);
release_ipmi_user(user, index);
return rv;
}
......@@ -1544,7 +1597,11 @@ int ipmi_unregister_for_cmd(struct ipmi_user *user,
struct ipmi_smi *intf = user->intf;
struct cmd_rcvr *rcvr;
struct cmd_rcvr *rcvrs = NULL;
int i, rv = -ENOENT;
int i, rv = -ENOENT, index;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
mutex_lock(&intf->cmd_rcvrs_mutex);
for (i = 0; i < IPMI_NUM_CHANNELS; i++) {
......@@ -1565,12 +1622,14 @@ int ipmi_unregister_for_cmd(struct ipmi_user *user,
}
mutex_unlock(&intf->cmd_rcvrs_mutex);
synchronize_rcu();
release_ipmi_user(user, index);
while (rcvrs) {
atomic_dec(&intf->event_waiters);
rcvr = rcvrs;
rcvrs = rcvr->next;
kfree(rcvr);
}
return rv;
}
EXPORT_SYMBOL(ipmi_unregister_for_cmd);
......@@ -2065,8 +2124,10 @@ static int i_ipmi_request(struct ipmi_user *user,
recv_msg = supplied_recv;
else {
recv_msg = ipmi_alloc_recv_msg();
if (recv_msg == NULL)
return -ENOMEM;
if (recv_msg == NULL) {
rv = -ENOMEM;
goto out;
}
}
recv_msg->user_msg_data = user_msg_data;
......@@ -2076,7 +2137,8 @@ static int i_ipmi_request(struct ipmi_user *user,
smi_msg = ipmi_alloc_smi_msg();
if (smi_msg == NULL) {
ipmi_free_recv_msg(recv_msg);
return -ENOMEM;
rv = -ENOMEM;
goto out;
}
}
......@@ -2088,6 +2150,7 @@ static int i_ipmi_request(struct ipmi_user *user,
recv_msg->user = user;
if (user)
/* The put happens when the message is freed. */
kref_get(&user->refcount);
recv_msg->msgid = msgid;
/*
......@@ -2123,6 +2186,7 @@ static int i_ipmi_request(struct ipmi_user *user,
}
rcu_read_unlock();
out:
return rv;
}
......@@ -2148,14 +2212,18 @@ int ipmi_request_settime(struct ipmi_user *user,
unsigned int retry_time_ms)
{
unsigned char saddr = 0, lun = 0;
int rv;
int rv, index;
if (!user)
return -EINVAL;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
rv = check_addr(user->intf, addr, &saddr, &lun);
if (rv)
return rv;
return i_ipmi_request(user,
if (!rv)
rv = i_ipmi_request(user,
user->intf,
addr,
msgid,
......@@ -2167,6 +2235,9 @@ int ipmi_request_settime(struct ipmi_user *user,
lun,
retries,
retry_time_ms);
release_ipmi_user(user, index);
return rv;
}
EXPORT_SYMBOL(ipmi_request_settime);
......@@ -2180,14 +2251,18 @@ int ipmi_request_supply_msgs(struct ipmi_user *user,
int priority)
{
unsigned char saddr = 0, lun = 0;
int rv;
int rv, index;
if (!user)
return -EINVAL;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
rv = check_addr(user->intf, addr, &saddr, &lun);
if (rv)
return rv;
return i_ipmi_request(user,
if (!rv)
rv = i_ipmi_request(user,
user->intf,
addr,
msgid,
......@@ -2199,6 +2274,9 @@ int ipmi_request_supply_msgs(struct ipmi_user *user,
saddr,
lun,
-1, 0);
release_ipmi_user(user, index);
return rv;
}
EXPORT_SYMBOL(ipmi_request_supply_msgs);
......@@ -3455,6 +3533,13 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
if (!intf)
return -ENOMEM;
rv = init_srcu_struct(&intf->users_srcu);
if (rv) {
kfree(intf);
return rv;
}
intf->bmc = &intf->tmp_bmc;
INIT_LIST_HEAD(&intf->bmc->intfs);
mutex_init(&intf->bmc->dyn_mutex);
......@@ -3507,7 +3592,6 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
intf->proc_dir = NULL;
#endif
mutex_lock(&smi_watchers_mutex);
mutex_lock(&ipmi_interfaces_mutex);
/* Look for a hole in the numbers. */
i = 0;
......@@ -3552,11 +3636,10 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
if (intf->proc_dir)
remove_proc_entries(intf);
#endif
intf->handlers = NULL;
list_del_rcu(&intf->link);
mutex_unlock(&ipmi_interfaces_mutex);
mutex_unlock(&smi_watchers_mutex);
synchronize_rcu();
synchronize_srcu(&ipmi_interfaces_srcu);
cleanup_srcu_struct(&intf->users_srcu);
kref_put(&intf->refcount, intf_free);
} else {
/*
......@@ -3567,9 +3650,9 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
smp_wmb();
intf->intf_num = i;
mutex_unlock(&ipmi_interfaces_mutex);
/* After this point the interface is legal to use. */
call_smi_watchers(i, intf->si_dev);
mutex_unlock(&smi_watchers_mutex);
}
return rv;
......@@ -3631,45 +3714,49 @@ static void cleanup_smi_msgs(struct ipmi_smi *intf)
int ipmi_unregister_smi(struct ipmi_smi *intf)
{
struct ipmi_smi_watcher *w;
int intf_num = intf->intf_num;
struct ipmi_user *user;
int intf_num = intf->intf_num, index;
mutex_lock(&smi_watchers_mutex);
mutex_lock(&ipmi_interfaces_mutex);
intf->intf_num = -1;
intf->in_shutdown = true;
list_del_rcu(&intf->link);
mutex_unlock(&ipmi_interfaces_mutex);
synchronize_rcu();
synchronize_srcu(&ipmi_interfaces_srcu);
cleanup_smi_msgs(intf);
/* Clean up the effects of users on the lower-level software. */
mutex_lock(&ipmi_interfaces_mutex);
rcu_read_lock();
list_for_each_entry_rcu(user, &intf->users, link) {
module_put(intf->handlers->owner);
if (intf->handlers->dec_usecount)
intf->handlers->dec_usecount(intf->send_info);
}
rcu_read_unlock();
intf->handlers = NULL;
mutex_unlock(&ipmi_interfaces_mutex);
#ifdef CONFIG_IPMI_PROC_INTERFACE
remove_proc_entries(intf);
#endif
ipmi_bmc_unregister(intf);
/* At this point no users can be added to the interface. */
/*
* Call all the watcher interfaces to tell them that
* an interface is gone.
* an interface is going away.
*/
mutex_lock(&smi_watchers_mutex);
list_for_each_entry(w, &smi_watchers, link)
w->smi_gone(intf_num);
mutex_unlock(&smi_watchers_mutex);
index = srcu_read_lock(&intf->users_srcu);
while (!list_empty(&intf->users)) {
struct ipmi_user *user =
container_of(list_next_rcu(&intf->users),
struct ipmi_user, link);
_ipmi_destroy_user(user);
}
srcu_read_unlock(&intf->users_srcu, index);
if (intf->handlers->shutdown)
intf->handlers->shutdown(intf->send_info);
cleanup_smi_msgs(intf);
#ifdef CONFIG_IPMI_PROC_INTERFACE
remove_proc_entries(intf);
#endif
ipmi_bmc_unregister(intf);
cleanup_srcu_struct(&intf->users_srcu);
kref_put(&intf->refcount, intf_free);
return 0;
}
EXPORT_SYMBOL(ipmi_unregister_smi);
......@@ -4141,8 +4228,7 @@ static int handle_read_event_rsp(struct ipmi_smi *intf,
struct ipmi_recv_msg *recv_msg, *recv_msg2;
struct list_head msgs;
struct ipmi_user *user;
int rv = 0;
int deliver_count = 0;
int rv = 0, deliver_count = 0, index;
unsigned long flags;
if (msg->rsp_size < 19) {
......@@ -4166,7 +4252,7 @@ static int handle_read_event_rsp(struct ipmi_smi *intf,
* Allocate and fill in one message for every user that is
* getting events.
*/
rcu_read_lock();
index = srcu_read_lock(&intf->users_srcu);
list_for_each_entry_rcu(user, &intf->users, link) {
if (!user->gets_events)
continue;
......@@ -4195,7 +4281,7 @@ static int handle_read_event_rsp(struct ipmi_smi *intf,
kref_get(&user->refcount);
list_add_tail(&recv_msg->link, &msgs);
}
rcu_read_unlock();
srcu_read_unlock(&intf->users_srcu, index);
if (deliver_count) {
/* Now deliver all the messages. */
......@@ -4242,7 +4328,7 @@ static int handle_bmc_rsp(struct ipmi_smi *intf,
struct ipmi_smi_msg *msg)
{
struct ipmi_recv_msg *recv_msg;
struct ipmi_user *user;
struct ipmi_system_interface_addr *smi_addr;
recv_msg = (struct ipmi_recv_msg *) msg->user_data;
if (recv_msg == NULL) {
......@@ -4251,16 +4337,6 @@ static int handle_bmc_rsp(struct ipmi_smi *intf,
return 0;
}
user = recv_msg->user;
/* Make sure the user still exists. */
if (user && !user->valid) {
/* The user for the message went away, so give up. */
ipmi_inc_stat(intf, unhandled_local_responses);
ipmi_free_recv_msg(recv_msg);
} else {
struct ipmi_system_interface_addr *smi_addr;
ipmi_inc_stat(intf, handled_local_responses);
recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
recv_msg->msgid = msg->msgid;
smi_addr = ((struct ipmi_system_interface_addr *)
......@@ -4274,7 +4350,6 @@ static int handle_bmc_rsp(struct ipmi_smi *intf,
recv_msg->msg.data = recv_msg->msg_data;
recv_msg->msg.data_len = msg->rsp_size - 2;
deliver_local_response(intf, recv_msg);
}
return 0;
}
......@@ -4342,10 +4417,6 @@ static int handle_one_recv_msg(struct ipmi_smi *intf,
if (!recv_msg)
goto out;
/* Make sure the user still exists. */
if (!recv_msg->user || !recv_msg->user->valid)
goto out;
recv_msg->recv_type = IPMI_RESPONSE_RESPONSE_TYPE;
recv_msg->msg.data = recv_msg->msg_data;
recv_msg->msg.data_len = 1;
......@@ -4488,14 +4559,15 @@ static void handle_new_recv_msgs(struct ipmi_smi *intf)
*/
if (atomic_add_unless(&intf->watchdog_pretimeouts_to_deliver, -1, 0)) {
struct ipmi_user *user;
int index;
rcu_read_lock();
index = srcu_read_lock(&intf->users_srcu);
list_for_each_entry_rcu(user, &intf->users, link) {
if (user->handler->ipmi_watchdog_pretimeout)
user->handler->ipmi_watchdog_pretimeout(
user->handler_data);
}
rcu_read_unlock();
srcu_read_unlock(&intf->users_srcu, index);
}
}
......@@ -4663,7 +4735,6 @@ static void check_msg_timeout(struct ipmi_smi *intf, struct seq_table *ent,
unsigned int *waiting_msgs)
{
struct ipmi_recv_msg *msg;
const struct ipmi_smi_handlers *handlers;
if (intf->in_shutdown)
return;
......@@ -4721,8 +4792,7 @@ static void check_msg_timeout(struct ipmi_smi *intf, struct seq_table *ent,
* only for messages to the local MC, which don't get
* resent.
*/
handlers = intf->handlers;
if (handlers) {
if (intf->handlers) {
if (is_lan_addr(&ent->recv_msg->addr))
ipmi_inc_stat(intf,
retransmitted_lan_commands);
......@@ -4730,7 +4800,7 @@ static void check_msg_timeout(struct ipmi_smi *intf, struct seq_table *ent,
ipmi_inc_stat(intf,
retransmitted_ipmb_commands);
smi_send(intf, handlers, smi_msg, 0);
smi_send(intf, intf->handlers, smi_msg, 0);
} else
ipmi_free_smi_msg(smi_msg);
......@@ -4822,12 +4892,12 @@ static atomic_t stop_operation;
static void ipmi_timeout(struct timer_list *unused)
{
struct ipmi_smi *intf;
int nt = 0;
int nt = 0, index;
if (atomic_read(&stop_operation))
return;
rcu_read_lock();
index = srcu_read_lock(&ipmi_interfaces_srcu);
list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
int lnt = 0;
......@@ -4850,7 +4920,7 @@ static void ipmi_timeout(struct timer_list *unused)
nt += lnt;
}
rcu_read_unlock();
srcu_read_unlock(&ipmi_interfaces_srcu, index);
if (nt)
mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment