Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
bitmap.h
Go to the documentation of this file.
1 /*
2  * bitmap.h: Copyright (C) Peter T. Breuer ([email protected]) 2003
3  *
4  * additions: Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
5  */
6 #ifndef BITMAP_H
7 #define BITMAP_H 1
8 
9 #define BITMAP_MAJOR_LO 3
10 /* version 4 insists the bitmap is in little-endian order
11  * with version 3, it is host-endian which is non-portable
12  */
13 #define BITMAP_MAJOR_HI 4
14 #define BITMAP_MAJOR_HOSTENDIAN 3
15 
16 /*
17  * in-memory bitmap:
18  *
19  * Use 16 bit block counters to track pending writes to each "chunk".
20  * The 2 high order bits are special-purpose, the first is a flag indicating
21  * whether a resync is needed. The second is a flag indicating whether a
22  * resync is active.
23  * This means that the counter is actually 14 bits:
24  *
25  * +--------+--------+------------------------------------------------+
26  * | resync | resync | counter |
27  * | needed | active | |
28  * | (0-1) | (0-1) | (0-16383) |
29  * +--------+--------+------------------------------------------------+
30  *
31  * The "resync needed" bit is set when:
32  * a '1' bit is read from storage at startup.
33  * a write request fails on some drives
34  * a resync is aborted on a chunk with 'resync active' set
35  * It is cleared (and resync-active set) when a resync starts across all drives
36  * of the chunk.
37  *
38  *
39  * The "resync active" bit is set when:
40  * a resync is started on all drives, and resync_needed is set.
41  * resync_needed will be cleared (as long as resync_active wasn't already set).
42  * It is cleared when a resync completes.
43  *
44  * The counter counts pending write requests, plus the on-disk bit.
45  * When the counter is '1' and the resync bits are clear, the on-disk
46  * bit can be cleared as well, thus setting the counter to 0.
47  * When we set a bit, or in the counter (to start a write), if the fields is
48  * 0, we first set the disk bit and set the counter to 1.
49  *
50  * If the counter is 0, the on-disk bit is clear and the stipe is clean
51  * Anything that dirties the stipe pushes the counter to 2 (at least)
52  * and sets the on-disk bit (lazily).
53  * If a periodic sweep find the counter at 2, it is decremented to 1.
54  * If the sweep find the counter at 1, the on-disk bit is cleared and the
55  * counter goes to zero.
56  *
57  * Also, we'll hijack the "map" pointer itself and use it as two 16 bit block
58  * counters as a fallback when "page" memory cannot be allocated:
59  *
60  * Normal case (page memory allocated):
61  *
62  * page pointer (32-bit)
63  *
64  * [ ] ------+
65  * |
66  * +-------> [ ][ ]..[ ] (4096 byte page == 2048 counters)
67  * c1 c2 c2048
68  *
69  * Hijacked case (page memory allocation failed):
70  *
71  * hijacked page pointer (32-bit)
72  *
73  * [ ][ ] (no page memory allocated)
74  * counter #1 (16-bit) counter #2 (16-bit)
75  *
76  */
77 
78 #ifdef __KERNEL__
79 
80 #define PAGE_BITS (PAGE_SIZE << 3)
81 #define PAGE_BIT_SHIFT (PAGE_SHIFT + 3)
82 
83 typedef __u16 bitmap_counter_t;
84 #define COUNTER_BITS 16
85 #define COUNTER_BIT_SHIFT 4
86 #define COUNTER_BYTE_SHIFT (COUNTER_BIT_SHIFT - 3)
87 
88 #define NEEDED_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 1)))
89 #define RESYNC_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 2)))
90 #define COUNTER_MAX ((bitmap_counter_t) RESYNC_MASK - 1)
91 #define NEEDED(x) (((bitmap_counter_t) x) & NEEDED_MASK)
92 #define RESYNC(x) (((bitmap_counter_t) x) & RESYNC_MASK)
93 #define COUNTER(x) (((bitmap_counter_t) x) & COUNTER_MAX)
94 
95 /* how many counters per page? */
96 #define PAGE_COUNTER_RATIO (PAGE_BITS / COUNTER_BITS)
97 /* same, except a shift value for more efficient bitops */
98 #define PAGE_COUNTER_SHIFT (PAGE_BIT_SHIFT - COUNTER_BIT_SHIFT)
99 /* same, except a mask value for more efficient bitops */
100 #define PAGE_COUNTER_MASK (PAGE_COUNTER_RATIO - 1)
101 
102 #define BITMAP_BLOCK_SHIFT 9
103 
104 #endif
105 
106 /*
107  * bitmap structures:
108  */
109 
110 #define BITMAP_MAGIC 0x6d746962
111 
112 /* use these for bitmap->flags and bitmap->sb->state bit-fields */
114  BITMAP_STALE = 1, /* the bitmap file is out of date or had -EIO */
115  BITMAP_WRITE_ERROR = 2, /* A write error has occurred */
117 };
118 
119 /* the superblock at the front of the bitmap file -- little endian */
120 typedef struct bitmap_super_s {
121  __le32 magic; /* 0 BITMAP_MAGIC */
122  __le32 version; /* 4 the bitmap major for now, could change... */
123  __u8 uuid[16]; /* 8 128 bit uuid - must match md device uuid */
124  __le64 events; /* 24 event counter for the bitmap (1)*/
125  __le64 events_cleared;/*32 event counter when last bit cleared (2) */
126  __le64 sync_size; /* 40 the size of the md device's sync range(3) */
127  __le32 state; /* 48 bitmap state information */
128  __le32 chunksize; /* 52 the bitmap chunk size in bytes */
129  __le32 daemon_sleep; /* 56 seconds between disk flushes */
130  __le32 write_behind; /* 60 number of outstanding write-behind writes */
131  __le32 sectors_reserved; /* 64 number of 512-byte sectors that are
132  * reserved for the bitmap. */
133 
134  __u8 pad[256 - 68]; /* set to zero */
136 
137 /* notes:
138  * (1) This event counter is updated before the eventcounter in the md superblock
139  * When a bitmap is loaded, it is only accepted if this event counter is equal
140  * to, or one greater than, the event counter in the superblock.
141  * (2) This event counter is updated when the other one is *if*and*only*if* the
142  * array is not degraded. As bits are not cleared when the array is degraded,
143  * this represents the last time that any bits were cleared.
144  * If a device is being added that has an event count with this value or
145  * higher, it is accepted as conforming to the bitmap.
146  * (3)This is the number of sectors represented by the bitmap, and is the range that
147  * resync happens across. For raid1 and raid5/6 it is the size of individual
148  * devices. For raid10 it is the size of the array.
149  */
150 
151 #ifdef __KERNEL__
152 
153 /* the in-memory bitmap is represented by bitmap_pages */
154 struct bitmap_page {
155  /*
156  * map points to the actual memory page
157  */
158  char *map;
159  /*
160  * in emergencies (when map cannot be alloced), hijack the map
161  * pointer and use it as two counters itself
162  */
163  unsigned int hijacked:1;
164  /*
165  * If any counter in this page is '1' or '2' - and so could be
166  * cleared then that page is marked as 'pending'
167  */
168  unsigned int pending:1;
169  /*
170  * count of dirty bits on the page
171  */
172  unsigned int count:30;
173 };
174 
175 /* the main bitmap structure - one per mddev */
176 struct bitmap {
177 
178  struct bitmap_counts {
180  struct bitmap_page *bp;
181  unsigned long pages; /* total number of pages
182  * in the bitmap */
183  unsigned long missing_pages; /* number of pages
184  * not yet allocated */
185  unsigned long chunkshift; /* chunksize = 2^chunkshift
186  * (for bitops) */
187  unsigned long chunks; /* Total number of data
188  * chunks for the array */
189  } counts;
190 
191  struct mddev *mddev; /* the md device that the bitmap is for */
192 
193  __u64 events_cleared;
194  int need_sync;
195 
196  struct bitmap_storage {
197  struct file *file; /* backing disk file */
198  struct page *sb_page; /* cached copy of the bitmap
199  * file superblock */
200  struct page **filemap; /* list of cache pages for
201  * the file */
202  unsigned long *filemap_attr; /* attributes associated
203  * w/ filemap pages */
204  unsigned long file_pages; /* number of pages in the file*/
205  unsigned long bytes; /* total bytes in the bitmap */
206  } storage;
207 
208  unsigned long flags;
209 
210  int allclean;
211 
212  atomic_t behind_writes;
213  unsigned long behind_writes_used; /* highest actual value at runtime */
214 
215  /*
216  * the bitmap daemon - periodically wakes up and sweeps the bitmap
217  * file, cleaning up bits and flushing out pages to disk as necessary
218  */
219  unsigned long daemon_lastrun; /* jiffies of last run */
220  unsigned long last_end_sync; /* when we lasted called end_sync to
221  * update bitmap with resync progress */
222 
223  atomic_t pending_writes; /* pending writes to the bitmap file */
224  wait_queue_head_t write_wait;
225  wait_queue_head_t overflow_wait;
226  wait_queue_head_t behind_wait;
227 
228  struct sysfs_dirent *sysfs_can_clear;
229 };
230 
231 /* the bitmap API */
232 
233 /* these are used only by md/bitmap */
234 int bitmap_create(struct mddev *mddev);
235 int bitmap_load(struct mddev *mddev);
236 void bitmap_flush(struct mddev *mddev);
237 void bitmap_destroy(struct mddev *mddev);
238 
239 void bitmap_print_sb(struct bitmap *bitmap);
240 void bitmap_update_sb(struct bitmap *bitmap);
241 void bitmap_status(struct seq_file *seq, struct bitmap *bitmap);
242 
243 int bitmap_setallbits(struct bitmap *bitmap);
244 void bitmap_write_all(struct bitmap *bitmap);
245 
246 void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e);
247 
248 /* these are exported */
250  unsigned long sectors, int behind);
252  unsigned long sectors, int success, int behind);
253 int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int degraded);
254 void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted);
255 void bitmap_close_sync(struct bitmap *bitmap);
257 
258 void bitmap_unplug(struct bitmap *bitmap);
259 void bitmap_daemon_work(struct mddev *mddev);
260 
261 int bitmap_resize(struct bitmap *bitmap, sector_t blocks,
262  int chunksize, int init);
263 #endif
264 
265 #endif