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