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