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