]> git.ipfire.org Git - thirdparty/mdadm.git/blame - super-intel.c
projects / thirdparty / mdadm.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
imsm: FIX: update first array in container only
[thirdparty/mdadm.git] / super-intel.c
CommitLineData
cdddbdbc
DW		 1/*
2 * mdadm - Intel(R) Matrix Storage Manager Support
3 *
a54d5262 4 * Copyright (C) 2002-2008 Intel Corporation
cdddbdbc
DW		 5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
51006d85 20#define HAVE_STDINT_H 1
cdddbdbc 21#include "mdadm.h"
c2a1e7da 22#include "mdmon.h"
51006d85 23#include "sha1.h"
88c32bb1 24#include "platform-intel.h"
cdddbdbc
DW		 25#include <values.h>
26#include <scsi/sg.h>
27#include <ctype.h>
d665cc31 28#include <dirent.h>
cdddbdbc
DW		 29
30/* MPB == Metadata Parameter Block */
31#define MPB_SIGNATURE "Intel Raid ISM Cfg Sig. "
32#define MPB_SIG_LEN (strlen(MPB_SIGNATURE))
33#define MPB_VERSION_RAID0 "1.0.00"
34#define MPB_VERSION_RAID1 "1.1.00"
fe7ed8cb
DW		 35#define MPB_VERSION_MANY_VOLUMES_PER_ARRAY "1.2.00"
36#define MPB_VERSION_3OR4_DISK_ARRAY "1.2.01"
cdddbdbc 37#define MPB_VERSION_RAID5 "1.2.02"
fe7ed8cb
DW		 38#define MPB_VERSION_5OR6_DISK_ARRAY "1.2.04"
39#define MPB_VERSION_CNG "1.2.06"
40#define MPB_VERSION_ATTRIBS "1.3.00"
cdddbdbc
DW		 41#define MAX_SIGNATURE_LENGTH 32
42#define MAX_RAID_SERIAL_LEN 16
fe7ed8cb
DW		 43
44#define MPB_ATTRIB_CHECKSUM_VERIFY __cpu_to_le32(0x80000000)
45#define MPB_ATTRIB_PM __cpu_to_le32(0x40000000)
46#define MPB_ATTRIB_2TB __cpu_to_le32(0x20000000)
47#define MPB_ATTRIB_RAID0 __cpu_to_le32(0x00000001)
48#define MPB_ATTRIB_RAID1 __cpu_to_le32(0x00000002)
49#define MPB_ATTRIB_RAID10 __cpu_to_le32(0x00000004)
50#define MPB_ATTRIB_RAID1E __cpu_to_le32(0x00000008)
51#define MPB_ATTRIB_RAID5 __cpu_to_le32(0x00000010)
52#define MPB_ATTRIB_RAIDCNG __cpu_to_le32(0x00000020)
53
c2c087e6
DW		 54#define MPB_SECTOR_CNT 418
55#define IMSM_RESERVED_SECTORS 4096
979d38be 56#define SECT_PER_MB_SHIFT 11
cdddbdbc
DW		 57
58/* Disk configuration info. */
59#define IMSM_MAX_DEVICES 255
60struct imsm_disk {
61 __u8 serial[MAX_RAID_SERIAL_LEN];/* 0xD8 - 0xE7 ascii serial number */
62 __u32 total_blocks; /* 0xE8 - 0xEB total blocks */
63 __u32 scsi_id; /* 0xEC - 0xEF scsi ID */
f2f27e63
DW		 64#define SPARE_DISK __cpu_to_le32(0x01) /* Spare */
65#define CONFIGURED_DISK __cpu_to_le32(0x02) /* Member of some RaidDev */
66#define FAILED_DISK __cpu_to_le32(0x04) /* Permanent failure */
cdddbdbc 67 __u32 status; /* 0xF0 - 0xF3 */
fe7ed8cb
DW		 68 __u32 owner_cfg_num; /* which config 0,1,2... owns this disk */
69#define IMSM_DISK_FILLERS 4
cdddbdbc
DW		 70 __u32 filler[IMSM_DISK_FILLERS]; /* 0xF4 - 0x107 MPB_DISK_FILLERS for future expansion */
71};
72
73/* RAID map configuration infos. */
74struct imsm_map {
75 __u32 pba_of_lba0; /* start address of partition */
76 __u32 blocks_per_member;/* blocks per member */
77 __u32 num_data_stripes; /* number of data stripes */
78 __u16 blocks_per_strip;
79 __u8 map_state; /* Normal, Uninitialized, Degraded, Failed */
80#define IMSM_T_STATE_NORMAL 0
81#define IMSM_T_STATE_UNINITIALIZED 1
e3bba0e0
DW		 82#define IMSM_T_STATE_DEGRADED 2
83#define IMSM_T_STATE_FAILED 3
cdddbdbc
DW		 84 __u8 raid_level;
85#define IMSM_T_RAID0 0
86#define IMSM_T_RAID1 1
87#define IMSM_T_RAID5 5 /* since metadata version 1.2.02 ? */
88 __u8 num_members; /* number of member disks */
fe7ed8cb
DW		 89 __u8 num_domains; /* number of parity domains */
90 __u8 failed_disk_num; /* valid only when state is degraded */
252d23c0 91 __u8 ddf;
cdddbdbc 92 __u32 filler[7]; /* expansion area */
7eef0453 93#define IMSM_ORD_REBUILD (1 << 24)
cdddbdbc 94 __u32 disk_ord_tbl[1]; /* disk_ord_tbl[num_members],
7eef0453
DW		 95 * top byte contains some flags
96 */
cdddbdbc
DW		 97} __attribute__ ((packed));
98
99struct imsm_vol {
f8f603f1 100 __u32 curr_migr_unit;
fe7ed8cb 101 __u32 checkpoint_id; /* id to access curr_migr_unit */
cdddbdbc 102 __u8 migr_state; /* Normal or Migrating */
e3bba0e0
DW		 103#define MIGR_INIT 0
104#define MIGR_REBUILD 1
105#define MIGR_VERIFY 2 /* analagous to echo check > sync_action */
106#define MIGR_GEN_MIGR 3
107#define MIGR_STATE_CHANGE 4
1484e727 108#define MIGR_REPAIR 5
cdddbdbc
DW		 109 __u8 migr_type; /* Initializing, Rebuilding, ... */
110 __u8 dirty;
fe7ed8cb
DW		 111 __u8 fs_state; /* fast-sync state for CnG (0xff == disabled) */
112 __u16 verify_errors; /* number of mismatches */
113 __u16 bad_blocks; /* number of bad blocks during verify */
114 __u32 filler[4];
cdddbdbc
DW		 115 struct imsm_map map[1];
116 /* here comes another one if migr_state */
117} __attribute__ ((packed));
118
119struct imsm_dev {
fe7ed8cb 120 __u8 volume[MAX_RAID_SERIAL_LEN];
cdddbdbc
DW		 121 __u32 size_low;
122 __u32 size_high;
fe7ed8cb
DW		 123#define DEV_BOOTABLE __cpu_to_le32(0x01)
124#define DEV_BOOT_DEVICE __cpu_to_le32(0x02)
125#define DEV_READ_COALESCING __cpu_to_le32(0x04)
126#define DEV_WRITE_COALESCING __cpu_to_le32(0x08)
127#define DEV_LAST_SHUTDOWN_DIRTY __cpu_to_le32(0x10)
128#define DEV_HIDDEN_AT_BOOT __cpu_to_le32(0x20)
129#define DEV_CURRENTLY_HIDDEN __cpu_to_le32(0x40)
130#define DEV_VERIFY_AND_FIX __cpu_to_le32(0x80)
131#define DEV_MAP_STATE_UNINIT __cpu_to_le32(0x100)
132#define DEV_NO_AUTO_RECOVERY __cpu_to_le32(0x200)
133#define DEV_CLONE_N_GO __cpu_to_le32(0x400)
134#define DEV_CLONE_MAN_SYNC __cpu_to_le32(0x800)
135#define DEV_CNG_MASTER_DISK_NUM __cpu_to_le32(0x1000)
cdddbdbc
DW		 136 __u32 status; /* Persistent RaidDev status */
137 __u32 reserved_blocks; /* Reserved blocks at beginning of volume */
fe7ed8cb
DW		 138 __u8 migr_priority;
139 __u8 num_sub_vols;
140 __u8 tid;
141 __u8 cng_master_disk;
142 __u16 cache_policy;
143 __u8 cng_state;
144 __u8 cng_sub_state;
145#define IMSM_DEV_FILLERS 10
cdddbdbc
DW		 146 __u32 filler[IMSM_DEV_FILLERS];
147 struct imsm_vol vol;
148} __attribute__ ((packed));
149
150struct imsm_super {
151 __u8 sig[MAX_SIGNATURE_LENGTH]; /* 0x00 - 0x1F */
152 __u32 check_sum; /* 0x20 - 0x23 MPB Checksum */
153 __u32 mpb_size; /* 0x24 - 0x27 Size of MPB */
154 __u32 family_num; /* 0x28 - 0x2B Checksum from first time this config was written */
155 __u32 generation_num; /* 0x2C - 0x2F Incremented each time this array's MPB is written */
604b746f
JD		 156 __u32 error_log_size; /* 0x30 - 0x33 in bytes */
157 __u32 attributes; /* 0x34 - 0x37 */
cdddbdbc
DW		 158 __u8 num_disks; /* 0x38 Number of configured disks */
159 __u8 num_raid_devs; /* 0x39 Number of configured volumes */
604b746f
JD		 160 __u8 error_log_pos; /* 0x3A */
161 __u8 fill[1]; /* 0x3B */
162 __u32 cache_size; /* 0x3c - 0x40 in mb */
163 __u32 orig_family_num; /* 0x40 - 0x43 original family num */
164 __u32 pwr_cycle_count; /* 0x44 - 0x47 simulated power cycle count for array */
165 __u32 bbm_log_size; /* 0x48 - 0x4B - size of bad Block Mgmt Log in bytes */
166#define IMSM_FILLERS 35
167 __u32 filler[IMSM_FILLERS]; /* 0x4C - 0xD7 RAID_MPB_FILLERS */
cdddbdbc
DW		 168 struct imsm_disk disk[1]; /* 0xD8 diskTbl[numDisks] */
169 /* here comes imsm_dev[num_raid_devs] */
604b746f 170 /* here comes BBM logs */
cdddbdbc
DW		 171} __attribute__ ((packed));
172
604b746f
JD		 173#define BBM_LOG_MAX_ENTRIES 254
174
175struct bbm_log_entry {
176 __u64 defective_block_start;
177#define UNREADABLE 0xFFFFFFFF
178 __u32 spare_block_offset;
179 __u16 remapped_marked_count;
180 __u16 disk_ordinal;
181} __attribute__ ((__packed__));
182
183struct bbm_log {
184 __u32 signature; /* 0xABADB10C */
185 __u32 entry_count;
186 __u32 reserved_spare_block_count; /* 0 */
187 __u32 reserved; /* 0xFFFF */
188 __u64 first_spare_lba;
189 struct bbm_log_entry mapped_block_entries[BBM_LOG_MAX_ENTRIES];
190} __attribute__ ((__packed__));
191
192
cdddbdbc
DW		 193#ifndef MDASSEMBLE
194static char *map_state_str[] = { "normal", "uninitialized", "degraded", "failed" };
195#endif
196
1484e727
DW		 197static __u8 migr_type(struct imsm_dev *dev)
198{
199 if (dev->vol.migr_type == MIGR_VERIFY &&
200 dev->status & DEV_VERIFY_AND_FIX)
201 return MIGR_REPAIR;
202 else
203 return dev->vol.migr_type;
204}
205
206static void set_migr_type(struct imsm_dev *dev, __u8 migr_type)
207{
208 /* for compatibility with older oroms convert MIGR_REPAIR, into
209 * MIGR_VERIFY w/ DEV_VERIFY_AND_FIX status
210 */
211 if (migr_type == MIGR_REPAIR) {
212 dev->vol.migr_type = MIGR_VERIFY;
213 dev->status |= DEV_VERIFY_AND_FIX;
214 } else {
215 dev->vol.migr_type = migr_type;
216 dev->status &= ~DEV_VERIFY_AND_FIX;
217 }
218}
219
87eb16df 220static unsigned int sector_count(__u32 bytes)
cdddbdbc 221{
87eb16df
DW		 222 return ((bytes + (512-1)) & (~(512-1))) / 512;
223}
cdddbdbc 224
87eb16df
DW		 225static unsigned int mpb_sectors(struct imsm_super *mpb)
226{
227 return sector_count(__le32_to_cpu(mpb->mpb_size));
cdddbdbc
DW		 228}
229
ba2de7ba
DW		 230struct intel_dev {
231 struct imsm_dev *dev;
232 struct intel_dev *next;
f21e18ca 233 unsigned index;
ba2de7ba
DW		 234};
235
1a64be56
LM		 236enum action {
237 DISK_REMOVE = 1,
238 DISK_ADD
239};
cdddbdbc
DW		 240/* internal representation of IMSM metadata */
241struct intel_super {
242 union {
949c47a0
DW		 243 void *buf; /* O_DIRECT buffer for reading/writing metadata */
244 struct imsm_super *anchor; /* immovable parameters */
cdddbdbc 245 };
949c47a0 246 size_t len; /* size of the 'buf' allocation */
4d7b1503
DW		 247 void *next_buf; /* for realloc'ing buf from the manager */
248 size_t next_len;
c2c087e6 249 int updates_pending; /* count of pending updates for mdmon */
bf5a934a 250 int current_vol; /* index of raid device undergoing creation */
0dcecb2e 251 __u32 create_offset; /* common start for 'current_vol' */
148acb7b 252 __u32 random; /* random data for seeding new family numbers */
ba2de7ba 253 struct intel_dev *devlist;
cdddbdbc
DW		 254 struct dl {
255 struct dl *next;
256 int index;
257 __u8 serial[MAX_RAID_SERIAL_LEN];
258 int major, minor;
259 char *devname;
b9f594fe 260 struct imsm_disk disk;
cdddbdbc 261 int fd;
0dcecb2e
DW		 262 int extent_cnt;
263 struct extent *e; /* for determining freespace @ create */
efb30e7f 264 int raiddisk; /* slot to fill in autolayout */
1a64be56 265 enum action action;
cdddbdbc 266 } *disks;
1a64be56
LM		 267 struct dl *disk_mgmt_list; /* list of disks to add/remove while mdmon
268 active */
47ee5a45 269 struct dl *missing; /* disks removed while we weren't looking */
43dad3d6 270 struct bbm_log *bbm_log;
88c32bb1
DW		 271 const char *hba; /* device path of the raid controller for this metadata */
272 const struct imsm_orom *orom; /* platform firmware support */
a2b97981
DW		 273 struct intel_super *next; /* (temp) list for disambiguating family_num */
274};
275
276struct intel_disk {
277 struct imsm_disk disk;
278 #define IMSM_UNKNOWN_OWNER (-1)
279 int owner;
280 struct intel_disk *next;
cdddbdbc
DW		 281};
282
c2c087e6
DW		 283struct extent {
284 unsigned long long start, size;
285};
286
88758e9d
DW		 287/* definition of messages passed to imsm_process_update */
288enum imsm_update_type {
289 update_activate_spare,
8273f55e 290 update_create_array,
33414a01 291 update_kill_array,
aa534678 292 update_rename_array,
1a64be56 293 update_add_remove_disk,
78b10e66 294 update_reshape_container_disks,
88758e9d
DW		 295};
296
297struct imsm_update_activate_spare {
298 enum imsm_update_type type;
d23fe947 299 struct dl *dl;
88758e9d
DW		 300 int slot;
301 int array;
302 struct imsm_update_activate_spare *next;
303};
304
78b10e66
N		 305struct geo_params {
306 int dev_id;
307 char *dev_name;
308 long long size;
309 int level;
310 int layout;
311 int chunksize;
312 int raid_disks;
313};
314
315
316struct imsm_update_reshape {
317 enum imsm_update_type type;
318 int old_raid_disks;
319 int new_raid_disks;
d195167d 320 int new_disks[1]; /* new_raid_disks - old_raid_disks makedev number */
78b10e66
N		 321};
322
54c2c1ea
DW		 323struct disk_info {
324 __u8 serial[MAX_RAID_SERIAL_LEN];
325};
326
8273f55e
DW		 327struct imsm_update_create_array {
328 enum imsm_update_type type;
8273f55e 329 int dev_idx;
6a3e913e 330 struct imsm_dev dev;
8273f55e
DW		 331};
332
33414a01
DW		 333struct imsm_update_kill_array {
334 enum imsm_update_type type;
335 int dev_idx;
336};
337
aa534678
DW		 338struct imsm_update_rename_array {
339 enum imsm_update_type type;
340 __u8 name[MAX_RAID_SERIAL_LEN];
341 int dev_idx;
342};
343
1a64be56 344struct imsm_update_add_remove_disk {
43dad3d6
DW		 345 enum imsm_update_type type;
346};
347
cdddbdbc
DW		 348static struct supertype *match_metadata_desc_imsm(char *arg)
349{
350 struct supertype *st;
351
352 if (strcmp(arg, "imsm") != 0 &&
353 strcmp(arg, "default") != 0
354 )
355 return NULL;
356
357 st = malloc(sizeof(*st));
4e9d2186
AW		 358 if (!st)
359 return NULL;
ef609477 360 memset(st, 0, sizeof(*st));
d1d599ea 361 st->container_dev = NoMdDev;
cdddbdbc
DW		 362 st->ss = &super_imsm;
363 st->max_devs = IMSM_MAX_DEVICES;
364 st->minor_version = 0;
365 st->sb = NULL;
366 return st;
367}
368
0e600426 369#ifndef MDASSEMBLE
cdddbdbc
DW		 370static __u8 *get_imsm_version(struct imsm_super *mpb)
371{
372 return &mpb->sig[MPB_SIG_LEN];
373}
0e600426 374#endif
cdddbdbc 375
949c47a0
DW		 376/* retrieve a disk directly from the anchor when the anchor is known to be
377 * up-to-date, currently only at load time
378 */
379static struct imsm_disk *__get_imsm_disk(struct imsm_super *mpb, __u8 index)
cdddbdbc 380{
949c47a0 381 if (index >= mpb->num_disks)
cdddbdbc
DW		 382 return NULL;
383 return &mpb->disk[index];
384}
385
95d07a2c
LM		 386/* retrieve the disk description based on a index of the disk
387 * in the sub-array
388 */
389static struct dl *get_imsm_dl_disk(struct intel_super *super, __u8 index)
949c47a0 390{
b9f594fe
DW		 391 struct dl *d;
392
393 for (d = super->disks; d; d = d->next)
394 if (d->index == index)
95d07a2c
LM		 395 return d;
396
397 return NULL;
398}
399/* retrieve a disk from the parsed metadata */
400static struct imsm_disk *get_imsm_disk(struct intel_super *super, __u8 index)
401{
402 struct dl *dl;
403
404 dl = get_imsm_dl_disk(super, index);
405 if (dl)
406 return &dl->disk;
407
b9f594fe 408 return NULL;
949c47a0
DW		 409}
410
411/* generate a checksum directly from the anchor when the anchor is known to be
412 * up-to-date, currently only at load or write_super after coalescing
413 */
414static __u32 __gen_imsm_checksum(struct imsm_super *mpb)
cdddbdbc
DW		 415{
416 __u32 end = mpb->mpb_size / sizeof(end);
417 __u32 *p = (__u32 *) mpb;
418 __u32 sum = 0;
419
97f734fd
N		 420 while (end--) {
421 sum += __le32_to_cpu(*p);
422 p++;
423 }
cdddbdbc
DW		 424
425 return sum - __le32_to_cpu(mpb->check_sum);
426}
427
a965f303
DW		 428static size_t sizeof_imsm_map(struct imsm_map *map)
429{
430 return sizeof(struct imsm_map) + sizeof(__u32) * (map->num_members - 1);
431}
432
433struct imsm_map *get_imsm_map(struct imsm_dev *dev, int second_map)
cdddbdbc 434{
a965f303
DW		 435 struct imsm_map *map = &dev->vol.map[0];
436
437 if (second_map && !dev->vol.migr_state)
438 return NULL;
439 else if (second_map) {
440 void *ptr = map;
441
442 return ptr + sizeof_imsm_map(map);
443 } else
444 return map;
445
446}
cdddbdbc 447
3393c6af
DW		 448/* return the size of the device.
449 * migr_state increases the returned size if map[0] were to be duplicated
450 */
451static size_t sizeof_imsm_dev(struct imsm_dev *dev, int migr_state)
a965f303
DW		 452{
453 size_t size = sizeof(*dev) - sizeof(struct imsm_map) +
454 sizeof_imsm_map(get_imsm_map(dev, 0));
cdddbdbc
DW		 455
456 /* migrating means an additional map */
a965f303
DW		 457 if (dev->vol.migr_state)
458 size += sizeof_imsm_map(get_imsm_map(dev, 1));
3393c6af
DW		 459 else if (migr_state)
460 size += sizeof_imsm_map(get_imsm_map(dev, 0));
cdddbdbc
DW		 461
462 return size;
463}
464
54c2c1ea
DW		 465#ifndef MDASSEMBLE
466/* retrieve disk serial number list from a metadata update */
467static struct disk_info *get_disk_info(struct imsm_update_create_array *update)
468{
469 void *u = update;
470 struct disk_info *inf;
471
472 inf = u + sizeof(*update) - sizeof(struct imsm_dev) +
473 sizeof_imsm_dev(&update->dev, 0);
474
475 return inf;
476}
477#endif
478
949c47a0 479static struct imsm_dev *__get_imsm_dev(struct imsm_super *mpb, __u8 index)
cdddbdbc
DW		 480{
481 int offset;
482 int i;
483 void *_mpb = mpb;
484
949c47a0 485 if (index >= mpb->num_raid_devs)
cdddbdbc
DW		 486 return NULL;
487
488 /* devices start after all disks */
489 offset = ((void *) &mpb->disk[mpb->num_disks]) - _mpb;
490
491 for (i = 0; i <= index; i++)
492 if (i == index)
493 return _mpb + offset;
494 else
3393c6af 495 offset += sizeof_imsm_dev(_mpb + offset, 0);
cdddbdbc
DW		 496
497 return NULL;
498}
499
949c47a0
DW		 500static struct imsm_dev *get_imsm_dev(struct intel_super *super, __u8 index)
501{
ba2de7ba
DW		 502 struct intel_dev *dv;
503
949c47a0
DW		 504 if (index >= super->anchor->num_raid_devs)
505 return NULL;
ba2de7ba
DW		 506 for (dv = super->devlist; dv; dv = dv->next)
507 if (dv->index == index)
508 return dv->dev;
509 return NULL;
949c47a0
DW		 510}
511
98130f40
AK		 512/*
513 * for second_map:
514 * == 0 get first map
515 * == 1 get second map
516 * == -1 than get map according to the current migr_state
517 */
518static __u32 get_imsm_ord_tbl_ent(struct imsm_dev *dev,
519 int slot,
520 int second_map)
7eef0453
DW		 521{
522 struct imsm_map *map;
523
98130f40
AK		 524 if (second_map == -1) {
525 if (dev->vol.migr_state)
526 map = get_imsm_map(dev, 1);
527 else
528 map = get_imsm_map(dev, 0);
529 } else {
530 map = get_imsm_map(dev, second_map);
531 }
7eef0453 532
ff077194
DW		 533 /* top byte identifies disk under rebuild */
534 return __le32_to_cpu(map->disk_ord_tbl[slot]);
535}
536
537#define ord_to_idx(ord) (((ord) << 8) >> 8)
98130f40 538static __u32 get_imsm_disk_idx(struct imsm_dev *dev, int slot, int second_map)
ff077194 539{
98130f40 540 __u32 ord = get_imsm_ord_tbl_ent(dev, slot, second_map);
ff077194
DW		 541
542 return ord_to_idx(ord);
7eef0453
DW		 543}
544
be73972f
DW		 545static void set_imsm_ord_tbl_ent(struct imsm_map *map, int slot, __u32 ord)
546{
547 map->disk_ord_tbl[slot] = __cpu_to_le32(ord);
548}
549
f21e18ca 550static int get_imsm_disk_slot(struct imsm_map *map, unsigned idx)
620b1713
DW		 551{
552 int slot;
553 __u32 ord;
554
555 for (slot = 0; slot < map->num_members; slot++) {
556 ord = __le32_to_cpu(map->disk_ord_tbl[slot]);
557 if (ord_to_idx(ord) == idx)
558 return slot;
559 }
560
561 return -1;
562}
563
cdddbdbc
DW		 564static int get_imsm_raid_level(struct imsm_map *map)
565{
566 if (map->raid_level == 1) {
567 if (map->num_members == 2)
568 return 1;
569 else
570 return 10;
571 }
572
573 return map->raid_level;
574}
575
c2c087e6
DW		 576static int cmp_extent(const void *av, const void *bv)
577{
578 const struct extent *a = av;
579 const struct extent *b = bv;
580 if (a->start < b->start)
581 return -1;
582 if (a->start > b->start)
583 return 1;
584 return 0;
585}
586
0dcecb2e 587static int count_memberships(struct dl *dl, struct intel_super *super)
c2c087e6 588{
c2c087e6 589 int memberships = 0;
620b1713 590 int i;
c2c087e6 591
949c47a0
DW		 592 for (i = 0; i < super->anchor->num_raid_devs; i++) {
593 struct imsm_dev *dev = get_imsm_dev(super, i);
a965f303 594 struct imsm_map *map = get_imsm_map(dev, 0);
c2c087e6 595
620b1713
DW		 596 if (get_imsm_disk_slot(map, dl->index) >= 0)
597 memberships++;
c2c087e6 598 }
0dcecb2e
DW		 599
600 return memberships;
601}
602
603static struct extent *get_extents(struct intel_super *super, struct dl *dl)
604{
605 /* find a list of used extents on the given physical device */
606 struct extent *rv, *e;
620b1713 607 int i;
0dcecb2e
DW		 608 int memberships = count_memberships(dl, super);
609 __u32 reservation = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
610
c2c087e6
DW		 611 rv = malloc(sizeof(struct extent) * (memberships + 1));
612 if (!rv)
613 return NULL;
614 e = rv;
615
949c47a0
DW		 616 for (i = 0; i < super->anchor->num_raid_devs; i++) {
617 struct imsm_dev *dev = get_imsm_dev(super, i);
a965f303 618 struct imsm_map *map = get_imsm_map(dev, 0);
c2c087e6 619
620b1713
DW		 620 if (get_imsm_disk_slot(map, dl->index) >= 0) {
621 e->start = __le32_to_cpu(map->pba_of_lba0);
622 e->size = __le32_to_cpu(map->blocks_per_member);
623 e++;
c2c087e6
DW		 624 }
625 }
626 qsort(rv, memberships, sizeof(*rv), cmp_extent);
627
14e8215b
DW		 628 /* determine the start of the metadata
629 * when no raid devices are defined use the default
630 * ...otherwise allow the metadata to truncate the value
631 * as is the case with older versions of imsm
632 */
633 if (memberships) {
634 struct extent *last = &rv[memberships - 1];
635 __u32 remainder;
636
637 remainder = __le32_to_cpu(dl->disk.total_blocks) -
638 (last->start + last->size);
dda5855f
DW		 639 /* round down to 1k block to satisfy precision of the kernel
640 * 'size' interface
641 */
642 remainder &= ~1UL;
643 /* make sure remainder is still sane */
f21e18ca 644 if (remainder < (unsigned)ROUND_UP(super->len, 512) >> 9)
dda5855f 645 remainder = ROUND_UP(super->len, 512) >> 9;
14e8215b
DW		 646 if (reservation > remainder)
647 reservation = remainder;
648 }
649 e->start = __le32_to_cpu(dl->disk.total_blocks) - reservation;
c2c087e6
DW		 650 e->size = 0;
651 return rv;
652}
653
14e8215b
DW		 654/* try to determine how much space is reserved for metadata from
655 * the last get_extents() entry, otherwise fallback to the
656 * default
657 */
658static __u32 imsm_reserved_sectors(struct intel_super *super, struct dl *dl)
659{
660 struct extent *e;
661 int i;
662 __u32 rv;
663
664 /* for spares just return a minimal reservation which will grow
665 * once the spare is picked up by an array
666 */
667 if (dl->index == -1)
668 return MPB_SECTOR_CNT;
669
670 e = get_extents(super, dl);
671 if (!e)
672 return MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
673
674 /* scroll to last entry */
675 for (i = 0; e[i].size; i++)
676 continue;
677
678 rv = __le32_to_cpu(dl->disk.total_blocks) - e[i].start;
679
680 free(e);
681
682 return rv;
683}
684
25ed7e59
DW		 685static int is_spare(struct imsm_disk *disk)
686{
687 return (disk->status & SPARE_DISK) == SPARE_DISK;
688}
689
690static int is_configured(struct imsm_disk *disk)
691{
692 return (disk->status & CONFIGURED_DISK) == CONFIGURED_DISK;
693}
694
695static int is_failed(struct imsm_disk *disk)
696{
697 return (disk->status & FAILED_DISK) == FAILED_DISK;
698}
699
80e7f8c3
AC		 700/* Return minimum size of a spare that can be used in this array*/
701static unsigned long long min_acceptable_spare_size_imsm(struct supertype *st)
702{
703 struct intel_super *super = st->sb;
704 struct dl *dl;
705 struct extent *e;
706 int i;
707 unsigned long long rv = 0;
708
709 if (!super)
710 return rv;
711 /* find first active disk in array */
712 dl = super->disks;
713 while (dl && (is_failed(&dl->disk) || dl->index == -1))
714 dl = dl->next;
715 if (!dl)
716 return rv;
717 /* find last lba used by subarrays */
718 e = get_extents(super, dl);
719 if (!e)
720 return rv;
721 for (i = 0; e[i].size; i++)
722 continue;
723 if (i > 0)
724 rv = e[i-1].start + e[i-1].size;
725 free(e);
726 /* add the amount of space needed for metadata */
727 rv = rv + MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
728 return rv * 512;
729}
730
1799c9e8 731#ifndef MDASSEMBLE
1e5c6983
DW		 732static __u64 blocks_per_migr_unit(struct imsm_dev *dev);
733
44470971 734static void print_imsm_dev(struct imsm_dev *dev, char *uuid, int disk_idx)
cdddbdbc
DW		 735{
736 __u64 sz;
0d80bb2f 737 int slot, i;
a965f303 738 struct imsm_map *map = get_imsm_map(dev, 0);
dd8bcb3b 739 struct imsm_map *map2 = get_imsm_map(dev, 1);
b10b37b8 740 __u32 ord;
cdddbdbc
DW		 741
742 printf("\n");
1e7bc0ed 743 printf("[%.16s]:\n", dev->volume);
44470971 744 printf(" UUID : %s\n", uuid);
dd8bcb3b
AK		 745 printf(" RAID Level : %d", get_imsm_raid_level(map));
746 if (map2)
747 printf(" <-- %d", get_imsm_raid_level(map2));
748 printf("\n");
749 printf(" Members : %d", map->num_members);
750 if (map2)
751 printf(" <-- %d", map2->num_members);
752 printf("\n");
0d80bb2f
DW		 753 printf(" Slots : [");
754 for (i = 0; i < map->num_members; i++) {
dd8bcb3b 755 ord = get_imsm_ord_tbl_ent(dev, i, 0);
0d80bb2f
DW		 756 printf("%s", ord & IMSM_ORD_REBUILD ? "_" : "U");
757 }
dd8bcb3b
AK		 758 printf("]");
759 if (map2) {
760 printf(" <-- [");
761 for (i = 0; i < map2->num_members; i++) {
762 ord = get_imsm_ord_tbl_ent(dev, i, 1);
763 printf("%s", ord & IMSM_ORD_REBUILD ? "_" : "U");
764 }
765 printf("]");
766 }
767 printf("\n");
620b1713
DW		 768 slot = get_imsm_disk_slot(map, disk_idx);
769 if (slot >= 0) {
98130f40 770 ord = get_imsm_ord_tbl_ent(dev, slot, -1);
b10b37b8
DW		 771 printf(" This Slot : %d%s\n", slot,
772 ord & IMSM_ORD_REBUILD ? " (out-of-sync)" : "");
773 } else
cdddbdbc
DW		 774 printf(" This Slot : ?\n");
775 sz = __le32_to_cpu(dev->size_high);
776 sz <<= 32;
777 sz += __le32_to_cpu(dev->size_low);
778 printf(" Array Size : %llu%s\n", (unsigned long long)sz,
779 human_size(sz * 512));
780 sz = __le32_to_cpu(map->blocks_per_member);
781 printf(" Per Dev Size : %llu%s\n", (unsigned long long)sz,
782 human_size(sz * 512));
783 printf(" Sector Offset : %u\n",
784 __le32_to_cpu(map->pba_of_lba0));
785 printf(" Num Stripes : %u\n",
786 __le32_to_cpu(map->num_data_stripes));
dd8bcb3b 787 printf(" Chunk Size : %u KiB",
cdddbdbc 788 __le16_to_cpu(map->blocks_per_strip) / 2);
dd8bcb3b
AK		 789 if (map2)
790 printf(" <-- %u KiB",
791 __le16_to_cpu(map2->blocks_per_strip) / 2);
792 printf("\n");
cdddbdbc 793 printf(" Reserved : %d\n", __le32_to_cpu(dev->reserved_blocks));
8655a7b1 794 printf(" Migrate State : ");
1484e727
DW		 795 if (dev->vol.migr_state) {
796 if (migr_type(dev) == MIGR_INIT)
8655a7b1 797 printf("initialize\n");
1484e727 798 else if (migr_type(dev) == MIGR_REBUILD)
8655a7b1 799 printf("rebuild\n");
1484e727 800 else if (migr_type(dev) == MIGR_VERIFY)
8655a7b1 801 printf("check\n");
1484e727 802 else if (migr_type(dev) == MIGR_GEN_MIGR)
8655a7b1 803 printf("general migration\n");
1484e727 804 else if (migr_type(dev) == MIGR_STATE_CHANGE)
8655a7b1 805 printf("state change\n");
1484e727 806 else if (migr_type(dev) == MIGR_REPAIR)
8655a7b1 807 printf("repair\n");
1484e727 808 else
8655a7b1
DW		 809 printf("<unknown:%d>\n", migr_type(dev));
810 } else
811 printf("idle\n");
3393c6af
DW		 812 printf(" Map State : %s", map_state_str[map->map_state]);
813 if (dev->vol.migr_state) {
814 struct imsm_map *map = get_imsm_map(dev, 1);
1e5c6983 815
b10b37b8 816 printf(" <-- %s", map_state_str[map->map_state]);
1e5c6983
DW		 817 printf("\n Checkpoint : %u (%llu)",
818 __le32_to_cpu(dev->vol.curr_migr_unit),
94fcb80a 819 (unsigned long long)blocks_per_migr_unit(dev));
3393c6af
DW		 820 }
821 printf("\n");
cdddbdbc 822 printf(" Dirty State : %s\n", dev->vol.dirty ? "dirty" : "clean");
cdddbdbc
DW		 823}
824
14e8215b 825static void print_imsm_disk(struct imsm_super *mpb, int index, __u32 reserved)
cdddbdbc 826{
949c47a0 827 struct imsm_disk *disk = __get_imsm_disk(mpb, index);
1f24f035 828 char str[MAX_RAID_SERIAL_LEN + 1];
cdddbdbc
DW		 829 __u64 sz;
830
d362da3d 831 if (index < 0 || !disk)
e9d82038
DW		 832 return;
833
cdddbdbc 834 printf("\n");
1f24f035 835 snprintf(str, MAX_RAID_SERIAL_LEN + 1, "%s", disk->serial);
cdddbdbc 836 printf(" Disk%02d Serial : %s\n", index, str);
25ed7e59
DW		 837 printf(" State :%s%s%s\n", is_spare(disk) ? " spare" : "",
838 is_configured(disk) ? " active" : "",
839 is_failed(disk) ? " failed" : "");
cdddbdbc 840 printf(" Id : %08x\n", __le32_to_cpu(disk->scsi_id));
14e8215b 841 sz = __le32_to_cpu(disk->total_blocks) - reserved;
cdddbdbc
DW		 842 printf(" Usable Size : %llu%s\n", (unsigned long long)sz,
843 human_size(sz * 512));
844}
845
a5d85af7 846static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info, char *map);
44470971 847
cdddbdbc
DW		 848static void examine_super_imsm(struct supertype *st, char *homehost)
849{
850 struct intel_super *super = st->sb;
949c47a0 851 struct imsm_super *mpb = super->anchor;
cdddbdbc
DW		 852 char str[MAX_SIGNATURE_LENGTH];
853 int i;
27fd6274
DW		 854 struct mdinfo info;
855 char nbuf[64];
cdddbdbc 856 __u32 sum;
14e8215b 857 __u32 reserved = imsm_reserved_sectors(super, super->disks);
94827db3 858 struct dl *dl;
27fd6274 859
cdddbdbc
DW		 860 snprintf(str, MPB_SIG_LEN, "%s", mpb->sig);
861 printf(" Magic : %s\n", str);
862 snprintf(str, strlen(MPB_VERSION_RAID0), "%s", get_imsm_version(mpb));
863 printf(" Version : %s\n", get_imsm_version(mpb));
148acb7b 864 printf(" Orig Family : %08x\n", __le32_to_cpu(mpb->orig_family_num));
cdddbdbc
DW		 865 printf(" Family : %08x\n", __le32_to_cpu(mpb->family_num));
866 printf(" Generation : %08x\n", __le32_to_cpu(mpb->generation_num));
a5d85af7 867 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 868 fname_from_uuid(st, &info, nbuf, ':');
27fd6274 869 printf(" UUID : %s\n", nbuf + 5);
cdddbdbc
DW		 870 sum = __le32_to_cpu(mpb->check_sum);
871 printf(" Checksum : %08x %s\n", sum,
949c47a0 872 __gen_imsm_checksum(mpb) == sum ? "correct" : "incorrect");
87eb16df 873 printf(" MPB Sectors : %d\n", mpb_sectors(mpb));
cdddbdbc
DW		 874 printf(" Disks : %d\n", mpb->num_disks);
875 printf(" RAID Devices : %d\n", mpb->num_raid_devs);
14e8215b 876 print_imsm_disk(mpb, super->disks->index, reserved);
604b746f
JD		 877 if (super->bbm_log) {
878 struct bbm_log *log = super->bbm_log;
879
880 printf("\n");
881 printf("Bad Block Management Log:\n");
882 printf(" Log Size : %d\n", __le32_to_cpu(mpb->bbm_log_size));
883 printf(" Signature : %x\n", __le32_to_cpu(log->signature));
884 printf(" Entry Count : %d\n", __le32_to_cpu(log->entry_count));
885 printf(" Spare Blocks : %d\n", __le32_to_cpu(log->reserved_spare_block_count));
13a3b65d
N		 886 printf(" First Spare : %llx\n",
887 (unsigned long long) __le64_to_cpu(log->first_spare_lba));
604b746f 888 }
44470971
DW		 889 for (i = 0; i < mpb->num_raid_devs; i++) {
890 struct mdinfo info;
891 struct imsm_dev *dev = __get_imsm_dev(mpb, i);
892
893 super->current_vol = i;
a5d85af7 894 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 895 fname_from_uuid(st, &info, nbuf, ':');
44470971
DW		 896 print_imsm_dev(dev, nbuf + 5, super->disks->index);
897 }
cdddbdbc
DW		 898 for (i = 0; i < mpb->num_disks; i++) {
899 if (i == super->disks->index)
900 continue;
14e8215b 901 print_imsm_disk(mpb, i, reserved);
cdddbdbc 902 }
94827db3
N		 903 for (dl = super->disks ; dl; dl = dl->next) {
904 struct imsm_disk *disk;
905 char str[MAX_RAID_SERIAL_LEN + 1];
906 __u64 sz;
907
908 if (dl->index >= 0)
909 continue;
910
911 disk = &dl->disk;
912 printf("\n");
913 snprintf(str, MAX_RAID_SERIAL_LEN + 1, "%s", disk->serial);
914 printf(" Disk Serial : %s\n", str);
915 printf(" State :%s%s%s\n", is_spare(disk) ? " spare" : "",
916 is_configured(disk) ? " active" : "",
917 is_failed(disk) ? " failed" : "");
918 printf(" Id : %08x\n", __le32_to_cpu(disk->scsi_id));
919 sz = __le32_to_cpu(disk->total_blocks) - reserved;
920 printf(" Usable Size : %llu%s\n", (unsigned long long)sz,
921 human_size(sz * 512));
922 }
cdddbdbc
DW		 923}
924
061f2c6a 925static void brief_examine_super_imsm(struct supertype *st, int verbose)
cdddbdbc 926{
27fd6274 927 /* We just write a generic IMSM ARRAY entry */
ff54de6e
N		 928 struct mdinfo info;
929 char nbuf[64];
1e7bc0ed 930 struct intel_super *super = st->sb;
1e7bc0ed 931
0d5a423f
DW		 932 if (!super->anchor->num_raid_devs) {
933 printf("ARRAY metadata=imsm\n");
1e7bc0ed 934 return;
0d5a423f 935 }
ff54de6e 936
a5d85af7 937 getinfo_super_imsm(st, &info, NULL);
4737ae25
N		 938 fname_from_uuid(st, &info, nbuf, ':');
939 printf("ARRAY metadata=imsm UUID=%s\n", nbuf + 5);
940}
941
942static void brief_examine_subarrays_imsm(struct supertype *st, int verbose)
943{
944 /* We just write a generic IMSM ARRAY entry */
945 struct mdinfo info;
946 char nbuf[64];
947 char nbuf1[64];
948 struct intel_super *super = st->sb;
949 int i;
950
951 if (!super->anchor->num_raid_devs)
952 return;
953
a5d85af7 954 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 955 fname_from_uuid(st, &info, nbuf, ':');
1e7bc0ed
DW		 956 for (i = 0; i < super->anchor->num_raid_devs; i++) {
957 struct imsm_dev *dev = get_imsm_dev(super, i);
958
959 super->current_vol = i;
a5d85af7 960 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 961 fname_from_uuid(st, &info, nbuf1, ':');
1124b3cf 962 printf("ARRAY /dev/md/%.16s container=%s member=%d UUID=%s\n",
cf8de691 963 dev->volume, nbuf + 5, i, nbuf1 + 5);
1e7bc0ed 964 }
cdddbdbc
DW		 965}
966
9d84c8ea
DW		 967static void export_examine_super_imsm(struct supertype *st)
968{
969 struct intel_super *super = st->sb;
970 struct imsm_super *mpb = super->anchor;
971 struct mdinfo info;
972 char nbuf[64];
973
a5d85af7 974 getinfo_super_imsm(st, &info, NULL);
9d84c8ea
DW		 975 fname_from_uuid(st, &info, nbuf, ':');
976 printf("MD_METADATA=imsm\n");
977 printf("MD_LEVEL=container\n");
978 printf("MD_UUID=%s\n", nbuf+5);
979 printf("MD_DEVICES=%u\n", mpb->num_disks);
980}
981
cdddbdbc
DW		 982static void detail_super_imsm(struct supertype *st, char *homehost)
983{
3ebe00a1
DW		 984 struct mdinfo info;
985 char nbuf[64];
986
a5d85af7 987 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 988 fname_from_uuid(st, &info, nbuf, ':');
3ebe00a1 989 printf("\n UUID : %s\n", nbuf + 5);
cdddbdbc
DW		 990}
991
992static void brief_detail_super_imsm(struct supertype *st)
993{
ff54de6e
N		 994 struct mdinfo info;
995 char nbuf[64];
a5d85af7 996 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 997 fname_from_uuid(st, &info, nbuf, ':');
ff54de6e 998 printf(" UUID=%s", nbuf + 5);
cdddbdbc 999}
d665cc31
DW		 1000
1001static int imsm_read_serial(int fd, char *devname, __u8 *serial);
1002static void fd2devname(int fd, char *name);
1003
1004static int imsm_enumerate_ports(const char *hba_path, int port_count, int host_base, int verbose)
1005{
1006 /* dump an unsorted list of devices attached to ahci, as well as
1007 * non-connected ports
1008 */
1009 int hba_len = strlen(hba_path) + 1;
1010 struct dirent *ent;
1011 DIR *dir;
1012 char *path = NULL;
1013 int err = 0;
1014 unsigned long port_mask = (1 << port_count) - 1;
1015
f21e18ca 1016 if (port_count > (int)sizeof(port_mask) * 8) {
d665cc31
DW		 1017 if (verbose)
1018 fprintf(stderr, Name ": port_count %d out of range\n", port_count);
1019 return 2;
1020 }
1021
1022 /* scroll through /sys/dev/block looking for devices attached to
1023 * this hba
1024 */
1025 dir = opendir("/sys/dev/block");
1026 for (ent = dir ? readdir(dir) : NULL; ent; ent = readdir(dir)) {
1027 int fd;
1028 char model[64];
1029 char vendor[64];
1030 char buf[1024];
1031 int major, minor;
1032 char *device;
1033 char *c;
1034 int port;
1035 int type;
1036
1037 if (sscanf(ent->d_name, "%d:%d", &major, &minor) != 2)
1038 continue;
1039 path = devt_to_devpath(makedev(major, minor));
1040 if (!path)
1041 continue;
1042 if (!path_attached_to_hba(path, hba_path)) {
1043 free(path);
1044 path = NULL;
1045 continue;
1046 }
1047
1048 /* retrieve the scsi device type */
1049 if (asprintf(&device, "/sys/dev/block/%d:%d/device/xxxxxxx", major, minor) < 0) {
1050 if (verbose)
1051 fprintf(stderr, Name ": failed to allocate 'device'\n");
1052 err = 2;
1053 break;
1054 }
1055 sprintf(device, "/sys/dev/block/%d:%d/device/type", major, minor);
1056 if (load_sys(device, buf) != 0) {
1057 if (verbose)
1058 fprintf(stderr, Name ": failed to read device type for %s\n",
1059 path);
1060 err = 2;
1061 free(device);
1062 break;
1063 }
1064 type = strtoul(buf, NULL, 10);
1065
1066 /* if it's not a disk print the vendor and model */
1067 if (!(type == 0 || type == 7 || type == 14)) {
1068 vendor[0] = '\0';
1069 model[0] = '\0';
1070 sprintf(device, "/sys/dev/block/%d:%d/device/vendor", major, minor);
1071 if (load_sys(device, buf) == 0) {
1072 strncpy(vendor, buf, sizeof(vendor));
1073 vendor[sizeof(vendor) - 1] = '\0';
1074 c = (char *) &vendor[sizeof(vendor) - 1];
1075 while (isspace(*c) || *c == '\0')
1076 *c-- = '\0';
1077
1078 }
1079 sprintf(device, "/sys/dev/block/%d:%d/device/model", major, minor);
1080 if (load_sys(device, buf) == 0) {
1081 strncpy(model, buf, sizeof(model));
1082 model[sizeof(model) - 1] = '\0';
1083 c = (char *) &model[sizeof(model) - 1];
1084 while (isspace(*c) || *c == '\0')
1085 *c-- = '\0';
1086 }
1087
1088 if (vendor[0] && model[0])
1089 sprintf(buf, "%.64s %.64s", vendor, model);
1090 else
1091 switch (type) { /* numbers from hald/linux/device.c */
1092 case 1: sprintf(buf, "tape"); break;
1093 case 2: sprintf(buf, "printer"); break;
1094 case 3: sprintf(buf, "processor"); break;
1095 case 4:
1096 case 5: sprintf(buf, "cdrom"); break;
1097 case 6: sprintf(buf, "scanner"); break;
1098 case 8: sprintf(buf, "media_changer"); break;
1099 case 9: sprintf(buf, "comm"); break;
1100 case 12: sprintf(buf, "raid"); break;
1101 default: sprintf(buf, "unknown");
1102 }
1103 } else
1104 buf[0] = '\0';
1105 free(device);
1106
1107 /* chop device path to 'host%d' and calculate the port number */
1108 c = strchr(&path[hba_len], '/');
4e5e717d
AW		 1109 if (!c) {
1110 if (verbose)
1111 fprintf(stderr, Name ": %s - invalid path name\n", path + hba_len);
1112 err = 2;
1113 break;
1114 }
d665cc31
DW		 1115 *c = '\0';
1116 if (sscanf(&path[hba_len], "host%d", &port) == 1)
1117 port -= host_base;
1118 else {
1119 if (verbose) {
1120 *c = '/'; /* repair the full string */
1121 fprintf(stderr, Name ": failed to determine port number for %s\n",
1122 path);
1123 }
1124 err = 2;
1125 break;
1126 }
1127
1128 /* mark this port as used */
1129 port_mask &= ~(1 << port);
1130
1131 /* print out the device information */
1132 if (buf[0]) {
1133 printf(" Port%d : - non-disk device (%s) -\n", port, buf);
1134 continue;
1135 }
1136
1137 fd = dev_open(ent->d_name, O_RDONLY);
1138 if (fd < 0)
1139 printf(" Port%d : - disk info unavailable -\n", port);
1140 else {
1141 fd2devname(fd, buf);
1142 printf(" Port%d : %s", port, buf);
1143 if (imsm_read_serial(fd, NULL, (__u8 *) buf) == 0)
1144 printf(" (%s)\n", buf);
1145 else
1146 printf("()\n");
1147 }
1148 close(fd);
1149 free(path);
1150 path = NULL;
1151 }
1152 if (path)
1153 free(path);
1154 if (dir)
1155 closedir(dir);
1156 if (err == 0) {
1157 int i;
1158
1159 for (i = 0; i < port_count; i++)
1160 if (port_mask & (1 << i))
1161 printf(" Port%d : - no device attached -\n", i);
1162 }
1163
1164 return err;
1165}
1166
5615172f 1167static int detail_platform_imsm(int verbose, int enumerate_only)
d665cc31
DW		 1168{
1169 /* There are two components to imsm platform support, the ahci SATA
1170 * controller and the option-rom. To find the SATA controller we
1171 * simply look in /sys/bus/pci/drivers/ahci to see if an ahci
1172 * controller with the Intel vendor id is present. This approach
1173 * allows mdadm to leverage the kernel's ahci detection logic, with the
1174 * caveat that if ahci.ko is not loaded mdadm will not be able to
1175 * detect platform raid capabilities. The option-rom resides in a
1176 * platform "Adapter ROM". We scan for its signature to retrieve the
1177 * platform capabilities. If raid support is disabled in the BIOS the
1178 * option-rom capability structure will not be available.
1179 */
1180 const struct imsm_orom *orom;
1181 struct sys_dev *list, *hba;
1182 DIR *dir;
1183 struct dirent *ent;
1184 const char *hba_path;
1185 int host_base = 0;
1186 int port_count = 0;
1187
5615172f
DW		 1188 if (enumerate_only) {
1189 if (check_env("IMSM_NO_PLATFORM") || find_imsm_orom())
1190 return 0;
1191 return 2;
1192 }
1193
d665cc31
DW		 1194 list = find_driver_devices("pci", "ahci");
1195 for (hba = list; hba; hba = hba->next)
1196 if (devpath_to_vendor(hba->path) == 0x8086)
1197 break;
1198
1199 if (!hba) {
1200 if (verbose)
1201 fprintf(stderr, Name ": unable to find active ahci controller\n");
1202 free_sys_dev(&list);
1203 return 2;
1204 } else if (verbose)
1205 fprintf(stderr, Name ": found Intel SATA AHCI Controller\n");
1206 hba_path = hba->path;
1207 hba->path = NULL;
1208 free_sys_dev(&list);
1209
1210 orom = find_imsm_orom();
1211 if (!orom) {
1212 if (verbose)
1213 fprintf(stderr, Name ": imsm option-rom not found\n");
1214 return 2;
1215 }
1216
1217 printf(" Platform : Intel(R) Matrix Storage Manager\n");
1218 printf(" Version : %d.%d.%d.%d\n", orom->major_ver, orom->minor_ver,
1219 orom->hotfix_ver, orom->build);
1220 printf(" RAID Levels :%s%s%s%s%s\n",
1221 imsm_orom_has_raid0(orom) ? " raid0" : "",
1222 imsm_orom_has_raid1(orom) ? " raid1" : "",
1223 imsm_orom_has_raid1e(orom) ? " raid1e" : "",
1224 imsm_orom_has_raid10(orom) ? " raid10" : "",
1225 imsm_orom_has_raid5(orom) ? " raid5" : "");
8be094f0
DW		 1226 printf(" Chunk Sizes :%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
1227 imsm_orom_has_chunk(orom, 2) ? " 2k" : "",
1228 imsm_orom_has_chunk(orom, 4) ? " 4k" : "",
1229 imsm_orom_has_chunk(orom, 8) ? " 8k" : "",
1230 imsm_orom_has_chunk(orom, 16) ? " 16k" : "",
1231 imsm_orom_has_chunk(orom, 32) ? " 32k" : "",
1232 imsm_orom_has_chunk(orom, 64) ? " 64k" : "",
1233 imsm_orom_has_chunk(orom, 128) ? " 128k" : "",
1234 imsm_orom_has_chunk(orom, 256) ? " 256k" : "",
1235 imsm_orom_has_chunk(orom, 512) ? " 512k" : "",
1236 imsm_orom_has_chunk(orom, 1024*1) ? " 1M" : "",
1237 imsm_orom_has_chunk(orom, 1024*2) ? " 2M" : "",
1238 imsm_orom_has_chunk(orom, 1024*4) ? " 4M" : "",
1239 imsm_orom_has_chunk(orom, 1024*8) ? " 8M" : "",
1240 imsm_orom_has_chunk(orom, 1024*16) ? " 16M" : "",
1241 imsm_orom_has_chunk(orom, 1024*32) ? " 32M" : "",
1242 imsm_orom_has_chunk(orom, 1024*64) ? " 64M" : "");
d665cc31
DW		 1243 printf(" Max Disks : %d\n", orom->tds);
1244 printf(" Max Volumes : %d\n", orom->vpa);
1245 printf(" I/O Controller : %s\n", hba_path);
1246
1247 /* find the smallest scsi host number to determine a port number base */
1248 dir = opendir(hba_path);
1249 for (ent = dir ? readdir(dir) : NULL; ent; ent = readdir(dir)) {
1250 int host;
1251
1252 if (sscanf(ent->d_name, "host%d", &host) != 1)
1253 continue;
1254 if (port_count == 0)
1255 host_base = host;
1256 else if (host < host_base)
1257 host_base = host;
1258
1259 if (host + 1 > port_count + host_base)
1260 port_count = host + 1 - host_base;
1261
1262 }
1263 if (dir)
1264 closedir(dir);
1265
1266 if (!port_count || imsm_enumerate_ports(hba_path, port_count,
1267 host_base, verbose) != 0) {
1268 if (verbose)
1269 fprintf(stderr, Name ": failed to enumerate ports\n");
1270 return 2;
1271 }
1272
1273 return 0;
1274}
cdddbdbc
DW		 1275#endif
1276
1277static int match_home_imsm(struct supertype *st, char *homehost)
1278{
5115ca67
DW		 1279 /* the imsm metadata format does not specify any host
1280 * identification information. We return -1 since we can never
1281 * confirm nor deny whether a given array is "meant" for this
148acb7b 1282 * host. We rely on compare_super and the 'family_num' fields to
5115ca67
DW		 1283 * exclude member disks that do not belong, and we rely on
1284 * mdadm.conf to specify the arrays that should be assembled.
1285 * Auto-assembly may still pick up "foreign" arrays.
1286 */
cdddbdbc 1287
9362c1c8 1288 return -1;
cdddbdbc
DW		 1289}
1290
1291static void uuid_from_super_imsm(struct supertype *st, int uuid[4])
1292{
51006d85
N		 1293 /* The uuid returned here is used for:
1294 * uuid to put into bitmap file (Create, Grow)
1295 * uuid for backup header when saving critical section (Grow)
1296 * comparing uuids when re-adding a device into an array
1297 * In these cases the uuid required is that of the data-array,
1298 * not the device-set.
1299 * uuid to recognise same set when adding a missing device back
1300 * to an array. This is a uuid for the device-set.
1301 *
1302 * For each of these we can make do with a truncated
1303 * or hashed uuid rather than the original, as long as
1304 * everyone agrees.
1305 * In each case the uuid required is that of the data-array,
1306 * not the device-set.
43dad3d6 1307 */
51006d85
N		 1308 /* imsm does not track uuid's so we synthesis one using sha1 on
1309 * - The signature (Which is constant for all imsm array, but no matter)
148acb7b 1310 * - the orig_family_num of the container
51006d85
N		 1311 * - the index number of the volume
1312 * - the 'serial' number of the volume.
1313 * Hopefully these are all constant.
1314 */
1315 struct intel_super *super = st->sb;
43dad3d6 1316
51006d85
N		 1317 char buf[20];
1318 struct sha1_ctx ctx;
1319 struct imsm_dev *dev = NULL;
148acb7b 1320 __u32 family_num;
51006d85 1321
148acb7b
DW		 1322 /* some mdadm versions failed to set ->orig_family_num, in which
1323 * case fall back to ->family_num. orig_family_num will be
1324 * fixed up with the first metadata update.
1325 */
1326 family_num = super->anchor->orig_family_num;
1327 if (family_num == 0)
1328 family_num = super->anchor->family_num;
51006d85 1329 sha1_init_ctx(&ctx);
92bd8f8d 1330 sha1_process_bytes(super->anchor->sig, MPB_SIG_LEN, &ctx);
148acb7b 1331 sha1_process_bytes(&family_num, sizeof(__u32), &ctx);
51006d85
N		 1332 if (super->current_vol >= 0)
1333 dev = get_imsm_dev(super, super->current_vol);
1334 if (dev) {
1335 __u32 vol = super->current_vol;
1336 sha1_process_bytes(&vol, sizeof(vol), &ctx);
1337 sha1_process_bytes(dev->volume, MAX_RAID_SERIAL_LEN, &ctx);
1338 }
1339 sha1_finish_ctx(&ctx, buf);
1340 memcpy(uuid, buf, 4*4);
cdddbdbc
DW		 1341}
1342
0d481d37 1343#if 0
4f5bc454
DW		 1344static void
1345get_imsm_numerical_version(struct imsm_super *mpb, int *m, int *p)
cdddbdbc 1346{
cdddbdbc
DW		 1347 __u8 *v = get_imsm_version(mpb);
1348 __u8 *end = mpb->sig + MAX_SIGNATURE_LENGTH;
1349 char major[] = { 0, 0, 0 };
1350 char minor[] = { 0 ,0, 0 };
1351 char patch[] = { 0, 0, 0 };
1352 char *ver_parse[] = { major, minor, patch };
1353 int i, j;
1354
1355 i = j = 0;
1356 while (*v != '\0' && v < end) {
1357 if (*v != '.' && j < 2)
1358 ver_parse[i][j++] = *v;
1359 else {
1360 i++;
1361 j = 0;
1362 }
1363 v++;
1364 }
1365
4f5bc454
DW		 1366 *m = strtol(minor, NULL, 0);
1367 *p = strtol(patch, NULL, 0);
1368}
0d481d37 1369#endif
4f5bc454 1370
1e5c6983
DW		 1371static __u32 migr_strip_blocks_resync(struct imsm_dev *dev)
1372{
1373 /* migr_strip_size when repairing or initializing parity */
1374 struct imsm_map *map = get_imsm_map(dev, 0);
1375 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
1376
1377 switch (get_imsm_raid_level(map)) {
1378 case 5:
1379 case 10:
1380 return chunk;
1381 default:
1382 return 128*1024 >> 9;
1383 }
1384}
1385
1386static __u32 migr_strip_blocks_rebuild(struct imsm_dev *dev)
1387{
1388 /* migr_strip_size when rebuilding a degraded disk, no idea why
1389 * this is different than migr_strip_size_resync(), but it's good
1390 * to be compatible
1391 */
1392 struct imsm_map *map = get_imsm_map(dev, 1);
1393 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
1394
1395 switch (get_imsm_raid_level(map)) {
1396 case 1:
1397 case 10:
1398 if (map->num_members % map->num_domains == 0)
1399 return 128*1024 >> 9;
1400 else
1401 return chunk;
1402 case 5:
1403 return max((__u32) 64*1024 >> 9, chunk);
1404 default:
1405 return 128*1024 >> 9;
1406 }
1407}
1408
1409static __u32 num_stripes_per_unit_resync(struct imsm_dev *dev)
1410{
1411 struct imsm_map *lo = get_imsm_map(dev, 0);
1412 struct imsm_map *hi = get_imsm_map(dev, 1);
1413 __u32 lo_chunk = __le32_to_cpu(lo->blocks_per_strip);
1414 __u32 hi_chunk = __le32_to_cpu(hi->blocks_per_strip);
1415
1416 return max((__u32) 1, hi_chunk / lo_chunk);
1417}
1418
1419static __u32 num_stripes_per_unit_rebuild(struct imsm_dev *dev)
1420{
1421 struct imsm_map *lo = get_imsm_map(dev, 0);
1422 int level = get_imsm_raid_level(lo);
1423
1424 if (level == 1 || level == 10) {
1425 struct imsm_map *hi = get_imsm_map(dev, 1);
1426
1427 return hi->num_domains;
1428 } else
1429 return num_stripes_per_unit_resync(dev);
1430}
1431
98130f40 1432static __u8 imsm_num_data_members(struct imsm_dev *dev, int second_map)
1e5c6983
DW		 1433{
1434 /* named 'imsm_' because raid0, raid1 and raid10
1435 * counter-intuitively have the same number of data disks
1436 */
98130f40 1437 struct imsm_map *map = get_imsm_map(dev, second_map);
1e5c6983
DW		 1438
1439 switch (get_imsm_raid_level(map)) {
1440 case 0:
1441 case 1:
1442 case 10:
1443 return map->num_members;
1444 case 5:
1445 return map->num_members - 1;
1446 default:
1447 dprintf("%s: unsupported raid level\n", __func__);
1448 return 0;
1449 }
1450}
1451
1452static __u32 parity_segment_depth(struct imsm_dev *dev)
1453{
1454 struct imsm_map *map = get_imsm_map(dev, 0);
1455 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
1456
1457 switch(get_imsm_raid_level(map)) {
1458 case 1:
1459 case 10:
1460 return chunk * map->num_domains;
1461 case 5:
1462 return chunk * map->num_members;
1463 default:
1464 return chunk;
1465 }
1466}
1467
1468static __u32 map_migr_block(struct imsm_dev *dev, __u32 block)
1469{
1470 struct imsm_map *map = get_imsm_map(dev, 1);
1471 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
1472 __u32 strip = block / chunk;
1473
1474 switch (get_imsm_raid_level(map)) {
1475 case 1:
1476 case 10: {
1477 __u32 vol_strip = (strip * map->num_domains) + 1;
1478 __u32 vol_stripe = vol_strip / map->num_members;
1479
1480 return vol_stripe * chunk + block % chunk;
1481 } case 5: {
1482 __u32 stripe = strip / (map->num_members - 1);
1483
1484 return stripe * chunk + block % chunk;
1485 }
1486 default:
1487 return 0;
1488 }
1489}
1490
1491static __u64 blocks_per_migr_unit(struct imsm_dev *dev)
1492{
1493 /* calculate the conversion factor between per member 'blocks'
1494 * (md/{resync,rebuild}_start) and imsm migration units, return
1495 * 0 for the 'not migrating' and 'unsupported migration' cases
1496 */
1497 if (!dev->vol.migr_state)
1498 return 0;
1499
1500 switch (migr_type(dev)) {
1501 case MIGR_VERIFY:
1502 case MIGR_REPAIR:
1503 case MIGR_INIT: {
1504 struct imsm_map *map = get_imsm_map(dev, 0);
1505 __u32 stripes_per_unit;
1506 __u32 blocks_per_unit;
1507 __u32 parity_depth;
1508 __u32 migr_chunk;
1509 __u32 block_map;
1510 __u32 block_rel;
1511 __u32 segment;
1512 __u32 stripe;
1513 __u8 disks;
1514
1515 /* yes, this is really the translation of migr_units to
1516 * per-member blocks in the 'resync' case
1517 */
1518 stripes_per_unit = num_stripes_per_unit_resync(dev);
1519 migr_chunk = migr_strip_blocks_resync(dev);
98130f40 1520 disks = imsm_num_data_members(dev, 0);
1e5c6983
DW		 1521 blocks_per_unit = stripes_per_unit * migr_chunk * disks;
1522 stripe = __le32_to_cpu(map->blocks_per_strip) * disks;
1523 segment = blocks_per_unit / stripe;
1524 block_rel = blocks_per_unit - segment * stripe;
1525 parity_depth = parity_segment_depth(dev);
1526 block_map = map_migr_block(dev, block_rel);
1527 return block_map + parity_depth * segment;
1528 }
1529 case MIGR_REBUILD: {
1530 __u32 stripes_per_unit;
1531 __u32 migr_chunk;
1532
1533 stripes_per_unit = num_stripes_per_unit_rebuild(dev);
1534 migr_chunk = migr_strip_blocks_rebuild(dev);
1535 return migr_chunk * stripes_per_unit;
1536 }
1537 case MIGR_GEN_MIGR:
aad6f216 1538 /* FIXME I need a number here */
1e5c6983
DW		 1539 case MIGR_STATE_CHANGE:
1540 default:
1541 return 0;
1542 }
1543}
1544
c2c087e6
DW		 1545static int imsm_level_to_layout(int level)
1546{
1547 switch (level) {
1548 case 0:
1549 case 1:
1550 return 0;
1551 case 5:
1552 case 6:
a380c027 1553 return ALGORITHM_LEFT_ASYMMETRIC;
c2c087e6 1554 case 10:
c92a2527 1555 return 0x102;
c2c087e6 1556 }
a18a888e 1557 return UnSet;
c2c087e6
DW		 1558}
1559
a5d85af7 1560static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info, char *dmap)
bf5a934a
DW		 1561{
1562 struct intel_super *super = st->sb;
949c47a0 1563 struct imsm_dev *dev = get_imsm_dev(super, super->current_vol);
a965f303 1564 struct imsm_map *map = get_imsm_map(dev, 0);
81ac8b4d 1565 struct imsm_map *prev_map = get_imsm_map(dev, 1);
efb30e7f 1566 struct dl *dl;
e207da2f 1567 char *devname;
a5d85af7 1568 int map_disks = info->array.raid_disks;
bf5a934a 1569
efb30e7f
DW		 1570 for (dl = super->disks; dl; dl = dl->next)
1571 if (dl->raiddisk == info->disk.raid_disk)
1572 break;
bf5a934a
DW		 1573 info->container_member = super->current_vol;
1574 info->array.raid_disks = map->num_members;
1575 info->array.level = get_imsm_raid_level(map);
1576 info->array.layout = imsm_level_to_layout(info->array.level);
1577 info->array.md_minor = -1;
1578 info->array.ctime = 0;
1579 info->array.utime = 0;
301406c9
DW		 1580 info->array.chunk_size = __le16_to_cpu(map->blocks_per_strip) << 9;
1581 info->array.state = !dev->vol.dirty;
da9b4a62
DW		 1582 info->custom_array_size = __le32_to_cpu(dev->size_high);
1583 info->custom_array_size <<= 32;
1584 info->custom_array_size |= __le32_to_cpu(dev->size_low);
301406c9
DW		 1585
1586 info->disk.major = 0;
1587 info->disk.minor = 0;
efb30e7f
DW		 1588 if (dl) {
1589 info->disk.major = dl->major;
1590 info->disk.minor = dl->minor;
1591 }
bf5a934a
DW		 1592
1593 info->data_offset = __le32_to_cpu(map->pba_of_lba0);
1594 info->component_size = __le32_to_cpu(map->blocks_per_member);
301406c9 1595 memset(info->uuid, 0, sizeof(info->uuid));
921d9e16 1596 info->recovery_start = MaxSector;
81ac8b4d
AK		 1597 info->reshape_active = (prev_map != NULL);
1598 if (info->reshape_active)
1599 info->delta_disks = map->num_members - prev_map->num_members;
1600 else
1601 info->delta_disks = 0;
bf5a934a 1602
1e5c6983 1603 if (map->map_state == IMSM_T_STATE_UNINITIALIZED || dev->vol.dirty) {
301406c9 1604 info->resync_start = 0;
1e5c6983
DW		 1605 } else if (dev->vol.migr_state) {
1606 switch (migr_type(dev)) {
1607 case MIGR_REPAIR:
1608 case MIGR_INIT: {
1609 __u64 blocks_per_unit = blocks_per_migr_unit(dev);
1610 __u64 units = __le32_to_cpu(dev->vol.curr_migr_unit);
1611
1612 info->resync_start = blocks_per_unit * units;
1613 break;
1614 }
1615 case MIGR_VERIFY:
1616 /* we could emulate the checkpointing of
1617 * 'sync_action=check' migrations, but for now
1618 * we just immediately complete them
1619 */
1620 case MIGR_REBUILD:
1621 /* this is handled by container_content_imsm() */
1622 case MIGR_GEN_MIGR:
1623 case MIGR_STATE_CHANGE:
1624 /* FIXME handle other migrations */
1625 default:
1626 /* we are not dirty, so... */
1627 info->resync_start = MaxSector;
1628 }
1629 } else
b7528a20 1630 info->resync_start = MaxSector;
301406c9
DW		 1631
1632 strncpy(info->name, (char *) dev->volume, MAX_RAID_SERIAL_LEN);
1633 info->name[MAX_RAID_SERIAL_LEN] = 0;
bf5a934a 1634
f35f2525
N		 1635 info->array.major_version = -1;
1636 info->array.minor_version = -2;
e207da2f
AW		 1637 devname = devnum2devname(st->container_dev);
1638 *info->text_version = '\0';
1639 if (devname)
1640 sprintf(info->text_version, "/%s/%d", devname, info->container_member);
1641 free(devname);
a67dd8cc 1642 info->safe_mode_delay = 4000; /* 4 secs like the Matrix driver */
51006d85 1643 uuid_from_super_imsm(st, info->uuid);
a5d85af7
N		 1644
1645 if (dmap) {
1646 int i, j;
1647 for (i=0; i<map_disks; i++) {
1648 dmap[i] = 0;
1649 if (i < info->array.raid_disks) {
1650 struct imsm_disk *dsk;
98130f40 1651 j = get_imsm_disk_idx(dev, i, -1);
a5d85af7
N		 1652 dsk = get_imsm_disk(super, j);
1653 if (dsk && (dsk->status & CONFIGURED_DISK))
1654 dmap[i] = 1;
1655 }
1656 }
1657 }
81ac8b4d 1658}
bf5a934a 1659
97b4d0e9
DW		 1660static __u8 imsm_check_degraded(struct intel_super *super, struct imsm_dev *dev, int failed);
1661static int imsm_count_failed(struct intel_super *super, struct imsm_dev *dev);
1662
1663static struct imsm_disk *get_imsm_missing(struct intel_super *super, __u8 index)
1664{
1665 struct dl *d;
1666
1667 for (d = super->missing; d; d = d->next)
1668 if (d->index == index)
1669 return &d->disk;
1670 return NULL;
1671}
1672
a5d85af7 1673static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info, char *map)
4f5bc454
DW		 1674{
1675 struct intel_super *super = st->sb;
4f5bc454 1676 struct imsm_disk *disk;
a5d85af7 1677 int map_disks = info->array.raid_disks;
ab3cb6b3
N		 1678 int max_enough = -1;
1679 int i;
1680 struct imsm_super *mpb;
4f5bc454 1681
bf5a934a 1682 if (super->current_vol >= 0) {
a5d85af7 1683 getinfo_super_imsm_volume(st, info, map);
bf5a934a
DW		 1684 return;
1685 }
d23fe947
DW		 1686
1687 /* Set raid_disks to zero so that Assemble will always pull in valid
1688 * spares
1689 */
1690 info->array.raid_disks = 0;
cdddbdbc
DW		 1691 info->array.level = LEVEL_CONTAINER;
1692 info->array.layout = 0;
1693 info->array.md_minor = -1;
c2c087e6 1694 info->array.ctime = 0; /* N/A for imsm */
cdddbdbc
DW		 1695 info->array.utime = 0;
1696 info->array.chunk_size = 0;
1697
1698 info->disk.major = 0;
1699 info->disk.minor = 0;
cdddbdbc 1700 info->disk.raid_disk = -1;
c2c087e6 1701 info->reshape_active = 0;
f35f2525
N		 1702 info->array.major_version = -1;
1703 info->array.minor_version = -2;
c2c087e6 1704 strcpy(info->text_version, "imsm");
a67dd8cc 1705 info->safe_mode_delay = 0;
c2c087e6
DW		 1706 info->disk.number = -1;
1707 info->disk.state = 0;
c5afc314 1708 info->name[0] = 0;
921d9e16 1709 info->recovery_start = MaxSector;
c2c087e6 1710
97b4d0e9 1711 /* do we have the all the insync disks that we expect? */
ab3cb6b3 1712 mpb = super->anchor;
97b4d0e9 1713
ab3cb6b3
N		 1714 for (i = 0; i < mpb->num_raid_devs; i++) {
1715 struct imsm_dev *dev = get_imsm_dev(super, i);
1716 int failed, enough, j, missing = 0;
1717 struct imsm_map *map;
1718 __u8 state;
97b4d0e9 1719
ab3cb6b3
N		 1720 failed = imsm_count_failed(super, dev);
1721 state = imsm_check_degraded(super, dev, failed);
1722 map = get_imsm_map(dev, dev->vol.migr_state);
1723
1724 /* any newly missing disks?
1725 * (catches single-degraded vs double-degraded)
1726 */
1727 for (j = 0; j < map->num_members; j++) {
98130f40 1728 __u32 ord = get_imsm_ord_tbl_ent(dev, i, -1);
ab3cb6b3
N		 1729 __u32 idx = ord_to_idx(ord);
1730
1731 if (!(ord & IMSM_ORD_REBUILD) &&
1732 get_imsm_missing(super, idx)) {
1733 missing = 1;
1734 break;
1735 }
97b4d0e9 1736 }
ab3cb6b3
N		 1737
1738 if (state == IMSM_T_STATE_FAILED)
1739 enough = -1;
1740 else if (state == IMSM_T_STATE_DEGRADED &&
1741 (state != map->map_state || missing))
1742 enough = 0;
1743 else /* we're normal, or already degraded */
1744 enough = 1;
1745
1746 /* in the missing/failed disk case check to see
1747 * if at least one array is runnable
1748 */
1749 max_enough = max(max_enough, enough);
1750 }
1751 dprintf("%s: enough: %d\n", __func__, max_enough);
1752 info->container_enough = max_enough;
97b4d0e9 1753
4a04ec6c 1754 if (super->disks) {
14e8215b
DW		 1755 __u32 reserved = imsm_reserved_sectors(super, super->disks);
1756
b9f594fe 1757 disk = &super->disks->disk;
14e8215b
DW		 1758 info->data_offset = __le32_to_cpu(disk->total_blocks) - reserved;
1759 info->component_size = reserved;
25ed7e59 1760 info->disk.state = is_configured(disk) ? (1 << MD_DISK_ACTIVE) : 0;
df474657
DW		 1761 /* we don't change info->disk.raid_disk here because
1762 * this state will be finalized in mdmon after we have
1763 * found the 'most fresh' version of the metadata
1764 */
25ed7e59
DW		 1765 info->disk.state |= is_failed(disk) ? (1 << MD_DISK_FAULTY) : 0;
1766 info->disk.state |= is_spare(disk) ? 0 : (1 << MD_DISK_SYNC);
cdddbdbc 1767 }
a575e2a7
DW		 1768
1769 /* only call uuid_from_super_imsm when this disk is part of a populated container,
1770 * ->compare_super may have updated the 'num_raid_devs' field for spares
1771 */
1772 if (info->disk.state & (1 << MD_DISK_SYNC) || super->anchor->num_raid_devs)
36ba7d48 1773 uuid_from_super_imsm(st, info->uuid);
22e263f6
AC		 1774 else
1775 memcpy(info->uuid, uuid_zero, sizeof(uuid_zero));
a5d85af7
N		 1776
1777 /* I don't know how to compute 'map' on imsm, so use safe default */
1778 if (map) {
1779 int i;
1780 for (i = 0; i < map_disks; i++)
1781 map[i] = 1;
1782 }
1783
cdddbdbc
DW		 1784}
1785
5c4cd5da
AC		 1786/* allocates memory and fills disk in mdinfo structure
1787 * for each disk in array */
1788struct mdinfo *getinfo_super_disks_imsm(struct supertype *st)
1789{
1790 struct mdinfo *mddev = NULL;
1791 struct intel_super *super = st->sb;
1792 struct imsm_disk *disk;
1793 int count = 0;
1794 struct dl *dl;
1795 if (!super || !super->disks)
1796 return NULL;
1797 dl = super->disks;
1798 mddev = malloc(sizeof(*mddev));
1799 if (!mddev) {
1800 fprintf(stderr, Name ": Failed to allocate memory.\n");
1801 return NULL;
1802 }
1803 memset(mddev, 0, sizeof(*mddev));
1804 while (dl) {
1805 struct mdinfo *tmp;
1806 disk = &dl->disk;
1807 tmp = malloc(sizeof(*tmp));
1808 if (!tmp) {
1809 fprintf(stderr, Name ": Failed to allocate memory.\n");
1810 if (mddev)
1811 sysfs_free(mddev);
1812 return NULL;
1813 }
1814 memset(tmp, 0, sizeof(*tmp));
1815 if (mddev->devs)
1816 tmp->next = mddev->devs;
1817 mddev->devs = tmp;
1818 tmp->disk.number = count++;
1819 tmp->disk.major = dl->major;
1820 tmp->disk.minor = dl->minor;
1821 tmp->disk.state = is_configured(disk) ?
1822 (1 << MD_DISK_ACTIVE) : 0;
1823 tmp->disk.state |= is_failed(disk) ? (1 << MD_DISK_FAULTY) : 0;
1824 tmp->disk.state |= is_spare(disk) ? 0 : (1 << MD_DISK_SYNC);
1825 tmp->disk.raid_disk = -1;
1826 dl = dl->next;
1827 }
1828 return mddev;
1829}
1830
cdddbdbc
DW		 1831static int update_super_imsm(struct supertype *st, struct mdinfo *info,
1832 char *update, char *devname, int verbose,
1833 int uuid_set, char *homehost)
1834{
f352c545
DW		 1835 /* For 'assemble' and 'force' we need to return non-zero if any
1836 * change was made. For others, the return value is ignored.
1837 * Update options are:
1838 * force-one : This device looks a bit old but needs to be included,
1839 * update age info appropriately.
1840 * assemble: clear any 'faulty' flag to allow this device to
1841 * be assembled.
1842 * force-array: Array is degraded but being forced, mark it clean
1843 * if that will be needed to assemble it.
1844 *
1845 * newdev: not used ????
1846 * grow: Array has gained a new device - this is currently for
1847 * linear only
1848 * resync: mark as dirty so a resync will happen.
1849 * name: update the name - preserving the homehost
6e46bf34 1850 * uuid: Change the uuid of the array to match watch is given
f352c545
DW		 1851 *
1852 * Following are not relevant for this imsm:
1853 * sparc2.2 : update from old dodgey metadata
1854 * super-minor: change the preferred_minor number
1855 * summaries: update redundant counters.
f352c545
DW		 1856 * homehost: update the recorded homehost
1857 * _reshape_progress: record new reshape_progress position.
1858 */
6e46bf34
DW		 1859 int rv = 1;
1860 struct intel_super *super = st->sb;
1861 struct imsm_super *mpb;
f352c545 1862
6e46bf34
DW		 1863 /* we can only update container info */
1864 if (!super || super->current_vol >= 0 || !super->anchor)
1865 return 1;
1866
1867 mpb = super->anchor;
1868
1869 if (strcmp(update, "uuid") == 0 && uuid_set && !info->update_private)
1e2b2765 1870 rv = -1;
6e46bf34
DW		 1871 else if (strcmp(update, "uuid") == 0 && uuid_set && info->update_private) {
1872 mpb->orig_family_num = *((__u32 *) info->update_private);
1873 rv = 0;
1874 } else if (strcmp(update, "uuid") == 0) {
1875 __u32 *new_family = malloc(sizeof(*new_family));
1876
1877 /* update orig_family_number with the incoming random
1878 * data, report the new effective uuid, and store the
1879 * new orig_family_num for future updates.
1880 */
1881 if (new_family) {
1882 memcpy(&mpb->orig_family_num, info->uuid, sizeof(__u32));
1883 uuid_from_super_imsm(st, info->uuid);
1884 *new_family = mpb->orig_family_num;
1885 info->update_private = new_family;
1886 rv = 0;
1887 }
1888 } else if (strcmp(update, "assemble") == 0)
1889 rv = 0;
1890 else
1e2b2765 1891 rv = -1;
f352c545 1892
6e46bf34
DW		 1893 /* successful update? recompute checksum */
1894 if (rv == 0)
1895 mpb->check_sum = __le32_to_cpu(__gen_imsm_checksum(mpb));
f352c545
DW		 1896
1897 return rv;
cdddbdbc
DW		 1898}
1899
c2c087e6 1900static size_t disks_to_mpb_size(int disks)
cdddbdbc 1901{
c2c087e6 1902 size_t size;
cdddbdbc 1903
c2c087e6
DW		 1904 size = sizeof(struct imsm_super);
1905 size += (disks - 1) * sizeof(struct imsm_disk);
1906 size += 2 * sizeof(struct imsm_dev);
1907 /* up to 2 maps per raid device (-2 for imsm_maps in imsm_dev */
1908 size += (4 - 2) * sizeof(struct imsm_map);
1909 /* 4 possible disk_ord_tbl's */
1910 size += 4 * (disks - 1) * sizeof(__u32);
1911
1912 return size;
1913}
1914
1915static __u64 avail_size_imsm(struct supertype *st, __u64 devsize)
1916{
1917 if (devsize < (MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS))
1918 return 0;
1919
1920 return devsize - (MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS);
cdddbdbc
DW		 1921}
1922
ba2de7ba
DW		 1923static void free_devlist(struct intel_super *super)
1924{
1925 struct intel_dev *dv;
1926
1927 while (super->devlist) {
1928 dv = super->devlist->next;
1929 free(super->devlist->dev);
1930 free(super->devlist);
1931 super->devlist = dv;
1932 }
1933}
1934
1935static void imsm_copy_dev(struct imsm_dev *dest, struct imsm_dev *src)
1936{
1937 memcpy(dest, src, sizeof_imsm_dev(src, 0));
1938}
1939
cdddbdbc
DW		 1940static int compare_super_imsm(struct supertype *st, struct supertype *tst)
1941{
1942 /*
1943 * return:
1944 * 0 same, or first was empty, and second was copied
1945 * 1 second had wrong number
1946 * 2 wrong uuid
1947 * 3 wrong other info
1948 */
1949 struct intel_super *first = st->sb;
1950 struct intel_super *sec = tst->sb;
1951
1952 if (!first) {
1953 st->sb = tst->sb;
1954 tst->sb = NULL;
1955 return 0;
1956 }
1957
d23fe947
DW		 1958 /* if an anchor does not have num_raid_devs set then it is a free
1959 * floating spare
1960 */
1961 if (first->anchor->num_raid_devs > 0 &&
1962 sec->anchor->num_raid_devs > 0) {
a2b97981
DW		 1963 /* Determine if these disks might ever have been
1964 * related. Further disambiguation can only take place
1965 * in load_super_imsm_all
1966 */
1967 __u32 first_family = first->anchor->orig_family_num;
1968 __u32 sec_family = sec->anchor->orig_family_num;
1969
f796af5d
DW		 1970 if (memcmp(first->anchor->sig, sec->anchor->sig,
1971 MAX_SIGNATURE_LENGTH) != 0)
1972 return 3;
1973
a2b97981
DW		 1974 if (first_family == 0)
1975 first_family = first->anchor->family_num;
1976 if (sec_family == 0)
1977 sec_family = sec->anchor->family_num;
1978
1979 if (first_family != sec_family)
d23fe947 1980 return 3;
f796af5d 1981
d23fe947 1982 }
cdddbdbc 1983
f796af5d 1984
3e372e5a
DW		 1985 /* if 'first' is a spare promote it to a populated mpb with sec's
1986 * family number
1987 */
1988 if (first->anchor->num_raid_devs == 0 &&
1989 sec->anchor->num_raid_devs > 0) {
78d30f94 1990 int i;
ba2de7ba
DW		 1991 struct intel_dev *dv;
1992 struct imsm_dev *dev;
78d30f94
DW		 1993
1994 /* we need to copy raid device info from sec if an allocation
1995 * fails here we don't associate the spare
1996 */
1997 for (i = 0; i < sec->anchor->num_raid_devs; i++) {
ba2de7ba
DW		 1998 dv = malloc(sizeof(*dv));
1999 if (!dv)
2000 break;
2001 dev = malloc(sizeof_imsm_dev(get_imsm_dev(sec, i), 1));
2002 if (!dev) {
2003 free(dv);
2004 break;
78d30f94 2005 }
ba2de7ba
DW		 2006 dv->dev = dev;
2007 dv->index = i;
2008 dv->next = first->devlist;
2009 first->devlist = dv;
78d30f94 2010 }
709743c5 2011 if (i < sec->anchor->num_raid_devs) {
ba2de7ba
DW		 2012 /* allocation failure */
2013 free_devlist(first);
2014 fprintf(stderr, "imsm: failed to associate spare\n");
2015 return 3;
78d30f94 2016 }
3e372e5a 2017 first->anchor->num_raid_devs = sec->anchor->num_raid_devs;
148acb7b 2018 first->anchor->orig_family_num = sec->anchor->orig_family_num;
3e372e5a 2019 first->anchor->family_num = sec->anchor->family_num;
ac6449be 2020 memcpy(first->anchor->sig, sec->anchor->sig, MAX_SIGNATURE_LENGTH);
709743c5
DW		 2021 for (i = 0; i < sec->anchor->num_raid_devs; i++)
2022 imsm_copy_dev(get_imsm_dev(first, i), get_imsm_dev(sec, i));
3e372e5a
DW		 2023 }
2024
cdddbdbc
DW		 2025 return 0;
2026}
2027
0030e8d6
DW		 2028static void fd2devname(int fd, char *name)
2029{
2030 struct stat st;
2031 char path[256];
33a6535d 2032 char dname[PATH_MAX];
0030e8d6
DW		 2033 char *nm;
2034 int rv;
2035
2036 name[0] = '\0';
2037 if (fstat(fd, &st) != 0)
2038 return;
2039 sprintf(path, "/sys/dev/block/%d:%d",
2040 major(st.st_rdev), minor(st.st_rdev));
2041
2042 rv = readlink(path, dname, sizeof(dname));
2043 if (rv <= 0)
2044 return;
2045
2046 dname[rv] = '\0';
2047 nm = strrchr(dname, '/');
2048 nm++;
2049 snprintf(name, MAX_RAID_SERIAL_LEN, "/dev/%s", nm);
2050}
2051
cdddbdbc
DW		 2052extern int scsi_get_serial(int fd, void *buf, size_t buf_len);
2053
2054static int imsm_read_serial(int fd, char *devname,
2055 __u8 serial[MAX_RAID_SERIAL_LEN])
2056{
2057 unsigned char scsi_serial[255];
cdddbdbc
DW		 2058 int rv;
2059 int rsp_len;
1f24f035 2060 int len;
316e2bf4
DW		 2061 char *dest;
2062 char *src;
2063 char *rsp_buf;
2064 int i;
cdddbdbc
DW		 2065
2066 memset(scsi_serial, 0, sizeof(scsi_serial));
cdddbdbc 2067
f9ba0ff1
DW		 2068 rv = scsi_get_serial(fd, scsi_serial, sizeof(scsi_serial));
2069
40ebbb9c 2070 if (rv && check_env("IMSM_DEVNAME_AS_SERIAL")) {
f9ba0ff1
DW		 2071 memset(serial, 0, MAX_RAID_SERIAL_LEN);
2072 fd2devname(fd, (char *) serial);
0030e8d6
DW		 2073 return 0;
2074 }
2075
cdddbdbc
DW		 2076 if (rv != 0) {
2077 if (devname)
2078 fprintf(stderr,
2079 Name ": Failed to retrieve serial for %s\n",
2080 devname);
2081 return rv;
2082 }
2083
2084 rsp_len = scsi_serial[3];
03cd4cc8
DW		 2085 if (!rsp_len) {
2086 if (devname)
2087 fprintf(stderr,
2088 Name ": Failed to retrieve serial for %s\n",
2089 devname);
2090 return 2;
2091 }
1f24f035 2092 rsp_buf = (char *) &scsi_serial[4];
5c3db629 2093
316e2bf4
DW		 2094 /* trim all whitespace and non-printable characters and convert
2095 * ':' to ';'
2096 */
2097 for (i = 0, dest = rsp_buf; i < rsp_len; i++) {
2098 src = &rsp_buf[i];
2099 if (*src > 0x20) {
2100 /* ':' is reserved for use in placeholder serial
2101 * numbers for missing disks
2102 */
2103 if (*src == ':')
2104 *dest++ = ';';
2105 else
2106 *dest++ = *src;
2107 }
2108 }
2109 len = dest - rsp_buf;
2110 dest = rsp_buf;
2111
2112 /* truncate leading characters */
2113 if (len > MAX_RAID_SERIAL_LEN) {
2114 dest += len - MAX_RAID_SERIAL_LEN;
1f24f035 2115 len = MAX_RAID_SERIAL_LEN;
316e2bf4 2116 }
5c3db629 2117
5c3db629 2118 memset(serial, 0, MAX_RAID_SERIAL_LEN);
316e2bf4 2119 memcpy(serial, dest, len);
cdddbdbc
DW		 2120
2121 return 0;
2122}
2123
1f24f035
DW		 2124static int serialcmp(__u8 *s1, __u8 *s2)
2125{
2126 return strncmp((char *) s1, (char *) s2, MAX_RAID_SERIAL_LEN);
2127}
2128
2129static void serialcpy(__u8 *dest, __u8 *src)
2130{
2131 strncpy((char *) dest, (char *) src, MAX_RAID_SERIAL_LEN);
2132}
2133
1799c9e8 2134#ifndef MDASSEMBLE
54c2c1ea
DW		 2135static struct dl *serial_to_dl(__u8 *serial, struct intel_super *super)
2136{
2137 struct dl *dl;
2138
2139 for (dl = super->disks; dl; dl = dl->next)
2140 if (serialcmp(dl->serial, serial) == 0)
2141 break;
2142
2143 return dl;
2144}
1799c9e8 2145#endif
54c2c1ea 2146
a2b97981
DW		 2147static struct imsm_disk *
2148__serial_to_disk(__u8 *serial, struct imsm_super *mpb, int *idx)
2149{
2150 int i;
2151
2152 for (i = 0; i < mpb->num_disks; i++) {
2153 struct imsm_disk *disk = __get_imsm_disk(mpb, i);
2154
2155 if (serialcmp(disk->serial, serial) == 0) {
2156 if (idx)
2157 *idx = i;
2158 return disk;
2159 }
2160 }
2161
2162 return NULL;
2163}
2164
cdddbdbc
DW		 2165static int
2166load_imsm_disk(int fd, struct intel_super *super, char *devname, int keep_fd)
2167{
a2b97981 2168 struct imsm_disk *disk;
cdddbdbc
DW		 2169 struct dl *dl;
2170 struct stat stb;
cdddbdbc 2171 int rv;
a2b97981 2172 char name[40];
d23fe947
DW		 2173 __u8 serial[MAX_RAID_SERIAL_LEN];
2174
2175 rv = imsm_read_serial(fd, devname, serial);
2176
2177 if (rv != 0)
2178 return 2;
2179
a2b97981 2180 dl = calloc(1, sizeof(*dl));
b9f594fe 2181 if (!dl) {
cdddbdbc
DW		 2182 if (devname)
2183 fprintf(stderr,
2184 Name ": failed to allocate disk buffer for %s\n",
2185 devname);
2186 return 2;
2187 }
cdddbdbc 2188
a2b97981
DW		 2189 fstat(fd, &stb);
2190 dl->major = major(stb.st_rdev);
2191 dl->minor = minor(stb.st_rdev);
2192 dl->next = super->disks;
2193 dl->fd = keep_fd ? fd : -1;
2194 assert(super->disks == NULL);
2195 super->disks = dl;
2196 serialcpy(dl->serial, serial);
2197 dl->index = -2;
2198 dl->e = NULL;
2199 fd2devname(fd, name);
2200 if (devname)
2201 dl->devname = strdup(devname);
2202 else
2203 dl->devname = strdup(name);
cdddbdbc 2204
d23fe947 2205 /* look up this disk's index in the current anchor */
a2b97981
DW		 2206 disk = __serial_to_disk(dl->serial, super->anchor, &dl->index);
2207 if (disk) {
2208 dl->disk = *disk;
2209 /* only set index on disks that are a member of a
2210 * populated contianer, i.e. one with raid_devs
2211 */
2212 if (is_failed(&dl->disk))
3f6efecc 2213 dl->index = -2;
a2b97981
DW		 2214 else if (is_spare(&dl->disk))
2215 dl->index = -1;
3f6efecc
DW		 2216 }
2217
949c47a0
DW		 2218 return 0;
2219}
2220
0e600426 2221#ifndef MDASSEMBLE
0c046afd
DW		 2222/* When migrating map0 contains the 'destination' state while map1
2223 * contains the current state. When not migrating map0 contains the
2224 * current state. This routine assumes that map[0].map_state is set to
2225 * the current array state before being called.
2226 *
2227 * Migration is indicated by one of the following states
2228 * 1/ Idle (migr_state=0 map0state=normal||unitialized||degraded||failed)
e3bba0e0 2229 * 2/ Initialize (migr_state=1 migr_type=MIGR_INIT map0state=normal
0c046afd 2230 * map1state=unitialized)
1484e727 2231 * 3/ Repair (Resync) (migr_state=1 migr_type=MIGR_REPAIR map0state=normal
0c046afd 2232 * map1state=normal)
e3bba0e0 2233 * 4/ Rebuild (migr_state=1 migr_type=MIGR_REBUILD map0state=normal
0c046afd
DW		 2234 * map1state=degraded)
2235 */
0556e1a2 2236static void migrate(struct imsm_dev *dev, __u8 to_state, int migr_type)
3393c6af 2237{
0c046afd 2238 struct imsm_map *dest;
3393c6af
DW		 2239 struct imsm_map *src = get_imsm_map(dev, 0);
2240
0c046afd 2241 dev->vol.migr_state = 1;
1484e727 2242 set_migr_type(dev, migr_type);
f8f603f1 2243 dev->vol.curr_migr_unit = 0;
0c046afd
DW		 2244 dest = get_imsm_map(dev, 1);
2245
0556e1a2 2246 /* duplicate and then set the target end state in map[0] */
3393c6af 2247 memcpy(dest, src, sizeof_imsm_map(src));
28bce06f
AK		 2248 if ((migr_type == MIGR_REBUILD) ||
2249 (migr_type == MIGR_GEN_MIGR)) {
0556e1a2
DW		 2250 __u32 ord;
2251 int i;
2252
2253 for (i = 0; i < src->num_members; i++) {
2254 ord = __le32_to_cpu(src->disk_ord_tbl[i]);
2255 set_imsm_ord_tbl_ent(src, i, ord_to_idx(ord));
2256 }
2257 }
2258
0c046afd 2259 src->map_state = to_state;
949c47a0 2260}
f8f603f1
DW		 2261
2262static void end_migration(struct imsm_dev *dev, __u8 map_state)
2263{
2264 struct imsm_map *map = get_imsm_map(dev, 0);
0556e1a2 2265 struct imsm_map *prev = get_imsm_map(dev, dev->vol.migr_state);
28bce06f 2266 int i, j;
0556e1a2
DW		 2267
2268 /* merge any IMSM_ORD_REBUILD bits that were not successfully
2269 * completed in the last migration.
2270 *
28bce06f 2271 * FIXME add support for raid-level-migration
0556e1a2
DW		 2272 */
2273 for (i = 0; i < prev->num_members; i++)
28bce06f
AK		 2274 for (j = 0; j < map->num_members; j++)
2275 /* during online capacity expansion
2276 * disks position can be changed if takeover is used
2277 */
2278 if (ord_to_idx(map->disk_ord_tbl[j]) ==
2279 ord_to_idx(prev->disk_ord_tbl[i])) {
2280 map->disk_ord_tbl[j] |= prev->disk_ord_tbl[i];
2281 break;
2282 }
f8f603f1
DW		 2283
2284 dev->vol.migr_state = 0;
28bce06f 2285 dev->vol.migr_type = 0;
f8f603f1
DW		 2286 dev->vol.curr_migr_unit = 0;
2287 map->map_state = map_state;
2288}
0e600426 2289#endif
949c47a0
DW		 2290
2291static int parse_raid_devices(struct intel_super *super)
2292{
2293 int i;
2294 struct imsm_dev *dev_new;
4d7b1503
DW		 2295 size_t len, len_migr;
2296 size_t space_needed = 0;
2297 struct imsm_super *mpb = super->anchor;
949c47a0
DW		 2298
2299 for (i = 0; i < super->anchor->num_raid_devs; i++) {
2300 struct imsm_dev *dev_iter = __get_imsm_dev(super->anchor, i);
ba2de7ba 2301 struct intel_dev *dv;
949c47a0 2302
4d7b1503
DW		 2303 len = sizeof_imsm_dev(dev_iter, 0);
2304 len_migr = sizeof_imsm_dev(dev_iter, 1);
2305 if (len_migr > len)
2306 space_needed += len_migr - len;
2307
ba2de7ba
DW		 2308 dv = malloc(sizeof(*dv));
2309 if (!dv)
2310 return 1;
4d7b1503 2311 dev_new = malloc(len_migr);
ba2de7ba
DW		 2312 if (!dev_new) {
2313 free(dv);
949c47a0 2314 return 1;
ba2de7ba 2315 }
949c47a0 2316 imsm_copy_dev(dev_new, dev_iter);
ba2de7ba
DW		 2317 dv->dev = dev_new;
2318 dv->index = i;
2319 dv->next = super->devlist;
2320 super->devlist = dv;
949c47a0 2321 }
cdddbdbc 2322
4d7b1503
DW		 2323 /* ensure that super->buf is large enough when all raid devices
2324 * are migrating
2325 */
2326 if (__le32_to_cpu(mpb->mpb_size) + space_needed > super->len) {
2327 void *buf;
2328
2329 len = ROUND_UP(__le32_to_cpu(mpb->mpb_size) + space_needed, 512);
2330 if (posix_memalign(&buf, 512, len) != 0)
2331 return 1;
2332
1f45a8ad
DW		 2333 memcpy(buf, super->buf, super->len);
2334 memset(buf + super->len, 0, len - super->len);
4d7b1503
DW		 2335 free(super->buf);
2336 super->buf = buf;
2337 super->len = len;
2338 }
2339
cdddbdbc
DW		 2340 return 0;
2341}
2342
604b746f
JD		 2343/* retrieve a pointer to the bbm log which starts after all raid devices */
2344struct bbm_log *__get_imsm_bbm_log(struct imsm_super *mpb)
2345{
2346 void *ptr = NULL;
2347
2348 if (__le32_to_cpu(mpb->bbm_log_size)) {
2349 ptr = mpb;
2350 ptr += mpb->mpb_size - __le32_to_cpu(mpb->bbm_log_size);
2351 }
2352
2353 return ptr;
2354}
2355
d23fe947 2356static void __free_imsm(struct intel_super *super, int free_disks);
9ca2c81c 2357
cdddbdbc
DW		 2358/* load_imsm_mpb - read matrix metadata
2359 * allocates super->mpb to be freed by free_super
2360 */
2361static int load_imsm_mpb(int fd, struct intel_super *super, char *devname)
2362{
2363 unsigned long long dsize;
cdddbdbc
DW		 2364 unsigned long long sectors;
2365 struct stat;
6416d527 2366 struct imsm_super *anchor;
cdddbdbc
DW		 2367 __u32 check_sum;
2368
cdddbdbc 2369 get_dev_size(fd, NULL, &dsize);
64436f06
N		 2370 if (dsize < 1024) {
2371 if (devname)
2372 fprintf(stderr,
2373 Name ": %s: device to small for imsm\n",
2374 devname);
2375 return 1;
2376 }
cdddbdbc
DW		 2377
2378 if (lseek64(fd, dsize - (512 * 2), SEEK_SET) < 0) {
2379 if (devname)
2380 fprintf(stderr,
2381 Name ": Cannot seek to anchor block on %s: %s\n",
2382 devname, strerror(errno));
2383 return 1;
2384 }
2385
949c47a0 2386 if (posix_memalign((void**)&anchor, 512, 512) != 0) {
ad97895e
DW		 2387 if (devname)
2388 fprintf(stderr,
2389 Name ": Failed to allocate imsm anchor buffer"
2390 " on %s\n", devname);
2391 return 1;
2392 }
949c47a0 2393 if (read(fd, anchor, 512) != 512) {
cdddbdbc
DW		 2394 if (devname)
2395 fprintf(stderr,
2396 Name ": Cannot read anchor block on %s: %s\n",
2397 devname, strerror(errno));
6416d527 2398 free(anchor);
cdddbdbc
DW		 2399 return 1;
2400 }
2401
6416d527 2402 if (strncmp((char *) anchor->sig, MPB_SIGNATURE, MPB_SIG_LEN) != 0) {
cdddbdbc
DW		 2403 if (devname)
2404 fprintf(stderr,
2405 Name ": no IMSM anchor on %s\n", devname);
6416d527 2406 free(anchor);
cdddbdbc
DW		 2407 return 2;
2408 }
2409
d23fe947 2410 __free_imsm(super, 0);
949c47a0
DW		 2411 super->len = ROUND_UP(anchor->mpb_size, 512);
2412 if (posix_memalign(&super->buf, 512, super->len) != 0) {
cdddbdbc
DW		 2413 if (devname)
2414 fprintf(stderr,
2415 Name ": unable to allocate %zu byte mpb buffer\n",
949c47a0 2416 super->len);
6416d527 2417 free(anchor);
cdddbdbc
DW		 2418 return 2;
2419 }
949c47a0 2420 memcpy(super->buf, anchor, 512);
cdddbdbc 2421
6416d527
NB		 2422 sectors = mpb_sectors(anchor) - 1;
2423 free(anchor);
949c47a0 2424 if (!sectors) {
ecf45690
DW		 2425 check_sum = __gen_imsm_checksum(super->anchor);
2426 if (check_sum != __le32_to_cpu(super->anchor->check_sum)) {
2427 if (devname)
2428 fprintf(stderr,
2429 Name ": IMSM checksum %x != %x on %s\n",
2430 check_sum,
2431 __le32_to_cpu(super->anchor->check_sum),
2432 devname);
2433 return 2;
2434 }
2435
a2b97981 2436 return 0;
949c47a0 2437 }
cdddbdbc
DW		 2438
2439 /* read the extended mpb */
2440 if (lseek64(fd, dsize - (512 * (2 + sectors)), SEEK_SET) < 0) {
2441 if (devname)
2442 fprintf(stderr,
2443 Name ": Cannot seek to extended mpb on %s: %s\n",
2444 devname, strerror(errno));
2445 return 1;
2446 }
2447
f21e18ca 2448 if ((unsigned)read(fd, super->buf + 512, super->len - 512) != super->len - 512) {
cdddbdbc
DW		 2449 if (devname)
2450 fprintf(stderr,
2451 Name ": Cannot read extended mpb on %s: %s\n",
2452 devname, strerror(errno));
2453 return 2;
2454 }
2455
949c47a0
DW		 2456 check_sum = __gen_imsm_checksum(super->anchor);
2457 if (check_sum != __le32_to_cpu(super->anchor->check_sum)) {
cdddbdbc
DW		 2458 if (devname)
2459 fprintf(stderr,
2460 Name ": IMSM checksum %x != %x on %s\n",
949c47a0 2461 check_sum, __le32_to_cpu(super->anchor->check_sum),
cdddbdbc 2462 devname);
db575f3b 2463 return 3;
cdddbdbc
DW		 2464 }
2465
604b746f
JD		 2466 /* FIXME the BBM log is disk specific so we cannot use this global
2467 * buffer for all disks. Ok for now since we only look at the global
2468 * bbm_log_size parameter to gate assembly
2469 */
2470 super->bbm_log = __get_imsm_bbm_log(super->anchor);
2471
a2b97981
DW		 2472 return 0;
2473}
2474
2475static int
2476load_and_parse_mpb(int fd, struct intel_super *super, char *devname, int keep_fd)
2477{
2478 int err;
2479
2480 err = load_imsm_mpb(fd, super, devname);
2481 if (err)
2482 return err;
2483 err = load_imsm_disk(fd, super, devname, keep_fd);
2484 if (err)
2485 return err;
2486 err = parse_raid_devices(super);
4d7b1503 2487
a2b97981 2488 return err;
cdddbdbc
DW		 2489}
2490
ae6aad82
DW		 2491static void __free_imsm_disk(struct dl *d)
2492{
2493 if (d->fd >= 0)
2494 close(d->fd);
2495 if (d->devname)
2496 free(d->devname);
0dcecb2e
DW		 2497 if (d->e)
2498 free(d->e);
ae6aad82
DW		 2499 free(d);
2500
2501}
1a64be56 2502
cdddbdbc
DW		 2503static void free_imsm_disks(struct intel_super *super)
2504{
47ee5a45 2505 struct dl *d;
cdddbdbc 2506
47ee5a45
DW		 2507 while (super->disks) {
2508 d = super->disks;
cdddbdbc 2509 super->disks = d->next;
ae6aad82 2510 __free_imsm_disk(d);
cdddbdbc 2511 }
47ee5a45
DW		 2512 while (super->missing) {
2513 d = super->missing;
2514 super->missing = d->next;
2515 __free_imsm_disk(d);
2516 }
2517
cdddbdbc
DW		 2518}
2519
9ca2c81c 2520/* free all the pieces hanging off of a super pointer */
d23fe947 2521static void __free_imsm(struct intel_super *super, int free_disks)
cdddbdbc 2522{
9ca2c81c 2523 if (super->buf) {
949c47a0 2524 free(super->buf);
9ca2c81c
DW		 2525 super->buf = NULL;
2526 }
d23fe947
DW		 2527 if (free_disks)
2528 free_imsm_disks(super);
ba2de7ba 2529 free_devlist(super);
88c32bb1
DW		 2530 if (super->hba) {
2531 free((void *) super->hba);
2532 super->hba = NULL;
2533 }
cdddbdbc
DW		 2534}
2535
9ca2c81c
DW		 2536static void free_imsm(struct intel_super *super)
2537{
d23fe947 2538 __free_imsm(super, 1);
9ca2c81c
DW		 2539 free(super);
2540}
cdddbdbc
DW		 2541
2542static void free_super_imsm(struct supertype *st)
2543{
2544 struct intel_super *super = st->sb;
2545
2546 if (!super)
2547 return;
2548
2549 free_imsm(super);
2550 st->sb = NULL;
2551}
2552
49133e57 2553static struct intel_super *alloc_super(void)
c2c087e6
DW		 2554{
2555 struct intel_super *super = malloc(sizeof(*super));
2556
2557 if (super) {
2558 memset(super, 0, sizeof(*super));
bf5a934a 2559 super->current_vol = -1;
0dcecb2e 2560 super->create_offset = ~((__u32 ) 0);
88c32bb1
DW		 2561 if (!check_env("IMSM_NO_PLATFORM"))
2562 super->orom = find_imsm_orom();
cceebc67 2563 if (super->orom && !check_env("IMSM_TEST_OROM")) {
88c32bb1
DW		 2564 struct sys_dev *list, *ent;
2565
2566 /* find the first intel ahci controller */
2567 list = find_driver_devices("pci", "ahci");
2568 for (ent = list; ent; ent = ent->next)
2569 if (devpath_to_vendor(ent->path) == 0x8086)
2570 break;
2571 if (ent) {
2572 super->hba = ent->path;
2573 ent->path = NULL;
2574 }
2575 free_sys_dev(&list);
2576 }
c2c087e6
DW		 2577 }
2578
2579 return super;
2580}
2581
cdddbdbc 2582#ifndef MDASSEMBLE
47ee5a45
DW		 2583/* find_missing - helper routine for load_super_imsm_all that identifies
2584 * disks that have disappeared from the system. This routine relies on
2585 * the mpb being uptodate, which it is at load time.
2586 */
2587static int find_missing(struct intel_super *super)
2588{
2589 int i;
2590 struct imsm_super *mpb = super->anchor;
2591 struct dl *dl;
2592 struct imsm_disk *disk;
47ee5a45
DW		 2593
2594 for (i = 0; i < mpb->num_disks; i++) {
2595 disk = __get_imsm_disk(mpb, i);
54c2c1ea 2596 dl = serial_to_dl(disk->serial, super);
47ee5a45
DW		 2597 if (dl)
2598 continue;
47ee5a45
DW		 2599
2600 dl = malloc(sizeof(*dl));
2601 if (!dl)
2602 return 1;
2603 dl->major = 0;
2604 dl->minor = 0;
2605 dl->fd = -1;
2606 dl->devname = strdup("missing");
2607 dl->index = i;
2608 serialcpy(dl->serial, disk->serial);
2609 dl->disk = *disk;
689c9bf3 2610 dl->e = NULL;
47ee5a45
DW		 2611 dl->next = super->missing;
2612 super->missing = dl;
2613 }
2614
2615 return 0;
2616}
2617
a2b97981
DW		 2618static struct intel_disk *disk_list_get(__u8 *serial, struct intel_disk *disk_list)
2619{
2620 struct intel_disk *idisk = disk_list;
2621
2622 while (idisk) {
2623 if (serialcmp(idisk->disk.serial, serial) == 0)
2624 break;
2625 idisk = idisk->next;
2626 }
2627
2628 return idisk;
2629}
2630
2631static int __prep_thunderdome(struct intel_super **table, int tbl_size,
2632 struct intel_super *super,
2633 struct intel_disk **disk_list)
2634{
2635 struct imsm_disk *d = &super->disks->disk;
2636 struct imsm_super *mpb = super->anchor;
2637 int i, j;
2638
2639 for (i = 0; i < tbl_size; i++) {
2640 struct imsm_super *tbl_mpb = table[i]->anchor;
2641 struct imsm_disk *tbl_d = &table[i]->disks->disk;
2642
2643 if (tbl_mpb->family_num == mpb->family_num) {
2644 if (tbl_mpb->check_sum == mpb->check_sum) {
2645 dprintf("%s: mpb from %d:%d matches %d:%d\n",
2646 __func__, super->disks->major,
2647 super->disks->minor,
2648 table[i]->disks->major,
2649 table[i]->disks->minor);
2650 break;
2651 }
2652
2653 if (((is_configured(d) && !is_configured(tbl_d)) ||
2654 is_configured(d) == is_configured(tbl_d)) &&
2655 tbl_mpb->generation_num < mpb->generation_num) {
2656 /* current version of the mpb is a
2657 * better candidate than the one in
2658 * super_table, but copy over "cross
2659 * generational" status
2660 */
2661 struct intel_disk *idisk;
2662
2663 dprintf("%s: mpb from %d:%d replaces %d:%d\n",
2664 __func__, super->disks->major,
2665 super->disks->minor,
2666 table[i]->disks->major,
2667 table[i]->disks->minor);
2668
2669 idisk = disk_list_get(tbl_d->serial, *disk_list);
2670 if (idisk && is_failed(&idisk->disk))
2671 tbl_d->status |= FAILED_DISK;
2672 break;
2673 } else {
2674 struct intel_disk *idisk;
2675 struct imsm_disk *disk;
2676
2677 /* tbl_mpb is more up to date, but copy
2678 * over cross generational status before
2679 * returning
2680 */
2681 disk = __serial_to_disk(d->serial, mpb, NULL);
2682 if (disk && is_failed(disk))
2683 d->status |= FAILED_DISK;
2684
2685 idisk = disk_list_get(d->serial, *disk_list);
2686 if (idisk) {
2687 idisk->owner = i;
2688 if (disk && is_configured(disk))
2689 idisk->disk.status |= CONFIGURED_DISK;
2690 }
2691
2692 dprintf("%s: mpb from %d:%d prefer %d:%d\n",
2693 __func__, super->disks->major,
2694 super->disks->minor,
2695 table[i]->disks->major,
2696 table[i]->disks->minor);
2697
2698 return tbl_size;
2699 }
2700 }
2701 }
2702
2703 if (i >= tbl_size)
2704 table[tbl_size++] = super;
2705 else
2706 table[i] = super;
2707
2708 /* update/extend the merged list of imsm_disk records */
2709 for (j = 0; j < mpb->num_disks; j++) {
2710 struct imsm_disk *disk = __get_imsm_disk(mpb, j);
2711 struct intel_disk *idisk;
2712
2713 idisk = disk_list_get(disk->serial, *disk_list);
2714 if (idisk) {
2715 idisk->disk.status |= disk->status;
2716 if (is_configured(&idisk->disk) ||
2717 is_failed(&idisk->disk))
2718 idisk->disk.status &= ~(SPARE_DISK);
2719 } else {
2720 idisk = calloc(1, sizeof(*idisk));
2721 if (!idisk)
2722 return -1;
2723 idisk->owner = IMSM_UNKNOWN_OWNER;
2724 idisk->disk = *disk;
2725 idisk->next = *disk_list;
2726 *disk_list = idisk;
2727 }
2728
2729 if (serialcmp(idisk->disk.serial, d->serial) == 0)
2730 idisk->owner = i;
2731 }
2732
2733 return tbl_size;
2734}
2735
2736static struct intel_super *
2737validate_members(struct intel_super *super, struct intel_disk *disk_list,
2738 const int owner)
2739{
2740 struct imsm_super *mpb = super->anchor;
2741 int ok_count = 0;
2742 int i;
2743
2744 for (i = 0; i < mpb->num_disks; i++) {
2745 struct imsm_disk *disk = __get_imsm_disk(mpb, i);
2746 struct intel_disk *idisk;
2747
2748 idisk = disk_list_get(disk->serial, disk_list);
2749 if (idisk) {
2750 if (idisk->owner == owner ||
2751 idisk->owner == IMSM_UNKNOWN_OWNER)
2752 ok_count++;
2753 else
2754 dprintf("%s: '%.16s' owner %d != %d\n",
2755 __func__, disk->serial, idisk->owner,
2756 owner);
2757 } else {
2758 dprintf("%s: unknown disk %x [%d]: %.16s\n",
2759 __func__, __le32_to_cpu(mpb->family_num), i,
2760 disk->serial);
2761 break;
2762 }
2763 }
2764
2765 if (ok_count == mpb->num_disks)
2766 return super;
2767 return NULL;
2768}
2769
2770static void show_conflicts(__u32 family_num, struct intel_super *super_list)
2771{
2772 struct intel_super *s;
2773
2774 for (s = super_list; s; s = s->next) {
2775 if (family_num != s->anchor->family_num)
2776 continue;
2777 fprintf(stderr, "Conflict, offlining family %#x on '%s'\n",
2778 __le32_to_cpu(family_num), s->disks->devname);
2779 }
2780}
2781
2782static struct intel_super *
2783imsm_thunderdome(struct intel_super **super_list, int len)
2784{
2785 struct intel_super *super_table[len];
2786 struct intel_disk *disk_list = NULL;
2787 struct intel_super *champion, *spare;
2788 struct intel_super *s, **del;
2789 int tbl_size = 0;
2790 int conflict;
2791 int i;
2792
2793 memset(super_table, 0, sizeof(super_table));
2794 for (s = *super_list; s; s = s->next)
2795 tbl_size = __prep_thunderdome(super_table, tbl_size, s, &disk_list);
2796
2797 for (i = 0; i < tbl_size; i++) {
2798 struct imsm_disk *d;
2799 struct intel_disk *idisk;
2800 struct imsm_super *mpb = super_table[i]->anchor;
2801
2802 s = super_table[i];
2803 d = &s->disks->disk;
2804
2805 /* 'd' must appear in merged disk list for its
2806 * configuration to be valid
2807 */
2808 idisk = disk_list_get(d->serial, disk_list);
2809 if (idisk && idisk->owner == i)
2810 s = validate_members(s, disk_list, i);
2811 else
2812 s = NULL;
2813
2814 if (!s)
2815 dprintf("%s: marking family: %#x from %d:%d offline\n",
2816 __func__, mpb->family_num,
2817 super_table[i]->disks->major,
2818 super_table[i]->disks->minor);
2819 super_table[i] = s;
2820 }
2821
2822 /* This is where the mdadm implementation differs from the Windows
2823 * driver which has no strict concept of a container. We can only
2824 * assemble one family from a container, so when returning a prodigal
2825 * array member to this system the code will not be able to disambiguate
2826 * the container contents that should be assembled ("foreign" versus
2827 * "local"). It requires user intervention to set the orig_family_num
2828 * to a new value to establish a new container. The Windows driver in
2829 * this situation fixes up the volume name in place and manages the
2830 * foreign array as an independent entity.
2831 */
2832 s = NULL;
2833 spare = NULL;
2834 conflict = 0;
2835 for (i = 0; i < tbl_size; i++) {
2836 struct intel_super *tbl_ent = super_table[i];
2837 int is_spare = 0;
2838
2839 if (!tbl_ent)
2840 continue;
2841
2842 if (tbl_ent->anchor->num_raid_devs == 0) {
2843 spare = tbl_ent;
2844 is_spare = 1;
2845 }
2846
2847 if (s && !is_spare) {
2848 show_conflicts(tbl_ent->anchor->family_num, *super_list);
2849 conflict++;
2850 } else if (!s && !is_spare)
2851 s = tbl_ent;
2852 }
2853
2854 if (!s)
2855 s = spare;
2856 if (!s) {
2857 champion = NULL;
2858 goto out;
2859 }
2860 champion = s;
2861
2862 if (conflict)
2863 fprintf(stderr, "Chose family %#x on '%s', "
2864 "assemble conflicts to new container with '--update=uuid'\n",
2865 __le32_to_cpu(s->anchor->family_num), s->disks->devname);
2866
2867 /* collect all dl's onto 'champion', and update them to
2868 * champion's version of the status
2869 */
2870 for (s = *super_list; s; s = s->next) {
2871 struct imsm_super *mpb = champion->anchor;
2872 struct dl *dl = s->disks;
2873
2874 if (s == champion)
2875 continue;
2876
2877 for (i = 0; i < mpb->num_disks; i++) {
2878 struct imsm_disk *disk;
2879
2880 disk = __serial_to_disk(dl->serial, mpb, &dl->index);
2881 if (disk) {
2882 dl->disk = *disk;
2883 /* only set index on disks that are a member of
2884 * a populated contianer, i.e. one with
2885 * raid_devs
2886 */
2887 if (is_failed(&dl->disk))
2888 dl->index = -2;
2889 else if (is_spare(&dl->disk))
2890 dl->index = -1;
2891 break;
2892 }
2893 }
2894
2895 if (i >= mpb->num_disks) {
2896 struct intel_disk *idisk;
2897
2898 idisk = disk_list_get(dl->serial, disk_list);
ecf408e9 2899 if (idisk && is_spare(&idisk->disk) &&
a2b97981
DW		 2900 !is_failed(&idisk->disk) && !is_configured(&idisk->disk))
2901 dl->index = -1;
2902 else {
2903 dl->index = -2;
2904 continue;
2905 }
2906 }
2907
2908 dl->next = champion->disks;
2909 champion->disks = dl;
2910 s->disks = NULL;
2911 }
2912
2913 /* delete 'champion' from super_list */
2914 for (del = super_list; *del; ) {
2915 if (*del == champion) {
2916 *del = (*del)->next;
2917 break;
2918 } else
2919 del = &(*del)->next;
2920 }
2921 champion->next = NULL;
2922
2923 out:
2924 while (disk_list) {
2925 struct intel_disk *idisk = disk_list;
2926
2927 disk_list = disk_list->next;
2928 free(idisk);
2929 }
2930
2931 return champion;
2932}
2933
cdddbdbc 2934static int load_super_imsm_all(struct supertype *st, int fd, void **sbp,
e1902a7b 2935 char *devname)
cdddbdbc
DW		 2936{
2937 struct mdinfo *sra;
a2b97981
DW		 2938 struct intel_super *super_list = NULL;
2939 struct intel_super *super = NULL;
db575f3b 2940 int devnum = fd2devnum(fd);
a2b97981 2941 struct mdinfo *sd;
db575f3b 2942 int retry;
a2b97981
DW		 2943 int err = 0;
2944 int i;
dab4a513
DW		 2945
2946 /* check if 'fd' an opened container */
b526e52d 2947 sra = sysfs_read(fd, 0, GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE);
cdddbdbc
DW		 2948 if (!sra)
2949 return 1;
2950
2951 if (sra->array.major_version != -1 ||
2952 sra->array.minor_version != -2 ||
1602d52c
AW		 2953 strcmp(sra->text_version, "imsm") != 0) {
2954 err = 1;
2955 goto error;
2956 }
a2b97981
DW		 2957 /* load all mpbs */
2958 for (sd = sra->devs, i = 0; sd; sd = sd->next, i++) {
49133e57 2959 struct intel_super *s = alloc_super();
7a6ecd55 2960 char nm[32];
a2b97981
DW		 2961 int dfd;
2962
2963 err = 1;
2964 if (!s)
2965 goto error;
2966 s->next = super_list;
2967 super_list = s;
cdddbdbc 2968
a2b97981 2969 err = 2;
cdddbdbc 2970 sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
e1902a7b 2971 dfd = dev_open(nm, O_RDWR);
a2b97981
DW		 2972 if (dfd < 0)
2973 goto error;
2974
e1902a7b 2975 err = load_and_parse_mpb(dfd, s, NULL, 1);
db575f3b
DW		 2976
2977 /* retry the load if we might have raced against mdmon */
a2b97981 2978 if (err == 3 && mdmon_running(devnum))
db575f3b
DW		 2979 for (retry = 0; retry < 3; retry++) {
2980 usleep(3000);
e1902a7b 2981 err = load_and_parse_mpb(dfd, s, NULL, 1);
a2b97981 2982 if (err != 3)
db575f3b
DW		 2983 break;
2984 }
a2b97981
DW		 2985 if (err)
2986 goto error;
cdddbdbc
DW		 2987 }
2988
a2b97981
DW		 2989 /* all mpbs enter, maybe one leaves */
2990 super = imsm_thunderdome(&super_list, i);
2991 if (!super) {
2992 err = 1;
2993 goto error;
cdddbdbc
DW		 2994 }
2995
47ee5a45
DW		 2996 if (find_missing(super) != 0) {
2997 free_imsm(super);
a2b97981
DW		 2998 err = 2;
2999 goto error;
47ee5a45 3000 }
a2b97981
DW		 3001 err = 0;
3002
3003 error:
3004 while (super_list) {
3005 struct intel_super *s = super_list;
3006
3007 super_list = super_list->next;
3008 free_imsm(s);
3009 }
1602d52c 3010 sysfs_free(sra);
a2b97981
DW		 3011
3012 if (err)
3013 return err;
f7e7067b 3014
cdddbdbc 3015 *sbp = super;
db575f3b 3016 st->container_dev = devnum;
a2b97981 3017 if (err == 0 && st->ss == NULL) {
bf5a934a 3018 st->ss = &super_imsm;
cdddbdbc
DW		 3019 st->minor_version = 0;
3020 st->max_devs = IMSM_MAX_DEVICES;
3021 }
cdddbdbc
DW		 3022 return 0;
3023}
2b959fbf
N		 3024
3025static int load_container_imsm(struct supertype *st, int fd, char *devname)
3026{
3027 return load_super_imsm_all(st, fd, &st->sb, devname);
3028}
cdddbdbc
DW		 3029#endif
3030
3031static int load_super_imsm(struct supertype *st, int fd, char *devname)
3032{
3033 struct intel_super *super;
3034 int rv;
3035
3036#ifndef MDASSEMBLE
e1902a7b 3037 if (load_super_imsm_all(st, fd, &st->sb, devname) == 0)
cdddbdbc
DW		 3038 return 0;
3039#endif
3040
691c6ee1
N		 3041 if (test_partition(fd))
3042 /* IMSM not allowed on partitions */
3043 return 1;
3044
37424f13
DW		 3045 free_super_imsm(st);
3046
49133e57 3047 super = alloc_super();
cdddbdbc
DW		 3048 if (!super) {
3049 fprintf(stderr,
3050 Name ": malloc of %zu failed.\n",
3051 sizeof(*super));
3052 return 1;
3053 }
3054
a2b97981 3055 rv = load_and_parse_mpb(fd, super, devname, 0);
cdddbdbc
DW		 3056
3057 if (rv) {
3058 if (devname)
3059 fprintf(stderr,
3060 Name ": Failed to load all information "
3061 "sections on %s\n", devname);
3062 free_imsm(super);
3063 return rv;
3064 }
3065
3066 st->sb = super;
3067 if (st->ss == NULL) {
3068 st->ss = &super_imsm;
3069 st->minor_version = 0;
3070 st->max_devs = IMSM_MAX_DEVICES;
3071 }
cdddbdbc
DW		 3072 return 0;
3073}
3074
ef6ffade
DW		 3075static __u16 info_to_blocks_per_strip(mdu_array_info_t *info)
3076{
3077 if (info->level == 1)
3078 return 128;
3079 return info->chunk_size >> 9;
3080}
3081
ff596308 3082static __u32 info_to_num_data_stripes(mdu_array_info_t *info, int num_domains)
ef6ffade
DW		 3083{
3084 __u32 num_stripes;
3085
3086 num_stripes = (info->size * 2) / info_to_blocks_per_strip(info);
ff596308 3087 num_stripes /= num_domains;
ef6ffade
DW		 3088
3089 return num_stripes;
3090}
3091
fcfd9599
DW		 3092static __u32 info_to_blocks_per_member(mdu_array_info_t *info)
3093{
4025c288
DW		 3094 if (info->level == 1)
3095 return info->size * 2;
3096 else
3097 return (info->size * 2) & ~(info_to_blocks_per_strip(info) - 1);
fcfd9599
DW		 3098}
3099
4d1313e9
DW		 3100static void imsm_update_version_info(struct intel_super *super)
3101{
3102 /* update the version and attributes */
3103 struct imsm_super *mpb = super->anchor;
3104 char *version;
3105 struct imsm_dev *dev;
3106 struct imsm_map *map;
3107 int i;
3108
3109 for (i = 0; i < mpb->num_raid_devs; i++) {
3110 dev = get_imsm_dev(super, i);
3111 map = get_imsm_map(dev, 0);
3112 if (__le32_to_cpu(dev->size_high) > 0)
3113 mpb->attributes |= MPB_ATTRIB_2TB;
3114
3115 /* FIXME detect when an array spans a port multiplier */
3116 #if 0
3117 mpb->attributes |= MPB_ATTRIB_PM;
3118 #endif
3119
3120 if (mpb->num_raid_devs > 1 ||
3121 mpb->attributes != MPB_ATTRIB_CHECKSUM_VERIFY) {
3122 version = MPB_VERSION_ATTRIBS;
3123 switch (get_imsm_raid_level(map)) {
3124 case 0: mpb->attributes |= MPB_ATTRIB_RAID0; break;
3125 case 1: mpb->attributes |= MPB_ATTRIB_RAID1; break;
3126 case 10: mpb->attributes |= MPB_ATTRIB_RAID10; break;
3127 case 5: mpb->attributes |= MPB_ATTRIB_RAID5; break;
3128 }
3129 } else {
3130 if (map->num_members >= 5)
3131 version = MPB_VERSION_5OR6_DISK_ARRAY;
3132 else if (dev->status == DEV_CLONE_N_GO)
3133 version = MPB_VERSION_CNG;
3134 else if (get_imsm_raid_level(map) == 5)
3135 version = MPB_VERSION_RAID5;
3136 else if (map->num_members >= 3)
3137 version = MPB_VERSION_3OR4_DISK_ARRAY;
3138 else if (get_imsm_raid_level(map) == 1)
3139 version = MPB_VERSION_RAID1;
3140 else
3141 version = MPB_VERSION_RAID0;
3142 }
3143 strcpy(((char *) mpb->sig) + strlen(MPB_SIGNATURE), version);
3144 }
3145}
3146
aa534678
DW		 3147static int check_name(struct intel_super *super, char *name, int quiet)
3148{
3149 struct imsm_super *mpb = super->anchor;
3150 char *reason = NULL;
3151 int i;
3152
3153 if (strlen(name) > MAX_RAID_SERIAL_LEN)
3154 reason = "must be 16 characters or less";
3155
3156 for (i = 0; i < mpb->num_raid_devs; i++) {
3157 struct imsm_dev *dev = get_imsm_dev(super, i);
3158
3159 if (strncmp((char *) dev->volume, name, MAX_RAID_SERIAL_LEN) == 0) {
3160 reason = "already exists";
3161 break;
3162 }
3163 }
3164
3165 if (reason && !quiet)
3166 fprintf(stderr, Name ": imsm volume name %s\n", reason);
3167
3168 return !reason;
3169}
3170
8b353278
DW		 3171static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info,
3172 unsigned long long size, char *name,
3173 char *homehost, int *uuid)
cdddbdbc 3174{
c2c087e6
DW		 3175 /* We are creating a volume inside a pre-existing container.
3176 * so st->sb is already set.
3177 */
3178 struct intel_super *super = st->sb;
949c47a0 3179 struct imsm_super *mpb = super->anchor;
ba2de7ba 3180 struct intel_dev *dv;
c2c087e6
DW		 3181 struct imsm_dev *dev;
3182 struct imsm_vol *vol;
3183 struct imsm_map *map;
3184 int idx = mpb->num_raid_devs;
3185 int i;
3186 unsigned long long array_blocks;
2c092cad 3187 size_t size_old, size_new;
ff596308 3188 __u32 num_data_stripes;
cdddbdbc 3189
88c32bb1 3190 if (super->orom && mpb->num_raid_devs >= super->orom->vpa) {
c2c087e6 3191 fprintf(stderr, Name": This imsm-container already has the "
88c32bb1 3192 "maximum of %d volumes\n", super->orom->vpa);
c2c087e6
DW		 3193 return 0;
3194 }
3195
2c092cad
DW		 3196 /* ensure the mpb is large enough for the new data */
3197 size_old = __le32_to_cpu(mpb->mpb_size);
3198 size_new = disks_to_mpb_size(info->nr_disks);
3199 if (size_new > size_old) {
3200 void *mpb_new;
3201 size_t size_round = ROUND_UP(size_new, 512);
3202
3203 if (posix_memalign(&mpb_new, 512, size_round) != 0) {
3204 fprintf(stderr, Name": could not allocate new mpb\n");
3205 return 0;
3206 }
3207 memcpy(mpb_new, mpb, size_old);
3208 free(mpb);
3209 mpb = mpb_new;
949c47a0 3210 super->anchor = mpb_new;
2c092cad
DW		 3211 mpb->mpb_size = __cpu_to_le32(size_new);
3212 memset(mpb_new + size_old, 0, size_round - size_old);
3213 }
bf5a934a 3214 super->current_vol = idx;
d23fe947
DW		 3215 /* when creating the first raid device in this container set num_disks
3216 * to zero, i.e. delete this spare and add raid member devices in
3217 * add_to_super_imsm_volume()
3218 */
3219 if (super->current_vol == 0)
3220 mpb->num_disks = 0;
5a038140 3221
aa534678
DW		 3222 if (!check_name(super, name, 0))
3223 return 0;
ba2de7ba
DW		 3224 dv = malloc(sizeof(*dv));
3225 if (!dv) {
3226 fprintf(stderr, Name ": failed to allocate device list entry\n");
3227 return 0;
3228 }
949c47a0
DW		 3229 dev = malloc(sizeof(*dev) + sizeof(__u32) * (info->raid_disks - 1));
3230 if (!dev) {
ba2de7ba 3231 free(dv);
949c47a0
DW		 3232 fprintf(stderr, Name": could not allocate raid device\n");
3233 return 0;
3234 }
c2c087e6 3235 strncpy((char *) dev->volume, name, MAX_RAID_SERIAL_LEN);
03bcbc65
DW		 3236 if (info->level == 1)
3237 array_blocks = info_to_blocks_per_member(info);
3238 else
3239 array_blocks = calc_array_size(info->level, info->raid_disks,
3240 info->layout, info->chunk_size,
3241 info->size*2);
979d38be
DW		 3242 /* round array size down to closest MB */
3243 array_blocks = (array_blocks >> SECT_PER_MB_SHIFT) << SECT_PER_MB_SHIFT;
3244
c2c087e6
DW		 3245 dev->size_low = __cpu_to_le32((__u32) array_blocks);
3246 dev->size_high = __cpu_to_le32((__u32) (array_blocks >> 32));
3247 dev->status = __cpu_to_le32(0);
3248 dev->reserved_blocks = __cpu_to_le32(0);
3249 vol = &dev->vol;
3250 vol->migr_state = 0;
1484e727 3251 set_migr_type(dev, MIGR_INIT);
c2c087e6 3252 vol->dirty = 0;
f8f603f1 3253 vol->curr_migr_unit = 0;
a965f303 3254 map = get_imsm_map(dev, 0);
0dcecb2e 3255 map->pba_of_lba0 = __cpu_to_le32(super->create_offset);
fcfd9599 3256 map->blocks_per_member = __cpu_to_le32(info_to_blocks_per_member(info));
ef6ffade 3257 map->blocks_per_strip = __cpu_to_le16(info_to_blocks_per_strip(info));
0556e1a2 3258 map->failed_disk_num = ~0;
c2c087e6
DW		 3259 map->map_state = info->level ? IMSM_T_STATE_UNINITIALIZED :
3260 IMSM_T_STATE_NORMAL;
252d23c0 3261 map->ddf = 1;
ef6ffade
DW		 3262
3263 if (info->level == 1 && info->raid_disks > 2) {
38950822
AW		 3264 free(dev);
3265 free(dv);
ef6ffade
DW		 3266 fprintf(stderr, Name": imsm does not support more than 2 disks"
3267 "in a raid1 volume\n");
3268 return 0;
3269 }
81062a36
DW		 3270
3271 map->raid_level = info->level;
4d1313e9 3272 if (info->level == 10) {
c2c087e6 3273 map->raid_level = 1;
4d1313e9 3274 map->num_domains = info->raid_disks / 2;
81062a36
DW		 3275 } else if (info->level == 1)
3276 map->num_domains = info->raid_disks;
3277 else
ff596308 3278 map->num_domains = 1;
81062a36 3279
ff596308
DW		 3280 num_data_stripes = info_to_num_data_stripes(info, map->num_domains);
3281 map->num_data_stripes = __cpu_to_le32(num_data_stripes);
ef6ffade 3282
c2c087e6
DW		 3283 map->num_members = info->raid_disks;
3284 for (i = 0; i < map->num_members; i++) {
3285 /* initialized in add_to_super */
4eb26970 3286 set_imsm_ord_tbl_ent(map, i, IMSM_ORD_REBUILD);
c2c087e6 3287 }
949c47a0 3288 mpb->num_raid_devs++;
ba2de7ba
DW		 3289
3290 dv->dev = dev;
3291 dv->index = super->current_vol;
3292 dv->next = super->devlist;
3293 super->devlist = dv;
c2c087e6 3294
4d1313e9
DW		 3295 imsm_update_version_info(super);
3296
c2c087e6 3297 return 1;
cdddbdbc
DW		 3298}
3299
bf5a934a
DW		 3300static int init_super_imsm(struct supertype *st, mdu_array_info_t *info,
3301 unsigned long long size, char *name,
3302 char *homehost, int *uuid)
3303{
3304 /* This is primarily called by Create when creating a new array.
3305 * We will then get add_to_super called for each component, and then
3306 * write_init_super called to write it out to each device.
3307 * For IMSM, Create can create on fresh devices or on a pre-existing
3308 * array.
3309 * To create on a pre-existing array a different method will be called.
3310 * This one is just for fresh drives.
3311 */
3312 struct intel_super *super;
3313 struct imsm_super *mpb;
3314 size_t mpb_size;
4d1313e9 3315 char *version;
bf5a934a 3316
bf5a934a 3317 if (st->sb)
e683ca88
DW		 3318 return init_super_imsm_volume(st, info, size, name, homehost, uuid);
3319
3320 if (info)
3321 mpb_size = disks_to_mpb_size(info->nr_disks);
3322 else
3323 mpb_size = 512;
bf5a934a 3324
49133e57 3325 super = alloc_super();
e683ca88 3326 if (super && posix_memalign(&super->buf, 512, mpb_size) != 0) {
bf5a934a 3327 free(super);
e683ca88
DW		 3328 super = NULL;
3329 }
3330 if (!super) {
3331 fprintf(stderr, Name
3332 ": %s could not allocate superblock\n", __func__);
bf5a934a
DW		 3333 return 0;
3334 }
e683ca88 3335 memset(super->buf, 0, mpb_size);
ef649044 3336 mpb = super->buf;
e683ca88
DW		 3337 mpb->mpb_size = __cpu_to_le32(mpb_size);
3338 st->sb = super;
3339
3340 if (info == NULL) {
3341 /* zeroing superblock */
3342 return 0;
3343 }
bf5a934a 3344
4d1313e9
DW		 3345 mpb->attributes = MPB_ATTRIB_CHECKSUM_VERIFY;
3346
3347 version = (char *) mpb->sig;
3348 strcpy(version, MPB_SIGNATURE);
3349 version += strlen(MPB_SIGNATURE);
3350 strcpy(version, MPB_VERSION_RAID0);
bf5a934a 3351
bf5a934a
DW		 3352 return 1;
3353}
3354
0e600426 3355#ifndef MDASSEMBLE
f20c3968 3356static int add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk,
bf5a934a
DW		 3357 int fd, char *devname)
3358{
3359 struct intel_super *super = st->sb;
d23fe947 3360 struct imsm_super *mpb = super->anchor;
bf5a934a
DW		 3361 struct dl *dl;
3362 struct imsm_dev *dev;
3363 struct imsm_map *map;
4eb26970 3364 int slot;
bf5a934a 3365
949c47a0 3366 dev = get_imsm_dev(super, super->current_vol);
a965f303 3367 map = get_imsm_map(dev, 0);
bf5a934a 3368
208933a7
N		 3369 if (! (dk->state & (1<<MD_DISK_SYNC))) {
3370 fprintf(stderr, Name ": %s: Cannot add spare devices to IMSM volume\n",
3371 devname);
3372 return 1;
3373 }
3374
efb30e7f
DW		 3375 if (fd == -1) {
3376 /* we're doing autolayout so grab the pre-marked (in
3377 * validate_geometry) raid_disk
3378 */
3379 for (dl = super->disks; dl; dl = dl->next)
3380 if (dl->raiddisk == dk->raid_disk)
3381 break;
3382 } else {
3383 for (dl = super->disks; dl ; dl = dl->next)
3384 if (dl->major == dk->major &&
3385 dl->minor == dk->minor)
3386 break;
3387 }
d23fe947 3388
208933a7
N		 3389 if (!dl) {
3390 fprintf(stderr, Name ": %s is not a member of the same container\n", devname);
f20c3968 3391 return 1;
208933a7 3392 }
bf5a934a 3393
d23fe947
DW		 3394 /* add a pristine spare to the metadata */
3395 if (dl->index < 0) {
3396 dl->index = super->anchor->num_disks;
3397 super->anchor->num_disks++;
3398 }
4eb26970
DW		 3399 /* Check the device has not already been added */
3400 slot = get_imsm_disk_slot(map, dl->index);
3401 if (slot >= 0 &&
98130f40 3402 (get_imsm_ord_tbl_ent(dev, slot, -1) & IMSM_ORD_REBUILD) == 0) {
4eb26970
DW		 3403 fprintf(stderr, Name ": %s has been included in this array twice\n",
3404 devname);
3405 return 1;
3406 }
be73972f 3407 set_imsm_ord_tbl_ent(map, dk->number, dl->index);
ee5aad5a 3408 dl->disk.status = CONFIGURED_DISK;
d23fe947
DW		 3409
3410 /* if we are creating the first raid device update the family number */
3411 if (super->current_vol == 0) {
3412 __u32 sum;
3413 struct imsm_dev *_dev = __get_imsm_dev(mpb, 0);
3414 struct imsm_disk *_disk = __get_imsm_disk(mpb, dl->index);
3415
791b666a
AW		 3416 if (!_dev || !_disk) {
3417 fprintf(stderr, Name ": BUG mpb setup error\n");
3418 return 1;
3419 }
d23fe947
DW		 3420 *_dev = *dev;
3421 *_disk = dl->disk;
148acb7b
DW		 3422 sum = random32();
3423 sum += __gen_imsm_checksum(mpb);
d23fe947 3424 mpb->family_num = __cpu_to_le32(sum);
148acb7b 3425 mpb->orig_family_num = mpb->family_num;
d23fe947 3426 }
f20c3968
DW		 3427
3428 return 0;
bf5a934a
DW		 3429}
3430
f20c3968 3431static int add_to_super_imsm(struct supertype *st, mdu_disk_info_t *dk,
cdddbdbc
DW		 3432 int fd, char *devname)
3433{
c2c087e6 3434 struct intel_super *super = st->sb;
c2c087e6
DW		 3435 struct dl *dd;
3436 unsigned long long size;
f2f27e63 3437 __u32 id;
c2c087e6
DW		 3438 int rv;
3439 struct stat stb;
3440
88c32bb1
DW		 3441 /* if we are on an RAID enabled platform check that the disk is
3442 * attached to the raid controller
3443 */
3444 if (super->hba && !disk_attached_to_hba(fd, super->hba)) {
3445 fprintf(stderr,
3446 Name ": %s is not attached to the raid controller: %s\n",
3447 devname ? : "disk", super->hba);
3448 return 1;
3449 }
3450
f20c3968
DW		 3451 if (super->current_vol >= 0)
3452 return add_to_super_imsm_volume(st, dk, fd, devname);
bf5a934a 3453
c2c087e6
DW		 3454 fstat(fd, &stb);
3455 dd = malloc(sizeof(*dd));
b9f594fe 3456 if (!dd) {
c2c087e6
DW		 3457 fprintf(stderr,
3458 Name ": malloc failed %s:%d.\n", __func__, __LINE__);
f20c3968 3459 return 1;
c2c087e6
DW		 3460 }
3461 memset(dd, 0, sizeof(*dd));
3462 dd->major = major(stb.st_rdev);
3463 dd->minor = minor(stb.st_rdev);
b9f594fe 3464 dd->index = -1;
c2c087e6 3465 dd->devname = devname ? strdup(devname) : NULL;
c2c087e6 3466 dd->fd = fd;
689c9bf3 3467 dd->e = NULL;
1a64be56 3468 dd->action = DISK_ADD;
c2c087e6 3469 rv = imsm_read_serial(fd, devname, dd->serial);
32ba9157 3470 if (rv) {
c2c087e6 3471 fprintf(stderr,
0030e8d6 3472 Name ": failed to retrieve scsi serial, aborting\n");
949c47a0 3473 free(dd);
0030e8d6 3474 abort();
c2c087e6
DW		 3475 }
3476
c2c087e6
DW		 3477 get_dev_size(fd, NULL, &size);
3478 size /= 512;
1f24f035 3479 serialcpy(dd->disk.serial, dd->serial);
b9f594fe 3480 dd->disk.total_blocks = __cpu_to_le32(size);
ee5aad5a 3481 dd->disk.status = SPARE_DISK;
c2c087e6 3482 if (sysfs_disk_to_scsi_id(fd, &id) == 0)
b9f594fe 3483 dd->disk.scsi_id = __cpu_to_le32(id);
c2c087e6 3484 else
b9f594fe 3485 dd->disk.scsi_id = __cpu_to_le32(0);
43dad3d6
DW		 3486
3487 if (st->update_tail) {
1a64be56
LM		 3488 dd->next = super->disk_mgmt_list;
3489 super->disk_mgmt_list = dd;
43dad3d6
DW		 3490 } else {
3491 dd->next = super->disks;
3492 super->disks = dd;
3493 }
f20c3968
DW		 3494
3495 return 0;
cdddbdbc
DW		 3496}
3497
1a64be56
LM		 3498
3499static int remove_from_super_imsm(struct supertype *st, mdu_disk_info_t *dk)
3500{
3501 struct intel_super *super = st->sb;
3502 struct dl *dd;
3503
3504 /* remove from super works only in mdmon - for communication
3505 * manager - monitor. Check if communication memory buffer
3506 * is prepared.
3507 */
3508 if (!st->update_tail) {
3509 fprintf(stderr,
3510 Name ": %s shall be used in mdmon context only"
3511 "(line %d).\n", __func__, __LINE__);
3512 return 1;
3513 }
3514 dd = malloc(sizeof(*dd));
3515 if (!dd) {
3516 fprintf(stderr,
3517 Name ": malloc failed %s:%d.\n", __func__, __LINE__);
3518 return 1;
3519 }
3520 memset(dd, 0, sizeof(*dd));
3521 dd->major = dk->major;
3522 dd->minor = dk->minor;
3523 dd->index = -1;
3524 dd->fd = -1;
3525 dd->disk.status = SPARE_DISK;
3526 dd->action = DISK_REMOVE;
3527
3528 dd->next = super->disk_mgmt_list;
3529 super->disk_mgmt_list = dd;
3530
3531
3532 return 0;
3533}
3534
f796af5d
DW		 3535static int store_imsm_mpb(int fd, struct imsm_super *mpb);
3536
3537static union {
3538 char buf[512];
3539 struct imsm_super anchor;
3540} spare_record __attribute__ ((aligned(512)));
c2c087e6 3541
d23fe947
DW		 3542/* spare records have their own family number and do not have any defined raid
3543 * devices
3544 */
3545static int write_super_imsm_spares(struct intel_super *super, int doclose)
3546{
d23fe947 3547 struct imsm_super *mpb = super->anchor;
f796af5d 3548 struct imsm_super *spare = &spare_record.anchor;
d23fe947
DW		 3549 __u32 sum;
3550 struct dl *d;
3551
f796af5d
DW		 3552 spare->mpb_size = __cpu_to_le32(sizeof(struct imsm_super)),
3553 spare->generation_num = __cpu_to_le32(1UL),
3554 spare->attributes = MPB_ATTRIB_CHECKSUM_VERIFY;
3555 spare->num_disks = 1,
3556 spare->num_raid_devs = 0,
3557 spare->cache_size = mpb->cache_size,
3558 spare->pwr_cycle_count = __cpu_to_le32(1),
3559
3560 snprintf((char *) spare->sig, MAX_SIGNATURE_LENGTH,
3561 MPB_SIGNATURE MPB_VERSION_RAID0);
d23fe947
DW		 3562
3563 for (d = super->disks; d; d = d->next) {
8796fdc4 3564 if (d->index != -1)
d23fe947
DW		 3565 continue;
3566
f796af5d
DW		 3567 spare->disk[0] = d->disk;
3568 sum = __gen_imsm_checksum(spare);
3569 spare->family_num = __cpu_to_le32(sum);
3570 spare->orig_family_num = 0;
3571 sum = __gen_imsm_checksum(spare);
3572 spare->check_sum = __cpu_to_le32(sum);
d23fe947 3573
f796af5d 3574 if (store_imsm_mpb(d->fd, spare)) {
d23fe947
DW		 3575 fprintf(stderr, "%s: failed for device %d:%d %s\n",
3576 __func__, d->major, d->minor, strerror(errno));
e74255d9 3577 return 1;
d23fe947
DW		 3578 }
3579 if (doclose) {
3580 close(d->fd);
3581 d->fd = -1;
3582 }
3583 }
3584
e74255d9 3585 return 0;
d23fe947
DW		 3586}
3587
36988a3d 3588static int write_super_imsm(struct supertype *st, int doclose)
cdddbdbc 3589{
36988a3d 3590 struct intel_super *super = st->sb;
949c47a0 3591 struct imsm_super *mpb = super->anchor;
c2c087e6
DW		 3592 struct dl *d;
3593 __u32 generation;
3594 __u32 sum;
d23fe947 3595 int spares = 0;
949c47a0 3596 int i;
a48ac0a8 3597 __u32 mpb_size = sizeof(struct imsm_super) - sizeof(struct imsm_disk);
36988a3d 3598 int num_disks = 0;
cdddbdbc 3599
c2c087e6
DW		 3600 /* 'generation' is incremented everytime the metadata is written */
3601 generation = __le32_to_cpu(mpb->generation_num);
3602 generation++;
3603 mpb->generation_num = __cpu_to_le32(generation);
3604
148acb7b
DW		 3605 /* fix up cases where previous mdadm releases failed to set
3606 * orig_family_num
3607 */
3608 if (mpb->orig_family_num == 0)
3609 mpb->orig_family_num = mpb->family_num;
3610
d23fe947 3611 for (d = super->disks; d; d = d->next) {
8796fdc4 3612 if (d->index == -1)
d23fe947 3613 spares++;
36988a3d 3614 else {
d23fe947 3615 mpb->disk[d->index] = d->disk;
36988a3d
AK		 3616 num_disks++;
3617 }
d23fe947 3618 }
36988a3d 3619 for (d = super->missing; d; d = d->next) {
47ee5a45 3620 mpb->disk[d->index] = d->disk;
36988a3d
AK		 3621 num_disks++;
3622 }
3623 mpb->num_disks = num_disks;
3624 mpb_size += sizeof(struct imsm_disk) * mpb->num_disks;
b9f594fe 3625
949c47a0
DW		 3626 for (i = 0; i < mpb->num_raid_devs; i++) {
3627 struct imsm_dev *dev = __get_imsm_dev(mpb, i);
36988a3d
AK		 3628 struct imsm_dev *dev2 = get_imsm_dev(super, i);
3629 if (dev && dev2) {
3630 imsm_copy_dev(dev, dev2);
3631 mpb_size += sizeof_imsm_dev(dev, 0);
3632 }
949c47a0 3633 }
a48ac0a8
DW		 3634 mpb_size += __le32_to_cpu(mpb->bbm_log_size);
3635 mpb->mpb_size = __cpu_to_le32(mpb_size);
949c47a0 3636
c2c087e6 3637 /* recalculate checksum */
949c47a0 3638 sum = __gen_imsm_checksum(mpb);
c2c087e6
DW		 3639 mpb->check_sum = __cpu_to_le32(sum);
3640
d23fe947 3641 /* write the mpb for disks that compose raid devices */
c2c087e6 3642 for (d = super->disks; d ; d = d->next) {
d23fe947
DW		 3643 if (d->index < 0)
3644 continue;
f796af5d 3645 if (store_imsm_mpb(d->fd, mpb))
c2c087e6
DW		 3646 fprintf(stderr, "%s: failed for device %d:%d %s\n",
3647 __func__, d->major, d->minor, strerror(errno));
c2c087e6
DW		 3648 if (doclose) {
3649 close(d->fd);
3650 d->fd = -1;
3651 }
3652 }
3653
d23fe947
DW		 3654 if (spares)
3655 return write_super_imsm_spares(super, doclose);
3656
e74255d9 3657 return 0;
c2c087e6
DW		 3658}
3659
0e600426 3660
9b1fb677 3661static int create_array(struct supertype *st, int dev_idx)
43dad3d6
DW		 3662{
3663 size_t len;
3664 struct imsm_update_create_array *u;
3665 struct intel_super *super = st->sb;
9b1fb677 3666 struct imsm_dev *dev = get_imsm_dev(super, dev_idx);
54c2c1ea
DW		 3667 struct imsm_map *map = get_imsm_map(dev, 0);
3668 struct disk_info *inf;
3669 struct imsm_disk *disk;
3670 int i;
43dad3d6 3671
54c2c1ea
DW		 3672 len = sizeof(*u) - sizeof(*dev) + sizeof_imsm_dev(dev, 0) +
3673 sizeof(*inf) * map->num_members;
43dad3d6
DW		 3674 u = malloc(len);
3675 if (!u) {
3676 fprintf(stderr, "%s: failed to allocate update buffer\n",
3677 __func__);
3678 return 1;
3679 }
3680
3681 u->type = update_create_array;
9b1fb677 3682 u->dev_idx = dev_idx;
43dad3d6 3683 imsm_copy_dev(&u->dev, dev);
54c2c1ea
DW		 3684 inf = get_disk_info(u);
3685 for (i = 0; i < map->num_members; i++) {
98130f40 3686 int idx = get_imsm_disk_idx(dev, i, -1);
9b1fb677 3687
54c2c1ea
DW		 3688 disk = get_imsm_disk(super, idx);
3689 serialcpy(inf[i].serial, disk->serial);
3690 }
43dad3d6
DW		 3691 append_metadata_update(st, u, len);
3692
3693 return 0;
3694}
3695
1a64be56 3696static int mgmt_disk(struct supertype *st)
43dad3d6
DW		 3697{
3698 struct intel_super *super = st->sb;
3699 size_t len;
1a64be56 3700 struct imsm_update_add_remove_disk *u;
43dad3d6 3701
1a64be56 3702 if (!super->disk_mgmt_list)
43dad3d6
DW		 3703 return 0;
3704
3705 len = sizeof(*u);
3706 u = malloc(len);
3707 if (!u) {
3708 fprintf(stderr, "%s: failed to allocate update buffer\n",
3709 __func__);
3710 return 1;
3711 }
3712
1a64be56 3713 u->type = update_add_remove_disk;
43dad3d6
DW		 3714 append_metadata_update(st, u, len);
3715
3716 return 0;
3717}
3718
c2c087e6
DW		 3719static int write_init_super_imsm(struct supertype *st)
3720{
9b1fb677
DW		 3721 struct intel_super *super = st->sb;
3722 int current_vol = super->current_vol;
3723
3724 /* we are done with current_vol reset it to point st at the container */
3725 super->current_vol = -1;
3726
8273f55e 3727 if (st->update_tail) {
43dad3d6
DW		 3728 /* queue the recently created array / added disk
3729 * as a metadata update */
8273f55e 3730 struct dl *d;
43dad3d6 3731 int rv;
8273f55e 3732
43dad3d6 3733 /* determine if we are creating a volume or adding a disk */
9b1fb677 3734 if (current_vol < 0) {
1a64be56
LM		 3735 /* in the mgmt (add/remove) disk case we are running
3736 * in mdmon context, so don't close fd's
43dad3d6 3737 */
1a64be56 3738 return mgmt_disk(st);
43dad3d6 3739 } else
9b1fb677 3740 rv = create_array(st, current_vol);
8273f55e
DW		 3741
3742 for (d = super->disks; d ; d = d->next) {
3743 close(d->fd);
3744 d->fd = -1;
3745 }
3746
43dad3d6 3747 return rv;
d682f344
N		 3748 } else {
3749 struct dl *d;
3750 for (d = super->disks; d; d = d->next)
3751 Kill(d->devname, NULL, 0, 1, 1);
36988a3d 3752 return write_super_imsm(st, 1);
d682f344 3753 }
cdddbdbc 3754}
0e600426 3755#endif
cdddbdbc 3756
e683ca88 3757static int store_super_imsm(struct supertype *st, int fd)
cdddbdbc 3758{
e683ca88
DW		 3759 struct intel_super *super = st->sb;
3760 struct imsm_super *mpb = super ? super->anchor : NULL;
551c80c1 3761
e683ca88 3762 if (!mpb)
ad97895e
DW		 3763 return 1;
3764
1799c9e8 3765#ifndef MDASSEMBLE
e683ca88 3766 return store_imsm_mpb(fd, mpb);
1799c9e8
N		 3767#else
3768 return 1;
3769#endif
cdddbdbc
DW		 3770}
3771
0e600426
N		 3772static int imsm_bbm_log_size(struct imsm_super *mpb)
3773{
3774 return __le32_to_cpu(mpb->bbm_log_size);
3775}
3776
3777#ifndef MDASSEMBLE
cdddbdbc
DW		 3778static int validate_geometry_imsm_container(struct supertype *st, int level,
3779 int layout, int raiddisks, int chunk,
c2c087e6 3780 unsigned long long size, char *dev,
2c514b71
NB		 3781 unsigned long long *freesize,
3782 int verbose)
cdddbdbc 3783{
c2c087e6
DW		 3784 int fd;
3785 unsigned long long ldsize;
88c32bb1 3786 const struct imsm_orom *orom;
cdddbdbc 3787
c2c087e6
DW		 3788 if (level != LEVEL_CONTAINER)
3789 return 0;
3790 if (!dev)
3791 return 1;
3792
88c32bb1
DW		 3793 if (check_env("IMSM_NO_PLATFORM"))
3794 orom = NULL;
3795 else
3796 orom = find_imsm_orom();
3797 if (orom && raiddisks > orom->tds) {
3798 if (verbose)
3799 fprintf(stderr, Name ": %d exceeds maximum number of"
3800 " platform supported disks: %d\n",
3801 raiddisks, orom->tds);
3802 return 0;
3803 }
3804
c2c087e6
DW		 3805 fd = open(dev, O_RDONLY|O_EXCL, 0);
3806 if (fd < 0) {
2c514b71
NB		 3807 if (verbose)
3808 fprintf(stderr, Name ": imsm: Cannot open %s: %s\n",
3809 dev, strerror(errno));
c2c087e6
DW		 3810 return 0;
3811 }
3812 if (!get_dev_size(fd, dev, &ldsize)) {
3813 close(fd);
3814 return 0;
3815 }
3816 close(fd);
3817
3818 *freesize = avail_size_imsm(st, ldsize >> 9);
3819
3820 return 1;
cdddbdbc
DW		 3821}
3822
0dcecb2e
DW		 3823static unsigned long long find_size(struct extent *e, int *idx, int num_extents)
3824{
3825 const unsigned long long base_start = e[*idx].start;
3826 unsigned long long end = base_start + e[*idx].size;
3827 int i;
3828
3829 if (base_start == end)
3830 return 0;
3831
3832 *idx = *idx + 1;
3833 for (i = *idx; i < num_extents; i++) {
3834 /* extend overlapping extents */
3835 if (e[i].start >= base_start &&
3836 e[i].start <= end) {
3837 if (e[i].size == 0)
3838 return 0;
3839 if (e[i].start + e[i].size > end)
3840 end = e[i].start + e[i].size;
3841 } else if (e[i].start > end) {
3842 *idx = i;
3843 break;
3844 }
3845 }
3846
3847 return end - base_start;
3848}
3849
3850static unsigned long long merge_extents(struct intel_super *super, int sum_extents)
3851{
3852 /* build a composite disk with all known extents and generate a new
3853 * 'maxsize' given the "all disks in an array must share a common start
3854 * offset" constraint
3855 */
3856 struct extent *e = calloc(sum_extents, sizeof(*e));
3857 struct dl *dl;
3858 int i, j;
3859 int start_extent;
3860 unsigned long long pos;
b9d77223 3861 unsigned long long start = 0;
0dcecb2e
DW		 3862 unsigned long long maxsize;
3863 unsigned long reserve;
3864
3865 if (!e)
a7dd165b 3866 return 0;
0dcecb2e
DW		 3867
3868 /* coalesce and sort all extents. also, check to see if we need to
3869 * reserve space between member arrays
3870 */
3871 j = 0;
3872 for (dl = super->disks; dl; dl = dl->next) {
3873 if (!dl->e)
3874 continue;
3875 for (i = 0; i < dl->extent_cnt; i++)
3876 e[j++] = dl->e[i];
3877 }
3878 qsort(e, sum_extents, sizeof(*e), cmp_extent);
3879
3880 /* merge extents */
3881 i = 0;
3882 j = 0;
3883 while (i < sum_extents) {
3884 e[j].start = e[i].start;
3885 e[j].size = find_size(e, &i, sum_extents);
3886 j++;
3887 if (e[j-1].size == 0)
3888 break;
3889 }
3890
3891 pos = 0;
3892 maxsize = 0;
3893 start_extent = 0;
3894 i = 0;
3895 do {
3896 unsigned long long esize;
3897
3898 esize = e[i].start - pos;
3899 if (esize >= maxsize) {
3900 maxsize = esize;
3901 start = pos;
3902 start_extent = i;
3903 }
3904 pos = e[i].start + e[i].size;
3905 i++;
3906 } while (e[i-1].size);
3907 free(e);
3908
a7dd165b
DW		 3909 if (maxsize == 0)
3910 return 0;
3911
3912 /* FIXME assumes volume at offset 0 is the first volume in a
3913 * container
3914 */
0dcecb2e
DW		 3915 if (start_extent > 0)
3916 reserve = IMSM_RESERVED_SECTORS; /* gap between raid regions */
3917 else
3918 reserve = 0;
3919
3920 if (maxsize < reserve)
a7dd165b 3921 return 0;
0dcecb2e
DW		 3922
3923 super->create_offset = ~((__u32) 0);
3924 if (start + reserve > super->create_offset)
a7dd165b 3925 return 0; /* start overflows create_offset */
0dcecb2e
DW		 3926 super->create_offset = start + reserve;
3927
3928 return maxsize - reserve;
3929}
3930
88c32bb1
DW		 3931static int is_raid_level_supported(const struct imsm_orom *orom, int level, int raiddisks)
3932{
3933 if (level < 0 || level == 6 || level == 4)
3934 return 0;
3935
3936 /* if we have an orom prevent invalid raid levels */
3937 if (orom)
3938 switch (level) {
3939 case 0: return imsm_orom_has_raid0(orom);
3940 case 1:
3941 if (raiddisks > 2)
3942 return imsm_orom_has_raid1e(orom);
1c556e92
DW		 3943 return imsm_orom_has_raid1(orom) && raiddisks == 2;
3944 case 10: return imsm_orom_has_raid10(orom) && raiddisks == 4;
3945 case 5: return imsm_orom_has_raid5(orom) && raiddisks > 2;
88c32bb1
DW		 3946 }
3947 else
3948 return 1; /* not on an Intel RAID platform so anything goes */
3949
3950 return 0;
3951}
3952
35f81cbb 3953#define pr_vrb(fmt, arg...) (void) (verbose && fprintf(stderr, Name fmt, ##arg))
6592ce37
DW		 3954static int
3955validate_geometry_imsm_orom(struct intel_super *super, int level, int layout,
3956 int raiddisks, int chunk, int verbose)
3957{
3958 if (!is_raid_level_supported(super->orom, level, raiddisks)) {
3959 pr_vrb(": platform does not support raid%d with %d disk%s\n",
3960 level, raiddisks, raiddisks > 1 ? "s" : "");
3961 return 0;
3962 }
3963 if (super->orom && level != 1 &&
3964 !imsm_orom_has_chunk(super->orom, chunk)) {
3965 pr_vrb(": platform does not support a chunk size of: %d\n", chunk);
3966 return 0;
3967 }
3968 if (layout != imsm_level_to_layout(level)) {
3969 if (level == 5)
3970 pr_vrb(": imsm raid 5 only supports the left-asymmetric layout\n");
3971 else if (level == 10)
3972 pr_vrb(": imsm raid 10 only supports the n2 layout\n");
3973 else
3974 pr_vrb(": imsm unknown layout %#x for this raid level %d\n",
3975 layout, level);
3976 return 0;
3977 }
3978
3979 return 1;
3980}
3981
c2c087e6
DW		 3982/* validate_geometry_imsm_volume - lifted from validate_geometry_ddf_bvd
3983 * FIX ME add ahci details
3984 */
8b353278
DW		 3985static int validate_geometry_imsm_volume(struct supertype *st, int level,
3986 int layout, int raiddisks, int chunk,
c2c087e6 3987 unsigned long long size, char *dev,
2c514b71
NB		 3988 unsigned long long *freesize,
3989 int verbose)
cdddbdbc 3990{
c2c087e6
DW		 3991 struct stat stb;
3992 struct intel_super *super = st->sb;
a20d2ba5 3993 struct imsm_super *mpb = super->anchor;
c2c087e6
DW		 3994 struct dl *dl;
3995 unsigned long long pos = 0;
3996 unsigned long long maxsize;
3997 struct extent *e;
3998 int i;
cdddbdbc 3999
88c32bb1
DW		 4000 /* We must have the container info already read in. */
4001 if (!super)
c2c087e6
DW		 4002 return 0;
4003
6592ce37 4004 if (!validate_geometry_imsm_orom(super, level, layout, raiddisks, chunk, verbose))
c2c087e6 4005 return 0;
c2c087e6
DW		 4006
4007 if (!dev) {
4008 /* General test: make sure there is space for
2da8544a
DW		 4009 * 'raiddisks' device extents of size 'size' at a given
4010 * offset
c2c087e6 4011 */
e46273eb 4012 unsigned long long minsize = size;
b7528a20 4013 unsigned long long start_offset = MaxSector;
c2c087e6
DW		 4014 int dcnt = 0;
4015 if (minsize == 0)
4016 minsize = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
4017 for (dl = super->disks; dl ; dl = dl->next) {
4018 int found = 0;
4019
bf5a934a 4020 pos = 0;
c2c087e6
DW		 4021 i = 0;
4022 e = get_extents(super, dl);
4023 if (!e) continue;
4024 do {
4025 unsigned long long esize;
4026 esize = e[i].start - pos;
4027 if (esize >= minsize)
4028 found = 1;
b7528a20 4029 if (found && start_offset == MaxSector) {
2da8544a
DW		 4030 start_offset = pos;
4031 break;
4032 } else if (found && pos != start_offset) {
4033 found = 0;
4034 break;
4035 }
c2c087e6
DW		 4036 pos = e[i].start + e[i].size;
4037 i++;
4038 } while (e[i-1].size);
4039 if (found)
4040 dcnt++;
4041 free(e);
4042 }
4043 if (dcnt < raiddisks) {
2c514b71
NB		 4044 if (verbose)
4045 fprintf(stderr, Name ": imsm: Not enough "
4046 "devices with space for this array "
4047 "(%d < %d)\n",
4048 dcnt, raiddisks);
c2c087e6
DW		 4049 return 0;
4050 }
4051 return 1;
4052 }
0dcecb2e 4053
c2c087e6
DW		 4054 /* This device must be a member of the set */
4055 if (stat(dev, &stb) < 0)
4056 return 0;
4057 if ((S_IFMT & stb.st_mode) != S_IFBLK)
4058 return 0;
4059 for (dl = super->disks ; dl ; dl = dl->next) {
f21e18ca
N		 4060 if (dl->major == (int)major(stb.st_rdev) &&
4061 dl->minor == (int)minor(stb.st_rdev))
c2c087e6
DW		 4062 break;
4063 }
4064 if (!dl) {
2c514b71
NB		 4065 if (verbose)
4066 fprintf(stderr, Name ": %s is not in the "
4067 "same imsm set\n", dev);
c2c087e6 4068 return 0;
a20d2ba5
DW		 4069 } else if (super->orom && dl->index < 0 && mpb->num_raid_devs) {
4070 /* If a volume is present then the current creation attempt
4071 * cannot incorporate new spares because the orom may not
4072 * understand this configuration (all member disks must be
4073 * members of each array in the container).
4074 */
4075 fprintf(stderr, Name ": %s is a spare and a volume"
4076 " is already defined for this container\n", dev);
4077 fprintf(stderr, Name ": The option-rom requires all member"
4078 " disks to be a member of all volumes\n");
4079 return 0;
c2c087e6 4080 }
0dcecb2e
DW		 4081
4082 /* retrieve the largest free space block */
c2c087e6
DW		 4083 e = get_extents(super, dl);
4084 maxsize = 0;
4085 i = 0;
0dcecb2e
DW		 4086 if (e) {
4087 do {
4088 unsigned long long esize;
4089
4090 esize = e[i].start - pos;
4091 if (esize >= maxsize)
4092 maxsize = esize;
4093 pos = e[i].start + e[i].size;
4094 i++;
4095 } while (e[i-1].size);
4096 dl->e = e;
4097 dl->extent_cnt = i;
4098 } else {
4099 if (verbose)
4100 fprintf(stderr, Name ": unable to determine free space for: %s\n",
4101 dev);
4102 return 0;
4103 }
4104 if (maxsize < size) {
4105 if (verbose)
4106 fprintf(stderr, Name ": %s not enough space (%llu < %llu)\n",
4107 dev, maxsize, size);
4108 return 0;
4109 }
4110
4111 /* count total number of extents for merge */
4112 i = 0;
4113 for (dl = super->disks; dl; dl = dl->next)
4114 if (dl->e)
4115 i += dl->extent_cnt;
4116
4117 maxsize = merge_extents(super, i);
a7dd165b 4118 if (maxsize < size || maxsize == 0) {
0dcecb2e
DW		 4119 if (verbose)
4120 fprintf(stderr, Name ": not enough space after merge (%llu < %llu)\n",
4121 maxsize, size);
4122 return 0;
0dcecb2e
DW		 4123 }
4124
c2c087e6
DW		 4125 *freesize = maxsize;
4126
4127 return 1;
cdddbdbc
DW		 4128}
4129
efb30e7f
DW		 4130static int reserve_space(struct supertype *st, int raiddisks,
4131 unsigned long long size, int chunk,
4132 unsigned long long *freesize)
4133{
4134 struct intel_super *super = st->sb;
4135 struct imsm_super *mpb = super->anchor;
4136 struct dl *dl;
4137 int i;
4138 int extent_cnt;
4139 struct extent *e;
4140 unsigned long long maxsize;
4141 unsigned long long minsize;
4142 int cnt;
4143 int used;
4144
4145 /* find the largest common start free region of the possible disks */
4146 used = 0;
4147 extent_cnt = 0;
4148 cnt = 0;
4149 for (dl = super->disks; dl; dl = dl->next) {
4150 dl->raiddisk = -1;
4151
4152 if (dl->index >= 0)
4153 used++;
4154
4155 /* don't activate new spares if we are orom constrained
4156 * and there is already a volume active in the container
4157 */
4158 if (super->orom && dl->index < 0 && mpb->num_raid_devs)
4159 continue;
4160
4161 e = get_extents(super, dl);
4162 if (!e)
4163 continue;
4164 for (i = 1; e[i-1].size; i++)
4165 ;
4166 dl->e = e;
4167 dl->extent_cnt = i;
4168 extent_cnt += i;
4169 cnt++;
4170 }
4171
4172 maxsize = merge_extents(super, extent_cnt);
4173 minsize = size;
4174 if (size == 0)
4175 minsize = chunk;
4176
4177 if (cnt < raiddisks ||
4178 (super->orom && used && used != raiddisks) ||
a7dd165b
DW		 4179 maxsize < minsize ||
4180 maxsize == 0) {
efb30e7f
DW		 4181 fprintf(stderr, Name ": not enough devices with space to create array.\n");
4182 return 0; /* No enough free spaces large enough */
4183 }
4184
4185 if (size == 0) {
4186 size = maxsize;
4187 if (chunk) {
4188 size /= chunk;
4189 size *= chunk;
4190 }
4191 }
4192
4193 cnt = 0;
4194 for (dl = super->disks; dl; dl = dl->next)
4195 if (dl->e)
4196 dl->raiddisk = cnt++;
4197
4198 *freesize = size;
4199
4200 return 1;
4201}
4202
bf5a934a
DW		 4203static int validate_geometry_imsm(struct supertype *st, int level, int layout,
4204 int raiddisks, int chunk, unsigned long long size,
4205 char *dev, unsigned long long *freesize,
4206 int verbose)
4207{
4208 int fd, cfd;
4209 struct mdinfo *sra;
20cbe8d2 4210 int is_member = 0;
bf5a934a
DW		 4211
4212 /* if given unused devices create a container
4213 * if given given devices in a container create a member volume
4214 */
4215 if (level == LEVEL_CONTAINER) {
4216 /* Must be a fresh device to add to a container */
4217 return validate_geometry_imsm_container(st, level, layout,
4218 raiddisks, chunk, size,
4219 dev, freesize,
4220 verbose);
4221 }
4222
8592f29d
N		 4223 if (!dev) {
4224 if (st->sb && freesize) {
efb30e7f
DW		 4225 /* we are being asked to automatically layout a
4226 * new volume based on the current contents of
4227 * the container. If the the parameters can be
4228 * satisfied reserve_space will record the disks,
4229 * start offset, and size of the volume to be
4230 * created. add_to_super and getinfo_super
4231 * detect when autolayout is in progress.
4232 */
6592ce37
DW		 4233 if (!validate_geometry_imsm_orom(st->sb, level, layout,
4234 raiddisks, chunk,
4235 verbose))
4236 return 0;
efb30e7f 4237 return reserve_space(st, raiddisks, size, chunk, freesize);
8592f29d
N		 4238 }
4239 return 1;
4240 }
bf5a934a
DW		 4241 if (st->sb) {
4242 /* creating in a given container */
4243 return validate_geometry_imsm_volume(st, level, layout,
4244 raiddisks, chunk, size,
4245 dev, freesize, verbose);
4246 }
4247
bf5a934a
DW		 4248 /* This device needs to be a device in an 'imsm' container */
4249 fd = open(dev, O_RDONLY|O_EXCL, 0);
4250 if (fd >= 0) {
4251 if (verbose)
4252 fprintf(stderr,
4253 Name ": Cannot create this array on device %s\n",
4254 dev);
4255 close(fd);
4256 return 0;
4257 }
4258 if (errno != EBUSY || (fd = open(dev, O_RDONLY, 0)) < 0) {
4259 if (verbose)
4260 fprintf(stderr, Name ": Cannot open %s: %s\n",
4261 dev, strerror(errno));
4262 return 0;
4263 }
4264 /* Well, it is in use by someone, maybe an 'imsm' container. */
4265 cfd = open_container(fd);
20cbe8d2 4266 close(fd);
bf5a934a 4267 if (cfd < 0) {
bf5a934a
DW		 4268 if (verbose)
4269 fprintf(stderr, Name ": Cannot use %s: It is busy\n",
4270 dev);
4271 return 0;
4272 }
4273 sra = sysfs_read(cfd, 0, GET_VERSION);
bf5a934a 4274 if (sra && sra->array.major_version == -1 &&
20cbe8d2
AW		 4275 strcmp(sra->text_version, "imsm") == 0)
4276 is_member = 1;
4277 sysfs_free(sra);
4278 if (is_member) {
bf5a934a
DW		 4279 /* This is a member of a imsm container. Load the container
4280 * and try to create a volume
4281 */
4282 struct intel_super *super;
4283
e1902a7b 4284 if (load_super_imsm_all(st, cfd, (void **) &super, NULL) == 0) {
bf5a934a
DW		 4285 st->sb = super;
4286 st->container_dev = fd2devnum(cfd);
4287 close(cfd);
4288 return validate_geometry_imsm_volume(st, level, layout,
4289 raiddisks, chunk,
4290 size, dev,
4291 freesize, verbose);
4292 }
20cbe8d2 4293 }
bf5a934a 4294
20cbe8d2
AW		 4295 if (verbose)
4296 fprintf(stderr, Name ": failed container membership check\n");
4297
4298 close(cfd);
4299 return 0;
bf5a934a 4300}
0bd16cf2 4301
30f58b22 4302static void default_geometry_imsm(struct supertype *st, int *level, int *layout, int *chunk)
0bd16cf2
DJ		 4303{
4304 struct intel_super *super = st->sb;
4305
30f58b22
DW		 4306 if (level && *level == UnSet)
4307 *level = LEVEL_CONTAINER;
4308
4309 if (level && layout && *layout == UnSet)
4310 *layout = imsm_level_to_layout(*level);
0bd16cf2 4311
1d54f286
N		 4312 if (chunk && (*chunk == UnSet || *chunk == 0) &&
4313 super && super->orom)
30f58b22 4314 *chunk = imsm_orom_default_chunk(super->orom);
0bd16cf2
DJ		 4315}
4316
33414a01
DW		 4317static void handle_missing(struct intel_super *super, struct imsm_dev *dev);
4318
4319static int kill_subarray_imsm(struct supertype *st)
4320{
4321 /* remove the subarray currently referenced by ->current_vol */
4322 __u8 i;
4323 struct intel_dev **dp;
4324 struct intel_super *super = st->sb;
4325 __u8 current_vol = super->current_vol;
4326 struct imsm_super *mpb = super->anchor;
4327
4328 if (super->current_vol < 0)
4329 return 2;
4330 super->current_vol = -1; /* invalidate subarray cursor */
4331
4332 /* block deletions that would change the uuid of active subarrays
4333 *
4334 * FIXME when immutable ids are available, but note that we'll
4335 * also need to fixup the invalidated/active subarray indexes in
4336 * mdstat
4337 */
4338 for (i = 0; i < mpb->num_raid_devs; i++) {
4339 char subarray[4];
4340
4341 if (i < current_vol)
4342 continue;
4343 sprintf(subarray, "%u", i);
4344 if (is_subarray_active(subarray, st->devname)) {
4345 fprintf(stderr,
4346 Name ": deleting subarray-%d would change the UUID of active subarray-%d, aborting\n",
4347 current_vol, i);
4348
4349 return 2;
4350 }
4351 }
4352
4353 if (st->update_tail) {
4354 struct imsm_update_kill_array *u = malloc(sizeof(*u));
4355
4356 if (!u)
4357 return 2;
4358 u->type = update_kill_array;
4359 u->dev_idx = current_vol;
4360 append_metadata_update(st, u, sizeof(*u));
4361
4362 return 0;
4363 }
4364
4365 for (dp = &super->devlist; *dp;)
4366 if ((*dp)->index == current_vol) {
4367 *dp = (*dp)->next;
4368 } else {
4369 handle_missing(super, (*dp)->dev);
4370 if ((*dp)->index > current_vol)
4371 (*dp)->index--;
4372 dp = &(*dp)->next;
4373 }
4374
4375 /* no more raid devices, all active components are now spares,
4376 * but of course failed are still failed
4377 */
4378 if (--mpb->num_raid_devs == 0) {
4379 struct dl *d;
4380
4381 for (d = super->disks; d; d = d->next)
4382 if (d->index > -2) {
4383 d->index = -1;
4384 d->disk.status = SPARE_DISK;
4385 }
4386 }
4387
4388 super->updates_pending++;
4389
4390 return 0;
4391}
aa534678 4392
a951a4f7 4393static int update_subarray_imsm(struct supertype *st, char *subarray,
fa56eddb 4394 char *update, struct mddev_ident *ident)
aa534678
DW		 4395{
4396 /* update the subarray currently referenced by ->current_vol */
4397 struct intel_super *super = st->sb;
4398 struct imsm_super *mpb = super->anchor;
4399
aa534678
DW		 4400 if (strcmp(update, "name") == 0) {
4401 char *name = ident->name;
a951a4f7
N		 4402 char *ep;
4403 int vol;
aa534678 4404
a951a4f7 4405 if (is_subarray_active(subarray, st->devname)) {
aa534678
DW		 4406 fprintf(stderr,
4407 Name ": Unable to update name of active subarray\n");
4408 return 2;
4409 }
4410
4411 if (!check_name(super, name, 0))
4412 return 2;
4413
a951a4f7
N		 4414 vol = strtoul(subarray, &ep, 10);
4415 if (*ep != '\0' || vol >= super->anchor->num_raid_devs)
4416 return 2;
4417
aa534678
DW		 4418 if (st->update_tail) {
4419 struct imsm_update_rename_array *u = malloc(sizeof(*u));
4420
4421 if (!u)
4422 return 2;
4423 u->type = update_rename_array;
a951a4f7 4424 u->dev_idx = vol;
aa534678
DW		 4425 snprintf((char *) u->name, MAX_RAID_SERIAL_LEN, "%s", name);
4426 append_metadata_update(st, u, sizeof(*u));
4427 } else {
4428 struct imsm_dev *dev;
4429 int i;
4430
a951a4f7 4431 dev = get_imsm_dev(super, vol);
aa534678
DW		 4432 snprintf((char *) dev->volume, MAX_RAID_SERIAL_LEN, "%s", name);
4433 for (i = 0; i < mpb->num_raid_devs; i++) {
4434 dev = get_imsm_dev(super, i);
4435 handle_missing(super, dev);
4436 }
4437 super->updates_pending++;
4438 }
4439 } else
4440 return 2;
4441
4442 return 0;
4443}
0e600426 4444#endif /* MDASSEMBLE */
bf5a934a 4445
28bce06f
AK		 4446static int is_gen_migration(struct imsm_dev *dev)
4447{
4448 if (!dev->vol.migr_state)
4449 return 0;
4450
4451 if (migr_type(dev) == MIGR_GEN_MIGR)
4452 return 1;
4453
4454 return 0;
4455}
4456
1e5c6983
DW		 4457static int is_rebuilding(struct imsm_dev *dev)
4458{
4459 struct imsm_map *migr_map;
4460
4461 if (!dev->vol.migr_state)
4462 return 0;
4463
4464 if (migr_type(dev) != MIGR_REBUILD)
4465 return 0;
4466
4467 migr_map = get_imsm_map(dev, 1);
4468
4469 if (migr_map->map_state == IMSM_T_STATE_DEGRADED)
4470 return 1;
4471 else
4472 return 0;
4473}
4474
4475static void update_recovery_start(struct imsm_dev *dev, struct mdinfo *array)
4476{
4477 struct mdinfo *rebuild = NULL;
4478 struct mdinfo *d;
4479 __u32 units;
4480
4481 if (!is_rebuilding(dev))
4482 return;
4483
4484 /* Find the rebuild target, but punt on the dual rebuild case */
4485 for (d = array->devs; d; d = d->next)
4486 if (d->recovery_start == 0) {
4487 if (rebuild)
4488 return;
4489 rebuild = d;
4490 }
4491
4363fd80
DW		 4492 if (!rebuild) {
4493 /* (?) none of the disks are marked with
4494 * IMSM_ORD_REBUILD, so assume they are missing and the
4495 * disk_ord_tbl was not correctly updated
4496 */
4497 dprintf("%s: failed to locate out-of-sync disk\n", __func__);
4498 return;
4499 }
4500
1e5c6983
DW		 4501 units = __le32_to_cpu(dev->vol.curr_migr_unit);
4502 rebuild->recovery_start = units * blocks_per_migr_unit(dev);
4503}
4504
4505
00bbdbda 4506static struct mdinfo *container_content_imsm(struct supertype *st, char *subarray)
cdddbdbc 4507{
4f5bc454
DW		 4508 /* Given a container loaded by load_super_imsm_all,
4509 * extract information about all the arrays into
4510 * an mdinfo tree.
00bbdbda 4511 * If 'subarray' is given, just extract info about that array.
4f5bc454
DW		 4512 *
4513 * For each imsm_dev create an mdinfo, fill it in,
4514 * then look for matching devices in super->disks
4515 * and create appropriate device mdinfo.
4516 */
4517 struct intel_super *super = st->sb;
949c47a0 4518 struct imsm_super *mpb = super->anchor;
4f5bc454 4519 struct mdinfo *rest = NULL;
00bbdbda 4520 unsigned int i;
a06d022d 4521 int bbm_errors = 0;
cdddbdbc 4522
a06d022d
KW		 4523 /* check for bad blocks */
4524 if (imsm_bbm_log_size(super->anchor))
4525 bbm_errors = 1;
604b746f 4526
4f5bc454 4527 for (i = 0; i < mpb->num_raid_devs; i++) {
00bbdbda
N		 4528 struct imsm_dev *dev;
4529 struct imsm_map *map;
4f5bc454 4530 struct mdinfo *this;
4f5bc454 4531 int slot;
00bbdbda
N		 4532 char *ep;
4533
4534 if (subarray &&
4535 (i != strtoul(subarray, &ep, 10) || *ep != '\0'))
4536 continue;
4537
4538 dev = get_imsm_dev(super, i);
4539 map = get_imsm_map(dev, 0);
4f5bc454 4540
1ce0101c
DW		 4541 /* do not publish arrays that are in the middle of an
4542 * unsupported migration
4543 */
4544 if (dev->vol.migr_state &&
28bce06f 4545 (migr_type(dev) == MIGR_STATE_CHANGE)) {
1ce0101c
DW		 4546 fprintf(stderr, Name ": cannot assemble volume '%.16s':"
4547 " unsupported migration in progress\n",
4548 dev->volume);
4549 continue;
4550 }
4551
4f5bc454 4552 this = malloc(sizeof(*this));
0fbd635c 4553 if (!this) {
cf1be220 4554 fprintf(stderr, Name ": failed to allocate %zu bytes\n",
0fbd635c
AW		 4555 sizeof(*this));
4556 break;
4557 }
4f5bc454
DW		 4558 memset(this, 0, sizeof(*this));
4559 this->next = rest;
4f5bc454 4560
301406c9 4561 super->current_vol = i;
a5d85af7 4562 getinfo_super_imsm_volume(st, this, NULL);
4f5bc454 4563 for (slot = 0 ; slot < map->num_members; slot++) {
1e5c6983 4564 unsigned long long recovery_start;
4f5bc454
DW		 4565 struct mdinfo *info_d;
4566 struct dl *d;
4567 int idx;
9a1608e5 4568 int skip;
7eef0453 4569 __u32 ord;
4f5bc454 4570
9a1608e5 4571 skip = 0;
98130f40
AK		 4572 idx = get_imsm_disk_idx(dev, slot, 0);
4573 ord = get_imsm_ord_tbl_ent(dev, slot, 0);
4f5bc454
DW		 4574 for (d = super->disks; d ; d = d->next)
4575 if (d->index == idx)
0fbd635c 4576 break;
4f5bc454 4577
1e5c6983 4578 recovery_start = MaxSector;
4f5bc454 4579 if (d == NULL)
9a1608e5 4580 skip = 1;
25ed7e59 4581 if (d && is_failed(&d->disk))
9a1608e5 4582 skip = 1;
7eef0453 4583 if (ord & IMSM_ORD_REBUILD)
1e5c6983 4584 recovery_start = 0;
9a1608e5
DW		 4585
4586 /*
4587 * if we skip some disks the array will be assmebled degraded;
1e5c6983
DW		 4588 * reset resync start to avoid a dirty-degraded
4589 * situation when performing the intial sync
9a1608e5
DW		 4590 *
4591 * FIXME handle dirty degraded
4592 */
1e5c6983 4593 if ((skip || recovery_start == 0) && !dev->vol.dirty)
b7528a20 4594 this->resync_start = MaxSector;
9a1608e5
DW		 4595 if (skip)
4596 continue;
4f5bc454 4597
1e5c6983 4598 info_d = calloc(1, sizeof(*info_d));
9a1608e5
DW		 4599 if (!info_d) {
4600 fprintf(stderr, Name ": failed to allocate disk"
1ce0101c 4601 " for volume %.16s\n", dev->volume);
1e5c6983
DW		 4602 info_d = this->devs;
4603 while (info_d) {
4604 struct mdinfo *d = info_d->next;
4605
4606 free(info_d);
4607 info_d = d;
4608 }
9a1608e5
DW		 4609 free(this);
4610 this = rest;
4611 break;
4612 }
4f5bc454
DW		 4613 info_d->next = this->devs;
4614 this->devs = info_d;
4615
4f5bc454
DW		 4616 info_d->disk.number = d->index;
4617 info_d->disk.major = d->major;
4618 info_d->disk.minor = d->minor;
4619 info_d->disk.raid_disk = slot;
1e5c6983 4620 info_d->recovery_start = recovery_start;
4f5bc454 4621
1e5c6983
DW		 4622 if (info_d->recovery_start == MaxSector)
4623 this->array.working_disks++;
4f5bc454
DW		 4624
4625 info_d->events = __le32_to_cpu(mpb->generation_num);
4626 info_d->data_offset = __le32_to_cpu(map->pba_of_lba0);
4627 info_d->component_size = __le32_to_cpu(map->blocks_per_member);
4f5bc454 4628 }
1e5c6983
DW		 4629 /* now that the disk list is up-to-date fixup recovery_start */
4630 update_recovery_start(dev, this);
9a1608e5 4631 rest = this;
4f5bc454
DW		 4632 }
4633
a06d022d
KW		 4634 /* if array has bad blocks, set suitable bit in array status */
4635 if (bbm_errors)
4636 rest->array.state |= (1<<MD_SB_BBM_ERRORS);
4637
4f5bc454 4638 return rest;
cdddbdbc
DW		 4639}
4640
845dea95 4641
fb49eef2 4642static __u8 imsm_check_degraded(struct intel_super *super, struct imsm_dev *dev, int failed)
c2a1e7da 4643{
a965f303 4644 struct imsm_map *map = get_imsm_map(dev, 0);
c2a1e7da
DW		 4645
4646 if (!failed)
3393c6af
DW		 4647 return map->map_state == IMSM_T_STATE_UNINITIALIZED ?
4648 IMSM_T_STATE_UNINITIALIZED : IMSM_T_STATE_NORMAL;
c2a1e7da
DW		 4649
4650 switch (get_imsm_raid_level(map)) {
4651 case 0:
4652 return IMSM_T_STATE_FAILED;
4653 break;
4654 case 1:
4655 if (failed < map->num_members)
4656 return IMSM_T_STATE_DEGRADED;
4657 else
4658 return IMSM_T_STATE_FAILED;
4659 break;
4660 case 10:
4661 {
4662 /**
c92a2527
DW		 4663 * check to see if any mirrors have failed, otherwise we
4664 * are degraded. Even numbered slots are mirrored on
4665 * slot+1
c2a1e7da 4666 */
c2a1e7da 4667 int i;
d9b420a5
N		 4668 /* gcc -Os complains that this is unused */
4669 int insync = insync;
c2a1e7da
DW		 4670
4671 for (i = 0; i < map->num_members; i++) {
98130f40 4672 __u32 ord = get_imsm_ord_tbl_ent(dev, i, -1);
c92a2527
DW		 4673 int idx = ord_to_idx(ord);
4674 struct imsm_disk *disk;
c2a1e7da 4675
c92a2527
DW		 4676 /* reset the potential in-sync count on even-numbered
4677 * slots. num_copies is always 2 for imsm raid10
4678 */
4679 if ((i & 1) == 0)
4680 insync = 2;
c2a1e7da 4681
c92a2527 4682 disk = get_imsm_disk(super, idx);
25ed7e59 4683 if (!disk || is_failed(disk) || ord & IMSM_ORD_REBUILD)
c92a2527 4684 insync--;
c2a1e7da 4685
c92a2527
DW		 4686 /* no in-sync disks left in this mirror the
4687 * array has failed
4688 */
4689 if (insync == 0)
4690 return IMSM_T_STATE_FAILED;
c2a1e7da
DW		 4691 }
4692
4693 return IMSM_T_STATE_DEGRADED;
4694 }
4695 case 5:
4696 if (failed < 2)
4697 return IMSM_T_STATE_DEGRADED;
4698 else
4699 return IMSM_T_STATE_FAILED;
4700 break;
4701 default:
4702 break;
4703 }
4704
4705 return map->map_state;
4706}
4707
ff077194 4708static int imsm_count_failed(struct intel_super *super, struct imsm_dev *dev)
c2a1e7da
DW		 4709{
4710 int i;
4711 int failed = 0;
4712 struct imsm_disk *disk;
ff077194 4713 struct imsm_map *map = get_imsm_map(dev, 0);
0556e1a2
DW		 4714 struct imsm_map *prev = get_imsm_map(dev, dev->vol.migr_state);
4715 __u32 ord;
4716 int idx;
c2a1e7da 4717
0556e1a2
DW		 4718 /* at the beginning of migration we set IMSM_ORD_REBUILD on
4719 * disks that are being rebuilt. New failures are recorded to
4720 * map[0]. So we look through all the disks we started with and
4721 * see if any failures are still present, or if any new ones
4722 * have arrived
4723 *
4724 * FIXME add support for online capacity expansion and
4725 * raid-level-migration
4726 */
4727 for (i = 0; i < prev->num_members; i++) {
4728 ord = __le32_to_cpu(prev->disk_ord_tbl[i]);
4729 ord |= __le32_to_cpu(map->disk_ord_tbl[i]);
4730 idx = ord_to_idx(ord);
c2a1e7da 4731
949c47a0 4732 disk = get_imsm_disk(super, idx);
25ed7e59 4733 if (!disk || is_failed(disk) || ord & IMSM_ORD_REBUILD)
fcb84475 4734 failed++;
c2a1e7da
DW		 4735 }
4736
4737 return failed;
845dea95
NB		 4738}
4739
97b4d0e9
DW		 4740#ifndef MDASSEMBLE
4741static int imsm_open_new(struct supertype *c, struct active_array *a,
4742 char *inst)
4743{
4744 struct intel_super *super = c->sb;
4745 struct imsm_super *mpb = super->anchor;
4746
4747 if (atoi(inst) >= mpb->num_raid_devs) {
4748 fprintf(stderr, "%s: subarry index %d, out of range\n",
4749 __func__, atoi(inst));
4750 return -ENODEV;
4751 }
4752
4753 dprintf("imsm: open_new %s\n", inst);
4754 a->info.container_member = atoi(inst);
4755 return 0;
4756}
4757
0c046afd
DW		 4758static int is_resyncing(struct imsm_dev *dev)
4759{
4760 struct imsm_map *migr_map;
4761
4762 if (!dev->vol.migr_state)
4763 return 0;
4764
1484e727
DW		 4765 if (migr_type(dev) == MIGR_INIT ||
4766 migr_type(dev) == MIGR_REPAIR)
0c046afd
DW		 4767 return 1;
4768
4c9bc37b
AK		 4769 if (migr_type(dev) == MIGR_GEN_MIGR)
4770 return 0;
4771
0c046afd
DW		 4772 migr_map = get_imsm_map(dev, 1);
4773
4c9bc37b
AK		 4774 if ((migr_map->map_state == IMSM_T_STATE_NORMAL) &&
4775 (dev->vol.migr_type != MIGR_GEN_MIGR))
0c046afd
DW		 4776 return 1;
4777 else
4778 return 0;
4779}
4780
0556e1a2
DW		 4781/* return true if we recorded new information */
4782static int mark_failure(struct imsm_dev *dev, struct imsm_disk *disk, int idx)
47ee5a45 4783{
0556e1a2
DW		 4784 __u32 ord;
4785 int slot;
4786 struct imsm_map *map;
4787
4788 /* new failures are always set in map[0] */
4789 map = get_imsm_map(dev, 0);
4790
4791 slot = get_imsm_disk_slot(map, idx);
4792 if (slot < 0)
4793 return 0;
4794
4795 ord = __le32_to_cpu(map->disk_ord_tbl[slot]);
25ed7e59 4796 if (is_failed(disk) && (ord & IMSM_ORD_REBUILD))
0556e1a2
DW		 4797 return 0;
4798
f2f27e63 4799 disk->status |= FAILED_DISK;
cf53434e 4800 disk->status &= ~CONFIGURED_DISK;
0556e1a2 4801 set_imsm_ord_tbl_ent(map, slot, idx | IMSM_ORD_REBUILD);
f21e18ca 4802 if (map->failed_disk_num == 0xff)
0556e1a2
DW		 4803 map->failed_disk_num = slot;
4804 return 1;
4805}
4806
4807static void mark_missing(struct imsm_dev *dev, struct imsm_disk *disk, int idx)
4808{
4809 mark_failure(dev, disk, idx);
4810
4811 if (disk->scsi_id == __cpu_to_le32(~(__u32)0))
4812 return;
4813
47ee5a45
DW		 4814 disk->scsi_id = __cpu_to_le32(~(__u32)0);
4815 memmove(&disk->serial[0], &disk->serial[1], MAX_RAID_SERIAL_LEN - 1);
4816}
4817
33414a01
DW		 4818static void handle_missing(struct intel_super *super, struct imsm_dev *dev)
4819{
4820 __u8 map_state;
4821 struct dl *dl;
4822 int failed;
4823
4824 if (!super->missing)
4825 return;
4826 failed = imsm_count_failed(super, dev);
4827 map_state = imsm_check_degraded(super, dev, failed);
4828
4829 dprintf("imsm: mark missing\n");
4830 end_migration(dev, map_state);
4831 for (dl = super->missing; dl; dl = dl->next)
4832 mark_missing(dev, &dl->disk, dl->index);
4833 super->updates_pending++;
4834}
4835
28bce06f
AK		 4836static void imsm_set_disk(struct active_array *a, int n, int state);
4837
aad6f216 4838/* Handle dirty -> clean transititions, resync and reshape. Degraded and rebuild
0c046afd
DW		 4839 * states are handled in imsm_set_disk() with one exception, when a
4840 * resync is stopped due to a new failure this routine will set the
4841 * 'degraded' state for the array.
4842 */
01f157d7 4843static int imsm_set_array_state(struct active_array *a, int consistent)
a862209d
DW		 4844{
4845 int inst = a->info.container_member;
4846 struct intel_super *super = a->container->sb;
949c47a0 4847 struct imsm_dev *dev = get_imsm_dev(super, inst);
a965f303 4848 struct imsm_map *map = get_imsm_map(dev, 0);
0c046afd
DW		 4849 int failed = imsm_count_failed(super, dev);
4850 __u8 map_state = imsm_check_degraded(super, dev, failed);
1e5c6983 4851 __u32 blocks_per_unit;
a862209d 4852
1af97990
AK		 4853 if (dev->vol.migr_state &&
4854 dev->vol.migr_type == MIGR_GEN_MIGR) {
4855 /* array state change is blocked due to reshape action
aad6f216
N		 4856 * We might need to
4857 * - abort the reshape (if last_checkpoint is 0 and action!= reshape)
4858 * - finish the reshape (if last_checkpoint is big and action != reshape)
4859 * - update curr_migr_unit
1af97990 4860 */
aad6f216
N		 4861 if (a->curr_action == reshape) {
4862 /* still reshaping, maybe update curr_migr_unit */
4863 long long blocks_per_unit = blocks_per_migr_unit(dev);
4864 long long unit = a->last_checkpoint;
4865 unit /= blocks_per_unit;
4866 if (unit > __le32_to_cpu(dev->vol.curr_migr_unit)) {
4867 dev->vol.curr_migr_unit = __cpu_to_le32(unit);
4868 super->updates_pending++;
4869 }
4870 } else {
4871 if (a->last_checkpoint == 0 && a->prev_action == reshape) {
4872 /* for some reason we aborted the reshape.
4873 * Better clean up
4874 */
4875 struct imsm_map *map2 = get_imsm_map(dev, 1);
4876 dev->vol.migr_state = 0;
4877 dev->vol.migr_type = 0;
4878 dev->vol.curr_migr_unit = 0;
4879 memcpy(map, map2, sizeof_imsm_map(map2));
4880 super->updates_pending++;
4881 }
4882 if (a->last_checkpoint >= a->info.component_size) {
4883 unsigned long long array_blocks;
4884 int used_disks;
4885 /* it seems the reshape is all done */
4886 dev->vol.migr_state = 0;
4887 dev->vol.migr_type = 0;
4888 dev->vol.curr_migr_unit = 0;
4889
98130f40 4890 used_disks = imsm_num_data_members(dev, -1);
aad6f216
N		 4891 array_blocks = map->blocks_per_member * used_disks;
4892 /* round array size down to closest MB */
4893 array_blocks = (array_blocks >> SECT_PER_MB_SHIFT)
4894 << SECT_PER_MB_SHIFT;
4895 dev->size_low = __cpu_to_le32((__u32) array_blocks);
4896 dev->size_high = __cpu_to_le32((__u32) (array_blocks >> 32));
4897 a->info.custom_array_size = array_blocks;
4898 a->check_reshape = 1; /* encourage manager to update
4899 * array size
4900 */
4901 super->updates_pending++;
4902 }
4903 }
4904 return 0;
1af97990
AK		 4905 }
4906
47ee5a45 4907 /* before we activate this array handle any missing disks */
33414a01
DW		 4908 if (consistent == 2)
4909 handle_missing(super, dev);
1e5c6983 4910
0c046afd 4911 if (consistent == 2 &&
b7941fd6 4912 (!is_resync_complete(&a->info) ||
0c046afd
DW		 4913 map_state != IMSM_T_STATE_NORMAL ||
4914 dev->vol.migr_state))
01f157d7 4915 consistent = 0;
272906ef 4916
b7941fd6 4917 if (is_resync_complete(&a->info)) {
0c046afd 4918 /* complete intialization / resync,
0556e1a2
DW		 4919 * recovery and interrupted recovery is completed in
4920 * ->set_disk
0c046afd
DW		 4921 */
4922 if (is_resyncing(dev)) {
4923 dprintf("imsm: mark resync done\n");
f8f603f1 4924 end_migration(dev, map_state);
115c3803 4925 super->updates_pending++;
484240d8 4926 a->last_checkpoint = 0;
115c3803 4927 }
0c046afd
DW		 4928 } else if (!is_resyncing(dev) && !failed) {
4929 /* mark the start of the init process if nothing is failed */
b7941fd6 4930 dprintf("imsm: mark resync start\n");
1484e727 4931 if (map->map_state == IMSM_T_STATE_UNINITIALIZED)
e3bba0e0 4932 migrate(dev, IMSM_T_STATE_NORMAL, MIGR_INIT);
1484e727
DW		 4933 else
4934 migrate(dev, IMSM_T_STATE_NORMAL, MIGR_REPAIR);
3393c6af 4935 super->updates_pending++;
115c3803 4936 }
a862209d 4937
1e5c6983
DW		 4938 /* check if we can update curr_migr_unit from resync_start, recovery_start */
4939 blocks_per_unit = blocks_per_migr_unit(dev);
4f0a7acc 4940 if (blocks_per_unit) {
1e5c6983
DW		 4941 __u32 units32;
4942 __u64 units;
4943
4f0a7acc 4944 units = a->last_checkpoint / blocks_per_unit;
1e5c6983
DW		 4945 units32 = units;
4946
4947 /* check that we did not overflow 32-bits, and that
4948 * curr_migr_unit needs updating
4949 */
4950 if (units32 == units &&
4951 __le32_to_cpu(dev->vol.curr_migr_unit) != units32) {
4952 dprintf("imsm: mark checkpoint (%u)\n", units32);
4953 dev->vol.curr_migr_unit = __cpu_to_le32(units32);
4954 super->updates_pending++;
4955 }
4956 }
f8f603f1 4957
3393c6af 4958 /* mark dirty / clean */
0c046afd 4959 if (dev->vol.dirty != !consistent) {
b7941fd6 4960 dprintf("imsm: mark '%s'\n", consistent ? "clean" : "dirty");
0c046afd
DW		 4961 if (consistent)
4962 dev->vol.dirty = 0;
4963 else
4964 dev->vol.dirty = 1;
a862209d
DW		 4965 super->updates_pending++;
4966 }
28bce06f
AK		 4967
4968 /* finalize online capacity expansion/reshape */
4969 if ((a->curr_action != reshape) &&
4970 (a->prev_action == reshape)) {
4971 struct mdinfo *mdi;
4972
4973 for (mdi = a->info.devs; mdi; mdi = mdi->next)
4974 imsm_set_disk(a, mdi->disk.raid_disk, mdi->curr_state);
4975 }
4976
01f157d7 4977 return consistent;
a862209d
DW		 4978}
4979
8d45d196 4980static void imsm_set_disk(struct active_array *a, int n, int state)
845dea95 4981{
8d45d196
DW		 4982 int inst = a->info.container_member;
4983 struct intel_super *super = a->container->sb;
949c47a0 4984 struct imsm_dev *dev = get_imsm_dev(super, inst);
a965f303 4985 struct imsm_map *map = get_imsm_map(dev, 0);
8d45d196 4986 struct imsm_disk *disk;
0c046afd 4987 int failed;
b10b37b8 4988 __u32 ord;
0c046afd 4989 __u8 map_state;
8d45d196
DW		 4990
4991 if (n > map->num_members)
4992 fprintf(stderr, "imsm: set_disk %d out of range 0..%d\n",
4993 n, map->num_members - 1);
4994
4995 if (n < 0)
4996 return;
4997
4e6e574a 4998 dprintf("imsm: set_disk %d:%x\n", n, state);
8d45d196 4999
98130f40 5000 ord = get_imsm_ord_tbl_ent(dev, n, -1);
b10b37b8 5001 disk = get_imsm_disk(super, ord_to_idx(ord));
8d45d196 5002
5802a811 5003 /* check for new failures */
0556e1a2
DW		 5004 if (state & DS_FAULTY) {
5005 if (mark_failure(dev, disk, ord_to_idx(ord)))
5006 super->updates_pending++;
8d45d196 5007 }
47ee5a45 5008
19859edc 5009 /* check if in_sync */
0556e1a2 5010 if (state & DS_INSYNC && ord & IMSM_ORD_REBUILD && is_rebuilding(dev)) {
b10b37b8
DW		 5011 struct imsm_map *migr_map = get_imsm_map(dev, 1);
5012
5013 set_imsm_ord_tbl_ent(migr_map, n, ord_to_idx(ord));
19859edc
DW		 5014 super->updates_pending++;
5015 }
8d45d196 5016
0c046afd
DW		 5017 failed = imsm_count_failed(super, dev);
5018 map_state = imsm_check_degraded(super, dev, failed);
5802a811 5019
0c046afd
DW		 5020 /* check if recovery complete, newly degraded, or failed */
5021 if (map_state == IMSM_T_STATE_NORMAL && is_rebuilding(dev)) {
f8f603f1 5022 end_migration(dev, map_state);
0556e1a2
DW		 5023 map = get_imsm_map(dev, 0);
5024 map->failed_disk_num = ~0;
0c046afd 5025 super->updates_pending++;
484240d8 5026 a->last_checkpoint = 0;
0c046afd
DW		 5027 } else if (map_state == IMSM_T_STATE_DEGRADED &&
5028 map->map_state != map_state &&
5029 !dev->vol.migr_state) {
5030 dprintf("imsm: mark degraded\n");
5031 map->map_state = map_state;
5032 super->updates_pending++;
484240d8 5033 a->last_checkpoint = 0;
0c046afd
DW		 5034 } else if (map_state == IMSM_T_STATE_FAILED &&
5035 map->map_state != map_state) {
5036 dprintf("imsm: mark failed\n");
f8f603f1 5037 end_migration(dev, map_state);
0c046afd 5038 super->updates_pending++;
484240d8 5039 a->last_checkpoint = 0;
28bce06f
AK		 5040 } else if (is_gen_migration(dev)) {
5041 dprintf("imsm: Detected General Migration in state: ");
5042 if (map_state == IMSM_T_STATE_NORMAL) {
5043 end_migration(dev, map_state);
5044 map = get_imsm_map(dev, 0);
5045 map->failed_disk_num = ~0;
5046 dprintf("normal\n");
5047 } else {
5048 if (map_state == IMSM_T_STATE_DEGRADED) {
5049 printf("degraded\n");
5050 end_migration(dev, map_state);
5051 } else {
5052 dprintf("failed\n");
5053 }
5054 map->map_state = map_state;
5055 }
5056 super->updates_pending++;
5802a811 5057 }
845dea95
NB		 5058}
5059
f796af5d 5060static int store_imsm_mpb(int fd, struct imsm_super *mpb)
c2a1e7da 5061{
f796af5d 5062 void *buf = mpb;
c2a1e7da
DW		 5063 __u32 mpb_size = __le32_to_cpu(mpb->mpb_size);
5064 unsigned long long dsize;
5065 unsigned long long sectors;
5066
5067 get_dev_size(fd, NULL, &dsize);
5068
272f648f
DW		 5069 if (mpb_size > 512) {
5070 /* -1 to account for anchor */
5071 sectors = mpb_sectors(mpb) - 1;
c2a1e7da 5072
272f648f
DW		 5073 /* write the extended mpb to the sectors preceeding the anchor */
5074 if (lseek64(fd, dsize - (512 * (2 + sectors)), SEEK_SET) < 0)
5075 return 1;
c2a1e7da 5076
f21e18ca
N		 5077 if ((unsigned long long)write(fd, buf + 512, 512 * sectors)
5078 != 512 * sectors)
272f648f
DW		 5079 return 1;
5080 }
c2a1e7da 5081
272f648f
DW		 5082 /* first block is stored on second to last sector of the disk */
5083 if (lseek64(fd, dsize - (512 * 2), SEEK_SET) < 0)
c2a1e7da
DW		 5084 return 1;
5085
f796af5d 5086 if (write(fd, buf, 512) != 512)
c2a1e7da
DW		 5087 return 1;
5088
c2a1e7da
DW		 5089 return 0;
5090}
5091
2e735d19 5092static void imsm_sync_metadata(struct supertype *container)
845dea95 5093{
2e735d19 5094 struct intel_super *super = container->sb;
c2a1e7da 5095
1a64be56 5096 dprintf("sync metadata: %d\n", super->updates_pending);
c2a1e7da
DW		 5097 if (!super->updates_pending)
5098 return;
5099
36988a3d 5100 write_super_imsm(container, 0);
c2a1e7da
DW		 5101
5102 super->updates_pending = 0;
845dea95
NB		 5103}
5104
272906ef
DW		 5105static struct dl *imsm_readd(struct intel_super *super, int idx, struct active_array *a)
5106{
5107 struct imsm_dev *dev = get_imsm_dev(super, a->info.container_member);
98130f40 5108 int i = get_imsm_disk_idx(dev, idx, -1);
272906ef
DW		 5109 struct dl *dl;
5110
5111 for (dl = super->disks; dl; dl = dl->next)
5112 if (dl->index == i)
5113 break;
5114
25ed7e59 5115 if (dl && is_failed(&dl->disk))
272906ef
DW		 5116 dl = NULL;
5117
5118 if (dl)
5119 dprintf("%s: found %x:%x\n", __func__, dl->major, dl->minor);
5120
5121 return dl;
5122}
5123
a20d2ba5 5124static struct dl *imsm_add_spare(struct intel_super *super, int slot,
8ba77d32
AK		 5125 struct active_array *a, int activate_new,
5126 struct mdinfo *additional_test_list)
272906ef
DW		 5127{
5128 struct imsm_dev *dev = get_imsm_dev(super, a->info.container_member);
98130f40 5129 int idx = get_imsm_disk_idx(dev, slot, -1);
a20d2ba5
DW		 5130 struct imsm_super *mpb = super->anchor;
5131 struct imsm_map *map;
272906ef
DW		 5132 unsigned long long pos;
5133 struct mdinfo *d;
5134 struct extent *ex;
a20d2ba5 5135 int i, j;
272906ef 5136 int found;
569cc43f
DW		 5137 __u32 array_start = 0;
5138 __u32 array_end = 0;
272906ef 5139 struct dl *dl;
6c932028 5140 struct mdinfo *test_list;
272906ef
DW		 5141
5142 for (dl = super->disks; dl; dl = dl->next) {
5143 /* If in this array, skip */
5144 for (d = a->info.devs ; d ; d = d->next)
e553d2a4
DW		 5145 if (d->state_fd >= 0 &&
5146 d->disk.major == dl->major &&
272906ef 5147 d->disk.minor == dl->minor) {
8ba77d32
AK		 5148 dprintf("%x:%x already in array\n",
5149 dl->major, dl->minor);
272906ef
DW		 5150 break;
5151 }
5152 if (d)
5153 continue;
6c932028
AK		 5154 test_list = additional_test_list;
5155 while (test_list) {
5156 if (test_list->disk.major == dl->major &&
5157 test_list->disk.minor == dl->minor) {
8ba77d32
AK		 5158 dprintf("%x:%x already in additional test list\n",
5159 dl->major, dl->minor);
5160 break;
5161 }
6c932028 5162 test_list = test_list->next;
8ba77d32 5163 }
6c932028 5164 if (test_list)
8ba77d32 5165 continue;
272906ef 5166
e553d2a4 5167 /* skip in use or failed drives */
25ed7e59 5168 if (is_failed(&dl->disk) || idx == dl->index ||
df474657
DW		 5169 dl->index == -2) {
5170 dprintf("%x:%x status (failed: %d index: %d)\n",
25ed7e59 5171 dl->major, dl->minor, is_failed(&dl->disk), idx);
9a1608e5
DW		 5172 continue;
5173 }
5174
a20d2ba5
DW		 5175 /* skip pure spares when we are looking for partially
5176 * assimilated drives
5177 */
5178 if (dl->index == -1 && !activate_new)
5179 continue;
5180
272906ef 5181 /* Does this unused device have the requisite free space?
a20d2ba5 5182 * It needs to be able to cover all member volumes
272906ef
DW		 5183 */
5184 ex = get_extents(super, dl);
5185 if (!ex) {
5186 dprintf("cannot get extents\n");
5187 continue;
5188 }
a20d2ba5
DW		 5189 for (i = 0; i < mpb->num_raid_devs; i++) {
5190 dev = get_imsm_dev(super, i);
5191 map = get_imsm_map(dev, 0);
272906ef 5192
a20d2ba5
DW		 5193 /* check if this disk is already a member of
5194 * this array
272906ef 5195 */
620b1713 5196 if (get_imsm_disk_slot(map, dl->index) >= 0)
a20d2ba5
DW		 5197 continue;
5198
5199 found = 0;
5200 j = 0;
5201 pos = 0;
5202 array_start = __le32_to_cpu(map->pba_of_lba0);
329c8278
DW		 5203 array_end = array_start +
5204 __le32_to_cpu(map->blocks_per_member) - 1;
a20d2ba5
DW		 5205
5206 do {
5207 /* check that we can start at pba_of_lba0 with
5208 * blocks_per_member of space
5209 */
329c8278 5210 if (array_start >= pos && array_end < ex[j].start) {
a20d2ba5
DW		 5211 found = 1;
5212 break;
5213 }
5214 pos = ex[j].start + ex[j].size;
5215 j++;
5216 } while (ex[j-1].size);
5217
5218 if (!found)
272906ef 5219 break;
a20d2ba5 5220 }
272906ef
DW		 5221
5222 free(ex);
a20d2ba5 5223 if (i < mpb->num_raid_devs) {
329c8278
DW		 5224 dprintf("%x:%x does not have %u to %u available\n",
5225 dl->major, dl->minor, array_start, array_end);
272906ef
DW		 5226 /* No room */
5227 continue;
a20d2ba5
DW		 5228 }
5229 return dl;
272906ef
DW		 5230 }
5231
5232 return dl;
5233}
5234
95d07a2c
LM		 5235
5236static int imsm_rebuild_allowed(struct supertype *cont, int dev_idx, int failed)
5237{
5238 struct imsm_dev *dev2;
5239 struct imsm_map *map;
5240 struct dl *idisk;
5241 int slot;
5242 int idx;
5243 __u8 state;
5244
5245 dev2 = get_imsm_dev(cont->sb, dev_idx);
5246 if (dev2) {
5247 state = imsm_check_degraded(cont->sb, dev2, failed);
5248 if (state == IMSM_T_STATE_FAILED) {
5249 map = get_imsm_map(dev2, 0);
5250 if (!map)
5251 return 1;
5252 for (slot = 0; slot < map->num_members; slot++) {
5253 /*
5254 * Check if failed disks are deleted from intel
5255 * disk list or are marked to be deleted
5256 */
98130f40 5257 idx = get_imsm_disk_idx(dev2, slot, -1);
95d07a2c
LM		 5258 idisk = get_imsm_dl_disk(cont->sb, idx);
5259 /*
5260 * Do not rebuild the array if failed disks
5261 * from failed sub-array are not removed from
5262 * container.
5263 */
5264 if (idisk &&
5265 is_failed(&idisk->disk) &&
5266 (idisk->action != DISK_REMOVE))
5267 return 0;
5268 }
5269 }
5270 }
5271 return 1;
5272}
5273
88758e9d
DW		 5274static struct mdinfo *imsm_activate_spare(struct active_array *a,
5275 struct metadata_update **updates)
5276{
5277 /**
d23fe947
DW		 5278 * Find a device with unused free space and use it to replace a
5279 * failed/vacant region in an array. We replace failed regions one a
5280 * array at a time. The result is that a new spare disk will be added
5281 * to the first failed array and after the monitor has finished
5282 * propagating failures the remainder will be consumed.
88758e9d 5283 *
d23fe947
DW		 5284 * FIXME add a capability for mdmon to request spares from another
5285 * container.
88758e9d
DW		 5286 */
5287
5288 struct intel_super *super = a->container->sb;
88758e9d 5289 int inst = a->info.container_member;
949c47a0 5290 struct imsm_dev *dev = get_imsm_dev(super, inst);
a965f303 5291 struct imsm_map *map = get_imsm_map(dev, 0);
88758e9d
DW		 5292 int failed = a->info.array.raid_disks;
5293 struct mdinfo *rv = NULL;
5294 struct mdinfo *d;
5295 struct mdinfo *di;
5296 struct metadata_update *mu;
5297 struct dl *dl;
5298 struct imsm_update_activate_spare *u;
5299 int num_spares = 0;
5300 int i;
95d07a2c 5301 int allowed;
88758e9d
DW		 5302
5303 for (d = a->info.devs ; d ; d = d->next) {
5304 if ((d->curr_state & DS_FAULTY) &&
5305 d->state_fd >= 0)
5306 /* wait for Removal to happen */
5307 return NULL;
5308 if (d->state_fd >= 0)
5309 failed--;
5310 }
5311
5312 dprintf("imsm: activate spare: inst=%d failed=%d (%d) level=%d\n",
5313 inst, failed, a->info.array.raid_disks, a->info.array.level);
1af97990
AK		 5314
5315 if (dev->vol.migr_state &&
5316 dev->vol.migr_type == MIGR_GEN_MIGR)
5317 /* No repair during migration */
5318 return NULL;
5319
fb49eef2 5320 if (imsm_check_degraded(super, dev, failed) != IMSM_T_STATE_DEGRADED)
88758e9d
DW		 5321 return NULL;
5322
95d07a2c
LM		 5323 /*
5324 * If there are any failed disks check state of the other volume.
5325 * Block rebuild if the another one is failed until failed disks
5326 * are removed from container.
5327 */
5328 if (failed) {
5329 dprintf("found failed disks in %s, check if there another"
5330 "failed sub-array.\n",
5331 dev->volume);
5332 /* check if states of the other volumes allow for rebuild */
5333 for (i = 0; i < super->anchor->num_raid_devs; i++) {
5334 if (i != inst) {
5335 allowed = imsm_rebuild_allowed(a->container,
5336 i, failed);
5337 if (!allowed)
5338 return NULL;
5339 }
5340 }
5341 }
5342
88758e9d 5343 /* For each slot, if it is not working, find a spare */
88758e9d
DW		 5344 for (i = 0; i < a->info.array.raid_disks; i++) {
5345 for (d = a->info.devs ; d ; d = d->next)
5346 if (d->disk.raid_disk == i)
5347 break;
5348 dprintf("found %d: %p %x\n", i, d, d?d->curr_state:0);
5349 if (d && (d->state_fd >= 0))
5350 continue;
5351
272906ef 5352 /*
a20d2ba5
DW		 5353 * OK, this device needs recovery. Try to re-add the
5354 * previous occupant of this slot, if this fails see if
5355 * we can continue the assimilation of a spare that was
5356 * partially assimilated, finally try to activate a new
5357 * spare.
272906ef
DW		 5358 */
5359 dl = imsm_readd(super, i, a);
5360 if (!dl)
8ba77d32 5361 dl = imsm_add_spare(super, i, a, 0, NULL);
a20d2ba5 5362 if (!dl)
8ba77d32 5363 dl = imsm_add_spare(super, i, a, 1, NULL);
272906ef
DW		 5364 if (!dl)
5365 continue;
5366
5367 /* found a usable disk with enough space */
5368 di = malloc(sizeof(*di));
79244939
DW		 5369 if (!di)
5370 continue;
272906ef
DW		 5371 memset(di, 0, sizeof(*di));
5372
5373 /* dl->index will be -1 in the case we are activating a
5374 * pristine spare. imsm_process_update() will create a
5375 * new index in this case. Once a disk is found to be
5376 * failed in all member arrays it is kicked from the
5377 * metadata
5378 */
5379 di->disk.number = dl->index;
d23fe947 5380
272906ef
DW		 5381 /* (ab)use di->devs to store a pointer to the device
5382 * we chose
5383 */
5384 di->devs = (struct mdinfo *) dl;
5385
5386 di->disk.raid_disk = i;
5387 di->disk.major = dl->major;
5388 di->disk.minor = dl->minor;
5389 di->disk.state = 0;
d23534e4 5390 di->recovery_start = 0;
272906ef
DW		 5391 di->data_offset = __le32_to_cpu(map->pba_of_lba0);
5392 di->component_size = a->info.component_size;
5393 di->container_member = inst;
148acb7b 5394 super->random = random32();
272906ef
DW		 5395 di->next = rv;
5396 rv = di;
5397 num_spares++;
5398 dprintf("%x:%x to be %d at %llu\n", dl->major, dl->minor,
5399 i, di->data_offset);
88758e9d 5400
272906ef 5401 break;
88758e9d
DW		 5402 }
5403
5404 if (!rv)
5405 /* No spares found */
5406 return rv;
5407 /* Now 'rv' has a list of devices to return.
5408 * Create a metadata_update record to update the
5409 * disk_ord_tbl for the array
5410 */
5411 mu = malloc(sizeof(*mu));
79244939
DW		 5412 if (mu) {
5413 mu->buf = malloc(sizeof(struct imsm_update_activate_spare) * num_spares);
5414 if (mu->buf == NULL) {
5415 free(mu);
5416 mu = NULL;
5417 }
5418 }
5419 if (!mu) {
5420 while (rv) {
5421 struct mdinfo *n = rv->next;
5422
5423 free(rv);
5424 rv = n;
5425 }
5426 return NULL;
5427 }
5428
88758e9d 5429 mu->space = NULL;
cb23f1f4 5430 mu->space_list = NULL;
88758e9d
DW		 5431 mu->len = sizeof(struct imsm_update_activate_spare) * num_spares;
5432 mu->next = *updates;
5433 u = (struct imsm_update_activate_spare *) mu->buf;
5434
5435 for (di = rv ; di ; di = di->next) {
5436 u->type = update_activate_spare;
d23fe947
DW		 5437 u->dl = (struct dl *) di->devs;
5438 di->devs = NULL;
88758e9d
DW		 5439 u->slot = di->disk.raid_disk;
5440 u->array = inst;
5441 u->next = u + 1;
5442 u++;
5443 }
5444 (u-1)->next = NULL;
5445 *updates = mu;
5446
5447 return rv;
5448}
5449
54c2c1ea 5450static int disks_overlap(struct intel_super *super, int idx, struct imsm_update_create_array *u)
8273f55e 5451{
54c2c1ea
DW		 5452 struct imsm_dev *dev = get_imsm_dev(super, idx);
5453 struct imsm_map *map = get_imsm_map(dev, 0);
5454 struct imsm_map *new_map = get_imsm_map(&u->dev, 0);
5455 struct disk_info *inf = get_disk_info(u);
5456 struct imsm_disk *disk;
8273f55e
DW		 5457 int i;
5458 int j;
8273f55e 5459
54c2c1ea 5460 for (i = 0; i < map->num_members; i++) {
98130f40 5461 disk = get_imsm_disk(super, get_imsm_disk_idx(dev, i, -1));
54c2c1ea
DW		 5462 for (j = 0; j < new_map->num_members; j++)
5463 if (serialcmp(disk->serial, inf[j].serial) == 0)
8273f55e
DW		 5464 return 1;
5465 }
5466
5467 return 0;
5468}
5469
1a64be56
LM		 5470
5471static struct dl *get_disk_super(struct intel_super *super, int major, int minor)
5472{
5473 struct dl *dl = NULL;
5474 for (dl = super->disks; dl; dl = dl->next)
5475 if ((dl->major == major) && (dl->minor == minor))
5476 return dl;
5477 return NULL;
5478}
5479
5480static int remove_disk_super(struct intel_super *super, int major, int minor)
5481{
5482 struct dl *prev = NULL;
5483 struct dl *dl;
5484
5485 prev = NULL;
5486 for (dl = super->disks; dl; dl = dl->next) {
5487 if ((dl->major == major) && (dl->minor == minor)) {
5488 /* remove */
5489 if (prev)
5490 prev->next = dl->next;
5491 else
5492 super->disks = dl->next;
5493 dl->next = NULL;
5494 __free_imsm_disk(dl);
5495 dprintf("%s: removed %x:%x\n",
5496 __func__, major, minor);
5497 break;
5498 }
5499 prev = dl;
5500 }
5501 return 0;
5502}
5503
f21e18ca 5504static void imsm_delete(struct intel_super *super, struct dl **dlp, unsigned index);
ae6aad82 5505
1a64be56
LM		 5506static int add_remove_disk_update(struct intel_super *super)
5507{
5508 int check_degraded = 0;
5509 struct dl *disk = NULL;
5510 /* add/remove some spares to/from the metadata/contrainer */
5511 while (super->disk_mgmt_list) {
5512 struct dl *disk_cfg;
5513
5514 disk_cfg = super->disk_mgmt_list;
5515 super->disk_mgmt_list = disk_cfg->next;
5516 disk_cfg->next = NULL;
5517
5518 if (disk_cfg->action == DISK_ADD) {
5519 disk_cfg->next = super->disks;
5520 super->disks = disk_cfg;
5521 check_degraded = 1;
5522 dprintf("%s: added %x:%x\n",
5523 __func__, disk_cfg->major,
5524 disk_cfg->minor);
5525 } else if (disk_cfg->action == DISK_REMOVE) {
5526 dprintf("Disk remove action processed: %x.%x\n",
5527 disk_cfg->major, disk_cfg->minor);
5528 disk = get_disk_super(super,
5529 disk_cfg->major,
5530 disk_cfg->minor);
5531 if (disk) {
5532 /* store action status */
5533 disk->action = DISK_REMOVE;
5534 /* remove spare disks only */
5535 if (disk->index == -1) {
5536 remove_disk_super(super,
5537 disk_cfg->major,
5538 disk_cfg->minor);
5539 }
5540 }
5541 /* release allocate disk structure */
5542 __free_imsm_disk(disk_cfg);
5543 }
5544 }
5545 return check_degraded;
5546}
5547
e8319a19
DW		 5548static void imsm_process_update(struct supertype *st,
5549 struct metadata_update *update)
5550{
5551 /**
5552 * crack open the metadata_update envelope to find the update record
5553 * update can be one of:
d195167d
AK		 5554 * update_reshape_container_disks - all the arrays in the container
5555 * are being reshaped to have more devices. We need to mark
5556 * the arrays for general migration and convert selected spares
5557 * into active devices.
5558 * update_activate_spare - a spare device has replaced a failed
e8319a19
DW		 5559 * device in an array, update the disk_ord_tbl. If this disk is
5560 * present in all member arrays then also clear the SPARE_DISK
5561 * flag
d195167d
AK		 5562 * update_create_array
5563 * update_kill_array
5564 * update_rename_array
5565 * update_add_remove_disk
e8319a19
DW		 5566 */
5567 struct intel_super *super = st->sb;
4d7b1503 5568 struct imsm_super *mpb;
e8319a19
DW		 5569 enum imsm_update_type type = *(enum imsm_update_type *) update->buf;
5570
4d7b1503
DW		 5571 /* update requires a larger buf but the allocation failed */
5572 if (super->next_len && !super->next_buf) {
5573 super->next_len = 0;
5574 return;
5575 }
5576
5577 if (super->next_buf) {
5578 memcpy(super->next_buf, super->buf, super->len);
5579 free(super->buf);
5580 super->len = super->next_len;
5581 super->buf = super->next_buf;
5582
5583 super->next_len = 0;
5584 super->next_buf = NULL;
5585 }
5586
5587 mpb = super->anchor;
5588
e8319a19 5589 switch (type) {
78b10e66 5590 case update_reshape_container_disks: {
d195167d
AK		 5591 struct imsm_update_reshape *u = (void *)update->buf;
5592 struct dl *new_disk;
5593 struct intel_dev *id;
5594 int i;
5595 int delta_disks = u->new_raid_disks - u->old_raid_disks;
5596 void **tofree = NULL;
834acc0b 5597 int devices_to_reshape = 1;
d195167d
AK		 5598
5599 dprintf("imsm: imsm_process_update() for update_reshape\n");
5600
5601 /* enable spares to use in array */
5602 for (i = 0; i < delta_disks; i++) {
d195167d
AK		 5603 new_disk = get_disk_super(super,
5604 major(u->new_disks[i]),
5605 minor(u->new_disks[i]));
d677e0b8
AK		 5606 dprintf("imsm: imsm_process_update(): new disk "\
5607 "for reshape is: %i:%i (%p, index = %i)\n",
5608 major(u->new_disks[i]), minor(u->new_disks[i]),
5609 new_disk, new_disk->index);
5610 if ((new_disk == NULL) ||
5611 ((new_disk->index >= 0) &&
5612 (new_disk->index < u->old_raid_disks)))
d195167d
AK		 5613 goto update_reshape_exit;
5614
5615 new_disk->index = mpb->num_disks++;
5616 /* slot to fill in autolayout */
5617 new_disk->raiddisk = new_disk->index;
5618 new_disk->disk.status |=
5619 CONFIGURED_DISK;
5620 new_disk->disk.status &= ~SPARE_DISK;
5621 }
5622
690aae1a 5623 dprintf("imsm: process_update(): update_reshape: volume set"
d195167d 5624 " mpb->num_raid_devs = %i\n", mpb->num_raid_devs);
834acc0b 5625 /* manage changes in volume
d195167d
AK		 5626 */
5627 for (id = super->devlist ; id; id = id->next) {
5628 void **sp = update->space_list;
5629 struct imsm_dev *newdev;
5630 struct imsm_map *newmap, *oldmap;
5631
5632 if (!sp)
5633 continue;
5634 update->space_list = *sp;
5635 newdev = (void*)sp;
5636 /* Copy the dev, but not (all of) the map */
5637 memcpy(newdev, id->dev, sizeof(*newdev));
5638 oldmap = get_imsm_map(id->dev, 0);
5639 newmap = get_imsm_map(newdev, 0);
5640 /* Copy the current map */
5641 memcpy(newmap, oldmap, sizeof_imsm_map(oldmap));
834acc0b
AK		 5642 /* update one device only
5643 */
5644 if (devices_to_reshape) {
5645 dprintf("process_update(): modifying "\
5646 "subdev: %i\n", id->index);
5647 devices_to_reshape--;
5648 newdev->vol.migr_state = 1;
5649 newdev->vol.curr_migr_unit = 0;
5650 newdev->vol.migr_type = MIGR_GEN_MIGR;
5651 newmap->num_members = u->new_raid_disks;
5652 for (i = 0; i < delta_disks; i++) {
5653 set_imsm_ord_tbl_ent(newmap,
5654 u->old_raid_disks + i,
5655 u->old_raid_disks + i);
5656 }
5657 /* New map is correct, now need to save old map
5658 */
5659 newmap = get_imsm_map(newdev, 1);
5660 memcpy(newmap, oldmap, sizeof_imsm_map(oldmap));
d195167d 5661 }
d195167d
AK		 5662
5663 sp = (void **)id->dev;
5664 id->dev = newdev;
5665 *sp = tofree;
5666 tofree = sp;
5667 }
5668
5669 update->space_list = tofree;
5670 super->updates_pending++;
5671update_reshape_exit:
78b10e66
N		 5672 break;
5673 }
e8319a19
DW		 5674 case update_activate_spare: {
5675 struct imsm_update_activate_spare *u = (void *) update->buf;
949c47a0 5676 struct imsm_dev *dev = get_imsm_dev(super, u->array);
a965f303 5677 struct imsm_map *map = get_imsm_map(dev, 0);
0c046afd 5678 struct imsm_map *migr_map;
e8319a19
DW		 5679 struct active_array *a;
5680 struct imsm_disk *disk;
0c046afd 5681 __u8 to_state;
e8319a19 5682 struct dl *dl;
e8319a19 5683 unsigned int found;
0c046afd 5684 int failed;
98130f40 5685 int victim = get_imsm_disk_idx(dev, u->slot, -1);
e8319a19
DW		 5686 int i;
5687
5688 for (dl = super->disks; dl; dl = dl->next)
d23fe947 5689 if (dl == u->dl)
e8319a19
DW		 5690 break;
5691
5692 if (!dl) {
5693 fprintf(stderr, "error: imsm_activate_spare passed "
1f24f035
DW		 5694 "an unknown disk (index: %d)\n",
5695 u->dl->index);
e8319a19
DW		 5696 return;
5697 }
5698
5699 super->updates_pending++;
5700
0c046afd
DW		 5701 /* count failures (excluding rebuilds and the victim)
5702 * to determine map[0] state
5703 */
5704 failed = 0;
5705 for (i = 0; i < map->num_members; i++) {
5706 if (i == u->slot)
5707 continue;
98130f40
AK		 5708 disk = get_imsm_disk(super,
5709 get_imsm_disk_idx(dev, i, -1));
25ed7e59 5710 if (!disk || is_failed(disk))
0c046afd
DW		 5711 failed++;
5712 }
5713
d23fe947
DW		 5714 /* adding a pristine spare, assign a new index */
5715 if (dl->index < 0) {
5716 dl->index = super->anchor->num_disks;
5717 super->anchor->num_disks++;
5718 }
d23fe947 5719 disk = &dl->disk;
f2f27e63
DW		 5720 disk->status |= CONFIGURED_DISK;
5721 disk->status &= ~SPARE_DISK;
e8319a19 5722
0c046afd
DW		 5723 /* mark rebuild */
5724 to_state = imsm_check_degraded(super, dev, failed);
5725 map->map_state = IMSM_T_STATE_DEGRADED;
e3bba0e0 5726 migrate(dev, to_state, MIGR_REBUILD);
0c046afd
DW		 5727 migr_map = get_imsm_map(dev, 1);
5728 set_imsm_ord_tbl_ent(map, u->slot, dl->index);
5729 set_imsm_ord_tbl_ent(migr_map, u->slot, dl->index | IMSM_ORD_REBUILD);
5730
148acb7b
DW		 5731 /* update the family_num to mark a new container
5732 * generation, being careful to record the existing
5733 * family_num in orig_family_num to clean up after
5734 * earlier mdadm versions that neglected to set it.
5735 */
5736 if (mpb->orig_family_num == 0)
5737 mpb->orig_family_num = mpb->family_num;
5738 mpb->family_num += super->random;
5739
e8319a19
DW		 5740 /* count arrays using the victim in the metadata */
5741 found = 0;
5742 for (a = st->arrays; a ; a = a->next) {
949c47a0 5743 dev = get_imsm_dev(super, a->info.container_member);
620b1713
DW		 5744 map = get_imsm_map(dev, 0);
5745
5746 if (get_imsm_disk_slot(map, victim) >= 0)
5747 found++;
e8319a19
DW		 5748 }
5749
24565c9a 5750 /* delete the victim if it is no longer being
e8319a19
DW		 5751 * utilized anywhere
5752 */
e8319a19 5753 if (!found) {
ae6aad82 5754 struct dl **dlp;
24565c9a 5755
47ee5a45
DW		 5756 /* We know that 'manager' isn't touching anything,
5757 * so it is safe to delete
5758 */
24565c9a 5759 for (dlp = &super->disks; *dlp; dlp = &(*dlp)->next)
ae6aad82
DW		 5760 if ((*dlp)->index == victim)
5761 break;
47ee5a45
DW		 5762
5763 /* victim may be on the missing list */
5764 if (!*dlp)
5765 for (dlp = &super->missing; *dlp; dlp = &(*dlp)->next)
5766 if ((*dlp)->index == victim)
5767 break;
24565c9a 5768 imsm_delete(super, dlp, victim);
e8319a19 5769 }
8273f55e
DW		 5770 break;
5771 }
5772 case update_create_array: {
5773 /* someone wants to create a new array, we need to be aware of
5774 * a few races/collisions:
5775 * 1/ 'Create' called by two separate instances of mdadm
5776 * 2/ 'Create' versus 'activate_spare': mdadm has chosen
5777 * devices that have since been assimilated via
5778 * activate_spare.
5779 * In the event this update can not be carried out mdadm will
5780 * (FIX ME) notice that its update did not take hold.
5781 */
5782 struct imsm_update_create_array *u = (void *) update->buf;
ba2de7ba 5783 struct intel_dev *dv;
8273f55e
DW		 5784 struct imsm_dev *dev;
5785 struct imsm_map *map, *new_map;
5786 unsigned long long start, end;
5787 unsigned long long new_start, new_end;
5788 int i;
54c2c1ea
DW		 5789 struct disk_info *inf;
5790 struct dl *dl;
8273f55e
DW		 5791
5792 /* handle racing creates: first come first serve */
5793 if (u->dev_idx < mpb->num_raid_devs) {
5794 dprintf("%s: subarray %d already defined\n",
5795 __func__, u->dev_idx);
ba2de7ba 5796 goto create_error;
8273f55e
DW		 5797 }
5798
5799 /* check update is next in sequence */
5800 if (u->dev_idx != mpb->num_raid_devs) {
6a3e913e
DW		 5801 dprintf("%s: can not create array %d expected index %d\n",
5802 __func__, u->dev_idx, mpb->num_raid_devs);
ba2de7ba 5803 goto create_error;
8273f55e
DW		 5804 }
5805
a965f303 5806 new_map = get_imsm_map(&u->dev, 0);
8273f55e
DW		 5807 new_start = __le32_to_cpu(new_map->pba_of_lba0);
5808 new_end = new_start + __le32_to_cpu(new_map->blocks_per_member);
54c2c1ea 5809 inf = get_disk_info(u);
8273f55e
DW		 5810
5811 /* handle activate_spare versus create race:
5812 * check to make sure that overlapping arrays do not include
5813 * overalpping disks
5814 */
5815 for (i = 0; i < mpb->num_raid_devs; i++) {
949c47a0 5816 dev = get_imsm_dev(super, i);
a965f303 5817 map = get_imsm_map(dev, 0);
8273f55e
DW		 5818 start = __le32_to_cpu(map->pba_of_lba0);
5819 end = start + __le32_to_cpu(map->blocks_per_member);
5820 if ((new_start >= start && new_start <= end) ||
5821 (start >= new_start && start <= new_end))
54c2c1ea
DW		 5822 /* overlap */;
5823 else
5824 continue;
5825
5826 if (disks_overlap(super, i, u)) {
8273f55e 5827 dprintf("%s: arrays overlap\n", __func__);
ba2de7ba 5828 goto create_error;
8273f55e
DW		 5829 }
5830 }
8273f55e 5831
949c47a0
DW		 5832 /* check that prepare update was successful */
5833 if (!update->space) {
5834 dprintf("%s: prepare update failed\n", __func__);
ba2de7ba 5835 goto create_error;
949c47a0
DW		 5836 }
5837
54c2c1ea
DW		 5838 /* check that all disks are still active before committing
5839 * changes. FIXME: could we instead handle this by creating a
5840 * degraded array? That's probably not what the user expects,
5841 * so better to drop this update on the floor.
5842 */
5843 for (i = 0; i < new_map->num_members; i++) {
5844 dl = serial_to_dl(inf[i].serial, super);
5845 if (!dl) {
5846 dprintf("%s: disk disappeared\n", __func__);
ba2de7ba 5847 goto create_error;
54c2c1ea 5848 }
949c47a0
DW		 5849 }
5850
8273f55e 5851 super->updates_pending++;
54c2c1ea
DW		 5852
5853 /* convert spares to members and fixup ord_tbl */
5854 for (i = 0; i < new_map->num_members; i++) {
5855 dl = serial_to_dl(inf[i].serial, super);
5856 if (dl->index == -1) {
5857 dl->index = mpb->num_disks;
5858 mpb->num_disks++;
5859 dl->disk.status |= CONFIGURED_DISK;
5860 dl->disk.status &= ~SPARE_DISK;
5861 }
5862 set_imsm_ord_tbl_ent(new_map, i, dl->index);
5863 }
5864
ba2de7ba
DW		 5865 dv = update->space;
5866 dev = dv->dev;
949c47a0
DW		 5867 update->space = NULL;
5868 imsm_copy_dev(dev, &u->dev);
ba2de7ba
DW		 5869 dv->index = u->dev_idx;
5870 dv->next = super->devlist;
5871 super->devlist = dv;
8273f55e 5872 mpb->num_raid_devs++;
8273f55e 5873
4d1313e9 5874 imsm_update_version_info(super);
8273f55e 5875 break;
ba2de7ba
DW		 5876 create_error:
5877 /* mdmon knows how to release update->space, but not
5878 * ((struct intel_dev *) update->space)->dev
5879 */
5880 if (update->space) {
5881 dv = update->space;
5882 free(dv->dev);
5883 }
8273f55e 5884 break;
e8319a19 5885 }
33414a01
DW		 5886 case update_kill_array: {
5887 struct imsm_update_kill_array *u = (void *) update->buf;
5888 int victim = u->dev_idx;
5889 struct active_array *a;
5890 struct intel_dev **dp;
5891 struct imsm_dev *dev;
5892
5893 /* sanity check that we are not affecting the uuid of
5894 * active arrays, or deleting an active array
5895 *
5896 * FIXME when immutable ids are available, but note that
5897 * we'll also need to fixup the invalidated/active
5898 * subarray indexes in mdstat
5899 */
5900 for (a = st->arrays; a; a = a->next)
5901 if (a->info.container_member >= victim)
5902 break;
5903 /* by definition if mdmon is running at least one array
5904 * is active in the container, so checking
5905 * mpb->num_raid_devs is just extra paranoia
5906 */
5907 dev = get_imsm_dev(super, victim);
5908 if (a || !dev || mpb->num_raid_devs == 1) {
5909 dprintf("failed to delete subarray-%d\n", victim);
5910 break;
5911 }
5912
5913 for (dp = &super->devlist; *dp;)
f21e18ca 5914 if ((*dp)->index == (unsigned)super->current_vol) {
33414a01
DW		 5915 *dp = (*dp)->next;
5916 } else {
f21e18ca 5917 if ((*dp)->index > (unsigned)victim)
33414a01
DW		 5918 (*dp)->index--;
5919 dp = &(*dp)->next;
5920 }
5921 mpb->num_raid_devs--;
5922 super->updates_pending++;
5923 break;
5924 }
aa534678
DW		 5925 case update_rename_array: {
5926 struct imsm_update_rename_array *u = (void *) update->buf;
5927 char name[MAX_RAID_SERIAL_LEN+1];
5928 int target = u->dev_idx;
5929 struct active_array *a;
5930 struct imsm_dev *dev;
5931
5932 /* sanity check that we are not affecting the uuid of
5933 * an active array
5934 */
5935 snprintf(name, MAX_RAID_SERIAL_LEN, "%s", (char *) u->name);
5936 name[MAX_RAID_SERIAL_LEN] = '\0';
5937 for (a = st->arrays; a; a = a->next)
5938 if (a->info.container_member == target)
5939 break;
5940 dev = get_imsm_dev(super, u->dev_idx);
5941 if (a || !dev || !check_name(super, name, 1)) {
5942 dprintf("failed to rename subarray-%d\n", target);
5943 break;
5944 }
5945
cdbe98cd 5946 snprintf((char *) dev->volume, MAX_RAID_SERIAL_LEN, "%s", name);
aa534678
DW		 5947 super->updates_pending++;
5948 break;
5949 }
1a64be56 5950 case update_add_remove_disk: {
43dad3d6 5951 /* we may be able to repair some arrays if disks are
1a64be56
LM		 5952 * being added, check teh status of add_remove_disk
5953 * if discs has been added.
5954 */
5955 if (add_remove_disk_update(super)) {
43dad3d6 5956 struct active_array *a;
072b727f
DW		 5957
5958 super->updates_pending++;
1a64be56 5959 for (a = st->arrays; a; a = a->next)
43dad3d6
DW		 5960 a->check_degraded = 1;
5961 }
43dad3d6 5962 break;
e8319a19 5963 }
1a64be56
LM		 5964 default:
5965 fprintf(stderr, "error: unsuported process update type:"
5966 "(type: %d)\n", type);
5967 }
e8319a19 5968}
88758e9d 5969
8273f55e
DW		 5970static void imsm_prepare_update(struct supertype *st,
5971 struct metadata_update *update)
5972{
949c47a0 5973 /**
4d7b1503
DW		 5974 * Allocate space to hold new disk entries, raid-device entries or a new
5975 * mpb if necessary. The manager synchronously waits for updates to
5976 * complete in the monitor, so new mpb buffers allocated here can be
5977 * integrated by the monitor thread without worrying about live pointers
5978 * in the manager thread.
8273f55e 5979 */
949c47a0 5980 enum imsm_update_type type = *(enum imsm_update_type *) update->buf;
4d7b1503
DW		 5981 struct intel_super *super = st->sb;
5982 struct imsm_super *mpb = super->anchor;
5983 size_t buf_len;
5984 size_t len = 0;
949c47a0
DW		 5985
5986 switch (type) {
78b10e66 5987 case update_reshape_container_disks: {
d195167d
AK		 5988 /* Every raid device in the container is about to
5989 * gain some more devices, and we will enter a
5990 * reconfiguration.
5991 * So each 'imsm_map' will be bigger, and the imsm_vol
5992 * will now hold 2 of them.
5993 * Thus we need new 'struct imsm_dev' allocations sized
5994 * as sizeof_imsm_dev but with more devices in both maps.
5995 */
5996 struct imsm_update_reshape *u = (void *)update->buf;
5997 struct intel_dev *dl;
5998 void **space_tail = (void**)&update->space_list;
5999
6000 dprintf("imsm: imsm_prepare_update() for update_reshape\n");
6001
6002 for (dl = super->devlist; dl; dl = dl->next) {
6003 int size = sizeof_imsm_dev(dl->dev, 1);
6004 void *s;
d677e0b8
AK		 6005 if (u->new_raid_disks > u->old_raid_disks)
6006 size += sizeof(__u32)*2*
6007 (u->new_raid_disks - u->old_raid_disks);
d195167d
AK		 6008 s = malloc(size);
6009 if (!s)
6010 break;
6011 *space_tail = s;
6012 space_tail = s;
6013 *space_tail = NULL;
6014 }
6015
6016 len = disks_to_mpb_size(u->new_raid_disks);
6017 dprintf("New anchor length is %llu\n", (unsigned long long)len);
78b10e66
N		 6018 break;
6019 }
949c47a0
DW		 6020 case update_create_array: {
6021 struct imsm_update_create_array *u = (void *) update->buf;
ba2de7ba 6022 struct intel_dev *dv;
54c2c1ea
DW		 6023 struct imsm_dev *dev = &u->dev;
6024 struct imsm_map *map = get_imsm_map(dev, 0);
6025 struct dl *dl;
6026 struct disk_info *inf;
6027 int i;
6028 int activate = 0;
949c47a0 6029
54c2c1ea
DW		 6030 inf = get_disk_info(u);
6031 len = sizeof_imsm_dev(dev, 1);
ba2de7ba
DW		 6032 /* allocate a new super->devlist entry */
6033 dv = malloc(sizeof(*dv));
6034 if (dv) {
6035 dv->dev = malloc(len);
6036 if (dv->dev)
6037 update->space = dv;
6038 else {
6039 free(dv);
6040 update->space = NULL;
6041 }
6042 }
949c47a0 6043
54c2c1ea
DW		 6044 /* count how many spares will be converted to members */
6045 for (i = 0; i < map->num_members; i++) {
6046 dl = serial_to_dl(inf[i].serial, super);
6047 if (!dl) {
6048 /* hmm maybe it failed?, nothing we can do about
6049 * it here
6050 */
6051 continue;
6052 }
6053 if (count_memberships(dl, super) == 0)
6054 activate++;
6055 }
6056 len += activate * sizeof(struct imsm_disk);
949c47a0
DW		 6057 break;
6058 default:
6059 break;
6060 }
6061 }
8273f55e 6062
4d7b1503
DW		 6063 /* check if we need a larger metadata buffer */
6064 if (super->next_buf)
6065 buf_len = super->next_len;
6066 else
6067 buf_len = super->len;
6068
6069 if (__le32_to_cpu(mpb->mpb_size) + len > buf_len) {
6070 /* ok we need a larger buf than what is currently allocated
6071 * if this allocation fails process_update will notice that
6072 * ->next_len is set and ->next_buf is NULL
6073 */
6074 buf_len = ROUND_UP(__le32_to_cpu(mpb->mpb_size) + len, 512);
6075 if (super->next_buf)
6076 free(super->next_buf);
6077
6078 super->next_len = buf_len;
1f45a8ad
DW		 6079 if (posix_memalign(&super->next_buf, 512, buf_len) == 0)
6080 memset(super->next_buf, 0, buf_len);
6081 else
4d7b1503
DW		 6082 super->next_buf = NULL;
6083 }
8273f55e
DW		 6084}
6085
ae6aad82 6086/* must be called while manager is quiesced */
f21e18ca 6087static void imsm_delete(struct intel_super *super, struct dl **dlp, unsigned index)
ae6aad82
DW		 6088{
6089 struct imsm_super *mpb = super->anchor;
ae6aad82
DW		 6090 struct dl *iter;
6091 struct imsm_dev *dev;
6092 struct imsm_map *map;
24565c9a
DW		 6093 int i, j, num_members;
6094 __u32 ord;
ae6aad82 6095
24565c9a
DW		 6096 dprintf("%s: deleting device[%d] from imsm_super\n",
6097 __func__, index);
ae6aad82
DW		 6098
6099 /* shift all indexes down one */
6100 for (iter = super->disks; iter; iter = iter->next)
f21e18ca 6101 if (iter->index > (int)index)
ae6aad82 6102 iter->index--;
47ee5a45 6103 for (iter = super->missing; iter; iter = iter->next)
f21e18ca 6104 if (iter->index > (int)index)
47ee5a45 6105 iter->index--;
ae6aad82
DW		 6106
6107 for (i = 0; i < mpb->num_raid_devs; i++) {
6108 dev = get_imsm_dev(super, i);
6109 map = get_imsm_map(dev, 0);
24565c9a
DW		 6110 num_members = map->num_members;
6111 for (j = 0; j < num_members; j++) {
6112 /* update ord entries being careful not to propagate
6113 * ord-flags to the first map
6114 */
98130f40 6115 ord = get_imsm_ord_tbl_ent(dev, j, -1);
ae6aad82 6116
24565c9a
DW		 6117 if (ord_to_idx(ord) <= index)
6118 continue;
ae6aad82 6119
24565c9a
DW		 6120 map = get_imsm_map(dev, 0);
6121 set_imsm_ord_tbl_ent(map, j, ord_to_idx(ord - 1));
6122 map = get_imsm_map(dev, 1);
6123 if (map)
6124 set_imsm_ord_tbl_ent(map, j, ord - 1);
ae6aad82
DW		 6125 }
6126 }
6127
6128 mpb->num_disks--;
6129 super->updates_pending++;
24565c9a
DW		 6130 if (*dlp) {
6131 struct dl *dl = *dlp;
6132
6133 *dlp = (*dlp)->next;
6134 __free_imsm_disk(dl);
6135 }
ae6aad82 6136}
0e600426 6137#endif /* MDASSEMBLE */
ae6aad82 6138
2cda7640
ML		 6139static char disk_by_path[] = "/dev/disk/by-path/";
6140
6141static const char *imsm_get_disk_controller_domain(const char *path)
6142{
6143 struct sys_dev *list, *hba = NULL;
6144 char disk_path[PATH_MAX];
6145 int ahci = 0;
6146 char *dpath = NULL;
6147
6148 list = find_driver_devices("pci", "ahci");
6149 for (hba = list; hba; hba = hba->next)
6150 if (devpath_to_vendor(hba->path) == 0x8086)
6151 break;
6152
6153 if (hba) {
6154 struct stat st;
6155
6156 strncpy(disk_path, disk_by_path, PATH_MAX - 1);
6157 strncat(disk_path, path, PATH_MAX - strlen(disk_path) - 1);
6158 if (stat(disk_path, &st) == 0) {
6159 dpath = devt_to_devpath(st.st_rdev);
6160 if (dpath)
6161 ahci = path_attached_to_hba(dpath, hba->path);
6162 }
6163 }
6164 dprintf("path: %s(%s) hba: %s attached: %d\n",
6165 path, dpath, (hba) ? hba->path : "NULL", ahci);
6166 free_sys_dev(&list);
6167 if (ahci)
6168 return "ahci";
6169 else
6170 return NULL;
6171}
6172
78b10e66
N		 6173static int imsm_find_array_minor_by_subdev(int subdev, int container, int *minor)
6174{
6175 char subdev_name[20];
6176 struct mdstat_ent *mdstat;
6177
6178 sprintf(subdev_name, "%d", subdev);
6179 mdstat = mdstat_by_subdev(subdev_name, container);
6180 if (!mdstat)
6181 return -1;
6182
6183 *minor = mdstat->devnum;
6184 free_mdstat(mdstat);
6185 return 0;
6186}
6187
6188static int imsm_reshape_is_allowed_on_container(struct supertype *st,
6189 struct geo_params *geo,
6190 int *old_raid_disks)
6191{
6192 int ret_val = 0;
6193 struct mdinfo *info, *member;
6194 int devices_that_can_grow = 0;
6195
6196 dprintf("imsm: imsm_reshape_is_allowed_on_container(ENTER): "
6197 "st->devnum = (%i)\n",
6198 st->devnum);
6199
6200 if (geo->size != -1 ||
6201 geo->level != UnSet ||
6202 geo->layout != UnSet ||
6203 geo->chunksize != 0 ||
6204 geo->raid_disks == UnSet) {
6205 dprintf("imsm: Container operation is allowed for "
6206 "raid disks number change only.\n");
6207 return ret_val;
6208 }
6209
6210 info = container_content_imsm(st, NULL);
6211 for (member = info; member; member = member->next) {
6212 int result;
6213 int minor;
6214
6215 dprintf("imsm: checking device_num: %i\n",
6216 member->container_member);
6217
6218 if (geo->raid_disks < member->array.raid_disks) {
6219 /* we work on container for Online Capacity Expansion
6220 * only so raid_disks has to grow
6221 */
6222 dprintf("imsm: for container operation raid disks "
6223 "increase is required\n");
6224 break;
6225 }
6226
6227 if ((info->array.level != 0) &&
6228 (info->array.level != 5)) {
6229 /* we cannot use this container with other raid level
6230 */
690aae1a 6231 dprintf("imsm: for container operation wrong"
78b10e66
N		 6232 " raid level (%i) detected\n",
6233 info->array.level);
6234 break;
6235 } else {
6236 /* check for platform support
6237 * for this raid level configuration
6238 */
6239 struct intel_super *super = st->sb;
6240 if (!is_raid_level_supported(super->orom,
6241 member->array.level,
6242 geo->raid_disks)) {
690aae1a 6243 dprintf("platform does not support raid%d with"
78b10e66
N		 6244 " %d disk%s\n",
6245 info->array.level,
6246 geo->raid_disks,
6247 geo->raid_disks > 1 ? "s" : "");
6248 break;
6249 }
6250 }
6251
6252 if (*old_raid_disks &&
6253 info->array.raid_disks != *old_raid_disks)
6254 break;
6255 *old_raid_disks = info->array.raid_disks;
6256
6257 /* All raid5 and raid0 volumes in container
6258 * have to be ready for Online Capacity Expansion
6259 * so they need to be assembled. We have already
6260 * checked that no recovery etc is happening.
6261 */
6262 result = imsm_find_array_minor_by_subdev(member->container_member,
6263 st->container_dev,
6264 &minor);
6265 if (result < 0) {
6266 dprintf("imsm: cannot find array\n");
6267 break;
6268 }
6269 devices_that_can_grow++;
6270 }
6271 sysfs_free(info);
6272 if (!member && devices_that_can_grow)
6273 ret_val = 1;
6274
6275 if (ret_val)
6276 dprintf("\tContainer operation allowed\n");
6277 else
6278 dprintf("\tError: %i\n", ret_val);
6279
6280 return ret_val;
6281}
6282
6283/* Function: get_spares_for_grow
6284 * Description: Allocates memory and creates list of spare devices
6285 * avaliable in container. Checks if spare drive size is acceptable.
6286 * Parameters: Pointer to the supertype structure
6287 * Returns: Pointer to the list of spare devices (mdinfo structure) on success,
6288 * NULL if fail
6289 */
6290static struct mdinfo *get_spares_for_grow(struct supertype *st)
6291{
78b10e66 6292 unsigned long long min_size = min_acceptable_spare_size_imsm(st);
326727d9 6293 return container_choose_spares(st, min_size, NULL, NULL, NULL, 0);
78b10e66
N		 6294}
6295
6296/******************************************************************************
6297 * function: imsm_create_metadata_update_for_reshape
6298 * Function creates update for whole IMSM container.
6299 *
6300 ******************************************************************************/
6301static int imsm_create_metadata_update_for_reshape(
6302 struct supertype *st,
6303 struct geo_params *geo,
6304 int old_raid_disks,
6305 struct imsm_update_reshape **updatep)
6306{
6307 struct intel_super *super = st->sb;
6308 struct imsm_super *mpb = super->anchor;
6309 int update_memory_size = 0;
6310 struct imsm_update_reshape *u = NULL;
6311 struct mdinfo *spares = NULL;
6312 int i;
6313 int delta_disks = 0;
6314
6315 dprintf("imsm_update_metadata_for_reshape(enter) raid_disks = %i\n",
6316 geo->raid_disks);
6317
6318 delta_disks = geo->raid_disks - old_raid_disks;
6319
6320 /* size of all update data without anchor */
6321 update_memory_size = sizeof(struct imsm_update_reshape);
6322
6323 /* now add space for spare disks that we need to add. */
6324 update_memory_size += sizeof(u->new_disks[0]) * (delta_disks - 1);
6325
6326 u = calloc(1, update_memory_size);
6327 if (u == NULL) {
6328 dprintf("error: "
6329 "cannot get memory for imsm_update_reshape update\n");
6330 return 0;
6331 }
6332 u->type = update_reshape_container_disks;
6333 u->old_raid_disks = old_raid_disks;
6334 u->new_raid_disks = geo->raid_disks;
6335
6336 /* now get spare disks list
6337 */
6338 spares = get_spares_for_grow(st);
6339
6340 if (spares == NULL
6341 || delta_disks > spares->array.spare_disks) {
6342 dprintf("imsm: ERROR: Cannot get spare devices.\n");
6343 goto abort;
6344 }
6345
6346 /* we have got spares
6347 * update disk list in imsm_disk list table in anchor
6348 */
6349 dprintf("imsm: %i spares are available.\n\n",
6350 spares->array.spare_disks);
6351
6352 for (i = 0; i < delta_disks; i++) {
6353 struct mdinfo *dev = spares->devs;
6354 struct dl *dl;
6355
6356 u->new_disks[i] = makedev(dev->disk.major,
6357 dev->disk.minor);
6358 dl = get_disk_super(super, dev->disk.major, dev->disk.minor);
6359 dl->index = mpb->num_disks++;
6360 }
6361 /* Now update the metadata so that container_content will find
6362 * the new devices
6363 */
6364 for (i = 0; i < mpb->num_raid_devs; i++) {
6365 int d;
6366 struct imsm_dev *dev = get_imsm_dev(super, i);
6367 struct imsm_map *map = get_imsm_map(dev, 0);
6368 map->num_members = geo->raid_disks;
6369 for (d = 0; d < delta_disks; d++) {
6370 set_imsm_ord_tbl_ent(map, old_raid_disks + d,
6371 mpb->num_disks - delta_disks + d);
6372 }
6373 }
6374
6375abort:
6376 /* free spares
6377 */
6378 sysfs_free(spares);
6379
d677e0b8 6380 dprintf("imsm: reshape update preparation :");
78b10e66 6381 if (i == delta_disks) {
d677e0b8 6382 dprintf(" OK\n");
78b10e66
N		 6383 *updatep = u;
6384 return update_memory_size;
6385 }
6386 free(u);
d677e0b8 6387 dprintf(" Error\n");
78b10e66
N		 6388
6389 return 0;
6390}
6391
6392
6393static int imsm_reshape_super(struct supertype *st, long long size, int level,
6394 int layout, int chunksize, int raid_disks,
690aae1a 6395 char *backup, char *dev, int verbose)
78b10e66
N		 6396{
6397 /* currently we only support increasing the number of devices
6398 * for a container. This increases the number of device for each
6399 * member array. They must all be RAID0 or RAID5.
6400 */
6401
6402 int ret_val = 1;
6403 struct geo_params geo;
6404
6405 dprintf("imsm: reshape_super called.\n");
6406
6407 memset(&geo, sizeof(struct geo_params), 0);
6408
6409 geo.dev_name = dev;
6410 geo.size = size;
6411 geo.level = level;
6412 geo.layout = layout;
6413 geo.chunksize = chunksize;
6414 geo.raid_disks = raid_disks;
6415
6416 dprintf("\tfor level : %i\n", geo.level);
6417 dprintf("\tfor raid_disks : %i\n", geo.raid_disks);
6418
6419 if (experimental() == 0)
6420 return ret_val;
6421
6422 /* verify reshape conditions
6423 * on container level we can only increase number of devices. */
6424 if (st->container_dev == st->devnum) {
6425 /* check for delta_disks > 0
6426 *and supported raid levels 0 and 5 only in container */
6427 int old_raid_disks = 0;
6428 if (imsm_reshape_is_allowed_on_container(
6429 st, &geo, &old_raid_disks)) {
6430 struct imsm_update_reshape *u = NULL;
6431 int len;
6432
6433 len = imsm_create_metadata_update_for_reshape(
6434 st, &geo, old_raid_disks, &u);
6435
6436 if (len) {
6437 ret_val = 0;
6438 append_metadata_update(st, u, len);
6439 } else
690aae1a 6440 fprintf(stderr, Name "imsm: Cannot prepare "
78b10e66
N		 6441 "update\n");
6442 } else
690aae1a 6443 fprintf(stderr, Name "imsm: Operation is not allowed "
78b10e66
N		 6444 "on this container\n");
6445 } else
690aae1a 6446 fprintf(stderr, Name "imsm: not a container operation\n");
78b10e66
N		 6447
6448 dprintf("imsm: reshape_super Exit code = %i\n", ret_val);
6449 return ret_val;
6450}
2cda7640 6451
cdddbdbc
DW		 6452struct superswitch super_imsm = {
6453#ifndef MDASSEMBLE
6454 .examine_super = examine_super_imsm,
6455 .brief_examine_super = brief_examine_super_imsm,
4737ae25 6456 .brief_examine_subarrays = brief_examine_subarrays_imsm,
9d84c8ea 6457 .export_examine_super = export_examine_super_imsm,
cdddbdbc
DW		 6458 .detail_super = detail_super_imsm,
6459 .brief_detail_super = brief_detail_super_imsm,
bf5a934a 6460 .write_init_super = write_init_super_imsm,
0e600426
N		 6461 .validate_geometry = validate_geometry_imsm,
6462 .add_to_super = add_to_super_imsm,
1a64be56 6463 .remove_from_super = remove_from_super_imsm,
d665cc31 6464 .detail_platform = detail_platform_imsm,
33414a01 6465 .kill_subarray = kill_subarray_imsm,
aa534678 6466 .update_subarray = update_subarray_imsm,
2b959fbf 6467 .load_container = load_container_imsm,
cdddbdbc
DW		 6468#endif
6469 .match_home = match_home_imsm,
6470 .uuid_from_super= uuid_from_super_imsm,
6471 .getinfo_super = getinfo_super_imsm,
5c4cd5da 6472 .getinfo_super_disks = getinfo_super_disks_imsm,
cdddbdbc
DW		 6473 .update_super = update_super_imsm,
6474
6475 .avail_size = avail_size_imsm,
80e7f8c3 6476 .min_acceptable_spare_size = min_acceptable_spare_size_imsm,
cdddbdbc
DW		 6477
6478 .compare_super = compare_super_imsm,
6479
6480 .load_super = load_super_imsm,
bf5a934a 6481 .init_super = init_super_imsm,
e683ca88 6482 .store_super = store_super_imsm,
cdddbdbc
DW		 6483 .free_super = free_super_imsm,
6484 .match_metadata_desc = match_metadata_desc_imsm,
bf5a934a 6485 .container_content = container_content_imsm,
30f58b22 6486 .default_geometry = default_geometry_imsm,
2cda7640 6487 .get_disk_controller_domain = imsm_get_disk_controller_domain,
78b10e66 6488 .reshape_super = imsm_reshape_super,
cdddbdbc 6489
cdddbdbc 6490 .external = 1,
4cce4069 6491 .name = "imsm",
845dea95 6492
0e600426 6493#ifndef MDASSEMBLE
845dea95
NB		 6494/* for mdmon */
6495 .open_new = imsm_open_new,
ed9d66aa 6496 .set_array_state= imsm_set_array_state,
845dea95
NB		 6497 .set_disk = imsm_set_disk,
6498 .sync_metadata = imsm_sync_metadata,
88758e9d 6499 .activate_spare = imsm_activate_spare,
e8319a19 6500 .process_update = imsm_process_update,
8273f55e 6501 .prepare_update = imsm_prepare_update,
0e600426 6502#endif /* MDASSEMBLE */
cdddbdbc 6503};
Unnamed repository; edit this file 'description' to name the repository.