]> git.ipfire.org Git - thirdparty/mdadm.git/blame - mdadm.h
Remove lots of unnecessary white space.
[thirdparty/mdadm.git] / mdadm.h
CommitLineData
64c4757e 1/*
9a9dab36 2 * mdadm - manage Linux "md" devices aka RAID arrays.
64c4757e 3 *
e736b623 4 * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
64c4757e
NB
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * Author: Neil Brown
e736b623 22 * Email: <neilb@suse.de>
64c4757e
NB
23 */
24
4ccdb956 25#define _GNU_SOURCE
c2c9bb6f 26#define _FILE_OFFSET_BITS 64
64c4757e 27#include <unistd.h>
0d35d5c4 28#ifdef __GLIBC__
64c4757e 29extern __off64_t lseek64 __P ((int __fd, __off64_t __offset, int __whence));
0d35d5c4 30#elif !defined(lseek64)
fffdbe5e 31# if defined(__NO_STAT64) || __WORDSIZE != 32
f783ca4f
NB
32# define lseek64 lseek
33# endif
98c6faba 34#endif
64c4757e
NB
35
36#include <sys/types.h>
37#include <sys/stat.h>
38#include <stdlib.h>
39#include <time.h>
11018a45 40#include <sys/time.h>
64c4757e
NB
41#include <getopt.h>
42#include <fcntl.h>
43#include <stdio.h>
44#include <errno.h>
45#include <string.h>
773135f5 46#include <syslog.h>
b56c3630
NB
47#ifdef __dietlibc__
48#include <strings.h>
280a927d
NB
49/* dietlibc has deprecated random and srandom!! */
50#define random rand
51#define srandom srand
98c6faba
NB
52#endif
53
64c4757e 54#include <linux/kdev_t.h>
e0d19036
NB
55/*#include <linux/fs.h> */
56#include <sys/mount.h>
57#include <asm/types.h>
64c4757e
NB
58#include <sys/ioctl.h>
59#define MD_MAJOR 9
dd0781e5 60#define MdpMinorShift 6
64c4757e 61
e0d19036 62#ifndef BLKGETSIZE64
98c6faba 63#define BLKGETSIZE64 _IOR(0x12,114,size_t) /* return device size in bytes (u64 *arg) */
e0d19036 64#endif
56eb10c0 65
c21e737b 66#define DEFAULT_CHUNK 512
c82f047c
NB
67#define DEFAULT_BITMAP_CHUNK 4096
68#define DEFAULT_BITMAP_DELAY 5
dfd4d8ee 69#define DEFAULT_MAX_WRITE_BEHIND 256
64c4757e 70
753cf905 71/* MAP_DIR should be somewhere that persists across the pivotroot
5d4d1b26 72 * from early boot to late boot.
96fd06ed 73 * /run seems to have emerged as the best standard.
5d4d1b26 74 */
753cf905 75#ifndef MAP_DIR
96fd06ed 76#define MAP_DIR "/run/mdadm"
753cf905
DL
77#endif /* MAP_DIR */
78/* MAP_FILE is what we name the map file we put in MAP_DIR, in case you
79 * want something other than the default of "map"
80 */
81#ifndef MAP_FILE
82#define MAP_FILE "map"
83#endif /* MAP_FILE */
84/* MDMON_DIR is where pid and socket files used for communicating
96fd06ed 85 * with mdmon normally live. Best is /var/run/mdadm as
753cf905
DL
86 * mdmon is needed at early boot then it needs to write there prior
87 * to /var/run being mounted read/write, and it also then needs to
88 * persist beyond when /var/run is mounter read-only. So, to be
89 * safe, the default is somewhere that is read/write early in the
90 * boot process and stays up as long as possible during shutdown.
91 */
92#ifndef MDMON_DIR
96fd06ed 93#define MDMON_DIR "/run/mdadm"
753cf905 94#endif /* MDMON_DIR */
5d4d1b26 95
403410eb
PC
96/* FAILED_SLOTS is where to save files storing recent removal of array
97 * member in order to allow future reuse of disk inserted in the same
98 * slot for array recovery
99 */
100#ifndef FAILED_SLOTS_DIR
96fd06ed 101#define FAILED_SLOTS_DIR "/run/mdadm/failed-slots"
403410eb
PC
102#endif /* FAILED_SLOTS */
103
64c4757e 104#include "md_u.h"
e0d19036 105#include "md_p.h"
c82f047c 106#include "bitmap.h"
f7dd881f 107#include "msg.h"
64c4757e 108
1e0d770c 109#include <endian.h>
efd441d1
NB
110/* Redhat don't like to #include <asm/byteorder.h>, and
111 * some time include <linux/byteorder/xxx_endian.h> isn't enough,
112 * and there is no standard conversion function so... */
0ae03b8a
NB
113/* And dietlibc doesn't think byteswap is ok, so.. */
114/* #include <byteswap.h> */
115#define bswap_16(x) (((x) & 0x00ffU) << 8 | \
116 ((x) & 0xff00U) >> 8)
117#define bswap_32(x) (((x) & 0x000000ffU) << 24 | \
118 ((x) & 0xff000000U) >> 24 | \
119 ((x) & 0x0000ff00U) << 8 | \
120 ((x) & 0x00ff0000U) >> 8)
121#define bswap_64(x) (((x) & 0x00000000000000ffULL) << 56 | \
122 ((x) & 0xff00000000000000ULL) >> 56 | \
123 ((x) & 0x000000000000ff00ULL) << 40 | \
124 ((x) & 0x00ff000000000000ULL) >> 40 | \
125 ((x) & 0x0000000000ff0000ULL) << 24 | \
126 ((x) & 0x0000ff0000000000ULL) >> 24 | \
127 ((x) & 0x00000000ff000000ULL) << 8 | \
128 ((x) & 0x000000ff00000000ULL) >> 8)
129
e39b673e 130#if !defined(__KLIBC__)
efd441d1
NB
131#if BYTE_ORDER == LITTLE_ENDIAN
132#define __cpu_to_le16(_x) (_x)
133#define __cpu_to_le32(_x) (_x)
134#define __cpu_to_le64(_x) (_x)
135#define __le16_to_cpu(_x) (_x)
136#define __le32_to_cpu(_x) (_x)
137#define __le64_to_cpu(_x) (_x)
974e620d
NB
138
139#define __cpu_to_be16(_x) bswap_16(_x)
140#define __cpu_to_be32(_x) bswap_32(_x)
141#define __cpu_to_be64(_x) bswap_64(_x)
142#define __be16_to_cpu(_x) bswap_16(_x)
143#define __be32_to_cpu(_x) bswap_32(_x)
144#define __be64_to_cpu(_x) bswap_64(_x)
efd441d1
NB
145#elif BYTE_ORDER == BIG_ENDIAN
146#define __cpu_to_le16(_x) bswap_16(_x)
147#define __cpu_to_le32(_x) bswap_32(_x)
148#define __cpu_to_le64(_x) bswap_64(_x)
149#define __le16_to_cpu(_x) bswap_16(_x)
150#define __le32_to_cpu(_x) bswap_32(_x)
151#define __le64_to_cpu(_x) bswap_64(_x)
974e620d
NB
152
153#define __cpu_to_be16(_x) (_x)
154#define __cpu_to_be32(_x) (_x)
155#define __cpu_to_be64(_x) (_x)
156#define __be16_to_cpu(_x) (_x)
157#define __be32_to_cpu(_x) (_x)
158#define __be64_to_cpu(_x) (_x)
1e0d770c
NB
159#else
160# error "unknown endianness."
161#endif
e39b673e 162#endif /* __KLIBC__ */
1e0d770c 163
1e5c6983
DW
164/*
165 * min()/max()/clamp() macros that also do
166 * strict type-checking.. See the
167 * "unnecessary" pointer comparison.
168 */
169#define min(x, y) ({ \
170 typeof(x) _min1 = (x); \
171 typeof(y) _min2 = (y); \
172 (void) (&_min1 == &_min2); \
173 _min1 < _min2 ? _min1 : _min2; })
174
175#define max(x, y) ({ \
176 typeof(x) _max1 = (x); \
177 typeof(y) _max2 = (y); \
178 (void) (&_max1 == &_max2); \
179 _max1 > _max2 ? _max1 : _max2; })
1e0d770c 180
4b1ac34b
NB
181/* general information that might be extracted from a superblock */
182struct mdinfo {
183 mdu_array_info_t array;
184 mdu_disk_info_t disk;
185 __u64 events;
fbf8a0b7 186 int uuid[4];
31317663 187 char name[33];
353632d9 188 unsigned long long data_offset;
fe384ca0 189 unsigned long long new_data_offset;
598f0d58
NB
190 unsigned long long component_size; /* same as array.size, except in
191 * sectors and up to 64bits.
192 */
da9b4a62
DW
193 unsigned long long custom_array_size; /* size for non-default sized
194 * arrays (in sectors)
195 */
81219e70
LM
196#define NO_RESHAPE 0
197#define VOLUME_RESHAPE 1
198#define CONTAINER_RESHAPE 2
5e88ab2e 199#define RESHAPE_NO_BACKUP 16 /* Mask 'or'ed in */
353632d9
NB
200 int reshape_active;
201 unsigned long long reshape_progress;
6e75048b
AK
202 int recovery_blocked; /* for external metadata it
203 * indicates that there is
204 * reshape in progress in
205 * container,
206 * for native metadata it is
207 * reshape_active field mirror
208 */
80bf9135
N
209 /* During reshape we can sometimes change the data_offset to avoid
210 * over-writing still-valid data. We need to know if there is space.
211 * So getinfo_super will fill in space_before and space_after in sectors.
212 * data_offset can be increased or decreased by this amount.
213 */
214 unsigned long long space_before, space_after;
e1516be1
DW
215 union {
216 unsigned long long resync_start; /* per-array resync position */
217 unsigned long long recovery_start; /* per-device rebuild position */
b7528a20 218 #define MaxSector (~0ULL) /* resync/recovery complete position */
e1516be1 219 };
fbdef498 220 long bitmap_offset; /* 0 == none, 1 == a file */
a67dd8cc 221 unsigned long safe_mode_delay; /* ms delay to mark clean */
353632d9 222 int new_level, delta_disks, new_layout, new_chunk;
06c7f68e 223 int errors;
f21e18ca 224 unsigned long cache_size; /* size of raid456 stripe cache*/
7e0f6979
NB
225 int mismatch_cnt;
226 char text_version[50];
dd15dc4a
NB
227
228 int container_member; /* for assembling external-metatdata arrays
229 * This is to be used internally by metadata
230 * handler only */
97b4d0e9
DW
231 int container_enough; /* flag external handlers can set to
232 * indicate that subarrays have not enough (-1),
233 * enough to start (0), or all expected disks (1) */
1011e834 234 char sys_name[20];
7e0f6979 235 struct mdinfo *devs;
06c7f68e 236 struct mdinfo *next;
549e9569
NB
237
238 /* Device info for mdmon: */
e1516be1 239 int recovery_fd;
549e9569 240 int state_fd;
8d45d196
DW
241 #define DS_FAULTY 1
242 #define DS_INSYNC 2
243 #define DS_WRITE_MOSTLY 4
244 #define DS_SPARE 8
245 #define DS_BLOCKED 16
246 #define DS_REMOVE 1024
92967543 247 #define DS_UNBLOCK 2048
549e9569
NB
248 int prev_state, curr_state, next_state;
249
4b1ac34b
NB
250};
251
5bbb4842
NB
252struct createinfo {
253 int uid;
254 int gid;
255 int autof;
256 int mode;
38098016 257 int symlinks;
eca944fa 258 int names;
058574b1 259 struct supertype *supertype;
5bbb4842
NB
260};
261
9a9dab36 262#define Name "mdadm"
682c7051 263
e0d19036
NB
264enum mode {
265 ASSEMBLE=1,
266 BUILD,
267 CREATE,
268 MANAGE,
269 MISC,
270 MONITOR,
dd0781e5 271 GROW,
8382f19b 272 INCREMENTAL,
1f48664b 273 AUTODETECT,
5187a385 274 mode_count
e0d19036
NB
275};
276
64c4757e 277extern char short_options[];
024768c4 278extern char short_bitmap_options[];
c06487ce 279extern char short_bitmap_auto_options[];
64c4757e 280extern struct option long_options[];
56eedc1a 281extern char Version[], Usage[], Help[], OptionHelp[],
5187a385 282 *mode_help[],
dd0781e5 283 Help_create[], Help_build[], Help_assemble[], Help_grow[],
8382f19b 284 Help_incr[],
e0d19036 285 Help_manage[], Help_misc[], Help_monitor[], Help_config[];
64c4757e 286
997aed5d 287/* for option that don't have short equivilents, we assign arbitrary
1c7a808c 288 * numbers later than any 'short' character option.
997aed5d
NB
289 */
290enum special_options {
1c7a808c 291 AssumeClean = 300,
997aed5d
NB
292 BitmapChunk,
293 WriteBehind,
294 ReAdd,
295 NoDegraded,
296 Sparc22,
1c7a808c 297 BackupFile,
997aed5d 298 HomeHost,
589395d6 299 AutoHomeHost,
38098016 300 Symlinks,
1f48664b 301 AutoDetect,
1770662b 302 Waitclean,
4cce4069 303 DetailPlatform,
33414a01 304 KillSubarray,
1c7a808c 305 UpdateSubarray,
edde9560 306 IncrementalPath,
1c7a808c
N
307 NoSharing,
308 HelpOptions,
309 Brief,
310 ManageOpt,
311 Add,
312 Remove,
313 Fail,
70c55e36
N
314 Replace,
315 With,
1c7a808c
N
316 MiscOpt,
317 WaitOpt,
318 ConfigFile,
319 ChunkSize,
320 WriteMostly,
321 Layout,
322 Auto,
323 Force,
324 SuperMinor,
325 EMail,
326 ProgramOpt,
327 Increment,
328 Fork,
329 Bitmap,
330 RebuildMapOpt,
87f26d14 331 InvalidBackup,
20b60dcd 332 UdevRules,
b76b30e0 333 FreezeReshape,
2dddadb0 334 Continue,
08ca2adf 335 OffRootOpt,
c2ecf5f6 336 Prefer,
f7d3febc 337 KillOpt,
40c9a66a 338 DataOffset,
6d388a88 339 ExamineBB,
74db60b0
N
340 Dump,
341 Restore,
997aed5d
NB
342};
343
f0ec6710
MN
344enum prefix_standard {
345 JEDEC,
346 IEC
347};
348
64c4757e 349/* structures read from config file */
52826846
NB
350/* List of mddevice names and identifiers
351 * Identifiers can be:
352 * uuid=128-hex-uuid
353 * super-minor=decimal-minor-number-from-superblock
354 * devices=comma,separated,list,of,device,names,with,wildcards
355 *
356 * If multiple fields are present, the intersection of all matching
357 * devices is considered
358 */
98c6faba 359#define UnSet (0xfffe)
fa56eddb 360struct mddev_ident {
dd0781e5 361 char *devname;
aba69144 362
dd0781e5 363 int uuid_set;
3fa06e9d 364 int uuid[4];
947fd4dd 365 char name[33];
52826846 366
f21e18ca 367 int super_minor;
52826846 368
dd0781e5 369 char *devices; /* comma separated list of device
52826846
NB
370 * names with wild cards
371 */
dd0781e5 372 int level;
f21e18ca
N
373 int raid_disks;
374 int spare_disks;
82d9eba6 375 struct supertype *st;
dd0781e5
NB
376 int autof; /* 1 for normal, 2 for partitioned */
377 char *spare_group;
7ef02d01 378 char *bitmap_file;
c82f047c 379 int bitmap_fd;
dd0781e5 380
1771a6e2
N
381 char *container; /* /dev/whatever name of container, or
382 * uuid of container. You would expect
383 * this to be the 'devname' or UUID
dbb44303
N
384 * of some other entry.
385 */
386 char *member; /* subarray within a container */
387
fa56eddb 388 struct mddev_ident *next;
b179246f
N
389 union {
390 /* fields needed by different users of this structure */
391 int assembled; /* set when assembly succeeds */
392 };
fa56eddb 393};
64c4757e 394
9e33d556
N
395struct context {
396 int readonly;
397 int runstop;
398 int verbose;
9e33d556
N
399 int brief;
400 int force;
401 char *homehost;
402 int require_homehost;
403 char *prefer;
404 int export;
405 int test;
406 char *subarray;
407 char *update;
408 int scan;
409 int SparcAdjust;
410 int autof;
411 int delay;
412 int freeze_reshape;
413 char *backup_file;
414 int invalid_backup;
415};
416
e705e81b
N
417struct shape {
418 int raiddisks;
419 int sparedisks;
420 int level;
421 int layout;
422 char *layout_str;
423 int chunk;
424 int bitmap_chunk;
425 char *bitmap_file;
426 int assume_clean;
427 int write_behind;
428 unsigned long long size;
429};
430
64c4757e 431/* List of device names - wildcards expanded */
a655e550 432struct mddev_dev {
64c4757e 433 char *devname;
c8e1a230
N
434 int disposition; /* 'a' for add, 'r' for remove, 'f' for fail,
435 * 'A' for re_add.
cd29a5c8
NB
436 * Not set for names read from .config
437 */
b3d31955 438 char writemostly; /* 1 for 'set writemostly', 2 for 'clear writemostly' */
70c55e36 439 int used; /* set when used */
72ca9bcf 440 long long data_offset;
a655e550
N
441 struct mddev_dev *next;
442};
64c4757e 443
682c7051
NB
444typedef struct mapping {
445 char *name;
446 int num;
447} mapping_t;
448
e0d19036
NB
449struct mdstat_ent {
450 char *dev;
4dd2df09 451 char devnm[32];
e0d19036
NB
452 int active;
453 char *level;
454 char *pattern; /* U or up, _ for down */
455 int percent; /* -1 if no resync */
f94c116f 456 int resync; /* 3 if check, 2 if reshape, 1 if resync, 0 if recovery */
549e9569
NB
457 int devcnt;
458 int raid_disks;
549e9569 459 char * metadata_version;
3b57c466
N
460 struct dev_member {
461 char *name;
462 struct dev_member *next;
1011e834 463 } *members;
e0d19036
NB
464 struct mdstat_ent *next;
465};
466
22a88995 467extern struct mdstat_ent *mdstat_read(int hold, int start);
e0d19036 468extern void free_mdstat(struct mdstat_ent *ms);
dd0781e5 469extern void mdstat_wait(int seconds);
58a4ba2a 470extern void mdstat_wait_fd(int fd, const sigset_t *sigmask);
4dd2df09 471extern int mddev_busy(char *devnm);
3b57c466 472extern struct mdstat_ent *mdstat_by_component(char *name);
4dd2df09 473extern struct mdstat_ent *mdstat_by_subdev(char *subdev, char *container);
8382f19b
NB
474
475struct map_ent {
476 struct map_ent *next;
4dd2df09 477 char devnm[32];
1522c538 478 char metadata[20];
8382f19b 479 int uuid[4];
195254b8 480 int bad;
8382f19b
NB
481 char *path;
482};
4dd2df09 483extern int map_update(struct map_ent **mpp, char *devnm, char *metadata,
8382f19b 484 int uuid[4], char *path);
4dd2df09 485extern void map_remove(struct map_ent **map, char *devnm);
8382f19b 486extern struct map_ent *map_by_uuid(struct map_ent **map, int uuid[4]);
4dd2df09 487extern struct map_ent *map_by_devnm(struct map_ent **map, char *devnm);
f2e55ecc 488extern struct map_ent *map_by_name(struct map_ent **map, char *name);
8382f19b
NB
489extern void map_read(struct map_ent **melp);
490extern int map_write(struct map_ent *mel);
4dd2df09 491extern void map_delete(struct map_ent **mapp, char *devnm);
8382f19b
NB
492extern void map_free(struct map_ent *map);
493extern void map_add(struct map_ent **melp,
4dd2df09 494 char *devnm, char *metadata, int uuid[4], char *path);
ad5bc697
N
495extern int map_lock(struct map_ent **melp);
496extern void map_unlock(struct map_ent **melp);
cc700db3 497extern void map_fork(void);
e0d19036 498
e86c9dd6 499/* various details can be requested */
dab4a513
DW
500enum sysfs_read_flags {
501 GET_LEVEL = (1 << 0),
502 GET_LAYOUT = (1 << 1),
503 GET_COMPONENT = (1 << 2),
504 GET_CHUNK = (1 << 3),
505 GET_CACHE = (1 << 4),
506 GET_MISMATCH = (1 << 5),
507 GET_VERSION = (1 << 6),
508 GET_DISKS = (1 << 7),
509 GET_DEGRADED = (1 << 8),
510 GET_SAFEMODE = (1 << 9),
c0c1acd6
N
511 GET_BITMAP_LOCATION = (1 << 10),
512
513 GET_DEVS = (1 << 20), /* gets role, major, minor */
514 GET_OFFSET = (1 << 21),
515 GET_SIZE = (1 << 22),
516 GET_STATE = (1 << 23),
517 GET_ERROR = (1 << 24),
dab4a513 518};
e86c9dd6
NB
519
520/* If fd >= 0, get the array it is open on,
4dd2df09 521 * else use devnm.
e86c9dd6 522 */
4dd2df09
N
523extern int sysfs_open(char *devnm, char *devname, char *attr);
524extern void sysfs_init(struct mdinfo *mdi, int fd, char *devnm);
7e0f6979 525extern void sysfs_free(struct mdinfo *sra);
4dd2df09 526extern struct mdinfo *sysfs_read(int fd, char *devnm, unsigned long options);
1770662b
DW
527extern int sysfs_attr_match(const char *attr, const char *str);
528extern int sysfs_match_word(const char *word, char **list);
7e0f6979 529extern int sysfs_set_str(struct mdinfo *sra, struct mdinfo *dev,
e86c9dd6 530 char *name, char *val);
7e0f6979 531extern int sysfs_set_num(struct mdinfo *sra, struct mdinfo *dev,
e86c9dd6 532 char *name, unsigned long long val);
012a8641
JS
533extern int sysfs_set_num_signed(struct mdinfo *sra, struct mdinfo *dev,
534 char *name, long long val);
97590376 535extern int sysfs_uevent(struct mdinfo *sra, char *event);
7236ee7a
N
536extern int sysfs_get_fd(struct mdinfo *sra, struct mdinfo *dev,
537 char *name);
538extern int sysfs_fd_get_ll(int fd, unsigned long long *val);
7e0f6979 539extern int sysfs_get_ll(struct mdinfo *sra, struct mdinfo *dev,
e86c9dd6 540 char *name, unsigned long long *val);
7236ee7a 541extern int sysfs_fd_get_str(int fd, char *val, int size);
bc77ed53
DW
542extern int sysfs_attribute_available(struct mdinfo *sra, struct mdinfo *dev,
543 char *name);
93ecfa01
N
544extern int sysfs_get_str(struct mdinfo *sra, struct mdinfo *dev,
545 char *name, char *val, int size);
8ed3e5e1 546extern int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms);
f35f2525 547extern int sysfs_set_array(struct mdinfo *info, int vers);
2904b26f 548extern int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume);
f1665f72 549extern int sysfs_disk_to_scsi_id(int fd, __u32 *id);
4dd2df09 550extern int sysfs_unique_holder(char *devnm, long rdev);
bc77ed53 551extern int sysfs_freeze_array(struct mdinfo *sra);
c69b251b 552extern int load_sys(char *path, char *buf);
130994cb
AK
553extern int reshape_prepare_fdlist(char *devname,
554 struct mdinfo *sra,
555 int raid_disks,
556 int nrdisks,
557 unsigned long blocks,
558 char *backup_file,
559 int *fdlist,
560 unsigned long long *offsets);
561extern void reshape_free_fdlist(int *fdlist,
562 unsigned long long *offsets,
563 int size);
e6e9d47b
AK
564extern int reshape_open_backup_file(char *backup,
565 int fd,
566 char *devname,
567 long blocks,
568 int *fdlist,
a93f87ee
N
569 unsigned long long *offsets,
570 int restart);
1c009fc2
AK
571extern unsigned long compute_backup_blocks(int nchunk, int ochunk,
572 unsigned int ndata, unsigned int odata);
e86c9dd6
NB
573
574extern int save_stripes(int *source, unsigned long long *offsets,
575 int raid_disks, int chunk_size, int level, int layout,
576 int nwrites, int *dest,
a6288483
N
577 unsigned long long start, unsigned long long length,
578 char *buf);
353632d9
NB
579extern int restore_stripes(int *dest, unsigned long long *offsets,
580 int raid_disks, int chunk_size, int level, int layout,
581 int source, unsigned long long read_offset,
2fcb75ae
AK
582 unsigned long long start, unsigned long long length,
583 char *src_buf);
e86c9dd6 584
52826846
NB
585#ifndef Sendmail
586#define Sendmail "/usr/lib/sendmail -t"
587#endif
588
773135f5
NB
589#define SYSLOG_FACILITY LOG_DAEMON
590
682c7051
NB
591extern char *map_num(mapping_t *map, int num);
592extern int map_name(mapping_t *map, char *name);
b640a252 593extern mapping_t r5layout[], r6layout[], pers[], modes[], faultylayout[];
682c7051 594
c2ecf5f6
N
595extern char *map_dev_preferred(int major, int minor, int create,
596 char *prefer);
597static inline char *map_dev(int major, int minor, int create)
598{
599 return map_dev_preferred(major, minor, create, NULL);
600}
64c4757e 601
549e9569 602struct active_array;
2e735d19 603struct metadata_update;
64c4757e 604
80bf9135 605/* 'struct reshape' records the intermediate states of
999b4972
N
606 * a general reshape.
607 * The starting geometry is converted to the 'before' geometry
608 * by at most an atomic level change. They could be the same.
609 * Similarly the 'after' geometry is converted to the final
610 * geometry by at most a level change.
611 * Note that 'before' and 'after' must have the same level.
612 * 'blocks' is the minimum number of sectors for a reshape unit.
613 * This will be a multiple of the stripe size in each of the
614 * 'before' and 'after' geometries.
615 * If 'blocks' is 0, no restriping is necessary.
89ecd3cf
N
616 * 'min_offset_change' is the minimum change to data_offset to
617 * allow the reshape to happen. It is at least the larger of
618 * the old and new chunk sizes, and typically the same as 'blocks'
619 * divided by number of data disks.
999b4972
N
620 */
621struct reshape {
622 int level;
623 int parity; /* number of parity blocks/devices */
624 struct {
625 int layout;
626 int data_disks;
627 } before, after;
628 unsigned long long backup_blocks;
89ecd3cf 629 unsigned long long min_offset_change;
999b4972
N
630 unsigned long long stripes; /* number of old stripes that comprise 'blocks'*/
631 unsigned long long new_size; /* New size of array in sectors */
632};
633
6adfd3af
NB
634/* A superswitch provides entry point the a metadata handler.
635 *
74db60b0 636 * The superswitch primarily operates on some "metadata" that
6adfd3af
NB
637 * is accessed via the 'supertype'.
638 * This metadata has one of three possible sources.
639 * 1/ It is read from a single device. In this case it may not completely
640 * describe the array or arrays as some information might be on other
641 * devices.
642 * 2/ It is read from all devices in a container. In this case all
643 * information is present.
644 * 3/ It is created by ->init_super / ->add_to_super. In this case it will
645 * be complete once enough ->add_to_super calls have completed.
646 *
647 * When creating an array inside a container, the metadata will be
648 * formed by a combination of 2 and 3. The metadata or the array is read,
649 * then new information is added.
650 *
651 * The metadata must sometimes have a concept of a 'current' array
652 * and a 'current' device.
653 * The 'current' array is set by init_super to be the newly created array,
654 * or is set by super_by_fd when it finds it is looking at an array inside
655 * a container.
656 *
657 * The 'current' device is either the device that the metadata was read from
658 * in case 1, or the last device added by add_to_super in case 3.
659 * Case 2 does not identify a 'current' device.
660 */
f9ce90ba 661extern struct superswitch {
6adfd3af
NB
662
663 /* Used to report details of metadata read from a component
664 * device. ->load_super has been called.
665 */
3da92f27 666 void (*examine_super)(struct supertype *st, char *homehost);
061f2c6a 667 void (*brief_examine_super)(struct supertype *st, int verbose);
4737ae25 668 void (*brief_examine_subarrays)(struct supertype *st, int verbose);
0d726f17 669 void (*export_examine_super)(struct supertype *st);
6d388a88 670 int (*examine_badblocks)(struct supertype *st, int fd, char *devname);
74db60b0 671 int (*copy_metadata)(struct supertype *st, int from, int to);
6adfd3af
NB
672
673 /* Used to report details of an active array.
674 * ->load_super was possibly given a 'component' string.
675 */
3da92f27 676 void (*detail_super)(struct supertype *st, char *homehost);
3da92f27 677 void (*brief_detail_super)(struct supertype *st);
0d726f17 678 void (*export_detail_super)(struct supertype *st);
6adfd3af 679
4cce4069 680 /* Optional: platform hardware / firmware details */
9eafa1de
MN
681 int (*detail_platform)(int verbose, int enumerate_only, char *controller_path);
682 int (*export_detail_platform)(int verbose, char *controller_path);
4cce4069 683
6adfd3af
NB
684 /* Used:
685 * to get uuid to storing in bitmap metadata
686 * and 'reshape' backup-data metadata
687 * To see if a device is being re-added to an array it was part of.
688 */
3da92f27 689 void (*uuid_from_super)(struct supertype *st, int uuid[4]);
6adfd3af 690
8592f29d 691 /* Extract generic details from metadata. This could be details about
6adfd3af
NB
692 * the container, or about an individual array within the container.
693 * The determination is made either by:
694 * load_super being given a 'component' string.
695 * validate_geometry determining what to create.
d2ca6449
NB
696 * The info includes both array information and device information.
697 * The particular device should be:
698 * The last device added by add_to_super
699 * The device the metadata was loaded from by load_super
a5d85af7
N
700 * If 'map' is present, then it is an array raid_disks long
701 * (raid_disk must already be set and correct) and it is filled
702 * with 1 for slots that are thought to be active and 0 for slots which
703 * appear to be failed/missing.
95eeceeb 704 * *info is zeroed out before data is added.
6adfd3af 705 */
a5d85af7 706 void (*getinfo_super)(struct supertype *st, struct mdinfo *info, char *map);
5c4cd5da 707 struct mdinfo *(*getinfo_super_disks)(struct supertype *st);
6adfd3af 708 /* Check if the given metadata is flagged as belonging to "this"
9362c1c8 709 * host. 0 for 'no', 1 for 'yes', -1 for "Don't record homehost"
6adfd3af 710 */
3da92f27 711 int (*match_home)(struct supertype *st, char *homehost);
6adfd3af
NB
712
713 /* Make one of several generic modifications to metadata
714 * prior to assembly (or other times).
715 * sparc2.2 - first bug in early 0.90 metadata
716 * super-minor - change name of 0.90 metadata
717 * summaries - 'correct' any redundant data
718 * resync - mark array as dirty to trigger a resync.
719 * uuid - set new uuid - only 0.90 or 1.x
720 * name - change the name of the array (where supported)
721 * homehost - change which host this array is tied to.
722 * devicesize - If metadata is at start of device, change recorded
723 * device size to match actual device size
724 * byteorder - swap bytes for 0.90 metadata
725 *
726 * force-one - mark that device as uptodate, not old or failed.
727 * force-array - mark array as clean if it would not otherwise
728 * assemble
729 * assemble - not sure how this is different from force-one...
730 * linear-grow-new - add a new device to a linear array, but don't
731 * change the size: so superblock still matches
732 * linear-grow-update - now change the size of the array.
16715c01
DL
733 * writemostly - set the WriteMostly1 bit in the superblock devflags
734 * readwrite - clear the WriteMostly1 bit in the superblock devflags
199f1a1f
N
735 * no-bitmap - clear any record that a bitmap is present.
736 * bbl - add a bad-block-log if possible
737 * no-bbl - remove and bad-block-log is it is empty.
738 * revert-reshape - If a reshape is in progress, modify metadata so
739 * it will resume going in the opposite direction.
6adfd3af 740 */
68c7d6d7 741 int (*update_super)(struct supertype *st, struct mdinfo *info,
3da92f27 742 char *update,
e5eac01f
NB
743 char *devname, int verbose,
744 int uuid_set, char *homehost);
6adfd3af
NB
745
746 /* Create new metadata for new array as described. This could
747 * be a new container, or an array in a pre-existing container.
748 * Also used to zero metadata prior to writing it to invalidate old
749 * metadata.
750 */
3da92f27
NB
751 int (*init_super)(struct supertype *st, mdu_array_info_t *info,
752 unsigned long long size, char *name,
83cd1e97
N
753 char *homehost, int *uuid,
754 unsigned long long data_offset);
6adfd3af
NB
755
756 /* update the metadata to include new device, either at create or
757 * when hot-adding a spare.
758 */
f20c3968 759 int (*add_to_super)(struct supertype *st, mdu_disk_info_t *dinfo,
72ca9bcf
N
760 int fd, char *devname,
761 unsigned long long data_offset);
1a64be56
LM
762 /* update the metadata to delete a device,
763 * when hot-removing.
764 */
765 int (*remove_from_super)(struct supertype *st, mdu_disk_info_t *dinfo);
6adfd3af
NB
766
767 /* Write metadata to one device when fixing problems or adding
768 * a new device.
769 */
3da92f27 770 int (*store_super)(struct supertype *st, int fd);
6adfd3af
NB
771
772 /* Write all metadata for this array.
773 */
111d01fc 774 int (*write_init_super)(struct supertype *st);
e2f408a4
N
775 /* Check if metadata read from one device is compatible with an array,
776 * used when assembling an array, or pseudo-assembling was with
777 * "--examine --brief"
778 * If "st" has not yet been loaded the superblock from, "tst" is
779 * moved in, otherwise the superblock in 'st' is compared with
780 * 'tst'.
781 */
64557c33 782 int (*compare_super)(struct supertype *st, struct supertype *tst);
e2f408a4
N
783 /* Load metadata from a single device. If 'devname' is not NULL
784 * print error messages as appropriate */
3da92f27 785 int (*load_super)(struct supertype *st, int fd, char *devname);
e2f408a4
N
786 /* 'fd' is a 'container' md array - load array metadata from the
787 * whole container.
788 */
2b959fbf 789 int (*load_container)(struct supertype *st, int fd, char *devname);
e2f408a4
N
790 /* If 'arg' is a valid name of this metadata type, allocate and
791 * return a 'supertype' for the particular minor version */
82d9eba6 792 struct supertype * (*match_metadata_desc)(char *arg);
e2f408a4
N
793 /* If a device has the given size, and the data_offset has been
794 * requested - work out how much space is available for data.
795 * This involves adjusting for reserved space (e.g. bitmaps)
796 * and for any rounding.
797 * 'mdadm' only calls this for existing arrays where a possible
798 * spare is being added. However some super-handlers call it
799 * internally from validate_geometry when creating an array.
800 */
387fcd59
N
801 __u64 (*avail_size)(struct supertype *st, __u64 size,
802 unsigned long long data_offset);
e2f408a4
N
803 /* This is similar to 'avail_size' in purpose, but is used for
804 * containers for which there is no 'component size' to compare.
805 * This reports that whole-device size which is a minimum
806 */
80e7f8c3 807 unsigned long long (*min_acceptable_spare_size)(struct supertype *st);
e2f408a4
N
808 /* Find somewhere to put a bitmap - possibly auto-size it - and
809 * update the metadata to record this. The array may be newly
810 * created, in which case data_size may be updated, or it might
811 * already exist. Metadata handler can know if init_super
812 * has been called, but not write_init_super.
813 */
3da92f27 814 int (*add_internal_bitmap)(struct supertype *st, int *chunkp,
199171a2 815 int delay, int write_behind,
f9c25f1d 816 unsigned long long size, int may_change, int major);
e2f408a4
N
817 /* Seek 'fd' to start of write-intent-bitmap. Must be an
818 * md-native format bitmap
819 */
3da92f27 820 void (*locate_bitmap)(struct supertype *st, int fd);
e2f408a4
N
821 /* if add_internal_bitmap succeeded for existing array, this
822 * writes it out.
823 */
3da92f27 824 int (*write_bitmap)(struct supertype *st, int fd);
e2f408a4 825 /* Free the superblock and any other allocated data */
3da92f27 826 void (*free_super)(struct supertype *st);
78e44928
NB
827
828 /* validate_geometry is called with an st returned by
829 * match_metadata_desc.
e2f408a4 830 * It should check that the geometry described is compatible with
78e44928
NB
831 * the metadata type. It will be called repeatedly as devices
832 * added to validate changing size and new devices. If there are
833 * inter-device dependencies, it should record sufficient details
834 * so these can be validated.
30f58b22 835 * Both 'size' and '*freesize' are in sectors. chunk is KiB.
ecbd9e81
N
836 * Return value is:
837 * 1: everything is OK
838 * 0: not OK for some reason - if 'verbose', then error was reported.
839 * -1: st->sb was NULL, 'subdev' is a member of a container of this
e2f408a4 840 * type, but array is not acceptable for some reason
ecbd9e81 841 * message was reported even if verbose is 0.
78e44928 842 */
17f25ca6
NB
843 int (*validate_geometry)(struct supertype *st, int level, int layout,
844 int raiddisks,
c21e737b 845 int *chunk, unsigned long long size,
af4348dd 846 unsigned long long data_offset,
2c514b71
NB
847 char *subdev, unsigned long long *freesize,
848 int verbose);
598f0d58 849
e2f408a4
N
850 /* Return a linked list of 'mdinfo' structures for all arrays
851 * in the container. For non-containers, it is like
852 * getinfo_super with an allocated mdinfo.*/
00bbdbda 853 struct mdinfo *(*container_content)(struct supertype *st, char *subarray);
30f58b22
DW
854 /* query the supertype for default geometry */
855 void (*default_geometry)(struct supertype *st, int *level, int *layout, int *chunk); /* optional */
33414a01
DW
856 /* Permit subarray's to be deleted from inactive containers */
857 int (*kill_subarray)(struct supertype *st); /* optional */
aa534678 858 /* Permit subarray's to be modified */
a951a4f7 859 int (*update_subarray)(struct supertype *st, char *subarray,
fa56eddb 860 char *update, struct mddev_ident *ident); /* optional */
7bc71196
DW
861 /* Check if reshape is supported for this external format.
862 * st is obtained from super_by_fd() where st->subarray[0] is
863 * initialized to indicate if reshape is being performed at the
864 * container or subarray level
865 */
016e00f5
AK
866#define APPLY_METADATA_CHANGES 1
867#define ROLLBACK_METADATA_CHANGES 0
868
d04f65f4
N
869 int (*reshape_super)(struct supertype *st,
870 unsigned long long size, int level,
7bc71196 871 int layout, int chunksize, int raid_disks,
41784c88 872 int delta_disks, char *backup, char *dev,
016e00f5 873 int direction,
41784c88 874 int verbose); /* optional */
999b4972
N
875 int (*manage_reshape)( /* optional */
876 int afd, struct mdinfo *sra, struct reshape *reshape,
877 struct supertype *st, unsigned long blocks,
878 int *fds, unsigned long long *offsets,
879 int dests, int *destfd, unsigned long long *destoffsets);
598f0d58 880
549e9569 881/* for mdmon */
cba0191b
NB
882 int (*open_new)(struct supertype *c, struct active_array *a,
883 char *inst);
ed9d66aa
NB
884
885 /* Tell the metadata handler the current state of the array.
886 * This covers whether it is known to be consistent (no pending writes)
01f157d7 887 * and how far along a resync is known to have progressed
ed9d66aa
NB
888 * (in a->resync_start).
889 * resync status is really irrelevant if the array is not consistent,
890 * but some metadata (DDF!) have a place to record the distinction.
1011e834 891 * If 'consistent' is '2', then the array can mark it dirty if a
01f157d7
N
892 * resync/recovery/whatever is required, or leave it clean if not.
893 * Return value is 0 dirty (not consistent) and 1 if clean.
894 * it is only really important if consistent is passed in as '2'.
4e5528c6 895 */
01f157d7 896 int (*set_array_state)(struct active_array *a, int consistent);
7a7cc504
NB
897
898 /* When the state of a device might have changed, we call set_disk to
899 * tell the metadata what the current state is.
900 * Typically this happens on spare->in_sync and (spare|in_sync)->faulty
901 * transitions.
902 * set_disk might be called when the state of the particular disk has
903 * not in fact changed.
904 */
8d45d196 905 void (*set_disk)(struct active_array *a, int n, int state);
2e735d19
NB
906 void (*sync_metadata)(struct supertype *st);
907 void (*process_update)(struct supertype *st,
908 struct metadata_update *update);
edd8d13c
NB
909 void (*prepare_update)(struct supertype *st,
910 struct metadata_update *update);
549e9569 911
6c3fb95c
NB
912 /* activate_spare will check if the array is degraded and, if it
913 * is, try to find some spare space in the container.
914 * On success, it add appropriate updates (For process_update) to
915 * to the 'updates' list and returns a list of 'mdinfo' identifying
916 * the device, or devices as there might be multiple missing
917 * devices and multiple spares available.
918 */
919 struct mdinfo *(*activate_spare)(struct active_array *a,
920 struct metadata_update **updates);
2cda7640
ML
921 /*
922 * Return statically allocated string that represents metadata specific
923 * controller domain of the disk. The domain is used in disk domain
924 * matching functions. Disks belong to the same domain if the they have
925 * the same domain from mdadm.conf and belong the same metadata domain.
926 * Returning NULL or not providing this handler means that metadata
927 * does not distinguish the differences between disks that belong to
928 * different controllers. They are in the domain specified by
929 * configuration file (mdadm.conf).
930 * In case when the metadata has the notion of domains based on disk
931 * it shall return NULL for disks that do not belong to the controller
932 * the supported domains. Such disks will form another domain and won't
933 * be mixed with supported ones.
934 */
935 const char *(*get_disk_controller_domain)(const char *path);
549e9569 936
ba53ea59
AK
937 /* for external backup area */
938 int (*recover_backup)(struct supertype *st, struct mdinfo *info);
939
f277ce36 940 int swapuuid; /* true if uuid is bigending rather than hostendian */
d03373f1 941 int external;
4cce4069 942 const char *name; /* canonical metadata name */
0f22b998 943} *superlist[];
82d9eba6 944
0f22b998
N
945extern struct superswitch super0, super1;
946extern struct superswitch super_imsm, super_ddf;
0592faeb 947extern struct superswitch mbr, gpt;
cdddbdbc 948
edd8d13c
NB
949struct metadata_update {
950 int len;
951 char *buf;
952 void *space; /* allocated space that monitor will use */
cb23f1f4
N
953 void **space_list; /* list of allocated spaces that monitor can
954 * use or that it returned.
955 */
edd8d13c
NB
956 struct metadata_update *next;
957};
958
6adfd3af
NB
959/* A supertype holds a particular collection of metadata.
960 * It identifies the metadata type by the superswitch, and the particular
961 * sub-version of that metadata type.
962 * metadata read in or created is stored in 'sb' and 'info'.
963 * There are also fields used by mdmon to track containers.
964 *
352452c3
N
965 * A supertype may refer to:
966 * Just an array, possibly in a container
967 * A container, not identifying any particular array
968 * Info read from just one device, not yet fully describing the array/container.
969 *
970 *
6adfd3af
NB
971 * A supertype is created by:
972 * super_by_fd
973 * guess_super
974 * dup_super
975 */
82d9eba6
NB
976struct supertype {
977 struct superswitch *ss;
978 int minor_version;
ea329559 979 int max_devs;
4dd2df09 980 char container_devnm[32]; /* devnm of container */
64557c33 981 void *sb;
111d01fc 982 void *info;
afa368f4
N
983 void *other; /* Hack used to convert v0.90 to v1.0 */
984 unsigned long long devsize;
df3346e6
LM
985 int ignore_hw_compat; /* used to inform metadata handlers that it should ignore
986 HW/firmware related incompatability to load metadata.
987 Used when examining metadata to display content of disk
988 when user has no hw/firmare compatible system.
989 */
edd8d13c
NB
990 struct metadata_update *updates;
991 struct metadata_update **update_tail;
992
549e9569
NB
993 /* extra stuff used by mdmon */
994 struct active_array *arrays;
549e9569 995 int sock; /* listen to external programs */
4dd2df09
N
996 char devnm[32]; /* e.g. md0. This appears in metadata_version:
997 * external:/md0/12
998 */
549e9569 999 int devcnt;
68226a80 1000 int retry_soon;
549e9569
NB
1001
1002 struct mdinfo *devs;
1003
82d9eba6 1004};
f9ce90ba 1005
4725bc31 1006extern struct supertype *super_by_fd(int fd, char **subarray);
54887ad8
N
1007enum guess_types { guess_any, guess_array, guess_partitions };
1008extern struct supertype *guess_super_type(int fd, enum guess_types guess_type);
1009static inline struct supertype *guess_super(int fd) {
1010 return guess_super_type(fd, guess_any);
1011}
3da92f27 1012extern struct supertype *dup_super(struct supertype *st);
beae1dfe 1013extern int get_dev_size(int fd, char *dname, unsigned long long *sizep);
3a371610 1014extern int must_be_container(int fd);
0f0749ad 1015extern int dev_size_from_id(dev_t id, unsigned long long *size);
a7c6e3fb 1016void wait_for(char *dev, int fd);
f9ce90ba 1017
5527fc74
N
1018/*
1019 * Data structures for policy management.
1020 * Each device can have a policy structure that lists
1021 * various name/value pairs each possibly with a metadata associated.
1022 * The policy list is sorted by name/value/metadata
1023 */
1024struct dev_policy {
1025 struct dev_policy *next;
1026 char *name; /* None of these strings are allocated. They are
1027 * all just references to strings which are known
1028 * to exist elsewhere.
1029 * name and metadata can be compared by address equality.
1030 */
1031 const char *metadata;
2cda7640 1032 const char *value;
5527fc74
N
1033};
1034
4e8d9f0a 1035extern char pol_act[], pol_domain[], pol_metadata[], pol_auto[];
5527fc74
N
1036
1037/* iterate over the sublist starting at list, having the same
1038 * 'name' as 'list', and matching the given metadata (Where
1039 * NULL matches anything
1040 */
1041#define pol_for_each(item, list, _metadata) \
1042 for (item = list; \
1043 item && item->name == list->name; \
1044 item = item->next) \
1045 if (!(!_metadata || !item->metadata || _metadata == item->metadata)) \
1046 ; else
1047
1048/*
1049 * policy records read from mdadm are largely just name-value pairs.
1050 * The names are constants, not strdupped
1051 */
1052struct pol_rule {
1053 struct pol_rule *next;
1054 char *type; /* rule_policy or rule_part */
1055 struct rule {
1056 struct rule *next;
1057 char *name;
1058 char *value;
1059 char *dups; /* duplicates of 'value' with a partNN appended */
1060 } *rule;
1061};
1062
1063extern char rule_policy[], rule_part[];
1064extern char rule_path[], rule_type[];
1065extern char type_part[], type_disk[];
1066
1067extern void policyline(char *line, char *type);
4e8d9f0a 1068extern void policy_add(char *type, ...);
5527fc74
N
1069extern void policy_free(void);
1070
73c9c47c 1071extern struct dev_policy *path_policy(char *path, char *type);
5527fc74 1072extern struct dev_policy *disk_policy(struct mdinfo *disk);
4dd2df09 1073extern struct dev_policy *devid_policy(int devid);
5527fc74
N
1074extern void dev_policy_free(struct dev_policy *p);
1075
e78dda3b
N
1076//extern void pol_new(struct dev_policy **pol, char *name, char *val, char *metadata);
1077extern void pol_add(struct dev_policy **pol, char *name, char *val, char *metadata);
5527fc74
N
1078extern struct dev_policy *pol_find(struct dev_policy *pol, char *name);
1079
e3bb5f14
N
1080enum policy_action {
1081 act_default,
1082 act_include,
1083 act_re_add,
d2db3045
N
1084 act_spare, /* This only applies to bare devices */
1085 act_spare_same_slot, /* this allows non-bare devices,
1086 * but only if recent removal */
1087 act_force_spare, /* this allow non-bare devices in any case */
e3bb5f14
N
1088 act_err
1089};
1090
1091extern int policy_action_allows(struct dev_policy *plist, const char *metadata,
1092 enum policy_action want);
1093extern int disk_action_allows(struct mdinfo *disk, const char *metadata,
1094 enum policy_action want);
f5f12c84
N
1095
1096struct domainlist {
1097 struct domainlist *next;
2cda7640 1098 const char *dom;
f5f12c84
N
1099};
1100
1101extern int domain_test(struct domainlist *dom, struct dev_policy *pol,
1102 const char *metadata);
1103extern struct domainlist *domain_from_array(struct mdinfo *mdi,
1104 const char *metadata);
4dd2df09 1105extern void domainlist_add_dev(struct domainlist **dom, int devid,
e78dda3b 1106 const char *metadata);
f5f12c84
N
1107extern void domain_free(struct domainlist *dl);
1108extern void domain_merge(struct domainlist **domp, struct dev_policy *pol,
1109 const char *metadata);
e78dda3b 1110void domain_add(struct domainlist **domp, char *domain);
f5f12c84 1111
403410eb
PC
1112extern void policy_save_path(char *id_path, struct map_ent *array);
1113extern int policy_check_path(struct mdinfo *disk, struct map_ent *array);
1114
838acbc2
NB
1115#if __GNUC__ < 3
1116struct stat64;
1117#endif
1118
45e878bb
NB
1119#define HAVE_NFTW we assume
1120#define HAVE_FTW
1121
2df1f269 1122#ifdef __UCLIBC__
45e878bb 1123# include <features.h>
2df1f269
BRF
1124# ifndef __UCLIBC_HAS_LFS__
1125# define lseek64 lseek
1126# endif
45e878bb
NB
1127# ifndef __UCLIBC_HAS_FTW__
1128# undef HAVE_FTW
1129# undef HAVE_NFTW
1130# endif
1131#endif
1132
1133#ifdef __dietlibc__
1134# undef HAVE_NFTW
1135#endif
1136
e39b673e 1137#if defined(__KLIBC__)
1138# undef HAVE_NFTW
1139# undef HAVE_FTW
1140#endif
1141
45e878bb 1142#ifndef HAVE_NFTW
173fc515 1143# define FTW_PHYS 1
45e878bb
NB
1144# ifndef HAVE_FTW
1145 struct FTW {};
173fc515
NB
1146# endif
1147#endif
1148
45e878bb
NB
1149#ifdef HAVE_FTW
1150# include <ftw.h>
1151#endif
1152
173fc515
NB
1153extern int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s);
1154
64c4757e 1155extern int Manage_ro(char *devname, int fd, int readonly);
fe7e0e64
N
1156extern int Manage_run(char *devname, int fd, int quiet);
1157extern int Manage_stop(char *devname, int fd, int quiet,
1158 int will_retry);
64c4757e 1159extern int Manage_subdevs(char *devname, int fd,
833bb0f8 1160 struct mddev_dev *devlist, int verbose, int test,
11b391ec 1161 char *update, int force);
1f48664b 1162extern int autodetect(void);
e5329c37 1163extern int Grow_Add_device(char *devname, int fd, char *newdev);
50f01ba5
N
1164extern int Grow_addbitmap(char *devname, int fd,
1165 struct context *c, struct shape *s);
32754b7d 1166extern int Grow_reshape(char *devname, int fd,
e2e53a2d 1167 struct mddev_dev *devlist,
40c9a66a 1168 unsigned long long data_offset,
32754b7d 1169 struct context *c, struct shape *s);
06b0d786 1170extern int Grow_restart(struct supertype *st, struct mdinfo *info,
ea0ebe96 1171 int *fdlist, int cnt, char *backup_file, int verbose);
e9e43ec3 1172extern int Grow_continue(int mdfd, struct supertype *st,
b76b30e0
AK
1173 struct mdinfo *info, char *backup_file,
1174 int freeze_reshape);
1175
3f54bd62
AK
1176extern int restore_backup(struct supertype *st,
1177 struct mdinfo *content,
1178 int working_disks,
1179 int spares,
1180 char *backup_file,
1181 int verbose);
2dddadb0
AK
1182extern int Grow_continue_command(char *devname, int fd,
1183 char *backup_file, int verbose);
64c4757e 1184
7f91af49 1185extern int Assemble(struct supertype *st, char *mddev,
fa56eddb 1186 struct mddev_ident *ident,
87f26d14 1187 struct mddev_dev *devlist,
4977146a 1188 struct context *c);
64c4757e 1189
a4e8316a
N
1190extern int Build(char *mddev, struct mddev_dev *devlist,
1191 struct shape *s, struct context *c);
64c4757e 1192
7f91af49 1193extern int Create(struct supertype *st, char *mddev,
171dccc8 1194 char *name, int *uuid,
a655e550 1195 int subdevs, struct mddev_dev *devlist,
99cc42f4 1196 struct shape *s,
40c9a66a
N
1197 struct context *c,
1198 unsigned long long data_offset);
64c4757e 1199
ef898ce6 1200extern int Detail(char *dev, struct context *c);
9eafa1de 1201extern int Detail_Platform(struct superswitch *ss, int scan, int verbose, int export, char *controller_path);
e0d19036 1202extern int Query(char *dev);
6d388a88 1203extern int ExamineBadblocks(char *devname, int brief, struct supertype *forcest);
eec3f887
N
1204extern int Examine(struct mddev_dev *devlist, struct context *c,
1205 struct supertype *forcest);
a655e550 1206extern int Monitor(struct mddev_dev *devlist,
e0d19036 1207 char *mailaddr, char *alert_cmd,
95c50205
N
1208 struct context *c,
1209 int daemonise, int oneshot,
1210 int dosyslog, char *pidfile, int increments,
1211 int share);
64c4757e 1212
ba728be7
N
1213extern int Kill(char *dev, struct supertype *st, int force, int verbose, int noexcl);
1214extern int Kill_subarray(char *dev, char *subarray, int verbose);
fa56eddb 1215extern int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet);
b90c0e9a 1216extern int Wait(char *dev);
9f1da824 1217extern int WaitClean(char *dev, int sock, int verbose);
9a9dab36 1218
11b6d91d
N
1219extern int Incremental(char *devname, struct context *c,
1220 struct supertype *st);
8382f19b
NB
1221extern void RebuildMap(void);
1222extern int IncrementalScan(int verbose);
950bc344 1223extern int IncrementalRemove(char *devname, char *path, int verbose);
c82f047c
NB
1224extern int CreateBitmap(char *filename, int force, char uuid[16],
1225 unsigned long chunksize, unsigned long daemon_sleep,
dfd4d8ee 1226 unsigned long write_behind,
dcec9ee5
NB
1227 unsigned long long array_size,
1228 int major);
55935d51 1229extern int ExamineBitmap(char *filename, int brief, struct supertype *st);
20b60dcd 1230extern int Write_rules(char *rule_name);
bf4fb153 1231extern int bitmap_update_uuid(int fd, int *uuid, int swap);
2a528478 1232extern unsigned long bitmap_sectors(struct bitmap_super_s *bsb);
74db60b0
N
1233extern int Dump_metadata(char *dev, char *dir, struct context *c,
1234 struct supertype *st);
1235extern int Restore_metadata(char *dev, char *dir, struct context *c,
1236 struct supertype *st, int only);
c82f047c 1237
64c4757e 1238extern int md_get_version(int fd);
e0d19036 1239extern int get_linux_version(void);
bc77ed53 1240extern int mdadm_version(char *version);
51d4261c 1241extern unsigned long long parse_size(char *size);
64c4757e 1242extern int parse_uuid(char *str, int uuid[4]);
4a06e2c2
N
1243extern int parse_layout_10(char *layout);
1244extern int parse_layout_faulty(char *layout);
79868890 1245extern long parse_num(char *num);
682c7051
NB
1246extern int check_ext2(int fd, char *name);
1247extern int check_reiser(int fd, char *name);
1248extern int check_raid(int fd, char *name);
53ed6ac3
KW
1249extern int check_partitions(int fd, char *dname,
1250 unsigned long long freesize,
1251 unsigned long long size);
64c4757e 1252
dd0781e5 1253extern int get_mdp_major(void);
8b0dabea 1254extern int dev_open(char *dev, int flags);
4dd2df09
N
1255extern int open_dev(char *devnm);
1256extern int open_dev_flags(char *devnm, int flags);
1257extern int open_dev_excl(char *devnm);
8d80900b 1258extern int is_standard(char *dev, int *nump);
9008ed1c 1259extern int same_dev(char *one, char *two);
9eafa1de 1260extern int compare_paths (char* path1,char* path2);
a7dec3fd 1261extern void enable_fds(int devices);
dd0781e5 1262
f1ae21c4 1263extern int parse_auto(char *str, char *msg, int config);
fa56eddb 1264extern struct mddev_ident *conf_get_ident(char *dev);
a655e550 1265extern struct mddev_dev *conf_get_devs(void);
8382f19b 1266extern int conf_test_dev(char *devname);
4e8d9f0a 1267extern int conf_test_metadata(const char *version, struct dev_policy *pol, int is_homehost);
8aec876d
NB
1268extern struct createinfo *conf_get_create_info(void);
1269extern void set_conffile(char *file);
1270extern char *conf_get_mailaddr(void);
1271extern char *conf_get_mailfrom(void);
1272extern char *conf_get_program(void);
0ac91628 1273extern char *conf_get_homehost(int *require_homehostp);
e0d19036 1274extern char *conf_line(FILE *file);
98c6faba 1275extern char *conf_word(FILE *file, int allow_key);
7103b9b8
N
1276extern void print_quoted(char *str);
1277extern void print_escape(char *str);
06d2ffc3 1278extern int use_udev(void);
0ac91628 1279extern int conf_name_is_free(char *name);
7c336758 1280extern int conf_verify_devnames(struct mddev_ident *array_list);
0ac91628 1281extern int devname_matches(char *name, char *match);
2244d1a9
N
1282extern struct mddev_ident *conf_match(struct supertype *st,
1283 struct mdinfo *info,
1284 char *devname,
1285 int verbose, int *rvp);
6d11ec6f 1286extern int experimental(void);
0ac91628 1287
e0d19036
NB
1288extern void free_line(char *line);
1289extern int match_oneof(char *devices, char *devname);
e0d19036 1290extern void uuid_from_super(int uuid[4], mdp_super_t *super);
22e263f6 1291extern const int uuid_zero[4];
f277ce36 1292extern int same_uuid(int a[4], int b[4], int swapuuid);
350f29f9 1293extern void copy_uuid(void *a, int b[4], int swapuuid);
aae5a112 1294extern char *__fname_from_uuid(int id[4], int swap, char *buf, char sep);
d7288ddc 1295extern char *fname_from_uuid(struct supertype *st,
ff54de6e 1296 struct mdinfo *info, char *buf, char sep);
4b1ac34b 1297extern unsigned long calc_csum(void *super, int bytes);
583315d9 1298extern int enough(int level, int raid_disks, int layout, int clean,
de5a472e 1299 char *avail);
8453e704 1300extern int enough_fd(int fd);
e0d19036 1301extern int ask(char *mesg);
8fac0577 1302extern unsigned long long get_component_size(int fd);
0430ed48 1303extern void remove_partitions(int fd);
691c6ee1 1304extern int test_partition(int fd);
bfd76b93 1305extern int test_partition_from_id(dev_t id);
577e8448 1306extern int get_data_disks(int level, int layout, int raid_disks);
5f8097be
NB
1307extern unsigned long long calc_array_size(int level, int raid_disks, int layout,
1308 int chunksize, unsigned long long devsize);
edd8d13c
NB
1309extern int flush_metadata_updates(struct supertype *st);
1310extern void append_metadata_update(struct supertype *st, void *buf, int len);
6234c63c 1311extern int assemble_container_content(struct supertype *st, int mdfd,
11b6d91d
N
1312 struct mdinfo *content,
1313 struct context *c,
1314 char *chosen_name);
326727d9
AC
1315extern struct mdinfo *container_choose_spares(struct supertype *st,
1316 unsigned long long min_size,
1317 struct domainlist *domlist,
1318 char *spare_group,
1319 const char *metadata, int get_one);
d52bb542 1320extern int move_spare(char *from_devname, char *to_devname, dev_t devid);
7801ac20
N
1321extern int add_disk(int mdfd, struct supertype *st,
1322 struct mdinfo *sra, struct mdinfo *info);
de6ae750
N
1323extern int remove_disk(int mdfd, struct supertype *st,
1324 struct mdinfo *sra, struct mdinfo *info);
f35f2525 1325extern int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info);
1e5c6983 1326unsigned long long min_recovery_start(struct mdinfo *array);
cd29a5c8 1327
56eb10c0 1328extern char *human_size(long long bytes);
f0ec6710 1329extern char *human_size_brief(long long bytes, int prefix);
e4965ef8 1330extern void print_r10_layout(int layout);
e0d19036 1331
4dd2df09 1332extern char *find_free_devnm(int use_partitions);
63152c1b 1333
e0d19036 1334extern void put_md_name(char *name);
4dd2df09
N
1335extern char *devid2devnm(int devid);
1336extern int devnm2devid(char *devnm);
1337extern char *get_md_name(char *devnm);
e0d19036 1338
c913b90e 1339extern char DefaultConfFile[];
b5e64645 1340
69207ff6
N
1341extern int create_mddev(char *dev, char *name, int autof, int trustworthy,
1342 char *chosen);
1343/* values for 'trustworthy' */
1344#define LOCAL 1
d1d3482b 1345#define LOCAL_ANY 10
69207ff6
N
1346#define FOREIGN 2
1347#define METADATA 3
6be1d39d 1348extern int open_mddev(char *dev, int report_errors);
a322f70c 1349extern int open_container(int fd);
4dd2df09
N
1350extern int metadata_container_matches(char *metadata, char *devnm);
1351extern int metadata_subdev_matches(char *metadata, char *devnm);
33414a01
DW
1352extern int is_container_member(struct mdstat_ent *ent, char *devname);
1353extern int is_subarray_active(char *subarray, char *devname);
feab51f8 1354extern int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet);
33414a01 1355extern struct superswitch *version_to_superswitch(char *vers);
b5e64645 1356
4dd2df09
N
1357extern int mdmon_running(char *devnm);
1358extern int mdmon_pid(char *devnm);
40ebbb9c 1359extern int check_env(char *name);
148acb7b 1360extern __u32 random32(void);
4dd2df09 1361extern int start_mdmon(char *devnm);
a931db9e 1362
999b4972
N
1363extern int child_monitor(int afd, struct mdinfo *sra, struct reshape *reshape,
1364 struct supertype *st, unsigned long stripes,
1365 int *fds, unsigned long long *offsets,
1366 int dests, int *destfd, unsigned long long *destoffsets);
10f22854 1367void abort_reshape(struct mdinfo *sra);
999b4972 1368
afa368f4
N
1369void *super1_make_v0(struct supertype *st, struct mdinfo *info, mdp_super_t *sb0);
1370
11877f4d 1371extern void fmt_devname(char *name, int num);
4dd2df09
N
1372extern char *stat2devnm(struct stat *st);
1373extern char *fd2devnm(int fd);
a931db9e 1374
2d762ade 1375#define _ROUND_UP(val, base) (((val) + (base) - 1) & ~(base - 1))
de897065
JS
1376#define ROUND_UP(val, base) _ROUND_UP(val, (typeof(val))(base))
1377#define ROUND_UP_PTR(ptr, base) ((typeof(ptr)) \
1378 (ROUND_UP((unsigned long)(ptr), base)))
6416d527 1379
3c558363
N
1380static inline int is_subarray(char *vers)
1381{
e9dd1598 1382 /* The version string for a 'subarray' (an array in a container)
1011e834 1383 * is
e9dd1598 1384 * /containername/componentname for normal read-write arrays
746a6567
N
1385 * -containername/componentname for arrays which mdmon must not
1386 * reconfigure. They might be read-only
1387 * or might be undergoing reshape etc.
e9dd1598
N
1388 * containername is e.g. md0, md_d1
1389 * componentname is dependant on the metadata. e.g. '1' 'S1' ...
1390 */
1391 return (*vers == '/' || *vers == '-');
3c558363
N
1392}
1393
e5408a32
DW
1394static inline char *to_subarray(struct mdstat_ent *ent, char *container)
1395{
1396 return &ent->metadata_version[10+strlen(container)+1];
1397}
1398
2a24d7b6
DW
1399#ifdef DEBUG
1400#define dprintf(fmt, arg...) \
1401 fprintf(stderr, fmt, ##arg)
1402#else
1403#define dprintf(fmt, arg...) \
1404 ({ if (0) fprintf(stderr, fmt, ##arg); 0; })
1405#endif
1a0ee0ba
DK
1406#include <assert.h>
1407#include <stdarg.h>
1408static inline int xasprintf(char **strp, const char *fmt, ...) {
1409 va_list ap;
1410 int ret;
1411 va_start(ap, fmt);
089485cb 1412 ret = vasprintf(strp, fmt, ap);
1a0ee0ba
DK
1413 va_end(ap);
1414 assert(ret >= 0);
1415 return ret;
1416}
2a24d7b6 1417
e7b84f9d
N
1418#define pr_err(fmt ...) fprintf(stderr, Name ": " fmt)
1419#define cont_err(fmt ...) fprintf(stderr, " " fmt)
1420
503975b9
N
1421void *xmalloc(size_t len);
1422void *xrealloc(void *ptr, size_t len);
1423void *xcalloc(size_t num, size_t size);
1424char *xstrdup(const char *str);
1425
b5e64645
NB
1426#define LEVEL_MULTIPATH (-4)
1427#define LEVEL_LINEAR (-1)
1428#define LEVEL_FAULTY (-5)
1429
17f25ca6
NB
1430/* kernel module doesn't know about these */
1431#define LEVEL_CONTAINER (-100)
a322f70c 1432#define LEVEL_UNSUPPORTED (-200)
17f25ca6 1433
b5e64645
NB
1434/* faulty stuff */
1435
1436#define WriteTransient 0
1437#define ReadTransient 1
1438#define WritePersistent 2
1439#define ReadPersistent 3
1440#define WriteAll 4 /* doesn't go to device */
1441#define ReadFixable 5
1442#define Modes 6
1443
1444#define ClearErrors 31
1445#define ClearFaults 30
1446
1447#define AllPersist 100 /* internal use only */
1448#define NoPersist 101
1449
1450#define ModeMask 0x1f
1451#define ModeShift 5
fe6729fa 1452
fe6729fa
NB
1453#ifdef __TINYC__
1454#undef minor
1455#undef major
1456#undef makedev
1457#define minor(x) ((x)&0xff)
1458#define major(x) (((x)>>8)&0xff)
1459#define makedev(M,m) (((M)<<8) | (m))
1460#endif
1461
b640a252 1462/* for raid4/5/6 */
e86c9dd6
NB
1463#define ALGORITHM_LEFT_ASYMMETRIC 0
1464#define ALGORITHM_RIGHT_ASYMMETRIC 1
1465#define ALGORITHM_LEFT_SYMMETRIC 2
1466#define ALGORITHM_RIGHT_SYMMETRIC 3
b640a252
N
1467
1468/* Define non-rotating (raid4) algorithms. These allow
1469 * conversion of raid4 to raid5.
1470 */
1471#define ALGORITHM_PARITY_0 4 /* P or P,Q are initial devices */
1472#define ALGORITHM_PARITY_N 5 /* P or P,Q are final devices. */
1473
1474/* DDF RAID6 layouts differ from md/raid6 layouts in two ways.
1475 * Firstly, the exact positioning of the parity block is slightly
1476 * different between the 'LEFT_*' modes of md and the "_N_*" modes
1477 * of DDF.
1478 * Secondly, or order of datablocks over which the Q syndrome is computed
1479 * is different.
1480 * Consequently we have different layouts for DDF/raid6 than md/raid6.
1481 * These layouts are from the DDFv1.2 spec.
1482 * Interestingly DDFv1.2-Errata-A does not specify N_CONTINUE but
1483 * leaves RLQ=3 as 'Vendor Specific'
1484 */
1485
1486#define ALGORITHM_ROTATING_ZERO_RESTART 8 /* DDF PRL=6 RLQ=1 */
1487#define ALGORITHM_ROTATING_N_RESTART 9 /* DDF PRL=6 RLQ=2 */
1488#define ALGORITHM_ROTATING_N_CONTINUE 10 /*DDF PRL=6 RLQ=3 */
1489
b640a252
N
1490/* For every RAID5 algorithm we define a RAID6 algorithm
1491 * with exactly the same layout for data and parity, and
1492 * with the Q block always on the last device (N-1).
1493 * This allows trivial conversion from RAID5 to RAID6
1494 */
1495#define ALGORITHM_LEFT_ASYMMETRIC_6 16
1496#define ALGORITHM_RIGHT_ASYMMETRIC_6 17
1497#define ALGORITHM_LEFT_SYMMETRIC_6 18
1498#define ALGORITHM_RIGHT_SYMMETRIC_6 19
1499#define ALGORITHM_PARITY_0_6 20
1500#define ALGORITHM_PARITY_N_6 ALGORITHM_PARITY_N
1501
33a6535d
AW
1502/* Define PATH_MAX in case we don't use glibc or standard library does
1503 * not have PATH_MAX defined. Assume max path length is 4K characters.
1504 */
1505#ifndef PATH_MAX
1506#define PATH_MAX 4096
1507#endif
1508
9dad51d4
N
1509#define RESYNC_NONE -1
1510#define RESYNC_DELAYED -2
1511#define RESYNC_PENDING -3
1512#define RESYNC_UNKNOWN -4
a0963a86 1513
480f3566
N
1514/* When using "GET_DISK_INFO" it isn't certain how high
1515 * we need to check. So we impose an absolute limit of
1516 * MAX_DISKS. This needs to be much more than the largest
1517 * number of devices any metadata can support. Currently
1518 * v1.x can support 1920
1519 */
1520#define MAX_DISKS 4096
1521
d04f65f4
N
1522/* Sometimes the 'size' value passed needs to mean "Maximum".
1523 * In those cases with use MAX_SIZE
1524 */
1525#define MAX_SIZE 1
822e393a
N
1526
1527/* We want to use unsigned numbers for sector counts, but need
1528 * a value for 'invalid'. Use '1'.
1529 */
1530#define INVALID_SECTORS 1
72ca9bcf
N
1531/* And another special number needed for --data_offset=variable */
1532#define VARIABLE_OFFSET 3