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

Commit 6a398a3e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-4.2/drivers' of git://git.kernel.dk/linux-block 

Pull block driver updates from Jens Axboe:
 "This contains:

   - a few race fixes for null_blk, from Akinobu Mita.

   - a series of fixes for mtip32xx, from Asai Thambi and Selvan Mani at
     Micron.

   - NVMe:
        * Fix for missing error return on allocation failure, from Axel
          Lin.

        * Code consolidation and cleanups from Christoph.

        * Memory barrier addition, syncing queue count and queue
          pointers. From Jon Derrick.

        * Various fixes from Keith, an addition to support user
          issue reset from sysfs or ioctl, and automatic namespace
          rescan.

        * Fix from Matias, avoiding losing some request flags when
          marking the request failfast.

   - small cleanups and sparse fixups for ps3vram.  From Geert
     Uytterhoeven and Geoff Lavand.

   - s390/dasd dead code removal, from Jarod Wilson.

   - a set of fixes and optimizations for loop, from Ming Lei.

   - conversion to blkdev_reread_part() of loop, dasd, ndb.  From Ming
     Lei.

   - updates to cciss.  From Tomas Henzl"

* 'for-4.2/drivers' of git://git.kernel.dk/linux-block: (44 commits)
  mtip32xx: Fix accessing freed memory
  block: nvme-scsi: Catch kcalloc failure
  NVMe: Fix IO for extended metadata formats
  nvme: don't overwrite req->cmd_flags on sync cmd
  mtip32xx: increase wait time for hba reset
  mtip32xx: fix minor number
  mtip32xx: remove unnecessary sleep in mtip_ftl_rebuild_poll()
  mtip32xx: fix crash on surprise removal of the drive
  mtip32xx: Abort I/O during secure erase operation
  mtip32xx: fix incorrectly setting MTIP_DDF_SEC_LOCK_BIT
  mtip32xx: remove unused variable 'port->allocated'
  mtip32xx: fix rmmod issue
  MAINTAINERS: Update ps3vram block driver
  block/ps3vram: Remove obsolete reference to MTD
  block/ps3vram: Fix sparse warnings
  NVMe: Automatic namespace rescan
  NVMe: Memory barrier before queue_count is incremented
  NVMe: add sysfs and ioctl controller reset
  null_blk: restart request processing on completion handler
  null_blk: prevent timer handler running on a different CPU where started
  ...
parents bfffa1cc 98f57c51

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -7982,6 +7982,7 @@ F: sound/ppc/snd_ps3* 


PS3VRAM DRIVER

M:	Jim Paris <jim@jtan.com>

M:	Geoff Levand <geoff@infradead.org>

L:	linuxppc-dev@lists.ozlabs.org

S:	Maintained

F:	drivers/block/ps3vram.c

drivers/block/loop.c

+52 −30
Original line number Diff line number Diff line
@@ -86,8 +86,6 @@ static DEFINE_MUTEX(loop_index_mutex); 
static int max_part;

static int part_shift;



static struct workqueue_struct *loop_wq;



static int transfer_xor(struct loop_device *lo, int cmd,

			struct page *raw_page, unsigned raw_off,

			struct page *loop_page, unsigned loop_off,
@@ -476,6 +474,28 @@ static int loop_flush(struct loop_device *lo) 
	return loop_switch(lo, NULL);

}



static void loop_reread_partitions(struct loop_device *lo,

				   struct block_device *bdev)

{

	int rc;



	/*

	 * bd_mutex has been held already in release path, so don't

	 * acquire it if this function is called in such case.

	 *

	 * If the reread partition isn't from release path, lo_refcnt

	 * must be at least one and it can only become zero when the

	 * current holder is released.

	 */

	if (!atomic_read(&lo->lo_refcnt))

		rc = __blkdev_reread_part(bdev);

	else

		rc = blkdev_reread_part(bdev);

	if (rc)

		pr_warn("%s: partition scan of loop%d (%s) failed (rc=%d)\n",

			__func__, lo->lo_number, lo->lo_file_name, rc);

}



/*

 * loop_change_fd switched the backing store of a loopback device to

 * a new file. This is useful for operating system installers to free up
@@ -524,7 +544,7 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev, 


	fput(old_file);

	if (lo->lo_flags & LO_FLAGS_PARTSCAN)

		ioctl_by_bdev(bdev, BLKRRPART, 0);

		loop_reread_partitions(lo, bdev);

	return 0;



 out_putf:
@@ -725,6 +745,12 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode, 
	size = get_loop_size(lo, file);

	if ((loff_t)(sector_t)size != size)

		goto out_putf;

	error = -ENOMEM;

	lo->wq = alloc_workqueue("kloopd%d",

			WQ_MEM_RECLAIM | WQ_HIGHPRI | WQ_UNBOUND, 16,

			lo->lo_number);

	if (!lo->wq)

		goto out_putf;



	error = 0;
@@ -755,7 +781,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode, 
	if (part_shift)

		lo->lo_flags |= LO_FLAGS_PARTSCAN;

	if (lo->lo_flags & LO_FLAGS_PARTSCAN)

		ioctl_by_bdev(bdev, BLKRRPART, 0);

		loop_reread_partitions(lo, bdev);



	/* Grab the block_device to prevent its destruction after we

	 * put /dev/loopXX inode. Later in loop_clr_fd() we bdput(bdev).
@@ -827,7 +853,7 @@ static int loop_clr_fd(struct loop_device *lo) 
	 * <dev>/do something like mkfs/losetup -d <dev> causing the losetup -d

	 * command to fail with EBUSY.

	 */

	if (lo->lo_refcnt > 1) {

	if (atomic_read(&lo->lo_refcnt) > 1) {

		lo->lo_flags |= LO_FLAGS_AUTOCLEAR;

		mutex_unlock(&lo->lo_ctl_mutex);

		return 0;
@@ -836,6 +862,9 @@ static int loop_clr_fd(struct loop_device *lo) 
	if (filp == NULL)

		return -EINVAL;



	/* freeze request queue during the transition */

	blk_mq_freeze_queue(lo->lo_queue);



	spin_lock_irq(&lo->lo_lock);

	lo->lo_state = Lo_rundown;

	lo->lo_backing_file = NULL;
@@ -867,11 +896,15 @@ static int loop_clr_fd(struct loop_device *lo) 
	lo->lo_state = Lo_unbound;

	/* This is safe: open() is still holding a reference. */

	module_put(THIS_MODULE);

	blk_mq_unfreeze_queue(lo->lo_queue);



	if (lo->lo_flags & LO_FLAGS_PARTSCAN && bdev)

		ioctl_by_bdev(bdev, BLKRRPART, 0);

		loop_reread_partitions(lo, bdev);

	lo->lo_flags = 0;

	if (!part_shift)

		lo->lo_disk->flags |= GENHD_FL_NO_PART_SCAN;

	destroy_workqueue(lo->wq);

	lo->wq = NULL;

	mutex_unlock(&lo->lo_ctl_mutex);

	/*

	 * Need not hold lo_ctl_mutex to fput backing file.
@@ -943,7 +976,7 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info) 
	     !(lo->lo_flags & LO_FLAGS_PARTSCAN)) {

		lo->lo_flags |= LO_FLAGS_PARTSCAN;

		lo->lo_disk->flags &= ~GENHD_FL_NO_PART_SCAN;

		ioctl_by_bdev(lo->lo_device, BLKRRPART, 0);

		loop_reread_partitions(lo, lo->lo_device);

	}



	lo->lo_encrypt_key_size = info->lo_encrypt_key_size;
@@ -1324,9 +1357,7 @@ static int lo_open(struct block_device *bdev, fmode_t mode) 
		goto out;

	}



	mutex_lock(&lo->lo_ctl_mutex);

	lo->lo_refcnt++;

	mutex_unlock(&lo->lo_ctl_mutex);

	atomic_inc(&lo->lo_refcnt);

out:

	mutex_unlock(&loop_index_mutex);

	return err;
@@ -1337,11 +1368,10 @@ static void lo_release(struct gendisk *disk, fmode_t mode) 
	struct loop_device *lo = disk->private_data;

	int err;



	mutex_lock(&lo->lo_ctl_mutex);



	if (--lo->lo_refcnt)

		goto out;

	if (atomic_dec_return(&lo->lo_refcnt))

		return;



	mutex_lock(&lo->lo_ctl_mutex);

	if (lo->lo_flags & LO_FLAGS_AUTOCLEAR) {

		/*

		 * In autoclear mode, stop the loop thread
@@ -1358,7 +1388,6 @@ static void lo_release(struct gendisk *disk, fmode_t mode) 
		loop_flush(lo);

	}



out:

	mutex_unlock(&lo->lo_ctl_mutex);

}
@@ -1425,9 +1454,13 @@ static int loop_queue_rq(struct blk_mq_hw_ctx *hctx, 
		const struct blk_mq_queue_data *bd)

{

	struct loop_cmd *cmd = blk_mq_rq_to_pdu(bd->rq);

	struct loop_device *lo = cmd->rq->q->queuedata;



	blk_mq_start_request(bd->rq);



	if (lo->lo_state != Lo_bound)

		return -EIO;



	if (cmd->rq->cmd_flags & REQ_WRITE) {

		struct loop_device *lo = cmd->rq->q->queuedata;

		bool need_sched = true;
@@ -1441,9 +1474,9 @@ static int loop_queue_rq(struct blk_mq_hw_ctx *hctx, 
		spin_unlock_irq(&lo->lo_lock);



		if (need_sched)

			queue_work(loop_wq, &lo->write_work);

			queue_work(lo->wq, &lo->write_work);

	} else {

		queue_work(loop_wq, &cmd->read_work);

		queue_work(lo->wq, &cmd->read_work);

	}



	return BLK_MQ_RQ_QUEUE_OK;
@@ -1455,9 +1488,6 @@ static void loop_handle_cmd(struct loop_cmd *cmd) 
	struct loop_device *lo = cmd->rq->q->queuedata;

	int ret = -EIO;



	if (lo->lo_state != Lo_bound)

		goto failed;



	if (write && (lo->lo_flags & LO_FLAGS_READ_ONLY))

		goto failed;
@@ -1594,6 +1624,7 @@ static int loop_add(struct loop_device **l, int i) 
		disk->flags |= GENHD_FL_NO_PART_SCAN;

	disk->flags |= GENHD_FL_EXT_DEVT;

	mutex_init(&lo->lo_ctl_mutex);

	atomic_set(&lo->lo_refcnt, 0);

	lo->lo_number		= i;

	spin_lock_init(&lo->lo_lock);

	disk->major		= LOOP_MAJOR;
@@ -1711,7 +1742,7 @@ static long loop_control_ioctl(struct file *file, unsigned int cmd, 
			mutex_unlock(&lo->lo_ctl_mutex);

			break;

		}

		if (lo->lo_refcnt > 0) {

		if (atomic_read(&lo->lo_refcnt) > 0) {

			ret = -EBUSY;

			mutex_unlock(&lo->lo_ctl_mutex);

			break;
@@ -1806,13 +1837,6 @@ static int __init loop_init(void) 
		goto misc_out;

	}



	loop_wq = alloc_workqueue("kloopd",

			WQ_MEM_RECLAIM | WQ_HIGHPRI | WQ_UNBOUND, 0);

	if (!loop_wq) {

		err = -ENOMEM;

		goto misc_out;

	}



	blk_register_region(MKDEV(LOOP_MAJOR, 0), range,

				  THIS_MODULE, loop_probe, NULL, NULL);
@@ -1850,8 +1874,6 @@ static void __exit loop_exit(void) 
	blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range);

	unregister_blkdev(LOOP_MAJOR, "loop");



	destroy_workqueue(loop_wq);



	misc_deregister(&loop_misc);

}

drivers/block/loop.h

+2 −1
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ struct loop_func_table; 


struct loop_device {

	int		lo_number;

	int		lo_refcnt;

	atomic_t	lo_refcnt;

	loff_t		lo_offset;

	loff_t		lo_sizelimit;

	int		lo_flags;
@@ -54,6 +54,7 @@ struct loop_device { 
	gfp_t		old_gfp_mask;



	spinlock_t		lo_lock;

	struct workqueue_struct *wq;

	struct list_head	write_cmd_head;

	struct work_struct	write_work;

	bool			write_started;

drivers/block/mtip32xx/mtip32xx.c

+84 −144
Original line number Diff line number Diff line
@@ -163,12 +163,6 @@ static bool mtip_check_surprise_removal(struct pci_dev *pdev) 
		else

			dev_warn(&dd->pdev->dev,

				"%s: dd->queue is NULL\n", __func__);

		if (dd->port) {

			set_bit(MTIP_PF_SR_CLEANUP_BIT, &dd->port->flags);

			wake_up_interruptible(&dd->port->svc_wait);

		} else

			dev_warn(&dd->pdev->dev,

				"%s: dd->port is NULL\n", __func__);

		return true; /* device removed */

	}
@@ -269,8 +263,11 @@ static int mtip_hba_reset(struct driver_data *dd) 
	/* Flush */

	readl(dd->mmio + HOST_CTL);



	/* Spin for up to 2 seconds, waiting for reset acknowledgement */

	timeout = jiffies + msecs_to_jiffies(2000);

	/*

	 * Spin for up to 10 seconds waiting for reset acknowledgement. Spec

	 * is 1 sec but in LUN failure conditions, up to 10 secs are required

	 */

	timeout = jiffies + msecs_to_jiffies(10000);

	do {

		mdelay(10);

		if (test_bit(MTIP_DDF_REMOVE_PENDING_BIT, &dd->dd_flag))
@@ -623,8 +620,7 @@ static void mtip_handle_tfe(struct driver_data *dd) 


	set_bit(MTIP_PF_EH_ACTIVE_BIT, &port->flags);



	if (test_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags) &&

			test_bit(MTIP_TAG_INTERNAL, port->allocated)) {

	if (test_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags)) {

		cmd = mtip_cmd_from_tag(dd, MTIP_TAG_INTERNAL);

		dbg_printk(MTIP_DRV_NAME " TFE for the internal command\n");
@@ -896,6 +892,10 @@ static inline irqreturn_t mtip_handle_irq(struct driver_data *data) 


		/* Acknowledge the interrupt status on the port.*/

		port_stat = readl(port->mmio + PORT_IRQ_STAT);

		if (unlikely(port_stat == 0xFFFFFFFF)) {

			mtip_check_surprise_removal(dd->pdev);

			return IRQ_HANDLED;

		}

		writel(port_stat, port->mmio + PORT_IRQ_STAT);



		/* Demux port status */
@@ -991,15 +991,10 @@ static bool mtip_pause_ncq(struct mtip_port *port, 
	reply = port->rxfis + RX_FIS_D2H_REG;

	task_file_data = readl(port->mmio+PORT_TFDATA);



	if (fis->command == ATA_CMD_SEC_ERASE_UNIT)

		clear_bit(MTIP_DDF_SEC_LOCK_BIT, &port->dd->dd_flag);



	if ((task_file_data & 1))

		return false;



	if (fis->command == ATA_CMD_SEC_ERASE_PREP) {

		set_bit(MTIP_PF_SE_ACTIVE_BIT, &port->flags);

		set_bit(MTIP_DDF_SEC_LOCK_BIT, &port->dd->dd_flag);

		port->ic_pause_timer = jiffies;

		return true;

	} else if ((fis->command == ATA_CMD_DOWNLOAD_MICRO) &&
@@ -1011,8 +1006,10 @@ static bool mtip_pause_ncq(struct mtip_port *port, 
		((fis->command == 0xFC) &&

			(fis->features == 0x27 || fis->features == 0x72 ||

			 fis->features == 0x62 || fis->features == 0x26))) {

		clear_bit(MTIP_DDF_SEC_LOCK_BIT, &port->dd->dd_flag);

		/* Com reset after secure erase or lowlevel format */

		mtip_restart_port(port);

		clear_bit(MTIP_PF_SE_ACTIVE_BIT, &port->flags);

		return false;

	}
@@ -1112,9 +1109,10 @@ static int mtip_exec_internal_command(struct mtip_port *port, 
	int_cmd = mtip_get_int_command(dd);



	set_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags);

	port->ic_pause_timer = 0;



	clear_bit(MTIP_PF_SE_ACTIVE_BIT, &port->flags);

	if (fis->command == ATA_CMD_SEC_ERASE_PREP)

		set_bit(MTIP_PF_SE_ACTIVE_BIT, &port->flags);



	clear_bit(MTIP_PF_DM_ACTIVE_BIT, &port->flags);



	if (atomic == GFP_KERNEL) {
@@ -1251,11 +1249,11 @@ static int mtip_exec_internal_command(struct mtip_port *port, 
exec_ic_exit:

	/* Clear the allocated and active bits for the internal command. */

	mtip_put_int_command(dd, int_cmd);

	clear_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags);

	if (rv >= 0 && mtip_pause_ncq(port, fis)) {

		/* NCQ paused */

		return rv;

	}

	clear_bit(MTIP_PF_IC_ACTIVE_BIT, &port->flags);

	wake_up_interruptible(&port->svc_wait);



	return rv;
@@ -2625,18 +2623,6 @@ static ssize_t mtip_hw_read_registers(struct file *f, char __user *ubuf, 
				readl(dd->mmio + HOST_IRQ_STAT));

	size += sprintf(&buf[size], "\n");



	size += sprintf(&buf[size], "L/ Allocated     : [ 0x");



	for (n = dd->slot_groups-1; n >= 0; n--) {

		if (sizeof(long) > sizeof(u32))

			group_allocated =

				dd->port->allocated[n/2] >> (32*(n&1));

		else

			group_allocated = dd->port->allocated[n];

		size += sprintf(&buf[size], "%08X ", group_allocated);

	}

	size += sprintf(&buf[size], "]\n");



	size += sprintf(&buf[size], "L/ Commands in Q : [ 0x");



	for (n = dd->slot_groups-1; n >= 0; n--) {
@@ -2780,48 +2766,6 @@ static void mtip_hw_debugfs_exit(struct driver_data *dd) 
		debugfs_remove_recursive(dd->dfs_node);

}



static int mtip_free_orphan(struct driver_data *dd)

{

	struct kobject *kobj;



	if (dd->bdev) {

		if (dd->bdev->bd_holders >= 1)

			return -2;



		bdput(dd->bdev);

		dd->bdev = NULL;

	}



	mtip_hw_debugfs_exit(dd);



	spin_lock(&rssd_index_lock);

	ida_remove(&rssd_index_ida, dd->index);

	spin_unlock(&rssd_index_lock);



	if (!test_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag) &&

			test_bit(MTIP_DDF_REBUILD_FAILED_BIT, &dd->dd_flag)) {

		put_disk(dd->disk);

	} else {

		if (dd->disk) {

			kobj = kobject_get(&disk_to_dev(dd->disk)->kobj);

			if (kobj) {

				mtip_hw_sysfs_exit(dd, kobj);

				kobject_put(kobj);

			}

			del_gendisk(dd->disk);

			dd->disk = NULL;

		}

		if (dd->queue) {

			dd->queue->queuedata = NULL;

			blk_cleanup_queue(dd->queue);

			blk_mq_free_tag_set(&dd->tags);

			dd->queue = NULL;

		}

	}

	kfree(dd);

	return 0;

}



/*

 * Perform any init/resume time hardware setup

 *
@@ -2944,7 +2888,6 @@ static int mtip_ftl_rebuild_poll(struct driver_data *dd) 
			mtip_block_initialize(dd);

			return 0;

		}

		ssleep(10);

	} while (time_before(jiffies, timeout));



	/* Check for timeout */
@@ -2969,7 +2912,6 @@ static int mtip_service_thread(void *data) 
	unsigned long slot, slot_start, slot_wrap;

	unsigned int num_cmd_slots = dd->slot_groups * 32;

	struct mtip_port *port = dd->port;

	int ret;



	while (1) {

		if (kthread_should_stop() ||
@@ -2990,10 +2932,6 @@ static int mtip_service_thread(void *data) 
			test_bit(MTIP_PF_SVC_THD_STOP_BIT, &port->flags))

			goto st_out;



		/* If I am an orphan, start self cleanup */

		if (test_bit(MTIP_PF_SR_CLEANUP_BIT, &port->flags))

			break;



		if (unlikely(test_bit(MTIP_DDF_REMOVE_PENDING_BIT,

				&dd->dd_flag)))

			goto st_out;
@@ -3047,26 +2985,6 @@ static int mtip_service_thread(void *data) 
		}

	}



	/* wait for pci remove to exit */

	while (1) {

		if (test_bit(MTIP_DDF_REMOVE_DONE_BIT, &dd->dd_flag))

			break;

		msleep_interruptible(1000);

		if (kthread_should_stop())

			goto st_out;

	}



	while (1) {

		ret = mtip_free_orphan(dd);

		if (!ret) {

			/* NOTE: All data structures are invalid, do not

			 * access any here */

			return 0;

		}

		msleep_interruptible(1000);

		if (kthread_should_stop())

			goto st_out;

	}

st_out:

	return 0;

}
@@ -3394,6 +3312,7 @@ static int mtip_hw_exit(struct driver_data *dd) 
	/* Release the IRQ. */

	irq_set_affinity_hint(dd->pdev->irq, NULL);

	devm_free_irq(&dd->pdev->dev, dd->pdev->irq, dd);

	msleep(1000);



	/* Free dma regions */

	mtip_dma_free(dd);
@@ -3699,6 +3618,26 @@ static const struct block_device_operations mtip_block_ops = { 
	.owner		= THIS_MODULE

};



static inline bool is_se_active(struct driver_data *dd)

{

	if (unlikely(test_bit(MTIP_PF_SE_ACTIVE_BIT, &dd->port->flags))) {

		if (dd->port->ic_pause_timer) {

			unsigned long to = dd->port->ic_pause_timer +

							msecs_to_jiffies(1000);

			if (time_after(jiffies, to)) {

				clear_bit(MTIP_PF_SE_ACTIVE_BIT,

							&dd->port->flags);

				clear_bit(MTIP_DDF_SEC_LOCK_BIT, &dd->dd_flag);

				dd->port->ic_pause_timer = 0;

				wake_up_interruptible(&dd->port->svc_wait);

				return false;

			}

		}

		return true;

	}

	return false;

}



/*

 * Block layer make request function.

 *
@@ -3716,6 +3655,9 @@ static int mtip_submit_request(struct blk_mq_hw_ctx *hctx, struct request *rq) 
	struct mtip_cmd *cmd = blk_mq_rq_to_pdu(rq);

	unsigned int nents;



	if (is_se_active(dd))

		return -ENODATA;



	if (unlikely(dd->dd_flag & MTIP_DDF_STOP_IO)) {

		if (unlikely(test_bit(MTIP_DDF_REMOVE_PENDING_BIT,

							&dd->dd_flag))) {
@@ -3900,7 +3842,8 @@ static int mtip_block_initialize(struct driver_data *dd) 


	dd->disk->driverfs_dev	= &dd->pdev->dev;

	dd->disk->major		= dd->major;

	dd->disk->first_minor	= dd->instance * MTIP_MAX_MINORS;

	dd->disk->first_minor	= index * MTIP_MAX_MINORS;

	dd->disk->minors 	= MTIP_MAX_MINORS;

	dd->disk->fops		= &mtip_block_ops;

	dd->disk->private_data	= dd;

	dd->index		= index;
@@ -4066,7 +4009,6 @@ static int mtip_block_remove(struct driver_data *dd) 
{

	struct kobject *kobj;



	if (!dd->sr) {

	mtip_hw_debugfs_exit(dd);



	if (dd->mtip_svc_handler) {
@@ -4084,7 +4026,11 @@ static int mtip_block_remove(struct driver_data *dd) 
		}

	}



	if (!dd->sr)

		mtip_standby_drive(dd);

	else

		dev_info(&dd->pdev->dev, "device %s surprise removal\n",

						dd->disk->disk_name);



	/*

	 * Delete our gendisk structure. This also removes the device
@@ -4095,12 +4041,12 @@ static int mtip_block_remove(struct driver_data *dd) 
		dd->bdev = NULL;

	}

	if (dd->disk) {

			if (dd->disk->queue) {

		del_gendisk(dd->disk);

		if (dd->disk->queue) {

			blk_cleanup_queue(dd->queue);

			blk_mq_free_tag_set(&dd->tags);

			dd->queue = NULL;

			} else

		}

		put_disk(dd->disk);

	}

	dd->disk  = NULL;
@@ -4108,10 +4054,6 @@ static int mtip_block_remove(struct driver_data *dd) 
	spin_lock(&rssd_index_lock);

	ida_remove(&rssd_index_ida, dd->index);

	spin_unlock(&rssd_index_lock);

	} else {

		dev_info(&dd->pdev->dev, "device %s surprise removal\n",

						dd->disk->disk_name);

	}



	/* De-initialize the protocol layer. */

	mtip_hw_exit(dd);
@@ -4140,11 +4082,11 @@ static int mtip_block_shutdown(struct driver_data *dd) 
		dev_info(&dd->pdev->dev,

			"Shutting down %s ...\n", dd->disk->disk_name);



		if (dd->disk->queue) {

		del_gendisk(dd->disk);

		if (dd->disk->queue) {

			blk_cleanup_queue(dd->queue);

			blk_mq_free_tag_set(&dd->tags);

		} else

		}

		put_disk(dd->disk);

		dd->disk  = NULL;

		dd->queue = NULL;
@@ -4507,6 +4449,7 @@ static void mtip_pci_remove(struct pci_dev *pdev) 
			"Completion workers still active!\n");

	}



	blk_mq_stop_hw_queues(dd->queue);

	/* Clean up the block layer. */

	mtip_block_remove(dd);
@@ -4524,10 +4467,7 @@ static void mtip_pci_remove(struct pci_dev *pdev) 
	list_del_init(&dd->remove_list);

	spin_unlock_irqrestore(&dev_lock, flags);



	if (!dd->sr)

	kfree(dd);

	else

		set_bit(MTIP_DDF_REMOVE_DONE_BIT, &dd->dd_flag);



	pcim_iounmap_regions(pdev, 1 << MTIP_ABAR);

	pci_set_drvdata(pdev, NULL);

drivers/block/mtip32xx/mtip32xx.h

+1 −9
Original line number Diff line number Diff line
@@ -142,7 +142,6 @@ enum { 
	MTIP_PF_SVC_THD_ACTIVE_BIT  = 4,

	MTIP_PF_ISSUE_CMDS_BIT      = 5,

	MTIP_PF_REBUILD_BIT         = 6,

	MTIP_PF_SR_CLEANUP_BIT      = 7,

	MTIP_PF_SVC_THD_STOP_BIT    = 8,



	/* below are bit numbers in 'dd_flag' defined in driver_data */
@@ -150,7 +149,6 @@ enum { 
	MTIP_DDF_REMOVE_PENDING_BIT = 1,

	MTIP_DDF_OVER_TEMP_BIT      = 2,

	MTIP_DDF_WRITE_PROTECT_BIT  = 3,

	MTIP_DDF_REMOVE_DONE_BIT    = 4,

	MTIP_DDF_CLEANUP_BIT        = 5,

	MTIP_DDF_RESUME_BIT         = 6,

	MTIP_DDF_INIT_DONE_BIT      = 7,
@@ -412,19 +410,13 @@ struct mtip_port { 
	 * by the DMA when the driver issues internal commands.

	 */

	dma_addr_t sector_buffer_dma;

	/*

	 * Bit significant, used to determine if a command slot has

	 * been allocated. i.e. the slot is in use.  Bits are cleared

	 * when the command slot and all associated data structures

	 * are no longer needed.

	 */



	u16 *log_buf;

	dma_addr_t log_buf_dma;



	u8 *smart_buf;

	dma_addr_t smart_buf_dma;



	unsigned long allocated[SLOTBITS_IN_LONGS];

	/*

	 * used to queue commands when an internal command is in progress

	 * or error handling is active