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