]> git.ipfire.org Git - thirdparty/mdadm.git/blame - super-intel.c
projects / thirdparty / mdadm.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
imsm: Update-subarray for write-intent bitmap
[thirdparty/mdadm.git] / super-intel.c
CommitLineData
cdddbdbc
DW		 1/*
2 * mdadm - Intel(R) Matrix Storage Manager Support
3 *
a54d5262 4 * Copyright (C) 2002-2008 Intel Corporation
cdddbdbc
DW		 5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
51006d85 20#define HAVE_STDINT_H 1
cdddbdbc 21#include "mdadm.h"
c2a1e7da 22#include "mdmon.h"
51006d85 23#include "sha1.h"
88c32bb1 24#include "platform-intel.h"
cdddbdbc
DW		 25#include <values.h>
26#include <scsi/sg.h>
27#include <ctype.h>
d665cc31 28#include <dirent.h>
cdddbdbc
DW		 29
30/* MPB == Metadata Parameter Block */
31#define MPB_SIGNATURE "Intel Raid ISM Cfg Sig. "
32#define MPB_SIG_LEN (strlen(MPB_SIGNATURE))
33#define MPB_VERSION_RAID0 "1.0.00"
34#define MPB_VERSION_RAID1 "1.1.00"
fe7ed8cb
DW		 35#define MPB_VERSION_MANY_VOLUMES_PER_ARRAY "1.2.00"
36#define MPB_VERSION_3OR4_DISK_ARRAY "1.2.01"
cdddbdbc 37#define MPB_VERSION_RAID5 "1.2.02"
fe7ed8cb
DW		 38#define MPB_VERSION_5OR6_DISK_ARRAY "1.2.04"
39#define MPB_VERSION_CNG "1.2.06"
40#define MPB_VERSION_ATTRIBS "1.3.00"
cdddbdbc
DW		 41#define MAX_SIGNATURE_LENGTH 32
42#define MAX_RAID_SERIAL_LEN 16
fe7ed8cb 43
19482bcc
AK		 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 */
418f9b36 77#define MPB_ATTRIB_SUPPORTED (MPB_ATTRIB_CHECKSUM_VERIFY | \
19482bcc
AK		 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 | \
bbab0940
TM		 84 MPB_ATTRIB_EXP_STRIPE_SIZE | \
85 MPB_ATTRIB_BBM)
418f9b36
N		 86
87/* Define attributes that are unused but not harmful */
88#define MPB_ATTRIB_IGNORED (MPB_ATTRIB_NEVER_USE)
fe7ed8cb 89
8e59f3d8 90#define MPB_SECTOR_CNT 2210
611d9529
MD		 91#define IMSM_RESERVED_SECTORS 8192
92#define NUM_BLOCKS_DIRTY_STRIPE_REGION 2048
979d38be 93#define SECT_PER_MB_SHIFT 11
f36a9ecd 94#define MAX_SECTOR_SIZE 4096
c2462068
PB		 95#define MULTIPLE_PPL_AREA_SIZE_IMSM (1024 * 1024) /* Size of the whole
96 * mutliple PPL area
97 */
cdddbdbc 98
fbc42556
JR		 99/*
100 * Internal Write-intent bitmap is stored in the same area where PPL.
101 * Both features are mutually exclusive, so it is not an issue.
102 * The first 8KiB of the area are reserved and shall not be used.
103 */
104#define IMSM_BITMAP_AREA_RESERVED_SIZE 8192
105
106#define IMSM_BITMAP_HEADER_OFFSET (IMSM_BITMAP_AREA_RESERVED_SIZE)
107#define IMSM_BITMAP_HEADER_SIZE MAX_SECTOR_SIZE
108
109#define IMSM_BITMAP_START_OFFSET (IMSM_BITMAP_HEADER_OFFSET + IMSM_BITMAP_HEADER_SIZE)
110#define IMSM_BITMAP_AREA_SIZE (MULTIPLE_PPL_AREA_SIZE_IMSM - IMSM_BITMAP_START_OFFSET)
111#define IMSM_BITMAP_AND_HEADER_SIZE (IMSM_BITMAP_AREA_SIZE + IMSM_BITMAP_HEADER_SIZE)
112
113#define IMSM_DEFAULT_BITMAP_CHUNKSIZE (64 * 1024 * 1024)
114#define IMSM_DEFAULT_BITMAP_DAEMON_SLEEP 5
115
761e3bd9
N		 116/*
117 * This macro let's us ensure that no-one accidentally
118 * changes the size of a struct
119 */
120#define ASSERT_SIZE(_struct, size) \
121static inline void __assert_size_##_struct(void) \
122{ \
123 switch (0) { \
124 case 0: break; \
125 case (sizeof(struct _struct) == size): break; \
126 } \
127}
128
cdddbdbc
DW		 129/* Disk configuration info. */
130#define IMSM_MAX_DEVICES 255
131struct imsm_disk {
132 __u8 serial[MAX_RAID_SERIAL_LEN];/* 0xD8 - 0xE7 ascii serial number */
5551b113 133 __u32 total_blocks_lo; /* 0xE8 - 0xEB total blocks lo */
cdddbdbc 134 __u32 scsi_id; /* 0xEC - 0xEF scsi ID */
f2f27e63
DW		 135#define SPARE_DISK __cpu_to_le32(0x01) /* Spare */
136#define CONFIGURED_DISK __cpu_to_le32(0x02) /* Member of some RaidDev */
137#define FAILED_DISK __cpu_to_le32(0x04) /* Permanent failure */
2432ce9b 138#define JOURNAL_DISK __cpu_to_le32(0x2000000) /* Device marked as Journaling Drive */
cdddbdbc 139 __u32 status; /* 0xF0 - 0xF3 */
1011e834 140 __u32 owner_cfg_num; /* which config 0,1,2... owns this disk */
5551b113
CA		 141 __u32 total_blocks_hi; /* 0xF4 - 0xF5 total blocks hi */
142#define IMSM_DISK_FILLERS 3
143 __u32 filler[IMSM_DISK_FILLERS]; /* 0xF5 - 0x107 MPB_DISK_FILLERS for future expansion */
cdddbdbc 144};
761e3bd9 145ASSERT_SIZE(imsm_disk, 48)
cdddbdbc 146
3b451610
AK		 147/* map selector for map managment
148 */
238c0a71
AK		 149#define MAP_0 0
150#define MAP_1 1
151#define MAP_X -1
3b451610 152
cdddbdbc
DW		 153/* RAID map configuration infos. */
154struct imsm_map {
5551b113
CA		 155 __u32 pba_of_lba0_lo; /* start address of partition */
156 __u32 blocks_per_member_lo;/* blocks per member */
157 __u32 num_data_stripes_lo; /* number of data stripes */
cdddbdbc
DW		 158 __u16 blocks_per_strip;
159 __u8 map_state; /* Normal, Uninitialized, Degraded, Failed */
160#define IMSM_T_STATE_NORMAL 0
161#define IMSM_T_STATE_UNINITIALIZED 1
e3bba0e0
DW		 162#define IMSM_T_STATE_DEGRADED 2
163#define IMSM_T_STATE_FAILED 3
cdddbdbc
DW		 164 __u8 raid_level;
165#define IMSM_T_RAID0 0
166#define IMSM_T_RAID1 1
167#define IMSM_T_RAID5 5 /* since metadata version 1.2.02 ? */
168 __u8 num_members; /* number of member disks */
fe7ed8cb
DW		 169 __u8 num_domains; /* number of parity domains */
170 __u8 failed_disk_num; /* valid only when state is degraded */
252d23c0 171 __u8 ddf;
5551b113
CA		 172 __u32 pba_of_lba0_hi;
173 __u32 blocks_per_member_hi;
174 __u32 num_data_stripes_hi;
175 __u32 filler[4]; /* expansion area */
7eef0453 176#define IMSM_ORD_REBUILD (1 << 24)
cdddbdbc 177 __u32 disk_ord_tbl[1]; /* disk_ord_tbl[num_members],
7eef0453
DW		 178 * top byte contains some flags
179 */
761e3bd9
N		 180};
181ASSERT_SIZE(imsm_map, 52)
cdddbdbc
DW		 182
183struct imsm_vol {
f8f603f1 184 __u32 curr_migr_unit;
fe7ed8cb 185 __u32 checkpoint_id; /* id to access curr_migr_unit */
cdddbdbc 186 __u8 migr_state; /* Normal or Migrating */
e3bba0e0
DW		 187#define MIGR_INIT 0
188#define MIGR_REBUILD 1
189#define MIGR_VERIFY 2 /* analagous to echo check > sync_action */
190#define MIGR_GEN_MIGR 3
191#define MIGR_STATE_CHANGE 4
1484e727 192#define MIGR_REPAIR 5
cdddbdbc 193 __u8 migr_type; /* Initializing, Rebuilding, ... */
2432ce9b
AP		 194#define RAIDVOL_CLEAN 0
195#define RAIDVOL_DIRTY 1
196#define RAIDVOL_DSRECORD_VALID 2
cdddbdbc 197 __u8 dirty;
fe7ed8cb
DW		 198 __u8 fs_state; /* fast-sync state for CnG (0xff == disabled) */
199 __u16 verify_errors; /* number of mismatches */
200 __u16 bad_blocks; /* number of bad blocks during verify */
201 __u32 filler[4];
cdddbdbc
DW		 202 struct imsm_map map[1];
203 /* here comes another one if migr_state */
761e3bd9
N		 204};
205ASSERT_SIZE(imsm_vol, 84)
cdddbdbc
DW		 206
207struct imsm_dev {
fe7ed8cb 208 __u8 volume[MAX_RAID_SERIAL_LEN];
cdddbdbc
DW		 209 __u32 size_low;
210 __u32 size_high;
fe7ed8cb
DW		 211#define DEV_BOOTABLE __cpu_to_le32(0x01)
212#define DEV_BOOT_DEVICE __cpu_to_le32(0x02)
213#define DEV_READ_COALESCING __cpu_to_le32(0x04)
214#define DEV_WRITE_COALESCING __cpu_to_le32(0x08)
215#define DEV_LAST_SHUTDOWN_DIRTY __cpu_to_le32(0x10)
216#define DEV_HIDDEN_AT_BOOT __cpu_to_le32(0x20)
217#define DEV_CURRENTLY_HIDDEN __cpu_to_le32(0x40)
218#define DEV_VERIFY_AND_FIX __cpu_to_le32(0x80)
219#define DEV_MAP_STATE_UNINIT __cpu_to_le32(0x100)
220#define DEV_NO_AUTO_RECOVERY __cpu_to_le32(0x200)
221#define DEV_CLONE_N_GO __cpu_to_le32(0x400)
222#define DEV_CLONE_MAN_SYNC __cpu_to_le32(0x800)
223#define DEV_CNG_MASTER_DISK_NUM __cpu_to_le32(0x1000)
cdddbdbc
DW		 224 __u32 status; /* Persistent RaidDev status */
225 __u32 reserved_blocks; /* Reserved blocks at beginning of volume */
fe7ed8cb
DW		 226 __u8 migr_priority;
227 __u8 num_sub_vols;
228 __u8 tid;
229 __u8 cng_master_disk;
230 __u16 cache_policy;
231 __u8 cng_state;
232 __u8 cng_sub_state;
2432ce9b
AP		 233 __u16 my_vol_raid_dev_num; /* Used in Unique volume Id for this RaidDev */
234
235 /* NVM_EN */
236 __u8 nv_cache_mode;
237 __u8 nv_cache_flags;
238
239 /* Unique Volume Id of the NvCache Volume associated with this volume */
240 __u32 nvc_vol_orig_family_num;
241 __u16 nvc_vol_raid_dev_num;
242
243#define RWH_OFF 0
244#define RWH_DISTRIBUTED 1
245#define RWH_JOURNALING_DRIVE 2
c2462068
PB		 246#define RWH_MULTIPLE_DISTRIBUTED 3
247#define RWH_MULTIPLE_PPLS_JOURNALING_DRIVE 4
248#define RWH_MULTIPLE_OFF 5
fbc42556 249#define RWH_BITMAP 6
2432ce9b
AP		 250 __u8 rwh_policy; /* Raid Write Hole Policy */
251 __u8 jd_serial[MAX_RAID_SERIAL_LEN]; /* Journal Drive serial number */
252 __u8 filler1;
253
254#define IMSM_DEV_FILLERS 3
cdddbdbc
DW		 255 __u32 filler[IMSM_DEV_FILLERS];
256 struct imsm_vol vol;
761e3bd9
N		 257};
258ASSERT_SIZE(imsm_dev, 164)
cdddbdbc
DW		 259
260struct imsm_super {
261 __u8 sig[MAX_SIGNATURE_LENGTH]; /* 0x00 - 0x1F */
262 __u32 check_sum; /* 0x20 - 0x23 MPB Checksum */
263 __u32 mpb_size; /* 0x24 - 0x27 Size of MPB */
264 __u32 family_num; /* 0x28 - 0x2B Checksum from first time this config was written */
265 __u32 generation_num; /* 0x2C - 0x2F Incremented each time this array's MPB is written */
604b746f
JD		 266 __u32 error_log_size; /* 0x30 - 0x33 in bytes */
267 __u32 attributes; /* 0x34 - 0x37 */
cdddbdbc
DW		 268 __u8 num_disks; /* 0x38 Number of configured disks */
269 __u8 num_raid_devs; /* 0x39 Number of configured volumes */
604b746f
JD		 270 __u8 error_log_pos; /* 0x3A */
271 __u8 fill[1]; /* 0x3B */
272 __u32 cache_size; /* 0x3c - 0x40 in mb */
273 __u32 orig_family_num; /* 0x40 - 0x43 original family num */
274 __u32 pwr_cycle_count; /* 0x44 - 0x47 simulated power cycle count for array */
275 __u32 bbm_log_size; /* 0x48 - 0x4B - size of bad Block Mgmt Log in bytes */
2a24dc1b
PB		 276 __u16 num_raid_devs_created; /* 0x4C - 0x4D Used for generating unique
277 * volume IDs for raid_dev created in this array
278 * (starts at 1)
279 */
280 __u16 filler1; /* 0x4E - 0x4F */
e48aed3c
AP		 281 __u64 creation_time; /* 0x50 - 0x57 Array creation time */
282#define IMSM_FILLERS 32
283 __u32 filler[IMSM_FILLERS]; /* 0x58 - 0xD7 RAID_MPB_FILLERS */
cdddbdbc
DW		 284 struct imsm_disk disk[1]; /* 0xD8 diskTbl[numDisks] */
285 /* here comes imsm_dev[num_raid_devs] */
604b746f 286 /* here comes BBM logs */
761e3bd9
N		 287};
288ASSERT_SIZE(imsm_super, 264)
cdddbdbc 289
604b746f 290#define BBM_LOG_MAX_ENTRIES 254
8d67477f
TM		 291#define BBM_LOG_MAX_LBA_ENTRY_VAL 256 /* Represents 256 LBAs */
292#define BBM_LOG_SIGNATURE 0xabadb10c
293
294struct bbm_log_block_addr {
295 __u16 w1;
296 __u32 dw1;
297} __attribute__ ((__packed__));
604b746f
JD		 298
299struct bbm_log_entry {
8d67477f
TM		 300 __u8 marked_count; /* Number of blocks marked - 1 */
301 __u8 disk_ordinal; /* Disk entry within the imsm_super */
302 struct bbm_log_block_addr defective_block_start;
604b746f
JD		 303} __attribute__ ((__packed__));
304
305struct bbm_log {
306 __u32 signature; /* 0xABADB10C */
307 __u32 entry_count;
8d67477f 308 struct bbm_log_entry marked_block_entries[BBM_LOG_MAX_ENTRIES];
761e3bd9
N		 309};
310ASSERT_SIZE(bbm_log, 2040)
604b746f 311
cdddbdbc 312static char *map_state_str[] = { "normal", "uninitialized", "degraded", "failed" };
cdddbdbc 313
b53bfba6
TM		 314#define BLOCKS_PER_KB (1024/512)
315
8e59f3d8
AK		 316#define RAID_DISK_RESERVED_BLOCKS_IMSM_HI 2209
317
318#define GEN_MIGR_AREA_SIZE 2048 /* General Migration Copy Area size in blocks */
319
de44e46f
PB		 320#define MIGR_REC_BUF_SECTORS 1 /* size of migr_record i/o buffer in sectors */
321#define MIGR_REC_SECTOR_POSITION 1 /* migr_record position offset on disk,
322 * MIGR_REC_BUF_SECTORS <= MIGR_REC_SECTOR_POS
17a4eaf9
AK		 323 */
324
8e59f3d8
AK		 325#define UNIT_SRC_NORMAL 0 /* Source data for curr_migr_unit must
326 * be recovered using srcMap */
327#define UNIT_SRC_IN_CP_AREA 1 /* Source data for curr_migr_unit has
328 * already been migrated and must
329 * be recovered from checkpoint area */
2432ce9b 330
c2462068 331#define PPL_ENTRY_SPACE (128 * 1024) /* Size of single PPL, without the header */
2432ce9b 332
8e59f3d8
AK		 333struct migr_record {
334 __u32 rec_status; /* Status used to determine how to restart
335 * migration in case it aborts
336 * in some fashion */
9f421827 337 __u32 curr_migr_unit_lo; /* 0..numMigrUnits-1 */
8e59f3d8
AK		 338 __u32 family_num; /* Family number of MPB
339 * containing the RaidDev
340 * that is migrating */
341 __u32 ascending_migr; /* True if migrating in increasing
342 * order of lbas */
343 __u32 blocks_per_unit; /* Num disk blocks per unit of operation */
344 __u32 dest_depth_per_unit; /* Num member blocks each destMap
345 * member disk
346 * advances per unit-of-operation */
9f421827
PB		 347 __u32 ckpt_area_pba_lo; /* Pba of first block of ckpt copy area */
348 __u32 dest_1st_member_lba_lo; /* First member lba on first
349 * stripe of destination */
350 __u32 num_migr_units_lo; /* Total num migration units-of-op */
8e59f3d8
AK		 351 __u32 post_migr_vol_cap; /* Size of volume after
352 * migration completes */
353 __u32 post_migr_vol_cap_hi; /* Expansion space for LBA64 */
354 __u32 ckpt_read_disk_num; /* Which member disk in destSubMap[0] the
355 * migration ckpt record was read from
356 * (for recovered migrations) */
9f421827
PB		 357 __u32 curr_migr_unit_hi; /* 0..numMigrUnits-1 high order 32 bits */
358 __u32 ckpt_area_pba_hi; /* Pba of first block of ckpt copy area
359 * high order 32 bits */
360 __u32 dest_1st_member_lba_hi; /* First member lba on first stripe of
361 * destination - high order 32 bits */
362 __u32 num_migr_units_hi; /* Total num migration units-of-op
363 * high order 32 bits */
761e3bd9
N		 364};
365ASSERT_SIZE(migr_record, 64)
8e59f3d8 366
ec50f7b6
LM		 367struct md_list {
368 /* usage marker:
369 * 1: load metadata
370 * 2: metadata does not match
371 * 4: already checked
372 */
373 int used;
374 char *devname;
375 int found;
376 int container;
377 dev_t st_rdev;
378 struct md_list *next;
379};
380
e7b84f9d 381#define pr_vrb(fmt, arg...) (void) (verbose && pr_err(fmt, ##arg))
ec50f7b6 382
1484e727
DW		 383static __u8 migr_type(struct imsm_dev *dev)
384{
385 if (dev->vol.migr_type == MIGR_VERIFY &&
386 dev->status & DEV_VERIFY_AND_FIX)
387 return MIGR_REPAIR;
388 else
389 return dev->vol.migr_type;
390}
391
392static void set_migr_type(struct imsm_dev *dev, __u8 migr_type)
393{
394 /* for compatibility with older oroms convert MIGR_REPAIR, into
395 * MIGR_VERIFY w/ DEV_VERIFY_AND_FIX status
396 */
397 if (migr_type == MIGR_REPAIR) {
398 dev->vol.migr_type = MIGR_VERIFY;
399 dev->status |= DEV_VERIFY_AND_FIX;
400 } else {
401 dev->vol.migr_type = migr_type;
402 dev->status &= ~DEV_VERIFY_AND_FIX;
403 }
404}
405
f36a9ecd 406static unsigned int sector_count(__u32 bytes, unsigned int sector_size)
cdddbdbc 407{
f36a9ecd 408 return ROUND_UP(bytes, sector_size) / sector_size;
87eb16df 409}
cdddbdbc 410
f36a9ecd
PB		 411static unsigned int mpb_sectors(struct imsm_super *mpb,
412 unsigned int sector_size)
87eb16df 413{
f36a9ecd 414 return sector_count(__le32_to_cpu(mpb->mpb_size), sector_size);
cdddbdbc
DW		 415}
416
ba2de7ba
DW		 417struct intel_dev {
418 struct imsm_dev *dev;
419 struct intel_dev *next;
f21e18ca 420 unsigned index;
ba2de7ba
DW		 421};
422
88654014
LM		 423struct intel_hba {
424 enum sys_dev_type type;
425 char *path;
426 char *pci_id;
427 struct intel_hba *next;
428};
429
1a64be56
LM		 430enum action {
431 DISK_REMOVE = 1,
432 DISK_ADD
433};
cdddbdbc
DW		 434/* internal representation of IMSM metadata */
435struct intel_super {
436 union {
949c47a0
DW		 437 void *buf; /* O_DIRECT buffer for reading/writing metadata */
438 struct imsm_super *anchor; /* immovable parameters */
cdddbdbc 439 };
8e59f3d8
AK		 440 union {
441 void *migr_rec_buf; /* buffer for I/O operations */
442 struct migr_record *migr_rec; /* migration record */
443 };
51d83f5d
AK		 444 int clean_migration_record_by_mdmon; /* when reshape is switched to next
445 array, it indicates that mdmon is allowed to clean migration
446 record */
949c47a0 447 size_t len; /* size of the 'buf' allocation */
bbab0940 448 size_t extra_space; /* extra space in 'buf' that is not used yet */
4d7b1503
DW		 449 void *next_buf; /* for realloc'ing buf from the manager */
450 size_t next_len;
c2c087e6 451 int updates_pending; /* count of pending updates for mdmon */
bf5a934a 452 int current_vol; /* index of raid device undergoing creation */
5551b113 453 unsigned long long create_offset; /* common start for 'current_vol' */
148acb7b 454 __u32 random; /* random data for seeding new family numbers */
ba2de7ba 455 struct intel_dev *devlist;
fa7bb6f8 456 unsigned int sector_size; /* sector size of used member drives */
cdddbdbc
DW		 457 struct dl {
458 struct dl *next;
459 int index;
460 __u8 serial[MAX_RAID_SERIAL_LEN];
461 int major, minor;
462 char *devname;
b9f594fe 463 struct imsm_disk disk;
cdddbdbc 464 int fd;
0dcecb2e
DW		 465 int extent_cnt;
466 struct extent *e; /* for determining freespace @ create */
efb30e7f 467 int raiddisk; /* slot to fill in autolayout */
1a64be56 468 enum action action;
ca0748fa 469 } *disks, *current_disk;
1a64be56
LM		 470 struct dl *disk_mgmt_list; /* list of disks to add/remove while mdmon
471 active */
47ee5a45 472 struct dl *missing; /* disks removed while we weren't looking */
43dad3d6 473 struct bbm_log *bbm_log;
88654014 474 struct intel_hba *hba; /* device path of the raid controller for this metadata */
88c32bb1 475 const struct imsm_orom *orom; /* platform firmware support */
a2b97981 476 struct intel_super *next; /* (temp) list for disambiguating family_num */
928f1424 477 struct md_bb bb; /* memory for get_bad_blocks call */
a2b97981
DW		 478};
479
480struct intel_disk {
481 struct imsm_disk disk;
482 #define IMSM_UNKNOWN_OWNER (-1)
483 int owner;
484 struct intel_disk *next;
cdddbdbc
DW		 485};
486
c2c087e6
DW		 487struct extent {
488 unsigned long long start, size;
489};
490
694575e7
KW		 491/* definitions of reshape process types */
492enum imsm_reshape_type {
493 CH_TAKEOVER,
b5347799 494 CH_MIGRATION,
7abc9871 495 CH_ARRAY_SIZE,
694575e7
KW		 496};
497
88758e9d
DW		 498/* definition of messages passed to imsm_process_update */
499enum imsm_update_type {
500 update_activate_spare,
8273f55e 501 update_create_array,
33414a01 502 update_kill_array,
aa534678 503 update_rename_array,
1a64be56 504 update_add_remove_disk,
78b10e66 505 update_reshape_container_disks,
48c5303a 506 update_reshape_migration,
2d40f3a1
AK		 507 update_takeover,
508 update_general_migration_checkpoint,
f3871fdc 509 update_size_change,
bbab0940 510 update_prealloc_badblocks_mem,
e6e9dd3f 511 update_rwh_policy,
88758e9d
DW		 512};
513
514struct imsm_update_activate_spare {
515 enum imsm_update_type type;
d23fe947 516 struct dl *dl;
88758e9d
DW		 517 int slot;
518 int array;
519 struct imsm_update_activate_spare *next;
520};
521
78b10e66 522struct geo_params {
4dd2df09 523 char devnm[32];
78b10e66 524 char *dev_name;
d04f65f4 525 unsigned long long size;
78b10e66
N		 526 int level;
527 int layout;
528 int chunksize;
529 int raid_disks;
530};
531
bb025c2f
KW		 532enum takeover_direction {
533 R10_TO_R0,
534 R0_TO_R10
535};
536struct imsm_update_takeover {
537 enum imsm_update_type type;
538 int subarray;
539 enum takeover_direction direction;
540};
78b10e66
N		 541
542struct imsm_update_reshape {
543 enum imsm_update_type type;
544 int old_raid_disks;
545 int new_raid_disks;
48c5303a
PC		 546
547 int new_disks[1]; /* new_raid_disks - old_raid_disks makedev number */
548};
549
550struct imsm_update_reshape_migration {
551 enum imsm_update_type type;
552 int old_raid_disks;
553 int new_raid_disks;
554 /* fields for array migration changes
555 */
556 int subdev;
557 int new_level;
558 int new_layout;
4bba0439 559 int new_chunksize;
48c5303a 560
d195167d 561 int new_disks[1]; /* new_raid_disks - old_raid_disks makedev number */
78b10e66
N		 562};
563
f3871fdc
AK		 564struct imsm_update_size_change {
565 enum imsm_update_type type;
566 int subdev;
567 long long new_size;
568};
569
2d40f3a1
AK		 570struct imsm_update_general_migration_checkpoint {
571 enum imsm_update_type type;
572 __u32 curr_migr_unit;
573};
574
54c2c1ea
DW		 575struct disk_info {
576 __u8 serial[MAX_RAID_SERIAL_LEN];
577};
578
8273f55e
DW		 579struct imsm_update_create_array {
580 enum imsm_update_type type;
8273f55e 581 int dev_idx;
6a3e913e 582 struct imsm_dev dev;
8273f55e
DW		 583};
584
33414a01
DW		 585struct imsm_update_kill_array {
586 enum imsm_update_type type;
587 int dev_idx;
588};
589
aa534678
DW		 590struct imsm_update_rename_array {
591 enum imsm_update_type type;
592 __u8 name[MAX_RAID_SERIAL_LEN];
593 int dev_idx;
594};
595
1a64be56 596struct imsm_update_add_remove_disk {
43dad3d6
DW		 597 enum imsm_update_type type;
598};
599
bbab0940
TM		 600struct imsm_update_prealloc_bb_mem {
601 enum imsm_update_type type;
602};
603
e6e9dd3f
AP		 604struct imsm_update_rwh_policy {
605 enum imsm_update_type type;
606 int new_policy;
607 int dev_idx;
608};
609
88654014
LM		 610static const char *_sys_dev_type[] = {
611 [SYS_DEV_UNKNOWN] = "Unknown",
612 [SYS_DEV_SAS] = "SAS",
614902f6 613 [SYS_DEV_SATA] = "SATA",
60f0f54d
PB		 614 [SYS_DEV_NVME] = "NVMe",
615 [SYS_DEV_VMD] = "VMD"
88654014
LM		 616};
617
618const char *get_sys_dev_type(enum sys_dev_type type)
619{
620 if (type >= SYS_DEV_MAX)
621 type = SYS_DEV_UNKNOWN;
622
623 return _sys_dev_type[type];
624}
625
626static struct intel_hba * alloc_intel_hba(struct sys_dev *device)
627{
503975b9
N		 628 struct intel_hba *result = xmalloc(sizeof(*result));
629
630 result->type = device->type;
631 result->path = xstrdup(device->path);
632 result->next = NULL;
633 if (result->path && (result->pci_id = strrchr(result->path, '/')) != NULL)
634 result->pci_id++;
635
88654014
LM		 636 return result;
637}
638
639static struct intel_hba * find_intel_hba(struct intel_hba *hba, struct sys_dev *device)
640{
594dc1b8
JS		 641 struct intel_hba *result;
642
88654014
LM		 643 for (result = hba; result; result = result->next) {
644 if (result->type == device->type && strcmp(result->path, device->path) == 0)
645 break;
646 }
647 return result;
648}
649
b4cf4cba 650static int attach_hba_to_super(struct intel_super *super, struct sys_dev *device)
88654014
LM		 651{
652 struct intel_hba *hba;
653
654 /* check if disk attached to Intel HBA */
655 hba = find_intel_hba(super->hba, device);
656 if (hba != NULL)
657 return 1;
658 /* Check if HBA is already attached to super */
659 if (super->hba == NULL) {
660 super->hba = alloc_intel_hba(device);
661 return 1;
6b781d33
AP		 662 }
663
664 hba = super->hba;
665 /* Intel metadata allows for all disks attached to the same type HBA.
614902f6 666 * Do not support HBA types mixing
6b781d33
AP		 667 */
668 if (device->type != hba->type)
88654014 669 return 2;
6b781d33
AP		 670
671 /* Multiple same type HBAs can be used if they share the same OROM */
672 const struct imsm_orom *device_orom = get_orom_by_device_id(device->dev_id);
673
674 if (device_orom != super->orom)
675 return 2;
676
677 while (hba->next)
678 hba = hba->next;
679
680 hba->next = alloc_intel_hba(device);
681 return 1;
88654014
LM		 682}
683
684static struct sys_dev* find_disk_attached_hba(int fd, const char *devname)
685{
9bc4ae77 686 struct sys_dev *list, *elem;
88654014
LM		 687 char *disk_path;
688
689 if ((list = find_intel_devices()) == NULL)
690 return 0;
691
692 if (fd < 0)
693 disk_path = (char *) devname;
694 else
695 disk_path = diskfd_to_devpath(fd);
696
9bc4ae77 697 if (!disk_path)
88654014 698 return 0;
88654014 699
9bc4ae77
N		 700 for (elem = list; elem; elem = elem->next)
701 if (path_attached_to_hba(disk_path, elem->path))
88654014 702 return elem;
9bc4ae77 703
88654014
LM		 704 if (disk_path != devname)
705 free(disk_path);
88654014
LM		 706
707 return NULL;
708}
709
d424212e
N		 710static int find_intel_hba_capability(int fd, struct intel_super *super,
711 char *devname);
f2f5c343 712
cdddbdbc
DW		 713static struct supertype *match_metadata_desc_imsm(char *arg)
714{
715 struct supertype *st;
716
717 if (strcmp(arg, "imsm") != 0 &&
718 strcmp(arg, "default") != 0
719 )
720 return NULL;
721
503975b9 722 st = xcalloc(1, sizeof(*st));
cdddbdbc
DW		 723 st->ss = &super_imsm;
724 st->max_devs = IMSM_MAX_DEVICES;
725 st->minor_version = 0;
726 st->sb = NULL;
727 return st;
728}
729
cdddbdbc
DW		 730static __u8 *get_imsm_version(struct imsm_super *mpb)
731{
732 return &mpb->sig[MPB_SIG_LEN];
733}
734
949c47a0
DW		 735/* retrieve a disk directly from the anchor when the anchor is known to be
736 * up-to-date, currently only at load time
737 */
738static struct imsm_disk *__get_imsm_disk(struct imsm_super *mpb, __u8 index)
cdddbdbc 739{
949c47a0 740 if (index >= mpb->num_disks)
cdddbdbc
DW		 741 return NULL;
742 return &mpb->disk[index];
743}
744
95d07a2c
LM		 745/* retrieve the disk description based on a index of the disk
746 * in the sub-array
747 */
748static struct dl *get_imsm_dl_disk(struct intel_super *super, __u8 index)
949c47a0 749{
b9f594fe
DW		 750 struct dl *d;
751
752 for (d = super->disks; d; d = d->next)
753 if (d->index == index)
95d07a2c
LM		 754 return d;
755
756 return NULL;
757}
758/* retrieve a disk from the parsed metadata */
759static struct imsm_disk *get_imsm_disk(struct intel_super *super, __u8 index)
760{
761 struct dl *dl;
762
763 dl = get_imsm_dl_disk(super, index);
764 if (dl)
765 return &dl->disk;
766
b9f594fe 767 return NULL;
949c47a0
DW		 768}
769
770/* generate a checksum directly from the anchor when the anchor is known to be
771 * up-to-date, currently only at load or write_super after coalescing
772 */
773static __u32 __gen_imsm_checksum(struct imsm_super *mpb)
cdddbdbc
DW		 774{
775 __u32 end = mpb->mpb_size / sizeof(end);
776 __u32 *p = (__u32 *) mpb;
777 __u32 sum = 0;
778
5d500228
N		 779 while (end--) {
780 sum += __le32_to_cpu(*p);
97f734fd
N		 781 p++;
782 }
cdddbdbc 783
5d500228 784 return sum - __le32_to_cpu(mpb->check_sum);
cdddbdbc
DW		 785}
786
a965f303
DW		 787static size_t sizeof_imsm_map(struct imsm_map *map)
788{
789 return sizeof(struct imsm_map) + sizeof(__u32) * (map->num_members - 1);
790}
791
792struct imsm_map *get_imsm_map(struct imsm_dev *dev, int second_map)
cdddbdbc 793{
5e7b0330
AK		 794 /* A device can have 2 maps if it is in the middle of a migration.
795 * If second_map is:
238c0a71
AK		 796 * MAP_0 - we return the first map
797 * MAP_1 - we return the second map if it exists, else NULL
798 * MAP_X - we return the second map if it exists, else the first
5e7b0330 799 */
a965f303 800 struct imsm_map *map = &dev->vol.map[0];
9535fc47 801 struct imsm_map *map2 = NULL;
a965f303 802
9535fc47
AK		 803 if (dev->vol.migr_state)
804 map2 = (void *)map + sizeof_imsm_map(map);
a965f303 805
9535fc47 806 switch (second_map) {
3b451610 807 case MAP_0:
9535fc47 808 break;
3b451610 809 case MAP_1:
9535fc47
AK		 810 map = map2;
811 break;
238c0a71 812 case MAP_X:
9535fc47
AK		 813 if (map2)
814 map = map2;
815 break;
9535fc47
AK		 816 default:
817 map = NULL;
818 }
819 return map;
5e7b0330 820
a965f303 821}
cdddbdbc 822
3393c6af
DW		 823/* return the size of the device.
824 * migr_state increases the returned size if map[0] were to be duplicated
825 */
826static size_t sizeof_imsm_dev(struct imsm_dev *dev, int migr_state)
a965f303
DW		 827{
828 size_t size = sizeof(*dev) - sizeof(struct imsm_map) +
238c0a71 829 sizeof_imsm_map(get_imsm_map(dev, MAP_0));
cdddbdbc
DW		 830
831 /* migrating means an additional map */
a965f303 832 if (dev->vol.migr_state)
238c0a71 833 size += sizeof_imsm_map(get_imsm_map(dev, MAP_1));
3393c6af 834 else if (migr_state)
238c0a71 835 size += sizeof_imsm_map(get_imsm_map(dev, MAP_0));
cdddbdbc
DW		 836
837 return size;
838}
839
54c2c1ea
DW		 840/* retrieve disk serial number list from a metadata update */
841static struct disk_info *get_disk_info(struct imsm_update_create_array *update)
842{
843 void *u = update;
844 struct disk_info *inf;
845
846 inf = u + sizeof(*update) - sizeof(struct imsm_dev) +
847 sizeof_imsm_dev(&update->dev, 0);
848
849 return inf;
850}
54c2c1ea 851
949c47a0 852static struct imsm_dev *__get_imsm_dev(struct imsm_super *mpb, __u8 index)
cdddbdbc
DW		 853{
854 int offset;
855 int i;
856 void *_mpb = mpb;
857
949c47a0 858 if (index >= mpb->num_raid_devs)
cdddbdbc
DW		 859 return NULL;
860
861 /* devices start after all disks */
862 offset = ((void *) &mpb->disk[mpb->num_disks]) - _mpb;
863
864 for (i = 0; i <= index; i++)
865 if (i == index)
866 return _mpb + offset;
867 else
3393c6af 868 offset += sizeof_imsm_dev(_mpb + offset, 0);
cdddbdbc
DW		 869
870 return NULL;
871}
872
949c47a0
DW		 873static struct imsm_dev *get_imsm_dev(struct intel_super *super, __u8 index)
874{
ba2de7ba
DW		 875 struct intel_dev *dv;
876
949c47a0
DW		 877 if (index >= super->anchor->num_raid_devs)
878 return NULL;
ba2de7ba
DW		 879 for (dv = super->devlist; dv; dv = dv->next)
880 if (dv->index == index)
881 return dv->dev;
882 return NULL;
949c47a0
DW		 883}
884
8d67477f
TM		 885static inline unsigned long long __le48_to_cpu(const struct bbm_log_block_addr
886 *addr)
887{
888 return ((((__u64)__le32_to_cpu(addr->dw1)) << 16) |
889 __le16_to_cpu(addr->w1));
890}
891
892static inline struct bbm_log_block_addr __cpu_to_le48(unsigned long long sec)
893{
894 struct bbm_log_block_addr addr;
895
896 addr.w1 = __cpu_to_le16((__u16)(sec & 0xffff));
897 addr.dw1 = __cpu_to_le32((__u32)(sec >> 16) & 0xffffffff);
898 return addr;
899}
900
8d67477f
TM		 901/* get size of the bbm log */
902static __u32 get_imsm_bbm_log_size(struct bbm_log *log)
903{
904 if (!log || log->entry_count == 0)
905 return 0;
906
907 return sizeof(log->signature) +
908 sizeof(log->entry_count) +
909 log->entry_count * sizeof(struct bbm_log_entry);
910}
6f50473f
TM		 911
912/* check if bad block is not partially stored in bbm log */
913static int is_stored_in_bbm(struct bbm_log *log, const __u8 idx, const unsigned
914 long long sector, const int length, __u32 *pos)
915{
916 __u32 i;
917
918 for (i = *pos; i < log->entry_count; i++) {
919 struct bbm_log_entry *entry = &log->marked_block_entries[i];
920 unsigned long long bb_start;
921 unsigned long long bb_end;
922
923 bb_start = __le48_to_cpu(&entry->defective_block_start);
924 bb_end = bb_start + (entry->marked_count + 1);
925
926 if ((entry->disk_ordinal == idx) && (bb_start >= sector) &&
927 (bb_end <= sector + length)) {
928 *pos = i;
929 return 1;
930 }
931 }
932 return 0;
933}
934
935/* record new bad block in bbm log */
936static int record_new_badblock(struct bbm_log *log, const __u8 idx, unsigned
937 long long sector, int length)
938{
939 int new_bb = 0;
940 __u32 pos = 0;
941 struct bbm_log_entry *entry = NULL;
942
943 while (is_stored_in_bbm(log, idx, sector, length, &pos)) {
944 struct bbm_log_entry *e = &log->marked_block_entries[pos];
945
946 if ((e->marked_count + 1 == BBM_LOG_MAX_LBA_ENTRY_VAL) &&
947 (__le48_to_cpu(&e->defective_block_start) == sector)) {
948 sector += BBM_LOG_MAX_LBA_ENTRY_VAL;
949 length -= BBM_LOG_MAX_LBA_ENTRY_VAL;
950 pos = pos + 1;
951 continue;
952 }
953 entry = e;
954 break;
955 }
956
957 if (entry) {
958 int cnt = (length <= BBM_LOG_MAX_LBA_ENTRY_VAL) ? length :
959 BBM_LOG_MAX_LBA_ENTRY_VAL;
960 entry->defective_block_start = __cpu_to_le48(sector);
961 entry->marked_count = cnt - 1;
962 if (cnt == length)
963 return 1;
964 sector += cnt;
965 length -= cnt;
966 }
967
968 new_bb = ROUND_UP(length, BBM_LOG_MAX_LBA_ENTRY_VAL) /
969 BBM_LOG_MAX_LBA_ENTRY_VAL;
970 if (log->entry_count + new_bb > BBM_LOG_MAX_ENTRIES)
971 return 0;
972
973 while (length > 0) {
974 int cnt = (length <= BBM_LOG_MAX_LBA_ENTRY_VAL) ? length :
975 BBM_LOG_MAX_LBA_ENTRY_VAL;
976 struct bbm_log_entry *entry =
977 &log->marked_block_entries[log->entry_count];
978
979 entry->defective_block_start = __cpu_to_le48(sector);
980 entry->marked_count = cnt - 1;
981 entry->disk_ordinal = idx;
982
983 sector += cnt;
984 length -= cnt;
985
986 log->entry_count++;
987 }
988
989 return new_bb;
990}
c07a5a4f 991
4c9e8c1e
TM		 992/* clear all bad blocks for given disk */
993static void clear_disk_badblocks(struct bbm_log *log, const __u8 idx)
994{
995 __u32 i = 0;
996
997 while (i < log->entry_count) {
998 struct bbm_log_entry *entries = log->marked_block_entries;
999
1000 if (entries[i].disk_ordinal == idx) {
1001 if (i < log->entry_count - 1)
1002 entries[i] = entries[log->entry_count - 1];
1003 log->entry_count--;
1004 } else {
1005 i++;
1006 }
1007 }
1008}
1009
c07a5a4f
TM		 1010/* clear given bad block */
1011static int clear_badblock(struct bbm_log *log, const __u8 idx, const unsigned
1012 long long sector, const int length) {
1013 __u32 i = 0;
1014
1015 while (i < log->entry_count) {
1016 struct bbm_log_entry *entries = log->marked_block_entries;
1017
1018 if ((entries[i].disk_ordinal == idx) &&
1019 (__le48_to_cpu(&entries[i].defective_block_start) ==
1020 sector) && (entries[i].marked_count + 1 == length)) {
1021 if (i < log->entry_count - 1)
1022 entries[i] = entries[log->entry_count - 1];
1023 log->entry_count--;
1024 break;
1025 }
1026 i++;
1027 }
1028
1029 return 1;
1030}
8d67477f
TM		 1031
1032/* allocate and load BBM log from metadata */
1033static int load_bbm_log(struct intel_super *super)
1034{
1035 struct imsm_super *mpb = super->anchor;
1036 __u32 bbm_log_size = __le32_to_cpu(mpb->bbm_log_size);
1037
1038 super->bbm_log = xcalloc(1, sizeof(struct bbm_log));
1039 if (!super->bbm_log)
1040 return 1;
1041
1042 if (bbm_log_size) {
1043 struct bbm_log *log = (void *)mpb +
1044 __le32_to_cpu(mpb->mpb_size) - bbm_log_size;
1045
1046 __u32 entry_count;
1047
1048 if (bbm_log_size < sizeof(log->signature) +
1049 sizeof(log->entry_count))
1050 return 2;
1051
1052 entry_count = __le32_to_cpu(log->entry_count);
1053 if ((__le32_to_cpu(log->signature) != BBM_LOG_SIGNATURE) ||
1054 (entry_count > BBM_LOG_MAX_ENTRIES))
1055 return 3;
1056
1057 if (bbm_log_size !=
1058 sizeof(log->signature) + sizeof(log->entry_count) +
1059 entry_count * sizeof(struct bbm_log_entry))
1060 return 4;
1061
1062 memcpy(super->bbm_log, log, bbm_log_size);
1063 } else {
1064 super->bbm_log->signature = __cpu_to_le32(BBM_LOG_SIGNATURE);
1065 super->bbm_log->entry_count = 0;
1066 }
1067
1068 return 0;
1069}
1070
b12796be
TM		 1071/* checks if bad block is within volume boundaries */
1072static int is_bad_block_in_volume(const struct bbm_log_entry *entry,
1073 const unsigned long long start_sector,
1074 const unsigned long long size)
1075{
1076 unsigned long long bb_start;
1077 unsigned long long bb_end;
1078
1079 bb_start = __le48_to_cpu(&entry->defective_block_start);
1080 bb_end = bb_start + (entry->marked_count + 1);
1081
1082 if (((bb_start >= start_sector) && (bb_start < start_sector + size)) ||
1083 ((bb_end >= start_sector) && (bb_end <= start_sector + size)))
1084 return 1;
1085
1086 return 0;
1087}
1088
1089/* get list of bad blocks on a drive for a volume */
1090static void get_volume_badblocks(const struct bbm_log *log, const __u8 idx,
1091 const unsigned long long start_sector,
1092 const unsigned long long size,
1093 struct md_bb *bbs)
1094{
1095 __u32 count = 0;
1096 __u32 i;
1097
1098 for (i = 0; i < log->entry_count; i++) {
1099 const struct bbm_log_entry *ent =
1100 &log->marked_block_entries[i];
1101 struct md_bb_entry *bb;
1102
1103 if ((ent->disk_ordinal == idx) &&
1104 is_bad_block_in_volume(ent, start_sector, size)) {
1105
1106 if (!bbs->entries) {
1107 bbs->entries = xmalloc(BBM_LOG_MAX_ENTRIES *
1108 sizeof(*bb));
1109 if (!bbs->entries)
1110 break;
1111 }
1112
1113 bb = &bbs->entries[count++];
1114 bb->sector = __le48_to_cpu(&ent->defective_block_start);
1115 bb->length = ent->marked_count + 1;
1116 }
1117 }
1118 bbs->count = count;
1119}
1120
98130f40
AK		 1121/*
1122 * for second_map:
238c0a71
AK		 1123 * == MAP_0 get first map
1124 * == MAP_1 get second map
1125 * == MAP_X than get map according to the current migr_state
98130f40
AK		 1126 */
1127static __u32 get_imsm_ord_tbl_ent(struct imsm_dev *dev,
1128 int slot,
1129 int second_map)
7eef0453
DW		 1130{
1131 struct imsm_map *map;
1132
5e7b0330 1133 map = get_imsm_map(dev, second_map);
7eef0453 1134
ff077194
DW		 1135 /* top byte identifies disk under rebuild */
1136 return __le32_to_cpu(map->disk_ord_tbl[slot]);
1137}
1138
1139#define ord_to_idx(ord) (((ord) << 8) >> 8)
98130f40 1140static __u32 get_imsm_disk_idx(struct imsm_dev *dev, int slot, int second_map)
ff077194 1141{
98130f40 1142 __u32 ord = get_imsm_ord_tbl_ent(dev, slot, second_map);
ff077194
DW		 1143
1144 return ord_to_idx(ord);
7eef0453
DW		 1145}
1146
be73972f
DW		 1147static void set_imsm_ord_tbl_ent(struct imsm_map *map, int slot, __u32 ord)
1148{
1149 map->disk_ord_tbl[slot] = __cpu_to_le32(ord);
1150}
1151
f21e18ca 1152static int get_imsm_disk_slot(struct imsm_map *map, unsigned idx)
620b1713
DW		 1153{
1154 int slot;
1155 __u32 ord;
1156
1157 for (slot = 0; slot < map->num_members; slot++) {
1158 ord = __le32_to_cpu(map->disk_ord_tbl[slot]);
1159 if (ord_to_idx(ord) == idx)
1160 return slot;
1161 }
1162
1163 return -1;
1164}
1165
cdddbdbc
DW		 1166static int get_imsm_raid_level(struct imsm_map *map)
1167{
1168 if (map->raid_level == 1) {
1169 if (map->num_members == 2)
1170 return 1;
1171 else
1172 return 10;
1173 }
1174
1175 return map->raid_level;
1176}
1177
c2c087e6
DW		 1178static int cmp_extent(const void *av, const void *bv)
1179{
1180 const struct extent *a = av;
1181 const struct extent *b = bv;
1182 if (a->start < b->start)
1183 return -1;
1184 if (a->start > b->start)
1185 return 1;
1186 return 0;
1187}
1188
0dcecb2e 1189static int count_memberships(struct dl *dl, struct intel_super *super)
c2c087e6 1190{
c2c087e6 1191 int memberships = 0;
620b1713 1192 int i;
c2c087e6 1193
949c47a0
DW		 1194 for (i = 0; i < super->anchor->num_raid_devs; i++) {
1195 struct imsm_dev *dev = get_imsm_dev(super, i);
238c0a71 1196 struct imsm_map *map = get_imsm_map(dev, MAP_0);
c2c087e6 1197
620b1713
DW		 1198 if (get_imsm_disk_slot(map, dl->index) >= 0)
1199 memberships++;
c2c087e6 1200 }
0dcecb2e
DW		 1201
1202 return memberships;
1203}
1204
b81221b7
CA		 1205static __u32 imsm_min_reserved_sectors(struct intel_super *super);
1206
486720e0 1207static int split_ull(unsigned long long n, void *lo, void *hi)
5551b113
CA		 1208{
1209 if (lo == 0 || hi == 0)
1210 return 1;
486720e0
JS		 1211 __put_unaligned32(__cpu_to_le32((__u32)n), lo);
1212 __put_unaligned32(__cpu_to_le32((n >> 32)), hi);
5551b113
CA		 1213 return 0;
1214}
1215
1216static unsigned long long join_u32(__u32 lo, __u32 hi)
1217{
1218 return (unsigned long long)__le32_to_cpu(lo) |
1219 (((unsigned long long)__le32_to_cpu(hi)) << 32);
1220}
1221
1222static unsigned long long total_blocks(struct imsm_disk *disk)
1223{
1224 if (disk == NULL)
1225 return 0;
1226 return join_u32(disk->total_blocks_lo, disk->total_blocks_hi);
1227}
1228
1229static unsigned long long pba_of_lba0(struct imsm_map *map)
1230{
1231 if (map == NULL)
1232 return 0;
1233 return join_u32(map->pba_of_lba0_lo, map->pba_of_lba0_hi);
1234}
1235
1236static unsigned long long blocks_per_member(struct imsm_map *map)
1237{
1238 if (map == NULL)
1239 return 0;
1240 return join_u32(map->blocks_per_member_lo, map->blocks_per_member_hi);
1241}
1242
1243static unsigned long long num_data_stripes(struct imsm_map *map)
1244{
1245 if (map == NULL)
1246 return 0;
1247 return join_u32(map->num_data_stripes_lo, map->num_data_stripes_hi);
1248}
1249
fcc2c9da
MD		 1250static unsigned long long imsm_dev_size(struct imsm_dev *dev)
1251{
1252 if (dev == NULL)
1253 return 0;
1254 return join_u32(dev->size_low, dev->size_high);
1255}
1256
9f421827
PB		 1257static unsigned long long migr_chkp_area_pba(struct migr_record *migr_rec)
1258{
1259 if (migr_rec == NULL)
1260 return 0;
1261 return join_u32(migr_rec->ckpt_area_pba_lo,
1262 migr_rec->ckpt_area_pba_hi);
1263}
1264
1265static unsigned long long current_migr_unit(struct migr_record *migr_rec)
1266{
1267 if (migr_rec == NULL)
1268 return 0;
1269 return join_u32(migr_rec->curr_migr_unit_lo,
1270 migr_rec->curr_migr_unit_hi);
1271}
1272
1273static unsigned long long migr_dest_1st_member_lba(struct migr_record *migr_rec)
1274{
1275 if (migr_rec == NULL)
1276 return 0;
1277 return join_u32(migr_rec->dest_1st_member_lba_lo,
1278 migr_rec->dest_1st_member_lba_hi);
1279}
1280
1281static unsigned long long get_num_migr_units(struct migr_record *migr_rec)
1282{
1283 if (migr_rec == NULL)
1284 return 0;
1285 return join_u32(migr_rec->num_migr_units_lo,
1286 migr_rec->num_migr_units_hi);
1287}
1288
5551b113
CA		 1289static void set_total_blocks(struct imsm_disk *disk, unsigned long long n)
1290{
1291 split_ull(n, &disk->total_blocks_lo, &disk->total_blocks_hi);
1292}
1293
1294static void set_pba_of_lba0(struct imsm_map *map, unsigned long long n)
1295{
1296 split_ull(n, &map->pba_of_lba0_lo, &map->pba_of_lba0_hi);
1297}
1298
1299static void set_blocks_per_member(struct imsm_map *map, unsigned long long n)
1300{
1301 split_ull(n, &map->blocks_per_member_lo, &map->blocks_per_member_hi);
1302}
1303
1304static void set_num_data_stripes(struct imsm_map *map, unsigned long long n)
1305{
1306 split_ull(n, &map->num_data_stripes_lo, &map->num_data_stripes_hi);
1307}
1308
fcc2c9da
MD		 1309static void set_imsm_dev_size(struct imsm_dev *dev, unsigned long long n)
1310{
1311 split_ull(n, &dev->size_low, &dev->size_high);
1312}
1313
9f421827
PB		 1314static void set_migr_chkp_area_pba(struct migr_record *migr_rec,
1315 unsigned long long n)
1316{
1317 split_ull(n, &migr_rec->ckpt_area_pba_lo, &migr_rec->ckpt_area_pba_hi);
1318}
1319
1320static void set_current_migr_unit(struct migr_record *migr_rec,
1321 unsigned long long n)
1322{
1323 split_ull(n, &migr_rec->curr_migr_unit_lo,
1324 &migr_rec->curr_migr_unit_hi);
1325}
1326
1327static void set_migr_dest_1st_member_lba(struct migr_record *migr_rec,
1328 unsigned long long n)
1329{
1330 split_ull(n, &migr_rec->dest_1st_member_lba_lo,
1331 &migr_rec->dest_1st_member_lba_hi);
1332}
1333
1334static void set_num_migr_units(struct migr_record *migr_rec,
1335 unsigned long long n)
1336{
1337 split_ull(n, &migr_rec->num_migr_units_lo,
1338 &migr_rec->num_migr_units_hi);
1339}
1340
44490938
MD		 1341static unsigned long long per_dev_array_size(struct imsm_map *map)
1342{
1343 unsigned long long array_size = 0;
1344
1345 if (map == NULL)
1346 return array_size;
1347
1348 array_size = num_data_stripes(map) * map->blocks_per_strip;
1349 if (get_imsm_raid_level(map) == 1 || get_imsm_raid_level(map) == 10)
1350 array_size *= 2;
1351
1352 return array_size;
1353}
1354
05501181
PB		 1355static struct extent *get_extents(struct intel_super *super, struct dl *dl,
1356 int get_minimal_reservation)
0dcecb2e
DW		 1357{
1358 /* find a list of used extents on the given physical device */
1359 struct extent *rv, *e;
620b1713 1360 int i;
0dcecb2e 1361 int memberships = count_memberships(dl, super);
b276dd33
DW		 1362 __u32 reservation;
1363
1364 /* trim the reserved area for spares, so they can join any array
1365 * regardless of whether the OROM has assigned sectors from the
1366 * IMSM_RESERVED_SECTORS region
1367 */
05501181 1368 if (dl->index == -1 || get_minimal_reservation)
b81221b7 1369 reservation = imsm_min_reserved_sectors(super);
b276dd33
DW		 1370 else
1371 reservation = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
0dcecb2e 1372
503975b9 1373 rv = xcalloc(sizeof(struct extent), (memberships + 1));
c2c087e6
DW		 1374 e = rv;
1375
949c47a0
DW		 1376 for (i = 0; i < super->anchor->num_raid_devs; i++) {
1377 struct imsm_dev *dev = get_imsm_dev(super, i);
238c0a71 1378 struct imsm_map *map = get_imsm_map(dev, MAP_0);
c2c087e6 1379
620b1713 1380 if (get_imsm_disk_slot(map, dl->index) >= 0) {
5551b113 1381 e->start = pba_of_lba0(map);
44490938 1382 e->size = per_dev_array_size(map);
620b1713 1383 e++;
c2c087e6
DW		 1384 }
1385 }
1386 qsort(rv, memberships, sizeof(*rv), cmp_extent);
1387
1011e834 1388 /* determine the start of the metadata
14e8215b
DW		 1389 * when no raid devices are defined use the default
1390 * ...otherwise allow the metadata to truncate the value
1391 * as is the case with older versions of imsm
1392 */
1393 if (memberships) {
1394 struct extent *last = &rv[memberships - 1];
5551b113 1395 unsigned long long remainder;
14e8215b 1396
5551b113 1397 remainder = total_blocks(&dl->disk) - (last->start + last->size);
dda5855f
DW		 1398 /* round down to 1k block to satisfy precision of the kernel
1399 * 'size' interface
1400 */
1401 remainder &= ~1UL;
1402 /* make sure remainder is still sane */
f21e18ca 1403 if (remainder < (unsigned)ROUND_UP(super->len, 512) >> 9)
dda5855f 1404 remainder = ROUND_UP(super->len, 512) >> 9;
14e8215b
DW		 1405 if (reservation > remainder)
1406 reservation = remainder;
1407 }
5551b113 1408 e->start = total_blocks(&dl->disk) - reservation;
c2c087e6
DW		 1409 e->size = 0;
1410 return rv;
1411}
1412
14e8215b
DW		 1413/* try to determine how much space is reserved for metadata from
1414 * the last get_extents() entry, otherwise fallback to the
1415 * default
1416 */
1417static __u32 imsm_reserved_sectors(struct intel_super *super, struct dl *dl)
1418{
1419 struct extent *e;
1420 int i;
1421 __u32 rv;
1422
1423 /* for spares just return a minimal reservation which will grow
1424 * once the spare is picked up by an array
1425 */
1426 if (dl->index == -1)
1427 return MPB_SECTOR_CNT;
1428
05501181 1429 e = get_extents(super, dl, 0);
14e8215b
DW		 1430 if (!e)
1431 return MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
1432
1433 /* scroll to last entry */
1434 for (i = 0; e[i].size; i++)
1435 continue;
1436
5551b113 1437 rv = total_blocks(&dl->disk) - e[i].start;
14e8215b
DW		 1438
1439 free(e);
1440
1441 return rv;
1442}
1443
25ed7e59
DW		 1444static int is_spare(struct imsm_disk *disk)
1445{
1446 return (disk->status & SPARE_DISK) == SPARE_DISK;
1447}
1448
1449static int is_configured(struct imsm_disk *disk)
1450{
1451 return (disk->status & CONFIGURED_DISK) == CONFIGURED_DISK;
1452}
1453
1454static int is_failed(struct imsm_disk *disk)
1455{
1456 return (disk->status & FAILED_DISK) == FAILED_DISK;
1457}
1458
2432ce9b
AP		 1459static int is_journal(struct imsm_disk *disk)
1460{
1461 return (disk->status & JOURNAL_DISK) == JOURNAL_DISK;
1462}
1463
b53bfba6
TM		 1464/* round array size down to closest MB and ensure it splits evenly
1465 * between members
1466 */
1467static unsigned long long round_size_to_mb(unsigned long long size, unsigned int
1468 disk_count)
1469{
1470 size /= disk_count;
1471 size = (size >> SECT_PER_MB_SHIFT) << SECT_PER_MB_SHIFT;
1472 size *= disk_count;
1473
1474 return size;
1475}
1476
8b9cd157
MK		 1477static int able_to_resync(int raid_level, int missing_disks)
1478{
1479 int max_missing_disks = 0;
1480
1481 switch (raid_level) {
1482 case 10:
1483 max_missing_disks = 1;
1484 break;
1485 default:
1486 max_missing_disks = 0;
1487 }
1488 return missing_disks <= max_missing_disks;
1489}
1490
b81221b7
CA		 1491/* try to determine how much space is reserved for metadata from
1492 * the last get_extents() entry on the smallest active disk,
1493 * otherwise fallback to the default
1494 */
1495static __u32 imsm_min_reserved_sectors(struct intel_super *super)
1496{
1497 struct extent *e;
1498 int i;
5551b113
CA		 1499 unsigned long long min_active;
1500 __u32 remainder;
b81221b7
CA		 1501 __u32 rv = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
1502 struct dl *dl, *dl_min = NULL;
1503
1504 if (!super)
1505 return rv;
1506
1507 min_active = 0;
1508 for (dl = super->disks; dl; dl = dl->next) {
1509 if (dl->index < 0)
1510 continue;
5551b113
CA		 1511 unsigned long long blocks = total_blocks(&dl->disk);
1512 if (blocks < min_active || min_active == 0) {
b81221b7 1513 dl_min = dl;
5551b113 1514 min_active = blocks;
b81221b7
CA		 1515 }
1516 }
1517 if (!dl_min)
1518 return rv;
1519
1520 /* find last lba used by subarrays on the smallest active disk */
05501181 1521 e = get_extents(super, dl_min, 0);
b81221b7
CA		 1522 if (!e)
1523 return rv;
1524 for (i = 0; e[i].size; i++)
1525 continue;
1526
1527 remainder = min_active - e[i].start;
1528 free(e);
1529
1530 /* to give priority to recovery we should not require full
1531 IMSM_RESERVED_SECTORS from the spare */
1532 rv = MPB_SECTOR_CNT + NUM_BLOCKS_DIRTY_STRIPE_REGION;
1533
1534 /* if real reservation is smaller use that value */
1535 return (remainder < rv) ? remainder : rv;
1536}
1537
fbfdcb06
AO		 1538/*
1539 * Return minimum size of a spare and sector size
1540 * that can be used in this array
1541 */
1542int get_spare_criteria_imsm(struct supertype *st, struct spare_criteria *c)
80e7f8c3
AC		 1543{
1544 struct intel_super *super = st->sb;
1545 struct dl *dl;
1546 struct extent *e;
1547 int i;
fbfdcb06
AO		 1548 unsigned long long size = 0;
1549
1550 c->min_size = 0;
4b57ecf6 1551 c->sector_size = 0;
80e7f8c3
AC		 1552
1553 if (!super)
fbfdcb06 1554 return -EINVAL;
80e7f8c3
AC		 1555 /* find first active disk in array */
1556 dl = super->disks;
1557 while (dl && (is_failed(&dl->disk) || dl->index == -1))
1558 dl = dl->next;
1559 if (!dl)
fbfdcb06 1560 return -EINVAL;
80e7f8c3 1561 /* find last lba used by subarrays */
05501181 1562 e = get_extents(super, dl, 0);
80e7f8c3 1563 if (!e)
fbfdcb06 1564 return -EINVAL;
80e7f8c3
AC		 1565 for (i = 0; e[i].size; i++)
1566 continue;
1567 if (i > 0)
fbfdcb06 1568 size = e[i-1].start + e[i-1].size;
80e7f8c3 1569 free(e);
b81221b7 1570
80e7f8c3 1571 /* add the amount of space needed for metadata */
fbfdcb06
AO		 1572 size += imsm_min_reserved_sectors(super);
1573
1574 c->min_size = size * 512;
4b57ecf6 1575 c->sector_size = super->sector_size;
b81221b7 1576
fbfdcb06 1577 return 0;
80e7f8c3
AC		 1578}
1579
d1e02575
AK		 1580static int is_gen_migration(struct imsm_dev *dev);
1581
f36a9ecd
PB		 1582#define IMSM_4K_DIV 8
1583
c47b0ff6
AK		 1584static __u64 blocks_per_migr_unit(struct intel_super *super,
1585 struct imsm_dev *dev);
1e5c6983 1586
c47b0ff6
AK		 1587static void print_imsm_dev(struct intel_super *super,
1588 struct imsm_dev *dev,
1589 char *uuid,
1590 int disk_idx)
cdddbdbc
DW		 1591{
1592 __u64 sz;
0d80bb2f 1593 int slot, i;
238c0a71
AK		 1594 struct imsm_map *map = get_imsm_map(dev, MAP_0);
1595 struct imsm_map *map2 = get_imsm_map(dev, MAP_1);
b10b37b8 1596 __u32 ord;
cdddbdbc
DW		 1597
1598 printf("\n");
1e7bc0ed 1599 printf("[%.16s]:\n", dev->volume);
ba1b3bc8 1600 printf(" Subarray : %d\n", super->current_vol);
44470971 1601 printf(" UUID : %s\n", uuid);
dd8bcb3b
AK		 1602 printf(" RAID Level : %d", get_imsm_raid_level(map));
1603 if (map2)
1604 printf(" <-- %d", get_imsm_raid_level(map2));
1605 printf("\n");
1606 printf(" Members : %d", map->num_members);
1607 if (map2)
1608 printf(" <-- %d", map2->num_members);
1609 printf("\n");
0d80bb2f
DW		 1610 printf(" Slots : [");
1611 for (i = 0; i < map->num_members; i++) {
238c0a71 1612 ord = get_imsm_ord_tbl_ent(dev, i, MAP_0);
0d80bb2f
DW		 1613 printf("%s", ord & IMSM_ORD_REBUILD ? "_" : "U");
1614 }
dd8bcb3b
AK		 1615 printf("]");
1616 if (map2) {
1617 printf(" <-- [");
1618 for (i = 0; i < map2->num_members; i++) {
238c0a71 1619 ord = get_imsm_ord_tbl_ent(dev, i, MAP_1);
dd8bcb3b
AK		 1620 printf("%s", ord & IMSM_ORD_REBUILD ? "_" : "U");
1621 }
1622 printf("]");
1623 }
1624 printf("\n");
7095bccb
AK		 1625 printf(" Failed disk : ");
1626 if (map->failed_disk_num == 0xff)
1627 printf("none");
1628 else
1629 printf("%i", map->failed_disk_num);
1630 printf("\n");
620b1713
DW		 1631 slot = get_imsm_disk_slot(map, disk_idx);
1632 if (slot >= 0) {
238c0a71 1633 ord = get_imsm_ord_tbl_ent(dev, slot, MAP_X);
b10b37b8
DW		 1634 printf(" This Slot : %d%s\n", slot,
1635 ord & IMSM_ORD_REBUILD ? " (out-of-sync)" : "");
1636 } else
cdddbdbc 1637 printf(" This Slot : ?\n");
84918897 1638 printf(" Sector Size : %u\n", super->sector_size);
fcc2c9da 1639 sz = imsm_dev_size(dev);
84918897
MK		 1640 printf(" Array Size : %llu%s\n",
1641 (unsigned long long)sz * 512 / super->sector_size,
cdddbdbc 1642 human_size(sz * 512));
5551b113 1643 sz = blocks_per_member(map);
84918897
MK		 1644 printf(" Per Dev Size : %llu%s\n",
1645 (unsigned long long)sz * 512 / super->sector_size,
cdddbdbc 1646 human_size(sz * 512));
5551b113
CA		 1647 printf(" Sector Offset : %llu\n",
1648 pba_of_lba0(map));
1649 printf(" Num Stripes : %llu\n",
1650 num_data_stripes(map));
dd8bcb3b 1651 printf(" Chunk Size : %u KiB",
cdddbdbc 1652 __le16_to_cpu(map->blocks_per_strip) / 2);
dd8bcb3b
AK		 1653 if (map2)
1654 printf(" <-- %u KiB",
1655 __le16_to_cpu(map2->blocks_per_strip) / 2);
1656 printf("\n");
cdddbdbc 1657 printf(" Reserved : %d\n", __le32_to_cpu(dev->reserved_blocks));
8655a7b1 1658 printf(" Migrate State : ");
1484e727
DW		 1659 if (dev->vol.migr_state) {
1660 if (migr_type(dev) == MIGR_INIT)
8655a7b1 1661 printf("initialize\n");
1484e727 1662 else if (migr_type(dev) == MIGR_REBUILD)
8655a7b1 1663 printf("rebuild\n");
1484e727 1664 else if (migr_type(dev) == MIGR_VERIFY)
8655a7b1 1665 printf("check\n");
1484e727 1666 else if (migr_type(dev) == MIGR_GEN_MIGR)
8655a7b1 1667 printf("general migration\n");
1484e727 1668 else if (migr_type(dev) == MIGR_STATE_CHANGE)
8655a7b1 1669 printf("state change\n");
1484e727 1670 else if (migr_type(dev) == MIGR_REPAIR)
8655a7b1 1671 printf("repair\n");
1484e727 1672 else
8655a7b1
DW		 1673 printf("<unknown:%d>\n", migr_type(dev));
1674 } else
1675 printf("idle\n");
3393c6af
DW		 1676 printf(" Map State : %s", map_state_str[map->map_state]);
1677 if (dev->vol.migr_state) {
238c0a71 1678 struct imsm_map *map = get_imsm_map(dev, MAP_1);
1e5c6983 1679
b10b37b8 1680 printf(" <-- %s", map_state_str[map->map_state]);
464d40e8
LD		 1681 printf("\n Checkpoint : %u ",
1682 __le32_to_cpu(dev->vol.curr_migr_unit));
089f9d79 1683 if (is_gen_migration(dev) && (slot > 1 || slot < 0))
464d40e8
LD		 1684 printf("(N/A)");
1685 else
1686 printf("(%llu)", (unsigned long long)
1687 blocks_per_migr_unit(super, dev));
3393c6af
DW		 1688 }
1689 printf("\n");
2432ce9b
AP		 1690 printf(" Dirty State : %s\n", (dev->vol.dirty & RAIDVOL_DIRTY) ?
1691 "dirty" : "clean");
1692 printf(" RWH Policy : ");
c2462068 1693 if (dev->rwh_policy == RWH_OFF || dev->rwh_policy == RWH_MULTIPLE_OFF)
2432ce9b
AP		 1694 printf("off\n");
1695 else if (dev->rwh_policy == RWH_DISTRIBUTED)
1696 printf("PPL distributed\n");
1697 else if (dev->rwh_policy == RWH_JOURNALING_DRIVE)
1698 printf("PPL journaling drive\n");
c2462068
PB		 1699 else if (dev->rwh_policy == RWH_MULTIPLE_DISTRIBUTED)
1700 printf("Multiple distributed PPLs\n");
1701 else if (dev->rwh_policy == RWH_MULTIPLE_PPLS_JOURNALING_DRIVE)
1702 printf("Multiple PPLs on journaling drive\n");
fbc42556
JR		 1703 else if (dev->rwh_policy == RWH_BITMAP)
1704 printf("Write-intent bitmap\n");
2432ce9b
AP		 1705 else
1706 printf("<unknown:%d>\n", dev->rwh_policy);
ba1b3bc8
AP		 1707
1708 printf(" Volume ID : %u\n", dev->my_vol_raid_dev_num);
cdddbdbc
DW		 1709}
1710
ef5c214e
MK		 1711static void print_imsm_disk(struct imsm_disk *disk,
1712 int index,
1713 __u32 reserved,
1714 unsigned int sector_size) {
1f24f035 1715 char str[MAX_RAID_SERIAL_LEN + 1];
cdddbdbc
DW		 1716 __u64 sz;
1717
0ec1f4e8 1718 if (index < -1 || !disk)
e9d82038
DW		 1719 return;
1720
cdddbdbc 1721 printf("\n");
1f24f035 1722 snprintf(str, MAX_RAID_SERIAL_LEN + 1, "%s", disk->serial);
0ec1f4e8
DW		 1723 if (index >= 0)
1724 printf(" Disk%02d Serial : %s\n", index, str);
1725 else
1726 printf(" Disk Serial : %s\n", str);
2432ce9b
AP		 1727 printf(" State :%s%s%s%s\n", is_spare(disk) ? " spare" : "",
1728 is_configured(disk) ? " active" : "",
1729 is_failed(disk) ? " failed" : "",
1730 is_journal(disk) ? " journal" : "");
cdddbdbc 1731 printf(" Id : %08x\n", __le32_to_cpu(disk->scsi_id));
5551b113 1732 sz = total_blocks(disk) - reserved;
ef5c214e
MK		 1733 printf(" Usable Size : %llu%s\n",
1734 (unsigned long long)sz * 512 / sector_size,
cdddbdbc
DW		 1735 human_size(sz * 512));
1736}
1737
de44e46f
PB		 1738void convert_to_4k_imsm_migr_rec(struct intel_super *super)
1739{
1740 struct migr_record *migr_rec = super->migr_rec;
1741
1742 migr_rec->blocks_per_unit /= IMSM_4K_DIV;
de44e46f
PB		 1743 migr_rec->dest_depth_per_unit /= IMSM_4K_DIV;
1744 split_ull((join_u32(migr_rec->post_migr_vol_cap,
1745 migr_rec->post_migr_vol_cap_hi) / IMSM_4K_DIV),
1746 &migr_rec->post_migr_vol_cap, &migr_rec->post_migr_vol_cap_hi);
9f421827
PB		 1747 set_migr_chkp_area_pba(migr_rec,
1748 migr_chkp_area_pba(migr_rec) / IMSM_4K_DIV);
1749 set_migr_dest_1st_member_lba(migr_rec,
1750 migr_dest_1st_member_lba(migr_rec) / IMSM_4K_DIV);
de44e46f
PB		 1751}
1752
f36a9ecd
PB		 1753void convert_to_4k_imsm_disk(struct imsm_disk *disk)
1754{
1755 set_total_blocks(disk, (total_blocks(disk)/IMSM_4K_DIV));
1756}
1757
1758void convert_to_4k(struct intel_super *super)
1759{
1760 struct imsm_super *mpb = super->anchor;
1761 struct imsm_disk *disk;
1762 int i;
e4467bc7 1763 __u32 bbm_log_size = __le32_to_cpu(mpb->bbm_log_size);
f36a9ecd
PB		 1764
1765 for (i = 0; i < mpb->num_disks ; i++) {
1766 disk = __get_imsm_disk(mpb, i);
1767 /* disk */
1768 convert_to_4k_imsm_disk(disk);
1769 }
1770 for (i = 0; i < mpb->num_raid_devs; i++) {
1771 struct imsm_dev *dev = __get_imsm_dev(mpb, i);
1772 struct imsm_map *map = get_imsm_map(dev, MAP_0);
1773 /* dev */
fcc2c9da 1774 set_imsm_dev_size(dev, imsm_dev_size(dev)/IMSM_4K_DIV);
f36a9ecd
PB		 1775 dev->vol.curr_migr_unit /= IMSM_4K_DIV;
1776
1777 /* map0 */
1778 set_blocks_per_member(map, blocks_per_member(map)/IMSM_4K_DIV);
1779 map->blocks_per_strip /= IMSM_4K_DIV;
1780 set_pba_of_lba0(map, pba_of_lba0(map)/IMSM_4K_DIV);
1781
1782 if (dev->vol.migr_state) {
1783 /* map1 */
1784 map = get_imsm_map(dev, MAP_1);
1785 set_blocks_per_member(map,
1786 blocks_per_member(map)/IMSM_4K_DIV);
1787 map->blocks_per_strip /= IMSM_4K_DIV;
1788 set_pba_of_lba0(map, pba_of_lba0(map)/IMSM_4K_DIV);
1789 }
1790 }
e4467bc7
TM		 1791 if (bbm_log_size) {
1792 struct bbm_log *log = (void *)mpb +
1793 __le32_to_cpu(mpb->mpb_size) - bbm_log_size;
1794 __u32 i;
1795
1796 for (i = 0; i < log->entry_count; i++) {
1797 struct bbm_log_entry *entry =
1798 &log->marked_block_entries[i];
1799
1800 __u8 count = entry->marked_count + 1;
1801 unsigned long long sector =
1802 __le48_to_cpu(&entry->defective_block_start);
1803
1804 entry->defective_block_start =
1805 __cpu_to_le48(sector/IMSM_4K_DIV);
1806 entry->marked_count = max(count/IMSM_4K_DIV, 1) - 1;
1807 }
1808 }
f36a9ecd
PB		 1809
1810 mpb->check_sum = __gen_imsm_checksum(mpb);
1811}
1812
520e69e2
AK		 1813void examine_migr_rec_imsm(struct intel_super *super)
1814{
1815 struct migr_record *migr_rec = super->migr_rec;
1816 struct imsm_super *mpb = super->anchor;
1817 int i;
1818
1819 for (i = 0; i < mpb->num_raid_devs; i++) {
1820 struct imsm_dev *dev = __get_imsm_dev(mpb, i);
3136abe5 1821 struct imsm_map *map;
b4ab44d8 1822 int slot = -1;
3136abe5 1823
520e69e2
AK		 1824 if (is_gen_migration(dev) == 0)
1825 continue;
1826
1827 printf("\nMigration Record Information:");
3136abe5 1828
44bfe6df
AK		 1829 /* first map under migration */
1830 map = get_imsm_map(dev, MAP_0);
3136abe5
AK		 1831 if (map)
1832 slot = get_imsm_disk_slot(map, super->disks->index);
089f9d79 1833 if (map == NULL || slot > 1 || slot < 0) {
520e69e2
AK		 1834 printf(" Empty\n ");
1835 printf("Examine one of first two disks in array\n");
1836 break;
1837 }
1838 printf("\n Status : ");
1839 if (__le32_to_cpu(migr_rec->rec_status) == UNIT_SRC_NORMAL)
1840 printf("Normal\n");
1841 else
1842 printf("Contains Data\n");
9f421827
PB		 1843 printf(" Current Unit : %llu\n",
1844 current_migr_unit(migr_rec));
520e69e2
AK		 1845 printf(" Family : %u\n",
1846 __le32_to_cpu(migr_rec->family_num));
1847 printf(" Ascending : %u\n",
1848 __le32_to_cpu(migr_rec->ascending_migr));
1849 printf(" Blocks Per Unit : %u\n",
1850 __le32_to_cpu(migr_rec->blocks_per_unit));
1851 printf(" Dest. Depth Per Unit : %u\n",
1852 __le32_to_cpu(migr_rec->dest_depth_per_unit));
9f421827
PB		 1853 printf(" Checkpoint Area pba : %llu\n",
1854 migr_chkp_area_pba(migr_rec));
1855 printf(" First member lba : %llu\n",
1856 migr_dest_1st_member_lba(migr_rec));
1857 printf(" Total Number of Units : %llu\n",
1858 get_num_migr_units(migr_rec));
1859 printf(" Size of volume : %llu\n",
1860 join_u32(migr_rec->post_migr_vol_cap,
1861 migr_rec->post_migr_vol_cap_hi));
520e69e2
AK		 1862 printf(" Record was read from : %u\n",
1863 __le32_to_cpu(migr_rec->ckpt_read_disk_num));
1864
1865 break;
1866 }
1867}
f36a9ecd 1868
de44e46f
PB		 1869void convert_from_4k_imsm_migr_rec(struct intel_super *super)
1870{
1871 struct migr_record *migr_rec = super->migr_rec;
1872
1873 migr_rec->blocks_per_unit *= IMSM_4K_DIV;
de44e46f
PB		 1874 migr_rec->dest_depth_per_unit *= IMSM_4K_DIV;
1875 split_ull((join_u32(migr_rec->post_migr_vol_cap,
1876 migr_rec->post_migr_vol_cap_hi) * IMSM_4K_DIV),
1877 &migr_rec->post_migr_vol_cap,
1878 &migr_rec->post_migr_vol_cap_hi);
9f421827
PB		 1879 set_migr_chkp_area_pba(migr_rec,
1880 migr_chkp_area_pba(migr_rec) * IMSM_4K_DIV);
1881 set_migr_dest_1st_member_lba(migr_rec,
1882 migr_dest_1st_member_lba(migr_rec) * IMSM_4K_DIV);
de44e46f
PB		 1883}
1884
f36a9ecd
PB		 1885void convert_from_4k(struct intel_super *super)
1886{
1887 struct imsm_super *mpb = super->anchor;
1888 struct imsm_disk *disk;
1889 int i;
e4467bc7 1890 __u32 bbm_log_size = __le32_to_cpu(mpb->bbm_log_size);
f36a9ecd
PB		 1891
1892 for (i = 0; i < mpb->num_disks ; i++) {
1893 disk = __get_imsm_disk(mpb, i);
1894 /* disk */
1895 set_total_blocks(disk, (total_blocks(disk)*IMSM_4K_DIV));
1896 }
1897
1898 for (i = 0; i < mpb->num_raid_devs; i++) {
1899 struct imsm_dev *dev = __get_imsm_dev(mpb, i);
1900 struct imsm_map *map = get_imsm_map(dev, MAP_0);
1901 /* dev */
fcc2c9da 1902 set_imsm_dev_size(dev, imsm_dev_size(dev)*IMSM_4K_DIV);
f36a9ecd
PB		 1903 dev->vol.curr_migr_unit *= IMSM_4K_DIV;
1904
1905 /* map0 */
1906 set_blocks_per_member(map, blocks_per_member(map)*IMSM_4K_DIV);
1907 map->blocks_per_strip *= IMSM_4K_DIV;
1908 set_pba_of_lba0(map, pba_of_lba0(map)*IMSM_4K_DIV);
1909
1910 if (dev->vol.migr_state) {
1911 /* map1 */
1912 map = get_imsm_map(dev, MAP_1);
1913 set_blocks_per_member(map,
1914 blocks_per_member(map)*IMSM_4K_DIV);
1915 map->blocks_per_strip *= IMSM_4K_DIV;
1916 set_pba_of_lba0(map, pba_of_lba0(map)*IMSM_4K_DIV);
1917 }
1918 }
e4467bc7
TM		 1919 if (bbm_log_size) {
1920 struct bbm_log *log = (void *)mpb +
1921 __le32_to_cpu(mpb->mpb_size) - bbm_log_size;
1922 __u32 i;
1923
1924 for (i = 0; i < log->entry_count; i++) {
1925 struct bbm_log_entry *entry =
1926 &log->marked_block_entries[i];
1927
1928 __u8 count = entry->marked_count + 1;
1929 unsigned long long sector =
1930 __le48_to_cpu(&entry->defective_block_start);
1931
1932 entry->defective_block_start =
1933 __cpu_to_le48(sector*IMSM_4K_DIV);
1934 entry->marked_count = count*IMSM_4K_DIV - 1;
1935 }
1936 }
f36a9ecd
PB		 1937
1938 mpb->check_sum = __gen_imsm_checksum(mpb);
1939}
1940
19482bcc
AK		 1941/*******************************************************************************
1942 * function: imsm_check_attributes
1943 * Description: Function checks if features represented by attributes flags
1011e834 1944 * are supported by mdadm.
19482bcc
AK		 1945 * Parameters:
1946 * attributes - Attributes read from metadata
1947 * Returns:
1011e834
N		 1948 * 0 - passed attributes contains unsupported features flags
1949 * 1 - all features are supported
19482bcc
AK		 1950 ******************************************************************************/
1951static int imsm_check_attributes(__u32 attributes)
1952{
1953 int ret_val = 1;
418f9b36
N		 1954 __u32 not_supported = MPB_ATTRIB_SUPPORTED^0xffffffff;
1955
1956 not_supported &= ~MPB_ATTRIB_IGNORED;
19482bcc
AK		 1957
1958 not_supported &= attributes;
1959 if (not_supported) {
e7b84f9d 1960 pr_err("(IMSM): Unsupported attributes : %x\n",
418f9b36 1961 (unsigned)__le32_to_cpu(not_supported));
19482bcc
AK		 1962 if (not_supported & MPB_ATTRIB_CHECKSUM_VERIFY) {
1963 dprintf("\t\tMPB_ATTRIB_CHECKSUM_VERIFY \n");
1964 not_supported ^= MPB_ATTRIB_CHECKSUM_VERIFY;
1965 }
1966 if (not_supported & MPB_ATTRIB_2TB) {
1967 dprintf("\t\tMPB_ATTRIB_2TB\n");
1968 not_supported ^= MPB_ATTRIB_2TB;
1969 }
1970 if (not_supported & MPB_ATTRIB_RAID0) {
1971 dprintf("\t\tMPB_ATTRIB_RAID0\n");
1972 not_supported ^= MPB_ATTRIB_RAID0;
1973 }
1974 if (not_supported & MPB_ATTRIB_RAID1) {
1975 dprintf("\t\tMPB_ATTRIB_RAID1\n");
1976 not_supported ^= MPB_ATTRIB_RAID1;
1977 }
1978 if (not_supported & MPB_ATTRIB_RAID10) {
1979 dprintf("\t\tMPB_ATTRIB_RAID10\n");
1980 not_supported ^= MPB_ATTRIB_RAID10;
1981 }
1982 if (not_supported & MPB_ATTRIB_RAID1E) {
1983 dprintf("\t\tMPB_ATTRIB_RAID1E\n");
1984 not_supported ^= MPB_ATTRIB_RAID1E;
1985 }
1986 if (not_supported & MPB_ATTRIB_RAID5) {
1987 dprintf("\t\tMPB_ATTRIB_RAID5\n");
1988 not_supported ^= MPB_ATTRIB_RAID5;
1989 }
1990 if (not_supported & MPB_ATTRIB_RAIDCNG) {
1991 dprintf("\t\tMPB_ATTRIB_RAIDCNG\n");
1992 not_supported ^= MPB_ATTRIB_RAIDCNG;
1993 }
1994 if (not_supported & MPB_ATTRIB_BBM) {
1995 dprintf("\t\tMPB_ATTRIB_BBM\n");
1996 not_supported ^= MPB_ATTRIB_BBM;
1997 }
1998 if (not_supported & MPB_ATTRIB_CHECKSUM_VERIFY) {
1999 dprintf("\t\tMPB_ATTRIB_CHECKSUM_VERIFY (== MPB_ATTRIB_LEGACY)\n");
2000 not_supported ^= MPB_ATTRIB_CHECKSUM_VERIFY;
2001 }
2002 if (not_supported & MPB_ATTRIB_EXP_STRIPE_SIZE) {
2003 dprintf("\t\tMPB_ATTRIB_EXP_STRIP_SIZE\n");
2004 not_supported ^= MPB_ATTRIB_EXP_STRIPE_SIZE;
2005 }
2006 if (not_supported & MPB_ATTRIB_2TB_DISK) {
2007 dprintf("\t\tMPB_ATTRIB_2TB_DISK\n");
2008 not_supported ^= MPB_ATTRIB_2TB_DISK;
2009 }
2010 if (not_supported & MPB_ATTRIB_NEVER_USE2) {
2011 dprintf("\t\tMPB_ATTRIB_NEVER_USE2\n");
2012 not_supported ^= MPB_ATTRIB_NEVER_USE2;
2013 }
2014 if (not_supported & MPB_ATTRIB_NEVER_USE) {
2015 dprintf("\t\tMPB_ATTRIB_NEVER_USE\n");
2016 not_supported ^= MPB_ATTRIB_NEVER_USE;
2017 }
2018
2019 if (not_supported)
1ade5cc1 2020 dprintf("(IMSM): Unknown attributes : %x\n", not_supported);
19482bcc
AK		 2021
2022 ret_val = 0;
2023 }
2024
2025 return ret_val;
2026}
2027
a5d85af7 2028static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info, char *map);
44470971 2029
cdddbdbc
DW		 2030static void examine_super_imsm(struct supertype *st, char *homehost)
2031{
2032 struct intel_super *super = st->sb;
949c47a0 2033 struct imsm_super *mpb = super->anchor;
cdddbdbc
DW		 2034 char str[MAX_SIGNATURE_LENGTH];
2035 int i;
27fd6274
DW		 2036 struct mdinfo info;
2037 char nbuf[64];
cdddbdbc 2038 __u32 sum;
14e8215b 2039 __u32 reserved = imsm_reserved_sectors(super, super->disks);
94827db3 2040 struct dl *dl;
e48aed3c 2041 time_t creation_time;
27fd6274 2042
618f4e6d
XN		 2043 strncpy(str, (char *)mpb->sig, MPB_SIG_LEN);
2044 str[MPB_SIG_LEN-1] = '\0';
cdddbdbc 2045 printf(" Magic : %s\n", str);
cdddbdbc 2046 printf(" Version : %s\n", get_imsm_version(mpb));
148acb7b 2047 printf(" Orig Family : %08x\n", __le32_to_cpu(mpb->orig_family_num));
cdddbdbc
DW		 2048 printf(" Family : %08x\n", __le32_to_cpu(mpb->family_num));
2049 printf(" Generation : %08x\n", __le32_to_cpu(mpb->generation_num));
e48aed3c
AP		 2050 creation_time = __le64_to_cpu(mpb->creation_time);
2051 printf(" Creation Time : %.24s\n",
2052 creation_time ? ctime(&creation_time) : "Unknown");
19482bcc
AK		 2053 printf(" Attributes : ");
2054 if (imsm_check_attributes(mpb->attributes))
2055 printf("All supported\n");
2056 else
2057 printf("not supported\n");
a5d85af7 2058 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 2059 fname_from_uuid(st, &info, nbuf, ':');
27fd6274 2060 printf(" UUID : %s\n", nbuf + 5);
cdddbdbc
DW		 2061 sum = __le32_to_cpu(mpb->check_sum);
2062 printf(" Checksum : %08x %s\n", sum,
949c47a0 2063 __gen_imsm_checksum(mpb) == sum ? "correct" : "incorrect");
f36a9ecd 2064 printf(" MPB Sectors : %d\n", mpb_sectors(mpb, super->sector_size));
cdddbdbc
DW		 2065 printf(" Disks : %d\n", mpb->num_disks);
2066 printf(" RAID Devices : %d\n", mpb->num_raid_devs);
ef5c214e
MK		 2067 print_imsm_disk(__get_imsm_disk(mpb, super->disks->index),
2068 super->disks->index, reserved, super->sector_size);
8d67477f 2069 if (get_imsm_bbm_log_size(super->bbm_log)) {
604b746f
JD		 2070 struct bbm_log *log = super->bbm_log;
2071
2072 printf("\n");
2073 printf("Bad Block Management Log:\n");
2074 printf(" Log Size : %d\n", __le32_to_cpu(mpb->bbm_log_size));
2075 printf(" Signature : %x\n", __le32_to_cpu(log->signature));
2076 printf(" Entry Count : %d\n", __le32_to_cpu(log->entry_count));
604b746f 2077 }
44470971
DW		 2078 for (i = 0; i < mpb->num_raid_devs; i++) {
2079 struct mdinfo info;
2080 struct imsm_dev *dev = __get_imsm_dev(mpb, i);
2081
2082 super->current_vol = i;
a5d85af7 2083 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 2084 fname_from_uuid(st, &info, nbuf, ':');
c47b0ff6 2085 print_imsm_dev(super, dev, nbuf + 5, super->disks->index);
44470971 2086 }
cdddbdbc
DW		 2087 for (i = 0; i < mpb->num_disks; i++) {
2088 if (i == super->disks->index)
2089 continue;
ef5c214e
MK		 2090 print_imsm_disk(__get_imsm_disk(mpb, i), i, reserved,
2091 super->sector_size);
cdddbdbc 2092 }
94827db3 2093
0ec1f4e8
DW		 2094 for (dl = super->disks; dl; dl = dl->next)
2095 if (dl->index == -1)
ef5c214e
MK		 2096 print_imsm_disk(&dl->disk, -1, reserved,
2097 super->sector_size);
520e69e2
AK		 2098
2099 examine_migr_rec_imsm(super);
cdddbdbc
DW		 2100}
2101
061f2c6a 2102static void brief_examine_super_imsm(struct supertype *st, int verbose)
cdddbdbc 2103{
27fd6274 2104 /* We just write a generic IMSM ARRAY entry */
ff54de6e
N		 2105 struct mdinfo info;
2106 char nbuf[64];
1e7bc0ed 2107 struct intel_super *super = st->sb;
1e7bc0ed 2108
0d5a423f
DW		 2109 if (!super->anchor->num_raid_devs) {
2110 printf("ARRAY metadata=imsm\n");
1e7bc0ed 2111 return;
0d5a423f 2112 }
ff54de6e 2113
a5d85af7 2114 getinfo_super_imsm(st, &info, NULL);
4737ae25
N		 2115 fname_from_uuid(st, &info, nbuf, ':');
2116 printf("ARRAY metadata=imsm UUID=%s\n", nbuf + 5);
2117}
2118
2119static void brief_examine_subarrays_imsm(struct supertype *st, int verbose)
2120{
2121 /* We just write a generic IMSM ARRAY entry */
2122 struct mdinfo info;
2123 char nbuf[64];
2124 char nbuf1[64];
2125 struct intel_super *super = st->sb;
2126 int i;
2127
2128 if (!super->anchor->num_raid_devs)
2129 return;
2130
a5d85af7 2131 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 2132 fname_from_uuid(st, &info, nbuf, ':');
1e7bc0ed
DW		 2133 for (i = 0; i < super->anchor->num_raid_devs; i++) {
2134 struct imsm_dev *dev = get_imsm_dev(super, i);
2135
2136 super->current_vol = i;
a5d85af7 2137 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 2138 fname_from_uuid(st, &info, nbuf1, ':');
1124b3cf 2139 printf("ARRAY /dev/md/%.16s container=%s member=%d UUID=%s\n",
cf8de691 2140 dev->volume, nbuf + 5, i, nbuf1 + 5);
1e7bc0ed 2141 }
cdddbdbc
DW		 2142}
2143
9d84c8ea
DW		 2144static void export_examine_super_imsm(struct supertype *st)
2145{
2146 struct intel_super *super = st->sb;
2147 struct imsm_super *mpb = super->anchor;
2148 struct mdinfo info;
2149 char nbuf[64];
2150
a5d85af7 2151 getinfo_super_imsm(st, &info, NULL);
9d84c8ea
DW		 2152 fname_from_uuid(st, &info, nbuf, ':');
2153 printf("MD_METADATA=imsm\n");
2154 printf("MD_LEVEL=container\n");
2155 printf("MD_UUID=%s\n", nbuf+5);
2156 printf("MD_DEVICES=%u\n", mpb->num_disks);
e48aed3c 2157 printf("MD_CREATION_TIME=%llu\n", __le64_to_cpu(mpb->creation_time));
9d84c8ea
DW		 2158}
2159
b771faef
BK		 2160static void detail_super_imsm(struct supertype *st, char *homehost,
2161 char *subarray)
cdddbdbc 2162{
3ebe00a1
DW		 2163 struct mdinfo info;
2164 char nbuf[64];
b771faef
BK		 2165 struct intel_super *super = st->sb;
2166 int temp_vol = super->current_vol;
2167
2168 if (subarray)
2169 super->current_vol = strtoul(subarray, NULL, 10);
3ebe00a1 2170
a5d85af7 2171 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 2172 fname_from_uuid(st, &info, nbuf, ':');
65884368 2173 printf("\n UUID : %s\n", nbuf + 5);
b771faef
BK		 2174
2175 super->current_vol = temp_vol;
cdddbdbc
DW		 2176}
2177
b771faef 2178static void brief_detail_super_imsm(struct supertype *st, char *subarray)
cdddbdbc 2179{
ff54de6e
N		 2180 struct mdinfo info;
2181 char nbuf[64];
b771faef
BK		 2182 struct intel_super *super = st->sb;
2183 int temp_vol = super->current_vol;
2184
2185 if (subarray)
2186 super->current_vol = strtoul(subarray, NULL, 10);
2187
a5d85af7 2188 getinfo_super_imsm(st, &info, NULL);
ae2bfd4e 2189 fname_from_uuid(st, &info, nbuf, ':');
ff54de6e 2190 printf(" UUID=%s", nbuf + 5);
b771faef
BK		 2191
2192 super->current_vol = temp_vol;
cdddbdbc 2193}
d665cc31 2194
6da53c0e
BK		 2195static int imsm_read_serial(int fd, char *devname, __u8 *serial,
2196 size_t serial_buf_len);
d665cc31
DW		 2197static void fd2devname(int fd, char *name);
2198
120dc887 2199static int ahci_enumerate_ports(const char *hba_path, int port_count, int host_base, int verbose)
d665cc31 2200{
120dc887
LM		 2201 /* dump an unsorted list of devices attached to AHCI Intel storage
2202 * controller, as well as non-connected ports
d665cc31
DW		 2203 */
2204 int hba_len = strlen(hba_path) + 1;
2205 struct dirent *ent;
2206 DIR *dir;
2207 char *path = NULL;
2208 int err = 0;
2209 unsigned long port_mask = (1 << port_count) - 1;
2210
f21e18ca 2211 if (port_count > (int)sizeof(port_mask) * 8) {
ba728be7 2212 if (verbose > 0)
e7b84f9d 2213 pr_err("port_count %d out of range\n", port_count);
d665cc31
DW		 2214 return 2;
2215 }
2216
2217 /* scroll through /sys/dev/block looking for devices attached to
2218 * this hba
2219 */
2220 dir = opendir("/sys/dev/block");
1a6dd6b9
PB		 2221 if (!dir)
2222 return 1;
2223
2224 for (ent = readdir(dir); ent; ent = readdir(dir)) {
d665cc31
DW		 2225 int fd;
2226 char model[64];
2227 char vendor[64];
2228 char buf[1024];
2229 int major, minor;
2230 char *device;
2231 char *c;
2232 int port;
2233 int type;
2234
2235 if (sscanf(ent->d_name, "%d:%d", &major, &minor) != 2)
2236 continue;
2237 path = devt_to_devpath(makedev(major, minor));
2238 if (!path)
2239 continue;
2240 if (!path_attached_to_hba(path, hba_path)) {
2241 free(path);
2242 path = NULL;
2243 continue;
2244 }
2245
2246 /* retrieve the scsi device type */
2247 if (asprintf(&device, "/sys/dev/block/%d:%d/device/xxxxxxx", major, minor) < 0) {
ba728be7 2248 if (verbose > 0)
e7b84f9d 2249 pr_err("failed to allocate 'device'\n");
d665cc31
DW		 2250 err = 2;
2251 break;
2252 }
2253 sprintf(device, "/sys/dev/block/%d:%d/device/type", major, minor);
193b6c0b 2254 if (load_sys(device, buf, sizeof(buf)) != 0) {
ba728be7 2255 if (verbose > 0)
e7b84f9d 2256 pr_err("failed to read device type for %s\n",
d665cc31
DW		 2257 path);
2258 err = 2;
2259 free(device);
2260 break;
2261 }
2262 type = strtoul(buf, NULL, 10);
2263
2264 /* if it's not a disk print the vendor and model */
2265 if (!(type == 0 || type == 7 || type == 14)) {
2266 vendor[0] = '\0';
2267 model[0] = '\0';
2268 sprintf(device, "/sys/dev/block/%d:%d/device/vendor", major, minor);
193b6c0b 2269 if (load_sys(device, buf, sizeof(buf)) == 0) {
d665cc31
DW		 2270 strncpy(vendor, buf, sizeof(vendor));
2271 vendor[sizeof(vendor) - 1] = '\0';
2272 c = (char *) &vendor[sizeof(vendor) - 1];
2273 while (isspace(*c) || *c == '\0')
2274 *c-- = '\0';
2275
2276 }
2277 sprintf(device, "/sys/dev/block/%d:%d/device/model", major, minor);
193b6c0b 2278 if (load_sys(device, buf, sizeof(buf)) == 0) {
d665cc31
DW		 2279 strncpy(model, buf, sizeof(model));
2280 model[sizeof(model) - 1] = '\0';
2281 c = (char *) &model[sizeof(model) - 1];
2282 while (isspace(*c) || *c == '\0')
2283 *c-- = '\0';
2284 }
2285
2286 if (vendor[0] && model[0])
2287 sprintf(buf, "%.64s %.64s", vendor, model);
2288 else
2289 switch (type) { /* numbers from hald/linux/device.c */
2290 case 1: sprintf(buf, "tape"); break;
2291 case 2: sprintf(buf, "printer"); break;
2292 case 3: sprintf(buf, "processor"); break;
2293 case 4:
2294 case 5: sprintf(buf, "cdrom"); break;
2295 case 6: sprintf(buf, "scanner"); break;
2296 case 8: sprintf(buf, "media_changer"); break;
2297 case 9: sprintf(buf, "comm"); break;
2298 case 12: sprintf(buf, "raid"); break;
2299 default: sprintf(buf, "unknown");
2300 }
2301 } else
2302 buf[0] = '\0';
2303 free(device);
2304
2305 /* chop device path to 'host%d' and calculate the port number */
2306 c = strchr(&path[hba_len], '/');
4e5e717d 2307 if (!c) {
ba728be7 2308 if (verbose > 0)
e7b84f9d 2309 pr_err("%s - invalid path name\n", path + hba_len);
4e5e717d
AW		 2310 err = 2;
2311 break;
2312 }
d665cc31 2313 *c = '\0';
0858eccf
AP		 2314 if ((sscanf(&path[hba_len], "ata%d", &port) == 1) ||
2315 ((sscanf(&path[hba_len], "host%d", &port) == 1)))
d665cc31
DW		 2316 port -= host_base;
2317 else {
ba728be7 2318 if (verbose > 0) {
d665cc31 2319 *c = '/'; /* repair the full string */
e7b84f9d 2320 pr_err("failed to determine port number for %s\n",
d665cc31
DW		 2321 path);
2322 }
2323 err = 2;
2324 break;
2325 }
2326
2327 /* mark this port as used */
2328 port_mask &= ~(1 << port);
2329
2330 /* print out the device information */
2331 if (buf[0]) {
2332 printf(" Port%d : - non-disk device (%s) -\n", port, buf);
2333 continue;
2334 }
2335
2336 fd = dev_open(ent->d_name, O_RDONLY);
2337 if (fd < 0)
2338 printf(" Port%d : - disk info unavailable -\n", port);
2339 else {
2340 fd2devname(fd, buf);
2341 printf(" Port%d : %s", port, buf);
6da53c0e
BK		 2342 if (imsm_read_serial(fd, NULL, (__u8 *)buf,
2343 sizeof(buf)) == 0)
2344 printf(" (%s)\n", buf);
d665cc31 2345 else
664d5325 2346 printf(" ()\n");
4dab422a 2347 close(fd);
d665cc31 2348 }
d665cc31
DW		 2349 free(path);
2350 path = NULL;
2351 }
2352 if (path)
2353 free(path);
2354 if (dir)
2355 closedir(dir);
2356 if (err == 0) {
2357 int i;
2358
2359 for (i = 0; i < port_count; i++)
2360 if (port_mask & (1 << i))
2361 printf(" Port%d : - no device attached -\n", i);
2362 }
2363
2364 return err;
2365}
2366
6da53c0e 2367static int print_nvme_info(struct sys_dev *hba)
60f0f54d 2368{
6da53c0e 2369 char buf[1024];
60f0f54d
PB		 2370 struct dirent *ent;
2371 DIR *dir;
6da53c0e
BK		 2372 char *rp;
2373 int fd;
60f0f54d 2374
6da53c0e 2375 dir = opendir("/sys/block/");
b9135011 2376 if (!dir)
b5eece69 2377 return 1;
b9135011
JS		 2378
2379 for (ent = readdir(dir); ent; ent = readdir(dir)) {
6da53c0e
BK		 2380 if (strstr(ent->d_name, "nvme")) {
2381 sprintf(buf, "/sys/block/%s", ent->d_name);
2382 rp = realpath(buf, NULL);
2383 if (!rp)
2384 continue;
2385 if (path_attached_to_hba(rp, hba->path)) {
2386 fd = open_dev(ent->d_name);
a8f3cfd5
MT		 2387 if (!imsm_is_nvme_supported(fd, 0)) {
2388 if (fd >= 0)
2389 close(fd);
6da53c0e
BK		 2390 free(rp);
2391 continue;
2392 }
60f0f54d 2393
6da53c0e
BK		 2394 fd2devname(fd, buf);
2395 if (hba->type == SYS_DEV_VMD)
2396 printf(" NVMe under VMD : %s", buf);
2397 else if (hba->type == SYS_DEV_NVME)
2398 printf(" NVMe Device : %s", buf);
2399 if (!imsm_read_serial(fd, NULL, (__u8 *)buf,
2400 sizeof(buf)))
2401 printf(" (%s)\n", buf);
2402 else
2403 printf("()\n");
2404 close(fd);
2405 }
2406 free(rp);
60f0f54d 2407 }
60f0f54d
PB		 2408 }
2409
b9135011 2410 closedir(dir);
b5eece69 2411 return 0;
60f0f54d
PB		 2412}
2413
120dc887
LM		 2414static void print_found_intel_controllers(struct sys_dev *elem)
2415{
2416 for (; elem; elem = elem->next) {
e7b84f9d 2417 pr_err("found Intel(R) ");
120dc887
LM		 2418 if (elem->type == SYS_DEV_SATA)
2419 fprintf(stderr, "SATA ");
155cbb4c
LM		 2420 else if (elem->type == SYS_DEV_SAS)
2421 fprintf(stderr, "SAS ");
0858eccf
AP		 2422 else if (elem->type == SYS_DEV_NVME)
2423 fprintf(stderr, "NVMe ");
60f0f54d
PB		 2424
2425 if (elem->type == SYS_DEV_VMD)
2426 fprintf(stderr, "VMD domain");
2427 else
2428 fprintf(stderr, "RAID controller");
2429
120dc887
LM		 2430 if (elem->pci_id)
2431 fprintf(stderr, " at %s", elem->pci_id);
2432 fprintf(stderr, ".\n");
2433 }
2434 fflush(stderr);
2435}
2436
120dc887
LM		 2437static int ahci_get_port_count(const char *hba_path, int *port_count)
2438{
2439 struct dirent *ent;
2440 DIR *dir;
2441 int host_base = -1;
2442
2443 *port_count = 0;
2444 if ((dir = opendir(hba_path)) == NULL)
2445 return -1;
2446
2447 for (ent = readdir(dir); ent; ent = readdir(dir)) {
2448 int host;
2449
0858eccf
AP		 2450 if ((sscanf(ent->d_name, "ata%d", &host) != 1) &&
2451 ((sscanf(ent->d_name, "host%d", &host) != 1)))
120dc887
LM		 2452 continue;
2453 if (*port_count == 0)
2454 host_base = host;
2455 else if (host < host_base)
2456 host_base = host;
2457
2458 if (host + 1 > *port_count + host_base)
2459 *port_count = host + 1 - host_base;
2460 }
2461 closedir(dir);
2462 return host_base;
2463}
2464
a891a3c2
LM		 2465static void print_imsm_capability(const struct imsm_orom *orom)
2466{
0858eccf
AP		 2467 printf(" Platform : Intel(R) ");
2468 if (orom->capabilities == 0 && orom->driver_features == 0)
2469 printf("Matrix Storage Manager\n");
ab0c6bb9
AP		 2470 else if (imsm_orom_is_enterprise(orom) && orom->major_ver >= 6)
2471 printf("Virtual RAID on CPU\n");
0858eccf
AP		 2472 else
2473 printf("Rapid Storage Technology%s\n",
2474 imsm_orom_is_enterprise(orom) ? " enterprise" : "");
2475 if (orom->major_ver || orom->minor_ver || orom->hotfix_ver || orom->build)
2476 printf(" Version : %d.%d.%d.%d\n", orom->major_ver,
2477 orom->minor_ver, orom->hotfix_ver, orom->build);
a891a3c2
LM		 2478 printf(" RAID Levels :%s%s%s%s%s\n",
2479 imsm_orom_has_raid0(orom) ? " raid0" : "",
2480 imsm_orom_has_raid1(orom) ? " raid1" : "",
2481 imsm_orom_has_raid1e(orom) ? " raid1e" : "",
2482 imsm_orom_has_raid10(orom) ? " raid10" : "",
2483 imsm_orom_has_raid5(orom) ? " raid5" : "");
2484 printf(" Chunk Sizes :%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
2485 imsm_orom_has_chunk(orom, 2) ? " 2k" : "",
2486 imsm_orom_has_chunk(orom, 4) ? " 4k" : "",
2487 imsm_orom_has_chunk(orom, 8) ? " 8k" : "",
2488 imsm_orom_has_chunk(orom, 16) ? " 16k" : "",
2489 imsm_orom_has_chunk(orom, 32) ? " 32k" : "",
2490 imsm_orom_has_chunk(orom, 64) ? " 64k" : "",
2491 imsm_orom_has_chunk(orom, 128) ? " 128k" : "",
2492 imsm_orom_has_chunk(orom, 256) ? " 256k" : "",
2493 imsm_orom_has_chunk(orom, 512) ? " 512k" : "",
2494 imsm_orom_has_chunk(orom, 1024*1) ? " 1M" : "",
2495 imsm_orom_has_chunk(orom, 1024*2) ? " 2M" : "",
2496 imsm_orom_has_chunk(orom, 1024*4) ? " 4M" : "",
2497 imsm_orom_has_chunk(orom, 1024*8) ? " 8M" : "",
2498 imsm_orom_has_chunk(orom, 1024*16) ? " 16M" : "",
2499 imsm_orom_has_chunk(orom, 1024*32) ? " 32M" : "",
2500 imsm_orom_has_chunk(orom, 1024*64) ? " 64M" : "");
29cd0821
CA		 2501 printf(" 2TB volumes :%s supported\n",
2502 (orom->attr & IMSM_OROM_ATTR_2TB)?"":" not");
2503 printf(" 2TB disks :%s supported\n",
2504 (orom->attr & IMSM_OROM_ATTR_2TB_DISK)?"":" not");
0e7f69a8 2505 printf(" Max Disks : %d\n", orom->tds);
0858eccf
AP		 2506 printf(" Max Volumes : %d per array, %d per %s\n",
2507 orom->vpa, orom->vphba,
2508 imsm_orom_is_nvme(orom) ? "platform" : "controller");
a891a3c2
LM		 2509 return;
2510}
2511
e50cf220
MN		 2512static void print_imsm_capability_export(const struct imsm_orom *orom)
2513{
2514 printf("MD_FIRMWARE_TYPE=imsm\n");
0858eccf
AP		 2515 if (orom->major_ver || orom->minor_ver || orom->hotfix_ver || orom->build)
2516 printf("IMSM_VERSION=%d.%d.%d.%d\n", orom->major_ver, orom->minor_ver,
2517 orom->hotfix_ver, orom->build);
e50cf220
MN		 2518 printf("IMSM_SUPPORTED_RAID_LEVELS=%s%s%s%s%s\n",
2519 imsm_orom_has_raid0(orom) ? "raid0 " : "",
2520 imsm_orom_has_raid1(orom) ? "raid1 " : "",
2521 imsm_orom_has_raid1e(orom) ? "raid1e " : "",
2522 imsm_orom_has_raid5(orom) ? "raid10 " : "",
2523 imsm_orom_has_raid10(orom) ? "raid5 " : "");
2524 printf("IMSM_SUPPORTED_CHUNK_SIZES=%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
2525 imsm_orom_has_chunk(orom, 2) ? "2k " : "",
2526 imsm_orom_has_chunk(orom, 4) ? "4k " : "",
2527 imsm_orom_has_chunk(orom, 8) ? "8k " : "",
2528 imsm_orom_has_chunk(orom, 16) ? "16k " : "",
2529 imsm_orom_has_chunk(orom, 32) ? "32k " : "",
2530 imsm_orom_has_chunk(orom, 64) ? "64k " : "",
2531 imsm_orom_has_chunk(orom, 128) ? "128k " : "",
2532 imsm_orom_has_chunk(orom, 256) ? "256k " : "",
2533 imsm_orom_has_chunk(orom, 512) ? "512k " : "",
2534 imsm_orom_has_chunk(orom, 1024*1) ? "1M " : "",
2535 imsm_orom_has_chunk(orom, 1024*2) ? "2M " : "",
2536 imsm_orom_has_chunk(orom, 1024*4) ? "4M " : "",
2537 imsm_orom_has_chunk(orom, 1024*8) ? "8M " : "",
2538 imsm_orom_has_chunk(orom, 1024*16) ? "16M " : "",
2539 imsm_orom_has_chunk(orom, 1024*32) ? "32M " : "",
2540 imsm_orom_has_chunk(orom, 1024*64) ? "64M " : "");
2541 printf("IMSM_2TB_VOLUMES=%s\n",(orom->attr & IMSM_OROM_ATTR_2TB) ? "yes" : "no");
2542 printf("IMSM_2TB_DISKS=%s\n",(orom->attr & IMSM_OROM_ATTR_2TB_DISK) ? "yes" : "no");
2543 printf("IMSM_MAX_DISKS=%d\n",orom->tds);
2544 printf("IMSM_MAX_VOLUMES_PER_ARRAY=%d\n",orom->vpa);
2545 printf("IMSM_MAX_VOLUMES_PER_CONTROLLER=%d\n",orom->vphba);
2546}
2547
9eafa1de 2548static int detail_platform_imsm(int verbose, int enumerate_only, char *controller_path)
d665cc31
DW		 2549{
2550 /* There are two components to imsm platform support, the ahci SATA
2551 * controller and the option-rom. To find the SATA controller we
2552 * simply look in /sys/bus/pci/drivers/ahci to see if an ahci
2553 * controller with the Intel vendor id is present. This approach
2554 * allows mdadm to leverage the kernel's ahci detection logic, with the
2555 * caveat that if ahci.ko is not loaded mdadm will not be able to
2556 * detect platform raid capabilities. The option-rom resides in a
2557 * platform "Adapter ROM". We scan for its signature to retrieve the
2558 * platform capabilities. If raid support is disabled in the BIOS the
2559 * option-rom capability structure will not be available.
2560 */
d665cc31 2561 struct sys_dev *list, *hba;
d665cc31
DW		 2562 int host_base = 0;
2563 int port_count = 0;
9eafa1de 2564 int result=1;
d665cc31 2565
5615172f 2566 if (enumerate_only) {
a891a3c2 2567 if (check_env("IMSM_NO_PLATFORM"))
5615172f 2568 return 0;
a891a3c2
LM		 2569 list = find_intel_devices();
2570 if (!list)
2571 return 2;
2572 for (hba = list; hba; hba = hba->next) {
6b781d33
AP		 2573 if (find_imsm_capability(hba)) {
2574 result = 0;
a891a3c2
LM		 2575 break;
2576 }
9eafa1de 2577 else
6b781d33 2578 result = 2;
a891a3c2 2579 }
a891a3c2 2580 return result;
5615172f
DW		 2581 }
2582
155cbb4c
LM		 2583 list = find_intel_devices();
2584 if (!list) {
ba728be7 2585 if (verbose > 0)
7a862a02 2586 pr_err("no active Intel(R) RAID controller found.\n");
d665cc31 2587 return 2;
ba728be7 2588 } else if (verbose > 0)
155cbb4c 2589 print_found_intel_controllers(list);
d665cc31 2590
a891a3c2 2591 for (hba = list; hba; hba = hba->next) {
0858eccf 2592 if (controller_path && (compare_paths(hba->path, controller_path) != 0))
9eafa1de 2593 continue;
0858eccf 2594 if (!find_imsm_capability(hba)) {
60f0f54d 2595 char buf[PATH_MAX];
e7b84f9d 2596 pr_err("imsm capabilities not found for controller: %s (type %s)\n",
60f0f54d
PB		 2597 hba->type == SYS_DEV_VMD ? vmd_domain_to_controller(hba, buf) : hba->path,
2598 get_sys_dev_type(hba->type));
0858eccf
AP		 2599 continue;
2600 }
2601 result = 0;
2602 }
2603
2604 if (controller_path && result == 1) {
2605 pr_err("no active Intel(R) RAID controller found under %s\n",
2606 controller_path);
2607 return result;
2608 }
2609
5e1d6128 2610 const struct orom_entry *entry;
0858eccf 2611
5e1d6128 2612 for (entry = orom_entries; entry; entry = entry->next) {
60f0f54d 2613 if (entry->type == SYS_DEV_VMD) {
07cb1e57 2614 print_imsm_capability(&entry->orom);
32716c51
PB		 2615 printf(" 3rd party NVMe :%s supported\n",
2616 imsm_orom_has_tpv_support(&entry->orom)?"":" not");
60f0f54d
PB		 2617 for (hba = list; hba; hba = hba->next) {
2618 if (hba->type == SYS_DEV_VMD) {
2619 char buf[PATH_MAX];
60f0f54d
PB		 2620 printf(" I/O Controller : %s (%s)\n",
2621 vmd_domain_to_controller(hba, buf), get_sys_dev_type(hba->type));
6da53c0e 2622 if (print_nvme_info(hba)) {
b5eece69
PB		 2623 if (verbose > 0)
2624 pr_err("failed to get devices attached to VMD domain.\n");
2625 result |= 2;
2626 }
60f0f54d
PB		 2627 }
2628 }
07cb1e57 2629 printf("\n");
60f0f54d
PB		 2630 continue;
2631 }
0858eccf 2632
60f0f54d
PB		 2633 print_imsm_capability(&entry->orom);
2634 if (entry->type == SYS_DEV_NVME) {
0858eccf
AP		 2635 for (hba = list; hba; hba = hba->next) {
2636 if (hba->type == SYS_DEV_NVME)
6da53c0e 2637 print_nvme_info(hba);
0858eccf 2638 }
60f0f54d 2639 printf("\n");
0858eccf
AP		 2640 continue;
2641 }
2642
2643 struct devid_list *devid;
5e1d6128 2644 for (devid = entry->devid_list; devid; devid = devid->next) {
0858eccf
AP		 2645 hba = device_by_id(devid->devid);
2646 if (!hba)
2647 continue;
2648
9eafa1de
MN		 2649 printf(" I/O Controller : %s (%s)\n",
2650 hba->path, get_sys_dev_type(hba->type));
2651 if (hba->type == SYS_DEV_SATA) {
2652 host_base = ahci_get_port_count(hba->path, &port_count);
2653 if (ahci_enumerate_ports(hba->path, port_count, host_base, verbose)) {
2654 if (verbose > 0)
7a862a02 2655 pr_err("failed to enumerate ports on SATA controller at %s.\n", hba->pci_id);
9eafa1de
MN		 2656 result |= 2;
2657 }
120dc887
LM		 2658 }
2659 }
0858eccf 2660 printf("\n");
d665cc31 2661 }
155cbb4c 2662
120dc887 2663 return result;
d665cc31 2664}
e50cf220 2665
9eafa1de 2666static int export_detail_platform_imsm(int verbose, char *controller_path)
e50cf220 2667{
e50cf220
MN		 2668 struct sys_dev *list, *hba;
2669 int result=1;
2670
2671 list = find_intel_devices();
2672 if (!list) {
2673 if (verbose > 0)
2674 pr_err("IMSM_DETAIL_PLATFORM_ERROR=NO_INTEL_DEVICES\n");
2675 result = 2;
e50cf220
MN		 2676 return result;
2677 }
2678
2679 for (hba = list; hba; hba = hba->next) {
9eafa1de
MN		 2680 if (controller_path && (compare_paths(hba->path,controller_path) != 0))
2681 continue;
60f0f54d
PB		 2682 if (!find_imsm_capability(hba) && verbose > 0) {
2683 char buf[PATH_MAX];
2684 pr_err("IMSM_DETAIL_PLATFORM_ERROR=NO_IMSM_CAPABLE_DEVICE_UNDER_%s\n",
2685 hba->type == SYS_DEV_VMD ? vmd_domain_to_controller(hba, buf) : hba->path);
2686 }
0858eccf 2687 else
e50cf220 2688 result = 0;
e50cf220
MN		 2689 }
2690
5e1d6128 2691 const struct orom_entry *entry;
0858eccf 2692
60f0f54d
PB		 2693 for (entry = orom_entries; entry; entry = entry->next) {
2694 if (entry->type == SYS_DEV_VMD) {
2695 for (hba = list; hba; hba = hba->next)
2696 print_imsm_capability_export(&entry->orom);
2697 continue;
2698 }
5e1d6128 2699 print_imsm_capability_export(&entry->orom);
60f0f54d 2700 }
0858eccf 2701
e50cf220
MN		 2702 return result;
2703}
2704
cdddbdbc
DW		 2705static int match_home_imsm(struct supertype *st, char *homehost)
2706{
5115ca67
DW		 2707 /* the imsm metadata format does not specify any host
2708 * identification information. We return -1 since we can never
2709 * confirm nor deny whether a given array is "meant" for this
148acb7b 2710 * host. We rely on compare_super and the 'family_num' fields to
5115ca67
DW		 2711 * exclude member disks that do not belong, and we rely on
2712 * mdadm.conf to specify the arrays that should be assembled.
2713 * Auto-assembly may still pick up "foreign" arrays.
2714 */
cdddbdbc 2715
9362c1c8 2716 return -1;
cdddbdbc
DW		 2717}
2718
2719static void uuid_from_super_imsm(struct supertype *st, int uuid[4])
2720{
51006d85
N		 2721 /* The uuid returned here is used for:
2722 * uuid to put into bitmap file (Create, Grow)
2723 * uuid for backup header when saving critical section (Grow)
2724 * comparing uuids when re-adding a device into an array
2725 * In these cases the uuid required is that of the data-array,
2726 * not the device-set.
2727 * uuid to recognise same set when adding a missing device back
2728 * to an array. This is a uuid for the device-set.
1011e834 2729 *
51006d85
N		 2730 * For each of these we can make do with a truncated
2731 * or hashed uuid rather than the original, as long as
2732 * everyone agrees.
2733 * In each case the uuid required is that of the data-array,
2734 * not the device-set.
43dad3d6 2735 */
51006d85
N		 2736 /* imsm does not track uuid's so we synthesis one using sha1 on
2737 * - The signature (Which is constant for all imsm array, but no matter)
148acb7b 2738 * - the orig_family_num of the container
51006d85
N		 2739 * - the index number of the volume
2740 * - the 'serial' number of the volume.
2741 * Hopefully these are all constant.
2742 */
2743 struct intel_super *super = st->sb;
43dad3d6 2744
51006d85
N		 2745 char buf[20];
2746 struct sha1_ctx ctx;
2747 struct imsm_dev *dev = NULL;
148acb7b 2748 __u32 family_num;
51006d85 2749
148acb7b
DW		 2750 /* some mdadm versions failed to set ->orig_family_num, in which
2751 * case fall back to ->family_num. orig_family_num will be
2752 * fixed up with the first metadata update.
2753 */
2754 family_num = super->anchor->orig_family_num;
2755 if (family_num == 0)
2756 family_num = super->anchor->family_num;
51006d85 2757 sha1_init_ctx(&ctx);
92bd8f8d 2758 sha1_process_bytes(super->anchor->sig, MPB_SIG_LEN, &ctx);
148acb7b 2759 sha1_process_bytes(&family_num, sizeof(__u32), &ctx);
51006d85
N		 2760 if (super->current_vol >= 0)
2761 dev = get_imsm_dev(super, super->current_vol);
2762 if (dev) {
2763 __u32 vol = super->current_vol;
2764 sha1_process_bytes(&vol, sizeof(vol), &ctx);
2765 sha1_process_bytes(dev->volume, MAX_RAID_SERIAL_LEN, &ctx);
2766 }
2767 sha1_finish_ctx(&ctx, buf);
2768 memcpy(uuid, buf, 4*4);
cdddbdbc
DW		 2769}
2770
0d481d37 2771#if 0
4f5bc454
DW		 2772static void
2773get_imsm_numerical_version(struct imsm_super *mpb, int *m, int *p)
cdddbdbc 2774{
cdddbdbc
DW		 2775 __u8 *v = get_imsm_version(mpb);
2776 __u8 *end = mpb->sig + MAX_SIGNATURE_LENGTH;
2777 char major[] = { 0, 0, 0 };
2778 char minor[] = { 0 ,0, 0 };
2779 char patch[] = { 0, 0, 0 };
2780 char *ver_parse[] = { major, minor, patch };
2781 int i, j;
2782
2783 i = j = 0;
2784 while (*v != '\0' && v < end) {
2785 if (*v != '.' && j < 2)
2786 ver_parse[i][j++] = *v;
2787 else {
2788 i++;
2789 j = 0;
2790 }
2791 v++;
2792 }
2793
4f5bc454
DW		 2794 *m = strtol(minor, NULL, 0);
2795 *p = strtol(patch, NULL, 0);
2796}
0d481d37 2797#endif
4f5bc454 2798
1e5c6983
DW		 2799static __u32 migr_strip_blocks_resync(struct imsm_dev *dev)
2800{
2801 /* migr_strip_size when repairing or initializing parity */
238c0a71 2802 struct imsm_map *map = get_imsm_map(dev, MAP_0);
1e5c6983
DW		 2803 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
2804
2805 switch (get_imsm_raid_level(map)) {
2806 case 5:
2807 case 10:
2808 return chunk;
2809 default:
2810 return 128*1024 >> 9;
2811 }
2812}
2813
2814static __u32 migr_strip_blocks_rebuild(struct imsm_dev *dev)
2815{
2816 /* migr_strip_size when rebuilding a degraded disk, no idea why
2817 * this is different than migr_strip_size_resync(), but it's good
2818 * to be compatible
2819 */
238c0a71 2820 struct imsm_map *map = get_imsm_map(dev, MAP_1);
1e5c6983
DW		 2821 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
2822
2823 switch (get_imsm_raid_level(map)) {
2824 case 1:
2825 case 10:
2826 if (map->num_members % map->num_domains == 0)
2827 return 128*1024 >> 9;
2828 else
2829 return chunk;
2830 case 5:
2831 return max((__u32) 64*1024 >> 9, chunk);
2832 default:
2833 return 128*1024 >> 9;
2834 }
2835}
2836
2837static __u32 num_stripes_per_unit_resync(struct imsm_dev *dev)
2838{
238c0a71
AK		 2839 struct imsm_map *lo = get_imsm_map(dev, MAP_0);
2840 struct imsm_map *hi = get_imsm_map(dev, MAP_1);
1e5c6983
DW		 2841 __u32 lo_chunk = __le32_to_cpu(lo->blocks_per_strip);
2842 __u32 hi_chunk = __le32_to_cpu(hi->blocks_per_strip);
2843
2844 return max((__u32) 1, hi_chunk / lo_chunk);
2845}
2846
2847static __u32 num_stripes_per_unit_rebuild(struct imsm_dev *dev)
2848{
238c0a71 2849 struct imsm_map *lo = get_imsm_map(dev, MAP_0);
1e5c6983
DW		 2850 int level = get_imsm_raid_level(lo);
2851
2852 if (level == 1 || level == 10) {
238c0a71 2853 struct imsm_map *hi = get_imsm_map(dev, MAP_1);
1e5c6983
DW		 2854
2855 return hi->num_domains;
2856 } else
2857 return num_stripes_per_unit_resync(dev);
2858}
2859
9529d343 2860static __u8 imsm_num_data_members(struct imsm_map *map)
1e5c6983
DW		 2861{
2862 /* named 'imsm_' because raid0, raid1 and raid10
2863 * counter-intuitively have the same number of data disks
2864 */
1e5c6983
DW		 2865 switch (get_imsm_raid_level(map)) {
2866 case 0:
36fd8ccc
AK		 2867 return map->num_members;
2868 break;
1e5c6983
DW		 2869 case 1:
2870 case 10:
36fd8ccc 2871 return map->num_members/2;
1e5c6983
DW		 2872 case 5:
2873 return map->num_members - 1;
2874 default:
1ade5cc1 2875 dprintf("unsupported raid level\n");
1e5c6983
DW		 2876 return 0;
2877 }
2878}
2879
44490938
MD		 2880static unsigned long long calc_component_size(struct imsm_map *map,
2881 struct imsm_dev *dev)
2882{
2883 unsigned long long component_size;
2884 unsigned long long dev_size = imsm_dev_size(dev);
a4f7290c 2885 long long calc_dev_size = 0;
44490938
MD		 2886 unsigned int member_disks = imsm_num_data_members(map);
2887
2888 if (member_disks == 0)
2889 return 0;
2890
2891 component_size = per_dev_array_size(map);
2892 calc_dev_size = component_size * member_disks;
2893
2894 /* Component size is rounded to 1MB so difference between size from
2895 * metadata and size calculated from num_data_stripes equals up to
2896 * 2048 blocks per each device. If the difference is higher it means
2897 * that array size was expanded and num_data_stripes was not updated.
2898 */
a4f7290c 2899 if (llabs(calc_dev_size - (long long)dev_size) >
44490938
MD		 2900 (1 << SECT_PER_MB_SHIFT) * member_disks) {
2901 component_size = dev_size / member_disks;
2902 dprintf("Invalid num_data_stripes in metadata; expected=%llu, found=%llu\n",
2903 component_size / map->blocks_per_strip,
2904 num_data_stripes(map));
2905 }
2906
2907 return component_size;
2908}
2909
1e5c6983
DW		 2910static __u32 parity_segment_depth(struct imsm_dev *dev)
2911{
238c0a71 2912 struct imsm_map *map = get_imsm_map(dev, MAP_0);
1e5c6983
DW		 2913 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
2914
2915 switch(get_imsm_raid_level(map)) {
2916 case 1:
2917 case 10:
2918 return chunk * map->num_domains;
2919 case 5:
2920 return chunk * map->num_members;
2921 default:
2922 return chunk;
2923 }
2924}
2925
2926static __u32 map_migr_block(struct imsm_dev *dev, __u32 block)
2927{
238c0a71 2928 struct imsm_map *map = get_imsm_map(dev, MAP_1);
1e5c6983
DW		 2929 __u32 chunk = __le32_to_cpu(map->blocks_per_strip);
2930 __u32 strip = block / chunk;
2931
2932 switch (get_imsm_raid_level(map)) {
2933 case 1:
2934 case 10: {
2935 __u32 vol_strip = (strip * map->num_domains) + 1;
2936 __u32 vol_stripe = vol_strip / map->num_members;
2937
2938 return vol_stripe * chunk + block % chunk;
2939 } case 5: {
2940 __u32 stripe = strip / (map->num_members - 1);
2941
2942 return stripe * chunk + block % chunk;
2943 }
2944 default:
2945 return 0;
2946 }
2947}
2948
c47b0ff6
AK		 2949static __u64 blocks_per_migr_unit(struct intel_super *super,
2950 struct imsm_dev *dev)
1e5c6983
DW		 2951{
2952 /* calculate the conversion factor between per member 'blocks'
2953 * (md/{resync,rebuild}_start) and imsm migration units, return
2954 * 0 for the 'not migrating' and 'unsupported migration' cases
2955 */
2956 if (!dev->vol.migr_state)
2957 return 0;
2958
2959 switch (migr_type(dev)) {
c47b0ff6
AK		 2960 case MIGR_GEN_MIGR: {
2961 struct migr_record *migr_rec = super->migr_rec;
2962 return __le32_to_cpu(migr_rec->blocks_per_unit);
2963 }
1e5c6983
DW		 2964 case MIGR_VERIFY:
2965 case MIGR_REPAIR:
2966 case MIGR_INIT: {
238c0a71 2967 struct imsm_map *map = get_imsm_map(dev, MAP_0);
1e5c6983
DW		 2968 __u32 stripes_per_unit;
2969 __u32 blocks_per_unit;
2970 __u32 parity_depth;
2971 __u32 migr_chunk;
2972 __u32 block_map;
2973 __u32 block_rel;
2974 __u32 segment;
2975 __u32 stripe;
2976 __u8 disks;
2977
2978 /* yes, this is really the translation of migr_units to
2979 * per-member blocks in the 'resync' case
2980 */
2981 stripes_per_unit = num_stripes_per_unit_resync(dev);
2982 migr_chunk = migr_strip_blocks_resync(dev);
9529d343 2983 disks = imsm_num_data_members(map);
1e5c6983 2984 blocks_per_unit = stripes_per_unit * migr_chunk * disks;
7b1ab482 2985 stripe = __le16_to_cpu(map->blocks_per_strip) * disks;
1e5c6983
DW		 2986 segment = blocks_per_unit / stripe;
2987 block_rel = blocks_per_unit - segment * stripe;
2988 parity_depth = parity_segment_depth(dev);
2989 block_map = map_migr_block(dev, block_rel);
2990 return block_map + parity_depth * segment;
2991 }
2992 case MIGR_REBUILD: {
2993 __u32 stripes_per_unit;
2994 __u32 migr_chunk;
2995
2996 stripes_per_unit = num_stripes_per_unit_rebuild(dev);
2997 migr_chunk = migr_strip_blocks_rebuild(dev);
2998 return migr_chunk * stripes_per_unit;
2999 }
1e5c6983
DW		 3000 case MIGR_STATE_CHANGE:
3001 default:
3002 return 0;
3003 }
3004}
3005
c2c087e6
DW		 3006static int imsm_level_to_layout(int level)
3007{
3008 switch (level) {
3009 case 0:
3010 case 1:
3011 return 0;
3012 case 5:
3013 case 6:
a380c027 3014 return ALGORITHM_LEFT_ASYMMETRIC;
c2c087e6 3015 case 10:
c92a2527 3016 return 0x102;
c2c087e6 3017 }
a18a888e 3018 return UnSet;
c2c087e6
DW		 3019}
3020
8e59f3d8
AK		 3021/*******************************************************************************
3022 * Function: read_imsm_migr_rec
3023 * Description: Function reads imsm migration record from last sector of disk
3024 * Parameters:
3025 * fd : disk descriptor
3026 * super : metadata info
3027 * Returns:
3028 * 0 : success,
3029 * -1 : fail
3030 ******************************************************************************/
3031static int read_imsm_migr_rec(int fd, struct intel_super *super)
3032{
3033 int ret_val = -1;
de44e46f 3034 unsigned int sector_size = super->sector_size;
8e59f3d8
AK		 3035 unsigned long long dsize;
3036
3037 get_dev_size(fd, NULL, &dsize);
de44e46f
PB		 3038 if (lseek64(fd, dsize - (sector_size*MIGR_REC_SECTOR_POSITION),
3039 SEEK_SET) < 0) {
e7b84f9d
N		 3040 pr_err("Cannot seek to anchor block: %s\n",
3041 strerror(errno));
8e59f3d8
AK		 3042 goto out;
3043 }
466070ad 3044 if ((unsigned int)read(fd, super->migr_rec_buf,
de44e46f
PB		 3045 MIGR_REC_BUF_SECTORS*sector_size) !=
3046 MIGR_REC_BUF_SECTORS*sector_size) {
e7b84f9d
N		 3047 pr_err("Cannot read migr record block: %s\n",
3048 strerror(errno));
8e59f3d8
AK		 3049 goto out;
3050 }
3051 ret_val = 0;
de44e46f
PB		 3052 if (sector_size == 4096)
3053 convert_from_4k_imsm_migr_rec(super);
8e59f3d8
AK		 3054
3055out:
3056 return ret_val;
3057}
3058
3136abe5
AK		 3059static struct imsm_dev *imsm_get_device_during_migration(
3060 struct intel_super *super)
3061{
3062
3063 struct intel_dev *dv;
3064
3065 for (dv = super->devlist; dv; dv = dv->next) {
3066 if (is_gen_migration(dv->dev))
3067 return dv->dev;
3068 }
3069 return NULL;
3070}
3071
8e59f3d8
AK		 3072/*******************************************************************************
3073 * Function: load_imsm_migr_rec
3074 * Description: Function reads imsm migration record (it is stored at the last
3075 * sector of disk)
3076 * Parameters:
3077 * super : imsm internal array info
8e59f3d8
AK		 3078 * Returns:
3079 * 0 : success
3080 * -1 : fail
4c965cc9 3081 * -2 : no migration in progress
8e59f3d8 3082 ******************************************************************************/
2f86fda3 3083static int load_imsm_migr_rec(struct intel_super *super)
8e59f3d8 3084{
594dc1b8 3085 struct dl *dl;
8e59f3d8
AK		 3086 char nm[30];
3087 int retval = -1;
3088 int fd = -1;
3136abe5 3089 struct imsm_dev *dev;
594dc1b8 3090 struct imsm_map *map;
b4ab44d8 3091 int slot = -1;
2f86fda3 3092 int keep_fd = 1;
3136abe5
AK		 3093
3094 /* find map under migration */
3095 dev = imsm_get_device_during_migration(super);
3096 /* nothing to load,no migration in progress?
3097 */
3098 if (dev == NULL)
4c965cc9 3099 return -2;
8e59f3d8 3100
2f86fda3
MT		 3101 map = get_imsm_map(dev, MAP_0);
3102 if (!map)
3103 return -1;
3136abe5 3104
2f86fda3
MT		 3105 for (dl = super->disks; dl; dl = dl->next) {
3106 /* skip spare and failed disks
3107 */
3108 if (dl->index < 0)
3109 continue;
3110 /* read only from one of the first two slots
3111 */
3112 slot = get_imsm_disk_slot(map, dl->index);
3113 if (slot > 1 || slot < 0)
3114 continue;
3115
3116 if (dl->fd < 0) {
8e59f3d8
AK		 3117 sprintf(nm, "%d:%d", dl->major, dl->minor);
3118 fd = dev_open(nm, O_RDONLY);
2f86fda3
MT		 3119 if (fd >= 0) {
3120 keep_fd = 0;
8e59f3d8 3121 break;
2f86fda3
MT		 3122 }
3123 } else {
3124 fd = dl->fd;
3125 break;
8e59f3d8
AK		 3126 }
3127 }
2f86fda3 3128
8e59f3d8 3129 if (fd < 0)
2f86fda3 3130 return retval;
8e59f3d8 3131 retval = read_imsm_migr_rec(fd, super);
2f86fda3 3132 if (!keep_fd)
8e59f3d8 3133 close(fd);
2f86fda3 3134
8e59f3d8
AK		 3135 return retval;
3136}
3137
c17608ea
AK		 3138/*******************************************************************************
3139 * function: imsm_create_metadata_checkpoint_update
3140 * Description: It creates update for checkpoint change.
3141 * Parameters:
3142 * super : imsm internal array info
3143 * u : pointer to prepared update
3144 * Returns:
3145 * Uptate length.
3146 * If length is equal to 0, input pointer u contains no update
3147 ******************************************************************************/
3148static int imsm_create_metadata_checkpoint_update(
3149 struct intel_super *super,
3150 struct imsm_update_general_migration_checkpoint **u)
3151{
3152
3153 int update_memory_size = 0;
3154
1ade5cc1 3155 dprintf("(enter)\n");
c17608ea
AK		 3156
3157 if (u == NULL)
3158 return 0;
3159 *u = NULL;
3160
3161 /* size of all update data without anchor */
3162 update_memory_size =
3163 sizeof(struct imsm_update_general_migration_checkpoint);
3164
503975b9 3165 *u = xcalloc(1, update_memory_size);
c17608ea 3166 if (*u == NULL) {
1ade5cc1 3167 dprintf("error: cannot get memory\n");
c17608ea
AK		 3168 return 0;
3169 }
3170 (*u)->type = update_general_migration_checkpoint;
9f421827 3171 (*u)->curr_migr_unit = current_migr_unit(super->migr_rec);
1ade5cc1 3172 dprintf("prepared for %u\n", (*u)->curr_migr_unit);
c17608ea
AK		 3173
3174 return update_memory_size;
3175}
3176
c17608ea
AK		 3177static void imsm_update_metadata_locally(struct supertype *st,
3178 void *buf, int len);
3179
687629c2
AK		 3180/*******************************************************************************
3181 * Function: write_imsm_migr_rec
3182 * Description: Function writes imsm migration record
3183 * (at the last sector of disk)
3184 * Parameters:
3185 * super : imsm internal array info
3186 * Returns:
3187 * 0 : success
3188 * -1 : if fail
3189 ******************************************************************************/
3190static int write_imsm_migr_rec(struct supertype *st)
3191{
3192 struct intel_super *super = st->sb;
de44e46f 3193 unsigned int sector_size = super->sector_size;
687629c2 3194 unsigned long long dsize;
687629c2
AK		 3195 int retval = -1;
3196 struct dl *sd;
c17608ea
AK		 3197 int len;
3198 struct imsm_update_general_migration_checkpoint *u;
3136abe5 3199 struct imsm_dev *dev;
594dc1b8 3200 struct imsm_map *map;
3136abe5
AK		 3201
3202 /* find map under migration */
3203 dev = imsm_get_device_during_migration(super);
3204 /* if no migration, write buffer anyway to clear migr_record
3205 * on disk based on first available device
3206 */
3207 if (dev == NULL)
3208 dev = get_imsm_dev(super, super->current_vol < 0 ? 0 :
3209 super->current_vol);
3210
44bfe6df 3211 map = get_imsm_map(dev, MAP_0);
687629c2 3212
de44e46f
PB		 3213 if (sector_size == 4096)
3214 convert_to_4k_imsm_migr_rec(super);
687629c2 3215 for (sd = super->disks ; sd ; sd = sd->next) {
b4ab44d8 3216 int slot = -1;
3136abe5
AK		 3217
3218 /* skip failed and spare devices */
3219 if (sd->index < 0)
3220 continue;
687629c2 3221 /* write to 2 first slots only */
3136abe5
AK		 3222 if (map)
3223 slot = get_imsm_disk_slot(map, sd->index);
089f9d79 3224 if (map == NULL || slot > 1 || slot < 0)
687629c2 3225 continue;
3136abe5 3226
2f86fda3
MT		 3227 get_dev_size(sd->fd, NULL, &dsize);
3228 if (lseek64(sd->fd, dsize - (MIGR_REC_SECTOR_POSITION *
3229 sector_size),
de44e46f 3230 SEEK_SET) < 0) {
e7b84f9d
N		 3231 pr_err("Cannot seek to anchor block: %s\n",
3232 strerror(errno));
687629c2
AK		 3233 goto out;
3234 }
2f86fda3 3235 if ((unsigned int)write(sd->fd, super->migr_rec_buf,
de44e46f
PB		 3236 MIGR_REC_BUF_SECTORS*sector_size) !=
3237 MIGR_REC_BUF_SECTORS*sector_size) {
e7b84f9d
N		 3238 pr_err("Cannot write migr record block: %s\n",
3239 strerror(errno));
687629c2
AK		 3240 goto out;
3241 }
687629c2 3242 }
de44e46f
PB		 3243 if (sector_size == 4096)
3244 convert_from_4k_imsm_migr_rec(super);
c17608ea
AK		 3245 /* update checkpoint information in metadata */
3246 len = imsm_create_metadata_checkpoint_update(super, &u);
c17608ea
AK		 3247 if (len <= 0) {
3248 dprintf("imsm: Cannot prepare update\n");
3249 goto out;
3250 }
3251 /* update metadata locally */
3252 imsm_update_metadata_locally(st, u, len);
3253 /* and possibly remotely */
3254 if (st->update_tail) {
3255 append_metadata_update(st, u, len);
3256 /* during reshape we do all work inside metadata handler
3257 * manage_reshape(), so metadata update has to be triggered
3258 * insida it
3259 */
3260 flush_metadata_updates(st);
3261 st->update_tail = &st->updates;
3262 } else
3263 free(u);
687629c2
AK		 3264
3265 retval = 0;
3266 out:
687629c2
AK		 3267 return retval;
3268}
3269
e2962bfc
AK		 3270/* spare/missing disks activations are not allowe when
3271 * array/container performs reshape operation, because
3272 * all arrays in container works on the same disks set
3273 */
3274int imsm_reshape_blocks_arrays_changes(struct intel_super *super)
3275{
3276 int rv = 0;
3277 struct intel_dev *i_dev;
3278 struct imsm_dev *dev;
3279
3280 /* check whole container
3281 */
3282 for (i_dev = super->devlist; i_dev; i_dev = i_dev->next) {
3283 dev = i_dev->dev;
3ad25638 3284 if (is_gen_migration(dev)) {
e2962bfc
AK		 3285 /* No repair during any migration in container
3286 */
3287 rv = 1;
3288 break;
3289 }
3290 }
3291 return rv;
3292}
3e684231 3293static unsigned long long imsm_component_size_alignment_check(int level,
c41e00b2 3294 int chunk_size,
f36a9ecd 3295 unsigned int sector_size,
c41e00b2
AK		 3296 unsigned long long component_size)
3297{
3e684231 3298 unsigned int component_size_alignment;
c41e00b2 3299
3e684231 3300 /* check component size alignment
c41e00b2 3301 */
3e684231 3302 component_size_alignment = component_size % (chunk_size/sector_size);
c41e00b2 3303
3e684231 3304 dprintf("(Level: %i, chunk_size = %i, component_size = %llu), component_size_alignment = %u\n",
c41e00b2 3305 level, chunk_size, component_size,
3e684231 3306 component_size_alignment);
c41e00b2 3307
3e684231
MZ		 3308 if (component_size_alignment && (level != 1) && (level != UnSet)) {
3309 dprintf("imsm: reported component size aligned from %llu ",
c41e00b2 3310 component_size);
3e684231 3311 component_size -= component_size_alignment;
1ade5cc1 3312 dprintf_cont("to %llu (%i).\n",
3e684231 3313 component_size, component_size_alignment);
c41e00b2
AK		 3314 }
3315
3316 return component_size;
3317}
e2962bfc 3318
fbc42556
JR		 3319/*******************************************************************************
3320 * Function: get_bitmap_header_sector
3321 * Description: Returns the sector where the bitmap header is placed.
3322 * Parameters:
3323 * st : supertype information
3324 * dev_idx : index of the device with bitmap
3325 *
3326 * Returns:
3327 * The sector where the bitmap header is placed
3328 ******************************************************************************/
3329static unsigned long long get_bitmap_header_sector(struct intel_super *super,
3330 int dev_idx)
3331{
3332 struct imsm_dev *dev = get_imsm_dev(super, dev_idx);
3333 struct imsm_map *map = get_imsm_map(dev, MAP_0);
3334
3335 if (!super->sector_size) {
3336 dprintf("sector size is not set\n");
3337 return 0;
3338 }
3339
3340 return pba_of_lba0(map) + calc_component_size(map, dev) +
3341 (IMSM_BITMAP_HEADER_OFFSET / super->sector_size);
3342}
3343
3344/*******************************************************************************
3345 * Function: get_bitmap_sector
3346 * Description: Returns the sector where the bitmap is placed.
3347 * Parameters:
3348 * st : supertype information
3349 * dev_idx : index of the device with bitmap
3350 *
3351 * Returns:
3352 * The sector where the bitmap is placed
3353 ******************************************************************************/
3354static unsigned long long get_bitmap_sector(struct intel_super *super,
3355 int dev_idx)
3356{
3357 if (!super->sector_size) {
3358 dprintf("sector size is not set\n");
3359 return 0;
3360 }
3361
3362 return get_bitmap_header_sector(super, dev_idx) +
3363 (IMSM_BITMAP_HEADER_SIZE / super->sector_size);
3364}
3365
2432ce9b
AP		 3366static unsigned long long get_ppl_sector(struct intel_super *super, int dev_idx)
3367{
3368 struct imsm_dev *dev = get_imsm_dev(super, dev_idx);
3369 struct imsm_map *map = get_imsm_map(dev, MAP_0);
3370
3371 return pba_of_lba0(map) +
3372 (num_data_stripes(map) * map->blocks_per_strip);
3373}
3374
a5d85af7 3375static void getinfo_super_imsm_volume(struct supertype *st, struct mdinfo *info, char *dmap)
bf5a934a
DW		 3376{
3377 struct intel_super *super = st->sb;
c47b0ff6 3378 struct migr_record *migr_rec = super->migr_rec;
949c47a0 3379 struct imsm_dev *dev = get_imsm_dev(super, super->current_vol);
238c0a71
AK		 3380 struct imsm_map *map = get_imsm_map(dev, MAP_0);
3381 struct imsm_map *prev_map = get_imsm_map(dev, MAP_1);
b335e593 3382 struct imsm_map *map_to_analyse = map;
efb30e7f 3383 struct dl *dl;
a5d85af7 3384 int map_disks = info->array.raid_disks;
bf5a934a 3385
95eeceeb 3386 memset(info, 0, sizeof(*info));
b335e593
AK		 3387 if (prev_map)
3388 map_to_analyse = prev_map;
3389
ca0748fa 3390 dl = super->current_disk;
9894ec0d 3391
bf5a934a 3392 info->container_member = super->current_vol;
cd0430a1 3393 info->array.raid_disks = map->num_members;
b335e593 3394 info->array.level = get_imsm_raid_level(map_to_analyse);
bf5a934a
DW		 3395 info->array.layout = imsm_level_to_layout(info->array.level);
3396 info->array.md_minor = -1;
3397 info->array.ctime = 0;
3398 info->array.utime = 0;
b335e593
AK		 3399 info->array.chunk_size =
3400 __le16_to_cpu(map_to_analyse->blocks_per_strip) << 9;
2432ce9b 3401 info->array.state = !(dev->vol.dirty & RAIDVOL_DIRTY);
fcc2c9da 3402 info->custom_array_size = imsm_dev_size(dev);
3ad25638
AK		 3403 info->recovery_blocked = imsm_reshape_blocks_arrays_changes(st->sb);
3404
3f510843 3405 if (is_gen_migration(dev)) {
3f83228a 3406 info->reshape_active = 1;
b335e593
AK		 3407 info->new_level = get_imsm_raid_level(map);
3408 info->new_layout = imsm_level_to_layout(info->new_level);
3409 info->new_chunk = __le16_to_cpu(map->blocks_per_strip) << 9;
3f83228a 3410 info->delta_disks = map->num_members - prev_map->num_members;
493f5dd6
N		 3411 if (info->delta_disks) {
3412 /* this needs to be applied to every array
3413 * in the container.
3414 */
81219e70 3415 info->reshape_active = CONTAINER_RESHAPE;
493f5dd6 3416 }
3f83228a
N		 3417 /* We shape information that we give to md might have to be
3418 * modify to cope with md's requirement for reshaping arrays.
3419 * For example, when reshaping a RAID0, md requires it to be
3420 * presented as a degraded RAID4.
3421 * Also if a RAID0 is migrating to a RAID5 we need to specify
3422 * the array as already being RAID5, but the 'before' layout
3423 * is a RAID4-like layout.
3424 */
3425 switch (info->array.level) {
3426 case 0:
3427 switch(info->new_level) {
3428 case 0:
3429 /* conversion is happening as RAID4 */
3430 info->array.level = 4;
3431 info->array.raid_disks += 1;
3432 break;
3433 case 5:
3434 /* conversion is happening as RAID5 */
3435 info->array.level = 5;
3436 info->array.layout = ALGORITHM_PARITY_N;
3f83228a
N		 3437 info->delta_disks -= 1;
3438 break;
3439 default:
3440 /* FIXME error message */
3441 info->array.level = UnSet;
3442 break;
3443 }
3444 break;
3445 }
b335e593
AK		 3446 } else {
3447 info->new_level = UnSet;
3448 info->new_layout = UnSet;
3449 info->new_chunk = info->array.chunk_size;
3f83228a 3450 info->delta_disks = 0;
b335e593 3451 }
ca0748fa 3452
efb30e7f
DW		 3453 if (dl) {
3454 info->disk.major = dl->major;
3455 info->disk.minor = dl->minor;
ca0748fa 3456 info->disk.number = dl->index;
656b6b5a
N		 3457 info->disk.raid_disk = get_imsm_disk_slot(map_to_analyse,
3458 dl->index);
efb30e7f 3459 }
bf5a934a 3460
5551b113 3461 info->data_offset = pba_of_lba0(map_to_analyse);
44490938 3462 info->component_size = calc_component_size(map, dev);
3e684231 3463 info->component_size = imsm_component_size_alignment_check(
c41e00b2
AK		 3464 info->array.level,
3465 info->array.chunk_size,
f36a9ecd 3466 super->sector_size,
c41e00b2 3467 info->component_size);
5e46202e 3468 info->bb.supported = 1;
139dae11 3469
301406c9 3470 memset(info->uuid, 0, sizeof(info->uuid));
921d9e16 3471 info->recovery_start = MaxSector;
bf5a934a 3472
c2462068
PB		 3473 if (info->array.level == 5 &&
3474 (dev->rwh_policy == RWH_DISTRIBUTED ||
3475 dev->rwh_policy == RWH_MULTIPLE_DISTRIBUTED)) {
2432ce9b
AP		 3476 info->consistency_policy = CONSISTENCY_POLICY_PPL;
3477 info->ppl_sector = get_ppl_sector(super, super->current_vol);
c2462068
PB		 3478 if (dev->rwh_policy == RWH_MULTIPLE_DISTRIBUTED)
3479 info->ppl_size = MULTIPLE_PPL_AREA_SIZE_IMSM >> 9;
3480 else
3481 info->ppl_size = (PPL_HEADER_SIZE + PPL_ENTRY_SPACE)
3482 >> 9;
2432ce9b
AP		 3483 } else if (info->array.level <= 0) {
3484 info->consistency_policy = CONSISTENCY_POLICY_NONE;
3485 } else {
fbc42556
JR		 3486 if (dev->rwh_policy == RWH_BITMAP) {
3487 info->bitmap_offset = get_bitmap_sector(super, super->current_vol);
3488 info->consistency_policy = CONSISTENCY_POLICY_BITMAP;
3489 } else {
3490 info->consistency_policy = CONSISTENCY_POLICY_RESYNC;
3491 }
2432ce9b
AP		 3492 }
3493
d2e6d5d6 3494 info->reshape_progress = 0;
b6796ce1 3495 info->resync_start = MaxSector;
b9172665 3496 if ((map_to_analyse->map_state == IMSM_T_STATE_UNINITIALIZED ||
2432ce9b 3497 !(info->array.state & 1)) &&
b9172665 3498 imsm_reshape_blocks_arrays_changes(super) == 0) {
301406c9 3499 info->resync_start = 0;
b6796ce1
AK		 3500 }
3501 if (dev->vol.migr_state) {
1e5c6983
DW		 3502 switch (migr_type(dev)) {
3503 case MIGR_REPAIR:
3504 case MIGR_INIT: {
c47b0ff6
AK		 3505 __u64 blocks_per_unit = blocks_per_migr_unit(super,
3506 dev);
1e5c6983
DW		 3507 __u64 units = __le32_to_cpu(dev->vol.curr_migr_unit);
3508
3509 info->resync_start = blocks_per_unit * units;
3510 break;
3511 }
d2e6d5d6 3512 case MIGR_GEN_MIGR: {
c47b0ff6
AK		 3513 __u64 blocks_per_unit = blocks_per_migr_unit(super,
3514 dev);
9f421827 3515 __u64 units = current_migr_unit(migr_rec);
04fa9523 3516 int used_disks;
d2e6d5d6 3517
befb629b
AK		 3518 if (__le32_to_cpu(migr_rec->ascending_migr) &&
3519 (units <
9f421827 3520 (get_num_migr_units(migr_rec)-1)) &&
befb629b
AK		 3521 (super->migr_rec->rec_status ==
3522 __cpu_to_le32(UNIT_SRC_IN_CP_AREA)))
3523 units++;
3524
d2e6d5d6 3525 info->reshape_progress = blocks_per_unit * units;
6289d1e0 3526
7a862a02 3527 dprintf("IMSM: General Migration checkpoint : %llu (%llu) -> read reshape progress : %llu\n",
19986c72
MB		 3528 (unsigned long long)units,
3529 (unsigned long long)blocks_per_unit,
3530 info->reshape_progress);
75156c46 3531
9529d343 3532 used_disks = imsm_num_data_members(prev_map);
75156c46 3533 if (used_disks > 0) {
895ffd99 3534 info->custom_array_size = per_dev_array_size(map) *
75156c46 3535 used_disks;
75156c46 3536 }
d2e6d5d6 3537 }
1e5c6983
DW		 3538 case MIGR_VERIFY:
3539 /* we could emulate the checkpointing of
3540 * 'sync_action=check' migrations, but for now
3541 * we just immediately complete them
3542 */
3543 case MIGR_REBUILD:
3544 /* this is handled by container_content_imsm() */
1e5c6983
DW		 3545 case MIGR_STATE_CHANGE:
3546 /* FIXME handle other migrations */
3547 default:
3548 /* we are not dirty, so... */
3549 info->resync_start = MaxSector;
3550 }
b6796ce1 3551 }
301406c9
DW		 3552
3553 strncpy(info->name, (char *) dev->volume, MAX_RAID_SERIAL_LEN);
3554 info->name[MAX_RAID_SERIAL_LEN] = 0;
bf5a934a 3555
f35f2525
N		 3556 info->array.major_version = -1;
3557 info->array.minor_version = -2;
4dd2df09 3558 sprintf(info->text_version, "/%s/%d", st->container_devnm, info->container_member);
a67dd8cc 3559 info->safe_mode_delay = 4000; /* 4 secs like the Matrix driver */
51006d85 3560 uuid_from_super_imsm(st, info->uuid);
a5d85af7
N		 3561
3562 if (dmap) {
3563 int i, j;
3564 for (i=0; i<map_disks; i++) {
3565 dmap[i] = 0;
3566 if (i < info->array.raid_disks) {
3567 struct imsm_disk *dsk;
238c0a71 3568 j = get_imsm_disk_idx(dev, i, MAP_X);
a5d85af7
N		 3569 dsk = get_imsm_disk(super, j);
3570 if (dsk && (dsk->status & CONFIGURED_DISK))
3571 dmap[i] = 1;
3572 }
3573 }
3574 }
81ac8b4d 3575}
bf5a934a 3576
3b451610
AK		 3577static __u8 imsm_check_degraded(struct intel_super *super, struct imsm_dev *dev,
3578 int failed, int look_in_map);
3579
3580static int imsm_count_failed(struct intel_super *super, struct imsm_dev *dev,
3581 int look_in_map);
3582
3583static void manage_second_map(struct intel_super *super, struct imsm_dev *dev)
3584{
3585 if (is_gen_migration(dev)) {
3586 int failed;
3587 __u8 map_state;
3588 struct imsm_map *map2 = get_imsm_map(dev, MAP_1);
3589
3590 failed = imsm_count_failed(super, dev, MAP_1);
238c0a71 3591 map_state = imsm_check_degraded(super, dev, failed, MAP_1);
3b451610
AK		 3592 if (map2->map_state != map_state) {
3593 map2->map_state = map_state;
3594 super->updates_pending++;
3595 }
3596 }
3597}
97b4d0e9
DW		 3598
3599static struct imsm_disk *get_imsm_missing(struct intel_super *super, __u8 index)
3600{
3601 struct dl *d;
3602
3603 for (d = super->missing; d; d = d->next)
3604 if (d->index == index)
3605 return &d->disk;
3606 return NULL;
3607}
3608
a5d85af7 3609static void getinfo_super_imsm(struct supertype *st, struct mdinfo *info, char *map)
4f5bc454
DW		 3610{
3611 struct intel_super *super = st->sb;
4f5bc454 3612 struct imsm_disk *disk;
a5d85af7 3613 int map_disks = info->array.raid_disks;
ab3cb6b3
N		 3614 int max_enough = -1;
3615 int i;
3616 struct imsm_super *mpb;
4f5bc454 3617
bf5a934a 3618 if (super->current_vol >= 0) {
a5d85af7 3619 getinfo_super_imsm_volume(st, info, map);
bf5a934a
DW		 3620 return;
3621 }
95eeceeb 3622 memset(info, 0, sizeof(*info));
d23fe947
DW		 3623
3624 /* Set raid_disks to zero so that Assemble will always pull in valid
3625 * spares
3626 */
3627 info->array.raid_disks = 0;
cdddbdbc
DW		 3628 info->array.level = LEVEL_CONTAINER;
3629 info->array.layout = 0;
3630 info->array.md_minor = -1;
1011e834 3631 info->array.ctime = 0; /* N/A for imsm */
cdddbdbc
DW		 3632 info->array.utime = 0;
3633 info->array.chunk_size = 0;
3634
3635 info->disk.major = 0;
3636 info->disk.minor = 0;
cdddbdbc 3637 info->disk.raid_disk = -1;
c2c087e6 3638 info->reshape_active = 0;
f35f2525
N		 3639 info->array.major_version = -1;
3640 info->array.minor_version = -2;
c2c087e6 3641 strcpy(info->text_version, "imsm");
a67dd8cc 3642 info->safe_mode_delay = 0;
c2c087e6
DW		 3643 info->disk.number = -1;
3644 info->disk.state = 0;
c5afc314 3645 info->name[0] = 0;
921d9e16 3646 info->recovery_start = MaxSector;
3ad25638 3647 info->recovery_blocked = imsm_reshape_blocks_arrays_changes(st->sb);
5e46202e 3648 info->bb.supported = 1;
c2c087e6 3649
97b4d0e9 3650 /* do we have the all the insync disks that we expect? */
ab3cb6b3 3651 mpb = super->anchor;
b7d81a38 3652 info->events = __le32_to_cpu(mpb->generation_num);
97b4d0e9 3653
ab3cb6b3
N		 3654 for (i = 0; i < mpb->num_raid_devs; i++) {
3655 struct imsm_dev *dev = get_imsm_dev(super, i);
3656 int failed, enough, j, missing = 0;
3657 struct imsm_map *map;
3658 __u8 state;
97b4d0e9 3659
3b451610
AK		 3660 failed = imsm_count_failed(super, dev, MAP_0);
3661 state = imsm_check_degraded(super, dev, failed, MAP_0);
238c0a71 3662 map = get_imsm_map(dev, MAP_0);
ab3cb6b3
N		 3663
3664 /* any newly missing disks?
3665 * (catches single-degraded vs double-degraded)
3666 */
3667 for (j = 0; j < map->num_members; j++) {
238c0a71 3668 __u32 ord = get_imsm_ord_tbl_ent(dev, j, MAP_0);
ab3cb6b3
N		 3669 __u32 idx = ord_to_idx(ord);
3670
20dc76d1
MT		 3671 if (super->disks && super->disks->index == (int)idx)
3672 info->disk.raid_disk = j;
3673
ab3cb6b3
N		 3674 if (!(ord & IMSM_ORD_REBUILD) &&
3675 get_imsm_missing(super, idx)) {
3676 missing = 1;
3677 break;
3678 }
97b4d0e9 3679 }
ab3cb6b3
N		 3680
3681 if (state == IMSM_T_STATE_FAILED)
3682 enough = -1;
3683 else if (state == IMSM_T_STATE_DEGRADED &&
3684 (state != map->map_state || missing))
3685 enough = 0;
3686 else /* we're normal, or already degraded */
3687 enough = 1;
d2bde6d3
AK		 3688 if (is_gen_migration(dev) && missing) {
3689 /* during general migration we need all disks
3690 * that process is running on.
3691 * No new missing disk is allowed.
3692 */
3693 max_enough = -1;
3694 enough = -1;
3695 /* no more checks necessary
3696 */
3697 break;
3698 }
ab3cb6b3
N		 3699 /* in the missing/failed disk case check to see
3700 * if at least one array is runnable
3701 */
3702 max_enough = max(max_enough, enough);
3703 }
1ade5cc1 3704 dprintf("enough: %d\n", max_enough);
ab3cb6b3 3705 info->container_enough = max_enough;
97b4d0e9 3706
4a04ec6c 3707 if (super->disks) {
14e8215b
DW		 3708 __u32 reserved = imsm_reserved_sectors(super, super->disks);
3709
b9f594fe 3710 disk = &super->disks->disk;
5551b113 3711 info->data_offset = total_blocks(&super->disks->disk) - reserved;
14e8215b 3712 info->component_size = reserved;
25ed7e59 3713 info->disk.state = is_configured(disk) ? (1 << MD_DISK_ACTIVE) : 0;
df474657
DW		 3714 /* we don't change info->disk.raid_disk here because
3715 * this state will be finalized in mdmon after we have
3716 * found the 'most fresh' version of the metadata
3717 */
25ed7e59 3718 info->disk.state |= is_failed(disk) ? (1 << MD_DISK_FAULTY) : 0;
2432ce9b
AP		 3719 info->disk.state |= (is_spare(disk) || is_journal(disk)) ?
3720 0 : (1 << MD_DISK_SYNC);
cdddbdbc 3721 }
a575e2a7
DW		 3722
3723 /* only call uuid_from_super_imsm when this disk is part of a populated container,
3724 * ->compare_super may have updated the 'num_raid_devs' field for spares
3725 */
3726 if (info->disk.state & (1 << MD_DISK_SYNC) || super->anchor->num_raid_devs)
36ba7d48 3727 uuid_from_super_imsm(st, info->uuid);
22e263f6
AC		 3728 else
3729 memcpy(info->uuid, uuid_zero, sizeof(uuid_zero));
a5d85af7
N		 3730
3731 /* I don't know how to compute 'map' on imsm, so use safe default */
3732 if (map) {
3733 int i;
3734 for (i = 0; i < map_disks; i++)
3735 map[i] = 1;
3736 }
3737
cdddbdbc
DW		 3738}
3739
5c4cd5da
AC		 3740/* allocates memory and fills disk in mdinfo structure
3741 * for each disk in array */
3742struct mdinfo *getinfo_super_disks_imsm(struct supertype *st)
3743{
594dc1b8 3744 struct mdinfo *mddev;
5c4cd5da
AC		 3745 struct intel_super *super = st->sb;
3746 struct imsm_disk *disk;
3747 int count = 0;
3748 struct dl *dl;
3749 if (!super || !super->disks)
3750 return NULL;
3751 dl = super->disks;
503975b9 3752 mddev = xcalloc(1, sizeof(*mddev));
5c4cd5da
AC		 3753 while (dl) {
3754 struct mdinfo *tmp;
3755 disk = &dl->disk;
503975b9 3756 tmp = xcalloc(1, sizeof(*tmp));
5c4cd5da
AC		 3757 if (mddev->devs)
3758 tmp->next = mddev->devs;
3759 mddev->devs = tmp;
3760 tmp->disk.number = count++;
3761 tmp->disk.major = dl->major;
3762 tmp->disk.minor = dl->minor;
3763 tmp->disk.state = is_configured(disk) ?
3764 (1 << MD_DISK_ACTIVE) : 0;
3765 tmp->disk.state |= is_failed(disk) ? (1 << MD_DISK_FAULTY) : 0;
3766 tmp->disk.state |= is_spare(disk) ? 0 : (1 << MD_DISK_SYNC);
3767 tmp->disk.raid_disk = -1;
3768 dl = dl->next;
3769 }
3770 return mddev;
3771}
3772
cdddbdbc
DW		 3773static int update_super_imsm(struct supertype *st, struct mdinfo *info,
3774 char *update, char *devname, int verbose,
3775 int uuid_set, char *homehost)
3776{
f352c545
DW		 3777 /* For 'assemble' and 'force' we need to return non-zero if any
3778 * change was made. For others, the return value is ignored.
3779 * Update options are:
3780 * force-one : This device looks a bit old but needs to be included,
3781 * update age info appropriately.
3782 * assemble: clear any 'faulty' flag to allow this device to
3783 * be assembled.
3784 * force-array: Array is degraded but being forced, mark it clean
3785 * if that will be needed to assemble it.
3786 *
3787 * newdev: not used ????
3788 * grow: Array has gained a new device - this is currently for
3789 * linear only
3790 * resync: mark as dirty so a resync will happen.
3791 * name: update the name - preserving the homehost
6e46bf34 3792 * uuid: Change the uuid of the array to match watch is given
f352c545
DW		 3793 *
3794 * Following are not relevant for this imsm:
3795 * sparc2.2 : update from old dodgey metadata
3796 * super-minor: change the preferred_minor number
3797 * summaries: update redundant counters.
f352c545
DW		 3798 * homehost: update the recorded homehost
3799 * _reshape_progress: record new reshape_progress position.
3800 */
6e46bf34
DW		 3801 int rv = 1;
3802 struct intel_super *super = st->sb;
3803 struct imsm_super *mpb;
f352c545 3804
6e46bf34
DW		 3805 /* we can only update container info */
3806 if (!super || super->current_vol >= 0 || !super->anchor)
3807 return 1;
3808
3809 mpb = super->anchor;
3810
81a5b4f5
N		 3811 if (strcmp(update, "uuid") == 0) {
3812 /* We take this to mean that the family_num should be updated.
3813 * However that is much smaller than the uuid so we cannot really
3814 * allow an explicit uuid to be given. And it is hard to reliably
3815 * know if one was.
3816 * So if !uuid_set we know the current uuid is random and just used
3817 * the first 'int' and copy it to the other 3 positions.
3818 * Otherwise we require the 4 'int's to be the same as would be the
3819 * case if we are using a random uuid. So an explicit uuid will be
3820 * accepted as long as all for ints are the same... which shouldn't hurt
6e46bf34 3821 */
81a5b4f5
N		 3822 if (!uuid_set) {
3823 info->uuid[1] = info->uuid[2] = info->uuid[3] = info->uuid[0];
6e46bf34 3824 rv = 0;
81a5b4f5
N		 3825 } else {
3826 if (info->uuid[0] != info->uuid[1] ||
3827 info->uuid[1] != info->uuid[2] ||
3828 info->uuid[2] != info->uuid[3])
3829 rv = -1;
3830 else
3831 rv = 0;
6e46bf34 3832 }
81a5b4f5
N		 3833 if (rv == 0)
3834 mpb->orig_family_num = info->uuid[0];
6e46bf34
DW		 3835 } else if (strcmp(update, "assemble") == 0)
3836 rv = 0;
3837 else
1e2b2765 3838 rv = -1;
f352c545 3839
6e46bf34
DW		 3840 /* successful update? recompute checksum */
3841 if (rv == 0)
3842 mpb->check_sum = __le32_to_cpu(__gen_imsm_checksum(mpb));
f352c545
DW		 3843
3844 return rv;
cdddbdbc
DW		 3845}
3846
c2c087e6 3847static size_t disks_to_mpb_size(int disks)
cdddbdbc 3848{
c2c087e6 3849 size_t size;
cdddbdbc 3850
c2c087e6
DW		 3851 size = sizeof(struct imsm_super);
3852 size += (disks - 1) * sizeof(struct imsm_disk);
3853 size += 2 * sizeof(struct imsm_dev);
3854 /* up to 2 maps per raid device (-2 for imsm_maps in imsm_dev */
3855 size += (4 - 2) * sizeof(struct imsm_map);
3856 /* 4 possible disk_ord_tbl's */
3857 size += 4 * (disks - 1) * sizeof(__u32);
bbab0940
TM		 3858 /* maximum bbm log */
3859 size += sizeof(struct bbm_log);
c2c087e6
DW		 3860
3861 return size;
3862}
3863
387fcd59
N		 3864static __u64 avail_size_imsm(struct supertype *st, __u64 devsize,
3865 unsigned long long data_offset)
c2c087e6
DW		 3866{
3867 if (devsize < (MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS))
3868 return 0;
3869
3870 return devsize - (MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS);
cdddbdbc
DW		 3871}
3872
ba2de7ba
DW		 3873static void free_devlist(struct intel_super *super)
3874{
3875 struct intel_dev *dv;
3876
3877 while (super->devlist) {
3878 dv = super->devlist->next;
3879 free(super->devlist->dev);
3880 free(super->devlist);
3881 super->devlist = dv;
3882 }
3883}
3884
3885static void imsm_copy_dev(struct imsm_dev *dest, struct imsm_dev *src)
3886{
3887 memcpy(dest, src, sizeof_imsm_dev(src, 0));
3888}
3889
c7b8547c
MT		 3890static int compare_super_imsm(struct supertype *st, struct supertype *tst,
3891 int verbose)
cdddbdbc
DW		 3892{
3893 /*
3894 * return:
3895 * 0 same, or first was empty, and second was copied
3896 * 1 second had wrong number
3897 * 2 wrong uuid
3898 * 3 wrong other info
3899 */
3900 struct intel_super *first = st->sb;
3901 struct intel_super *sec = tst->sb;
3902
5d500228
N		 3903 if (!first) {
3904 st->sb = tst->sb;
3905 tst->sb = NULL;
3906 return 0;
3907 }
8603ea6f
LM		 3908 /* in platform dependent environment test if the disks
3909 * use the same Intel hba
cb8f6859 3910 * If not on Intel hba at all, allow anything.
8603ea6f 3911 */
6b781d33
AP		 3912 if (!check_env("IMSM_NO_PLATFORM") && first->hba && sec->hba) {
3913 if (first->hba->type != sec->hba->type) {
c7b8547c
MT		 3914 if (verbose)
3915 pr_err("HBAs of devices do not match %s != %s\n",
3916 get_sys_dev_type(first->hba->type),
3917 get_sys_dev_type(sec->hba->type));
6b781d33
AP		 3918 return 3;
3919 }
c7b8547c 3920
6b781d33 3921 if (first->orom != sec->orom) {
c7b8547c
MT		 3922 if (verbose)
3923 pr_err("HBAs of devices do not match %s != %s\n",
3924 first->hba->pci_id, sec->hba->pci_id);
8603ea6f
LM		 3925 return 3;
3926 }
c7b8547c 3927
8603ea6f 3928 }
cdddbdbc 3929
d23fe947
DW		 3930 /* if an anchor does not have num_raid_devs set then it is a free
3931 * floating spare
3932 */
3933 if (first->anchor->num_raid_devs > 0 &&
3934 sec->anchor->num_raid_devs > 0) {
a2b97981
DW		 3935 /* Determine if these disks might ever have been
3936 * related. Further disambiguation can only take place
3937 * in load_super_imsm_all
3938 */
3939 __u32 first_family = first->anchor->orig_family_num;
3940 __u32 sec_family = sec->anchor->orig_family_num;
3941
f796af5d
DW		 3942 if (memcmp(first->anchor->sig, sec->anchor->sig,
3943 MAX_SIGNATURE_LENGTH) != 0)
3944 return 3;
3945
a2b97981
DW		 3946 if (first_family == 0)
3947 first_family = first->anchor->family_num;
3948 if (sec_family == 0)
3949 sec_family = sec->anchor->family_num;
3950
3951 if (first_family != sec_family)
d23fe947 3952 return 3;
f796af5d 3953
d23fe947 3954 }
cdddbdbc 3955
3e372e5a
DW		 3956 /* if 'first' is a spare promote it to a populated mpb with sec's
3957 * family number
3958 */
3959 if (first->anchor->num_raid_devs == 0 &&
3960 sec->anchor->num_raid_devs > 0) {
78d30f94 3961 int i;
ba2de7ba
DW		 3962 struct intel_dev *dv;
3963 struct imsm_dev *dev;
78d30f94
DW		 3964
3965 /* we need to copy raid device info from sec if an allocation
3966 * fails here we don't associate the spare
3967 */
3968 for (i = 0; i < sec->anchor->num_raid_devs; i++) {
503975b9
N		 3969 dv = xmalloc(sizeof(*dv));
3970 dev = xmalloc(sizeof_imsm_dev(get_imsm_dev(sec, i), 1));
ba2de7ba
DW		 3971 dv->dev = dev;
3972 dv->index = i;
3973 dv->next = first->devlist;
3974 first->devlist = dv;
78d30f94 3975 }
709743c5 3976 if (i < sec->anchor->num_raid_devs) {
ba2de7ba
DW		 3977 /* allocation failure */
3978 free_devlist(first);
e12b3daa 3979 pr_err("imsm: failed to associate spare\n");
ba2de7ba 3980 return 3;
78d30f94 3981 }
3e372e5a 3982 first->anchor->num_raid_devs = sec->anchor->num_raid_devs;
148acb7b 3983 first->anchor->orig_family_num = sec->anchor->orig_family_num;
3e372e5a 3984 first->anchor->family_num = sec->anchor->family_num;
ac6449be 3985 memcpy(first->anchor->sig, sec->anchor->sig, MAX_SIGNATURE_LENGTH);
709743c5
DW		 3986 for (i = 0; i < sec->anchor->num_raid_devs; i++)
3987 imsm_copy_dev(get_imsm_dev(first, i), get_imsm_dev(sec, i));
3e372e5a
DW		 3988 }
3989
cdddbdbc
DW		 3990 return 0;
3991}
3992
0030e8d6
DW		 3993static void fd2devname(int fd, char *name)
3994{
3995 struct stat st;
3996 char path[256];
33a6535d 3997 char dname[PATH_MAX];
0030e8d6
DW		 3998 char *nm;
3999 int rv;
4000
4001 name[0] = '\0';
4002 if (fstat(fd, &st) != 0)
4003 return;
4004 sprintf(path, "/sys/dev/block/%d:%d",
4005 major(st.st_rdev), minor(st.st_rdev));
4006
9cf014ec 4007 rv = readlink(path, dname, sizeof(dname)-1);
0030e8d6
DW		 4008 if (rv <= 0)
4009 return;
9587c373 4010
0030e8d6
DW		 4011 dname[rv] = '\0';
4012 nm = strrchr(dname, '/');
7897de29
JS		 4013 if (nm) {
4014 nm++;
4015 snprintf(name, MAX_RAID_SERIAL_LEN, "/dev/%s", nm);
4016 }
0030e8d6
DW		 4017}
4018
21e9380b
AP		 4019static int nvme_get_serial(int fd, void *buf, size_t buf_len)
4020{
4021 char path[60];
4022 char *name = fd2kname(fd);
4023
4024 if (!name)
4025 return 1;
4026
4027 if (strncmp(name, "nvme", 4) != 0)
4028 return 1;
4029
4030 snprintf(path, sizeof(path) - 1, "/sys/block/%s/device/serial", name);
4031
4032 return load_sys(path, buf, buf_len);
4033}
4034
cdddbdbc
DW		 4035extern int scsi_get_serial(int fd, void *buf, size_t buf_len);
4036
4037static int imsm_read_serial(int fd, char *devname,
6da53c0e 4038 __u8 *serial, size_t serial_buf_len)
cdddbdbc 4039{
21e9380b 4040 char buf[50];
cdddbdbc 4041 int rv;
6da53c0e 4042 size_t len;
316e2bf4
DW		 4043 char *dest;
4044 char *src;
21e9380b
AP		 4045 unsigned int i;
4046
4047 memset(buf, 0, sizeof(buf));
cdddbdbc 4048
21e9380b 4049 rv = nvme_get_serial(fd, buf, sizeof(buf));
cdddbdbc 4050
21e9380b
AP		 4051 if (rv)
4052 rv = scsi_get_serial(fd, buf, sizeof(buf));
f9ba0ff1 4053
40ebbb9c 4054 if (rv && check_env("IMSM_DEVNAME_AS_SERIAL")) {
f9ba0ff1
DW		 4055 memset(serial, 0, MAX_RAID_SERIAL_LEN);
4056 fd2devname(fd, (char *) serial);
0030e8d6
DW		 4057 return 0;
4058 }
4059
cdddbdbc
DW		 4060 if (rv != 0) {
4061 if (devname)
e7b84f9d
N		 4062 pr_err("Failed to retrieve serial for %s\n",
4063 devname);
cdddbdbc
DW		 4064 return rv;
4065 }
4066
316e2bf4
DW		 4067 /* trim all whitespace and non-printable characters and convert
4068 * ':' to ';'
4069 */
21e9380b
AP		 4070 for (i = 0, dest = buf; i < sizeof(buf) && buf[i]; i++) {
4071 src = &buf[i];
316e2bf4
DW		 4072 if (*src > 0x20) {
4073 /* ':' is reserved for use in placeholder serial
4074 * numbers for missing disks
4075 */
4076 if (*src == ':')
4077 *dest++ = ';';
4078 else
4079 *dest++ = *src;
4080 }
4081 }
21e9380b
AP		 4082 len = dest - buf;
4083 dest = buf;
316e2bf4 4084
6da53c0e
BK		 4085 if (len > serial_buf_len) {
4086 /* truncate leading characters */
4087 dest += len - serial_buf_len;
4088 len = serial_buf_len;
316e2bf4 4089 }
5c3db629 4090
6da53c0e 4091 memset(serial, 0, serial_buf_len);
316e2bf4 4092 memcpy(serial, dest, len);
cdddbdbc
DW		 4093
4094 return 0;
4095}
4096
1f24f035
DW		 4097static int serialcmp(__u8 *s1, __u8 *s2)
4098{
4099 return strncmp((char *) s1, (char *) s2, MAX_RAID_SERIAL_LEN);
4100}
4101
4102static void serialcpy(__u8 *dest, __u8 *src)
4103{
4104 strncpy((char *) dest, (char *) src, MAX_RAID_SERIAL_LEN);
4105}
4106
54c2c1ea
DW		 4107static struct dl *serial_to_dl(__u8 *serial, struct intel_super *super)
4108{
4109 struct dl *dl;
4110
4111 for (dl = super->disks; dl; dl = dl->next)
4112 if (serialcmp(dl->serial, serial) == 0)
4113 break;
4114
4115 return dl;
4116}
4117
a2b97981
DW		 4118static struct imsm_disk *
4119__serial_to_disk(__u8 *serial, struct imsm_super *mpb, int *idx)
4120{
4121 int i;
4122
4123 for (i = 0; i < mpb->num_disks; i++) {
4124 struct imsm_disk *disk = __get_imsm_disk(mpb, i);
4125
4126 if (serialcmp(disk->serial, serial) == 0) {
4127 if (idx)
4128 *idx = i;
4129 return disk;
4130 }
4131 }
4132
4133 return NULL;
4134}
4135
cdddbdbc
DW		 4136static int
4137load_imsm_disk(int fd, struct intel_super *super, char *devname, int keep_fd)
4138{
a2b97981 4139 struct imsm_disk *disk;
cdddbdbc
DW		 4140 struct dl *dl;
4141 struct stat stb;
cdddbdbc 4142 int rv;
a2b97981 4143 char name[40];
d23fe947
DW		 4144 __u8 serial[MAX_RAID_SERIAL_LEN];
4145
6da53c0e 4146 rv = imsm_read_serial(fd, devname, serial, MAX_RAID_SERIAL_LEN);
d23fe947
DW		 4147
4148 if (rv != 0)
4149 return 2;
4150
503975b9 4151 dl = xcalloc(1, sizeof(*dl));
cdddbdbc 4152
a2b97981
DW		 4153 fstat(fd, &stb);
4154 dl->major = major(stb.st_rdev);
4155 dl->minor = minor(stb.st_rdev);
4156 dl->next = super->disks;
4157 dl->fd = keep_fd ? fd : -1;
4158 assert(super->disks == NULL);
4159 super->disks = dl;
4160 serialcpy(dl->serial, serial);
4161 dl->index = -2;
4162 dl->e = NULL;
4163 fd2devname(fd, name);
4164 if (devname)
503975b9 4165 dl->devname = xstrdup(devname);
a2b97981 4166 else
503975b9 4167 dl->devname = xstrdup(name);
cdddbdbc 4168
d23fe947 4169 /* look up this disk's index in the current anchor */
a2b97981
DW		 4170 disk = __serial_to_disk(dl->serial, super->anchor, &dl->index);
4171 if (disk) {
4172 dl->disk = *disk;
4173 /* only set index on disks that are a member of a
4174 * populated contianer, i.e. one with raid_devs
4175 */
4176 if (is_failed(&dl->disk))
3f6efecc 4177 dl->index = -2;
2432ce9b 4178 else if (is_spare(&dl->disk) || is_journal(&dl->disk))
a2b97981 4179 dl->index = -1;
3f6efecc
DW		 4180 }
4181
949c47a0
DW		 4182 return 0;
4183}
4184
0c046afd
DW		 4185/* When migrating map0 contains the 'destination' state while map1
4186 * contains the current state. When not migrating map0 contains the
4187 * current state. This routine assumes that map[0].map_state is set to
4188 * the current array state before being called.
4189 *
4190 * Migration is indicated by one of the following states
4191 * 1/ Idle (migr_state=0 map0state=normal||unitialized||degraded||failed)
e3bba0e0 4192 * 2/ Initialize (migr_state=1 migr_type=MIGR_INIT map0state=normal
0c046afd 4193 * map1state=unitialized)
1484e727 4194 * 3/ Repair (Resync) (migr_state=1 migr_type=MIGR_REPAIR map0state=normal
0c046afd 4195 * map1state=normal)
e3bba0e0 4196 * 4/ Rebuild (migr_state=1 migr_type=MIGR_REBUILD map0state=normal
0c046afd 4197 * map1state=degraded)
8e59f3d8
AK		 4198 * 5/ Migration (mig_state=1 migr_type=MIGR_GEN_MIGR map0state=normal
4199 * map1state=normal)
0c046afd 4200 */
8e59f3d8
AK		 4201static void migrate(struct imsm_dev *dev, struct intel_super *super,
4202 __u8 to_state, int migr_type)
3393c6af 4203{
0c046afd 4204 struct imsm_map *dest;
238c0a71 4205 struct imsm_map *src = get_imsm_map(dev, MAP_0);
3393c6af 4206
0c046afd 4207 dev->vol.migr_state = 1;
1484e727 4208 set_migr_type(dev, migr_type);
f8f603f1 4209 dev->vol.curr_migr_unit = 0;
238c0a71 4210 dest = get_imsm_map(dev, MAP_1);
0c046afd 4211
0556e1a2 4212 /* duplicate and then set the target end state in map[0] */
3393c6af 4213 memcpy(dest, src, sizeof_imsm_map(src));
fb12a745 4214 if (migr_type == MIGR_GEN_MIGR) {
0556e1a2
DW		 4215 __u32 ord;
4216 int i;
4217
4218 for (i = 0; i < src->num_members; i++) {
4219 ord = __le32_to_cpu(src->disk_ord_tbl[i]);
4220 set_imsm_ord_tbl_ent(src, i, ord_to_idx(ord));
4221 }
4222 }
4223
8e59f3d8
AK		 4224 if (migr_type == MIGR_GEN_MIGR)
4225 /* Clear migration record */
4226 memset(super->migr_rec, 0, sizeof(struct migr_record));
4227
0c046afd 4228 src->map_state = to_state;
949c47a0 4229}
f8f603f1 4230
809da78e
AK		 4231static void end_migration(struct imsm_dev *dev, struct intel_super *super,
4232 __u8 map_state)
f8f603f1 4233{
238c0a71
AK		 4234 struct imsm_map *map = get_imsm_map(dev, MAP_0);
4235 struct imsm_map *prev = get_imsm_map(dev, dev->vol.migr_state == 0 ?
4236 MAP_0 : MAP_1);
28bce06f 4237 int i, j;
0556e1a2
DW		 4238
4239 /* merge any IMSM_ORD_REBUILD bits that were not successfully
4240 * completed in the last migration.
4241 *
28bce06f 4242 * FIXME add support for raid-level-migration
0556e1a2 4243 */
089f9d79
JS		 4244 if (map_state != map->map_state && (is_gen_migration(dev) == 0) &&
4245 prev->map_state != IMSM_T_STATE_UNINITIALIZED) {
809da78e
AK		 4246 /* when final map state is other than expected
4247 * merge maps (not for migration)
4248 */
4249 int failed;
4250
4251 for (i = 0; i < prev->num_members; i++)
4252 for (j = 0; j < map->num_members; j++)
4253 /* during online capacity expansion
4254 * disks position can be changed
4255 * if takeover is used
4256 */
4257 if (ord_to_idx(map->disk_ord_tbl[j]) ==
4258 ord_to_idx(prev->disk_ord_tbl[i])) {
4259 map->disk_ord_tbl[j] |=
4260 prev->disk_ord_tbl[i];
4261 break;
4262 }
4263 failed = imsm_count_failed(super, dev, MAP_0);
4264 map_state = imsm_check_degraded(super, dev, failed, MAP_0);
4265 }
f8f603f1
DW		 4266
4267 dev->vol.migr_state = 0;
ea672ee1 4268 set_migr_type(dev, 0);
f8f603f1
DW		 4269 dev->vol.curr_migr_unit = 0;
4270 map->map_state = map_state;
4271}
949c47a0
DW		 4272
4273static int parse_raid_devices(struct intel_super *super)
4274{
4275 int i;
4276 struct imsm_dev *dev_new;
4d7b1503 4277 size_t len, len_migr;
401d313b 4278 size_t max_len = 0;
4d7b1503
DW		 4279 size_t space_needed = 0;
4280 struct imsm_super *mpb = super->anchor;
949c47a0
DW		 4281
4282 for (i = 0; i < super->anchor->num_raid_devs; i++) {
4283 struct imsm_dev *dev_iter = __get_imsm_dev(super->anchor, i);
ba2de7ba 4284 struct intel_dev *dv;
949c47a0 4285
4d7b1503
DW		 4286 len = sizeof_imsm_dev(dev_iter, 0);
4287 len_migr = sizeof_imsm_dev(dev_iter, 1);
4288 if (len_migr > len)
4289 space_needed += len_migr - len;
ca9de185 4290
503975b9 4291 dv = xmalloc(sizeof(*dv));
401d313b
AK		 4292 if (max_len < len_migr)
4293 max_len = len_migr;
4294 if (max_len > len_migr)
4295 space_needed += max_len - len_migr;
503975b9 4296 dev_new = xmalloc(max_len);
949c47a0 4297 imsm_copy_dev(dev_new, dev_iter);
ba2de7ba
DW		 4298 dv->dev = dev_new;
4299 dv->index = i;
4300 dv->next = super->devlist;
4301 super->devlist = dv;
949c47a0 4302 }
cdddbdbc 4303
4d7b1503
DW		 4304 /* ensure that super->buf is large enough when all raid devices
4305 * are migrating
4306 */
4307 if (__le32_to_cpu(mpb->mpb_size) + space_needed > super->len) {
4308 void *buf;
4309
f36a9ecd
PB		 4310 len = ROUND_UP(__le32_to_cpu(mpb->mpb_size) + space_needed,
4311 super->sector_size);
4312 if (posix_memalign(&buf, MAX_SECTOR_SIZE, len) != 0)
4d7b1503
DW		 4313 return 1;
4314
1f45a8ad
DW		 4315 memcpy(buf, super->buf, super->len);
4316 memset(buf + super->len, 0, len - super->len);
4d7b1503
DW		 4317 free(super->buf);
4318 super->buf = buf;
4319 super->len = len;
4320 }
ca9de185 4321
bbab0940
TM		 4322 super->extra_space += space_needed;
4323
cdddbdbc
DW		 4324 return 0;
4325}
4326
e2f41b2c
AK		 4327/*******************************************************************************
4328 * Function: check_mpb_migr_compatibility
4329 * Description: Function checks for unsupported migration features:
4330 * - migration optimization area (pba_of_lba0)
4331 * - descending reshape (ascending_migr)
4332 * Parameters:
4333 * super : imsm metadata information
4334 * Returns:
4335 * 0 : migration is compatible
4336 * -1 : migration is not compatible
4337 ******************************************************************************/
4338int check_mpb_migr_compatibility(struct intel_super *super)
4339{
4340 struct imsm_map *map0, *map1;
4341 struct migr_record *migr_rec = super->migr_rec;
4342 int i;
4343
4344 for (i = 0; i < super->anchor->num_raid_devs; i++) {
4345 struct imsm_dev *dev_iter = __get_imsm_dev(super->anchor, i);
4346
4347 if (dev_iter &&
4348 dev_iter->vol.migr_state == 1 &&
4349 dev_iter->vol.migr_type == MIGR_GEN_MIGR) {
4350 /* This device is migrating */
238c0a71
AK		 4351 map0 = get_imsm_map(dev_iter, MAP_0);
4352 map1 = get_imsm_map(dev_iter, MAP_1);
5551b113 4353 if (pba_of_lba0(map0) != pba_of_lba0(map1))
e2f41b2c
AK		 4354 /* migration optimization area was used */
4355 return -1;
fc54fe7a
JS		 4356 if (migr_rec->ascending_migr == 0 &&
4357 migr_rec->dest_depth_per_unit > 0)
e2f41b2c
AK		 4358 /* descending reshape not supported yet */
4359 return -1;
4360 }
4361 }
4362 return 0;
4363}
4364
d23fe947 4365static void __free_imsm(struct intel_super *super, int free_disks);
9ca2c81c 4366
cdddbdbc 4367/* load_imsm_mpb - read matrix metadata
f2f5c343 4368 * allocates super->mpb to be freed by free_imsm
cdddbdbc
DW		 4369 */
4370static int load_imsm_mpb(int fd, struct intel_super *super, char *devname)
4371{
4372 unsigned long long dsize;
cdddbdbc 4373 unsigned long long sectors;
f36a9ecd 4374 unsigned int sector_size = super->sector_size;
cdddbdbc 4375 struct stat;
6416d527 4376 struct imsm_super *anchor;
cdddbdbc
DW		 4377 __u32 check_sum;
4378
cdddbdbc 4379 get_dev_size(fd, NULL, &dsize);
f36a9ecd 4380 if (dsize < 2*sector_size) {
64436f06 4381 if (devname)
e7b84f9d
N		 4382 pr_err("%s: device to small for imsm\n",
4383 devname);
64436f06
N		 4384 return 1;
4385 }
cdddbdbc 4386
f36a9ecd 4387 if (lseek64(fd, dsize - (sector_size * 2), SEEK_SET) < 0) {
cdddbdbc 4388 if (devname)
e7b84f9d
N		 4389 pr_err("Cannot seek to anchor block on %s: %s\n",
4390 devname, strerror(errno));
cdddbdbc
DW		 4391 return 1;
4392 }
4393
f36a9ecd 4394 if (posix_memalign((void **)&anchor, sector_size, sector_size) != 0) {
ad97895e 4395 if (devname)
7a862a02 4396 pr_err("Failed to allocate imsm anchor buffer on %s\n", devname);
ad97895e
DW		 4397 return 1;
4398 }
466070ad 4399 if ((unsigned int)read(fd, anchor, sector_size) != sector_size) {
cdddbdbc 4400 if (devname)
e7b84f9d
N		 4401 pr_err("Cannot read anchor block on %s: %s\n",
4402 devname, strerror(errno));
6416d527 4403 free(anchor);
cdddbdbc
DW		 4404 return 1;
4405 }
4406
6416d527 4407 if (strncmp((char *) anchor->sig, MPB_SIGNATURE, MPB_SIG_LEN) != 0) {
cdddbdbc 4408 if (devname)
e7b84f9d 4409 pr_err("no IMSM anchor on %s\n", devname);
6416d527 4410 free(anchor);
cdddbdbc
DW		 4411 return 2;
4412 }
4413
d23fe947 4414 __free_imsm(super, 0);
f2f5c343
LM		 4415 /* reload capability and hba */
4416
4417 /* capability and hba must be updated with new super allocation */
d424212e 4418 find_intel_hba_capability(fd, super, devname);
f36a9ecd
PB		 4419 super->len = ROUND_UP(anchor->mpb_size, sector_size);
4420 if (posix_memalign(&super->buf, MAX_SECTOR_SIZE, super->len) != 0) {
cdddbdbc 4421 if (devname)
e7b84f9d
N		 4422 pr_err("unable to allocate %zu byte mpb buffer\n",
4423 super->len);
6416d527 4424 free(anchor);
cdddbdbc
DW		 4425 return 2;
4426 }
f36a9ecd 4427 memcpy(super->buf, anchor, sector_size);
cdddbdbc 4428
f36a9ecd 4429 sectors = mpb_sectors(anchor, sector_size) - 1;
6416d527 4430 free(anchor);
8e59f3d8 4431
85337573
AO		 4432 if (posix_memalign(&super->migr_rec_buf, MAX_SECTOR_SIZE,
4433 MIGR_REC_BUF_SECTORS*MAX_SECTOR_SIZE) != 0) {
1ade5cc1 4434 pr_err("could not allocate migr_rec buffer\n");
8e59f3d8
AK		 4435 free(super->buf);
4436 return 2;
4437 }
51d83f5d 4438 super->clean_migration_record_by_mdmon = 0;
8e59f3d8 4439
949c47a0 4440 if (!sectors) {
ecf45690
DW		 4441 check_sum = __gen_imsm_checksum(super->anchor);
4442 if (check_sum != __le32_to_cpu(super->anchor->check_sum)) {
4443 if (devname)
e7b84f9d
N		 4444 pr_err("IMSM checksum %x != %x on %s\n",
4445 check_sum,
4446 __le32_to_cpu(super->anchor->check_sum),
4447 devname);
ecf45690
DW		 4448 return 2;
4449 }
4450
a2b97981 4451 return 0;
949c47a0 4452 }
cdddbdbc
DW		 4453
4454 /* read the extended mpb */
f36a9ecd 4455 if (lseek64(fd, dsize - (sector_size * (2 + sectors)), SEEK_SET) < 0) {
cdddbdbc 4456 if (devname)
e7b84f9d
N		 4457 pr_err("Cannot seek to extended mpb on %s: %s\n",
4458 devname, strerror(errno));
cdddbdbc
DW		 4459 return 1;
4460 }
4461
f36a9ecd
PB		 4462 if ((unsigned int)read(fd, super->buf + sector_size,
4463 super->len - sector_size) != super->len - sector_size) {
cdddbdbc 4464 if (devname)
e7b84f9d
N		 4465 pr_err("Cannot read extended mpb on %s: %s\n",
4466 devname, strerror(errno));
cdddbdbc
DW		 4467 return 2;
4468 }
4469
949c47a0
DW		 4470 check_sum = __gen_imsm_checksum(super->anchor);
4471 if (check_sum != __le32_to_cpu(super->anchor->check_sum)) {
cdddbdbc 4472 if (devname)
e7b84f9d
N		 4473 pr_err("IMSM checksum %x != %x on %s\n",
4474 check_sum, __le32_to_cpu(super->anchor->check_sum),
4475 devname);
db575f3b 4476 return 3;
cdddbdbc
DW		 4477 }
4478
a2b97981
DW		 4479 return 0;
4480}
4481
8e59f3d8
AK		 4482static int read_imsm_migr_rec(int fd, struct intel_super *super);
4483
97f81ee2
CA		 4484/* clears hi bits in metadata if MPB_ATTRIB_2TB_DISK not set */
4485static void clear_hi(struct intel_super *super)
4486{
4487 struct imsm_super *mpb = super->anchor;
4488 int i, n;
4489 if (mpb->attributes & MPB_ATTRIB_2TB_DISK)
4490 return;
4491 for (i = 0; i < mpb->num_disks; ++i) {
4492 struct imsm_disk *disk = &mpb->disk[i];
4493 disk->total_blocks_hi = 0;
4494 }
4495 for (i = 0; i < mpb->num_raid_devs; ++i) {
4496 struct imsm_dev *dev = get_imsm_dev(super, i);
4497 if (!dev)
4498 return;
4499 for (n = 0; n < 2; ++n) {
4500 struct imsm_map *map = get_imsm_map(dev, n);
4501 if (!map)
4502 continue;
4503 map->pba_of_lba0_hi = 0;
4504 map->blocks_per_member_hi = 0;
4505 map->num_data_stripes_hi = 0;
4506 }
4507 }
4508}
4509
a2b97981
DW		 4510static int
4511load_and_parse_mpb(int fd, struct intel_super *super, char *devname, int keep_fd)
4512{
4513 int err;
4514
4515 err = load_imsm_mpb(fd, super, devname);
4516 if (err)
4517 return err;
f36a9ecd
PB		 4518 if (super->sector_size == 4096)
4519 convert_from_4k(super);
a2b97981
DW		 4520 err = load_imsm_disk(fd, super, devname, keep_fd);
4521 if (err)
4522 return err;
4523 err = parse_raid_devices(super);
8d67477f
TM		 4524 if (err)
4525 return err;
4526 err = load_bbm_log(super);
97f81ee2 4527 clear_hi(super);
a2b97981 4528 return err;
cdddbdbc
DW		 4529}
4530
ae6aad82
DW		 4531static void __free_imsm_disk(struct dl *d)
4532{
4533 if (d->fd >= 0)
4534 close(d->fd);
4535 if (d->devname)
4536 free(d->devname);
0dcecb2e
DW		 4537 if (d->e)
4538 free(d->e);
ae6aad82
DW		 4539 free(d);
4540
4541}
1a64be56 4542
cdddbdbc
DW		 4543static void free_imsm_disks(struct intel_super *super)
4544{
47ee5a45 4545 struct dl *d;
cdddbdbc 4546
47ee5a45
DW		 4547 while (super->disks) {
4548 d = super->disks;
cdddbdbc 4549 super->disks = d->next;
ae6aad82 4550 __free_imsm_disk(d);
cdddbdbc 4551 }
cb82edca
AK		 4552 while (super->disk_mgmt_list) {
4553 d = super->disk_mgmt_list;
4554 super->disk_mgmt_list = d->next;
4555 __free_imsm_disk(d);
4556 }
47ee5a45
DW		 4557 while (super->missing) {
4558 d = super->missing;
4559 super->missing = d->next;
4560 __free_imsm_disk(d);
4561 }
4562
cdddbdbc
DW		 4563}
4564
9ca2c81c 4565/* free all the pieces hanging off of a super pointer */
d23fe947 4566static void __free_imsm(struct intel_super *super, int free_disks)
cdddbdbc 4567{
88654014
LM		 4568 struct intel_hba *elem, *next;
4569
9ca2c81c 4570 if (super->buf) {
949c47a0 4571 free(super->buf);
9ca2c81c
DW		 4572 super->buf = NULL;
4573 }
f2f5c343
LM		 4574 /* unlink capability description */
4575 super->orom = NULL;
8e59f3d8
AK		 4576 if (super->migr_rec_buf) {
4577 free(super->migr_rec_buf);
4578 super->migr_rec_buf = NULL;
4579 }
d23fe947
DW		 4580 if (free_disks)
4581 free_imsm_disks(super);
ba2de7ba 4582 free_devlist(super);
88654014
LM		 4583 elem = super->hba;
4584 while (elem) {
4585 if (elem->path)
4586 free((void *)elem->path);
4587 next = elem->next;
4588 free(elem);
4589 elem = next;
88c32bb1 4590 }
8d67477f
TM		 4591 if (super->bbm_log)
4592 free(super->bbm_log);
88654014 4593 super->hba = NULL;
cdddbdbc
DW		 4594}
4595
9ca2c81c
DW		 4596static void free_imsm(struct intel_super *super)
4597{
d23fe947 4598 __free_imsm(super, 1);
928f1424 4599 free(super->bb.entries);
9ca2c81c
DW		 4600 free(super);
4601}
cdddbdbc
DW		 4602
4603static void free_super_imsm(struct supertype *st)
4604{
4605 struct intel_super *super = st->sb;
4606
4607 if (!super)
4608 return;
4609
4610 free_imsm(super);
4611 st->sb = NULL;
4612}
4613
49133e57 4614static struct intel_super *alloc_super(void)
c2c087e6 4615{
503975b9 4616 struct intel_super *super = xcalloc(1, sizeof(*super));
c2c087e6 4617
503975b9
N		 4618 super->current_vol = -1;
4619 super->create_offset = ~((unsigned long long) 0);
928f1424
TM		 4620
4621 super->bb.entries = xmalloc(BBM_LOG_MAX_ENTRIES *
4622 sizeof(struct md_bb_entry));
4623 if (!super->bb.entries) {
4624 free(super);
4625 return NULL;
4626 }
4627
c2c087e6
DW		 4628 return super;
4629}
4630
f0f5a016
LM		 4631/*
4632 * find and allocate hba and OROM/EFI based on valid fd of RAID component device
4633 */
d424212e 4634static int find_intel_hba_capability(int fd, struct intel_super *super, char *devname)
f0f5a016
LM		 4635{
4636 struct sys_dev *hba_name;
4637 int rv = 0;
4638
3a30e28e
MT		 4639 if (fd >= 0 && test_partition(fd)) {
4640 pr_err("imsm: %s is a partition, cannot be used in IMSM\n",
4641 devname);
4642 return 1;
4643 }
089f9d79 4644 if (fd < 0 || check_env("IMSM_NO_PLATFORM")) {
f2f5c343 4645 super->orom = NULL;
f0f5a016
LM		 4646 super->hba = NULL;
4647 return 0;
4648 }
4649 hba_name = find_disk_attached_hba(fd, NULL);
4650 if (!hba_name) {
d424212e 4651 if (devname)
e7b84f9d
N		 4652 pr_err("%s is not attached to Intel(R) RAID controller.\n",
4653 devname);
f0f5a016
LM		 4654 return 1;
4655 }
4656 rv = attach_hba_to_super(super, hba_name);
4657 if (rv == 2) {
d424212e
N		 4658 if (devname) {
4659 struct intel_hba *hba = super->hba;
f0f5a016 4660
60f0f54d
PB		 4661 pr_err("%s is attached to Intel(R) %s %s (%s),\n"
4662 " but the container is assigned to Intel(R) %s %s (",
d424212e 4663 devname,
614902f6 4664 get_sys_dev_type(hba_name->type),
60f0f54d 4665 hba_name->type == SYS_DEV_VMD ? "domain" : "RAID controller",
f0f5a016 4666 hba_name->pci_id ? : "Err!",
60f0f54d
PB		 4667 get_sys_dev_type(super->hba->type),
4668 hba->type == SYS_DEV_VMD ? "domain" : "RAID controller");
f0f5a016 4669
f0f5a016
LM		 4670 while (hba) {
4671 fprintf(stderr, "%s", hba->pci_id ? : "Err!");
4672 if (hba->next)
4673 fprintf(stderr, ", ");
4674 hba = hba->next;
4675 }
6b781d33 4676 fprintf(stderr, ").\n"
cca67208 4677 " Mixing devices attached to different controllers is not allowed.\n");
f0f5a016 4678 }
f0f5a016
LM		 4679 return 2;
4680 }
6b781d33 4681 super->orom = find_imsm_capability(hba_name);
f2f5c343
LM		 4682 if (!super->orom)
4683 return 3;
614902f6 4684
f0f5a016
LM		 4685 return 0;
4686}
4687
47ee5a45
DW		 4688/* find_missing - helper routine for load_super_imsm_all that identifies
4689 * disks that have disappeared from the system. This routine relies on
4690 * the mpb being uptodate, which it is at load time.
4691 */
4692static int find_missing(struct intel_super *super)
4693{
4694 int i;
4695 struct imsm_super *mpb = super->anchor;
4696 struct dl *dl;
4697 struct imsm_disk *disk;
47ee5a45
DW		 4698
4699 for (i = 0; i < mpb->num_disks; i++) {
4700 disk = __get_imsm_disk(mpb, i);
54c2c1ea 4701 dl = serial_to_dl(disk->serial, super);
47ee5a45
DW		 4702 if (dl)
4703 continue;
47ee5a45 4704
503975b9 4705 dl = xmalloc(sizeof(*dl));
47ee5a45
DW		 4706 dl->major = 0;
4707 dl->minor = 0;
4708 dl->fd = -1;
503975b9 4709 dl->devname = xstrdup("missing");
47ee5a45
DW		 4710 dl->index = i;
4711 serialcpy(dl->serial, disk->serial);
4712 dl->disk = *disk;
689c9bf3 4713 dl->e = NULL;
47ee5a45
DW		 4714 dl->next = super->missing;
4715 super->missing = dl;
4716 }
4717
4718 return 0;
4719}
4720
a2b97981
DW		 4721static struct intel_disk *disk_list_get(__u8 *serial, struct intel_disk *disk_list)
4722{
4723 struct intel_disk *idisk = disk_list;
4724
4725 while (idisk) {
4726 if (serialcmp(idisk->disk.serial, serial) == 0)
4727 break;
4728 idisk = idisk->next;
4729 }
4730
4731 return idisk;
4732}
4733
4734static int __prep_thunderdome(struct intel_super **table, int tbl_size,
4735 struct intel_super *super,
4736 struct intel_disk **disk_list)
4737{
4738 struct imsm_disk *d = &super->disks->disk;
4739 struct imsm_super *mpb = super->anchor;
4740 int i, j;
4741
4742 for (i = 0; i < tbl_size; i++) {
4743 struct imsm_super *tbl_mpb = table[i]->anchor;
4744 struct imsm_disk *tbl_d = &table[i]->disks->disk;
4745
4746 if (tbl_mpb->family_num == mpb->family_num) {
4747 if (tbl_mpb->check_sum == mpb->check_sum) {
1ade5cc1
N		 4748 dprintf("mpb from %d:%d matches %d:%d\n",
4749 super->disks->major,
a2b97981
DW		 4750 super->disks->minor,
4751 table[i]->disks->major,
4752 table[i]->disks->minor);
4753 break;
4754 }
4755
4756 if (((is_configured(d) && !is_configured(tbl_d)) ||
4757 is_configured(d) == is_configured(tbl_d)) &&
4758 tbl_mpb->generation_num < mpb->generation_num) {
4759 /* current version of the mpb is a
4760 * better candidate than the one in
4761 * super_table, but copy over "cross
4762 * generational" status
4763 */
4764 struct intel_disk *idisk;
4765
1ade5cc1
N		 4766 dprintf("mpb from %d:%d replaces %d:%d\n",
4767 super->disks->major,
a2b97981
DW		 4768 super->disks->minor,
4769 table[i]->disks->major,
4770 table[i]->disks->minor);
4771
4772 idisk = disk_list_get(tbl_d->serial, *disk_list);
4773 if (idisk && is_failed(&idisk->disk))
4774 tbl_d->status |= FAILED_DISK;
4775 break;
4776 } else {
4777 struct intel_disk *idisk;
4778 struct imsm_disk *disk;
4779
4780 /* tbl_mpb is more up to date, but copy
4781 * over cross generational status before
4782 * returning
4783 */
4784 disk = __serial_to_disk(d->serial, mpb, NULL);
4785 if (disk && is_failed(disk))
4786 d->status |= FAILED_DISK;
4787
4788 idisk = disk_list_get(d->serial, *disk_list);
4789 if (idisk) {
4790 idisk->owner = i;
4791 if (disk && is_configured(disk))
4792 idisk->disk.status |= CONFIGURED_DISK;
4793 }
4794
1ade5cc1
N		 4795 dprintf("mpb from %d:%d prefer %d:%d\n",
4796 super->disks->major,
a2b97981
DW		 4797 super->disks->minor,
4798 table[i]->disks->major,
4799 table[i]->disks->minor);
4800
4801 return tbl_size;
4802 }
4803 }
4804 }
4805
4806 if (i >= tbl_size)
4807 table[tbl_size++] = super;
4808 else
4809 table[i] = super;
4810
4811 /* update/extend the merged list of imsm_disk records */
4812 for (j = 0; j < mpb->num_disks; j++) {
4813 struct imsm_disk *disk = __get_imsm_disk(mpb, j);
4814 struct intel_disk *idisk;
4815
4816 idisk = disk_list_get(disk->serial, *disk_list);
4817 if (idisk) {
4818 idisk->disk.status |= disk->status;
4819 if (is_configured(&idisk->disk) ||
4820 is_failed(&idisk->disk))
4821 idisk->disk.status &= ~(SPARE_DISK);
4822 } else {
503975b9 4823 idisk = xcalloc(1, sizeof(*idisk));
a2b97981
DW		 4824 idisk->owner = IMSM_UNKNOWN_OWNER;
4825 idisk->disk = *disk;
4826 idisk->next = *disk_list;
4827 *disk_list = idisk;
4828 }
4829
4830 if (serialcmp(idisk->disk.serial, d->serial) == 0)
4831 idisk->owner = i;
4832 }
4833
4834 return tbl_size;
4835}
4836
4837static struct intel_super *
4838validate_members(struct intel_super *super, struct intel_disk *disk_list,
4839 const int owner)
4840{
4841 struct imsm_super *mpb = super->anchor;
4842 int ok_count = 0;
4843 int i;
4844
4845 for (i = 0; i < mpb->num_disks; i++) {
4846 struct imsm_disk *disk = __get_imsm_disk(mpb, i);
4847 struct intel_disk *idisk;
4848
4849 idisk = disk_list_get(disk->serial, disk_list);
4850 if (idisk) {
4851 if (idisk->owner == owner ||
4852 idisk->owner == IMSM_UNKNOWN_OWNER)
4853 ok_count++;
4854 else
1ade5cc1
N		 4855 dprintf("'%.16s' owner %d != %d\n",
4856 disk->serial, idisk->owner,
a2b97981
DW		 4857 owner);
4858 } else {
1ade5cc1
N		 4859 dprintf("unknown disk %x [%d]: %.16s\n",
4860 __le32_to_cpu(mpb->family_num), i,
a2b97981
DW		 4861 disk->serial);
4862 break;
4863 }
4864 }
4865
4866 if (ok_count == mpb->num_disks)
4867 return super;
4868 return NULL;
4869}
4870
4871static void show_conflicts(__u32 family_num, struct intel_super *super_list)
4872{
4873 struct intel_super *s;
4874
4875 for (s = super_list; s; s = s->next) {
4876 if (family_num != s->anchor->family_num)
4877 continue;
e12b3daa 4878 pr_err("Conflict, offlining family %#x on '%s'\n",
a2b97981
DW		 4879 __le32_to_cpu(family_num), s->disks->devname);
4880 }
4881}
4882
4883static struct intel_super *
4884imsm_thunderdome(struct intel_super **super_list, int len)
4885{
4886 struct intel_super *super_table[len];
4887 struct intel_disk *disk_list = NULL;
4888 struct intel_super *champion, *spare;
4889 struct intel_super *s, **del;
4890 int tbl_size = 0;
4891 int conflict;
4892 int i;
4893
4894 memset(super_table, 0, sizeof(super_table));
4895 for (s = *super_list; s; s = s->next)
4896 tbl_size = __prep_thunderdome(super_table, tbl_size, s, &disk_list);
4897
4898 for (i = 0; i < tbl_size; i++) {
4899 struct imsm_disk *d;
4900 struct intel_disk *idisk;
4901 struct imsm_super *mpb = super_table[i]->anchor;
4902
4903 s = super_table[i];
4904 d = &s->disks->disk;
4905
4906 /* 'd' must appear in merged disk list for its
4907 * configuration to be valid
4908 */
4909 idisk = disk_list_get(d->serial, disk_list);
4910 if (idisk && idisk->owner == i)
4911 s = validate_members(s, disk_list, i);
4912 else
4913 s = NULL;
4914
4915 if (!s)
1ade5cc1
N		 4916 dprintf("marking family: %#x from %d:%d offline\n",
4917 mpb->family_num,
a2b97981
DW		 4918 super_table[i]->disks->major,
4919 super_table[i]->disks->minor);
4920 super_table[i] = s;
4921 }
4922
4923 /* This is where the mdadm implementation differs from the Windows
4924 * driver which has no strict concept of a container. We can only
4925 * assemble one family from a container, so when returning a prodigal
4926 * array member to this system the code will not be able to disambiguate
4927 * the container contents that should be assembled ("foreign" versus
4928 * "local"). It requires user intervention to set the orig_family_num
4929 * to a new value to establish a new container. The Windows driver in
4930 * this situation fixes up the volume name in place and manages the
4931 * foreign array as an independent entity.
4932 */
4933 s = NULL;
4934 spare = NULL;
4935 conflict = 0;
4936 for (i = 0; i < tbl_size; i++) {
4937 struct intel_super *tbl_ent = super_table[i];
4938 int is_spare = 0;
4939
4940 if (!tbl_ent)
4941 continue;
4942
4943 if (tbl_ent->anchor->num_raid_devs == 0) {
4944 spare = tbl_ent;
4945 is_spare = 1;
4946 }
4947
4948 if (s && !is_spare) {
4949 show_conflicts(tbl_ent->anchor->family_num, *super_list);
4950 conflict++;
4951 } else if (!s && !is_spare)
4952 s = tbl_ent;
4953 }
4954
4955 if (!s)
4956 s = spare;
4957 if (!s) {
4958 champion = NULL;
4959 goto out;
4960 }
4961 champion = s;
4962
4963 if (conflict)
7a862a02 4964 pr_err("Chose family %#x on '%s', assemble conflicts to new container with '--update=uuid'\n",
a2b97981
DW		 4965 __le32_to_cpu(s->anchor->family_num), s->disks->devname);
4966
4967 /* collect all dl's onto 'champion', and update them to
4968 * champion's version of the status
4969 */
4970 for (s = *super_list; s; s = s->next) {
4971 struct imsm_super *mpb = champion->anchor;
4972 struct dl *dl = s->disks;
4973
4974 if (s == champion)
4975 continue;
4976
5d7b407a
CA		 4977 mpb->attributes |= s->anchor->attributes & MPB_ATTRIB_2TB_DISK;
4978
a2b97981
DW		 4979 for (i = 0; i < mpb->num_disks; i++) {
4980 struct imsm_disk *disk;
4981
4982 disk = __serial_to_disk(dl->serial, mpb, &dl->index);
4983 if (disk) {
4984 dl->disk = *disk;
4985 /* only set index on disks that are a member of
4986 * a populated contianer, i.e. one with
4987 * raid_devs
4988 */
4989 if (is_failed(&dl->disk))
4990 dl->index = -2;
4991 else if (is_spare(&dl->disk))
4992 dl->index = -1;
4993 break;
4994 }
4995 }
4996
4997 if (i >= mpb->num_disks) {
4998 struct intel_disk *idisk;
4999
5000 idisk = disk_list_get(dl->serial, disk_list);
ecf408e9 5001 if (idisk && is_spare(&idisk->disk) &&
a2b97981
DW		 5002 !is_failed(&idisk->disk) && !is_configured(&idisk->disk))
5003 dl->index = -1;
5004 else {
5005 dl->index = -2;
5006 continue;
5007 }
5008 }
5009
5010 dl->next = champion->disks;
5011 champion->disks = dl;
5012 s->disks = NULL;
5013 }
5014
5015 /* delete 'champion' from super_list */
5016 for (del = super_list; *del; ) {
5017 if (*del == champion) {
5018 *del = (*del)->next;
5019 break;
5020 } else
5021 del = &(*del)->next;
5022 }
5023 champion->next = NULL;
5024
5025 out:
5026 while (disk_list) {
5027 struct intel_disk *idisk = disk_list;
5028
5029 disk_list = disk_list->next;
5030 free(idisk);
5031 }
5032
5033 return champion;
5034}
5035
9587c373
LM		 5036static int
5037get_sra_super_block(int fd, struct intel_super **super_list, char *devname, int *max, int keep_fd);
4dd2df09 5038static int get_super_block(struct intel_super **super_list, char *devnm, char *devname,
9587c373 5039 int major, int minor, int keep_fd);
ec50f7b6
LM		 5040static int
5041get_devlist_super_block(struct md_list *devlist, struct intel_super **super_list,
5042 int *max, int keep_fd);
5043
cdddbdbc 5044static int load_super_imsm_all(struct supertype *st, int fd, void **sbp,
ec50f7b6
LM		 5045 char *devname, struct md_list *devlist,
5046 int keep_fd)
cdddbdbc 5047{
a2b97981
DW		 5048 struct intel_super *super_list = NULL;
5049 struct intel_super *super = NULL;
a2b97981 5050 int err = 0;
9587c373 5051 int i = 0;
dab4a513 5052
9587c373
LM		 5053 if (fd >= 0)
5054 /* 'fd' is an opened container */
5055 err = get_sra_super_block(fd, &super_list, devname, &i, keep_fd);
5056 else
ec50f7b6
LM		 5057 /* get super block from devlist devices */
5058 err = get_devlist_super_block(devlist, &super_list, &i, keep_fd);
9587c373 5059 if (err)
1602d52c 5060 goto error;
a2b97981
DW		 5061 /* all mpbs enter, maybe one leaves */
5062 super = imsm_thunderdome(&super_list, i);
5063 if (!super) {
5064 err = 1;
5065 goto error;
cdddbdbc
DW		 5066 }
5067
47ee5a45
DW		 5068 if (find_missing(super) != 0) {
5069 free_imsm(super);
a2b97981
DW		 5070 err = 2;
5071 goto error;
47ee5a45 5072 }
8e59f3d8
AK		 5073
5074 /* load migration record */
2f86fda3 5075 err = load_imsm_migr_rec(super);
4c965cc9
AK		 5076 if (err == -1) {
5077 /* migration is in progress,
5078 * but migr_rec cannot be loaded,
5079 */
8e59f3d8
AK		 5080 err = 4;
5081 goto error;
5082 }
e2f41b2c
AK		 5083
5084 /* Check migration compatibility */
089f9d79 5085 if (err == 0 && check_mpb_migr_compatibility(super) != 0) {
e7b84f9d 5086 pr_err("Unsupported migration detected");
e2f41b2c
AK		 5087 if (devname)
5088 fprintf(stderr, " on %s\n", devname);
5089 else
5090 fprintf(stderr, " (IMSM).\n");
5091
5092 err = 5;
5093 goto error;
5094 }
5095
a2b97981
DW		 5096 err = 0;
5097
5098 error:
5099 while (super_list) {
5100 struct intel_super *s = super_list;
5101
5102 super_list = super_list->next;
5103 free_imsm(s);
5104 }
9587c373 5105
a2b97981
DW		 5106 if (err)
5107 return err;
f7e7067b 5108
cdddbdbc 5109 *sbp = super;
9587c373 5110 if (fd >= 0)
4dd2df09 5111 strcpy(st->container_devnm, fd2devnm(fd));
9587c373 5112 else
4dd2df09 5113 st->container_devnm[0] = 0;
a2b97981 5114 if (err == 0 && st->ss == NULL) {
bf5a934a 5115 st->ss = &super_imsm;
cdddbdbc
DW		 5116 st->minor_version = 0;
5117 st->max_devs = IMSM_MAX_DEVICES;
5118 }
cdddbdbc
DW		 5119 return 0;
5120}
2b959fbf 5121
ec50f7b6
LM		 5122static int
5123get_devlist_super_block(struct md_list *devlist, struct intel_super **super_list,
5124 int *max, int keep_fd)
5125{
5126 struct md_list *tmpdev;
5127 int err = 0;
5128 int i = 0;
9587c373 5129
ec50f7b6
LM		 5130 for (i = 0, tmpdev = devlist; tmpdev; tmpdev = tmpdev->next) {
5131 if (tmpdev->used != 1)
5132 continue;
5133 if (tmpdev->container == 1) {
ca9de185 5134 int lmax = 0;
ec50f7b6
LM		 5135 int fd = dev_open(tmpdev->devname, O_RDONLY|O_EXCL);
5136 if (fd < 0) {
e7b84f9d 5137 pr_err("cannot open device %s: %s\n",
ec50f7b6
LM		 5138 tmpdev->devname, strerror(errno));
5139 err = 8;
5140 goto error;
5141 }
5142 err = get_sra_super_block(fd, super_list,
5143 tmpdev->devname, &lmax,
5144 keep_fd);
5145 i += lmax;
5146 close(fd);
5147 if (err) {
5148 err = 7;
5149 goto error;
5150 }
5151 } else {
5152 int major = major(tmpdev->st_rdev);
5153 int minor = minor(tmpdev->st_rdev);
5154 err = get_super_block(super_list,
4dd2df09 5155 NULL,
ec50f7b6
LM		 5156 tmpdev->devname,
5157 major, minor,
5158 keep_fd);
5159 i++;
5160 if (err) {
5161 err = 6;
5162 goto error;
5163 }
5164 }
5165 }
5166 error:
5167 *max = i;
5168 return err;
5169}
9587c373 5170
4dd2df09 5171static int get_super_block(struct intel_super **super_list, char *devnm, char *devname,
9587c373
LM		 5172 int major, int minor, int keep_fd)
5173{
594dc1b8 5174 struct intel_super *s;
9587c373
LM		 5175 char nm[32];
5176 int dfd = -1;
9587c373
LM		 5177 int err = 0;
5178 int retry;
5179
5180 s = alloc_super();
5181 if (!s) {
5182 err = 1;
5183 goto error;
5184 }
5185
5186 sprintf(nm, "%d:%d", major, minor);
5187 dfd = dev_open(nm, O_RDWR);
5188 if (dfd < 0) {
5189 err = 2;
5190 goto error;
5191 }
5192
fa7bb6f8 5193 get_dev_sector_size(dfd, NULL, &s->sector_size);
cb8f6859 5194 find_intel_hba_capability(dfd, s, devname);
9587c373
LM		 5195 err = load_and_parse_mpb(dfd, s, NULL, keep_fd);
5196
5197 /* retry the load if we might have raced against mdmon */
4dd2df09 5198 if (err == 3 && devnm && mdmon_running(devnm))
9587c373
LM		 5199 for (retry = 0; retry < 3; retry++) {
5200 usleep(3000);
5201 err = load_and_parse_mpb(dfd, s, NULL, keep_fd);
5202 if (err != 3)
5203 break;
5204 }
5205 error:
5206 if (!err) {
5207 s->next = *super_list;
5208 *super_list = s;
5209 } else {
5210 if (s)
8d67477f 5211 free_imsm(s);
36614e95 5212 if (dfd >= 0)
9587c373
LM		 5213 close(dfd);
5214 }
089f9d79 5215 if (dfd >= 0 && !keep_fd)
9587c373
LM		 5216 close(dfd);
5217 return err;
5218
5219}
5220
5221static int
5222get_sra_super_block(int fd, struct intel_super **super_list, char *devname, int *max, int keep_fd)
5223{
5224 struct mdinfo *sra;
4dd2df09 5225 char *devnm;
9587c373
LM		 5226 struct mdinfo *sd;
5227 int err = 0;
5228 int i = 0;
4dd2df09 5229 sra = sysfs_read(fd, NULL, GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE);
9587c373
LM		 5230 if (!sra)
5231 return 1;
5232
5233 if (sra->array.major_version != -1 ||
5234 sra->array.minor_version != -2 ||
5235 strcmp(sra->text_version, "imsm") != 0) {
5236 err = 1;
5237 goto error;
5238 }
5239 /* load all mpbs */
4dd2df09 5240 devnm = fd2devnm(fd);
9587c373 5241 for (sd = sra->devs, i = 0; sd; sd = sd->next, i++) {
4dd2df09 5242 if (get_super_block(super_list, devnm, devname,
9587c373
LM		 5243 sd->disk.major, sd->disk.minor, keep_fd) != 0) {
5244 err = 7;
5245 goto error;
5246 }
5247 }
5248 error:
5249 sysfs_free(sra);
5250 *max = i;
5251 return err;
5252}
5253
2b959fbf
N		 5254static int load_container_imsm(struct supertype *st, int fd, char *devname)
5255{
ec50f7b6 5256 return load_super_imsm_all(st, fd, &st->sb, devname, NULL, 1);
2b959fbf 5257}
cdddbdbc
DW		 5258
5259static int load_super_imsm(struct supertype *st, int fd, char *devname)
5260{
5261 struct intel_super *super;
5262 int rv;
8a3544f8 5263 int retry;
cdddbdbc 5264
357ac106 5265 if (test_partition(fd))
691c6ee1
N		 5266 /* IMSM not allowed on partitions */
5267 return 1;
5268
37424f13
DW		 5269 free_super_imsm(st);
5270
49133e57 5271 super = alloc_super();
fa7bb6f8 5272 get_dev_sector_size(fd, NULL, &super->sector_size);
8d67477f
TM		 5273 if (!super)
5274 return 1;
ea2bc72b
LM		 5275 /* Load hba and capabilities if they exist.
5276 * But do not preclude loading metadata in case capabilities or hba are
5277 * non-compliant and ignore_hw_compat is set.
5278 */
d424212e 5279 rv = find_intel_hba_capability(fd, super, devname);
f2f5c343 5280 /* no orom/efi or non-intel hba of the disk */
089f9d79 5281 if (rv != 0 && st->ignore_hw_compat == 0) {
f2f5c343 5282 if (devname)
e7b84f9d 5283 pr_err("No OROM/EFI properties for %s\n", devname);
f2f5c343
LM		 5284 free_imsm(super);
5285 return 2;
5286 }
a2b97981 5287 rv = load_and_parse_mpb(fd, super, devname, 0);
cdddbdbc 5288
8a3544f8
AP		 5289 /* retry the load if we might have raced against mdmon */
5290 if (rv == 3) {
f96b1302
AP		 5291 struct mdstat_ent *mdstat = NULL;
5292 char *name = fd2kname(fd);
5293
5294 if (name)
5295 mdstat = mdstat_by_component(name);
8a3544f8
AP		 5296
5297 if (mdstat && mdmon_running(mdstat->devnm) && getpid() != mdmon_pid(mdstat->devnm)) {
5298 for (retry = 0; retry < 3; retry++) {
5299 usleep(3000);
5300 rv = load_and_parse_mpb(fd, super, devname, 0);
5301 if (rv != 3)
5302 break;
5303 }
5304 }
5305
5306 free_mdstat(mdstat);
5307 }
5308
cdddbdbc
DW		 5309 if (rv) {
5310 if (devname)
7a862a02 5311 pr_err("Failed to load all information sections on %s\n", devname);
cdddbdbc
DW		 5312 free_imsm(super);
5313 return rv;
5314 }
5315
5316 st->sb = super;
5317 if (st->ss == NULL) {
5318 st->ss = &super_imsm;
5319 st->minor_version = 0;
5320 st->max_devs = IMSM_MAX_DEVICES;
5321 }
8e59f3d8
AK		 5322
5323 /* load migration record */
2f86fda3 5324 if (load_imsm_migr_rec(super) == 0) {
2e062e82
AK		 5325 /* Check for unsupported migration features */
5326 if (check_mpb_migr_compatibility(super) != 0) {
e7b84f9d 5327 pr_err("Unsupported migration detected");
2e062e82
AK		 5328 if (devname)
5329 fprintf(stderr, " on %s\n", devname);
5330 else
5331 fprintf(stderr, " (IMSM).\n");
5332 return 3;
5333 }
e2f41b2c
AK		 5334 }
5335
cdddbdbc
DW		 5336 return 0;
5337}
5338
ef6ffade
DW		 5339static __u16 info_to_blocks_per_strip(mdu_array_info_t *info)
5340{
5341 if (info->level == 1)
5342 return 128;
5343 return info->chunk_size >> 9;
5344}
5345
5551b113
CA		 5346static unsigned long long info_to_blocks_per_member(mdu_array_info_t *info,
5347 unsigned long long size)
fcfd9599 5348{
4025c288 5349 if (info->level == 1)
5551b113 5350 return size * 2;
4025c288 5351 else
5551b113 5352 return (size * 2) & ~(info_to_blocks_per_strip(info) - 1);
fcfd9599
DW		 5353}
5354
4d1313e9
DW		 5355static void imsm_update_version_info(struct intel_super *super)
5356{
5357 /* update the version and attributes */
5358 struct imsm_super *mpb = super->anchor;
5359 char *version;
5360 struct imsm_dev *dev;
5361 struct imsm_map *map;
5362 int i;
5363
5364 for (i = 0; i < mpb->num_raid_devs; i++) {
5365 dev = get_imsm_dev(super, i);
238c0a71 5366 map = get_imsm_map(dev, MAP_0);
4d1313e9
DW		 5367 if (__le32_to_cpu(dev->size_high) > 0)
5368 mpb->attributes |= MPB_ATTRIB_2TB;
5369
5370 /* FIXME detect when an array spans a port multiplier */
5371 #if 0
5372 mpb->attributes |= MPB_ATTRIB_PM;
5373 #endif
5374
5375 if (mpb->num_raid_devs > 1 ||
5376 mpb->attributes != MPB_ATTRIB_CHECKSUM_VERIFY) {
5377 version = MPB_VERSION_ATTRIBS;
5378 switch (get_imsm_raid_level(map)) {
5379 case 0: mpb->attributes |= MPB_ATTRIB_RAID0; break;
5380 case 1: mpb->attributes |= MPB_ATTRIB_RAID1; break;
5381 case 10: mpb->attributes |= MPB_ATTRIB_RAID10; break;
5382 case 5: mpb->attributes |= MPB_ATTRIB_RAID5; break;
5383 }
5384 } else {
5385 if (map->num_members >= 5)
5386 version = MPB_VERSION_5OR6_DISK_ARRAY;
5387 else if (dev->status == DEV_CLONE_N_GO)
5388 version = MPB_VERSION_CNG;
5389 else if (get_imsm_raid_level(map) == 5)
5390 version = MPB_VERSION_RAID5;
5391 else if (map->num_members >= 3)
5392 version = MPB_VERSION_3OR4_DISK_ARRAY;
5393 else if (get_imsm_raid_level(map) == 1)
5394 version = MPB_VERSION_RAID1;
5395 else
5396 version = MPB_VERSION_RAID0;
5397 }
5398 strcpy(((char *) mpb->sig) + strlen(MPB_SIGNATURE), version);
5399 }
5400}
5401
aa534678
DW		 5402static int check_name(struct intel_super *super, char *name, int quiet)
5403{
5404 struct imsm_super *mpb = super->anchor;
5405 char *reason = NULL;
9bd99a90
RS		 5406 char *start = name;
5407 size_t len = strlen(name);
aa534678
DW		 5408 int i;
5409
9bd99a90
RS		 5410 if (len > 0) {
5411 while (isspace(start[len - 1]))
5412 start[--len] = 0;
5413 while (*start && isspace(*start))
5414 ++start, --len;
5415 memmove(name, start, len + 1);
5416 }
5417
5418 if (len > MAX_RAID_SERIAL_LEN)
aa534678 5419 reason = "must be 16 characters or less";
9bd99a90
RS		 5420 else if (len == 0)
5421 reason = "must be a non-empty string";
aa534678
DW		 5422
5423 for (i = 0; i < mpb->num_raid_devs; i++) {
5424 struct imsm_dev *dev = get_imsm_dev(super, i);
5425
5426 if (strncmp((char *) dev->volume, name, MAX_RAID_SERIAL_LEN) == 0) {
5427 reason = "already exists";
5428 break;
5429 }
5430 }
5431
5432 if (reason && !quiet)
e7b84f9d 5433 pr_err("imsm volume name %s\n", reason);
aa534678
DW		 5434
5435 return !reason;
5436}
5437
8b353278 5438static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info,
5308f117 5439 struct shape *s, char *name,
83cd1e97
N		 5440 char *homehost, int *uuid,
5441 long long data_offset)
cdddbdbc 5442{
c2c087e6
DW		 5443 /* We are creating a volume inside a pre-existing container.
5444 * so st->sb is already set.
5445 */
5446 struct intel_super *super = st->sb;
f36a9ecd 5447 unsigned int sector_size = super->sector_size;
949c47a0 5448 struct imsm_super *mpb = super->anchor;
ba2de7ba 5449 struct intel_dev *dv;
c2c087e6
DW		 5450 struct imsm_dev *dev;
5451 struct imsm_vol *vol;
5452 struct imsm_map *map;
5453 int idx = mpb->num_raid_devs;
5454 int i;
760365f9 5455 int namelen;
c2c087e6 5456 unsigned long long array_blocks;
2c092cad 5457 size_t size_old, size_new;
5551b113 5458 unsigned long long num_data_stripes;
b53bfba6
TM		 5459 unsigned int data_disks;
5460 unsigned long long size_per_member;
cdddbdbc 5461
88c32bb1 5462 if (super->orom && mpb->num_raid_devs >= super->orom->vpa) {
7a862a02 5463 pr_err("This imsm-container already has the maximum of %d volumes\n", super->orom->vpa);
c2c087e6
DW		 5464 return 0;
5465 }
5466
2c092cad
DW		 5467 /* ensure the mpb is large enough for the new data */
5468 size_old = __le32_to_cpu(mpb->mpb_size);
5469 size_new = disks_to_mpb_size(info->nr_disks);
5470 if (size_new > size_old) {
5471 void *mpb_new;
f36a9ecd 5472 size_t size_round = ROUND_UP(size_new, sector_size);
2c092cad 5473
f36a9ecd 5474 if (posix_memalign(&mpb_new, sector_size, size_round) != 0) {
e7b84f9d 5475 pr_err("could not allocate new mpb\n");
2c092cad
DW		 5476 return 0;
5477 }
85337573
AO		 5478 if (posix_memalign(&super->migr_rec_buf, MAX_SECTOR_SIZE,
5479 MIGR_REC_BUF_SECTORS*
5480 MAX_SECTOR_SIZE) != 0) {
1ade5cc1 5481 pr_err("could not allocate migr_rec buffer\n");
8e59f3d8
AK		 5482 free(super->buf);
5483 free(super);
ea944c8f 5484 free(mpb_new);
8e59f3d8
AK		 5485 return 0;
5486 }
2c092cad
DW		 5487 memcpy(mpb_new, mpb, size_old);
5488 free(mpb);
5489 mpb = mpb_new;
949c47a0 5490 super->anchor = mpb_new;
2c092cad
DW		 5491 mpb->mpb_size = __cpu_to_le32(size_new);
5492 memset(mpb_new + size_old, 0, size_round - size_old);
bbab0940 5493 super->len = size_round;
2c092cad 5494 }
bf5a934a 5495 super->current_vol = idx;
3960e579
DW		 5496
5497 /* handle 'failed_disks' by either:
5498 * a) create dummy disk entries in the table if this the first
5499 * volume in the array. We add them here as this is the only
5500 * opportunity to add them. add_to_super_imsm_volume()
5501 * handles the non-failed disks and continues incrementing
5502 * mpb->num_disks.
5503 * b) validate that 'failed_disks' matches the current number
5504 * of missing disks if the container is populated
d23fe947 5505 */
3960e579 5506 if (super->current_vol == 0) {
d23fe947 5507 mpb->num_disks = 0;
3960e579
DW		 5508 for (i = 0; i < info->failed_disks; i++) {
5509 struct imsm_disk *disk;
5510
5511 mpb->num_disks++;
5512 disk = __get_imsm_disk(mpb, i);
5513 disk->status = CONFIGURED_DISK | FAILED_DISK;
5514 disk->scsi_id = __cpu_to_le32(~(__u32)0);
5515 snprintf((char *) disk->serial, MAX_RAID_SERIAL_LEN,
5b975129 5516 "missing:%d", (__u8)i);
3960e579
DW		 5517 }
5518 find_missing(super);
5519 } else {
5520 int missing = 0;
5521 struct dl *d;
5522
5523 for (d = super->missing; d; d = d->next)
5524 missing++;
5525 if (info->failed_disks > missing) {
e7b84f9d 5526 pr_err("unable to add 'missing' disk to container\n");
3960e579
DW		 5527 return 0;
5528 }
5529 }
5a038140 5530
aa534678
DW		 5531 if (!check_name(super, name, 0))
5532 return 0;
503975b9
N		 5533 dv = xmalloc(sizeof(*dv));
5534 dev = xcalloc(1, sizeof(*dev) + sizeof(__u32) * (info->raid_disks - 1));
760365f9
JS		 5535 /*
5536 * Explicitly allow truncating to not confuse gcc's
5537 * -Werror=stringop-truncation
5538 */
5539 namelen = min((int) strlen(name), MAX_RAID_SERIAL_LEN);
5540 memcpy(dev->volume, name, namelen);
e03640bd 5541 array_blocks = calc_array_size(info->level, info->raid_disks,
03bcbc65 5542 info->layout, info->chunk_size,
b53bfba6
TM		 5543 s->size * BLOCKS_PER_KB);
5544 data_disks = get_data_disks(info->level, info->layout,
5545 info->raid_disks);
5546 array_blocks = round_size_to_mb(array_blocks, data_disks);
5547 size_per_member = array_blocks / data_disks;
979d38be 5548
fcc2c9da 5549 set_imsm_dev_size(dev, array_blocks);
1a2487c2 5550 dev->status = (DEV_READ_COALESCING | DEV_WRITE_COALESCING);
c2c087e6
DW		 5551 vol = &dev->vol;
5552 vol->migr_state = 0;
1484e727 5553 set_migr_type(dev, MIGR_INIT);
3960e579 5554 vol->dirty = !info->state;
f8f603f1 5555 vol->curr_migr_unit = 0;
238c0a71 5556 map = get_imsm_map(dev, MAP_0);
5551b113 5557 set_pba_of_lba0(map, super->create_offset);
ef6ffade 5558 map->blocks_per_strip = __cpu_to_le16(info_to_blocks_per_strip(info));
0556e1a2 5559 map->failed_disk_num = ~0;
bf4442ab 5560 if (info->level > 0)
fffaf1ff
N		 5561 map->map_state = (info->state ? IMSM_T_STATE_NORMAL
5562 : IMSM_T_STATE_UNINITIALIZED);
bf4442ab
AK		 5563 else
5564 map->map_state = info->failed_disks ? IMSM_T_STATE_FAILED :
5565 IMSM_T_STATE_NORMAL;
252d23c0 5566 map->ddf = 1;
ef6ffade
DW		 5567
5568 if (info->level == 1 && info->raid_disks > 2) {
38950822
AW		 5569 free(dev);
5570 free(dv);
7a862a02 5571 pr_err("imsm does not support more than 2 disksin a raid1 volume\n");
ef6ffade
DW		 5572 return 0;
5573 }
81062a36
DW		 5574
5575 map->raid_level = info->level;
4d1313e9 5576 if (info->level == 10) {
c2c087e6 5577 map->raid_level = 1;
4d1313e9 5578 map->num_domains = info->raid_disks / 2;
81062a36
DW		 5579 } else if (info->level == 1)
5580 map->num_domains = info->raid_disks;
5581 else
ff596308 5582 map->num_domains = 1;
81062a36 5583
5551b113 5584 /* info->size is only int so use the 'size' parameter instead */
b53bfba6 5585 num_data_stripes = size_per_member / info_to_blocks_per_strip(info);
5551b113
CA		 5586 num_data_stripes /= map->num_domains;
5587 set_num_data_stripes(map, num_data_stripes);
ef6ffade 5588
44490938
MD		 5589 size_per_member += NUM_BLOCKS_DIRTY_STRIPE_REGION;
5590 set_blocks_per_member(map, info_to_blocks_per_member(info,
5591 size_per_member /
5592 BLOCKS_PER_KB));
5593
c2c087e6
DW		 5594 map->num_members = info->raid_disks;
5595 for (i = 0; i < map->num_members; i++) {
5596 /* initialized in add_to_super */
4eb26970 5597 set_imsm_ord_tbl_ent(map, i, IMSM_ORD_REBUILD);
c2c087e6 5598 }
949c47a0 5599 mpb->num_raid_devs++;
2a24dc1b
PB		 5600 mpb->num_raid_devs_created++;
5601 dev->my_vol_raid_dev_num = mpb->num_raid_devs_created;
ba2de7ba 5602
b7580566 5603 if (s->consistency_policy <= CONSISTENCY_POLICY_RESYNC) {
c2462068 5604 dev->rwh_policy = RWH_MULTIPLE_OFF;
2432ce9b 5605 } else if (s->consistency_policy == CONSISTENCY_POLICY_PPL) {
c2462068 5606 dev->rwh_policy = RWH_MULTIPLE_DISTRIBUTED;
2432ce9b
AP		 5607 } else {
5608 free(dev);
5609 free(dv);
5610 pr_err("imsm does not support consistency policy %s\n",
5611 map_num(consistency_policies, s->consistency_policy));
5612 return 0;
5613 }
5614
ba2de7ba
DW		 5615 dv->dev = dev;
5616 dv->index = super->current_vol;
5617 dv->next = super->devlist;
5618 super->devlist = dv;
c2c087e6 5619
4d1313e9
DW		 5620 imsm_update_version_info(super);
5621
c2c087e6 5622 return 1;
cdddbdbc
DW		 5623}
5624
bf5a934a 5625static int init_super_imsm(struct supertype *st, mdu_array_info_t *info,
5308f117 5626 struct shape *s, char *name,
83cd1e97
N		 5627 char *homehost, int *uuid,
5628 unsigned long long data_offset)
bf5a934a
DW		 5629{
5630 /* This is primarily called by Create when creating a new array.
5631 * We will then get add_to_super called for each component, and then
5632 * write_init_super called to write it out to each device.
5633 * For IMSM, Create can create on fresh devices or on a pre-existing
5634 * array.
5635 * To create on a pre-existing array a different method will be called.
5636 * This one is just for fresh drives.
5637 */
5638 struct intel_super *super;
5639 struct imsm_super *mpb;
5640 size_t mpb_size;
4d1313e9 5641 char *version;
bf5a934a 5642
83cd1e97 5643 if (data_offset != INVALID_SECTORS) {
ed503f89 5644 pr_err("data-offset not supported by imsm\n");
83cd1e97
N		 5645 return 0;
5646 }
5647
bf5a934a 5648 if (st->sb)
5308f117 5649 return init_super_imsm_volume(st, info, s, name, homehost, uuid,
83cd1e97 5650 data_offset);
e683ca88
DW		 5651
5652 if (info)
5653 mpb_size = disks_to_mpb_size(info->nr_disks);
5654 else
f36a9ecd 5655 mpb_size = MAX_SECTOR_SIZE;
bf5a934a 5656
49133e57 5657 super = alloc_super();
f36a9ecd
PB		 5658 if (super &&
5659 posix_memalign(&super->buf, MAX_SECTOR_SIZE, mpb_size) != 0) {
8d67477f 5660 free_imsm(super);
e683ca88
DW		 5661 super = NULL;
5662 }
5663 if (!super) {
1ade5cc1 5664 pr_err("could not allocate superblock\n");
bf5a934a
DW		 5665 return 0;
5666 }
de44e46f
PB		 5667 if (posix_memalign(&super->migr_rec_buf, MAX_SECTOR_SIZE,
5668 MIGR_REC_BUF_SECTORS*MAX_SECTOR_SIZE) != 0) {
1ade5cc1 5669 pr_err("could not allocate migr_rec buffer\n");
8e59f3d8 5670 free(super->buf);
8d67477f 5671 free_imsm(super);
8e59f3d8
AK		 5672 return 0;
5673 }
e683ca88 5674 memset(super->buf, 0, mpb_size);
ef649044 5675 mpb = super->buf;
e683ca88
DW		 5676 mpb->mpb_size = __cpu_to_le32(mpb_size);
5677 st->sb = super;
5678
5679 if (info == NULL) {
5680 /* zeroing superblock */
5681 return 0;
5682 }
bf5a934a 5683
4d1313e9
DW		 5684 mpb->attributes = MPB_ATTRIB_CHECKSUM_VERIFY;
5685
5686 version = (char *) mpb->sig;
5687 strcpy(version, MPB_SIGNATURE);
5688 version += strlen(MPB_SIGNATURE);
5689 strcpy(version, MPB_VERSION_RAID0);
bf5a934a 5690
bf5a934a
DW		 5691 return 1;
5692}
5693
f2cc4f7d
AO		 5694static int drive_validate_sector_size(struct intel_super *super, struct dl *dl)
5695{
5696 unsigned int member_sector_size;
5697
5698 if (dl->fd < 0) {
5699 pr_err("Invalid file descriptor for %s\n", dl->devname);
5700 return 0;
5701 }
5702
5703 if (!get_dev_sector_size(dl->fd, dl->devname, &member_sector_size))
5704 return 0;
5705 if (member_sector_size != super->sector_size)
5706 return 0;
5707 return 1;
5708}
5709
f20c3968 5710static int add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk,
bf5a934a
DW		 5711 int fd, char *devname)
5712{
5713 struct intel_super *super = st->sb;
d23fe947 5714 struct imsm_super *mpb = super->anchor;
3960e579 5715 struct imsm_disk *_disk;
bf5a934a
DW		 5716 struct imsm_dev *dev;
5717 struct imsm_map *map;
3960e579 5718 struct dl *dl, *df;
4eb26970 5719 int slot;
bf5a934a 5720
949c47a0 5721 dev = get_imsm_dev(super, super->current_vol);
238c0a71 5722 map = get_imsm_map(dev, MAP_0);
bf5a934a 5723
208933a7 5724 if (! (dk->state & (1<<MD_DISK_SYNC))) {
e7b84f9d 5725 pr_err("%s: Cannot add spare devices to IMSM volume\n",
208933a7
N		 5726 devname);
5727 return 1;
5728 }
5729
efb30e7f
DW		 5730 if (fd == -1) {
5731 /* we're doing autolayout so grab the pre-marked (in
5732 * validate_geometry) raid_disk
5733 */
5734 for (dl = super->disks; dl; dl = dl->next)
5735 if (dl->raiddisk == dk->raid_disk)
5736 break;
5737 } else {
5738 for (dl = super->disks; dl ; dl = dl->next)
5739 if (dl->major == dk->major &&
5740 dl->minor == dk->minor)
5741 break;
5742 }
d23fe947 5743
208933a7 5744 if (!dl) {
e7b84f9d 5745 pr_err("%s is not a member of the same container\n", devname);
f20c3968 5746 return 1;
208933a7 5747 }
bf5a934a 5748
59632db9
MZ		 5749 if (mpb->num_disks == 0)
5750 if (!get_dev_sector_size(dl->fd, dl->devname,
5751 &super->sector_size))
5752 return 1;
5753
f2cc4f7d
AO		 5754 if (!drive_validate_sector_size(super, dl)) {
5755 pr_err("Combining drives of different sector size in one volume is not allowed\n");
5756 return 1;
5757 }
5758
d23fe947
DW		 5759 /* add a pristine spare to the metadata */
5760 if (dl->index < 0) {
5761 dl->index = super->anchor->num_disks;
5762 super->anchor->num_disks++;
5763 }
4eb26970
DW		 5764 /* Check the device has not already been added */
5765 slot = get_imsm_disk_slot(map, dl->index);
5766 if (slot >= 0 &&
238c0a71 5767 (get_imsm_ord_tbl_ent(dev, slot, MAP_X) & IMSM_ORD_REBUILD) == 0) {
e7b84f9d 5768 pr_err("%s has been included in this array twice\n",
4eb26970
DW		 5769 devname);
5770 return 1;
5771 }
656b6b5a 5772 set_imsm_ord_tbl_ent(map, dk->raid_disk, dl->index);
ee5aad5a 5773 dl->disk.status = CONFIGURED_DISK;
d23fe947 5774
3960e579
DW		 5775 /* update size of 'missing' disks to be at least as large as the
5776 * largest acitve member (we only have dummy missing disks when
5777 * creating the first volume)
5778 */
5779 if (super->current_vol == 0) {
5780 for (df = super->missing; df; df = df->next) {
5551b113
CA		 5781 if (total_blocks(&dl->disk) > total_blocks(&df->disk))
5782 set_total_blocks(&df->disk, total_blocks(&dl->disk));
3960e579
DW		 5783 _disk = __get_imsm_disk(mpb, df->index);
5784 *_disk = df->disk;
5785 }
5786 }
5787
5788 /* refresh unset/failed slots to point to valid 'missing' entries */
5789 for (df = super->missing; df; df = df->next)
5790 for (slot = 0; slot < mpb->num_disks; slot++) {
238c0a71 5791 __u32 ord = get_imsm_ord_tbl_ent(dev, slot, MAP_X);
3960e579
DW		 5792
5793 if ((ord & IMSM_ORD_REBUILD) == 0)
5794 continue;
5795 set_imsm_ord_tbl_ent(map, slot, df->index | IMSM_ORD_REBUILD);
1ace8403 5796 if (is_gen_migration(dev)) {
238c0a71
AK		 5797 struct imsm_map *map2 = get_imsm_map(dev,
5798 MAP_1);
0a108d63 5799 int slot2 = get_imsm_disk_slot(map2, df->index);
089f9d79 5800 if (slot2 < map2->num_members && slot2 >= 0) {
1ace8403 5801 __u32 ord2 = get_imsm_ord_tbl_ent(dev,
238c0a71
AK		 5802 slot2,
5803 MAP_1);
1ace8403
AK		 5804 if ((unsigned)df->index ==
5805 ord_to_idx(ord2))
5806 set_imsm_ord_tbl_ent(map2,
0a108d63 5807 slot2,
1ace8403
AK		 5808 df->index |
5809 IMSM_ORD_REBUILD);
5810 }
5811 }
3960e579
DW		 5812 dprintf("set slot:%d to missing disk:%d\n", slot, df->index);
5813 break;
5814 }
5815
d23fe947
DW		 5816 /* if we are creating the first raid device update the family number */
5817 if (super->current_vol == 0) {
5818 __u32 sum;
5819 struct imsm_dev *_dev = __get_imsm_dev(mpb, 0);
d23fe947 5820
3960e579 5821 _disk = __get_imsm_disk(mpb, dl->index);
791b666a 5822 if (!_dev || !_disk) {
e7b84f9d 5823 pr_err("BUG mpb setup error\n");
791b666a
AW		 5824 return 1;
5825 }
d23fe947
DW		 5826 *_dev = *dev;
5827 *_disk = dl->disk;
148acb7b
DW		 5828 sum = random32();
5829 sum += __gen_imsm_checksum(mpb);
d23fe947 5830 mpb->family_num = __cpu_to_le32(sum);
148acb7b 5831 mpb->orig_family_num = mpb->family_num;
e48aed3c 5832 mpb->creation_time = __cpu_to_le64((__u64)time(NULL));
d23fe947 5833 }
ca0748fa 5834 super->current_disk = dl;
f20c3968 5835 return 0;
bf5a934a
DW		 5836}
5837
a8619d23
AK		 5838/* mark_spare()
5839 * Function marks disk as spare and restores disk serial
5840 * in case it was previously marked as failed by takeover operation
5841 * reruns:
5842 * -1 : critical error
5843 * 0 : disk is marked as spare but serial is not set
5844 * 1 : success
5845 */
5846int mark_spare(struct dl *disk)
5847{
5848 __u8 serial[MAX_RAID_SERIAL_LEN];
5849 int ret_val = -1;
5850
5851 if (!disk)
5852 return ret_val;
5853
5854 ret_val = 0;
6da53c0e 5855 if (!imsm_read_serial(disk->fd, NULL, serial, MAX_RAID_SERIAL_LEN)) {
a8619d23
AK		 5856 /* Restore disk serial number, because takeover marks disk
5857 * as failed and adds to serial ':0' before it becomes
5858 * a spare disk.
5859 */
5860 serialcpy(disk->serial, serial);
5861 serialcpy(disk->disk.serial, serial);
5862 ret_val = 1;
5863 }
5864 disk->disk.status = SPARE_DISK;
5865 disk->index = -1;
5866
5867 return ret_val;
5868}
88654014 5869
12724c01
TM		 5870
5871static int write_super_imsm_spare(struct intel_super *super, struct dl *d);
5872
f20c3968 5873static int add_to_super_imsm(struct supertype *st, mdu_disk_info_t *dk,
72ca9bcf
N		 5874 int fd, char *devname,
5875 unsigned long long data_offset)
cdddbdbc 5876{
c2c087e6 5877 struct intel_super *super = st->sb;
c2c087e6
DW		 5878 struct dl *dd;
5879 unsigned long long size;
fa7bb6f8 5880 unsigned int member_sector_size;
f2f27e63 5881 __u32 id;
c2c087e6
DW		 5882 int rv;
5883 struct stat stb;
5884
88654014
LM		 5885 /* If we are on an RAID enabled platform check that the disk is
5886 * attached to the raid controller.
5887 * We do not need to test disks attachment for container based additions,
5888 * they shall be already tested when container was created/assembled.
88c32bb1 5889 */
d424212e 5890 rv = find_intel_hba_capability(fd, super, devname);
f2f5c343 5891 /* no orom/efi or non-intel hba of the disk */
f0f5a016
LM		 5892 if (rv != 0) {
5893 dprintf("capability: %p fd: %d ret: %d\n",
5894 super->orom, fd, rv);
5895 return 1;
88c32bb1
DW		 5896 }
5897
f20c3968
DW		 5898 if (super->current_vol >= 0)
5899 return add_to_super_imsm_volume(st, dk, fd, devname);
bf5a934a 5900
c2c087e6 5901 fstat(fd, &stb);
503975b9 5902 dd = xcalloc(sizeof(*dd), 1);
c2c087e6
DW		 5903 dd->major = major(stb.st_rdev);
5904 dd->minor = minor(stb.st_rdev);
503975b9 5905 dd->devname = devname ? xstrdup(devname) : NULL;
c2c087e6 5906 dd->fd = fd;
689c9bf3 5907 dd->e = NULL;
1a64be56 5908 dd->action = DISK_ADD;
6da53c0e 5909 rv = imsm_read_serial(fd, devname, dd->serial, MAX_RAID_SERIAL_LEN);
32ba9157 5910 if (rv) {
e7b84f9d 5911 pr_err("failed to retrieve scsi serial, aborting\n");
20bee0f8
PB		 5912 if (dd->devname)
5913 free(dd->devname);
949c47a0 5914 free(dd);
0030e8d6 5915 abort();
c2c087e6 5916 }
20bee0f8
PB		 5917 if (super->hba && ((super->hba->type == SYS_DEV_NVME) ||
5918 (super->hba->type == SYS_DEV_VMD))) {
5919 int i;
5920 char *devpath = diskfd_to_devpath(fd);
5921 char controller_path[PATH_MAX];
5922
5923 if (!devpath) {
5924 pr_err("failed to get devpath, aborting\n");
5925 if (dd->devname)
5926 free(dd->devname);
5927 free(dd);
5928 return 1;
5929 }
5930
5931 snprintf(controller_path, PATH_MAX-1, "%s/device", devpath);
5932 free(devpath);
5933
a8f3cfd5
MT		 5934 if (!imsm_is_nvme_supported(dd->fd, 1)) {
5935 if (dd->devname)
5936 free(dd->devname);
5937 free(dd);
5938 return 1;
5939 }
5940
20bee0f8
PB		 5941 if (devpath_to_vendor(controller_path) == 0x8086) {
5942 /*
5943 * If Intel's NVMe drive has serial ended with
5944 * "-A","-B","-1" or "-2" it means that this is "x8"
5945 * device (double drive on single PCIe card).
5946 * User should be warned about potential data loss.
5947 */
5948 for (i = MAX_RAID_SERIAL_LEN-1; i > 0; i--) {
5949 /* Skip empty character at the end */
5950 if (dd->serial[i] == 0)
5951 continue;
5952
5953 if (((dd->serial[i] == 'A') ||
5954 (dd->serial[i] == 'B') ||
5955 (dd->serial[i] == '1') ||
5956 (dd->serial[i] == '2')) &&
5957 (dd->serial[i-1] == '-'))
5958 pr_err("\tThe action you are about to take may put your data at risk.\n"
5959 "\tPlease note that x8 devices may consist of two separate x4 devices "
5960 "located on a single PCIe port.\n"
5961 "\tRAID 0 is the only supported configuration for this type of x8 device.\n");
5962 break;
5963 }
32716c51
PB		 5964 } else if (super->hba->type == SYS_DEV_VMD && super->orom &&
5965 !imsm_orom_has_tpv_support(super->orom)) {
5966 pr_err("\tPlatform configuration does not support non-Intel NVMe drives.\n"
8b751247 5967 "\tPlease refer to Intel(R) RSTe/VROC user guide.\n");
32716c51
PB		 5968 free(dd->devname);
5969 free(dd);
5970 return 1;
20bee0f8
PB		 5971 }
5972 }
c2c087e6 5973
c2c087e6 5974 get_dev_size(fd, NULL, &size);
fa7bb6f8
PB		 5975 get_dev_sector_size(fd, NULL, &member_sector_size);
5976
5977 if (super->sector_size == 0) {
5978 /* this a first device, so sector_size is not set yet */
5979 super->sector_size = member_sector_size;
fa7bb6f8
PB		 5980 }
5981
71e5411e 5982 /* clear migr_rec when adding disk to container */
85337573
AO		 5983 memset(super->migr_rec_buf, 0, MIGR_REC_BUF_SECTORS*MAX_SECTOR_SIZE);
5984 if (lseek64(fd, size - MIGR_REC_SECTOR_POSITION*member_sector_size,
de44e46f 5985 SEEK_SET) >= 0) {
466070ad 5986 if ((unsigned int)write(fd, super->migr_rec_buf,
85337573
AO		 5987 MIGR_REC_BUF_SECTORS*member_sector_size) !=
5988 MIGR_REC_BUF_SECTORS*member_sector_size)
71e5411e
PB		 5989 perror("Write migr_rec failed");
5990 }
5991
c2c087e6 5992 size /= 512;
1f24f035 5993 serialcpy(dd->disk.serial, dd->serial);
5551b113
CA		 5994 set_total_blocks(&dd->disk, size);
5995 if (__le32_to_cpu(dd->disk.total_blocks_hi) > 0) {
5996 struct imsm_super *mpb = super->anchor;
5997 mpb->attributes |= MPB_ATTRIB_2TB_DISK;
5998 }
a8619d23 5999 mark_spare(dd);
c2c087e6 6000 if (sysfs_disk_to_scsi_id(fd, &id) == 0)
b9f594fe 6001 dd->disk.scsi_id = __cpu_to_le32(id);
c2c087e6 6002 else
b9f594fe 6003 dd->disk.scsi_id = __cpu_to_le32(0);
43dad3d6
DW		 6004
6005 if (st->update_tail) {
1a64be56
LM		 6006 dd->next = super->disk_mgmt_list;
6007 super->disk_mgmt_list = dd;
43dad3d6 6008 } else {
12724c01
TM		 6009 /* this is called outside of mdmon
6010 * write initial spare metadata
6011 * mdmon will overwrite it.
6012 */
43dad3d6
DW		 6013 dd->next = super->disks;
6014 super->disks = dd;
12724c01 6015 write_super_imsm_spare(super, dd);
43dad3d6 6016 }
f20c3968
DW		 6017
6018 return 0;
cdddbdbc
DW		 6019}
6020
1a64be56
LM		 6021static int remove_from_super_imsm(struct supertype *st, mdu_disk_info_t *dk)
6022{
6023 struct intel_super *super = st->sb;
6024 struct dl *dd;
6025
6026 /* remove from super works only in mdmon - for communication
6027 * manager - monitor. Check if communication memory buffer
6028 * is prepared.
6029 */
6030 if (!st->update_tail) {
1ade5cc1 6031 pr_err("shall be used in mdmon context only\n");
1a64be56
LM		 6032 return 1;
6033 }
503975b9 6034 dd = xcalloc(1, sizeof(*dd));
1a64be56
LM		 6035 dd->major = dk->major;
6036 dd->minor = dk->minor;
1a64be56 6037 dd->fd = -1;
a8619d23 6038 mark_spare(dd);
1a64be56
LM		 6039 dd->action = DISK_REMOVE;
6040
6041 dd->next = super->disk_mgmt_list;
6042 super->disk_mgmt_list = dd;
6043
1a64be56
LM		 6044 return 0;
6045}
6046
f796af5d
DW		 6047static int store_imsm_mpb(int fd, struct imsm_super *mpb);
6048
6049static union {
f36a9ecd 6050 char buf[MAX_SECTOR_SIZE];
f796af5d 6051 struct imsm_super anchor;
f36a9ecd 6052} spare_record __attribute__ ((aligned(MAX_SECTOR_SIZE)));
c2c087e6 6053
12724c01
TM		 6054
6055static int write_super_imsm_spare(struct intel_super *super, struct dl *d)
d23fe947 6056{
d23fe947 6057 struct imsm_super *mpb = super->anchor;
f796af5d 6058 struct imsm_super *spare = &spare_record.anchor;
d23fe947 6059 __u32 sum;
12724c01
TM		 6060
6061 if (d->index != -1)
6062 return 1;
d23fe947 6063
68641cdb
JS		 6064 spare->mpb_size = __cpu_to_le32(sizeof(struct imsm_super));
6065 spare->generation_num = __cpu_to_le32(1UL);
f796af5d 6066 spare->attributes = MPB_ATTRIB_CHECKSUM_VERIFY;
68641cdb
JS		 6067 spare->num_disks = 1;
6068 spare->num_raid_devs = 0;
6069 spare->cache_size = mpb->cache_size;
6070 spare->pwr_cycle_count = __cpu_to_le32(1);
f796af5d
DW		 6071
6072 snprintf((char *) spare->sig, MAX_SIGNATURE_LENGTH,
6073 MPB_SIGNATURE MPB_VERSION_RAID0);
d23fe947 6074
12724c01
TM		 6075 spare->disk[0] = d->disk;
6076 if (__le32_to_cpu(d->disk.total_blocks_hi) > 0)
6077 spare->attributes |= MPB_ATTRIB_2TB_DISK;
6078
6079 if (super->sector_size == 4096)
6080 convert_to_4k_imsm_disk(&spare->disk[0]);
d23fe947 6081
12724c01
TM		 6082 sum = __gen_imsm_checksum(spare);
6083 spare->family_num = __cpu_to_le32(sum);
6084 spare->orig_family_num = 0;
6085 sum = __gen_imsm_checksum(spare);
6086 spare->check_sum = __cpu_to_le32(sum);
027c374f 6087
12724c01
TM		 6088 if (store_imsm_mpb(d->fd, spare)) {
6089 pr_err("failed for device %d:%d %s\n",
6090 d->major, d->minor, strerror(errno));
6091 return 1;
6092 }
6093
6094 return 0;
6095}
6096/* spare records have their own family number and do not have any defined raid
6097 * devices
6098 */
6099static int write_super_imsm_spares(struct intel_super *super, int doclose)
6100{
6101 struct dl *d;
f36a9ecd 6102
12724c01
TM		 6103 for (d = super->disks; d; d = d->next) {
6104 if (d->index != -1)
6105 continue;
d23fe947 6106
12724c01 6107 if (write_super_imsm_spare(super, d))
e74255d9 6108 return 1;
12724c01 6109
d23fe947
DW		 6110 if (doclose) {
6111 close(d->fd);
6112 d->fd = -1;
6113 }
6114 }
6115
e74255d9 6116 return 0;
d23fe947
DW		 6117}
6118
36988a3d 6119static int write_super_imsm(struct supertype *st, int doclose)
cdddbdbc 6120{
36988a3d 6121 struct intel_super *super = st->sb;
f36a9ecd 6122 unsigned int sector_size = super->sector_size;
949c47a0 6123 struct imsm_super *mpb = super->anchor;
c2c087e6
DW		 6124 struct dl *d;
6125 __u32 generation;
6126 __u32 sum;
d23fe947 6127 int spares = 0;
949c47a0 6128 int i;
a48ac0a8 6129 __u32 mpb_size = sizeof(struct imsm_super) - sizeof(struct imsm_disk);
36988a3d 6130 int num_disks = 0;
146c6260 6131 int clear_migration_record = 1;
bbab0940 6132 __u32 bbm_log_size;
cdddbdbc 6133
c2c087e6
DW		 6134 /* 'generation' is incremented everytime the metadata is written */
6135 generation = __le32_to_cpu(mpb->generation_num);
6136 generation++;
6137 mpb->generation_num = __cpu_to_le32(generation);
6138
148acb7b
DW		 6139 /* fix up cases where previous mdadm releases failed to set
6140 * orig_family_num
6141 */
6142 if (mpb->orig_family_num == 0)
6143 mpb->orig_family_num = mpb->family_num;
6144
d23fe947 6145 for (d = super->disks; d; d = d->next) {
8796fdc4 6146 if (d->index == -1)
d23fe947 6147 spares++;
36988a3d 6148 else {
d23fe947 6149 mpb->disk[d->index] = d->disk;
36988a3d
AK		 6150 num_disks++;
6151 }
d23fe947 6152 }
36988a3d 6153 for (d = super->missing; d; d = d->next) {
47ee5a45 6154 mpb->disk[d->index] = d->disk;
36988a3d
AK		 6155 num_disks++;
6156 }
6157 mpb->num_disks = num_disks;
6158 mpb_size += sizeof(struct imsm_disk) * mpb->num_disks;
b9f594fe 6159
949c47a0
DW		 6160 for (i = 0; i < mpb->num_raid_devs; i++) {
6161 struct imsm_dev *dev = __get_imsm_dev(mpb, i);
36988a3d
AK		 6162 struct imsm_dev *dev2 = get_imsm_dev(super, i);
6163 if (dev && dev2) {
6164 imsm_copy_dev(dev, dev2);
6165 mpb_size += sizeof_imsm_dev(dev, 0);
6166 }
146c6260
AK		 6167 if (is_gen_migration(dev2))
6168 clear_migration_record = 0;
949c47a0 6169 }
bbab0940
TM		 6170
6171 bbm_log_size = get_imsm_bbm_log_size(super->bbm_log);
6172
6173 if (bbm_log_size) {
6174 memcpy((void *)mpb + mpb_size, super->bbm_log, bbm_log_size);
6175 mpb->attributes |= MPB_ATTRIB_BBM;
6176 } else
6177 mpb->attributes &= ~MPB_ATTRIB_BBM;
6178
6179 super->anchor->bbm_log_size = __cpu_to_le32(bbm_log_size);
6180 mpb_size += bbm_log_size;
a48ac0a8 6181 mpb->mpb_size = __cpu_to_le32(mpb_size);
949c47a0 6182
bbab0940
TM		 6183#ifdef DEBUG
6184 assert(super->len == 0 || mpb_size <= super->len);
6185#endif
6186
c2c087e6 6187 /* recalculate checksum */
949c47a0 6188 sum = __gen_imsm_checksum(mpb);
c2c087e6
DW		 6189 mpb->check_sum = __cpu_to_le32(sum);
6190
51d83f5d
AK		 6191 if (super->clean_migration_record_by_mdmon) {
6192 clear_migration_record = 1;
6193 super->clean_migration_record_by_mdmon = 0;
6194 }
146c6260 6195 if (clear_migration_record)
de44e46f 6196 memset(super->migr_rec_buf, 0,
85337573 6197 MIGR_REC_BUF_SECTORS*MAX_SECTOR_SIZE);
146c6260 6198
f36a9ecd
PB		 6199 if (sector_size == 4096)
6200 convert_to_4k(super);
6201
d23fe947 6202 /* write the mpb for disks that compose raid devices */
c2c087e6 6203 for (d = super->disks; d ; d = d->next) {
86c54047 6204 if (d->index < 0 || is_failed(&d->disk))
d23fe947 6205 continue;
30602f53 6206
146c6260
AK		 6207 if (clear_migration_record) {
6208 unsigned long long dsize;
6209
6210 get_dev_size(d->fd, NULL, &dsize);
de44e46f
PB		 6211 if (lseek64(d->fd, dsize - sector_size,
6212 SEEK_SET) >= 0) {
466070ad
PB		 6213 if ((unsigned int)write(d->fd,
6214 super->migr_rec_buf,
de44e46f
PB		 6215 MIGR_REC_BUF_SECTORS*sector_size) !=
6216 MIGR_REC_BUF_SECTORS*sector_size)
9e2d750d 6217 perror("Write migr_rec failed");
146c6260
AK		 6218 }
6219 }
51d83f5d
AK		 6220
6221 if (store_imsm_mpb(d->fd, mpb))
6222 fprintf(stderr,
1ade5cc1
N		 6223 "failed for device %d:%d (fd: %d)%s\n",
6224 d->major, d->minor,
51d83f5d
AK		 6225 d->fd, strerror(errno));
6226
c2c087e6
DW		 6227 if (doclose) {
6228 close(d->fd);
6229 d->fd = -1;
6230 }
6231 }
6232
d23fe947
DW		 6233 if (spares)
6234 return write_super_imsm_spares(super, doclose);
6235
e74255d9 6236 return 0;
c2c087e6
DW		 6237}
6238
9b1fb677 6239static int create_array(struct supertype *st, int dev_idx)
43dad3d6
DW		 6240{
6241 size_t len;
6242 struct imsm_update_create_array *u;
6243 struct intel_super *super = st->sb;
9b1fb677 6244 struct imsm_dev *dev = get_imsm_dev(super, dev_idx);
238c0a71 6245 struct imsm_map *map = get_imsm_map(dev, MAP_0);
54c2c1ea
DW		 6246 struct disk_info *inf;
6247 struct imsm_disk *disk;
6248 int i;
43dad3d6 6249
54c2c1ea
DW		 6250 len = sizeof(*u) - sizeof(*dev) + sizeof_imsm_dev(dev, 0) +
6251 sizeof(*inf) * map->num_members;
503975b9 6252 u = xmalloc(len);
43dad3d6 6253 u->type = update_create_array;
9b1fb677 6254 u->dev_idx = dev_idx;
43dad3d6 6255 imsm_copy_dev(&u->dev, dev);
54c2c1ea
DW		 6256 inf = get_disk_info(u);
6257 for (i = 0; i < map->num_members; i++) {
238c0a71 6258 int idx = get_imsm_disk_idx(dev, i, MAP_X);
9b1fb677 6259
54c2c1ea 6260 disk = get_imsm_disk(super, idx);
1ca5c8e0
N		 6261 if (!disk)
6262 disk = get_imsm_missing(super, idx);
54c2c1ea
DW		 6263 serialcpy(inf[i].serial, disk->serial);
6264 }
43dad3d6
DW		 6265 append_metadata_update(st, u, len);
6266
6267 return 0;
6268}
6269
1a64be56 6270static int mgmt_disk(struct supertype *st)
43dad3d6
DW		 6271{
6272 struct intel_super *super = st->sb;
6273 size_t len;
1a64be56 6274 struct imsm_update_add_remove_disk *u;
43dad3d6 6275
1a64be56 6276 if (!super->disk_mgmt_list)
43dad3d6
DW		 6277 return 0;
6278
6279 len = sizeof(*u);
503975b9 6280 u = xmalloc(len);
1a64be56 6281 u->type = update_add_remove_disk;
43dad3d6
DW		 6282 append_metadata_update(st, u, len);
6283
6284 return 0;
6285}
2432ce9b
AP		 6286
6287__u32 crc32c_le(__u32 crc, unsigned char const *p, size_t len);
6288
e397cefe
AP		 6289static int write_ppl_header(unsigned long long ppl_sector, int fd, void *buf)
6290{
6291 struct ppl_header *ppl_hdr = buf;
6292 int ret;
6293
6294 ppl_hdr->checksum = __cpu_to_le32(~crc32c_le(~0, buf, PPL_HEADER_SIZE));
6295
6296 if (lseek64(fd, ppl_sector * 512, SEEK_SET) < 0) {
6297 ret = -errno;
6298 perror("Failed to seek to PPL header location");
6299 return ret;
6300 }
6301
6302 if (write(fd, buf, PPL_HEADER_SIZE) != PPL_HEADER_SIZE) {
6303 ret = -errno;
6304 perror("Write PPL header failed");
6305 return ret;
6306 }
6307
6308 fsync(fd);
6309
6310 return 0;
6311}
6312
2432ce9b
AP		 6313static int write_init_ppl_imsm(struct supertype *st, struct mdinfo *info, int fd)
6314{
6315 struct intel_super *super = st->sb;
6316 void *buf;
6317 struct ppl_header *ppl_hdr;
6318 int ret;
6319
b2514242
PB		 6320 /* first clear entire ppl space */
6321 ret = zero_disk_range(fd, info->ppl_sector, info->ppl_size);
6322 if (ret)
6323 return ret;
6324
6325 ret = posix_memalign(&buf, MAX_SECTOR_SIZE, PPL_HEADER_SIZE);
2432ce9b
AP		 6326 if (ret) {
6327 pr_err("Failed to allocate PPL header buffer\n");
e397cefe 6328 return -ret;
2432ce9b
AP		 6329 }
6330
6331 memset(buf, 0, PPL_HEADER_SIZE);
6332 ppl_hdr = buf;
6333 memset(ppl_hdr->reserved, 0xff, PPL_HDR_RESERVED);
6334 ppl_hdr->signature = __cpu_to_le32(super->anchor->orig_family_num);
b23d0750
AP		 6335
6336 if (info->mismatch_cnt) {
6337 /*
6338 * We are overwriting an invalid ppl. Make one entry with wrong
6339 * checksum to prevent the kernel from skipping resync.
6340 */
6341 ppl_hdr->entries_count = __cpu_to_le32(1);
6342 ppl_hdr->entries[0].checksum = ~0;
6343 }
6344
e397cefe 6345 ret = write_ppl_header(info->ppl_sector, fd, buf);
2432ce9b
AP		 6346
6347 free(buf);
6348 return ret;
6349}
6350
e397cefe
AP		 6351static int is_rebuilding(struct imsm_dev *dev);
6352
2432ce9b
AP		 6353static int validate_ppl_imsm(struct supertype *st, struct mdinfo *info,
6354 struct mdinfo *disk)
6355{
6356 struct intel_super *super = st->sb;
6357 struct dl *d;
e397cefe 6358 void *buf_orig, *buf, *buf_prev = NULL;
2432ce9b 6359 int ret = 0;
e397cefe 6360 struct ppl_header *ppl_hdr = NULL;
2432ce9b
AP		 6361 __u32 crc;
6362 struct imsm_dev *dev;
2432ce9b 6363 __u32 idx;
44b6b876
PB		 6364 unsigned int i;
6365 unsigned long long ppl_offset = 0;
6366 unsigned long long prev_gen_num = 0;
2432ce9b
AP		 6367
6368 if (disk->disk.raid_disk < 0)
6369 return 0;
6370
2432ce9b 6371 dev = get_imsm_dev(super, info->container_member);
2fc0fc63 6372 idx = get_imsm_disk_idx(dev, disk->disk.raid_disk, MAP_0);
2432ce9b
AP		 6373 d = get_imsm_dl_disk(super, idx);
6374
6375 if (!d || d->index < 0 || is_failed(&d->disk))
e397cefe
AP		 6376 return 0;
6377
6378 if (posix_memalign(&buf_orig, MAX_SECTOR_SIZE, PPL_HEADER_SIZE * 2)) {
6379 pr_err("Failed to allocate PPL header buffer\n");
6380 return -1;
6381 }
6382 buf = buf_orig;
2432ce9b 6383
44b6b876
PB		 6384 ret = 1;
6385 while (ppl_offset < MULTIPLE_PPL_AREA_SIZE_IMSM) {
e397cefe
AP		 6386 void *tmp;
6387
44b6b876 6388 dprintf("Checking potential PPL at offset: %llu\n", ppl_offset);
2432ce9b 6389
44b6b876
PB		 6390 if (lseek64(d->fd, info->ppl_sector * 512 + ppl_offset,
6391 SEEK_SET) < 0) {
6392 perror("Failed to seek to PPL header location");
6393 ret = -1;
e397cefe 6394 break;
44b6b876 6395 }
2432ce9b 6396
44b6b876
PB		 6397 if (read(d->fd, buf, PPL_HEADER_SIZE) != PPL_HEADER_SIZE) {
6398 perror("Read PPL header failed");
6399 ret = -1;
e397cefe 6400 break;
44b6b876 6401 }
2432ce9b 6402
44b6b876 6403 ppl_hdr = buf;
2432ce9b 6404
44b6b876
PB		 6405 crc = __le32_to_cpu(ppl_hdr->checksum);
6406 ppl_hdr->checksum = 0;
6407
6408 if (crc != ~crc32c_le(~0, buf, PPL_HEADER_SIZE)) {
6409 dprintf("Wrong PPL header checksum on %s\n",
6410 d->devname);
e397cefe 6411 break;
44b6b876
PB		 6412 }
6413
6414 if (prev_gen_num > __le64_to_cpu(ppl_hdr->generation)) {
6415 /* previous was newest, it was already checked */
e397cefe 6416 break;
44b6b876
PB		 6417 }
6418
6419 if ((__le32_to_cpu(ppl_hdr->signature) !=
6420 super->anchor->orig_family_num)) {
6421 dprintf("Wrong PPL header signature on %s\n",
6422 d->devname);
6423 ret = 1;
e397cefe 6424 break;
44b6b876
PB		 6425 }
6426
6427 ret = 0;
6428 prev_gen_num = __le64_to_cpu(ppl_hdr->generation);
2432ce9b 6429
44b6b876
PB		 6430 ppl_offset += PPL_HEADER_SIZE;
6431 for (i = 0; i < __le32_to_cpu(ppl_hdr->entries_count); i++)
6432 ppl_offset +=
6433 __le32_to_cpu(ppl_hdr->entries[i].pp_size);
e397cefe
AP		 6434
6435 if (!buf_prev)
6436 buf_prev = buf + PPL_HEADER_SIZE;
6437 tmp = buf_prev;
6438 buf_prev = buf;
6439 buf = tmp;
2432ce9b
AP		 6440 }
6441
e397cefe
AP		 6442 if (buf_prev) {
6443 buf = buf_prev;
6444 ppl_hdr = buf_prev;
6445 }
2432ce9b 6446
54148aba
PB		 6447 /*
6448 * Update metadata to use mutliple PPLs area (1MB).
6449 * This is done once for all RAID members
6450 */
6451 if (info->consistency_policy == CONSISTENCY_POLICY_PPL &&
6452 info->ppl_size != (MULTIPLE_PPL_AREA_SIZE_IMSM >> 9)) {
6453 char subarray[20];
6454 struct mdinfo *member_dev;
6455
6456 sprintf(subarray, "%d", info->container_member);
6457
6458 if (mdmon_running(st->container_devnm))
6459 st->update_tail = &st->updates;
6460
6461 if (st->ss->update_subarray(st, subarray, "ppl", NULL)) {
6462 pr_err("Failed to update subarray %s\n",
6463 subarray);
6464 } else {
6465 if (st->update_tail)
6466 flush_metadata_updates(st);
6467 else
6468 st->ss->sync_metadata(st);
6469 info->ppl_size = (MULTIPLE_PPL_AREA_SIZE_IMSM >> 9);
6470 for (member_dev = info->devs; member_dev;
6471 member_dev = member_dev->next)
6472 member_dev->ppl_size =
6473 (MULTIPLE_PPL_AREA_SIZE_IMSM >> 9);
6474 }
6475 }
6476
b23d0750 6477 if (ret == 1) {
2fc0fc63
AP		 6478 struct imsm_map *map = get_imsm_map(dev, MAP_X);
6479
50b9c10d
PB		 6480 if (map->map_state == IMSM_T_STATE_UNINITIALIZED ||
6481 (map->map_state == IMSM_T_STATE_NORMAL &&
2ec9d182 6482 !(dev->vol.dirty & RAIDVOL_DIRTY)) ||
e397cefe 6483 (is_rebuilding(dev) &&
2ec9d182
AP		 6484 dev->vol.curr_migr_unit == 0 &&
6485 get_imsm_disk_idx(dev, disk->disk.raid_disk, MAP_1) != idx))
b23d0750
AP		 6486 ret = st->ss->write_init_ppl(st, info, d->fd);
6487 else
6488 info->mismatch_cnt++;
e397cefe
AP		 6489 } else if (ret == 0 &&
6490 ppl_hdr->entries_count == 0 &&
6491 is_rebuilding(dev) &&
6492 info->resync_start == 0) {
6493 /*
6494 * The header has no entries - add a single empty entry and
6495 * rewrite the header to prevent the kernel from going into
6496 * resync after an interrupted rebuild.
6497 */
6498 ppl_hdr->entries_count = __cpu_to_le32(1);
6499 ret = write_ppl_header(info->ppl_sector, d->fd, buf);
b23d0750 6500 }
2432ce9b 6501
e397cefe
AP		 6502 free(buf_orig);
6503
2432ce9b
AP		 6504 return ret;
6505}
6506
2432ce9b
AP		 6507static int write_init_ppl_imsm_all(struct supertype *st, struct mdinfo *info)
6508{
6509 struct intel_super *super = st->sb;
6510 struct dl *d;
6511 int ret = 0;
6512
6513 if (info->consistency_policy != CONSISTENCY_POLICY_PPL ||
6514 info->array.level != 5)
6515 return 0;
6516
6517 for (d = super->disks; d ; d = d->next) {
6518 if (d->index < 0 || is_failed(&d->disk))
6519 continue;
6520
6521 ret = st->ss->write_init_ppl(st, info, d->fd);
6522 if (ret)
6523 break;
6524 }
6525
6526 return ret;
6527}
43dad3d6 6528
fbc42556
JR		 6529/*******************************************************************************
6530 * Function: write_init_bitmap_imsm_vol
6531 * Description: Write a bitmap header and prepares the area for the bitmap.
6532 * Parameters:
6533 * st : supertype information
6534 * vol_idx : the volume index to use
6535 *
6536 * Returns:
6537 * 0 : success
6538 * -1 : fail
6539 ******************************************************************************/
6540static int write_init_bitmap_imsm_vol(struct supertype *st, int vol_idx)
6541{
6542 struct intel_super *super = st->sb;
6543 int prev_current_vol = super->current_vol;
6544 struct dl *d;
6545 int ret = 0;
6546
6547 super->current_vol = vol_idx;
6548 for (d = super->disks; d; d = d->next) {
6549 if (d->index < 0 || is_failed(&d->disk))
6550 continue;
6551 ret = st->ss->write_bitmap(st, d->fd, NoUpdate);
6552 if (ret)
6553 break;
6554 }
6555 super->current_vol = prev_current_vol;
6556 return ret;
6557}
6558
6559/*******************************************************************************
6560 * Function: write_init_bitmap_imsm_all
6561 * Description: Write a bitmap header and prepares the area for the bitmap.
6562 * Operation is executed for volumes with CONSISTENCY_POLICY_BITMAP.
6563 * Parameters:
6564 * st : supertype information
6565 * info : info about the volume where the bitmap should be written
6566 * vol_idx : the volume index to use
6567 *
6568 * Returns:
6569 * 0 : success
6570 * -1 : fail
6571 ******************************************************************************/
6572static int write_init_bitmap_imsm_all(struct supertype *st, struct mdinfo *info,
6573 int vol_idx)
6574{
6575 int ret = 0;
6576
6577 if (info && (info->consistency_policy == CONSISTENCY_POLICY_BITMAP))
6578 ret = write_init_bitmap_imsm_vol(st, vol_idx);
6579
6580 return ret;
6581}
6582
c2c087e6
DW		 6583static int write_init_super_imsm(struct supertype *st)
6584{
9b1fb677
DW		 6585 struct intel_super *super = st->sb;
6586 int current_vol = super->current_vol;
2432ce9b
AP		 6587 int rv = 0;
6588 struct mdinfo info;
6589
6590 getinfo_super_imsm(st, &info, NULL);
9b1fb677
DW		 6591
6592 /* we are done with current_vol reset it to point st at the container */
6593 super->current_vol = -1;
6594
8273f55e 6595 if (st->update_tail) {
43dad3d6
DW		 6596 /* queue the recently created array / added disk
6597 * as a metadata update */
8273f55e 6598
43dad3d6 6599 /* determine if we are creating a volume or adding a disk */
9b1fb677 6600 if (current_vol < 0) {
1a64be56
LM		 6601 /* in the mgmt (add/remove) disk case we are running
6602 * in mdmon context, so don't close fd's
43dad3d6 6603 */
2432ce9b
AP		 6604 rv = mgmt_disk(st);
6605 } else {
fbc42556 6606 /* adding the second volume to the array */
2432ce9b 6607 rv = write_init_ppl_imsm_all(st, &info);
fbc42556
JR		 6608 if (!rv)
6609 rv = write_init_bitmap_imsm_all(st, &info, current_vol);
2432ce9b
AP		 6610 if (!rv)
6611 rv = create_array(st, current_vol);
6612 }
d682f344
N		 6613 } else {
6614 struct dl *d;
6615 for (d = super->disks; d; d = d->next)
ba728be7 6616 Kill(d->devname, NULL, 0, -1, 1);
fbc42556 6617 if (current_vol >= 0) {
2432ce9b 6618 rv = write_init_ppl_imsm_all(st, &info);
fbc42556
JR		 6619 if (!rv)
6620 rv = write_init_bitmap_imsm_all(st, &info, current_vol);
6621 }
6622
2432ce9b
AP		 6623 if (!rv)
6624 rv = write_super_imsm(st, 1);
d682f344 6625 }
2432ce9b
AP		 6626
6627 return rv;
cdddbdbc
DW		 6628}
6629
e683ca88 6630static int store_super_imsm(struct supertype *st, int fd)
cdddbdbc 6631{
e683ca88
DW		 6632 struct intel_super *super = st->sb;
6633 struct imsm_super *mpb = super ? super->anchor : NULL;
551c80c1 6634
e683ca88 6635 if (!mpb)
ad97895e
DW		 6636 return 1;
6637
f36a9ecd
PB		 6638 if (super->sector_size == 4096)
6639 convert_to_4k(super);
e683ca88 6640 return store_imsm_mpb(fd, mpb);
cdddbdbc
DW		 6641}
6642
cdddbdbc
DW		 6643static int validate_geometry_imsm_container(struct supertype *st, int level,
6644 int layout, int raiddisks, int chunk,
af4348dd
N		 6645 unsigned long long size,
6646 unsigned long long data_offset,
6647 char *dev,
2c514b71
NB		 6648 unsigned long long *freesize,
6649 int verbose)
cdddbdbc 6650{
c2c087e6
DW		 6651 int fd;
6652 unsigned long long ldsize;
594dc1b8 6653 struct intel_super *super;
f2f5c343 6654 int rv = 0;
cdddbdbc 6655
c2c087e6
DW		 6656 if (level != LEVEL_CONTAINER)
6657 return 0;
6658 if (!dev)
6659 return 1;
6660
6661 fd = open(dev, O_RDONLY|O_EXCL, 0);
6662 if (fd < 0) {
ba728be7 6663 if (verbose > 0)
e7b84f9d 6664 pr_err("imsm: Cannot open %s: %s\n",
2c514b71 6665 dev, strerror(errno));
c2c087e6
DW		 6666 return 0;
6667 }
6668 if (!get_dev_size(fd, dev, &ldsize)) {
6669 close(fd);
6670 return 0;
6671 }
f2f5c343
LM		 6672
6673 /* capabilities retrieve could be possible
6674 * note that there is no fd for the disks in array.
6675 */
6676 super = alloc_super();
8d67477f
TM		 6677 if (!super) {
6678 close(fd);
6679 return 0;
6680 }
fa7bb6f8
PB		 6681 if (!get_dev_sector_size(fd, NULL, &super->sector_size)) {
6682 close(fd);
6683 free_imsm(super);
6684 return 0;
6685 }
6686
ba728be7 6687 rv = find_intel_hba_capability(fd, super, verbose > 0 ? dev : NULL);
f2f5c343
LM		 6688 if (rv != 0) {
6689#if DEBUG
6690 char str[256];
6691 fd2devname(fd, str);
1ade5cc1 6692 dprintf("fd: %d %s orom: %p rv: %d raiddisk: %d\n",
f2f5c343
LM		 6693 fd, str, super->orom, rv, raiddisks);
6694#endif
6695 /* no orom/efi or non-intel hba of the disk */
6696 close(fd);
6697 free_imsm(super);
6698 return 0;
6699 }
c2c087e6 6700 close(fd);
9126b9a8
CA		 6701 if (super->orom) {
6702 if (raiddisks > super->orom->tds) {
6703 if (verbose)
7a862a02 6704 pr_err("%d exceeds maximum number of platform supported disks: %d\n",
9126b9a8
CA		 6705 raiddisks, super->orom->tds);
6706 free_imsm(super);
6707 return 0;
6708 }
6709 if ((super->orom->attr & IMSM_OROM_ATTR_2TB_DISK) == 0 &&
6710 (ldsize >> 9) >> 32 > 0) {
6711 if (verbose)
e7b84f9d 6712 pr_err("%s exceeds maximum platform supported size\n", dev);
9126b9a8
CA		 6713 free_imsm(super);
6714 return 0;
6715 }
f2f5c343 6716 }
c2c087e6 6717
af4348dd 6718 *freesize = avail_size_imsm(st, ldsize >> 9, data_offset);
f2f5c343 6719 free_imsm(super);
c2c087e6
DW		 6720
6721 return 1;
cdddbdbc
DW		 6722}
6723
0dcecb2e
DW		 6724static unsigned long long find_size(struct extent *e, int *idx, int num_extents)
6725{
6726 const unsigned long long base_start = e[*idx].start;
6727 unsigned long long end = base_start + e[*idx].size;
6728 int i;
6729
6730 if (base_start == end)
6731 return 0;
6732
6733 *idx = *idx + 1;
6734 for (i = *idx; i < num_extents; i++) {
6735 /* extend overlapping extents */
6736 if (e[i].start >= base_start &&
6737 e[i].start <= end) {
6738 if (e[i].size == 0)
6739 return 0;
6740 if (e[i].start + e[i].size > end)
6741 end = e[i].start + e[i].size;
6742 } else if (e[i].start > end) {
6743 *idx = i;
6744 break;
6745 }
6746 }
6747
6748 return end - base_start;
6749}
6750
6751static unsigned long long merge_extents(struct intel_super *super, int sum_extents)
6752{
6753 /* build a composite disk with all known extents and generate a new
6754 * 'maxsize' given the "all disks in an array must share a common start
6755 * offset" constraint
6756 */
503975b9 6757 struct extent *e = xcalloc(sum_extents, sizeof(*e));
0dcecb2e
DW		 6758 struct dl *dl;
6759 int i, j;
6760 int start_extent;
6761 unsigned long long pos;
b9d77223 6762 unsigned long long start = 0;
0dcecb2e
DW		 6763 unsigned long long maxsize;
6764 unsigned long reserve;
6765
0dcecb2e
DW		 6766 /* coalesce and sort all extents. also, check to see if we need to
6767 * reserve space between member arrays
6768 */
6769 j = 0;
6770 for (dl = super->disks; dl; dl = dl->next) {
6771 if (!dl->e)
6772 continue;
6773 for (i = 0; i < dl->extent_cnt; i++)
6774 e[j++] = dl->e[i];
6775 }
6776 qsort(e, sum_extents, sizeof(*e), cmp_extent);
6777
6778 /* merge extents */
6779 i = 0;
6780 j = 0;
6781 while (i < sum_extents) {
6782 e[j].start = e[i].start;
6783 e[j].size = find_size(e, &i, sum_extents);
6784 j++;
6785 if (e[j-1].size == 0)
6786 break;
6787 }
6788
6789 pos = 0;
6790 maxsize = 0;
6791 start_extent = 0;
6792 i = 0;
6793 do {
6794 unsigned long long esize;
6795
6796 esize = e[i].start - pos;
6797 if (esize >= maxsize) {
6798 maxsize = esize;
6799 start = pos;
6800 start_extent = i;
6801 }
6802 pos = e[i].start + e[i].size;
6803 i++;
6804 } while (e[i-1].size);
6805 free(e);
6806
a7dd165b
DW		 6807 if (maxsize == 0)
6808 return 0;
6809
6810 /* FIXME assumes volume at offset 0 is the first volume in a
6811 * container
6812 */
0dcecb2e
DW		 6813 if (start_extent > 0)
6814 reserve = IMSM_RESERVED_SECTORS; /* gap between raid regions */
6815 else
6816 reserve = 0;
6817
6818 if (maxsize < reserve)
a7dd165b 6819 return 0;
0dcecb2e 6820
5551b113 6821 super->create_offset = ~((unsigned long long) 0);
0dcecb2e 6822 if (start + reserve > super->create_offset)
a7dd165b 6823 return 0; /* start overflows create_offset */
0dcecb2e
DW		 6824 super->create_offset = start + reserve;
6825
6826 return maxsize - reserve;
6827}
6828
88c32bb1
DW		 6829static int is_raid_level_supported(const struct imsm_orom *orom, int level, int raiddisks)
6830{
6831 if (level < 0 || level == 6 || level == 4)
6832 return 0;
6833
6834 /* if we have an orom prevent invalid raid levels */
6835 if (orom)
6836 switch (level) {
6837 case 0: return imsm_orom_has_raid0(orom);
6838 case 1:
6839 if (raiddisks > 2)
6840 return imsm_orom_has_raid1e(orom);
1c556e92
DW		 6841 return imsm_orom_has_raid1(orom) && raiddisks == 2;
6842 case 10: return imsm_orom_has_raid10(orom) && raiddisks == 4;
6843 case 5: return imsm_orom_has_raid5(orom) && raiddisks > 2;
88c32bb1
DW		 6844 }
6845 else
6846 return 1; /* not on an Intel RAID platform so anything goes */
6847
6848 return 0;
6849}
6850
ca9de185
LM		 6851static int
6852active_arrays_by_format(char *name, char* hba, struct md_list **devlist,
6853 int dpa, int verbose)
6854{
6855 struct mdstat_ent *mdstat = mdstat_read(0, 0);
594dc1b8 6856 struct mdstat_ent *memb;
ca9de185
LM		 6857 int count = 0;
6858 int num = 0;
594dc1b8 6859 struct md_list *dv;
ca9de185
LM		 6860 int found;
6861
6862 for (memb = mdstat ; memb ; memb = memb->next) {
6863 if (memb->metadata_version &&
fc54fe7a 6864 (strncmp(memb->metadata_version, "external:", 9) == 0) &&
ca9de185
LM		 6865 (strcmp(&memb->metadata_version[9], name) == 0) &&
6866 !is_subarray(memb->metadata_version+9) &&
6867 memb->members) {
6868 struct dev_member *dev = memb->members;
6869 int fd = -1;
6870 while(dev && (fd < 0)) {
503975b9
N		 6871 char *path = xmalloc(strlen(dev->name) + strlen("/dev/") + 1);
6872 num = sprintf(path, "%s%s", "/dev/", dev->name);
6873 if (num > 0)
6874 fd = open(path, O_RDONLY, 0);
089f9d79 6875 if (num <= 0 || fd < 0) {
676e87a8 6876 pr_vrb("Cannot open %s: %s\n",
503975b9 6877 dev->name, strerror(errno));
ca9de185 6878 }
503975b9 6879 free(path);
ca9de185
LM		 6880 dev = dev->next;
6881 }
6882 found = 0;
089f9d79 6883 if (fd >= 0 && disk_attached_to_hba(fd, hba)) {
ca9de185
LM		 6884 struct mdstat_ent *vol;
6885 for (vol = mdstat ; vol ; vol = vol->next) {
089f9d79 6886 if (vol->active > 0 &&
ca9de185 6887 vol->metadata_version &&
9581efb1 6888 is_container_member(vol, memb->devnm)) {
ca9de185
LM		 6889 found++;
6890 count++;
6891 }
6892 }
6893 if (*devlist && (found < dpa)) {
503975b9 6894 dv = xcalloc(1, sizeof(*dv));
9581efb1
N		 6895 dv->devname = xmalloc(strlen(memb->devnm) + strlen("/dev/") + 1);
6896 sprintf(dv->devname, "%s%s", "/dev/", memb->devnm);
503975b9
N		 6897 dv->found = found;
6898 dv->used = 0;
6899 dv->next = *devlist;
6900 *devlist = dv;
ca9de185
LM		 6901 }
6902 }
6903 if (fd >= 0)
6904 close(fd);
6905 }
6906 }
6907 free_mdstat(mdstat);
6908 return count;
6909}
6910
6911#ifdef DEBUG_LOOP
6912static struct md_list*
6913get_loop_devices(void)
6914{
6915 int i;
6916 struct md_list *devlist = NULL;
594dc1b8 6917 struct md_list *dv;
ca9de185
LM		 6918
6919 for(i = 0; i < 12; i++) {
503975b9
N		 6920 dv = xcalloc(1, sizeof(*dv));
6921 dv->devname = xmalloc(40);
ca9de185
LM		 6922 sprintf(dv->devname, "/dev/loop%d", i);
6923 dv->next = devlist;
6924 devlist = dv;
6925 }
6926 return devlist;
6927}
6928#endif
6929
6930static struct md_list*
6931get_devices(const char *hba_path)
6932{
6933 struct md_list *devlist = NULL;
594dc1b8 6934 struct md_list *dv;
ca9de185
LM		 6935 struct dirent *ent;
6936 DIR *dir;
6937 int err = 0;
6938
6939#if DEBUG_LOOP
6940 devlist = get_loop_devices();
6941 return devlist;
6942#endif
6943 /* scroll through /sys/dev/block looking for devices attached to
6944 * this hba
6945 */
6946 dir = opendir("/sys/dev/block");
6947 for (ent = dir ? readdir(dir) : NULL; ent; ent = readdir(dir)) {
6948 int fd;
6949 char buf[1024];
6950 int major, minor;
6951 char *path = NULL;
6952 if (sscanf(ent->d_name, "%d:%d", &major, &minor) != 2)
6953 continue;
6954 path = devt_to_devpath(makedev(major, minor));
6955 if (!path)
6956 continue;
6957 if (!path_attached_to_hba(path, hba_path)) {
6958 free(path);
6959 path = NULL;
6960 continue;
6961 }
6962 free(path);
6963 path = NULL;
6964 fd = dev_open(ent->d_name, O_RDONLY);
6965 if (fd >= 0) {
6966 fd2devname(fd, buf);
6967 close(fd);
6968 } else {
e7b84f9d 6969 pr_err("cannot open device: %s\n",
ca9de185
LM		 6970 ent->d_name);
6971 continue;
6972 }
6973
503975b9
N		 6974 dv = xcalloc(1, sizeof(*dv));
6975 dv->devname = xstrdup(buf);
ca9de185
LM		 6976 dv->next = devlist;
6977 devlist = dv;
6978 }
6979 if (err) {
6980 while(devlist) {
6981 dv = devlist;
6982 devlist = devlist->next;
6983 free(dv->devname);
6984 free(dv);
6985 }
6986 }
562aa102 6987 closedir(dir);
ca9de185
LM		 6988 return devlist;
6989}
6990
6991static int
6992count_volumes_list(struct md_list *devlist, char *homehost,
6993 int verbose, int *found)
6994{
6995 struct md_list *tmpdev;
6996 int count = 0;
594dc1b8 6997 struct supertype *st;
ca9de185
LM		 6998
6999 /* first walk the list of devices to find a consistent set
7000 * that match the criterea, if that is possible.
7001 * We flag the ones we like with 'used'.
7002 */
7003 *found = 0;
7004 st = match_metadata_desc_imsm("imsm");
7005 if (st == NULL) {
676e87a8 7006 pr_vrb("cannot allocate memory for imsm supertype\n");
ca9de185
LM		 7007 return 0;
7008 }
7009
7010 for (tmpdev = devlist; tmpdev; tmpdev = tmpdev->next) {
7011 char *devname = tmpdev->devname;
0a6bff09 7012 dev_t rdev;
ca9de185
LM		 7013 struct supertype *tst;
7014 int dfd;
7015 if (tmpdev->used > 1)
7016 continue;
7017 tst = dup_super(st);
7018 if (tst == NULL) {
676e87a8 7019 pr_vrb("cannot allocate memory for imsm supertype\n");
ca9de185
LM		 7020 goto err_1;
7021 }
7022 tmpdev->container = 0;
7023 dfd = dev_open(devname, O_RDONLY|O_EXCL);
7024 if (dfd < 0) {
1ade5cc1 7025 dprintf("cannot open device %s: %s\n",
ca9de185
LM		 7026 devname, strerror(errno));
7027 tmpdev->used = 2;
0a6bff09 7028 } else if (!fstat_is_blkdev(dfd, devname, &rdev)) {
ca9de185
LM		 7029 tmpdev->used = 2;
7030 } else if (must_be_container(dfd)) {
7031 struct supertype *cst;
7032 cst = super_by_fd(dfd, NULL);
7033 if (cst == NULL) {
1ade5cc1 7034 dprintf("cannot recognize container type %s\n",
ca9de185
LM		 7035 devname);
7036 tmpdev->used = 2;
7037 } else if (tst->ss != st->ss) {
1ade5cc1 7038 dprintf("non-imsm container - ignore it: %s\n",
ca9de185
LM		 7039 devname);
7040 tmpdev->used = 2;
7041 } else if (!tst->ss->load_container ||
7042 tst->ss->load_container(tst, dfd, NULL))
7043 tmpdev->used = 2;
7044 else {
7045 tmpdev->container = 1;
7046 }
7047 if (cst)
7048 cst->ss->free_super(cst);
7049 } else {
0a6bff09 7050 tmpdev->st_rdev = rdev;
ca9de185 7051 if (tst->ss->load_super(tst,dfd, NULL)) {
1ade5cc1 7052 dprintf("no RAID superblock on %s\n",
ca9de185
LM		 7053 devname);
7054 tmpdev->used = 2;
7055 } else if (tst->ss->compare_super == NULL) {
1ade5cc1 7056 dprintf("Cannot assemble %s metadata on %s\n",
ca9de185
LM		 7057 tst->ss->name, devname);
7058 tmpdev->used = 2;
7059 }
7060 }
7061 if (dfd >= 0)
7062 close(dfd);
7063 if (tmpdev->used == 2 || tmpdev->used == 4) {
7064 /* Ignore unrecognised devices during auto-assembly */
7065 goto loop;
7066 }
7067 else {
7068 struct mdinfo info;
7069 tst->ss->getinfo_super(tst, &info, NULL);
7070
7071 if (st->minor_version == -1)
7072 st->minor_version = tst->minor_version;
7073
7074 if (memcmp(info.uuid, uuid_zero,
7075 sizeof(int[4])) == 0) {
7076 /* this is a floating spare. It cannot define
7077 * an array unless there are no more arrays of
7078 * this type to be found. It can be included
7079 * in an array of this type though.
7080 */
7081 tmpdev->used = 3;
7082 goto loop;
7083 }
7084
7085 if (st->ss != tst->ss ||
7086 st->minor_version != tst->minor_version ||
c7b8547c 7087 st->ss->compare_super(st, tst, 1) != 0) {
ca9de185
LM		 7088 /* Some mismatch. If exactly one array matches this host,
7089 * we can resolve on that one.
7090 * Or, if we are auto assembling, we just ignore the second
7091 * for now.
7092 */
1ade5cc1 7093 dprintf("superblock on %s doesn't match others - assembly aborted\n",
ca9de185
LM		 7094 devname);
7095 goto loop;
7096 }
7097 tmpdev->used = 1;
7098 *found = 1;
7099 dprintf("found: devname: %s\n", devname);
7100 }
7101 loop:
7102 if (tst)
7103 tst->ss->free_super(tst);
7104 }
7105 if (*found != 0) {
7106 int err;
7107 if ((err = load_super_imsm_all(st, -1, &st->sb, NULL, devlist, 0)) == 0) {
7108 struct mdinfo *iter, *head = st->ss->container_content(st, NULL);
7109 for (iter = head; iter; iter = iter->next) {
7110 dprintf("content->text_version: %s vol\n",
7111 iter->text_version);
7112 if (iter->array.state & (1<<MD_SB_BLOCK_VOLUME)) {
7113 /* do not assemble arrays with unsupported
7114 configurations */
1ade5cc1 7115 dprintf("Cannot activate member %s.\n",
ca9de185
LM		 7116 iter->text_version);
7117 } else
7118 count++;
7119 }
7120 sysfs_free(head);
7121
7122 } else {
1ade5cc1 7123 dprintf("No valid super block on device list: err: %d %p\n",
ca9de185
LM		 7124 err, st->sb);
7125 }
7126 } else {
1ade5cc1 7127 dprintf("no more devices to examine\n");
ca9de185
LM		 7128 }
7129
7130 for (tmpdev = devlist; tmpdev; tmpdev = tmpdev->next) {
089f9d79 7131 if (tmpdev->used == 1 && tmpdev->found) {
ca9de185
LM		 7132 if (count) {
7133 if (count < tmpdev->found)
7134 count = 0;
7135 else
7136 count -= tmpdev->found;
7137 }
7138 }
7139 if (tmpdev->used == 1)
7140 tmpdev->used = 4;
7141 }
7142 err_1:
7143 if (st)
7144 st->ss->free_super(st);
7145 return count;
7146}
7147
d3c11416
AO		 7148static int __count_volumes(char *hba_path, int dpa, int verbose,
7149 int cmp_hba_path)
ca9de185 7150{
72a45777 7151 struct sys_dev *idev, *intel_devices = find_intel_devices();
ca9de185 7152 int count = 0;
72a45777
PB		 7153 const struct orom_entry *entry;
7154 struct devid_list *dv, *devid_list;
ca9de185 7155
d3c11416 7156 if (!hba_path)
ca9de185
LM		 7157 return 0;
7158
72a45777 7159 for (idev = intel_devices; idev; idev = idev->next) {
d3c11416
AO		 7160 if (strstr(idev->path, hba_path))
7161 break;
72a45777
PB		 7162 }
7163
7164 if (!idev || !idev->dev_id)
ca9de185 7165 return 0;
72a45777
PB		 7166
7167 entry = get_orom_entry_by_device_id(idev->dev_id);
7168
7169 if (!entry || !entry->devid_list)
7170 return 0;
7171
7172 devid_list = entry->devid_list;
7173 for (dv = devid_list; dv; dv = dv->next) {
594dc1b8 7174 struct md_list *devlist;
d3c11416
AO		 7175 struct sys_dev *device = NULL;
7176 char *hpath;
72a45777
PB		 7177 int found = 0;
7178
d3c11416
AO		 7179 if (cmp_hba_path)
7180 device = device_by_id_and_path(dv->devid, hba_path);
7181 else
7182 device = device_by_id(dv->devid);
7183
72a45777 7184 if (device)
d3c11416 7185 hpath = device->path;
72a45777
PB		 7186 else
7187 return 0;
7188
d3c11416 7189 devlist = get_devices(hpath);
72a45777
PB		 7190 /* if no intel devices return zero volumes */
7191 if (devlist == NULL)
7192 return 0;
7193
d3c11416
AO		 7194 count += active_arrays_by_format("imsm", hpath, &devlist, dpa,
7195 verbose);
7196 dprintf("path: %s active arrays: %d\n", hpath, count);
72a45777
PB		 7197 if (devlist == NULL)
7198 return 0;
7199 do {
7200 found = 0;
7201 count += count_volumes_list(devlist,
7202 NULL,
7203 verbose,
7204 &found);
7205 dprintf("found %d count: %d\n", found, count);
7206 } while (found);
7207
d3c11416 7208 dprintf("path: %s total number of volumes: %d\n", hpath, count);
72a45777
PB		 7209
7210 while (devlist) {
7211 struct md_list *dv = devlist;
7212 devlist = devlist->next;
7213 free(dv->devname);
7214 free(dv);
7215 }
ca9de185
LM		 7216 }
7217 return count;
7218}
7219
d3c11416
AO		 7220static int count_volumes(struct intel_hba *hba, int dpa, int verbose)
7221{
7222 if (!hba)
7223 return 0;
7224 if (hba->type == SYS_DEV_VMD) {
7225 struct sys_dev *dev;
7226 int count = 0;
7227
7228 for (dev = find_intel_devices(); dev; dev = dev->next) {
7229 if (dev->type == SYS_DEV_VMD)
7230 count += __count_volumes(dev->path, dpa,
7231 verbose, 1);
7232 }
7233 return count;
7234 }
7235 return __count_volumes(hba->path, dpa, verbose, 0);
7236}
7237
cd9d1ac7
DW		 7238static int imsm_default_chunk(const struct imsm_orom *orom)
7239{
7240 /* up to 512 if the plaform supports it, otherwise the platform max.
7241 * 128 if no platform detected
7242 */
7243 int fs = max(7, orom ? fls(orom->sss) : 0);
7244
7245 return min(512, (1 << fs));
7246}
73408129 7247
6592ce37
DW		 7248static int
7249validate_geometry_imsm_orom(struct intel_super *super, int level, int layout,
2cc699af 7250 int raiddisks, int *chunk, unsigned long long size, int verbose)
6592ce37 7251{
660260d0
DW		 7252 /* check/set platform and metadata limits/defaults */
7253 if (super->orom && raiddisks > super->orom->dpa) {
676e87a8 7254 pr_vrb("platform supports a maximum of %d disks per array\n",
660260d0 7255 super->orom->dpa);
73408129
LM		 7256 return 0;
7257 }
7258
5d500228 7259 /* capabilities of OROM tested - copied from validate_geometry_imsm_volume */
660260d0 7260 if (!is_raid_level_supported(super->orom, level, raiddisks)) {
676e87a8 7261 pr_vrb("platform does not support raid%d with %d disk%s\n",
6592ce37
DW		 7262 level, raiddisks, raiddisks > 1 ? "s" : "");
7263 return 0;
7264 }
cd9d1ac7 7265
7ccc4cc4 7266 if (*chunk == 0 || *chunk == UnSet)
cd9d1ac7
DW		 7267 *chunk = imsm_default_chunk(super->orom);
7268
7ccc4cc4 7269 if (super->orom && !imsm_orom_has_chunk(super->orom, *chunk)) {
676e87a8 7270 pr_vrb("platform does not support a chunk size of: %d\n", *chunk);
cd9d1ac7 7271 return 0;
6592ce37 7272 }
cd9d1ac7 7273
6592ce37
DW		 7274 if (layout != imsm_level_to_layout(level)) {
7275 if (level == 5)
676e87a8 7276 pr_vrb("imsm raid 5 only supports the left-asymmetric layout\n");
6592ce37 7277 else if (level == 10)
676e87a8 7278 pr_vrb("imsm raid 10 only supports the n2 layout\n");
6592ce37 7279 else
676e87a8 7280 pr_vrb("imsm unknown layout %#x for this raid level %d\n",
6592ce37
DW		 7281 layout, level);
7282 return 0;
7283 }
2cc699af 7284
7ccc4cc4 7285 if (super->orom && (super->orom->attr & IMSM_OROM_ATTR_2TB) == 0 &&
2cc699af 7286 (calc_array_size(level, raiddisks, layout, *chunk, size) >> 32) > 0) {
676e87a8 7287 pr_vrb("platform does not support a volume size over 2TB\n");
2cc699af
CA		 7288 return 0;
7289 }
614902f6 7290
6592ce37
DW		 7291 return 1;
7292}
7293
1011e834 7294/* validate_geometry_imsm_volume - lifted from validate_geometry_ddf_bvd
c2c087e6
DW		 7295 * FIX ME add ahci details
7296 */
8b353278 7297static int validate_geometry_imsm_volume(struct supertype *st, int level,
c21e737b 7298 int layout, int raiddisks, int *chunk,
af4348dd
N		 7299 unsigned long long size,
7300 unsigned long long data_offset,
7301 char *dev,
2c514b71
NB		 7302 unsigned long long *freesize,
7303 int verbose)
cdddbdbc 7304{
9e04ac1c 7305 dev_t rdev;
c2c087e6 7306 struct intel_super *super = st->sb;
b2916f25 7307 struct imsm_super *mpb;
c2c087e6
DW		 7308 struct dl *dl;
7309 unsigned long long pos = 0;
7310 unsigned long long maxsize;
7311 struct extent *e;
7312 int i;
cdddbdbc 7313
88c32bb1
DW		 7314 /* We must have the container info already read in. */
7315 if (!super)
c2c087e6
DW		 7316 return 0;
7317
b2916f25
JS		 7318 mpb = super->anchor;
7319
2cc699af 7320 if (!validate_geometry_imsm_orom(super, level, layout, raiddisks, chunk, size, verbose)) {
3e684231 7321 pr_err("RAID geometry validation failed. Cannot proceed with the action(s).\n");
c2c087e6 7322 return 0;
d54559f0 7323 }
c2c087e6
DW		 7324 if (!dev) {
7325 /* General test: make sure there is space for
2da8544a
DW		 7326 * 'raiddisks' device extents of size 'size' at a given
7327 * offset
c2c087e6 7328 */
e46273eb 7329 unsigned long long minsize = size;
b7528a20 7330 unsigned long long start_offset = MaxSector;
c2c087e6
DW		 7331 int dcnt = 0;
7332 if (minsize == 0)
7333 minsize = MPB_SECTOR_CNT + IMSM_RESERVED_SECTORS;
7334 for (dl = super->disks; dl ; dl = dl->next) {
7335 int found = 0;
7336
bf5a934a 7337 pos = 0;
c2c087e6 7338 i = 0;
05501181 7339 e = get_extents(super, dl, 0);
c2c087e6
DW		 7340 if (!e) continue;
7341 do {
7342 unsigned long long esize;
7343 esize = e[i].start - pos;
7344 if (esize >= minsize)
7345 found = 1;
b7528a20 7346 if (found && start_offset == MaxSector) {
2da8544a
DW		 7347 start_offset = pos;
7348 break;
7349 } else if (found && pos != start_offset) {
7350 found = 0;
7351 break;
7352 }
c2c087e6
DW		 7353 pos = e[i].start + e[i].size;
7354 i++;
7355 } while (e[i-1].size);
7356 if (found)
7357 dcnt++;
7358 free(e);
7359 }
7360 if (dcnt < raiddisks) {
2c514b71 7361 if (verbose)
7a862a02 7362 pr_err("imsm: Not enough devices with space for this array (%d < %d)\n",
2c514b71 7363 dcnt, raiddisks);
c2c087e6
DW		 7364 return 0;
7365 }
7366 return 1;
7367 }
0dcecb2e 7368
c2c087e6 7369 /* This device must be a member of the set */
9e04ac1c 7370 if (!stat_is_blkdev(dev, &rdev))
c2c087e6
DW		 7371 return 0;
7372 for (dl = super->disks ; dl ; dl = dl->next) {
9e04ac1c
ZL		 7373 if (dl->major == (int)major(rdev) &&
7374 dl->minor == (int)minor(rdev))
c2c087e6
DW		 7375 break;
7376 }
7377 if (!dl) {
2c514b71 7378 if (verbose)
7a862a02 7379 pr_err("%s is not in the same imsm set\n", dev);
c2c087e6 7380 return 0;
a20d2ba5
DW		 7381 } else if (super->orom && dl->index < 0 && mpb->num_raid_devs) {
7382 /* If a volume is present then the current creation attempt
7383 * cannot incorporate new spares because the orom may not
7384 * understand this configuration (all member disks must be
7385 * members of each array in the container).
7386 */
7a862a02
N		 7387 pr_err("%s is a spare and a volume is already defined for this container\n", dev);
7388 pr_err("The option-rom requires all member disks to be a member of all volumes\n");
a20d2ba5 7389 return 0;
5fe62b94
WD		 7390 } else if (super->orom && mpb->num_raid_devs > 0 &&
7391 mpb->num_disks != raiddisks) {
7a862a02 7392 pr_err("The option-rom requires all member disks to be a member of all volumes\n");
5fe62b94 7393 return 0;
c2c087e6 7394 }
0dcecb2e
DW		 7395
7396 /* retrieve the largest free space block */
05501181 7397 e = get_extents(super, dl, 0);
c2c087e6
DW		 7398 maxsize = 0;
7399 i = 0;
0dcecb2e
DW		 7400 if (e) {
7401 do {
7402 unsigned long long esize;
7403
7404 esize = e[i].start - pos;
7405 if (esize >= maxsize)
7406 maxsize = esize;
7407 pos = e[i].start + e[i].size;
7408 i++;
7409 } while (e[i-1].size);
7410 dl->e = e;
7411 dl->extent_cnt = i;
7412 } else {
7413 if (verbose)
e7b84f9d 7414 pr_err("unable to determine free space for: %s\n",
0dcecb2e
DW		 7415 dev);
7416 return 0;
7417 }
7418 if (maxsize < size) {
7419 if (verbose)
e7b84f9d 7420 pr_err("%s not enough space (%llu < %llu)\n",
0dcecb2e
DW		 7421 dev, maxsize, size);
7422 return 0;
7423 }
7424
7425 /* count total number of extents for merge */
7426 i = 0;
7427 for (dl = super->disks; dl; dl = dl->next)
7428 if (dl->e)
7429 i += dl->extent_cnt;
7430
7431 maxsize = merge_extents(super, i);
3baa56ab 7432
1a1ced1e
KS		 7433 if (mpb->num_raid_devs > 0 && size && size != maxsize)
7434 pr_err("attempting to create a second volume with size less then remaining space.\n");
3baa56ab 7435
a7dd165b 7436 if (maxsize < size || maxsize == 0) {
b3071342
LD		 7437 if (verbose) {
7438 if (maxsize == 0)
7a862a02 7439 pr_err("no free space left on device. Aborting...\n");
b3071342 7440 else
7a862a02 7441 pr_err("not enough space to create volume of given size (%llu < %llu). Aborting...\n",
b3071342
LD		 7442 maxsize, size);
7443 }
0dcecb2e 7444 return 0;
0dcecb2e
DW		 7445 }
7446
c2c087e6
DW		 7447 *freesize = maxsize;
7448
ca9de185 7449 if (super->orom) {
72a45777 7450 int count = count_volumes(super->hba,
ca9de185
LM		 7451 super->orom->dpa, verbose);
7452 if (super->orom->vphba <= count) {
676e87a8 7453 pr_vrb("platform does not support more than %d raid volumes.\n",
ca9de185
LM		 7454 super->orom->vphba);
7455 return 0;
7456 }
7457 }
c2c087e6 7458 return 1;
cdddbdbc
DW		 7459}
7460
13bcac90 7461static int imsm_get_free_size(struct supertype *st, int raiddisks,
efb30e7f
DW		 7462 unsigned long long size, int chunk,
7463 unsigned long long *freesize)
7464{
7465 struct intel_super *super = st->sb;
7466 struct imsm_super *mpb = super->anchor;
7467 struct dl *dl;
7468 int i;
7469 int extent_cnt;
7470 struct extent *e;
7471 unsigned long long maxsize;
7472 unsigned long long minsize;
7473 int cnt;
7474 int used;
7475
7476 /* find the largest common start free region of the possible disks */
7477 used = 0;
7478 extent_cnt = 0;
7479 cnt = 0;
7480 for (dl = super->disks; dl; dl = dl->next) {
7481 dl->raiddisk = -1;
7482
7483 if (dl->index >= 0)
7484 used++;
7485
7486 /* don't activate new spares if we are orom constrained
7487 * and there is already a volume active in the container
7488 */
7489 if (super->orom && dl->index < 0 && mpb->num_raid_devs)
7490 continue;
7491
05501181 7492 e = get_extents(super, dl, 0);
efb30e7f
DW		 7493 if (!e)
7494 continue;
7495 for (i = 1; e[i-1].size; i++)
7496 ;
7497 dl->e = e;
7498 dl->extent_cnt = i;
7499 extent_cnt += i;
7500 cnt++;
7501 }
7502
7503 maxsize = merge_extents(super, extent_cnt);
7504 minsize = size;
7505 if (size == 0)
612e59d8
CA		 7506 /* chunk is in K */
7507 minsize = chunk * 2;
efb30e7f
DW		 7508
7509 if (cnt < raiddisks ||
7510 (super->orom && used && used != raiddisks) ||
a7dd165b
DW		 7511 maxsize < minsize ||
7512 maxsize == 0) {
e7b84f9d 7513 pr_err("not enough devices with space to create array.\n");
efb30e7f
DW		 7514 return 0; /* No enough free spaces large enough */
7515 }
7516
7517 if (size == 0) {
7518 size = maxsize;
7519 if (chunk) {
612e59d8
CA		 7520 size /= 2 * chunk;
7521 size *= 2 * chunk;
efb30e7f 7522 }
f878b242
LM		 7523 maxsize = size;
7524 }
1a1ced1e
KS		 7525 if (mpb->num_raid_devs > 0 && size && size != maxsize)
7526 pr_err("attempting to create a second volume with size less then remaining space.\n");
efb30e7f
DW		 7527 cnt = 0;
7528 for (dl = super->disks; dl; dl = dl->next)
7529 if (dl->e)
7530 dl->raiddisk = cnt++;
7531
7532 *freesize = size;
7533
13bcac90
AK		 7534 dprintf("imsm: imsm_get_free_size() returns : %llu\n", size);
7535
efb30e7f
DW		 7536 return 1;
7537}
7538
13bcac90
AK		 7539static int reserve_space(struct supertype *st, int raiddisks,
7540 unsigned long long size, int chunk,
7541 unsigned long long *freesize)
7542{
7543 struct intel_super *super = st->sb;
7544 struct dl *dl;
7545 int cnt;
7546 int rv = 0;
7547
7548 rv = imsm_get_free_size(st, raiddisks, size, chunk, freesize);
7549 if (rv) {
7550 cnt = 0;
7551 for (dl = super->disks; dl; dl = dl->next)
7552 if (dl->e)
7553 dl->raiddisk = cnt++;
7554 rv = 1;
7555 }
7556
7557 return rv;
7558}
7559
bf5a934a 7560static int validate_geometry_imsm(struct supertype *st, int level, int layout,
c21e737b 7561 int raiddisks, int *chunk, unsigned long long size,
af4348dd 7562 unsigned long long data_offset,
bf5a934a 7563 char *dev, unsigned long long *freesize,
5308f117 7564 int consistency_policy, int verbose)
bf5a934a
DW		 7565{
7566 int fd, cfd;
7567 struct mdinfo *sra;
20cbe8d2 7568 int is_member = 0;
bf5a934a 7569
d54559f0
LM		 7570 /* load capability
7571 * if given unused devices create a container
bf5a934a
DW		 7572 * if given given devices in a container create a member volume
7573 */
7574 if (level == LEVEL_CONTAINER) {
7575 /* Must be a fresh device to add to a container */
7576 return validate_geometry_imsm_container(st, level, layout,
c21e737b 7577 raiddisks,
7ccc4cc4 7578 *chunk,
af4348dd 7579 size, data_offset,
bf5a934a
DW		 7580 dev, freesize,
7581 verbose);
7582 }
9587c373 7583
06a6101c
BK		 7584 /*
7585 * Size is given in sectors.
7586 */
7587 if (size && (size < 2048)) {
22dc741f 7588 pr_err("Given size must be greater than 1M.\n");
54865c30
RS		 7589 /* Depends on algorithm in Create.c :
7590 * if container was given (dev == NULL) return -1,
7591 * if block device was given ( dev != NULL) return 0.
7592 */
7593 return dev ? -1 : 0;
7594 }
7595
8592f29d 7596 if (!dev) {
e91a3bad 7597 if (st->sb) {
ca9de185 7598 struct intel_super *super = st->sb;
e91a3bad 7599 if (!validate_geometry_imsm_orom(st->sb, level, layout,
2cc699af 7600 raiddisks, chunk, size,
e91a3bad
LM		 7601 verbose))
7602 return 0;
efb30e7f
DW		 7603 /* we are being asked to automatically layout a
7604 * new volume based on the current contents of
7605 * the container. If the the parameters can be
7606 * satisfied reserve_space will record the disks,
7607 * start offset, and size of the volume to be
7608 * created. add_to_super and getinfo_super
7609 * detect when autolayout is in progress.
7610 */
ca9de185
LM		 7611 /* assuming that freesize is always given when array is
7612 created */
7613 if (super->orom && freesize) {
7614 int count;
72a45777 7615 count = count_volumes(super->hba,
ca9de185
LM		 7616 super->orom->dpa, verbose);
7617 if (super->orom->vphba <= count) {
676e87a8 7618 pr_vrb("platform does not support more than %d raid volumes.\n",
ca9de185
LM		 7619 super->orom->vphba);
7620 return 0;
7621 }
7622 }
e91a3bad
LM		 7623 if (freesize)
7624 return reserve_space(st, raiddisks, size,
7ccc4cc4 7625 *chunk, freesize);
8592f29d
N		 7626 }
7627 return 1;
7628 }
bf5a934a
DW		 7629 if (st->sb) {
7630 /* creating in a given container */
7631 return validate_geometry_imsm_volume(st, level, layout,
7632 raiddisks, chunk, size,
af4348dd 7633 data_offset,
bf5a934a
DW		 7634 dev, freesize, verbose);
7635 }
7636
bf5a934a
DW		 7637 /* This device needs to be a device in an 'imsm' container */
7638 fd = open(dev, O_RDONLY|O_EXCL, 0);
7639 if (fd >= 0) {
7640 if (verbose)
e7b84f9d
N		 7641 pr_err("Cannot create this array on device %s\n",
7642 dev);
bf5a934a
DW		 7643 close(fd);
7644 return 0;
7645 }
7646 if (errno != EBUSY || (fd = open(dev, O_RDONLY, 0)) < 0) {
7647 if (verbose)
e7b84f9d 7648 pr_err("Cannot open %s: %s\n",
bf5a934a
DW		 7649 dev, strerror(errno));
7650 return 0;
7651 }
7652 /* Well, it is in use by someone, maybe an 'imsm' container. */
7653 cfd = open_container(fd);
20cbe8d2 7654 close(fd);
bf5a934a 7655 if (cfd < 0) {
bf5a934a 7656 if (verbose)
e7b84f9d 7657 pr_err("Cannot use %s: It is busy\n",
bf5a934a
DW		 7658 dev);
7659 return 0;
7660 }
4dd2df09 7661 sra = sysfs_read(cfd, NULL, GET_VERSION);
bf5a934a 7662 if (sra && sra->array.major_version == -1 &&
20cbe8d2
AW		 7663 strcmp(sra->text_version, "imsm") == 0)
7664 is_member = 1;
7665 sysfs_free(sra);
7666 if (is_member) {
bf5a934a
DW		 7667 /* This is a member of a imsm container. Load the container
7668 * and try to create a volume
7669 */
7670 struct intel_super *super;
7671
ec50f7b6 7672 if (load_super_imsm_all(st, cfd, (void **) &super, NULL, NULL, 1) == 0) {
bf5a934a 7673 st->sb = super;
4dd2df09 7674 strcpy(st->container_devnm, fd2devnm(cfd));
bf5a934a
DW		 7675 close(cfd);
7676 return validate_geometry_imsm_volume(st, level, layout,
7677 raiddisks, chunk,
af4348dd 7678 size, data_offset, dev,
ecbd9e81
N		 7679 freesize, 1)
7680 ? 1 : -1;
bf5a934a 7681 }
20cbe8d2 7682 }
bf5a934a 7683
20cbe8d2 7684 if (verbose)
e7b84f9d 7685 pr_err("failed container membership check\n");
20cbe8d2
AW		 7686
7687 close(cfd);
7688 return 0;
bf5a934a 7689}
0bd16cf2 7690
30f58b22 7691static void default_geometry_imsm(struct supertype *st, int *level, int *layout, int *chunk)
0bd16cf2
DJ		 7692{
7693 struct intel_super *super = st->sb;
7694
30f58b22
DW		 7695 if (level && *level == UnSet)
7696 *level = LEVEL_CONTAINER;
7697
7698 if (level && layout && *layout == UnSet)
7699 *layout = imsm_level_to_layout(*level);
0bd16cf2 7700
cd9d1ac7
DW		 7701 if (chunk && (*chunk == UnSet || *chunk == 0))
7702 *chunk = imsm_default_chunk(super->orom);
0bd16cf2
DJ		 7703}
7704
33414a01
DW		 7705static void handle_missing(struct intel_super *super, struct imsm_dev *dev);
7706
3364781b 7707static int kill_subarray_imsm(struct supertype *st, char *subarray_id)
33414a01 7708{
3364781b 7709 /* remove the subarray currently referenced by subarray_id */
33414a01
DW		 7710 __u8 i;
7711 struct intel_dev **dp;
7712 struct intel_super *super = st->sb;
3364781b 7713 __u8 current_vol = strtoul(subarray_id, NULL, 10);
33414a01
DW		 7714 struct imsm_super *mpb = super->anchor;
7715
3364781b 7716 if (mpb->num_raid_devs == 0)
33414a01 7717 return 2;
33414a01
DW		 7718
7719 /* block deletions that would change the uuid of active subarrays
7720 *
7721 * FIXME when immutable ids are available, but note that we'll
7722 * also need to fixup the invalidated/active subarray indexes in
7723 * mdstat
7724 */
7725 for (i = 0; i < mpb->num_raid_devs; i++) {
7726 char subarray[4];
7727
7728 if (i < current_vol)
7729 continue;
7730 sprintf(subarray, "%u", i);
4dd2df09 7731 if (is_subarray_active(subarray, st->devnm)) {
e7b84f9d
N		 7732 pr_err("deleting subarray-%d would change the UUID of active subarray-%d, aborting\n",
7733 current_vol, i);
33414a01
DW		 7734
7735 return 2;
7736 }
7737 }
7738
7739 if (st->update_tail) {
503975b9 7740 struct imsm_update_kill_array *u = xmalloc(sizeof(*u));
33414a01 7741
33414a01
DW		 7742 u->type = update_kill_array;
7743 u->dev_idx = current_vol;
7744 append_metadata_update(st, u, sizeof(*u));
7745
7746 return 0;
7747 }
7748
7749 for (dp = &super->devlist; *dp;)
7750 if ((*dp)->index == current_vol) {
7751 *dp = (*dp)->next;
7752 } else {
7753 handle_missing(super, (*dp)->dev);
7754 if ((*dp)->index > current_vol)
7755 (*dp)->index--;
7756 dp = &(*dp)->next;
7757 }
7758
7759 /* no more raid devices, all active components are now spares,
7760 * but of course failed are still failed
7761 */
7762 if (--mpb->num_raid_devs == 0) {
7763 struct dl *d;
7764
7765 for (d = super->disks; d; d = d->next)
a8619d23
AK		 7766 if (d->index > -2)
7767 mark_spare(d);
33414a01
DW		 7768 }
7769
7770 super->updates_pending++;
7771
7772 return 0;
7773}
aa534678 7774
19ad203e
JR		 7775static int get_rwh_policy_from_update(char *update)
7776{
7777 if (strcmp(update, "ppl") == 0)
7778 return RWH_MULTIPLE_DISTRIBUTED;
7779 else if (strcmp(update, "no-ppl") == 0)
7780 return RWH_MULTIPLE_OFF;
7781 else if (strcmp(update, "bitmap") == 0)
7782 return RWH_BITMAP;
7783 else if (strcmp(update, "no-bitmap") == 0)
7784 return RWH_OFF;
7785 return -1;
7786}
7787
a951a4f7 7788static int update_subarray_imsm(struct supertype *st, char *subarray,
fa56eddb 7789 char *update, struct mddev_ident *ident)
aa534678
DW		 7790{
7791 /* update the subarray currently referenced by ->current_vol */
7792 struct intel_super *super = st->sb;
7793 struct imsm_super *mpb = super->anchor;
7794
aa534678
DW		 7795 if (strcmp(update, "name") == 0) {
7796 char *name = ident->name;
a951a4f7
N		 7797 char *ep;
7798 int vol;
aa534678 7799
4dd2df09 7800 if (is_subarray_active(subarray, st->devnm)) {
e7b84f9d 7801 pr_err("Unable to update name of active subarray\n");
aa534678
DW		 7802 return 2;
7803 }
7804
7805 if (!check_name(super, name, 0))
7806 return 2;
7807
a951a4f7
N		 7808 vol = strtoul(subarray, &ep, 10);
7809 if (*ep != '\0' || vol >= super->anchor->num_raid_devs)
7810 return 2;
7811
aa534678 7812 if (st->update_tail) {
503975b9 7813 struct imsm_update_rename_array *u = xmalloc(sizeof(*u));
aa534678 7814
aa534678 7815 u->type = update_rename_array;
a951a4f7 7816 u->dev_idx = vol;
618f4e6d
XN		 7817 strncpy((char *) u->name, name, MAX_RAID_SERIAL_LEN);
7818 u->name[MAX_RAID_SERIAL_LEN-1] = '\0';
aa534678
DW		 7819 append_metadata_update(st, u, sizeof(*u));
7820 } else {
7821 struct imsm_dev *dev;
ebad3af2 7822 int i, namelen;
aa534678 7823
a951a4f7 7824 dev = get_imsm_dev(super, vol);
ebad3af2
JS		 7825 memset(dev->volume, '\0', MAX_RAID_SERIAL_LEN);
7826 namelen = min((int)strlen(name), MAX_RAID_SERIAL_LEN);
7827 memcpy(dev->volume, name, namelen);
aa534678
DW		 7828 for (i = 0; i < mpb->num_raid_devs; i++) {
7829 dev = get_imsm_dev(super, i);
7830 handle_missing(super, dev);
7831 }
7832 super->updates_pending++;
7833 }
19ad203e 7834 } else if (get_rwh_policy_from_update(update) != -1) {
e6e9dd3f
AP		 7835 int new_policy;
7836 char *ep;
7837 int vol = strtoul(subarray, &ep, 10);
7838
7839 if (*ep != '\0' || vol >= super->anchor->num_raid_devs)
7840 return 2;
7841
19ad203e 7842 new_policy = get_rwh_policy_from_update(update);
e6e9dd3f
AP		 7843
7844 if (st->update_tail) {
7845 struct imsm_update_rwh_policy *u = xmalloc(sizeof(*u));
7846
7847 u->type = update_rwh_policy;
7848 u->dev_idx = vol;
7849 u->new_policy = new_policy;
7850 append_metadata_update(st, u, sizeof(*u));
7851 } else {
7852 struct imsm_dev *dev;
7853
7854 dev = get_imsm_dev(super, vol);
7855 dev->rwh_policy = new_policy;
7856 super->updates_pending++;
7857 }
19ad203e
JR		 7858 if (new_policy == RWH_BITMAP)
7859 return write_init_bitmap_imsm_vol(st, vol);
aa534678
DW		 7860 } else
7861 return 2;
7862
7863 return 0;
7864}
bf5a934a 7865
28bce06f
AK		 7866static int is_gen_migration(struct imsm_dev *dev)
7867{
7534230b
AK		 7868 if (dev == NULL)
7869 return 0;
7870
28bce06f
AK		 7871 if (!dev->vol.migr_state)
7872 return 0;
7873
7874 if (migr_type(dev) == MIGR_GEN_MIGR)
7875 return 1;
7876
7877 return 0;
7878}
7879
1e5c6983
DW		 7880static int is_rebuilding(struct imsm_dev *dev)
7881{
7882 struct imsm_map *migr_map;
7883
7884 if (!dev->vol.migr_state)
7885 return 0;
7886
7887 if (migr_type(dev) != MIGR_REBUILD)
7888 return 0;
7889
238c0a71 7890 migr_map = get_imsm_map(dev, MAP_1);
1e5c6983
DW		 7891
7892 if (migr_map->map_state == IMSM_T_STATE_DEGRADED)
7893 return 1;
7894 else
7895 return 0;
7896}
7897
6ce1fbf1
AK		 7898static int is_initializing(struct imsm_dev *dev)
7899{
7900 struct imsm_map *migr_map;
7901
7902 if (!dev->vol.migr_state)
7903 return 0;
7904
7905 if (migr_type(dev) != MIGR_INIT)
7906 return 0;
7907
238c0a71 7908 migr_map = get_imsm_map(dev, MAP_1);
6ce1fbf1
AK		 7909
7910 if (migr_map->map_state == IMSM_T_STATE_UNINITIALIZED)
7911 return 1;
7912
7913 return 0;
6ce1fbf1
AK		 7914}
7915
c47b0ff6
AK		 7916static void update_recovery_start(struct intel_super *super,
7917 struct imsm_dev *dev,
7918 struct mdinfo *array)
1e5c6983
DW		 7919{
7920 struct mdinfo *rebuild = NULL;
7921 struct mdinfo *d;
7922 __u32 units;
7923
7924 if (!is_rebuilding(dev))
7925 return;
7926
7927 /* Find the rebuild target, but punt on the dual rebuild case */
7928 for (d = array->devs; d; d = d->next)
7929 if (d->recovery_start == 0) {
7930 if (rebuild)
7931 return;
7932 rebuild = d;
7933 }
7934
4363fd80
DW		 7935 if (!rebuild) {
7936 /* (?) none of the disks are marked with
7937 * IMSM_ORD_REBUILD, so assume they are missing and the
7938 * disk_ord_tbl was not correctly updated
7939 */
1ade5cc1 7940 dprintf("failed to locate out-of-sync disk\n");
4363fd80
DW		 7941 return;
7942 }
7943
1e5c6983 7944 units = __le32_to_cpu(dev->vol.curr_migr_unit);
c47b0ff6 7945 rebuild->recovery_start = units * blocks_per_migr_unit(super, dev);
1e5c6983
DW		 7946}
7947
276d77db 7948static int recover_backup_imsm(struct supertype *st, struct mdinfo *info);
1e5c6983 7949
00bbdbda 7950static struct mdinfo *container_content_imsm(struct supertype *st, char *subarray)
cdddbdbc 7951{
4f5bc454
DW		 7952 /* Given a container loaded by load_super_imsm_all,
7953 * extract information about all the arrays into
7954 * an mdinfo tree.
00bbdbda 7955 * If 'subarray' is given, just extract info about that array.
4f5bc454
DW		 7956 *
7957 * For each imsm_dev create an mdinfo, fill it in,
7958 * then look for matching devices in super->disks
7959 * and create appropriate device mdinfo.
7960 */
7961 struct intel_super *super = st->sb;
949c47a0 7962 struct imsm_super *mpb = super->anchor;
4f5bc454 7963 struct mdinfo *rest = NULL;
00bbdbda 7964 unsigned int i;
81219e70 7965 int sb_errors = 0;
abef11a3
AK		 7966 struct dl *d;
7967 int spare_disks = 0;
b6180160 7968 int current_vol = super->current_vol;
cdddbdbc 7969
19482bcc
AK		 7970 /* do not assemble arrays when not all attributes are supported */
7971 if (imsm_check_attributes(mpb->attributes) == 0) {
81219e70 7972 sb_errors = 1;
7a862a02 7973 pr_err("Unsupported attributes in IMSM metadata.Arrays activation is blocked.\n");
19482bcc
AK		 7974 }
7975
abef11a3
AK		 7976 /* count spare devices, not used in maps
7977 */
7978 for (d = super->disks; d; d = d->next)
7979 if (d->index == -1)
7980 spare_disks++;
7981
4f5bc454 7982 for (i = 0; i < mpb->num_raid_devs; i++) {
00bbdbda
N		 7983 struct imsm_dev *dev;
7984 struct imsm_map *map;
86e3692b 7985 struct imsm_map *map2;
4f5bc454 7986 struct mdinfo *this;
a6482415 7987 int slot;
a6482415 7988 int chunk;
00bbdbda 7989 char *ep;
8b9cd157 7990 int level;
00bbdbda
N		 7991
7992 if (subarray &&
7993 (i != strtoul(subarray, &ep, 10) || *ep != '\0'))
7994 continue;
7995
7996 dev = get_imsm_dev(super, i);
238c0a71
AK		 7997 map = get_imsm_map(dev, MAP_0);
7998 map2 = get_imsm_map(dev, MAP_1);
8b9cd157 7999 level = get_imsm_raid_level(map);
4f5bc454 8000
1ce0101c
DW		 8001 /* do not publish arrays that are in the middle of an
8002 * unsupported migration
8003 */
8004 if (dev->vol.migr_state &&
28bce06f 8005 (migr_type(dev) == MIGR_STATE_CHANGE)) {
7a862a02 8006 pr_err("cannot assemble volume '%.16s': unsupported migration in progress\n",
1ce0101c
DW		 8007 dev->volume);
8008 continue;
8009 }
2db86302
LM		 8010 /* do not publish arrays that are not support by controller's
8011 * OROM/EFI
8012 */
1ce0101c 8013
503975b9 8014 this = xmalloc(sizeof(*this));
4f5bc454 8015
301406c9 8016 super->current_vol = i;
a5d85af7 8017 getinfo_super_imsm_volume(st, this, NULL);
9894ec0d 8018 this->next = rest;
a6482415 8019 chunk = __le16_to_cpu(map->blocks_per_strip) >> 1;
81219e70
LM		 8020 /* mdadm does not support all metadata features- set the bit in all arrays state */
8021 if (!validate_geometry_imsm_orom(super,
8b9cd157
MK		 8022 level, /* RAID level */
8023 imsm_level_to_layout(level),
81219e70 8024 map->num_members, /* raid disks */
fcc2c9da 8025 &chunk, imsm_dev_size(dev),
81219e70 8026 1 /* verbose */)) {
7a862a02 8027 pr_err("IMSM RAID geometry validation failed. Array %s activation is blocked.\n",
81219e70
LM		 8028 dev->volume);
8029 this->array.state |=
8030 (1<<MD_SB_BLOCK_CONTAINER_RESHAPE) |
8031 (1<<MD_SB_BLOCK_VOLUME);
8032 }
81219e70
LM		 8033
8034 /* if array has bad blocks, set suitable bit in all arrays state */
8035 if (sb_errors)
8036 this->array.state |=
8037 (1<<MD_SB_BLOCK_CONTAINER_RESHAPE) |
8038 (1<<MD_SB_BLOCK_VOLUME);
8039
4f5bc454 8040 for (slot = 0 ; slot < map->num_members; slot++) {
1e5c6983 8041 unsigned long long recovery_start;
4f5bc454
DW		 8042 struct mdinfo *info_d;
8043 struct dl *d;
8044 int idx;
9a1608e5 8045 int skip;
7eef0453 8046 __u32 ord;
8b9cd157 8047 int missing = 0;
4f5bc454 8048
9a1608e5 8049 skip = 0;
238c0a71
AK		 8050 idx = get_imsm_disk_idx(dev, slot, MAP_0);
8051 ord = get_imsm_ord_tbl_ent(dev, slot, MAP_X);
4f5bc454
DW		 8052 for (d = super->disks; d ; d = d->next)
8053 if (d->index == idx)
0fbd635c 8054 break;
4f5bc454 8055
1e5c6983 8056 recovery_start = MaxSector;
4f5bc454 8057 if (d == NULL)
9a1608e5 8058 skip = 1;
25ed7e59 8059 if (d && is_failed(&d->disk))
9a1608e5 8060 skip = 1;
8b9cd157 8061 if (!skip && (ord & IMSM_ORD_REBUILD))
1e5c6983 8062 recovery_start = 0;
1e93d0d1
BK		 8063 if (!(ord & IMSM_ORD_REBUILD))
8064 this->array.working_disks++;
1011e834 8065 /*
9a1608e5 8066 * if we skip some disks the array will be assmebled degraded;
1e5c6983
DW		 8067 * reset resync start to avoid a dirty-degraded
8068 * situation when performing the intial sync
9a1608e5 8069 */
8b9cd157
MK		 8070 if (skip)
8071 missing++;
8072
8073 if (!(dev->vol.dirty & RAIDVOL_DIRTY)) {
8074 if ((!able_to_resync(level, missing) ||
8075 recovery_start == 0))
8076 this->resync_start = MaxSector;
8077 } else {
8078 /*
8079 * FIXME handle dirty degraded
8080 */
8081 }
8082
9a1608e5
DW		 8083 if (skip)
8084 continue;
4f5bc454 8085
503975b9 8086 info_d = xcalloc(1, sizeof(*info_d));
4f5bc454
DW		 8087 info_d->next = this->devs;
8088 this->devs = info_d;
8089
4f5bc454
DW		 8090 info_d->disk.number = d->index;
8091 info_d->disk.major = d->major;
8092 info_d->disk.minor = d->minor;
8093 info_d->disk.raid_disk = slot;
1e5c6983 8094 info_d->recovery_start = recovery_start;
86e3692b
AK		 8095 if (map2) {
8096 if (slot < map2->num_members)
8097 info_d->disk.state = (1 << MD_DISK_ACTIVE);
04c3c514
AK		 8098 else
8099 this->array.spare_disks++;
86e3692b
AK		 8100 } else {
8101 if (slot < map->num_members)
8102 info_d->disk.state = (1 << MD_DISK_ACTIVE);
04c3c514
AK		 8103 else
8104 this->array.spare_disks++;
86e3692b 8105 }
4f5bc454
DW		 8106
8107 info_d->events = __le32_to_cpu(mpb->generation_num);
5551b113 8108 info_d->data_offset = pba_of_lba0(map);
44490938 8109 info_d->component_size = calc_component_size(map, dev);
06fb291a
PB		 8110
8111 if (map->raid_level == 5) {
2432ce9b
AP		 8112 info_d->ppl_sector = this->ppl_sector;
8113 info_d->ppl_size = this->ppl_size;
98e96bdb
AP		 8114 if (this->consistency_policy == CONSISTENCY_POLICY_PPL &&
8115 recovery_start == 0)
8116 this->resync_start = 0;
06fb291a 8117 }
b12796be 8118
5e46202e 8119 info_d->bb.supported = 1;
b12796be
TM		 8120 get_volume_badblocks(super->bbm_log, ord_to_idx(ord),
8121 info_d->data_offset,
8122 info_d->component_size,
8123 &info_d->bb);
4f5bc454 8124 }
1e5c6983 8125 /* now that the disk list is up-to-date fixup recovery_start */
c47b0ff6 8126 update_recovery_start(super, dev, this);
abef11a3 8127 this->array.spare_disks += spare_disks;
276d77db
AK		 8128
8129 /* check for reshape */
8130 if (this->reshape_active == 1)
8131 recover_backup_imsm(st, this);
9a1608e5 8132 rest = this;
4f5bc454
DW		 8133 }
8134
b6180160 8135 super->current_vol = current_vol;
4f5bc454 8136 return rest;
cdddbdbc
DW		 8137}
8138
3b451610
AK		 8139static __u8 imsm_check_degraded(struct intel_super *super, struct imsm_dev *dev,
8140 int failed, int look_in_map)
c2a1e7da 8141{
3b451610
AK		 8142 struct imsm_map *map;
8143
8144 map = get_imsm_map(dev, look_in_map);
c2a1e7da
DW		 8145
8146 if (!failed)
1011e834 8147 return map->map_state == IMSM_T_STATE_UNINITIALIZED ?
3393c6af 8148 IMSM_T_STATE_UNINITIALIZED : IMSM_T_STATE_NORMAL;
c2a1e7da
DW		 8149
8150 switch (get_imsm_raid_level(map)) {
8151 case 0:
8152 return IMSM_T_STATE_FAILED;
8153 break;
8154 case 1:
8155 if (failed < map->num_members)
8156 return IMSM_T_STATE_DEGRADED;
8157 else
8158 return IMSM_T_STATE_FAILED;
8159 break;
8160 case 10:
8161 {
8162 /**
c92a2527
DW		 8163 * check to see if any mirrors have failed, otherwise we
8164 * are degraded. Even numbered slots are mirrored on
8165 * slot+1
c2a1e7da 8166 */
c2a1e7da 8167 int i;
d9b420a5
N		 8168 /* gcc -Os complains that this is unused */
8169 int insync = insync;
c2a1e7da
DW		 8170
8171 for (i = 0; i < map->num_members; i++) {
238c0a71 8172 __u32 ord = get_imsm_ord_tbl_ent(dev, i, MAP_X);
c92a2527
DW		 8173 int idx = ord_to_idx(ord);
8174 struct imsm_disk *disk;
c2a1e7da 8175
c92a2527 8176 /* reset the potential in-sync count on even-numbered
1011e834 8177 * slots. num_copies is always 2 for imsm raid10
c92a2527
DW		 8178 */
8179 if ((i & 1) == 0)
8180 insync = 2;
c2a1e7da 8181
c92a2527 8182 disk = get_imsm_disk(super, idx);
25ed7e59 8183 if (!disk || is_failed(disk) || ord & IMSM_ORD_REBUILD)
c92a2527 8184 insync--;
c2a1e7da 8185
c92a2527
DW		 8186 /* no in-sync disks left in this mirror the
8187 * array has failed
8188 */
8189 if (insync == 0)
8190 return IMSM_T_STATE_FAILED;
c2a1e7da
DW		 8191 }
8192
8193 return IMSM_T_STATE_DEGRADED;
8194 }
8195 case 5:
8196 if (failed < 2)
8197 return IMSM_T_STATE_DEGRADED;
8198 else
8199 return IMSM_T_STATE_FAILED;
8200 break;
8201 default:
8202 break;
8203 }
8204
8205 return map->map_state;
8206}
8207
3b451610
AK		 8208static int imsm_count_failed(struct intel_super *super, struct imsm_dev *dev,
8209 int look_in_map)
c2a1e7da
DW		 8210{
8211 int i;
8212 int failed = 0;
8213 struct imsm_disk *disk;
d5985138
AK		 8214 struct imsm_map *map = get_imsm_map(dev, MAP_0);
8215 struct imsm_map *prev = get_imsm_map(dev, MAP_1);
68fe4598 8216 struct imsm_map *map_for_loop;
0556e1a2
DW		 8217 __u32 ord;
8218 int idx;
d5985138 8219 int idx_1;
c2a1e7da 8220
0556e1a2
DW		 8221 /* at the beginning of migration we set IMSM_ORD_REBUILD on
8222 * disks that are being rebuilt. New failures are recorded to
8223 * map[0]. So we look through all the disks we started with and
8224 * see if any failures are still present, or if any new ones
8225 * have arrived
0556e1a2 8226 */
d5985138
AK		 8227 map_for_loop = map;
8228 if (prev && (map->num_members < prev->num_members))
8229 map_for_loop = prev;
68fe4598
LD		 8230
8231 for (i = 0; i < map_for_loop->num_members; i++) {
d5985138 8232 idx_1 = -255;
238c0a71
AK		 8233 /* when MAP_X is passed both maps failures are counted
8234 */
d5985138 8235 if (prev &&
089f9d79
JS		 8236 (look_in_map == MAP_1 || look_in_map == MAP_X) &&
8237 i < prev->num_members) {
d5985138
AK		 8238 ord = __le32_to_cpu(prev->disk_ord_tbl[i]);
8239 idx_1 = ord_to_idx(ord);
c2a1e7da 8240
d5985138
AK		 8241 disk = get_imsm_disk(super, idx_1);
8242 if (!disk || is_failed(disk) || ord & IMSM_ORD_REBUILD)
8243 failed++;
8244 }
089f9d79
JS		 8245 if ((look_in_map == MAP_0 || look_in_map == MAP_X) &&
8246 i < map->num_members) {
d5985138
AK		 8247 ord = __le32_to_cpu(map->disk_ord_tbl[i]);
8248 idx = ord_to_idx(ord);
8249
8250 if (idx != idx_1) {
8251 disk = get_imsm_disk(super, idx);
8252 if (!disk || is_failed(disk) ||
8253 ord & IMSM_ORD_REBUILD)
8254 failed++;
8255 }
8256 }
c2a1e7da
DW		 8257 }
8258
8259 return failed;
845dea95
NB		 8260}
8261
97b4d0e9
DW		 8262static int imsm_open_new(struct supertype *c, struct active_array *a,
8263 char *inst)
8264{
8265 struct intel_super *super = c->sb;
8266 struct imsm_super *mpb = super->anchor;
bbab0940 8267 struct imsm_update_prealloc_bb_mem u;
9587c373 8268
97b4d0e9 8269 if (atoi(inst) >= mpb->num_raid_devs) {
1ade5cc1 8270 pr_err("subarry index %d, out of range\n", atoi(inst));
97b4d0e9
DW		 8271 return -ENODEV;
8272 }
8273
8274 dprintf("imsm: open_new %s\n", inst);
8275 a->info.container_member = atoi(inst);
bbab0940
TM		 8276
8277 u.type = update_prealloc_badblocks_mem;
8278 imsm_update_metadata_locally(c, &u, sizeof(u));
8279
97b4d0e9
DW		 8280 return 0;
8281}
8282
0c046afd
DW		 8283static int is_resyncing(struct imsm_dev *dev)
8284{
8285 struct imsm_map *migr_map;
8286
8287 if (!dev->vol.migr_state)
8288 return 0;
8289
1484e727
DW		 8290 if (migr_type(dev) == MIGR_INIT ||
8291 migr_type(dev) == MIGR_REPAIR)
0c046afd
DW		 8292 return 1;
8293
4c9bc37b
AK		 8294 if (migr_type(dev) == MIGR_GEN_MIGR)
8295 return 0;
8296
238c0a71 8297 migr_map = get_imsm_map(dev, MAP_1);
0c046afd 8298
089f9d79
JS		 8299 if (migr_map->map_state == IMSM_T_STATE_NORMAL &&
8300 dev->vol.migr_type != MIGR_GEN_MIGR)
0c046afd
DW		 8301 return 1;
8302 else
8303 return 0;
8304}
8305
0556e1a2 8306/* return true if we recorded new information */
4c9e8c1e
TM		 8307static int mark_failure(struct intel_super *super,
8308 struct imsm_dev *dev, struct imsm_disk *disk, int idx)
47ee5a45 8309{
0556e1a2
DW		 8310 __u32 ord;
8311 int slot;
8312 struct imsm_map *map;
86c54047
DW		 8313 char buf[MAX_RAID_SERIAL_LEN+3];
8314 unsigned int len, shift = 0;
0556e1a2
DW		 8315
8316 /* new failures are always set in map[0] */
238c0a71 8317 map = get_imsm_map(dev, MAP_0);
0556e1a2
DW		 8318
8319 slot = get_imsm_disk_slot(map, idx);
8320 if (slot < 0)
8321 return 0;
8322
8323 ord = __le32_to_cpu(map->disk_ord_tbl[slot]);
25ed7e59 8324 if (is_failed(disk) && (ord & IMSM_ORD_REBUILD))
0556e1a2
DW		 8325 return 0;
8326
7d0c5e24
LD		 8327 memcpy(buf, disk->serial, MAX_RAID_SERIAL_LEN);
8328 buf[MAX_RAID_SERIAL_LEN] = '\000';
8329 strcat(buf, ":0");
86c54047
DW		 8330 if ((len = strlen(buf)) >= MAX_RAID_SERIAL_LEN)
8331 shift = len - MAX_RAID_SERIAL_LEN + 1;
167d8bb8 8332 memcpy(disk->serial, &buf[shift], len + 1 - shift);
86c54047 8333
f2f27e63 8334 disk->status |= FAILED_DISK;
0556e1a2 8335 set_imsm_ord_tbl_ent(map, slot, idx | IMSM_ORD_REBUILD);
17788994
AK		 8336 /* mark failures in second map if second map exists and this disk
8337 * in this slot.
8338 * This is valid for migration, initialization and rebuild
8339 */
8340 if (dev->vol.migr_state) {
238c0a71 8341 struct imsm_map *map2 = get_imsm_map(dev, MAP_1);
0a108d63
AK		 8342 int slot2 = get_imsm_disk_slot(map2, idx);
8343
089f9d79 8344 if (slot2 < map2->num_members && slot2 >= 0)
0a108d63 8345 set_imsm_ord_tbl_ent(map2, slot2,
1ace8403
AK		 8346 idx | IMSM_ORD_REBUILD);
8347 }
d7a1fda2
MT		 8348 if (map->failed_disk_num == 0xff ||
8349 (!is_rebuilding(dev) && map->failed_disk_num > slot))
0556e1a2 8350 map->failed_disk_num = slot;
4c9e8c1e
TM		 8351
8352 clear_disk_badblocks(super->bbm_log, ord_to_idx(ord));
8353
0556e1a2
DW		 8354 return 1;
8355}
8356
4c9e8c1e
TM		 8357static void mark_missing(struct intel_super *super,
8358 struct imsm_dev *dev, struct imsm_disk *disk, int idx)
0556e1a2 8359{
4c9e8c1e 8360 mark_failure(super, dev, disk, idx);
0556e1a2
DW		 8361
8362 if (disk->scsi_id == __cpu_to_le32(~(__u32)0))
8363 return;
8364
47ee5a45
DW		 8365 disk->scsi_id = __cpu_to_le32(~(__u32)0);
8366 memmove(&disk->serial[0], &disk->serial[1], MAX_RAID_SERIAL_LEN - 1);
8367}
8368
33414a01
DW		 8369static void handle_missing(struct intel_super *super, struct imsm_dev *dev)
8370{
33414a01 8371 struct dl *dl;
33414a01
DW		 8372
8373 if (!super->missing)
8374 return;
33414a01 8375
79b68f1b
PC		 8376 /* When orom adds replacement for missing disk it does
8377 * not remove entry of missing disk, but just updates map with
8378 * new added disk. So it is not enough just to test if there is
8379 * any missing disk, we have to look if there are any failed disks
8380 * in map to stop migration */
8381
33414a01 8382 dprintf("imsm: mark missing\n");
3d59f0c0
AK		 8383 /* end process for initialization and rebuild only
8384 */
8385 if (is_gen_migration(dev) == 0) {
fb12a745 8386 int failed = imsm_count_failed(super, dev, MAP_0);
3d59f0c0 8387
fb12a745
TM		 8388 if (failed) {
8389 __u8 map_state;
8390 struct imsm_map *map = get_imsm_map(dev, MAP_0);
8391 struct imsm_map *map1;
8392 int i, ord, ord_map1;
8393 int rebuilt = 1;
3d59f0c0 8394
fb12a745
TM		 8395 for (i = 0; i < map->num_members; i++) {
8396 ord = get_imsm_ord_tbl_ent(dev, i, MAP_0);
8397 if (!(ord & IMSM_ORD_REBUILD))
8398 continue;
8399
8400 map1 = get_imsm_map(dev, MAP_1);
8401 if (!map1)
8402 continue;
8403
8404 ord_map1 = __le32_to_cpu(map1->disk_ord_tbl[i]);
8405 if (ord_map1 & IMSM_ORD_REBUILD)
8406 rebuilt = 0;
8407 }
8408
8409 if (rebuilt) {
8410 map_state = imsm_check_degraded(super, dev,
8411 failed, MAP_0);
8412 end_migration(dev, super, map_state);
8413 }
8414 }
3d59f0c0 8415 }
33414a01 8416 for (dl = super->missing; dl; dl = dl->next)
4c9e8c1e 8417 mark_missing(super, dev, &dl->disk, dl->index);
33414a01
DW		 8418 super->updates_pending++;
8419}
8420
f3871fdc
AK		 8421static unsigned long long imsm_set_array_size(struct imsm_dev *dev,
8422 long long new_size)
70bdf0dc 8423{
70bdf0dc 8424 unsigned long long array_blocks;
9529d343
MD		 8425 struct imsm_map *map = get_imsm_map(dev, MAP_0);
8426 int used_disks = imsm_num_data_members(map);
70bdf0dc
AK		 8427
8428 if (used_disks == 0) {
8429 /* when problems occures
8430 * return current array_blocks value
8431 */
fcc2c9da 8432 array_blocks = imsm_dev_size(dev);
70bdf0dc
AK		 8433
8434 return array_blocks;
8435 }
8436
8437 /* set array size in metadata
8438 */
9529d343 8439 if (new_size <= 0)
f3871fdc
AK		 8440 /* OLCE size change is caused by added disks
8441 */
44490938 8442 array_blocks = per_dev_array_size(map) * used_disks;
9529d343 8443 else
f3871fdc
AK		 8444 /* Online Volume Size Change
8445 * Using available free space
8446 */
8447 array_blocks = new_size;
70bdf0dc 8448
b53bfba6 8449 array_blocks = round_size_to_mb(array_blocks, used_disks);
fcc2c9da 8450 set_imsm_dev_size(dev, array_blocks);
70bdf0dc
AK		 8451
8452 return array_blocks;
8453}
8454
28bce06f
AK		 8455static void imsm_set_disk(struct active_array *a, int n, int state);
8456
0e2d1a4e
AK		 8457static void imsm_progress_container_reshape(struct intel_super *super)
8458{
8459 /* if no device has a migr_state, but some device has a
8460 * different number of members than the previous device, start
8461 * changing the number of devices in this device to match
8462 * previous.
8463 */
8464 struct imsm_super *mpb = super->anchor;
8465 int prev_disks = -1;
8466 int i;
1dfaa380 8467 int copy_map_size;
0e2d1a4e
AK		 8468
8469 for (i = 0; i < mpb->num_raid_devs; i++) {
8470 struct imsm_dev *dev = get_imsm_dev(super, i);
238c0a71 8471 struct imsm_map *map = get_imsm_map(dev, MAP_0);
0e2d1a4e
AK		 8472 struct imsm_map *map2;
8473 int prev_num_members;
0e2d1a4e
AK		 8474
8475 if (dev->vol.migr_state)
8476 return;
8477
8478 if (prev_disks == -1)
8479 prev_disks = map->num_members;
8480 if (prev_disks == map->num_members)
8481 continue;
8482
8483 /* OK, this array needs to enter reshape mode.
8484 * i.e it needs a migr_state
8485 */
8486
1dfaa380 8487 copy_map_size = sizeof_imsm_map(map);
0e2d1a4e
AK		 8488 prev_num_members = map->num_members;
8489 map->num_members = prev_disks;
8490 dev->vol.migr_state = 1;
8491 dev->vol.curr_migr_unit = 0;
ea672ee1 8492 set_migr_type(dev, MIGR_GEN_MIGR);
0e2d1a4e
AK		 8493 for (i = prev_num_members;
8494 i < map->num_members; i++)
8495 set_imsm_ord_tbl_ent(map, i, i);
238c0a71 8496 map2 = get_imsm_map(dev, MAP_1);
0e2d1a4e 8497 /* Copy the current map */
1dfaa380 8498 memcpy(map2, map, copy_map_size);
0e2d1a4e
AK		 8499 map2->num_members = prev_num_members;
8500
f3871fdc 8501 imsm_set_array_size(dev, -1);
51d83f5d 8502 super->clean_migration_record_by_mdmon = 1;
0e2d1a4e
AK		 8503 super->updates_pending++;
8504 }
8505}
8506
aad6f216 8507/* Handle dirty -> clean transititions, resync and reshape. Degraded and rebuild
0c046afd
DW		 8508 * states are handled in imsm_set_disk() with one exception, when a
8509 * resync is stopped due to a new failure this routine will set the
8510 * 'degraded' state for the array.
8511 */
01f157d7 8512static int imsm_set_array_state(struct active_array *a, int consistent)
a862209d
DW		 8513{
8514 int inst = a->info.container_member;
8515 struct intel_super *super = a->container->sb;
949c47a0 8516 struct imsm_dev *dev = get_imsm_dev(super, inst);
238c0a71 8517 struct imsm_map *map = get_imsm_map(dev, MAP_0);
3b451610
AK		 8518 int failed = imsm_count_failed(super, dev, MAP_0);
8519 __u8 map_state = imsm_check_degraded(super, dev, failed, MAP_0);
1e5c6983 8520 __u32 blocks_per_unit;
a862209d 8521
1af97990
AK		 8522 if (dev->vol.migr_state &&
8523 dev->vol.migr_type == MIGR_GEN_MIGR) {
8524 /* array state change is blocked due to reshape action
aad6f216
N		 8525 * We might need to
8526 * - abort the reshape (if last_checkpoint is 0 and action!= reshape)
8527 * - finish the reshape (if last_checkpoint is big and action != reshape)
8528 * - update curr_migr_unit
1af97990 8529 */
aad6f216
N		 8530 if (a->curr_action == reshape) {
8531 /* still reshaping, maybe update curr_migr_unit */
633b5610 8532 goto mark_checkpoint;
aad6f216
N		 8533 } else {
8534 if (a->last_checkpoint == 0 && a->prev_action == reshape) {
8535 /* for some reason we aborted the reshape.
b66e591b
AK		 8536 *
8537 * disable automatic metadata rollback
8538 * user action is required to recover process
aad6f216 8539 */
b66e591b 8540 if (0) {
238c0a71
AK		 8541 struct imsm_map *map2 =
8542 get_imsm_map(dev, MAP_1);
8543 dev->vol.migr_state = 0;
8544 set_migr_type(dev, 0);
8545 dev->vol.curr_migr_unit = 0;
8546 memcpy(map, map2,
8547 sizeof_imsm_map(map2));
8548 super->updates_pending++;
b66e591b 8549 }
aad6f216
N		 8550 }
8551 if (a->last_checkpoint >= a->info.component_size) {
8552 unsigned long long array_blocks;
8553 int used_disks;
e154ced3 8554 struct mdinfo *mdi;
aad6f216 8555
9529d343 8556 used_disks = imsm_num_data_members(map);
d55adef9
AK		 8557 if (used_disks > 0) {
8558 array_blocks =
44490938 8559 per_dev_array_size(map) *
d55adef9 8560 used_disks;
b53bfba6
TM		 8561 array_blocks =
8562 round_size_to_mb(array_blocks,
8563 used_disks);
d55adef9
AK		 8564 a->info.custom_array_size = array_blocks;
8565 /* encourage manager to update array
8566 * size
8567 */
e154ced3 8568
d55adef9 8569 a->check_reshape = 1;
633b5610 8570 }
e154ced3
AK		 8571 /* finalize online capacity expansion/reshape */
8572 for (mdi = a->info.devs; mdi; mdi = mdi->next)
8573 imsm_set_disk(a,
8574 mdi->disk.raid_disk,
8575 mdi->curr_state);
8576
0e2d1a4e 8577 imsm_progress_container_reshape(super);
e154ced3 8578 }
aad6f216 8579 }
1af97990
AK		 8580 }
8581
47ee5a45 8582 /* before we activate this array handle any missing disks */
33414a01
DW		 8583 if (consistent == 2)
8584 handle_missing(super, dev);
1e5c6983 8585
0c046afd 8586 if (consistent == 2 &&
b7941fd6 8587 (!is_resync_complete(&a->info) ||
0c046afd
DW		 8588 map_state != IMSM_T_STATE_NORMAL ||
8589 dev->vol.migr_state))
01f157d7 8590 consistent = 0;
272906ef 8591
b7941fd6 8592 if (is_resync_complete(&a->info)) {
0c046afd 8593 /* complete intialization / resync,
0556e1a2
DW		 8594 * recovery and interrupted recovery is completed in
8595 * ->set_disk
0c046afd
DW		 8596 */
8597 if (is_resyncing(dev)) {
8598 dprintf("imsm: mark resync done\n");
809da78e 8599 end_migration(dev, super, map_state);
115c3803 8600 super->updates_pending++;
484240d8 8601 a->last_checkpoint = 0;
115c3803 8602 }
b9172665
AK		 8603 } else if ((!is_resyncing(dev) && !failed) &&
8604 (imsm_reshape_blocks_arrays_changes(super) == 0)) {
0c046afd 8605 /* mark the start of the init process if nothing is failed */
b7941fd6 8606 dprintf("imsm: mark resync start\n");
1484e727 8607 if (map->map_state == IMSM_T_STATE_UNINITIALIZED)
8e59f3d8 8608 migrate(dev, super, IMSM_T_STATE_NORMAL, MIGR_INIT);
1484e727 8609 else
8e59f3d8 8610 migrate(dev, super, IMSM_T_STATE_NORMAL, MIGR_REPAIR);
3393c6af 8611 super->updates_pending++;
115c3803 8612 }
a862209d 8613
633b5610 8614mark_checkpoint:
5b83bacf
AK		 8615 /* skip checkpointing for general migration,
8616 * it is controlled in mdadm
8617 */
8618 if (is_gen_migration(dev))
8619 goto skip_mark_checkpoint;
8620
1e5c6983 8621 /* check if we can update curr_migr_unit from resync_start, recovery_start */
c47b0ff6 8622 blocks_per_unit = blocks_per_migr_unit(super, dev);
4f0a7acc 8623 if (blocks_per_unit) {
1e5c6983
DW		 8624 __u32 units32;
8625 __u64 units;
8626
4f0a7acc 8627 units = a->last_checkpoint / blocks_per_unit;
1e5c6983
DW		 8628 units32 = units;
8629
8630 /* check that we did not overflow 32-bits, and that
8631 * curr_migr_unit needs updating
8632 */
8633 if (units32 == units &&
bfd80a56 8634 units32 != 0 &&
1e5c6983
DW		 8635 __le32_to_cpu(dev->vol.curr_migr_unit) != units32) {
8636 dprintf("imsm: mark checkpoint (%u)\n", units32);
8637 dev->vol.curr_migr_unit = __cpu_to_le32(units32);
8638 super->updates_pending++;
8639 }
8640 }
f8f603f1 8641
5b83bacf 8642skip_mark_checkpoint:
3393c6af 8643 /* mark dirty / clean */
2432ce9b
AP		 8644 if (((dev->vol.dirty & RAIDVOL_DIRTY) && consistent) ||
8645 (!(dev->vol.dirty & RAIDVOL_DIRTY) && !consistent)) {
b7941fd6 8646 dprintf("imsm: mark '%s'\n", consistent ? "clean" : "dirty");
2432ce9b
AP		 8647 if (consistent) {
8648 dev->vol.dirty = RAIDVOL_CLEAN;
8649 } else {
8650 dev->vol.dirty = RAIDVOL_DIRTY;
c2462068
PB		 8651 if (dev->rwh_policy == RWH_DISTRIBUTED ||
8652 dev->rwh_policy == RWH_MULTIPLE_DISTRIBUTED)
2432ce9b
AP		 8653 dev->vol.dirty |= RAIDVOL_DSRECORD_VALID;
8654 }
a862209d
DW		 8655 super->updates_pending++;
8656 }
28bce06f 8657
01f157d7 8658 return consistent;
a862209d
DW		 8659}
8660
6f50473f
TM		 8661static int imsm_disk_slot_to_ord(struct active_array *a, int slot)
8662{
8663 int inst = a->info.container_member;
8664 struct intel_super *super = a->container->sb;
8665 struct imsm_dev *dev = get_imsm_dev(super, inst);
8666 struct imsm_map *map = get_imsm_map(dev, MAP_0);
8667
8668 if (slot > map->num_members) {
8669 pr_err("imsm: imsm_disk_slot_to_ord %d out of range 0..%d\n",
8670 slot, map->num_members - 1);
8671 return -1;
8672 }
8673
8674 if (slot < 0)
8675 return -1;
8676
8677 return get_imsm_ord_tbl_ent(dev, slot, MAP_0);
8678}
8679
8d45d196 8680static void imsm_set_disk(struct active_array *a, int n, int state)
845dea95 8681{
8d45d196
DW		 8682 int inst = a->info.container_member;
8683 struct intel_super *super = a->container->sb;
949c47a0 8684 struct imsm_dev *dev = get_imsm_dev(super, inst);
238c0a71 8685 struct imsm_map *map = get_imsm_map(dev, MAP_0);
8d45d196 8686 struct imsm_disk *disk;
7ce05701
LD		 8687 struct mdinfo *mdi;
8688 int recovery_not_finished = 0;
0c046afd 8689 int failed;
6f50473f 8690 int ord;
0c046afd 8691 __u8 map_state;
fb12a745
TM		 8692 int rebuild_done = 0;
8693 int i;
8d45d196 8694
fb12a745 8695 ord = get_imsm_ord_tbl_ent(dev, n, MAP_X);
6f50473f 8696 if (ord < 0)
8d45d196
DW		 8697 return;
8698
4e6e574a 8699 dprintf("imsm: set_disk %d:%x\n", n, state);
b10b37b8 8700 disk = get_imsm_disk(super, ord_to_idx(ord));
8d45d196 8701
5802a811 8702 /* check for new failures */
ae7d61e3 8703 if (disk && (state & DS_FAULTY)) {
4c9e8c1e 8704 if (mark_failure(super, dev, disk, ord_to_idx(ord)))
0556e1a2 8705 super->updates_pending++;
8d45d196 8706 }
47ee5a45 8707
19859edc 8708 /* check if in_sync */
0556e1a2 8709 if (state & DS_INSYNC && ord & IMSM_ORD_REBUILD && is_rebuilding(dev)) {
238c0a71 8710 struct imsm_map *migr_map = get_imsm_map(dev, MAP_1);
b10b37b8
DW		 8711
8712 set_imsm_ord_tbl_ent(migr_map, n, ord_to_idx(ord));
fb12a745 8713 rebuild_done = 1;
19859edc
DW		 8714 super->updates_pending++;
8715 }
8d45d196 8716
3b451610
AK		 8717 failed = imsm_count_failed(super, dev, MAP_0);
8718 map_state = imsm_check_degraded(super, dev, failed, MAP_0);
5802a811 8719
0c046afd 8720 /* check if recovery complete, newly degraded, or failed */
94002678
AK		 8721 dprintf("imsm: Detected transition to state ");
8722 switch (map_state) {
8723 case IMSM_T_STATE_NORMAL: /* transition to normal state */
8724 dprintf("normal: ");
8725 if (is_rebuilding(dev)) {
1ade5cc1 8726 dprintf_cont("while rebuilding");
7ce05701
LD		 8727 /* check if recovery is really finished */
8728 for (mdi = a->info.devs; mdi ; mdi = mdi->next)
8729 if (mdi->recovery_start != MaxSector) {
8730 recovery_not_finished = 1;
8731 break;
8732 }
8733 if (recovery_not_finished) {
1ade5cc1
N		 8734 dprintf_cont("\n");
8735 dprintf("Rebuild has not finished yet, state not changed");
7ce05701
LD		 8736 if (a->last_checkpoint < mdi->recovery_start) {
8737 a->last_checkpoint = mdi->recovery_start;
8738 super->updates_pending++;
8739 }
8740 break;
8741 }
94002678 8742 end_migration(dev, super, map_state);
94002678
AK		 8743 map->failed_disk_num = ~0;
8744 super->updates_pending++;
8745 a->last_checkpoint = 0;
8746 break;
8747 }
8748 if (is_gen_migration(dev)) {
1ade5cc1 8749 dprintf_cont("while general migration");
bf2f0071 8750 if (a->last_checkpoint >= a->info.component_size)
809da78e 8751 end_migration(dev, super, map_state);
94002678
AK		 8752 else
8753 map->map_state = map_state;
28bce06f 8754 map->failed_disk_num = ~0;
94002678 8755 super->updates_pending++;
bf2f0071 8756 break;
94002678
AK		 8757 }
8758 break;
8759 case IMSM_T_STATE_DEGRADED: /* transition to degraded state */
1ade5cc1 8760 dprintf_cont("degraded: ");
089f9d79 8761 if (map->map_state != map_state && !dev->vol.migr_state) {
1ade5cc1 8762 dprintf_cont("mark degraded");
94002678
AK		 8763 map->map_state = map_state;
8764 super->updates_pending++;
8765 a->last_checkpoint = 0;
8766 break;
8767 }
8768 if (is_rebuilding(dev)) {
d7a1fda2 8769 dprintf_cont("while rebuilding ");
a4e96fd8
MT		 8770 if (state & DS_FAULTY) {
8771 dprintf_cont("removing failed drive ");
d7a1fda2
MT		 8772 if (n == map->failed_disk_num) {
8773 dprintf_cont("end migration");
8774 end_migration(dev, super, map_state);
a4e96fd8 8775 a->last_checkpoint = 0;
d7a1fda2 8776 } else {
a4e96fd8 8777 dprintf_cont("fail detected during rebuild, changing map state");
d7a1fda2
MT		 8778 map->map_state = map_state;
8779 }
94002678 8780 super->updates_pending++;
fb12a745
TM		 8781 }
8782
a4e96fd8
MT		 8783 if (!rebuild_done)
8784 break;
8785
fb12a745
TM		 8786 /* check if recovery is really finished */
8787 for (mdi = a->info.devs; mdi ; mdi = mdi->next)
8788 if (mdi->recovery_start != MaxSector) {
8789 recovery_not_finished = 1;
8790 break;
8791 }
8792 if (recovery_not_finished) {
8793 dprintf_cont("\n");
a4e96fd8 8794 dprintf_cont("Rebuild has not finished yet");
fb12a745
TM		 8795 if (a->last_checkpoint < mdi->recovery_start) {
8796 a->last_checkpoint =
8797 mdi->recovery_start;
8798 super->updates_pending++;
8799 }
8800 break;
94002678 8801 }
fb12a745
TM		 8802
8803 dprintf_cont(" Rebuild done, still degraded");
a4e96fd8
MT		 8804 end_migration(dev, super, map_state);
8805 a->last_checkpoint = 0;
8806 super->updates_pending++;
fb12a745
TM		 8807
8808 for (i = 0; i < map->num_members; i++) {
8809 int idx = get_imsm_ord_tbl_ent(dev, i, MAP_0);
8810
8811 if (idx & IMSM_ORD_REBUILD)
8812 map->failed_disk_num = i;
8813 }
8814 super->updates_pending++;
94002678
AK		 8815 break;
8816 }
8817 if (is_gen_migration(dev)) {
1ade5cc1 8818 dprintf_cont("while general migration");
bf2f0071 8819 if (a->last_checkpoint >= a->info.component_size)
809da78e 8820 end_migration(dev, super, map_state);
94002678
AK		 8821 else {
8822 map->map_state = map_state;
3b451610 8823 manage_second_map(super, dev);
94002678
AK		 8824 }
8825 super->updates_pending++;
bf2f0071 8826 break;
28bce06f 8827 }
6ce1fbf1 8828 if (is_initializing(dev)) {
1ade5cc1 8829 dprintf_cont("while initialization.");
6ce1fbf1
AK		 8830 map->map_state = map_state;
8831 super->updates_pending++;
8832 break;
8833 }
94002678
AK		 8834 break;
8835 case IMSM_T_STATE_FAILED: /* transition to failed state */
1ade5cc1 8836 dprintf_cont("failed: ");
94002678 8837 if (is_gen_migration(dev)) {
1ade5cc1 8838 dprintf_cont("while general migration");
94002678
AK		 8839 map->map_state = map_state;
8840 super->updates_pending++;
8841 break;
8842 }
8843 if (map->map_state != map_state) {
1ade5cc1 8844 dprintf_cont("mark failed");
94002678
AK		 8845 end_migration(dev, super, map_state);
8846 super->updates_pending++;
8847 a->last_checkpoint = 0;
8848 break;
8849 }
8850 break;
8851 default:
1ade5cc1 8852 dprintf_cont("state %i\n", map_state);
5802a811 8853 }
1ade5cc1 8854 dprintf_cont("\n");
845dea95
NB		 8855}
8856
f796af5d 8857static int store_imsm_mpb(int fd, struct imsm_super *mpb)
c2a1e7da 8858{
f796af5d 8859 void *buf = mpb;
c2a1e7da
DW		 8860 __u32 mpb_size = __le32_to_cpu(mpb->mpb_size);
8861 unsigned long long dsize;
8862 unsigned long long sectors;
f36a9ecd 8863 unsigned int sector_size;
c2a1e7da 8864
f36a9ecd 8865 get_dev_sector_size(fd, NULL, &sector_size);
c2a1e7da
DW		 8866 get_dev_size(fd, NULL, &dsize);
8867
f36a9ecd 8868 if (mpb_size > sector_size) {
272f648f 8869 /* -1 to account for anchor */
f36a9ecd 8870 sectors = mpb_sectors(mpb, sector_size) - 1;
c2a1e7da 8871
272f648f 8872 /* write the extended mpb to the sectors preceeding the anchor */
f36a9ecd
PB		 8873 if (lseek64(fd, dsize - (sector_size * (2 + sectors)),
8874 SEEK_SET) < 0)
272f648f 8875 return 1;
c2a1e7da 8876
f36a9ecd
PB		 8877 if ((unsigned long long)write(fd, buf + sector_size,
8878 sector_size * sectors) != sector_size * sectors)
272f648f
DW		 8879 return 1;
8880 }
c2a1e7da 8881
272f648f 8882 /* first block is stored on second to last sector of the disk */
f36a9ecd 8883 if (lseek64(fd, dsize - (sector_size * 2), SEEK_SET) < 0)
c2a1e7da
DW		 8884 return 1;
8885
466070ad 8886 if ((unsigned int)write(fd, buf, sector_size) != sector_size)
c2a1e7da
DW		 8887 return 1;
8888
c2a1e7da
DW		 8889 return 0;
8890}
8891
2e735d19 8892static void imsm_sync_metadata(struct supertype *container)
845dea95 8893{
2e735d19 8894 struct intel_super *super = container->sb;
c2a1e7da 8895
1a64be56 8896 dprintf("sync metadata: %d\n", super->updates_pending);
c2a1e7da
DW		 8897 if (!super->updates_pending)
8898 return;
8899
36988a3d 8900 write_super_imsm(container, 0);
c2a1e7da
DW		 8901
8902 super->updates_pending = 0;
845dea95
NB		 8903}
8904
272906ef
DW		 8905static struct dl *imsm_readd(struct intel_super *super, int idx, struct active_array *a)
8906{
8907 struct imsm_dev *dev = get_imsm_dev(super, a->info.container_member);
238c0a71 8908 int i = get_imsm_disk_idx(dev, idx, MAP_X);
272906ef
DW		 8909 struct dl *dl;
8910
8911 for (dl = super->disks; dl; dl = dl->next)
8912 if (dl->index == i)
8913 break;
8914
25ed7e59 8915 if (dl && is_failed(&dl->disk))
272906ef
DW		 8916 dl = NULL;
8917
8918 if (dl)
1ade5cc1 8919 dprintf("found %x:%x\n", dl->major, dl->minor);
272906ef
DW		 8920
8921 return dl;
8922}
8923
a20d2ba5 8924static struct dl *imsm_add_spare(struct intel_super *super, int slot,
8ba77d32
AK		 8925 struct active_array *a, int activate_new,
8926 struct mdinfo *additional_test_list)
272906ef
DW		 8927{
8928 struct imsm_dev *dev = get_imsm_dev(super, a->info.container_member);
238c0a71 8929 int idx = get_imsm_disk_idx(dev, slot, MAP_X);
a20d2ba5
DW		 8930 struct imsm_super *mpb = super->anchor;
8931 struct imsm_map *map;
272906ef
DW		 8932 unsigned long long pos;
8933 struct mdinfo *d;
8934 struct extent *ex;
a20d2ba5 8935 int i, j;
272906ef 8936 int found;
569cc43f
DW		 8937 __u32 array_start = 0;
8938 __u32 array_end = 0;
272906ef 8939 struct dl *dl;
6c932028 8940 struct mdinfo *test_list;
272906ef
DW		 8941
8942 for (dl = super->disks; dl; dl = dl->next) {
8943 /* If in this array, skip */
8944 for (d = a->info.devs ; d ; d = d->next)
e553d2a4
DW		 8945 if (d->state_fd >= 0 &&
8946 d->disk.major == dl->major &&
272906ef 8947 d->disk.minor == dl->minor) {
8ba77d32
AK		 8948 dprintf("%x:%x already in array\n",
8949 dl->major, dl->minor);
272906ef
DW		 8950 break;
8951 }
8952 if (d)
8953 continue;
6c932028
AK		 8954 test_list = additional_test_list;
8955 while (test_list) {
8956 if (test_list->disk.major == dl->major &&
8957 test_list->disk.minor == dl->minor) {
8ba77d32
AK		 8958 dprintf("%x:%x already in additional test list\n",
8959 dl->major, dl->minor);
8960 break;
8961 }
6c932028 8962 test_list = test_list->next;
8ba77d32 8963 }
6c932028 8964 if (test_list)
8ba77d32 8965 continue;
272906ef 8966
e553d2a4 8967 /* skip in use or failed drives */
25ed7e59 8968 if (is_failed(&dl->disk) || idx == dl->index ||
df474657
DW		 8969 dl->index == -2) {
8970 dprintf("%x:%x status (failed: %d index: %d)\n",
25ed7e59 8971 dl->major, dl->minor, is_failed(&dl->disk), idx);
9a1608e5
DW		 8972 continue;
8973 }
8974
a20d2ba5
DW		 8975 /* skip pure spares when we are looking for partially
8976 * assimilated drives
8977 */
8978 if (dl->index == -1 && !activate_new)
8979 continue;
8980
f2cc4f7d
AO		 8981 if (!drive_validate_sector_size(super, dl))
8982 continue;
8983
272906ef 8984 /* Does this unused device have the requisite free space?
a20d2ba5 8985 * It needs to be able to cover all member volumes
272906ef 8986 */
05501181 8987 ex = get_extents(super, dl, 1);
272906ef
DW		 8988 if (!ex) {
8989 dprintf("cannot get extents\n");
8990 continue;
8991 }
a20d2ba5
DW		 8992 for (i = 0; i < mpb->num_raid_devs; i++) {
8993 dev = get_imsm_dev(super, i);
238c0a71 8994 map = get_imsm_map(dev, MAP_0);
272906ef 8995
a20d2ba5
DW		 8996 /* check if this disk is already a member of
8997 * this array
272906ef 8998 */
620b1713 8999 if (get_imsm_disk_slot(map, dl->index) >= 0)
a20d2ba5
DW		 9000 continue;
9001
9002 found = 0;
9003 j = 0;
9004 pos = 0;
5551b113 9005 array_start = pba_of_lba0(map);
329c8278 9006 array_end = array_start +
44490938 9007 per_dev_array_size(map) - 1;
a20d2ba5
DW		 9008
9009 do {
9010 /* check that we can start at pba_of_lba0 with
44490938 9011 * num_data_stripes*blocks_per_stripe of space
a20d2ba5 9012 */
329c8278 9013 if (array_start >= pos && array_end < ex[j].start) {
a20d2ba5
DW		 9014 found = 1;
9015 break;
9016 }
9017 pos = ex[j].start + ex[j].size;
9018 j++;
9019 } while (ex[j-1].size);
9020
9021 if (!found)
272906ef 9022 break;
a20d2ba5 9023 }
272906ef
DW		 9024
9025 free(ex);
a20d2ba5 9026 if (i < mpb->num_raid_devs) {
329c8278
DW		 9027 dprintf("%x:%x does not have %u to %u available\n",
9028 dl->major, dl->minor, array_start, array_end);
272906ef
DW		 9029 /* No room */
9030 continue;
a20d2ba5
DW		 9031 }
9032 return dl;
272906ef
DW		 9033 }
9034
9035 return dl;
9036}
9037
95d07a2c
LM		 9038static int imsm_rebuild_allowed(struct supertype *cont, int dev_idx, int failed)
9039{
9040 struct imsm_dev *dev2;
9041 struct imsm_map *map;
9042 struct dl *idisk;
9043 int slot;
9044 int idx;
9045 __u8 state;
9046
9047 dev2 = get_imsm_dev(cont->sb, dev_idx);
9048 if (dev2) {
238c0a71 9049 state = imsm_check_degraded(cont->sb, dev2, failed, MAP_0);
95d07a2c 9050 if (state == IMSM_T_STATE_FAILED) {
238c0a71 9051 map = get_imsm_map(dev2, MAP_0);
95d07a2c
LM		 9052 if (!map)
9053 return 1;
9054 for (slot = 0; slot < map->num_members; slot++) {
9055 /*
9056 * Check if failed disks are deleted from intel
9057 * disk list or are marked to be deleted
9058 */
238c0a71 9059 idx = get_imsm_disk_idx(dev2, slot, MAP_X);
95d07a2c
LM		 9060 idisk = get_imsm_dl_disk(cont->sb, idx);
9061 /*
9062 * Do not rebuild the array if failed disks
9063 * from failed sub-array are not removed from
9064 * container.
9065 */
9066 if (idisk &&
9067 is_failed(&idisk->disk) &&
9068 (idisk->action != DISK_REMOVE))
9069 return 0;
9070 }
9071 }
9072 }
9073 return 1;
9074}
9075
88758e9d
DW		 9076static struct mdinfo *imsm_activate_spare(struct active_array *a,
9077 struct metadata_update **updates)
9078{
9079 /**
d23fe947
DW		 9080 * Find a device with unused free space and use it to replace a
9081 * failed/vacant region in an array. We replace failed regions one a
9082 * array at a time. The result is that a new spare disk will be added
9083 * to the first failed array and after the monitor has finished
9084 * propagating failures the remainder will be consumed.
88758e9d 9085 *
d23fe947
DW		 9086 * FIXME add a capability for mdmon to request spares from another
9087 * container.
88758e9d
DW		 9088 */
9089
9090 struct intel_super *super = a->container->sb;
88758e9d 9091 int inst = a->info.container_member;
949c47a0 9092 struct imsm_dev *dev = get_imsm_dev(super, inst);
238c0a71 9093 struct imsm_map *map = get_imsm_map(dev, MAP_0);
88758e9d
DW		 9094 int failed = a->info.array.raid_disks;
9095 struct mdinfo *rv = NULL;
9096 struct mdinfo *d;
9097 struct mdinfo *di;
9098 struct metadata_update *mu;
9099 struct dl *dl;
9100 struct imsm_update_activate_spare *u;
9101 int num_spares = 0;
9102 int i;
95d07a2c 9103 int allowed;
88758e9d
DW		 9104
9105 for (d = a->info.devs ; d ; d = d->next) {
9106 if ((d->curr_state & DS_FAULTY) &&
9107 d->state_fd >= 0)
9108 /* wait for Removal to happen */
9109 return NULL;
9110 if (d->state_fd >= 0)
9111 failed--;
9112 }
9113
9114 dprintf("imsm: activate spare: inst=%d failed=%d (%d) level=%d\n",
9115 inst, failed, a->info.array.raid_disks, a->info.array.level);
1af97990 9116
e2962bfc
AK		 9117 if (imsm_reshape_blocks_arrays_changes(super))
9118 return NULL;
1af97990 9119
fc8ca064
AK		 9120 /* Cannot activate another spare if rebuild is in progress already
9121 */
9122 if (is_rebuilding(dev)) {
7a862a02 9123 dprintf("imsm: No spare activation allowed. Rebuild in progress already.\n");
fc8ca064
AK		 9124 return NULL;
9125 }
9126
89c67882
AK		 9127 if (a->info.array.level == 4)
9128 /* No repair for takeovered array
9129 * imsm doesn't support raid4
9130 */
9131 return NULL;
9132
3b451610
AK		 9133 if (imsm_check_degraded(super, dev, failed, MAP_0) !=
9134 IMSM_T_STATE_DEGRADED)
88758e9d
DW		 9135 return NULL;
9136
83ca7d45
AP		 9137 if (get_imsm_map(dev, MAP_0)->map_state == IMSM_T_STATE_UNINITIALIZED) {
9138 dprintf("imsm: No spare activation allowed. Volume is not initialized.\n");
9139 return NULL;
9140 }
9141
95d07a2c
LM		 9142 /*
9143 * If there are any failed disks check state of the other volume.
9144 * Block rebuild if the another one is failed until failed disks
9145 * are removed from container.
9146 */
9147 if (failed) {
7a862a02 9148 dprintf("found failed disks in %.*s, check if there anotherfailed sub-array.\n",
c4acd1e5 9149 MAX_RAID_SERIAL_LEN, dev->volume);
95d07a2c
LM		 9150 /* check if states of the other volumes allow for rebuild */
9151 for (i = 0; i < super->anchor->num_raid_devs; i++) {
9152 if (i != inst) {
9153 allowed = imsm_rebuild_allowed(a->container,
9154 i, failed);
9155 if (!allowed)
9156 return NULL;
9157 }
9158 }
9159 }
9160
88758e9d 9161 /* For each slot, if it is not working, find a spare */
88758e9d
DW		 9162 for (i = 0; i < a->info.array.raid_disks; i++) {
9163 for (d = a->info.devs ; d ; d = d->next)
9164 if (d->disk.raid_disk == i)
9165 break;
9166 dprintf("found %d: %p %x\n", i, d, d?d->curr_state:0);
9167 if (d && (d->state_fd >= 0))
9168 continue;
9169
272906ef 9170 /*
a20d2ba5
DW		 9171 * OK, this device needs recovery. Try to re-add the
9172 * previous occupant of this slot, if this fails see if
9173 * we can continue the assimilation of a spare that was
9174 * partially assimilated, finally try to activate a new
9175 * spare.
272906ef
DW		 9176 */
9177 dl = imsm_readd(super, i, a);
9178 if (!dl)
b303fe21 9179 dl = imsm_add_spare(super, i, a, 0, rv);
a20d2ba5 9180 if (!dl)
b303fe21 9181 dl = imsm_add_spare(super, i, a, 1, rv);
272906ef
DW		 9182 if (!dl)
9183 continue;
1011e834 9184
272906ef 9185 /* found a usable disk with enough space */
503975b9 9186 di = xcalloc(1, sizeof(*di));
272906ef
DW		 9187
9188 /* dl->index will be -1 in the case we are activating a
9189 * pristine spare. imsm_process_update() will create a
9190 * new index in this case. Once a disk is found to be
9191 * failed in all member arrays it is kicked from the
9192 * metadata
9193 */
9194 di->disk.number = dl->index;
d23fe947 9195
272906ef
DW		 9196 /* (ab)use di->devs to store a pointer to the device
9197 * we chose
9198 */
9199 di->devs = (struct mdinfo *) dl;
9200
9201 di->disk.raid_disk = i;
9202 di->disk.major = dl->major;
9203 di->disk.minor = dl->minor;
9204 di->disk.state = 0;
d23534e4 9205 di->recovery_start = 0;
5551b113 9206 di->data_offset = pba_of_lba0(map);
272906ef
DW		 9207 di->component_size = a->info.component_size;
9208 di->container_member = inst;
5e46202e 9209 di->bb.supported = 1;
2c8890e9 9210 if (a->info.consistency_policy == CONSISTENCY_POLICY_PPL) {
2432ce9b 9211 di->ppl_sector = get_ppl_sector(super, inst);
c2462068 9212 di->ppl_size = MULTIPLE_PPL_AREA_SIZE_IMSM >> 9;
2432ce9b 9213 }
148acb7b 9214 super->random = random32();
272906ef
DW		 9215 di->next = rv;
9216 rv = di;
9217 num_spares++;
9218 dprintf("%x:%x to be %d at %llu\n", dl->major, dl->minor,
9219 i, di->data_offset);
88758e9d
DW		 9220 }
9221
9222 if (!rv)
9223 /* No spares found */
9224 return rv;
9225 /* Now 'rv' has a list of devices to return.
9226 * Create a metadata_update record to update the
9227 * disk_ord_tbl for the array
9228 */
503975b9 9229 mu = xmalloc(sizeof(*mu));
1011e834 9230 mu->buf = xcalloc(num_spares,
503975b9 9231 sizeof(struct imsm_update_activate_spare));
88758e9d 9232 mu->space = NULL;
cb23f1f4 9233 mu->space_list = NULL;
88758e9d
DW		 9234 mu->len = sizeof(struct imsm_update_activate_spare) * num_spares;
9235 mu->next = *updates;
9236 u = (struct imsm_update_activate_spare *) mu->buf;
9237
9238 for (di = rv ; di ; di = di->next) {
9239 u->type = update_activate_spare;
d23fe947
DW		 9240 u->dl = (struct dl *) di->devs;
9241 di->devs = NULL;
88758e9d
DW		 9242 u->slot = di->disk.raid_disk;
9243 u->array = inst;
9244 u->next = u + 1;
9245 u++;
9246 }
9247 (u-1)->next = NULL;
9248 *updates = mu;
9249
9250 return rv;
9251}
9252
54c2c1ea 9253static int disks_overlap(struct intel_super *super, int idx, struct imsm_update_create_array *u)
8273f55e 9254{
54c2c1ea 9255 struct imsm_dev *dev = get_imsm_dev(super, idx);
238c0a71
AK		 9256 struct imsm_map *map = get_imsm_map(dev, MAP_0);
9257 struct imsm_map *new_map = get_imsm_map(&u->dev, MAP_0);
54c2c1ea
DW		 9258 struct disk_info *inf = get_disk_info(u);
9259 struct imsm_disk *disk;
8273f55e
DW		 9260 int i;
9261 int j;
8273f55e 9262
54c2c1ea 9263 for (i = 0; i < map->num_members; i++) {
238c0a71 9264 disk = get_imsm_disk(super, get_imsm_disk_idx(dev, i, MAP_X));
54c2c1ea
DW		 9265 for (j = 0; j < new_map->num_members; j++)
9266 if (serialcmp(disk->serial, inf[j].serial) == 0)
8273f55e
DW		 9267 return 1;
9268 }
9269
9270 return 0;
9271}
9272
1a64be56
LM		 9273static struct dl *get_disk_super(struct intel_super *super, int major, int minor)
9274{
594dc1b8
JS		 9275 struct dl *dl;
9276
1a64be56 9277 for (dl = super->disks; dl; dl = dl->next)
089f9d79 9278 if (dl->major == major && dl->minor == minor)
1a64be56
LM		 9279 return dl;
9280 return NULL;
9281}
9282
9283static int remove_disk_super(struct intel_super *super, int major, int minor)
9284{
594dc1b8 9285 struct dl *prev;
1a64be56
LM		 9286 struct dl *dl;
9287
9288 prev = NULL;
9289 for (dl = super->disks; dl; dl = dl->next) {
089f9d79 9290 if (dl->major == major && dl->minor == minor) {
1a64be56
LM		 9291 /* remove */
9292 if (prev)
9293 prev->next = dl->next;
9294 else
9295 super->disks = dl->next;
9296 dl->next = NULL;
9297 __free_imsm_disk(dl);
1ade5cc1 9298 dprintf("removed %x:%x\n", major, minor);
1a64be56
LM		 9299 break;
9300 }
9301 prev = dl;
9302 }
9303 return 0;
9304}
9305
f21e18ca 9306static void imsm_delete(struct intel_super *super, struct dl **dlp, unsigned index);
ae6aad82 9307
1a64be56
LM		 9308static int add_remove_disk_update(struct intel_super *super)
9309{
9310 int check_degraded = 0;
594dc1b8
JS		 9311 struct dl *disk;
9312
1a64be56
LM		 9313 /* add/remove some spares to/from the metadata/contrainer */
9314 while (super->disk_mgmt_list) {
9315 struct dl *disk_cfg;
9316
9317 disk_cfg = super->disk_mgmt_list;
9318 super->disk_mgmt_list = disk_cfg->next;
9319 disk_cfg->next = NULL;
9320
9321 if (disk_cfg->action == DISK_ADD) {
9322 disk_cfg->next = super->disks;
9323 super->disks = disk_cfg;
9324 check_degraded = 1;
1ade5cc1
N		 9325 dprintf("added %x:%x\n",
9326 disk_cfg->major, disk_cfg->minor);
1a64be56
LM		 9327 } else if (disk_cfg->action == DISK_REMOVE) {
9328 dprintf("Disk remove action processed: %x.%x\n",
9329 disk_cfg->major, disk_cfg->minor);
9330 disk = get_disk_super(super,
9331 disk_cfg->major,
9332 disk_cfg->minor);
9333 if (disk) {
9334 /* store action status */
9335 disk->action = DISK_REMOVE;
9336 /* remove spare disks only */
9337 if (disk->index == -1) {
9338 remove_disk_super(super,
9339 disk_cfg->major,
9340 disk_cfg->minor);
91c97c54
MT		 9341 } else {
9342 disk_cfg->fd = disk->fd;
9343 disk->fd = -1;
1a64be56
LM		 9344 }
9345 }
9346 /* release allocate disk structure */
9347 __free_imsm_disk(disk_cfg);
9348 }
9349 }
9350 return check_degraded;
9351}
9352
a29911da
PC		 9353static int apply_reshape_migration_update(struct imsm_update_reshape_migration *u,
9354 struct intel_super *super,
9355 void ***space_list)
9356{
9357 struct intel_dev *id;
9358 void **tofree = NULL;
9359 int ret_val = 0;
9360
1ade5cc1 9361 dprintf("(enter)\n");
089f9d79 9362 if (u->subdev < 0 || u->subdev > 1) {
a29911da
PC		 9363 dprintf("imsm: Error: Wrong subdev: %i\n", u->subdev);
9364 return ret_val;
9365 }
089f9d79 9366 if (space_list == NULL || *space_list == NULL) {
a29911da
PC		 9367 dprintf("imsm: Error: Memory is not allocated\n");
9368 return ret_val;
9369 }
9370
9371 for (id = super->devlist ; id; id = id->next) {
9372 if (id->index == (unsigned)u->subdev) {
9373 struct imsm_dev *dev = get_imsm_dev(super, u->subdev);
9374 struct imsm_map *map;
9375 struct imsm_dev *new_dev =
9376 (struct imsm_dev *)*space_list;
238c0a71 9377 struct imsm_map *migr_map = get_imsm_map(dev, MAP_1);
a29911da
PC		 9378 int to_state;
9379 struct dl *new_disk;
9380
9381 if (new_dev == NULL)
9382 return ret_val;
9383 *space_list = **space_list;
9384 memcpy(new_dev, dev, sizeof_imsm_dev(dev, 0));
238c0a71 9385 map = get_imsm_map(new_dev, MAP_0);
a29911da
PC		 9386 if (migr_map) {
9387 dprintf("imsm: Error: migration in progress");
9388 return ret_val;
9389 }
9390
9391 to_state = map->map_state;
9392 if ((u->new_level == 5) && (map->raid_level == 0)) {
9393 map->num_members++;
9394 /* this should not happen */
9395 if (u->new_disks[0] < 0) {
9396 map->failed_disk_num =
9397 map->num_members - 1;
9398 to_state = IMSM_T_STATE_DEGRADED;
9399 } else
9400 to_state = IMSM_T_STATE_NORMAL;
9401 }
8e59f3d8 9402 migrate(new_dev, super, to_state, MIGR_GEN_MIGR);
a29911da
PC		 9403 if (u->new_level > -1)
9404 map->raid_level = u->new_level;
238c0a71 9405 migr_map = get_imsm_map(new_dev, MAP_1);
a29911da
PC		 9406 if ((u->new_level == 5) &&
9407 (migr_map->raid_level == 0)) {
9408 int ord = map->num_members - 1;
9409 migr_map->num_members--;
9410 if (u->new_disks[0] < 0)
9411 ord |= IMSM_ORD_REBUILD;
9412 set_imsm_ord_tbl_ent(map,
9413 map->num_members - 1,
9414 ord);
9415 }
9416 id->dev = new_dev;
9417 tofree = (void **)dev;
9418
4bba0439
PC		 9419 /* update chunk size
9420 */
06fb291a
PB		 9421 if (u->new_chunksize > 0) {
9422 unsigned long long num_data_stripes;
9529d343
MD		 9423 struct imsm_map *dest_map =
9424 get_imsm_map(dev, MAP_0);
06fb291a 9425 int used_disks =
9529d343 9426 imsm_num_data_members(dest_map);
06fb291a
PB		 9427
9428 if (used_disks == 0)
9429 return ret_val;
9430
4bba0439
PC		 9431 map->blocks_per_strip =
9432 __cpu_to_le16(u->new_chunksize * 2);
06fb291a 9433 num_data_stripes =
fcc2c9da 9434 imsm_dev_size(dev) / used_disks;
06fb291a
PB		 9435 num_data_stripes /= map->blocks_per_strip;
9436 num_data_stripes /= map->num_domains;
9437 set_num_data_stripes(map, num_data_stripes);
9438 }
4bba0439 9439
44490938
MD		 9440 /* ensure blocks_per_member has valid value
9441 */
9442 set_blocks_per_member(map,
9443 per_dev_array_size(map) +
9444 NUM_BLOCKS_DIRTY_STRIPE_REGION);
9445
a29911da
PC		 9446 /* add disk
9447 */
089f9d79
JS		 9448 if (u->new_level != 5 || migr_map->raid_level != 0 ||
9449 migr_map->raid_level == map->raid_level)
a29911da
PC		 9450 goto skip_disk_add;
9451
9452 if (u->new_disks[0] >= 0) {
9453 /* use passes spare
9454 */
9455 new_disk = get_disk_super(super,
9456 major(u->new_disks[0]),
9457 minor(u->new_disks[0]));
7a862a02 9458 dprintf("imsm: new disk for reshape is: %i:%i (%p, index = %i)\n",
a29911da
PC		 9459 major(u->new_disks[0]),
9460 minor(u->new_disks[0]),
9461 new_disk, new_disk->index);
9462 if (new_disk == NULL)
9463 goto error_disk_add;
9464
9465 new_disk->index = map->num_members - 1;
9466 /* slot to fill in autolayout
9467 */
9468 new_disk->raiddisk = new_disk->index;
9469 new_disk->disk.status |= CONFIGURED_DISK;
9470 new_disk->disk.status &= ~SPARE_DISK;
9471 } else
9472 goto error_disk_add;
9473
9474skip_disk_add:
9475 *tofree = *space_list;
9476 /* calculate new size
9477 */
f3871fdc 9478 imsm_set_array_size(new_dev, -1);
a29911da
PC		 9479
9480 ret_val = 1;
9481 }
9482 }
9483
9484 if (tofree)
9485 *space_list = tofree;
9486 return ret_val;
9487
9488error_disk_add:
9489 dprintf("Error: imsm: Cannot find disk.\n");
9490 return ret_val;
9491}
9492
f3871fdc
AK		 9493static int apply_size_change_update(struct imsm_update_size_change *u,
9494 struct intel_super *super)
9495{
9496 struct intel_dev *id;
9497 int ret_val = 0;
9498
1ade5cc1 9499 dprintf("(enter)\n");
089f9d79 9500 if (u->subdev < 0 || u->subdev > 1) {
f3871fdc
AK		 9501 dprintf("imsm: Error: Wrong subdev: %i\n", u->subdev);
9502 return ret_val;
9503 }
9504
9505 for (id = super->devlist ; id; id = id->next) {
9506 if (id->index == (unsigned)u->subdev) {
9507 struct imsm_dev *dev = get_imsm_dev(super, u->subdev);
9508 struct imsm_map *map = get_imsm_map(dev, MAP_0);
9529d343 9509 int used_disks = imsm_num_data_members(map);
f3871fdc 9510 unsigned long long blocks_per_member;
06fb291a 9511 unsigned long long num_data_stripes;
44490938
MD		 9512 unsigned long long new_size_per_disk;
9513
9514 if (used_disks == 0)
9515 return 0;
f3871fdc
AK		 9516
9517 /* calculate new size
9518 */
44490938
MD		 9519 new_size_per_disk = u->new_size / used_disks;
9520 blocks_per_member = new_size_per_disk +
9521 NUM_BLOCKS_DIRTY_STRIPE_REGION;
9522 num_data_stripes = new_size_per_disk /
06fb291a
PB		 9523 map->blocks_per_strip;
9524 num_data_stripes /= map->num_domains;
9525 dprintf("(size: %llu, blocks per member: %llu, num_data_stipes: %llu)\n",
44490938 9526 u->new_size, new_size_per_disk,
06fb291a 9527 num_data_stripes);
f3871fdc 9528 set_blocks_per_member(map, blocks_per_member);
06fb291a 9529 set_num_data_stripes(map, num_data_stripes);
f3871fdc
AK		 9530 imsm_set_array_size(dev, u->new_size);
9531
9532 ret_val = 1;
9533 break;
9534 }
9535 }
9536
9537 return ret_val;
9538}
9539
69d40de4
JR		 9540static int prepare_spare_to_activate(struct supertype *st,
9541 struct imsm_update_activate_spare *u)
9542{
9543 struct intel_super *super = st->sb;
9544 int prev_current_vol = super->current_vol;
9545 struct active_array *a;
9546 int ret = 1;
9547
9548 for (a = st->arrays; a; a = a->next)
9549 /*
9550 * Additional initialization (adding bitmap header, filling
9551 * the bitmap area with '1's to force initial rebuild for a whole
9552 * data-area) is required when adding the spare to the volume
9553 * with write-intent bitmap.
9554 */
9555 if (a->info.container_member == u->array &&
9556 a->info.consistency_policy == CONSISTENCY_POLICY_BITMAP) {
9557 struct dl *dl;
9558
9559 for (dl = super->disks; dl; dl = dl->next)
9560 if (dl == u->dl)
9561 break;
9562 if (!dl)
9563 break;
9564
9565 super->current_vol = u->array;
9566 if (st->ss->write_bitmap(st, dl->fd, NoUpdate))
9567 ret = 0;
9568 super->current_vol = prev_current_vol;
9569 }
9570 return ret;
9571}
9572
061d7da3 9573static int apply_update_activate_spare(struct imsm_update_activate_spare *u,
ca9de185 9574 struct intel_super *super,
061d7da3
LO		 9575 struct active_array *active_array)
9576{
9577 struct imsm_super *mpb = super->anchor;
9578 struct imsm_dev *dev = get_imsm_dev(super, u->array);
238c0a71 9579 struct imsm_map *map = get_imsm_map(dev, MAP_0);
061d7da3
LO		 9580 struct imsm_map *migr_map;
9581 struct active_array *a;
9582 struct imsm_disk *disk;
9583 __u8 to_state;
9584 struct dl *dl;
9585 unsigned int found;
9586 int failed;
5961eeec 9587 int victim;
061d7da3 9588 int i;
5961eeec 9589 int second_map_created = 0;
061d7da3 9590
5961eeec 9591 for (; u; u = u->next) {
238c0a71 9592 victim = get_imsm_disk_idx(dev, u->slot, MAP_X);
061d7da3 9593
5961eeec 9594 if (victim < 0)
9595 return 0;
061d7da3 9596
5961eeec 9597 for (dl = super->disks; dl; dl = dl->next)
9598 if (dl == u->dl)
9599 break;
061d7da3 9600
5961eeec 9601 if (!dl) {
7a862a02 9602 pr_err("error: imsm_activate_spare passed an unknown disk (index: %d)\n",
5961eeec 9603 u->dl->index);
9604 return 0;
9605 }
061d7da3 9606
5961eeec 9607 /* count failures (excluding rebuilds and the victim)
9608 * to determine map[0] state
9609 */
9610 failed = 0;
9611 for (i = 0; i < map->num_members; i++) {
9612 if (i == u->slot)
9613 continue;
9614 disk = get_imsm_disk(super,
238c0a71 9615 get_imsm_disk_idx(dev, i, MAP_X));
5961eeec 9616 if (!disk || is_failed(disk))
9617 failed++;
9618 }
061d7da3 9619
5961eeec 9620 /* adding a pristine spare, assign a new index */
9621 if (dl->index < 0) {
9622 dl->index = super->anchor->num_disks;
9623 super->anchor->num_disks++;
9624 }
9625 disk = &dl->disk;
9626 disk->status |= CONFIGURED_DISK;
9627 disk->status &= ~SPARE_DISK;
9628
9629 /* mark rebuild */
238c0a71 9630 to_state = imsm_check_degraded(super, dev, failed, MAP_0);
5961eeec 9631 if (!second_map_created) {
9632 second_map_created = 1;
9633 map->map_state = IMSM_T_STATE_DEGRADED;
9634 migrate(dev, super, to_state, MIGR_REBUILD);
9635 } else
9636 map->map_state = to_state;
238c0a71 9637 migr_map = get_imsm_map(dev, MAP_1);
5961eeec 9638 set_imsm_ord_tbl_ent(map, u->slot, dl->index);
9639 set_imsm_ord_tbl_ent(migr_map, u->slot,
9640 dl->index | IMSM_ORD_REBUILD);
9641
9642 /* update the family_num to mark a new container
9643 * generation, being careful to record the existing
9644 * family_num in orig_family_num to clean up after
9645 * earlier mdadm versions that neglected to set it.
9646 */
9647 if (mpb->orig_family_num == 0)
9648 mpb->orig_family_num = mpb->family_num;
9649 mpb->family_num += super->random;
9650
9651 /* count arrays using the victim in the metadata */
9652 found = 0;
9653 for (a = active_array; a ; a = a->next) {
9654 dev = get_imsm_dev(super, a->info.container_member);
238c0a71 9655 map = get_imsm_map(dev, MAP_0);
061d7da3 9656
5961eeec 9657 if (get_imsm_disk_slot(map, victim) >= 0)
9658 found++;
9659 }
061d7da3 9660
5961eeec 9661 /* delete the victim if it is no longer being
9662 * utilized anywhere
061d7da3 9663 */
5961eeec 9664 if (!found) {
9665 struct dl **dlp;
061d7da3 9666
5961eeec 9667 /* We know that 'manager' isn't touching anything,
9668 * so it is safe to delete
9669 */
9670 for (dlp = &super->disks; *dlp; dlp = &(*dlp)->next)
061d7da3
LO		 9671 if ((*dlp)->index == victim)
9672 break;
5961eeec 9673
9674 /* victim may be on the missing list */
9675 if (!*dlp)
9676 for (dlp = &super->missing; *dlp;
9677 dlp = &(*dlp)->next)
9678 if ((*dlp)->index == victim)
9679 break;
9680 imsm_delete(super, dlp, victim);
9681 }
061d7da3
LO		 9682 }
9683
9684 return 1;
9685}
a29911da 9686
2e5dc010
N		 9687static int apply_reshape_container_disks_update(struct imsm_update_reshape *u,
9688 struct intel_super *super,
9689 void ***space_list)
9690{
9691 struct dl *new_disk;
9692 struct intel_dev *id;
9693 int i;
9694 int delta_disks = u->new_raid_disks - u->old_raid_disks;
ee4beede 9695 int disk_count = u->old_raid_disks;
2e5dc010
N		 9696 void **tofree = NULL;
9697 int devices_to_reshape = 1;
9698 struct imsm_super *mpb = super->anchor;
9699 int ret_val = 0;
d098291a 9700 unsigned int dev_id;
2e5dc010 9701
1ade5cc1 9702 dprintf("(enter)\n");
2e5dc010
N		 9703
9704 /* enable spares to use in array */
9705 for (i = 0; i < delta_disks; i++) {
9706 new_disk = get_disk_super(super,
9707 major(u->new_disks[i]),
9708 minor(u->new_disks[i]));
7a862a02 9709 dprintf("imsm: new disk for reshape is: %i:%i (%p, index = %i)\n",
2e5dc010
N		 9710 major(u->new_disks[i]), minor(u->new_disks[i]),
9711 new_disk, new_disk->index);
089f9d79
JS		 9712 if (new_disk == NULL ||
9713 (new_disk->index >= 0 &&
9714 new_disk->index < u->old_raid_disks))
2e5dc010 9715 goto update_reshape_exit;
ee4beede 9716 new_disk->index = disk_count++;
2e5dc010
N		 9717 /* slot to fill in autolayout
9718 */
9719 new_disk->raiddisk = new_disk->index;
9720 new_disk->disk.status |=
9721 CONFIGURED_DISK;
9722 new_disk->disk.status &= ~SPARE_DISK;
9723 }
9724
ed7333bd
AK		 9725 dprintf("imsm: volume set mpb->num_raid_devs = %i\n",
9726 mpb->num_raid_devs);
2e5dc010
N		 9727 /* manage changes in volume
9728 */
d098291a 9729 for (dev_id = 0; dev_id < mpb->num_raid_devs; dev_id++) {
2e5dc010
N		 9730 void **sp = *space_list;
9731 struct imsm_dev *newdev;
9732 struct imsm_map *newmap, *oldmap;
9733
d098291a
AK		 9734 for (id = super->devlist ; id; id = id->next) {
9735 if (id->index == dev_id)
9736 break;
9737 }
9738 if (id == NULL)
9739 break;
2e5dc010
N		 9740 if (!sp)
9741 continue;
9742 *space_list = *sp;
9743 newdev = (void*)sp;
9744 /* Copy the dev, but not (all of) the map */
9745 memcpy(newdev, id->dev, sizeof(*newdev));
238c0a71
AK		 9746 oldmap = get_imsm_map(id->dev, MAP_0);
9747 newmap = get_imsm_map(newdev, MAP_0);
2e5dc010
N		 9748 /* Copy the current map */
9749 memcpy(newmap, oldmap, sizeof_imsm_map(oldmap));
9750 /* update one device only
9751 */
9752 if (devices_to_reshape) {
ed7333bd
AK		 9753 dprintf("imsm: modifying subdev: %i\n",
9754 id->index);
2e5dc010
N		 9755 devices_to_reshape--;
9756 newdev->vol.migr_state = 1;
9757 newdev->vol.curr_migr_unit = 0;
ea672ee1 9758 set_migr_type(newdev, MIGR_GEN_MIGR);
2e5dc010
N		 9759 newmap->num_members = u->new_raid_disks;
9760 for (i = 0; i < delta_disks; i++) {
9761 set_imsm_ord_tbl_ent(newmap,
9762 u->old_raid_disks + i,
9763 u->old_raid_disks + i);
9764 }
9765 /* New map is correct, now need to save old map
9766 */
238c0a71 9767 newmap = get_imsm_map(newdev, MAP_1);
2e5dc010
N		 9768 memcpy(newmap, oldmap, sizeof_imsm_map(oldmap));
9769
f3871fdc 9770 imsm_set_array_size(newdev, -1);
2e5dc010
N		 9771 }
9772
9773 sp = (void **)id->dev;
9774 id->dev = newdev;
9775 *sp = tofree;
9776 tofree = sp;
8e59f3d8
AK		 9777
9778 /* Clear migration record */
9779 memset(super->migr_rec, 0, sizeof(struct migr_record));
2e5dc010 9780 }
819bc634
AK		 9781 if (tofree)
9782 *space_list = tofree;
2e5dc010
N		 9783 ret_val = 1;
9784
9785update_reshape_exit:
9786
9787 return ret_val;
9788}
9789
bb025c2f 9790static int apply_takeover_update(struct imsm_update_takeover *u,
8ca6df95
KW		 9791 struct intel_super *super,
9792 void ***space_list)
bb025c2f
KW		 9793{
9794 struct imsm_dev *dev = NULL;
8ca6df95
KW		 9795 struct intel_dev *dv;
9796 struct imsm_dev *dev_new;
bb025c2f
KW		 9797 struct imsm_map *map;
9798 struct dl *dm, *du;
8ca6df95 9799 int i;
bb025c2f
KW		 9800
9801 for (dv = super->devlist; dv; dv = dv->next)
9802 if (dv->index == (unsigned int)u->subarray) {
9803 dev = dv->dev;
9804 break;
9805 }
9806
9807 if (dev == NULL)
9808 return 0;
9809
238c0a71 9810 map = get_imsm_map(dev, MAP_0);
bb025c2f
KW		 9811
9812 if (u->direction == R10_TO_R0) {
06fb291a
PB		 9813 unsigned long long num_data_stripes;
9814
43d5ec18 9815 /* Number of failed disks must be half of initial disk number */
3b451610
AK		 9816 if (imsm_count_failed(super, dev, MAP_0) !=
9817 (map->num_members / 2))
43d5ec18
KW		 9818 return 0;
9819
bb025c2f
KW		 9820 /* iterate through devices to mark removed disks as spare */
9821 for (dm = super->disks; dm; dm = dm->next) {
9822 if (dm->disk.status & FAILED_DISK) {
9823 int idx = dm->index;
9824 /* update indexes on the disk list */
9825/* FIXME this loop-with-the-loop looks wrong, I'm not convinced
9826 the index values will end up being correct.... NB */
9827 for (du = super->disks; du; du = du->next)
9828 if (du->index > idx)
9829 du->index--;
9830 /* mark as spare disk */
a8619d23 9831 mark_spare(dm);
bb025c2f
KW		 9832 }
9833 }
bb025c2f
KW		 9834 /* update map */
9835 map->num_members = map->num_members / 2;
9836 map->map_state = IMSM_T_STATE_NORMAL;
9837 map->num_domains = 1;
9838 map->raid_level = 0;
9839 map->failed_disk_num = -1;
4a353e6e
RS		 9840 num_data_stripes = imsm_dev_size(dev) / 2;
9841 num_data_stripes /= map->blocks_per_strip;
9842 set_num_data_stripes(map, num_data_stripes);
bb025c2f
KW		 9843 }
9844
8ca6df95
KW		 9845 if (u->direction == R0_TO_R10) {
9846 void **space;
4a353e6e
RS		 9847 unsigned long long num_data_stripes;
9848
8ca6df95
KW		 9849 /* update slots in current disk list */
9850 for (dm = super->disks; dm; dm = dm->next) {
9851 if (dm->index >= 0)
9852 dm->index *= 2;
9853 }
9854 /* create new *missing* disks */
9855 for (i = 0; i < map->num_members; i++) {
9856 space = *space_list;
9857 if (!space)
9858 continue;
9859 *space_list = *space;
9860 du = (void *)space;
9861 memcpy(du, super->disks, sizeof(*du));
8ca6df95
KW		 9862 du->fd = -1;
9863 du->minor = 0;
9864 du->major = 0;
9865 du->index = (i * 2) + 1;
9866 sprintf((char *)du->disk.serial,
9867 " MISSING_%d", du->index);
9868 sprintf((char *)du->serial,
9869 "MISSING_%d", du->index);
9870 du->next = super->missing;
9871 super->missing = du;
9872 }
9873 /* create new dev and map */
9874 space = *space_list;
9875 if (!space)
9876 return 0;
9877 *space_list = *space;
9878 dev_new = (void *)space;
9879 memcpy(dev_new, dev, sizeof(*dev));
9880 /* update new map */
238c0a71 9881 map = get_imsm_map(dev_new, MAP_0);
8ca6df95 9882 map->num_members = map->num_members * 2;
1a2487c2 9883 map->map_state = IMSM_T_STATE_DEGRADED;
8ca6df95
KW		 9884 map->num_domains = 2;
9885 map->raid_level = 1;
4a353e6e
RS		 9886 num_data_stripes = imsm_dev_size(dev) / 2;
9887 num_data_stripes /= map->blocks_per_strip;
9888 num_data_stripes /= map->num_domains;
9889 set_num_data_stripes(map, num_data_stripes);
9890
8ca6df95
KW		 9891 /* replace dev<->dev_new */
9892 dv->dev = dev_new;
9893 }
bb025c2f
KW		 9894 /* update disk order table */
9895 for (du = super->disks; du; du = du->next)
9896 if (du->index >= 0)
9897 set_imsm_ord_tbl_ent(map, du->index, du->index);
8ca6df95 9898 for (du = super->missing; du; du = du->next)
1a2487c2
KW		 9899 if (du->index >= 0) {
9900 set_imsm_ord_tbl_ent(map, du->index, du->index);
4c9e8c1e 9901 mark_missing(super, dv->dev, &du->disk, du->index);
1a2487c2 9902 }
bb025c2f
KW		 9903
9904 return 1;
9905}
9906
e8319a19
DW		 9907static void imsm_process_update(struct supertype *st,
9908 struct metadata_update *update)
9909{
9910 /**
9911 * crack open the metadata_update envelope to find the update record
9912 * update can be one of:
d195167d
AK		 9913 * update_reshape_container_disks - all the arrays in the container
9914 * are being reshaped to have more devices. We need to mark
9915 * the arrays for general migration and convert selected spares
9916 * into active devices.
9917 * update_activate_spare - a spare device has replaced a failed
1011e834
N		 9918 * device in an array, update the disk_ord_tbl. If this disk is
9919 * present in all member arrays then also clear the SPARE_DISK
9920 * flag
d195167d
AK		 9921 * update_create_array
9922 * update_kill_array
9923 * update_rename_array
9924 * update_add_remove_disk
e8319a19
DW		 9925 */
9926 struct intel_super *super = st->sb;
4d7b1503 9927 struct imsm_super *mpb;
e8319a19
DW		 9928 enum imsm_update_type type = *(enum imsm_update_type *) update->buf;
9929
4d7b1503
DW		 9930 /* update requires a larger buf but the allocation failed */
9931 if (super->next_len && !super->next_buf) {
9932 super->next_len = 0;
9933 return;
9934 }
9935
9936 if (super->next_buf) {
9937 memcpy(super->next_buf, super->buf, super->len);
9938 free(super->buf);
9939 super->len = super->next_len;
9940 super->buf = super->next_buf;
9941
9942 super->next_len = 0;
9943 super->next_buf = NULL;
9944 }
9945
9946 mpb = super->anchor;
9947
e8319a19 9948 switch (type) {
0ec5d470
AK		 9949 case update_general_migration_checkpoint: {
9950 struct intel_dev *id;
9951 struct imsm_update_general_migration_checkpoint *u =
9952 (void *)update->buf;
9953
1ade5cc1 9954 dprintf("called for update_general_migration_checkpoint\n");
0ec5d470
AK		 9955
9956 /* find device under general migration */
9957 for (id = super->devlist ; id; id = id->next) {
9958 if (is_gen_migration(id->dev)) {
9959 id->dev->vol.curr_migr_unit =
9960 __cpu_to_le32(u->curr_migr_unit);
9961 super->updates_pending++;
9962 }
9963 }
9964 break;
9965 }
bb025c2f
KW		 9966 case update_takeover: {
9967 struct imsm_update_takeover *u = (void *)update->buf;
1a2487c2
KW		 9968 if (apply_takeover_update(u, super, &update->space_list)) {
9969 imsm_update_version_info(super);
bb025c2f 9970 super->updates_pending++;
1a2487c2 9971 }
bb025c2f
KW		 9972 break;
9973 }
9974
78b10e66 9975 case update_reshape_container_disks: {
d195167d 9976 struct imsm_update_reshape *u = (void *)update->buf;
2e5dc010
N		 9977 if (apply_reshape_container_disks_update(
9978 u, super, &update->space_list))
9979 super->updates_pending++;
78b10e66
N		 9980 break;
9981 }
48c5303a 9982 case update_reshape_migration: {
a29911da
PC		 9983 struct imsm_update_reshape_migration *u = (void *)update->buf;
9984 if (apply_reshape_migration_update(
9985 u, super, &update->space_list))
9986 super->updates_pending++;
48c5303a
PC		 9987 break;
9988 }
f3871fdc
AK		 9989 case update_size_change: {
9990 struct imsm_update_size_change *u = (void *)update->buf;
9991 if (apply_size_change_update(u, super))
9992 super->updates_pending++;
9993 break;
9994 }
e8319a19 9995 case update_activate_spare: {
1011e834 9996 struct imsm_update_activate_spare *u = (void *) update->buf;
69d40de4
JR		 9997
9998 if (prepare_spare_to_activate(st, u) &&
9999 apply_update_activate_spare(u, super, st->arrays))
061d7da3 10000 super->updates_pending++;
8273f55e
DW		 10001 break;
10002 }
10003 case update_create_array: {
10004 /* someone wants to create a new array, we need to be aware of
10005 * a few races/collisions:
10006 * 1/ 'Create' called by two separate instances of mdadm
10007 * 2/ 'Create' versus 'activate_spare': mdadm has chosen
10008 * devices that have since been assimilated via
10009 * activate_spare.
10010 * In the event this update can not be carried out mdadm will
10011 * (FIX ME) notice that its update did not take hold.
10012 */
10013 struct imsm_update_create_array *u = (void *) update->buf;
ba2de7ba 10014 struct intel_dev *dv;
8273f55e
DW		 10015 struct imsm_dev *dev;
10016 struct imsm_map *map, *new_map;
10017 unsigned long long start, end;
10018 unsigned long long new_start, new_end;
10019 int i;
54c2c1ea
DW		 10020 struct disk_info *inf;
10021 struct dl *dl;
8273f55e
DW		 10022
10023 /* handle racing creates: first come first serve */
10024 if (u->dev_idx < mpb->num_raid_devs) {
1ade5cc1 10025 dprintf("subarray %d already defined\n", u->dev_idx);
ba2de7ba 10026 goto create_error;
8273f55e
DW		 10027 }
10028
10029 /* check update is next in sequence */
10030 if (u->dev_idx != mpb->num_raid_devs) {
1ade5cc1
N		 10031 dprintf("can not create array %d expected index %d\n",
10032 u->dev_idx, mpb->num_raid_devs);
ba2de7ba 10033 goto create_error;
8273f55e
DW		 10034 }
10035
238c0a71 10036 new_map = get_imsm_map(&u->dev, MAP_0);
5551b113 10037 new_start = pba_of_lba0(new_map);
44490938 10038 new_end = new_start + per_dev_array_size(new_map);
54c2c1ea 10039 inf = get_disk_info(u);
8273f55e
DW		 10040
10041 /* handle activate_spare versus create race:
10042 * check to make sure that overlapping arrays do not include
10043 * overalpping disks
10044 */
10045 for (i = 0; i < mpb->num_raid_devs; i++) {
949c47a0 10046 dev = get_imsm_dev(super, i);
238c0a71 10047 map = get_imsm_map(dev, MAP_0);
5551b113 10048 start = pba_of_lba0(map);
44490938 10049 end = start + per_dev_array_size(map);
8273f55e
DW		 10050 if ((new_start >= start && new_start <= end) ||
10051 (start >= new_start && start <= new_end))
54c2c1ea
DW		 10052 /* overlap */;
10053 else
10054 continue;
10055
10056 if (disks_overlap(super, i, u)) {
1ade5cc1 10057 dprintf("arrays overlap\n");
ba2de7ba 10058 goto create_error;
8273f55e
DW		 10059 }
10060 }
8273f55e 10061
949c47a0
DW		 10062 /* check that prepare update was successful */
10063 if (!update->space) {
1ade5cc1 10064 dprintf("prepare update failed\n");
ba2de7ba 10065 goto create_error;
949c47a0
DW		 10066 }
10067
54c2c1ea
DW		 10068 /* check that all disks are still active before committing
10069 * changes. FIXME: could we instead handle this by creating a
10070 * degraded array? That's probably not what the user expects,
10071 * so better to drop this update on the floor.
10072 */
10073 for (i = 0; i < new_map->num_members; i++) {
10074 dl = serial_to_dl(inf[i].serial, super);
10075 if (!dl) {
1ade5cc1 10076 dprintf("disk disappeared\n");
ba2de7ba 10077 goto create_error;
54c2c1ea 10078 }
949c47a0
DW		 10079 }
10080
8273f55e 10081 super->updates_pending++;
54c2c1ea
DW		 10082
10083 /* convert spares to members and fixup ord_tbl */
10084 for (i = 0; i < new_map->num_members; i++) {
10085 dl = serial_to_dl(inf[i].serial, super);
10086 if (dl->index == -1) {
10087 dl->index = mpb->num_disks;
10088 mpb->num_disks++;
10089 dl->disk.status |= CONFIGURED_DISK;
10090 dl->disk.status &= ~SPARE_DISK;
10091 }
10092 set_imsm_ord_tbl_ent(new_map, i, dl->index);
10093 }
10094
ba2de7ba
DW		 10095 dv = update->space;
10096 dev = dv->dev;
949c47a0
DW		 10097 update->space = NULL;
10098 imsm_copy_dev(dev, &u->dev);
ba2de7ba
DW		 10099 dv->index = u->dev_idx;
10100 dv->next = super->devlist;
10101 super->devlist = dv;
8273f55e 10102 mpb->num_raid_devs++;
8273f55e 10103
4d1313e9 10104 imsm_update_version_info(super);
8273f55e 10105 break;
ba2de7ba
DW		 10106 create_error:
10107 /* mdmon knows how to release update->space, but not
10108 * ((struct intel_dev *) update->space)->dev
10109 */
10110 if (update->space) {
10111 dv = update->space;
10112 free(dv->dev);
10113 }
8273f55e 10114 break;
e8319a19 10115 }
33414a01
DW		 10116 case update_kill_array: {
10117 struct imsm_update_kill_array *u = (void *) update->buf;
10118 int victim = u->dev_idx;
10119 struct active_array *a;
10120 struct intel_dev **dp;
10121 struct imsm_dev *dev;
10122
10123 /* sanity check that we are not affecting the uuid of
10124 * active arrays, or deleting an active array
10125 *
10126 * FIXME when immutable ids are available, but note that
10127 * we'll also need to fixup the invalidated/active
10128 * subarray indexes in mdstat
10129 */
10130 for (a = st->arrays; a; a = a->next)
10131 if (a->info.container_member >= victim)
10132 break;
10133 /* by definition if mdmon is running at least one array
10134 * is active in the container, so checking
10135 * mpb->num_raid_devs is just extra paranoia
10136 */
10137 dev = get_imsm_dev(super, victim);
10138 if (a || !dev || mpb->num_raid_devs == 1) {
10139 dprintf("failed to delete subarray-%d\n", victim);
10140 break;
10141 }
10142
10143 for (dp = &super->devlist; *dp;)
f21e18ca 10144 if ((*dp)->index == (unsigned)super->current_vol) {
33414a01
DW		 10145 *dp = (*dp)->next;
10146 } else {
f21e18ca 10147 if ((*dp)->index > (unsigned)victim)
33414a01
DW		 10148 (*dp)->index--;
10149 dp = &(*dp)->next;
10150 }
10151 mpb->num_raid_devs--;
10152 super->updates_pending++;
10153 break;
10154 }
aa534678
DW		 10155 case update_rename_array: {
10156 struct imsm_update_rename_array *u = (void *) update->buf;
10157 char name[MAX_RAID_SERIAL_LEN+1];
10158 int target = u->dev_idx;
10159 struct active_array *a;
10160 struct imsm_dev *dev;
10161
10162 /* sanity check that we are not affecting the uuid of
10163 * an active array
10164 */
40659392 10165 memset(name, 0, sizeof(name));
aa534678
DW		 10166 snprintf(name, MAX_RAID_SERIAL_LEN, "%s", (char *) u->name);
10167 name[MAX_RAID_SERIAL_LEN] = '\0';
10168 for (a = st->arrays; a; a = a->next)
10169 if (a->info.container_member == target)
10170 break;
10171 dev = get_imsm_dev(super, u->dev_idx);
10172 if (a || !dev || !check_name(super, name, 1)) {
10173 dprintf("failed to rename subarray-%d\n", target);
10174 break;
10175 }
10176
40659392 10177 memcpy(dev->volume, name, MAX_RAID_SERIAL_LEN);
aa534678
DW		 10178 super->updates_pending++;
10179 break;
10180 }
1a64be56 10181 case update_add_remove_disk: {
43dad3d6 10182 /* we may be able to repair some arrays if disks are
095b8088 10183 * being added, check the status of add_remove_disk
1a64be56
LM		 10184 * if discs has been added.
10185 */
10186 if (add_remove_disk_update(super)) {
43dad3d6 10187 struct active_array *a;
072b727f
DW		 10188
10189 super->updates_pending++;
1a64be56 10190 for (a = st->arrays; a; a = a->next)
43dad3d6
DW		 10191 a->check_degraded = 1;
10192 }
43dad3d6 10193 break;
e8319a19 10194 }
bbab0940
TM		 10195 case update_prealloc_badblocks_mem:
10196 break;
e6e9dd3f
AP		 10197 case update_rwh_policy: {
10198 struct imsm_update_rwh_policy *u = (void *)update->buf;
10199 int target = u->dev_idx;
10200 struct imsm_dev *dev = get_imsm_dev(super, target);
10201 if (!dev) {
10202 dprintf("could not find subarray-%d\n", target);
10203 break;
10204 }
10205
10206 if (dev->rwh_policy != u->new_policy) {
10207 dev->rwh_policy = u->new_policy;
10208 super->updates_pending++;
10209 }
10210 break;
10211 }
1a64be56 10212 default:
ebf3be99 10213 pr_err("error: unsupported process update type:(type: %d)\n", type);
1a64be56 10214 }
e8319a19 10215}
88758e9d 10216
bc0b9d34
PC		 10217static struct mdinfo *get_spares_for_grow(struct supertype *st);
10218
5fe6f031
N		 10219static int imsm_prepare_update(struct supertype *st,
10220 struct metadata_update *update)
8273f55e 10221{
949c47a0 10222 /**
4d7b1503
DW		 10223 * Allocate space to hold new disk entries, raid-device entries or a new
10224 * mpb if necessary. The manager synchronously waits for updates to
10225 * complete in the monitor, so new mpb buffers allocated here can be
10226 * integrated by the monitor thread without worrying about live pointers
10227 * in the manager thread.
8273f55e 10228 */
095b8088 10229 enum imsm_update_type type;
4d7b1503 10230 struct intel_super *super = st->sb;
f36a9ecd 10231 unsigned int sector_size = super->sector_size;
4d7b1503
DW		 10232 struct imsm_super *mpb = super->anchor;
10233 size_t buf_len;
10234 size_t len = 0;
949c47a0 10235
095b8088
N		 10236 if (update->len < (int)sizeof(type))
10237 return 0;
10238
10239 type = *(enum imsm_update_type *) update->buf;
10240
949c47a0 10241 switch (type) {
0ec5d470 10242 case update_general_migration_checkpoint:
095b8088
N		 10243 if (update->len < (int)sizeof(struct imsm_update_general_migration_checkpoint))
10244 return 0;
1ade5cc1 10245 dprintf("called for update_general_migration_checkpoint\n");
0ec5d470 10246 break;
abedf5fc
KW		 10247 case update_takeover: {
10248 struct imsm_update_takeover *u = (void *)update->buf;
095b8088
N		 10249 if (update->len < (int)sizeof(*u))
10250 return 0;
abedf5fc
KW		 10251 if (u->direction == R0_TO_R10) {
10252 void **tail = (void **)&update->space_list;
10253 struct imsm_dev *dev = get_imsm_dev(super, u->subarray);
238c0a71 10254 struct imsm_map *map = get_imsm_map(dev, MAP_0);
abedf5fc
KW		 10255 int num_members = map->num_members;
10256 void *space;
10257 int size, i;
abedf5fc
KW		 10258 /* allocate memory for added disks */
10259 for (i = 0; i < num_members; i++) {
10260 size = sizeof(struct dl);
503975b9 10261 space = xmalloc(size);
abedf5fc
KW		 10262 *tail = space;
10263 tail = space;
10264 *tail = NULL;
10265 }
10266 /* allocate memory for new device */
10267 size = sizeof_imsm_dev(super->devlist->dev, 0) +
10268 (num_members * sizeof(__u32));
503975b9
N		 10269 space = xmalloc(size);
10270 *tail = space;
10271 tail = space;
10272 *tail = NULL;
10273 len = disks_to_mpb_size(num_members * 2);
abedf5fc
KW		 10274 }
10275
10276 break;
10277 }
78b10e66 10278 case update_reshape_container_disks: {
d195167d
AK		 10279 /* Every raid device in the container is about to
10280 * gain some more devices, and we will enter a
10281 * reconfiguration.
10282 * So each 'imsm_map' will be bigger, and the imsm_vol
10283 * will now hold 2 of them.
10284 * Thus we need new 'struct imsm_dev' allocations sized
10285 * as sizeof_imsm_dev but with more devices in both maps.
10286 */
10287 struct imsm_update_reshape *u = (void *)update->buf;
10288 struct intel_dev *dl;
10289 void **space_tail = (void**)&update->space_list;
10290
095b8088
N		 10291 if (update->len < (int)sizeof(*u))
10292 return 0;
10293
1ade5cc1 10294 dprintf("for update_reshape\n");
d195167d
AK		 10295
10296 for (dl = super->devlist; dl; dl = dl->next) {
10297 int size = sizeof_imsm_dev(dl->dev, 1);
10298 void *s;
d677e0b8
AK		 10299 if (u->new_raid_disks > u->old_raid_disks)
10300 size += sizeof(__u32)*2*
10301 (u->new_raid_disks - u->old_raid_disks);
503975b9 10302 s = xmalloc(size);
d195167d
AK		 10303 *space_tail = s;
10304 space_tail = s;
10305 *space_tail = NULL;
10306 }
10307
10308 len = disks_to_mpb_size(u->new_raid_disks);
10309 dprintf("New anchor length is %llu\n", (unsigned long long)len);
78b10e66
N		 10310 break;
10311 }
48c5303a 10312 case update_reshape_migration: {
bc0b9d34
PC		 10313 /* for migration level 0->5 we need to add disks
10314 * so the same as for container operation we will copy
10315 * device to the bigger location.
10316 * in memory prepared device and new disk area are prepared
10317 * for usage in process update
10318 */
10319 struct imsm_update_reshape_migration *u = (void *)update->buf;
10320 struct intel_dev *id;
10321 void **space_tail = (void **)&update->space_list;
10322 int size;
10323 void *s;
10324 int current_level = -1;
10325
095b8088
N		 10326 if (update->len < (int)sizeof(*u))
10327 return 0;
10328
1ade5cc1 10329 dprintf("for update_reshape\n");
bc0b9d34
PC		 10330
10331 /* add space for bigger array in update
10332 */
10333 for (id = super->devlist; id; id = id->next) {
10334 if (id->index == (unsigned)u->subdev) {
10335 size = sizeof_imsm_dev(id->dev, 1);
10336 if (u->new_raid_disks > u->old_raid_disks)
10337 size += sizeof(__u32)*2*
10338 (u->new_raid_disks - u->old_raid_disks);
503975b9 10339 s = xmalloc(size);
bc0b9d34
PC		 10340 *space_tail = s;
10341 space_tail = s;
10342 *space_tail = NULL;
10343 break;
10344 }
10345 }
10346 if (update->space_list == NULL)
10347 break;
10348
10349 /* add space for disk in update
10350 */
10351 size = sizeof(struct dl);
503975b9 10352 s = xmalloc(size);
bc0b9d34
PC		 10353 *space_tail = s;
10354 space_tail = s;
10355 *space_tail = NULL;
10356
10357 /* add spare device to update
10358 */
10359 for (id = super->devlist ; id; id = id->next)
10360 if (id->index == (unsigned)u->subdev) {
10361 struct imsm_dev *dev;
10362 struct imsm_map *map;
10363
10364 dev = get_imsm_dev(super, u->subdev);
238c0a71 10365 map = get_imsm_map(dev, MAP_0);
bc0b9d34
PC		 10366 current_level = map->raid_level;
10367 break;
10368 }
089f9d79 10369 if (u->new_level == 5 && u->new_level != current_level) {
bc0b9d34
PC		 10370 struct mdinfo *spares;
10371
10372 spares = get_spares_for_grow(st);
10373 if (spares) {
10374 struct dl *dl;
10375 struct mdinfo *dev;
10376
10377 dev = spares->devs;
10378 if (dev) {
10379 u->new_disks[0] =
10380 makedev(dev->disk.major,
10381 dev->disk.minor);
10382 dl = get_disk_super(super,
10383 dev->disk.major,
10384 dev->disk.minor);
10385 dl->index = u->old_raid_disks;
10386 dev = dev->next;
10387 }
10388 sysfs_free(spares);
10389 }
10390 }
10391 len = disks_to_mpb_size(u->new_raid_disks);
10392 dprintf("New anchor length is %llu\n", (unsigned long long)len);
48c5303a
PC		 10393 break;
10394 }
f3871fdc 10395 case update_size_change: {
095b8088
N		 10396 if (update->len < (int)sizeof(struct imsm_update_size_change))
10397 return 0;
10398 break;
10399 }
10400 case update_activate_spare: {
10401 if (update->len < (int)sizeof(struct imsm_update_activate_spare))
10402 return 0;
f3871fdc
AK		 10403 break;
10404 }
949c47a0
DW		 10405 case update_create_array: {
10406 struct imsm_update_create_array *u = (void *) update->buf;
ba2de7ba 10407 struct intel_dev *dv;
54c2c1ea 10408 struct imsm_dev *dev = &u->dev;
238c0a71 10409 struct imsm_map *map = get_imsm_map(dev, MAP_0);
54c2c1ea
DW		 10410 struct dl *dl;
10411 struct disk_info *inf;
10412 int i;
10413 int activate = 0;
949c47a0 10414
095b8088
N		 10415 if (update->len < (int)sizeof(*u))
10416 return 0;
10417
54c2c1ea
DW		 10418 inf = get_disk_info(u);
10419 len = sizeof_imsm_dev(dev, 1);
ba2de7ba 10420 /* allocate a new super->devlist entry */
503975b9
N		 10421 dv = xmalloc(sizeof(*dv));
10422 dv->dev = xmalloc(len);
10423 update->space = dv;
949c47a0 10424
54c2c1ea
DW		 10425 /* count how many spares will be converted to members */
10426 for (i = 0; i < map->num_members; i++) {
10427 dl = serial_to_dl(inf[i].serial, super);
10428 if (!dl) {
10429 /* hmm maybe it failed?, nothing we can do about
10430 * it here
10431 */
10432 continue;
10433 }
10434 if (count_memberships(dl, super) == 0)
10435 activate++;
10436 }
10437 len += activate * sizeof(struct imsm_disk);
949c47a0 10438 break;
095b8088
N		 10439 }
10440 case update_kill_array: {
10441 if (update->len < (int)sizeof(struct imsm_update_kill_array))
10442 return 0;
949c47a0
DW		 10443 break;
10444 }
095b8088
N		 10445 case update_rename_array: {
10446 if (update->len < (int)sizeof(struct imsm_update_rename_array))
10447 return 0;
10448 break;
10449 }
10450 case update_add_remove_disk:
10451 /* no update->len needed */
10452 break;
bbab0940
TM		 10453 case update_prealloc_badblocks_mem:
10454 super->extra_space += sizeof(struct bbm_log) -
10455 get_imsm_bbm_log_size(super->bbm_log);
10456 break;
e6e9dd3f
AP		 10457 case update_rwh_policy: {
10458 if (update->len < (int)sizeof(struct imsm_update_rwh_policy))
10459 return 0;
10460 break;
10461 }
095b8088
N		 10462 default:
10463 return 0;
949c47a0 10464 }
8273f55e 10465
4d7b1503
DW		 10466 /* check if we need a larger metadata buffer */
10467 if (super->next_buf)
10468 buf_len = super->next_len;
10469 else
10470 buf_len = super->len;
10471
bbab0940 10472 if (__le32_to_cpu(mpb->mpb_size) + super->extra_space + len > buf_len) {
4d7b1503
DW		 10473 /* ok we need a larger buf than what is currently allocated
10474 * if this allocation fails process_update will notice that
10475 * ->next_len is set and ->next_buf is NULL
10476 */
bbab0940
TM		 10477 buf_len = ROUND_UP(__le32_to_cpu(mpb->mpb_size) +
10478 super->extra_space + len, sector_size);
4d7b1503
DW		 10479 if (super->next_buf)
10480 free(super->next_buf);
10481
10482 super->next_len = buf_len;
f36a9ecd 10483 if (posix_memalign(&super->next_buf, sector_size, buf_len) == 0)
1f45a8ad
DW		 10484 memset(super->next_buf, 0, buf_len);
10485 else
4d7b1503
DW		 10486 super->next_buf = NULL;
10487 }
5fe6f031 10488 return 1;
8273f55e
DW		 10489}
10490
ae6aad82 10491/* must be called while manager is quiesced */
f21e18ca 10492static void imsm_delete(struct intel_super *super, struct dl **dlp, unsigned index)
ae6aad82
DW		 10493{
10494 struct imsm_super *mpb = super->anchor;
ae6aad82
DW		 10495 struct dl *iter;
10496 struct imsm_dev *dev;
10497 struct imsm_map *map;
4c9e8c1e 10498 unsigned int i, j, num_members;
fb12a745 10499 __u32 ord, ord_map0;
4c9e8c1e 10500 struct bbm_log *log = super->bbm_log;
ae6aad82 10501
1ade5cc1 10502 dprintf("deleting device[%d] from imsm_super\n", index);
ae6aad82
DW		 10503
10504 /* shift all indexes down one */
10505 for (iter = super->disks; iter; iter = iter->next)
f21e18ca 10506 if (iter->index > (int)index)
ae6aad82 10507 iter->index--;
47ee5a45 10508 for (iter = super->missing; iter; iter = iter->next)
f21e18ca 10509 if (iter->index > (int)index)
47ee5a45 10510 iter->index--;
ae6aad82
DW		 10511
10512 for (i = 0; i < mpb->num_raid_devs; i++) {
10513 dev = get_imsm_dev(super, i);
238c0a71 10514 map = get_imsm_map(dev, MAP_0);
24565c9a
DW		 10515 num_members = map->num_members;
10516 for (j = 0; j < num_members; j++) {
10517 /* update ord entries being careful not to propagate
10518 * ord-flags to the first map
10519 */
238c0a71 10520 ord = get_imsm_ord_tbl_ent(dev, j, MAP_X);
fb12a745 10521 ord_map0 = get_imsm_ord_tbl_ent(dev, j, MAP_0);
ae6aad82 10522
24565c9a
DW		 10523 if (ord_to_idx(ord) <= index)
10524 continue;
ae6aad82 10525
238c0a71 10526 map = get_imsm_map(dev, MAP_0);
fb12a745 10527 set_imsm_ord_tbl_ent(map, j, ord_map0 - 1);
238c0a71 10528 map = get_imsm_map(dev, MAP_1);
24565c9a
DW		 10529 if (map)
10530 set_imsm_ord_tbl_ent(map, j, ord - 1);
ae6aad82
DW		 10531 }
10532 }
10533
4c9e8c1e
TM		 10534 for (i = 0; i < log->entry_count; i++) {
10535 struct bbm_log_entry *entry = &log->marked_block_entries[i];
10536
10537 if (entry->disk_ordinal <= index)
10538 continue;
10539 entry->disk_ordinal--;
10540 }
10541
ae6aad82
DW		 10542 mpb->num_disks--;
10543 super->updates_pending++;
24565c9a
DW		 10544 if (*dlp) {
10545 struct dl *dl = *dlp;
10546
10547 *dlp = (*dlp)->next;
10548 __free_imsm_disk(dl);
10549 }
ae6aad82 10550}
9a717282 10551
9a717282
AK		 10552static int imsm_get_allowed_degradation(int level, int raid_disks,
10553 struct intel_super *super,
10554 struct imsm_dev *dev)
10555{
10556 switch (level) {
bf5cf7c7 10557 case 1:
9a717282
AK		 10558 case 10:{
10559 int ret_val = 0;
10560 struct imsm_map *map;
10561 int i;
10562
10563 ret_val = raid_disks/2;
10564 /* check map if all disks pairs not failed
10565 * in both maps
10566 */
238c0a71 10567 map = get_imsm_map(dev, MAP_0);
9a717282
AK		 10568 for (i = 0; i < ret_val; i++) {
10569 int degradation = 0;
10570 if (get_imsm_disk(super, i) == NULL)
10571 degradation++;
10572 if (get_imsm_disk(super, i + 1) == NULL)
10573 degradation++;
10574 if (degradation == 2)
10575 return 0;
10576 }
238c0a71 10577 map = get_imsm_map(dev, MAP_1);
9a717282
AK		 10578 /* if there is no second map
10579 * result can be returned
10580 */
10581 if (map == NULL)
10582 return ret_val;
10583 /* check degradation in second map
10584 */
10585 for (i = 0; i < ret_val; i++) {
10586 int degradation = 0;
10587 if (get_imsm_disk(super, i) == NULL)
10588 degradation++;
10589 if (get_imsm_disk(super, i + 1) == NULL)
10590 degradation++;
10591 if (degradation == 2)
10592 return 0;
10593 }
10594 return ret_val;
10595 }
10596 case 5:
10597 return 1;
10598 case 6:
10599 return 2;
10600 default:
10601 return 0;
10602 }
10603}
10604
d31ad643
PB		 10605/*******************************************************************************
10606 * Function: validate_container_imsm
10607 * Description: This routine validates container after assemble,
10608 * eg. if devices in container are under the same controller.
10609 *
10610 * Parameters:
10611 * info : linked list with info about devices used in array
10612 * Returns:
10613 * 1 : HBA mismatch
10614 * 0 : Success
10615 ******************************************************************************/
10616int validate_container_imsm(struct mdinfo *info)
10617{
6b781d33
AP		 10618 if (check_env("IMSM_NO_PLATFORM"))
10619 return 0;
d31ad643 10620
6b781d33
AP		 10621 struct sys_dev *idev;
10622 struct sys_dev *hba = NULL;
10623 struct sys_dev *intel_devices = find_intel_devices();
10624 char *dev_path = devt_to_devpath(makedev(info->disk.major,
10625 info->disk.minor));
10626
10627 for (idev = intel_devices; idev; idev = idev->next) {
10628 if (dev_path && strstr(dev_path, idev->path)) {
10629 hba = idev;
10630 break;
d31ad643 10631 }
6b781d33
AP		 10632 }
10633 if (dev_path)
d31ad643
PB		 10634 free(dev_path);
10635
6b781d33
AP		 10636 if (!hba) {
10637 pr_err("WARNING - Cannot detect HBA for device %s!\n",
10638 devid2kname(makedev(info->disk.major, info->disk.minor)));
10639 return 1;
10640 }
10641
10642 const struct imsm_orom *orom = get_orom_by_device_id(hba->dev_id);
10643 struct mdinfo *dev;
10644
10645 for (dev = info->next; dev; dev = dev->next) {
10646 dev_path = devt_to_devpath(makedev(dev->disk.major, dev->disk.minor));
10647
10648 struct sys_dev *hba2 = NULL;
10649 for (idev = intel_devices; idev; idev = idev->next) {
10650 if (dev_path && strstr(dev_path, idev->path)) {
10651 hba2 = idev;
10652 break;
d31ad643
PB		 10653 }
10654 }
6b781d33
AP		 10655 if (dev_path)
10656 free(dev_path);
10657
10658 const struct imsm_orom *orom2 = hba2 == NULL ? NULL :
10659 get_orom_by_device_id(hba2->dev_id);
10660
10661 if (hba2 && hba->type != hba2->type) {
10662 pr_err("WARNING - HBAs of devices do not match %s != %s\n",
10663 get_sys_dev_type(hba->type), get_sys_dev_type(hba2->type));
10664 return 1;
10665 }
10666
07cb1e57 10667 if (orom != orom2) {
6b781d33
AP		 10668 pr_err("WARNING - IMSM container assembled with disks under different HBAs!\n"
10669 " This operation is not supported and can lead to data loss.\n");
10670 return 1;
10671 }
10672
10673 if (!orom) {
10674 pr_err("WARNING - IMSM container assembled with disks under HBAs without IMSM platform support!\n"
10675 " This operation is not supported and can lead to data loss.\n");
10676 return 1;
10677 }
d31ad643 10678 }
6b781d33 10679
d31ad643
PB		 10680 return 0;
10681}
32141c17 10682
6f50473f
TM		 10683/*******************************************************************************
10684* Function: imsm_record_badblock
10685* Description: This routine stores new bad block record in BBM log
10686*
10687* Parameters:
10688* a : array containing a bad block
10689* slot : disk number containing a bad block
10690* sector : bad block sector
10691* length : bad block sectors range
10692* Returns:
10693* 1 : Success
10694* 0 : Error
10695******************************************************************************/
10696static int imsm_record_badblock(struct active_array *a, int slot,
10697 unsigned long long sector, int length)
10698{
10699 struct intel_super *super = a->container->sb;
10700 int ord;
10701 int ret;
10702
10703 ord = imsm_disk_slot_to_ord(a, slot);
10704 if (ord < 0)
10705 return 0;
10706
10707 ret = record_new_badblock(super->bbm_log, ord_to_idx(ord), sector,
10708 length);
10709 if (ret)
10710 super->updates_pending++;
10711
10712 return ret;
10713}
c07a5a4f
TM		 10714/*******************************************************************************
10715* Function: imsm_clear_badblock
10716* Description: This routine clears bad block record from BBM log
10717*
10718* Parameters:
10719* a : array containing a bad block
10720* slot : disk number containing a bad block
10721* sector : bad block sector
10722* length : bad block sectors range
10723* Returns:
10724* 1 : Success
10725* 0 : Error
10726******************************************************************************/
10727static int imsm_clear_badblock(struct active_array *a, int slot,
10728 unsigned long long sector, int length)
10729{
10730 struct intel_super *super = a->container->sb;
10731 int ord;
10732 int ret;
10733
10734 ord = imsm_disk_slot_to_ord(a, slot);
10735 if (ord < 0)
10736 return 0;
10737
10738 ret = clear_badblock(super->bbm_log, ord_to_idx(ord), sector, length);
10739 if (ret)
10740 super->updates_pending++;
10741
10742 return ret;
10743}
928f1424
TM		 10744/*******************************************************************************
10745* Function: imsm_get_badblocks
10746* Description: This routine get list of bad blocks for an array
10747*
10748* Parameters:
10749* a : array
10750* slot : disk number
10751* Returns:
10752* bb : structure containing bad blocks
10753* NULL : error
10754******************************************************************************/
10755static struct md_bb *imsm_get_badblocks(struct active_array *a, int slot)
10756{
10757 int inst = a->info.container_member;
10758 struct intel_super *super = a->container->sb;
10759 struct imsm_dev *dev = get_imsm_dev(super, inst);
10760 struct imsm_map *map = get_imsm_map(dev, MAP_0);
10761 int ord;
10762
10763 ord = imsm_disk_slot_to_ord(a, slot);
10764 if (ord < 0)
10765 return NULL;
10766
10767 get_volume_badblocks(super->bbm_log, ord_to_idx(ord), pba_of_lba0(map),
44490938 10768 per_dev_array_size(map), &super->bb);
928f1424
TM		 10769
10770 return &super->bb;
10771}
27156a57
TM		 10772/*******************************************************************************
10773* Function: examine_badblocks_imsm
10774* Description: Prints list of bad blocks on a disk to the standard output
10775*
10776* Parameters:
10777* st : metadata handler
10778* fd : open file descriptor for device
10779* devname : device name
10780* Returns:
10781* 0 : Success
10782* 1 : Error
10783******************************************************************************/
10784static int examine_badblocks_imsm(struct supertype *st, int fd, char *devname)
10785{
10786 struct intel_super *super = st->sb;
10787 struct bbm_log *log = super->bbm_log;
10788 struct dl *d = NULL;
10789 int any = 0;
10790
10791 for (d = super->disks; d ; d = d->next) {
10792 if (strcmp(d->devname, devname) == 0)
10793 break;
10794 }
10795
10796 if ((d == NULL) || (d->index < 0)) { /* serial mismatch probably */
10797 pr_err("%s doesn't appear to be part of a raid array\n",
10798 devname);
10799 return 1;
10800 }
10801
10802 if (log != NULL) {
10803 unsigned int i;
10804 struct bbm_log_entry *entry = &log->marked_block_entries[0];
10805
10806 for (i = 0; i < log->entry_count; i++) {
10807 if (entry[i].disk_ordinal == d->index) {
10808 unsigned long long sector = __le48_to_cpu(
10809 &entry[i].defective_block_start);
10810 int cnt = entry[i].marked_count + 1;
10811
10812 if (!any) {
10813 printf("Bad-blocks on %s:\n", devname);
10814 any = 1;
10815 }
10816
10817 printf("%20llu for %d sectors\n", sector, cnt);
10818 }
10819 }
10820 }
10821
10822 if (!any)
10823 printf("No bad-blocks list configured on %s\n", devname);
10824
10825 return 0;
10826}
687629c2
AK		 10827/*******************************************************************************
10828 * Function: init_migr_record_imsm
10829 * Description: Function inits imsm migration record
10830 * Parameters:
10831 * super : imsm internal array info
10832 * dev : device under migration
10833 * info : general array info to find the smallest device
10834 * Returns:
10835 * none
10836 ******************************************************************************/
10837void init_migr_record_imsm(struct supertype *st, struct imsm_dev *dev,
10838 struct mdinfo *info)
10839{
10840 struct intel_super *super = st->sb;
10841 struct migr_record *migr_rec = super->migr_rec;
10842 int new_data_disks;
10843 unsigned long long dsize, dev_sectors;
10844 long long unsigned min_dev_sectors = -1LLU;
238c0a71
AK		 10845 struct imsm_map *map_dest = get_imsm_map(dev, MAP_0);
10846 struct imsm_map *map_src = get_imsm_map(dev, MAP_1);
687629c2 10847 unsigned long long num_migr_units;
3ef4403c 10848 unsigned long long array_blocks;
2f86fda3 10849 struct dl *dl_disk = NULL;
687629c2
AK		 10850
10851 memset(migr_rec, 0, sizeof(struct migr_record));
10852 migr_rec->family_num = __cpu_to_le32(super->anchor->family_num);
10853
10854 /* only ascending reshape supported now */
10855 migr_rec->ascending_migr = __cpu_to_le32(1);
10856
10857 migr_rec->dest_depth_per_unit = GEN_MIGR_AREA_SIZE /
10858 max(map_dest->blocks_per_strip, map_src->blocks_per_strip);
e1742195
AK		 10859 migr_rec->dest_depth_per_unit *=
10860 max(map_dest->blocks_per_strip, map_src->blocks_per_strip);
9529d343 10861 new_data_disks = imsm_num_data_members(map_dest);
687629c2
AK		 10862 migr_rec->blocks_per_unit =
10863 __cpu_to_le32(migr_rec->dest_depth_per_unit * new_data_disks);
10864 migr_rec->dest_depth_per_unit =
10865 __cpu_to_le32(migr_rec->dest_depth_per_unit);
3ef4403c 10866 array_blocks = info->component_size * new_data_disks;
687629c2
AK		 10867 num_migr_units =
10868 array_blocks / __le32_to_cpu(migr_rec->blocks_per_unit);
10869
10870 if (array_blocks % __le32_to_cpu(migr_rec->blocks_per_unit))
10871 num_migr_units++;
9f421827 10872 set_num_migr_units(migr_rec, num_migr_units);
687629c2
AK		 10873
10874 migr_rec->post_migr_vol_cap = dev->size_low;
10875 migr_rec->post_migr_vol_cap_hi = dev->size_high;
10876
687629c2 10877 /* Find the smallest dev */
2f86fda3
MT		 10878 for (dl_disk = super->disks; dl_disk ; dl_disk = dl_disk->next) {
10879 /* ignore spares in container */
10880 if (dl_disk->index < 0)
687629c2 10881 continue;
2f86fda3 10882 get_dev_size(dl_disk->fd, NULL, &dsize);
687629c2
AK		 10883 dev_sectors = dsize / 512;
10884 if (dev_sectors < min_dev_sectors)
10885 min_dev_sectors = dev_sectors;
687629c2 10886 }
9f421827 10887 set_migr_chkp_area_pba(migr_rec, min_dev_sectors -
687629c2
AK		 10888 RAID_DISK_RESERVED_BLOCKS_IMSM_HI);
10889
10890 write_imsm_migr_rec(st);
10891
10892 return;
10893}
10894
10895/*******************************************************************************
10896 * Function: save_backup_imsm
10897 * Description: Function saves critical data stripes to Migration Copy Area
10898 * and updates the current migration unit status.
10899 * Use restore_stripes() to form a destination stripe,
10900 * and to write it to the Copy Area.
10901 * Parameters:
10902 * st : supertype information
aea93171 10903 * dev : imsm device that backup is saved for
687629c2
AK		 10904 * info : general array info
10905 * buf : input buffer
687629c2
AK		 10906 * length : length of data to backup (blocks_per_unit)
10907 * Returns:
10908 * 0 : success
10909 *, -1 : fail
10910 ******************************************************************************/
10911int save_backup_imsm(struct supertype *st,
10912 struct imsm_dev *dev,
10913 struct mdinfo *info,
10914 void *buf,
687629c2
AK		 10915 int length)
10916{
10917 int rv = -1;
10918 struct intel_super *super = st->sb;
594dc1b8
JS		 10919 unsigned long long *target_offsets;
10920 int *targets;
687629c2 10921 int i;
238c0a71 10922 struct imsm_map *map_dest = get_imsm_map(dev, MAP_0);
687629c2 10923 int new_disks = map_dest->num_members;
ab724b98
AK		 10924 int dest_layout = 0;
10925 int dest_chunk;
d1877f69 10926 unsigned long long start;
9529d343 10927 int data_disks = imsm_num_data_members(map_dest);
687629c2 10928
503975b9 10929 targets = xmalloc(new_disks * sizeof(int));
687629c2 10930
2f86fda3
MT		 10931 for (i = 0; i < new_disks; i++) {
10932 struct dl *dl_disk = get_imsm_dl_disk(super, i);
10933
10934 targets[i] = dl_disk->fd;
10935 }
7e45b550 10936
503975b9 10937 target_offsets = xcalloc(new_disks, sizeof(unsigned long long));
687629c2 10938
d1877f69 10939 start = info->reshape_progress * 512;
687629c2 10940 for (i = 0; i < new_disks; i++) {
9f421827 10941 target_offsets[i] = migr_chkp_area_pba(super->migr_rec) * 512;
d1877f69
AK		 10942 /* move back copy area adderss, it will be moved forward
10943 * in restore_stripes() using start input variable
10944 */
10945 target_offsets[i] -= start/data_disks;
687629c2
AK		 10946 }
10947
68eb8bc6 10948 dest_layout = imsm_level_to_layout(map_dest->raid_level);
ab724b98
AK		 10949 dest_chunk = __le16_to_cpu(map_dest->blocks_per_strip) * 512;
10950
687629c2
AK		 10951 if (restore_stripes(targets, /* list of dest devices */
10952 target_offsets, /* migration record offsets */
10953 new_disks,
ab724b98
AK		 10954 dest_chunk,
10955 map_dest->raid_level,
10956 dest_layout,
10957 -1, /* source backup file descriptor */
10958 0, /* input buf offset
10959 * always 0 buf is already offseted */
d1877f69 10960 start,
687629c2
AK		 10961 length,
10962 buf) != 0) {
e7b84f9d 10963 pr_err("Error restoring stripes\n");
687629c2
AK		 10964 goto abort;
10965 }
10966
10967 rv = 0;
10968
10969abort:
10970 if (targets) {
687629c2
AK		 10971 free(targets);
10972 }
10973 free(target_offsets);
10974
10975 return rv;
10976}
10977
10978/*******************************************************************************
10979 * Function: save_checkpoint_imsm
10980 * Description: Function called for current unit status update
10981 * in the migration record. It writes it to disk.
10982 * Parameters:
10983 * super : imsm internal array info
10984 * info : general array info
10985 * Returns:
10986 * 0: success
10987 * 1: failure
0228d92c
AK		 10988 * 2: failure, means no valid migration record
10989 * / no general migration in progress /
687629c2
AK		 10990 ******************************************************************************/
10991int save_checkpoint_imsm(struct supertype *st, struct mdinfo *info, int state)
10992{
10993 struct intel_super *super = st->sb;
f8b72ef5
AK		 10994 unsigned long long blocks_per_unit;
10995 unsigned long long curr_migr_unit;
10996
2f86fda3 10997 if (load_imsm_migr_rec(super) != 0) {
7a862a02 10998 dprintf("imsm: ERROR: Cannot read migration record for checkpoint save.\n");
2e062e82
AK		 10999 return 1;
11000 }
11001
f8b72ef5
AK		 11002 blocks_per_unit = __le32_to_cpu(super->migr_rec->blocks_per_unit);
11003 if (blocks_per_unit == 0) {
0228d92c
AK		 11004 dprintf("imsm: no migration in progress.\n");
11005 return 2;
687629c2 11006 }
f8b72ef5
AK		 11007 curr_migr_unit = info->reshape_progress / blocks_per_unit;
11008 /* check if array is alligned to copy area
11009 * if it is not alligned, add one to current migration unit value
11010 * this can happend on array reshape finish only
11011 */
11012 if (info->reshape_progress % blocks_per_unit)
11013 curr_migr_unit++;
687629c2 11014
9f421827 11015 set_current_migr_unit(super->migr_rec, curr_migr_unit);
687629c2 11016 super->migr_rec->rec_status = __cpu_to_le32(state);
9f421827
PB		 11017 set_migr_dest_1st_member_lba(super->migr_rec,
11018 super->migr_rec->dest_depth_per_unit * curr_migr_unit);
11019
687629c2 11020 if (write_imsm_migr_rec(st) < 0) {
7a862a02 11021 dprintf("imsm: Cannot write migration record outside backup area\n");
687629c2
AK		 11022 return 1;
11023 }
11024
11025 return 0;
11026}
11027
276d77db
AK		 11028/*******************************************************************************
11029 * Function: recover_backup_imsm
11030 * Description: Function recovers critical data from the Migration Copy Area
11031 * while assembling an array.
11032 * Parameters:
11033 * super : imsm internal array info
11034 * info : general array info
11035 * Returns:
11036 * 0 : success (or there is no data to recover)
11037 * 1 : fail
11038 ******************************************************************************/
11039int recover_backup_imsm(struct supertype *st, struct mdinfo *info)
11040{
11041 struct intel_super *super = st->sb;
11042 struct migr_record *migr_rec = super->migr_rec;
594dc1b8 11043 struct imsm_map *map_dest;
276d77db
AK		 11044 struct intel_dev *id = NULL;
11045 unsigned long long read_offset;
11046 unsigned long long write_offset;
11047 unsigned unit_len;
2f86fda3 11048 int new_disks, err;
276d77db
AK		 11049 char *buf = NULL;
11050 int retval = 1;
f36a9ecd 11051 unsigned int sector_size = super->sector_size;
9f421827
PB		 11052 unsigned long curr_migr_unit = current_migr_unit(migr_rec);
11053 unsigned long num_migr_units = get_num_migr_units(migr_rec);
276d77db 11054 char buffer[20];
6c3560c0 11055 int skipped_disks = 0;
2f86fda3 11056 struct dl *dl_disk;
276d77db
AK		 11057
11058 err = sysfs_get_str(info, NULL, "array_state", (char *)buffer, 20);
11059 if (err < 1)
11060 return 1;
11061
11062 /* recover data only during assemblation */
11063 if (strncmp(buffer, "inactive", 8) != 0)
11064 return 0;
11065 /* no data to recover */
11066 if (__le32_to_cpu(migr_rec->rec_status) == UNIT_SRC_NORMAL)
11067 return 0;
11068 if (curr_migr_unit >= num_migr_units)
11069 return 1;
11070
11071 /* find device during reshape */
11072 for (id = super->devlist; id; id = id->next)
11073 if (is_gen_migration(id->dev))
11074 break;
11075 if (id == NULL)
11076 return 1;
11077
238c0a71 11078 map_dest = get_imsm_map(id->dev, MAP_0);
276d77db
AK		 11079 new_disks = map_dest->num_members;
11080
9f421827 11081 read_offset = migr_chkp_area_pba(migr_rec) * 512;
276d77db 11082
9f421827 11083 write_offset = (migr_dest_1st_member_lba(migr_rec) +
5551b113 11084 pba_of_lba0(map_dest)) * 512;
276d77db
AK		 11085
11086 unit_len = __le32_to_cpu(migr_rec->dest_depth_per_unit) * 512;
f36a9ecd 11087 if (posix_memalign((void **)&buf, sector_size, unit_len) != 0)
276d77db 11088 goto abort;
276d77db 11089
2f86fda3
MT		 11090 for (dl_disk = super->disks; dl_disk; dl_disk = dl_disk->next) {
11091 if (dl_disk->index < 0)
11092 continue;
276d77db 11093
2f86fda3 11094 if (dl_disk->fd < 0) {
6c3560c0
AK		 11095 skipped_disks++;
11096 continue;
11097 }
2f86fda3 11098 if (lseek64(dl_disk->fd, read_offset, SEEK_SET) < 0) {
e7b84f9d
N		 11099 pr_err("Cannot seek to block: %s\n",
11100 strerror(errno));
137debce
AK		 11101 skipped_disks++;
11102 continue;
276d77db 11103 }
2f86fda3 11104 if (read(dl_disk->fd, buf, unit_len) != unit_len) {
e7b84f9d
N		 11105 pr_err("Cannot read copy area block: %s\n",
11106 strerror(errno));
137debce
AK		 11107 skipped_disks++;
11108 continue;
276d77db 11109 }
2f86fda3 11110 if (lseek64(dl_disk->fd, write_offset, SEEK_SET) < 0) {
e7b84f9d
N		 11111 pr_err("Cannot seek to block: %s\n",
11112 strerror(errno));
137debce
AK		 11113 skipped_disks++;
11114 continue;
276d77db 11115 }
2f86fda3 11116 if (write(dl_disk->fd, buf, unit_len) != unit_len) {
e7b84f9d
N		 11117 pr_err("Cannot restore block: %s\n",
11118 strerror(errno));
137debce
AK		 11119 skipped_disks++;
11120 continue;
276d77db
AK		 11121 }
11122 }
11123
137debce
AK		 11124 if (skipped_disks > imsm_get_allowed_degradation(info->new_level,
11125 new_disks,
11126 super,
11127 id->dev)) {
7a862a02 11128 pr_err("Cannot restore data from backup. Too many failed disks\n");
6c3560c0
AK		 11129 goto abort;
11130 }
11131
befb629b
AK		 11132 if (save_checkpoint_imsm(st, info, UNIT_SRC_NORMAL)) {
11133 /* ignore error == 2, this can mean end of reshape here
11134 */
7a862a02 11135 dprintf("imsm: Cannot write checkpoint to migration record (UNIT_SRC_NORMAL) during restart\n");
befb629b 11136 } else
276d77db 11137 retval = 0;
276d77db
AK		 11138
11139abort:
276d77db
AK		 11140 free(buf);
11141 return retval;
11142}
11143
2cda7640
ML		 11144static char disk_by_path[] = "/dev/disk/by-path/";
11145
11146static const char *imsm_get_disk_controller_domain(const char *path)
11147{
2cda7640 11148 char disk_path[PATH_MAX];
96234762
LM		 11149 char *drv=NULL;
11150 struct stat st;
2cda7640 11151
6d8d290a 11152 strcpy(disk_path, disk_by_path);
96234762
LM		 11153 strncat(disk_path, path, PATH_MAX - strlen(disk_path) - 1);
11154 if (stat(disk_path, &st) == 0) {
11155 struct sys_dev* hba;
594dc1b8 11156 char *path;
96234762
LM		 11157
11158 path = devt_to_devpath(st.st_rdev);
11159 if (path == NULL)
11160 return "unknown";
11161 hba = find_disk_attached_hba(-1, path);
11162 if (hba && hba->type == SYS_DEV_SAS)
11163 drv = "isci";
11164 else if (hba && hba->type == SYS_DEV_SATA)
11165 drv = "ahci";
c6839718
MT		 11166 else if (hba && hba->type == SYS_DEV_VMD)
11167 drv = "vmd";
11168 else if (hba && hba->type == SYS_DEV_NVME)
11169 drv = "nvme";
1011e834 11170 else
96234762
LM		 11171 drv = "unknown";
11172 dprintf("path: %s hba: %s attached: %s\n",
11173 path, (hba) ? hba->path : "NULL", drv);
11174 free(path);
2cda7640 11175 }
96234762 11176 return drv;
2cda7640
ML		 11177}
11178
4dd2df09 11179static char *imsm_find_array_devnm_by_subdev(int subdev, char *container)
78b10e66 11180{
4dd2df09 11181 static char devnm[32];
78b10e66
N		 11182 char subdev_name[20];
11183 struct mdstat_ent *mdstat;
11184
11185 sprintf(subdev_name, "%d", subdev);
11186 mdstat = mdstat_by_subdev(subdev_name, container);
11187 if (!mdstat)
4dd2df09 11188 return NULL;
78b10e66 11189
4dd2df09 11190 strcpy(devnm, mdstat->devnm);
78b10e66 11191 free_mdstat(mdstat);
4dd2df09 11192 return devnm;
78b10e66
N		 11193}
11194
11195static int imsm_reshape_is_allowed_on_container(struct supertype *st,
11196 struct geo_params *geo,
fbf3d202
AK		 11197 int *old_raid_disks,
11198 int direction)
78b10e66 11199{
694575e7
KW		 11200 /* currently we only support increasing the number of devices
11201 * for a container. This increases the number of device for each
11202 * member array. They must all be RAID0 or RAID5.
11203 */
78b10e66
N		 11204 int ret_val = 0;
11205 struct mdinfo *info, *member;
11206 int devices_that_can_grow = 0;
11207
7a862a02 11208 dprintf("imsm: imsm_reshape_is_allowed_on_container(ENTER): st->devnm = (%s)\n", st->devnm);
78b10e66 11209
d04f65f4 11210 if (geo->size > 0 ||
78b10e66
N		 11211 geo->level != UnSet ||
11212 geo->layout != UnSet ||
11213 geo->chunksize != 0 ||
11214 geo->raid_disks == UnSet) {
7a862a02 11215 dprintf("imsm: Container operation is allowed for raid disks number change only.\n");
78b10e66
N		 11216 return ret_val;
11217 }
11218
fbf3d202 11219 if (direction == ROLLBACK_METADATA_CHANGES) {
7a862a02 11220 dprintf("imsm: Metadata changes rollback is not supported for container operation.\n");
fbf3d202
AK		 11221 return ret_val;
11222 }
11223
78b10e66
N		 11224 info = container_content_imsm(st, NULL);
11225 for (member = info; member; member = member->next) {
4dd2df09 11226 char *result;
78b10e66
N		 11227
11228 dprintf("imsm: checking device_num: %i\n",
11229 member->container_member);
11230
d7d205bd 11231 if (geo->raid_disks <= member->array.raid_disks) {
78b10e66
N		 11232 /* we work on container for Online Capacity Expansion
11233 * only so raid_disks has to grow
11234 */
7a862a02 11235 dprintf("imsm: for container operation raid disks increase is required\n");
78b10e66
N		 11236 break;
11237 }
11238
089f9d79 11239 if (info->array.level != 0 && info->array.level != 5) {
78b10e66
N		 11240 /* we cannot use this container with other raid level
11241 */
7a862a02 11242 dprintf("imsm: for container operation wrong raid level (%i) detected\n",
78b10e66
N		 11243 info->array.level);
11244 break;
11245 } else {
11246 /* check for platform support
11247 * for this raid level configuration
11248 */
11249 struct intel_super *super = st->sb;
11250 if (!is_raid_level_supported(super->orom,
11251 member->array.level,
11252 geo->raid_disks)) {
7a862a02 11253 dprintf("platform does not support raid%d with %d disk%s\n",
78b10e66
N		 11254 info->array.level,
11255 geo->raid_disks,
11256 geo->raid_disks > 1 ? "s" : "");
11257 break;
11258 }
2a4a08e7
AK		 11259 /* check if component size is aligned to chunk size
11260 */
11261 if (info->component_size %
11262 (info->array.chunk_size/512)) {
7a862a02 11263 dprintf("Component size is not aligned to chunk size\n");
2a4a08e7
AK		 11264 break;
11265 }
78b10e66
N		 11266 }
11267
11268 if (*old_raid_disks &&
11269 info->array.raid_disks != *old_raid_disks)
11270 break;
11271 *old_raid_disks = info->array.raid_disks;
11272
11273 /* All raid5 and raid0 volumes in container
11274 * have to be ready for Online Capacity Expansion
11275 * so they need to be assembled. We have already
11276 * checked that no recovery etc is happening.
11277 */
4dd2df09
N		 11278 result = imsm_find_array_devnm_by_subdev(member->container_member,
11279 st->container_devnm);
11280 if (result == NULL) {
78b10e66
N		 11281 dprintf("imsm: cannot find array\n");
11282 break;
11283 }
11284 devices_that_can_grow++;
11285 }
11286 sysfs_free(info);
11287 if (!member && devices_that_can_grow)
11288 ret_val = 1;
11289
11290 if (ret_val)
1ade5cc1 11291 dprintf("Container operation allowed\n");
78b10e66 11292 else
1ade5cc1 11293 dprintf("Error: %i\n", ret_val);
78b10e66
N		 11294
11295 return ret_val;
11296}
11297
11298/* Function: get_spares_for_grow
11299 * Description: Allocates memory and creates list of spare devices
1011e834 11300 * avaliable in container. Checks if spare drive size is acceptable.
78b10e66
N		 11301 * Parameters: Pointer to the supertype structure
11302 * Returns: Pointer to the list of spare devices (mdinfo structure) on success,
1011e834 11303 * NULL if fail
78b10e66
N		 11304 */
11305static struct mdinfo *get_spares_for_grow(struct supertype *st)
11306{
fbfdcb06
AO		 11307 struct spare_criteria sc;
11308
11309 get_spare_criteria_imsm(st, &sc);
11310 return container_choose_spares(st, &sc, NULL, NULL, NULL, 0);
78b10e66
N		 11311}
11312
11313/******************************************************************************
11314 * function: imsm_create_metadata_update_for_reshape
11315 * Function creates update for whole IMSM container.
11316 *
11317 ******************************************************************************/
11318static int imsm_create_metadata_update_for_reshape(
11319 struct supertype *st,
11320 struct geo_params *geo,
11321 int old_raid_disks,
11322 struct imsm_update_reshape **updatep)
11323{
11324 struct intel_super *super = st->sb;
11325 struct imsm_super *mpb = super->anchor;
594dc1b8
JS		 11326 int update_memory_size;
11327 struct imsm_update_reshape *u;
11328 struct mdinfo *spares;
78b10e66 11329 int i;
594dc1b8 11330 int delta_disks;
bbd24d86 11331 struct mdinfo *dev;
78b10e66 11332
1ade5cc1 11333 dprintf("(enter) raid_disks = %i\n", geo->raid_disks);
78b10e66
N		 11334
11335 delta_disks = geo->raid_disks - old_raid_disks;
11336
11337 /* size of all update data without anchor */
11338 update_memory_size = sizeof(struct imsm_update_reshape);
11339
11340 /* now add space for spare disks that we need to add. */
11341 update_memory_size += sizeof(u->new_disks[0]) * (delta_disks - 1);
11342
503975b9 11343 u = xcalloc(1, update_memory_size);
78b10e66
N		 11344 u->type = update_reshape_container_disks;
11345 u->old_raid_disks = old_raid_disks;
11346 u->new_raid_disks = geo->raid_disks;
11347
11348 /* now get spare disks list
11349 */
11350 spares = get_spares_for_grow(st);
11351
d7be7d87 11352 if (spares == NULL || delta_disks > spares->array.spare_disks) {
7a862a02 11353 pr_err("imsm: ERROR: Cannot get spare devices for %s.\n", geo->dev_name);
e4c72d1d 11354 i = -1;
78b10e66
N		 11355 goto abort;
11356 }
11357
11358 /* we have got spares
11359 * update disk list in imsm_disk list table in anchor
11360 */
11361 dprintf("imsm: %i spares are available.\n\n",
11362 spares->array.spare_disks);
11363
bbd24d86 11364 dev = spares->devs;
78b10e66 11365 for (i = 0; i < delta_disks; i++) {
78b10e66
N		 11366 struct dl *dl;
11367
bbd24d86
AK		 11368 if (dev == NULL)
11369 break;
78b10e66
N		 11370 u->new_disks[i] = makedev(dev->disk.major,
11371 dev->disk.minor);
11372 dl = get_disk_super(super, dev->disk.major, dev->disk.minor);
ee4beede
AK		 11373 dl->index = mpb->num_disks;
11374 mpb->num_disks++;
bbd24d86 11375 dev = dev->next;
78b10e66 11376 }
78b10e66
N		 11377
11378abort:
11379 /* free spares
11380 */
11381 sysfs_free(spares);
11382
d677e0b8 11383 dprintf("imsm: reshape update preparation :");
78b10e66 11384 if (i == delta_disks) {
1ade5cc1 11385 dprintf_cont(" OK\n");
78b10e66
N		 11386 *updatep = u;
11387 return update_memory_size;
11388 }
11389 free(u);
1ade5cc1 11390 dprintf_cont(" Error\n");
78b10e66
N		 11391
11392 return 0;
11393}
11394
f3871fdc
AK		 11395/******************************************************************************
11396 * function: imsm_create_metadata_update_for_size_change()
11397 * Creates update for IMSM array for array size change.
11398 *
11399 ******************************************************************************/
11400static int imsm_create_metadata_update_for_size_change(
11401 struct supertype *st,
11402 struct geo_params *geo,
11403 struct imsm_update_size_change **updatep)
11404{
11405 struct intel_super *super = st->sb;
594dc1b8
JS		 11406 int update_memory_size;
11407 struct imsm_update_size_change *u;
f3871fdc 11408
1ade5cc1 11409 dprintf("(enter) New size = %llu\n", geo->size);
f3871fdc
AK		 11410
11411 /* size of all update data without anchor */
11412 update_memory_size = sizeof(struct imsm_update_size_change);
11413
503975b9 11414 u = xcalloc(1, update_memory_size);
f3871fdc
AK		 11415 u->type = update_size_change;
11416 u->subdev = super->current_vol;
11417 u->new_size = geo->size;
11418
11419 dprintf("imsm: reshape update preparation : OK\n");
11420 *updatep = u;
11421
11422 return update_memory_size;
11423}
11424
48c5303a
PC		 11425/******************************************************************************
11426 * function: imsm_create_metadata_update_for_migration()
11427 * Creates update for IMSM array.
11428 *
11429 ******************************************************************************/
11430static int imsm_create_metadata_update_for_migration(
11431 struct supertype *st,
11432 struct geo_params *geo,
11433 struct imsm_update_reshape_migration **updatep)
11434{
11435 struct intel_super *super = st->sb;
594dc1b8
JS		 11436 int update_memory_size;
11437 struct imsm_update_reshape_migration *u;
48c5303a
PC		 11438 struct imsm_dev *dev;
11439 int previous_level = -1;
11440
1ade5cc1 11441 dprintf("(enter) New Level = %i\n", geo->level);
48c5303a
PC		 11442
11443 /* size of all update data without anchor */
11444 update_memory_size = sizeof(struct imsm_update_reshape_migration);
11445
503975b9 11446 u = xcalloc(1, update_memory_size);
48c5303a
PC		 11447 u->type = update_reshape_migration;
11448 u->subdev = super->current_vol;
11449 u->new_level = geo->level;
11450 u->new_layout = geo->layout;
11451 u->new_raid_disks = u->old_raid_disks = geo->raid_disks;
11452 u->new_disks[0] = -1;
4bba0439 11453 u->new_chunksize = -1;
48c5303a
PC		 11454
11455 dev = get_imsm_dev(super, u->subdev);
11456 if (dev) {
11457 struct imsm_map *map;
11458
238c0a71 11459 map = get_imsm_map(dev, MAP_0);
4bba0439
PC		 11460 if (map) {
11461 int current_chunk_size =
11462 __le16_to_cpu(map->blocks_per_strip) / 2;
11463
11464 if (geo->chunksize != current_chunk_size) {
11465 u->new_chunksize = geo->chunksize / 1024;
7a862a02 11466 dprintf("imsm: chunk size change from %i to %i\n",
4bba0439
PC		 11467 current_chunk_size, u->new_chunksize);
11468 }
48c5303a 11469 previous_level = map->raid_level;
4bba0439 11470 }
48c5303a 11471 }
089f9d79 11472 if (geo->level == 5 && previous_level == 0) {
48c5303a
PC		 11473 struct mdinfo *spares = NULL;
11474
11475 u->new_raid_disks++;
11476 spares = get_spares_for_grow(st);
089f9d79 11477 if (spares == NULL || spares->array.spare_disks < 1) {
48c5303a
PC		 11478 free(u);
11479 sysfs_free(spares);
11480 update_memory_size = 0;
565cc99e 11481 pr_err("cannot get spare device for requested migration\n");
48c5303a
PC		 11482 return 0;
11483 }
11484 sysfs_free(spares);
11485 }
11486 dprintf("imsm: reshape update preparation : OK\n");
11487 *updatep = u;
11488
11489 return update_memory_size;
11490}
11491
8dd70bce
AK		 11492static void imsm_update_metadata_locally(struct supertype *st,
11493 void *buf, int len)
11494{
11495 struct metadata_update mu;
11496
11497 mu.buf = buf;
11498 mu.len = len;
11499 mu.space = NULL;
11500 mu.space_list = NULL;
11501 mu.next = NULL;
5fe6f031
N		 11502 if (imsm_prepare_update(st, &mu))
11503 imsm_process_update(st, &mu);
8dd70bce
AK		 11504
11505 while (mu.space_list) {
11506 void **space = mu.space_list;
11507 mu.space_list = *space;
11508 free(space);
11509 }
11510}
78b10e66 11511
471bceb6 11512/***************************************************************************
694575e7 11513* Function: imsm_analyze_change
471bceb6 11514* Description: Function analyze change for single volume
1011e834 11515* and validate if transition is supported
fbf3d202
AK		 11516* Parameters: Geometry parameters, supertype structure,
11517* metadata change direction (apply/rollback)
694575e7 11518* Returns: Operation type code on success, -1 if fail
471bceb6
KW		 11519****************************************************************************/
11520enum imsm_reshape_type imsm_analyze_change(struct supertype *st,
fbf3d202
AK		 11521 struct geo_params *geo,
11522 int direction)
694575e7 11523{
471bceb6
KW		 11524 struct mdinfo info;
11525 int change = -1;
11526 int check_devs = 0;
c21e737b 11527 int chunk;
67a2db32
AK		 11528 /* number of added/removed disks in operation result */
11529 int devNumChange = 0;
11530 /* imsm compatible layout value for array geometry verification */
11531 int imsm_layout = -1;
7abc9871
AK		 11532 int data_disks;
11533 struct imsm_dev *dev;
9529d343 11534 struct imsm_map *map;
7abc9871 11535 struct intel_super *super;
d04f65f4 11536 unsigned long long current_size;
65d38cca 11537 unsigned long long free_size;
d04f65f4 11538 unsigned long long max_size;
65d38cca 11539 int rv;
471bceb6
KW		 11540
11541 getinfo_super_imsm_volume(st, &info, NULL);
089f9d79
JS		 11542 if (geo->level != info.array.level && geo->level >= 0 &&
11543 geo->level != UnSet) {
471bceb6
KW		 11544 switch (info.array.level) {
11545 case 0:
11546 if (geo->level == 5) {
b5347799 11547 change = CH_MIGRATION;
e13ce846 11548 if (geo->layout != ALGORITHM_LEFT_ASYMMETRIC) {
7a862a02 11549 pr_err("Error. Requested Layout not supported (left-asymmetric layout is supported only)!\n");
e13ce846
AK		 11550 change = -1;
11551 goto analyse_change_exit;
11552 }
67a2db32 11553 imsm_layout = geo->layout;
471bceb6 11554 check_devs = 1;
e91a3bad
LM		 11555 devNumChange = 1; /* parity disk added */
11556 } else if (geo->level == 10) {
471bceb6
KW		 11557 change = CH_TAKEOVER;
11558 check_devs = 1;
e91a3bad 11559 devNumChange = 2; /* two mirrors added */
67a2db32 11560 imsm_layout = 0x102; /* imsm supported layout */
471bceb6 11561 }
dfe77a9e
KW		 11562 break;
11563 case 1:
471bceb6
KW		 11564 case 10:
11565 if (geo->level == 0) {
11566 change = CH_TAKEOVER;
11567 check_devs = 1;
e91a3bad 11568 devNumChange = -(geo->raid_disks/2);
67a2db32 11569 imsm_layout = 0; /* imsm raid0 layout */
471bceb6
KW		 11570 }
11571 break;
11572 }
11573 if (change == -1) {
7a862a02 11574 pr_err("Error. Level Migration from %d to %d not supported!\n",
e7b84f9d 11575 info.array.level, geo->level);
471bceb6
KW		 11576 goto analyse_change_exit;
11577 }
11578 } else
11579 geo->level = info.array.level;
11580
089f9d79
JS		 11581 if (geo->layout != info.array.layout &&
11582 (geo->layout != UnSet && geo->layout != -1)) {
b5347799 11583 change = CH_MIGRATION;
089f9d79
JS		 11584 if (info.array.layout == 0 && info.array.level == 5 &&
11585 geo->layout == 5) {
471bceb6 11586 /* reshape 5 -> 4 */
089f9d79
JS		 11587 } else if (info.array.layout == 5 && info.array.level == 5 &&
11588 geo->layout == 0) {
471bceb6
KW		 11589 /* reshape 4 -> 5 */
11590 geo->layout = 0;
11591 geo->level = 5;
11592 } else {
7a862a02 11593 pr_err("Error. Layout Migration from %d to %d not supported!\n",
e7b84f9d 11594 info.array.layout, geo->layout);
471bceb6
KW		 11595 change = -1;
11596 goto analyse_change_exit;
11597 }
67a2db32 11598 } else {
471bceb6 11599 geo->layout = info.array.layout;
67a2db32
AK		 11600 if (imsm_layout == -1)
11601 imsm_layout = info.array.layout;
11602 }
471bceb6 11603
089f9d79
JS		 11604 if (geo->chunksize > 0 && geo->chunksize != UnSet &&
11605 geo->chunksize != info.array.chunk_size) {
2d2b0eb7
MD		 11606 if (info.array.level == 10) {
11607 pr_err("Error. Chunk size change for RAID 10 is not supported.\n");
11608 change = -1;
11609 goto analyse_change_exit;
1e9b2c3f
PB		 11610 } else if (info.component_size % (geo->chunksize/512)) {
11611 pr_err("New chunk size (%dK) does not evenly divide device size (%lluk). Aborting...\n",
11612 geo->chunksize/1024, info.component_size/2);
11613 change = -1;
11614 goto analyse_change_exit;
2d2b0eb7 11615 }
b5347799 11616 change = CH_MIGRATION;
2d2b0eb7 11617 } else {
471bceb6 11618 geo->chunksize = info.array.chunk_size;
2d2b0eb7 11619 }
471bceb6 11620
c21e737b 11621 chunk = geo->chunksize / 1024;
7abc9871
AK		 11622
11623 super = st->sb;
11624 dev = get_imsm_dev(super, super->current_vol);
9529d343
MD		 11625 map = get_imsm_map(dev, MAP_0);
11626 data_disks = imsm_num_data_members(map);
c41e00b2 11627 /* compute current size per disk member
7abc9871 11628 */
c41e00b2
AK		 11629 current_size = info.custom_array_size / data_disks;
11630
089f9d79 11631 if (geo->size > 0 && geo->size != MAX_SIZE) {
c41e00b2
AK		 11632 /* align component size
11633 */
3e684231 11634 geo->size = imsm_component_size_alignment_check(
c41e00b2 11635 get_imsm_raid_level(dev->vol.map),
f36a9ecd 11636 chunk * 1024, super->sector_size,
c41e00b2 11637 geo->size * 2);
65d0b4ce 11638 if (geo->size == 0) {
7a862a02 11639 pr_err("Error. Size expansion is supported only (current size is %llu, requested size /rounded/ is 0).\n",
65d0b4ce
LD		 11640 current_size);
11641 goto analyse_change_exit;
11642 }
c41e00b2 11643 }
7abc9871 11644
089f9d79 11645 if (current_size != geo->size && geo->size > 0) {
7abc9871 11646 if (change != -1) {
7a862a02 11647 pr_err("Error. Size change should be the only one at a time.\n");
7abc9871
AK		 11648 change = -1;
11649 goto analyse_change_exit;
11650 }
11651 if ((super->current_vol + 1) != super->anchor->num_raid_devs) {
7a862a02 11652 pr_err("Error. The last volume in container can be expanded only (%i/%s).\n",
4dd2df09 11653 super->current_vol, st->devnm);
7abc9871
AK		 11654 goto analyse_change_exit;
11655 }
65d38cca
LD		 11656 /* check the maximum available size
11657 */
11658 rv = imsm_get_free_size(st, dev->vol.map->num_members,
11659 0, chunk, &free_size);
11660 if (rv == 0)
11661 /* Cannot find maximum available space
11662 */
11663 max_size = 0;
11664 else {
11665 max_size = free_size + current_size;
11666 /* align component size
11667 */
3e684231 11668 max_size = imsm_component_size_alignment_check(
65d38cca 11669 get_imsm_raid_level(dev->vol.map),
f36a9ecd 11670 chunk * 1024, super->sector_size,
65d38cca
LD		 11671 max_size);
11672 }
d04f65f4 11673 if (geo->size == MAX_SIZE) {
b130333f
AK		 11674 /* requested size change to the maximum available size
11675 */
65d38cca 11676 if (max_size == 0) {
7a862a02 11677 pr_err("Error. Cannot find maximum available space.\n");
b130333f
AK		 11678 change = -1;
11679 goto analyse_change_exit;
65d38cca
LD		 11680 } else
11681 geo->size = max_size;
c41e00b2 11682 }
b130333f 11683
681b7ae2 11684 if (direction == ROLLBACK_METADATA_CHANGES) {
fbf3d202
AK		 11685 /* accept size for rollback only
11686 */
11687 } else {
11688 /* round size due to metadata compatibility
11689 */
11690 geo->size = (geo->size >> SECT_PER_MB_SHIFT)
11691 << SECT_PER_MB_SHIFT;
11692 dprintf("Prepare update for size change to %llu\n",
11693 geo->size );
11694 if (current_size >= geo->size) {
7a862a02 11695 pr_err("Error. Size expansion is supported only (current size is %llu, requested size /rounded/ is %llu).\n",
e7b84f9d 11696 current_size, geo->size);
fbf3d202
AK		 11697 goto analyse_change_exit;
11698 }
65d38cca 11699 if (max_size && geo->size > max_size) {
7a862a02 11700 pr_err("Error. Requested size is larger than maximum available size (maximum available size is %llu, requested size /rounded/ is %llu).\n",
e7b84f9d 11701 max_size, geo->size);
65d38cca
LD		 11702 goto analyse_change_exit;
11703 }
7abc9871
AK		 11704 }
11705 geo->size *= data_disks;
11706 geo->raid_disks = dev->vol.map->num_members;
11707 change = CH_ARRAY_SIZE;
11708 }
471bceb6
KW		 11709 if (!validate_geometry_imsm(st,
11710 geo->level,
67a2db32 11711 imsm_layout,
e91a3bad 11712 geo->raid_disks + devNumChange,
c21e737b 11713 &chunk,
af4348dd 11714 geo->size, INVALID_SECTORS,
5308f117 11715 0, 0, info.consistency_policy, 1))
471bceb6
KW		 11716 change = -1;
11717
11718 if (check_devs) {
11719 struct intel_super *super = st->sb;
11720 struct imsm_super *mpb = super->anchor;
11721
11722 if (mpb->num_raid_devs > 1) {
7a862a02 11723 pr_err("Error. Cannot perform operation on %s- for this operation it MUST be single array in container\n",
e7b84f9d 11724 geo->dev_name);
471bceb6
KW		 11725 change = -1;
11726 }
11727 }
11728
11729analyse_change_exit:
089f9d79
JS		 11730 if (direction == ROLLBACK_METADATA_CHANGES &&
11731 (change == CH_MIGRATION || change == CH_TAKEOVER)) {
7a862a02 11732 dprintf("imsm: Metadata changes rollback is not supported for migration and takeover operations.\n");
fbf3d202
AK		 11733 change = -1;
11734 }
471bceb6 11735 return change;
694575e7
KW		 11736}
11737
bb025c2f
KW		 11738int imsm_takeover(struct supertype *st, struct geo_params *geo)
11739{
11740 struct intel_super *super = st->sb;
11741 struct imsm_update_takeover *u;
11742
503975b9 11743 u = xmalloc(sizeof(struct imsm_update_takeover));
bb025c2f
KW		 11744
11745 u->type = update_takeover;
11746 u->subarray = super->current_vol;
11747
11748 /* 10->0 transition */
11749 if (geo->level == 0)
11750 u->direction = R10_TO_R0;
11751
0529c688
KW		 11752 /* 0->10 transition */
11753 if (geo->level == 10)
11754 u->direction = R0_TO_R10;
11755
bb025c2f
KW		 11756 /* update metadata locally */
11757 imsm_update_metadata_locally(st, u,
11758 sizeof(struct imsm_update_takeover));
11759 /* and possibly remotely */
11760 if (st->update_tail)
11761 append_metadata_update(st, u,
11762 sizeof(struct imsm_update_takeover));
11763 else
11764 free(u);
11765
11766 return 0;
11767}
11768
895ffd99
MT		 11769/* Flush size update if size calculated by num_data_stripes is higher than
11770 * imsm_dev_size to eliminate differences during reshape.
11771 * Mdmon will recalculate them correctly.
11772 * If subarray index is not set then check whole container.
11773 * Returns:
11774 * 0 - no error occurred
11775 * 1 - error detected
11776 */
11777static int imsm_fix_size_mismatch(struct supertype *st, int subarray_index)
11778{
11779 struct intel_super *super = st->sb;
11780 int tmp = super->current_vol;
11781 int ret_val = 1;
11782 int i;
11783
11784 for (i = 0; i < super->anchor->num_raid_devs; i++) {
11785 if (subarray_index >= 0 && i != subarray_index)
11786 continue;
11787 super->current_vol = i;
11788 struct imsm_dev *dev = get_imsm_dev(super, super->current_vol);
11789 struct imsm_map *map = get_imsm_map(dev, MAP_0);
11790 unsigned int disc_count = imsm_num_data_members(map);
11791 struct geo_params geo;
11792 struct imsm_update_size_change *update;
11793 unsigned long long calc_size = per_dev_array_size(map) * disc_count;
11794 unsigned long long d_size = imsm_dev_size(dev);
11795 int u_size;
11796
11797 if (calc_size == d_size || dev->vol.migr_type == MIGR_GEN_MIGR)
11798 continue;
11799
11800 /* There is a difference, verify that imsm_dev_size is
11801 * rounded correctly and push update.
11802 */
11803 if (d_size != round_size_to_mb(d_size, disc_count)) {
11804 dprintf("imsm: Size of volume %d is not rounded correctly\n",
11805 i);
11806 goto exit;
11807 }
11808 memset(&geo, 0, sizeof(struct geo_params));
11809 geo.size = d_size;
11810 u_size = imsm_create_metadata_update_for_size_change(st, &geo,
11811 &update);
11812 if (u_size < 1) {
11813 dprintf("imsm: Cannot prepare size change update\n");
11814 goto exit;
11815 }
11816 imsm_update_metadata_locally(st, update, u_size);
11817 if (st->update_tail) {
11818 append_metadata_update(st, update, u_size);
11819 flush_metadata_updates(st);
11820 st->update_tail = &st->updates;
11821 } else {
11822 imsm_sync_metadata(st);
11823 }
11824 }
11825 ret_val = 0;
11826exit:
11827 super->current_vol = tmp;
11828 return ret_val;
11829}
11830
d04f65f4
N		 11831static int imsm_reshape_super(struct supertype *st, unsigned long long size,
11832 int level,
78b10e66 11833 int layout, int chunksize, int raid_disks,
41784c88 11834 int delta_disks, char *backup, char *dev,
016e00f5 11835 int direction, int verbose)
78b10e66 11836{
78b10e66
N		 11837 int ret_val = 1;
11838 struct geo_params geo;
11839
1ade5cc1 11840 dprintf("(enter)\n");
78b10e66 11841
71204a50 11842 memset(&geo, 0, sizeof(struct geo_params));
78b10e66
N		 11843
11844 geo.dev_name = dev;
4dd2df09 11845 strcpy(geo.devnm, st->devnm);
78b10e66
N		 11846 geo.size = size;
11847 geo.level = level;
11848 geo.layout = layout;
11849 geo.chunksize = chunksize;
11850 geo.raid_disks = raid_disks;
41784c88
AK		 11851 if (delta_disks != UnSet)
11852 geo.raid_disks += delta_disks;
78b10e66 11853
1ade5cc1
N		 11854 dprintf("for level : %i\n", geo.level);
11855 dprintf("for raid_disks : %i\n", geo.raid_disks);
78b10e66 11856
4dd2df09 11857 if (strcmp(st->container_devnm, st->devnm) == 0) {
694575e7
KW		 11858 /* On container level we can only increase number of devices. */
11859 dprintf("imsm: info: Container operation\n");
78b10e66 11860 int old_raid_disks = 0;
6dc0be30 11861
78b10e66 11862 if (imsm_reshape_is_allowed_on_container(
fbf3d202 11863 st, &geo, &old_raid_disks, direction)) {
78b10e66
N		 11864 struct imsm_update_reshape *u = NULL;
11865 int len;
11866
895ffd99
MT		 11867 if (imsm_fix_size_mismatch(st, -1)) {
11868 dprintf("imsm: Cannot fix size mismatch\n");
11869 goto exit_imsm_reshape_super;
11870 }
11871
78b10e66
N		 11872 len = imsm_create_metadata_update_for_reshape(
11873 st, &geo, old_raid_disks, &u);
11874
ed08d51c
AK		 11875 if (len <= 0) {
11876 dprintf("imsm: Cannot prepare update\n");
11877 goto exit_imsm_reshape_super;
11878 }
11879
8dd70bce
AK		 11880 ret_val = 0;
11881 /* update metadata locally */
11882 imsm_update_metadata_locally(st, u, len);
11883 /* and possibly remotely */
11884 if (st->update_tail)
11885 append_metadata_update(st, u, len);
11886 else
ed08d51c 11887 free(u);
8dd70bce 11888
694575e7 11889 } else {
7a862a02 11890 pr_err("(imsm) Operation is not allowed on this container\n");
694575e7
KW		 11891 }
11892 } else {
11893 /* On volume level we support following operations
471bceb6
KW		 11894 * - takeover: raid10 -> raid0; raid0 -> raid10
11895 * - chunk size migration
11896 * - migration: raid5 -> raid0; raid0 -> raid5
11897 */
11898 struct intel_super *super = st->sb;
11899 struct intel_dev *dev = super->devlist;
4dd2df09 11900 int change;
694575e7 11901 dprintf("imsm: info: Volume operation\n");
471bceb6
KW		 11902 /* find requested device */
11903 while (dev) {
1011e834 11904 char *devnm =
4dd2df09
N		 11905 imsm_find_array_devnm_by_subdev(
11906 dev->index, st->container_devnm);
11907 if (devnm && strcmp(devnm, geo.devnm) == 0)
471bceb6
KW		 11908 break;
11909 dev = dev->next;
11910 }
11911 if (dev == NULL) {
4dd2df09
N		 11912 pr_err("Cannot find %s (%s) subarray\n",
11913 geo.dev_name, geo.devnm);
471bceb6
KW		 11914 goto exit_imsm_reshape_super;
11915 }
11916 super->current_vol = dev->index;
fbf3d202 11917 change = imsm_analyze_change(st, &geo, direction);
694575e7 11918 switch (change) {
471bceb6 11919 case CH_TAKEOVER:
bb025c2f 11920 ret_val = imsm_takeover(st, &geo);
694575e7 11921 break;
48c5303a
PC		 11922 case CH_MIGRATION: {
11923 struct imsm_update_reshape_migration *u = NULL;
11924 int len =
11925 imsm_create_metadata_update_for_migration(
11926 st, &geo, &u);
11927 if (len < 1) {
7a862a02 11928 dprintf("imsm: Cannot prepare update\n");
48c5303a
PC		 11929 break;
11930 }
471bceb6 11931 ret_val = 0;
48c5303a
PC		 11932 /* update metadata locally */
11933 imsm_update_metadata_locally(st, u, len);
11934 /* and possibly remotely */
11935 if (st->update_tail)
11936 append_metadata_update(st, u, len);
11937 else
11938 free(u);
11939 }
11940 break;
7abc9871 11941 case CH_ARRAY_SIZE: {
f3871fdc
AK		 11942 struct imsm_update_size_change *u = NULL;
11943 int len =
11944 imsm_create_metadata_update_for_size_change(
11945 st, &geo, &u);
11946 if (len < 1) {
7a862a02 11947 dprintf("imsm: Cannot prepare update\n");
f3871fdc
AK		 11948 break;
11949 }
11950 ret_val = 0;
11951 /* update metadata locally */
11952 imsm_update_metadata_locally(st, u, len);
11953 /* and possibly remotely */
11954 if (st->update_tail)
11955 append_metadata_update(st, u, len);
11956 else
11957 free(u);
7abc9871
AK		 11958 }
11959 break;
471bceb6
KW		 11960 default:
11961 ret_val = 1;
694575e7 11962 }
694575e7 11963 }
78b10e66 11964
ed08d51c 11965exit_imsm_reshape_super:
78b10e66
N		 11966 dprintf("imsm: reshape_super Exit code = %i\n", ret_val);
11967 return ret_val;
11968}
2cda7640 11969
0febb20c
AO		 11970#define COMPLETED_OK 0
11971#define COMPLETED_NONE 1
11972#define COMPLETED_DELAYED 2
11973
11974static int read_completed(int fd, unsigned long long *val)
11975{
11976 int ret;
11977 char buf[50];
11978
11979 ret = sysfs_fd_get_str(fd, buf, 50);
11980 if (ret < 0)
11981 return ret;
11982
11983 ret = COMPLETED_OK;
11984 if (strncmp(buf, "none", 4) == 0) {
11985 ret = COMPLETED_NONE;
11986 } else if (strncmp(buf, "delayed", 7) == 0) {
11987 ret = COMPLETED_DELAYED;
11988 } else {
11989 char *ep;
11990 *val = strtoull(buf, &ep, 0);
11991 if (ep == buf || (*ep != 0 && *ep != '\n' && *ep != ' '))
11992 ret = -1;
11993 }
11994 return ret;
11995}
11996
eee67a47
AK		 11997/*******************************************************************************
11998 * Function: wait_for_reshape_imsm
11999 * Description: Function writes new sync_max value and waits until
12000 * reshape process reach new position
12001 * Parameters:
12002 * sra : general array info
eee67a47
AK		 12003 * ndata : number of disks in new array's layout
12004 * Returns:
12005 * 0 : success,
12006 * 1 : there is no reshape in progress,
12007 * -1 : fail
12008 ******************************************************************************/
ae9f01f8 12009int wait_for_reshape_imsm(struct mdinfo *sra, int ndata)
eee67a47 12010{
85ca499c 12011 int fd = sysfs_get_fd(sra, NULL, "sync_completed");
df2647fa 12012 int retry = 3;
eee67a47 12013 unsigned long long completed;
ae9f01f8
AK		 12014 /* to_complete : new sync_max position */
12015 unsigned long long to_complete = sra->reshape_progress;
12016 unsigned long long position_to_set = to_complete / ndata;
eee67a47 12017
ae9f01f8 12018 if (fd < 0) {
1ade5cc1 12019 dprintf("cannot open reshape_position\n");
eee67a47 12020 return 1;
ae9f01f8 12021 }
eee67a47 12022
df2647fa
PB		 12023 do {
12024 if (sysfs_fd_get_ll(fd, &completed) < 0) {
12025 if (!retry) {
12026 dprintf("cannot read reshape_position (no reshape in progres)\n");
12027 close(fd);
12028 return 1;
12029 }
12030 usleep(30000);
12031 } else
12032 break;
12033 } while (retry--);
eee67a47 12034
85ca499c 12035 if (completed > position_to_set) {
1ade5cc1 12036 dprintf("wrong next position to set %llu (%llu)\n",
85ca499c 12037 to_complete, position_to_set);
ae9f01f8
AK		 12038 close(fd);
12039 return -1;
12040 }
12041 dprintf("Position set: %llu\n", position_to_set);
12042 if (sysfs_set_num(sra, NULL, "sync_max",
12043 position_to_set) != 0) {
1ade5cc1 12044 dprintf("cannot set reshape position to %llu\n",
ae9f01f8
AK		 12045 position_to_set);
12046 close(fd);
12047 return -1;
eee67a47
AK		 12048 }
12049
eee67a47 12050 do {
0febb20c 12051 int rc;
eee67a47 12052 char action[20];
5ff3a780 12053 int timeout = 3000;
0febb20c 12054
5ff3a780 12055 sysfs_wait(fd, &timeout);
a47e44fb
AK		 12056 if (sysfs_get_str(sra, NULL, "sync_action",
12057 action, 20) > 0 &&
d7d3809a 12058 strncmp(action, "reshape", 7) != 0) {
b2be2b62
AO		 12059 if (strncmp(action, "idle", 4) == 0)
12060 break;
d7d3809a
AP		 12061 close(fd);
12062 return -1;
12063 }
0febb20c
AO		 12064
12065 rc = read_completed(fd, &completed);
12066 if (rc < 0) {
1ade5cc1 12067 dprintf("cannot read reshape_position (in loop)\n");
eee67a47
AK		 12068 close(fd);
12069 return 1;
0febb20c
AO		 12070 } else if (rc == COMPLETED_NONE)
12071 break;
85ca499c 12072 } while (completed < position_to_set);
b2be2b62 12073
eee67a47
AK		 12074 close(fd);
12075 return 0;
eee67a47
AK		 12076}
12077
b915c95f
AK		 12078/*******************************************************************************
12079 * Function: check_degradation_change
12080 * Description: Check that array hasn't become failed.
12081 * Parameters:
12082 * info : for sysfs access
12083 * sources : source disks descriptors
12084 * degraded: previous degradation level
12085 * Returns:
12086 * degradation level
12087 ******************************************************************************/
12088int check_degradation_change(struct mdinfo *info,
12089 int *sources,
12090 int degraded)
12091{
12092 unsigned long long new_degraded;
e1993023
LD		 12093 int rv;
12094
12095 rv = sysfs_get_ll(info, NULL, "degraded", &new_degraded);
089f9d79 12096 if (rv == -1 || (new_degraded != (unsigned long long)degraded)) {
b915c95f
AK		 12097 /* check each device to ensure it is still working */
12098 struct mdinfo *sd;
12099 new_degraded = 0;
12100 for (sd = info->devs ; sd ; sd = sd->next) {
12101 if (sd->disk.state & (1<<MD_DISK_FAULTY))
12102 continue;
12103 if (sd->disk.state & (1<<MD_DISK_SYNC)) {
cf52eff5
TM		 12104 char sbuf[100];
12105
b915c95f 12106 if (sysfs_get_str(info,
cf52eff5 12107 sd, "state", sbuf, sizeof(sbuf)) < 0 ||
b915c95f
AK		 12108 strstr(sbuf, "faulty") ||
12109 strstr(sbuf, "in_sync") == NULL) {
12110 /* this device is dead */
12111 sd->disk.state = (1<<MD_DISK_FAULTY);
12112 if (sd->disk.raid_disk >= 0 &&
12113 sources[sd->disk.raid_disk] >= 0) {
12114 close(sources[
12115 sd->disk.raid_disk]);
12116 sources[sd->disk.raid_disk] =
12117 -1;
12118 }
12119 new_degraded++;
12120 }
12121 }
12122 }
12123 }
12124
12125 return new_degraded;
12126}
12127
10f22854
AK		 12128/*******************************************************************************
12129 * Function: imsm_manage_reshape
12130 * Description: Function finds array under reshape and it manages reshape
12131 * process. It creates stripes backups (if required) and sets
942e1cdb 12132 * checkpoints.
10f22854
AK		 12133 * Parameters:
12134 * afd : Backup handle (nattive) - not used
12135 * sra : general array info
12136 * reshape : reshape parameters - not used
12137 * st : supertype structure
12138 * blocks : size of critical section [blocks]
12139 * fds : table of source device descriptor
12140 * offsets : start of array (offest per devices)
12141 * dests : not used
12142 * destfd : table of destination device descriptor
12143 * destoffsets : table of destination offsets (per device)
12144 * Returns:
12145 * 1 : success, reshape is done
12146 * 0 : fail
12147 ******************************************************************************/
999b4972
N		 12148static int imsm_manage_reshape(
12149 int afd, struct mdinfo *sra, struct reshape *reshape,
10f22854 12150 struct supertype *st, unsigned long backup_blocks,
999b4972
N		 12151 int *fds, unsigned long long *offsets,
12152 int dests, int *destfd, unsigned long long *destoffsets)
12153{
10f22854
AK		 12154 int ret_val = 0;
12155 struct intel_super *super = st->sb;
594dc1b8 12156 struct intel_dev *dv;
de44e46f 12157 unsigned int sector_size = super->sector_size;
10f22854 12158 struct imsm_dev *dev = NULL;
9529d343 12159 struct imsm_map *map_src, *map_dest;
10f22854
AK		 12160 int migr_vol_qan = 0;
12161 int ndata, odata; /* [bytes] */
12162 int chunk; /* [bytes] */
12163 struct migr_record *migr_rec;
12164 char *buf = NULL;
12165 unsigned int buf_size; /* [bytes] */
12166 unsigned long long max_position; /* array size [bytes] */
12167 unsigned long long next_step; /* [blocks]/[bytes] */
12168 unsigned long long old_data_stripe_length;
10f22854
AK		 12169 unsigned long long start_src; /* [bytes] */
12170 unsigned long long start; /* [bytes] */
12171 unsigned long long start_buf_shift; /* [bytes] */
b915c95f 12172 int degraded = 0;
ab724b98 12173 int source_layout = 0;
895ffd99 12174 int subarray_index = -1;
10f22854 12175
79a16a9b
JS		 12176 if (!sra)
12177 return ret_val;
12178
12179 if (!fds || !offsets)
10f22854
AK		 12180 goto abort;
12181
12182 /* Find volume during the reshape */
12183 for (dv = super->devlist; dv; dv = dv->next) {
fc54fe7a
JS		 12184 if (dv->dev->vol.migr_type == MIGR_GEN_MIGR &&
12185 dv->dev->vol.migr_state == 1) {
10f22854
AK		 12186 dev = dv->dev;
12187 migr_vol_qan++;
895ffd99 12188 subarray_index = dv->index;
10f22854
AK		 12189 }
12190 }
12191 /* Only one volume can migrate at the same time */
12192 if (migr_vol_qan != 1) {
676e87a8 12193 pr_err("%s", migr_vol_qan ?
10f22854
AK		 12194 "Number of migrating volumes greater than 1\n" :
12195 "There is no volume during migrationg\n");
12196 goto abort;
12197 }
12198
9529d343 12199 map_dest = get_imsm_map(dev, MAP_0);
238c0a71 12200 map_src = get_imsm_map(dev, MAP_1);
10f22854
AK		 12201 if (map_src == NULL)
12202 goto abort;
10f22854 12203
9529d343
MD		 12204 ndata = imsm_num_data_members(map_dest);
12205 odata = imsm_num_data_members(map_src);
10f22854 12206
7b1ab482 12207 chunk = __le16_to_cpu(map_src->blocks_per_strip) * 512;
10f22854
AK		 12208 old_data_stripe_length = odata * chunk;
12209
12210 migr_rec = super->migr_rec;
12211
10f22854
AK		 12212 /* initialize migration record for start condition */
12213 if (sra->reshape_progress == 0)
12214 init_migr_record_imsm(st, dev, sra);
b2c59438
AK		 12215 else {
12216 if (__le32_to_cpu(migr_rec->rec_status) != UNIT_SRC_NORMAL) {
7a862a02 12217 dprintf("imsm: cannot restart migration when data are present in copy area.\n");
b2c59438
AK		 12218 goto abort;
12219 }
6a75c8ca
AK		 12220 /* Save checkpoint to update migration record for current
12221 * reshape position (in md). It can be farther than current
12222 * reshape position in metadata.
12223 */
12224 if (save_checkpoint_imsm(st, sra, UNIT_SRC_NORMAL) == 1) {
12225 /* ignore error == 2, this can mean end of reshape here
12226 */
7a862a02 12227 dprintf("imsm: Cannot write checkpoint to migration record (UNIT_SRC_NORMAL, initial save)\n");
6a75c8ca
AK		 12228 goto abort;
12229 }
b2c59438 12230 }
10f22854
AK		 12231
12232 /* size for data */
12233 buf_size = __le32_to_cpu(migr_rec->blocks_per_unit) * 512;
12234 /* extend buffer size for parity disk */
12235 buf_size += __le32_to_cpu(migr_rec->dest_depth_per_unit) * 512;
3e684231 12236 /* add space for stripe alignment */
10f22854 12237 buf_size += old_data_stripe_length;
de44e46f
PB		 12238 if (posix_memalign((void **)&buf, MAX_SECTOR_SIZE, buf_size)) {
12239 dprintf("imsm: Cannot allocate checkpoint buffer\n");
10f22854
AK		 12240 goto abort;
12241 }
12242
3ef4403c 12243 max_position = sra->component_size * ndata;
68eb8bc6 12244 source_layout = imsm_level_to_layout(map_src->raid_level);
10f22854 12245
9f421827
PB		 12246 while (current_migr_unit(migr_rec) <
12247 get_num_migr_units(migr_rec)) {
10f22854
AK		 12248 /* current reshape position [blocks] */
12249 unsigned long long current_position =
12250 __le32_to_cpu(migr_rec->blocks_per_unit)
9f421827 12251 * current_migr_unit(migr_rec);
10f22854
AK		 12252 unsigned long long border;
12253
b915c95f
AK		 12254 /* Check that array hasn't become failed.
12255 */
12256 degraded = check_degradation_change(sra, fds, degraded);
12257 if (degraded > 1) {
7a862a02 12258 dprintf("imsm: Abort reshape due to degradation level (%i)\n", degraded);
b915c95f
AK		 12259 goto abort;
12260 }
12261
10f22854
AK		 12262 next_step = __le32_to_cpu(migr_rec->blocks_per_unit);
12263
12264 if ((current_position + next_step) > max_position)
12265 next_step = max_position - current_position;
12266
92144abf 12267 start = current_position * 512;
10f22854 12268
942e1cdb 12269 /* align reading start to old geometry */
10f22854
AK		 12270 start_buf_shift = start % old_data_stripe_length;
12271 start_src = start - start_buf_shift;
12272
12273 border = (start_src / odata) - (start / ndata);
12274 border /= 512;
12275 if (border <= __le32_to_cpu(migr_rec->dest_depth_per_unit)) {
12276 /* save critical stripes to buf
12277 * start - start address of current unit
12278 * to backup [bytes]
12279 * start_src - start address of current unit
12280 * to backup alligned to source array
12281 * [bytes]
12282 */
594dc1b8 12283 unsigned long long next_step_filler;
10f22854
AK		 12284 unsigned long long copy_length = next_step * 512;
12285
12286 /* allign copy area length to stripe in old geometry */
12287 next_step_filler = ((copy_length + start_buf_shift)
12288 % old_data_stripe_length);
12289 if (next_step_filler)
12290 next_step_filler = (old_data_stripe_length
12291 - next_step_filler);
7a862a02 12292 dprintf("save_stripes() parameters: start = %llu,\tstart_src = %llu,\tnext_step*512 = %llu,\tstart_in_buf_shift = %llu,\tnext_step_filler = %llu\n",
10f22854
AK		 12293 start, start_src, copy_length,
12294 start_buf_shift, next_step_filler);
12295
12296 if (save_stripes(fds, offsets, map_src->num_members,
ab724b98
AK		 12297 chunk, map_src->raid_level,
12298 source_layout, 0, NULL, start_src,
10f22854
AK		 12299 copy_length +
12300 next_step_filler + start_buf_shift,
12301 buf)) {
7a862a02 12302 dprintf("imsm: Cannot save stripes to buffer\n");
10f22854
AK		 12303 goto abort;
12304 }
12305 /* Convert data to destination format and store it
12306 * in backup general migration area
12307 */
12308 if (save_backup_imsm(st, dev, sra,
aea93171 12309 buf + start_buf_shift, copy_length)) {
7a862a02 12310 dprintf("imsm: Cannot save stripes to target devices\n");
10f22854
AK		 12311 goto abort;
12312 }
12313 if (save_checkpoint_imsm(st, sra,
12314 UNIT_SRC_IN_CP_AREA)) {
7a862a02 12315 dprintf("imsm: Cannot write checkpoint to migration record (UNIT_SRC_IN_CP_AREA)\n");
10f22854
AK		 12316 goto abort;
12317 }
8016a6d4
AK		 12318 } else {
12319 /* set next step to use whole border area */
12320 border /= next_step;
12321 if (border > 1)
12322 next_step *= border;
10f22854
AK		 12323 }
12324 /* When data backed up, checkpoint stored,
12325 * kick the kernel to reshape unit of data
12326 */
12327 next_step = next_step + sra->reshape_progress;
8016a6d4
AK		 12328 /* limit next step to array max position */
12329 if (next_step > max_position)
12330 next_step = max_position;
10f22854
AK		 12331 sysfs_set_num(sra, NULL, "suspend_lo", sra->reshape_progress);
12332 sysfs_set_num(sra, NULL, "suspend_hi", next_step);
ae9f01f8 12333 sra->reshape_progress = next_step;
10f22854
AK		 12334
12335 /* wait until reshape finish */
c85338c6 12336 if (wait_for_reshape_imsm(sra, ndata)) {
c47b0ff6
AK		 12337 dprintf("wait_for_reshape_imsm returned error!\n");
12338 goto abort;
12339 }
84d11e6c
N		 12340 if (sigterm)
12341 goto abort;
10f22854 12342
0228d92c
AK		 12343 if (save_checkpoint_imsm(st, sra, UNIT_SRC_NORMAL) == 1) {
12344 /* ignore error == 2, this can mean end of reshape here
12345 */
7a862a02 12346 dprintf("imsm: Cannot write checkpoint to migration record (UNIT_SRC_NORMAL)\n");
10f22854
AK		 12347 goto abort;
12348 }
12349
12350 }
12351
71e5411e
PB		 12352 /* clear migr_rec on disks after successful migration */
12353 struct dl *d;
12354
85337573 12355 memset(super->migr_rec_buf, 0, MIGR_REC_BUF_SECTORS*MAX_SECTOR_SIZE);
71e5411e
PB		 12356 for (d = super->disks; d; d = d->next) {
12357 if (d->index < 0 || is_failed(&d->disk))
12358 continue;
12359 unsigned long long dsize;
12360
12361 get_dev_size(d->fd, NULL, &dsize);
de44e46f 12362 if (lseek64(d->fd, dsize - MIGR_REC_SECTOR_POSITION*sector_size,
71e5411e 12363 SEEK_SET) >= 0) {
466070ad 12364 if ((unsigned int)write(d->fd, super->migr_rec_buf,
de44e46f
PB		 12365 MIGR_REC_BUF_SECTORS*sector_size) !=
12366 MIGR_REC_BUF_SECTORS*sector_size)
71e5411e
PB		 12367 perror("Write migr_rec failed");
12368 }
12369 }
12370
10f22854
AK		 12371 /* return '1' if done */
12372 ret_val = 1;
895ffd99
MT		 12373
12374 /* After the reshape eliminate size mismatch in metadata.
12375 * Don't update md/component_size here, volume hasn't
12376 * to take whole space. It is allowed by kernel.
12377 * md/component_size will be set propoperly after next assembly.
12378 */
12379 imsm_fix_size_mismatch(st, subarray_index);
12380
10f22854
AK		 12381abort:
12382 free(buf);
942e1cdb
N		 12383 /* See Grow.c: abort_reshape() for further explanation */
12384 sysfs_set_num(sra, NULL, "suspend_lo", 0x7FFFFFFFFFFFFFFFULL);
12385 sysfs_set_num(sra, NULL, "suspend_hi", 0);
12386 sysfs_set_num(sra, NULL, "suspend_lo", 0);
10f22854
AK		 12387
12388 return ret_val;
999b4972 12389}
0c21b485 12390
fbc42556
JR		 12391/*******************************************************************************
12392 * Function: calculate_bitmap_min_chunksize
12393 * Description: Calculates the minimal valid bitmap chunk size
12394 * Parameters:
12395 * max_bits : indicate how many bits can be used for the bitmap
12396 * data_area_size : the size of the data area covered by the bitmap
12397 *
12398 * Returns:
12399 * The bitmap chunk size
12400 ******************************************************************************/
12401static unsigned long long
12402calculate_bitmap_min_chunksize(unsigned long long max_bits,
12403 unsigned long long data_area_size)
12404{
12405 unsigned long long min_chunk =
12406 4096; /* sub-page chunks don't work yet.. */
12407 unsigned long long bits = data_area_size / min_chunk + 1;
12408
12409 while (bits > max_bits) {
12410 min_chunk *= 2;
12411 bits = (bits + 1) / 2;
12412 }
12413 return min_chunk;
12414}
12415
12416/*******************************************************************************
12417 * Function: calculate_bitmap_chunksize
12418 * Description: Calculates the bitmap chunk size for the given device
12419 * Parameters:
12420 * st : supertype information
12421 * dev : device for the bitmap
12422 *
12423 * Returns:
12424 * The bitmap chunk size
12425 ******************************************************************************/
12426static unsigned long long calculate_bitmap_chunksize(struct supertype *st,
12427 struct imsm_dev *dev)
12428{
12429 struct intel_super *super = st->sb;
12430 unsigned long long min_chunksize;
12431 unsigned long long result = IMSM_DEFAULT_BITMAP_CHUNKSIZE;
12432 size_t dev_size = imsm_dev_size(dev);
12433
12434 min_chunksize = calculate_bitmap_min_chunksize(
12435 IMSM_BITMAP_AREA_SIZE * super->sector_size, dev_size);
12436
12437 if (result < min_chunksize)
12438 result = min_chunksize;
12439
12440 return result;
12441}
12442
12443/*******************************************************************************
12444 * Function: init_bitmap_header
12445 * Description: Initialize the bitmap header structure
12446 * Parameters:
12447 * st : supertype information
12448 * bms : bitmap header struct to initialize
12449 * dev : device for the bitmap
12450 *
12451 * Returns:
12452 * 0 : success
12453 * -1 : fail
12454 ******************************************************************************/
12455static int init_bitmap_header(struct supertype *st, struct bitmap_super_s *bms,
12456 struct imsm_dev *dev)
12457{
12458 int vol_uuid[4];
12459
12460 if (!bms || !dev)
12461 return -1;
12462
12463 bms->magic = __cpu_to_le32(BITMAP_MAGIC);
12464 bms->version = __cpu_to_le32(BITMAP_MAJOR_HI);
12465 bms->daemon_sleep = __cpu_to_le32(IMSM_DEFAULT_BITMAP_DAEMON_SLEEP);
12466 bms->sync_size = __cpu_to_le64(IMSM_BITMAP_AREA_SIZE);
12467 bms->write_behind = __cpu_to_le32(0);
12468
12469 uuid_from_super_imsm(st, vol_uuid);
12470 memcpy(bms->uuid, vol_uuid, 16);
12471
12472 bms->chunksize = calculate_bitmap_chunksize(st, dev);
12473
12474 return 0;
12475}
12476
12477/*******************************************************************************
12478 * Function: validate_internal_bitmap_for_drive
12479 * Description: Verify if the bitmap header for a given drive.
12480 * Parameters:
12481 * st : supertype information
12482 * offset : The offset from the beginning of the drive where to look for
12483 * the bitmap header.
12484 * d : the drive info
12485 *
12486 * Returns:
12487 * 0 : success
12488 * -1 : fail
12489 ******************************************************************************/
12490static int validate_internal_bitmap_for_drive(struct supertype *st,
12491 unsigned long long offset,
12492 struct dl *d)
12493{
12494 struct intel_super *super = st->sb;
12495 int ret = -1;
12496 int vol_uuid[4];
12497 bitmap_super_t *bms;
12498 int fd;
12499
12500 if (!d)
12501 return -1;
12502
12503 void *read_buf;
12504
12505 if (posix_memalign(&read_buf, MAX_SECTOR_SIZE, IMSM_BITMAP_HEADER_SIZE))
12506 return -1;
12507
12508 fd = d->fd;
12509 if (fd < 0) {
12510 fd = open(d->devname, O_RDONLY, 0);
12511 if (fd < 0) {
12512 dprintf("cannot open the device %s\n", d->devname);
12513 goto abort;
12514 }
12515 }
12516
12517 if (lseek64(fd, offset * super->sector_size, SEEK_SET) < 0)
12518 goto abort;
12519 if (read(fd, read_buf, IMSM_BITMAP_HEADER_SIZE) !=
12520 IMSM_BITMAP_HEADER_SIZE)
12521 goto abort;
12522
12523 uuid_from_super_imsm(st, vol_uuid);
12524
12525 bms = read_buf;
12526 if ((bms->magic != __cpu_to_le32(BITMAP_MAGIC)) ||
12527 (bms->version != __cpu_to_le32(BITMAP_MAJOR_HI)) ||
12528 (!same_uuid((int *)bms->uuid, vol_uuid, st->ss->swapuuid))) {
12529 dprintf("wrong bitmap header detected\n");
12530 goto abort;
12531 }
12532
12533 ret = 0;
12534abort:
12535 if ((d->fd < 0) && (fd >= 0))
12536 close(fd);
12537 if (read_buf)
12538 free(read_buf);
12539
12540 return ret;
12541}
12542
12543/*******************************************************************************
12544 * Function: validate_internal_bitmap_imsm
12545 * Description: Verify if the bitmap header is in place and with proper data.
12546 * Parameters:
12547 * st : supertype information
12548 *
12549 * Returns:
12550 * 0 : success or device w/o RWH_BITMAP
12551 * -1 : fail
12552 ******************************************************************************/
12553static int validate_internal_bitmap_imsm(struct supertype *st)
12554{
12555 struct intel_super *super = st->sb;
12556 struct imsm_dev *dev = get_imsm_dev(super, super->current_vol);
12557 unsigned long long offset;
12558 struct dl *d;
12559
12560 if (!dev)
12561 return -1;
12562
12563 if (dev->rwh_policy != RWH_BITMAP)
12564 return 0;
12565
12566 offset = get_bitmap_header_sector(super, super->current_vol);
12567 for (d = super->disks; d; d = d->next) {
12568 if (d->index < 0 || is_failed(&d->disk))
12569 continue;
12570
12571 if (validate_internal_bitmap_for_drive(st, offset, d)) {
12572 pr_err("imsm: bitmap validation failed\n");
12573 return -1;
12574 }
12575 }
12576 return 0;
12577}
12578
12579/*******************************************************************************
12580 * Function: add_internal_bitmap_imsm
12581 * Description: Mark the volume to use the bitmap and updates the chunk size value.
12582 * Parameters:
12583 * st : supertype information
12584 * chunkp : bitmap chunk size
12585 * delay : not used for imsm
12586 * write_behind : not used for imsm
12587 * size : not used for imsm
12588 * may_change : not used for imsm
12589 * amajor : not used for imsm
12590 *
12591 * Returns:
12592 * 0 : success
12593 * -1 : fail
12594 ******************************************************************************/
12595static int add_internal_bitmap_imsm(struct supertype *st, int *chunkp,
12596 int delay, int write_behind,
12597 unsigned long long size, int may_change,
12598 int amajor)
12599{
12600 struct intel_super *super = st->sb;
12601 int vol_idx = super->current_vol;
12602 struct imsm_dev *dev;
12603
12604 if (!super->devlist || vol_idx == -1 || !chunkp)
12605 return -1;
12606
12607 dev = get_imsm_dev(super, vol_idx);
12608
12609 if (!dev) {
12610 dprintf("cannot find the device for volume index %d\n",
12611 vol_idx);
12612 return -1;
12613 }
12614 dev->rwh_policy = RWH_BITMAP;
12615
12616 *chunkp = calculate_bitmap_chunksize(st, dev);
12617
12618 return 0;
12619}
12620
12621/*******************************************************************************
12622 * Function: locate_bitmap_imsm
12623 * Description: Seek 'fd' to start of write-intent-bitmap.
12624 * Parameters:
12625 * st : supertype information
12626 * fd : file descriptor for the device
12627 * node_num : not used for imsm
12628 *
12629 * Returns:
12630 * 0 : success
12631 * -1 : fail
12632 ******************************************************************************/
12633static int locate_bitmap_imsm(struct supertype *st, int fd, int node_num)
12634{
12635 struct intel_super *super = st->sb;
12636 unsigned long long offset;
12637 int vol_idx = super->current_vol;
12638
12639 if (!super->devlist || vol_idx == -1)
12640 return -1;
12641
12642 offset = get_bitmap_header_sector(super, super->current_vol);
12643 dprintf("bitmap header offset is %llu\n", offset);
12644
12645 lseek64(fd, offset << 9, 0);
12646
12647 return 0;
12648}
12649
12650/*******************************************************************************
12651 * Function: write_init_bitmap_imsm
12652 * Description: Write a bitmap header and prepares the area for the bitmap.
12653 * Parameters:
12654 * st : supertype information
12655 * fd : file descriptor for the device
12656 * update : not used for imsm
12657 *
12658 * Returns:
12659 * 0 : success
12660 * -1 : fail
12661 ******************************************************************************/
12662static int write_init_bitmap_imsm(struct supertype *st, int fd,
12663 enum bitmap_update update)
12664{
12665 struct intel_super *super = st->sb;
12666 int vol_idx = super->current_vol;
12667 int ret = 0;
12668 unsigned long long offset;
12669 bitmap_super_t bms = { 0 };
12670 size_t written = 0;
12671 size_t to_write;
12672 ssize_t rv_num;
12673 void *buf;
12674
12675 if (!super->devlist || !super->sector_size || vol_idx == -1)
12676 return -1;
12677
12678 struct imsm_dev *dev = get_imsm_dev(super, vol_idx);
12679
12680 /* first clear the space for bitmap header */
12681 unsigned long long bitmap_area_start =
12682 get_bitmap_header_sector(super, vol_idx);
12683
12684 dprintf("zeroing area start (%llu) and size (%u)\n", bitmap_area_start,
12685 IMSM_BITMAP_AND_HEADER_SIZE / super->sector_size);
12686 if (zero_disk_range(fd, bitmap_area_start,
12687 IMSM_BITMAP_HEADER_SIZE / super->sector_size)) {
12688 pr_err("imsm: cannot zeroing the space for the bitmap\n");
12689 return -1;
12690 }
12691
12692 /* The bitmap area should be filled with "1"s to perform initial
12693 * synchronization.
12694 */
12695 if (posix_memalign(&buf, MAX_SECTOR_SIZE, MAX_SECTOR_SIZE))
12696 return -1;
12697 memset(buf, 0xFF, MAX_SECTOR_SIZE);
12698 offset = get_bitmap_sector(super, vol_idx);
12699 lseek64(fd, offset << 9, 0);
12700 while (written < IMSM_BITMAP_AREA_SIZE) {
12701 to_write = IMSM_BITMAP_AREA_SIZE - written;
12702 if (to_write > MAX_SECTOR_SIZE)
12703 to_write = MAX_SECTOR_SIZE;
12704 rv_num = write(fd, buf, MAX_SECTOR_SIZE);
12705 if (rv_num != MAX_SECTOR_SIZE) {
12706 ret = -1;
12707 dprintf("cannot initialize bitmap area\n");
12708 goto abort;
12709 }
12710 written += rv_num;
12711 }
12712
12713 /* write a bitmap header */
12714 init_bitmap_header(st, &bms, dev);
12715 memset(buf, 0, MAX_SECTOR_SIZE);
12716 memcpy(buf, &bms, sizeof(bitmap_super_t));
12717 if (locate_bitmap_imsm(st, fd, 0)) {
12718 ret = -1;
12719 dprintf("cannot locate the bitmap\n");
12720 goto abort;
12721 }
12722 if (write(fd, buf, MAX_SECTOR_SIZE) != MAX_SECTOR_SIZE) {
12723 ret = -1;
12724 dprintf("cannot write the bitmap header\n");
12725 goto abort;
12726 }
12727 fsync(fd);
12728
12729abort:
12730 free(buf);
12731
12732 return ret;
12733}
12734
12735/*******************************************************************************
12736 * Function: is_vol_to_setup_bitmap
12737 * Description: Checks if a bitmap should be activated on the dev.
12738 * Parameters:
12739 * info : info about the volume to setup the bitmap
12740 * dev : the device to check against bitmap creation
12741 *
12742 * Returns:
12743 * 0 : bitmap should be set up on the device
12744 * -1 : otherwise
12745 ******************************************************************************/
12746static int is_vol_to_setup_bitmap(struct mdinfo *info, struct imsm_dev *dev)
12747{
12748 if (!dev || !info)
12749 return -1;
12750
12751 if ((strcmp((char *)dev->volume, info->name) == 0) &&
12752 (dev->rwh_policy == RWH_BITMAP))
12753 return -1;
12754
12755 return 0;
12756}
12757
12758/*******************************************************************************
12759 * Function: set_bitmap_sysfs
12760 * Description: Set the sysfs atributes of a given volume to activate the bitmap.
12761 * Parameters:
12762 * info : info about the volume where the bitmap should be setup
12763 * chunksize : bitmap chunk size
12764 * location : location of the bitmap
12765 *
12766 * Returns:
12767 * 0 : success
12768 * -1 : fail
12769 ******************************************************************************/
12770static int set_bitmap_sysfs(struct mdinfo *info, unsigned long long chunksize,
12771 char *location)
12772{
12773 /* The bitmap/metadata is set to external to allow changing of value for
12774 * bitmap/location. When external is used, the kernel will treat an offset
12775 * related to the device's first lba (in opposition to the "internal" case
12776 * when this value is related to the beginning of the superblock).
12777 */
12778 if (sysfs_set_str(info, NULL, "bitmap/metadata", "external")) {
12779 dprintf("failed to set bitmap/metadata\n");
12780 return -1;
12781 }
12782
12783 /* It can only be changed when no bitmap is active.
12784 * Should be bigger than 512 and must be power of 2.
12785 * It is expecting the value in bytes.
12786 */
12787 if (sysfs_set_num(info, NULL, "bitmap/chunksize",
12788 __cpu_to_le32(chunksize))) {
12789 dprintf("failed to set bitmap/chunksize\n");
12790 return -1;
12791 }
12792
12793 /* It is expecting the value in sectors. */
12794 if (sysfs_set_num(info, NULL, "bitmap/space",
12795 __cpu_to_le64(IMSM_BITMAP_AREA_SIZE))) {
12796 dprintf("failed to set bitmap/space\n");
12797 return -1;
12798 }
12799
12800 /* Determines the delay between the bitmap updates.
12801 * It is expecting the value in seconds.
12802 */
12803 if (sysfs_set_num(info, NULL, "bitmap/time_base",
12804 __cpu_to_le64(IMSM_DEFAULT_BITMAP_DAEMON_SLEEP))) {
12805 dprintf("failed to set bitmap/time_base\n");
12806 return -1;
12807 }
12808
12809 /* It is expecting the value in sectors with a sign at the beginning. */
12810 if (sysfs_set_str(info, NULL, "bitmap/location", location)) {
12811 dprintf("failed to set bitmap/location\n");
12812 return -1;
12813 }
12814
12815 return 0;
12816}
12817
12818/*******************************************************************************
12819 * Function: set_bitmap_imsm
12820 * Description: Setup the bitmap for the given volume
12821 * Parameters:
12822 * st : supertype information
12823 * info : info about the volume where the bitmap should be setup
12824 *
12825 * Returns:
12826 * 0 : success
12827 * -1 : fail
12828 ******************************************************************************/
12829static int set_bitmap_imsm(struct supertype *st, struct mdinfo *info)
12830{
12831 struct intel_super *super = st->sb;
12832 int prev_current_vol = super->current_vol;
12833 struct imsm_dev *dev;
12834 int ret = -1;
12835 char location[16] = "";
12836 unsigned long long chunksize;
12837 struct intel_dev *dev_it;
12838
12839 for (dev_it = super->devlist; dev_it; dev_it = dev_it->next) {
12840 super->current_vol = dev_it->index;
12841 dev = get_imsm_dev(super, super->current_vol);
12842
12843 if (is_vol_to_setup_bitmap(info, dev)) {
12844 if (validate_internal_bitmap_imsm(st)) {
12845 dprintf("bitmap header validation failed\n");
12846 goto abort;
12847 }
12848
12849 chunksize = calculate_bitmap_chunksize(st, dev);
12850 dprintf("chunk size is %llu\n", chunksize);
12851
12852 snprintf(location, sizeof(location), "+%llu",
12853 get_bitmap_sector(super, super->current_vol));
12854 dprintf("bitmap offset is %s\n", location);
12855
12856 if (set_bitmap_sysfs(info, chunksize, location)) {
12857 dprintf("cannot setup the bitmap\n");
12858 goto abort;
12859 }
12860 }
12861 }
12862 ret = 0;
12863abort:
12864 super->current_vol = prev_current_vol;
12865 return ret;
12866}
12867
cdddbdbc 12868struct superswitch super_imsm = {
cdddbdbc
DW		 12869 .examine_super = examine_super_imsm,
12870 .brief_examine_super = brief_examine_super_imsm,
4737ae25 12871 .brief_examine_subarrays = brief_examine_subarrays_imsm,
9d84c8ea 12872 .export_examine_super = export_examine_super_imsm,
cdddbdbc
DW		 12873 .detail_super = detail_super_imsm,
12874 .brief_detail_super = brief_detail_super_imsm,
bf5a934a 12875 .write_init_super = write_init_super_imsm,
0e600426
N		 12876 .validate_geometry = validate_geometry_imsm,
12877 .add_to_super = add_to_super_imsm,
1a64be56 12878 .remove_from_super = remove_from_super_imsm,
d665cc31 12879 .detail_platform = detail_platform_imsm,
e50cf220 12880 .export_detail_platform = export_detail_platform_imsm,
33414a01 12881 .kill_subarray = kill_subarray_imsm,
aa534678 12882 .update_subarray = update_subarray_imsm,
2b959fbf 12883 .load_container = load_container_imsm,
71204a50
N		 12884 .default_geometry = default_geometry_imsm,
12885 .get_disk_controller_domain = imsm_get_disk_controller_domain,
12886 .reshape_super = imsm_reshape_super,
12887 .manage_reshape = imsm_manage_reshape,
9e2d750d 12888 .recover_backup = recover_backup_imsm,
27156a57 12889 .examine_badblocks = examine_badblocks_imsm,
cdddbdbc
DW		 12890 .match_home = match_home_imsm,
12891 .uuid_from_super= uuid_from_super_imsm,
12892 .getinfo_super = getinfo_super_imsm,
5c4cd5da 12893 .getinfo_super_disks = getinfo_super_disks_imsm,
cdddbdbc
DW		 12894 .update_super = update_super_imsm,
12895
12896 .avail_size = avail_size_imsm,
fbfdcb06 12897 .get_spare_criteria = get_spare_criteria_imsm,
cdddbdbc
DW		 12898
12899 .compare_super = compare_super_imsm,
12900
12901 .load_super = load_super_imsm,
bf5a934a 12902 .init_super = init_super_imsm,
e683ca88 12903 .store_super = store_super_imsm,
cdddbdbc
DW		 12904 .free_super = free_super_imsm,
12905 .match_metadata_desc = match_metadata_desc_imsm,
bf5a934a 12906 .container_content = container_content_imsm,
0c21b485 12907 .validate_container = validate_container_imsm,
cdddbdbc 12908
fbc42556
JR		 12909 .add_internal_bitmap = add_internal_bitmap_imsm,
12910 .locate_bitmap = locate_bitmap_imsm,
12911 .write_bitmap = write_init_bitmap_imsm,
12912 .set_bitmap = set_bitmap_imsm,
12913
2432ce9b
AP		 12914 .write_init_ppl = write_init_ppl_imsm,
12915 .validate_ppl = validate_ppl_imsm,
12916
cdddbdbc 12917 .external = 1,
4cce4069 12918 .name = "imsm",
845dea95
NB		 12919
12920/* for mdmon */
12921 .open_new = imsm_open_new,
ed9d66aa 12922 .set_array_state= imsm_set_array_state,
845dea95
NB		 12923 .set_disk = imsm_set_disk,
12924 .sync_metadata = imsm_sync_metadata,
88758e9d 12925 .activate_spare = imsm_activate_spare,
e8319a19 12926 .process_update = imsm_process_update,
8273f55e 12927 .prepare_update = imsm_prepare_update,
6f50473f 12928 .record_bad_block = imsm_record_badblock,
c07a5a4f 12929 .clear_bad_block = imsm_clear_badblock,
928f1424 12930 .get_bad_blocks = imsm_get_badblocks,
cdddbdbc 12931};
Unnamed repository; edit this file 'description' to name the repository.