lkml.org 
[lkml]   [2011]   [Feb]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v5 4/9] writeback: create dirty_info structure
    Date
    Bundle dirty limits and dirty memory usage metrics into a dirty_info
    structure to simplify interfaces of routines that need all.

    Signed-off-by: Greg Thelen <gthelen@google.com>
    Acked-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
    ---
    Changelog since v4:
    - Within new dirty_info structure, replaced nr_reclaimable with nr_file_dirty
    and nr_unstable_nfs to give callers finer grain dirty usage information.
    - Added new dirty_info_reclaimable() function.
    - Made more use of dirty_info structure in throttle_vm_writeout().

    Changelog since v3:
    - This is a new patch in v4.

    fs/fs-writeback.c | 7 ++---
    include/linux/writeback.h | 15 ++++++++++++-
    mm/backing-dev.c | 18 +++++++++------
    mm/page-writeback.c | 50 ++++++++++++++++++++++----------------------
    mm/vmstat.c | 6 +++-
    5 files changed, 57 insertions(+), 39 deletions(-)

    diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
    index 59c6e49..d75e4da 100644
    --- a/fs/fs-writeback.c
    +++ b/fs/fs-writeback.c
    @@ -595,12 +595,11 @@ static void __writeback_inodes_sb(struct super_block *sb,

    static inline bool over_bground_thresh(void)
    {
    - unsigned long background_thresh, dirty_thresh;
    + struct dirty_info info;

    - global_dirty_limits(&background_thresh, &dirty_thresh);
    + global_dirty_info(&info);

    - return (global_page_state(NR_FILE_DIRTY) +
    - global_page_state(NR_UNSTABLE_NFS) > background_thresh);
    + return dirty_info_reclaimable(&info) > info.background_thresh;
    }

    /*
    diff --git a/include/linux/writeback.h b/include/linux/writeback.h
    index 0ead399..a06fb38 100644
    --- a/include/linux/writeback.h
    +++ b/include/linux/writeback.h
    @@ -84,6 +84,19 @@ static inline void inode_sync_wait(struct inode *inode)
    /*
    * mm/page-writeback.c
    */
    +struct dirty_info {
    + unsigned long dirty_thresh;
    + unsigned long background_thresh;
    + unsigned long nr_file_dirty;
    + unsigned long nr_writeback;
    + unsigned long nr_unstable_nfs;
    +};
    +
    +static inline unsigned long dirty_info_reclaimable(struct dirty_info *info)
    +{
    + return info->nr_file_dirty + info->nr_unstable_nfs;
    +}
    +
    #ifdef CONFIG_BLOCK
    void laptop_io_completion(struct backing_dev_info *info);
    void laptop_sync_completion(void);
    @@ -124,7 +137,7 @@ struct ctl_table;
    int dirty_writeback_centisecs_handler(struct ctl_table *, int,
    void __user *, size_t *, loff_t *);

    -void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
    +void global_dirty_info(struct dirty_info *info);
    unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
    unsigned long dirty);

    diff --git a/mm/backing-dev.c b/mm/backing-dev.c
    index 027100d..17a06ab 100644
    --- a/mm/backing-dev.c
    +++ b/mm/backing-dev.c
    @@ -66,8 +66,7 @@ static int bdi_debug_stats_show(struct seq_file *m, void *v)
    {
    struct backing_dev_info *bdi = m->private;
    struct bdi_writeback *wb = &bdi->wb;
    - unsigned long background_thresh;
    - unsigned long dirty_thresh;
    + struct dirty_info dirty_info;
    unsigned long bdi_thresh;
    unsigned long nr_dirty, nr_io, nr_more_io, nr_wb;
    struct inode *inode;
    @@ -82,8 +81,8 @@ static int bdi_debug_stats_show(struct seq_file *m, void *v)
    nr_more_io++;
    spin_unlock(&inode_lock);

    - global_dirty_limits(&background_thresh, &dirty_thresh);
    - bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
    + global_dirty_info(&dirty_info);
    + bdi_thresh = bdi_dirty_limit(bdi, dirty_info.dirty_thresh);

    #define K(x) ((x) << (PAGE_SHIFT - 10))
    seq_printf(m,
    @@ -99,9 +98,14 @@ static int bdi_debug_stats_show(struct seq_file *m, void *v)
    "state: %8lx\n",
    (unsigned long) K(bdi_stat(bdi, BDI_WRITEBACK)),
    (unsigned long) K(bdi_stat(bdi, BDI_RECLAIMABLE)),
    - K(bdi_thresh), K(dirty_thresh),
    - K(background_thresh), nr_dirty, nr_io, nr_more_io,
    - !list_empty(&bdi->bdi_list), bdi->state);
    + K(bdi_thresh),
    + K(dirty_info.dirty_thresh),
    + K(dirty_info.background_thresh),
    + nr_dirty,
    + nr_io,
    + nr_more_io,
    + !list_empty(&bdi->bdi_list),
    + bdi->state);
    #undef K

    return 0;
    diff --git a/mm/page-writeback.c b/mm/page-writeback.c
    index 4408e54..00424b9 100644
    --- a/mm/page-writeback.c
    +++ b/mm/page-writeback.c
    @@ -398,7 +398,7 @@ unsigned long determine_dirtyable_memory(void)
    }

    /*
    - * global_dirty_limits - background-writeback and dirty-throttling thresholds
    + * global_dirty_info - return dirty thresholds and usage metrics
    *
    * Calculate the dirty thresholds based on sysctl parameters
    * - vm.dirty_background_ratio or vm.dirty_background_bytes
    @@ -406,7 +406,7 @@ unsigned long determine_dirtyable_memory(void)
    * The dirty limits will be lifted by 1/4 for PF_LESS_THROTTLE (ie. nfsd) and
    * real-time tasks.
    */
    -void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty)
    +void global_dirty_info(struct dirty_info *info)
    {
    unsigned long background;
    unsigned long dirty;
    @@ -426,6 +426,10 @@ void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty)
    else
    background = (dirty_background_ratio * available_memory) / 100;

    + info->nr_file_dirty = global_page_state(NR_FILE_DIRTY);
    + info->nr_writeback = global_page_state(NR_WRITEBACK);
    + info->nr_unstable_nfs = global_page_state(NR_UNSTABLE_NFS);
    +
    if (background >= dirty)
    background = dirty / 2;
    tsk = current;
    @@ -433,8 +437,8 @@ void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty)
    background += background / 4;
    dirty += dirty / 4;
    }
    - *pbackground = background;
    - *pdirty = dirty;
    + info->background_thresh = background;
    + info->dirty_thresh = dirty;
    }

    /*
    @@ -478,12 +482,9 @@ unsigned long bdi_dirty_limit(struct backing_dev_info *bdi, unsigned long dirty)
    static void balance_dirty_pages(struct address_space *mapping,
    unsigned long write_chunk)
    {
    - unsigned long nr_reclaimable;
    + struct dirty_info sys_info;
    long bdi_nr_reclaimable;
    - unsigned long nr_writeback;
    long bdi_nr_writeback;
    - unsigned long background_thresh;
    - unsigned long dirty_thresh;
    unsigned long bdi_thresh;
    unsigned long pages_written = 0;
    unsigned long pause = 1;
    @@ -498,22 +499,19 @@ static void balance_dirty_pages(struct address_space *mapping,
    .range_cyclic = 1,
    };

    - nr_reclaimable = global_page_state(NR_FILE_DIRTY) +
    - global_page_state(NR_UNSTABLE_NFS);
    - nr_writeback = global_page_state(NR_WRITEBACK);
    -
    - global_dirty_limits(&background_thresh, &dirty_thresh);
    + global_dirty_info(&sys_info);

    /*
    * Throttle it only when the background writeback cannot
    * catch-up. This avoids (excessively) small writeouts
    * when the bdi limits are ramping up.
    */
    - if (nr_reclaimable + nr_writeback <=
    - (background_thresh + dirty_thresh) / 2)
    + if (dirty_info_reclaimable(&sys_info) + sys_info.nr_writeback <=
    + (sys_info.background_thresh +
    + sys_info.dirty_thresh) / 2)
    break;

    - bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
    + bdi_thresh = bdi_dirty_limit(bdi, sys_info.dirty_thresh);
    bdi_thresh = task_dirty_limit(current, bdi_thresh);

    /*
    @@ -542,7 +540,8 @@ static void balance_dirty_pages(struct address_space *mapping,
    */
    dirty_exceeded =
    (bdi_nr_reclaimable + bdi_nr_writeback > bdi_thresh)
    - || (nr_reclaimable + nr_writeback > dirty_thresh);
    + || (dirty_info_reclaimable(&sys_info) +
    + sys_info.nr_writeback > sys_info.dirty_thresh);

    if (!dirty_exceeded)
    break;
    @@ -595,7 +594,8 @@ static void balance_dirty_pages(struct address_space *mapping,
    * background_thresh, to keep the amount of dirty memory low.
    */
    if ((laptop_mode && pages_written) ||
    - (!laptop_mode && (nr_reclaimable > background_thresh)))
    + (!laptop_mode && (dirty_info_reclaimable(&sys_info) >
    + sys_info.background_thresh)))
    bdi_start_background_writeback(bdi);
    }

    @@ -655,21 +655,21 @@ EXPORT_SYMBOL(balance_dirty_pages_ratelimited_nr);

    void throttle_vm_writeout(gfp_t gfp_mask)
    {
    - unsigned long background_thresh;
    - unsigned long dirty_thresh;
    + struct dirty_info sys_info;

    for ( ; ; ) {
    - global_dirty_limits(&background_thresh, &dirty_thresh);
    + global_dirty_info(&sys_info);

    /*
    * Boost the allowable dirty threshold a bit for page
    * allocators so they don't get DoS'ed by heavy writers
    */
    - dirty_thresh += dirty_thresh / 10; /* wheeee... */
    + sys_info.dirty_thresh +=
    + sys_info.dirty_thresh / 10; /* wheeee... */

    - if (global_page_state(NR_UNSTABLE_NFS) +
    - global_page_state(NR_WRITEBACK) <= dirty_thresh)
    - break;
    + if (sys_info.nr_unstable_nfs +
    + sys_info.nr_writeback <= sys_info.dirty_thresh)
    + break;
    congestion_wait(BLK_RW_ASYNC, HZ/10);

    /*
    diff --git a/mm/vmstat.c b/mm/vmstat.c
    index 0c3b504..ec95924 100644
    --- a/mm/vmstat.c
    +++ b/mm/vmstat.c
    @@ -1044,6 +1044,7 @@ static void *vmstat_start(struct seq_file *m, loff_t *pos)
    {
    unsigned long *v;
    int i, stat_items_size;
    + struct dirty_info dirty_info;

    if (*pos >= ARRAY_SIZE(vmstat_text))
    return NULL;
    @@ -1062,8 +1063,9 @@ static void *vmstat_start(struct seq_file *m, loff_t *pos)
    v[i] = global_page_state(i);
    v += NR_VM_ZONE_STAT_ITEMS;

    - global_dirty_limits(v + NR_DIRTY_BG_THRESHOLD,
    - v + NR_DIRTY_THRESHOLD);
    + global_dirty_info(&dirty_info);
    + v[NR_DIRTY_BG_THRESHOLD] = dirty_info.background_thresh;
    + v[NR_DIRTY_THRESHOLD] = dirty_info.dirty_thresh;
    v += NR_VM_WRITEBACK_STAT_ITEMS;

    #ifdef CONFIG_VM_EVENT_COUNTERS
    --
    1.7.3.1


    \
     
     \ /
      Last update: 2011-02-25 22:41    [W:0.033 / U:63.676 seconds]
    ©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site