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