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