Create: support --readonly flag.
[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 /* List of device names - wildcards expanded */
378 struct mddev_dev {
379 char *devname;
380 int disposition; /* 'a' for add, 'r' for remove, 'f' for fail,
381 * 'A' for re_add.
382 * Not set for names read from .config
383 */
384 char writemostly; /* 1 for 'set writemostly', 2 for 'clear writemostly' */
385 char used; /* set when used */
386 struct mddev_dev *next;
387 };
388
389 typedef struct mapping {
390 char *name;
391 int num;
392 } mapping_t;
393
394
395 struct mdstat_ent {
396 char *dev;
397 int devnum;
398 int active;
399 char *level;
400 char *pattern; /* U or up, _ for down */
401 int percent; /* -1 if no resync */
402 int resync; /* 3 if check, 2 if reshape, 1 if resync, 0 if recovery */
403 int devcnt;
404 int raid_disks;
405 char * metadata_version;
406 struct dev_member {
407 char *name;
408 struct dev_member *next;
409 } *members;
410 struct mdstat_ent *next;
411 };
412
413 extern struct mdstat_ent *mdstat_read(int hold, int start);
414 extern void free_mdstat(struct mdstat_ent *ms);
415 extern void mdstat_wait(int seconds);
416 extern void mdstat_wait_fd(int fd, const sigset_t *sigmask);
417 extern int mddev_busy(int devnum);
418 extern struct mdstat_ent *mdstat_by_component(char *name);
419 extern struct mdstat_ent *mdstat_by_subdev(char *subdev, int container);
420
421 struct map_ent {
422 struct map_ent *next;
423 int devnum;
424 char metadata[20];
425 int uuid[4];
426 int bad;
427 char *path;
428 };
429 extern int map_update(struct map_ent **mpp, int devnum, char *metadata,
430 int uuid[4], char *path);
431 extern void map_remove(struct map_ent **map, int devnum);
432 extern struct map_ent *map_by_uuid(struct map_ent **map, int uuid[4]);
433 extern struct map_ent *map_by_devnum(struct map_ent **map, int devnum);
434 extern struct map_ent *map_by_name(struct map_ent **map, char *name);
435 extern void map_read(struct map_ent **melp);
436 extern int map_write(struct map_ent *mel);
437 extern void map_delete(struct map_ent **mapp, int devnum);
438 extern void map_free(struct map_ent *map);
439 extern void map_add(struct map_ent **melp,
440 int devnum, char *metadata, int uuid[4], char *path);
441 extern int map_lock(struct map_ent **melp);
442 extern void map_unlock(struct map_ent **melp);
443 extern void map_fork(void);
444
445 /* various details can be requested */
446 enum sysfs_read_flags {
447 GET_LEVEL = (1 << 0),
448 GET_LAYOUT = (1 << 1),
449 GET_COMPONENT = (1 << 2),
450 GET_CHUNK = (1 << 3),
451 GET_CACHE = (1 << 4),
452 GET_MISMATCH = (1 << 5),
453 GET_VERSION = (1 << 6),
454 GET_DISKS = (1 << 7),
455 GET_DEGRADED = (1 << 8),
456 GET_SAFEMODE = (1 << 9),
457 GET_BITMAP_LOCATION = (1 << 10),
458
459 GET_DEVS = (1 << 20), /* gets role, major, minor */
460 GET_OFFSET = (1 << 21),
461 GET_SIZE = (1 << 22),
462 GET_STATE = (1 << 23),
463 GET_ERROR = (1 << 24),
464 };
465
466 /* If fd >= 0, get the array it is open on,
467 * else use devnum. >=0 -> major9. <0.....
468 */
469 extern int sysfs_open(int devnum, char *devname, char *attr);
470 extern void sysfs_init(struct mdinfo *mdi, int fd, int devnum);
471 extern void sysfs_free(struct mdinfo *sra);
472 extern struct mdinfo *sysfs_read(int fd, int devnum, unsigned long options);
473 extern int sysfs_attr_match(const char *attr, const char *str);
474 extern int sysfs_match_word(const char *word, char **list);
475 extern int sysfs_set_str(struct mdinfo *sra, struct mdinfo *dev,
476 char *name, char *val);
477 extern int sysfs_set_num(struct mdinfo *sra, struct mdinfo *dev,
478 char *name, unsigned long long val);
479 extern int sysfs_set_num_signed(struct mdinfo *sra, struct mdinfo *dev,
480 char *name, long long val);
481 extern int sysfs_uevent(struct mdinfo *sra, char *event);
482 extern int sysfs_get_fd(struct mdinfo *sra, struct mdinfo *dev,
483 char *name);
484 extern int sysfs_fd_get_ll(int fd, unsigned long long *val);
485 extern int sysfs_get_ll(struct mdinfo *sra, struct mdinfo *dev,
486 char *name, unsigned long long *val);
487 extern int sysfs_fd_get_str(int fd, char *val, int size);
488 extern int sysfs_attribute_available(struct mdinfo *sra, struct mdinfo *dev,
489 char *name);
490 extern int sysfs_get_str(struct mdinfo *sra, struct mdinfo *dev,
491 char *name, char *val, int size);
492 extern int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms);
493 extern int sysfs_set_array(struct mdinfo *info, int vers);
494 extern int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume);
495 extern int sysfs_disk_to_scsi_id(int fd, __u32 *id);
496 extern int sysfs_unique_holder(int devnum, long rdev);
497 extern int sysfs_freeze_array(struct mdinfo *sra);
498 extern int load_sys(char *path, char *buf);
499 extern int reshape_prepare_fdlist(char *devname,
500 struct mdinfo *sra,
501 int raid_disks,
502 int nrdisks,
503 unsigned long blocks,
504 char *backup_file,
505 int *fdlist,
506 unsigned long long *offsets);
507 extern void reshape_free_fdlist(int *fdlist,
508 unsigned long long *offsets,
509 int size);
510 extern int reshape_open_backup_file(char *backup,
511 int fd,
512 char *devname,
513 long blocks,
514 int *fdlist,
515 unsigned long long *offsets,
516 int restart);
517 extern unsigned long compute_backup_blocks(int nchunk, int ochunk,
518 unsigned int ndata, unsigned int odata);
519
520 extern int save_stripes(int *source, unsigned long long *offsets,
521 int raid_disks, int chunk_size, int level, int layout,
522 int nwrites, int *dest,
523 unsigned long long start, unsigned long long length,
524 char *buf);
525 extern int restore_stripes(int *dest, unsigned long long *offsets,
526 int raid_disks, int chunk_size, int level, int layout,
527 int source, unsigned long long read_offset,
528 unsigned long long start, unsigned long long length,
529 char *src_buf);
530
531 #ifndef Sendmail
532 #define Sendmail "/usr/lib/sendmail -t"
533 #endif
534
535 #define SYSLOG_FACILITY LOG_DAEMON
536
537 extern char *map_num(mapping_t *map, int num);
538 extern int map_name(mapping_t *map, char *name);
539 extern mapping_t r5layout[], r6layout[], pers[], modes[], faultylayout[];
540
541 extern char *map_dev_preferred(int major, int minor, int create,
542 char *prefer);
543 static inline char *map_dev(int major, int minor, int create)
544 {
545 return map_dev_preferred(major, minor, create, NULL);
546 }
547
548 struct active_array;
549 struct metadata_update;
550
551
552 /* 'struct reshape' records the intermediate states
553 * a general reshape.
554 * The starting geometry is converted to the 'before' geometry
555 * by at most an atomic level change. They could be the same.
556 * Similarly the 'after' geometry is converted to the final
557 * geometry by at most a level change.
558 * Note that 'before' and 'after' must have the same level.
559 * 'blocks' is the minimum number of sectors for a reshape unit.
560 * This will be a multiple of the stripe size in each of the
561 * 'before' and 'after' geometries.
562 * If 'blocks' is 0, no restriping is necessary.
563 */
564 struct reshape {
565 int level;
566 int parity; /* number of parity blocks/devices */
567 struct {
568 int layout;
569 int data_disks;
570 } before, after;
571 unsigned long long backup_blocks;
572 unsigned long long stripes; /* number of old stripes that comprise 'blocks'*/
573 unsigned long long new_size; /* New size of array in sectors */
574 };
575
576 /* A superswitch provides entry point the a metadata handler.
577 *
578 * The super_switch primarily operates on some "metadata" that
579 * is accessed via the 'supertype'.
580 * This metadata has one of three possible sources.
581 * 1/ It is read from a single device. In this case it may not completely
582 * describe the array or arrays as some information might be on other
583 * devices.
584 * 2/ It is read from all devices in a container. In this case all
585 * information is present.
586 * 3/ It is created by ->init_super / ->add_to_super. In this case it will
587 * be complete once enough ->add_to_super calls have completed.
588 *
589 * When creating an array inside a container, the metadata will be
590 * formed by a combination of 2 and 3. The metadata or the array is read,
591 * then new information is added.
592 *
593 * The metadata must sometimes have a concept of a 'current' array
594 * and a 'current' device.
595 * The 'current' array is set by init_super to be the newly created array,
596 * or is set by super_by_fd when it finds it is looking at an array inside
597 * a container.
598 *
599 * The 'current' device is either the device that the metadata was read from
600 * in case 1, or the last device added by add_to_super in case 3.
601 * Case 2 does not identify a 'current' device.
602 */
603 extern struct superswitch {
604
605 /* Used to report details of metadata read from a component
606 * device. ->load_super has been called.
607 */
608 void (*examine_super)(struct supertype *st, char *homehost);
609 void (*brief_examine_super)(struct supertype *st, int verbose);
610 void (*brief_examine_subarrays)(struct supertype *st, int verbose);
611 void (*export_examine_super)(struct supertype *st);
612
613 /* Used to report details of an active array.
614 * ->load_super was possibly given a 'component' string.
615 */
616 void (*detail_super)(struct supertype *st, char *homehost);
617 void (*brief_detail_super)(struct supertype *st);
618 void (*export_detail_super)(struct supertype *st);
619
620 /* Optional: platform hardware / firmware details */
621 int (*detail_platform)(int verbose, int enumerate_only);
622
623 /* Used:
624 * to get uuid to storing in bitmap metadata
625 * and 'reshape' backup-data metadata
626 * To see if a device is being re-added to an array it was part of.
627 */
628 void (*uuid_from_super)(struct supertype *st, int uuid[4]);
629
630 /* Extract generic details from metadata. This could be details about
631 * the container, or about an individual array within the container.
632 * The determination is made either by:
633 * load_super being given a 'component' string.
634 * validate_geometry determining what to create.
635 * The info includes both array information and device information.
636 * The particular device should be:
637 * The last device added by add_to_super
638 * The device the metadata was loaded from by load_super
639 * If 'map' is present, then it is an array raid_disks long
640 * (raid_disk must already be set and correct) and it is filled
641 * with 1 for slots that are thought to be active and 0 for slots which
642 * appear to be failed/missing.
643 * *info is zeroed out before data is added.
644 */
645 void (*getinfo_super)(struct supertype *st, struct mdinfo *info, char *map);
646 struct mdinfo *(*getinfo_super_disks)(struct supertype *st);
647 /* Check if the given metadata is flagged as belonging to "this"
648 * host. 0 for 'no', 1 for 'yes', -1 for "Don't record homehost"
649 */
650 int (*match_home)(struct supertype *st, char *homehost);
651
652 /* Make one of several generic modifications to metadata
653 * prior to assembly (or other times).
654 * sparc2.2 - first bug in early 0.90 metadata
655 * super-minor - change name of 0.90 metadata
656 * summaries - 'correct' any redundant data
657 * resync - mark array as dirty to trigger a resync.
658 * uuid - set new uuid - only 0.90 or 1.x
659 * name - change the name of the array (where supported)
660 * homehost - change which host this array is tied to.
661 * devicesize - If metadata is at start of device, change recorded
662 * device size to match actual device size
663 * byteorder - swap bytes for 0.90 metadata
664 *
665 * force-one - mark that device as uptodate, not old or failed.
666 * force-array - mark array as clean if it would not otherwise
667 * assemble
668 * assemble - not sure how this is different from force-one...
669 * linear-grow-new - add a new device to a linear array, but don't
670 * change the size: so superblock still matches
671 * linear-grow-update - now change the size of the array.
672 * writemostly - set the WriteMostly1 bit in the superblock devflags
673 * readwrite - clear the WriteMostly1 bit in the superblock devflags
674 */
675 int (*update_super)(struct supertype *st, struct mdinfo *info,
676 char *update,
677 char *devname, int verbose,
678 int uuid_set, char *homehost);
679
680 /* Create new metadata for new array as described. This could
681 * be a new container, or an array in a pre-existing container.
682 * Also used to zero metadata prior to writing it to invalidate old
683 * metadata.
684 */
685 int (*init_super)(struct supertype *st, mdu_array_info_t *info,
686 unsigned long long size, char *name,
687 char *homehost, int *uuid);
688
689 /* update the metadata to include new device, either at create or
690 * when hot-adding a spare.
691 */
692 int (*add_to_super)(struct supertype *st, mdu_disk_info_t *dinfo,
693 int fd, char *devname);
694 /* update the metadata to delete a device,
695 * when hot-removing.
696 */
697 int (*remove_from_super)(struct supertype *st, mdu_disk_info_t *dinfo);
698
699 /* Write metadata to one device when fixing problems or adding
700 * a new device.
701 */
702 int (*store_super)(struct supertype *st, int fd);
703
704 /* Write all metadata for this array.
705 */
706 int (*write_init_super)(struct supertype *st);
707 int (*compare_super)(struct supertype *st, struct supertype *tst);
708 int (*load_super)(struct supertype *st, int fd, char *devname);
709 int (*load_container)(struct supertype *st, int fd, char *devname);
710 struct supertype * (*match_metadata_desc)(char *arg);
711 __u64 (*avail_size)(struct supertype *st, __u64 size);
712 unsigned long long (*min_acceptable_spare_size)(struct supertype *st);
713 int (*add_internal_bitmap)(struct supertype *st, int *chunkp,
714 int delay, int write_behind,
715 unsigned long long size, int may_change, int major);
716 void (*locate_bitmap)(struct supertype *st, int fd);
717 int (*write_bitmap)(struct supertype *st, int fd);
718 void (*free_super)(struct supertype *st);
719
720 /* validate_geometry is called with an st returned by
721 * match_metadata_desc.
722 * It should check that the geometry described in compatible with
723 * the metadata type. It will be called repeatedly as devices
724 * added to validate changing size and new devices. If there are
725 * inter-device dependencies, it should record sufficient details
726 * so these can be validated.
727 * Both 'size' and '*freesize' are in sectors. chunk is KiB.
728 * Return value is:
729 * 1: everything is OK
730 * 0: not OK for some reason - if 'verbose', then error was reported.
731 * -1: st->sb was NULL, 'subdev' is a member of a container of this
732 * types, but array is not acceptable for some reason
733 * message was reported even if verbose is 0.
734 */
735 int (*validate_geometry)(struct supertype *st, int level, int layout,
736 int raiddisks,
737 int *chunk, unsigned long long size,
738 char *subdev, unsigned long long *freesize,
739 int verbose);
740
741 struct mdinfo *(*container_content)(struct supertype *st, char *subarray);
742 /* query the supertype for default geometry */
743 void (*default_geometry)(struct supertype *st, int *level, int *layout, int *chunk); /* optional */
744 /* Permit subarray's to be deleted from inactive containers */
745 int (*kill_subarray)(struct supertype *st); /* optional */
746 /* Permit subarray's to be modified */
747 int (*update_subarray)(struct supertype *st, char *subarray,
748 char *update, struct mddev_ident *ident); /* optional */
749 /* Check if reshape is supported for this external format.
750 * st is obtained from super_by_fd() where st->subarray[0] is
751 * initialized to indicate if reshape is being performed at the
752 * container or subarray level
753 */
754 #define APPLY_METADATA_CHANGES 1
755 #define ROLLBACK_METADATA_CHANGES 0
756
757 int (*reshape_super)(struct supertype *st, long long size, int level,
758 int layout, int chunksize, int raid_disks,
759 int delta_disks, char *backup, char *dev,
760 int direction,
761 int verbose); /* optional */
762 int (*manage_reshape)( /* optional */
763 int afd, struct mdinfo *sra, struct reshape *reshape,
764 struct supertype *st, unsigned long blocks,
765 int *fds, unsigned long long *offsets,
766 int dests, int *destfd, unsigned long long *destoffsets);
767
768 /* for mdmon */
769 int (*open_new)(struct supertype *c, struct active_array *a,
770 char *inst);
771
772 /* Tell the metadata handler the current state of the array.
773 * This covers whether it is known to be consistent (no pending writes)
774 * and how far along a resync is known to have progressed
775 * (in a->resync_start).
776 * resync status is really irrelevant if the array is not consistent,
777 * but some metadata (DDF!) have a place to record the distinction.
778 * If 'consistent' is '2', then the array can mark it dirty if a
779 * resync/recovery/whatever is required, or leave it clean if not.
780 * Return value is 0 dirty (not consistent) and 1 if clean.
781 * it is only really important if consistent is passed in as '2'.
782 */
783 int (*set_array_state)(struct active_array *a, int consistent);
784
785 /* When the state of a device might have changed, we call set_disk to
786 * tell the metadata what the current state is.
787 * Typically this happens on spare->in_sync and (spare|in_sync)->faulty
788 * transitions.
789 * set_disk might be called when the state of the particular disk has
790 * not in fact changed.
791 */
792 void (*set_disk)(struct active_array *a, int n, int state);
793 void (*sync_metadata)(struct supertype *st);
794 void (*process_update)(struct supertype *st,
795 struct metadata_update *update);
796 void (*prepare_update)(struct supertype *st,
797 struct metadata_update *update);
798
799 /* activate_spare will check if the array is degraded and, if it
800 * is, try to find some spare space in the container.
801 * On success, it add appropriate updates (For process_update) to
802 * to the 'updates' list and returns a list of 'mdinfo' identifying
803 * the device, or devices as there might be multiple missing
804 * devices and multiple spares available.
805 */
806 struct mdinfo *(*activate_spare)(struct active_array *a,
807 struct metadata_update **updates);
808 /*
809 * Return statically allocated string that represents metadata specific
810 * controller domain of the disk. The domain is used in disk domain
811 * matching functions. Disks belong to the same domain if the they have
812 * the same domain from mdadm.conf and belong the same metadata domain.
813 * Returning NULL or not providing this handler means that metadata
814 * does not distinguish the differences between disks that belong to
815 * different controllers. They are in the domain specified by
816 * configuration file (mdadm.conf).
817 * In case when the metadata has the notion of domains based on disk
818 * it shall return NULL for disks that do not belong to the controller
819 * the supported domains. Such disks will form another domain and won't
820 * be mixed with supported ones.
821 */
822 const char *(*get_disk_controller_domain)(const char *path);
823
824 /* for external backup area */
825 int (*recover_backup)(struct supertype *st, struct mdinfo *info);
826
827 int swapuuid; /* true if uuid is bigending rather than hostendian */
828 int external;
829 const char *name; /* canonical metadata name */
830 } *superlist[];
831
832 extern struct superswitch super0, super1;
833 extern struct superswitch super_imsm, super_ddf;
834 extern struct superswitch mbr, gpt;
835
836 struct metadata_update {
837 int len;
838 char *buf;
839 void *space; /* allocated space that monitor will use */
840 void **space_list; /* list of allocated spaces that monitor can
841 * use or that it returned.
842 */
843 struct metadata_update *next;
844 };
845
846 /* A supertype holds a particular collection of metadata.
847 * It identifies the metadata type by the superswitch, and the particular
848 * sub-version of that metadata type.
849 * metadata read in or created is stored in 'sb' and 'info'.
850 * There are also fields used by mdmon to track containers.
851 *
852 * A supertype may refer to:
853 * Just an array, possibly in a container
854 * A container, not identifying any particular array
855 * Info read from just one device, not yet fully describing the array/container.
856 *
857 *
858 * A supertype is created by:
859 * super_by_fd
860 * guess_super
861 * dup_super
862 */
863 struct supertype {
864 struct superswitch *ss;
865 int minor_version;
866 int max_devs;
867 int container_dev; /* devnum of container */
868 void *sb;
869 void *info;
870 int ignore_hw_compat; /* used to inform metadata handlers that it should ignore
871 HW/firmware related incompatability to load metadata.
872 Used when examining metadata to display content of disk
873 when user has no hw/firmare compatible system.
874 */
875 struct metadata_update *updates;
876 struct metadata_update **update_tail;
877
878 /* extra stuff used by mdmon */
879 struct active_array *arrays;
880 int sock; /* listen to external programs */
881 int devnum;
882 char *devname; /* e.g. md0. This appears in metadata_verison:
883 * external:/md0/12
884 */
885 int devcnt;
886 int retry_soon;
887
888 struct mdinfo *devs;
889
890 };
891
892 extern struct supertype *super_by_fd(int fd, char **subarray);
893 enum guess_types { guess_any, guess_array, guess_partitions };
894 extern struct supertype *guess_super_type(int fd, enum guess_types guess_type);
895 static inline struct supertype *guess_super(int fd) {
896 return guess_super_type(fd, guess_any);
897 }
898 extern struct supertype *dup_super(struct supertype *st);
899 extern int get_dev_size(int fd, char *dname, unsigned long long *sizep);
900 extern int must_be_container(int fd);
901 extern int dev_size_from_id(dev_t id, unsigned long long *size);
902 extern void get_one_disk(int mdfd, mdu_array_info_t *ainf,
903 mdu_disk_info_t *disk);
904 void wait_for(char *dev, int fd);
905
906 /*
907 * Data structures for policy management.
908 * Each device can have a policy structure that lists
909 * various name/value pairs each possibly with a metadata associated.
910 * The policy list is sorted by name/value/metadata
911 */
912 struct dev_policy {
913 struct dev_policy *next;
914 char *name; /* None of these strings are allocated. They are
915 * all just references to strings which are known
916 * to exist elsewhere.
917 * name and metadata can be compared by address equality.
918 */
919 const char *metadata;
920 const char *value;
921 };
922
923 extern char pol_act[], pol_domain[], pol_metadata[], pol_auto[];
924
925 /* iterate over the sublist starting at list, having the same
926 * 'name' as 'list', and matching the given metadata (Where
927 * NULL matches anything
928 */
929 #define pol_for_each(item, list, _metadata) \
930 for (item = list; \
931 item && item->name == list->name; \
932 item = item->next) \
933 if (!(!_metadata || !item->metadata || _metadata == item->metadata)) \
934 ; else
935
936 /*
937 * policy records read from mdadm are largely just name-value pairs.
938 * The names are constants, not strdupped
939 */
940 struct pol_rule {
941 struct pol_rule *next;
942 char *type; /* rule_policy or rule_part */
943 struct rule {
944 struct rule *next;
945 char *name;
946 char *value;
947 char *dups; /* duplicates of 'value' with a partNN appended */
948 } *rule;
949 };
950
951 extern char rule_policy[], rule_part[];
952 extern char rule_path[], rule_type[];
953 extern char type_part[], type_disk[];
954
955 extern void policyline(char *line, char *type);
956 extern void policy_add(char *type, ...);
957 extern void policy_free(void);
958
959 extern struct dev_policy *path_policy(char *path, char *type);
960 extern struct dev_policy *disk_policy(struct mdinfo *disk);
961 extern struct dev_policy *devnum_policy(int dev);
962 extern void dev_policy_free(struct dev_policy *p);
963
964 //extern void pol_new(struct dev_policy **pol, char *name, char *val, char *metadata);
965 extern void pol_add(struct dev_policy **pol, char *name, char *val, char *metadata);
966 extern struct dev_policy *pol_find(struct dev_policy *pol, char *name);
967
968 enum policy_action {
969 act_default,
970 act_include,
971 act_re_add,
972 act_spare, /* This only applies to bare devices */
973 act_spare_same_slot, /* this allows non-bare devices,
974 * but only if recent removal */
975 act_force_spare, /* this allow non-bare devices in any case */
976 act_err
977 };
978
979 extern int policy_action_allows(struct dev_policy *plist, const char *metadata,
980 enum policy_action want);
981 extern int disk_action_allows(struct mdinfo *disk, const char *metadata,
982 enum policy_action want);
983
984 struct domainlist {
985 struct domainlist *next;
986 const char *dom;
987 };
988
989 extern int domain_test(struct domainlist *dom, struct dev_policy *pol,
990 const char *metadata);
991 extern struct domainlist *domain_from_array(struct mdinfo *mdi,
992 const char *metadata);
993 extern void domainlist_add_dev(struct domainlist **dom, int devnum,
994 const char *metadata);
995 extern void domain_free(struct domainlist *dl);
996 extern void domain_merge(struct domainlist **domp, struct dev_policy *pol,
997 const char *metadata);
998 void domain_add(struct domainlist **domp, char *domain);
999
1000 extern void policy_save_path(char *id_path, struct map_ent *array);
1001 extern int policy_check_path(struct mdinfo *disk, struct map_ent *array);
1002
1003 #if __GNUC__ < 3
1004 struct stat64;
1005 #endif
1006
1007 #define HAVE_NFTW we assume
1008 #define HAVE_FTW
1009
1010 #ifdef __UCLIBC__
1011 # include <features.h>
1012 # ifndef __UCLIBC_HAS_LFS__
1013 # define lseek64 lseek
1014 # endif
1015 # ifndef __UCLIBC_HAS_FTW__
1016 # undef HAVE_FTW
1017 # undef HAVE_NFTW
1018 # endif
1019 #endif
1020
1021 #ifdef __dietlibc__
1022 # undef HAVE_NFTW
1023 #endif
1024
1025 #if defined(__KLIBC__)
1026 # undef HAVE_NFTW
1027 # undef HAVE_FTW
1028 #endif
1029
1030 #ifndef HAVE_NFTW
1031 # define FTW_PHYS 1
1032 # ifndef HAVE_FTW
1033 struct FTW {};
1034 # endif
1035 #endif
1036
1037 #ifdef HAVE_FTW
1038 # include <ftw.h>
1039 #endif
1040
1041 extern int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s);
1042
1043
1044 extern int Manage_ro(char *devname, int fd, int readonly);
1045 extern int Manage_runstop(char *devname, int fd, int runstop, int quiet);
1046 extern int Manage_resize(char *devname, int fd, long long size, int raid_disks);
1047 extern int Manage_subdevs(char *devname, int fd,
1048 struct mddev_dev *devlist, int verbose, int test,
1049 char *update, int force);
1050 extern int autodetect(void);
1051 extern int Grow_Add_device(char *devname, int fd, char *newdev);
1052 extern int Grow_addbitmap(char *devname, int fd, char *file, int chunk, int delay, int write_behind, int force);
1053 extern int Grow_reshape(char *devname, int fd, int quiet, char *backup_file,
1054 long long size,
1055 int level, char *layout_str, int chunksize, int raid_disks,
1056 struct mddev_dev *devlist,
1057 int assume_clean, int force);
1058 extern int Grow_restart(struct supertype *st, struct mdinfo *info,
1059 int *fdlist, int cnt, char *backup_file, int verbose);
1060 extern int Grow_continue(int mdfd, struct supertype *st,
1061 struct mdinfo *info, char *backup_file,
1062 int freeze_reshape);
1063
1064 extern int restore_backup(struct supertype *st,
1065 struct mdinfo *content,
1066 int working_disks,
1067 int spares,
1068 char *backup_file,
1069 int verbose);
1070 extern int Grow_continue_command(char *devname, int fd,
1071 char *backup_file, int verbose);
1072
1073 extern int Assemble(struct supertype *st, char *mddev,
1074 struct mddev_ident *ident,
1075 struct mddev_dev *devlist,
1076 char *backup_file, int invalid_backup,
1077 int readonly, int runstop,
1078 char *update, char *homehost, int require_homehost,
1079 int verbose, int force, int freeze_reshape);
1080
1081 extern int Build(char *mddev, int chunk, int level, int layout,
1082 int raiddisks, struct mddev_dev *devlist, int assume_clean,
1083 char *bitmap_file, int bitmap_chunk, int write_behind,
1084 int delay, int verbose, int autof, unsigned long long size);
1085
1086
1087 extern int Create(struct supertype *st, char *mddev,
1088 int chunk, int level, int layout, unsigned long long size,
1089 int raiddisks, int sparedisks,
1090 char *name, char *homehost, int *uuid,
1091 int subdevs, struct mddev_dev *devlist,
1092 int runstop, int readonly, int verbose,
1093 int force, int assume_clean,
1094 char *bitmap_file, int bitmap_chunk, int write_behind, int delay, int autof);
1095
1096 extern int Detail(char *dev, int brief, int export, int test, char *homehost, char *prefer);
1097 extern int Detail_Platform(struct superswitch *ss, int scan, int verbose);
1098 extern int Query(char *dev);
1099 extern int Examine(struct mddev_dev *devlist, int brief, int export, int scan,
1100 int SparcAdjust, struct supertype *forcest, char *homehost);
1101 extern int Monitor(struct mddev_dev *devlist,
1102 char *mailaddr, char *alert_cmd,
1103 int period, int daemonise, int scan, int oneshot,
1104 int dosyslog, int test, char *pidfile, int increments,
1105 int share, char *prefer);
1106
1107 extern int Kill(char *dev, struct supertype *st, int force, int quiet, int noexcl);
1108 extern int Kill_subarray(char *dev, char *subarray, int quiet);
1109 extern int Update_subarray(char *dev, char *subarray, char *update, struct mddev_ident *ident, int quiet);
1110 extern int Wait(char *dev);
1111 extern int WaitClean(char *dev, int sock, int verbose);
1112
1113 extern int Incremental(char *devname, int verbose, int runstop,
1114 struct supertype *st, char *homehost, int require_homehost,
1115 int autof, int freeze_reshape);
1116 extern void RebuildMap(void);
1117 extern int IncrementalScan(int verbose);
1118 extern int IncrementalRemove(char *devname, char *path, int verbose);
1119 extern int CreateBitmap(char *filename, int force, char uuid[16],
1120 unsigned long chunksize, unsigned long daemon_sleep,
1121 unsigned long write_behind,
1122 unsigned long long array_size,
1123 int major);
1124 extern int ExamineBitmap(char *filename, int brief, struct supertype *st);
1125 extern int Write_rules(char *rule_name);
1126 extern int bitmap_update_uuid(int fd, int *uuid, int swap);
1127 extern unsigned long bitmap_sectors(struct bitmap_super_s *bsb);
1128
1129 extern int md_get_version(int fd);
1130 extern int get_linux_version(void);
1131 extern int mdadm_version(char *version);
1132 extern long long parse_size(char *size);
1133 extern int parse_uuid(char *str, int uuid[4]);
1134 extern int parse_layout_10(char *layout);
1135 extern int parse_layout_faulty(char *layout);
1136 extern int check_ext2(int fd, char *name);
1137 extern int check_reiser(int fd, char *name);
1138 extern int check_raid(int fd, char *name);
1139 extern int check_partitions(int fd, char *dname,
1140 unsigned long long freesize,
1141 unsigned long long size);
1142
1143 extern int get_mdp_major(void);
1144 extern int dev_open(char *dev, int flags);
1145 extern int open_dev(int devnum);
1146 extern int open_dev_flags(int devnum, int flags);
1147 extern int open_dev_excl(int devnum);
1148 extern int is_standard(char *dev, int *nump);
1149 extern int same_dev(char *one, char *two);
1150
1151 extern int parse_auto(char *str, char *msg, int config);
1152 extern struct mddev_ident *conf_get_ident(char *dev);
1153 extern struct mddev_dev *conf_get_devs(void);
1154 extern int conf_test_dev(char *devname);
1155 extern int conf_test_metadata(const char *version, struct dev_policy *pol, int is_homehost);
1156 extern struct createinfo *conf_get_create_info(void);
1157 extern void set_conffile(char *file);
1158 extern char *conf_get_mailaddr(void);
1159 extern char *conf_get_mailfrom(void);
1160 extern char *conf_get_program(void);
1161 extern char *conf_get_homehost(int *require_homehostp);
1162 extern char *conf_line(FILE *file);
1163 extern char *conf_word(FILE *file, int allow_key);
1164 extern int conf_name_is_free(char *name);
1165 extern int conf_verify_devnames(struct mddev_ident *array_list);
1166 extern int devname_matches(char *name, char *match);
1167 extern struct mddev_ident *conf_match(struct supertype *st,
1168 struct mdinfo *info,
1169 char *devname,
1170 int verbose, int *rvp);
1171 extern int experimental(void);
1172
1173 extern void free_line(char *line);
1174 extern int match_oneof(char *devices, char *devname);
1175 extern void uuid_from_super(int uuid[4], mdp_super_t *super);
1176 extern const int uuid_zero[4];
1177 extern int same_uuid(int a[4], int b[4], int swapuuid);
1178 extern void copy_uuid(void *a, int b[4], int swapuuid);
1179 extern char *__fname_from_uuid(int id[4], int swap, char *buf, char sep);
1180 extern char *fname_from_uuid(struct supertype *st,
1181 struct mdinfo *info, char *buf, char sep);
1182 extern unsigned long calc_csum(void *super, int bytes);
1183 extern int enough(int level, int raid_disks, int layout, int clean,
1184 char *avail);
1185 extern int enough_fd(int fd);
1186 extern int ask(char *mesg);
1187 extern unsigned long long get_component_size(int fd);
1188 extern void remove_partitions(int fd);
1189 extern int test_partition(int fd);
1190 extern int test_partition_from_id(dev_t id);
1191 extern int get_data_disks(int level, int layout, int raid_disks);
1192 extern unsigned long long calc_array_size(int level, int raid_disks, int layout,
1193 int chunksize, unsigned long long devsize);
1194 extern int flush_metadata_updates(struct supertype *st);
1195 extern void append_metadata_update(struct supertype *st, void *buf, int len);
1196 extern int assemble_container_content(struct supertype *st, int mdfd,
1197 struct mdinfo *content, int runstop,
1198 int readonly,
1199 char *chosen_name, int verbose,
1200 char *backup_file, int freeze_reshape);
1201 extern struct mdinfo *container_choose_spares(struct supertype *st,
1202 unsigned long long min_size,
1203 struct domainlist *domlist,
1204 char *spare_group,
1205 const char *metadata, int get_one);
1206 extern int move_spare(char *from_devname, char *to_devname, dev_t devid);
1207 extern int add_disk(int mdfd, struct supertype *st,
1208 struct mdinfo *sra, struct mdinfo *info);
1209 extern int remove_disk(int mdfd, struct supertype *st,
1210 struct mdinfo *sra, struct mdinfo *info);
1211 extern int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info);
1212 unsigned long long min_recovery_start(struct mdinfo *array);
1213
1214 extern char *human_size(long long bytes);
1215 extern char *human_size_brief(long long bytes);
1216 extern void print_r10_layout(int layout);
1217
1218 #define NoMdDev (1<<23)
1219 extern int find_free_devnum(int use_partitions);
1220
1221 extern void put_md_name(char *name);
1222 extern char *get_md_name(int dev);
1223
1224 extern char DefaultConfFile[];
1225
1226 extern int create_mddev(char *dev, char *name, int autof, int trustworthy,
1227 char *chosen);
1228 /* values for 'trustworthy' */
1229 #define LOCAL 1
1230 #define LOCAL_ANY 10
1231 #define FOREIGN 2
1232 #define METADATA 3
1233 extern int open_mddev(char *dev, int report_errors);
1234 extern int open_container(int fd);
1235 extern int is_container_member(struct mdstat_ent *ent, char *devname);
1236 extern int is_subarray_active(char *subarray, char *devname);
1237 extern int open_subarray(char *dev, char *subarray, struct supertype *st, int quiet);
1238 extern struct superswitch *version_to_superswitch(char *vers);
1239
1240 extern int mdmon_running(int devnum);
1241 extern int mdmon_pid(int devnum);
1242 extern int check_env(char *name);
1243 extern __u32 random32(void);
1244 extern int start_mdmon(int devnum);
1245
1246 extern int child_monitor(int afd, struct mdinfo *sra, struct reshape *reshape,
1247 struct supertype *st, unsigned long stripes,
1248 int *fds, unsigned long long *offsets,
1249 int dests, int *destfd, unsigned long long *destoffsets);
1250 void abort_reshape(struct mdinfo *sra);
1251
1252 extern char *devnum2devname(int num);
1253 extern void fmt_devname(char *name, int num);
1254 extern int devname2devnum(char *name);
1255 extern int stat2devnum(struct stat *st);
1256 extern int fd2devnum(int fd);
1257
1258 static inline int dev2major(int d)
1259 {
1260 if (d >= 0)
1261 return MD_MAJOR;
1262 else
1263 return get_mdp_major();
1264 }
1265
1266 static inline int dev2minor(int d)
1267 {
1268 if (d >= 0)
1269 return d;
1270 return (-1-d) << MdpMinorShift;
1271 }
1272
1273 #define _ROUND_UP(val, base) (((val) + (base) - 1) & ~(base - 1))
1274 #define ROUND_UP(val, base) _ROUND_UP(val, (typeof(val))(base))
1275 #define ROUND_UP_PTR(ptr, base) ((typeof(ptr)) \
1276 (ROUND_UP((unsigned long)(ptr), base)))
1277
1278 static inline int is_subarray(char *vers)
1279 {
1280 /* The version string for a 'subarray' (an array in a container)
1281 * is
1282 * /containername/componentname for normal read-write arrays
1283 * -containername/componentname for arrays which mdmon must not
1284 * reconfigure. They might be read-only
1285 * or might be undergoing reshape etc.
1286 * containername is e.g. md0, md_d1
1287 * componentname is dependant on the metadata. e.g. '1' 'S1' ...
1288 */
1289 return (*vers == '/' || *vers == '-');
1290 }
1291
1292 static inline char *to_subarray(struct mdstat_ent *ent, char *container)
1293 {
1294 return &ent->metadata_version[10+strlen(container)+1];
1295 }
1296
1297 #ifdef DEBUG
1298 #define dprintf(fmt, arg...) \
1299 fprintf(stderr, fmt, ##arg)
1300 #else
1301 #define dprintf(fmt, arg...) \
1302 ({ if (0) fprintf(stderr, fmt, ##arg); 0; })
1303 #endif
1304 #include <assert.h>
1305 #include <stdarg.h>
1306 static inline int xasprintf(char **strp, const char *fmt, ...) {
1307 va_list ap;
1308 int ret;
1309 va_start(ap, fmt);
1310 ret = vasprintf(strp, fmt, ap);
1311 va_end(ap);
1312 assert(ret >= 0);
1313 return ret;
1314 }
1315
1316 #define pr_err(fmt ...) fprintf(stderr, Name ": " fmt)
1317 #define cont_err(fmt ...) fprintf(stderr, " " fmt)
1318
1319 void *xmalloc(size_t len);
1320 void *xrealloc(void *ptr, size_t len);
1321 void *xcalloc(size_t num, size_t size);
1322 char *xstrdup(const char *str);
1323
1324 #define LEVEL_MULTIPATH (-4)
1325 #define LEVEL_LINEAR (-1)
1326 #define LEVEL_FAULTY (-5)
1327
1328 /* kernel module doesn't know about these */
1329 #define LEVEL_CONTAINER (-100)
1330 #define LEVEL_UNSUPPORTED (-200)
1331
1332
1333 /* faulty stuff */
1334
1335 #define WriteTransient 0
1336 #define ReadTransient 1
1337 #define WritePersistent 2
1338 #define ReadPersistent 3
1339 #define WriteAll 4 /* doesn't go to device */
1340 #define ReadFixable 5
1341 #define Modes 6
1342
1343 #define ClearErrors 31
1344 #define ClearFaults 30
1345
1346 #define AllPersist 100 /* internal use only */
1347 #define NoPersist 101
1348
1349 #define ModeMask 0x1f
1350 #define ModeShift 5
1351
1352
1353 #ifdef __TINYC__
1354 #undef minor
1355 #undef major
1356 #undef makedev
1357 #define minor(x) ((x)&0xff)
1358 #define major(x) (((x)>>8)&0xff)
1359 #define makedev(M,m) (((M)<<8) | (m))
1360 #endif
1361
1362 /* for raid4/5/6 */
1363 #define ALGORITHM_LEFT_ASYMMETRIC 0
1364 #define ALGORITHM_RIGHT_ASYMMETRIC 1
1365 #define ALGORITHM_LEFT_SYMMETRIC 2
1366 #define ALGORITHM_RIGHT_SYMMETRIC 3
1367
1368 /* Define non-rotating (raid4) algorithms. These allow
1369 * conversion of raid4 to raid5.
1370 */
1371 #define ALGORITHM_PARITY_0 4 /* P or P,Q are initial devices */
1372 #define ALGORITHM_PARITY_N 5 /* P or P,Q are final devices. */
1373
1374 /* DDF RAID6 layouts differ from md/raid6 layouts in two ways.
1375 * Firstly, the exact positioning of the parity block is slightly
1376 * different between the 'LEFT_*' modes of md and the "_N_*" modes
1377 * of DDF.
1378 * Secondly, or order of datablocks over which the Q syndrome is computed
1379 * is different.
1380 * Consequently we have different layouts for DDF/raid6 than md/raid6.
1381 * These layouts are from the DDFv1.2 spec.
1382 * Interestingly DDFv1.2-Errata-A does not specify N_CONTINUE but
1383 * leaves RLQ=3 as 'Vendor Specific'
1384 */
1385
1386 #define ALGORITHM_ROTATING_ZERO_RESTART 8 /* DDF PRL=6 RLQ=1 */
1387 #define ALGORITHM_ROTATING_N_RESTART 9 /* DDF PRL=6 RLQ=2 */
1388 #define ALGORITHM_ROTATING_N_CONTINUE 10 /*DDF PRL=6 RLQ=3 */
1389
1390
1391 /* For every RAID5 algorithm we define a RAID6 algorithm
1392 * with exactly the same layout for data and parity, and
1393 * with the Q block always on the last device (N-1).
1394 * This allows trivial conversion from RAID5 to RAID6
1395 */
1396 #define ALGORITHM_LEFT_ASYMMETRIC_6 16
1397 #define ALGORITHM_RIGHT_ASYMMETRIC_6 17
1398 #define ALGORITHM_LEFT_SYMMETRIC_6 18
1399 #define ALGORITHM_RIGHT_SYMMETRIC_6 19
1400 #define ALGORITHM_PARITY_0_6 20
1401 #define ALGORITHM_PARITY_N_6 ALGORITHM_PARITY_N
1402
1403 /* Define PATH_MAX in case we don't use glibc or standard library does
1404 * not have PATH_MAX defined. Assume max path length is 4K characters.
1405 */
1406 #ifndef PATH_MAX
1407 #define PATH_MAX 4096
1408 #endif
1409
1410 #define RESYNC_NONE -1
1411 #define RESYNC_DELAYED -2
1412 #define RESYNC_PENDING -3
1413 #define RESYNC_UNKNOWN -4
1414
1415 /* When using "GET_DISK_INFO" it isn't certain how high
1416 * we need to check. So we impose an absolute limit of
1417 * MAX_DISKS. This needs to be much more than the largest
1418 * number of devices any metadata can support. Currently
1419 * v1.x can support 1920
1420 */
1421 #define MAX_DISKS 4096
1422
1423 extern int __offroot;