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