Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband (3ff1562e) · Commits · 戴 / test

drivers/infiniband/Kconfig

+1 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@ config INFINIBAND_USER_MAD

		config INFINIBAND_USER_ACCESS
		tristate "InfiniBand userspace access (verbs and CM)"
		select ANON_INODES
		---help---
		Userspace InfiniBand access support. This enables the
		kernel side of userspace verbs and the userspace

drivers/infiniband/core/ucm.c

+52 −11

Original line number	Diff line number	Diff line
		@@ -1215,7 +1215,10 @@ static void ib_ucm_release_dev(struct device *dev)

		ucm_dev = container_of(dev, struct ib_ucm_device, dev);
		cdev_del(&ucm_dev->cdev);
		if (ucm_dev->devnum < IB_UCM_MAX_DEVICES)
		clear_bit(ucm_dev->devnum, dev_map);
		else
		clear_bit(ucm_dev->devnum - IB_UCM_MAX_DEVICES, dev_map);
		kfree(ucm_dev);
		}

		@@ -1237,8 +1240,32 @@ static ssize_t show_ibdev(struct device dev, struct device_attribute attr,
		}
		static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);

		static dev_t overflow_maj;
		static DECLARE_BITMAP(overflow_map, IB_UCM_MAX_DEVICES);
		static int find_overflow_devnum(void)
		{
		int ret;

		if (!overflow_maj) {
		ret = alloc_chrdev_region(&overflow_maj, 0, IB_UCM_MAX_DEVICES,
		"infiniband_cm");
		if (ret) {
		printk(KERN_ERR "ucm: couldn't register dynamic device number\n");
		return ret;
		}
		}

		ret = find_first_zero_bit(overflow_map, IB_UCM_MAX_DEVICES);
		if (ret >= IB_UCM_MAX_DEVICES)
		return -1;

		return ret;
		}

		static void ib_ucm_add_one(struct ib_device *device)
		{
		int devnum;
		dev_t base;
		struct ib_ucm_device *ucm_dev;

		if (!device->alloc_ucontext \|\|
		@@ -1251,16 +1278,25 @@ static void ib_ucm_add_one(struct ib_device *device)

		ucm_dev->ib_dev = device;

		ucm_dev->devnum = find_first_zero_bit(dev_map, IB_UCM_MAX_DEVICES);
		if (ucm_dev->devnum >= IB_UCM_MAX_DEVICES)
		devnum = find_first_zero_bit(dev_map, IB_UCM_MAX_DEVICES);
		if (devnum >= IB_UCM_MAX_DEVICES) {
		devnum = find_overflow_devnum();
		if (devnum < 0)
		goto err;

		set_bit(ucm_dev->devnum, dev_map);
		ucm_dev->devnum = devnum + IB_UCM_MAX_DEVICES;
		base = devnum + overflow_maj;
		set_bit(devnum, overflow_map);
		} else {
		ucm_dev->devnum = devnum;
		base = devnum + IB_UCM_BASE_DEV;
		set_bit(devnum, dev_map);
		}

		cdev_init(&ucm_dev->cdev, &ucm_fops);
		ucm_dev->cdev.owner = THIS_MODULE;
		kobject_set_name(&ucm_dev->cdev.kobj, "ucm%d", ucm_dev->devnum);
		if (cdev_add(&ucm_dev->cdev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1))
		if (cdev_add(&ucm_dev->cdev, base, 1))
		goto err;

		ucm_dev->dev.class = &cm_class;
		@@ -1281,7 +1317,10 @@ err_dev:
		device_unregister(&ucm_dev->dev);
		err_cdev:
		cdev_del(&ucm_dev->cdev);
		clear_bit(ucm_dev->devnum, dev_map);
		if (ucm_dev->devnum < IB_UCM_MAX_DEVICES)
		clear_bit(devnum, dev_map);
		else
		clear_bit(devnum, overflow_map);
		err:
		kfree(ucm_dev);
		return;
		@@ -1340,6 +1379,8 @@ static void __exit ib_ucm_cleanup(void)
		ib_unregister_client(&ucm_client);
		class_remove_file(&cm_class, &class_attr_abi_version);
		unregister_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES);
		if (overflow_maj)
		unregister_chrdev_region(overflow_maj, IB_UCM_MAX_DEVICES);
		idr_destroy(&ctx_id_table);
		}

drivers/infiniband/core/ud_header.c

+4 −10

Original line number	Diff line number	Diff line
		@@ -181,6 +181,7 @@ static const struct ib_field deth_table[] = {
		* ib_ud_header_init - Initialize UD header structure
		* @payload_bytes:Length of packet payload
		* @grh_present:GRH flag (if non-zero, GRH will be included)
		* @immediate_present: specify if immediate data should be used
		* @header:Structure to initialize
		*
		* ib_ud_header_init() initializes the lrh.link_version, lrh.link_next_header,
		@@ -191,21 +192,13 @@ static const struct ib_field deth_table[] = {
		*/
		void ib_ud_header_init(int payload_bytes,
		int grh_present,
		int immediate_present,
		struct ib_ud_header *header)
		{
		int header_len;
		u16 packet_length;

		memset(header, 0, sizeof *header);

		header_len =
		IB_LRH_BYTES +
		IB_BTH_BYTES +
		IB_DETH_BYTES;
		if (grh_present) {
		header_len += IB_GRH_BYTES;
		}

		header->lrh.link_version = 0;
		header->lrh.link_next_header =
		grh_present ? IB_LNH_IBA_GLOBAL : IB_LNH_IBA_LOCAL;
		@@ -231,7 +224,8 @@ void ib_ud_header_init(int payload_bytes,

		header->lrh.packet_length = cpu_to_be16(packet_length);

		if (header->immediate_present)
		header->immediate_present = immediate_present;
		if (immediate_present)
		header->bth.opcode = IB_OPCODE_UD_SEND_ONLY_WITH_IMMEDIATE;
		else
		header->bth.opcode = IB_OPCODE_UD_SEND_ONLY;

drivers/infiniband/core/umem.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -136,7 +136,7 @@ struct ib_umem ib_umem_get(struct ib_ucontext context, unsigned long addr,
		down_write(&current->mm->mmap_sem);

		locked = npages + current->mm->locked_vm;
		lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur >> PAGE_SHIFT;
		lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;

		if ((locked > lock_limit) && !capable(CAP_IPC_LOCK)) {
		ret = -ENOMEM;

drivers/infiniband/core/user_mad.c

+92 −81

Original line number	Diff line number	Diff line
		@@ -65,12 +65,9 @@ enum {
		};

		/*
		* Our lifetime rules for these structs are the following: each time a
		* device special file is opened, we look up the corresponding struct
		* ib_umad_port by minor in the umad_port[] table while holding the
		* port_lock. If this lookup succeeds, we take a reference on the
		* ib_umad_port's struct ib_umad_device while still holding the
		* port_lock; if the lookup fails, we fail the open(). We drop these
		* Our lifetime rules for these structs are the following:
		* device special file is opened, we take a reference on the
		* ib_umad_port's struct ib_umad_device. We drop these
		* references in the corresponding close().
		*
		* In addition to references coming from open character devices, there
		@@ -78,19 +75,14 @@ enum {
		* module's reference taken when allocating the ib_umad_device in
		* ib_umad_add_one().
		*
		* When destroying an ib_umad_device, we clear all of its
		* ib_umad_ports from umad_port[] while holding port_lock before
		* dropping the module's reference to the ib_umad_device. This is
		* always safe because any open() calls will either succeed and obtain
		* a reference before we clear the umad_port[] entries, or fail after
		* we clear the umad_port[] entries.
		* When destroying an ib_umad_device, we drop the module's reference.
		*/

		struct ib_umad_port {
		struct cdev *cdev;
		struct cdev cdev;
		struct device *dev;

		struct cdev *sm_cdev;
		struct cdev sm_cdev;
		struct device *sm_dev;
		struct semaphore sm_sem;

		@@ -136,7 +128,6 @@ static struct class *umad_class;
		static const dev_t base_dev = MKDEV(IB_UMAD_MAJOR, IB_UMAD_MINOR_BASE);

		static DEFINE_SPINLOCK(port_lock);
		static struct ib_umad_port *umad_port[IB_UMAD_MAX_PORTS];
		static DECLARE_BITMAP(dev_map, IB_UMAD_MAX_PORTS);

		static void ib_umad_add_one(struct ib_device *device);
		@@ -779,15 +770,11 @@ static long ib_umad_compat_ioctl(struct file *filp, unsigned int cmd,
		/*
		* ib_umad_open() does not need the BKL:
		*
		* - umad_port[] accesses are protected by port_lock, the
		* ib_umad_port structures are properly reference counted, and
		* - the ib_umad_port structures are properly reference counted, and
		* everything else is purely local to the file being created, so
		* races against other open calls are not a problem;
		* - the ioctl method does not affect any global state outside of the
		* file structure being operated on;
		* - the port is added to umad_port[] as the last part of module
		* initialization so the open method will either immediately run
		* -ENXIO, or all required initialization will be done.
		*/
		static int ib_umad_open(struct inode inode, struct file filp)
		{
		@@ -795,13 +782,10 @@ static int ib_umad_open(struct inode inode, struct file filp)
		struct ib_umad_file *file;
		int ret = 0;

		spin_lock(&port_lock);
		port = umad_port[iminor(inode) - IB_UMAD_MINOR_BASE];
		port = container_of(inode->i_cdev, struct ib_umad_port, cdev);
		if (port)
		kref_get(&port->umad_dev->ref);
		spin_unlock(&port_lock);

		if (!port)
		else
		return -ENXIO;

		mutex_lock(&port->file_mutex);
		@@ -892,13 +876,10 @@ static int ib_umad_sm_open(struct inode inode, struct file filp)
		};
		int ret;

		spin_lock(&port_lock);
		port = umad_port[iminor(inode) - IB_UMAD_MINOR_BASE - IB_UMAD_MAX_PORTS];
		port = container_of(inode->i_cdev, struct ib_umad_port, sm_cdev);
		if (port)
		kref_get(&port->umad_dev->ref);
		spin_unlock(&port_lock);

		if (!port)
		else
		return -ENXIO;

		if (filp->f_flags & O_NONBLOCK) {
		@@ -990,16 +971,51 @@ static ssize_t show_abi_version(struct class class, char buf)
		}
		static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);

		static dev_t overflow_maj;
		static DECLARE_BITMAP(overflow_map, IB_UMAD_MAX_PORTS);
		static int find_overflow_devnum(void)
		{
		int ret;

		if (!overflow_maj) {
		ret = alloc_chrdev_region(&overflow_maj, 0, IB_UMAD_MAX_PORTS * 2,
		"infiniband_mad");
		if (ret) {
		printk(KERN_ERR "user_mad: couldn't register dynamic device number\n");
		return ret;
		}
		}

		ret = find_first_zero_bit(overflow_map, IB_UMAD_MAX_PORTS);
		if (ret >= IB_UMAD_MAX_PORTS)
		return -1;

		return ret;
		}

		static int ib_umad_init_port(struct ib_device *device, int port_num,
		struct ib_umad_port *port)
		{
		int devnum;
		dev_t base;

		spin_lock(&port_lock);
		port->dev_num = find_first_zero_bit(dev_map, IB_UMAD_MAX_PORTS);
		if (port->dev_num >= IB_UMAD_MAX_PORTS) {
		devnum = find_first_zero_bit(dev_map, IB_UMAD_MAX_PORTS);
		if (devnum >= IB_UMAD_MAX_PORTS) {
		spin_unlock(&port_lock);
		devnum = find_overflow_devnum();
		if (devnum < 0)
		return -1;

		spin_lock(&port_lock);
		port->dev_num = devnum + IB_UMAD_MAX_PORTS;
		base = devnum + overflow_maj;
		set_bit(devnum, overflow_map);
		} else {
		port->dev_num = devnum;
		base = devnum + base_dev;
		set_bit(devnum, dev_map);
		}
		set_bit(port->dev_num, dev_map);
		spin_unlock(&port_lock);

		port->ib_dev = device;
		@@ -1008,17 +1024,14 @@ static int ib_umad_init_port(struct ib_device *device, int port_num,
		mutex_init(&port->file_mutex);
		INIT_LIST_HEAD(&port->file_list);

		port->cdev = cdev_alloc();
		if (!port->cdev)
		return -1;
		port->cdev->owner = THIS_MODULE;
		port->cdev->ops = &umad_fops;
		kobject_set_name(&port->cdev->kobj, "umad%d", port->dev_num);
		if (cdev_add(port->cdev, base_dev + port->dev_num, 1))
		cdev_init(&port->cdev, &umad_fops);
		port->cdev.owner = THIS_MODULE;
		kobject_set_name(&port->cdev.kobj, "umad%d", port->dev_num);
		if (cdev_add(&port->cdev, base, 1))
		goto err_cdev;

		port->dev = device_create(umad_class, device->dma_device,
		port->cdev->dev, port,
		port->cdev.dev, port,
		"umad%d", port->dev_num);
		if (IS_ERR(port->dev))
		goto err_cdev;
		@@ -1028,17 +1041,15 @@ static int ib_umad_init_port(struct ib_device *device, int port_num,
		if (device_create_file(port->dev, &dev_attr_port))
		goto err_dev;

		port->sm_cdev = cdev_alloc();
		if (!port->sm_cdev)
		goto err_dev;
		port->sm_cdev->owner = THIS_MODULE;
		port->sm_cdev->ops = &umad_sm_fops;
		kobject_set_name(&port->sm_cdev->kobj, "issm%d", port->dev_num);
		if (cdev_add(port->sm_cdev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1))
		base += IB_UMAD_MAX_PORTS;
		cdev_init(&port->sm_cdev, &umad_sm_fops);
		port->sm_cdev.owner = THIS_MODULE;
		kobject_set_name(&port->sm_cdev.kobj, "issm%d", port->dev_num);
		if (cdev_add(&port->sm_cdev, base, 1))
		goto err_sm_cdev;

		port->sm_dev = device_create(umad_class, device->dma_device,
		port->sm_cdev->dev, port,
		port->sm_cdev.dev, port,
		"issm%d", port->dev_num);
		if (IS_ERR(port->sm_dev))
		goto err_sm_cdev;
		@@ -1048,24 +1059,23 @@ static int ib_umad_init_port(struct ib_device *device, int port_num,
		if (device_create_file(port->sm_dev, &dev_attr_port))
		goto err_sm_dev;

		spin_lock(&port_lock);
		umad_port[port->dev_num] = port;
		spin_unlock(&port_lock);

		return 0;

		err_sm_dev:
		device_destroy(umad_class, port->sm_cdev->dev);
		device_destroy(umad_class, port->sm_cdev.dev);

		err_sm_cdev:
		cdev_del(port->sm_cdev);
		cdev_del(&port->sm_cdev);

		err_dev:
		device_destroy(umad_class, port->cdev->dev);
		device_destroy(umad_class, port->cdev.dev);

		err_cdev:
		cdev_del(port->cdev);
		clear_bit(port->dev_num, dev_map);
		cdev_del(&port->cdev);
		if (port->dev_num < IB_UMAD_MAX_PORTS)
		clear_bit(devnum, dev_map);
		else
		clear_bit(devnum, overflow_map);

		return -1;
		}
		@@ -1079,15 +1089,11 @@ static void ib_umad_kill_port(struct ib_umad_port *port)
		dev_set_drvdata(port->dev, NULL);
		dev_set_drvdata(port->sm_dev, NULL);

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

		cdev_del(port->cdev);
		cdev_del(port->sm_cdev);

		spin_lock(&port_lock);
		umad_port[port->dev_num] = NULL;
		spin_unlock(&port_lock);
		cdev_del(&port->cdev);
		cdev_del(&port->sm_cdev);

		mutex_lock(&port->file_mutex);

		@@ -1106,7 +1112,10 @@ static void ib_umad_kill_port(struct ib_umad_port *port)

		mutex_unlock(&port->file_mutex);

		if (port->dev_num < IB_UMAD_MAX_PORTS)
		clear_bit(port->dev_num, dev_map);
		else
		clear_bit(port->dev_num - IB_UMAD_MAX_PORTS, overflow_map);
		}

		static void ib_umad_add_one(struct ib_device *device)
		@@ -1214,6 +1223,8 @@ static void __exit ib_umad_cleanup(void)
		ib_unregister_client(&umad_client);
		class_destroy(umad_class);
		unregister_chrdev_region(base_dev, IB_UMAD_MAX_PORTS * 2);
		if (overflow_maj)
		unregister_chrdev_region(overflow_maj, IB_UMAD_MAX_PORTS * 2);
		}

		module_init(ib_umad_init);

Admin message