imsm: remove redundant characters from some error messages
[thirdparty/mdadm.git] / super-intel.c
1 /*
2 * mdadm - Intel(R) Matrix Storage Manager Support
3 *
4 * Copyright (C) 2002-2008 Intel Corporation
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
20 #define HAVE_STDINT_H 1
21 #include "mdadm.h"
22 #include "mdmon.h"
23 #include "sha1.h"
24 #include "platform-intel.h"
25 #include <values.h>
26 #include <scsi/sg.h>
27 #include <ctype.h>
28 #include <dirent.h>
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"
35 #define MPB_VERSION_MANY_VOLUMES_PER_ARRAY "1.2.00"
36 #define MPB_VERSION_3OR4_DISK_ARRAY "1.2.01"
37 #define MPB_VERSION_RAID5 "1.2.02"
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"
41 #define MAX_SIGNATURE_LENGTH 32
42 #define MAX_RAID_SERIAL_LEN 16
43
44 /* supports RAID0 */
45 #define MPB_ATTRIB_RAID0 __cpu_to_le32(0x00000001)
46 /* supports RAID1 */
47 #define MPB_ATTRIB_RAID1 __cpu_to_le32(0x00000002)
48 /* supports RAID10 */
49 #define MPB_ATTRIB_RAID10 __cpu_to_le32(0x00000004)
50 /* supports RAID1E */
51 #define MPB_ATTRIB_RAID1E __cpu_to_le32(0x00000008)
52 /* supports RAID5 */
53 #define MPB_ATTRIB_RAID5 __cpu_to_le32(0x00000010)
54 /* supports RAID CNG */
55 #define MPB_ATTRIB_RAIDCNG __cpu_to_le32(0x00000020)
56 /* supports expanded stripe sizes of 256K, 512K and 1MB */
57 #define MPB_ATTRIB_EXP_STRIPE_SIZE __cpu_to_le32(0x00000040)
58
59 /* The OROM Support RST Caching of Volumes */
60 #define MPB_ATTRIB_NVM __cpu_to_le32(0x02000000)
61 /* The OROM supports creating disks greater than 2TB */
62 #define MPB_ATTRIB_2TB_DISK __cpu_to_le32(0x04000000)
63 /* The OROM supports Bad Block Management */
64 #define MPB_ATTRIB_BBM __cpu_to_le32(0x08000000)
65
66 /* THe OROM Supports NVM Caching of Volumes */
67 #define MPB_ATTRIB_NEVER_USE2 __cpu_to_le32(0x10000000)
68 /* The OROM supports creating volumes greater than 2TB */
69 #define MPB_ATTRIB_2TB __cpu_to_le32(0x20000000)
70 /* originally for PMP, now it's wasted b/c. Never use this bit! */
71 #define MPB_ATTRIB_NEVER_USE __cpu_to_le32(0x40000000)
72 /* Verify MPB contents against checksum after reading MPB */
73 #define MPB_ATTRIB_CHECKSUM_VERIFY __cpu_to_le32(0x80000000)
74
75 /* Define all supported attributes that have to be accepted by mdadm
76 */
77 #define MPB_ATTRIB_SUPPORTED (MPB_ATTRIB_CHECKSUM_VERIFY | \
78 MPB_ATTRIB_2TB | \
79 MPB_ATTRIB_2TB_DISK | \
80 MPB_ATTRIB_RAID0 | \
81 MPB_ATTRIB_RAID1 | \
82 MPB_ATTRIB_RAID10 | \
83 MPB_ATTRIB_RAID5 | \
84 MPB_ATTRIB_EXP_STRIPE_SIZE)
85
86 /* Define attributes that are unused but not harmful */
87 #define MPB_ATTRIB_IGNORED (MPB_ATTRIB_NEVER_USE)
88
89 #define MPB_SECTOR_CNT 2210
90 #define IMSM_RESERVED_SECTORS 4096
91 #define NUM_BLOCKS_DIRTY_STRIPE_REGION 2056
92 #define SECT_PER_MB_SHIFT 11
93
94 /* Disk configuration info. */
95 #define IMSM_MAX_DEVICES 255
96 struct imsm_disk {
97 __u8 serial[MAX_RAID_SERIAL_LEN];/* 0xD8 - 0xE7 ascii serial number */
98 __u32 total_blocks_lo; /* 0xE8 - 0xEB total blocks lo */
99 __u32 scsi_id; /* 0xEC - 0xEF scsi ID */
100 #define SPARE_DISK __cpu_to_le32(0x01) /* Spare */
101 #define CONFIGURED_DISK __cpu_to_le32(0x02) /* Member of some RaidDev */
102 #define FAILED_DISK __cpu_to_le32(0x04) /* Permanent failure */
103 __u32 status; /* 0xF0 - 0xF3 */
104 __u32 owner_cfg_num; /* which config 0,1,2... owns this disk */
105 __u32 total_blocks_hi; /* 0xF4 - 0xF5 total blocks hi */
106 #define IMSM_DISK_FILLERS 3
107 __u32 filler[IMSM_DISK_FILLERS]; /* 0xF5 - 0x107 MPB_DISK_FILLERS for future expansion */
108 };
109
110 /* map selector for map managment
111 */
112 #define MAP_0 0
113 #define MAP_1 1
114 #define MAP_X -1
115
116 /* RAID map configuration infos. */
117 struct imsm_map {
118 __u32 pba_of_lba0_lo; /* start address of partition */
119 __u32 blocks_per_member_lo;/* blocks per member */
120 __u32 num_data_stripes_lo; /* number of data stripes */
121 __u16 blocks_per_strip;
122 __u8 map_state; /* Normal, Uninitialized, Degraded, Failed */
123 #define IMSM_T_STATE_NORMAL 0
124 #define IMSM_T_STATE_UNINITIALIZED 1
125 #define IMSM_T_STATE_DEGRADED 2
126 #define IMSM_T_STATE_FAILED 3
127 __u8 raid_level;
128 #define IMSM_T_RAID0 0
129 #define IMSM_T_RAID1 1
130 #define IMSM_T_RAID5 5 /* since metadata version 1.2.02 ? */
131 __u8 num_members; /* number of member disks */
132 __u8 num_domains; /* number of parity domains */
133 __u8 failed_disk_num; /* valid only when state is degraded */
134 __u8 ddf;
135 __u32 pba_of_lba0_hi;
136 __u32 blocks_per_member_hi;
137 __u32 num_data_stripes_hi;
138 __u32 filler[4]; /* expansion area */
139 #define IMSM_ORD_REBUILD (1 << 24)
140 __u32 disk_ord_tbl[1]; /* disk_ord_tbl[num_members],
141 * top byte contains some flags
142 */
143 } __attribute__ ((packed));
144
145 struct imsm_vol {
146 __u32 curr_migr_unit;
147 __u32 checkpoint_id; /* id to access curr_migr_unit */
148 __u8 migr_state; /* Normal or Migrating */
149 #define MIGR_INIT 0
150 #define MIGR_REBUILD 1
151 #define MIGR_VERIFY 2 /* analagous to echo check > sync_action */
152 #define MIGR_GEN_MIGR 3
153 #define MIGR_STATE_CHANGE 4
154 #define MIGR_REPAIR 5
155 __u8 migr_type; /* Initializing, Rebuilding, ... */
156 __u8 dirty;
157 __u8 fs_state; /* fast-sync state for CnG (0xff == disabled) */
158 __u16 verify_errors; /* number of mismatches */
159 __u16 bad_blocks; /* number of bad blocks during verify */
160 __u32 filler[4];
161 struct imsm_map map[1];
162 /* here comes another one if migr_state */
163 } __attribute__ ((packed));
164
165 struct imsm_dev {
166 __u8 volume[MAX_RAID_SERIAL_LEN];
167 __u32 size_low;
168 __u32 size_high;
169 #define DEV_BOOTABLE __cpu_to_le32(0x01)
170 #define DEV_BOOT_DEVICE __cpu_to_le32(0x02)
171 #define DEV_READ_COALESCING __cpu_to_le32(0x04)
172 #define DEV_WRITE_COALESCING __cpu_to_le32(0x08)
173 #define DEV_LAST_SHUTDOWN_DIRTY __cpu_to_le32(0x10)
174 #define DEV_HIDDEN_AT_BOOT __cpu_to_le32(0x20)
175 #define DEV_CURRENTLY_HIDDEN __cpu_to_le32(0x40)
176 #define DEV_VERIFY_AND_FIX __cpu_to_le32(0x80)
177 #define DEV_MAP_STATE_UNINIT __cpu_to_le32(0x100)
178 #define DEV_NO_AUTO_RECOVERY __cpu_to_le32(0x200)
179 #define DEV_CLONE_N_GO __cpu_to_le32(0x400)
180 #define DEV_CLONE_MAN_SYNC __cpu_to_le32(0x800)
181 #define DEV_CNG_MASTER_DISK_NUM __cpu_to_le32(0x1000)
182 __u32 status; /* Persistent RaidDev status */
183 __u32 reserved_blocks; /* Reserved blocks at beginning of volume */
184 __u8 migr_priority;
185 __u8 num_sub_vols;
186 __u8 tid;
187 __u8 cng_master_disk;
188 __u16 cache_policy;
189 __u8 cng_state;
190 __u8 cng_sub_state;
191 #define IMSM_DEV_FILLERS 10
192 __u32 filler[IMSM_DEV_FILLERS];
193 struct imsm_vol vol;
194 } __attribute__ ((packed));
195
196 struct imsm_super {
197 __u8 sig[MAX_SIGNATURE_LENGTH]; /* 0x00 - 0x1F */
198 __u32 check_sum; /* 0x20 - 0x23 MPB Checksum */
199 __u32 mpb_size; /* 0x24 - 0x27 Size of MPB */
200 __u32 family_num; /* 0x28 - 0x2B Checksum from first time this config was written */
201 __u32 generation_num; /* 0x2C - 0x2F Incremented each time this array's MPB is written */
202 __u32 error_log_size; /* 0x30 - 0x33 in bytes */
203 __u32 attributes; /* 0x34 - 0x37 */
204 __u8 num_disks; /* 0x38 Number of configured disks */
205 __u8 num_raid_devs; /* 0x39 Number of configured volumes */
206 __u8 error_log_pos; /* 0x3A */
207 __u8 fill[1]; /* 0x3B */
208 __u32 cache_size; /* 0x3c - 0x40 in mb */
209 __u32 orig_family_num; /* 0x40 - 0x43 original family num */
210 __u32 pwr_cycle_count; /* 0x44 - 0x47 simulated power cycle count for array */
211 __u32 bbm_log_size; /* 0x48 - 0x4B - size of bad Block Mgmt Log in bytes */
212 #define IMSM_FILLERS 35
213 __u32 filler[IMSM_FILLERS]; /* 0x4C - 0xD7 RAID_MPB_FILLERS */
214 struct imsm_disk disk[1]; /* 0xD8 diskTbl[numDisks] */
215 /* here comes imsm_dev[num_raid_devs] */
216 /* here comes BBM logs */
217 } __attribute__ ((packed));
218
219 #define BBM_LOG_MAX_ENTRIES 254
220
221 struct bbm_log_entry {
222 __u64 defective_block_start;
223 #define UNREADABLE 0xFFFFFFFF
224 __u32 spare_block_offset;
225 __u16 remapped_marked_count;
226 __u16 disk_ordinal;
227 } __attribute__ ((__packed__));
228
229 struct bbm_log {
230 __u32 signature; /* 0xABADB10C */
231 __u32 entry_count;
232 __u32 reserved_spare_block_count; /* 0 */
233 __u32 reserved; /* 0xFFFF */
234 __u64 first_spare_lba;
235 struct bbm_log_entry mapped_block_entries[BBM_LOG_MAX_ENTRIES];
236 } __attribute__ ((__packed__));
237
238 #ifndef MDASSEMBLE
239 static char *map_state_str[] = { "normal", "uninitialized", "degraded", "failed" };
240 #endif
241
242 #define RAID_DISK_RESERVED_BLOCKS_IMSM_HI 2209
243
244 #define GEN_MIGR_AREA_SIZE 2048 /* General Migration Copy Area size in blocks */
245
246 #define MIGR_REC_BUF_SIZE 512 /* size of migr_record i/o buffer */
247 #define MIGR_REC_POSITION 512 /* migr_record position offset on disk,
248 * MIGR_REC_BUF_SIZE <= MIGR_REC_POSITION
249 */
250
251 #define UNIT_SRC_NORMAL 0 /* Source data for curr_migr_unit must
252 * be recovered using srcMap */
253 #define UNIT_SRC_IN_CP_AREA 1 /* Source data for curr_migr_unit has
254 * already been migrated and must
255 * be recovered from checkpoint area */
256 struct migr_record {
257 __u32 rec_status; /* Status used to determine how to restart
258 * migration in case it aborts
259 * in some fashion */
260 __u32 curr_migr_unit; /* 0..numMigrUnits-1 */
261 __u32 family_num; /* Family number of MPB
262 * containing the RaidDev
263 * that is migrating */
264 __u32 ascending_migr; /* True if migrating in increasing
265 * order of lbas */
266 __u32 blocks_per_unit; /* Num disk blocks per unit of operation */
267 __u32 dest_depth_per_unit; /* Num member blocks each destMap
268 * member disk
269 * advances per unit-of-operation */
270 __u32 ckpt_area_pba; /* Pba of first block of ckpt copy area */
271 __u32 dest_1st_member_lba; /* First member lba on first
272 * stripe of destination */
273 __u32 num_migr_units; /* Total num migration units-of-op */
274 __u32 post_migr_vol_cap; /* Size of volume after
275 * migration completes */
276 __u32 post_migr_vol_cap_hi; /* Expansion space for LBA64 */
277 __u32 ckpt_read_disk_num; /* Which member disk in destSubMap[0] the
278 * migration ckpt record was read from
279 * (for recovered migrations) */
280 } __attribute__ ((__packed__));
281
282 struct md_list {
283 /* usage marker:
284 * 1: load metadata
285 * 2: metadata does not match
286 * 4: already checked
287 */
288 int used;
289 char *devname;
290 int found;
291 int container;
292 dev_t st_rdev;
293 struct md_list *next;
294 };
295
296 #define pr_vrb(fmt, arg...) (void) (verbose && pr_err(fmt, ##arg))
297
298 static __u8 migr_type(struct imsm_dev *dev)
299 {
300 if (dev->vol.migr_type == MIGR_VERIFY &&
301 dev->status & DEV_VERIFY_AND_FIX)
302 return MIGR_REPAIR;
303 else
304 return dev->vol.migr_type;
305 }
306
307 static void set_migr_type(struct imsm_dev *dev, __u8 migr_type)
308 {
309 /* for compatibility with older oroms convert MIGR_REPAIR, into
310 * MIGR_VERIFY w/ DEV_VERIFY_AND_FIX status
311 */
312 if (migr_type == MIGR_REPAIR) {
313 dev->vol.migr_type = MIGR_VERIFY;
314 dev->status |= DEV_VERIFY_AND_FIX;
315 } else {
316 dev->vol.migr_type = migr_type;
317 dev->status &= ~DEV_VERIFY_AND_FIX;
318 }
319 }
320
321 static unsigned int sector_count(__u32 bytes)
322 {
323 return ROUND_UP(bytes, 512) / 512;
324 }
325
326 static unsigned int mpb_sectors(struct imsm_super *mpb)
327 {
328 return sector_count(__le32_to_cpu(mpb->mpb_size));
329 }
330
331 struct intel_dev {
332 struct imsm_dev *dev;
333 struct intel_dev *next;
334 unsigned index;
335 };
336
337 struct intel_hba {
338 enum sys_dev_type type;
339 char *path;
340 char *pci_id;
341 struct intel_hba *next;
342 };
343
344 enum action {
345 DISK_REMOVE = 1,
346 DISK_ADD
347 };
348 /* internal representation of IMSM metadata */
349 struct intel_super {
350 union {
351 void *buf; /* O_DIRECT buffer for reading/writing metadata */
352 struct imsm_super *anchor; /* immovable parameters */
353 };
354 union {
355 void *migr_rec_buf; /* buffer for I/O operations */
356 struct migr_record *migr_rec; /* migration record */
357 };
358 int clean_migration_record_by_mdmon; /* when reshape is switched to next
359 array, it indicates that mdmon is allowed to clean migration
360 record */
361 size_t len; /* size of the 'buf' allocation */
362 void *next_buf; /* for realloc'ing buf from the manager */
363 size_t next_len;
364 int updates_pending; /* count of pending updates for mdmon */
365 int current_vol; /* index of raid device undergoing creation */
366 unsigned long long create_offset; /* common start for 'current_vol' */
367 __u32 random; /* random data for seeding new family numbers */
368 struct intel_dev *devlist;
369 struct dl {
370 struct dl *next;
371 int index;
372 __u8 serial[MAX_RAID_SERIAL_LEN];
373 int major, minor;
374 char *devname;
375 struct imsm_disk disk;
376 int fd;
377 int extent_cnt;
378 struct extent *e; /* for determining freespace @ create */
379 int raiddisk; /* slot to fill in autolayout */
380 enum action action;
381 } *disks, *current_disk;
382 struct dl *disk_mgmt_list; /* list of disks to add/remove while mdmon
383 active */
384 struct dl *missing; /* disks removed while we weren't looking */
385 struct bbm_log *bbm_log;
386 struct intel_hba *hba; /* device path of the raid controller for this metadata */
387 const struct imsm_orom *orom; /* platform firmware support */
388 struct intel_super *next; /* (temp) list for disambiguating family_num */
389 };
390
391 struct intel_disk {
392 struct imsm_disk disk;
393 #define IMSM_UNKNOWN_OWNER (-1)
394 int owner;
395 struct intel_disk *next;
396 };
397
398 struct extent {
399 unsigned long long start, size;
400 };
401
402 /* definitions of reshape process types */
403 enum imsm_reshape_type {
404 CH_TAKEOVER,
405 CH_MIGRATION,
406 CH_ARRAY_SIZE,
407 };
408
409 /* definition of messages passed to imsm_process_update */
410 enum imsm_update_type {
411 update_activate_spare,
412 update_create_array,
413 update_kill_array,
414 update_rename_array,
415 update_add_remove_disk,
416 update_reshape_container_disks,
417 update_reshape_migration,
418 update_takeover,
419 update_general_migration_checkpoint,
420 update_size_change,
421 };
422
423 struct imsm_update_activate_spare {
424 enum imsm_update_type type;
425 struct dl *dl;
426 int slot;
427 int array;
428 struct imsm_update_activate_spare *next;
429 };
430
431 struct geo_params {
432 char devnm[32];
433 char *dev_name;
434 unsigned long long size;
435 int level;
436 int layout;
437 int chunksize;
438 int raid_disks;
439 };
440
441 enum takeover_direction {
442 R10_TO_R0,
443 R0_TO_R10
444 };
445 struct imsm_update_takeover {
446 enum imsm_update_type type;
447 int subarray;
448 enum takeover_direction direction;
449 };
450
451 struct imsm_update_reshape {
452 enum imsm_update_type type;
453 int old_raid_disks;
454 int new_raid_disks;
455
456 int new_disks[1]; /* new_raid_disks - old_raid_disks makedev number */
457 };
458
459 struct imsm_update_reshape_migration {
460 enum imsm_update_type type;
461 int old_raid_disks;
462 int new_raid_disks;
463 /* fields for array migration changes
464 */
465 int subdev;
466 int new_level;
467 int new_layout;
468 int new_chunksize;
469
470 int new_disks[1]; /* new_raid_disks - old_raid_disks makedev number */
471 };
472
473 struct imsm_update_size_change {
474 enum imsm_update_type type;
475 int subdev;
476 long long new_size;
477 };
478
479 struct imsm_update_general_migration_checkpoint {
480 enum imsm_update_type type;
481 __u32 curr_migr_unit;
482 };
483
484 struct disk_info {
485 __u8 serial[MAX_RAID_SERIAL_LEN];
486 };
487
488 struct imsm_update_create_array {
489 enum imsm_update_type type;
490 int dev_idx;
491 struct imsm_dev dev;
492 };
493
494 struct imsm_update_kill_array {
495 enum imsm_update_type type;
496 int dev_idx;
497 };
498
499 struct imsm_update_rename_array {
500 enum imsm_update_type type;
501 __u8 name[MAX_RAID_SERIAL_LEN];
502 int dev_idx;
503 };
504
505 struct imsm_update_add_remove_disk {
506 enum imsm_update_type type;
507 };
508
509 static const char *_sys_dev_type[] = {
510 [SYS_DEV_UNKNOWN] = "Unknown",
511 [SYS_DEV_SAS] = "SAS",
512 [SYS_DEV_SATA] = "SATA",
513 [SYS_DEV_NVME] = "NVMe",
514 [SYS_DEV_VMD] = "VMD"
515 };
516
517 const char *get_sys_dev_type(enum sys_dev_type type)
518 {
519 if (type >= SYS_DEV_MAX)
520 type = SYS_DEV_UNKNOWN;
521
522 return _sys_dev_type[type];
523 }
524
525 static struct intel_hba * alloc_intel_hba(struct sys_dev *device)
526 {
527 struct intel_hba *result = xmalloc(sizeof(*result));
528
529 result->type = device->type;
530 result->path = xstrdup(device->path);
531 result->next = NULL;
532 if (result->path && (result->pci_id = strrchr(result->path, '/')) != NULL)
533 result->pci_id++;
534
535 return result;
536 }
537
538 static struct intel_hba * find_intel_hba(struct intel_hba *hba, struct sys_dev *device)
539 {
540 struct intel_hba *result;
541
542 for (result = hba; result; result = result->next) {
543 if (result->type == device->type && strcmp(result->path, device->path) == 0)
544 break;
545 }
546 return result;
547 }
548
549 static int attach_hba_to_super(struct intel_super *super, struct sys_dev *device)
550 {
551 struct intel_hba *hba;
552
553 /* check if disk attached to Intel HBA */
554 hba = find_intel_hba(super->hba, device);
555 if (hba != NULL)
556 return 1;
557 /* Check if HBA is already attached to super */
558 if (super->hba == NULL) {
559 super->hba = alloc_intel_hba(device);
560 return 1;
561 }
562
563 hba = super->hba;
564 /* Intel metadata allows for all disks attached to the same type HBA.
565 * Do not support HBA types mixing
566 */
567 if (device->type != hba->type)
568 return 2;
569
570 /* Always forbid spanning between VMD domains (seen as different controllers by mdadm) */
571 if (device->type == SYS_DEV_VMD && !path_attached_to_hba(device->path, hba->path))
572 return 2;
573
574 /* Multiple same type HBAs can be used if they share the same OROM */
575 const struct imsm_orom *device_orom = get_orom_by_device_id(device->dev_id);
576
577 if (device_orom != super->orom)
578 return 2;
579
580 while (hba->next)
581 hba = hba->next;
582
583 hba->next = alloc_intel_hba(device);
584 return 1;
585 }
586
587 static struct sys_dev* find_disk_attached_hba(int fd, const char *devname)
588 {
589 struct sys_dev *list, *elem;
590 char *disk_path;
591
592 if ((list = find_intel_devices()) == NULL)
593 return 0;
594
595 if (fd < 0)
596 disk_path = (char *) devname;
597 else
598 disk_path = diskfd_to_devpath(fd);
599
600 if (!disk_path)
601 return 0;
602
603 for (elem = list; elem; elem = elem->next)
604 if (path_attached_to_hba(disk_path, elem->path))
605 return elem;
606
607 if (disk_path != devname)
608 free(disk_path);
609
610 return NULL;
611 }
612
613 static int find_intel_hba_capability(int fd, struct intel_super *super,
614 char *devname);
615
616 static struct supertype *match_metadata_desc_imsm(char *arg)
617 {
618 struct supertype *st;
619
620 if (strcmp(arg, "imsm") != 0 &&
621 strcmp(arg, "default") != 0
622 )
623 return NULL;
624
625 st = xcalloc(1, sizeof(*st));
626 st->ss = &super_imsm;
627 st->max_devs = IMSM_MAX_DEVICES;
628 st->minor_version = 0;
629 st->sb = NULL;
630 return st;
631 }
632
633 #ifndef MDASSEMBLE
634 static __u8 *get_imsm_version(struct imsm_super *mpb)
635 {
636 return &mpb->sig[MPB_SIG_LEN];
637 }
638 #endif
639
640 /* retrieve a disk directly from the anchor when the anchor is known to be
641 * up-to-date, currently only at load time
642 */
643 static struct imsm_disk *__get_imsm_disk(struct imsm_super *mpb, __u8 index)
644 {
645 if (index >= mpb->num_disks)
646 return NULL;
647 return &mpb->disk[index];
648 }
649
650 /* retrieve the disk description based on a index of the disk
651 * in the sub-array
652 */
653 static struct dl *get_imsm_dl_disk(struct intel_super *super, __u8 index)
654 {
655 struct dl *d;
656
657 for (d = super->disks; d; d = d->next)
658 if (d->index == index)
659 return d;
660
661 return NULL;
662 }
663 /* retrieve a disk from the parsed metadata */
664 static struct imsm_disk *get_imsm_disk(struct intel_super *super, __u8 index)
665 {
666 struct dl *dl;
667
668 dl = get_imsm_dl_disk(super, index);
669 if (dl)
670 return &dl->disk;
671
672 return NULL;
673 }
674
675 /* generate a checksum directly from the anchor when the anchor is known to be
676 * up-to-date, currently only at load or write_super after coalescing
677 */
678 static __u32 __gen_imsm_checksum(struct imsm_super *mpb)
679 {
680 __u32 end = mpb->mpb_size / sizeof(end);
681 __u32 *p = (__u32 *) mpb;
682 __u32 sum = 0;
683
684 while (end--) {
685 sum += __le32_to_cpu(*p);
686 p++;
687 }
688
689 return sum - __le32_to_cpu(mpb->check_sum);
690 }
691
692 static size_t sizeof_imsm_map(struct imsm_map *map)
693 {
694 return sizeof(struct imsm_map) + sizeof(__u32) * (map->num_members - 1);
695 }
696
697 struct imsm_map *get_imsm_map(struct imsm_dev *dev, int second_map)
698 {
699 /* A device can have 2 maps if it is in the middle of a migration.
700 * If second_map is:
701 * MAP_0 - we return the first map
702 * MAP_1 - we return the second map if it exists, else NULL
703 * MAP_X - we return the second map if it exists, else the first
704 */
705 struct imsm_map *map = &dev->vol.map[0];
706 struct imsm_map *map2 = NULL;
707
708 if (dev->vol.migr_state)
709 map2 = (void *)map + sizeof_imsm_map(map);
710
711 switch (second_map) {
712 case MAP_0:
713 break;
714 case MAP_1:
715 map = map2;
716 break;
717 case MAP_X:
718 if (map2)
719 map = map2;
720 break;
721 default:
722 map = NULL;
723 }
724 return map;
725
726 }
727
728 /* return the size of the device.
729 * migr_state increases the returned size if map[0] were to be duplicated
730 */
731 static size_t sizeof_imsm_dev(struct imsm_dev *dev, int migr_state)
732 {
733 size_t size = sizeof(*dev) - sizeof(struct imsm_map) +
734 sizeof_imsm_map(get_imsm_map(dev, MAP_0));
735
736 /* migrating means an additional map */
737 if (dev->vol.migr_state)
738 size += sizeof_imsm_map(get_imsm_map(dev, MAP_1));
739 else if (migr_state)
740 size += sizeof_imsm_map(get_imsm_map(dev, MAP_0));
741
742 return size;
743 }
744
745 #ifndef MDASSEMBLE
746 /* retrieve disk serial number list from a metadata update */
747 static struct disk_info *get_disk_info(struct imsm_update_create_array *update)
748 {
749 void *u = update;
750 struct disk_info *inf;
751
752 inf = u + sizeof(*update) - sizeof(struct imsm_dev) +
753 sizeof_imsm_dev(&update->dev, 0);
754
755 return inf;
756 }
757 #endif
758
759 static struct imsm_dev *__get_imsm_dev(struct imsm_super *mpb, __u8 index)
760 {
761 int offset;
762 int i;
763 void *_mpb = mpb;
764
765 if (index >= mpb->num_raid_devs)
766 return NULL;
767
768 /* devices start after all disks */
769 offset = ((void *) &mpb->disk[mpb->num_disks]) - _mpb;
770
771 for (i = 0; i <= index; i++)
772 if (i == index)
773 return _mpb + offset;
774 else
775 offset += sizeof_imsm_dev(_mpb + offset, 0);
776
777 return NULL;
778 }
779
780 static struct imsm_dev *get_imsm_dev(struct intel_super *super, __u8 index)
781 {
782 struct intel_dev *dv;
783
784 if (index >= super->anchor->num_raid_devs)
785 return NULL;
786 for (dv = super->devlist; dv; dv = dv->next)
787 if (dv->index == index)
788 return dv->dev;
789 return NULL;
790 }
791
792 /*
793 * for second_map:
794 * == MAP_0 get first map
795 * == MAP_1 get second map
796 * == MAP_X than get map according to the current migr_state
797 */
798 static __u32 get_imsm_ord_tbl_ent(struct imsm_dev *dev,
799 int slot,
800 int second_map)
801 {
802 struct imsm_map *map;
803
804 map = get_imsm_map(dev, second_map);
805
806 /* top byte identifies disk under rebuild */
807 return __le32_to_cpu(map->disk_ord_tbl[slot]);
808 }
809
810 #define ord_to_idx(ord) (((ord) << 8) >> 8)
811 static __u32 get_imsm_disk_idx(struct imsm_dev *dev, int slot, int second_map)
812 {
813 __u32 ord = get_imsm_ord_tbl_ent(dev, slot, second_map);
814
815 return ord_to_idx(ord);
816 }
817
818 static void set_imsm_ord_tbl_ent(struct imsm_map *map, int slot, __u32 ord)
819 {
820 map->disk_ord_tbl[slot] = __cpu_to_le32(ord);
821 }
822
823 static int get_imsm_disk_slot(struct imsm_map *map, unsigned idx)
824 {
825 int slot;
826 __u32 ord;
827
828 for (slot = 0; slot < map->num_members; slot++) {
829 ord = __le32_to_cpu(map->disk_ord_tbl[slot]);
830 if (ord_to_idx(ord) == idx)
831 return slot;
832 }
833
834 return -1;
835 }
836
837 static int get_imsm_raid_level(struct imsm_map *map)
838 {
839 if (map->raid_level == 1) {
840 if (map->num_members == 2)
841 return 1;
842 else
843 return 10;
844 }
845
846 return map->raid_level;
847 }
848
849 static int cmp_extent(const void *av, const void *bv)
850 {
851 const struct extent *a = av;
852 const struct extent *b = bv;
853 if (a->start < b->start)
854 return -1;
855 if (a->start > b->start)
856 return 1;
857 return 0;
858 }
859
860 static int count_memberships(struct dl *dl, struct intel_super *super)
861 {
862 int memberships = 0;
863 int i;
864
865 for (i = 0; i < super->anchor->num_raid_devs; i++) {
866 struct imsm_dev *dev = get_imsm_dev(super, i);
867 struct imsm_map *map = get_imsm_map(dev, MAP_0);
868
869 if (get_imsm_disk_slot(map, dl->index) >= 0)
870 memberships++;
871 }
872
873 return memberships;
874 }
875
876 static __u32 imsm_min_reserved_sectors(struct intel_super *super);
877
878 static int split_ull(unsigned long long n, __u32 *lo, __u32 *hi)
879 {
880 if (lo == 0 || hi == 0)
881 return 1;
882 *lo = __le32_to_cpu((unsigned)n);
883 *hi = __le32_to_cpu((unsigned)(n >> 32));
884 return 0;
885 }
886
887 static unsigned long long join_u32(__u32 lo, __u32 hi)
888 {
889 return (unsigned long long)__le32_to_cpu(lo) |
890 (((unsigned long long)__le32_to_cpu(hi)) << 32);
891 }
892
893 static unsigned long long total_blocks(struct imsm_disk *disk)
894 {
895 if (disk == NULL)
896 return 0;
897 return join_u32(disk->total_blocks_lo, disk->total_blocks_hi);
898 }
899
900 static unsigned long long pba_of_lba0(struct imsm_map *map)
901 {
902 if (map == NULL)
903 return 0;
904 return join_u32(map->pba_of_lba0_lo, map->pba_of_lba0_hi);
905 }
906
907 static unsigned long long blocks_per_member(struct imsm_map *map)
908 {
909 if (map == NULL)
910 return 0;
911 return join_u32(map->blocks_per_member_lo, map->blocks_per_member_hi);
912 }
913
914 #ifndef MDASSEMBLE
915 static unsigned long long num_data_stripes(struct imsm_map *map)
916 {
917 if (map == NULL)
918 return 0;
919 return join_u32(map->num_data_stripes_lo, map->num_data_stripes_hi);
920 }
921
922 static void set_total_blocks(struct imsm_disk *disk, unsigned long long n)
923 {
924 split_ull(n, &disk->total_blocks_lo, &disk->total_blocks_hi);
925 }
926 #endif
927
928 static void set_pba_of_lba0(struct imsm_map *map, unsigned long long n)
929 {
930 split_ull(n, &map->pba_of_lba0_lo, &map->pba_of_lba0_hi);
931 }
932
933 static void set_blocks_per_member(struct imsm_map *map, unsigned long long n)
934 {
935 split_ull(n, &map->blocks_per_member_lo, &map->blocks_per_member_hi);
936 }
937
938 static void set_num_data_stripes(struct imsm_map *map, unsigned long long n)
939 {
940 split_ull(n, &map->num_data_stripes_lo, &map->num_data_stripes_hi);
941 }
942
943 static struct extent *get_extents(struct intel_super *super, struct dl *dl)
944 {
945 /* find a list of used extents on the given physical device */
946 struct extent *rv, *e;
947 int i;
948 int memberships = count_memberships(dl, super);
949 __u32 reservation;
950
951 /* trim the reserved area for spares, so they can join any array
952 * regardless of whether the OROM has assigned sectors from the
953 * IMSM_RESERVED_SECTORS region
954 */
955 if (dl->index == -1)
956 reservation = imsm_min_reserved_sectors(super);
957 else
958 reservation = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
959
960 rv = xcalloc(sizeof(struct extent), (memberships + 1));
961 e = rv;
962
963 for (i = 0; i < super->anchor->num_raid_devs; i++) {
964 struct imsm_dev *dev = get_imsm_dev(super, i);
965 struct imsm_map *map = get_imsm_map(dev, MAP_0);
966
967 if (get_imsm_disk_slot(map, dl->index) >= 0) {
968 e->start = pba_of_lba0(map);
969 e->size = blocks_per_member(map);
970 e++;
971 }
972 }
973 qsort(rv, memberships, sizeof(*rv), cmp_extent);
974
975 /* determine the start of the metadata
976 * when no raid devices are defined use the default
977 * ...otherwise allow the metadata to truncate the value
978 * as is the case with older versions of imsm
979 */
980 if (memberships) {
981 struct extent *last = &rv[memberships - 1];
982 unsigned long long remainder;
983
984 remainder = total_blocks(&dl->disk) - (last->start + last->size);
985 /* round down to 1k block to satisfy precision of the kernel
986 * 'size' interface
987 */
988 remainder &= ~1UL;
989 /* make sure remainder is still sane */
990 if (remainder < (unsigned)ROUND_UP(super->len, 512) >> 9)
991 remainder = ROUND_UP(super->len, 512) >> 9;
992 if (reservation > remainder)
993 reservation = remainder;
994 }
995 e->start = total_blocks(&dl->disk) - reservation;
996 e->size = 0;
997 return rv;
998 }
999
1000 /* try to determine how much space is reserved for metadata from
1001 * the last get_extents() entry, otherwise fallback to the
1002 * default
1003 */
1004 static __u32 imsm_reserved_sectors(struct intel_super *super, struct dl *dl)
1005 {
1006 struct extent *e;
1007 int i;
1008 __u32 rv;
1009
1010 /* for spares just return a minimal reservation which will grow
1011 * once the spare is picked up by an array
1012 */
1013 if (dl->index == -1)
1014 return MPB_SECTOR_CNT;
1015
1016 e = get_extents(super, dl);
1017 if (!e)
1018 return MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
1019
1020 /* scroll to last entry */
1021 for (i = 0; e[i].size; i++)
1022 continue;
1023
1024 rv = total_blocks(&dl->disk) - e[i].start;
1025
1026 free(e);
1027
1028 return rv;
1029 }
1030
1031 static int is_spare(struct imsm_disk *disk)
1032 {
1033 return (disk->status & SPARE_DISK) == SPARE_DISK;
1034 }
1035
1036 static int is_configured(struct imsm_disk *disk)
1037 {
1038 return (disk->status & CONFIGURED_DISK) == CONFIGURED_DISK;
1039 }
1040
1041 static int is_failed(struct imsm_disk *disk)
1042 {
1043 return (disk->status & FAILED_DISK) == FAILED_DISK;
1044 }
1045
1046 /* try to determine how much space is reserved for metadata from
1047 * the last get_extents() entry on the smallest active disk,
1048 * otherwise fallback to the default
1049 */
1050 static __u32 imsm_min_reserved_sectors(struct intel_super *super)
1051 {
1052 struct extent *e;
1053 int i;
1054 unsigned long long min_active;
1055 __u32 remainder;
1056 __u32 rv = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
1057 struct dl *dl, *dl_min = NULL;
1058
1059 if (!super)
1060 return rv;
1061
1062 min_active = 0;
1063 for (dl = super->disks; dl; dl = dl->next) {
1064 if (dl->index < 0)
1065 continue;
1066 unsigned long long blocks = total_blocks(&dl->disk);
1067 if (blocks < min_active || min_active == 0) {
1068 dl_min = dl;
1069 min_active = blocks;
1070 }
1071 }
1072 if (!dl_min)
1073 return rv;
1074
1075 /* find last lba used by subarrays on the smallest active disk */
1076 e = get_extents(super, dl_min);
1077 if (!e)
1078 return rv;
1079 for (i = 0; e[i].size; i++)
1080 continue;
1081
1082 remainder = min_active - e[i].start;
1083 free(e);
1084
1085 /* to give priority to recovery we should not require full
1086 IMSM_RESERVED_SECTORS from the spare */
1087 rv = MPB_SECTOR_CNT + NUM_BLOCKS_DIRTY_STRIPE_REGION;
1088
1089 /* if real reservation is smaller use that value */
1090 return (remainder < rv) ? remainder : rv;
1091 }
1092
1093 /* Return minimum size of a spare that can be used in this array*/
1094 static unsigned long long min_acceptable_spare_size_imsm(struct supertype *st)
1095 {
1096 struct intel_super *super = st->sb;
1097 struct dl *dl;
1098 struct extent *e;
1099 int i;
1100 unsigned long long rv = 0;
1101
1102 if (!super)
1103 return rv;
1104 /* find first active disk in array */
1105 dl = super->disks;
1106 while (dl && (is_failed(&dl->disk) || dl->index == -1))
1107 dl = dl->next;
1108 if (!dl)
1109 return rv;
1110 /* find last lba used by subarrays */
1111 e = get_extents(super, dl);
1112 if (!e)
1113 return rv;
1114 for (i = 0; e[i].size; i++)
1115 continue;
1116 if (i > 0)
1117 rv = e[i-1].start + e[i-1].size;
1118 free(e);
1119
1120 /* add the amount of space needed for metadata */
1121 rv = rv + imsm_min_reserved_sectors(super);
1122
1123 return rv * 512;
1124 }
1125
1126 static int is_gen_migration(struct imsm_dev *dev);
1127
1128 #ifndef MDASSEMBLE
1129 static __u64 blocks_per_migr_unit(struct intel_super *super,
1130 struct imsm_dev *dev);
1131
1132 static void print_imsm_dev(struct intel_super *super,
1133 struct imsm_dev *dev,
1134 char *uuid,
1135 int disk_idx)
1136 {
1137 __u64 sz;
1138 int slot, i;
1139 struct imsm_map *map = get_imsm_map(dev, MAP_0);
1140 struct imsm_map *map2 = get_imsm_map(dev, MAP_1);
1141 __u32 ord;
1142
1143 printf("\n");
1144 printf("[%.16s]:\n", dev->volume);
1145 printf(" UUID : %s\n", uuid);
1146 printf(" RAID Level : %d", get_imsm_raid_level(map));
1147 if (map2)
1148 printf(" <-- %d", get_imsm_raid_level(map2));
1149 printf("\n");
1150 printf(" Members : %d", map->num_members);
1151 if (map2)
1152 printf(" <-- %d", map2->num_members);
1153 printf("\n");
1154 printf(" Slots : [");
1155 for (i = 0; i < map->num_members; i++) {
1156 ord = get_imsm_ord_tbl_ent(dev, i, MAP_0);
1157 printf("%s", ord & IMSM_ORD_REBUILD ? "_" : "U");
1158 }
1159 printf("]");
1160 if (map2) {
1161 printf(" <-- [");
1162 for (i = 0; i < map2->num_members; i++) {
1163 ord = get_imsm_ord_tbl_ent(dev, i, MAP_1);
1164 printf("%s", ord & IMSM_ORD_REBUILD ? "_" : "U");
1165 }
1166 printf("]");
1167 }
1168 printf("\n");
1169 printf(" Failed disk : ");
1170 if (map->failed_disk_num == 0xff)
1171 printf("none");
1172 else
1173 printf("%i", map->failed_disk_num);
1174 printf("\n");
1175 slot = get_imsm_disk_slot(map, disk_idx);
1176 if (slot >= 0) {
1177 ord = get_imsm_ord_tbl_ent(dev, slot, MAP_X);
1178 printf(" This Slot : %d%s\n", slot,
1179 ord & IMSM_ORD_REBUILD ? " (out-of-sync)" : "");
1180 } else
1181 printf(" This Slot : ?\n");
1182 sz = __le32_to_cpu(dev->size_high);
1183 sz <<= 32;
1184 sz += __le32_to_cpu(dev->size_low);
1185 printf(" Array Size : %llu%s\n", (unsigned long long)sz,
1186 human_size(sz * 512));
1187 sz = blocks_per_member(map);
1188 printf(" Per Dev Size : %llu%s\n", (unsigned long long)sz,
1189 human_size(sz * 512));
1190 printf(" Sector Offset : %llu\n",
1191 pba_of_lba0(map));
1192 printf(" Num Stripes : %llu\n",
1193 num_data_stripes(map));
1194 printf(" Chunk Size : %u KiB",
1195 __le16_to_cpu(map->blocks_per_strip) / 2);
1196 if (map2)
1197 printf(" <-- %u KiB",
1198 __le16_to_cpu(map2->blocks_per_strip) / 2);
1199 printf("\n");
1200 printf(" Reserved : %d\n", __le32_to_cpu(dev->reserved_blocks));
1201 printf(" Migrate State : ");
1202 if (dev->vol.migr_state) {
1203 if (migr_type(dev) == MIGR_INIT)
1204 printf("initialize\n");
1205 else if (migr_type(dev) == MIGR_REBUILD)
1206 printf("rebuild\n");
1207 else if (migr_type(dev) == MIGR_VERIFY)
1208 printf("check\n");
1209 else if (migr_type(dev) == MIGR_GEN_MIGR)
1210 printf("general migration\n");
1211 else if (migr_type(dev) == MIGR_STATE_CHANGE)
1212 printf("state change\n");
1213 else if (migr_type(dev) == MIGR_REPAIR)
1214 printf("repair\n");
1215 else
1216 printf("<unknown:%d>\n", migr_type(dev));
1217 } else
1218 printf("idle\n");
1219 printf(" Map State : %s", map_state_str[map->map_state]);
1220 if (dev->vol.migr_state) {
1221 struct imsm_map *map = get_imsm_map(dev, MAP_1);
1222
1223 printf(" <-- %s", map_state_str[map->map_state]);
1224 printf("\n Checkpoint : %u ",
1225 __le32_to_cpu(dev->vol.curr_migr_unit));
1226 if ((is_gen_migration(dev)) && ((slot > 1) || (slot < 0)))
1227 printf("(N/A)");
1228 else
1229 printf("(%llu)", (unsigned long long)
1230 blocks_per_migr_unit(super, dev));
1231 }
1232 printf("\n");
1233 printf(" Dirty State : %s\n", dev->vol.dirty ? "dirty" : "clean");
1234 }
1235
1236 static void print_imsm_disk(struct imsm_disk *disk, int index, __u32 reserved)
1237 {
1238 char str[MAX_RAID_SERIAL_LEN + 1];
1239 __u64 sz;
1240
1241 if (index < -1 || !disk)
1242 return;
1243
1244 printf("\n");
1245 snprintf(str, MAX_RAID_SERIAL_LEN + 1, "%s", disk->serial);
1246 if (index >= 0)
1247 printf(" Disk%02d Serial : %s\n", index, str);
1248 else
1249 printf(" Disk Serial : %s\n", str);
1250 printf(" State :%s%s%s\n", is_spare(disk) ? " spare" : "",
1251 is_configured(disk) ? " active" : "",
1252 is_failed(disk) ? " failed" : "");
1253 printf(" Id : %08x\n", __le32_to_cpu(disk->scsi_id));
1254 sz = total_blocks(disk) - reserved;
1255 printf(" Usable Size : %llu%s\n", (unsigned long long)sz,
1256 human_size(sz * 512));
1257 }
1258
1259 void examine_migr_rec_imsm(struct intel_super *super)
1260 {
1261 struct migr_record *migr_rec = super->migr_rec;
1262 struct imsm_super *mpb = super->anchor;
1263 int i;
1264
1265 for (i = 0; i < mpb->num_raid_devs; i++) {
1266 struct imsm_dev *dev = __get_imsm_dev(mpb, i);
1267 struct imsm_map *map;
1268 int slot = -1;
1269
1270 if (is_gen_migration(dev) == 0)
1271 continue;
1272
1273 printf("\nMigration Record Information:");
1274
1275 /* first map under migration */
1276 map = get_imsm_map(dev, MAP_0);
1277 if (map)
1278 slot = get_imsm_disk_slot(map, super->disks->index);
1279 if ((map == NULL) || (slot > 1) || (slot < 0)) {
1280 printf(" Empty\n ");
1281 printf("Examine one of first two disks in array\n");
1282 break;
1283 }
1284 printf("\n Status : ");
1285 if (__le32_to_cpu(migr_rec->rec_status) == UNIT_SRC_NORMAL)
1286 printf("Normal\n");
1287 else
1288 printf("Contains Data\n");
1289 printf(" Current Unit : %u\n",
1290 __le32_to_cpu(migr_rec->curr_migr_unit));
1291 printf(" Family : %u\n",
1292 __le32_to_cpu(migr_rec->family_num));
1293 printf(" Ascending : %u\n",
1294 __le32_to_cpu(migr_rec->ascending_migr));
1295 printf(" Blocks Per Unit : %u\n",
1296 __le32_to_cpu(migr_rec->blocks_per_unit));
1297 printf(" Dest. Depth Per Unit : %u\n",
1298 __le32_to_cpu(migr_rec->dest_depth_per_unit));
1299 printf(" Checkpoint Area pba : %u\n",
1300 __le32_to_cpu(migr_rec->ckpt_area_pba));
1301 printf(" First member lba : %u\n",
1302 __le32_to_cpu(migr_rec->dest_1st_member_lba));
1303 printf(" Total Number of Units : %u\n",
1304 __le32_to_cpu(migr_rec->num_migr_units));
1305 printf(" Size of volume : %u\n",
1306 __le32_to_cpu(migr_rec->post_migr_vol_cap));
1307 printf(" Expansion space for LBA64 : %u\n",
1308 __le32_to_cpu(migr_rec->post_migr_vol_cap_hi));
1309 printf(" Record was read from : %u\n",
1310 __le32_to_cpu(migr_rec->ckpt_read_disk_num));
1311
1312 break;
1313 }
1314 }
1315 #endif /* MDASSEMBLE */
1316 /*******************************************************************************
1317 * function: imsm_check_attributes
1318 * Description: Function checks if features represented by attributes flags
1319 * are supported by mdadm.
1320 * Parameters:
1321 * attributes - Attributes read from metadata
1322 * Returns:
1323 * 0 - passed attributes contains unsupported features flags
1324 * 1 - all features are supported
1325 ******************************************************************************/
1326 static int imsm_check_attributes(__u32 attributes)
1327 {
1328 int ret_val = 1;
1329 __u32 not_supported = MPB_ATTRIB_SUPPORTED^0xffffffff;
1330
1331 not_supported &= ~MPB_ATTRIB_IGNORED;
1332
1333 not_supported &= attributes;
1334 if (not_supported) {
1335 pr_err("(IMSM): Unsupported attributes : %x\n",
1336 (unsigned)__le32_to_cpu(not_supported));
1337 if (not_supported & MPB_ATTRIB_CHECKSUM_VERIFY) {
1338 dprintf("\t\tMPB_ATTRIB_CHECKSUM_VERIFY \n");
1339 not_supported ^= MPB_ATTRIB_CHECKSUM_VERIFY;
1340 }
1341 if (not_supported & MPB_ATTRIB_2TB) {
1342 dprintf("\t\tMPB_ATTRIB_2TB\n");
1343 not_supported ^= MPB_ATTRIB_2TB;
1344 }
1345 if (not_supported & MPB_ATTRIB_RAID0) {
1346 dprintf("\t\tMPB_ATTRIB_RAID0\n");
1347 not_supported ^= MPB_ATTRIB_RAID0;
1348 }
1349 if (not_supported & MPB_ATTRIB_RAID1) {
1350 dprintf("\t\tMPB_ATTRIB_RAID1\n");
1351 not_supported ^= MPB_ATTRIB_RAID1;
1352 }
1353 if (not_supported & MPB_ATTRIB_RAID10) {
1354 dprintf("\t\tMPB_ATTRIB_RAID10\n");
1355 not_supported ^= MPB_ATTRIB_RAID10;
1356 }
1357 if (not_supported & MPB_ATTRIB_RAID1E) {
1358 dprintf("\t\tMPB_ATTRIB_RAID1E\n");
1359 not_supported ^= MPB_ATTRIB_RAID1E;
1360 }
1361 if (not_supported & MPB_ATTRIB_RAID5) {
1362 dprintf("\t\tMPB_ATTRIB_RAID5\n");
1363 not_supported ^= MPB_ATTRIB_RAID5;
1364 }
1365 if (not_supported & MPB_ATTRIB_RAIDCNG) {
1366 dprintf("\t\tMPB_ATTRIB_RAIDCNG\n");
1367 not_supported ^= MPB_ATTRIB_RAIDCNG;
1368 }
1369 if (not_supported & MPB_ATTRIB_BBM) {
1370 dprintf("\t\tMPB_ATTRIB_BBM\n");
1371 not_supported ^= MPB_ATTRIB_BBM;
1372 }
1373 if (not_supported & MPB_ATTRIB_CHECKSUM_VERIFY) {
1374 dprintf("\t\tMPB_ATTRIB_CHECKSUM_VERIFY (== MPB_ATTRIB_LEGACY)\n");
1375 not_supported ^= MPB_ATTRIB_CHECKSUM_VERIFY;
1376 }
1377 if (not_supported & MPB_ATTRIB_EXP_STRIPE_SIZE) {
1378 dprintf("\t\tMPB_ATTRIB_EXP_STRIP_SIZE\n");
1379 not_supported ^= MPB_ATTRIB_EXP_STRIPE_SIZE;
1380 }
1381 if (not_supported & MPB_ATTRIB_2TB_DISK) {
1382 dprintf("\t\tMPB_ATTRIB_2TB_DISK\n");
1383 not_supported ^= MPB_ATTRIB_2TB_DISK;
1384 }
1385 if (not_supported & MPB_ATTRIB_NEVER_USE2) {
1386 dprintf("\t\tMPB_ATTRIB_NEVER_USE2\n");
1387 not_supported ^= MPB_ATTRIB_NEVER_USE2;
1388 }
1389 if (not_supported & MPB_ATTRIB_NEVER_USE) {
1390 dprintf("\t\tMPB_ATTRIB_NEVER_USE\n");
1391 not_supported ^= MPB_ATTRIB_NEVER_USE;
1392 }
1393
1394 if (not_supported)
1395 dprintf("(IMSM): Unknown attributes : %x\n", not_supported);
1396
1397 ret_val = 0;
1398 }
1399
1400 return ret_val;
1401 }
1402
1403 #ifndef MDASSEMBLE
1404 static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info, char *map);
1405
1406 static void examine_super_imsm(struct supertype *st, char *homehost)
1407 {
1408 struct intel_super *super = st->sb;
1409 struct imsm_super *mpb = super->anchor;
1410 char str[MAX_SIGNATURE_LENGTH];
1411 int i;
1412 struct mdinfo info;
1413 char nbuf[64];
1414 __u32 sum;
1415 __u32 reserved = imsm_reserved_sectors(super, super->disks);
1416 struct dl *dl;
1417
1418 snprintf(str, MPB_SIG_LEN, "%s", mpb->sig);
1419 printf(" Magic : %s\n", str);
1420 snprintf(str, strlen(MPB_VERSION_RAID0), "%s", get_imsm_version(mpb));
1421 printf(" Version : %s\n", get_imsm_version(mpb));
1422 printf(" Orig Family : %08x\n", __le32_to_cpu(mpb->orig_family_num));
1423 printf(" Family : %08x\n", __le32_to_cpu(mpb->family_num));
1424 printf(" Generation : %08x\n", __le32_to_cpu(mpb->generation_num));
1425 printf(" Attributes : ");
1426 if (imsm_check_attributes(mpb->attributes))
1427 printf("All supported\n");
1428 else
1429 printf("not supported\n");
1430 getinfo_super_imsm(st, &info, NULL);
1431 fname_from_uuid(st, &info, nbuf, ':');
1432 printf(" UUID : %s\n", nbuf + 5);
1433 sum = __le32_to_cpu(mpb->check_sum);
1434 printf(" Checksum : %08x %s\n", sum,
1435 __gen_imsm_checksum(mpb) == sum ? "correct" : "incorrect");
1436 printf(" MPB Sectors : %d\n", mpb_sectors(mpb));
1437 printf(" Disks : %d\n", mpb->num_disks);
1438 printf(" RAID Devices : %d\n", mpb->num_raid_devs);
1439 print_imsm_disk(__get_imsm_disk(mpb, super->disks->index), super->disks->index, reserved);
1440 if (super->bbm_log) {
1441 struct bbm_log *log = super->bbm_log;
1442
1443 printf("\n");
1444 printf("Bad Block Management Log:\n");
1445 printf(" Log Size : %d\n", __le32_to_cpu(mpb->bbm_log_size));
1446 printf(" Signature : %x\n", __le32_to_cpu(log->signature));
1447 printf(" Entry Count : %d\n", __le32_to_cpu(log->entry_count));
1448 printf(" Spare Blocks : %d\n", __le32_to_cpu(log->reserved_spare_block_count));
1449 printf(" First Spare : %llx\n",
1450 (unsigned long long) __le64_to_cpu(log->first_spare_lba));
1451 }
1452 for (i = 0; i < mpb->num_raid_devs; i++) {
1453 struct mdinfo info;
1454 struct imsm_dev *dev = __get_imsm_dev(mpb, i);
1455
1456 super->current_vol = i;
1457 getinfo_super_imsm(st, &info, NULL);
1458 fname_from_uuid(st, &info, nbuf, ':');
1459 print_imsm_dev(super, dev, nbuf + 5, super->disks->index);
1460 }
1461 for (i = 0; i < mpb->num_disks; i++) {
1462 if (i == super->disks->index)
1463 continue;
1464 print_imsm_disk(__get_imsm_disk(mpb, i), i, reserved);
1465 }
1466
1467 for (dl = super->disks; dl; dl = dl->next)
1468 if (dl->index == -1)
1469 print_imsm_disk(&dl->disk, -1, reserved);
1470
1471 examine_migr_rec_imsm(super);
1472 }
1473
1474 static void brief_examine_super_imsm(struct supertype *st, int verbose)
1475 {
1476 /* We just write a generic IMSM ARRAY entry */
1477 struct mdinfo info;
1478 char nbuf[64];
1479 struct intel_super *super = st->sb;
1480
1481 if (!super->anchor->num_raid_devs) {
1482 printf("ARRAY metadata=imsm\n");
1483 return;
1484 }
1485
1486 getinfo_super_imsm(st, &info, NULL);
1487 fname_from_uuid(st, &info, nbuf, ':');
1488 printf("ARRAY metadata=imsm UUID=%s\n", nbuf + 5);
1489 }
1490
1491 static void brief_examine_subarrays_imsm(struct supertype *st, int verbose)
1492 {
1493 /* We just write a generic IMSM ARRAY entry */
1494 struct mdinfo info;
1495 char nbuf[64];
1496 char nbuf1[64];
1497 struct intel_super *super = st->sb;
1498 int i;
1499
1500 if (!super->anchor->num_raid_devs)
1501 return;
1502
1503 getinfo_super_imsm(st, &info, NULL);
1504 fname_from_uuid(st, &info, nbuf, ':');
1505 for (i = 0; i < super->anchor->num_raid_devs; i++) {
1506 struct imsm_dev *dev = get_imsm_dev(super, i);
1507
1508 super->current_vol = i;
1509 getinfo_super_imsm(st, &info, NULL);
1510 fname_from_uuid(st, &info, nbuf1, ':');
1511 printf("ARRAY /dev/md/%.16s container=%s member=%d UUID=%s\n",
1512 dev->volume, nbuf + 5, i, nbuf1 + 5);
1513 }
1514 }
1515
1516 static void export_examine_super_imsm(struct supertype *st)
1517 {
1518 struct intel_super *super = st->sb;
1519 struct imsm_super *mpb = super->anchor;
1520 struct mdinfo info;
1521 char nbuf[64];
1522
1523 getinfo_super_imsm(st, &info, NULL);
1524 fname_from_uuid(st, &info, nbuf, ':');
1525 printf("MD_METADATA=imsm\n");
1526 printf("MD_LEVEL=container\n");
1527 printf("MD_UUID=%s\n", nbuf+5);
1528 printf("MD_DEVICES=%u\n", mpb->num_disks);
1529 }
1530
1531 static int copy_metadata_imsm(struct supertype *st, int from, int to)
1532 {
1533 /* The second last 512byte sector of the device contains
1534 * the "struct imsm_super" metadata.
1535 * This contains mpb_size which is the size in bytes of the
1536 * extended metadata. This is located immediately before
1537 * the imsm_super.
1538 * We want to read all that, plus the last sector which
1539 * may contain a migration record, and write it all
1540 * to the target.
1541 */
1542 void *buf;
1543 unsigned long long dsize, offset;
1544 int sectors;
1545 struct imsm_super *sb;
1546 int written = 0;
1547
1548 if (posix_memalign(&buf, 4096, 4096) != 0)
1549 return 1;
1550
1551 if (!get_dev_size(from, NULL, &dsize))
1552 goto err;
1553
1554 if (lseek64(from, dsize-1024, 0) < 0)
1555 goto err;
1556 if (read(from, buf, 512) != 512)
1557 goto err;
1558 sb = buf;
1559 if (strncmp((char*)sb->sig, MPB_SIGNATURE, MPB_SIG_LEN) != 0)
1560 goto err;
1561
1562 sectors = mpb_sectors(sb) + 2;
1563 offset = dsize - sectors * 512;
1564 if (lseek64(from, offset, 0) < 0 ||
1565 lseek64(to, offset, 0) < 0)
1566 goto err;
1567 while (written < sectors * 512) {
1568 int n = sectors*512 - written;
1569 if (n > 4096)
1570 n = 4096;
1571 if (read(from, buf, n) != n)
1572 goto err;
1573 if (write(to, buf, n) != n)
1574 goto err;
1575 written += n;
1576 }
1577 free(buf);
1578 return 0;
1579 err:
1580 free(buf);
1581 return 1;
1582 }
1583
1584 static void detail_super_imsm(struct supertype *st, char *homehost)
1585 {
1586 struct mdinfo info;
1587 char nbuf[64];
1588
1589 getinfo_super_imsm(st, &info, NULL);
1590 fname_from_uuid(st, &info, nbuf, ':');
1591 printf("\n UUID : %s\n", nbuf + 5);
1592 }
1593
1594 static void brief_detail_super_imsm(struct supertype *st)
1595 {
1596 struct mdinfo info;
1597 char nbuf[64];
1598 getinfo_super_imsm(st, &info, NULL);
1599 fname_from_uuid(st, &info, nbuf, ':');
1600 printf(" UUID=%s", nbuf + 5);
1601 }
1602
1603 static int imsm_read_serial(int fd, char *devname, __u8 *serial);
1604 static void fd2devname(int fd, char *name);
1605
1606 static int ahci_enumerate_ports(const char *hba_path, int port_count, int host_base, int verbose)
1607 {
1608 /* dump an unsorted list of devices attached to AHCI Intel storage
1609 * controller, as well as non-connected ports
1610 */
1611 int hba_len = strlen(hba_path) + 1;
1612 struct dirent *ent;
1613 DIR *dir;
1614 char *path = NULL;
1615 int err = 0;
1616 unsigned long port_mask = (1 << port_count) - 1;
1617
1618 if (port_count > (int)sizeof(port_mask) * 8) {
1619 if (verbose > 0)
1620 pr_err("port_count %d out of range\n", port_count);
1621 return 2;
1622 }
1623
1624 /* scroll through /sys/dev/block looking for devices attached to
1625 * this hba
1626 */
1627 dir = opendir("/sys/dev/block");
1628 if (!dir)
1629 return 1;
1630
1631 for (ent = readdir(dir); ent; ent = readdir(dir)) {
1632 int fd;
1633 char model[64];
1634 char vendor[64];
1635 char buf[1024];
1636 int major, minor;
1637 char *device;
1638 char *c;
1639 int port;
1640 int type;
1641
1642 if (sscanf(ent->d_name, "%d:%d", &major, &minor) != 2)
1643 continue;
1644 path = devt_to_devpath(makedev(major, minor));
1645 if (!path)
1646 continue;
1647 if (!path_attached_to_hba(path, hba_path)) {
1648 free(path);
1649 path = NULL;
1650 continue;
1651 }
1652
1653 /* retrieve the scsi device type */
1654 if (asprintf(&device, "/sys/dev/block/%d:%d/device/xxxxxxx", major, minor) < 0) {
1655 if (verbose > 0)
1656 pr_err("failed to allocate 'device'\n");
1657 err = 2;
1658 break;
1659 }
1660 sprintf(device, "/sys/dev/block/%d:%d/device/type", major, minor);
1661 if (load_sys(device, buf, sizeof(buf)) != 0) {
1662 if (verbose > 0)
1663 pr_err("failed to read device type for %s\n",
1664 path);
1665 err = 2;
1666 free(device);
1667 break;
1668 }
1669 type = strtoul(buf, NULL, 10);
1670
1671 /* if it's not a disk print the vendor and model */
1672 if (!(type == 0 || type == 7 || type == 14)) {
1673 vendor[0] = '\0';
1674 model[0] = '\0';
1675 sprintf(device, "/sys/dev/block/%d:%d/device/vendor", major, minor);
1676 if (load_sys(device, buf, sizeof(buf)) == 0) {
1677 strncpy(vendor, buf, sizeof(vendor));
1678 vendor[sizeof(vendor) - 1] = '\0';
1679 c = (char *) &vendor[sizeof(vendor) - 1];
1680 while (isspace(*c) || *c == '\0')
1681 *c-- = '\0';
1682
1683 }
1684 sprintf(device, "/sys/dev/block/%d:%d/device/model", major, minor);
1685 if (load_sys(device, buf, sizeof(buf)) == 0) {
1686 strncpy(model, buf, sizeof(model));
1687 model[sizeof(model) - 1] = '\0';
1688 c = (char *) &model[sizeof(model) - 1];
1689 while (isspace(*c) || *c == '\0')
1690 *c-- = '\0';
1691 }
1692
1693 if (vendor[0] && model[0])
1694 sprintf(buf, "%.64s %.64s", vendor, model);
1695 else
1696 switch (type) { /* numbers from hald/linux/device.c */
1697 case 1: sprintf(buf, "tape"); break;
1698 case 2: sprintf(buf, "printer"); break;
1699 case 3: sprintf(buf, "processor"); break;
1700 case 4:
1701 case 5: sprintf(buf, "cdrom"); break;
1702 case 6: sprintf(buf, "scanner"); break;
1703 case 8: sprintf(buf, "media_changer"); break;
1704 case 9: sprintf(buf, "comm"); break;
1705 case 12: sprintf(buf, "raid"); break;
1706 default: sprintf(buf, "unknown");
1707 }
1708 } else
1709 buf[0] = '\0';
1710 free(device);
1711
1712 /* chop device path to 'host%d' and calculate the port number */
1713 c = strchr(&path[hba_len], '/');
1714 if (!c) {
1715 if (verbose > 0)
1716 pr_err("%s - invalid path name\n", path + hba_len);
1717 err = 2;
1718 break;
1719 }
1720 *c = '\0';
1721 if ((sscanf(&path[hba_len], "ata%d", &port) == 1) ||
1722 ((sscanf(&path[hba_len], "host%d", &port) == 1)))
1723 port -= host_base;
1724 else {
1725 if (verbose > 0) {
1726 *c = '/'; /* repair the full string */
1727 pr_err("failed to determine port number for %s\n",
1728 path);
1729 }
1730 err = 2;
1731 break;
1732 }
1733
1734 /* mark this port as used */
1735 port_mask &= ~(1 << port);
1736
1737 /* print out the device information */
1738 if (buf[0]) {
1739 printf(" Port%d : - non-disk device (%s) -\n", port, buf);
1740 continue;
1741 }
1742
1743 fd = dev_open(ent->d_name, O_RDONLY);
1744 if (fd < 0)
1745 printf(" Port%d : - disk info unavailable -\n", port);
1746 else {
1747 fd2devname(fd, buf);
1748 printf(" Port%d : %s", port, buf);
1749 if (imsm_read_serial(fd, NULL, (__u8 *) buf) == 0)
1750 printf(" (%.*s)\n", MAX_RAID_SERIAL_LEN, buf);
1751 else
1752 printf(" ()\n");
1753 close(fd);
1754 }
1755 free(path);
1756 path = NULL;
1757 }
1758 if (path)
1759 free(path);
1760 if (dir)
1761 closedir(dir);
1762 if (err == 0) {
1763 int i;
1764
1765 for (i = 0; i < port_count; i++)
1766 if (port_mask & (1 << i))
1767 printf(" Port%d : - no device attached -\n", i);
1768 }
1769
1770 return err;
1771 }
1772
1773 static int print_vmd_attached_devs(struct sys_dev *hba)
1774 {
1775 struct dirent *ent;
1776 DIR *dir;
1777 char path[292];
1778 char link[256];
1779 char *c, *rp;
1780
1781 if (hba->type != SYS_DEV_VMD)
1782 return 1;
1783
1784 /* scroll through /sys/dev/block looking for devices attached to
1785 * this hba
1786 */
1787 dir = opendir("/sys/bus/pci/drivers/nvme");
1788 if (!dir)
1789 return 1;
1790
1791 for (ent = readdir(dir); ent; ent = readdir(dir)) {
1792 int n;
1793
1794 /* is 'ent' a device? check that the 'subsystem' link exists and
1795 * that its target matches 'bus'
1796 */
1797 sprintf(path, "/sys/bus/pci/drivers/nvme/%s/subsystem",
1798 ent->d_name);
1799 n = readlink(path, link, sizeof(link));
1800 if (n < 0 || n >= (int)sizeof(link))
1801 continue;
1802 link[n] = '\0';
1803 c = strrchr(link, '/');
1804 if (!c)
1805 continue;
1806 if (strncmp("pci", c+1, strlen("pci")) != 0)
1807 continue;
1808
1809 sprintf(path, "/sys/bus/pci/drivers/nvme/%s", ent->d_name);
1810 /* if not a intel NVMe - skip it*/
1811 if (devpath_to_vendor(path) != 0x8086)
1812 continue;
1813
1814 rp = realpath(path, NULL);
1815 if (!rp)
1816 continue;
1817
1818 if (path_attached_to_hba(rp, hba->path)) {
1819 printf(" NVMe under VMD : %s\n", rp);
1820 }
1821 free(rp);
1822 }
1823
1824 closedir(dir);
1825 return 0;
1826 }
1827
1828 static void print_found_intel_controllers(struct sys_dev *elem)
1829 {
1830 for (; elem; elem = elem->next) {
1831 pr_err("found Intel(R) ");
1832 if (elem->type == SYS_DEV_SATA)
1833 fprintf(stderr, "SATA ");
1834 else if (elem->type == SYS_DEV_SAS)
1835 fprintf(stderr, "SAS ");
1836 else if (elem->type == SYS_DEV_NVME)
1837 fprintf(stderr, "NVMe ");
1838
1839 if (elem->type == SYS_DEV_VMD)
1840 fprintf(stderr, "VMD domain");
1841 else
1842 fprintf(stderr, "RAID controller");
1843
1844 if (elem->pci_id)
1845 fprintf(stderr, " at %s", elem->pci_id);
1846 fprintf(stderr, ".\n");
1847 }
1848 fflush(stderr);
1849 }
1850
1851 static int ahci_get_port_count(const char *hba_path, int *port_count)
1852 {
1853 struct dirent *ent;
1854 DIR *dir;
1855 int host_base = -1;
1856
1857 *port_count = 0;
1858 if ((dir = opendir(hba_path)) == NULL)
1859 return -1;
1860
1861 for (ent = readdir(dir); ent; ent = readdir(dir)) {
1862 int host;
1863
1864 if ((sscanf(ent->d_name, "ata%d", &host) != 1) &&
1865 ((sscanf(ent->d_name, "host%d", &host) != 1)))
1866 continue;
1867 if (*port_count == 0)
1868 host_base = host;
1869 else if (host < host_base)
1870 host_base = host;
1871
1872 if (host + 1 > *port_count + host_base)
1873 *port_count = host + 1 - host_base;
1874 }
1875 closedir(dir);
1876 return host_base;
1877 }
1878
1879 static void print_imsm_capability(const struct imsm_orom *orom)
1880 {
1881 printf(" Platform : Intel(R) ");
1882 if (orom->capabilities == 0 && orom->driver_features == 0)
1883 printf("Matrix Storage Manager\n");
1884 else
1885 printf("Rapid Storage Technology%s\n",
1886 imsm_orom_is_enterprise(orom) ? " enterprise" : "");
1887 if (orom->major_ver || orom->minor_ver || orom->hotfix_ver || orom->build)
1888 printf(" Version : %d.%d.%d.%d\n", orom->major_ver,
1889 orom->minor_ver, orom->hotfix_ver, orom->build);
1890 printf(" RAID Levels :%s%s%s%s%s\n",
1891 imsm_orom_has_raid0(orom) ? " raid0" : "",
1892 imsm_orom_has_raid1(orom) ? " raid1" : "",
1893 imsm_orom_has_raid1e(orom) ? " raid1e" : "",
1894 imsm_orom_has_raid10(orom) ? " raid10" : "",
1895 imsm_orom_has_raid5(orom) ? " raid5" : "");
1896 printf(" Chunk Sizes :%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
1897 imsm_orom_has_chunk(orom, 2) ? " 2k" : "",
1898 imsm_orom_has_chunk(orom, 4) ? " 4k" : "",
1899 imsm_orom_has_chunk(orom, 8) ? " 8k" : "",
1900 imsm_orom_has_chunk(orom, 16) ? " 16k" : "",
1901 imsm_orom_has_chunk(orom, 32) ? " 32k" : "",
1902 imsm_orom_has_chunk(orom, 64) ? " 64k" : "",
1903 imsm_orom_has_chunk(orom, 128) ? " 128k" : "",
1904 imsm_orom_has_chunk(orom, 256) ? " 256k" : "",
1905 imsm_orom_has_chunk(orom, 512) ? " 512k" : "",
1906 imsm_orom_has_chunk(orom, 1024*1) ? " 1M" : "",
1907 imsm_orom_has_chunk(orom, 1024*2) ? " 2M" : "",
1908 imsm_orom_has_chunk(orom, 1024*4) ? " 4M" : "",
1909 imsm_orom_has_chunk(orom, 1024*8) ? " 8M" : "",
1910 imsm_orom_has_chunk(orom, 1024*16) ? " 16M" : "",
1911 imsm_orom_has_chunk(orom, 1024*32) ? " 32M" : "",
1912 imsm_orom_has_chunk(orom, 1024*64) ? " 64M" : "");
1913 printf(" 2TB volumes :%s supported\n",
1914 (orom->attr & IMSM_OROM_ATTR_2TB)?"":" not");
1915 printf(" 2TB disks :%s supported\n",
1916 (orom->attr & IMSM_OROM_ATTR_2TB_DISK)?"":" not");
1917 printf(" Max Disks : %d\n", orom->tds);
1918 printf(" Max Volumes : %d per array, %d per %s\n",
1919 orom->vpa, orom->vphba,
1920 imsm_orom_is_nvme(orom) ? "platform" : "controller");
1921 return;
1922 }
1923
1924 static void print_imsm_capability_export(const struct imsm_orom *orom)
1925 {
1926 printf("MD_FIRMWARE_TYPE=imsm\n");
1927 if (orom->major_ver || orom->minor_ver || orom->hotfix_ver || orom->build)
1928 printf("IMSM_VERSION=%d.%d.%d.%d\n", orom->major_ver, orom->minor_ver,
1929 orom->hotfix_ver, orom->build);
1930 printf("IMSM_SUPPORTED_RAID_LEVELS=%s%s%s%s%s\n",
1931 imsm_orom_has_raid0(orom) ? "raid0 " : "",
1932 imsm_orom_has_raid1(orom) ? "raid1 " : "",
1933 imsm_orom_has_raid1e(orom) ? "raid1e " : "",
1934 imsm_orom_has_raid5(orom) ? "raid10 " : "",
1935 imsm_orom_has_raid10(orom) ? "raid5 " : "");
1936 printf("IMSM_SUPPORTED_CHUNK_SIZES=%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
1937 imsm_orom_has_chunk(orom, 2) ? "2k " : "",
1938 imsm_orom_has_chunk(orom, 4) ? "4k " : "",
1939 imsm_orom_has_chunk(orom, 8) ? "8k " : "",
1940 imsm_orom_has_chunk(orom, 16) ? "16k " : "",
1941 imsm_orom_has_chunk(orom, 32) ? "32k " : "",
1942 imsm_orom_has_chunk(orom, 64) ? "64k " : "",
1943 imsm_orom_has_chunk(orom, 128) ? "128k " : "",
1944 imsm_orom_has_chunk(orom, 256) ? "256k " : "",
1945 imsm_orom_has_chunk(orom, 512) ? "512k " : "",
1946 imsm_orom_has_chunk(orom, 1024*1) ? "1M " : "",
1947 imsm_orom_has_chunk(orom, 1024*2) ? "2M " : "",
1948 imsm_orom_has_chunk(orom, 1024*4) ? "4M " : "",
1949 imsm_orom_has_chunk(orom, 1024*8) ? "8M " : "",
1950 imsm_orom_has_chunk(orom, 1024*16) ? "16M " : "",
1951 imsm_orom_has_chunk(orom, 1024*32) ? "32M " : "",
1952 imsm_orom_has_chunk(orom, 1024*64) ? "64M " : "");
1953 printf("IMSM_2TB_VOLUMES=%s\n",(orom->attr & IMSM_OROM_ATTR_2TB) ? "yes" : "no");
1954 printf("IMSM_2TB_DISKS=%s\n",(orom->attr & IMSM_OROM_ATTR_2TB_DISK) ? "yes" : "no");
1955 printf("IMSM_MAX_DISKS=%d\n",orom->tds);
1956 printf("IMSM_MAX_VOLUMES_PER_ARRAY=%d\n",orom->vpa);
1957 printf("IMSM_MAX_VOLUMES_PER_CONTROLLER=%d\n",orom->vphba);
1958 }
1959
1960 static int detail_platform_imsm(int verbose, int enumerate_only, char *controller_path)
1961 {
1962 /* There are two components to imsm platform support, the ahci SATA
1963 * controller and the option-rom. To find the SATA controller we
1964 * simply look in /sys/bus/pci/drivers/ahci to see if an ahci
1965 * controller with the Intel vendor id is present. This approach
1966 * allows mdadm to leverage the kernel's ahci detection logic, with the
1967 * caveat that if ahci.ko is not loaded mdadm will not be able to
1968 * detect platform raid capabilities. The option-rom resides in a
1969 * platform "Adapter ROM". We scan for its signature to retrieve the
1970 * platform capabilities. If raid support is disabled in the BIOS the
1971 * option-rom capability structure will not be available.
1972 */
1973 struct sys_dev *list, *hba;
1974 int host_base = 0;
1975 int port_count = 0;
1976 int result=1;
1977
1978 if (enumerate_only) {
1979 if (check_env("IMSM_NO_PLATFORM"))
1980 return 0;
1981 list = find_intel_devices();
1982 if (!list)
1983 return 2;
1984 for (hba = list; hba; hba = hba->next) {
1985 if (find_imsm_capability(hba)) {
1986 result = 0;
1987 break;
1988 }
1989 else
1990 result = 2;
1991 }
1992 return result;
1993 }
1994
1995 list = find_intel_devices();
1996 if (!list) {
1997 if (verbose > 0)
1998 pr_err("no active Intel(R) RAID controller found.\n");
1999 return 2;
2000 } else if (verbose > 0)
2001 print_found_intel_controllers(list);
2002
2003 for (hba = list; hba; hba = hba->next) {
2004 if (controller_path && (compare_paths(hba->path, controller_path) != 0))
2005 continue;
2006 if (!find_imsm_capability(hba)) {
2007 char buf[PATH_MAX];
2008 pr_err("imsm capabilities not found for controller: %s (type %s)\n",
2009 hba->type == SYS_DEV_VMD ? vmd_domain_to_controller(hba, buf) : hba->path,
2010 get_sys_dev_type(hba->type));
2011 continue;
2012 }
2013 result = 0;
2014 }
2015
2016 if (controller_path && result == 1) {
2017 pr_err("no active Intel(R) RAID controller found under %s\n",
2018 controller_path);
2019 return result;
2020 }
2021
2022 const struct orom_entry *entry;
2023
2024 for (entry = orom_entries; entry; entry = entry->next) {
2025 if (entry->type == SYS_DEV_VMD) {
2026 for (hba = list; hba; hba = hba->next) {
2027 if (hba->type == SYS_DEV_VMD) {
2028 char buf[PATH_MAX];
2029 print_imsm_capability(&entry->orom);
2030 printf(" I/O Controller : %s (%s)\n",
2031 vmd_domain_to_controller(hba, buf), get_sys_dev_type(hba->type));
2032 if (print_vmd_attached_devs(hba)) {
2033 if (verbose > 0)
2034 pr_err("failed to get devices attached to VMD domain.\n");
2035 result |= 2;
2036 }
2037 printf("\n");
2038 }
2039 }
2040 continue;
2041 }
2042
2043 print_imsm_capability(&entry->orom);
2044 if (entry->type == SYS_DEV_NVME) {
2045 for (hba = list; hba; hba = hba->next) {
2046 if (hba->type == SYS_DEV_NVME)
2047 printf(" NVMe Device : %s\n", hba->path);
2048 }
2049 printf("\n");
2050 continue;
2051 }
2052
2053 struct devid_list *devid;
2054 for (devid = entry->devid_list; devid; devid = devid->next) {
2055 hba = device_by_id(devid->devid);
2056 if (!hba)
2057 continue;
2058
2059 printf(" I/O Controller : %s (%s)\n",
2060 hba->path, get_sys_dev_type(hba->type));
2061 if (hba->type == SYS_DEV_SATA) {
2062 host_base = ahci_get_port_count(hba->path, &port_count);
2063 if (ahci_enumerate_ports(hba->path, port_count, host_base, verbose)) {
2064 if (verbose > 0)
2065 pr_err("failed to enumerate ports on SATA controller at %s.\n", hba->pci_id);
2066 result |= 2;
2067 }
2068 }
2069 }
2070 printf("\n");
2071 }
2072
2073 return result;
2074 }
2075
2076 static int export_detail_platform_imsm(int verbose, char *controller_path)
2077 {
2078 struct sys_dev *list, *hba;
2079 int result=1;
2080
2081 list = find_intel_devices();
2082 if (!list) {
2083 if (verbose > 0)
2084 pr_err("IMSM_DETAIL_PLATFORM_ERROR=NO_INTEL_DEVICES\n");
2085 result = 2;
2086 return result;
2087 }
2088
2089 for (hba = list; hba; hba = hba->next) {
2090 if (controller_path && (compare_paths(hba->path,controller_path) != 0))
2091 continue;
2092 if (!find_imsm_capability(hba) && verbose > 0) {
2093 char buf[PATH_MAX];
2094 pr_err("IMSM_DETAIL_PLATFORM_ERROR=NO_IMSM_CAPABLE_DEVICE_UNDER_%s\n",
2095 hba->type == SYS_DEV_VMD ? vmd_domain_to_controller(hba, buf) : hba->path);
2096 }
2097 else
2098 result = 0;
2099 }
2100
2101 const struct orom_entry *entry;
2102
2103 for (entry = orom_entries; entry; entry = entry->next) {
2104 if (entry->type == SYS_DEV_VMD) {
2105 for (hba = list; hba; hba = hba->next)
2106 print_imsm_capability_export(&entry->orom);
2107 continue;
2108 }
2109 print_imsm_capability_export(&entry->orom);
2110 }
2111
2112 return result;
2113 }
2114
2115 #endif
2116
2117 static int match_home_imsm(struct supertype *st, char *homehost)
2118 {
2119 /* the imsm metadata format does not specify any host
2120 * identification information. We return -1 since we can never
2121 * confirm nor deny whether a given array is "meant" for this
2122 * host. We rely on compare_super and the 'family_num' fields to
2123 * exclude member disks that do not belong, and we rely on
2124 * mdadm.conf to specify the arrays that should be assembled.
2125 * Auto-assembly may still pick up "foreign" arrays.
2126 */
2127
2128 return -1;
2129 }
2130
2131 static void uuid_from_super_imsm(struct supertype *st, int uuid[4])
2132 {
2133 /* The uuid returned here is used for:
2134 * uuid to put into bitmap file (Create, Grow)
2135 * uuid for backup header when saving critical section (Grow)
2136 * comparing uuids when re-adding a device into an array
2137 * In these cases the uuid required is that of the data-array,
2138 * not the device-set.
2139 * uuid to recognise same set when adding a missing device back
2140 * to an array. This is a uuid for the device-set.
2141 *
2142 * For each of these we can make do with a truncated
2143 * or hashed uuid rather than the original, as long as
2144 * everyone agrees.
2145 * In each case the uuid required is that of the data-array,
2146 * not the device-set.
2147 */
2148 /* imsm does not track uuid's so we synthesis one using sha1 on
2149 * - The signature (Which is constant for all imsm array, but no matter)
2150 * - the orig_family_num of the container
2151 * - the index number of the volume
2152 * - the 'serial' number of the volume.
2153 * Hopefully these are all constant.
2154 */
2155 struct intel_super *super = st->sb;
2156
2157 char buf[20];
2158 struct sha1_ctx ctx;
2159 struct imsm_dev *dev = NULL;
2160 __u32 family_num;
2161
2162 /* some mdadm versions failed to set ->orig_family_num, in which
2163 * case fall back to ->family_num. orig_family_num will be
2164 * fixed up with the first metadata update.
2165 */
2166 family_num = super->anchor->orig_family_num;
2167 if (family_num == 0)
2168 family_num = super->anchor->family_num;
2169 sha1_init_ctx(&ctx);
2170 sha1_process_bytes(super->anchor->sig, MPB_SIG_LEN, &ctx);
2171 sha1_process_bytes(&family_num, sizeof(__u32), &ctx);
2172 if (super->current_vol >= 0)
2173 dev = get_imsm_dev(super, super->current_vol);
2174 if (dev) {
2175 __u32 vol = super->current_vol;
2176 sha1_process_bytes(&vol, sizeof(vol), &ctx);
2177 sha1_process_bytes(dev->volume, MAX_RAID_SERIAL_LEN, &ctx);
2178 }
2179 sha1_finish_ctx(&ctx, buf);
2180 memcpy(uuid, buf, 4*4);
2181 }
2182
2183 #if 0
2184 static void
2185 get_imsm_numerical_version(struct imsm_super *mpb, int *m, int *p)
2186 {
2187 __u8 *v = get_imsm_version(mpb);
2188 __u8 *end = mpb->sig + MAX_SIGNATURE_LENGTH;
2189 char major[] = { 0, 0, 0 };
2190 char minor[] = { 0 ,0, 0 };
2191 char patch[] = { 0, 0, 0 };
2192 char *ver_parse[] = { major, minor, patch };
2193 int i, j;
2194
2195 i = j = 0;
2196 while (*v != '\0' && v < end) {
2197 if (*v != '.' && j < 2)
2198 ver_parse[i][j++] = *v;
2199 else {
2200 i++;
2201 j = 0;
2202 }
2203 v++;
2204 }
2205
2206 *m = strtol(minor, NULL, 0);
2207 *p = strtol(patch, NULL, 0);
2208 }
2209 #endif
2210
2211 static __u32 migr_strip_blocks_resync(struct imsm_dev *dev)
2212 {
2213 /* migr_strip_size when repairing or initializing parity */
2214 struct imsm_map *map = get_imsm_map(dev, MAP_0);
2215 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
2216
2217 switch (get_imsm_raid_level(map)) {
2218 case 5:
2219 case 10:
2220 return chunk;
2221 default:
2222 return 128*1024 >> 9;
2223 }
2224 }
2225
2226 static __u32 migr_strip_blocks_rebuild(struct imsm_dev *dev)
2227 {
2228 /* migr_strip_size when rebuilding a degraded disk, no idea why
2229 * this is different than migr_strip_size_resync(), but it's good
2230 * to be compatible
2231 */
2232 struct imsm_map *map = get_imsm_map(dev, MAP_1);
2233 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
2234
2235 switch (get_imsm_raid_level(map)) {
2236 case 1:
2237 case 10:
2238 if (map->num_members % map->num_domains == 0)
2239 return 128*1024 >> 9;
2240 else
2241 return chunk;
2242 case 5:
2243 return max((__u32) 64*1024 >> 9, chunk);
2244 default:
2245 return 128*1024 >> 9;
2246 }
2247 }
2248
2249 static __u32 num_stripes_per_unit_resync(struct imsm_dev *dev)
2250 {
2251 struct imsm_map *lo = get_imsm_map(dev, MAP_0);
2252 struct imsm_map *hi = get_imsm_map(dev, MAP_1);
2253 __u32 lo_chunk = __le32_to_cpu(lo->blocks_per_strip);
2254 __u32 hi_chunk = __le32_to_cpu(hi->blocks_per_strip);
2255
2256 return max((__u32) 1, hi_chunk / lo_chunk);
2257 }
2258
2259 static __u32 num_stripes_per_unit_rebuild(struct imsm_dev *dev)
2260 {
2261 struct imsm_map *lo = get_imsm_map(dev, MAP_0);
2262 int level = get_imsm_raid_level(lo);
2263
2264 if (level == 1 || level == 10) {
2265 struct imsm_map *hi = get_imsm_map(dev, MAP_1);
2266
2267 return hi->num_domains;
2268 } else
2269 return num_stripes_per_unit_resync(dev);
2270 }
2271
2272 static __u8 imsm_num_data_members(struct imsm_dev *dev, int second_map)
2273 {
2274 /* named 'imsm_' because raid0, raid1 and raid10
2275 * counter-intuitively have the same number of data disks
2276 */
2277 struct imsm_map *map = get_imsm_map(dev, second_map);
2278
2279 switch (get_imsm_raid_level(map)) {
2280 case 0:
2281 return map->num_members;
2282 break;
2283 case 1:
2284 case 10:
2285 return map->num_members/2;
2286 case 5:
2287 return map->num_members - 1;
2288 default:
2289 dprintf("unsupported raid level\n");
2290 return 0;
2291 }
2292 }
2293
2294 static __u32 parity_segment_depth(struct imsm_dev *dev)
2295 {
2296 struct imsm_map *map = get_imsm_map(dev, MAP_0);
2297 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
2298
2299 switch(get_imsm_raid_level(map)) {
2300 case 1:
2301 case 10:
2302 return chunk * map->num_domains;
2303 case 5:
2304 return chunk * map->num_members;
2305 default:
2306 return chunk;
2307 }
2308 }
2309
2310 static __u32 map_migr_block(struct imsm_dev *dev, __u32 block)
2311 {
2312 struct imsm_map *map = get_imsm_map(dev, MAP_1);
2313 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
2314 __u32 strip = block / chunk;
2315
2316 switch (get_imsm_raid_level(map)) {
2317 case 1:
2318 case 10: {
2319 __u32 vol_strip = (strip * map->num_domains) + 1;
2320 __u32 vol_stripe = vol_strip / map->num_members;
2321
2322 return vol_stripe * chunk + block % chunk;
2323 } case 5: {
2324 __u32 stripe = strip / (map->num_members - 1);
2325
2326 return stripe * chunk + block % chunk;
2327 }
2328 default:
2329 return 0;
2330 }
2331 }
2332
2333 static __u64 blocks_per_migr_unit(struct intel_super *super,
2334 struct imsm_dev *dev)
2335 {
2336 /* calculate the conversion factor between per member 'blocks'
2337 * (md/{resync,rebuild}_start) and imsm migration units, return
2338 * 0 for the 'not migrating' and 'unsupported migration' cases
2339 */
2340 if (!dev->vol.migr_state)
2341 return 0;
2342
2343 switch (migr_type(dev)) {
2344 case MIGR_GEN_MIGR: {
2345 struct migr_record *migr_rec = super->migr_rec;
2346 return __le32_to_cpu(migr_rec->blocks_per_unit);
2347 }
2348 case MIGR_VERIFY:
2349 case MIGR_REPAIR:
2350 case MIGR_INIT: {
2351 struct imsm_map *map = get_imsm_map(dev, MAP_0);
2352 __u32 stripes_per_unit;
2353 __u32 blocks_per_unit;
2354 __u32 parity_depth;
2355 __u32 migr_chunk;
2356 __u32 block_map;
2357 __u32 block_rel;
2358 __u32 segment;
2359 __u32 stripe;
2360 __u8 disks;
2361
2362 /* yes, this is really the translation of migr_units to
2363 * per-member blocks in the 'resync' case
2364 */
2365 stripes_per_unit = num_stripes_per_unit_resync(dev);
2366 migr_chunk = migr_strip_blocks_resync(dev);
2367 disks = imsm_num_data_members(dev, MAP_0);
2368 blocks_per_unit = stripes_per_unit * migr_chunk * disks;
2369 stripe = __le16_to_cpu(map->blocks_per_strip) * disks;
2370 segment = blocks_per_unit / stripe;
2371 block_rel = blocks_per_unit - segment * stripe;
2372 parity_depth = parity_segment_depth(dev);
2373 block_map = map_migr_block(dev, block_rel);
2374 return block_map + parity_depth * segment;
2375 }
2376 case MIGR_REBUILD: {
2377 __u32 stripes_per_unit;
2378 __u32 migr_chunk;
2379
2380 stripes_per_unit = num_stripes_per_unit_rebuild(dev);
2381 migr_chunk = migr_strip_blocks_rebuild(dev);
2382 return migr_chunk * stripes_per_unit;
2383 }
2384 case MIGR_STATE_CHANGE:
2385 default:
2386 return 0;
2387 }
2388 }
2389
2390 static int imsm_level_to_layout(int level)
2391 {
2392 switch (level) {
2393 case 0:
2394 case 1:
2395 return 0;
2396 case 5:
2397 case 6:
2398 return ALGORITHM_LEFT_ASYMMETRIC;
2399 case 10:
2400 return 0x102;
2401 }
2402 return UnSet;
2403 }
2404
2405 /*******************************************************************************
2406 * Function: read_imsm_migr_rec
2407 * Description: Function reads imsm migration record from last sector of disk
2408 * Parameters:
2409 * fd : disk descriptor
2410 * super : metadata info
2411 * Returns:
2412 * 0 : success,
2413 * -1 : fail
2414 ******************************************************************************/
2415 static int read_imsm_migr_rec(int fd, struct intel_super *super)
2416 {
2417 int ret_val = -1;
2418 unsigned long long dsize;
2419
2420 get_dev_size(fd, NULL, &dsize);
2421 if (lseek64(fd, dsize - MIGR_REC_POSITION, SEEK_SET) < 0) {
2422 pr_err("Cannot seek to anchor block: %s\n",
2423 strerror(errno));
2424 goto out;
2425 }
2426 if (read(fd, super->migr_rec_buf, MIGR_REC_BUF_SIZE) !=
2427 MIGR_REC_BUF_SIZE) {
2428 pr_err("Cannot read migr record block: %s\n",
2429 strerror(errno));
2430 goto out;
2431 }
2432 ret_val = 0;
2433
2434 out:
2435 return ret_val;
2436 }
2437
2438 static struct imsm_dev *imsm_get_device_during_migration(
2439 struct intel_super *super)
2440 {
2441
2442 struct intel_dev *dv;
2443
2444 for (dv = super->devlist; dv; dv = dv->next) {
2445 if (is_gen_migration(dv->dev))
2446 return dv->dev;
2447 }
2448 return NULL;
2449 }
2450
2451 /*******************************************************************************
2452 * Function: load_imsm_migr_rec
2453 * Description: Function reads imsm migration record (it is stored at the last
2454 * sector of disk)
2455 * Parameters:
2456 * super : imsm internal array info
2457 * info : general array info
2458 * Returns:
2459 * 0 : success
2460 * -1 : fail
2461 * -2 : no migration in progress
2462 ******************************************************************************/
2463 static int load_imsm_migr_rec(struct intel_super *super, struct mdinfo *info)
2464 {
2465 struct mdinfo *sd;
2466 struct dl *dl;
2467 char nm[30];
2468 int retval = -1;
2469 int fd = -1;
2470 struct imsm_dev *dev;
2471 struct imsm_map *map;
2472 int slot = -1;
2473
2474 /* find map under migration */
2475 dev = imsm_get_device_during_migration(super);
2476 /* nothing to load,no migration in progress?
2477 */
2478 if (dev == NULL)
2479 return -2;
2480 map = get_imsm_map(dev, MAP_0);
2481
2482 if (info) {
2483 for (sd = info->devs ; sd ; sd = sd->next) {
2484 /* skip spare and failed disks
2485 */
2486 if (sd->disk.raid_disk < 0)
2487 continue;
2488 /* read only from one of the first two slots */
2489 if (map)
2490 slot = get_imsm_disk_slot(map,
2491 sd->disk.raid_disk);
2492 if ((map == NULL) || (slot > 1) || (slot < 0))
2493 continue;
2494
2495 sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
2496 fd = dev_open(nm, O_RDONLY);
2497 if (fd >= 0)
2498 break;
2499 }
2500 }
2501 if (fd < 0) {
2502 for (dl = super->disks; dl; dl = dl->next) {
2503 /* skip spare and failed disks
2504 */
2505 if (dl->index < 0)
2506 continue;
2507 /* read only from one of the first two slots */
2508 if (map)
2509 slot = get_imsm_disk_slot(map, dl->index);
2510 if ((map == NULL) || (slot > 1) || (slot < 0))
2511 continue;
2512 sprintf(nm, "%d:%d", dl->major, dl->minor);
2513 fd = dev_open(nm, O_RDONLY);
2514 if (fd >= 0)
2515 break;
2516 }
2517 }
2518 if (fd < 0)
2519 goto out;
2520 retval = read_imsm_migr_rec(fd, super);
2521
2522 out:
2523 if (fd >= 0)
2524 close(fd);
2525 return retval;
2526 }
2527
2528 #ifndef MDASSEMBLE
2529 /*******************************************************************************
2530 * function: imsm_create_metadata_checkpoint_update
2531 * Description: It creates update for checkpoint change.
2532 * Parameters:
2533 * super : imsm internal array info
2534 * u : pointer to prepared update
2535 * Returns:
2536 * Uptate length.
2537 * If length is equal to 0, input pointer u contains no update
2538 ******************************************************************************/
2539 static int imsm_create_metadata_checkpoint_update(
2540 struct intel_super *super,
2541 struct imsm_update_general_migration_checkpoint **u)
2542 {
2543
2544 int update_memory_size = 0;
2545
2546 dprintf("(enter)\n");
2547
2548 if (u == NULL)
2549 return 0;
2550 *u = NULL;
2551
2552 /* size of all update data without anchor */
2553 update_memory_size =
2554 sizeof(struct imsm_update_general_migration_checkpoint);
2555
2556 *u = xcalloc(1, update_memory_size);
2557 if (*u == NULL) {
2558 dprintf("error: cannot get memory\n");
2559 return 0;
2560 }
2561 (*u)->type = update_general_migration_checkpoint;
2562 (*u)->curr_migr_unit = __le32_to_cpu(super->migr_rec->curr_migr_unit);
2563 dprintf("prepared for %u\n", (*u)->curr_migr_unit);
2564
2565 return update_memory_size;
2566 }
2567
2568 static void imsm_update_metadata_locally(struct supertype *st,
2569 void *buf, int len);
2570
2571 /*******************************************************************************
2572 * Function: write_imsm_migr_rec
2573 * Description: Function writes imsm migration record
2574 * (at the last sector of disk)
2575 * Parameters:
2576 * super : imsm internal array info
2577 * Returns:
2578 * 0 : success
2579 * -1 : if fail
2580 ******************************************************************************/
2581 static int write_imsm_migr_rec(struct supertype *st)
2582 {
2583 struct intel_super *super = st->sb;
2584 unsigned long long dsize;
2585 char nm[30];
2586 int fd = -1;
2587 int retval = -1;
2588 struct dl *sd;
2589 int len;
2590 struct imsm_update_general_migration_checkpoint *u;
2591 struct imsm_dev *dev;
2592 struct imsm_map *map;
2593
2594 /* find map under migration */
2595 dev = imsm_get_device_during_migration(super);
2596 /* if no migration, write buffer anyway to clear migr_record
2597 * on disk based on first available device
2598 */
2599 if (dev == NULL)
2600 dev = get_imsm_dev(super, super->current_vol < 0 ? 0 :
2601 super->current_vol);
2602
2603 map = get_imsm_map(dev, MAP_0);
2604
2605 for (sd = super->disks ; sd ; sd = sd->next) {
2606 int slot = -1;
2607
2608 /* skip failed and spare devices */
2609 if (sd->index < 0)
2610 continue;
2611 /* write to 2 first slots only */
2612 if (map)
2613 slot = get_imsm_disk_slot(map, sd->index);
2614 if ((map == NULL) || (slot > 1) || (slot < 0))
2615 continue;
2616
2617 sprintf(nm, "%d:%d", sd->major, sd->minor);
2618 fd = dev_open(nm, O_RDWR);
2619 if (fd < 0)
2620 continue;
2621 get_dev_size(fd, NULL, &dsize);
2622 if (lseek64(fd, dsize - MIGR_REC_POSITION, SEEK_SET) < 0) {
2623 pr_err("Cannot seek to anchor block: %s\n",
2624 strerror(errno));
2625 goto out;
2626 }
2627 if (write(fd, super->migr_rec_buf, MIGR_REC_BUF_SIZE) !=
2628 MIGR_REC_BUF_SIZE) {
2629 pr_err("Cannot write migr record block: %s\n",
2630 strerror(errno));
2631 goto out;
2632 }
2633 close(fd);
2634 fd = -1;
2635 }
2636 /* update checkpoint information in metadata */
2637 len = imsm_create_metadata_checkpoint_update(super, &u);
2638
2639 if (len <= 0) {
2640 dprintf("imsm: Cannot prepare update\n");
2641 goto out;
2642 }
2643 /* update metadata locally */
2644 imsm_update_metadata_locally(st, u, len);
2645 /* and possibly remotely */
2646 if (st->update_tail) {
2647 append_metadata_update(st, u, len);
2648 /* during reshape we do all work inside metadata handler
2649 * manage_reshape(), so metadata update has to be triggered
2650 * insida it
2651 */
2652 flush_metadata_updates(st);
2653 st->update_tail = &st->updates;
2654 } else
2655 free(u);
2656
2657 retval = 0;
2658 out:
2659 if (fd >= 0)
2660 close(fd);
2661 return retval;
2662 }
2663 #endif /* MDASSEMBLE */
2664
2665 /* spare/missing disks activations are not allowe when
2666 * array/container performs reshape operation, because
2667 * all arrays in container works on the same disks set
2668 */
2669 int imsm_reshape_blocks_arrays_changes(struct intel_super *super)
2670 {
2671 int rv = 0;
2672 struct intel_dev *i_dev;
2673 struct imsm_dev *dev;
2674
2675 /* check whole container
2676 */
2677 for (i_dev = super->devlist; i_dev; i_dev = i_dev->next) {
2678 dev = i_dev->dev;
2679 if (is_gen_migration(dev)) {
2680 /* No repair during any migration in container
2681 */
2682 rv = 1;
2683 break;
2684 }
2685 }
2686 return rv;
2687 }
2688 static unsigned long long imsm_component_size_aligment_check(int level,
2689 int chunk_size,
2690 unsigned long long component_size)
2691 {
2692 unsigned int component_size_alligment;
2693
2694 /* check component size aligment
2695 */
2696 component_size_alligment = component_size % (chunk_size/512);
2697
2698 dprintf("(Level: %i, chunk_size = %i, component_size = %llu), component_size_alligment = %u\n",
2699 level, chunk_size, component_size,
2700 component_size_alligment);
2701
2702 if (component_size_alligment && (level != 1) && (level != UnSet)) {
2703 dprintf("imsm: reported component size alligned from %llu ",
2704 component_size);
2705 component_size -= component_size_alligment;
2706 dprintf_cont("to %llu (%i).\n",
2707 component_size, component_size_alligment);
2708 }
2709
2710 return component_size;
2711 }
2712
2713 static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info, char *dmap)
2714 {
2715 struct intel_super *super = st->sb;
2716 struct migr_record *migr_rec = super->migr_rec;
2717 struct imsm_dev *dev = get_imsm_dev(super, super->current_vol);
2718 struct imsm_map *map = get_imsm_map(dev, MAP_0);
2719 struct imsm_map *prev_map = get_imsm_map(dev, MAP_1);
2720 struct imsm_map *map_to_analyse = map;
2721 struct dl *dl;
2722 int map_disks = info->array.raid_disks;
2723
2724 memset(info, 0, sizeof(*info));
2725 if (prev_map)
2726 map_to_analyse = prev_map;
2727
2728 dl = super->current_disk;
2729
2730 info->container_member = super->current_vol;
2731 info->array.raid_disks = map->num_members;
2732 info->array.level = get_imsm_raid_level(map_to_analyse);
2733 info->array.layout = imsm_level_to_layout(info->array.level);
2734 info->array.md_minor = -1;
2735 info->array.ctime = 0;
2736 info->array.utime = 0;
2737 info->array.chunk_size =
2738 __le16_to_cpu(map_to_analyse->blocks_per_strip) << 9;
2739 info->array.state = !dev->vol.dirty;
2740 info->custom_array_size = __le32_to_cpu(dev->size_high);
2741 info->custom_array_size <<= 32;
2742 info->custom_array_size |= __le32_to_cpu(dev->size_low);
2743 info->recovery_blocked = imsm_reshape_blocks_arrays_changes(st->sb);
2744
2745 if (is_gen_migration(dev)) {
2746 info->reshape_active = 1;
2747 info->new_level = get_imsm_raid_level(map);
2748 info->new_layout = imsm_level_to_layout(info->new_level);
2749 info->new_chunk = __le16_to_cpu(map->blocks_per_strip) << 9;
2750 info->delta_disks = map->num_members - prev_map->num_members;
2751 if (info->delta_disks) {
2752 /* this needs to be applied to every array
2753 * in the container.
2754 */
2755 info->reshape_active = CONTAINER_RESHAPE;
2756 }
2757 /* We shape information that we give to md might have to be
2758 * modify to cope with md's requirement for reshaping arrays.
2759 * For example, when reshaping a RAID0, md requires it to be
2760 * presented as a degraded RAID4.
2761 * Also if a RAID0 is migrating to a RAID5 we need to specify
2762 * the array as already being RAID5, but the 'before' layout
2763 * is a RAID4-like layout.
2764 */
2765 switch (info->array.level) {
2766 case 0:
2767 switch(info->new_level) {
2768 case 0:
2769 /* conversion is happening as RAID4 */
2770 info->array.level = 4;
2771 info->array.raid_disks += 1;
2772 break;
2773 case 5:
2774 /* conversion is happening as RAID5 */
2775 info->array.level = 5;
2776 info->array.layout = ALGORITHM_PARITY_N;
2777 info->delta_disks -= 1;
2778 break;
2779 default:
2780 /* FIXME error message */
2781 info->array.level = UnSet;
2782 break;
2783 }
2784 break;
2785 }
2786 } else {
2787 info->new_level = UnSet;
2788 info->new_layout = UnSet;
2789 info->new_chunk = info->array.chunk_size;
2790 info->delta_disks = 0;
2791 }
2792
2793 if (dl) {
2794 info->disk.major = dl->major;
2795 info->disk.minor = dl->minor;
2796 info->disk.number = dl->index;
2797 info->disk.raid_disk = get_imsm_disk_slot(map_to_analyse,
2798 dl->index);
2799 }
2800
2801 info->data_offset = pba_of_lba0(map_to_analyse);
2802 info->component_size = blocks_per_member(map_to_analyse);
2803
2804 info->component_size = imsm_component_size_aligment_check(
2805 info->array.level,
2806 info->array.chunk_size,
2807 info->component_size);
2808
2809 memset(info->uuid, 0, sizeof(info->uuid));
2810 info->recovery_start = MaxSector;
2811
2812 info->reshape_progress = 0;
2813 info->resync_start = MaxSector;
2814 if ((map_to_analyse->map_state == IMSM_T_STATE_UNINITIALIZED ||
2815 dev->vol.dirty) &&
2816 imsm_reshape_blocks_arrays_changes(super) == 0) {
2817 info->resync_start = 0;
2818 }
2819 if (dev->vol.migr_state) {
2820 switch (migr_type(dev)) {
2821 case MIGR_REPAIR:
2822 case MIGR_INIT: {
2823 __u64 blocks_per_unit = blocks_per_migr_unit(super,
2824 dev);
2825 __u64 units = __le32_to_cpu(dev->vol.curr_migr_unit);
2826
2827 info->resync_start = blocks_per_unit * units;
2828 break;
2829 }
2830 case MIGR_GEN_MIGR: {
2831 __u64 blocks_per_unit = blocks_per_migr_unit(super,
2832 dev);
2833 __u64 units = __le32_to_cpu(migr_rec->curr_migr_unit);
2834 unsigned long long array_blocks;
2835 int used_disks;
2836
2837 if (__le32_to_cpu(migr_rec->ascending_migr) &&
2838 (units <
2839 (__le32_to_cpu(migr_rec->num_migr_units)-1)) &&
2840 (super->migr_rec->rec_status ==
2841 __cpu_to_le32(UNIT_SRC_IN_CP_AREA)))
2842 units++;
2843
2844 info->reshape_progress = blocks_per_unit * units;
2845
2846 dprintf("IMSM: General Migration checkpoint : %llu (%llu) -> read reshape progress : %llu\n",
2847 (unsigned long long)units,
2848 (unsigned long long)blocks_per_unit,
2849 info->reshape_progress);
2850
2851 used_disks = imsm_num_data_members(dev, MAP_1);
2852 if (used_disks > 0) {
2853 array_blocks = blocks_per_member(map) *
2854 used_disks;
2855 /* round array size down to closest MB
2856 */
2857 info->custom_array_size = (array_blocks
2858 >> SECT_PER_MB_SHIFT)
2859 << SECT_PER_MB_SHIFT;
2860 }
2861 }
2862 case MIGR_VERIFY:
2863 /* we could emulate the checkpointing of
2864 * 'sync_action=check' migrations, but for now
2865 * we just immediately complete them
2866 */
2867 case MIGR_REBUILD:
2868 /* this is handled by container_content_imsm() */
2869 case MIGR_STATE_CHANGE:
2870 /* FIXME handle other migrations */
2871 default:
2872 /* we are not dirty, so... */
2873 info->resync_start = MaxSector;
2874 }
2875 }
2876
2877 strncpy(info->name, (char *) dev->volume, MAX_RAID_SERIAL_LEN);
2878 info->name[MAX_RAID_SERIAL_LEN] = 0;
2879
2880 info->array.major_version = -1;
2881 info->array.minor_version = -2;
2882 sprintf(info->text_version, "/%s/%d", st->container_devnm, info->container_member);
2883 info->safe_mode_delay = 4000; /* 4 secs like the Matrix driver */
2884 uuid_from_super_imsm(st, info->uuid);
2885
2886 if (dmap) {
2887 int i, j;
2888 for (i=0; i<map_disks; i++) {
2889 dmap[i] = 0;
2890 if (i < info->array.raid_disks) {
2891 struct imsm_disk *dsk;
2892 j = get_imsm_disk_idx(dev, i, MAP_X);
2893 dsk = get_imsm_disk(super, j);
2894 if (dsk && (dsk->status & CONFIGURED_DISK))
2895 dmap[i] = 1;
2896 }
2897 }
2898 }
2899 }
2900
2901 static __u8 imsm_check_degraded(struct intel_super *super, struct imsm_dev *dev,
2902 int failed, int look_in_map);
2903
2904 static int imsm_count_failed(struct intel_super *super, struct imsm_dev *dev,
2905 int look_in_map);
2906
2907 #ifndef MDASSEMBLE
2908 static void manage_second_map(struct intel_super *super, struct imsm_dev *dev)
2909 {
2910 if (is_gen_migration(dev)) {
2911 int failed;
2912 __u8 map_state;
2913 struct imsm_map *map2 = get_imsm_map(dev, MAP_1);
2914
2915 failed = imsm_count_failed(super, dev, MAP_1);
2916 map_state = imsm_check_degraded(super, dev, failed, MAP_1);
2917 if (map2->map_state != map_state) {
2918 map2->map_state = map_state;
2919 super->updates_pending++;
2920 }
2921 }
2922 }
2923 #endif
2924
2925 static struct imsm_disk *get_imsm_missing(struct intel_super *super, __u8 index)
2926 {
2927 struct dl *d;
2928
2929 for (d = super->missing; d; d = d->next)
2930 if (d->index == index)
2931 return &d->disk;
2932 return NULL;
2933 }
2934
2935 static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info, char *map)
2936 {
2937 struct intel_super *super = st->sb;
2938 struct imsm_disk *disk;
2939 int map_disks = info->array.raid_disks;
2940 int max_enough = -1;
2941 int i;
2942 struct imsm_super *mpb;
2943
2944 if (super->current_vol >= 0) {
2945 getinfo_super_imsm_volume(st, info, map);
2946 return;
2947 }
2948 memset(info, 0, sizeof(*info));
2949
2950 /* Set raid_disks to zero so that Assemble will always pull in valid
2951 * spares
2952 */
2953 info->array.raid_disks = 0;
2954 info->array.level = LEVEL_CONTAINER;
2955 info->array.layout = 0;
2956 info->array.md_minor = -1;
2957 info->array.ctime = 0; /* N/A for imsm */
2958 info->array.utime = 0;
2959 info->array.chunk_size = 0;
2960
2961 info->disk.major = 0;
2962 info->disk.minor = 0;
2963 info->disk.raid_disk = -1;
2964 info->reshape_active = 0;
2965 info->array.major_version = -1;
2966 info->array.minor_version = -2;
2967 strcpy(info->text_version, "imsm");
2968 info->safe_mode_delay = 0;
2969 info->disk.number = -1;
2970 info->disk.state = 0;
2971 info->name[0] = 0;
2972 info->recovery_start = MaxSector;
2973 info->recovery_blocked = imsm_reshape_blocks_arrays_changes(st->sb);
2974
2975 /* do we have the all the insync disks that we expect? */
2976 mpb = super->anchor;
2977
2978 for (i = 0; i < mpb->num_raid_devs; i++) {
2979 struct imsm_dev *dev = get_imsm_dev(super, i);
2980 int failed, enough, j, missing = 0;
2981 struct imsm_map *map;
2982 __u8 state;
2983
2984 failed = imsm_count_failed(super, dev, MAP_0);
2985 state = imsm_check_degraded(super, dev, failed, MAP_0);
2986 map = get_imsm_map(dev, MAP_0);
2987
2988 /* any newly missing disks?
2989 * (catches single-degraded vs double-degraded)
2990 */
2991 for (j = 0; j < map->num_members; j++) {
2992 __u32 ord = get_imsm_ord_tbl_ent(dev, j, MAP_0);
2993 __u32 idx = ord_to_idx(ord);
2994
2995 if (!(ord & IMSM_ORD_REBUILD) &&
2996 get_imsm_missing(super, idx)) {
2997 missing = 1;
2998 break;
2999 }
3000 }
3001
3002 if (state == IMSM_T_STATE_FAILED)
3003 enough = -1;
3004 else if (state == IMSM_T_STATE_DEGRADED &&
3005 (state != map->map_state || missing))
3006 enough = 0;
3007 else /* we're normal, or already degraded */
3008 enough = 1;
3009 if (is_gen_migration(dev) && missing) {
3010 /* during general migration we need all disks
3011 * that process is running on.
3012 * No new missing disk is allowed.
3013 */
3014 max_enough = -1;
3015 enough = -1;
3016 /* no more checks necessary
3017 */
3018 break;
3019 }
3020 /* in the missing/failed disk case check to see
3021 * if at least one array is runnable
3022 */
3023 max_enough = max(max_enough, enough);
3024 }
3025 dprintf("enough: %d\n", max_enough);
3026 info->container_enough = max_enough;
3027
3028 if (super->disks) {
3029 __u32 reserved = imsm_reserved_sectors(super, super->disks);
3030
3031 disk = &super->disks->disk;
3032 info->data_offset = total_blocks(&super->disks->disk) - reserved;
3033 info->component_size = reserved;
3034 info->disk.state = is_configured(disk) ? (1 << MD_DISK_ACTIVE) : 0;
3035 /* we don't change info->disk.raid_disk here because
3036 * this state will be finalized in mdmon after we have
3037 * found the 'most fresh' version of the metadata
3038 */
3039 info->disk.state |= is_failed(disk) ? (1 << MD_DISK_FAULTY) : 0;
3040 info->disk.state |= is_spare(disk) ? 0 : (1 << MD_DISK_SYNC);
3041 }
3042
3043 /* only call uuid_from_super_imsm when this disk is part of a populated container,
3044 * ->compare_super may have updated the 'num_raid_devs' field for spares
3045 */
3046 if (info->disk.state & (1 << MD_DISK_SYNC) || super->anchor->num_raid_devs)
3047 uuid_from_super_imsm(st, info->uuid);
3048 else
3049 memcpy(info->uuid, uuid_zero, sizeof(uuid_zero));
3050
3051 /* I don't know how to compute 'map' on imsm, so use safe default */
3052 if (map) {
3053 int i;
3054 for (i = 0; i < map_disks; i++)
3055 map[i] = 1;
3056 }
3057
3058 }
3059
3060 /* allocates memory and fills disk in mdinfo structure
3061 * for each disk in array */
3062 struct mdinfo *getinfo_super_disks_imsm(struct supertype *st)
3063 {
3064 struct mdinfo *mddev;
3065 struct intel_super *super = st->sb;
3066 struct imsm_disk *disk;
3067 int count = 0;
3068 struct dl *dl;
3069 if (!super || !super->disks)
3070 return NULL;
3071 dl = super->disks;
3072 mddev = xcalloc(1, sizeof(*mddev));
3073 while (dl) {
3074 struct mdinfo *tmp;
3075 disk = &dl->disk;
3076 tmp = xcalloc(1, sizeof(*tmp));
3077 if (mddev->devs)
3078 tmp->next = mddev->devs;
3079 mddev->devs = tmp;
3080 tmp->disk.number = count++;
3081 tmp->disk.major = dl->major;
3082 tmp->disk.minor = dl->minor;
3083 tmp->disk.state = is_configured(disk) ?
3084 (1 << MD_DISK_ACTIVE) : 0;
3085 tmp->disk.state |= is_failed(disk) ? (1 << MD_DISK_FAULTY) : 0;
3086 tmp->disk.state |= is_spare(disk) ? 0 : (1 << MD_DISK_SYNC);
3087 tmp->disk.raid_disk = -1;
3088 dl = dl->next;
3089 }
3090 return mddev;
3091 }
3092
3093 static int update_super_imsm(struct supertype *st, struct mdinfo *info,
3094 char *update, char *devname, int verbose,
3095 int uuid_set, char *homehost)
3096 {
3097 /* For 'assemble' and 'force' we need to return non-zero if any
3098 * change was made. For others, the return value is ignored.
3099 * Update options are:
3100 * force-one : This device looks a bit old but needs to be included,
3101 * update age info appropriately.
3102 * assemble: clear any 'faulty' flag to allow this device to
3103 * be assembled.
3104 * force-array: Array is degraded but being forced, mark it clean
3105 * if that will be needed to assemble it.
3106 *
3107 * newdev: not used ????