include/linux/writeback.h

   1 /*
   2  * include/linux/writeback.h
   3  */
   4 #ifndef WRITEBACK_H
   5 #define WRITEBACK_H
   6
   7 #include <linux/sched.h>
   8 #include <linux/fs.h>
   9
  10 /*
  11  * The 1/4 region under the global dirty thresh is for smooth dirty throttling:
  12  *
  13  *      (thresh - thresh/DIRTY_FULL_SCOPE, thresh)
  14  *
  15  * The 1/16 region above the global dirty limit will be put to maximum pauses:
  16  *
  17  *      (limit, limit + limit/DIRTY_MAXPAUSE_AREA)
  18  *
  19  * The 1/16 region above the max-pause region, dirty exceeded bdi's will be put
  20  * to loops:
  21  *
  22  *      (limit + limit/DIRTY_MAXPAUSE_AREA, limit + limit/DIRTY_PASSGOOD_AREA)
  23  *
  24  * Further beyond, all dirtier tasks will enter a loop waiting (possibly long
  25  * time) for the dirty pages to drop, unless written enough pages.
  26  *
  27  * The global dirty threshold is normally equal to the global dirty limit,
  28  * except when the system suddenly allocates a lot of anonymous memory and
  29  * knocks down the global dirty threshold quickly, in which case the global
  30  * dirty limit will follow down slowly to prevent livelocking all dirtier tasks.
  31  */
  32 #define DIRTY_SCOPE             8
  33 #define DIRTY_FULL_SCOPE        (DIRTY_SCOPE / 2)
  34 #define DIRTY_MAXPAUSE_AREA             16
  35 #define DIRTY_PASSGOOD_AREA             8
  36
  37 /*
  38  * 4MB minimal write chunk size
  39  */
  40 #define MIN_WRITEBACK_PAGES     (4096UL >> (PAGE_CACHE_SHIFT - 10))
  41
  42 struct backing_dev_info;
  43
  44 /*
  45  * fs/fs-writeback.c
  46  */
  47 enum writeback_sync_modes {
  48         WB_SYNC_NONE,   /* Don't wait on anything */
  49         WB_SYNC_ALL,    /* Wait on every mapping */
  50 };
  51
  52 /*
  53  * A control structure which tells the writeback code what to do.  These are
  54  * always on the stack, and hence need no locking.  They are always initialised
  55  * in a manner such that unspecified fields are set to zero.
  56  */
  57 struct writeback_control {
  58         enum writeback_sync_modes sync_mode;
  59         long nr_to_write;               /* Write this many pages, and decrement
  60                                            this for each page written */
  61         long pages_skipped;             /* Pages which were not written */
  62
  63         /*
  64          * For a_ops->writepages(): is start or end are non-zero then this is
  65          * a hint that the filesystem need only write out the pages inside that
  66          * byterange.  The byte at `end' is included in the writeout request.
  67          */
  68         loff_t range_start;
  69         loff_t range_end;
  70
  71         unsigned for_kupdate:1;         /* A kupdate writeback */
  72         unsigned for_background:1;      /* A background writeback */
  73         unsigned tagged_writepages:1;   /* tag-and-write to avoid livelock */
  74         unsigned for_reclaim:1;         /* Invoked from the page allocator */
  75         unsigned range_cyclic:1;        /* range_start is cyclic */
  76 };
  77
  78 /*
  79  * fs/fs-writeback.c
  80  */
  81 struct bdi_writeback;
  82 int inode_wait(void *);
  83 void writeback_inodes_sb(struct super_block *);
  84 void writeback_inodes_sb_nr(struct super_block *, unsigned long nr);
  85 int writeback_inodes_sb_if_idle(struct super_block *);
  86 int writeback_inodes_sb_nr_if_idle(struct super_block *, unsigned long nr);
  87 void sync_inodes_sb(struct super_block *);
  88 long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages);
  89 long wb_do_writeback(struct bdi_writeback *wb, int force_wait);
  90 void wakeup_flusher_threads(long nr_pages);
  91
  92 /* writeback.h requires fs.h; it, too, is not included from here. */
  93 static inline void wait_on_inode(struct inode *inode)
  94 {
  95         might_sleep();
  96         wait_on_bit(&inode->i_state, __I_NEW, inode_wait, TASK_UNINTERRUPTIBLE);
  97 }
  98 static inline void inode_sync_wait(struct inode *inode)
  99 {
 100         might_sleep();
 101         wait_on_bit(&inode->i_state, __I_SYNC, inode_wait,
 102                                                         TASK_UNINTERRUPTIBLE);
 103 }
 104
 105
 106 /*
 107  * mm/page-writeback.c
 108  */
 109 #ifdef CONFIG_BLOCK
 110 void laptop_io_completion(struct backing_dev_info *info);
 111 void laptop_sync_completion(void);
 112 void laptop_mode_sync(struct work_struct *work);
 113 void laptop_mode_timer_fn(unsigned long data);
 114 #else
 115 static inline void laptop_sync_completion(void) { }
 116 #endif
 117 void throttle_vm_writeout(gfp_t gfp_mask);
 118
 119 extern unsigned long global_dirty_limit;
 120
 121 /* These are exported to sysctl. */
 122 extern int dirty_background_ratio;
 123 extern unsigned long dirty_background_bytes;
 124 extern int vm_dirty_ratio;
 125 extern unsigned long vm_dirty_bytes;
 126 extern unsigned int dirty_writeback_interval;
 127 extern unsigned int dirty_expire_interval;
 128 extern int vm_highmem_is_dirtyable;
 129 extern int block_dump;
 130 extern int laptop_mode;
 131
 132 extern unsigned long determine_dirtyable_memory(void);
 133
 134 extern int dirty_background_ratio_handler(struct ctl_table *table, int write,
 135                 void __user *buffer, size_t *lenp,
 136                 loff_t *ppos);
 137 extern int dirty_background_bytes_handler(struct ctl_table *table, int write,
 138                 void __user *buffer, size_t *lenp,
 139                 loff_t *ppos);
 140 extern int dirty_ratio_handler(struct ctl_table *table, int write,
 141                 void __user *buffer, size_t *lenp,
 142                 loff_t *ppos);
 143 extern int dirty_bytes_handler(struct ctl_table *table, int write,
 144                 void __user *buffer, size_t *lenp,
 145                 loff_t *ppos);
 146
 147 struct ctl_table;
 148 int dirty_writeback_centisecs_handler(struct ctl_table *, int,
 149                                       void __user *, size_t *, loff_t *);
 150
 151 void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
 152 unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
 153                                unsigned long dirty);
 154
 155 void __bdi_update_bandwidth(struct backing_dev_info *bdi,
 156                             unsigned long thresh,
 157                             unsigned long dirty,
 158                             unsigned long bdi_thresh,
 159                             unsigned long bdi_dirty,
 160                             unsigned long start_time);
 161
 162 void page_writeback_init(void);
 163 void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
 164                                         unsigned long nr_pages_dirtied);
 165
 166 static inline void
 167 balance_dirty_pages_ratelimited(struct address_space *mapping)
 168 {
 169         balance_dirty_pages_ratelimited_nr(mapping, 1);
 170 }
 171
 172 typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
 173                                 void *data);
 174
 175 int generic_writepages(struct address_space *mapping,
 176                        struct writeback_control *wbc);
 177 void tag_pages_for_writeback(struct address_space *mapping,
 178                              pgoff_t start, pgoff_t end);
 179 int write_cache_pages(struct address_space *mapping,
 180                       struct writeback_control *wbc, writepage_t writepage,
 181                       void *data);
 182 int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
 183 void set_page_dirty_balance(struct page *page, int page_mkwrite);
 184 void writeback_set_ratelimit(void);
 185 void tag_pages_for_writeback(struct address_space *mapping,
 186                              pgoff_t start, pgoff_t end);
 187
 188 /* pdflush.c */
 189 extern int nr_pdflush_threads;  /* Global so it can be exported to sysctl
 190                                    read-only. */
 191
 192
 193 #endif          /* WRITEBACK_H */