renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-11-20 00:26:39 +08:00
Code

laptop-mode: Make flushes per-device

Browse Source 
One of the features of laptop-mode is that it forces a writeout of dirty
pages if something else triggers a physical read or write from a device.
The current implementation flushes pages on all devices, rather than only
the one that triggered the flush. This patch alters the behaviour so that
only the recently accessed block device is flushed, preventing other
disks being spun up for no terribly good reason.

Signed-off-by: Matthew Garrett <mjg@redhat.com>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
This commit is contained in:
Matthew Garrett 2010-04-06 14:25:14 +02:00 committed by Jens Axboe
parent 9195291e5f
commit 31373d09da
4 changed files with 30 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
block/blk-core.c
View File

@ -451,6 +451,7 @@ void blk_cleanup_queue(struct request_queue *q)
*/ */
blk_sync_queue(q); blk_sync_queue(q);
del_timer_sync(&q->backing_dev_info.laptop_mode_wb_timer);
mutex_lock(&q->sysfs_lock); mutex_lock(&q->sysfs_lock);
queue_flag_set_unlocked(QUEUE_FLAG_DEAD, q); queue_flag_set_unlocked(QUEUE_FLAG_DEAD, q);
mutex_unlock(&q->sysfs_lock); mutex_unlock(&q->sysfs_lock);
@ -511,6 +512,8 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
return NULL; return NULL;
} }
setup_timer(&q->backing_dev_info.laptop_mode_wb_timer,
laptop_mode_timer_fn, (unsigned long) q);
init_timer(&q->unplug_timer); init_timer(&q->unplug_timer);
setup_timer(&q->timeout, blk_rq_timed_out_timer, (unsigned long) q); setup_timer(&q->timeout, blk_rq_timed_out_timer, (unsigned long) q);
INIT_LIST_HEAD(&q->timeout_list); INIT_LIST_HEAD(&q->timeout_list);
@ -2101,7 +2104,7 @@ static void blk_finish_request(struct request *req, int error)
BUG_ON(blk_queued_rq(req)); BUG_ON(blk_queued_rq(req));
if (unlikely(laptop_mode) && blk_fs_request(req)) if (unlikely(laptop_mode) && blk_fs_request(req))
laptop_io_completion(); laptop_io_completion(&req->q->backing_dev_info);
blk_delete_timer(req); blk_delete_timer(req);

3
include/linux/backing-dev.h
View File

@ -14,6 +14,7 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/timer.h>
#include <linux/writeback.h> #include <linux/writeback.h>
#include <asm/atomic.h> #include <asm/atomic.h>
@ -88,6 +89,8 @@ struct backing_dev_info {
struct device *dev; struct device *dev;
struct timer_list laptop_mode_wb_timer;
#ifdef CONFIG_DEBUG_FS #ifdef CONFIG_DEBUG_FS
struct dentry *debug_dir; struct dentry *debug_dir;
struct dentry *debug_stats; struct dentry *debug_stats;

4
include/linux/writeback.h
View File

@ -96,8 +96,10 @@ static inline void inode_sync_wait(struct inode *inode)
/* /*
* mm/page-writeback.c * mm/page-writeback.c
*/ */
void laptop_io_completion(void); void laptop_io_completion(struct backing_dev_info *info);
void laptop_sync_completion(void); void laptop_sync_completion(void);
void laptop_mode_sync(struct work_struct *work);
void laptop_mode_timer_fn(unsigned long data);
void throttle_vm_writeout(gfp_t gfp_mask); void throttle_vm_writeout(gfp_t gfp_mask);
/* These are exported to sysctl. */ /* These are exported to sysctl. */

39
mm/page-writeback.c
View File

@ -683,10 +683,6 @@ void throttle_vm_writeout(gfp_t gfp_mask)
} }
} }
static void laptop_timer_fn(unsigned long unused);
static DEFINE_TIMER(laptop_mode_wb_timer, laptop_timer_fn, 0, 0);
/* /*
* sysctl handler for /proc/sys/vm/dirty_writeback_centisecs * sysctl handler for /proc/sys/vm/dirty_writeback_centisecs
*/ */
@ -697,21 +693,19 @@ int dirty_writeback_centisecs_handler(ctl_table *table, int write,
return 0; return 0;
} }
static void do_laptop_sync(struct work_struct *work) void laptop_mode_timer_fn(unsigned long data)
{ {
wakeup_flusher_threads(0); struct request_queue *q = (struct request_queue *)data;
kfree(work); int nr_pages = global_page_state(NR_FILE_DIRTY) +
} global_page_state(NR_UNSTABLE_NFS);
static void laptop_timer_fn(unsigned long unused) /*
{ * We want to write everything out, not just down to the dirty
struct work_struct *work; * threshold
*/
work = kmalloc(sizeof(*work), GFP_ATOMIC); if (bdi_has_dirty_io(&q->backing_dev_info))
if (work) { bdi_start_writeback(&q->backing_dev_info, NULL, nr_pages);
INIT_WORK(work, do_laptop_sync);
schedule_work(work);
}
} }
/* /*
@ -719,9 +713,9 @@ static void laptop_timer_fn(unsigned long unused)
* of all dirty data a few seconds from now. If the flush is already scheduled * of all dirty data a few seconds from now. If the flush is already scheduled
* then push it back - the user is still using the disk. * then push it back - the user is still using the disk.
*/ */
void laptop_io_completion(void) void laptop_io_completion(struct backing_dev_info *info)
{ {
mod_timer(&laptop_mode_wb_timer, jiffies + laptop_mode); mod_timer(&info->laptop_mode_wb_timer, jiffies + laptop_mode);
} }
/* /*
@ -731,7 +725,14 @@ void laptop_io_completion(void)
*/ */
void laptop_sync_completion(void) void laptop_sync_completion(void)
{ {
del_timer(&laptop_mode_wb_timer); struct backing_dev_info *bdi;
rcu_read_lock();
list_for_each_entry_rcu(bdi, &bdi_list, bdi_list)
del_timer(&bdi->laptop_mode_wb_timer);
rcu_read_unlock();
} }
/* /*