system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-09-21 03:28:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

ipmi: Rework device id and guid handling to catch changing BMCs

Browse source 
A BMC's guid or device id info may change dynamically, this could
result in a different configuration that needs to be done.  Adjust
the BMCs dynamically.

Signed-off-by: Corey Minyard <cminyard@mvista.com>
This commit is contained in:
Corey Minyard 2017-09-01 16:32:40 -05:00
parent c659ff34f6
commit b2cfd8ab4a
1 changed files with 167 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

240
drivers/char/ipmi/ipmi_msghandler.c
View file

@ -265,18 +265,24 @@ struct ipmi_proc_entry {
}; };
#endif #endif
/*
* Note that the product id, manufacturer id, guid, and device id are
* immutable in this structure, so dyn_mutex is not required for
* accessing those. If those change on a BMC, a new BMC is allocated.
*/
struct bmc_device { struct bmc_device {
struct platform_device pdev; struct platform_device pdev;
struct list_head intfs; struct list_head intfs; /* Interfaces on this BMC. */
struct ipmi_device_id id; struct ipmi_device_id id;
struct ipmi_device_id fetch_id; struct ipmi_device_id fetch_id;
int dyn_id_set; int dyn_id_set;
unsigned long dyn_id_expiry; unsigned long dyn_id_expiry;
struct mutex dyn_mutex; /* protects id & dyn* fields */ struct mutex dyn_mutex; /* Protects id, intfs, & dyn* */
u8 guid[16]; u8 guid[16];
u8 fetch_guid[16]; u8 fetch_guid[16];
int dyn_guid_set; int dyn_guid_set;
struct kref usecount; struct kref usecount;
struct work_struct remove_work;
}; };
#define to_bmc_device(x) container_of((x), struct bmc_device, pdev.dev) #define to_bmc_device(x) container_of((x), struct bmc_device, pdev.dev)
@ -423,6 +429,7 @@ struct ipmi_smi {
bool bmc_registered; bool bmc_registered;
struct list_head bmc_link; struct list_head bmc_link;
char *my_dev_name; char *my_dev_name;
bool in_bmc_register; /* Handle recursive situations. Yuck. */
/* /*
* This is the lower-layer's sender routine. Note that you * This is the lower-layer's sender routine. Note that you
@ -509,10 +516,7 @@ struct ipmi_smi {
* it. Note that the message will still be freed by the * it. Note that the message will still be freed by the
* caller. This only works on the system interface. * caller. This only works on the system interface.
* *
* The only user outside of initialization an panic handling is * Protected by bmc_reg_mutex.
* the dynamic device id fetching, so no mutex is currently
* required on this. If more users come along, some sort of
* mutex will be required.
*/ */
void (*null_user_handler)(ipmi_smi_t intf, struct ipmi_recv_msg *msg); void (*null_user_handler)(ipmi_smi_t intf, struct ipmi_recv_msg *msg);
@ -541,6 +545,11 @@ struct ipmi_smi {
#define to_si_intf_from_dev(device) container_of(device, struct ipmi_smi, dev) #define to_si_intf_from_dev(device) container_of(device, struct ipmi_smi, dev)
static void __get_guid(ipmi_smi_t intf); static void __get_guid(ipmi_smi_t intf);
static void __ipmi_bmc_unregister(ipmi_smi_t intf);
static int __ipmi_bmc_register(ipmi_smi_t intf,
struct ipmi_device_id *id,
bool guid_set, u8 *guid, int intf_num);
/** /**
* The driver model view of the IPMI messaging driver. * The driver model view of the IPMI messaging driver.
@ -552,9 +561,7 @@ static struct platform_driver ipmidriver = {
} }
}; };
/* /*
* This mutex protects adding/removing BMCs on the ipmidriver's device * This mutex keeps us from adding the same BMC twice.
* list. This way we can pull items out of the driver's list and reuse
* them.
*/ */
static DEFINE_MUTEX(ipmidriver_mutex); static DEFINE_MUTEX(ipmidriver_mutex);
@ -2197,12 +2204,13 @@ static int __get_device_id(ipmi_smi_t intf, struct bmc_device *bmc)
* Except for the first time this is called (in ipmi_register_smi()), * Except for the first time this is called (in ipmi_register_smi()),
* this will always return good data; * this will always return good data;
*/ */
static int bmc_get_device_id(ipmi_smi_t intf, struct bmc_device *bmc, static int __bmc_get_device_id(ipmi_smi_t intf, struct bmc_device *bmc,
struct ipmi_device_id *id, struct ipmi_device_id *id,
bool *guid_set, u8 *guid) bool *guid_set, u8 *guid, int intf_num)
{ {
int rv = 0; int rv = 0;
int prev_dyn_id_set, prev_guid_set; int prev_dyn_id_set, prev_guid_set;
bool intf_set = intf != NULL;
if (!intf) { if (!intf) {
mutex_lock(&bmc->dyn_mutex); mutex_lock(&bmc->dyn_mutex);
@ -2231,27 +2239,60 @@ static int bmc_get_device_id(ipmi_smi_t intf, struct bmc_device *bmc,
} }
/* If we have a valid and current ID, just return that. */ /* If we have a valid and current ID, just return that. */
if (bmc->dyn_id_set && time_is_after_jiffies(bmc->dyn_id_expiry)) if (intf->in_bmc_register ||
goto out; (bmc->dyn_id_set && time_is_after_jiffies(bmc->dyn_id_expiry)))
goto out_noprocessing;
prev_guid_set = bmc->dyn_guid_set; prev_guid_set = bmc->dyn_guid_set;
__get_guid(intf); __get_guid(intf);
if (bmc->dyn_guid_set)
memcpy(bmc->guid, bmc->fetch_guid, 16);
else if (prev_guid_set)
/*
* The guid used to be valid and it failed to fetch,
* just use the cached value.
*/
bmc->dyn_guid_set = prev_guid_set;
prev_dyn_id_set = bmc->dyn_id_set; prev_dyn_id_set = bmc->dyn_id_set;
rv = __get_device_id(intf, bmc); rv = __get_device_id(intf, bmc);
if (rv) if (rv)
goto out; goto out;
memcpy(&bmc->id, &bmc->fetch_id, sizeof(bmc->id)); /*
* The guid, device id, manufacturer id, and product id should
* not change on a BMC. If it does we have to do some dancing.
*/
if (!intf->bmc_registered
|| (!prev_guid_set && bmc->dyn_guid_set)
|| (!prev_dyn_id_set && bmc->dyn_id_set)
|| (prev_guid_set && bmc->dyn_guid_set
&& memcmp(bmc->guid, bmc->fetch_guid, 16))
|| bmc->id.device_id != bmc->fetch_id.device_id
|| bmc->id.manufacturer_id != bmc->fetch_id.manufacturer_id
|| bmc->id.product_id != bmc->fetch_id.product_id) {
struct ipmi_device_id id = bmc->fetch_id;
int guid_set = bmc->dyn_guid_set;
u8 guid[16];
memcpy(guid, bmc->fetch_guid, 16);
mutex_unlock(&bmc->dyn_mutex);
__ipmi_bmc_unregister(intf);
/* Fill in the temporary BMC for good measure. */
intf->bmc->id = id;
intf->bmc->dyn_guid_set = guid_set;
memcpy(intf->bmc->guid, guid, 16);
rv = __ipmi_bmc_register(intf, &id, guid_set, guid, intf_num);
if (!intf_set) {
/*
* We weren't given the interface on the
* command line, so restart the operation on
* the next interface for the BMC.
*/
mutex_unlock(&intf->bmc_reg_mutex);
mutex_lock(&bmc->dyn_mutex);
goto retry_bmc_lock;
}
/* We have a new BMC, set it up. */
bmc = intf->bmc;
mutex_lock(&bmc->dyn_mutex);
goto out_noprocessing;
}
bmc->dyn_id_expiry = jiffies + IPMI_DYN_DEV_ID_EXPIRY; bmc->dyn_id_expiry = jiffies + IPMI_DYN_DEV_ID_EXPIRY;
@ -2260,15 +2301,28 @@ static int bmc_get_device_id(ipmi_smi_t intf, struct bmc_device *bmc,
rv = 0; /* Ignore failures if we have previous data. */ rv = 0; /* Ignore failures if we have previous data. */
bmc->dyn_id_set = prev_dyn_id_set; bmc->dyn_id_set = prev_dyn_id_set;
} }
if (!rv) {
bmc->id = bmc->fetch_id;
if (bmc->dyn_guid_set)
memcpy(bmc->guid, bmc->fetch_guid, 16);
else if (prev_guid_set)
/*
* The guid used to be valid and it failed to fetch,
* just use the cached value.
*/
bmc->dyn_guid_set = prev_guid_set;
}
out_noprocessing:
if (!rv) {
if (id)
*id = bmc->id;
if (id) if (guid_set)
*id = bmc->id; *guid_set = bmc->dyn_guid_set;
if (guid_set) if (guid && bmc->dyn_guid_set)
*guid_set = bmc->dyn_guid_set; memcpy(guid, bmc->guid, 16);
}
if (guid && bmc->dyn_guid_set)
memcpy(guid, bmc->guid, 16);
mutex_unlock(&bmc->dyn_mutex); mutex_unlock(&bmc->dyn_mutex);
mutex_unlock(&intf->bmc_reg_mutex); mutex_unlock(&intf->bmc_reg_mutex);
@ -2277,6 +2331,13 @@ static int bmc_get_device_id(ipmi_smi_t intf, struct bmc_device *bmc,
return rv; return rv;
} }
static int bmc_get_device_id(ipmi_smi_t intf, struct bmc_device *bmc,
struct ipmi_device_id *id,
bool *guid_set, u8 *guid)
{
return __bmc_get_device_id(intf, bmc, id, guid_set, guid, -1);
}
#ifdef CONFIG_PROC_FS #ifdef CONFIG_PROC_FS
static int smi_ipmb_proc_show(struct seq_file *m, void *v) static int smi_ipmb_proc_show(struct seq_file *m, void *v)
{ {
@ -2721,26 +2782,22 @@ static const struct device_type bmc_device_type = {
static int __find_bmc_guid(struct device *dev, void *data) static int __find_bmc_guid(struct device *dev, void *data)
{ {
unsigned char *id = data; unsigned char *guid = data;
struct bmc_device *bmc; struct bmc_device *bmc;
bool guid_set;
u8 guid[16];
int rv; int rv;
if (dev->type != &bmc_device_type) if (dev->type != &bmc_device_type)
return 0; return 0;
bmc = to_bmc_device(dev); bmc = to_bmc_device(dev);
rv = bmc_get_device_id(NULL, bmc, NULL, &guid_set, guid); rv = bmc->dyn_guid_set && memcmp(bmc->guid, guid, 16) == 0;
if (rv || !guid_set) if (rv)
return 0; rv = kref_get_unless_zero(&bmc->usecount);
return rv;
return memcmp(guid, id, 16) == 0;
} }
/* /*
* Must be called with ipmidriver_mutex held. Returns with the * Returns with the bmc's usecount incremented, if it is non-NULL.
* bmc's usecount incremented, if it is non-NULL.
*/ */
static struct bmc_device *ipmi_find_bmc_guid(struct device_driver *drv, static struct bmc_device *ipmi_find_bmc_guid(struct device_driver *drv,
unsigned char *guid) unsigned char *guid)
@ -2751,7 +2808,6 @@ static struct bmc_device *ipmi_find_bmc_guid(struct device_driver *drv,
dev = driver_find_device(drv, NULL, guid, __find_bmc_guid); dev = driver_find_device(drv, NULL, guid, __find_bmc_guid);
if (dev) { if (dev) {
bmc = to_bmc_device(dev); bmc = to_bmc_device(dev);
kref_get(&bmc->usecount);
put_device(dev); put_device(dev);
} }
return bmc; return bmc;
@ -2766,24 +2822,21 @@ static int __find_bmc_prod_dev_id(struct device *dev, void *data)
{ {
struct prod_dev_id *cid = data; struct prod_dev_id *cid = data;
struct bmc_device *bmc; struct bmc_device *bmc;
struct ipmi_device_id id;
int rv; int rv;
if (dev->type != &bmc_device_type) if (dev->type != &bmc_device_type)
return 0; return 0;
bmc = to_bmc_device(dev); bmc = to_bmc_device(dev);
rv = bmc_get_device_id(NULL, bmc, &id, NULL, NULL); rv = (bmc->id.product_id == cid->product_id
&& bmc->id.device_id == cid->device_id);
if (rv) if (rv)
return 0; rv = kref_get_unless_zero(&bmc->usecount);
return rv;
return (id.product_id == cid->product_id
&& id.device_id == cid->device_id);
} }
/* /*
* Must be called with ipmidriver_mutex held. Returns with the * Returns with the bmc's usecount incremented, if it is non-NULL.
* bmc's usecount incremented, if it is non-NULL.
*/ */
static struct bmc_device *ipmi_find_bmc_prod_dev_id( static struct bmc_device *ipmi_find_bmc_prod_dev_id(
struct device_driver *drv, struct device_driver *drv,
@ -2799,7 +2852,6 @@ static struct bmc_device *ipmi_find_bmc_prod_dev_id(
dev = driver_find_device(drv, NULL, &id, __find_bmc_prod_dev_id); dev = driver_find_device(drv, NULL, &id, __find_bmc_prod_dev_id);
if (dev) { if (dev) {
bmc = to_bmc_device(dev); bmc = to_bmc_device(dev);
kref_get(&bmc->usecount);
put_device(dev); put_device(dev);
} }
return bmc; return bmc;
@ -2813,25 +2865,39 @@ release_bmc_device(struct device *dev)
kfree(to_bmc_device(dev)); kfree(to_bmc_device(dev));
} }
static void static void cleanup_bmc_work(struct work_struct *work)
cleanup_bmc_device(struct kref *ref)
{ {
struct bmc_device *bmc = container_of(ref, struct bmc_device, usecount); struct bmc_device *bmc = container_of(work, struct bmc_device,
remove_work);
int id = bmc->pdev.id; /* Unregister overwrites id */ int id = bmc->pdev.id; /* Unregister overwrites id */
platform_device_unregister(&bmc->pdev); platform_device_unregister(&bmc->pdev);
ida_simple_remove(&ipmi_bmc_ida, id); ida_simple_remove(&ipmi_bmc_ida, id);
} }
static void ipmi_bmc_unregister(ipmi_smi_t intf) static void
cleanup_bmc_device(struct kref *ref)
{
struct bmc_device *bmc = container_of(ref, struct bmc_device, usecount);
/*
* Remove the platform device in a work queue to avoid issues
* with removing the device attributes while reading a device
* attribute.
*/
schedule_work(&bmc->remove_work);
}
/*
* Must be called with intf->bmc_reg_mutex held.
*/
static void __ipmi_bmc_unregister(ipmi_smi_t intf)
{ {
struct bmc_device *bmc = intf->bmc; struct bmc_device *bmc = intf->bmc;
if (!intf->bmc_registered) if (!intf->bmc_registered)
return; return;
mutex_lock(&intf->bmc_reg_mutex);
sysfs_remove_link(&intf->si_dev->kobj, "bmc"); sysfs_remove_link(&intf->si_dev->kobj, "bmc");
sysfs_remove_link(&bmc->pdev.dev.kobj, intf->my_dev_name); sysfs_remove_link(&bmc->pdev.dev.kobj, intf->my_dev_name);
kfree(intf->my_dev_name); kfree(intf->my_dev_name);
@ -2841,32 +2907,48 @@ static void ipmi_bmc_unregister(ipmi_smi_t intf)
list_del(&intf->bmc_link); list_del(&intf->bmc_link);
mutex_unlock(&bmc->dyn_mutex); mutex_unlock(&bmc->dyn_mutex);
intf->bmc = &intf->tmp_bmc; intf->bmc = &intf->tmp_bmc;
mutex_lock(&ipmidriver_mutex);
kref_put(&bmc->usecount, cleanup_bmc_device); kref_put(&bmc->usecount, cleanup_bmc_device);
mutex_unlock(&ipmidriver_mutex);
intf->bmc_registered = false; intf->bmc_registered = false;
}
static void ipmi_bmc_unregister(ipmi_smi_t intf)
{
mutex_lock(&intf->bmc_reg_mutex);
__ipmi_bmc_unregister(intf);
mutex_unlock(&intf->bmc_reg_mutex); mutex_unlock(&intf->bmc_reg_mutex);
} }
static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum) /*
* Must be called with intf->bmc_reg_mutex held.
*/
static int __ipmi_bmc_register(ipmi_smi_t intf,
struct ipmi_device_id *id,
bool guid_set, u8 *guid, int intf_num)
{ {
int rv; int rv;
struct bmc_device *bmc = intf->bmc; struct bmc_device *bmc = intf->bmc;
struct bmc_device *old_bmc; struct bmc_device *old_bmc;
/*
* platform_device_register() can cause bmc_reg_mutex to
* be claimed because of the is_visible functions of
* the attributes. Eliminate possible recursion and
* release the lock.
*/
intf->in_bmc_register = true;
mutex_unlock(&intf->bmc_reg_mutex);
/* /*
* Try to find if there is an bmc_device struct * Try to find if there is an bmc_device struct
* representing the interfaced BMC already * representing the interfaced BMC already
*/ */
mutex_lock(&ipmidriver_mutex); mutex_lock(&ipmidriver_mutex);
if (bmc->dyn_guid_set) if (guid_set)
old_bmc = ipmi_find_bmc_guid(&ipmidriver.driver, bmc->guid); old_bmc = ipmi_find_bmc_guid(&ipmidriver.driver, guid);
else else
old_bmc = ipmi_find_bmc_prod_dev_id(&ipmidriver.driver, old_bmc = ipmi_find_bmc_prod_dev_id(&ipmidriver.driver,
bmc->id.product_id, id->product_id,
bmc->id.device_id); id->device_id);
mutex_unlock(&ipmidriver_mutex);
/* /*
* If there is already an bmc_device, free the new one, * If there is already an bmc_device, free the new one,
@ -2874,6 +2956,10 @@ static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum)
*/ */
if (old_bmc) { if (old_bmc) {
bmc = old_bmc; bmc = old_bmc;
/*
* Note: old_bmc already has usecount incremented by
* the BMC find functions.
*/
intf->bmc = old_bmc; intf->bmc = old_bmc;
mutex_lock(&bmc->dyn_mutex); mutex_lock(&bmc->dyn_mutex);
list_add_tail(&intf->bmc_link, &bmc->intfs); list_add_tail(&intf->bmc_link, &bmc->intfs);
@ -2893,6 +2979,13 @@ static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum)
} }
INIT_LIST_HEAD(&bmc->intfs); INIT_LIST_HEAD(&bmc->intfs);
mutex_init(&bmc->dyn_mutex); mutex_init(&bmc->dyn_mutex);
INIT_WORK(&bmc->remove_work, cleanup_bmc_work);
bmc->id = *id;
bmc->dyn_id_set = 1;
bmc->dyn_guid_set = guid_set;
memcpy(bmc->guid, guid, 16);
bmc->dyn_id_expiry = jiffies + IPMI_DYN_DEV_ID_EXPIRY;
bmc->pdev.name = "ipmi_bmc"; bmc->pdev.name = "ipmi_bmc";
@ -2938,7 +3031,9 @@ static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum)
goto out_put_bmc; goto out_put_bmc;
} }
intf->my_dev_name = kasprintf(GFP_KERNEL, "ipmi%d", ifnum); if (intf_num == -1)
intf_num = intf->intf_num;
intf->my_dev_name = kasprintf(GFP_KERNEL, "ipmi%d", intf_num);
if (!intf->my_dev_name) { if (!intf->my_dev_name) {
rv = -ENOMEM; rv = -ENOMEM;
printk(KERN_ERR printk(KERN_ERR
@ -2962,6 +3057,9 @@ static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum)
intf->bmc_registered = true; intf->bmc_registered = true;
out: out:
mutex_unlock(&ipmidriver_mutex);
mutex_lock(&intf->bmc_reg_mutex);
intf->in_bmc_register = false;
return rv; return rv;
@ -2977,9 +3075,7 @@ static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum)
list_del(&intf->bmc_link); list_del(&intf->bmc_link);
mutex_unlock(&bmc->dyn_mutex); mutex_unlock(&bmc->dyn_mutex);
intf->bmc = &intf->tmp_bmc; intf->bmc = &intf->tmp_bmc;
mutex_lock(&ipmidriver_mutex);
kref_put(&bmc->usecount, cleanup_bmc_device); kref_put(&bmc->usecount, cleanup_bmc_device);
mutex_unlock(&ipmidriver_mutex);
goto out; goto out;
out_list_del: out_list_del:
@ -3283,16 +3379,12 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
if (rv) if (rv)
goto out; goto out;
rv = bmc_get_device_id(intf, NULL, &id, NULL, NULL); rv = __bmc_get_device_id(intf, NULL, &id, NULL, NULL, i);
if (rv) { if (rv) {
dev_err(si_dev, "Unable to get the device id: %d\n", rv); dev_err(si_dev, "Unable to get the device id: %d\n", rv);
goto out; goto out;
} }
rv = ipmi_bmc_register(intf, i);
if (rv)
goto out;
if (ipmi_version_major(&id) > 1 if (ipmi_version_major(&id) > 1
|| (ipmi_version_major(&id) == 1 || (ipmi_version_major(&id) == 1
&& ipmi_version_minor(&id) >= 5)) { && ipmi_version_minor(&id) >= 5)) {
@ -3300,6 +3392,7 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
* Start scanning the channels to see what is * Start scanning the channels to see what is
* available. * available.
*/ */
mutex_lock(&intf->bmc_reg_mutex);
intf->null_user_handler = channel_handler; intf->null_user_handler = channel_handler;
intf->curr_channel = 0; intf->curr_channel = 0;
rv = send_channel_info_cmd(intf, 0); rv = send_channel_info_cmd(intf, 0);
@ -3314,6 +3407,7 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
wait_event(intf->waitq, wait_event(intf->waitq,
intf->curr_channel >= IPMI_MAX_CHANNELS); intf->curr_channel >= IPMI_MAX_CHANNELS);
intf->null_user_handler = NULL; intf->null_user_handler = NULL;
mutex_unlock(&intf->bmc_reg_mutex);
} else { } else {
/* Assume a single IPMB channel at zero. */ /* Assume a single IPMB channel at zero. */
intf->channels[0].medium = IPMI_CHANNEL_MEDIUM_IPMB; intf->channels[0].medium = IPMI_CHANNEL_MEDIUM_IPMB;