include/linux/backing-dev.h

   1 /*
   2  * include/linux/backing-dev.h
   3  *
   4  * low-level device information and state which is propagated up through
   5  * to high-level code.
   6  */
   7
   8 #ifndef _LINUX_BACKING_DEV_H
   9 #define _LINUX_BACKING_DEV_H
  10
  11 #include <linux/kernel.h>
  12 #include <linux/fs.h>
  13 #include <linux/sched.h>
  14 #include <linux/blkdev.h>
  15 #include <linux/writeback.h>
  16 #include <linux/blk-cgroup.h>
  17 #include <linux/backing-dev-defs.h>
  18 #include <linux/slab.h>
  19
  20 int __must_check bdi_init(struct backing_dev_info *bdi);
  21
  22 static inline struct backing_dev_info *bdi_get(struct backing_dev_info *bdi)
  23 {
  24         kref_get(&bdi->refcnt);
  25         return bdi;
  26 }
  27
  28 void bdi_put(struct backing_dev_info *bdi);
  29
  30 __printf(3, 4)
  31 int bdi_register(struct backing_dev_info *bdi, struct device *parent,
  32                 const char *fmt, ...);
  33 int bdi_register_va(struct backing_dev_info *bdi, struct device *parent,
  34                 const char *fmt, va_list args);
  35 int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
  36 int bdi_register_owner(struct backing_dev_info *bdi, struct device *owner);
  37 void bdi_unregister(struct backing_dev_info *bdi);
  38
  39 int __must_check bdi_setup_and_register(struct backing_dev_info *, char *);
  40 void bdi_destroy(struct backing_dev_info *bdi);
  41 struct backing_dev_info *bdi_alloc_node(gfp_t gfp_mask, int node_id);
  42 static inline struct backing_dev_info *bdi_alloc(gfp_t gfp_mask)
  43 {
  44         return bdi_alloc_node(gfp_mask, NUMA_NO_NODE);
  45 }
  46
  47 void wb_start_writeback(struct bdi_writeback *wb, long nr_pages,
  48                         bool range_cyclic, enum wb_reason reason);
  49 void wb_start_background_writeback(struct bdi_writeback *wb);
  50 void wb_workfn(struct work_struct *work);
  51 void wb_wakeup_delayed(struct bdi_writeback *wb);
  52
  53 extern spinlock_t bdi_lock;
  54 extern struct list_head bdi_list;
  55
  56 extern struct workqueue_struct *bdi_wq;
  57
  58 static inline bool wb_has_dirty_io(struct bdi_writeback *wb)
  59 {
  60         return test_bit(WB_has_dirty_io, &wb->state);
  61 }
  62
  63 static inline bool bdi_has_dirty_io(struct backing_dev_info *bdi)
  64 {
  65         /*
  66          * @bdi->tot_write_bandwidth is guaranteed to be > 0 if there are
  67          * any dirty wbs.  See wb_update_write_bandwidth().
  68          */
  69         return atomic_long_read(&bdi->tot_write_bandwidth);
  70 }
  71
  72 static inline void __add_wb_stat(struct bdi_writeback *wb,
  73                                  enum wb_stat_item item, s64 amount)
  74 {
  75         __percpu_counter_add(&wb->stat[item], amount, WB_STAT_BATCH);
  76 }
  77
  78 static inline void __inc_wb_stat(struct bdi_writeback *wb,
  79                                  enum wb_stat_item item)
  80 {
  81         __add_wb_stat(wb, item, 1);
  82 }
  83
  84 static inline void inc_wb_stat(struct bdi_writeback *wb, enum wb_stat_item item)
  85 {
  86         unsigned long flags;
  87
  88         local_irq_save(flags);
  89         __inc_wb_stat(wb, item);
  90         local_irq_restore(flags);
  91 }
  92
  93 static inline void __dec_wb_stat(struct bdi_writeback *wb,
  94                                  enum wb_stat_item item)
  95 {
  96         __add_wb_stat(wb, item, -1);
  97 }
  98
  99 static inline void dec_wb_stat(struct bdi_writeback *wb, enum wb_stat_item item)
 100 {
 101         unsigned long flags;
 102
 103         local_irq_save(flags);
 104         __dec_wb_stat(wb, item);
 105         local_irq_restore(flags);
 106 }
 107
 108 static inline s64 wb_stat(struct bdi_writeback *wb, enum wb_stat_item item)
 109 {
 110         return percpu_counter_read_positive(&wb->stat[item]);
 111 }
 112
 113 static inline s64 __wb_stat_sum(struct bdi_writeback *wb,
 114                                 enum wb_stat_item item)
 115 {
 116         return percpu_counter_sum_positive(&wb->stat[item]);
 117 }
 118
 119 static inline s64 wb_stat_sum(struct bdi_writeback *wb, enum wb_stat_item item)
 120 {
 121         s64 sum;
 122         unsigned long flags;
 123
 124         local_irq_save(flags);
 125         sum = __wb_stat_sum(wb, item);
 126         local_irq_restore(flags);
 127
 128         return sum;
 129 }
 130
 131 extern void wb_writeout_inc(struct bdi_writeback *wb);
 132
 133 /*
 134  * maximal error of a stat counter.
 135  */
 136 static inline unsigned long wb_stat_error(struct bdi_writeback *wb)
 137 {
 138 #ifdef CONFIG_SMP
 139         return nr_cpu_ids * WB_STAT_BATCH;
 140 #else
 141         return 1;
 142 #endif
 143 }
 144
 145 int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio);
 146 int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
 147
 148 /*
 149  * Flags in backing_dev_info::capability
 150  *
 151  * The first three flags control whether dirty pages will contribute to the
 152  * VM's accounting and whether writepages() should be called for dirty pages
 153  * (something that would not, for example, be appropriate for ramfs)
 154  *
 155  * WARNING: these flags are closely related and should not normally be
 156  * used separately.  The BDI_CAP_NO_ACCT_AND_WRITEBACK combines these
 157  * three flags into a single convenience macro.
 158  *
 159  * BDI_CAP_NO_ACCT_DIRTY:  Dirty pages shouldn't contribute to accounting
 160  * BDI_CAP_NO_WRITEBACK:   Don't write pages back
 161  * BDI_CAP_NO_ACCT_WB:     Don't automatically account writeback pages
 162  * BDI_CAP_STRICTLIMIT:    Keep number of dirty pages below bdi threshold.
 163  *
 164  * BDI_CAP_CGROUP_WRITEBACK: Supports cgroup-aware writeback.
 165  */
 166 #define BDI_CAP_NO_ACCT_DIRTY   0x00000001
 167 #define BDI_CAP_NO_WRITEBACK    0x00000002
 168 #define BDI_CAP_NO_ACCT_WB      0x00000004
 169 #define BDI_CAP_STABLE_WRITES   0x00000008
 170 #define BDI_CAP_STRICTLIMIT     0x00000010
 171 #define BDI_CAP_CGROUP_WRITEBACK 0x00000020
 172
 173 #define BDI_CAP_NO_ACCT_AND_WRITEBACK \
 174         (BDI_CAP_NO_WRITEBACK | BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_ACCT_WB)
 175
 176 extern struct backing_dev_info noop_backing_dev_info;
 177
 178 /**
 179  * writeback_in_progress - determine whether there is writeback in progress
 180  * @wb: bdi_writeback of interest
 181  *
 182  * Determine whether there is writeback waiting to be handled against a
 183  * bdi_writeback.
 184  */
 185 static inline bool writeback_in_progress(struct bdi_writeback *wb)
 186 {
 187         return test_bit(WB_writeback_running, &wb->state);
 188 }
 189
 190 static inline struct backing_dev_info *inode_to_bdi(struct inode *inode)
 191 {
 192         struct super_block *sb;
 193
 194         if (!inode)
 195                 return &noop_backing_dev_info;
 196
 197         sb = inode->i_sb;
 198 #ifdef CONFIG_BLOCK
 199         if (sb_is_blkdev_sb(sb))
 200                 return I_BDEV(inode)->bd_bdi;
 201 #endif
 202         return sb->s_bdi;
 203 }
 204
 205 static inline int wb_congested(struct bdi_writeback *wb, int cong_bits)
 206 {
 207         struct backing_dev_info *bdi = wb->bdi;
 208
 209         if (bdi->congested_fn)
 210                 return bdi->congested_fn(bdi->congested_data, cong_bits);
 211         return wb->congested->state & cong_bits;
 212 }
 213
 214 long congestion_wait(int sync, long timeout);
 215 long wait_iff_congested(struct pglist_data *pgdat, int sync, long timeout);
 216 int pdflush_proc_obsolete(struct ctl_table *table, int write,
 217                 void __user *buffer, size_t *lenp, loff_t *ppos);
 218
 219 static inline bool bdi_cap_stable_pages_required(struct backing_dev_info *bdi)
 220 {
 221         return bdi->capabilities & BDI_CAP_STABLE_WRITES;
 222 }
 223
 224 static inline bool bdi_cap_writeback_dirty(struct backing_dev_info *bdi)
 225 {
 226         return !(bdi->capabilities & BDI_CAP_NO_WRITEBACK);
 227 }
 228
 229 static inline bool bdi_cap_account_dirty(struct backing_dev_info *bdi)
 230 {
 231         return !(bdi->capabilities & BDI_CAP_NO_ACCT_DIRTY);
 232 }
 233
 234 static inline bool bdi_cap_account_writeback(struct backing_dev_info *bdi)
 235 {
 236         /* Paranoia: BDI_CAP_NO_WRITEBACK implies BDI_CAP_NO_ACCT_WB */
 237         return !(bdi->capabilities & (BDI_CAP_NO_ACCT_WB |
 238                                       BDI_CAP_NO_WRITEBACK));
 239 }
 240
 241 static inline bool mapping_cap_writeback_dirty(struct address_space *mapping)
 242 {
 243         return bdi_cap_writeback_dirty(inode_to_bdi(mapping->host));
 244 }
 245
 246 static inline bool mapping_cap_account_dirty(struct address_space *mapping)
 247 {
 248         return bdi_cap_account_dirty(inode_to_bdi(mapping->host));
 249 }
 250
 251 static inline int bdi_sched_wait(void *word)
 252 {
 253         schedule();
 254         return 0;
 255 }
 256
 257 #ifdef CONFIG_CGROUP_WRITEBACK
 258
 259 struct bdi_writeback_congested *
 260 wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp);
 261 void wb_congested_put(struct bdi_writeback_congested *congested);
 262 struct bdi_writeback *wb_get_create(struct backing_dev_info *bdi,
 263                                     struct cgroup_subsys_state *memcg_css,
 264                                     gfp_t gfp);
 265 void wb_memcg_offline(struct mem_cgroup *memcg);
 266 void wb_blkcg_offline(struct blkcg *blkcg);
 267 int inode_congested(struct inode *inode, int cong_bits);
 268
 269 /**
 270  * inode_cgwb_enabled - test whether cgroup writeback is enabled on an inode
 271  * @inode: inode of interest
 272  *
 273  * cgroup writeback requires support from both the bdi and filesystem.
 274  * Also, both memcg and iocg have to be on the default hierarchy.  Test
 275  * whether all conditions are met.
 276  *
 277  * Note that the test result may change dynamically on the same inode
 278  * depending on how memcg and iocg are configured.
 279  */
 280 static inline bool inode_cgwb_enabled(struct inode *inode)
 281 {
 282         struct backing_dev_info *bdi = inode_to_bdi(inode);
 283
 284         return cgroup_subsys_on_dfl(memory_cgrp_subsys) &&
 285                 cgroup_subsys_on_dfl(io_cgrp_subsys) &&
 286                 bdi_cap_account_dirty(bdi) &&
 287                 (bdi->capabilities & BDI_CAP_CGROUP_WRITEBACK) &&
 288                 (inode->i_sb->s_iflags & SB_I_CGROUPWB);
 289 }
 290
 291 /**
 292  * wb_find_current - find wb for %current on a bdi
 293  * @bdi: bdi of interest
 294  *
 295  * Find the wb of @bdi which matches both the memcg and blkcg of %current.
 296  * Must be called under rcu_read_lock() which protects the returend wb.
 297  * NULL if not found.
 298  */
 299 static inline struct bdi_writeback *wb_find_current(struct backing_dev_info *bdi)
 300 {
 301         struct cgroup_subsys_state *memcg_css;
 302         struct bdi_writeback *wb;
 303
 304         memcg_css = task_css(current, memory_cgrp_id);
 305         if (!memcg_css->parent)
 306                 return &bdi->wb;
 307
 308         wb = radix_tree_lookup(&bdi->cgwb_tree, memcg_css->id);
 309
 310         /*
 311          * %current's blkcg equals the effective blkcg of its memcg.  No
 312          * need to use the relatively expensive cgroup_get_e_css().
 313          */
 314         if (likely(wb && wb->blkcg_css == task_css(current, io_cgrp_id)))
 315                 return wb;
 316         return NULL;
 317 }
 318
 319 /**
 320  * wb_get_create_current - get or create wb for %current on a bdi
 321  * @bdi: bdi of interest
 322  * @gfp: allocation mask
 323  *
 324  * Equivalent to wb_get_create() on %current's memcg.  This function is
 325  * called from a relatively hot path and optimizes the common cases using
 326  * wb_find_current().
 327  */
 328 static inline struct bdi_writeback *
 329 wb_get_create_current(struct backing_dev_info *bdi, gfp_t gfp)
 330 {
 331         struct bdi_writeback *wb;
 332
 333         rcu_read_lock();
 334         wb = wb_find_current(bdi);
 335         if (wb && unlikely(!wb_tryget(wb)))
 336                 wb = NULL;
 337         rcu_read_unlock();
 338
 339         if (unlikely(!wb)) {
 340                 struct cgroup_subsys_state *memcg_css;
 341
 342                 memcg_css = task_get_css(current, memory_cgrp_id);
 343                 wb = wb_get_create(bdi, memcg_css, gfp);
 344                 css_put(memcg_css);
 345         }
 346         return wb;
 347 }
 348
 349 /**
 350  * inode_to_wb_is_valid - test whether an inode has a wb associated
 351  * @inode: inode of interest
 352  *
 353  * Returns %true if @inode has a wb associated.  May be called without any
 354  * locking.
 355  */
 356 static inline bool inode_to_wb_is_valid(struct inode *inode)
 357 {
 358         return inode->i_wb;
 359 }
 360
 361 /**
 362  * inode_to_wb - determine the wb of an inode
 363  * @inode: inode of interest
 364  *
 365  * Returns the wb @inode is currently associated with.  The caller must be
 366  * holding either @inode->i_lock, @inode->i_mapping->tree_lock, or the
 367  * associated wb's list_lock.
 368  */
 369 static inline struct bdi_writeback *inode_to_wb(struct inode *inode)
 370 {
 371 #ifdef CONFIG_LOCKDEP
 372         WARN_ON_ONCE(debug_locks &&
 373                      (!lockdep_is_held(&inode->i_lock) &&
 374                       !lockdep_is_held(&inode->i_mapping->tree_lock) &&
 375                       !lockdep_is_held(&inode->i_wb->list_lock)));
 376 #endif
 377         return inode->i_wb;
 378 }
 379
 380 /**
 381  * unlocked_inode_to_wb_begin - begin unlocked inode wb access transaction
 382  * @inode: target inode
 383  * @lockedp: temp bool output param, to be passed to the end function
 384  *
 385  * The caller wants to access the wb associated with @inode but isn't
 386  * holding inode->i_lock, mapping->tree_lock or wb->list_lock.  This
 387  * function determines the wb associated with @inode and ensures that the
 388  * association doesn't change until the transaction is finished with
 389  * unlocked_inode_to_wb_end().
 390  *
 391  * The caller must call unlocked_inode_to_wb_end() with *@lockdep
 392  * afterwards and can't sleep during transaction.  IRQ may or may not be
 393  * disabled on return.
 394  */
 395 static inline struct bdi_writeback *
 396 unlocked_inode_to_wb_begin(struct inode *inode, bool *lockedp)
 397 {
 398         rcu_read_lock();
 399
 400         /*
 401          * Paired with store_release in inode_switch_wb_work_fn() and
 402          * ensures that we see the new wb if we see cleared I_WB_SWITCH.
 403          */
 404         *lockedp = smp_load_acquire(&inode->i_state) & I_WB_SWITCH;
 405
 406         if (unlikely(*lockedp))
 407                 spin_lock_irq(&inode->i_mapping->tree_lock);
 408
 409         /*
 410          * Protected by either !I_WB_SWITCH + rcu_read_lock() or tree_lock.
 411          * inode_to_wb() will bark.  Deref directly.
 412          */
 413         return inode->i_wb;
 414 }
 415
 416 /**
 417  * unlocked_inode_to_wb_end - end inode wb access transaction
 418  * @inode: target inode
 419  * @locked: *@lockedp from unlocked_inode_to_wb_begin()
 420  */
 421 static inline void unlocked_inode_to_wb_end(struct inode *inode, bool locked)
 422 {
 423         if (unlikely(locked))
 424                 spin_unlock_irq(&inode->i_mapping->tree_lock);
 425
 426         rcu_read_unlock();
 427 }
 428
 429 #else   /* CONFIG_CGROUP_WRITEBACK */
 430
 431 static inline bool inode_cgwb_enabled(struct inode *inode)
 432 {
 433         return false;
 434 }
 435
 436 static inline struct bdi_writeback_congested *
 437 wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp)
 438 {
 439         atomic_inc(&bdi->wb_congested->refcnt);
 440         return bdi->wb_congested;
 441 }
 442
 443 static inline void wb_congested_put(struct bdi_writeback_congested *congested)
 444 {
 445         if (atomic_dec_and_test(&congested->refcnt))
 446                 kfree(congested);
 447 }
 448
 449 static inline struct bdi_writeback *wb_find_current(struct backing_dev_info *bdi)
 450 {
 451         return &bdi->wb;
 452 }
 453
 454 static inline struct bdi_writeback *
 455 wb_get_create_current(struct backing_dev_info *bdi, gfp_t gfp)
 456 {
 457         return &bdi->wb;
 458 }
 459
 460 static inline bool inode_to_wb_is_valid(struct inode *inode)
 461 {
 462         return true;
 463 }
 464
 465 static inline struct bdi_writeback *inode_to_wb(struct inode *inode)
 466 {
 467         return &inode_to_bdi(inode)->wb;
 468 }
 469
 470 static inline struct bdi_writeback *
 471 unlocked_inode_to_wb_begin(struct inode *inode, bool *lockedp)
 472 {
 473         return inode_to_wb(inode);
 474 }
 475
 476 static inline void unlocked_inode_to_wb_end(struct inode *inode, bool locked)
 477 {
 478 }
 479
 480 static inline void wb_memcg_offline(struct mem_cgroup *memcg)
 481 {
 482 }
 483
 484 static inline void wb_blkcg_offline(struct blkcg *blkcg)
 485 {
 486 }
 487
 488 static inline int inode_congested(struct inode *inode, int cong_bits)
 489 {
 490         return wb_congested(&inode_to_bdi(inode)->wb, cong_bits);
 491 }
 492
 493 #endif  /* CONFIG_CGROUP_WRITEBACK */
 494
 495 static inline int inode_read_congested(struct inode *inode)
 496 {
 497         return inode_congested(inode, 1 << WB_sync_congested);
 498 }
 499
 500 static inline int inode_write_congested(struct inode *inode)
 501 {
 502         return inode_congested(inode, 1 << WB_async_congested);
 503 }
 504
 505 static inline int inode_rw_congested(struct inode *inode)
 506 {
 507         return inode_congested(inode, (1 << WB_sync_congested) |
 508                                       (1 << WB_async_congested));
 509 }
 510
 511 static inline int bdi_congested(struct backing_dev_info *bdi, int cong_bits)
 512 {
 513         return wb_congested(&bdi->wb, cong_bits);
 514 }
 515
 516 static inline int bdi_read_congested(struct backing_dev_info *bdi)
 517 {
 518         return bdi_congested(bdi, 1 << WB_sync_congested);
 519 }
 520
 521 static inline int bdi_write_congested(struct backing_dev_info *bdi)
 522 {
 523         return bdi_congested(bdi, 1 << WB_async_congested);
 524 }
 525
 526 static inline int bdi_rw_congested(struct backing_dev_info *bdi)
 527 {
 528         return bdi_congested(bdi, (1 << WB_sync_congested) |
 529                                   (1 << WB_async_congested));
 530 }
 531
 532 #endif  /* _LINUX_BACKING_DEV_H */