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