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