← Back to branch summary

~ubuntu-branches/ubuntu/precise/mdadm/precise-proposed

« back to all changes in this revision

Viewing changes to mdadm.h

  • Committer: Package Import Robot
  • Author(s): Surbhi Palande
  • Date: 2010-09-30 17:46:19 UTC
  • mfrom: (1.4.1 experimental) (1.1.25 sid)
  • Revision ID: package-import@ubuntu.com-20100930174619-txqppxj5vhrrvlhq
Tags: 3.1.4-1+8efb9d1ubuntu1
https://launchpad.net/bugs/603582
* Merge from debian unstable. (LP: #603582) 
* Remaining changes
  - Assemble.c, config.c: upgraded to the mdadm-3.1.4 version of these files
    from Debian.
  - debian/control: we need udev and util-linux in the right version. We
    also remove the build dependency from quilt and docbook-to-man as both
    are not used in Ubuntus mdadm.
  - debian/initramfs/hook: kept the Ubuntus version for handling the absence
    of active raid arrays in <initramfs>/etc/mdadm/mdadm.conf
  - debian/initramfs/script.local-top.DEBIAN, debian/mdadm-startall,
    debian/mdadm.raid.DEBIAN: removed. udev does its job now instead.
  - debian/mdadm-startall.sgml, debian/mdadm-startall.8: documentation of
    unused startall script
  - debian/mdadm.config, debian/mdadm.postinst - let udev do the handling
    instead. Resolved merge conflict by keeping Ubuntu's version.
  - debian/rules: kept debian's switch to using dh_lintian
  - debian/mdadm.links, debian/mdadm.manpages: dropped owing to the fact
    that these are not used in Ubuntu. Also dropped the build-dep on docbook
    to man)
  - debian/mdadm.postinst, debian/mdadm.config, initramfs/init-premount:
    boot-degraded enablement; maintain udev starting of RAID devices;
    init-premount hook script for the initramfs, to provide information at
    boot
  - debian/mkconf.in is the older mkconf. Kept the Ubuntus version.
  - debian/rules: Kept Ubuntus version for installing apport hooks, not
    installing un-used startall script and for adding a udev rule
    corresponding to mdadm.
  - debian/install-rc, check.d/_numbers, check.d/root_on_raid: Ubuntu partman
    installer changes
  - debian/presubj: Dropped this unused bug reporting file. Instead use
    source_mdadm.py act as an apport hook for bug handling.
  - rename debian/mdadm.vol_id.udev to debian/mdadm.mdadm-blkid.udev so that
    the rules file ends up with a more reasonable name

Show diffs side-by-side

added added

removed removed

Lines of Context:
mdadm.h
1
1
/*
2
2
 * mdadm - manage Linux "md" devices aka RAID arrays.
3
3
 *
4
 
 * Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
 
4
 * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
5
5
 *
6
6
 *
7
7
 *    This program is free software; you can redistribute it and/or modify
19
19
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
20
 *
21
21
 *    Author: Neil Brown
22
 
 *    Email: <neilb@cse.unsw.edu.au>
23
 
 *    Paper: Neil Brown
24
 
 *           School of Computer Science and Engineering
25
 
 *           The University of New South Wales
26
 
 *           Sydney, 2052
27
 
 *           Australia
 
22
 *    Email: <neilb@suse.de>
28
23
 */
29
24
 
30
25
#define _GNU_SOURCE
73
68
#define DEFAULT_BITMAP_DELAY 5
74
69
#define DEFAULT_MAX_WRITE_BEHIND 256
75
70
 
 
71
/* MAP_DIR should be somewhere that persists across the pivotroot
 
72
 * from early boot to late boot.
 
73
 * Currently /dev seems to be the only option on most distros.
 
74
 */
 
75
#ifndef MAP_DIR
 
76
#define MAP_DIR "/dev/.mdadm"
 
77
#endif /* MAP_DIR */
 
78
/* MAP_FILE is what we name the map file we put in MAP_DIR, in case you
 
79
 * want something other than the default of "map"
 
80
 */
 
81
#ifndef MAP_FILE
 
82
#define MAP_FILE "map"
 
83
#endif /* MAP_FILE */
 
84
/* MDMON_DIR is where pid and socket files used for communicating
 
85
 * with mdmon normally live.  It *should* be /var/run, but when
 
86
 * mdmon is needed at early boot then it needs to write there prior
 
87
 * to /var/run being mounted read/write, and it also then needs to
 
88
 * persist beyond when /var/run is mounter read-only.  So, to be
 
89
 * safe, the default is somewhere that is read/write early in the
 
90
 * boot process and stays up as long as possible during shutdown.
 
91
 */
 
92
#ifndef MDMON_DIR
 
93
#define MDMON_DIR "/dev/.mdadm/"
 
94
#endif /* MDMON_DIR */
 
95
 
76
96
#include        "md_u.h"
77
97
#include        "md_p.h"
78
98
#include        "bitmap.h"
 
99
#include        "msg.h"
79
100
 
80
101
#include <endian.h>
81
102
/* Redhat don't like to #include <asm/byteorder.h>, and
106
127
#define __le16_to_cpu(_x) (_x)
107
128
#define __le32_to_cpu(_x) (_x)
108
129
#define __le64_to_cpu(_x) (_x)
 
130
 
 
131
#define __cpu_to_be16(_x) bswap_16(_x)
 
132
#define __cpu_to_be32(_x) bswap_32(_x)
 
133
#define __cpu_to_be64(_x) bswap_64(_x)
 
134
#define __be16_to_cpu(_x) bswap_16(_x)
 
135
#define __be32_to_cpu(_x) bswap_32(_x)
 
136
#define __be64_to_cpu(_x) bswap_64(_x)
109
137
#elif BYTE_ORDER == BIG_ENDIAN
110
138
#define __cpu_to_le16(_x) bswap_16(_x)
111
139
#define __cpu_to_le32(_x) bswap_32(_x)
113
141
#define __le16_to_cpu(_x) bswap_16(_x)
114
142
#define __le32_to_cpu(_x) bswap_32(_x)
115
143
#define __le64_to_cpu(_x) bswap_64(_x)
 
144
 
 
145
#define __cpu_to_be16(_x) (_x)
 
146
#define __cpu_to_be32(_x) (_x)
 
147
#define __cpu_to_be64(_x) (_x)
 
148
#define __be16_to_cpu(_x) (_x)
 
149
#define __be32_to_cpu(_x) (_x)
 
150
#define __be64_to_cpu(_x) (_x)
116
151
#else
117
152
#  error "unknown endianness."
118
153
#endif
119
154
#endif /* __KLIBC__ */
120
155
 
121
156
 
 
157
/*
 
158
 * min()/max()/clamp() macros that also do
 
159
 * strict type-checking.. See the
 
160
 * "unnecessary" pointer comparison.
 
161
 */
 
162
#define min(x, y) ({                            \
 
163
        typeof(x) _min1 = (x);                  \
 
164
        typeof(y) _min2 = (y);                  \
 
165
        (void) (&_min1 == &_min2);              \
 
166
        _min1 < _min2 ? _min1 : _min2; })
 
167
 
 
168
#define max(x, y) ({                            \
 
169
        typeof(x) _max1 = (x);                  \
 
170
        typeof(y) _max2 = (y);                  \
 
171
        (void) (&_max1 == &_max2);              \
 
172
        _max1 > _max2 ? _max1 : _max2; })
122
173
 
123
174
/* general information that might be extracted from a superblock */
124
175
struct mdinfo {
128
179
        int                     uuid[4];
129
180
        char                    name[33];
130
181
        unsigned long long      data_offset;
131
 
        unsigned long long      component_size;
 
182
        unsigned long long      component_size; /* same as array.size, except in
 
183
                                                 * sectors and up to 64bits.
 
184
                                                 */
 
185
        unsigned long long      custom_array_size; /* size for non-default sized
 
186
                                                    * arrays (in sectors)
 
187
                                                    */
132
188
        int                     reshape_active;
133
189
        unsigned long long      reshape_progress;
 
190
        union {
 
191
                unsigned long long resync_start; /* per-array resync position */
 
192
                unsigned long long recovery_start; /* per-device rebuild position */
 
193
                #define MaxSector  (~0ULL) /* resync/recovery complete position */
 
194
        };
 
195
        unsigned long           safe_mode_delay; /* ms delay to mark clean */
134
196
        int                     new_level, delta_disks, new_layout, new_chunk;
135
197
        int                     errors;
136
 
        int                     cache_size; /* size of raid456 stripe cache*/
 
198
        unsigned long           cache_size; /* size of raid456 stripe cache*/
137
199
        int                     mismatch_cnt;
138
200
        char                    text_version[50];
 
201
        void                    *update_private; /* for passing metadata-format
 
202
                                                  * specific update data
 
203
                                                  * between successive calls to
 
204
                                                  * update_super()
 
205
                                                  */
139
206
 
 
207
        int container_member; /* for assembling external-metatdata arrays
 
208
                               * This is to be used internally by metadata
 
209
                               * handler only */
 
210
        int container_enough; /* flag external handlers can set to
 
211
                               * indicate that subarrays have not enough (-1),
 
212
                               * enough to start (0), or all expected disks (1) */
140
213
        char            sys_name[20];
141
214
        struct mdinfo *devs;
142
215
        struct mdinfo *next;
 
216
 
 
217
        /* Device info for mdmon: */
 
218
        int recovery_fd;
 
219
        int state_fd;
 
220
        #define DS_FAULTY       1
 
221
        #define DS_INSYNC       2
 
222
        #define DS_WRITE_MOSTLY 4
 
223
        #define DS_SPARE        8
 
224
        #define DS_BLOCKED      16
 
225
        #define DS_REMOVE       1024
 
226
        #define DS_UNBLOCK      2048
 
227
        int prev_state, curr_state, next_state;
 
228
 
143
229
};
144
230
 
145
231
struct createinfo {
176
262
 
177
263
/* for option that don't have short equivilents, we assign arbitrary
178
264
 * small numbers.  '1' means an undecorated option, so we start at '2'.
 
265
 * (note we must stop before we get to 65 i.e. 'A')
179
266
 */
180
267
enum special_options {
181
268
        AssumeClean = 2,
184
271
        ReAdd,
185
272
        NoDegraded,
186
273
        Sparc22,
187
 
        BackupFile,
 
274
        BackupFile, /* 8 */
188
275
        HomeHost,
189
276
        AutoHomeHost,
190
277
        Symlinks,
191
278
        AutoDetect,
 
279
        Waitclean,
 
280
        DetailPlatform,
 
281
        KillSubarray,
 
282
        UpdateSubarray, /* 16 */
192
283
};
193
284
 
194
285
/* structures read from config file */
209
300
        int     uuid[4];
210
301
        char    name[33];
211
302
 
212
 
        unsigned int super_minor;
 
303
        int super_minor;
213
304
 
214
305
        char    *devices;       /* comma separated list of device
215
306
                                 * names with wild cards
216
307
                                 */
217
308
        int     level;
218
 
        unsigned int raid_disks;
219
 
        unsigned int spare_disks;
 
309
        int raid_disks;
 
310
        int spare_disks;
220
311
        struct supertype *st;
221
312
        int     autof;          /* 1 for normal, 2 for partitioned */
222
313
        char    *spare_group;
223
314
        char    *bitmap_file;
224
315
        int     bitmap_fd;
225
316
 
 
317
        char    *container;     /* /dev/whatever name of container, or
 
318
                                 * uuid of container.  You would expect
 
319
                                 * this to be the 'devname' or UUID
 
320
                                 * of some other entry.
 
321
                                 */
 
322
        char    *member;        /* subarray within a container */
 
323
 
226
324
        struct mddev_ident_s *next;
 
325
        union {
 
326
                /* fields needed by different users of this structure */
 
327
                int assembled;  /* set when assembly succeeds */
 
328
        };
227
329
} *mddev_ident_t;
228
330
 
229
331
/* List of device names - wildcards expanded */
232
334
        char disposition;       /* 'a' for add, 'r' for remove, 'f' for fail.
233
335
                                 * Not set for names read from .config
234
336
                                 */
235
 
        char writemostly;
 
337
        char writemostly;       /* 1 for 'set writemostly', 2 for 'clear writemostly' */
236
338
        char re_add;
237
339
        char used;              /* set when used */
 
340
        struct mdinfo *content; /* If devname is a container, this might list
 
341
                                 * the remaining member arrays. */
238
342
        struct mddev_dev_s *next;
239
343
} *mddev_dev_t;
240
344
 
252
356
        char            *pattern; /* U or up, _ for down */
253
357
        int             percent; /* -1 if no resync */
254
358
        int             resync; /* 1 if resync, 0 if recovery */
 
359
        int             devcnt;
 
360
        int             raid_disks;
 
361
        int             chunk_size;
 
362
        char *          metadata_version;
 
363
        struct dev_member {
 
364
                char                    *name;
 
365
                struct dev_member       *next;
 
366
        }               *members;
255
367
        struct mdstat_ent *next;
256
368
};
257
369
 
258
370
extern struct mdstat_ent *mdstat_read(int hold, int start);
259
371
extern void free_mdstat(struct mdstat_ent *ms);
260
372
extern void mdstat_wait(int seconds);
 
373
extern void mdstat_wait_fd(int fd, const sigset_t *sigmask);
261
374
extern int mddev_busy(int devnum);
 
375
extern struct mdstat_ent *mdstat_by_component(char *name);
262
376
 
263
377
struct map_ent {
264
378
        struct map_ent *next;
265
379
        int     devnum;
266
 
        int     major,minor;
 
380
        char    metadata[20];
267
381
        int     uuid[4];
 
382
        int     bad;
268
383
        char    *path;
269
384
};
270
 
extern int map_update(struct map_ent **mpp, int devnum, int major, int minor,
 
385
extern int map_update(struct map_ent **mpp, int devnum, char *metadata,
271
386
                      int uuid[4], char *path);
 
387
extern void map_remove(struct map_ent **map, int devnum);
272
388
extern struct map_ent *map_by_uuid(struct map_ent **map, int uuid[4]);
 
389
extern struct map_ent *map_by_devnum(struct map_ent **map, int devnum);
 
390
extern struct map_ent *map_by_name(struct map_ent **map, char *name);
273
391
extern void map_read(struct map_ent **melp);
274
392
extern int map_write(struct map_ent *mel);
275
393
extern void map_delete(struct map_ent **mapp, int devnum);
276
394
extern void map_free(struct map_ent *map);
277
395
extern void map_add(struct map_ent **melp,
278
 
                    int devnum, int major, int minor, int uuid[4], char *path);
 
396
                    int devnum, char *metadata, int uuid[4], char *path);
 
397
extern int map_lock(struct map_ent **melp);
 
398
extern void map_unlock(struct map_ent **melp);
279
399
 
280
400
/* various details can be requested */
281
 
#define GET_LEVEL       1
282
 
#define GET_LAYOUT      2
283
 
#define GET_COMPONENT   4
284
 
#define GET_CHUNK       8
285
 
#define GET_CACHE       16
286
 
#define GET_MISMATCH    32
287
 
#define GET_VERSION     64
288
 
 
289
 
#define GET_DEVS        1024 /* gets role, major, minor */
290
 
#define GET_OFFSET      2048
291
 
#define GET_SIZE        4096
292
 
#define GET_STATE       8192
293
 
#define GET_ERROR       16384
 
401
enum sysfs_read_flags {
 
402
        GET_LEVEL       = (1 << 0),
 
403
        GET_LAYOUT      = (1 << 1),
 
404
        GET_COMPONENT   = (1 << 2),
 
405
        GET_CHUNK       = (1 << 3),
 
406
        GET_CACHE       = (1 << 4),
 
407
        GET_MISMATCH    = (1 << 5),
 
408
        GET_VERSION     = (1 << 6),
 
409
        GET_DISKS       = (1 << 7),
 
410
        GET_DEGRADED    = (1 << 8),
 
411
        GET_SAFEMODE    = (1 << 9),
 
412
        GET_DEVS        = (1 << 10), /* gets role, major, minor */
 
413
        GET_OFFSET      = (1 << 11),
 
414
        GET_SIZE        = (1 << 12),
 
415
        GET_STATE       = (1 << 13),
 
416
        GET_ERROR       = (1 << 14),
 
417
};
294
418
 
295
419
/* If fd >= 0, get the array it is open on,
296
420
 * else use devnum. >=0 -> major9. <0.....
297
421
 */
 
422
extern int sysfs_open(int devnum, char *devname, char *attr);
 
423
extern void sysfs_init(struct mdinfo *mdi, int fd, int devnum);
298
424
extern void sysfs_free(struct mdinfo *sra);
299
425
extern struct mdinfo *sysfs_read(int fd, int devnum, unsigned long options);
 
426
extern int sysfs_attr_match(const char *attr, const char *str);
 
427
extern int sysfs_match_word(const char *word, char **list);
300
428
extern int sysfs_set_str(struct mdinfo *sra, struct mdinfo *dev,
301
429
                         char *name, char *val);
302
430
extern int sysfs_set_num(struct mdinfo *sra, struct mdinfo *dev,
303
431
                         char *name, unsigned long long val);
 
432
extern int sysfs_uevent(struct mdinfo *sra, char *event);
 
433
extern int sysfs_get_fd(struct mdinfo *sra, struct mdinfo *dev,
 
434
                        char *name);
 
435
extern int sysfs_fd_get_ll(int fd, unsigned long long *val);
304
436
extern int sysfs_get_ll(struct mdinfo *sra, struct mdinfo *dev,
305
437
                        char *name, unsigned long long *val);
 
438
extern int sysfs_fd_get_str(int fd, char *val, int size);
 
439
extern int sysfs_get_str(struct mdinfo *sra, struct mdinfo *dev,
 
440
                         char *name, char *val, int size);
 
441
extern int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms);
 
442
extern int sysfs_set_array(struct mdinfo *info, int vers);
 
443
extern int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume);
 
444
extern int sysfs_disk_to_scsi_id(int fd, __u32 *id);
 
445
extern int sysfs_unique_holder(int devnum, long rdev);
 
446
extern int load_sys(char *path, char *buf);
306
447
 
307
448
 
308
449
extern int save_stripes(int *source, unsigned long long *offsets,
309
450
                        int raid_disks, int chunk_size, int level, int layout,
310
451
                        int nwrites, int *dest,
311
 
                        unsigned long long start, unsigned long long length);
 
452
                        unsigned long long start, unsigned long long length,
 
453
                        char *buf);
312
454
extern int restore_stripes(int *dest, unsigned long long *offsets,
313
455
                           int raid_disks, int chunk_size, int level, int layout,
314
456
                           int source, unsigned long long read_offset,
322
464
 
323
465
extern char *map_num(mapping_t *map, int num);
324
466
extern int map_name(mapping_t *map, char *name);
325
 
extern mapping_t r5layout[], pers[], modes[], faultylayout[];
 
467
extern mapping_t r5layout[], r6layout[], pers[], modes[], faultylayout[];
326
468
 
327
469
extern char *map_dev(int major, int minor, int create);
328
470
 
 
471
struct active_array;
 
472
struct metadata_update;
329
473
 
 
474
/* A superswitch provides entry point the a metadata handler.
 
475
 *
 
476
 * The super_switch primarily operates on some "metadata" that
 
477
 * is accessed via the 'supertype'.
 
478
 * This metadata has one of three possible sources.
 
479
 * 1/ It is read from a single device.  In this case it may not completely
 
480
 *    describe the array or arrays as some information might be on other
 
481
 *    devices.
 
482
 * 2/ It is read from all devices in a container.  In this case all
 
483
 *    information is present.
 
484
 * 3/ It is created by ->init_super / ->add_to_super.  In this case it will
 
485
 *    be complete once enough ->add_to_super calls have completed.
 
486
 *
 
487
 * When creating an array inside a container, the metadata will be
 
488
 * formed by a combination of 2 and 3.  The metadata or the array is read,
 
489
 * then new information is added.
 
490
 *
 
491
 * The metadata must sometimes have a concept of a 'current' array
 
492
 * and a 'current' device.
 
493
 * The 'current' array is set by init_super to be the newly created array,
 
494
 * or is set by super_by_fd when it finds it is looking at an array inside
 
495
 * a container.
 
496
 *
 
497
 * The 'current' device is either the device that the metadata was read from
 
498
 * in case 1, or the last device added by add_to_super in case 3.
 
499
 * Case 2 does not identify a 'current' device.
 
500
 */
330
501
extern struct superswitch {
 
502
 
 
503
        /* Used to report details of metadata read from a component
 
504
         * device. ->load_super has been called.
 
505
         */
331
506
        void (*examine_super)(struct supertype *st, char *homehost);
332
 
        void (*brief_examine_super)(struct supertype *st);
 
507
        void (*brief_examine_super)(struct supertype *st, int verbose);
 
508
        void (*brief_examine_subarrays)(struct supertype *st, int verbose);
333
509
        void (*export_examine_super)(struct supertype *st);
 
510
 
 
511
        /* Used to report details of an active array.
 
512
         * ->load_super was possibly given a 'component' string.
 
513
         */
334
514
        void (*detail_super)(struct supertype *st, char *homehost);
335
515
        void (*brief_detail_super)(struct supertype *st);
336
516
        void (*export_detail_super)(struct supertype *st);
 
517
 
 
518
        /* Optional: platform hardware / firmware details */
 
519
        int (*detail_platform)(int verbose, int enumerate_only);
 
520
 
 
521
        /* Used:
 
522
         *   to get uuid to storing in bitmap metadata
 
523
         *   and 'reshape' backup-data metadata
 
524
         *   To see if a device is being re-added to an array it was part of.
 
525
         */
337
526
        void (*uuid_from_super)(struct supertype *st, int uuid[4]);
 
527
 
 
528
        /* Extract generic details from metadata.  This could be details about
 
529
         * the container, or about an individual array within the container.
 
530
         * The determination is made either by:
 
531
         *   load_super being given a 'component' string.
 
532
         *   validate_geometry determining what to create.
 
533
         * The info includes both array information and device information.
 
534
         * The particular device should be:
 
535
         *   The last device added by add_to_super
 
536
         *   The device the metadata was loaded from by load_super
 
537
         */
338
538
        void (*getinfo_super)(struct supertype *st, struct mdinfo *info);
 
539
 
 
540
        /* Check if the given metadata is flagged as belonging to "this"
 
541
         * host.  0 for 'no', 1 for 'yes', -1 for "Don't record homehost"
 
542
         */
339
543
        int (*match_home)(struct supertype *st, char *homehost);
 
544
 
 
545
        /* Make one of several generic modifications to metadata
 
546
         * prior to assembly (or other times).
 
547
         *   sparc2.2  - first bug in early 0.90 metadata
 
548
         *   super-minor - change name of 0.90 metadata
 
549
         *   summaries - 'correct' any redundant data
 
550
         *   resync - mark array as dirty to trigger a resync.
 
551
         *   uuid - set new uuid - only 0.90 or 1.x
 
552
         *   name - change the name of the array (where supported)
 
553
         *   homehost - change which host this array is tied to.
 
554
         *   devicesize - If metadata is at start of device, change recorded
 
555
         *               device size to match actual device size
 
556
         *   byteorder - swap bytes for 0.90 metadata
 
557
         *
 
558
         *   force-one  - mark that device as uptodate, not old or failed.
 
559
         *   force-array - mark array as clean if it would not otherwise
 
560
         *               assemble
 
561
         *   assemble   - not sure how this is different from force-one...
 
562
         *   linear-grow-new - add a new device to a linear array, but don't
 
563
         *                   change the size: so superblock still matches
 
564
         *   linear-grow-update - now change the size of the array.
 
565
         */
340
566
        int (*update_super)(struct supertype *st, struct mdinfo *info,
341
567
                            char *update,
342
568
                            char *devname, int verbose,
343
569
                            int uuid_set, char *homehost);
 
570
 
 
571
        /* Create new metadata for new array as described.  This could
 
572
         * be a new container, or an array in a pre-existing container.
 
573
         * Also used to zero metadata prior to writing it to invalidate old
 
574
         * metadata.
 
575
         */
344
576
        int (*init_super)(struct supertype *st, mdu_array_info_t *info,
345
577
                          unsigned long long size, char *name,
346
578
                          char *homehost, int *uuid);
347
 
        void (*add_to_super)(struct supertype *st, mdu_disk_info_t *dinfo);
 
579
 
 
580
        /* update the metadata to include new device, either at create or
 
581
         * when hot-adding a spare.
 
582
         */
 
583
        int (*add_to_super)(struct supertype *st, mdu_disk_info_t *dinfo,
 
584
                             int fd, char *devname);
 
585
 
 
586
        /* Write metadata to one device when fixing problems or adding
 
587
         * a new device.
 
588
         */
348
589
        int (*store_super)(struct supertype *st, int fd);
349
 
        int (*write_init_super)(struct supertype *st, mdu_disk_info_t *dinfo,
350
 
                                char *devname);
 
590
 
 
591
        /*  Write all metadata for this array.
 
592
         */
 
593
        int (*write_init_super)(struct supertype *st);
351
594
        int (*compare_super)(struct supertype *st, struct supertype *tst);
352
595
        int (*load_super)(struct supertype *st, int fd, char *devname);
353
596
        struct supertype * (*match_metadata_desc)(char *arg);
358
601
        void (*locate_bitmap)(struct supertype *st, int fd);
359
602
        int (*write_bitmap)(struct supertype *st, int fd);
360
603
        void (*free_super)(struct supertype *st);
361
 
        int major;
 
604
 
 
605
        /* validate_geometry is called with an st returned by
 
606
         * match_metadata_desc.
 
607
         * It should check that the geometry described in compatible with
 
608
         * the metadata type.  It will be called repeatedly as devices
 
609
         * added to validate changing size and new devices.  If there are
 
610
         * inter-device dependencies, it should record sufficient details
 
611
         * so these can be validated.
 
612
         * Both 'size' and '*freesize' are in sectors.  chunk is bytes.
 
613
         */
 
614
        int (*validate_geometry)(struct supertype *st, int level, int layout,
 
615
                                 int raiddisks,
 
616
                                 int chunk, unsigned long long size,
 
617
                                 char *subdev, unsigned long long *freesize,
 
618
                                 int verbose);
 
619
 
 
620
        struct mdinfo *(*container_content)(struct supertype *st);
 
621
        /* Allow a metadata handler to override mdadm's default layouts */
 
622
        int (*default_layout)(int level); /* optional */
 
623
        /* query the supertype for default chunk size */
 
624
        int (*default_chunk)(struct supertype *st); /* optional */
 
625
        /* Permit subarray's to be deleted from inactive containers */
 
626
        int (*kill_subarray)(struct supertype *st); /* optional */
 
627
        /* Permit subarray's to be modified */
 
628
        int (*update_subarray)(struct supertype *st, char *update, mddev_ident_t ident); /* optional */
 
629
 
 
630
/* for mdmon */
 
631
        int (*open_new)(struct supertype *c, struct active_array *a,
 
632
                        char *inst);
 
633
 
 
634
        /* Tell the metadata handler the current state of the array.
 
635
         * This covers whether it is known to be consistent (no pending writes)
 
636
         * and how far along a resync is known to have progressed
 
637
         * (in a->resync_start).
 
638
         * resync status is really irrelevant if the array is not consistent,
 
639
         * but some metadata (DDF!) have a place to record the distinction.
 
640
         * If 'consistent' is '2', then the array can mark it dirty if a 
 
641
         * resync/recovery/whatever is required, or leave it clean if not.
 
642
         * Return value is 0 dirty (not consistent) and 1 if clean.
 
643
         * it is only really important if consistent is passed in as '2'.
 
644
         */
 
645
        int (*set_array_state)(struct active_array *a, int consistent);
 
646
 
 
647
        /* When the state of a device might have changed, we call set_disk to
 
648
         * tell the metadata what the current state is.
 
649
         * Typically this happens on spare->in_sync and (spare|in_sync)->faulty
 
650
         * transitions.
 
651
         * set_disk might be called when the state of the particular disk has
 
652
         * not in fact changed.
 
653
         */
 
654
        void (*set_disk)(struct active_array *a, int n, int state);
 
655
        void (*sync_metadata)(struct supertype *st);
 
656
        void (*process_update)(struct supertype *st,
 
657
                               struct metadata_update *update);
 
658
        void (*prepare_update)(struct supertype *st,
 
659
                               struct metadata_update *update);
 
660
 
 
661
        /* activate_spare will check if the array is degraded and, if it
 
662
         * is, try to find some spare space in the container.
 
663
         * On success, it add appropriate updates (For process_update) to
 
664
         * to the 'updates' list and returns a list of 'mdinfo' identifying
 
665
         * the device, or devices as there might be multiple missing
 
666
         * devices and multiple spares available.
 
667
         */
 
668
        struct mdinfo *(*activate_spare)(struct active_array *a,
 
669
                                         struct metadata_update **updates);
 
670
 
362
671
        int swapuuid; /* true if uuid is bigending rather than hostendian */
363
 
} super0, super1, *superlist[];
364
 
 
 
672
        int external;
 
673
        const char *name; /* canonical metadata name */
 
674
} super0, super1, super_ddf, *superlist[];
 
675
 
 
676
extern struct superswitch super_imsm;
 
677
 
 
678
struct metadata_update {
 
679
        int     len;
 
680
        char    *buf;
 
681
        void    *space; /* allocated space that monitor will use */
 
682
        struct metadata_update *next;
 
683
};
 
684
 
 
685
/* A supertype holds a particular collection of metadata.
 
686
 * It identifies the metadata type by the superswitch, and the particular
 
687
 * sub-version of that metadata type.
 
688
 * metadata read in or created is stored in 'sb' and 'info'.
 
689
 * There are also fields used by mdmon to track containers.
 
690
 *
 
691
 * A supertype may refer to:
 
692
 *   Just an array, possibly in a container
 
693
 *   A container, not identifying any particular array
 
694
 *   Info read from just one device, not yet fully describing the array/container.
 
695
 *
 
696
 *
 
697
 * A supertype is created by:
 
698
 *   super_by_fd
 
699
 *   guess_super
 
700
 *   dup_super
 
701
 */
365
702
struct supertype {
366
703
        struct superswitch *ss;
367
704
        int minor_version;
368
705
        int max_devs;
 
706
        int container_dev;    /* devnum of container */
 
707
        char subarray[32];      /* name of array inside container */
369
708
        void *sb;
 
709
        void *info;
 
710
        int loaded_container;   /* Set if load_super found a container,
 
711
                                 * not just one device */
 
712
 
 
713
        struct metadata_update *updates;
 
714
        struct metadata_update **update_tail;
 
715
 
 
716
        /* extra stuff used by mdmon */
 
717
        struct active_array *arrays;
 
718
        int sock; /* listen to external programs */
 
719
        int devnum;
 
720
        char *devname; /* e.g. md0.  This appears in metadata_verison:
 
721
                        *  external:/md0/12
 
722
                        */
 
723
        int devcnt;
 
724
 
 
725
        struct mdinfo *devs;
 
726
 
370
727
};
371
728
 
372
729
extern struct supertype *super_by_fd(int fd);
375
732
extern int get_dev_size(int fd, char *dname, unsigned long long *sizep);
376
733
extern void get_one_disk(int mdfd, mdu_array_info_t *ainf,
377
734
                         mdu_disk_info_t *disk);
 
735
void wait_for(char *dev, int fd);
378
736
 
379
737
#if __GNUC__ < 3
380
738
struct stat64;
383
741
#define HAVE_NFTW  we assume
384
742
#define HAVE_FTW
385
743
 
386
 
#ifdef UCLIBC
 
744
#ifdef __UCLIBC__
387
745
# include <features.h>
 
746
# ifndef __UCLIBC_HAS_LFS__
 
747
#  define lseek64 lseek
 
748
# endif
388
749
# ifndef  __UCLIBC_HAS_FTW__
389
750
#  undef HAVE_FTW
390
751
#  undef HAVE_NFTW
417
778
extern int Manage_ro(char *devname, int fd, int readonly);
418
779
extern int Manage_runstop(char *devname, int fd, int runstop, int quiet);
419
780
extern int Manage_resize(char *devname, int fd, long long size, int raid_disks);
420
 
extern int Manage_reconfig(char *devname, int fd, int layout);
421
781
extern int Manage_subdevs(char *devname, int fd,
422
 
                          mddev_dev_t devlist, int verbose);
 
782
                          mddev_dev_t devlist, int verbose, int test);
423
783
extern int autodetect(void);
424
784
extern int Grow_Add_device(char *devname, int fd, char *newdev);
425
785
extern int Grow_addbitmap(char *devname, int fd, char *file, int chunk, int delay, int write_behind, int force);
426
786
extern int Grow_reshape(char *devname, int fd, int quiet, char *backup_file,
427
787
                        long long size,
428
 
                        int level, int layout, int chunksize, int raid_disks);
 
788
                        int level, char *layout_str, int chunksize, int raid_disks);
429
789
extern int Grow_restart(struct supertype *st, struct mdinfo *info,
430
 
                        int *fdlist, int cnt, char *backup_file);
431
 
 
432
 
 
433
 
extern int Assemble(struct supertype *st, char *mddev, int mdfd,
 
790
                        int *fdlist, int cnt, char *backup_file, int verbose);
 
791
extern int Grow_continue(int mdfd, struct supertype *st,
 
792
                         struct mdinfo *info, char *backup_file);
 
793
 
 
794
extern int Assemble(struct supertype *st, char *mddev,
434
795
                    mddev_ident_t ident,
435
796
                    mddev_dev_t devlist, char *backup_file,
436
797
                    int readonly, int runstop,
437
 
                    char *update, char *homehost,
 
798
                    char *update, char *homehost, int require_homehost,
438
799
                    int verbose, int force);
439
800
 
440
 
extern int Build(char *mddev, int mdfd, int chunk, int level, int layout,
441
 
                 int raiddisks,
442
 
                 mddev_dev_t devlist, int assume_clean,
443
 
                 char *bitmap_file, int bitmap_chunk, int write_behind, int delay, int verbose);
444
 
 
445
 
 
446
 
extern int Create(struct supertype *st, char *mddev, int mdfd,
 
801
extern int Build(char *mddev, int chunk, int level, int layout,
 
802
                 int raiddisks, mddev_dev_t devlist, int assume_clean,
 
803
                 char *bitmap_file, int bitmap_chunk, int write_behind,
 
804
                 int delay, int verbose, int autof, unsigned long long size);
 
805
 
 
806
 
 
807
extern int Create(struct supertype *st, char *mddev,
447
808
                  int chunk, int level, int layout, unsigned long long size, int raiddisks, int sparedisks,
448
809
                  char *name, char *homehost, int *uuid,
449
810
                  int subdevs, mddev_dev_t devlist,
450
811
                  int runstop, int verbose, int force, int assume_clean,
451
 
                  char *bitmap_file, int bitmap_chunk, int write_behind, int delay);
 
812
                  char *bitmap_file, int bitmap_chunk, int write_behind, int delay, int autof);
452
813
 
453
814
extern int Detail(char *dev, int brief, int export, int test, char *homehost);
 
815
extern int Detail_Platform(struct superswitch *ss, int scan, int verbose);
454
816
extern int Query(char *dev);
455
817
extern int Examine(mddev_dev_t devlist, int brief, int export, int scan,
456
818
                   int SparcAdjust, struct supertype *forcest, char *homehost);
457
819
extern int Monitor(mddev_dev_t devlist,
458
820
                   char *mailaddr, char *alert_cmd,
459
821
                   int period, int daemonise, int scan, int oneshot,
460
 
                   int dosyslog, int test, char *pidfile);
 
822
                   int dosyslog, int test, char *pidfile, int increments);
461
823
 
462
 
extern int Kill(char *dev, int force, int quiet);
 
824
extern int Kill(char *dev, struct supertype *st, int force, int quiet, int noexcl);
 
825
extern int Kill_subarray(char *dev, char *subarray, int quiet);
 
826
extern int Update_subarray(char *dev, char *subarray, char *update, mddev_ident_t ident, int quiet);
463
827
extern int Wait(char *dev);
 
828
extern int WaitClean(char *dev, int sock, int verbose);
464
829
 
465
830
extern int Incremental(char *devname, int verbose, int runstop,
466
 
                       struct supertype *st, char *homehost, int autof);
 
831
                       struct supertype *st, char *homehost, int require_homehost,
 
832
                       int autof);
 
833
extern int Incremental_container(struct supertype *st, char *devname,
 
834
                                 int verbose, int runstop, int autof,
 
835
                                 int trustworthy);
467
836
extern void RebuildMap(void);
468
837
extern int IncrementalScan(int verbose);
469
 
 
 
838
extern int IncrementalRemove(char *devname, int verbose);
470
839
extern int CreateBitmap(char *filename, int force, char uuid[16],
471
840
                        unsigned long chunksize, unsigned long daemon_sleep,
472
841
                        unsigned long write_behind,
478
847
 
479
848
extern int md_get_version(int fd);
480
849
extern int get_linux_version(void);
 
850
extern long long parse_size(char *size);
481
851
extern int parse_uuid(char *str, int uuid[4]);
 
852
extern int parse_layout_10(char *layout);
 
853
extern int parse_layout_faulty(char *layout);
482
854
extern int check_ext2(int fd, char *name);
483
855
extern int check_reiser(int fd, char *name);
484
856
extern int check_raid(int fd, char *name);
 
857
extern int check_partitions(int fd, char *dname, unsigned long long freesize);
485
858
 
486
859
extern int get_mdp_major(void);
487
860
extern int dev_open(char *dev, int flags);
 
861
extern int open_dev(int devnum);
 
862
extern int open_dev_excl(int devnum);
488
863
extern int is_standard(char *dev, int *nump);
 
864
extern int same_dev(char *one, char *two);
489
865
 
490
866
extern int parse_auto(char *str, char *msg, int config);
491
867
extern mddev_ident_t conf_get_ident(char *dev);
492
868
extern mddev_dev_t conf_get_devs(void);
493
869
extern int conf_test_dev(char *devname);
 
870
extern int conf_test_metadata(const char *version, int is_homehost);
494
871
extern struct createinfo *conf_get_create_info(void);
495
872
extern void set_conffile(char *file);
496
873
extern char *conf_get_mailaddr(void);
497
874
extern char *conf_get_mailfrom(void);
498
875
extern char *conf_get_program(void);
499
 
extern char *conf_get_homehost(void);
 
876
extern char *conf_get_homehost(int *require_homehostp);
500
877
extern char *conf_line(FILE *file);
501
878
extern char *conf_word(FILE *file, int allow_key);
 
879
extern int conf_name_is_free(char *name);
 
880
extern int devname_matches(char *name, char *match);
 
881
extern struct mddev_ident_s *conf_match(struct mdinfo *info, struct supertype *st);
 
882
 
502
883
extern void free_line(char *line);
503
884
extern int match_oneof(char *devices, char *devname);
504
885
extern void uuid_from_super(int uuid[4], mdp_super_t *super);
 
886
extern const int uuid_match_any[4];
505
887
extern int same_uuid(int a[4], int b[4], int swapuuid);
506
888
extern void copy_uuid(void *a, int b[4], int swapuuid);
 
889
extern char *__fname_from_uuid(int id[4], int swap, char *buf, char sep);
 
890
extern char *fname_from_uuid(struct supertype *st,
 
891
                             struct mdinfo *info, char *buf, char sep);
507
892
extern unsigned long calc_csum(void *super, int bytes);
508
893
extern int enough(int level, int raid_disks, int layout, int clean,
509
894
                   char *avail, int avail_disks);
510
895
extern int ask(char *mesg);
511
896
extern unsigned long long get_component_size(int fd);
512
897
extern void remove_partitions(int fd);
 
898
extern int test_partition(int fd);
 
899
extern unsigned long long calc_array_size(int level, int raid_disks, int layout,
 
900
                                   int chunksize, unsigned long long devsize);
 
901
extern int flush_metadata_updates(struct supertype *st);
 
902
extern void append_metadata_update(struct supertype *st, void *buf, int len);
 
903
extern int assemble_container_content(struct supertype *st, int mdfd,
 
904
                                      struct mdinfo *content, int runstop,
 
905
                                      char *chosen_name, int verbose);
513
906
 
 
907
extern int add_disk(int mdfd, struct supertype *st,
 
908
                    struct mdinfo *sra, struct mdinfo *info);
 
909
extern int set_array_info(int mdfd, struct supertype *st, struct mdinfo *info);
 
910
unsigned long long min_recovery_start(struct mdinfo *array);
514
911
 
515
912
extern char *human_size(long long bytes);
516
 
char *human_size_brief(long long bytes);
 
913
extern char *human_size_brief(long long bytes);
 
914
extern void print_r10_layout(int layout);
517
915
 
518
916
#define NoMdDev (1<<23)
519
917
extern int find_free_devnum(int use_partitions);
523
921
 
524
922
extern char DefaultConfFile[];
525
923
 
526
 
extern int open_mddev(char *dev, int autof);
527
 
extern int open_mddev_devnum(char *devname, int devnum, char *name,
528
 
                             char *chosen_name, int parts);
529
 
 
 
924
extern int create_mddev(char *dev, char *name, int autof, int trustworthy,
 
925
                        char *chosen);
 
926
/* values for 'trustworthy' */
 
927
#define LOCAL   1
 
928
#define LOCAL_ANY 10
 
929
#define FOREIGN 2
 
930
#define METADATA 3
 
931
extern int open_mddev(char *dev, int report_errors);
 
932
extern int open_container(int fd);
 
933
extern int is_container_member(struct mdstat_ent *ent, char *devname);
 
934
extern int is_subarray_active(char *subarray, char *devname);
 
935
int is_container_active(char *devname);
 
936
extern int open_subarray(char *dev, struct supertype *st, int quiet);
 
937
extern struct superswitch *version_to_superswitch(char *vers);
 
938
 
 
939
extern int mdmon_running(int devnum);
 
940
extern int mdmon_pid(int devnum);
 
941
extern int check_env(char *name);
 
942
extern __u32 random32(void);
 
943
extern int start_mdmon(int devnum);
 
944
 
 
945
extern char *devnum2devname(int num);
 
946
extern int devname2devnum(char *name);
 
947
extern int stat2devnum(struct stat *st);
 
948
extern int fd2devnum(int fd);
 
949
 
 
950
static inline int dev2major(int d)
 
951
{
 
952
        if (d >= 0)
 
953
                return MD_MAJOR;
 
954
        else
 
955
                return get_mdp_major();
 
956
}
 
957
 
 
958
static inline int dev2minor(int d)
 
959
{
 
960
        if (d >= 0)
 
961
                return d;
 
962
        return (-1-d) << MdpMinorShift;
 
963
}
 
964
 
 
965
static inline int ROUND_UP(int a, int base)
 
966
{
 
967
        return ((a+base-1)/base)*base;
 
968
}
 
969
 
 
970
static inline int is_subarray(char *vers)
 
971
{
 
972
        /* The version string for a 'subarray' (an array in a container)
 
973
         * is 
 
974
         *    /containername/componentname    for normal read-write arrays
 
975
         *    -containername/componentname    for read-only arrays.
 
976
         * containername is e.g. md0, md_d1
 
977
         * componentname is dependant on the metadata. e.g. '1' 'S1' ...
 
978
         */
 
979
        return (*vers == '/' || *vers == '-');
 
980
}
 
981
 
 
982
#ifdef DEBUG
 
983
#define dprintf(fmt, arg...) \
 
984
        fprintf(stderr, fmt, ##arg)
 
985
#else
 
986
#define dprintf(fmt, arg...) \
 
987
        ({ if (0) fprintf(stderr, fmt, ##arg); 0; })
 
988
#endif
 
989
#include <assert.h>
 
990
#include <stdarg.h>
 
991
static inline int xasprintf(char **strp, const char *fmt, ...) {
 
992
        va_list ap;
 
993
        int ret;
 
994
        va_start(ap, fmt);
 
995
        ret = vasprintf(strp, fmt, ap);
 
996
        va_end(ap);
 
997
        assert(ret >= 0);
 
998
        return ret;
 
999
}
530
1000
 
531
1001
#define LEVEL_MULTIPATH         (-4)
532
1002
#define LEVEL_LINEAR            (-1)
533
1003
#define LEVEL_FAULTY            (-5)
534
1004
 
 
1005
/* kernel module doesn't know about these */
 
1006
#define LEVEL_CONTAINER         (-100)
 
1007
#define LEVEL_UNSUPPORTED       (-200)
 
1008
 
535
1009
 
536
1010
/* faulty stuff */
537
1011
 
562
1036
#define makedev(M,m) (((M)<<8) | (m))
563
1037
#endif
564
1038
 
565
 
/* for raid5 */
 
1039
/* for raid4/5/6 */
566
1040
#define ALGORITHM_LEFT_ASYMMETRIC       0
567
1041
#define ALGORITHM_RIGHT_ASYMMETRIC      1
568
1042
#define ALGORITHM_LEFT_SYMMETRIC        2
569
1043
#define ALGORITHM_RIGHT_SYMMETRIC       3
 
1044
 
 
1045
/* Define non-rotating (raid4) algorithms.  These allow
 
1046
 * conversion of raid4 to raid5.
 
1047
 */
 
1048
#define ALGORITHM_PARITY_0              4 /* P or P,Q are initial devices */
 
1049
#define ALGORITHM_PARITY_N              5 /* P or P,Q are final devices. */
 
1050
 
 
1051
/* DDF RAID6 layouts differ from md/raid6 layouts in two ways.
 
1052
 * Firstly, the exact positioning of the parity block is slightly
 
1053
 * different between the 'LEFT_*' modes of md and the "_N_*" modes
 
1054
 * of DDF.
 
1055
 * Secondly, or order of datablocks over which the Q syndrome is computed
 
1056
 * is different.
 
1057
 * Consequently we have different layouts for DDF/raid6 than md/raid6.
 
1058
 * These layouts are from the DDFv1.2 spec.
 
1059
 * Interestingly DDFv1.2-Errata-A does not specify N_CONTINUE but
 
1060
 * leaves RLQ=3 as 'Vendor Specific'
 
1061
 */
 
1062
 
 
1063
#define ALGORITHM_ROTATING_ZERO_RESTART 8 /* DDF PRL=6 RLQ=1 */
 
1064
#define ALGORITHM_ROTATING_N_RESTART    9 /* DDF PRL=6 RLQ=2 */
 
1065
#define ALGORITHM_ROTATING_N_CONTINUE   10 /*DDF PRL=6 RLQ=3 */
 
1066
 
 
1067
 
 
1068
/* For every RAID5 algorithm we define a RAID6 algorithm
 
1069
 * with exactly the same layout for data and parity, and
 
1070
 * with the Q block always on the last device (N-1).
 
1071
 * This allows trivial conversion from RAID5 to RAID6
 
1072
 */
 
1073
#define ALGORITHM_LEFT_ASYMMETRIC_6     16
 
1074
#define ALGORITHM_RIGHT_ASYMMETRIC_6    17
 
1075
#define ALGORITHM_LEFT_SYMMETRIC_6      18
 
1076
#define ALGORITHM_RIGHT_SYMMETRIC_6     19
 
1077
#define ALGORITHM_PARITY_0_6            20
 
1078
#define ALGORITHM_PARITY_N_6            ALGORITHM_PARITY_N
 
1079
 
 
1080
/* Define PATH_MAX in case we don't use glibc or standard library does
 
1081
 * not have PATH_MAX defined. Assume max path length is 4K characters.
 
1082
 */
 
1083
#ifndef PATH_MAX
 
1084
#define PATH_MAX        4096
 
1085
#endif
 
1086