struct map_ent {
struct map_ent *next;
int devnum;
- int major,minor;
+ char metadata[20];
int uuid[4];
char *path;
};
-extern int map_update(struct map_ent **mpp, int devnum, int major, int minor,
+extern int map_update(struct map_ent **mpp, int devnum, char *metadata,
int uuid[4], char *path);
extern struct map_ent *map_by_uuid(struct map_ent **map, int uuid[4]);
extern void map_read(struct map_ent **melp);
extern void map_delete(struct map_ent **mapp, int devnum);
extern void map_free(struct map_ent *map);
extern void map_add(struct map_ent **melp,
- int devnum, int major, int minor, int uuid[4], char *path);
+ int devnum, char *metadata, int uuid[4], char *path);
/* various details can be requested */
#define GET_LEVEL 1
#define GET_MISMATCH 32
#define GET_VERSION 64
#define GET_DISKS 128
+#define GET_DEGRADED 256
#define GET_DEVS 1024 /* gets role, major, minor */
#define GET_OFFSET 2048
extern int sysfs_set_array(struct mdinfo *sra,
struct mdinfo *info);
extern int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd);
-extern int sysfs_disk_to_sg(int fd);
extern int sysfs_disk_to_scsi_id(int fd, __u32 *id);
+extern int sysfs_unique_holder(int devnum, long rdev);
extern int save_stripes(int *source, unsigned long long *offsets,
struct active_array;
struct metadata_update;
+/* A superswitch provides entry point the a metadata handler.
+ *
+ * The super_switch primarily operates on some "metadata" that
+ * is accessed via the 'supertype'.
+ * This metadata has one of three possible sources.
+ * 1/ It is read from a single device. In this case it may not completely
+ * describe the array or arrays as some information might be on other
+ * devices.
+ * 2/ It is read from all devices in a container. In this case all
+ * information is present.
+ * 3/ It is created by ->init_super / ->add_to_super. In this case it will
+ * be complete once enough ->add_to_super calls have completed.
+ *
+ * When creating an array inside a container, the metadata will be
+ * formed by a combination of 2 and 3. The metadata or the array is read,
+ * then new information is added.
+ *
+ * The metadata must sometimes have a concept of a 'current' array
+ * and a 'current' device.
+ * The 'current' array is set by init_super to be the newly created array,
+ * or is set by super_by_fd when it finds it is looking at an array inside
+ * a container.
+ *
+ * The 'current' device is either the device that the metadata was read from
+ * in case 1, or the last device added by add_to_super in case 3.
+ * Case 2 does not identify a 'current' device.
+ */
extern struct superswitch {
+
+ /* Used to report details of metadata read from a component
+ * device. ->load_super has been called.
+ */
void (*examine_super)(struct supertype *st, char *homehost);
void (*brief_examine_super)(struct supertype *st);
void (*export_examine_super)(struct supertype *st);
+
+ /* Used to report details of an active array.
+ * ->load_super was possibly given a 'component' string.
+ */
void (*detail_super)(struct supertype *st, char *homehost);
void (*brief_detail_super)(struct supertype *st);
void (*export_detail_super)(struct supertype *st);
+
+ /* Used:
+ * to get uuid to storing in bitmap metadata
+ * and 'reshape' backup-data metadata
+ * To see if a device is being re-added to an array it was part of.
+ */
void (*uuid_from_super)(struct supertype *st, int uuid[4]);
+
+ /* Extra generic details from metadata. This could be details about
+ * the container, or about an individual array within the container.
+ * The determination is made either by:
+ * load_super being given a 'component' string.
+ * validate_geometry determining what to create.
+ * The info includes both array information and device information.
+ * The particular device should be:
+ * The last device added by add_to_super
+ * The device the metadata was loaded from by load_super
+ */
void (*getinfo_super)(struct supertype *st, struct mdinfo *info);
- void (*getinfo_super_n)(struct supertype *st, struct mdinfo *info);
+
+ /* Check if the given metadata is flagged as belonging to "this"
+ * host. For arrays that don't determine a minor-number, this
+ * can always be true (??)
+ */
int (*match_home)(struct supertype *st, char *homehost);
+
+ /* Make one of several generic modifications to metadata
+ * prior to assembly (or other times).
+ * sparc2.2 - first bug in early 0.90 metadata
+ * super-minor - change name of 0.90 metadata
+ * summaries - 'correct' any redundant data
+ * resync - mark array as dirty to trigger a resync.
+ * uuid - set new uuid - only 0.90 or 1.x
+ * name - change the name of the array (where supported)
+ * homehost - change which host this array is tied to.
+ * devicesize - If metadata is at start of device, change recorded
+ * device size to match actual device size
+ * byteorder - swap bytes for 0.90 metadata
+ *
+ * force-one - mark that device as uptodate, not old or failed.
+ * force-array - mark array as clean if it would not otherwise
+ * assemble
+ * assemble - not sure how this is different from force-one...
+ * linear-grow-new - add a new device to a linear array, but don't
+ * change the size: so superblock still matches
+ * linear-grow-update - now change the size of the array.
+ */
int (*update_super)(struct supertype *st, struct mdinfo *info,
char *update,
char *devname, int verbose,
int uuid_set, char *homehost);
+
+ /* Create new metadata for new array as described. This could
+ * be a new container, or an array in a pre-existing container.
+ * Also used to zero metadata prior to writing it to invalidate old
+ * metadata.
+ */
int (*init_super)(struct supertype *st, mdu_array_info_t *info,
unsigned long long size, char *name,
char *homehost, int *uuid);
+
+ /* update the metadata to include new device, either at create or
+ * when hot-adding a spare.
+ */
void (*add_to_super)(struct supertype *st, mdu_disk_info_t *dinfo,
int fd, char *devname);
+
+ /* Write metadata to one device when fixing problems or adding
+ * a new device.
+ */
int (*store_super)(struct supertype *st, int fd);
+
+ /* Write all metadata for this array.
+ */
int (*write_init_super)(struct supertype *st);
int (*compare_super)(struct supertype *st, struct supertype *tst);
int (*load_super)(struct supertype *st, int fd, char *devname);
void (*locate_bitmap)(struct supertype *st, int fd);
int (*write_bitmap)(struct supertype *st, int fd);
void (*free_super)(struct supertype *st);
+
+ /* validate_geometry is called with an st returned by
+ * match_metadata_desc.
+ * It should check that the geometry described in compatible with
+ * the metadata type. It will be called repeatedly as devices
+ * added to validate changing size and new devices. If there are
+ * inter-device dependencies, it should record sufficient details
+ * so these can be validated.
+ */
int (*validate_geometry)(struct supertype *st, int level, int layout,
int raiddisks,
int chunk, unsigned long long size,
- char *subdev, unsigned long long *freesize);
+ char *subdev, unsigned long long *freesize,
+ int verbose);
struct mdinfo *(*container_content)(struct supertype *st);
void (*sync_metadata)(struct supertype *st);
void (*process_update)(struct supertype *st,
struct metadata_update *update);
+ void (*prepare_update)(struct supertype *st,
+ struct metadata_update *update);
/* activate_spare will check if the array is degraded and, if it
* is, try to find some spare space in the container.
struct mdinfo *(*activate_spare)(struct active_array *a,
struct metadata_update **updates);
- int major;
int swapuuid; /* true if uuid is bigending rather than hostendian */
int external;
-} super0, super1, super_ddf, super_ddf_bvd, super_ddf_svd, *superlist[];
+} super0, super1, super_ddf, *superlist[];
+
+extern struct superswitch super_imsm;
-extern struct superswitch super_imsm, super_imsm_volume;
+struct metadata_update {
+ int len;
+ char *buf;
+ void *space; /* allocated space that monitor will use */
+ struct metadata_update *next;
+};
+/* A supertype holds a particular collection of metadata.
+ * It identifies the metadata type by the superswitch, and the particular
+ * sub-version of that metadata type.
+ * metadata read in or created is stored in 'sb' and 'info'.
+ * There are also fields used by mdmon to track containers.
+ *
+ * A supertype is created by:
+ * super_by_fd
+ * guess_super
+ * dup_super
+ */
struct supertype {
struct superswitch *ss;
int minor_version;
int max_devs;
int container_dev; /* devnum of container */
+ char subarray[32]; /* name of array inside container */
void *sb;
void *info;
+ struct metadata_update *updates;
+ struct metadata_update **update_tail;
+
/* extra stuff used by mdmon */
struct active_array *arrays;
int sock; /* listen to external programs */
- int mgr_pipe[2]; /* communicate between threads */
- int mon_pipe[2]; /* communicate between threads */
int devnum;
char *devname; /* e.g. md0. This appears in metadata_verison:
* external:/md0/12
};
-extern struct supertype supertype_container_member;
extern struct supertype *super_by_fd(int fd);
extern struct supertype *guess_super(int fd);
extern struct supertype *dup_super(struct supertype *st);
extern void remove_partitions(int fd);
extern unsigned long long calc_array_size(int level, int raid_disks, int layout,
int chunksize, unsigned long long devsize);
+extern int flush_metadata_updates(struct supertype *st);
+extern void append_metadata_update(struct supertype *st, void *buf, int len);
extern char *human_size(long long bytes);
extern int mdmon_running(int devnum);
extern int signal_mdmon(int devnum);
+extern int env_no_mdmon(void);
+extern int start_mdmon(int devnum);
extern char *devnum2devname(int num);
+extern int devname2devnum(char *name);
extern int fd2devnum(int fd);
static inline int dev2major(int d)
return (-1-d) << MdpMinorShift;
}
+static inline int ROUND_UP(int a, int base)
+{
+ return ((a+base-1)/base)*base;
+}
+
#define LEVEL_MULTIPATH (-4)
#define LEVEL_LINEAR (-1)
#define LEVEL_FAULTY (-5)