check/mode-original.h

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public
   4  * License v2 as published by the Free Software Foundation.
   5  *
   6  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   9  * General Public License for more details.
  10  *
  11  * You should have received a copy of the GNU General Public
  12  * License along with this program; if not, write to the
  13  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  14  * Boston, MA 021110-1307, USA.
  15  */
  16
  17 /*
  18  * Defines and function declarations for original mode check.
  19  */
  20
  21 #ifndef __BTRFS_CHECK_MODE_ORIGINAL_H__
  22 #define __BTRFS_CHECK_MODE_ORIGINAL_H__
  23
  24 #include "rbtree-utils.h"
  25
  26 struct extent_backref {
  27         struct rb_node node;
  28         unsigned int is_data:1;
  29         unsigned int found_extent_tree:1;
  30         unsigned int full_backref:1;
  31         unsigned int found_ref:1;
  32         unsigned int broken:1;
  33 };
  34
  35 static inline struct extent_backref* rb_node_to_extent_backref(struct rb_node *node)
  36 {
  37         return rb_entry(node, struct extent_backref, node);
  38 }
  39
  40 struct data_backref {
  41         struct extent_backref node;
  42         union {
  43                 u64 parent;
  44                 u64 root;
  45         };
  46         u64 owner;
  47         u64 offset;
  48         u64 disk_bytenr;
  49         u64 bytes;
  50         u64 ram_bytes;
  51         u32 num_refs;
  52         u32 found_ref;
  53 };
  54
  55 static inline struct data_backref* to_data_backref(struct extent_backref *back)
  56 {
  57         return container_of(back, struct data_backref, node);
  58 }
  59
  60 /*
  61  * Much like data_backref, just removed the undetermined members
  62  * and change it to use list_head.
  63  * During extent scan, it is stored in root->orphan_data_extent.
  64  * During fs tree scan, it is then moved to inode_rec->orphan_data_extents.
  65  */
  66 struct orphan_data_extent {
  67         struct list_head list;
  68         u64 root;
  69         u64 objectid;
  70         u64 offset;
  71         u64 disk_bytenr;
  72         u64 disk_len;
  73 };
  74
  75 struct tree_backref {
  76         struct extent_backref node;
  77         union {
  78                 u64 parent;
  79                 u64 root;
  80         };
  81 };
  82
  83 static inline struct tree_backref* to_tree_backref(struct extent_backref *back)
  84 {
  85         return container_of(back, struct tree_backref, node);
  86 }
  87
  88 /* Explicit initialization for extent_record::flag_block_full_backref */
  89 enum { FLAG_UNSET = 2 };
  90
  91 struct extent_record {
  92         struct list_head backrefs;
  93         struct list_head dups;
  94         struct rb_root backref_tree;
  95         struct list_head list;
  96         struct cache_extent cache;
  97         struct btrfs_disk_key parent_key;
  98         u64 start;
  99         u64 max_size;
 100         u64 nr;
 101         u64 refs;
 102         u64 extent_item_refs;
 103         u64 generation;
 104         u64 parent_generation;
 105         u64 info_objectid;
 106         u32 num_duplicates;
 107         u8 info_level;
 108         unsigned int flag_block_full_backref:2;
 109         unsigned int found_rec:1;
 110         unsigned int content_checked:1;
 111         unsigned int owner_ref_checked:1;
 112         unsigned int is_root:1;
 113         unsigned int metadata:1;
 114         unsigned int bad_full_backref:1;
 115         unsigned int crossing_stripes:1;
 116         unsigned int wrong_chunk_type:1;
 117 };
 118
 119 static inline struct extent_record* to_extent_record(struct list_head *entry)
 120 {
 121         return container_of(entry, struct extent_record, list);
 122 }
 123
 124 struct inode_backref {
 125         struct list_head list;
 126         unsigned int found_dir_item:1;
 127         unsigned int found_dir_index:1;
 128         unsigned int found_inode_ref:1;
 129         u8 filetype;
 130         u8 ref_type;
 131         int errors;
 132         u64 dir;
 133         u64 index;
 134         u16 namelen;
 135         char name[0];
 136 };
 137
 138 static inline struct inode_backref* to_inode_backref(struct list_head *entry)
 139 {
 140         return list_entry(entry, struct inode_backref, list);
 141 }
 142
 143 struct root_item_record {
 144         struct list_head list;
 145         u64 objectid;
 146         u64 bytenr;
 147         u64 last_snapshot;
 148         u8 level;
 149         u8 drop_level;
 150         struct btrfs_key drop_key;
 151 };
 152
 153 #define REF_ERR_NO_DIR_ITEM             (1 << 0)
 154 #define REF_ERR_NO_DIR_INDEX            (1 << 1)
 155 #define REF_ERR_NO_INODE_REF            (1 << 2)
 156 #define REF_ERR_DUP_DIR_ITEM            (1 << 3)
 157 #define REF_ERR_DUP_DIR_INDEX           (1 << 4)
 158 #define REF_ERR_DUP_INODE_REF           (1 << 5)
 159 #define REF_ERR_INDEX_UNMATCH           (1 << 6)
 160 #define REF_ERR_FILETYPE_UNMATCH        (1 << 7)
 161 #define REF_ERR_NAME_TOO_LONG           (1 << 8) // 100
 162 #define REF_ERR_NO_ROOT_REF             (1 << 9)
 163 #define REF_ERR_NO_ROOT_BACKREF         (1 << 10)
 164 #define REF_ERR_DUP_ROOT_REF            (1 << 11)
 165 #define REF_ERR_DUP_ROOT_BACKREF        (1 << 12)
 166
 167 struct file_extent_hole {
 168         struct rb_node node;
 169         u64 start;
 170         u64 len;
 171 };
 172
 173 #define I_ERR_NO_INODE_ITEM             (1 << 0)
 174 #define I_ERR_NO_ORPHAN_ITEM            (1 << 1)
 175 #define I_ERR_DUP_INODE_ITEM            (1 << 2)
 176 #define I_ERR_DUP_DIR_INDEX             (1 << 3)
 177 #define I_ERR_ODD_DIR_ITEM              (1 << 4)
 178 #define I_ERR_ODD_FILE_EXTENT           (1 << 5)
 179 #define I_ERR_BAD_FILE_EXTENT           (1 << 6)
 180 #define I_ERR_FILE_EXTENT_OVERLAP       (1 << 7)
 181 #define I_ERR_FILE_EXTENT_DISCOUNT      (1 << 8) // 100
 182 #define I_ERR_DIR_ISIZE_WRONG           (1 << 9)
 183 #define I_ERR_FILE_NBYTES_WRONG         (1 << 10) // 400
 184 #define I_ERR_ODD_CSUM_ITEM             (1 << 11)
 185 #define I_ERR_SOME_CSUM_MISSING         (1 << 12)
 186 #define I_ERR_LINK_COUNT_WRONG          (1 << 13)
 187 #define I_ERR_FILE_EXTENT_ORPHAN        (1 << 14)
 188 #define I_ERR_FILE_EXTENT_TOO_LARGE     (1 << 15)
 189
 190 struct inode_record {
 191         struct list_head backrefs;
 192         unsigned int checked:1;
 193         unsigned int merging:1;
 194         unsigned int found_inode_item:1;
 195         unsigned int found_dir_item:1;
 196         unsigned int found_file_extent:1;
 197         unsigned int found_csum_item:1;
 198         unsigned int some_csum_missing:1;
 199         unsigned int nodatasum:1;
 200         int errors;
 201
 202         u64 ino;
 203         u32 nlink;
 204         u32 imode;
 205         u64 isize;
 206         u64 nbytes;
 207
 208         u32 found_link;
 209         u64 found_size;
 210         u64 extent_start;
 211         u64 extent_end;
 212         struct rb_root holes;
 213         struct list_head orphan_extents;
 214
 215         u32 refs;
 216 };
 217
 218 struct root_backref {
 219         struct list_head list;
 220         unsigned int found_dir_item:1;
 221         unsigned int found_dir_index:1;
 222         unsigned int found_back_ref:1;
 223         unsigned int found_forward_ref:1;
 224         unsigned int reachable:1;
 225         int errors;
 226         u64 ref_root;
 227         u64 dir;
 228         u64 index;
 229         u16 namelen;
 230         char name[0];
 231 };
 232
 233 static inline struct root_backref* to_root_backref(struct list_head *entry)
 234 {
 235         return list_entry(entry, struct root_backref, list);
 236 }
 237
 238 struct root_record {
 239         struct list_head backrefs;
 240         struct cache_extent cache;
 241         unsigned int found_root_item:1;
 242         u64 objectid;
 243         u32 found_ref;
 244 };
 245
 246 struct ptr_node {
 247         struct cache_extent cache;
 248         void *data;
 249 };
 250
 251 struct shared_node {
 252         struct cache_extent cache;
 253         struct cache_tree root_cache;
 254         struct cache_tree inode_cache;
 255         struct inode_record *current;
 256         u32 refs;
 257 };
 258
 259 struct block_info {
 260         u64 start;
 261         u32 size;
 262 };
 263
 264 struct walk_control {
 265         struct cache_tree shared;
 266         struct shared_node *nodes[BTRFS_MAX_LEVEL];
 267         int active_node;
 268         int root_level;
 269 };
 270
 271 struct bad_item {
 272         struct btrfs_key key;
 273         u64 root_id;
 274         struct list_head list;
 275 };
 276
 277 struct extent_entry {
 278         u64 bytenr;
 279         u64 bytes;
 280         int count;
 281         int broken;
 282         struct list_head list;
 283 };
 284
 285 struct root_item_info {
 286         /* level of the root */
 287         u8 level;
 288         /* number of nodes at this level, must be 1 for a root */
 289         int node_count;
 290         u64 bytenr;
 291         u64 gen;
 292         struct cache_extent cache_extent;
 293 };
 294
 295 #endif