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

Commit 6c954667 authored by Lin Ming's avatar Lin Ming Committed by Jens Axboe
Browse files

block: add runtime pm helpers 

Add runtime pm helper functions:

void blk_pm_runtime_init(struct request_queue *q, struct device *dev)
  - Initialization function for drivers to call.

int blk_pre_runtime_suspend(struct request_queue *q)
  - If any requests are in the queue, mark last busy and return -EBUSY.
    Otherwise set q->rpm_status to RPM_SUSPENDING and return 0.

void blk_post_runtime_suspend(struct request_queue *q, int err)
  - If the suspend succeeded then set q->rpm_status to RPM_SUSPENDED.
    Otherwise set it to RPM_ACTIVE and mark last busy.

void blk_pre_runtime_resume(struct request_queue *q)
  - Set q->rpm_status to RPM_RESUMING.

void blk_post_runtime_resume(struct request_queue *q, int err)
  - If the resume succeeded then set q->rpm_status to RPM_ACTIVE
    and call __blk_run_queue, then mark last busy and autosuspend.
    Otherwise set q->rpm_status to RPM_SUSPENDED.

The idea and API is designed by Alan Stern and described here:
http://marc.info/?l=linux-scsi&m=133727953625963&w=2



Signed-off-by: default avatarLin Ming <ming.m.lin@intel.com>
Signed-off-by: default avatarAaron Lu <aaron.lu@intel.com>
Acked-by: default avatarAlan Stern <stern@rowland.harvard.edu>
Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 66311274

block/blk-core.c

+144 −0
Original line number Original line Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include <linux/list_sort.h>

#include <linux/list_sort.h>

#include <linux/delay.h>

#include <linux/delay.h>

#include <linux/ratelimit.h>

#include <linux/ratelimit.h>

#include <linux/pm_runtime.h>





#define CREATE_TRACE_POINTS

#define CREATE_TRACE_POINTS

#include <trace/events/block.h>

#include <trace/events/block.h>
@@ -3045,6 +3046,149 @@ void blk_finish_plug(struct blk_plug *plug) 
}

}

EXPORT_SYMBOL(blk_finish_plug);

EXPORT_SYMBOL(blk_finish_plug);





#ifdef CONFIG_PM_RUNTIME

/**

 * blk_pm_runtime_init - Block layer runtime PM initialization routine

 * @q: the queue of the device

 * @dev: the device the queue belongs to

 *

 * Description:

 *    Initialize runtime-PM-related fields for @q and start auto suspend for

 *    @dev. Drivers that want to take advantage of request-based runtime PM

 *    should call this function after @dev has been initialized, and its

 *    request queue @q has been allocated, and runtime PM for it can not happen

 *    yet(either due to disabled/forbidden or its usage_count > 0). In most

 *    cases, driver should call this function before any I/O has taken place.

 *

 *    This function takes care of setting up using auto suspend for the device,

 *    the autosuspend delay is set to -1 to make runtime suspend impossible

 *    until an updated value is either set by user or by driver. Drivers do

 *    not need to touch other autosuspend settings.

 *

 *    The block layer runtime PM is request based, so only works for drivers

 *    that use request as their IO unit instead of those directly use bio's.

 */

void blk_pm_runtime_init(struct request_queue *q, struct device *dev)

{

	q->dev = dev;

	q->rpm_status = RPM_ACTIVE;

	pm_runtime_set_autosuspend_delay(q->dev, -1);

	pm_runtime_use_autosuspend(q->dev);

}

EXPORT_SYMBOL(blk_pm_runtime_init);



/**

 * blk_pre_runtime_suspend - Pre runtime suspend check

 * @q: the queue of the device

 *

 * Description:

 *    This function will check if runtime suspend is allowed for the device

 *    by examining if there are any requests pending in the queue. If there

 *    are requests pending, the device can not be runtime suspended; otherwise,

 *    the queue's status will be updated to SUSPENDING and the driver can

 *    proceed to suspend the device.

 *

 *    For the not allowed case, we mark last busy for the device so that

 *    runtime PM core will try to autosuspend it some time later.

 *

 *    This function should be called near the start of the device's

 *    runtime_suspend callback.

 *

 * Return:

 *    0		- OK to runtime suspend the device

 *    -EBUSY	- Device should not be runtime suspended

 */

int blk_pre_runtime_suspend(struct request_queue *q)

{

	int ret = 0;



	spin_lock_irq(q->queue_lock);

	if (q->nr_pending) {

		ret = -EBUSY;

		pm_runtime_mark_last_busy(q->dev);

	} else {

		q->rpm_status = RPM_SUSPENDING;

	}

	spin_unlock_irq(q->queue_lock);

	return ret;

}

EXPORT_SYMBOL(blk_pre_runtime_suspend);



/**

 * blk_post_runtime_suspend - Post runtime suspend processing

 * @q: the queue of the device

 * @err: return value of the device's runtime_suspend function

 *

 * Description:

 *    Update the queue's runtime status according to the return value of the

 *    device's runtime suspend function and mark last busy for the device so

 *    that PM core will try to auto suspend the device at a later time.

 *

 *    This function should be called near the end of the device's

 *    runtime_suspend callback.

 */

void blk_post_runtime_suspend(struct request_queue *q, int err)

{

	spin_lock_irq(q->queue_lock);

	if (!err) {

		q->rpm_status = RPM_SUSPENDED;

	} else {

		q->rpm_status = RPM_ACTIVE;

		pm_runtime_mark_last_busy(q->dev);

	}

	spin_unlock_irq(q->queue_lock);

}

EXPORT_SYMBOL(blk_post_runtime_suspend);



/**

 * blk_pre_runtime_resume - Pre runtime resume processing

 * @q: the queue of the device

 *

 * Description:

 *    Update the queue's runtime status to RESUMING in preparation for the

 *    runtime resume of the device.

 *

 *    This function should be called near the start of the device's

 *    runtime_resume callback.

 */

void blk_pre_runtime_resume(struct request_queue *q)

{

	spin_lock_irq(q->queue_lock);

	q->rpm_status = RPM_RESUMING;

	spin_unlock_irq(q->queue_lock);

}

EXPORT_SYMBOL(blk_pre_runtime_resume);



/**

 * blk_post_runtime_resume - Post runtime resume processing

 * @q: the queue of the device

 * @err: return value of the device's runtime_resume function

 *

 * Description:

 *    Update the queue's runtime status according to the return value of the

 *    device's runtime_resume function. If it is successfully resumed, process

 *    the requests that are queued into the device's queue when it is resuming

 *    and then mark last busy and initiate autosuspend for it.

 *

 *    This function should be called near the end of the device's

 *    runtime_resume callback.

 */

void blk_post_runtime_resume(struct request_queue *q, int err)

{

	spin_lock_irq(q->queue_lock);

	if (!err) {

		q->rpm_status = RPM_ACTIVE;

		__blk_run_queue(q);

		pm_runtime_mark_last_busy(q->dev);

		pm_runtime_autosuspend(q->dev);

	} else {

		q->rpm_status = RPM_SUSPENDED;

	}

	spin_unlock_irq(q->queue_lock);

}

EXPORT_SYMBOL(blk_post_runtime_resume);

#endif



int __init blk_dev_init(void)

int __init blk_dev_init(void)

{

{

	BUILD_BUG_ON(__REQ_NR_BITS > 8 *

	BUILD_BUG_ON(__REQ_NR_BITS > 8 *

include/linux/blkdev.h

+27 −0
Original line number Original line Diff line number Diff line
@@ -361,6 +361,12 @@ struct request_queue { 
	 */

	 */

	struct kobject kobj;

	struct kobject kobj;





#ifdef CONFIG_PM_RUNTIME

	struct device		*dev;

	int			rpm_status;

	unsigned int		nr_pending;

#endif



	/*

	/*

	 * queue settings

	 * queue settings

	 */

	 */
@@ -960,6 +966,27 @@ struct request_queue *blk_alloc_queue(gfp_t); 
struct request_queue *blk_alloc_queue_node(gfp_t, int);

struct request_queue *blk_alloc_queue_node(gfp_t, int);

extern void blk_put_queue(struct request_queue *);

extern void blk_put_queue(struct request_queue *);





/*

 * block layer runtime pm functions

 */

#ifdef CONFIG_PM_RUNTIME

extern void blk_pm_runtime_init(struct request_queue *q, struct device *dev);

extern int blk_pre_runtime_suspend(struct request_queue *q);

extern void blk_post_runtime_suspend(struct request_queue *q, int err);

extern void blk_pre_runtime_resume(struct request_queue *q);

extern void blk_post_runtime_resume(struct request_queue *q, int err);

#else

static inline void blk_pm_runtime_init(struct request_queue *q,

	struct device *dev) {}

static inline int blk_pre_runtime_suspend(struct request_queue *q)

{

	return -ENOSYS;

}

static inline void blk_post_runtime_suspend(struct request_queue *q, int err) {}

static inline void blk_pre_runtime_resume(struct request_queue *q) {}

static inline void blk_post_runtime_resume(struct request_queue *q, int err) {}

#endif



/*

/*

 * blk_plug permits building a queue of related requests by holding the I/O

 * blk_plug permits building a queue of related requests by holding the I/O

 * fragments for a short period. This allows merging of sequential requests

 * fragments for a short period. This allows merging of sequential requests