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