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