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