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