LCOV - code coverage report
Current view: top level - include/linux - writeback.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3 3 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       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             : struct backing_dev_info;
      11             : 
      12             : extern spinlock_t inode_lock;
      13             : extern struct list_head inode_in_use;
      14             : extern struct list_head inode_unused;
      15           1 : 
      16             : /*
      17             :  * fs/fs-writeback.c
      18             :  */
      19             : enum writeback_sync_modes {
      20           1 :         WB_SYNC_NONE,   /* Don't wait on anything */
      21             :         WB_SYNC_ALL,    /* Wait on every mapping */
      22             : };
      23             : 
      24             : /*
      25             :  * A control structure which tells the writeback code what to do.  These are
      26             :  * always on the stack, and hence need no locking.  They are always initialised
      27             :  * in a manner such that unspecified fields are set to zero.
      28             :  */
      29             : struct writeback_control {
      30             :         struct backing_dev_info *bdi;   /* If !NULL, only write back this
      31             :                                            queue */
      32             :         struct super_block *sb;         /* if !NULL, only write inodes from
      33             :                                            this super_block */
      34             :         enum writeback_sync_modes sync_mode;
      35             :         unsigned long *older_than_this; /* If !NULL, only write back inodes
      36             :                                            older than this */
      37             :         long nr_to_write;               /* Write this many pages, and decrement
      38             :                                            this for each page written */
      39             :         long pages_skipped;             /* Pages which were not written */
      40             : 
      41             :         /*
      42             :          * For a_ops->writepages(): is start or end are non-zero then this is
      43             :          * a hint that the filesystem need only write out the pages inside that
      44             :          * byterange.  The byte at `end' is included in the writeout request.
      45             :          */
      46             :         loff_t range_start;
      47             :         loff_t range_end;
      48             : 
      49             :         unsigned nonblocking:1;         /* Don't get stuck on request queues */
      50             :         unsigned encountered_congestion:1; /* An output: a queue is full */
      51             :         unsigned for_kupdate:1;         /* A kupdate writeback */
      52             :         unsigned for_background:1;      /* A background writeback */
      53             :         unsigned for_reclaim:1;         /* Invoked from the page allocator */
      54             :         unsigned range_cyclic:1;        /* range_start is cyclic */
      55             :         unsigned more_io:1;             /* more io to be dispatched */
      56             :         /*
      57             :          * write_cache_pages() won't update wbc->nr_to_write and
      58             :          * mapping->writeback_index if no_nrwrite_index_update
      59             :          * is set.  write_cache_pages() may write more than we
      60             :          * requested and we want to make sure nr_to_write and
      61             :          * writeback_index are updated in a consistent manner
      62             :          * so we use a single control to update them
      63             :          */
      64             :         unsigned no_nrwrite_index_update:1;
      65             : };
      66           1 : 
      67             : /*
      68             :  * fs/fs-writeback.c
      69             :  */     
      70             : struct bdi_writeback;
      71             : int inode_wait(void *);
      72             : void writeback_inodes_sb(struct super_block *);
      73             : int writeback_inodes_sb_if_idle(struct super_block *);
      74             : void sync_inodes_sb(struct super_block *);
      75             : void writeback_inodes_wbc(struct writeback_control *wbc);
      76             : long wb_do_writeback(struct bdi_writeback *wb, int force_wait);
      77             : void wakeup_flusher_threads(long nr_pages);
      78             : 
      79             : /* writeback.h requires fs.h; it, too, is not included from here. */
      80             : static inline void wait_on_inode(struct inode *inode)
      81             : {
      82             :         might_sleep();
      83             :         wait_on_bit(&inode->i_state, __I_NEW, inode_wait, TASK_UNINTERRUPTIBLE);
      84             : }
      85             : static inline void inode_sync_wait(struct inode *inode)
      86             : {
      87             :         might_sleep();
      88             :         wait_on_bit(&inode->i_state, __I_SYNC, inode_wait,
      89             :                                                         TASK_UNINTERRUPTIBLE);
      90             : }
      91             : 
      92             : 
      93             : /*
      94             :  * mm/page-writeback.c
      95             :  */
      96             : void laptop_io_completion(void);
      97             : void laptop_sync_completion(void);
      98             : void throttle_vm_writeout(gfp_t gfp_mask);
      99             : 
     100             : /* These are exported to sysctl. */
     101             : extern int dirty_background_ratio;
     102             : extern unsigned long dirty_background_bytes;
     103             : extern int vm_dirty_ratio;
     104             : extern unsigned long vm_dirty_bytes;
     105             : extern unsigned int dirty_writeback_interval;
     106             : extern unsigned int dirty_expire_interval;
     107             : extern int vm_highmem_is_dirtyable;
     108             : extern int block_dump;
     109             : extern int laptop_mode;
     110             : 
     111             : extern unsigned long determine_dirtyable_memory(void);
     112             : 
     113             : extern int dirty_background_ratio_handler(struct ctl_table *table, int write,
     114             :                 void __user *buffer, size_t *lenp,
     115             :                 loff_t *ppos);
     116             : extern int dirty_background_bytes_handler(struct ctl_table *table, int write,
     117             :                 void __user *buffer, size_t *lenp,
     118             :                 loff_t *ppos);
     119             : extern int dirty_ratio_handler(struct ctl_table *table, int write,
     120             :                 void __user *buffer, size_t *lenp,
     121             :                 loff_t *ppos);
     122             : extern int dirty_bytes_handler(struct ctl_table *table, int write,
     123             :                 void __user *buffer, size_t *lenp,
     124             :                 loff_t *ppos);
     125             : 
     126             : struct ctl_table;
     127             : int dirty_writeback_centisecs_handler(struct ctl_table *, int,
     128             :                                       void __user *, size_t *, loff_t *);
     129             : 
     130             : void get_dirty_limits(unsigned long *pbackground, unsigned long *pdirty,
     131             :                       unsigned long *pbdi_dirty, struct backing_dev_info *bdi);
     132             : 
     133             : void page_writeback_init(void);
     134             : void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
     135             :                                         unsigned long nr_pages_dirtied);
     136             : 
     137             : static inline void
     138             : balance_dirty_pages_ratelimited(struct address_space *mapping)
     139             : {
     140             :         balance_dirty_pages_ratelimited_nr(mapping, 1);
     141             : }
     142             : 
     143             : typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
     144             :                                 void *data);
     145             : 
     146             : int generic_writepages(struct address_space *mapping,
     147             :                        struct writeback_control *wbc);
     148             : int write_cache_pages(struct address_space *mapping,
     149             :                       struct writeback_control *wbc, writepage_t writepage,
     150             :                       void *data);
     151             : int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
     152             : void set_page_dirty_balance(struct page *page, int page_mkwrite);
     153             : void writeback_set_ratelimit(void);
     154             : 
     155             : /* pdflush.c */
     156             : extern int nr_pdflush_threads;  /* Global so it can be exported to sysctl
     157             :                                    read-only. */
     158             : 
     159             : 
     160             : #endif          /* WRITEBACK_H */

Generated by: LCOV version 1.10