LCOV - code coverage report
Current view: top level - fs/btrfs - disk-io.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 6 0.0 %
Date: 2014-02-18 Functions: 0 0 -
Branches: 0 12 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (C) 2007 Oracle.  All rights reserved.
       3                 :            :  *
       4                 :            :  * This program is free software; you can redistribute it and/or
       5                 :            :  * modify it under the terms of the GNU General Public
       6                 :            :  * License v2 as published by the Free Software Foundation.
       7                 :            :  *
       8                 :            :  * This program is distributed in the hope that it will be useful,
       9                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      10                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      11                 :            :  * General Public License for more details.
      12                 :            :  *
      13                 :            :  * You should have received a copy of the GNU General Public
      14                 :            :  * License along with this program; if not, write to the
      15                 :            :  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      16                 :            :  * Boston, MA 021110-1307, USA.
      17                 :            :  */
      18                 :            : 
      19                 :            : #ifndef __DISKIO__
      20                 :            : #define __DISKIO__
      21                 :            : 
      22                 :            : #define BTRFS_SUPER_INFO_OFFSET (64 * 1024)
      23                 :            : #define BTRFS_SUPER_INFO_SIZE 4096
      24                 :            : 
      25                 :            : #define BTRFS_SUPER_MIRROR_MAX   3
      26                 :            : #define BTRFS_SUPER_MIRROR_SHIFT 12
      27                 :            : 
      28                 :            : enum {
      29                 :            :         BTRFS_WQ_ENDIO_DATA = 0,
      30                 :            :         BTRFS_WQ_ENDIO_METADATA = 1,
      31                 :            :         BTRFS_WQ_ENDIO_FREE_SPACE = 2,
      32                 :            :         BTRFS_WQ_ENDIO_RAID56 = 3,
      33                 :            : };
      34                 :            : 
      35                 :            : static inline u64 btrfs_sb_offset(int mirror)
      36                 :            : {
      37                 :            :         u64 start = 16 * 1024;
      38 [ #  # ][ #  # ]:          0 :         if (mirror)
      39                 :          0 :                 return start << (BTRFS_SUPER_MIRROR_SHIFT * mirror);
      40                 :            :         return BTRFS_SUPER_INFO_OFFSET;
      41                 :            : }
      42                 :            : 
      43                 :            : struct btrfs_device;
      44                 :            : struct btrfs_fs_devices;
      45                 :            : 
      46                 :            : struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
      47                 :            :                                       u32 blocksize, u64 parent_transid);
      48                 :            : int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
      49                 :            :                          u64 parent_transid);
      50                 :            : int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
      51                 :            :                          int mirror_num, struct extent_buffer **eb);
      52                 :            : struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
      53                 :            :                                                    u64 bytenr, u32 blocksize);
      54                 :            : void clean_tree_block(struct btrfs_trans_handle *trans,
      55                 :            :                       struct btrfs_root *root, struct extent_buffer *buf);
      56                 :            : int open_ctree(struct super_block *sb,
      57                 :            :                struct btrfs_fs_devices *fs_devices,
      58                 :            :                char *options);
      59                 :            : int close_ctree(struct btrfs_root *root);
      60                 :            : int write_ctree_super(struct btrfs_trans_handle *trans,
      61                 :            :                       struct btrfs_root *root, int max_mirrors);
      62                 :            : struct buffer_head *btrfs_read_dev_super(struct block_device *bdev);
      63                 :            : int btrfs_commit_super(struct btrfs_root *root);
      64                 :            : struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
      65                 :            :                                             u64 bytenr, u32 blocksize);
      66                 :            : struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root,
      67                 :            :                                       struct btrfs_key *location);
      68                 :            : int btrfs_init_fs_root(struct btrfs_root *root);
      69                 :            : int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
      70                 :            :                          struct btrfs_root *root);
      71                 :            : 
      72                 :            : struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
      73                 :            :                                      struct btrfs_key *key,
      74                 :            :                                      bool check_ref);
      75                 :            : static inline struct btrfs_root *
      76                 :            : btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
      77                 :            :                            struct btrfs_key *location)
      78                 :            : {
      79                 :          0 :         return btrfs_get_fs_root(fs_info, location, true);
      80                 :            : }
      81                 :            : 
      82                 :            : int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info);
      83                 :            : void btrfs_btree_balance_dirty(struct btrfs_root *root);
      84                 :            : void btrfs_btree_balance_dirty_nodelay(struct btrfs_root *root);
      85                 :            : void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
      86                 :            :                                  struct btrfs_root *root);
      87                 :            : void btrfs_free_fs_root(struct btrfs_root *root);
      88                 :            : 
      89                 :            : #ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
      90                 :            : struct btrfs_root *btrfs_alloc_dummy_root(void);
      91                 :            : #endif
      92                 :            : 
      93                 :            : /*
      94                 :            :  * This function is used to grab the root, and avoid it is freed when we
      95                 :            :  * access it. But it doesn't ensure that the tree is not dropped.
      96                 :            :  *
      97                 :            :  * If you want to ensure the whole tree is safe, you should use
      98                 :            :  *      fs_info->subvol_srcu
      99                 :            :  */
     100                 :            : static inline struct btrfs_root *btrfs_grab_fs_root(struct btrfs_root *root)
     101                 :            : {
     102         [ #  # ]:          0 :         if (atomic_inc_not_zero(&root->refs))
     103                 :            :                 return root;
     104                 :            :         return NULL;
     105                 :            : }
     106                 :            : 
     107                 :            : static inline void btrfs_put_fs_root(struct btrfs_root *root)
     108                 :            : {
     109   [ #  #  #  #  :          0 :         if (atomic_dec_and_test(&root->refs))
                   #  # ]
     110                 :          0 :                 kfree(root);
     111                 :            : }
     112                 :            : 
     113                 :            : void btrfs_mark_buffer_dirty(struct extent_buffer *buf);
     114                 :            : int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
     115                 :            :                           int atomic);
     116                 :            : int btrfs_set_buffer_uptodate(struct extent_buffer *buf);
     117                 :            : int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid);
     118                 :            : u32 btrfs_csum_data(char *data, u32 seed, size_t len);
     119                 :            : void btrfs_csum_final(u32 crc, char *result);
     120                 :            : int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
     121                 :            :                         int metadata);
     122                 :            : int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
     123                 :            :                         int rw, struct bio *bio, int mirror_num,
     124                 :            :                         unsigned long bio_flags, u64 bio_offset,
     125                 :            :                         extent_submit_bio_hook_t *submit_bio_start,
     126                 :            :                         extent_submit_bio_hook_t *submit_bio_done);
     127                 :            : unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info);
     128                 :            : int btrfs_write_tree_block(struct extent_buffer *buf);
     129                 :            : int btrfs_wait_tree_block_writeback(struct extent_buffer *buf);
     130                 :            : int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
     131                 :            :                              struct btrfs_fs_info *fs_info);
     132                 :            : int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
     133                 :            :                        struct btrfs_root *root);
     134                 :            : void btrfs_cleanup_one_transaction(struct btrfs_transaction *trans,
     135                 :            :                                   struct btrfs_root *root);
     136                 :            : struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
     137                 :            :                                      struct btrfs_fs_info *fs_info,
     138                 :            :                                      u64 objectid);
     139                 :            : int btree_lock_page_hook(struct page *page, void *data,
     140                 :            :                                 void (*flush_fn)(void *));
     141                 :            : int btrfs_calc_num_tolerated_disk_barrier_failures(
     142                 :            :         struct btrfs_fs_info *fs_info);
     143                 :            : 
     144                 :            : #ifdef CONFIG_DEBUG_LOCK_ALLOC
     145                 :            : void btrfs_init_lockdep(void);
     146                 :            : void btrfs_set_buffer_lockdep_class(u64 objectid,
     147                 :            :                                     struct extent_buffer *eb, int level);
     148                 :            : #else
     149                 :            : static inline void btrfs_init_lockdep(void)
     150                 :            : { }
     151                 :            : static inline void btrfs_set_buffer_lockdep_class(u64 objectid,
     152                 :            :                                         struct extent_buffer *eb, int level)
     153                 :            : {
     154                 :            : }
     155                 :            : #endif
     156                 :            : #endif

Generated by: LCOV version 1.9