Skip to contentSkip to conversation

Add full sysfs support to the IPMI driver

PATCH In review Corey Minyard 4 participants 5 messages Mar 21, 2006 – Mar 22, 2006 IPMI

lore
Share & tools
lore
#0 lore raw

PATCH 2/2 Add full sysfs support to the IPMI driver

This patch adds full driver model support for the IPMI driver. It links in the proper bus and device support.

It adds an "ipmi" driver interface that has each BMC discovered by the driver (as a device). These BMCs appear in the devices/platform directory. If there are multiple interfaces to the same BMC, the driver should discover this and will only have one BMC entry. The BMC entry will have pointers to each interface device that connects to it.

The device information (statistics and config information) has not yet been ported over to the driver model from proc, that will come later.

This work was based on work by Yani Ioannou. I basically rewrote it using that code as a guide, but he still deserves credit :).

Signed-off-by Corey Minyard
 drivers/char/ipmi/ipmi_devintf.c    |   46 ++-
 drivers/char/ipmi/ipmi_msghandler.c |  547 +++++++++++++++++++++++++++++++++++-
 drivers/char/ipmi/ipmi_poweroff.c   |    2 
 drivers/char/ipmi/ipmi_si_intf.c    |  108 ++++---
 drivers/char/ipmi/ipmi_watchdog.c   |    2 
 include/linux/ipmi.h                |    3 
 include/linux/ipmi_msgdefs.h        |    1 
 include/linux/ipmi_smi.h            |   47 ++-
 8 files changed, 701 insertions(+), 55 deletions(-)
drivers/char/ipmi/ipmi_msghandler.c +533 -14
Index: linux-2.6.16/drivers/char/ipmi/ipmi_msghandler.c
===================================================================
@@ -162,6 +162,28 @@ struct ipmi_proc_entry
 };
 #endif
 
+struct bmc_device
+{
+	struct platform_device dev;
+	struct ipmi_device_id  id;
+	unsigned char          guid[16];
+	int                    guid_set;
+	int                    interfaces;
+
+	/* bmc device attributes */
+	struct device_attribute device_id_attr;
+	struct device_attribute provides_dev_sdrs_attr;
+	struct device_attribute revision_attr;
+	struct device_attribute firmware_rev_attr;
+	struct device_attribute version_attr;
+	struct device_attribute add_dev_support_attr;
+	struct device_attribute manufacturer_id_attr;
+	struct device_attribute product_id_attr;
+	struct device_attribute guid_attr;
+	struct device_attribute aux_firmware_rev_attr;
+};
+#define to_bmc_device(device) container_of(device, struct bmc_device, dev)
+
 #define IPMI_IPMB_NUM_SEQ	64
 #define IPMI_MAX_CHANNELS       16
 struct ipmi_smi
@@ -178,9 +200,8 @@ struct ipmi_smi
 	/* Used for wake ups at startup. */
 	wait_queue_head_t waitq;
 
-	/* The IPMI version of the BMC on the other end. */
-	unsigned char       version_major;
-	unsigned char       version_minor;
+	struct bmc_device *bmc;
+	char *my_dev_name;
 
 	/* This is the lower-layer's sender routine. */
 	struct ipmi_smi_handlers *handlers;
@@ -194,6 +215,9 @@ struct ipmi_smi
 	struct ipmi_proc_entry *proc_entries;
 #endif
 
+	/* Driver-model device for the system interface. */
+	struct device          *si_dev;
+
 	/* A table of sequence numbers for this interface.  We use the
            sequence numbers for IPMB messages that go out of the
            interface to match them up with their responses.  A routine
@@ -312,6 +336,7 @@ struct ipmi_smi
 	/* Events that were received with the proper format. */
 	unsigned int events;
 };
+#define to_si_intf_from_dev(device) container_of(device, struct ipmi_smi, dev)
 
 /* Used to mark an interface entry that cannot be used but is not a
  * free entry, either, primarily used at creation and deletion time so
@@ -320,6 +345,14 @@ struct ipmi_smi
 #define IPMI_INVALID_INTERFACE(i) (((i) == NULL) \
 				   || (i == IPMI_INVALID_INTERFACE_ENTRY))
 
+/**
+ * The driver model view of the IPMI messaging driver.
+ */
+static struct device_driver ipmidriver = {
+	.name = "ipmi",
+	.bus = &platform_bus_type
+};
+
 #define MAX_IPMI_INTERFACES 4
 static ipmi_smi_t ipmi_interfaces[MAX_IPMI_INTERFACES];
 
@@ -393,7 +426,7 @@ int ipmi_smi_watcher_register(struct ipm
 		if (IPMI_INVALID_INTERFACE(intf))
 			continue;
 		spin_unlock_irqrestore(&interfaces_lock, flags);
-		watcher->new_smi(i);
+		watcher->new_smi(i, intf->si_dev);
 		spin_lock_irqsave(&interfaces_lock, flags);
 	}
 	spin_unlock_irqrestore(&interfaces_lock, flags);
@@ -409,14 +442,14 @@ int ipmi_smi_watcher_unregister(struct i
 }
 
 static void
-call_smi_watchers(int i)
+call_smi_watchers(int i, struct device *dev)
 {
 	struct ipmi_smi_watcher *w;
 
 	down_read(&smi_watchers_sem);
 	list_for_each_entry(w, &smi_watchers, link) {
 		if (try_module_get(w->owner)) {
-			w->new_smi(i);
+			w->new_smi(i, dev);
 			module_put(w->owner);
 		}
 	}
@@ -842,8 +875,8 @@ void ipmi_get_version(ipmi_user_t   user
 		      unsigned char *major,
 		      unsigned char *minor)
 {
-	*major = user->intf->version_major;
-	*minor = user->intf->version_minor;
+	*major = ipmi_version_major(&user->intf->bmc->id);
+	*minor = ipmi_version_minor(&user->intf->bmc->id);
 }
 
 int ipmi_set_my_address(ipmi_user_t   user,
@@ -1551,7 +1584,8 @@ static int version_file_read_proc(char *
 	ipmi_smi_t intf = data;
 
 	return sprintf(out, "%d.%d\n",
-		       intf->version_major, intf->version_minor);
+		       ipmi_version_major(&intf->bmc->id),
+		       ipmi_version_minor(&intf->bmc->id));
 }
 
 static int stat_file_read_proc(char *page, char **start, off_t off,
@@ -1710,6 +1744,465 @@ static void remove_proc_entries(ipmi_smi
 #endif /* CONFIG_PROC_FS */
 }
 
+static int __find_bmc_guid(struct device *dev, void *data)
+{
+	unsigned char *id = (unsigned char *) data;
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return memcmp(bmc->guid, id, 16) == 0;
+}
+
+struct bmc_device * ipmi_find_bmc_guid(struct device_driver *drv,
+				       unsigned char *guid)
+{
+	struct device *dev;
+
+	dev = driver_find_device(drv, NULL, guid, __find_bmc_guid);
+	if (dev)
+		return to_bmc_device(to_platform_device(dev));
+	else
+		return NULL;
+}
+
+struct prod_dev_id {
+	unsigned int  product_id;
+	unsigned char device_id;
+};
+
+static int __find_bmc_prod_dev_id(struct device *dev, void *data)
+{
+	struct prod_dev_id *id = (struct prod_dev_id *) data;
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return (bmc->id.product_id == id->product_id
+		&& bmc->id.product_id == id->product_id
+		&& bmc->id.device_id == id->device_id);
+}
+
+static struct bmc_device *ipmi_find_bmc_prod_dev_id(
+	struct device_driver *drv,
+	unsigned char product_id, unsigned char device_id)
+{
+	struct prod_dev_id id = {
+		.product_id = product_id,
+		.device_id = device_id,
+	};
+	struct device *dev;
+
+	dev = driver_find_device(drv, NULL, &id, __find_bmc_prod_dev_id);
+	if (dev)
+		return to_bmc_device(to_platform_device(dev));
+	else
+		return NULL;
+}
+
+static void ipmi_bmc_release(struct device *dev)
+{
+	printk(KERN_DEBUG "ipmi_bmc release\n");
+}
+
+static ssize_t device_id_show(struct device *dev,
+			      struct device_attribute *attr,
+			      char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 10, "%u\n", bmc->id.device_id);
+}
+
+static ssize_t provides_dev_sdrs_show(struct device *dev,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 10, "%u\n",
+			bmc->id.device_revision && 0x80 >> 7);
+}
+
+static ssize_t revision_show(struct device *dev, struct device_attribute *attr,
+			     char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 20, "%u\n",
+			bmc->id.device_revision && 0x0F);
+}
+
+static ssize_t firmware_rev_show(struct device *dev,
+				 struct device_attribute *attr,
+				 char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 20, "%u.%x\n", bmc->id.firmware_revision_1,
+			bmc->id.firmware_revision_2);
+}
+
+static ssize_t ipmi_version_show(struct device *dev,
+				 struct device_attribute *attr,
+				 char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 20, "%u.%u\n",
+			ipmi_version_major(&bmc->id),
+			ipmi_version_minor(&bmc->id));
+}
+
+static ssize_t add_dev_support_show(struct device *dev,
+				    struct device_attribute *attr,
+				    char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 10, "0x%02x\n",
+			bmc->id.additional_device_support);
+}
+
+static ssize_t manufacturer_id_show(struct device *dev,
+				    struct device_attribute *attr,
+				    char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 20, "0x%6.6x\n", bmc->id.manufacturer_id);
+}
+
+static ssize_t product_id_show(struct device *dev,
+			       struct device_attribute *attr,
+			       char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 10, "0x%4.4x\n", bmc->id.product_id);
+}
+
+static ssize_t aux_firmware_rev_show(struct device *dev,
+				     struct device_attribute *attr,
+				     char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 21, "0x%02x 0x%02x 0x%02x 0x%02x\n",
+			bmc->id.aux_firmware_revision[3],
+			bmc->id.aux_firmware_revision[2],
+			bmc->id.aux_firmware_revision[1],
+			bmc->id.aux_firmware_revision[0]);
+}
+
+static ssize_t guid_show(struct device *dev, struct device_attribute *attr,
+			 char *buf)
+{
+	struct bmc_device *bmc;
+
+	bmc = to_bmc_device(to_platform_device(dev));
+	return snprintf(buf, 100, "%Lx%Lx\n",
+			(long long) bmc->guid[0],
+			(long long) bmc->guid[8]);
+}
+
+static void ipmi_bmc_unregister(ipmi_smi_t intf)
+{
+	struct bmc_device *bmc = intf->bmc;
+
+	sysfs_remove_link(&intf->si_dev->kobj, "bmc");
+	if (intf->my_dev_name) {
+		sysfs_remove_link(&bmc->dev.dev.kobj, intf->my_dev_name);
+		kfree(intf->my_dev_name);
+		intf->my_dev_name = NULL;
+	}
+
+	bmc->interfaces--;
+	if (bmc->interfaces == 0) {
+		device_remove_file(&bmc->dev.dev,
+				&bmc->device_id_attr);
+		device_remove_file(&bmc->dev.dev,
+				&bmc->provides_dev_sdrs_attr);
+		device_remove_file(&bmc->dev.dev,
+				&bmc->revision_attr);
+		device_remove_file(&bmc->dev.dev,
+				&bmc->firmware_rev_attr);
+		device_remove_file(&bmc->dev.dev,
+				&bmc->version_attr);
+		device_remove_file(&bmc->dev.dev,
+				&bmc->add_dev_support_attr);
+		device_remove_file(&bmc->dev.dev,
+				&bmc->manufacturer_id_attr);
+		device_remove_file(&bmc->dev.dev,
+				&bmc->product_id_attr);
+		device_remove_file(&bmc->dev.dev,
+				&bmc->aux_firmware_rev_attr);
+		if (bmc->guid_set)
+			device_remove_file(&bmc->dev.dev,
+					   &bmc->guid_attr);
+		platform_device_unregister(&bmc->dev);
+	}
+}
+
+static int ipmi_bmc_register(ipmi_smi_t intf)
+{
+	int               rv;
+	struct bmc_device *bmc = intf->bmc;
+	struct bmc_device *old_bmc;
+	int               size;
+	char              dummy[1];
+
+	/*
+	 * Try to find if there is an bmc_device struct
+	 * representing the interfaced BMC already
+	 */
+	if (bmc->guid_set)
+		old_bmc = ipmi_find_bmc_guid(&ipmidriver, bmc->guid);
+	else
+		old_bmc = ipmi_find_bmc_prod_dev_id(&ipmidriver,
+						    bmc->id.product_id,
+						    bmc->id.device_id);
+
+	/*
+	 * If there is already an bmc_device, free the new one,
+	 * otherwise register the new BMC device
+	 */
+	if (old_bmc) {
+		kfree(bmc);
+		intf->bmc = old_bmc;
+		bmc = old_bmc;
+
+		bmc->interfaces++;
+
+		printk(KERN_INFO
+		       "ipmi: interfacing existing BMC (man_id: 0x%6.6x,"
+		       " prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
+		       bmc->id.manufacturer_id,
+		       bmc->id.product_id,
+		       bmc->id.device_id);
+	} else {
+		bmc->dev.name = "ipmi_bmc";
+		bmc->dev.id = bmc->id.device_id;
+		bmc->dev.dev.driver = &ipmidriver;
+		bmc->dev.dev.release = ipmi_bmc_release;
+		bmc->interfaces = 1;
+
+		rv = platform_device_register(&bmc->dev);
+		if (rv) {
+			printk(KERN_ERR
+			       "ipmi_msghandler:"
+			       " Unable to register bmc device: %d\n",
+			       rv);
+			return rv;
+		}
+
+		bmc->device_id_attr.attr.name = "device_id";
+		bmc->device_id_attr.attr.owner = THIS_MODULE;
+		bmc->device_id_attr.attr.mode = S_IRUGO;
+		bmc->device_id_attr.show = device_id_show;
+
+		bmc->provides_dev_sdrs_attr.attr.name = "provides_device_sdrs";
+		bmc->provides_dev_sdrs_attr.attr.owner = THIS_MODULE;
+		bmc->provides_dev_sdrs_attr.attr.mode = S_IRUGO;
+		bmc->provides_dev_sdrs_attr.show = provides_dev_sdrs_show;
+
+
+		bmc->revision_attr.attr.name = "revision";
+		bmc->revision_attr.attr.owner = THIS_MODULE;
+		bmc->revision_attr.attr.mode = S_IRUGO;
+		bmc->revision_attr.show = revision_show;
+
+		bmc->firmware_rev_attr.attr.name = "firmware_revision";
+		bmc->firmware_rev_attr.attr.owner = THIS_MODULE;
+		bmc->firmware_rev_attr.attr.mode = S_IRUGO;
+		bmc->firmware_rev_attr.show = firmware_rev_show;
+
+		bmc->version_attr.attr.name = "ipmi_version";
+		bmc->version_attr.attr.owner = THIS_MODULE;
+		bmc->version_attr.attr.mode = S_IRUGO;
+		bmc->version_attr.show = ipmi_version_show;
+
+		bmc->add_dev_support_attr.attr.name
+			= "additional_device_support";
+		bmc->add_dev_support_attr.attr.owner = THIS_MODULE;
+		bmc->add_dev_support_attr.attr.mode = S_IRUGO;
+		bmc->add_dev_support_attr.show = add_dev_support_show;
+
+		bmc->manufacturer_id_attr.attr.name = "manufacturer_id";
+		bmc->manufacturer_id_attr.attr.owner = THIS_MODULE;
+		bmc->manufacturer_id_attr.attr.mode = S_IRUGO;
+		bmc->manufacturer_id_attr.show = manufacturer_id_show;
+
+		bmc->product_id_attr.attr.name = "product_id";
+		bmc->product_id_attr.attr.owner = THIS_MODULE;
+		bmc->product_id_attr.attr.mode = S_IRUGO;
+		bmc->product_id_attr.show = product_id_show;
+
+		bmc->guid_attr.attr.name = "guid";
+		bmc->guid_attr.attr.owner = THIS_MODULE;
+		bmc->guid_attr.attr.mode = S_IRUGO;
+		bmc->guid_attr.show = guid_show;
+
+		bmc->aux_firmware_rev_attr.attr.name = "aux_firmware_revision";
+		bmc->aux_firmware_rev_attr.attr.owner = THIS_MODULE;
+		bmc->aux_firmware_rev_attr.attr.mode = S_IRUGO;
+		bmc->aux_firmware_rev_attr.show = aux_firmware_rev_show;
+
+		device_create_file(&bmc->dev.dev,
+				   &bmc->device_id_attr);
+		device_create_file(&bmc->dev.dev,
+				   &bmc->provides_dev_sdrs_attr);
+		device_create_file(&bmc->dev.dev,
+				   &bmc->revision_attr);
+		device_create_file(&bmc->dev.dev,
+				   &bmc->firmware_rev_attr);
+		device_create_file(&bmc->dev.dev,
+				   &bmc->version_attr);
+		device_create_file(&bmc->dev.dev,
+				   &bmc->add_dev_support_attr);
+		device_create_file(&bmc->dev.dev,
+				   &bmc->manufacturer_id_attr);
+		device_create_file(&bmc->dev.dev,
+				   &bmc->product_id_attr);
+		if (bmc->id.aux_firmware_revision_set)
+			device_create_file(&bmc->dev.dev,
+					   &bmc->aux_firmware_rev_attr);
+		if (bmc->guid_set)
+			device_create_file(&bmc->dev.dev,
+					   &bmc->guid_attr);
+
+		printk(KERN_INFO
+		       "ipmi: Found new BMC (man_id: 0x%6.6x, "
+		       " prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
+		       bmc->id.manufacturer_id,
+		       bmc->id.product_id,
+		       bmc->id.device_id);
+	}
+
+	/*
+	 * create symlink from system interface device to bmc device
+	 * and back.
+	 */
+	rv = sysfs_create_link(&intf->si_dev->kobj,
+			       &bmc->dev.dev.kobj, "bmc");
+	if (rv) {
+		printk(KERN_ERR
+		       "ipmi_msghandler: Unable to create bmc symlink: %d\n",
+		       rv);
+		goto out_err;
+	}
+
+	size = snprintf(dummy, 0, "ipmi%d", intf->intf_num);
+	intf->my_dev_name = kmalloc(size+1, GFP_KERNEL);
+	if (!intf->my_dev_name) {
+		rv = -ENOMEM;
+		printk(KERN_ERR
+		       "ipmi_msghandler: allocate link from BMC: %d\n",
+		       rv);
+		goto out_err;
+	}
+	snprintf(intf->my_dev_name, size+1, "ipmi%d", intf->intf_num);
+
+	rv = sysfs_create_link(&bmc->dev.dev.kobj, &intf->si_dev->kobj,
+			       intf->my_dev_name);
+	if (rv) {
+		kfree(intf->my_dev_name);
+		intf->my_dev_name = NULL;
+		printk(KERN_ERR
+		       "ipmi_msghandler:"
+		       " Unable to create symlink to bmc: %d\n",
+		       rv);
+		goto out_err;
+	}
+
+	return 0;
+
+out_err:
+	ipmi_bmc_unregister(intf);
+	return rv;
+}
+
+static int
+send_guid_cmd(ipmi_smi_t intf, int chan)
+{
+	struct kernel_ipmi_msg            msg;
+	struct ipmi_system_interface_addr si;
+
+	si.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
+	si.channel = IPMI_BMC_CHANNEL;
+	si.lun = 0;
+
+	msg.netfn = IPMI_NETFN_APP_REQUEST;
+	msg.cmd = IPMI_GET_DEVICE_GUID_CMD;
+	msg.data = NULL;
+	msg.data_len = 0;
+	return i_ipmi_request(NULL,
+			      intf,
+			      (struct ipmi_addr *) &si,
+			      0,
+			      &msg,
+			      intf,
+			      NULL,
+			      NULL,
+			      0,
+			      intf->channels[0].address,
+			      intf->channels[0].lun,
+			      -1, 0);
+}
+
+static void
+guid_handler(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
+{
+	if ((msg->addr.addr_type != IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
+	    || (msg->msg.netfn != IPMI_NETFN_APP_RESPONSE)
+	    || (msg->msg.cmd != IPMI_GET_DEVICE_GUID_CMD))
+		/* Not for me */
+		return;
+
+	if (msg->msg.data[0] != 0) {
+		/* Error from getting the GUID, the BMC doesn't have one. */
+		intf->bmc->guid_set = 0;
+		goto out;
+	}
+
+	if (msg->msg.data_len < 17) {
+		intf->bmc->guid_set = 0;
+		printk(KERN_WARNING PFX
+		       "guid_handler: The GUID response from the BMC was too"
+		       " short, it was %d but should have been 17.  Assuming"
+		       " GUID is not available.\n",
+		       msg->msg.data_len);
+		goto out;
+	}
+
+	memcpy(intf->bmc->guid, msg->msg.data, 16);
+	intf->bmc->guid_set = 1;
+ out:
+	wake_up(&intf->waitq);
+}
+
+static void
+get_guid(ipmi_smi_t intf)
+{
+	int rv;
+
+	intf->bmc->guid_set = 0x2;
+	intf->null_user_handler = guid_handler;
+	rv = send_guid_cmd(intf, 0);
+	if (rv)
+		/* Send failed, no GUID available. */
+		intf->bmc->guid_set = 0;
+	wait_event(intf->waitq, intf->bmc->guid_set != 2);
+	intf->null_user_handler = NULL;
+}
+
 static int
 send_channel_info_cmd(ipmi_smi_t intf, int chan)
 {
@@ -1802,8 +2295,8 @@ channel_handler(ipmi_smi_t intf, struct 
 
 int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
 		      void		       *send_info,
-		      unsigned char            version_major,
-		      unsigned char            version_minor,
+		      struct ipmi_device_id    *device_id,
+		      struct device            *si_dev,
 		      unsigned char            slave_addr,
 		      ipmi_smi_t               *new_intf)
 {
@@ -1811,7 +2304,11 @@ int ipmi_register_smi(struct ipmi_smi_ha
 	int              rv;
 	ipmi_smi_t       intf;
 	unsigned long    flags;
+	int              version_major;
+	int              version_minor;
 
+	version_major = ipmi_version_major(device_id);
+	version_minor = ipmi_version_minor(device_id);
 
 	/* Make sure the driver is actually initialized, this handles
 	   problems with initialization order. */
@@ -1829,10 +2326,16 @@ int ipmi_register_smi(struct ipmi_smi_ha
 	if (!intf)
 		return -ENOMEM;
 	memset(intf, 0, sizeof(*intf));
+	intf->bmc = kmalloc(sizeof(*intf->bmc), GFP_KERNEL);
+	if (!intf->bmc) {
+		kfree(intf);
+		return -ENOMEM;
+	}
+	memset(intf->bmc, 0, sizeof(*intf->bmc));
 	intf->intf_num = -1;
 	kref_init(&intf->refcount);
-	intf->version_major = version_major;
-	intf->version_minor = version_minor;
+	intf->bmc->id = *device_id;
+	intf->si_dev = si_dev;
 	for (j = 0; j < IPMI_MAX_CHANNELS; j++) {
 		intf->channels[j].address = IPMI_BMC_SLAVE_ADDR;
 		intf->channels[j].lun = 2;
@@ -1882,6 +2385,8 @@ int ipmi_register_smi(struct ipmi_smi_ha
 	   caller before sending any messages with it. */
 	*new_intf = intf;
 
+	get_guid(intf);
+
 	if ((version_major > 1)
 	    || ((version_major == 1) && (version_minor >= 5)))
 	{
@@ -1896,6 +2401,7 @@ int ipmi_register_smi(struct ipmi_smi_ha
 		/* Wait for the channel info to be read. */
 		wait_event(intf->waitq,
 			   intf->curr_channel >= IPMI_MAX_CHANNELS);
+		intf->null_user_handler = NULL;
 	} else {
 		/* Assume a single IPMB channel at zero. */
 		intf->channels[0].medium = IPMI_CHANNEL_MEDIUM_IPMB;
@@ -1905,6 +2411,8 @@ int ipmi_register_smi(struct ipmi_smi_ha
 	if (rv == 0)
 		rv = add_proc_entries(intf, i);
 
+	rv = ipmi_bmc_register(intf);
+
  out:
 	if (rv) {
 		if (intf->proc_dir)
@@ -1919,7 +2427,7 @@ int ipmi_register_smi(struct ipmi_smi_ha
 		spin_lock_irqsave(&interfaces_lock, flags);
 		ipmi_interfaces[i] = intf;
 		spin_unlock_irqrestore(&interfaces_lock, flags);
-		call_smi_watchers(i);
+		call_smi_watchers(i, intf->si_dev);
 	}
 
 	return rv;
@@ -1931,6 +2439,8 @@ int ipmi_unregister_smi(ipmi_smi_t intf)
 	struct ipmi_smi_watcher *w;
 	unsigned long           flags;
 
+	ipmi_bmc_unregister(intf);
+
 	spin_lock_irqsave(&interfaces_lock, flags);
 	for (i = 0; i < MAX_IPMI_INTERFACES; i++) {
 		if (ipmi_interfaces[i] == intf) {
@@ -3194,10 +3704,17 @@ static struct notifier_block panic_block
 static int ipmi_init_msghandler(void)
 {
 	int i;
+	int rv;
 
 	if (initialized)
 		return 0;
 
+	rv = driver_register(&ipmidriver);
+	if (rv) {
+		printk(KERN_ERR PFX "Could not register IPMI driver\n");
+		return rv;
+	}
+
 	printk(KERN_INFO "ipmi message handler version "
 	       IPMI_DRIVER_VERSION "\n");
 
@@ -3254,6 +3771,8 @@ static __exit void cleanup_ipmi(void)
 	remove_proc_entry(proc_ipmi_root->name, &proc_root);
 #endif /* CONFIG_PROC_FS */
 
+	driver_unregister(&ipmidriver);
+
 	initialized = 0;
 
 	/* Check for buffer leaks. */
include/linux/ipmi_msgdefs.h +1 -0
Index: linux-2.6.16/include/linux/ipmi_msgdefs.h
===================================================================
@@ -47,6 +47,7 @@
 #define IPMI_NETFN_APP_RESPONSE			0x07
 #define IPMI_GET_DEVICE_ID_CMD		0x01
 #define IPMI_CLEAR_MSG_FLAGS_CMD	0x30
+#define IPMI_GET_DEVICE_GUID_CMD	0x08
 #define IPMI_GET_MSG_FLAGS_CMD		0x31
 #define IPMI_SEND_MSG_CMD		0x34
 #define IPMI_GET_MSG_CMD		0x33
include/linux/ipmi_smi.h +45 -2

63 lines not on this page · raw message

drivers/char/ipmi/ipmi_si_intf.c +75 -33

229 lines not on this page · raw message

include/linux/ipmi.h +2 -1
Index: linux-2.6.16/include/linux/ipmi.h
===================================================================
@@ -36,6 +36,7 @@
 
 #include <linux/ipmi_msgdefs.h>
 #include <linux/compiler.h>
+#include <linux/device.h>
 
 /*
  * This file describes an interface to an IPMI driver.  You have to
@@ -397,7 +398,7 @@ struct ipmi_smi_watcher
 	   the watcher list.  So you can add and remove users from the
 	   IPMI interface, send messages, etc., but you cannot add
 	   or remove SMI watchers or SMI interfaces. */
-	void (*new_smi)(int if_num);
+	void (*new_smi)(int if_num, struct device *dev);
 	void (*smi_gone)(int if_num);
 };
 
drivers/char/ipmi/ipmi_devintf.c +43 -3

70 lines not on this page · raw message

drivers/char/ipmi/ipmi_poweroff.c +1 -1
Index: linux-2.6.16/drivers/char/ipmi/ipmi_poweroff.c
===================================================================
@@ -466,7 +466,7 @@ static void ipmi_poweroff_function (void
 
 /* Wait for an IPMI interface to be installed, the first one installed
    will be grabbed by this code and used to perform the powerdown. */
-static void ipmi_po_new_smi(int if_num)
+static void ipmi_po_new_smi(int if_num, struct device *device)
 {
 	struct ipmi_system_interface_addr smi_addr;
 	struct kernel_ipmi_msg            send_msg;
drivers/char/ipmi/ipmi_watchdog.c +1 -1
Index: linux-2.6.16/drivers/char/ipmi/ipmi_watchdog.c
===================================================================
@@ -992,7 +992,7 @@ static struct notifier_block wdog_panic_
 };
 
 
-static void ipmi_new_smi(int if_num)
+static void ipmi_new_smi(int if_num, struct device *device)
 {
 	ipmi_register_watchdog(if_num);
 }
#1 lore raw

drivers/char/ipmi/ipmi_msghandler.c static void remove_proc_entries(ipmi_smi · line 1804

Quoted 4 lines · Corey Minyard
drivers/char/ipmi/ipmi_msghandler.c +4 -0
+static void ipmi_bmc_release(struct device *dev)
+{
+	printk(KERN_DEBUG "ipmi_bmc release\n");
+}

eehhhh NO.
Please read the many comments and documentations about why a release function is NOT allowed to be empty. In fact the kernel warned you about that, didn't it?

#2 lore raw
Quoted 13 lines · Arjan van de Ven

drivers/char/ipmi/ipmi_msghandler.c static void remove_proc_entries(ipmi_smi · line 1804

Quoted 4 lines · Corey Minyard
drivers/char/ipmi/ipmi_msghandler.c +4 -0
+static void ipmi_bmc_release(struct device *dev)
+{
+	printk(KERN_DEBUG "ipmi_bmc release\n");
+}

eehhhh NO.
Please read the many comments and documentations about why a release function is NOT allowed to be empty. In fact the kernel warned you about that, didn't it?

Of course that's not ok.

Come on people, does everyone think I just put that warning message in the kernel for fun to force you to create an empty release function? Why do people ignore the helpful hints that the kernel provides?

I can take that check out and watch people get their code wrong even more, as it sure doesn't seem like it is helping anyone out these days...

Corey, haven't we discussed this in the past?

greg k-h

#3 lore raw
Quoted 9 lines · Greg KH

Of course that's not ok.

Come on people, does everyone think I just put that warning message in the kernel for fun to force you to create an empty release function? Why do people ignore the helpful hints that the kernel provides?

I can take that check out and watch people get their code wrong even more, as it sure doesn't seem like it is helping anyone out these days...

Put a description on sufficiently stable site and make that

	printk(KERN_ERR "Read The Fucking Manual, wanker: %s\n", URL);
#4 lore raw
In reply to Greg KH
Quoted 27 lines · Greg KH
Quoted 5 lines · Arjan van de Ven

On Tue, 2006-03-21 at 16:13 -0600, Corey Minyard wrote:

Quoted 12 lines

drivers/char/ipmi/ipmi_msghandler.c static void remove_proc_entries(ipmi_smi · line 1804

Quoted 6 lines
drivers/char/ipmi/ipmi_msghandler.c +4 -0
+static void ipmi_bmc_release(struct device *dev)
+{
+	printk(KERN_DEBUG "ipmi_bmc release\n");
+}

eehhhh NO.
Please read the many comments and documentations about why a release function is NOT allowed to be empty. In fact the kernel warned you about that, didn't it?

Of course that's not ok.

Come on people, does everyone think I just put that warning message in the kernel for fun to force you to create an empty release function? Why do people ignore the helpful hints that the kernel provides?

Quoted 7 lines

I can take that check out and watch people get their code wrong even more, as it sure doesn't seem like it is helping anyone out these days...

Corey, haven't we discussed this in the past?

I don't think so, this is my first attempt at anything beyond a simple class device for the driver model. This code was a rework of something that came from someone else, so I never actually saw the kernel message.

I did look in the include files while doing this and a little at the driver-model docs, and I didn't see anything that jumped out and said "THIS IS IMPORTANT". The release field documented in devices.txt, for instance, says:

release: Callback to free the device after all references have
gone away. This should be set by the allocator of the device (i.e. the bus driver that discovered the device).

It's not altogether obvious how to use this function or its importance from this text, though if I had thought about it I would have figured it out. If you want to affect behaviour, you need to add text
like: "NOTE: You must keep the data that holds the device structure around until the release function is called. If you do not, something could be using the device structure after you free it's data, resulting in bad things happening". A comment should probably appear in the include file, too.

If the issue Russell brought up is really an issue, it truely needs some documentation written about it.

That said, I should have looked a little deeper on this. I saw it there, read the docs and include file, and thought, "That's probably just there to aid debugging," and left it in.

-Corey