fs/reiser4/block_alloc.h

   1 /* Copyright 2002, 2003 by Hans Reiser, licensing governed by reiser4/README */
   2
   3 #if !defined(__FS_REISER4_BLOCK_ALLOC_H__)
   4 #define __FS_REISER4_BLOCK_ALLOC_H__
   5
   6 #include "dformat.h"
   7 #include "forward.h"
   8
   9 #include <linux/types.h>        /* for __u??  */
  10 #include <linux/fs.h>
  11
  12 /* Mask when is applied to given block number shows is that block number is a
  13    fake one */
  14 #define REISER4_FAKE_BLOCKNR_BIT_MASK   0x8000000000000000ULL
  15 /* Mask which isolates a type of object this fake block number was assigned
  16    to */
  17 #define REISER4_BLOCKNR_STATUS_BIT_MASK 0xC000000000000000ULL
  18
  19 /*result after applying the REISER4_BLOCKNR_STATUS_BIT_MASK should be compared
  20    against these two values to understand is the object unallocated or bitmap
  21    shadow object (WORKING BITMAP block, look at the plugin/space/bitmap.c) */
  22 #define REISER4_UNALLOCATED_STATUS_VALUE    0xC000000000000000ULL
  23 #define REISER4_BITMAP_BLOCKS_STATUS_VALUE  0x8000000000000000ULL
  24
  25 /* specification how block allocation was counted in sb block counters */
  26 typedef enum {
  27         BLOCK_NOT_COUNTED = 0,  /* reiser4 has no info about this block yet */
  28         BLOCK_GRABBED = 1,      /* free space grabbed for further allocation
  29                                    of this block */
  30         BLOCK_FLUSH_RESERVED = 2,       /* block is reserved for flush needs. */
  31         BLOCK_UNALLOCATED = 3,  /* block is used for existing in-memory object
  32                                    ( unallocated formatted or unformatted
  33                                    node) */
  34         BLOCK_ALLOCATED = 4     /* block is mapped to disk, real on-disk block
  35                                    number assigned */
  36 } block_stage_t;
  37
  38 /* a hint for block allocator */
  39 struct reiser4_blocknr_hint {
  40         /* FIXME: I think we want to add a longterm lock on the bitmap block
  41            here. This is to prevent jnode_flush() calls from interleaving
  42            allocations on the same bitmap, once a hint is established. */
  43
  44         /* search start hint */
  45         reiser4_block_nr blk;
  46         /* if not zero, it is a region size we search for free blocks in */
  47         reiser4_block_nr max_dist;
  48         /* level for allocation, may be useful have branch-level and higher
  49            write-optimized. */
  50         tree_level level;
  51         /* block allocator assumes that blocks, which will be mapped to disk,
  52            are in this specified block_stage */
  53         block_stage_t block_stage;
  54         /* If direction = 1 allocate blocks in backward direction from the end
  55          * of disk to the beginning of disk.  */
  56         unsigned int backward:1;
  57
  58 };
  59
  60 /* These flags control block allocation/deallocation behavior */
  61 enum reiser4_ba_flags {
  62         /* do allocatations from reserved (5%) area */
  63         BA_RESERVED = (1 << 0),
  64
  65         /* block allocator can do commit trying to recover free space */
  66         BA_CAN_COMMIT = (1 << 1),
  67
  68         /* if operation will be applied to formatted block */
  69         BA_FORMATTED = (1 << 2),
  70
  71         /* defer actual block freeing until transaction commit */
  72         BA_DEFER = (1 << 3),
  73
  74         /* allocate blocks for permanent fs objects (formatted or unformatted),
  75             not wandered of log blocks */
  76         BA_PERMANENT = (1 << 4),
  77
  78         /* grab space even it was disabled */
  79         BA_FORCE = (1 << 5),
  80
  81         /* use default start value for free blocks search. */
  82         BA_USE_DEFAULT_SEARCH_START = (1 << 6)
  83 };
  84
  85 typedef enum reiser4_ba_flags reiser4_ba_flags_t;
  86
  87 extern void reiser4_blocknr_hint_init(reiser4_blocknr_hint * hint);
  88 extern void reiser4_blocknr_hint_done(reiser4_blocknr_hint * hint);
  89 extern void update_blocknr_hint_default(const struct super_block *,
  90                                         const reiser4_block_nr *);
  91 extern void get_blocknr_hint_default(reiser4_block_nr *);
  92
  93 extern reiser4_block_nr reiser4_fs_reserved_space(struct super_block *super);
  94
  95 int assign_fake_blocknr_formatted(reiser4_block_nr *);
  96 reiser4_block_nr fake_blocknr_unformatted(int);
  97
  98 /* free -> grabbed -> fake_allocated -> used */
  99
 100 int reiser4_grab_space(__u64 count, reiser4_ba_flags_t flags);
 101 void all_grabbed2free(void);
 102 void grabbed2free(reiser4_context * , reiser4_super_info_data * , __u64 count);
 103 void fake_allocated2free(__u64 count, reiser4_ba_flags_t flags);
 104 void grabbed2flush_reserved_nolock(txn_atom * atom, __u64 count);
 105 void grabbed2flush_reserved(__u64 count);
 106 int reiser4_alloc_blocks(reiser4_blocknr_hint * hint,
 107                          reiser4_block_nr * start,
 108                          reiser4_block_nr * len, reiser4_ba_flags_t flags);
 109 int reiser4_dealloc_blocks(const reiser4_block_nr *,
 110                            const reiser4_block_nr *,
 111                            block_stage_t, reiser4_ba_flags_t flags);
 112
 113 static inline int reiser4_alloc_block(reiser4_blocknr_hint * hint,
 114                                       reiser4_block_nr * start,
 115                                       reiser4_ba_flags_t flags)
 116 {
 117         reiser4_block_nr one = 1;
 118         return reiser4_alloc_blocks(hint, start, &one, flags);
 119 }
 120
 121 static inline int reiser4_dealloc_block(const reiser4_block_nr * block,
 122                                         block_stage_t stage,
 123                                         reiser4_ba_flags_t flags)
 124 {
 125         const reiser4_block_nr one = 1;
 126         return reiser4_dealloc_blocks(block, &one, stage, flags);
 127 }
 128
 129 #define reiser4_grab_space_force(count, flags)          \
 130         reiser4_grab_space(count, flags | BA_FORCE)
 131
 132 extern void grabbed2free_mark(__u64 mark);
 133 extern int reiser4_grab_reserved(struct super_block *,
 134                                  __u64, reiser4_ba_flags_t);
 135 extern void reiser4_release_reserved(struct super_block *super);
 136
 137 /* grabbed -> fake_allocated */
 138
 139 /* fake_allocated -> used */
 140
 141 /* used -> fake_allocated -> grabbed -> free */
 142
 143 extern void flush_reserved2grabbed(txn_atom * atom, __u64 count);
 144
 145 extern int reiser4_blocknr_is_fake(const reiser4_block_nr * da);
 146
 147 extern void grabbed2cluster_reserved(int count);
 148 extern void cluster_reserved2grabbed(int count);
 149 extern void cluster_reserved2free(int count);
 150
 151 extern int reiser4_check_block_counters(const struct super_block *);
 152
 153 #if REISER4_DEBUG
 154
 155 extern void reiser4_check_block(const reiser4_block_nr *, int);
 156
 157 #else
 158
 159 #  define reiser4_check_block(beg, val)        noop
 160
 161 #endif
 162
 163 extern int reiser4_pre_commit_hook(void);
 164 extern void reiser4_post_commit_hook(void);
 165 extern void reiser4_post_write_back_hook(void);
 166
 167 #endif                          /* __FS_REISER4_BLOCK_ALLOC_H__ */
 168
 169 /* Make Linus happy.
 170    Local variables:
 171    c-indentation-style: "K&R"
 172    mode-name: "LC"
 173    c-basic-offset: 8
 174    tab-width: 8
 175    fill-column: 120
 176    End:
 177 */