include/linux/writeback.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * include/linux/writeback.h
   4  */
   5 #ifndef WRITEBACK_H
   6 #define WRITEBACK_H
   7
   8 #include <linux/sched.h>
   9 #include <linux/workqueue.h>
  10 #include <linux/fs.h>
  11 #include <linux/flex_proportions.h>
  12 #include <linux/backing-dev-defs.h>
  13 #include <linux/blk_types.h>
  14
  15 struct bio;
  16
  17 DECLARE_PER_CPU(int, dirty_throttle_leaks);
  18
  19 /*
  20  * The global dirty threshold is normally equal to the global dirty limit,
  21  * except when the system suddenly allocates a lot of anonymous memory and
  22  * knocks down the global dirty threshold quickly, in which case the global
  23  * dirty limit will follow down slowly to prevent livelocking all dirtier tasks.
  24  */
  25 #define DIRTY_SCOPE             8
  26
  27 struct backing_dev_info;
  28
  29 /*
  30  * fs/fs-writeback.c
  31  */
  32 enum writeback_sync_modes {
  33         WB_SYNC_NONE,   /* Don't wait on anything */
  34         WB_SYNC_ALL,    /* Wait on every mapping */
  35 };
  36
  37 /*
  38  * A control structure which tells the writeback code what to do.  These are
  39  * always on the stack, and hence need no locking.  They are always initialised
  40  * in a manner such that unspecified fields are set to zero.
  41  */
  42 struct writeback_control {
  43         long nr_to_write;               /* Write this many pages, and decrement
  44                                            this for each page written */
  45         long pages_skipped;             /* Pages which were not written */
  46
  47         /*
  48          * For a_ops->writepages(): if start or end are non-zero then this is
  49          * a hint that the filesystem need only write out the pages inside that
  50          * byterange.  The byte at `end' is included in the writeout request.
  51          */
  52         loff_t range_start;
  53         loff_t range_end;
  54
  55         enum writeback_sync_modes sync_mode;
  56
  57         unsigned for_kupdate:1;         /* A kupdate writeback */
  58         unsigned for_background:1;      /* A background writeback */
  59         unsigned tagged_writepages:1;   /* tag-and-write to avoid livelock */
  60         unsigned for_reclaim:1;         /* Invoked from the page allocator */
  61         unsigned range_cyclic:1;        /* range_start is cyclic */
  62         unsigned for_sync:1;            /* sync(2) WB_SYNC_ALL writeback */
  63         unsigned unpinned_fscache_wb:1; /* Cleared I_PINNING_FSCACHE_WB */
  64
  65         /*
  66          * When writeback IOs are bounced through async layers, only the
  67          * initial synchronous phase should be accounted towards inode
  68          * cgroup ownership arbitration to avoid confusion.  Later stages
  69          * can set the following flag to disable the accounting.
  70          */
  71         unsigned no_cgroup_owner:1;
  72
  73         unsigned punt_to_cgroup:1;      /* cgrp punting, see __REQ_CGROUP_PUNT */
  74
  75         /* To enable batching of swap writes to non-block-device backends,
  76          * "plug" can be set point to a 'struct swap_iocb *'.  When all swap
  77          * writes have been submitted, if with swap_iocb is not NULL,
  78          * swap_write_unplug() should be called.
  79          */
  80         struct swap_iocb **swap_plug;
  81
  82 #ifdef CONFIG_CGROUP_WRITEBACK
  83         struct bdi_writeback *wb;       /* wb this writeback is issued under */
  84         struct inode *inode;            /* inode being written out */
  85
  86         /* foreign inode detection, see wbc_detach_inode() */
  87         int wb_id;                      /* current wb id */
  88         int wb_lcand_id;                /* last foreign candidate wb id */
  89         int wb_tcand_id;                /* this foreign candidate wb id */
  90         size_t wb_bytes;                /* bytes written by current wb */
  91         size_t wb_lcand_bytes;          /* bytes written by last candidate */
  92         size_t wb_tcand_bytes;          /* bytes written by this candidate */
  93 #endif
  94 };
  95
  96 static inline blk_opf_t wbc_to_write_flags(struct writeback_control *wbc)
  97 {
  98         blk_opf_t flags = 0;
  99
 100         if (wbc->punt_to_cgroup)
 101                 flags = REQ_CGROUP_PUNT;
 102
 103         if (wbc->sync_mode == WB_SYNC_ALL)
 104                 flags |= REQ_SYNC;
 105         else if (wbc->for_kupdate || wbc->for_background)
 106                 flags |= REQ_BACKGROUND;
 107
 108         return flags;
 109 }
 110
 111 #ifdef CONFIG_CGROUP_WRITEBACK
 112 #define wbc_blkcg_css(wbc) \
 113         ((wbc)->wb ? (wbc)->wb->blkcg_css : blkcg_root_css)
 114 #else
 115 #define wbc_blkcg_css(wbc)              (blkcg_root_css)
 116 #endif /* CONFIG_CGROUP_WRITEBACK */
 117
 118 /*
 119  * A wb_domain represents a domain that wb's (bdi_writeback's) belong to
 120  * and are measured against each other in.  There always is one global
 121  * domain, global_wb_domain, that every wb in the system is a member of.
 122  * This allows measuring the relative bandwidth of each wb to distribute
 123  * dirtyable memory accordingly.
 124  */
 125 struct wb_domain {
 126         spinlock_t lock;
 127
 128         /*
 129          * Scale the writeback cache size proportional to the relative
 130          * writeout speed.
 131          *
 132          * We do this by keeping a floating proportion between BDIs, based
 133          * on page writeback completions [end_page_writeback()]. Those
 134          * devices that write out pages fastest will get the larger share,
 135          * while the slower will get a smaller share.
 136          *
 137          * We use page writeout completions because we are interested in
 138          * getting rid of dirty pages. Having them written out is the
 139          * primary goal.
 140          *
 141          * We introduce a concept of time, a period over which we measure
 142          * these events, because demand can/will vary over time. The length
 143          * of this period itself is measured in page writeback completions.
 144          */
 145         struct fprop_global completions;
 146         struct timer_list period_timer; /* timer for aging of completions */
 147         unsigned long period_time;
 148
 149         /*
 150          * The dirtyable memory and dirty threshold could be suddenly
 151          * knocked down by a large amount (eg. on the startup of KVM in a
 152          * swapless system). This may throw the system into deep dirty
 153          * exceeded state and throttle heavy/light dirtiers alike. To
 154          * retain good responsiveness, maintain global_dirty_limit for
 155          * tracking slowly down to the knocked down dirty threshold.
 156          *
 157          * Both fields are protected by ->lock.
 158          */
 159         unsigned long dirty_limit_tstamp;
 160         unsigned long dirty_limit;
 161 };
 162
 163 /**
 164  * wb_domain_size_changed - memory available to a wb_domain has changed
 165  * @dom: wb_domain of interest
 166  *
 167  * This function should be called when the amount of memory available to
 168  * @dom has changed.  It resets @dom's dirty limit parameters to prevent
 169  * the past values which don't match the current configuration from skewing
 170  * dirty throttling.  Without this, when memory size of a wb_domain is
 171  * greatly reduced, the dirty throttling logic may allow too many pages to
 172  * be dirtied leading to consecutive unnecessary OOMs and may get stuck in
 173  * that situation.
 174  */
 175 static inline void wb_domain_size_changed(struct wb_domain *dom)
 176 {
 177         spin_lock(&dom->lock);
 178         dom->dirty_limit_tstamp = jiffies;
 179         dom->dirty_limit = 0;
 180         spin_unlock(&dom->lock);
 181 }
 182
 183 /*
 184  * fs/fs-writeback.c
 185  */
 186 struct bdi_writeback;
 187 void writeback_inodes_sb(struct super_block *, enum wb_reason reason);
 188 void writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
 189                                                         enum wb_reason reason);
 190 void try_to_writeback_inodes_sb(struct super_block *sb, enum wb_reason reason);
 191 void sync_inodes_sb(struct super_block *);
 192 void wakeup_flusher_threads(enum wb_reason reason);
 193 void wakeup_flusher_threads_bdi(struct backing_dev_info *bdi,
 194                                 enum wb_reason reason);
 195 void inode_wait_for_writeback(struct inode *inode);
 196 void inode_io_list_del(struct inode *inode);
 197
 198 /* writeback.h requires fs.h; it, too, is not included from here. */
 199 static inline void wait_on_inode(struct inode *inode)
 200 {
 201         might_sleep();
 202         wait_on_bit(&inode->i_state, __I_NEW, TASK_UNINTERRUPTIBLE);
 203 }
 204
 205 #ifdef CONFIG_CGROUP_WRITEBACK
 206
 207 #include <linux/cgroup.h>
 208 #include <linux/bio.h>
 209
 210 void __inode_attach_wb(struct inode *inode, struct page *page);
 211 void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
 212                                  struct inode *inode)
 213         __releases(&inode->i_lock);
 214 void wbc_detach_inode(struct writeback_control *wbc);
 215 void wbc_account_cgroup_owner(struct writeback_control *wbc, struct page *page,
 216                               size_t bytes);
 217 int cgroup_writeback_by_id(u64 bdi_id, int memcg_id,
 218                            enum wb_reason reason, struct wb_completion *done);
 219 void cgroup_writeback_umount(void);
 220 bool cleanup_offline_cgwb(struct bdi_writeback *wb);
 221
 222 /**
 223  * inode_attach_wb - associate an inode with its wb
 224  * @inode: inode of interest
 225  * @page: page being dirtied (may be NULL)
 226  *
 227  * If @inode doesn't have its wb, associate it with the wb matching the
 228  * memcg of @page or, if @page is NULL, %current.  May be called w/ or w/o
 229  * @inode->i_lock.
 230  */
 231 static inline void inode_attach_wb(struct inode *inode, struct page *page)
 232 {
 233         if (!inode->i_wb)
 234                 __inode_attach_wb(inode, page);
 235 }
 236
 237 /**
 238  * inode_detach_wb - disassociate an inode from its wb
 239  * @inode: inode of interest
 240  *
 241  * @inode is being freed.  Detach from its wb.
 242  */
 243 static inline void inode_detach_wb(struct inode *inode)
 244 {
 245         if (inode->i_wb) {
 246                 WARN_ON_ONCE(!(inode->i_state & I_CLEAR));
 247                 wb_put(inode->i_wb);
 248                 inode->i_wb = NULL;
 249         }
 250 }
 251
 252 /**
 253  * wbc_attach_fdatawrite_inode - associate wbc and inode for fdatawrite
 254  * @wbc: writeback_control of interest
 255  * @inode: target inode
 256  *
 257  * This function is to be used by __filemap_fdatawrite_range(), which is an
 258  * alternative entry point into writeback code, and first ensures @inode is
 259  * associated with a bdi_writeback and attaches it to @wbc.
 260  */
 261 static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
 262                                                struct inode *inode)
 263 {
 264         spin_lock(&inode->i_lock);
 265         inode_attach_wb(inode, NULL);
 266         wbc_attach_and_unlock_inode(wbc, inode);
 267 }
 268
 269 /**
 270  * wbc_init_bio - writeback specific initializtion of bio
 271  * @wbc: writeback_control for the writeback in progress
 272  * @bio: bio to be initialized
 273  *
 274  * @bio is a part of the writeback in progress controlled by @wbc.  Perform
 275  * writeback specific initialization.  This is used to apply the cgroup
 276  * writeback context.  Must be called after the bio has been associated with
 277  * a device.
 278  */
 279 static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
 280 {
 281         /*
 282          * pageout() path doesn't attach @wbc to the inode being written
 283          * out.  This is intentional as we don't want the function to block
 284          * behind a slow cgroup.  Ultimately, we want pageout() to kick off
 285          * regular writeback instead of writing things out itself.
 286          */
 287         if (wbc->wb)
 288                 bio_associate_blkg_from_css(bio, wbc->wb->blkcg_css);
 289 }
 290
 291 #else   /* CONFIG_CGROUP_WRITEBACK */
 292
 293 static inline void inode_attach_wb(struct inode *inode, struct page *page)
 294 {
 295 }
 296
 297 static inline void inode_detach_wb(struct inode *inode)
 298 {
 299 }
 300
 301 static inline void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
 302                                                struct inode *inode)
 303         __releases(&inode->i_lock)
 304 {
 305         spin_unlock(&inode->i_lock);
 306 }
 307
 308 static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
 309                                                struct inode *inode)
 310 {
 311 }
 312
 313 static inline void wbc_detach_inode(struct writeback_control *wbc)
 314 {
 315 }
 316
 317 static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
 318 {
 319 }
 320
 321 static inline void wbc_account_cgroup_owner(struct writeback_control *wbc,
 322                                             struct page *page, size_t bytes)
 323 {
 324 }
 325
 326 static inline void cgroup_writeback_umount(void)
 327 {
 328 }
 329
 330 #endif  /* CONFIG_CGROUP_WRITEBACK */
 331
 332 /*
 333  * mm/page-writeback.c
 334  */
 335 void laptop_io_completion(struct backing_dev_info *info);
 336 void laptop_sync_completion(void);
 337 void laptop_mode_timer_fn(struct timer_list *t);
 338 bool node_dirty_ok(struct pglist_data *pgdat);
 339 int wb_domain_init(struct wb_domain *dom, gfp_t gfp);
 340 #ifdef CONFIG_CGROUP_WRITEBACK
 341 void wb_domain_exit(struct wb_domain *dom);
 342 #endif
 343
 344 extern struct wb_domain global_wb_domain;
 345
 346 /* These are exported to sysctl. */
 347 extern unsigned int dirty_writeback_interval;
 348 extern unsigned int dirty_expire_interval;
 349 extern unsigned int dirtytime_expire_interval;
 350 extern int laptop_mode;
 351
 352 int dirtytime_interval_handler(struct ctl_table *table, int write,
 353                 void *buffer, size_t *lenp, loff_t *ppos);
 354
 355 void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
 356 unsigned long wb_calc_thresh(struct bdi_writeback *wb, unsigned long thresh);
 357
 358 void wb_update_bandwidth(struct bdi_writeback *wb);
 359
 360 /* Invoke balance dirty pages in async mode. */
 361 #define BDP_ASYNC 0x0001
 362
 363 void balance_dirty_pages_ratelimited(struct address_space *mapping);
 364 int balance_dirty_pages_ratelimited_flags(struct address_space *mapping,
 365                 unsigned int flags);
 366
 367 bool wb_over_bg_thresh(struct bdi_writeback *wb);
 368
 369 typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
 370                                 void *data);
 371
 372 int generic_writepages(struct address_space *mapping,
 373                        struct writeback_control *wbc);
 374 void tag_pages_for_writeback(struct address_space *mapping,
 375                              pgoff_t start, pgoff_t end);
 376 int write_cache_pages(struct address_space *mapping,
 377                       struct writeback_control *wbc, writepage_t writepage,
 378                       void *data);
 379 int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
 380 void writeback_set_ratelimit(void);
 381 void tag_pages_for_writeback(struct address_space *mapping,
 382                              pgoff_t start, pgoff_t end);
 383
 384 bool filemap_dirty_folio(struct address_space *mapping, struct folio *folio);
 385 void folio_account_redirty(struct folio *folio);
 386 static inline void account_page_redirty(struct page *page)
 387 {
 388         folio_account_redirty(page_folio(page));
 389 }
 390 bool folio_redirty_for_writepage(struct writeback_control *, struct folio *);
 391 bool redirty_page_for_writepage(struct writeback_control *, struct page *);
 392
 393 void sb_mark_inode_writeback(struct inode *inode);
 394 void sb_clear_inode_writeback(struct inode *inode);
 395
 396 #endif          /* WRITEBACK_H */