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

Commit b7e70ca9 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'async-scsi-resume' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/isci 

Pull async SCSI resume support from Dan Williams:
 "Allow disks and other devices to resume in parallel.

  This provides a tangible speed up for a non-esoteric use case (laptop
  resume):

    https://01.org/suspendresume/blogs/tebrandt/2013/hard-disk-resume-optimization-simpler-approach"

* 'async-scsi-resume' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/isci:
  scsi: async sd resume
parents 7f873078 3c31b52f

drivers/scsi/Kconfig

+3 −0
Original line number Diff line number Diff line
@@ -263,6 +263,9 @@ config SCSI_SCAN_ASYNC 
	  You can override this choice by specifying "scsi_mod.scan=sync"

	  or async on the kernel's command line.



	  Note that this setting also affects whether resuming from

	  system suspend will be performed asynchronously.



menu "SCSI Transports"

	depends on SCSI

drivers/scsi/scsi.c

+9 −0
Original line number Diff line number Diff line
@@ -91,6 +91,15 @@ EXPORT_SYMBOL(scsi_logging_level); 
ASYNC_DOMAIN(scsi_sd_probe_domain);

EXPORT_SYMBOL(scsi_sd_probe_domain);



/*

 * Separate domain (from scsi_sd_probe_domain) to maximize the benefit of

 * asynchronous system resume operations.  It is marked 'exclusive' to avoid

 * being included in the async_synchronize_full() that is invoked by

 * dpm_resume()

 */

ASYNC_DOMAIN_EXCLUSIVE(scsi_sd_pm_domain);

EXPORT_SYMBOL(scsi_sd_pm_domain);



/* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.

 * You may not alter any existing entry (although adding new ones is

 * encouraged once assigned by ANSI/INCITS T10

drivers/scsi/scsi_pm.c

+99 −29
Original line number Diff line number Diff line
@@ -18,35 +18,77 @@ 


#ifdef CONFIG_PM_SLEEP



static int scsi_dev_type_suspend(struct device *dev, int (*cb)(struct device *))

static int do_scsi_suspend(struct device *dev, const struct dev_pm_ops *pm)

{

	return pm && pm->suspend ? pm->suspend(dev) : 0;

}



static int do_scsi_freeze(struct device *dev, const struct dev_pm_ops *pm)

{

	return pm && pm->freeze ? pm->freeze(dev) : 0;

}



static int do_scsi_poweroff(struct device *dev, const struct dev_pm_ops *pm)

{

	return pm && pm->poweroff ? pm->poweroff(dev) : 0;

}



static int do_scsi_resume(struct device *dev, const struct dev_pm_ops *pm)

{

	return pm && pm->resume ? pm->resume(dev) : 0;

}



static int do_scsi_thaw(struct device *dev, const struct dev_pm_ops *pm)

{

	return pm && pm->thaw ? pm->thaw(dev) : 0;

}



static int do_scsi_restore(struct device *dev, const struct dev_pm_ops *pm)

{

	return pm && pm->restore ? pm->restore(dev) : 0;

}



static int scsi_dev_type_suspend(struct device *dev,

		int (*cb)(struct device *, const struct dev_pm_ops *))

{

	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

	int err;



	/* flush pending in-flight resume operations, suspend is synchronous */

	async_synchronize_full_domain(&scsi_sd_pm_domain);



	err = scsi_device_quiesce(to_scsi_device(dev));

	if (err == 0) {

		if (cb) {

			err = cb(dev);

		err = cb(dev, pm);

		if (err)

			scsi_device_resume(to_scsi_device(dev));

	}

	}

	dev_dbg(dev, "scsi suspend: %d\n", err);

	return err;

}



static int scsi_dev_type_resume(struct device *dev, int (*cb)(struct device *))

static int scsi_dev_type_resume(struct device *dev,

		int (*cb)(struct device *, const struct dev_pm_ops *))

{

	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

	int err = 0;



	if (cb)

		err = cb(dev);

	err = cb(dev, pm);

	scsi_device_resume(to_scsi_device(dev));

	dev_dbg(dev, "scsi resume: %d\n", err);



	if (err == 0) {

		pm_runtime_disable(dev);

		pm_runtime_set_active(dev);

		pm_runtime_enable(dev);

	}



	return err;

}



static int

scsi_bus_suspend_common(struct device *dev, int (*cb)(struct device *))

scsi_bus_suspend_common(struct device *dev,

		int (*cb)(struct device *, const struct dev_pm_ops *))

{

	int err = 0;
@@ -66,20 +108,54 @@ scsi_bus_suspend_common(struct device *dev, int (*cb)(struct device *)) 
	return err;

}



static int

scsi_bus_resume_common(struct device *dev, int (*cb)(struct device *))

static void async_sdev_resume(void *dev, async_cookie_t cookie)

{

	int err = 0;

	scsi_dev_type_resume(dev, do_scsi_resume);

}



	if (scsi_is_sdev_device(dev))

		err = scsi_dev_type_resume(dev, cb);

static void async_sdev_thaw(void *dev, async_cookie_t cookie)

{

	scsi_dev_type_resume(dev, do_scsi_thaw);

}



	if (err == 0) {

static void async_sdev_restore(void *dev, async_cookie_t cookie)

{

	scsi_dev_type_resume(dev, do_scsi_restore);

}



static int scsi_bus_resume_common(struct device *dev,

		int (*cb)(struct device *, const struct dev_pm_ops *))

{

	async_func_t fn;



	if (!scsi_is_sdev_device(dev))

		fn = NULL;

	else if (cb == do_scsi_resume)

		fn = async_sdev_resume;

	else if (cb == do_scsi_thaw)

		fn = async_sdev_thaw;

	else if (cb == do_scsi_restore)

		fn = async_sdev_restore;

	else

		fn = NULL;



	if (fn) {

		async_schedule_domain(fn, dev, &scsi_sd_pm_domain);



		/*

		 * If a user has disabled async probing a likely reason

		 * is due to a storage enclosure that does not inject

		 * staggered spin-ups.  For safety, make resume

		 * synchronous as well in that case.

		 */

		if (strncmp(scsi_scan_type, "async", 5) != 0)

			async_synchronize_full_domain(&scsi_sd_pm_domain);

	} else {

		pm_runtime_disable(dev);

		pm_runtime_set_active(dev);

		pm_runtime_enable(dev);

	}

	return err;

	return 0;

}



static int scsi_bus_prepare(struct device *dev)
@@ -97,38 +173,32 @@ static int scsi_bus_prepare(struct device *dev) 


static int scsi_bus_suspend(struct device *dev)

{

	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

	return scsi_bus_suspend_common(dev, pm ? pm->suspend : NULL);

	return scsi_bus_suspend_common(dev, do_scsi_suspend);

}



static int scsi_bus_resume(struct device *dev)

{

	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

	return scsi_bus_resume_common(dev, pm ? pm->resume : NULL);

	return scsi_bus_resume_common(dev, do_scsi_resume);

}



static int scsi_bus_freeze(struct device *dev)

{

	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

	return scsi_bus_suspend_common(dev, pm ? pm->freeze : NULL);

	return scsi_bus_suspend_common(dev, do_scsi_freeze);

}



static int scsi_bus_thaw(struct device *dev)

{

	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

	return scsi_bus_resume_common(dev, pm ? pm->thaw : NULL);

	return scsi_bus_resume_common(dev, do_scsi_thaw);

}



static int scsi_bus_poweroff(struct device *dev)

{

	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

	return scsi_bus_suspend_common(dev, pm ? pm->poweroff : NULL);

	return scsi_bus_suspend_common(dev, do_scsi_poweroff);

}



static int scsi_bus_restore(struct device *dev)

{

	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

	return scsi_bus_resume_common(dev, pm ? pm->restore : NULL);

	return scsi_bus_resume_common(dev, do_scsi_restore);

}



#else /* CONFIG_PM_SLEEP */

drivers/scsi/scsi_priv.h

+2 −0
Original line number Diff line number Diff line
@@ -112,6 +112,7 @@ extern void scsi_exit_procfs(void); 
#endif /* CONFIG_PROC_FS */



/* scsi_scan.c */

extern char scsi_scan_type[];

extern int scsi_complete_async_scans(void);

extern int scsi_scan_host_selected(struct Scsi_Host *, unsigned int,

				   unsigned int, unsigned int, int);
@@ -166,6 +167,7 @@ static inline int scsi_autopm_get_host(struct Scsi_Host *h) { return 0; } 
static inline void scsi_autopm_put_host(struct Scsi_Host *h) {}

#endif /* CONFIG_PM_RUNTIME */



extern struct async_domain scsi_sd_pm_domain;

extern struct async_domain scsi_sd_probe_domain;



/*

drivers/scsi/scsi_scan.c

+1 −1
Original line number Diff line number Diff line
@@ -97,7 +97,7 @@ MODULE_PARM_DESC(max_luns, 
#define SCSI_SCAN_TYPE_DEFAULT "sync"

#endif



static char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;

char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;



module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);

MODULE_PARM_DESC(scan, "sync, async or none");