1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * bitmap.h: Copyright (C) Peter T. Breuer (ptb@ot.uc3m.es) 2003
4 *
5 * additions: Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
6 */
7#ifndef BITMAP_H
8#define BITMAP_H 1
9
10#define BITMAP_MAGIC 0x6d746962
11
12/*
13 * version 3 is host-endian order, this is deprecated and not used for new
14 * array
15 */
16#define BITMAP_MAJOR_LO 3
17#define BITMAP_MAJOR_HOSTENDIAN 3
18/* version 4 is little-endian order, the default value */
19#define BITMAP_MAJOR_HI 4
20/* version 5 is only used for cluster */
21#define BITMAP_MAJOR_CLUSTERED 5
22/* version 6 is only used for lockless bitmap */
23#define BITMAP_MAJOR_LOCKLESS 6
24
25/* use these for bitmap->flags and bitmap->sb->state bit-fields */
26enum bitmap_state {
27 BITMAP_STALE = 1, /* the bitmap file is out of date or had -EIO */
28 BITMAP_WRITE_ERROR = 2, /* A write error has occurred */
29 BITMAP_FIRST_USE = 3, /* llbitmap is just created */
30 BITMAP_CLEAN = 4, /* llbitmap is created with assume_clean */
31 BITMAP_DAEMON_BUSY = 5, /* llbitmap daemon is not finished after daemon_sleep */
32 BITMAP_HOSTENDIAN =15,
33};
34
35/* the superblock at the front of the bitmap file -- little endian */
36typedef struct bitmap_super_s {
37 __le32 magic; /* 0 BITMAP_MAGIC */
38 __le32 version; /* 4 the bitmap major for now, could change... */
39 __u8 uuid[16]; /* 8 128 bit uuid - must match md device uuid */
40 __le64 events; /* 24 event counter for the bitmap (1)*/
41 __le64 events_cleared;/*32 event counter when last bit cleared (2) */
42 __le64 sync_size; /* 40 the size of the md device's sync range(3) */
43 __le32 state; /* 48 bitmap state information */
44 __le32 chunksize; /* 52 the bitmap chunk size in bytes */
45 __le32 daemon_sleep; /* 56 seconds between disk flushes */
46 __le32 write_behind; /* 60 number of outstanding write-behind writes */
47 __le32 sectors_reserved; /* 64 number of 512-byte sectors that are
48 * reserved for the bitmap. */
49 __le32 nodes; /* 68 the maximum number of nodes in cluster. */
50 __u8 cluster_name[64]; /* 72 cluster name to which this md belongs */
51 __u8 pad[256 - 136]; /* set to zero */
52} bitmap_super_t;
53
54/* notes:
55 * (1) This event counter is updated before the eventcounter in the md superblock
56 * When a bitmap is loaded, it is only accepted if this event counter is equal
57 * to, or one greater than, the event counter in the superblock.
58 * (2) This event counter is updated when the other one is *if*and*only*if* the
59 * array is not degraded. As bits are not cleared when the array is degraded,
60 * this represents the last time that any bits were cleared.
61 * If a device is being added that has an event count with this value or
62 * higher, it is accepted as conforming to the bitmap.
63 * (3)This is the number of sectors represented by the bitmap, and is the range that
64 * resync happens across. For raid1 and raid5/6 it is the size of individual
65 * devices. For raid10 it is the size of the array.
66 */
67
68struct md_bitmap_stats {
69 u64 events_cleared;
70 int behind_writes;
71 bool behind_wait;
72
73 unsigned long missing_pages;
74 unsigned long file_pages;
75 unsigned long sync_size;
76 unsigned long pages;
77 struct file *file;
78};
79
80typedef void (md_bitmap_fn)(struct mddev *mddev, sector_t offset,
81 unsigned long sectors);
82
83struct bitmap_operations {
84 struct md_submodule_head head;
85
86 bool (*enabled)(void *data, bool flush);
87 int (*create)(struct mddev *mddev);
88 int (*resize)(struct mddev *mddev, sector_t blocks, int chunksize);
89
90 int (*load)(struct mddev *mddev);
91 void (*destroy)(struct mddev *mddev);
92 void (*flush)(struct mddev *mddev);
93 void (*write_all)(struct mddev *mddev);
94 void (*dirty_bits)(struct mddev *mddev, unsigned long s,
95 unsigned long e);
96 void (*unplug)(struct mddev *mddev, bool sync);
97 void (*daemon_work)(struct mddev *mddev);
98
99 void (*start_behind_write)(struct mddev *mddev);
100 void (*end_behind_write)(struct mddev *mddev);
101 void (*wait_behind_writes)(struct mddev *mddev);
102
103 md_bitmap_fn *start_write;
104 md_bitmap_fn *end_write;
105 md_bitmap_fn *start_discard;
106 md_bitmap_fn *end_discard;
107
108 sector_t (*skip_sync_blocks)(struct mddev *mddev, sector_t offset);
109 bool (*blocks_synced)(struct mddev *mddev, sector_t offset);
110 bool (*start_sync)(struct mddev *mddev, sector_t offset,
111 sector_t *blocks, bool degraded);
112 void (*end_sync)(struct mddev *mddev, sector_t offset, sector_t *blocks);
113 void (*cond_end_sync)(struct mddev *mddev, sector_t sector, bool force);
114 void (*close_sync)(struct mddev *mddev);
115
116 void (*update_sb)(void *data);
117 int (*get_stats)(void *data, struct md_bitmap_stats *stats);
118
119 void (*sync_with_cluster)(struct mddev *mddev,
120 sector_t old_lo, sector_t old_hi,
121 sector_t new_lo, sector_t new_hi);
122 void *(*get_from_slot)(struct mddev *mddev, int slot);
123 int (*copy_from_slot)(struct mddev *mddev, int slot, sector_t *lo,
124 sector_t *hi, bool clear_bits);
125 void (*set_pages)(void *data, unsigned long pages);
126 void (*free)(void *data);
127
128 struct attribute_group *group;
129};
130
131/* the bitmap API */
132static inline bool md_bitmap_registered(struct mddev *mddev)
133{
134 return mddev->bitmap_ops != NULL;
135}
136
137static inline bool md_bitmap_enabled(struct mddev *mddev, bool flush)
138{
139 /* bitmap_ops must be registered before creating bitmap. */
140 if (!md_bitmap_registered(mddev))
141 return false;
142
143 if (!mddev->bitmap)
144 return false;
145
146 return mddev->bitmap_ops->enabled(mddev->bitmap, flush);
147}
148
149static inline bool md_bitmap_start_sync(struct mddev *mddev, sector_t offset,
150 sector_t *blocks, bool degraded)
151{
152 /* always resync if no bitmap */
153 if (!md_bitmap_enabled(mddev, flush: false)) {
154 *blocks = 1024;
155 return true;
156 }
157
158 return mddev->bitmap_ops->start_sync(mddev, offset, blocks, degraded);
159}
160
161static inline void md_bitmap_end_sync(struct mddev *mddev, sector_t offset,
162 sector_t *blocks)
163{
164 if (!md_bitmap_enabled(mddev, flush: false)) {
165 *blocks = 1024;
166 return;
167 }
168
169 mddev->bitmap_ops->end_sync(mddev, offset, blocks);
170}
171
172#ifdef CONFIG_MD_BITMAP
173int md_bitmap_init(void);
174void md_bitmap_exit(void);
175#else
176static inline int md_bitmap_init(void)
177{
178 return 0;
179}
180static inline void md_bitmap_exit(void)
181{
182}
183#endif
184
185#ifdef CONFIG_MD_LLBITMAP
186int md_llbitmap_init(void);
187void md_llbitmap_exit(void);
188#else
189static inline int md_llbitmap_init(void)
190{
191 return 0;
192}
193static inline void md_llbitmap_exit(void)
194{
195}
196#endif
197
198#endif
199

source code of linux/drivers/md/md-bitmap.h