Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f4e91eb4 authored by Tony Jones's avatar Tony Jones Committed by Greg Kroah-Hartman
Browse files

IB: convert struct class_device to struct device 



This converts the main ib_device to use struct device instead of struct
class_device as class_device is going away.

Signed-off-by: default avatarTony Jones <tonyj@suse.de>
Signed-off-by: default avatarKay Sievers <kay.sievers@vrfy.org>
Cc: Roland Dreier <rolandd@cisco.com>
Cc: Sean Hefty <sean.hefty@intel.com>
Cc: Hal Rosenstock <hal.rosenstock@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent c4c66cf1

drivers/infiniband/core/sysfs.c

+40 −36
Original line number Original line Diff line number Diff line
@@ -427,17 +427,17 @@ static struct kobj_type port_type = { 
	.default_attrs = port_default_attrs

	.default_attrs = port_default_attrs

};

};





static void ib_device_release(struct class_device *cdev)

static void ib_device_release(struct device *device)

{

{

	struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);

	struct ib_device *dev = container_of(device, struct ib_device, dev);





	kfree(dev);

	kfree(dev);

}

}





static int ib_device_uevent(struct class_device *cdev,

static int ib_device_uevent(struct device *device,

			    struct kobj_uevent_env *env)

			    struct kobj_uevent_env *env)

{

{

	struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);

	struct ib_device *dev = container_of(device, struct ib_device, dev);





	if (add_uevent_var(env, "NAME=%s", dev->name))

	if (add_uevent_var(env, "NAME=%s", dev->name))

		return -ENOMEM;

		return -ENOMEM;
@@ -567,9 +567,10 @@ static int add_port(struct ib_device *device, int port_num) 
	return ret;

	return ret;

}

}





static ssize_t show_node_type(struct class_device *cdev, char *buf)

static ssize_t show_node_type(struct device *device,

			      struct device_attribute *attr, char *buf)

{

{

	struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);

	struct ib_device *dev = container_of(device, struct ib_device, dev);





	if (!ibdev_is_alive(dev))

	if (!ibdev_is_alive(dev))

		return -ENODEV;

		return -ENODEV;
@@ -583,9 +584,10 @@ static ssize_t show_node_type(struct class_device *cdev, char *buf) 
	}

	}

}

}





static ssize_t show_sys_image_guid(struct class_device *cdev, char *buf)

static ssize_t show_sys_image_guid(struct device *device,

				   struct device_attribute *dev_attr, char *buf)

{

{

	struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);

	struct ib_device *dev = container_of(device, struct ib_device, dev);

	struct ib_device_attr attr;

	struct ib_device_attr attr;

	ssize_t ret;

	ssize_t ret;
@@ -603,9 +605,10 @@ static ssize_t show_sys_image_guid(struct class_device *cdev, char *buf) 
		       be16_to_cpu(((__be16 *) &attr.sys_image_guid)[3]));

		       be16_to_cpu(((__be16 *) &attr.sys_image_guid)[3]));

}

}





static ssize_t show_node_guid(struct class_device *cdev, char *buf)

static ssize_t show_node_guid(struct device *device,

			      struct device_attribute *attr, char *buf)

{

{

	struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);

	struct ib_device *dev = container_of(device, struct ib_device, dev);





	if (!ibdev_is_alive(dev))

	if (!ibdev_is_alive(dev))

		return -ENODEV;

		return -ENODEV;
@@ -617,17 +620,19 @@ static ssize_t show_node_guid(struct class_device *cdev, char *buf) 
		       be16_to_cpu(((__be16 *) &dev->node_guid)[3]));

		       be16_to_cpu(((__be16 *) &dev->node_guid)[3]));

}

}





static ssize_t show_node_desc(struct class_device *cdev, char *buf)

static ssize_t show_node_desc(struct device *device,

			      struct device_attribute *attr, char *buf)

{

{

	struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);

	struct ib_device *dev = container_of(device, struct ib_device, dev);





	return sprintf(buf, "%.64s\n", dev->node_desc);

	return sprintf(buf, "%.64s\n", dev->node_desc);

}

}





static ssize_t set_node_desc(struct class_device *cdev, const char *buf,

static ssize_t set_node_desc(struct device *device,

			      size_t count)

			     struct device_attribute *attr,

			     const char *buf, size_t count)

{

{

	struct ib_device *dev = container_of(cdev, struct ib_device, class_dev);

	struct ib_device *dev = container_of(device, struct ib_device, dev);

	struct ib_device_modify desc = {};

	struct ib_device_modify desc = {};

	int ret;

	int ret;
@@ -642,44 +647,43 @@ static ssize_t set_node_desc(struct class_device *cdev, const char *buf, 
	return count;

	return count;

}

}





static CLASS_DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL);

static DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL);

static CLASS_DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL);

static DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL);

static CLASS_DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL);

static DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL);

static CLASS_DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc,

static DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc, set_node_desc);

			 set_node_desc);





static struct class_device_attribute *ib_class_attributes[] = {

static struct device_attribute *ib_class_attributes[] = {

	&class_device_attr_node_type,

	&dev_attr_node_type,

	&class_device_attr_sys_image_guid,

	&dev_attr_sys_image_guid,

	&class_device_attr_node_guid,

	&dev_attr_node_guid,

	&class_device_attr_node_desc

	&dev_attr_node_desc

};

};





static struct class ib_class = {

static struct class ib_class = {

	.name    = "infiniband",

	.name    = "infiniband",

	.release = ib_device_release,

	.dev_release = ib_device_release,

	.uevent = ib_device_uevent,

	.dev_uevent = ib_device_uevent,

};

};





int ib_device_register_sysfs(struct ib_device *device)

int ib_device_register_sysfs(struct ib_device *device)

{

{

	struct class_device *class_dev = &device->class_dev;

	struct device *class_dev = &device->dev;

	int ret;

	int ret;

	int i;

	int i;





	class_dev->class      = &ib_class;

	class_dev->class      = &ib_class;

	class_dev->class_data = device;

	class_dev->driver_data = device;

	class_dev->dev	      = device->dma_device;

	class_dev->parent     = device->dma_device;

	strlcpy(class_dev->class_id, device->name, BUS_ID_SIZE);

	strlcpy(class_dev->bus_id, device->name, BUS_ID_SIZE);





	INIT_LIST_HEAD(&device->port_list);

	INIT_LIST_HEAD(&device->port_list);





	ret = class_device_register(class_dev);

	ret = device_register(class_dev);

	if (ret)

	if (ret)

		goto err;

		goto err;





	for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i) {

	for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i) {

		ret = class_device_create_file(class_dev, ib_class_attributes[i]);

		ret = device_create_file(class_dev, ib_class_attributes[i]);

		if (ret)

		if (ret)

			goto err_unregister;

			goto err_unregister;

	}

	}
@@ -723,7 +727,7 @@ int ib_device_register_sysfs(struct ib_device *device) 
	kobject_put(&class_dev->kobj);

	kobject_put(&class_dev->kobj);





err_unregister:

err_unregister:

	class_device_unregister(class_dev);

	device_unregister(class_dev);





err:

err:

	return ret;

	return ret;
@@ -744,7 +748,7 @@ void ib_device_unregister_sysfs(struct ib_device *device) 
	}

	}





	kobject_put(device->ports_parent);

	kobject_put(device->ports_parent);

	class_device_unregister(&device->class_dev);

	device_unregister(&device->dev);

}

}





int ib_sysfs_setup(void)

int ib_sysfs_setup(void)

drivers/infiniband/core/ucm.c

+31 −31
Original line number Original line Diff line number Diff line
@@ -58,8 +58,8 @@ MODULE_LICENSE("Dual BSD/GPL"); 




struct ib_ucm_device {

struct ib_ucm_device {

	int			devnum;

	int			devnum;

	struct cdev		dev;

	struct cdev		cdev;

	struct class_device	class_dev;

	struct device		dev;

	struct ib_device	*ib_dev;

	struct ib_device	*ib_dev;

};

};
@@ -1171,7 +1171,7 @@ static int ib_ucm_open(struct inode *inode, struct file *filp) 




	filp->private_data = file;

	filp->private_data = file;

	file->filp = filp;

	file->filp = filp;

	file->device = container_of(inode->i_cdev, struct ib_ucm_device, dev);

	file->device = container_of(inode->i_cdev, struct ib_ucm_device, cdev);





	return 0;

	return 0;

}

}
@@ -1202,14 +1202,14 @@ static int ib_ucm_close(struct inode *inode, struct file *filp) 
	return 0;

	return 0;

}

}





static void ucm_release_class_dev(struct class_device *class_dev)

static void ib_ucm_release_dev(struct device *dev)

{

{

	struct ib_ucm_device *dev;

	struct ib_ucm_device *ucm_dev;





	dev = container_of(class_dev, struct ib_ucm_device, class_dev);

	ucm_dev = container_of(dev, struct ib_ucm_device, dev);

	cdev_del(&dev->dev);

	cdev_del(&ucm_dev->cdev);

	clear_bit(dev->devnum, dev_map);

	clear_bit(ucm_dev->devnum, dev_map);

	kfree(dev);

	kfree(ucm_dev);

}

}





static const struct file_operations ucm_fops = {

static const struct file_operations ucm_fops = {
@@ -1220,14 +1220,15 @@ static const struct file_operations ucm_fops = { 
	.poll    = ib_ucm_poll,

	.poll    = ib_ucm_poll,

};

};





static ssize_t show_ibdev(struct class_device *class_dev, char *buf)

static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,

			  char *buf)

{

{

	struct ib_ucm_device *dev;

	struct ib_ucm_device *ucm_dev;





	dev = container_of(class_dev, struct ib_ucm_device, class_dev);

	ucm_dev = container_of(dev, struct ib_ucm_device, dev);

	return sprintf(buf, "%s\n", dev->ib_dev->name);

	return sprintf(buf, "%s\n", ucm_dev->ib_dev->name);

}

}

static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);

static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);





static void ib_ucm_add_one(struct ib_device *device)

static void ib_ucm_add_one(struct ib_device *device)

{

{
@@ -1249,32 +1250,31 @@ static void ib_ucm_add_one(struct ib_device *device) 




	set_bit(ucm_dev->devnum, dev_map);

	set_bit(ucm_dev->devnum, dev_map);





	cdev_init(&ucm_dev->dev, &ucm_fops);

	cdev_init(&ucm_dev->cdev, &ucm_fops);

	ucm_dev->dev.owner = THIS_MODULE;

	ucm_dev->cdev.owner = THIS_MODULE;

	kobject_set_name(&ucm_dev->dev.kobj, "ucm%d", ucm_dev->devnum);

	kobject_set_name(&ucm_dev->cdev.kobj, "ucm%d", ucm_dev->devnum);

	if (cdev_add(&ucm_dev->dev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1))

	if (cdev_add(&ucm_dev->cdev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1))

		goto err;

		goto err;





	ucm_dev->class_dev.class = &cm_class;

	ucm_dev->dev.class = &cm_class;

	ucm_dev->class_dev.dev = device->dma_device;

	ucm_dev->dev.parent = device->dma_device;

	ucm_dev->class_dev.devt = ucm_dev->dev.dev;

	ucm_dev->dev.devt = ucm_dev->cdev.dev;

	ucm_dev->class_dev.release = ucm_release_class_dev;

	ucm_dev->dev.release = ib_ucm_release_dev;

	snprintf(ucm_dev->class_dev.class_id, BUS_ID_SIZE, "ucm%d",

	snprintf(ucm_dev->dev.bus_id, BUS_ID_SIZE, "ucm%d",

		 ucm_dev->devnum);

		 ucm_dev->devnum);

	if (class_device_register(&ucm_dev->class_dev))

	if (device_register(&ucm_dev->dev))

		goto err_cdev;

		goto err_cdev;





	if (class_device_create_file(&ucm_dev->class_dev,

	if (device_create_file(&ucm_dev->dev, &dev_attr_ibdev))

				     &class_device_attr_ibdev))

		goto err_dev;

		goto err_class;





	ib_set_client_data(device, &ucm_client, ucm_dev);

	ib_set_client_data(device, &ucm_client, ucm_dev);

	return;

	return;





err_class:

err_dev:

	class_device_unregister(&ucm_dev->class_dev);

	device_unregister(&ucm_dev->dev);

err_cdev:

err_cdev:

	cdev_del(&ucm_dev->dev);

	cdev_del(&ucm_dev->cdev);

	clear_bit(ucm_dev->devnum, dev_map);

	clear_bit(ucm_dev->devnum, dev_map);

err:

err:

	kfree(ucm_dev);

	kfree(ucm_dev);
@@ -1288,7 +1288,7 @@ static void ib_ucm_remove_one(struct ib_device *device) 
	if (!ucm_dev)

	if (!ucm_dev)

		return;

		return;





	class_device_unregister(&ucm_dev->class_dev);

	device_unregister(&ucm_dev->dev);

}

}





static ssize_t show_abi_version(struct class *class, char *buf)

static ssize_t show_abi_version(struct class *class, char *buf)

drivers/infiniband/core/user_mad.c

+55 −54
Original line number Original line Diff line number Diff line
@@ -88,11 +88,11 @@ enum { 
 */

 */





struct ib_umad_port {

struct ib_umad_port {

	struct cdev           *dev;

	struct cdev           *cdev;

	struct class_device   *class_dev;

	struct device	      *dev;





	struct cdev           *sm_dev;

	struct cdev           *sm_cdev;

	struct class_device   *sm_class_dev;

	struct device	      *sm_dev;

	struct semaphore       sm_sem;

	struct semaphore       sm_sem;





	struct mutex	       file_mutex;

	struct mutex	       file_mutex;
@@ -948,27 +948,29 @@ static struct ib_client umad_client = { 
	.remove = ib_umad_remove_one

	.remove = ib_umad_remove_one

};

};





static ssize_t show_ibdev(struct class_device *class_dev, char *buf)

static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,

			  char *buf)

{

{

	struct ib_umad_port *port = class_get_devdata(class_dev);

	struct ib_umad_port *port = dev_get_drvdata(dev);





	if (!port)

	if (!port)

		return -ENODEV;

		return -ENODEV;





	return sprintf(buf, "%s\n", port->ib_dev->name);

	return sprintf(buf, "%s\n", port->ib_dev->name);

}

}

static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);

static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);





static ssize_t show_port(struct class_device *class_dev, char *buf)

static ssize_t show_port(struct device *dev, struct device_attribute *attr,

			 char *buf)

{

{

	struct ib_umad_port *port = class_get_devdata(class_dev);

	struct ib_umad_port *port = dev_get_drvdata(dev);





	if (!port)

	if (!port)

		return -ENODEV;

		return -ENODEV;





	return sprintf(buf, "%d\n", port->port_num);

	return sprintf(buf, "%d\n", port->port_num);

}

}

static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL);

static DEVICE_ATTR(port, S_IRUGO, show_port, NULL);





static ssize_t show_abi_version(struct class *class, char *buf)

static ssize_t show_abi_version(struct class *class, char *buf)

{

{
@@ -994,48 +996,47 @@ static int ib_umad_init_port(struct ib_device *device, int port_num, 
	mutex_init(&port->file_mutex);

	mutex_init(&port->file_mutex);

	INIT_LIST_HEAD(&port->file_list);

	INIT_LIST_HEAD(&port->file_list);





	port->dev = cdev_alloc();

	port->cdev = cdev_alloc();

	if (!port->dev)

	if (!port->cdev)

		return -1;

		return -1;

	port->dev->owner = THIS_MODULE;

	port->cdev->owner = THIS_MODULE;

	port->dev->ops   = &umad_fops;

	port->cdev->ops   = &umad_fops;

	kobject_set_name(&port->dev->kobj, "umad%d", port->dev_num);

	kobject_set_name(&port->cdev->kobj, "umad%d", port->dev_num);

	if (cdev_add(port->dev, base_dev + port->dev_num, 1))

	if (cdev_add(port->cdev, base_dev + port->dev_num, 1))

		goto err_cdev;

		goto err_cdev;





	port->class_dev = class_device_create(umad_class, NULL, port->dev->dev,

	port->dev = device_create(umad_class, device->dma_device,

					      device->dma_device,

				  port->cdev->dev, "umad%d", port->dev_num);

					      "umad%d", port->dev_num);

	if (IS_ERR(port->dev))

	if (IS_ERR(port->class_dev))

		goto err_cdev;

		goto err_cdev;





	if (class_device_create_file(port->class_dev, &class_device_attr_ibdev))

	if (device_create_file(port->dev, &dev_attr_ibdev))

		goto err_class;

		goto err_dev;

	if (class_device_create_file(port->class_dev, &class_device_attr_port))

	if (device_create_file(port->dev, &dev_attr_port))

		goto err_class;

		goto err_dev;





	port->sm_dev = cdev_alloc();

	port->sm_cdev = cdev_alloc();

	if (!port->sm_dev)

	if (!port->sm_cdev)

		goto err_class;

		goto err_dev;

	port->sm_dev->owner = THIS_MODULE;

	port->sm_cdev->owner = THIS_MODULE;

	port->sm_dev->ops   = &umad_sm_fops;

	port->sm_cdev->ops   = &umad_sm_fops;

	kobject_set_name(&port->sm_dev->kobj, "issm%d", port->dev_num);

	kobject_set_name(&port->sm_cdev->kobj, "issm%d", port->dev_num);

	if (cdev_add(port->sm_dev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1))

	if (cdev_add(port->sm_cdev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1))

		goto err_sm_cdev;

		goto err_sm_cdev;





	port->sm_class_dev = class_device_create(umad_class, NULL, port->sm_dev->dev,

	port->sm_dev = device_create(umad_class, device->dma_device,

						 device->dma_device,

				     port->sm_cdev->dev,

				     "issm%d", port->dev_num);

				     "issm%d", port->dev_num);

	if (IS_ERR(port->sm_class_dev))

	if (IS_ERR(port->sm_dev))

		goto err_sm_cdev;

		goto err_sm_cdev;





	class_set_devdata(port->class_dev,    port);

	dev_set_drvdata(port->dev,    port);

	class_set_devdata(port->sm_class_dev, port);

	dev_set_drvdata(port->sm_dev, port);





	if (class_device_create_file(port->sm_class_dev, &class_device_attr_ibdev))

	if (device_create_file(port->sm_dev, &dev_attr_ibdev))

		goto err_sm_class;

		goto err_sm_dev;

	if (class_device_create_file(port->sm_class_dev, &class_device_attr_port))

	if (device_create_file(port->sm_dev, &dev_attr_port))

		goto err_sm_class;

		goto err_sm_dev;





	spin_lock(&port_lock);

	spin_lock(&port_lock);

	umad_port[port->dev_num] = port;

	umad_port[port->dev_num] = port;
@@ -1043,17 +1044,17 @@ static int ib_umad_init_port(struct ib_device *device, int port_num, 




	return 0;

	return 0;





err_sm_class:

err_sm_dev:

	class_device_destroy(umad_class, port->sm_dev->dev);

	device_destroy(umad_class, port->sm_cdev->dev);





err_sm_cdev:

err_sm_cdev:

	cdev_del(port->sm_dev);

	cdev_del(port->sm_cdev);





err_class:

err_dev:

	class_device_destroy(umad_class, port->dev->dev);

	device_destroy(umad_class, port->cdev->dev);





err_cdev:

err_cdev:

	cdev_del(port->dev);

	cdev_del(port->cdev);

	clear_bit(port->dev_num, dev_map);

	clear_bit(port->dev_num, dev_map);





	return -1;

	return -1;
@@ -1065,14 +1066,14 @@ static void ib_umad_kill_port(struct ib_umad_port *port) 
	int already_dead;

	int already_dead;

	int id;

	int id;





	class_set_devdata(port->class_dev,    NULL);

	dev_set_drvdata(port->dev,    NULL);

	class_set_devdata(port->sm_class_dev, NULL);

	dev_set_drvdata(port->sm_dev, NULL);





	class_device_destroy(umad_class, port->dev->dev);

	device_destroy(umad_class, port->cdev->dev);

	class_device_destroy(umad_class, port->sm_dev->dev);

	device_destroy(umad_class, port->sm_cdev->dev);





	cdev_del(port->dev);

	cdev_del(port->cdev);

	cdev_del(port->sm_dev);

	cdev_del(port->sm_cdev);





	spin_lock(&port_lock);

	spin_lock(&port_lock);

	umad_port[port->dev_num] = NULL;

	umad_port[port->dev_num] = NULL;

drivers/infiniband/core/uverbs.h

+2 −2
Original line number Original line Diff line number Diff line
@@ -73,8 +73,8 @@ struct ib_uverbs_device { 
	struct kref				ref;

	struct kref				ref;

	struct completion			comp;

	struct completion			comp;

	int					devnum;

	int					devnum;

	struct cdev			       *dev;

	struct cdev			       *cdev;

	struct class_device		       *class_dev;

	struct device			       *dev;

	struct ib_device		       *ib_dev;

	struct ib_device		       *ib_dev;

	int					num_comp_vectors;

	int					num_comp_vectors;

};

};

drivers/infiniband/core/uverbs_main.c

+26 −25
Original line number Original line Diff line number Diff line
@@ -690,27 +690,29 @@ static struct ib_client uverbs_client = { 
	.remove = ib_uverbs_remove_one

	.remove = ib_uverbs_remove_one

};

};





static ssize_t show_ibdev(struct class_device *class_dev, char *buf)

static ssize_t show_ibdev(struct device *device, struct device_attribute *attr,

			  char *buf)

{

{

	struct ib_uverbs_device *dev = class_get_devdata(class_dev);

	struct ib_uverbs_device *dev = dev_get_drvdata(device);





	if (!dev)

	if (!dev)

		return -ENODEV;

		return -ENODEV;





	return sprintf(buf, "%s\n", dev->ib_dev->name);

	return sprintf(buf, "%s\n", dev->ib_dev->name);

}

}

static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);

static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);





static ssize_t show_dev_abi_version(struct class_device *class_dev, char *buf)

static ssize_t show_dev_abi_version(struct device *device,

				    struct device_attribute *attr, char *buf)

{

{

	struct ib_uverbs_device *dev = class_get_devdata(class_dev);

	struct ib_uverbs_device *dev = dev_get_drvdata(device);





	if (!dev)

	if (!dev)

		return -ENODEV;

		return -ENODEV;





	return sprintf(buf, "%d\n", dev->ib_dev->uverbs_abi_ver);

	return sprintf(buf, "%d\n", dev->ib_dev->uverbs_abi_ver);

}

}

static CLASS_DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL);

static DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL);





static ssize_t show_abi_version(struct class *class, char *buf)

static ssize_t show_abi_version(struct class *class, char *buf)

{

{
@@ -744,27 +746,26 @@ static void ib_uverbs_add_one(struct ib_device *device) 
	uverbs_dev->ib_dev           = device;

	uverbs_dev->ib_dev           = device;

	uverbs_dev->num_comp_vectors = device->num_comp_vectors;

	uverbs_dev->num_comp_vectors = device->num_comp_vectors;





	uverbs_dev->dev = cdev_alloc();

	uverbs_dev->cdev = cdev_alloc();

	if (!uverbs_dev->dev)

	if (!uverbs_dev->cdev)

		goto err;

		goto err;

	uverbs_dev->dev->owner = THIS_MODULE;

	uverbs_dev->cdev->owner = THIS_MODULE;

	uverbs_dev->dev->ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops;

	uverbs_dev->cdev->ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops;

	kobject_set_name(&uverbs_dev->dev->kobj, "uverbs%d", uverbs_dev->devnum);

	kobject_set_name(&uverbs_dev->cdev->kobj, "uverbs%d", uverbs_dev->devnum);

	if (cdev_add(uverbs_dev->dev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1))

	if (cdev_add(uverbs_dev->cdev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1))

		goto err_cdev;

		goto err_cdev;





	uverbs_dev->class_dev = class_device_create(uverbs_class, NULL,

	uverbs_dev->dev = device_create(uverbs_class, device->dma_device,

						    uverbs_dev->dev->dev,

					uverbs_dev->cdev->dev,

						    device->dma_device,

					"uverbs%d", uverbs_dev->devnum);

					"uverbs%d", uverbs_dev->devnum);

	if (IS_ERR(uverbs_dev->class_dev))

	if (IS_ERR(uverbs_dev->dev))

		goto err_cdev;

		goto err_cdev;





	class_set_devdata(uverbs_dev->class_dev, uverbs_dev);

	dev_set_drvdata(uverbs_dev->dev, uverbs_dev);





	if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_ibdev))

	if (device_create_file(uverbs_dev->dev, &dev_attr_ibdev))

		goto err_class;

		goto err_class;

	if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_abi_version))

	if (device_create_file(uverbs_dev->dev, &dev_attr_abi_version))

		goto err_class;

		goto err_class;





	spin_lock(&map_lock);

	spin_lock(&map_lock);
@@ -776,10 +777,10 @@ static void ib_uverbs_add_one(struct ib_device *device) 
	return;

	return;





err_class:

err_class:

	class_device_destroy(uverbs_class, uverbs_dev->dev->dev);

	device_destroy(uverbs_class, uverbs_dev->cdev->dev);





err_cdev:

err_cdev:

	cdev_del(uverbs_dev->dev);

	cdev_del(uverbs_dev->cdev);

	clear_bit(uverbs_dev->devnum, dev_map);

	clear_bit(uverbs_dev->devnum, dev_map);





err:

err:
@@ -796,9 +797,9 @@ static void ib_uverbs_remove_one(struct ib_device *device) 
	if (!uverbs_dev)

	if (!uverbs_dev)

		return;

		return;





	class_set_devdata(uverbs_dev->class_dev, NULL);

	dev_set_drvdata(uverbs_dev->dev, NULL);

	class_device_destroy(uverbs_class, uverbs_dev->dev->dev);

	device_destroy(uverbs_class, uverbs_dev->cdev->dev);

	cdev_del(uverbs_dev->dev);

	cdev_del(uverbs_dev->cdev);





	spin_lock(&map_lock);

	spin_lock(&map_lock);

	dev_table[uverbs_dev->devnum] = NULL;

	dev_table[uverbs_dev->devnum] = NULL;