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