]> git.ipfire.org Git - thirdparty/mdadm.git/blame - super-ddf.c
projects / thirdparty / mdadm.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge commit '956a13fb850321bed8568dfa8692c0c323538d7c'
[thirdparty/mdadm.git] / super-ddf.c
CommitLineData
a322f70c
DW		 1/*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
e736b623 4 * Copyright (C) 2006-2009 Neil Brown <neilb@suse.de>
a322f70c
DW		 5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * Author: Neil Brown
22 * Email: <neil@brown.name>
23 *
24 * Specifications for DDF takes from Common RAID DDF Specification Revision 1.2
25 * (July 28 2006). Reused by permission of SNIA.
26 */
27
28#define HAVE_STDINT_H 1
29#include "mdadm.h"
549e9569 30#include "mdmon.h"
a322f70c
DW		 31#include "sha1.h"
32#include <values.h>
33
a322f70c
DW		 34/* a non-official T10 name for creation GUIDs */
35static char T10[] = "Linux-MD";
36
37/* DDF timestamps are 1980 based, so we need to add
38 * second-in-decade-of-seventies to convert to linux timestamps.
39 * 10 years with 2 leap years.
40 */
41#define DECADE (3600*24*(365*10+2))
42unsigned long crc32(
43 unsigned long crc,
44 const unsigned char *buf,
45 unsigned len);
46
bedbf68a 47#define DDF_NOTFOUND (~0U)
48#define DDF_CONTAINER (DDF_NOTFOUND-1)
49
a322f70c
DW		 50/* The DDF metadata handling.
51 * DDF metadata lives at the end of the device.
52 * The last 512 byte block provides an 'anchor' which is used to locate
53 * the rest of the metadata which usually lives immediately behind the anchor.
54 *
55 * Note:
56 * - all multibyte numeric fields are bigendian.
57 * - all strings are space padded.
58 *
59 */
60
61/* Primary Raid Level (PRL) */
62#define DDF_RAID0 0x00
63#define DDF_RAID1 0x01
64#define DDF_RAID3 0x03
65#define DDF_RAID4 0x04
66#define DDF_RAID5 0x05
67#define DDF_RAID1E 0x11
68#define DDF_JBOD 0x0f
69#define DDF_CONCAT 0x1f
70#define DDF_RAID5E 0x15
71#define DDF_RAID5EE 0x25
59e36268 72#define DDF_RAID6 0x06
a322f70c
DW		 73
74/* Raid Level Qualifier (RLQ) */
75#define DDF_RAID0_SIMPLE 0x00
76#define DDF_RAID1_SIMPLE 0x00 /* just 2 devices in this plex */
77#define DDF_RAID1_MULTI 0x01 /* exactly 3 devices in this plex */
78#define DDF_RAID3_0 0x00 /* parity in first extent */
79#define DDF_RAID3_N 0x01 /* parity in last extent */
80#define DDF_RAID4_0 0x00 /* parity in first extent */
81#define DDF_RAID4_N 0x01 /* parity in last extent */
82/* these apply to raid5e and raid5ee as well */
83#define DDF_RAID5_0_RESTART 0x00 /* same as 'right asymmetric' - layout 1 */
59e36268 84#define DDF_RAID6_0_RESTART 0x01 /* raid6 different from raid5 here!!! */
a322f70c
DW		 85#define DDF_RAID5_N_RESTART 0x02 /* same as 'left asymmetric' - layout 0 */
86#define DDF_RAID5_N_CONTINUE 0x03 /* same as 'left symmetric' - layout 2 */
87
88#define DDF_RAID1E_ADJACENT 0x00 /* raid10 nearcopies==2 */
89#define DDF_RAID1E_OFFSET 0x01 /* raid10 offsetcopies==2 */
90
91/* Secondary RAID Level (SRL) */
92#define DDF_2STRIPED 0x00 /* This is weirder than RAID0 !! */
93#define DDF_2MIRRORED 0x01
94#define DDF_2CONCAT 0x02
95#define DDF_2SPANNED 0x03 /* This is also weird - be careful */
96
97/* Magic numbers */
98#define DDF_HEADER_MAGIC __cpu_to_be32(0xDE11DE11)
99#define DDF_CONTROLLER_MAGIC __cpu_to_be32(0xAD111111)
100#define DDF_PHYS_RECORDS_MAGIC __cpu_to_be32(0x22222222)
101#define DDF_PHYS_DATA_MAGIC __cpu_to_be32(0x33333333)
102#define DDF_VIRT_RECORDS_MAGIC __cpu_to_be32(0xDDDDDDDD)
103#define DDF_VD_CONF_MAGIC __cpu_to_be32(0xEEEEEEEE)
104#define DDF_SPARE_ASSIGN_MAGIC __cpu_to_be32(0x55555555)
105#define DDF_VU_CONF_MAGIC __cpu_to_be32(0x88888888)
106#define DDF_VENDOR_LOG_MAGIC __cpu_to_be32(0x01dBEEF0)
107#define DDF_BBM_LOG_MAGIC __cpu_to_be32(0xABADB10C)
108
109#define DDF_GUID_LEN 24
59e36268
NB		 110#define DDF_REVISION_0 "01.00.00"
111#define DDF_REVISION_2 "01.02.00"
a322f70c
DW		 112
113struct ddf_header {
88c164f4 114 __u32 magic; /* DDF_HEADER_MAGIC */
a322f70c
DW		 115 __u32 crc;
116 char guid[DDF_GUID_LEN];
59e36268 117 char revision[8]; /* 01.02.00 */
a322f70c
DW		 118 __u32 seq; /* starts at '1' */
119 __u32 timestamp;
120 __u8 openflag;
121 __u8 foreignflag;
122 __u8 enforcegroups;
123 __u8 pad0; /* 0xff */
124 __u8 pad1[12]; /* 12 * 0xff */
125 /* 64 bytes so far */
126 __u8 header_ext[32]; /* reserved: fill with 0xff */
127 __u64 primary_lba;
128 __u64 secondary_lba;
129 __u8 type;
130 __u8 pad2[3]; /* 0xff */
131 __u32 workspace_len; /* sectors for vendor space -
132 * at least 32768(sectors) */
133 __u64 workspace_lba;
134 __u16 max_pd_entries; /* one of 15, 63, 255, 1023, 4095 */
135 __u16 max_vd_entries; /* 2^(4,6,8,10,12)-1 : i.e. as above */
136 __u16 max_partitions; /* i.e. max num of configuration
137 record entries per disk */
138 __u16 config_record_len; /* 1 +ROUNDUP(max_primary_element_entries
139 *12/512) */
140 __u16 max_primary_element_entries; /* 16, 64, 256, 1024, or 4096 */
141 __u8 pad3[54]; /* 0xff */
142 /* 192 bytes so far */
143 __u32 controller_section_offset;
144 __u32 controller_section_length;
145 __u32 phys_section_offset;
146 __u32 phys_section_length;
147 __u32 virt_section_offset;
148 __u32 virt_section_length;
149 __u32 config_section_offset;
150 __u32 config_section_length;
151 __u32 data_section_offset;
152 __u32 data_section_length;
153 __u32 bbm_section_offset;
154 __u32 bbm_section_length;
155 __u32 diag_space_offset;
156 __u32 diag_space_length;
157 __u32 vendor_offset;
158 __u32 vendor_length;
159 /* 256 bytes so far */
160 __u8 pad4[256]; /* 0xff */
161};
162
163/* type field */
164#define DDF_HEADER_ANCHOR 0x00
165#define DDF_HEADER_PRIMARY 0x01
166#define DDF_HEADER_SECONDARY 0x02
167
168/* The content of the 'controller section' - global scope */
169struct ddf_controller_data {
88c164f4 170 __u32 magic; /* DDF_CONTROLLER_MAGIC */
a322f70c
DW		 171 __u32 crc;
172 char guid[DDF_GUID_LEN];
173 struct controller_type {
174 __u16 vendor_id;
175 __u16 device_id;
176 __u16 sub_vendor_id;
177 __u16 sub_device_id;
178 } type;
179 char product_id[16];
180 __u8 pad[8]; /* 0xff */
181 __u8 vendor_data[448];
182};
183
184/* The content of phys_section - global scope */
185struct phys_disk {
88c164f4 186 __u32 magic; /* DDF_PHYS_RECORDS_MAGIC */
a322f70c
DW		 187 __u32 crc;
188 __u16 used_pdes;
189 __u16 max_pdes;
190 __u8 pad[52];
191 struct phys_disk_entry {
192 char guid[DDF_GUID_LEN];
193 __u32 refnum;
194 __u16 type;
195 __u16 state;
196 __u64 config_size; /* DDF structures must be after here */
197 char path[18]; /* another horrible structure really */
198 __u8 pad[6];
199 } entries[0];
200};
201
202/* phys_disk_entry.type is a bitmap - bigendian remember */
203#define DDF_Forced_PD_GUID 1
204#define DDF_Active_in_VD 2
88c164f4 205#define DDF_Global_Spare 4 /* VD_CONF records are ignored */
a322f70c
DW		 206#define DDF_Spare 8 /* overrides Global_spare */
207#define DDF_Foreign 16
208#define DDF_Legacy 32 /* no DDF on this device */
209
210#define DDF_Interface_mask 0xf00
211#define DDF_Interface_SCSI 0x100
212#define DDF_Interface_SAS 0x200
213#define DDF_Interface_SATA 0x300
214#define DDF_Interface_FC 0x400
215
216/* phys_disk_entry.state is a bigendian bitmap */
217#define DDF_Online 1
218#define DDF_Failed 2 /* overrides 1,4,8 */
219#define DDF_Rebuilding 4
220#define DDF_Transition 8
221#define DDF_SMART 16
222#define DDF_ReadErrors 32
223#define DDF_Missing 64
224
225/* The content of the virt_section global scope */
226struct virtual_disk {
88c164f4 227 __u32 magic; /* DDF_VIRT_RECORDS_MAGIC */
a322f70c
DW		 228 __u32 crc;
229 __u16 populated_vdes;
230 __u16 max_vdes;
231 __u8 pad[52];
232 struct virtual_entry {
233 char guid[DDF_GUID_LEN];
234 __u16 unit;
235 __u16 pad0; /* 0xffff */
236 __u16 guid_crc;
237 __u16 type;
238 __u8 state;
239 __u8 init_state;
240 __u8 pad1[14];
241 char name[16];
242 } entries[0];
243};
244
245/* virtual_entry.type is a bitmap - bigendian */
246#define DDF_Shared 1
247#define DDF_Enforce_Groups 2
248#define DDF_Unicode 4
249#define DDF_Owner_Valid 8
250
251/* virtual_entry.state is a bigendian bitmap */
252#define DDF_state_mask 0x7
253#define DDF_state_optimal 0x0
254#define DDF_state_degraded 0x1
255#define DDF_state_deleted 0x2
256#define DDF_state_missing 0x3
257#define DDF_state_failed 0x4
7a7cc504 258#define DDF_state_part_optimal 0x5
a322f70c
DW		 259
260#define DDF_state_morphing 0x8
261#define DDF_state_inconsistent 0x10
262
263/* virtual_entry.init_state is a bigendian bitmap */
264#define DDF_initstate_mask 0x03
265#define DDF_init_not 0x00
7a7cc504
NB		 266#define DDF_init_quick 0x01 /* initialisation is progress.
267 * i.e. 'state_inconsistent' */
a322f70c
DW		 268#define DDF_init_full 0x02
269
270#define DDF_access_mask 0xc0
271#define DDF_access_rw 0x00
272#define DDF_access_ro 0x80
273#define DDF_access_blocked 0xc0
274
275/* The content of the config_section - local scope
276 * It has multiple records each config_record_len sectors
277 * They can be vd_config or spare_assign
278 */
279
280struct vd_config {
88c164f4 281 __u32 magic; /* DDF_VD_CONF_MAGIC */
a322f70c
DW		 282 __u32 crc;
283 char guid[DDF_GUID_LEN];
284 __u32 timestamp;
285 __u32 seqnum;
286 __u8 pad0[24];
287 __u16 prim_elmnt_count;
288 __u8 chunk_shift; /* 0 == 512, 1==1024 etc */
289 __u8 prl;
290 __u8 rlq;
291 __u8 sec_elmnt_count;
292 __u8 sec_elmnt_seq;
293 __u8 srl;
598f0d58
NB		 294 __u64 blocks; /* blocks per component could be different
295 * on different component devices...(only
296 * for concat I hope) */
297 __u64 array_blocks; /* blocks in array */
a322f70c
DW		 298 __u8 pad1[8];
299 __u32 spare_refs[8];
300 __u8 cache_pol[8];
301 __u8 bg_rate;
302 __u8 pad2[3];
303 __u8 pad3[52];
304 __u8 pad4[192];
305 __u8 v0[32]; /* reserved- 0xff */
306 __u8 v1[32]; /* reserved- 0xff */
307 __u8 v2[16]; /* reserved- 0xff */
308 __u8 v3[16]; /* reserved- 0xff */
309 __u8 vendor[32];
310 __u32 phys_refnum[0]; /* refnum of each disk in sequence */
311 /*__u64 lba_offset[0]; LBA offset in each phys. Note extents in a
312 bvd are always the same size */
313};
57a66662 314#define LBA_OFFSET(ddf, vd) ((__u64 *) &(vd)->phys_refnum[(ddf)->mppe])
a322f70c
DW		 315
316/* vd_config.cache_pol[7] is a bitmap */
317#define DDF_cache_writeback 1 /* else writethrough */
318#define DDF_cache_wadaptive 2 /* only applies if writeback */
319#define DDF_cache_readahead 4
320#define DDF_cache_radaptive 8 /* only if doing read-ahead */
321#define DDF_cache_ifnobatt 16 /* even to write cache if battery is poor */
322#define DDF_cache_wallowed 32 /* enable write caching */
323#define DDF_cache_rallowed 64 /* enable read caching */
324
325struct spare_assign {
88c164f4 326 __u32 magic; /* DDF_SPARE_ASSIGN_MAGIC */
a322f70c
DW		 327 __u32 crc;
328 __u32 timestamp;
329 __u8 reserved[7];
330 __u8 type;
331 __u16 populated; /* SAEs used */
332 __u16 max; /* max SAEs */
333 __u8 pad[8];
334 struct spare_assign_entry {
335 char guid[DDF_GUID_LEN];
336 __u16 secondary_element;
337 __u8 pad[6];
338 } spare_ents[0];
339};
340/* spare_assign.type is a bitmap */
341#define DDF_spare_dedicated 0x1 /* else global */
342#define DDF_spare_revertible 0x2 /* else committable */
343#define DDF_spare_active 0x4 /* else not active */
344#define DDF_spare_affinity 0x8 /* enclosure affinity */
345
346/* The data_section contents - local scope */
347struct disk_data {
88c164f4 348 __u32 magic; /* DDF_PHYS_DATA_MAGIC */
a322f70c
DW		 349 __u32 crc;
350 char guid[DDF_GUID_LEN];
351 __u32 refnum; /* crc of some magic drive data ... */
352 __u8 forced_ref; /* set when above was not result of magic */
353 __u8 forced_guid; /* set if guid was forced rather than magic */
354 __u8 vendor[32];
355 __u8 pad[442];
356};
357
358/* bbm_section content */
359struct bad_block_log {
360 __u32 magic;
361 __u32 crc;
362 __u16 entry_count;
363 __u32 spare_count;
364 __u8 pad[10];
365 __u64 first_spare;
366 struct mapped_block {
367 __u64 defective_start;
368 __u32 replacement_start;
369 __u16 remap_count;
370 __u8 pad[2];
371 } entries[0];
372};
373
374/* Struct for internally holding ddf structures */
375/* The DDF structure stored on each device is potentially
376 * quite different, as some data is global and some is local.
377 * The global data is:
378 * - ddf header
379 * - controller_data
380 * - Physical disk records
381 * - Virtual disk records
382 * The local data is:
383 * - Configuration records
384 * - Physical Disk data section
385 * ( and Bad block and vendor which I don't care about yet).
386 *
387 * The local data is parsed into separate lists as it is read
388 * and reconstructed for writing. This means that we only need
389 * to make config changes once and they are automatically
390 * propagated to all devices.
391 * Note that the ddf_super has space of the conf and disk data
392 * for this disk and also for a list of all such data.
393 * The list is only used for the superblock that is being
394 * built in Create or Assemble to describe the whole array.
395 */
396struct ddf_super {
6416d527 397 struct ddf_header anchor, primary, secondary;
a322f70c 398 struct ddf_controller_data controller;
6416d527 399 struct ddf_header *active;
a322f70c
DW		 400 struct phys_disk *phys;
401 struct virtual_disk *virt;
402 int pdsize, vdsize;
f21e18ca 403 unsigned int max_part, mppe, conf_rec_len;
d2ca6449 404 int currentdev;
18a2f463 405 int updates_pending;
a322f70c 406 struct vcl {
6416d527
NB		 407 union {
408 char space[512];
409 struct {
410 struct vcl *next;
f21e18ca 411 unsigned int vcnum; /* index into ->virt */
8ec5d685 412 struct vd_config **other_bvds;
6416d527
NB		 413 __u64 *block_sizes; /* NULL if all the same */
414 };
415 };
a322f70c 416 struct vd_config conf;
d2ca6449 417 } *conflist, *currentconf;
a322f70c 418 struct dl {
6416d527
NB		 419 union {
420 char space[512];
421 struct {
422 struct dl *next;
423 int major, minor;
424 char *devname;
425 int fd;
426 unsigned long long size; /* sectors */
097bcf00 427 unsigned long long primary_lba; /* sectors */
428 unsigned long long secondary_lba; /* sectors */
429 unsigned long long workspace_lba; /* sectors */
6416d527
NB		 430 int pdnum; /* index in ->phys */
431 struct spare_assign *spare;
8592f29d
N		 432 void *mdupdate; /* hold metadata update */
433
434 /* These fields used by auto-layout */
435 int raiddisk; /* slot to fill in autolayout */
436 __u64 esize;
6416d527
NB		 437 };
438 };
a322f70c 439 struct disk_data disk;
b2280677 440 struct vcl *vlist[0]; /* max_part in size */
2cc2983d 441 } *dlist, *add_list;
a322f70c
DW		 442};
443
444#ifndef offsetof
445#define offsetof(t,f) ((size_t)&(((t*)0)->f))
446#endif
447
7d5a7ff3 448#if DEBUG
fb9d0acb 449static int all_ff(const char *guid);
7d5a7ff3 450static void pr_state(struct ddf_super *ddf, const char *msg)
451{
452 unsigned int i;
453 dprintf("%s/%s: ", __func__, msg);
454 for (i = 0; i < __be16_to_cpu(ddf->active->max_vd_entries); i++) {
455 if (all_ff(ddf->virt->entries[i].guid))
456 continue;
457 dprintf("%u(s=%02x i=%02x) ", i,
458 ddf->virt->entries[i].state,
459 ddf->virt->entries[i].init_state);
460 }
461 dprintf("\n");
462}
463#else
464static void pr_state(const struct ddf_super *ddf, const char *msg) {}
465#endif
466
467#define ddf_set_updates_pending(x) \
468 do { (x)->updates_pending = 1; pr_state(x, __func__); } while (0)
469
fcc22180 470static unsigned int get_pd_index_from_refnum(const struct vcl *vc,
471 __u32 refnum, unsigned int nmax,
472 const struct vd_config **bvd,
473 unsigned int *idx);
474
f21e18ca 475static unsigned int calc_crc(void *buf, int len)
a322f70c
DW		 476{
477 /* crcs are always at the same place as in the ddf_header */
478 struct ddf_header *ddf = buf;
479 __u32 oldcrc = ddf->crc;
480 __u32 newcrc;
481 ddf->crc = 0xffffffff;
482
483 newcrc = crc32(0, buf, len);
484 ddf->crc = oldcrc;
4abe6b70
N		 485 /* The crc is store (like everything) bigendian, so convert
486 * here for simplicity
487 */
488 return __cpu_to_be32(newcrc);
a322f70c
DW		 489}
490
a3163bf0 491#define DDF_INVALID_LEVEL 0xff
492#define DDF_NO_SECONDARY 0xff
493static int err_bad_md_layout(const mdu_array_info_t *array)
494{
495 pr_err("RAID%d layout %x with %d disks is unsupported for DDF\n",
496 array->level, array->layout, array->raid_disks);
497 return DDF_INVALID_LEVEL;
498}
499
500static int layout_md2ddf(const mdu_array_info_t *array,
501 struct vd_config *conf)
502{
503 __u16 prim_elmnt_count = __cpu_to_be16(array->raid_disks);
504 __u8 prl = DDF_INVALID_LEVEL, rlq = 0;
505 __u8 sec_elmnt_count = 1;
506 __u8 srl = DDF_NO_SECONDARY;
507
508 switch (array->level) {
509 case LEVEL_LINEAR:
510 prl = DDF_CONCAT;
511 break;
512 case 0:
513 rlq = DDF_RAID0_SIMPLE;
514 prl = DDF_RAID0;
515 break;
516 case 1:
517 switch (array->raid_disks) {
518 case 2:
519 rlq = DDF_RAID1_SIMPLE;
520 break;
521 case 3:
522 rlq = DDF_RAID1_MULTI;
523 break;
524 default:
525 return err_bad_md_layout(array);
526 }
527 prl = DDF_RAID1;
528 break;
529 case 4:
530 if (array->layout != 0)
531 return err_bad_md_layout(array);
532 rlq = DDF_RAID4_N;
533 prl = DDF_RAID4;
534 break;
535 case 5:
536 switch (array->layout) {
537 case ALGORITHM_LEFT_ASYMMETRIC:
538 rlq = DDF_RAID5_N_RESTART;
539 break;
540 case ALGORITHM_RIGHT_ASYMMETRIC:
541 rlq = DDF_RAID5_0_RESTART;
542 break;
543 case ALGORITHM_LEFT_SYMMETRIC:
544 rlq = DDF_RAID5_N_CONTINUE;
545 break;
546 case ALGORITHM_RIGHT_SYMMETRIC:
547 /* not mentioned in standard */
548 default:
549 return err_bad_md_layout(array);
550 }
551 prl = DDF_RAID5;
552 break;
553 case 6:
554 switch (array->layout) {
555 case ALGORITHM_ROTATING_N_RESTART:
556 rlq = DDF_RAID5_N_RESTART;
557 break;
558 case ALGORITHM_ROTATING_ZERO_RESTART:
559 rlq = DDF_RAID6_0_RESTART;
560 break;
561 case ALGORITHM_ROTATING_N_CONTINUE:
562 rlq = DDF_RAID5_N_CONTINUE;
563 break;
564 default:
565 return err_bad_md_layout(array);
566 }
567 prl = DDF_RAID6;
568 break;
569 case 10:
570 if (array->raid_disks % 2 == 0 && array->layout == 0x102) {
571 rlq = DDF_RAID1_SIMPLE;
572 prim_elmnt_count = __cpu_to_be16(2);
573 sec_elmnt_count = array->raid_disks / 2;
574 } else if (array->raid_disks % 3 == 0
575 && array->layout == 0x103) {
576 rlq = DDF_RAID1_MULTI;
577 prim_elmnt_count = __cpu_to_be16(3);
578 sec_elmnt_count = array->raid_disks / 3;
579 } else
580 return err_bad_md_layout(array);
581 srl = DDF_2SPANNED;
582 prl = DDF_RAID1;
583 break;
584 default:
585 return err_bad_md_layout(array);
586 }
587 conf->prl = prl;
588 conf->prim_elmnt_count = prim_elmnt_count;
589 conf->rlq = rlq;
590 conf->srl = srl;
591 conf->sec_elmnt_count = sec_elmnt_count;
592 return 0;
593}
594
8a2848a7 595static int err_bad_ddf_layout(const struct vd_config *conf)
596{
597 pr_err("DDF RAID %u qualifier %u with %u disks is unsupported\n",
598 conf->prl, conf->rlq, __be16_to_cpu(conf->prim_elmnt_count));
599 return -1;
600}
601
602static int layout_ddf2md(const struct vd_config *conf,
603 mdu_array_info_t *array)
604{
605 int level = LEVEL_UNSUPPORTED;
606 int layout = 0;
607 int raiddisks = __be16_to_cpu(conf->prim_elmnt_count);
608
609 if (conf->sec_elmnt_count > 1) {
610 /* see also check_secondary() */
611 if (conf->prl != DDF_RAID1 ||
612 (conf->srl != DDF_2STRIPED && conf->srl != DDF_2SPANNED)) {
613 pr_err("Unsupported secondary RAID level %u/%u\n",
614 conf->prl, conf->srl);
615 return -1;
616 }
617 if (raiddisks == 2 && conf->rlq == DDF_RAID1_SIMPLE)
618 layout = 0x102;
619 else if (raiddisks == 3 && conf->rlq == DDF_RAID1_MULTI)
620 layout = 0x103;
621 else
622 return err_bad_ddf_layout(conf);
623 raiddisks *= conf->sec_elmnt_count;
624 level = 10;
625 goto good;
626 }
627
628 switch (conf->prl) {
629 case DDF_CONCAT:
630 level = LEVEL_LINEAR;
631 break;
632 case DDF_RAID0:
633 if (conf->rlq != DDF_RAID0_SIMPLE)
634 return err_bad_ddf_layout(conf);
635 level = 0;
636 break;
637 case DDF_RAID1:
638 if (!((conf->rlq == DDF_RAID1_SIMPLE && raiddisks == 2) ||
639 (conf->rlq == DDF_RAID1_MULTI && raiddisks == 3)))
640 return err_bad_ddf_layout(conf);
641 level = 1;
642 break;
643 case DDF_RAID4:
644 if (conf->rlq != DDF_RAID4_N)
645 return err_bad_ddf_layout(conf);
646 level = 4;
647 break;
648 case DDF_RAID5:
649 switch (conf->rlq) {
650 case DDF_RAID5_N_RESTART:
651 layout = ALGORITHM_LEFT_ASYMMETRIC;
652 break;
653 case DDF_RAID5_0_RESTART:
654 layout = ALGORITHM_RIGHT_ASYMMETRIC;
655 break;
656 case DDF_RAID5_N_CONTINUE:
657 layout = ALGORITHM_LEFT_SYMMETRIC;
658 break;
659 default:
660 return err_bad_ddf_layout(conf);
661 }
662 level = 5;
663 break;
664 case DDF_RAID6:
665 switch (conf->rlq) {
666 case DDF_RAID5_N_RESTART:
667 layout = ALGORITHM_ROTATING_N_RESTART;
668 break;
669 case DDF_RAID6_0_RESTART:
670 layout = ALGORITHM_ROTATING_ZERO_RESTART;
671 break;
672 case DDF_RAID5_N_CONTINUE:
673 layout = ALGORITHM_ROTATING_N_CONTINUE;
674 break;
675 default:
676 return err_bad_ddf_layout(conf);
677 }
678 level = 6;
679 break;
680 default:
681 return err_bad_ddf_layout(conf);
682 };
683
684good:
685 array->level = level;
686 array->layout = layout;
687 array->raid_disks = raiddisks;
688 return 0;
689}
690
a322f70c
DW		 691static int load_ddf_header(int fd, unsigned long long lba,
692 unsigned long long size,
693 int type,
694 struct ddf_header *hdr, struct ddf_header *anchor)
695{
696 /* read a ddf header (primary or secondary) from fd/lba
697 * and check that it is consistent with anchor
698 * Need to check:
699 * magic, crc, guid, rev, and LBA's header_type, and
700 * everything after header_type must be the same
701 */
702 if (lba >= size-1)
703 return 0;
704
705 if (lseek64(fd, lba<<9, 0) < 0)
706 return 0;
707
708 if (read(fd, hdr, 512) != 512)
709 return 0;
710
711 if (hdr->magic != DDF_HEADER_MAGIC)
712 return 0;
713 if (calc_crc(hdr, 512) != hdr->crc)
714 return 0;
715 if (memcmp(anchor->guid, hdr->guid, DDF_GUID_LEN) != 0 ||
716 memcmp(anchor->revision, hdr->revision, 8) != 0 ||
717 anchor->primary_lba != hdr->primary_lba ||
718 anchor->secondary_lba != hdr->secondary_lba ||
719 hdr->type != type ||
720 memcmp(anchor->pad2, hdr->pad2, 512 -
721 offsetof(struct ddf_header, pad2)) != 0)
722 return 0;
723
724 /* Looks good enough to me... */
725 return 1;
726}
727
728static void *load_section(int fd, struct ddf_super *super, void *buf,
729 __u32 offset_be, __u32 len_be, int check)
730{
731 unsigned long long offset = __be32_to_cpu(offset_be);
732 unsigned long long len = __be32_to_cpu(len_be);
733 int dofree = (buf == NULL);
734
735 if (check)
736 if (len != 2 && len != 8 && len != 32
737 && len != 128 && len != 512)
738 return NULL;
739
740 if (len > 1024)
741 return NULL;
742 if (buf) {
743 /* All pre-allocated sections are a single block */
744 if (len != 1)
745 return NULL;
3d2c4fc7
DW		 746 } else if (posix_memalign(&buf, 512, len<<9) != 0)
747 buf = NULL;
6416d527 748
a322f70c
DW		 749 if (!buf)
750 return NULL;
751
752 if (super->active->type == 1)
753 offset += __be64_to_cpu(super->active->primary_lba);
754 else
755 offset += __be64_to_cpu(super->active->secondary_lba);
756
f21e18ca 757 if ((unsigned long long)lseek64(fd, offset<<9, 0) != (offset<<9)) {
a322f70c
DW		 758 if (dofree)
759 free(buf);
760 return NULL;
761 }
f21e18ca 762 if ((unsigned long long)read(fd, buf, len<<9) != (len<<9)) {
a322f70c
DW		 763 if (dofree)
764 free(buf);
765 return NULL;
766 }
767 return buf;
768}
769
770static int load_ddf_headers(int fd, struct ddf_super *super, char *devname)
771{
772 unsigned long long dsize;
773
774 get_dev_size(fd, NULL, &dsize);
775
776 if (lseek64(fd, dsize-512, 0) < 0) {
777 if (devname)
e7b84f9d
N		 778 pr_err("Cannot seek to anchor block on %s: %s\n",
779 devname, strerror(errno));
a322f70c
DW		 780 return 1;
781 }
782 if (read(fd, &super->anchor, 512) != 512) {
783 if (devname)
e7b84f9d
N		 784 pr_err("Cannot read anchor block on %s: %s\n",
785 devname, strerror(errno));
a322f70c
DW		 786 return 1;
787 }
788 if (super->anchor.magic != DDF_HEADER_MAGIC) {
789 if (devname)
e7b84f9d 790 pr_err("no DDF anchor found on %s\n",
a322f70c
DW		 791 devname);
792 return 2;
793 }
794 if (calc_crc(&super->anchor, 512) != super->anchor.crc) {
795 if (devname)
e7b84f9d 796 pr_err("bad CRC on anchor on %s\n",
a322f70c
DW		 797 devname);
798 return 2;
799 }
59e36268
NB		 800 if (memcmp(super->anchor.revision, DDF_REVISION_0, 8) != 0 &&
801 memcmp(super->anchor.revision, DDF_REVISION_2, 8) != 0) {
a322f70c 802 if (devname)
e7b84f9d 803 pr_err("can only support super revision"
59e36268
NB		 804 " %.8s and earlier, not %.8s on %s\n",
805 DDF_REVISION_2, super->anchor.revision,devname);
a322f70c
DW		 806 return 2;
807 }
dbeb699a 808 super->active = NULL;
a322f70c
DW		 809 if (load_ddf_header(fd, __be64_to_cpu(super->anchor.primary_lba),
810 dsize >> 9, 1,
811 &super->primary, &super->anchor) == 0) {
812 if (devname)
e7b84f9d
N		 813 pr_err("Failed to load primary DDF header "
814 "on %s\n", devname);
dbeb699a 815 } else
816 super->active = &super->primary;
a322f70c
DW		 817 if (load_ddf_header(fd, __be64_to_cpu(super->anchor.secondary_lba),
818 dsize >> 9, 2,
819 &super->secondary, &super->anchor)) {
3eff7c1d
N		 820 if (super->active == NULL
821 || (__be32_to_cpu(super->primary.seq)
822 < __be32_to_cpu(super->secondary.seq) &&
823 !super->secondary.openflag)
a322f70c
DW		 824 || (__be32_to_cpu(super->primary.seq)
825 == __be32_to_cpu(super->secondary.seq) &&
826 super->primary.openflag && !super->secondary.openflag)
827 )
828 super->active = &super->secondary;
dbeb699a 829 } else if (devname)
830 pr_err("Failed to load secondary DDF header on %s\n",
831 devname);
832 if (super->active == NULL)
833 return 2;
a322f70c
DW		 834 return 0;
835}
836
837static int load_ddf_global(int fd, struct ddf_super *super, char *devname)
838{
839 void *ok;
840 ok = load_section(fd, super, &super->controller,
841 super->active->controller_section_offset,
842 super->active->controller_section_length,
843 0);
844 super->phys = load_section(fd, super, NULL,
845 super->active->phys_section_offset,
846 super->active->phys_section_length,
847 1);
848 super->pdsize = __be32_to_cpu(super->active->phys_section_length) * 512;
849
850 super->virt = load_section(fd, super, NULL,
851 super->active->virt_section_offset,
852 super->active->virt_section_length,
853 1);
854 super->vdsize = __be32_to_cpu(super->active->virt_section_length) * 512;
855 if (!ok ||
856 !super->phys ||
857 !super->virt) {
858 free(super->phys);
859 free(super->virt);
a2349791
NB		 860 super->phys = NULL;
861 super->virt = NULL;
a322f70c
DW		 862 return 2;
863 }
864 super->conflist = NULL;
865 super->dlist = NULL;
8c3b8c2c
NB		 866
867 super->max_part = __be16_to_cpu(super->active->max_partitions);
868 super->mppe = __be16_to_cpu(super->active->max_primary_element_entries);
869 super->conf_rec_len = __be16_to_cpu(super->active->config_record_len);
a322f70c
DW		 870 return 0;
871}
872
3c48f7be 873#define DDF_UNUSED_BVD 0xff
874static int alloc_other_bvds(const struct ddf_super *ddf, struct vcl *vcl)
875{
876 unsigned int n_vds = vcl->conf.sec_elmnt_count - 1;
877 unsigned int i, vdsize;
878 void *p;
879 if (n_vds == 0) {
880 vcl->other_bvds = NULL;
881 return 0;
882 }
883 vdsize = ddf->conf_rec_len * 512;
884 if (posix_memalign(&p, 512, n_vds *
885 (vdsize + sizeof(struct vd_config *))) != 0)
886 return -1;
887 vcl->other_bvds = (struct vd_config **) (p + n_vds * vdsize);
888 for (i = 0; i < n_vds; i++) {
889 vcl->other_bvds[i] = p + i * vdsize;
890 memset(vcl->other_bvds[i], 0, vdsize);
891 vcl->other_bvds[i]->sec_elmnt_seq = DDF_UNUSED_BVD;
892 }
893 return 0;
894}
895
3dc821b0 896static void add_other_bvd(struct vcl *vcl, struct vd_config *vd,
897 unsigned int len)
898{
899 int i;
900 for (i = 0; i < vcl->conf.sec_elmnt_count-1; i++)
3c48f7be 901 if (vcl->other_bvds[i]->sec_elmnt_seq == vd->sec_elmnt_seq)
3dc821b0 902 break;
903
904 if (i < vcl->conf.sec_elmnt_count-1) {
905 if (vd->seqnum <= vcl->other_bvds[i]->seqnum)
906 return;
907 } else {
908 for (i = 0; i < vcl->conf.sec_elmnt_count-1; i++)
3c48f7be 909 if (vcl->other_bvds[i]->sec_elmnt_seq == DDF_UNUSED_BVD)
3dc821b0 910 break;
911 if (i == vcl->conf.sec_elmnt_count-1) {
912 pr_err("no space for sec level config %u, count is %u\n",
913 vd->sec_elmnt_seq, vcl->conf.sec_elmnt_count);
914 return;
915 }
3dc821b0 916 }
917 memcpy(vcl->other_bvds[i], vd, len);
918}
919
a322f70c
DW		 920static int load_ddf_local(int fd, struct ddf_super *super,
921 char *devname, int keep)
922{
923 struct dl *dl;
924 struct stat stb;
925 char *conf;
f21e18ca
N		 926 unsigned int i;
927 unsigned int confsec;
b2280677 928 int vnum;
f21e18ca 929 unsigned int max_virt_disks = __be16_to_cpu(super->active->max_vd_entries);
d2ca6449 930 unsigned long long dsize;
a322f70c
DW		 931
932 /* First the local disk info */
3d2c4fc7 933 if (posix_memalign((void**)&dl, 512,
6416d527 934 sizeof(*dl) +
3d2c4fc7 935 (super->max_part) * sizeof(dl->vlist[0])) != 0) {
e7b84f9d 936 pr_err("%s could not allocate disk info buffer\n",
3d2c4fc7
DW		 937 __func__);
938 return 1;
939 }
a322f70c
DW		 940
941 load_section(fd, super, &dl->disk,
942 super->active->data_section_offset,
943 super->active->data_section_length,
944 0);
503975b9 945 dl->devname = devname ? xstrdup(devname) : NULL;
598f0d58 946
a322f70c
DW		 947 fstat(fd, &stb);
948 dl->major = major(stb.st_rdev);
949 dl->minor = minor(stb.st_rdev);
950 dl->next = super->dlist;
951 dl->fd = keep ? fd : -1;
d2ca6449
NB		 952
953 dl->size = 0;
954 if (get_dev_size(fd, devname, &dsize))
955 dl->size = dsize >> 9;
097bcf00 956 /* If the disks have different sizes, the LBAs will differ
957 * between phys disks.
958 * At this point here, the values in super->active must be valid
959 * for this phys disk. */
960 dl->primary_lba = super->active->primary_lba;
961 dl->secondary_lba = super->active->secondary_lba;
962 dl->workspace_lba = super->active->workspace_lba;
b2280677 963 dl->spare = NULL;
f21e18ca 964 for (i = 0 ; i < super->max_part ; i++)
a322f70c
DW		 965 dl->vlist[i] = NULL;
966 super->dlist = dl;
59e36268 967 dl->pdnum = -1;
f21e18ca 968 for (i = 0; i < __be16_to_cpu(super->active->max_pd_entries); i++)
5575e7d9
NB		 969 if (memcmp(super->phys->entries[i].guid,
970 dl->disk.guid, DDF_GUID_LEN) == 0)
971 dl->pdnum = i;
972
a322f70c
DW		 973 /* Now the config list. */
974 /* 'conf' is an array of config entries, some of which are
975 * probably invalid. Those which are good need to be copied into
976 * the conflist
977 */
a322f70c
DW		 978
979 conf = load_section(fd, super, NULL,
980 super->active->config_section_offset,
981 super->active->config_section_length,
982 0);
983
b2280677 984 vnum = 0;
e223334f
N		 985 for (confsec = 0;
986 confsec < __be32_to_cpu(super->active->config_section_length);
987 confsec += super->conf_rec_len) {
a322f70c 988 struct vd_config *vd =
e223334f 989 (struct vd_config *)((char*)conf + confsec*512);
a322f70c
DW		 990 struct vcl *vcl;
991
b2280677
NB		 992 if (vd->magic == DDF_SPARE_ASSIGN_MAGIC) {
993 if (dl->spare)
994 continue;
3d2c4fc7
DW		 995 if (posix_memalign((void**)&dl->spare, 512,
996 super->conf_rec_len*512) != 0) {
e7b84f9d
N		 997 pr_err("%s could not allocate spare info buf\n",
998 __func__);
3d2c4fc7
DW		 999 return 1;
1000 }
613b0d17 1001
b2280677
NB		 1002 memcpy(dl->spare, vd, super->conf_rec_len*512);
1003 continue;
1004 }
a322f70c
DW		 1005 if (vd->magic != DDF_VD_CONF_MAGIC)
1006 continue;
1007 for (vcl = super->conflist; vcl; vcl = vcl->next) {
1008 if (memcmp(vcl->conf.guid,
1009 vd->guid, DDF_GUID_LEN) == 0)
1010 break;
1011 }
1012
1013 if (vcl) {
b2280677 1014 dl->vlist[vnum++] = vcl;
3dc821b0 1015 if (vcl->other_bvds != NULL &&
1016 vcl->conf.sec_elmnt_seq != vd->sec_elmnt_seq) {
1017 add_other_bvd(vcl, vd, super->conf_rec_len*512);
1018 continue;
1019 }
a322f70c
DW		 1020 if (__be32_to_cpu(vd->seqnum) <=
1021 __be32_to_cpu(vcl->conf.seqnum))
1022 continue;
59e36268 1023 } else {
3d2c4fc7 1024 if (posix_memalign((void**)&vcl, 512,
6416d527 1025 (super->conf_rec_len*512 +
3d2c4fc7 1026 offsetof(struct vcl, conf))) != 0) {
e7b84f9d
N		 1027 pr_err("%s could not allocate vcl buf\n",
1028 __func__);
3d2c4fc7
DW		 1029 return 1;
1030 }
a322f70c 1031 vcl->next = super->conflist;
59e36268 1032 vcl->block_sizes = NULL; /* FIXME not for CONCAT */
3c48f7be 1033 vcl->conf.sec_elmnt_count = vd->sec_elmnt_count;
1034 if (alloc_other_bvds(super, vcl) != 0) {
1035 pr_err("%s could not allocate other bvds\n",
1036 __func__);
1037 free(vcl);
1038 return 1;
1039 };
a322f70c 1040 super->conflist = vcl;
b2280677 1041 dl->vlist[vnum++] = vcl;
a322f70c 1042 }
8c3b8c2c 1043 memcpy(&vcl->conf, vd, super->conf_rec_len*512);
59e36268
NB		 1044 for (i=0; i < max_virt_disks ; i++)
1045 if (memcmp(super->virt->entries[i].guid,
1046 vcl->conf.guid, DDF_GUID_LEN)==0)
1047 break;
1048 if (i < max_virt_disks)
1049 vcl->vcnum = i;
a322f70c
DW		 1050 }
1051 free(conf);
1052
1053 return 0;
1054}
1055
1056#ifndef MDASSEMBLE
1057static int load_super_ddf_all(struct supertype *st, int fd,
e1902a7b 1058 void **sbp, char *devname);
a322f70c 1059#endif
37424f13
DW		 1060
1061static void free_super_ddf(struct supertype *st);
1062
a322f70c
DW		 1063static int load_super_ddf(struct supertype *st, int fd,
1064 char *devname)
1065{
1066 unsigned long long dsize;
1067 struct ddf_super *super;
1068 int rv;
1069
a322f70c
DW		 1070 if (get_dev_size(fd, devname, &dsize) == 0)
1071 return 1;
1072
b31df436 1073 if (!st->ignore_hw_compat && test_partition(fd))
691c6ee1
N		 1074 /* DDF is not allowed on partitions */
1075 return 1;
1076
a322f70c
DW		 1077 /* 32M is a lower bound */
1078 if (dsize <= 32*1024*1024) {
97320d7c 1079 if (devname)
e7b84f9d
N		 1080 pr_err("%s is too small for ddf: "
1081 "size is %llu sectors.\n",
1082 devname, dsize>>9);
97320d7c 1083 return 1;
a322f70c
DW		 1084 }
1085 if (dsize & 511) {
97320d7c 1086 if (devname)
e7b84f9d
N		 1087 pr_err("%s is an odd size for ddf: "
1088 "size is %llu bytes.\n",
1089 devname, dsize);
97320d7c 1090 return 1;
a322f70c
DW		 1091 }
1092
37424f13
DW		 1093 free_super_ddf(st);
1094
6416d527 1095 if (posix_memalign((void**)&super, 512, sizeof(*super))!= 0) {
e7b84f9d 1096 pr_err("malloc of %zu failed.\n",
a322f70c
DW		 1097 sizeof(*super));
1098 return 1;
1099 }
a2349791 1100 memset(super, 0, sizeof(*super));
a322f70c
DW		 1101
1102 rv = load_ddf_headers(fd, super, devname);
1103 if (rv) {
1104 free(super);
1105 return rv;
1106 }
1107
1108 /* Have valid headers and have chosen the best. Let's read in the rest*/
1109
1110 rv = load_ddf_global(fd, super, devname);
1111
1112 if (rv) {
1113 if (devname)
e7b84f9d
N		 1114 pr_err("Failed to load all information "
1115 "sections on %s\n", devname);
a322f70c
DW		 1116 free(super);
1117 return rv;
1118 }
1119
3d2c4fc7
DW		 1120 rv = load_ddf_local(fd, super, devname, 0);
1121
1122 if (rv) {
1123 if (devname)
e7b84f9d
N		 1124 pr_err("Failed to load all information "
1125 "sections on %s\n", devname);
3d2c4fc7
DW		 1126 free(super);
1127 return rv;
1128 }
a322f70c
DW		 1129
1130 /* Should possibly check the sections .... */
1131
1132 st->sb = super;
1133 if (st->ss == NULL) {
1134 st->ss = &super_ddf;
1135 st->minor_version = 0;
1136 st->max_devs = 512;
1137 }
1138 return 0;
1139
1140}
1141
1142static void free_super_ddf(struct supertype *st)
1143{
1144 struct ddf_super *ddf = st->sb;
1145 if (ddf == NULL)
1146 return;
1147 free(ddf->phys);
1148 free(ddf->virt);
1149 while (ddf->conflist) {
1150 struct vcl *v = ddf->conflist;
1151 ddf->conflist = v->next;
59e36268
NB		 1152 if (v->block_sizes)
1153 free(v->block_sizes);
3c48f7be 1154 if (v->other_bvds)
1155 /*
1156 v->other_bvds[0] points to beginning of buffer,
1157 see alloc_other_bvds()
1158 */
1159 free(v->other_bvds[0]);
a322f70c
DW		 1160 free(v);
1161 }
1162 while (ddf->dlist) {
1163 struct dl *d = ddf->dlist;
1164 ddf->dlist = d->next;
1165 if (d->fd >= 0)
1166 close(d->fd);
b2280677
NB		 1167 if (d->spare)
1168 free(d->spare);
a322f70c
DW		 1169 free(d);
1170 }
8a38cb04
N		 1171 while (ddf->add_list) {
1172 struct dl *d = ddf->add_list;
1173 ddf->add_list = d->next;
1174 if (d->fd >= 0)
1175 close(d->fd);
1176 if (d->spare)
1177 free(d->spare);
1178 free(d);
1179 }
a322f70c
DW		 1180 free(ddf);
1181 st->sb = NULL;
1182}
1183
1184static struct supertype *match_metadata_desc_ddf(char *arg)
1185{
1186 /* 'ddf' only support containers */
1187 struct supertype *st;
1188 if (strcmp(arg, "ddf") != 0 &&
1189 strcmp(arg, "default") != 0
1190 )
1191 return NULL;
1192
503975b9 1193 st = xcalloc(1, sizeof(*st));
a322f70c
DW		 1194 st->ss = &super_ddf;
1195 st->max_devs = 512;
1196 st->minor_version = 0;
1197 st->sb = NULL;
1198 return st;
1199}
1200
a322f70c
DW		 1201#ifndef MDASSEMBLE
1202
1203static mapping_t ddf_state[] = {
1204 { "Optimal", 0},
1205 { "Degraded", 1},
1206 { "Deleted", 2},
1207 { "Missing", 3},
1208 { "Failed", 4},
1209 { "Partially Optimal", 5},
1210 { "-reserved-", 6},
1211 { "-reserved-", 7},
1212 { NULL, 0}
1213};
1214
1215static mapping_t ddf_init_state[] = {
1216 { "Not Initialised", 0},
1217 { "QuickInit in Progress", 1},
1218 { "Fully Initialised", 2},
1219 { "*UNKNOWN*", 3},
1220 { NULL, 0}
1221};
1222static mapping_t ddf_access[] = {
1223 { "Read/Write", 0},
1224 { "Reserved", 1},
1225 { "Read Only", 2},
1226 { "Blocked (no access)", 3},
1227 { NULL ,0}
1228};
1229
1230static mapping_t ddf_level[] = {
1231 { "RAID0", DDF_RAID0},
1232 { "RAID1", DDF_RAID1},
1233 { "RAID3", DDF_RAID3},
1234 { "RAID4", DDF_RAID4},
1235 { "RAID5", DDF_RAID5},
1236 { "RAID1E",DDF_RAID1E},
1237 { "JBOD", DDF_JBOD},
1238 { "CONCAT",DDF_CONCAT},
1239 { "RAID5E",DDF_RAID5E},
1240 { "RAID5EE",DDF_RAID5EE},
1241 { "RAID6", DDF_RAID6},
1242 { NULL, 0}
1243};
1244static mapping_t ddf_sec_level[] = {
1245 { "Striped", DDF_2STRIPED},
1246 { "Mirrored", DDF_2MIRRORED},
1247 { "Concat", DDF_2CONCAT},
1248 { "Spanned", DDF_2SPANNED},
1249 { NULL, 0}
1250};
1251#endif
1252
fb9d0acb 1253static int all_ff(const char *guid)
42dc2744
N		 1254{
1255 int i;
1256 for (i = 0; i < DDF_GUID_LEN; i++)
1257 if (guid[i] != (char)0xff)
1258 return 0;
1259 return 1;
1260}
1261
a322f70c
DW		 1262#ifndef MDASSEMBLE
1263static void print_guid(char *guid, int tstamp)
1264{
1265 /* A GUIDs are part (or all) ASCII and part binary.
1266 * They tend to be space padded.
59e36268
NB		 1267 * We print the GUID in HEX, then in parentheses add
1268 * any initial ASCII sequence, and a possible
1269 * time stamp from bytes 16-19
a322f70c
DW		 1270 */
1271 int l = DDF_GUID_LEN;
1272 int i;
59e36268
NB		 1273
1274 for (i=0 ; i<DDF_GUID_LEN ; i++) {
1275 if ((i&3)==0 && i != 0) printf(":");
1276 printf("%02X", guid[i]&255);
1277 }
1278
cfccea8c 1279 printf("\n (");
a322f70c
DW		 1280 while (l && guid[l-1] == ' ')
1281 l--;
1282 for (i=0 ; i<l ; i++) {
1283 if (guid[i] >= 0x20 && guid[i] < 0x7f)
1284 fputc(guid[i], stdout);
1285 else
59e36268 1286 break;
a322f70c
DW		 1287 }
1288 if (tstamp) {
1289 time_t then = __be32_to_cpu(*(__u32*)(guid+16)) + DECADE;
1290 char tbuf[100];
1291 struct tm *tm;
1292 tm = localtime(&then);
59e36268 1293 strftime(tbuf, 100, " %D %T",tm);
a322f70c
DW		 1294 fputs(tbuf, stdout);
1295 }
59e36268 1296 printf(")");
a322f70c
DW		 1297}
1298
be9b9ef4 1299static const char *guid_str(const char *guid)
1300{
1301 static char buf[DDF_GUID_LEN*2+1];
1302 int i;
1303 char *p = buf;
4a03cbd1 1304 for (i = 0; i < DDF_GUID_LEN; i++) {
1305 unsigned char c = guid[i];
1306 if (c >= 32 && c < 127)
1307 p += sprintf(p, "%c", c);
1308 else
1309 p += sprintf(p, "%02x", c);
1310 }
be9b9ef4 1311 *p = '\0';
1312 return (const char *) buf;
1313}
1314
a322f70c
DW		 1315static void examine_vd(int n, struct ddf_super *sb, char *guid)
1316{
8c3b8c2c 1317 int crl = sb->conf_rec_len;
a322f70c
DW		 1318 struct vcl *vcl;
1319
1320 for (vcl = sb->conflist ; vcl ; vcl = vcl->next) {
f21e18ca 1321 unsigned int i;
a322f70c
DW		 1322 struct vd_config *vc = &vcl->conf;
1323
1324 if (calc_crc(vc, crl*512) != vc->crc)
1325 continue;
1326 if (memcmp(vc->guid, guid, DDF_GUID_LEN) != 0)
1327 continue;
1328
1329 /* Ok, we know about this VD, let's give more details */
b06e3095 1330 printf(" Raid Devices[%d] : %d (", n,
a322f70c 1331 __be16_to_cpu(vc->prim_elmnt_count));
f21e18ca 1332 for (i = 0; i < __be16_to_cpu(vc->prim_elmnt_count); i++) {
b06e3095
N		 1333 int j;
1334 int cnt = __be16_to_cpu(sb->phys->used_pdes);
1335 for (j=0; j<cnt; j++)
1336 if (vc->phys_refnum[i] == sb->phys->entries[j].refnum)
1337 break;
1338 if (i) printf(" ");
1339 if (j < cnt)
1340 printf("%d", j);
1341 else
1342 printf("--");
1343 }
1344 printf(")\n");
1345 if (vc->chunk_shift != 255)
613b0d17
N		 1346 printf(" Chunk Size[%d] : %d sectors\n", n,
1347 1 << vc->chunk_shift);
a322f70c
DW		 1348 printf(" Raid Level[%d] : %s\n", n,
1349 map_num(ddf_level, vc->prl)?:"-unknown-");
1350 if (vc->sec_elmnt_count != 1) {
1351 printf(" Secondary Position[%d] : %d of %d\n", n,
1352 vc->sec_elmnt_seq, vc->sec_elmnt_count);
1353 printf(" Secondary Level[%d] : %s\n", n,
1354 map_num(ddf_sec_level, vc->srl) ?: "-unknown-");
1355 }
1356 printf(" Device Size[%d] : %llu\n", n,
c9b6907b 1357 (unsigned long long)__be64_to_cpu(vc->blocks)/2);
a322f70c 1358 printf(" Array Size[%d] : %llu\n", n,
c9b6907b 1359 (unsigned long long)__be64_to_cpu(vc->array_blocks)/2);
a322f70c
DW		 1360 }
1361}
1362
1363static void examine_vds(struct ddf_super *sb)
1364{
1365 int cnt = __be16_to_cpu(sb->virt->populated_vdes);
fb9d0acb 1366 unsigned int i;
a322f70c
DW		 1367 printf(" Virtual Disks : %d\n", cnt);
1368
fb9d0acb 1369 for (i = 0; i < __be16_to_cpu(sb->virt->max_vdes); i++) {
a322f70c 1370 struct virtual_entry *ve = &sb->virt->entries[i];
fb9d0acb 1371 if (all_ff(ve->guid))
1372 continue;
b06e3095 1373 printf("\n");
a322f70c
DW		 1374 printf(" VD GUID[%d] : ", i); print_guid(ve->guid, 1);
1375 printf("\n");
1376 printf(" unit[%d] : %d\n", i, __be16_to_cpu(ve->unit));
1377 printf(" state[%d] : %s, %s%s\n", i,
1378 map_num(ddf_state, ve->state & 7),
1379 (ve->state & 8) ? "Morphing, ": "",
1380 (ve->state & 16)? "Not Consistent" : "Consistent");
1381 printf(" init state[%d] : %s\n", i,
1382 map_num(ddf_init_state, ve->init_state&3));
1383 printf(" access[%d] : %s\n", i,
1384 map_num(ddf_access, (ve->init_state>>6) & 3));
1385 printf(" Name[%d] : %.16s\n", i, ve->name);
1386 examine_vd(i, sb, ve->guid);
1387 }
1388 if (cnt) printf("\n");
1389}
1390
1391static void examine_pds(struct ddf_super *sb)
1392{
1393 int cnt = __be16_to_cpu(sb->phys->used_pdes);
1394 int i;
1395 struct dl *dl;
1396 printf(" Physical Disks : %d\n", cnt);
962371a5 1397 printf(" Number RefNo Size Device Type/State\n");
a322f70c
DW		 1398
1399 for (i=0 ; i<cnt ; i++) {
1400 struct phys_disk_entry *pd = &sb->phys->entries[i];
1401 int type = __be16_to_cpu(pd->type);
1402 int state = __be16_to_cpu(pd->state);
1403
b06e3095
N		 1404 //printf(" PD GUID[%d] : ", i); print_guid(pd->guid, 0);
1405 //printf("\n");
1406 printf(" %3d %08x ", i,
a322f70c 1407 __be32_to_cpu(pd->refnum));
613b0d17 1408 printf("%8lluK ",
c9b6907b 1409 (unsigned long long)__be64_to_cpu(pd->config_size)>>1);
b06e3095
N		 1410 for (dl = sb->dlist; dl ; dl = dl->next) {
1411 if (dl->disk.refnum == pd->refnum) {
1412 char *dv = map_dev(dl->major, dl->minor, 0);
1413 if (dv) {
962371a5 1414 printf("%-15s", dv);
b06e3095
N		 1415 break;
1416 }
1417 }
1418 }
1419 if (!dl)
962371a5 1420 printf("%15s","");
b06e3095 1421 printf(" %s%s%s%s%s",
a322f70c 1422 (type&2) ? "active":"",
b06e3095 1423 (type&4) ? "Global-Spare":"",
a322f70c
DW		 1424 (type&8) ? "spare" : "",
1425 (type&16)? ", foreign" : "",
1426 (type&32)? "pass-through" : "");
18cb4496
N		 1427 if (state & DDF_Failed)
1428 /* This over-rides these three */
1429 state &= ~(DDF_Online|DDF_Rebuilding|DDF_Transition);
b06e3095 1430 printf("/%s%s%s%s%s%s%s",
a322f70c
DW		 1431 (state&1)? "Online": "Offline",
1432 (state&2)? ", Failed": "",
1433 (state&4)? ", Rebuilding": "",
1434 (state&8)? ", in-transition": "",
b06e3095
N		 1435 (state&16)? ", SMART-errors": "",
1436 (state&32)? ", Unrecovered-Read-Errors": "",
a322f70c 1437 (state&64)? ", Missing" : "");
a322f70c
DW		 1438 printf("\n");
1439 }
1440}
1441
1442static void examine_super_ddf(struct supertype *st, char *homehost)
1443{
1444 struct ddf_super *sb = st->sb;
1445
1446 printf(" Magic : %08x\n", __be32_to_cpu(sb->anchor.magic));
1447 printf(" Version : %.8s\n", sb->anchor.revision);
598f0d58
NB		 1448 printf("Controller GUID : "); print_guid(sb->controller.guid, 0);
1449 printf("\n");
1450 printf(" Container GUID : "); print_guid(sb->anchor.guid, 1);
a322f70c
DW		 1451 printf("\n");
1452 printf(" Seq : %08x\n", __be32_to_cpu(sb->active->seq));
1453 printf(" Redundant hdr : %s\n", sb->secondary.magic == DDF_HEADER_MAGIC
1454 ?"yes" : "no");
1455 examine_vds(sb);
1456 examine_pds(sb);
1457}
1458
a5d85af7 1459static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *map);
ff54de6e 1460
bedbf68a 1461static void uuid_from_ddf_guid(const char *guid, int uuid[4]);
42dc2744 1462static void uuid_from_super_ddf(struct supertype *st, int uuid[4]);
ff54de6e 1463
bedbf68a 1464static unsigned int get_vd_num_of_subarray(struct supertype *st)
1465{
1466 /*
1467 * Figure out the VD number for this supertype.
1468 * Returns DDF_CONTAINER for the container itself,
1469 * and DDF_NOTFOUND on error.
1470 */
1471 struct ddf_super *ddf = st->sb;
1472 struct mdinfo *sra;
1473 char *sub, *end;
1474 unsigned int vcnum;
1475
1476 if (*st->container_devnm == '\0')
1477 return DDF_CONTAINER;
1478
1479 sra = sysfs_read(-1, st->devnm, GET_VERSION);
1480 if (!sra || sra->array.major_version != -1 ||
1481 sra->array.minor_version != -2 ||
1482 !is_subarray(sra->text_version))
1483 return DDF_NOTFOUND;
1484
1485 sub = strchr(sra->text_version + 1, '/');
1486 if (sub != NULL)
1487 vcnum = strtoul(sub + 1, &end, 10);
1488 if (sub == NULL || *sub == '\0' || *end != '\0' ||
1489 vcnum >= __be16_to_cpu(ddf->active->max_vd_entries))
1490 return DDF_NOTFOUND;
1491
1492 return vcnum;
1493}
1494
061f2c6a 1495static void brief_examine_super_ddf(struct supertype *st, int verbose)
4737ae25
N		 1496{
1497 /* We just write a generic DDF ARRAY entry
1498 */
1499 struct mdinfo info;
1500 char nbuf[64];
a5d85af7 1501 getinfo_super_ddf(st, &info, NULL);
4737ae25
N		 1502 fname_from_uuid(st, &info, nbuf, ':');
1503
1504 printf("ARRAY metadata=ddf UUID=%s\n", nbuf + 5);
1505}
1506
1507static void brief_examine_subarrays_ddf(struct supertype *st, int verbose)
a322f70c
DW		 1508{
1509 /* We just write a generic DDF ARRAY entry
a322f70c 1510 */
42dc2744 1511 struct ddf_super *ddf = st->sb;
ff54de6e 1512 struct mdinfo info;
f21e18ca 1513 unsigned int i;
ff54de6e 1514 char nbuf[64];
a5d85af7 1515 getinfo_super_ddf(st, &info, NULL);
ff54de6e 1516 fname_from_uuid(st, &info, nbuf, ':');
42dc2744 1517
f21e18ca 1518 for (i = 0; i < __be16_to_cpu(ddf->virt->max_vdes); i++) {
42dc2744
N		 1519 struct virtual_entry *ve = &ddf->virt->entries[i];
1520 struct vcl vcl;
1521 char nbuf1[64];
1522 if (all_ff(ve->guid))
1523 continue;
1524 memcpy(vcl.conf.guid, ve->guid, DDF_GUID_LEN);
1525 ddf->currentconf =&vcl;
1526 uuid_from_super_ddf(st, info.uuid);
1527 fname_from_uuid(st, &info, nbuf1, ':');
1528 printf("ARRAY container=%s member=%d UUID=%s\n",
1529 nbuf+5, i, nbuf1+5);
1530 }
a322f70c
DW		 1531}
1532
bceedeec
N		 1533static void export_examine_super_ddf(struct supertype *st)
1534{
1535 struct mdinfo info;
1536 char nbuf[64];
a5d85af7 1537 getinfo_super_ddf(st, &info, NULL);
bceedeec
N		 1538 fname_from_uuid(st, &info, nbuf, ':');
1539 printf("MD_METADATA=ddf\n");
1540 printf("MD_LEVEL=container\n");
1541 printf("MD_UUID=%s\n", nbuf+5);
1542}
bceedeec 1543
74db60b0
N		 1544static int copy_metadata_ddf(struct supertype *st, int from, int to)
1545{
1546 void *buf;
1547 unsigned long long dsize, offset;
1548 int bytes;
1549 struct ddf_header *ddf;
1550 int written = 0;
1551
1552 /* The meta consists of an anchor, a primary, and a secondary.
1553 * This all lives at the end of the device.
1554 * So it is easiest to find the earliest of primary and
1555 * secondary, and copy everything from there.
1556 *
1557 * Anchor is 512 from end It contains primary_lba and secondary_lba
1558 * we choose one of those
1559 */
1560
1561 if (posix_memalign(&buf, 4096, 4096) != 0)
1562 return 1;
1563
1564 if (!get_dev_size(from, NULL, &dsize))
1565 goto err;
1566
1567 if (lseek64(from, dsize-512, 0) < 0)
1568 goto err;
1569 if (read(from, buf, 512) != 512)
1570 goto err;
1571 ddf = buf;
1572 if (ddf->magic != DDF_HEADER_MAGIC ||
1573 calc_crc(ddf, 512) != ddf->crc ||
1574 (memcmp(ddf->revision, DDF_REVISION_0, 8) != 0 &&
1575 memcmp(ddf->revision, DDF_REVISION_2, 8) != 0))
1576 goto err;
1577
1578 offset = dsize - 512;
1579 if ((__be64_to_cpu(ddf->primary_lba) << 9) < offset)
1580 offset = __be64_to_cpu(ddf->primary_lba) << 9;
1581 if ((__be64_to_cpu(ddf->secondary_lba) << 9) < offset)
1582 offset = __be64_to_cpu(ddf->secondary_lba) << 9;
1583
1584 bytes = dsize - offset;
1585
1586 if (lseek64(from, offset, 0) < 0 ||
1587 lseek64(to, offset, 0) < 0)
1588 goto err;
1589 while (written < bytes) {
1590 int n = bytes - written;
1591 if (n > 4096)
1592 n = 4096;
1593 if (read(from, buf, n) != n)
1594 goto err;
1595 if (write(to, buf, n) != n)
1596 goto err;
1597 written += n;
1598 }
1599 free(buf);
1600 return 0;
1601err:
1602 free(buf);
1603 return 1;
1604}
1605
a322f70c
DW		 1606static void detail_super_ddf(struct supertype *st, char *homehost)
1607{
1608 /* FIXME later
1609 * Could print DDF GUID
1610 * Need to find which array
1611 * If whole, briefly list all arrays
1612 * If one, give name
1613 */
1614}
1615
1616static void brief_detail_super_ddf(struct supertype *st)
1617{
ff54de6e
N		 1618 struct mdinfo info;
1619 char nbuf[64];
bedbf68a 1620 struct ddf_super *ddf = st->sb;
1621 unsigned int vcnum = get_vd_num_of_subarray(st);
1622 if (vcnum == DDF_CONTAINER)
1623 uuid_from_super_ddf(st, info.uuid);
1624 else if (vcnum == DDF_NOTFOUND)
1625 return;
1626 else
1627 uuid_from_ddf_guid(ddf->virt->entries[vcnum].guid, info.uuid);
ff54de6e
N		 1628 fname_from_uuid(st, &info, nbuf,':');
1629 printf(" UUID=%s", nbuf + 5);
a322f70c 1630}
a322f70c
DW		 1631#endif
1632
1633static int match_home_ddf(struct supertype *st, char *homehost)
1634{
1635 /* It matches 'this' host if the controller is a
1636 * Linux-MD controller with vendor_data matching
1637 * the hostname
1638 */
1639 struct ddf_super *ddf = st->sb;
f21e18ca 1640 unsigned int len;
d1d3482b
N		 1641
1642 if (!homehost)
1643 return 0;
1644 len = strlen(homehost);
a322f70c
DW		 1645
1646 return (memcmp(ddf->controller.guid, T10, 8) == 0 &&
1647 len < sizeof(ddf->controller.vendor_data) &&
1648 memcmp(ddf->controller.vendor_data, homehost,len) == 0 &&
1649 ddf->controller.vendor_data[len] == 0);
1650}
1651
0e600426 1652#ifndef MDASSEMBLE
baba3f4e 1653static int find_index_in_bvd(const struct ddf_super *ddf,
1654 const struct vd_config *conf, unsigned int n,
1655 unsigned int *n_bvd)
1656{
1657 /*
1658 * Find the index of the n-th valid physical disk in this BVD
1659 */
1660 unsigned int i, j;
1661 for (i = 0, j = 0; i < ddf->mppe &&
1662 j < __be16_to_cpu(conf->prim_elmnt_count); i++) {
1663 if (conf->phys_refnum[i] != 0xffffffff) {
1664 if (n == j) {
1665 *n_bvd = i;
1666 return 1;
1667 }
1668 j++;
1669 }
1670 }
1671 dprintf("%s: couldn't find BVD member %u (total %u)\n",
1672 __func__, n, __be16_to_cpu(conf->prim_elmnt_count));
1673 return 0;
1674}
1675
1676static struct vd_config *find_vdcr(struct ddf_super *ddf, unsigned int inst,
1677 unsigned int n,
1678 unsigned int *n_bvd, struct vcl **vcl)
a322f70c 1679{
7a7cc504 1680 struct vcl *v;
59e36268 1681
baba3f4e 1682 for (v = ddf->conflist; v; v = v->next) {
1683 unsigned int nsec, ibvd;
1684 struct vd_config *conf;
1685 if (inst != v->vcnum)
1686 continue;
1687 conf = &v->conf;
1688 if (conf->sec_elmnt_count == 1) {
1689 if (find_index_in_bvd(ddf, conf, n, n_bvd)) {
1690 *vcl = v;
1691 return conf;
1692 } else
1693 goto bad;
1694 }
1695 if (v->other_bvds == NULL) {
1696 pr_err("%s: BUG: other_bvds is NULL, nsec=%u\n",
1697 __func__, conf->sec_elmnt_count);
1698 goto bad;
1699 }
1700 nsec = n / __be16_to_cpu(conf->prim_elmnt_count);
1701 if (conf->sec_elmnt_seq != nsec) {
1702 for (ibvd = 1; ibvd < conf->sec_elmnt_count; ibvd++) {
baba3f4e 1703 if (v->other_bvds[ibvd-1]->sec_elmnt_seq
1704 == nsec)
1705 break;
1706 }
1707 if (ibvd == conf->sec_elmnt_count)
1708 goto bad;
1709 conf = v->other_bvds[ibvd-1];
1710 }
1711 if (!find_index_in_bvd(ddf, conf,
1712 n - nsec*conf->sec_elmnt_count, n_bvd))
1713 goto bad;
1714 dprintf("%s: found disk %u as member %u in bvd %d of array %u\n"
1715 , __func__, n, *n_bvd, ibvd-1, inst);
1716 *vcl = v;
1717 return conf;
1718 }
1719bad:
1720 pr_err("%s: Could't find disk %d in array %u\n", __func__, n, inst);
7a7cc504
NB		 1721 return NULL;
1722}
0e600426 1723#endif
7a7cc504 1724
5ec636b7 1725static int find_phys(const struct ddf_super *ddf, __u32 phys_refnum)
7a7cc504
NB		 1726{
1727 /* Find the entry in phys_disk which has the given refnum
1728 * and return it's index
1729 */
f21e18ca
N		 1730 unsigned int i;
1731 for (i = 0; i < __be16_to_cpu(ddf->phys->max_pdes); i++)
7a7cc504
NB		 1732 if (ddf->phys->entries[i].refnum == phys_refnum)
1733 return i;
1734 return -1;
a322f70c
DW		 1735}
1736
bedbf68a 1737static void uuid_from_ddf_guid(const char *guid, int uuid[4])
1738{
1739 char buf[20];
1740 struct sha1_ctx ctx;
1741 sha1_init_ctx(&ctx);
1742 sha1_process_bytes(guid, DDF_GUID_LEN, &ctx);
1743 sha1_finish_ctx(&ctx, buf);
1744 memcpy(uuid, buf, 4*4);
1745}
1746
a322f70c
DW		 1747static void uuid_from_super_ddf(struct supertype *st, int uuid[4])
1748{
1749 /* The uuid returned here is used for:
1750 * uuid to put into bitmap file (Create, Grow)
1751 * uuid for backup header when saving critical section (Grow)
1752 * comparing uuids when re-adding a device into an array
51006d85
N		 1753 * In these cases the uuid required is that of the data-array,
1754 * not the device-set.
1755 * uuid to recognise same set when adding a missing device back
1756 * to an array. This is a uuid for the device-set.
613b0d17 1757 *
a322f70c
DW		 1758 * For each of these we can make do with a truncated
1759 * or hashed uuid rather than the original, as long as
1760 * everyone agrees.
a322f70c
DW		 1761 * In the case of SVD we assume the BVD is of interest,
1762 * though that might be the case if a bitmap were made for
1763 * a mirrored SVD - worry about that later.
1764 * So we need to find the VD configuration record for the
1765 * relevant BVD and extract the GUID and Secondary_Element_Seq.
1766 * The first 16 bytes of the sha1 of these is used.
1767 */
1768 struct ddf_super *ddf = st->sb;
d2ca6449 1769 struct vcl *vcl = ddf->currentconf;
c5afc314 1770 char *guid;
a322f70c 1771
c5afc314
N		 1772 if (vcl)
1773 guid = vcl->conf.guid;
1774 else
1775 guid = ddf->anchor.guid;
bedbf68a 1776 uuid_from_ddf_guid(guid, uuid);
a322f70c
DW		 1777}
1778
a5d85af7 1779static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, char *map);
78e44928 1780
a5d85af7 1781static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *map)
a322f70c
DW		 1782{
1783 struct ddf_super *ddf = st->sb;
a5d85af7 1784 int map_disks = info->array.raid_disks;
90fa1a29 1785 __u32 *cptr;
a322f70c 1786
78e44928 1787 if (ddf->currentconf) {
a5d85af7 1788 getinfo_super_ddf_bvd(st, info, map);
78e44928
NB		 1789 return;
1790 }
95eeceeb 1791 memset(info, 0, sizeof(*info));
78e44928 1792
a322f70c
DW		 1793 info->array.raid_disks = __be16_to_cpu(ddf->phys->used_pdes);
1794 info->array.level = LEVEL_CONTAINER;
1795 info->array.layout = 0;
1796 info->array.md_minor = -1;
90fa1a29
JS		 1797 cptr = (__u32 *)(ddf->anchor.guid + 16);
1798 info->array.ctime = DECADE + __be32_to_cpu(*cptr);
1799
a322f70c
DW		 1800 info->array.utime = 0;
1801 info->array.chunk_size = 0;
510242aa 1802 info->container_enough = 1;
a322f70c 1803
a322f70c
DW		 1804 info->disk.major = 0;
1805 info->disk.minor = 0;
cba0191b
NB		 1806 if (ddf->dlist) {
1807 info->disk.number = __be32_to_cpu(ddf->dlist->disk.refnum);
59e36268 1808 info->disk.raid_disk = find_phys(ddf, ddf->dlist->disk.refnum);
d2ca6449
NB		 1809
1810 info->data_offset = __be64_to_cpu(ddf->phys->
613b0d17
N		 1811 entries[info->disk.raid_disk].
1812 config_size);
d2ca6449 1813 info->component_size = ddf->dlist->size - info->data_offset;
cba0191b
NB		 1814 } else {
1815 info->disk.number = -1;
661dce36 1816 info->disk.raid_disk = -1;
cba0191b
NB		 1817// info->disk.raid_disk = find refnum in the table and use index;
1818 }
f22385f9 1819 info->disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
a19c88b8 1820
921d9e16 1821 info->recovery_start = MaxSector;
a19c88b8 1822 info->reshape_active = 0;
6e75048b 1823 info->recovery_blocked = 0;
c5afc314 1824 info->name[0] = 0;
a322f70c 1825
f35f2525
N		 1826 info->array.major_version = -1;
1827 info->array.minor_version = -2;
159c3a1a 1828 strcpy(info->text_version, "ddf");
a67dd8cc 1829 info->safe_mode_delay = 0;
159c3a1a 1830
c5afc314 1831 uuid_from_super_ddf(st, info->uuid);
a322f70c 1832
a5d85af7
N		 1833 if (map) {
1834 int i;
1835 for (i = 0 ; i < map_disks; i++) {
1836 if (i < info->array.raid_disks &&
1837 (__be16_to_cpu(ddf->phys->entries[i].state) & DDF_Online) &&
1838 !(__be16_to_cpu(ddf->phys->entries[i].state) & DDF_Failed))
1839 map[i] = 1;
1840 else
1841 map[i] = 0;
1842 }
1843 }
a322f70c
DW		 1844}
1845
a5d85af7 1846static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, char *map)
a322f70c
DW		 1847{
1848 struct ddf_super *ddf = st->sb;
d2ca6449
NB		 1849 struct vcl *vc = ddf->currentconf;
1850 int cd = ddf->currentdev;
ddf94a43 1851 int n_prim;
db42fa9b 1852 int j;
8592f29d 1853 struct dl *dl;
a5d85af7 1854 int map_disks = info->array.raid_disks;
90fa1a29 1855 __u32 *cptr;
ddf94a43 1856 struct vd_config *conf;
a322f70c 1857
95eeceeb 1858 memset(info, 0, sizeof(*info));
8a2848a7 1859 if (layout_ddf2md(&vc->conf, &info->array) == -1)
1860 return;
a322f70c 1861 info->array.md_minor = -1;
90fa1a29
JS		 1862 cptr = (__u32 *)(vc->conf.guid + 16);
1863 info->array.ctime = DECADE + __be32_to_cpu(*cptr);
d2ca6449
NB		 1864 info->array.utime = DECADE + __be32_to_cpu(vc->conf.timestamp);
1865 info->array.chunk_size = 512 << vc->conf.chunk_shift;
da9b4a62 1866 info->custom_array_size = 0;
d2ca6449 1867
ddf94a43 1868 conf = &vc->conf;
1869 n_prim = __be16_to_cpu(conf->prim_elmnt_count);
1870 if (conf->sec_elmnt_count > 1 && cd >= n_prim) {
1871 int ibvd = cd / n_prim - 1;
1872 cd %= n_prim;
1873 conf = vc->other_bvds[ibvd];
1874 }
1875
f21e18ca 1876 if (cd >= 0 && (unsigned)cd < ddf->mppe) {
57a66662 1877 info->data_offset =
1878 __be64_to_cpu(LBA_OFFSET(ddf, &vc->conf)[cd]);
d2ca6449
NB		 1879 if (vc->block_sizes)
1880 info->component_size = vc->block_sizes[cd];
1881 else
1882 info->component_size = __be64_to_cpu(vc->conf.blocks);
1883 }
a322f70c 1884
fb204fb2 1885 for (dl = ddf->dlist; dl ; dl = dl->next)
f5ded787 1886 if (dl->disk.refnum == conf->phys_refnum[cd])
fb204fb2
N		 1887 break;
1888
a322f70c
DW		 1889 info->disk.major = 0;
1890 info->disk.minor = 0;
fb204fb2 1891 info->disk.state = 0;
8592f29d
N		 1892 if (dl) {
1893 info->disk.major = dl->major;
1894 info->disk.minor = dl->minor;
7c3fb3ec 1895 info->disk.raid_disk = cd + conf->sec_elmnt_seq
1896 * __be16_to_cpu(conf->prim_elmnt_count);
fb204fb2
N		 1897 info->disk.number = dl->pdnum;
1898 info->disk.state = (1<<MD_DISK_SYNC)|(1<<MD_DISK_ACTIVE);
8592f29d 1899 }
a322f70c 1900
103f2410
NB		 1901 info->container_member = ddf->currentconf->vcnum;
1902
921d9e16 1903 info->recovery_start = MaxSector;
80d26cb2 1904 info->resync_start = 0;
624c5ad4 1905 info->reshape_active = 0;
6e75048b 1906 info->recovery_blocked = 0;
80d26cb2
NB		 1907 if (!(ddf->virt->entries[info->container_member].state
1908 & DDF_state_inconsistent) &&
1909 (ddf->virt->entries[info->container_member].init_state
1910 & DDF_initstate_mask)
1911 == DDF_init_full)
b7528a20 1912 info->resync_start = MaxSector;
80d26cb2 1913
a322f70c
DW		 1914 uuid_from_super_ddf(st, info->uuid);
1915
f35f2525
N		 1916 info->array.major_version = -1;
1917 info->array.minor_version = -2;
9b63e648 1918 sprintf(info->text_version, "/%s/%d",
4dd2df09 1919 st->container_devnm,
9b63e648 1920 info->container_member);
a67dd8cc 1921 info->safe_mode_delay = 200;
159c3a1a 1922
db42fa9b
N		 1923 memcpy(info->name, ddf->virt->entries[info->container_member].name, 16);
1924 info->name[16]=0;
1925 for(j=0; j<16; j++)
1926 if (info->name[j] == ' ')
1927 info->name[j] = 0;
a5d85af7
N		 1928
1929 if (map)
1930 for (j = 0; j < map_disks; j++) {
1931 map[j] = 0;
1932 if (j < info->array.raid_disks) {
1933 int i = find_phys(ddf, vc->conf.phys_refnum[j]);
613b0d17 1934 if (i >= 0 &&
a5d85af7
N		 1935 (__be16_to_cpu(ddf->phys->entries[i].state) & DDF_Online) &&
1936 !(__be16_to_cpu(ddf->phys->entries[i].state) & DDF_Failed))
1937 map[i] = 1;
1938 }
1939 }
a322f70c
DW		 1940}
1941
1942static int update_super_ddf(struct supertype *st, struct mdinfo *info,
1943 char *update,
1944 char *devname, int verbose,
1945 int uuid_set, char *homehost)
1946{
1947 /* For 'assemble' and 'force' we need to return non-zero if any
1948 * change was made. For others, the return value is ignored.
1949 * Update options are:
1950 * force-one : This device looks a bit old but needs to be included,
1951 * update age info appropriately.
1952 * assemble: clear any 'faulty' flag to allow this device to
1953 * be assembled.
1954 * force-array: Array is degraded but being forced, mark it clean
1955 * if that will be needed to assemble it.
1956 *
1957 * newdev: not used ????
1958 * grow: Array has gained a new device - this is currently for
1959 * linear only
1960 * resync: mark as dirty so a resync will happen.
59e36268 1961 * uuid: Change the uuid of the array to match what is given
a322f70c
DW		 1962 * homehost: update the recorded homehost
1963 * name: update the name - preserving the homehost
1964 * _reshape_progress: record new reshape_progress position.
1965 *
1966 * Following are not relevant for this version:
1967 * sparc2.2 : update from old dodgey metadata
1968 * super-minor: change the preferred_minor number
1969 * summaries: update redundant counters.
1970 */
1971 int rv = 0;
1972// struct ddf_super *ddf = st->sb;
7a7cc504 1973// struct vd_config *vd = find_vdcr(ddf, info->container_member);
a322f70c
DW		 1974// struct virtual_entry *ve = find_ve(ddf);
1975
a322f70c
DW		 1976 /* we don't need to handle "force-*" or "assemble" as
1977 * there is no need to 'trick' the kernel. We the metadata is
1978 * first updated to activate the array, all the implied modifications
1979 * will just happen.
1980 */
1981
1982 if (strcmp(update, "grow") == 0) {
1983 /* FIXME */
1e2b2765 1984 } else if (strcmp(update, "resync") == 0) {
a322f70c 1985// info->resync_checkpoint = 0;
1e2b2765 1986 } else if (strcmp(update, "homehost") == 0) {
a322f70c
DW		 1987 /* homehost is stored in controller->vendor_data,
1988 * or it is when we are the vendor
1989 */
1990// if (info->vendor_is_local)
1991// strcpy(ddf->controller.vendor_data, homehost);
1e2b2765 1992 rv = -1;
f49208ec 1993 } else if (strcmp(update, "name") == 0) {
a322f70c
DW		 1994 /* name is stored in virtual_entry->name */
1995// memset(ve->name, ' ', 16);
1996// strncpy(ve->name, info->name, 16);
1e2b2765 1997 rv = -1;
f49208ec 1998 } else if (strcmp(update, "_reshape_progress") == 0) {
a322f70c 1999 /* We don't support reshape yet */
f49208ec
N		 2000 } else if (strcmp(update, "assemble") == 0 ) {
2001 /* Do nothing, just succeed */
2002 rv = 0;
1e2b2765
N		 2003 } else
2004 rv = -1;
a322f70c
DW		 2005
2006// update_all_csum(ddf);
2007
2008 return rv;
2009}
2010
5f8097be
NB		 2011static void make_header_guid(char *guid)
2012{
2013 __u32 stamp;
5f8097be
NB		 2014 /* Create a DDF Header of Virtual Disk GUID */
2015
2016 /* 24 bytes of fiction required.
2017 * first 8 are a 'vendor-id' - "Linux-MD"
2018 * next 8 are controller type.. how about 0X DEAD BEEF 0000 0000
2019 * Remaining 8 random number plus timestamp
2020 */
2021 memcpy(guid, T10, sizeof(T10));
2022 stamp = __cpu_to_be32(0xdeadbeef);
2023 memcpy(guid+8, &stamp, 4);
2024 stamp = __cpu_to_be32(0);
2025 memcpy(guid+12, &stamp, 4);
2026 stamp = __cpu_to_be32(time(0) - DECADE);
2027 memcpy(guid+16, &stamp, 4);
bfb7ea78 2028 stamp = random32();
5f8097be 2029 memcpy(guid+20, &stamp, 4);
5f8097be 2030}
59e36268 2031
fb9d0acb 2032static unsigned int find_unused_vde(const struct ddf_super *ddf)
2033{
2034 unsigned int i;
2035 for (i = 0; i < __be16_to_cpu(ddf->virt->max_vdes); i++) {
2036 if (all_ff(ddf->virt->entries[i].guid))
2037 return i;
2038 }
2039 return DDF_NOTFOUND;
2040}
2041
2042static unsigned int find_vde_by_name(const struct ddf_super *ddf,
2043 const char *name)
2044{
2045 unsigned int i;
2046 if (name == NULL)
2047 return DDF_NOTFOUND;
2048 for (i = 0; i < __be16_to_cpu(ddf->virt->max_vdes); i++) {
2049 if (all_ff(ddf->virt->entries[i].guid))
2050 continue;
2051 if (!strncmp(name, ddf->virt->entries[i].name,
2052 sizeof(ddf->virt->entries[i].name)))
2053 return i;
2054 }
2055 return DDF_NOTFOUND;
2056}
2057
2058static unsigned int find_vde_by_guid(const struct ddf_super *ddf,
2059 const char *guid)
2060{
2061 unsigned int i;
2062 if (guid == NULL || all_ff(guid))
2063 return DDF_NOTFOUND;
2064 for (i = 0; i < __be16_to_cpu(ddf->virt->max_vdes); i++)
2065 if (!memcmp(ddf->virt->entries[i].guid, guid, DDF_GUID_LEN))
2066 return i;
2067 return DDF_NOTFOUND;
2068}
2069
78e44928
NB		 2070static int init_super_ddf_bvd(struct supertype *st,
2071 mdu_array_info_t *info,
2072 unsigned long long size,
2073 char *name, char *homehost,
83cd1e97 2074 int *uuid, unsigned long long data_offset);
78e44928 2075
a322f70c
DW		 2076static int init_super_ddf(struct supertype *st,
2077 mdu_array_info_t *info,
2078 unsigned long long size, char *name, char *homehost,
83cd1e97 2079 int *uuid, unsigned long long data_offset)
a322f70c
DW		 2080{
2081 /* This is primarily called by Create when creating a new array.
2082 * We will then get add_to_super called for each component, and then
2083 * write_init_super called to write it out to each device.
2084 * For DDF, Create can create on fresh devices or on a pre-existing
2085 * array.
2086 * To create on a pre-existing array a different method will be called.
2087 * This one is just for fresh drives.
2088 *
2089 * We need to create the entire 'ddf' structure which includes:
2090 * DDF headers - these are easy.
2091 * Controller data - a Sector describing this controller .. not that
2092 * this is a controller exactly.
2093 * Physical Disk Record - one entry per device, so
2094 * leave plenty of space.
2095 * Virtual Disk Records - again, just leave plenty of space.
2096 * This just lists VDs, doesn't give details
2097 * Config records - describes the VDs that use this disk
2098 * DiskData - describes 'this' device.
2099 * BadBlockManagement - empty
2100 * Diag Space - empty
2101 * Vendor Logs - Could we put bitmaps here?
2102 *
2103 */
2104 struct ddf_super *ddf;
2105 char hostname[17];
2106 int hostlen;
a322f70c
DW		 2107 int max_phys_disks, max_virt_disks;
2108 unsigned long long sector;
2109 int clen;
2110 int i;
2111 int pdsize, vdsize;
2112 struct phys_disk *pd;
2113 struct virtual_disk *vd;
2114
83cd1e97 2115 if (data_offset != INVALID_SECTORS) {
ed503f89 2116 pr_err("data-offset not supported by DDF\n");
83cd1e97
N		 2117 return 0;
2118 }
2119
78e44928 2120 if (st->sb)
83cd1e97
N		 2121 return init_super_ddf_bvd(st, info, size, name, homehost, uuid,
2122 data_offset);
ba7eb04f 2123
3d2c4fc7 2124 if (posix_memalign((void**)&ddf, 512, sizeof(*ddf)) != 0) {
e7b84f9d 2125 pr_err("%s could not allocate superblock\n", __func__);
3d2c4fc7
DW		 2126 return 0;
2127 }
6264b437 2128 memset(ddf, 0, sizeof(*ddf));
a322f70c
DW		 2129 ddf->dlist = NULL; /* no physical disks yet */
2130 ddf->conflist = NULL; /* No virtual disks yet */
955e9ea1
DW		 2131 st->sb = ddf;
2132
2133 if (info == NULL) {
2134 /* zeroing superblock */
2135 return 0;
2136 }
a322f70c
DW		 2137
2138 /* At least 32MB *must* be reserved for the ddf. So let's just
2139 * start 32MB from the end, and put the primary header there.
2140 * Don't do secondary for now.
2141 * We don't know exactly where that will be yet as it could be
2142 * different on each device. To just set up the lengths.
2143 *
2144 */
2145
2146 ddf->anchor.magic = DDF_HEADER_MAGIC;
5f8097be 2147 make_header_guid(ddf->anchor.guid);
a322f70c 2148
59e36268 2149 memcpy(ddf->anchor.revision, DDF_REVISION_2, 8);
a322f70c
DW		 2150 ddf->anchor.seq = __cpu_to_be32(1);
2151 ddf->anchor.timestamp = __cpu_to_be32(time(0) - DECADE);
2152 ddf->anchor.openflag = 0xFF;
2153 ddf->anchor.foreignflag = 0;
2154 ddf->anchor.enforcegroups = 0; /* Is this best?? */
2155 ddf->anchor.pad0 = 0xff;
2156 memset(ddf->anchor.pad1, 0xff, 12);
2157 memset(ddf->anchor.header_ext, 0xff, 32);
2158 ddf->anchor.primary_lba = ~(__u64)0;
2159 ddf->anchor.secondary_lba = ~(__u64)0;
2160 ddf->anchor.type = DDF_HEADER_ANCHOR;
2161 memset(ddf->anchor.pad2, 0xff, 3);
2162 ddf->anchor.workspace_len = __cpu_to_be32(32768); /* Must be reserved */
2163 ddf->anchor.workspace_lba = ~(__u64)0; /* Put this at bottom
2164 of 32M reserved.. */
2165 max_phys_disks = 1023; /* Should be enough */
2166 ddf->anchor.max_pd_entries = __cpu_to_be16(max_phys_disks);
2167 max_virt_disks = 255;
2168 ddf->anchor.max_vd_entries = __cpu_to_be16(max_virt_disks); /* ?? */
2169 ddf->anchor.max_partitions = __cpu_to_be16(64); /* ?? */
2170 ddf->max_part = 64;
8c3b8c2c 2171 ddf->mppe = 256;
59e36268
NB		 2172 ddf->conf_rec_len = 1 + ROUND_UP(ddf->mppe * (4+8), 512)/512;
2173 ddf->anchor.config_record_len = __cpu_to_be16(ddf->conf_rec_len);
2174 ddf->anchor.max_primary_element_entries = __cpu_to_be16(ddf->mppe);
a322f70c 2175 memset(ddf->anchor.pad3, 0xff, 54);
a322f70c
DW		 2176 /* controller sections is one sector long immediately
2177 * after the ddf header */
2178 sector = 1;
2179 ddf->anchor.controller_section_offset = __cpu_to_be32(sector);
2180 ddf->anchor.controller_section_length = __cpu_to_be32(1);
2181 sector += 1;
2182
2183 /* phys is 8 sectors after that */
2184 pdsize = ROUND_UP(sizeof(struct phys_disk) +
2185 sizeof(struct phys_disk_entry)*max_phys_disks,
2186 512);
2187 switch(pdsize/512) {
2188 case 2: case 8: case 32: case 128: case 512: break;
2189 default: abort();
2190 }
2191 ddf->anchor.phys_section_offset = __cpu_to_be32(sector);
2192 ddf->anchor.phys_section_length =
2193 __cpu_to_be32(pdsize/512); /* max_primary_element_entries/8 */
2194 sector += pdsize/512;
2195
2196 /* virt is another 32 sectors */
2197 vdsize = ROUND_UP(sizeof(struct virtual_disk) +
2198 sizeof(struct virtual_entry) * max_virt_disks,
2199 512);
2200 switch(vdsize/512) {
2201 case 2: case 8: case 32: case 128: case 512: break;
2202 default: abort();
2203 }
2204 ddf->anchor.virt_section_offset = __cpu_to_be32(sector);
2205 ddf->anchor.virt_section_length =
2206 __cpu_to_be32(vdsize/512); /* max_vd_entries/8 */
2207 sector += vdsize/512;
2208
59e36268 2209 clen = ddf->conf_rec_len * (ddf->max_part+1);
a322f70c
DW		 2210 ddf->anchor.config_section_offset = __cpu_to_be32(sector);
2211 ddf->anchor.config_section_length = __cpu_to_be32(clen);
2212 sector += clen;
2213
2214 ddf->anchor.data_section_offset = __cpu_to_be32(sector);
2215 ddf->anchor.data_section_length = __cpu_to_be32(1);
2216 sector += 1;
2217
2218 ddf->anchor.bbm_section_length = __cpu_to_be32(0);
2219 ddf->anchor.bbm_section_offset = __cpu_to_be32(0xFFFFFFFF);
2220 ddf->anchor.diag_space_length = __cpu_to_be32(0);
2221 ddf->anchor.diag_space_offset = __cpu_to_be32(0xFFFFFFFF);
2222 ddf->anchor.vendor_length = __cpu_to_be32(0);
2223 ddf->anchor.vendor_offset = __cpu_to_be32(0xFFFFFFFF);
2224
2225 memset(ddf->anchor.pad4, 0xff, 256);
2226
2227 memcpy(&ddf->primary, &ddf->anchor, 512);
2228 memcpy(&ddf->secondary, &ddf->anchor, 512);
2229
2230 ddf->primary.openflag = 1; /* I guess.. */
2231 ddf->primary.type = DDF_HEADER_PRIMARY;
2232
2233 ddf->secondary.openflag = 1; /* I guess.. */
2234 ddf->secondary.type = DDF_HEADER_SECONDARY;
2235
2236 ddf->active = &ddf->primary;
2237
2238 ddf->controller.magic = DDF_CONTROLLER_MAGIC;
2239
2240 /* 24 more bytes of fiction required.
2241 * first 8 are a 'vendor-id' - "Linux-MD"
2242 * Remaining 16 are serial number.... maybe a hostname would do?
2243 */
2244 memcpy(ddf->controller.guid, T10, sizeof(T10));
1ba6bff9
DW		 2245 gethostname(hostname, sizeof(hostname));
2246 hostname[sizeof(hostname) - 1] = 0;
a322f70c
DW		 2247 hostlen = strlen(hostname);
2248 memcpy(ddf->controller.guid + 24 - hostlen, hostname, hostlen);
2249 for (i = strlen(T10) ; i+hostlen < 24; i++)
2250 ddf->controller.guid[i] = ' ';
2251
2252 ddf->controller.type.vendor_id = __cpu_to_be16(0xDEAD);
2253 ddf->controller.type.device_id = __cpu_to_be16(0xBEEF);
2254 ddf->controller.type.sub_vendor_id = 0;
2255 ddf->controller.type.sub_device_id = 0;
2256 memcpy(ddf->controller.product_id, "What Is My PID??", 16);
2257 memset(ddf->controller.pad, 0xff, 8);
2258 memset(ddf->controller.vendor_data, 0xff, 448);
a9e1c11d
N		 2259 if (homehost && strlen(homehost) < 440)
2260 strcpy((char*)ddf->controller.vendor_data, homehost);
a322f70c 2261
3d2c4fc7 2262 if (posix_memalign((void**)&pd, 512, pdsize) != 0) {
e7b84f9d 2263 pr_err("%s could not allocate pd\n", __func__);
3d2c4fc7
DW		 2264 return 0;
2265 }
6416d527 2266 ddf->phys = pd;
a322f70c
DW		 2267 ddf->pdsize = pdsize;
2268
2269 memset(pd, 0xff, pdsize);
2270 memset(pd, 0, sizeof(*pd));
076515ba 2271 pd->magic = DDF_PHYS_RECORDS_MAGIC;
a322f70c
DW		 2272 pd->used_pdes = __cpu_to_be16(0);
2273 pd->max_pdes = __cpu_to_be16(max_phys_disks);
2274 memset(pd->pad, 0xff, 52);
4a3ca8ac 2275 for (i = 0; i < max_phys_disks; i++)
2276 memset(pd->entries[i].guid, 0xff, DDF_GUID_LEN);
a322f70c 2277
3d2c4fc7 2278 if (posix_memalign((void**)&vd, 512, vdsize) != 0) {
e7b84f9d 2279 pr_err("%s could not allocate vd\n", __func__);
3d2c4fc7
DW		 2280 return 0;
2281 }
6416d527 2282 ddf->virt = vd;
a322f70c
DW		 2283 ddf->vdsize = vdsize;
2284 memset(vd, 0, vdsize);
2285 vd->magic = DDF_VIRT_RECORDS_MAGIC;
2286 vd->populated_vdes = __cpu_to_be16(0);
2287 vd->max_vdes = __cpu_to_be16(max_virt_disks);
2288 memset(vd->pad, 0xff, 52);
2289
5f8097be
NB		 2290 for (i=0; i<max_virt_disks; i++)
2291 memset(&vd->entries[i], 0xff, sizeof(struct virtual_entry));
2292
a322f70c 2293 st->sb = ddf;
7d5a7ff3 2294 ddf_set_updates_pending(ddf);
a322f70c
DW		 2295 return 1;
2296}
2297
5f8097be
NB		 2298static int chunk_to_shift(int chunksize)
2299{
2300 return ffs(chunksize/512)-1;
2301}
2302
0e600426 2303#ifndef MDASSEMBLE
59e36268
NB		 2304struct extent {
2305 unsigned long long start, size;
2306};
78e44928 2307static int cmp_extent(const void *av, const void *bv)
59e36268
NB		 2308{
2309 const struct extent *a = av;
2310 const struct extent *b = bv;
2311 if (a->start < b->start)
2312 return -1;
2313 if (a->start > b->start)
2314 return 1;
2315 return 0;
2316}
2317
78e44928 2318static struct extent *get_extents(struct ddf_super *ddf, struct dl *dl)
59e36268
NB		 2319{
2320 /* find a list of used extents on the give physical device
2321 * (dnum) of the given ddf.
2322 * Return a malloced array of 'struct extent'
2323
613b0d17 2324 * FIXME ignore DDF_Legacy devices?
59e36268
NB		 2325
2326 */
2327 struct extent *rv;
2328 int n = 0;
fcc22180 2329 unsigned int i;
59e36268 2330
503975b9 2331 rv = xmalloc(sizeof(struct extent) * (ddf->max_part + 2));
59e36268
NB		 2332
2333 for (i = 0; i < ddf->max_part; i++) {
fcc22180 2334 const struct vd_config *bvd;
2335 unsigned int ibvd;
59e36268 2336 struct vcl *v = dl->vlist[i];
fcc22180 2337 if (v == NULL ||
2338 get_pd_index_from_refnum(v, dl->disk.refnum, ddf->mppe,
2339 &bvd, &ibvd) == DDF_NOTFOUND)
59e36268 2340 continue;
fcc22180 2341 rv[n].start = __be64_to_cpu(LBA_OFFSET(ddf, bvd)[ibvd]);
2342 rv[n].size = __be64_to_cpu(bvd->blocks);
2343 n++;
59e36268
NB		 2344 }
2345 qsort(rv, n, sizeof(*rv), cmp_extent);
2346
2347 rv[n].start = __be64_to_cpu(ddf->phys->entries[dl->pdnum].config_size);
2348 rv[n].size = 0;
2349 return rv;
2350}
0e600426 2351#endif
59e36268 2352
5f8097be
NB		 2353static int init_super_ddf_bvd(struct supertype *st,
2354 mdu_array_info_t *info,
2355 unsigned long long size,
2356 char *name, char *homehost,
83cd1e97 2357 int *uuid, unsigned long long data_offset)
5f8097be
NB		 2358{
2359 /* We are creating a BVD inside a pre-existing container.
2360 * so st->sb is already set.
2361 * We need to create a new vd_config and a new virtual_entry
2362 */
2363 struct ddf_super *ddf = st->sb;
5aaf6c7b 2364 unsigned int venum, i;
5f8097be
NB		 2365 struct virtual_entry *ve;
2366 struct vcl *vcl;
2367 struct vd_config *vc;
5f8097be 2368
fb9d0acb 2369 if (find_vde_by_name(ddf, name) != DDF_NOTFOUND) {
2370 pr_err("This ddf already has an array called %s\n", name);
5f8097be
NB		 2371 return 0;
2372 }
fb9d0acb 2373 venum = find_unused_vde(ddf);
2374 if (venum == DDF_NOTFOUND) {
2375 pr_err("Cannot find spare slot for virtual disk\n");
5f8097be
NB		 2376 return 0;
2377 }
2378 ve = &ddf->virt->entries[venum];
2379
2380 /* A Virtual Disk GUID contains the T10 Vendor ID, controller type,
2381 * timestamp, random number
2382 */
2383 make_header_guid(ve->guid);
2384 ve->unit = __cpu_to_be16(info->md_minor);
2385 ve->pad0 = 0xFFFF;
2386 ve->guid_crc = crc32(0, (unsigned char*)ddf->anchor.guid, DDF_GUID_LEN);
2387 ve->type = 0;
7a7cc504
NB		 2388 ve->state = DDF_state_degraded; /* Will be modified as devices are added */
2389 if (info->state & 1) /* clean */
2390 ve->init_state = DDF_init_full;
2391 else
2392 ve->init_state = DDF_init_not;
2393
5f8097be
NB		 2394 memset(ve->pad1, 0xff, 14);
2395 memset(ve->name, ' ', 16);
2396 if (name)
2397 strncpy(ve->name, name, 16);
2398 ddf->virt->populated_vdes =
2399 __cpu_to_be16(__be16_to_cpu(ddf->virt->populated_vdes)+1);
2400
2401 /* Now create a new vd_config */
3d2c4fc7
DW		 2402 if (posix_memalign((void**)&vcl, 512,
2403 (offsetof(struct vcl, conf) + ddf->conf_rec_len * 512)) != 0) {
e7b84f9d 2404 pr_err("%s could not allocate vd_config\n", __func__);
3d2c4fc7
DW		 2405 return 0;
2406 }
59e36268
NB		 2407 vcl->vcnum = venum;
2408 vcl->block_sizes = NULL; /* FIXME not for CONCAT */
5f8097be
NB		 2409 vc = &vcl->conf;
2410
2411 vc->magic = DDF_VD_CONF_MAGIC;
2412 memcpy(vc->guid, ve->guid, DDF_GUID_LEN);
2413 vc->timestamp = __cpu_to_be32(time(0)-DECADE);
2414 vc->seqnum = __cpu_to_be32(1);
2415 memset(vc->pad0, 0xff, 24);
5f8097be 2416 vc->chunk_shift = chunk_to_shift(info->chunk_size);
a3163bf0 2417 if (layout_md2ddf(info, vc) == -1 ||
2418 __be16_to_cpu(vc->prim_elmnt_count) > ddf->mppe) {
2419 pr_err("%s: unsupported RAID level/layout %d/%d with %d disks\n",
2420 __func__, info->level, info->layout, info->raid_disks);
2421 free(vcl);
2422 return 0;
2423 }
5f8097be 2424 vc->sec_elmnt_seq = 0;
3c48f7be 2425 if (alloc_other_bvds(ddf, vcl) != 0) {
2426 pr_err("%s could not allocate other bvds\n",
2427 __func__);
2428 free(vcl);
2429 return 0;
2430 }
5f8097be
NB		 2431 vc->blocks = __cpu_to_be64(info->size * 2);
2432 vc->array_blocks = __cpu_to_be64(
2433 calc_array_size(info->level, info->raid_disks, info->layout,
2434 info->chunk_size, info->size*2));
2435 memset(vc->pad1, 0xff, 8);
2436 vc->spare_refs[0] = 0xffffffff;
2437 vc->spare_refs[1] = 0xffffffff;
2438 vc->spare_refs[2] = 0xffffffff;
2439 vc->spare_refs[3] = 0xffffffff;
2440 vc->spare_refs[4] = 0xffffffff;
2441 vc->spare_refs[5] = 0xffffffff;
2442 vc->spare_refs[6] = 0xffffffff;
2443 vc->spare_refs[7] = 0xffffffff;
2444 memset(vc->cache_pol, 0, 8);
2445 vc->bg_rate = 0x80;
2446 memset(vc->pad2, 0xff, 3);
2447 memset(vc->pad3, 0xff, 52);
2448 memset(vc->pad4, 0xff, 192);
2449 memset(vc->v0, 0xff, 32);
2450 memset(vc->v1, 0xff, 32);
2451 memset(vc->v2, 0xff, 16);
2452 memset(vc->v3, 0xff, 16);
2453 memset(vc->vendor, 0xff, 32);
598f0d58 2454
8c3b8c2c 2455 memset(vc->phys_refnum, 0xff, 4*ddf->mppe);
e5a2a3cf 2456 memset(vc->phys_refnum+ddf->mppe, 0x00, 8*ddf->mppe);
5f8097be 2457
5aaf6c7b 2458 for (i = 1; i < vc->sec_elmnt_count; i++) {
2459 memcpy(vcl->other_bvds[i-1], vc, ddf->conf_rec_len * 512);
2460 vcl->other_bvds[i-1]->sec_elmnt_seq = i;
2461 }
2462
5f8097be
NB		 2463 vcl->next = ddf->conflist;
2464 ddf->conflist = vcl;
d2ca6449 2465 ddf->currentconf = vcl;
7d5a7ff3 2466 ddf_set_updates_pending(ddf);
5f8097be
NB		 2467 return 1;
2468}
2469
63eb2454 2470static int get_svd_state(const struct ddf_super *, const struct vcl *);
2471
0e600426 2472#ifndef MDASSEMBLE
5f8097be
NB		 2473static void add_to_super_ddf_bvd(struct supertype *st,
2474 mdu_disk_info_t *dk, int fd, char *devname)
2475{
2476 /* fd and devname identify a device with-in the ddf container (st).
2477 * dk identifies a location in the new BVD.
2478 * We need to find suitable free space in that device and update
2479 * the phys_refnum and lba_offset for the newly created vd_config.
2480 * We might also want to update the type in the phys_disk
5575e7d9 2481 * section.
8592f29d
N		 2482 *
2483 * Alternately: fd == -1 and we have already chosen which device to
2484 * use and recorded in dlist->raid_disk;
5f8097be
NB		 2485 */
2486 struct dl *dl;
2487 struct ddf_super *ddf = st->sb;
2488 struct vd_config *vc;
f21e18ca 2489 unsigned int i;
59e36268
NB		 2490 unsigned long long blocks, pos, esize;
2491 struct extent *ex;
475ccbdb 2492 unsigned int raid_disk = dk->raid_disk;
5f8097be 2493
8592f29d
N		 2494 if (fd == -1) {
2495 for (dl = ddf->dlist; dl ; dl = dl->next)
2496 if (dl->raiddisk == dk->raid_disk)
2497 break;
2498 } else {
2499 for (dl = ddf->dlist; dl ; dl = dl->next)
2500 if (dl->major == dk->major &&
2501 dl->minor == dk->minor)
2502 break;
2503 }
5f8097be
NB		 2504 if (!dl || ! (dk->state & (1<<MD_DISK_SYNC)))
2505 return;
2506
d2ca6449 2507 vc = &ddf->currentconf->conf;
475ccbdb 2508 if (vc->sec_elmnt_count > 1) {
2509 unsigned int n = __be16_to_cpu(vc->prim_elmnt_count);
2510 if (raid_disk >= n)
2511 vc = ddf->currentconf->other_bvds[raid_disk / n - 1];
2512 raid_disk %= n;
2513 }
59e36268
NB		 2514
2515 ex = get_extents(ddf, dl);
2516 if (!ex)
2517 return;
2518
2519 i = 0; pos = 0;
2520 blocks = __be64_to_cpu(vc->blocks);
d2ca6449
NB		 2521 if (ddf->currentconf->block_sizes)
2522 blocks = ddf->currentconf->block_sizes[dk->raid_disk];
59e36268
NB		 2523
2524 do {
2525 esize = ex[i].start - pos;
2526 if (esize >= blocks)
2527 break;
2528 pos = ex[i].start + ex[i].size;
2529 i++;
2530 } while (ex[i-1].size);
2531
2532 free(ex);
2533 if (esize < blocks)
2534 return;
2535
d2ca6449 2536 ddf->currentdev = dk->raid_disk;
475ccbdb 2537 vc->phys_refnum[raid_disk] = dl->disk.refnum;
2538 LBA_OFFSET(ddf, vc)[raid_disk] = __cpu_to_be64(pos);
5f8097be 2539
f21e18ca 2540 for (i = 0; i < ddf->max_part ; i++)
5575e7d9
NB		 2541 if (dl->vlist[i] == NULL)
2542 break;
2543 if (i == ddf->max_part)
2544 return;
d2ca6449 2545 dl->vlist[i] = ddf->currentconf;
5f8097be 2546
8592f29d
N		 2547 if (fd >= 0)
2548 dl->fd = fd;
2549 if (devname)
2550 dl->devname = devname;
7a7cc504 2551
63eb2454 2552 /* Check if we can mark array as optimal yet */
d2ca6449 2553 i = ddf->currentconf->vcnum;
63eb2454 2554 ddf->virt->entries[i].state =
2555 (ddf->virt->entries[i].state & ~DDF_state_mask)
2556 | get_svd_state(ddf, ddf->currentconf);
5575e7d9
NB		 2557 ddf->phys->entries[dl->pdnum].type &= ~__cpu_to_be16(DDF_Global_Spare);
2558 ddf->phys->entries[dl->pdnum].type |= __cpu_to_be16(DDF_Active_in_VD);
4f9bbe63 2559 dprintf("%s: added disk %d/%08x to VD %d/%s as disk %d\n",
2560 __func__, dl->pdnum, __be32_to_cpu(dl->disk.refnum),
2561 ddf->currentconf->vcnum, guid_str(vc->guid),
2562 dk->raid_disk);
7d5a7ff3 2563 ddf_set_updates_pending(ddf);
5f8097be
NB		 2564}
2565
4a3ca8ac 2566static unsigned int find_unused_pde(const struct ddf_super *ddf)
2567{
2568 unsigned int i;
2569 for (i = 0; i < __be16_to_cpu(ddf->phys->max_pdes); i++) {
2570 if (all_ff(ddf->phys->entries[i].guid))
2571 return i;
2572 }
2573 return DDF_NOTFOUND;
2574}
2575
a322f70c
DW		 2576/* add a device to a container, either while creating it or while
2577 * expanding a pre-existing container
2578 */
f20c3968 2579static int add_to_super_ddf(struct supertype *st,
72ca9bcf
N		 2580 mdu_disk_info_t *dk, int fd, char *devname,
2581 unsigned long long data_offset)
a322f70c
DW		 2582{
2583 struct ddf_super *ddf = st->sb;
2584 struct dl *dd;
2585 time_t now;
2586 struct tm *tm;
2587 unsigned long long size;
2588 struct phys_disk_entry *pde;
f21e18ca 2589 unsigned int n, i;
a322f70c 2590 struct stat stb;
90fa1a29 2591 __u32 *tptr;
a322f70c 2592
78e44928
NB		 2593 if (ddf->currentconf) {
2594 add_to_super_ddf_bvd(st, dk, fd, devname);
f20c3968 2595 return 0;
78e44928
NB		 2596 }
2597
a322f70c
DW		 2598 /* This is device numbered dk->number. We need to create
2599 * a phys_disk entry and a more detailed disk_data entry.
2600 */
2601 fstat(fd, &stb);
4a3ca8ac 2602 n = find_unused_pde(ddf);
2603 if (n == DDF_NOTFOUND) {
2604 pr_err("%s: No free slot in array, cannot add disk\n",
2605 __func__);
2606 return 1;
2607 }
2608 pde = &ddf->phys->entries[n];
4ee8cca9 2609 get_dev_size(fd, NULL, &size);
2610 if (size <= 32*1024*1024) {
2611 pr_err("%s: device size must be at least 32MB\n",
2612 __func__);
2613 return 1;
2614 }
2615 size >>= 9;
4a3ca8ac 2616
3d2c4fc7
DW		 2617 if (posix_memalign((void**)&dd, 512,
2618 sizeof(*dd) + sizeof(dd->vlist[0]) * ddf->max_part) != 0) {
e7b84f9d
N		 2619 pr_err("%s could allocate buffer for new disk, aborting\n",
2620 __func__);
f20c3968 2621 return 1;
3d2c4fc7 2622 }
a322f70c
DW		 2623 dd->major = major(stb.st_rdev);
2624 dd->minor = minor(stb.st_rdev);
2625 dd->devname = devname;
a322f70c 2626 dd->fd = fd;
b2280677 2627 dd->spare = NULL;
a322f70c
DW		 2628
2629 dd->disk.magic = DDF_PHYS_DATA_MAGIC;
2630 now = time(0);
2631 tm = localtime(&now);
2632 sprintf(dd->disk.guid, "%8s%04d%02d%02d",
2633 T10, tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday);
90fa1a29
JS		 2634 tptr = (__u32 *)(dd->disk.guid + 16);
2635 *tptr++ = random32();
2636 *tptr = random32();
a322f70c 2637
59e36268
NB		 2638 do {
2639 /* Cannot be bothered finding a CRC of some irrelevant details*/
bfb7ea78 2640 dd->disk.refnum = random32();
f21e18ca
N		 2641 for (i = __be16_to_cpu(ddf->active->max_pd_entries);
2642 i > 0; i--)
2643 if (ddf->phys->entries[i-1].refnum == dd->disk.refnum)
59e36268 2644 break;
f21e18ca 2645 } while (i > 0);
59e36268 2646
a322f70c
DW		 2647 dd->disk.forced_ref = 1;
2648 dd->disk.forced_guid = 1;
2649 memset(dd->disk.vendor, ' ', 32);
2650 memcpy(dd->disk.vendor, "Linux", 5);
2651 memset(dd->disk.pad, 0xff, 442);
b2280677 2652 for (i = 0; i < ddf->max_part ; i++)
a322f70c
DW		 2653 dd->vlist[i] = NULL;
2654
5575e7d9
NB		 2655 dd->pdnum = n;
2656
2cc2983d
N		 2657 if (st->update_tail) {
2658 int len = (sizeof(struct phys_disk) +
2659 sizeof(struct phys_disk_entry));
2660 struct phys_disk *pd;
2661
503975b9 2662 pd = xmalloc(len);
2cc2983d
N		 2663 pd->magic = DDF_PHYS_RECORDS_MAGIC;
2664 pd->used_pdes = __cpu_to_be16(n);
2665 pde = &pd->entries[0];
2666 dd->mdupdate = pd;
4a3ca8ac 2667 } else
2668 ddf->phys->used_pdes = __cpu_to_be16(
2669 1 + __be16_to_cpu(ddf->phys->used_pdes));
a322f70c
DW		 2670
2671 memcpy(pde->guid, dd->disk.guid, DDF_GUID_LEN);
2672 pde->refnum = dd->disk.refnum;
5575e7d9 2673 pde->type = __cpu_to_be16(DDF_Forced_PD_GUID | DDF_Global_Spare);
a322f70c 2674 pde->state = __cpu_to_be16(DDF_Online);
4ee8cca9 2675 dd->size = size;
2676 /*
2677 * If there is already a device in dlist, try to reserve the same
2678 * amount of workspace. Otherwise, use 32MB.
2679 * We checked disk size above already.
2680 */
2681#define __calc_lba(new, old, lba, mb) do { \
2682 unsigned long long dif; \
2683 if ((old) != NULL) \
2684 dif = (old)->size - __be64_to_cpu((old)->lba); \
2685 else \
2686 dif = (new)->size; \
2687 if ((new)->size > dif) \
2688 (new)->lba = __cpu_to_be64((new)->size - dif); \
2689 else \
2690 (new)->lba = __cpu_to_be64((new)->size - (mb*1024*2)); \
2691 } while (0)
2692 __calc_lba(dd, ddf->dlist, workspace_lba, 32);
2693 __calc_lba(dd, ddf->dlist, primary_lba, 16);
2694 __calc_lba(dd, ddf->dlist, secondary_lba, 32);
2695 pde->config_size = dd->workspace_lba;
2696
a322f70c
DW		 2697 sprintf(pde->path, "%17.17s","Information: nil") ;
2698 memset(pde->pad, 0xff, 6);
2699
2cc2983d
N		 2700 if (st->update_tail) {
2701 dd->next = ddf->add_list;
2702 ddf->add_list = dd;
2703 } else {
2704 dd->next = ddf->dlist;
2705 ddf->dlist = dd;
7d5a7ff3 2706 ddf_set_updates_pending(ddf);
2cc2983d 2707 }
f20c3968
DW		 2708
2709 return 0;
a322f70c
DW		 2710}
2711
4dd968cc
N		 2712static int remove_from_super_ddf(struct supertype *st, mdu_disk_info_t *dk)
2713{
2714 struct ddf_super *ddf = st->sb;
2715 struct dl *dl;
2716
2717 /* mdmon has noticed that this disk (dk->major/dk->minor) has
2718 * disappeared from the container.
2719 * We need to arrange that it disappears from the metadata and
2720 * internal data structures too.
2721 * Most of the work is done by ddf_process_update which edits
2722 * the metadata and closes the file handle and attaches the memory
2723 * where free_updates will free it.
2724 */
2725 for (dl = ddf->dlist; dl ; dl = dl->next)
2726 if (dl->major == dk->major &&
2727 dl->minor == dk->minor)
2728 break;
2729 if (!dl)
2730 return -1;
2731
2732 if (st->update_tail) {
2733 int len = (sizeof(struct phys_disk) +
2734 sizeof(struct phys_disk_entry));
2735 struct phys_disk *pd;
2736
503975b9 2737 pd = xmalloc(len);
4dd968cc
N		 2738 pd->magic = DDF_PHYS_RECORDS_MAGIC;
2739 pd->used_pdes = __cpu_to_be16(dl->pdnum);
2740 pd->entries[0].state = __cpu_to_be16(DDF_Missing);
2741 append_metadata_update(st, pd, len);
2742 }
2743 return 0;
2744}
2745
a322f70c
DW		 2746/*
2747 * This is the write_init_super method for a ddf container. It is
2748 * called when creating a container or adding another device to a
2749 * container.
2750 */
42d5dfd9 2751#define NULL_CONF_SZ 4096
18a2f463 2752
7f798aca 2753static int __write_ddf_structure(struct dl *d, struct ddf_super *ddf, __u8 type,
2754 char *null_aligned)
a322f70c 2755{
7f798aca 2756 unsigned long long sector;
2757 struct ddf_header *header;
2758 int fd, i, n_config, conf_size;
a4057a88 2759 int ret = 0;
7f798aca 2760
2761 fd = d->fd;
2762
2763 switch (type) {
2764 case DDF_HEADER_PRIMARY:
2765 header = &ddf->primary;
2766 sector = __be64_to_cpu(header->primary_lba);
2767 break;
2768 case DDF_HEADER_SECONDARY:
2769 header = &ddf->secondary;
2770 sector = __be64_to_cpu(header->secondary_lba);
2771 break;
2772 default:
2773 return 0;
2774 }
2775
2776 header->type = type;
a4057a88 2777 header->openflag = 1;
7f798aca 2778 header->crc = calc_crc(header, 512);
2779
2780 lseek64(fd, sector<<9, 0);
2781 if (write(fd, header, 512) < 0)
a4057a88 2782 goto out;
7f798aca 2783
2784 ddf->controller.crc = calc_crc(&ddf->controller, 512);
2785 if (write(fd, &ddf->controller, 512) < 0)
a4057a88 2786 goto out;
a322f70c 2787
7f798aca 2788 ddf->phys->crc = calc_crc(ddf->phys, ddf->pdsize);
2789 if (write(fd, ddf->phys, ddf->pdsize) < 0)
a4057a88 2790 goto out;
7f798aca 2791 ddf->virt->crc = calc_crc(ddf->virt, ddf->vdsize);
2792 if (write(fd, ddf->virt, ddf->vdsize) < 0)
a4057a88 2793 goto out;
7f798aca 2794
2795 /* Now write lots of config records. */
2796 n_config = ddf->max_part;
2797 conf_size = ddf->conf_rec_len * 512;
2798 for (i = 0 ; i <= n_config ; i++) {
e3c2a365 2799 struct vcl *c;
2800 struct vd_config *vdc = NULL;
2801 if (i == n_config) {
7f798aca 2802 c = (struct vcl *)d->spare;
e3c2a365 2803 if (c)
2804 vdc = &c->conf;
2805 } else {
2806 unsigned int dummy;
2807 c = d->vlist[i];
2808 if (c)
2809 get_pd_index_from_refnum(
2810 c, d->disk.refnum,
2811 ddf->mppe,
2812 (const struct vd_config **)&vdc,
2813 &dummy);
2814 }
7f798aca 2815 if (c) {
be9b9ef4 2816 dprintf("writing conf record %i on disk %08x for %s/%u\n",
ad60eea1 2817 i, __be32_to_cpu(d->disk.refnum),
2818 guid_str(vdc->guid),
be9b9ef4 2819 vdc->sec_elmnt_seq);
dacf3dc5 2820 vdc->seqnum = header->seq;
e3c2a365 2821 vdc->crc = calc_crc(vdc, conf_size);
2822 if (write(fd, vdc, conf_size) < 0)
7f798aca 2823 break;
2824 } else {
2825 unsigned int togo = conf_size;
2826 while (togo > NULL_CONF_SZ) {
2827 if (write(fd, null_aligned, NULL_CONF_SZ) < 0)
2828 break;
2829 togo -= NULL_CONF_SZ;
2830 }
2831 if (write(fd, null_aligned, togo) < 0)
2832 break;
2833 }
2834 }
2835 if (i <= n_config)
a4057a88 2836 goto out;
7f798aca 2837
2838 d->disk.crc = calc_crc(&d->disk, 512);
2839 if (write(fd, &d->disk, 512) < 0)
a4057a88 2840 goto out;
7f798aca 2841
a4057a88 2842 ret = 1;
2843out:
2844 header->openflag = 0;
2845 header->crc = calc_crc(header, 512);
2846
2847 lseek64(fd, sector<<9, 0);
2848 if (write(fd, header, 512) < 0)
2849 ret = 0;
2850
2851 return ret;
7f798aca 2852}
2853
2854static int __write_init_super_ddf(struct supertype *st)
2855{
a322f70c 2856 struct ddf_super *ddf = st->sb;
a322f70c 2857 struct dl *d;
175593bf
DW		 2858 int attempts = 0;
2859 int successes = 0;
7f798aca 2860 unsigned long long size;
42d5dfd9 2861 char *null_aligned;
0175cbf6 2862 __u32 seq;
42d5dfd9 2863
7d5a7ff3 2864 pr_state(ddf, __func__);
42d5dfd9
JS		 2865 if (posix_memalign((void**)&null_aligned, 4096, NULL_CONF_SZ) != 0) {
2866 return -ENOMEM;
2867 }
2868 memset(null_aligned, 0xff, NULL_CONF_SZ);
a322f70c 2869
dc9e279c 2870 seq = ddf->active->seq + 1;
0175cbf6 2871
175593bf
DW		 2872 /* try to write updated metadata,
2873 * if we catch a failure move on to the next disk
2874 */
a322f70c
DW		 2875 for (d = ddf->dlist; d; d=d->next) {
2876 int fd = d->fd;
2877
2878 if (fd < 0)
2879 continue;
2880
175593bf 2881 attempts++;
a322f70c
DW		 2882 /* We need to fill in the primary, (secondary) and workspace
2883 * lba's in the headers, set their checksums,
2884 * Also checksum phys, virt....
2885 *
2886 * Then write everything out, finally the anchor is written.
2887 */
2888 get_dev_size(fd, NULL, &size);
2889 size /= 512;
097bcf00 2890 if (d->workspace_lba != 0)
2891 ddf->anchor.workspace_lba = d->workspace_lba;
2892 else
2893 ddf->anchor.workspace_lba =
2894 __cpu_to_be64(size - 32*1024*2);
2895 if (d->primary_lba != 0)
2896 ddf->anchor.primary_lba = d->primary_lba;
2897 else
2898 ddf->anchor.primary_lba =
2899 __cpu_to_be64(size - 16*1024*2);
2900 if (d->secondary_lba != 0)
2901 ddf->anchor.secondary_lba = d->secondary_lba;
2902 else
2903 ddf->anchor.secondary_lba =
2904 __cpu_to_be64(size - 32*1024*2);
0175cbf6 2905 ddf->anchor.seq = seq;
a322f70c
DW		 2906 memcpy(&ddf->primary, &ddf->anchor, 512);
2907 memcpy(&ddf->secondary, &ddf->anchor, 512);
2908
2909 ddf->anchor.openflag = 0xFF; /* 'open' means nothing */
2910 ddf->anchor.seq = 0xFFFFFFFF; /* no sequencing in anchor */
2911 ddf->anchor.crc = calc_crc(&ddf->anchor, 512);
2912
7f798aca 2913 if (!__write_ddf_structure(d, ddf, DDF_HEADER_PRIMARY,
2914 null_aligned))
175593bf 2915 continue;
a322f70c 2916
7f798aca 2917 if (!__write_ddf_structure(d, ddf, DDF_HEADER_SECONDARY,
2918 null_aligned))
175593bf 2919 continue;
a322f70c 2920
a322f70c 2921 lseek64(fd, (size-1)*512, SEEK_SET);
175593bf
DW		 2922 if (write(fd, &ddf->anchor, 512) < 0)
2923 continue;
2924 successes++;
2925 }
42d5dfd9 2926 free(null_aligned);
175593bf 2927
175593bf 2928 return attempts != successes;
a322f70c 2929}
7a7cc504
NB		 2930
2931static int write_init_super_ddf(struct supertype *st)
2932{
9b1fb677
DW		 2933 struct ddf_super *ddf = st->sb;
2934 struct vcl *currentconf = ddf->currentconf;
2935
2936 /* we are done with currentconf reset it to point st at the container */
2937 ddf->currentconf = NULL;
edd8d13c
NB		 2938
2939 if (st->update_tail) {
2940 /* queue the virtual_disk and vd_config as metadata updates */
2941 struct virtual_disk *vd;
2942 struct vd_config *vc;
c5943560 2943 int len, tlen;
2944 unsigned int i;
edd8d13c 2945
9b1fb677 2946 if (!currentconf) {
2cc2983d
N		 2947 int len = (sizeof(struct phys_disk) +
2948 sizeof(struct phys_disk_entry));
2949
2950 /* adding a disk to the container. */
2951 if (!ddf->add_list)
2952 return 0;
2953
2954 append_metadata_update(st, ddf->add_list->mdupdate, len);
2955 ddf->add_list->mdupdate = NULL;
2956 return 0;
2957 }
2958
2959 /* Newly created VD */
2960
edd8d13c
NB		 2961 /* First the virtual disk. We have a slightly fake header */
2962 len = sizeof(struct virtual_disk) + sizeof(struct virtual_entry);
503975b9 2963 vd = xmalloc(len);
edd8d13c 2964 *vd = *ddf->virt;
9b1fb677
DW		 2965 vd->entries[0] = ddf->virt->entries[currentconf->vcnum];
2966 vd->populated_vdes = __cpu_to_be16(currentconf->vcnum);
edd8d13c
NB		 2967 append_metadata_update(st, vd, len);
2968
2969 /* Then the vd_config */
2970 len = ddf->conf_rec_len * 512;
c5943560 2971 tlen = len * currentconf->conf.sec_elmnt_count;
2972 vc = xmalloc(tlen);
9b1fb677 2973 memcpy(vc, &currentconf->conf, len);
c5943560 2974 for (i = 1; i < currentconf->conf.sec_elmnt_count; i++)
2975 memcpy((char *)vc + i*len, currentconf->other_bvds[i-1],
2976 len);
2977 append_metadata_update(st, vc, tlen);
edd8d13c
NB		 2978
2979 /* FIXME I need to close the fds! */
2980 return 0;
613b0d17 2981 } else {
d682f344 2982 struct dl *d;
19041058 2983 if (!currentconf)
2984 for (d = ddf->dlist; d; d=d->next)
2985 while (Kill(d->devname, NULL, 0, -1, 1) == 0);
1cc7f4fe 2986 return __write_init_super_ddf(st);
d682f344 2987 }
7a7cc504
NB		 2988}
2989
a322f70c
DW		 2990#endif
2991
387fcd59
N		 2992static __u64 avail_size_ddf(struct supertype *st, __u64 devsize,
2993 unsigned long long data_offset)
a322f70c
DW		 2994{
2995 /* We must reserve the last 32Meg */
2996 if (devsize <= 32*1024*2)
2997 return 0;
2998 return devsize - 32*1024*2;
2999}
3000
3001#ifndef MDASSEMBLE
8592f29d
N		 3002
3003static int reserve_space(struct supertype *st, int raiddisks,
3004 unsigned long long size, int chunk,
3005 unsigned long long *freesize)
3006{
3007 /* Find 'raiddisks' spare extents at least 'size' big (but
3008 * only caring about multiples of 'chunk') and remember
3009 * them.
3010 * If the cannot be found, fail.
3011 */
3012 struct dl *dl;
3013 struct ddf_super *ddf = st->sb;
3014 int cnt = 0;
3015
3016 for (dl = ddf->dlist; dl ; dl=dl->next) {
613b0d17 3017 dl->raiddisk = -1;
8592f29d
N		 3018 dl->esize = 0;
3019 }
3020 /* Now find largest extent on each device */
3021 for (dl = ddf->dlist ; dl ; dl=dl->next) {
3022 struct extent *e = get_extents(ddf, dl);
3023 unsigned long long pos = 0;
3024 int i = 0;
3025 int found = 0;
3026 unsigned long long minsize = size;
3027
3028 if (size == 0)
3029 minsize = chunk;
3030
3031 if (!e)
3032 continue;
3033 do {
3034 unsigned long long esize;
3035 esize = e[i].start - pos;
3036 if (esize >= minsize) {
3037 found = 1;
3038 minsize = esize;
3039 }
3040 pos = e[i].start + e[i].size;
3041 i++;
3042 } while (e[i-1].size);
3043 if (found) {
3044 cnt++;
3045 dl->esize = minsize;
3046 }
3047 free(e);
3048 }
3049 if (cnt < raiddisks) {
e7b84f9d 3050 pr_err("not enough devices with space to create array.\n");
8592f29d
N		 3051 return 0; /* No enough free spaces large enough */
3052 }
3053 if (size == 0) {
3054 /* choose the largest size of which there are at least 'raiddisk' */
3055 for (dl = ddf->dlist ; dl ; dl=dl->next) {
3056 struct dl *dl2;
3057 if (dl->esize <= size)
3058 continue;
3059 /* This is bigger than 'size', see if there are enough */
3060 cnt = 0;
7b80ad6a 3061 for (dl2 = ddf->dlist; dl2 ; dl2=dl2->next)
8592f29d
N		 3062 if (dl2->esize >= dl->esize)
3063 cnt++;
3064 if (cnt >= raiddisks)
3065 size = dl->esize;
3066 }
3067 if (chunk) {
3068 size = size / chunk;
3069 size *= chunk;
3070 }
3071 *freesize = size;
3072 if (size < 32) {
e7b84f9d 3073 pr_err("not enough spare devices to create array.\n");
8592f29d
N		 3074 return 0;
3075 }
3076 }
3077 /* We have a 'size' of which there are enough spaces.
3078 * We simply do a first-fit */
3079 cnt = 0;
3080 for (dl = ddf->dlist ; dl && cnt < raiddisks ; dl=dl->next) {
3081 if (dl->esize < size)
3082 continue;
613b0d17 3083
8592f29d
N		 3084 dl->raiddisk = cnt;
3085 cnt++;
3086 }
3087 return 1;
3088}
3089
2c514b71
NB		 3090static int
3091validate_geometry_ddf_container(struct supertype *st,
3092 int level, int layout, int raiddisks,
3093 int chunk, unsigned long long size,
af4348dd 3094 unsigned long long data_offset,
2c514b71
NB		 3095 char *dev, unsigned long long *freesize,
3096 int verbose);
78e44928
NB		 3097
3098static int validate_geometry_ddf_bvd(struct supertype *st,
3099 int level, int layout, int raiddisks,
c21e737b 3100 int *chunk, unsigned long long size,
af4348dd 3101 unsigned long long data_offset,
2c514b71
NB		 3102 char *dev, unsigned long long *freesize,
3103 int verbose);
78e44928
NB		 3104
3105static int validate_geometry_ddf(struct supertype *st,
2c514b71 3106 int level, int layout, int raiddisks,
c21e737b 3107 int *chunk, unsigned long long size,
af4348dd 3108 unsigned long long data_offset,
2c514b71
NB		 3109 char *dev, unsigned long long *freesize,
3110 int verbose)
a322f70c
DW		 3111{
3112 int fd;
3113 struct mdinfo *sra;
3114 int cfd;
3115
3116 /* ddf potentially supports lots of things, but it depends on
3117 * what devices are offered (and maybe kernel version?)
3118 * If given unused devices, we will make a container.
3119 * If given devices in a container, we will make a BVD.
3120 * If given BVDs, we make an SVD, changing all the GUIDs in the process.
3121 */
3122
bb7295f1
N		 3123 if (chunk && *chunk == UnSet)
3124 *chunk = DEFAULT_CHUNK;
3125
542ef4ec 3126 if (level == -1000000) level = LEVEL_CONTAINER;
a322f70c 3127 if (level == LEVEL_CONTAINER) {
78e44928
NB		 3128 /* Must be a fresh device to add to a container */
3129 return validate_geometry_ddf_container(st, level, layout,
c21e737b 3130 raiddisks, chunk?*chunk:0,
af4348dd
N		 3131 size, data_offset, dev,
3132 freesize,
2c514b71 3133 verbose);
5f8097be
NB		 3134 }
3135
78e44928 3136 if (!dev) {
a3163bf0 3137 mdu_array_info_t array = {
3138 .level = level, .layout = layout,
3139 .raid_disks = raiddisks
3140 };
3141 struct vd_config conf;
3142 if (layout_md2ddf(&array, &conf) == -1) {
b42f577a 3143 if (verbose)
94b08b7c 3144 pr_err("DDF does not support level %d /layout %d arrays with %d disks\n",
3145 level, layout, raiddisks);
78e44928 3146 return 0;
b42f577a 3147 }
78e44928 3148 /* Should check layout? etc */
8592f29d
N		 3149
3150 if (st->sb && freesize) {
3151 /* --create was given a container to create in.
3152 * So we need to check that there are enough
3153 * free spaces and return the amount of space.
3154 * We may as well remember which drives were
3155 * chosen so that add_to_super/getinfo_super
3156 * can return them.
3157 */
c21e737b 3158 return reserve_space(st, raiddisks, size, chunk?*chunk:0, freesize);
8592f29d 3159 }
a322f70c 3160 return 1;
78e44928 3161 }
a322f70c 3162
8592f29d
N		 3163 if (st->sb) {
3164 /* A container has already been opened, so we are
3165 * creating in there. Maybe a BVD, maybe an SVD.
3166 * Should make a distinction one day.
3167 */
3168 return validate_geometry_ddf_bvd(st, level, layout, raiddisks,
af4348dd
N		 3169 chunk, size, data_offset, dev,
3170 freesize,
8592f29d
N		 3171 verbose);
3172 }
78e44928
NB		 3173 /* This is the first device for the array.
3174 * If it is a container, we read it in and do automagic allocations,
3175 * no other devices should be given.
3176 * Otherwise it must be a member device of a container, and we
3177 * do manual allocation.
3178 * Later we should check for a BVD and make an SVD.
a322f70c 3179 */
a322f70c
DW		 3180 fd = open(dev, O_RDONLY|O_EXCL, 0);
3181 if (fd >= 0) {
4dd2df09 3182 sra = sysfs_read(fd, NULL, GET_VERSION);
a322f70c
DW		 3183 close(fd);
3184 if (sra && sra->array.major_version == -1 &&
78e44928
NB		 3185 strcmp(sra->text_version, "ddf") == 0) {
3186
3187 /* load super */
3188 /* find space for 'n' devices. */
3189 /* remember the devices */
3190 /* Somehow return the fact that we have enough */
a322f70c
DW		 3191 }
3192
2c514b71 3193 if (verbose)
e7b84f9d
N		 3194 pr_err("ddf: Cannot create this array "
3195 "on device %s - a container is required.\n",
3196 dev);
a322f70c
DW		 3197 return 0;
3198 }
3199 if (errno != EBUSY || (fd = open(dev, O_RDONLY, 0)) < 0) {
2c514b71 3200 if (verbose)
e7b84f9d 3201 pr_err("ddf: Cannot open %s: %s\n",
613b0d17 3202 dev, strerror(errno));
a322f70c
DW		 3203 return 0;
3204 }
3205 /* Well, it is in use by someone, maybe a 'ddf' container. */
3206 cfd = open_container(fd);
3207 if (cfd < 0) {
3208 close(fd);
2c514b71 3209 if (verbose)
e7b84f9d 3210 pr_err("ddf: Cannot use %s: %s\n",
613b0d17 3211 dev, strerror(EBUSY));
a322f70c
DW		 3212 return 0;
3213 }
4dd2df09 3214 sra = sysfs_read(cfd, NULL, GET_VERSION);
a322f70c
DW		 3215 close(fd);
3216 if (sra && sra->array.major_version == -1 &&
3217 strcmp(sra->text_version, "ddf") == 0) {
3218 /* This is a member of a ddf container. Load the container
3219 * and try to create a bvd
3220 */
3221 struct ddf_super *ddf;
e1902a7b 3222 if (load_super_ddf_all(st, cfd, (void **)&ddf, NULL) == 0) {
5f8097be 3223 st->sb = ddf;
4dd2df09 3224 strcpy(st->container_devnm, fd2devnm(cfd));
a322f70c 3225 close(cfd);
78e44928 3226 return validate_geometry_ddf_bvd(st, level, layout,
a322f70c 3227 raiddisks, chunk, size,
af4348dd 3228 data_offset,
2c514b71
NB		 3229 dev, freesize,
3230 verbose);
a322f70c
DW		 3231 }
3232 close(cfd);
c42ec1ed
DW		 3233 } else /* device may belong to a different container */
3234 return 0;
3235
a322f70c
DW		 3236 return 1;
3237}
3238
2c514b71
NB		 3239static int
3240validate_geometry_ddf_container(struct supertype *st,
3241 int level, int layout, int raiddisks,
3242 int chunk, unsigned long long size,
af4348dd 3243 unsigned long long data_offset,
2c514b71
NB		 3244 char *dev, unsigned long long *freesize,
3245 int verbose)
a322f70c
DW		 3246{
3247 int fd;
3248 unsigned long long ldsize;
3249
3250 if (level != LEVEL_CONTAINER)
3251 return 0;
3252 if (!dev)
3253 return 1;
3254
3255 fd = open(dev, O_RDONLY|O_EXCL, 0);
3256 if (fd < 0) {
2c514b71 3257 if (verbose)
e7b84f9d 3258 pr_err("ddf: Cannot open %s: %s\n",
613b0d17 3259 dev, strerror(errno));
a322f70c
DW		 3260 return 0;
3261 }
3262 if (!get_dev_size(fd, dev, &ldsize)) {
3263 close(fd);
3264 return 0;
3265 }
3266 close(fd);
3267
387fcd59 3268 *freesize = avail_size_ddf(st, ldsize >> 9, INVALID_SECTORS);
ea17e7aa
N		 3269 if (*freesize == 0)
3270 return 0;
a322f70c
DW		 3271
3272 return 1;
3273}
3274
78e44928
NB		 3275static int validate_geometry_ddf_bvd(struct supertype *st,
3276 int level, int layout, int raiddisks,
c21e737b 3277 int *chunk, unsigned long long size,
af4348dd 3278 unsigned long long data_offset,
2c514b71
NB		 3279 char *dev, unsigned long long *freesize,
3280 int verbose)
a322f70c
DW		 3281{
3282 struct stat stb;
3283 struct ddf_super *ddf = st->sb;
3284 struct dl *dl;
5f8097be
NB		 3285 unsigned long long pos = 0;
3286 unsigned long long maxsize;
3287 struct extent *e;
3288 int i;
a322f70c 3289 /* ddf/bvd supports lots of things, but not containers */
b42f577a
N		 3290 if (level == LEVEL_CONTAINER) {
3291 if (verbose)
e7b84f9d 3292 pr_err("DDF cannot create a container within an container\n");
a322f70c 3293 return 0;
b42f577a 3294 }
a322f70c
DW		 3295 /* We must have the container info already read in. */
3296 if (!ddf)
3297 return 0;
3298
5f8097be
NB		 3299 if (!dev) {
3300 /* General test: make sure there is space for
3301 * 'raiddisks' device extents of size 'size'.
3302 */
3303 unsigned long long minsize = size;
3304 int dcnt = 0;
3305 if (minsize == 0)
3306 minsize = 8;
3307 for (dl = ddf->dlist; dl ; dl = dl->next)
3308 {
3309 int found = 0;
7e1432fb 3310 pos = 0;
5f8097be
NB		 3311
3312 i = 0;
3313 e = get_extents(ddf, dl);
3314 if (!e) continue;
3315 do {
3316 unsigned long long esize;
3317 esize = e[i].start - pos;
3318 if (esize >= minsize)
3319 found = 1;
3320 pos = e[i].start + e[i].size;
3321 i++;
3322 } while (e[i-1].size);
3323 if (found)
3324 dcnt++;
3325 free(e);
3326 }
3327 if (dcnt < raiddisks) {
2c514b71 3328 if (verbose)
e7b84f9d
N		 3329 pr_err("ddf: Not enough devices with "
3330 "space for this array (%d < %d)\n",
3331 dcnt, raiddisks);
5f8097be
NB		 3332 return 0;
3333 }
3334 return 1;
3335 }
a322f70c
DW		 3336 /* This device must be a member of the set */
3337 if (stat(dev, &stb) < 0)
3338 return 0;
3339 if ((S_IFMT & stb.st_mode) != S_IFBLK)
3340 return 0;
3341 for (dl = ddf->dlist ; dl ; dl = dl->next) {
f21e18ca
N		 3342 if (dl->major == (int)major(stb.st_rdev) &&
3343 dl->minor == (int)minor(stb.st_rdev))
a322f70c
DW		 3344 break;
3345 }
5f8097be 3346 if (!dl) {
2c514b71 3347 if (verbose)
e7b84f9d 3348 pr_err("ddf: %s is not in the "
613b0d17
N		 3349 "same DDF set\n",
3350 dev);
5f8097be
NB		 3351 return 0;
3352 }
3353 e = get_extents(ddf, dl);
3354 maxsize = 0;
3355 i = 0;
3356 if (e) do {
613b0d17
N		 3357 unsigned long long esize;
3358 esize = e[i].start - pos;
3359 if (esize >= maxsize)
3360 maxsize = esize;
3361 pos = e[i].start + e[i].size;
3362 i++;
3363 } while (e[i-1].size);
5f8097be 3364 *freesize = maxsize;
a322f70c
DW		 3365 // FIXME here I am
3366
3367 return 1;
3368}
59e36268 3369
a322f70c 3370static int load_super_ddf_all(struct supertype *st, int fd,
e1902a7b 3371 void **sbp, char *devname)
a322f70c
DW		 3372{
3373 struct mdinfo *sra;
3374 struct ddf_super *super;
3375 struct mdinfo *sd, *best = NULL;
3376 int bestseq = 0;
3377 int seq;
3378 char nm[20];
3379 int dfd;
3380
b526e52d 3381 sra = sysfs_read(fd, 0, GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE);
a322f70c
DW		 3382 if (!sra)
3383 return 1;
3384 if (sra->array.major_version != -1 ||
3385 sra->array.minor_version != -2 ||
3386 strcmp(sra->text_version, "ddf") != 0)
3387 return 1;
3388
6416d527 3389 if (posix_memalign((void**)&super, 512, sizeof(*super)) != 0)
a322f70c 3390 return 1;
a2349791 3391 memset(super, 0, sizeof(*super));
a322f70c
DW		 3392
3393 /* first, try each device, and choose the best ddf */
3394 for (sd = sra->devs ; sd ; sd = sd->next) {
3395 int rv;
3396 sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
7a7cc504
NB		 3397 dfd = dev_open(nm, O_RDONLY);
3398 if (dfd < 0)
a322f70c
DW		 3399 return 2;
3400 rv = load_ddf_headers(dfd, super, NULL);
7a7cc504 3401 close(dfd);
a322f70c
DW		 3402 if (rv == 0) {
3403 seq = __be32_to_cpu(super->active->seq);
3404 if (super->active->openflag)
3405 seq--;
3406 if (!best || seq > bestseq) {
3407 bestseq = seq;
3408 best = sd;
3409 }
3410 }
3411 }
3412 if (!best)
3413 return 1;
3414 /* OK, load this ddf */
3415 sprintf(nm, "%d:%d", best->disk.major, best->disk.minor);
3416 dfd = dev_open(nm, O_RDONLY);
7a7cc504 3417 if (dfd < 0)
a322f70c
DW		 3418 return 1;
3419 load_ddf_headers(dfd, super, NULL);
3420 load_ddf_global(dfd, super, NULL);
3421 close(dfd);
3422 /* Now we need the device-local bits */
3423 for (sd = sra->devs ; sd ; sd = sd->next) {
3d2c4fc7
DW		 3424 int rv;
3425
a322f70c 3426 sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
e1902a7b 3427 dfd = dev_open(nm, O_RDWR);
7a7cc504 3428 if (dfd < 0)
a322f70c 3429 return 2;
3d2c4fc7
DW		 3430 rv = load_ddf_headers(dfd, super, NULL);
3431 if (rv == 0)
e1902a7b 3432 rv = load_ddf_local(dfd, super, NULL, 1);
3d2c4fc7
DW		 3433 if (rv)
3434 return 1;
a322f70c 3435 }
33414a01 3436
a322f70c
DW		 3437 *sbp = super;
3438 if (st->ss == NULL) {
78e44928 3439 st->ss = &super_ddf;
a322f70c
DW		 3440 st->minor_version = 0;
3441 st->max_devs = 512;
3442 }
4dd2df09 3443 strcpy(st->container_devnm, fd2devnm(fd));
a322f70c
DW		 3444 return 0;
3445}
2b959fbf
N		 3446
3447static int load_container_ddf(struct supertype *st, int fd,
3448 char *devname)
3449{
3450 return load_super_ddf_all(st, fd, &st->sb, devname);
3451}
3452
0e600426 3453#endif /* MDASSEMBLE */
a322f70c 3454
a5c7adb3 3455static int check_secondary(const struct vcl *vc)
3456{
3457 const struct vd_config *conf = &vc->conf;
3458 int i;
3459
3460 /* The only DDF secondary RAID level md can support is
3461 * RAID 10, if the stripe sizes and Basic volume sizes
3462 * are all equal.
3463 * Other configurations could in theory be supported by exposing
3464 * the BVDs to user space and using device mapper for the secondary
3465 * mapping. So far we don't support that.
3466 */
3467
3468 __u64 sec_elements[4] = {0, 0, 0, 0};
3469#define __set_sec_seen(n) (sec_elements[(n)>>6] |= (1<<((n)&63)))
3470#define __was_sec_seen(n) ((sec_elements[(n)>>6] & (1<<((n)&63))) != 0)
3471
3472 if (vc->other_bvds == NULL) {
3473 pr_err("No BVDs for secondary RAID found\n");
3474 return -1;
3475 }
3476 if (conf->prl != DDF_RAID1) {
3477 pr_err("Secondary RAID level only supported for mirrored BVD\n");
3478 return -1;
3479 }
3480 if (conf->srl != DDF_2STRIPED && conf->srl != DDF_2SPANNED) {
3481 pr_err("Secondary RAID level %d is unsupported\n",
3482 conf->srl);
3483 return -1;
3484 }
3485 __set_sec_seen(conf->sec_elmnt_seq);
3486 for (i = 0; i < conf->sec_elmnt_count-1; i++) {
3487 const struct vd_config *bvd = vc->other_bvds[i];
3c48f7be 3488 if (bvd->sec_elmnt_seq == DDF_UNUSED_BVD)
c98567ba 3489 continue;
a5c7adb3 3490 if (bvd->srl != conf->srl) {
3491 pr_err("Inconsistent secondary RAID level across BVDs\n");
3492 return -1;
3493 }
3494 if (bvd->prl != conf->prl) {
3495 pr_err("Different RAID levels for BVDs are unsupported\n");
3496 return -1;
3497 }
3498 if (bvd->prim_elmnt_count != conf->prim_elmnt_count) {
3499 pr_err("All BVDs must have the same number of primary elements\n");
3500 return -1;
3501 }
3502 if (bvd->chunk_shift != conf->chunk_shift) {
3503 pr_err("Different strip sizes for BVDs are unsupported\n");
3504 return -1;
3505 }
3506 if (bvd->array_blocks != conf->array_blocks) {
3507 pr_err("Different BVD sizes are unsupported\n");
3508 return -1;
3509 }
3510 __set_sec_seen(bvd->sec_elmnt_seq);
3511 }
3512 for (i = 0; i < conf->sec_elmnt_count; i++) {
3513 if (!__was_sec_seen(i)) {
3514 pr_err("BVD %d is missing\n", i);
3515 return -1;
3516 }
3517 }
3518 return 0;
3519}
3520
8a38db86 3521static unsigned int get_pd_index_from_refnum(const struct vcl *vc,
4e587018 3522 __u32 refnum, unsigned int nmax,
3523 const struct vd_config **bvd,
3524 unsigned int *idx)
8a38db86 3525{
4e587018 3526 unsigned int i, j, n, sec, cnt;
3527
3528 cnt = __be16_to_cpu(vc->conf.prim_elmnt_count);
3529 sec = (vc->conf.sec_elmnt_count == 1 ? 0 : vc->conf.sec_elmnt_seq);
3530
3531 for (i = 0, j = 0 ; i < nmax ; i++) {
3532 /* j counts valid entries for this BVD */
3533 if (vc->conf.phys_refnum[i] != 0xffffffff)
3534 j++;
3535 if (vc->conf.phys_refnum[i] == refnum) {
3536 *bvd = &vc->conf;
3537 *idx = i;
3538 return sec * cnt + j - 1;
3539 }
3540 }
3541 if (vc->other_bvds == NULL)
3542 goto bad;
3543
3544 for (n = 1; n < vc->conf.sec_elmnt_count; n++) {
3545 struct vd_config *vd = vc->other_bvds[n-1];
4e587018 3546 sec = vd->sec_elmnt_seq;
3c48f7be 3547 if (sec == DDF_UNUSED_BVD)
3548 continue;
4e587018 3549 for (i = 0, j = 0 ; i < nmax ; i++) {
3550 if (vd->phys_refnum[i] != 0xffffffff)
3551 j++;
3552 if (vd->phys_refnum[i] == refnum) {
3553 *bvd = vd;
3554 *idx = i;
3555 return sec * cnt + j - 1;
3556 }
3557 }
3558 }
3559bad:
3560 *bvd = NULL;
d6e7b083 3561 return DDF_NOTFOUND;
8a38db86 3562}
3563
00bbdbda 3564static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray)
598f0d58
NB		 3565{
3566 /* Given a container loaded by load_super_ddf_all,
3567 * extract information about all the arrays into
3568 * an mdinfo tree.
3569 *
3570 * For each vcl in conflist: create an mdinfo, fill it in,
3571 * then look for matching devices (phys_refnum) in dlist
3572 * and create appropriate device mdinfo.
3573 */
3574 struct ddf_super *ddf = st->sb;
3575 struct mdinfo *rest = NULL;
3576 struct vcl *vc;
3577
3578 for (vc = ddf->conflist ; vc ; vc=vc->next)
3579 {
f21e18ca
N		 3580 unsigned int i;
3581 unsigned int j;
598f0d58 3582 struct mdinfo *this;
00bbdbda 3583 char *ep;
90fa1a29 3584 __u32 *cptr;
8a38db86 3585 unsigned int pd;
00bbdbda
N		 3586
3587 if (subarray &&
3588 (strtoul(subarray, &ep, 10) != vc->vcnum ||
3589 *ep != '\0'))
3590 continue;
3591
a5c7adb3 3592 if (vc->conf.sec_elmnt_count > 1) {
3593 if (check_secondary(vc) != 0)
3594 continue;
3595 }
3596
503975b9 3597 this = xcalloc(1, sizeof(*this));
598f0d58
NB		 3598 this->next = rest;
3599 rest = this;
3600
8a2848a7 3601 if (layout_ddf2md(&vc->conf, &this->array))
3602 continue;
598f0d58 3603 this->array.md_minor = -1;
f35f2525
N		 3604 this->array.major_version = -1;
3605 this->array.minor_version = -2;
90fa1a29
JS		 3606 cptr = (__u32 *)(vc->conf.guid + 16);
3607 this->array.ctime = DECADE + __be32_to_cpu(*cptr);
598f0d58
NB		 3608 this->array.utime = DECADE +
3609 __be32_to_cpu(vc->conf.timestamp);
3610 this->array.chunk_size = 512 << vc->conf.chunk_shift;
3611
59e36268 3612 i = vc->vcnum;
7a7cc504
NB		 3613 if ((ddf->virt->entries[i].state & DDF_state_inconsistent) ||
3614 (ddf->virt->entries[i].init_state & DDF_initstate_mask) !=
ed9d66aa 3615 DDF_init_full) {
598f0d58 3616 this->array.state = 0;
ed9d66aa
NB		 3617 this->resync_start = 0;
3618 } else {
598f0d58 3619 this->array.state = 1;
b7528a20 3620 this->resync_start = MaxSector;
ed9d66aa 3621 }
db42fa9b
N		 3622 memcpy(this->name, ddf->virt->entries[i].name, 16);
3623 this->name[16]=0;
3624 for(j=0; j<16; j++)
3625 if (this->name[j] == ' ')
3626 this->name[j] = 0;
598f0d58
NB		 3627
3628 memset(this->uuid, 0, sizeof(this->uuid));
3629 this->component_size = __be64_to_cpu(vc->conf.blocks);
3630 this->array.size = this->component_size / 2;
5f2aace8 3631 this->container_member = i;
598f0d58 3632
c5afc314
N		 3633 ddf->currentconf = vc;
3634 uuid_from_super_ddf(st, this->uuid);
f646805e 3635 if (!subarray)
3636 ddf->currentconf = NULL;
c5afc314 3637
60f18132 3638 sprintf(this->text_version, "/%s/%d",
4dd2df09 3639 st->container_devnm, this->container_member);
60f18132 3640
8a38db86 3641 for (pd = 0; pd < __be16_to_cpu(ddf->phys->used_pdes); pd++) {
598f0d58
NB		 3642 struct mdinfo *dev;
3643 struct dl *d;
4e587018 3644 const struct vd_config *bvd;
3645 unsigned int iphys;
fa033bec 3646 int stt;
598f0d58 3647
8a38db86 3648 if (ddf->phys->entries[pd].refnum == 0xFFFFFFFF)
bc17324f 3649 continue;
0cf5ef67
N		 3650
3651 stt = __be16_to_cpu(ddf->phys->entries[pd].state);
fa033bec
N		 3652 if ((stt & (DDF_Online|DDF_Failed|DDF_Rebuilding))
3653 != DDF_Online)
3654 continue;
3655
8a38db86 3656 i = get_pd_index_from_refnum(
4e587018 3657 vc, ddf->phys->entries[pd].refnum,
3658 ddf->mppe, &bvd, &iphys);
d6e7b083 3659 if (i == DDF_NOTFOUND)
8a38db86 3660 continue;
3661
fa033bec 3662 this->array.working_disks++;
bc17324f 3663
0cf5ef67 3664 for (d = ddf->dlist; d ; d=d->next)
8a38db86 3665 if (d->disk.refnum ==
3666 ddf->phys->entries[pd].refnum)
0cf5ef67
N		 3667 break;
3668 if (d == NULL)
3669 /* Haven't found that one yet, maybe there are others */
3670 continue;
3671
503975b9 3672 dev = xcalloc(1, sizeof(*dev));
598f0d58
NB		 3673 dev->next = this->devs;
3674 this->devs = dev;
3675
3676 dev->disk.number = __be32_to_cpu(d->disk.refnum);
3677 dev->disk.major = d->major;
3678 dev->disk.minor = d->minor;
3679 dev->disk.raid_disk = i;
3680 dev->disk.state = (1<<MD_DISK_SYNC)|(1<<MD_DISK_ACTIVE);
d23534e4 3681 dev->recovery_start = MaxSector;
598f0d58 3682
120f7677 3683 dev->events = __be32_to_cpu(ddf->primary.seq);
57a66662 3684 dev->data_offset =
3685 __be64_to_cpu(LBA_OFFSET(ddf, bvd)[iphys]);
4e587018 3686 dev->component_size = __be64_to_cpu(bvd->blocks);
598f0d58
NB		 3687 if (d->devname)
3688 strcpy(dev->name, d->devname);
3689 }
3690 }
3691 return rest;
3692}
3693
955e9ea1 3694static int store_super_ddf(struct supertype *st, int fd)
a322f70c 3695{
955e9ea1 3696 struct ddf_super *ddf = st->sb;
a322f70c 3697 unsigned long long dsize;
6416d527 3698 void *buf;
3d2c4fc7 3699 int rc;
a322f70c 3700
955e9ea1
DW		 3701 if (!ddf)
3702 return 1;
3703
a322f70c
DW		 3704 if (!get_dev_size(fd, NULL, &dsize))
3705 return 1;
3706
dbf98368 3707 if (ddf->dlist || ddf->conflist) {
3708 struct stat sta;
3709 struct dl *dl;
3710 int ofd, ret;
3711
3712 if (fstat(fd, &sta) == -1 || !S_ISBLK(sta.st_mode)) {
3713 pr_err("%s: file descriptor for invalid device\n",
3714 __func__);
3715 return 1;
3716 }
3717 for (dl = ddf->dlist; dl; dl = dl->next)
3718 if (dl->major == (int)major(sta.st_rdev) &&
3719 dl->minor == (int)minor(sta.st_rdev))
3720 break;
3721 if (!dl) {
3722 pr_err("%s: couldn't find disk %d/%d\n", __func__,
3723 (int)major(sta.st_rdev),
3724 (int)minor(sta.st_rdev));
3725 return 1;
3726 }
3727 /*
3728 For DDF, writing to just one disk makes no sense.
3729 We would run the risk of writing inconsistent meta data
3730 to the devices. So just call __write_init_super_ddf and
3731 write to all devices, including this one.
3732 Use the fd passed to this function, just in case dl->fd
3733 is invalid.
3734 */
3735 ofd = dl->fd;
3736 dl->fd = fd;
3737 ret = __write_init_super_ddf(st);
3738 dl->fd = ofd;
3739 return ret;
3740 }
3741
3d2c4fc7
DW		 3742 if (posix_memalign(&buf, 512, 512) != 0)
3743 return 1;
6416d527
NB		 3744 memset(buf, 0, 512);
3745
a322f70c 3746 lseek64(fd, dsize-512, 0);
3d2c4fc7 3747 rc = write(fd, buf, 512);
6416d527 3748 free(buf);
3d2c4fc7
DW		 3749 if (rc < 0)
3750 return 1;
a322f70c
DW		 3751 return 0;
3752}
3753
a19c88b8
NB		 3754static int compare_super_ddf(struct supertype *st, struct supertype *tst)
3755{
3756 /*
3757 * return:
3758 * 0 same, or first was empty, and second was copied
3759 * 1 second had wrong number
3760 * 2 wrong uuid
3761 * 3 wrong other info
3762 */
3763 struct ddf_super *first = st->sb;
3764 struct ddf_super *second = tst->sb;
4eefd651 3765 struct dl *dl1, *dl2;
3766 struct vcl *vl1, *vl2;
2d210697 3767 unsigned int max_vds, max_pds, pd, vd;
a19c88b8
NB		 3768
3769 if (!first) {
3770 st->sb = tst->sb;
3771 tst->sb = NULL;
3772 return 0;
3773 }
3774
3775 if (memcmp(first->anchor.guid, second->anchor.guid, DDF_GUID_LEN) != 0)
3776 return 2;
3777
2d210697 3778 if (first->anchor.seq != second->anchor.seq) {
3779 dprintf("%s: sequence number mismatch %u/%u\n", __func__,
3780 __be32_to_cpu(first->anchor.seq),
3781 __be32_to_cpu(second->anchor.seq));
3782 return 3;
3783 }
3784 if (first->max_part != second->max_part ||
3785 first->phys->used_pdes != second->phys->used_pdes ||
3786 first->virt->populated_vdes != second->virt->populated_vdes) {
3787 dprintf("%s: PD/VD number mismatch\n", __func__);
3788 return 3;
3789 }
3790
3791 max_pds = __be16_to_cpu(first->phys->used_pdes);
3792 for (dl2 = second->dlist; dl2; dl2 = dl2->next) {
3793 for (pd = 0; pd < max_pds; pd++)
3794 if (first->phys->entries[pd].refnum == dl2->disk.refnum)
3795 break;
3796 if (pd == max_pds) {
3797 dprintf("%s: no match for disk %08x\n", __func__,
3798 __be32_to_cpu(dl2->disk.refnum));
3799 return 3;
3800 }
3801 }
3802
3803 max_vds = __be16_to_cpu(first->active->max_vd_entries);
3804 for (vl2 = second->conflist; vl2; vl2 = vl2->next) {
3805 if (vl2->conf.magic != DDF_VD_CONF_MAGIC)
3806 continue;
3807 for (vd = 0; vd < max_vds; vd++)
3808 if (!memcmp(first->virt->entries[vd].guid,
3809 vl2->conf.guid, DDF_GUID_LEN))
3810 break;
3811 if (vd == max_vds) {
3812 dprintf("%s: no match for VD config\n", __func__);
3813 return 3;
3814 }
3815 }
a19c88b8 3816 /* FIXME should I look at anything else? */
2d210697 3817
4eefd651 3818 /*
3819 At this point we are fairly sure that the meta data matches.
3820 But the new disk may contain additional local data.
3821 Add it to the super block.
3822 */
3823 for (vl2 = second->conflist; vl2; vl2 = vl2->next) {
3824 for (vl1 = first->conflist; vl1; vl1 = vl1->next)
3825 if (!memcmp(vl1->conf.guid, vl2->conf.guid,
3826 DDF_GUID_LEN))
3827 break;
3828 if (vl1) {
3829 if (vl1->other_bvds != NULL &&
3830 vl1->conf.sec_elmnt_seq !=
3831 vl2->conf.sec_elmnt_seq) {
3832 dprintf("%s: adding BVD %u\n", __func__,
3833 vl2->conf.sec_elmnt_seq);
3834 add_other_bvd(vl1, &vl2->conf,
3835 first->conf_rec_len*512);
3836 }
3837 continue;
3838 }
3839
3840 if (posix_memalign((void **)&vl1, 512,
3841 (first->conf_rec_len*512 +
3842 offsetof(struct vcl, conf))) != 0) {
3843 pr_err("%s could not allocate vcl buf\n",
3844 __func__);
3845 return 3;
3846 }
3847
3848 vl1->next = first->conflist;
3849 vl1->block_sizes = NULL;
4eefd651 3850 memcpy(&vl1->conf, &vl2->conf, first->conf_rec_len*512);
3c48f7be 3851 if (alloc_other_bvds(first, vl1) != 0) {
3852 pr_err("%s could not allocate other bvds\n",
3853 __func__);
3854 free(vl1);
3855 return 3;
3856 }
4eefd651 3857 for (vd = 0; vd < max_vds; vd++)
3858 if (!memcmp(first->virt->entries[vd].guid,
3859 vl1->conf.guid, DDF_GUID_LEN))
3860 break;
3861 vl1->vcnum = vd;
3862 dprintf("%s: added config for VD %u\n", __func__, vl1->vcnum);
3863 first->conflist = vl1;
3864 }
3865
3866 for (dl2 = second->dlist; dl2; dl2 = dl2->next) {
3867 for (dl1 = first->dlist; dl1; dl1 = dl1->next)
3868 if (dl1->disk.refnum == dl2->disk.refnum)
3869 break;
3870 if (dl1)
3871 continue;
3872
3873 if (posix_memalign((void **)&dl1, 512,
3874 sizeof(*dl1) + (first->max_part) * sizeof(dl1->vlist[0]))
3875 != 0) {
3876 pr_err("%s could not allocate disk info buffer\n",
3877 __func__);
3878 return 3;
3879 }
3880 memcpy(dl1, dl2, sizeof(*dl1));
3881 dl1->mdupdate = NULL;
3882 dl1->next = first->dlist;
3883 dl1->fd = -1;
3884 for (pd = 0; pd < max_pds; pd++)
3885 if (first->phys->entries[pd].refnum == dl1->disk.refnum)
3886 break;
3887 dl1->pdnum = pd;
3888 if (dl2->spare) {
3889 if (posix_memalign((void **)&dl1->spare, 512,
3890 first->conf_rec_len*512) != 0) {
3891 pr_err("%s could not allocate spare info buf\n",
3892 __func__);
3893 return 3;
3894 }
3895 memcpy(dl1->spare, dl2->spare, first->conf_rec_len*512);
3896 }
3897 for (vd = 0 ; vd < first->max_part ; vd++) {
3898 if (!dl2->vlist[vd]) {
3899 dl1->vlist[vd] = NULL;
3900 continue;
3901 }
3902 for (vl1 = first->conflist; vl1; vl1 = vl1->next) {
3903 if (!memcmp(vl1->conf.guid,
3904 dl2->vlist[vd]->conf.guid,
3905 DDF_GUID_LEN))
3906 break;
3907 dl1->vlist[vd] = vl1;
3908 }
3909 }
3910 first->dlist = dl1;
3911 dprintf("%s: added disk %d: %08x\n", __func__, dl1->pdnum,
ad60eea1 3912 __be32_to_cpu(dl1->disk.refnum));
4eefd651 3913 }
3914
a19c88b8
NB		 3915 return 0;
3916}
3917
0e600426 3918#ifndef MDASSEMBLE
4e5528c6
NB		 3919/*
3920 * A new array 'a' has been started which claims to be instance 'inst'
3921 * within container 'c'.
3922 * We need to confirm that the array matches the metadata in 'c' so
3923 * that we don't corrupt any metadata.
3924 */
cba0191b 3925static int ddf_open_new(struct supertype *c, struct active_array *a, char *inst)
549e9569 3926{
a2aa439e 3927 struct ddf_super *ddf = c->sb;
3928 int n = atoi(inst);
fb9d0acb 3929 if (all_ff(ddf->virt->entries[n].guid)) {
3930 pr_err("%s: subarray %d doesn't exist\n", __func__, n);
a2aa439e 3931 return -ENODEV;
3932 }
3933 dprintf("ddf: open_new %d\n", n);
3934 a->info.container_member = n;
549e9569
NB		 3935 return 0;
3936}
3937
4e5528c6
NB		 3938/*
3939 * The array 'a' is to be marked clean in the metadata.
ed9d66aa 3940 * If '->resync_start' is not ~(unsigned long long)0, then the array is only
4e5528c6
NB		 3941 * clean up to the point (in sectors). If that cannot be recorded in the
3942 * metadata, then leave it as dirty.
3943 *
3944 * For DDF, we need to clear the DDF_state_inconsistent bit in the
3945 * !global! virtual_disk.virtual_entry structure.
3946 */
01f157d7 3947static int ddf_set_array_state(struct active_array *a, int consistent)
549e9569 3948{
4e5528c6
NB		 3949 struct ddf_super *ddf = a->container->sb;
3950 int inst = a->info.container_member;
18a2f463 3951 int old = ddf->virt->entries[inst].state;
01f157d7
N		 3952 if (consistent == 2) {
3953 /* Should check if a recovery should be started FIXME */
3954 consistent = 1;
b7941fd6 3955 if (!is_resync_complete(&a->info))
01f157d7
N		 3956 consistent = 0;
3957 }
ed9d66aa
NB		 3958 if (consistent)
3959 ddf->virt->entries[inst].state &= ~DDF_state_inconsistent;
3960 else
4e5528c6 3961 ddf->virt->entries[inst].state |= DDF_state_inconsistent;
18a2f463 3962 if (old != ddf->virt->entries[inst].state)
7d5a7ff3 3963 ddf_set_updates_pending(ddf);
18a2f463
NB		 3964
3965 old = ddf->virt->entries[inst].init_state;
ed9d66aa 3966 ddf->virt->entries[inst].init_state &= ~DDF_initstate_mask;
b7941fd6 3967 if (is_resync_complete(&a->info))
ed9d66aa 3968 ddf->virt->entries[inst].init_state |= DDF_init_full;
b7941fd6 3969 else if (a->info.resync_start == 0)
ed9d66aa 3970 ddf->virt->entries[inst].init_state |= DDF_init_not;
4e5528c6 3971 else
ed9d66aa 3972 ddf->virt->entries[inst].init_state |= DDF_init_quick;
18a2f463 3973 if (old != ddf->virt->entries[inst].init_state)
7d5a7ff3 3974 ddf_set_updates_pending(ddf);
ed9d66aa 3975
b27336a2 3976 dprintf("ddf mark %d/%s (%d) %s %llu\n", inst,
3977 guid_str(ddf->virt->entries[inst].guid), a->curr_state,
3978 consistent?"clean":"dirty",
b7941fd6 3979 a->info.resync_start);
01f157d7 3980 return consistent;
fd7cde1b
DW		 3981}
3982
5ec636b7 3983static int get_bvd_state(const struct ddf_super *ddf,
3984 const struct vd_config *vc)
3985{
3986 unsigned int i, n_bvd, working = 0;
3987 unsigned int n_prim = __be16_to_cpu(vc->prim_elmnt_count);
3988 int pd, st, state;
3989 for (i = 0; i < n_prim; i++) {
3990 if (!find_index_in_bvd(ddf, vc, i, &n_bvd))
3991 continue;
3992 pd = find_phys(ddf, vc->phys_refnum[n_bvd]);
3993 if (pd < 0)
3994 continue;
3995 st = __be16_to_cpu(ddf->phys->entries[pd].state);
3996 if ((st & (DDF_Online|DDF_Failed|DDF_Rebuilding))
3997 == DDF_Online)
3998 working++;
3999 }
4000
4001 state = DDF_state_degraded;
4002 if (working == n_prim)
4003 state = DDF_state_optimal;
4004 else
4005 switch (vc->prl) {
4006 case DDF_RAID0:
4007 case DDF_CONCAT:
4008 case DDF_JBOD:
4009 state = DDF_state_failed;
4010 break;
4011 case DDF_RAID1:
4012 if (working == 0)
4013 state = DDF_state_failed;
4014 else if (working >= 2)
4015 state = DDF_state_part_optimal;
4016 break;
4017 case DDF_RAID4:
4018 case DDF_RAID5:
4019 if (working < n_prim - 1)
4020 state = DDF_state_failed;
4021 break;
4022 case DDF_RAID6:
4023 if (working < n_prim - 2)
4024 state = DDF_state_failed;
4025 else if (working == n_prim - 1)
4026 state = DDF_state_part_optimal;
4027 break;
4028 }
4029 return state;
4030}
4031
0777d17d 4032static int secondary_state(int state, int other, int seclevel)
4033{
4034 if (state == DDF_state_optimal && other == DDF_state_optimal)
4035 return DDF_state_optimal;
4036 if (seclevel == DDF_2MIRRORED) {
4037 if (state == DDF_state_optimal || other == DDF_state_optimal)
4038 return DDF_state_part_optimal;
4039 if (state == DDF_state_failed && other == DDF_state_failed)
4040 return DDF_state_failed;
4041 return DDF_state_degraded;
4042 } else {
4043 if (state == DDF_state_failed || other == DDF_state_failed)
4044 return DDF_state_failed;
4045 if (state == DDF_state_degraded || other == DDF_state_degraded)
4046 return DDF_state_degraded;
4047 return DDF_state_part_optimal;
4048 }
4049}
4050
4051static int get_svd_state(const struct ddf_super *ddf, const struct vcl *vcl)
4052{
4053 int state = get_bvd_state(ddf, &vcl->conf);
4054 unsigned int i;
4055 for (i = 1; i < vcl->conf.sec_elmnt_count; i++) {
4056 state = secondary_state(
4057 state,
4058 get_bvd_state(ddf, vcl->other_bvds[i-1]),
4059 vcl->conf.srl);
4060 }
4061 return state;
4062}
4063
7a7cc504
NB		 4064/*
4065 * The state of each disk is stored in the global phys_disk structure
4066 * in phys_disk.entries[n].state.
4067 * This makes various combinations awkward.
4068 * - When a device fails in any array, it must be failed in all arrays
4069 * that include a part of this device.
4070 * - When a component is rebuilding, we cannot include it officially in the
4071 * array unless this is the only array that uses the device.
4072 *
4073 * So: when transitioning:
4074 * Online -> failed, just set failed flag. monitor will propagate
4075 * spare -> online, the device might need to be added to the array.
4076 * spare -> failed, just set failed. Don't worry if in array or not.
4077 */
8d45d196 4078static void ddf_set_disk(struct active_array *a, int n, int state)
549e9569 4079{
7a7cc504 4080 struct ddf_super *ddf = a->container->sb;
baba3f4e 4081 unsigned int inst = a->info.container_member, n_bvd;
4082 struct vcl *vcl;
4083 struct vd_config *vc = find_vdcr(ddf, inst, (unsigned int)n,
4084 &n_bvd, &vcl);
4085 int pd;
e1316fab
N		 4086 struct mdinfo *mdi;
4087 struct dl *dl;
7a7cc504
NB		 4088
4089 if (vc == NULL) {
2c514b71 4090 dprintf("ddf: cannot find instance %d!!\n", inst);
7a7cc504
NB		 4091 return;
4092 }
e1316fab
N		 4093 /* Find the matching slot in 'info'. */
4094 for (mdi = a->info.devs; mdi; mdi = mdi->next)
4095 if (mdi->disk.raid_disk == n)
4096 break;
4097 if (!mdi)
4098 return;
4099
4100 /* and find the 'dl' entry corresponding to that. */
4101 for (dl = ddf->dlist; dl; dl = dl->next)
77632af9
N		 4102 if (mdi->state_fd >= 0 &&
4103 mdi->disk.major == dl->major &&
e1316fab
N		 4104 mdi->disk.minor == dl->minor)
4105 break;
4106 if (!dl)
4107 return;
4108
baba3f4e 4109 pd = find_phys(ddf, vc->phys_refnum[n_bvd]);
e1316fab
N		 4110 if (pd < 0 || pd != dl->pdnum) {
4111 /* disk doesn't currently exist or has changed.
4112 * If it is now in_sync, insert it. */
baba3f4e 4113 dprintf("%s: phys disk not found for %d: %d/%d ref %08x\n",
4114 __func__, dl->pdnum, dl->major, dl->minor,
ad60eea1 4115 __be32_to_cpu(dl->disk.refnum));
baba3f4e 4116 dprintf("%s: array %u disk %u ref %08x pd %d\n",
4117 __func__, inst, n_bvd, vc->phys_refnum[n_bvd], pd);
7a7cc504 4118 if ((state & DS_INSYNC) && ! (state & DS_FAULTY)) {
baba3f4e 4119 pd = dl->pdnum; /* FIXME: is this really correct ? */
4120 vc->phys_refnum[n_bvd] = dl->disk.refnum;
57a66662 4121 LBA_OFFSET(ddf, vc)[n_bvd] =
4122 __cpu_to_be64(mdi->data_offset);
e1316fab
N		 4123 ddf->phys->entries[pd].type &=
4124 ~__cpu_to_be16(DDF_Global_Spare);
4125 ddf->phys->entries[pd].type |=
4126 __cpu_to_be16(DDF_Active_in_VD);
7d5a7ff3 4127 ddf_set_updates_pending(ddf);
7a7cc504
NB		 4128 }
4129 } else {
18a2f463 4130 int old = ddf->phys->entries[pd].state;
7a7cc504
NB		 4131 if (state & DS_FAULTY)
4132 ddf->phys->entries[pd].state |= __cpu_to_be16(DDF_Failed);
4133 if (state & DS_INSYNC) {
4134 ddf->phys->entries[pd].state |= __cpu_to_be16(DDF_Online);
4135 ddf->phys->entries[pd].state &= __cpu_to_be16(~DDF_Rebuilding);
4136 }
18a2f463 4137 if (old != ddf->phys->entries[pd].state)
7d5a7ff3 4138 ddf_set_updates_pending(ddf);
7a7cc504
NB		 4139 }
4140
2c514b71 4141 dprintf("ddf: set_disk %d to %x\n", n, state);
7e1432fb 4142
7a7cc504
NB		 4143 /* Now we need to check the state of the array and update
4144 * virtual_disk.entries[n].state.
4145 * It needs to be one of "optimal", "degraded", "failed".
4146 * I don't understand 'deleted' or 'missing'.
4147 */
0777d17d 4148 state = get_svd_state(ddf, vcl);
7a7cc504 4149
18a2f463
NB		 4150 if (ddf->virt->entries[inst].state !=
4151 ((ddf->virt->entries[inst].state & ~DDF_state_mask)
4152 | state)) {
4153
4154 ddf->virt->entries[inst].state =
4155 (ddf->virt->entries[inst].state & ~DDF_state_mask)
4156 | state;
7d5a7ff3 4157 ddf_set_updates_pending(ddf);
18a2f463 4158 }
7a7cc504 4159
549e9569
NB		 4160}
4161
2e735d19 4162static void ddf_sync_metadata(struct supertype *st)
549e9569 4163{
7a7cc504
NB		 4164
4165 /*
4166 * Write all data to all devices.
4167 * Later, we might be able to track whether only local changes
4168 * have been made, or whether any global data has been changed,
4169 * but ddf is sufficiently weird that it probably always
4170 * changes global data ....
4171 */
18a2f463
NB		 4172 struct ddf_super *ddf = st->sb;
4173 if (!ddf->updates_pending)
4174 return;
4175 ddf->updates_pending = 0;
1cc7f4fe 4176 __write_init_super_ddf(st);
2c514b71 4177 dprintf("ddf: sync_metadata\n");
549e9569
NB		 4178}
4179
f646805e 4180static int del_from_conflist(struct vcl **list, const char *guid)
4181{
4182 struct vcl **p;
4183 int found = 0;
4184 for (p = list; p && *p; p = &((*p)->next))
4185 if (!memcmp((*p)->conf.guid, guid, DDF_GUID_LEN)) {
4186 found = 1;
4187 *p = (*p)->next;
4188 }
4189 return found;
4190}
4191
4192static int _kill_subarray_ddf(struct ddf_super *ddf, const char *guid)
4193{
4194 struct dl *dl;
4195 unsigned int vdnum, i;
4196 vdnum = find_vde_by_guid(ddf, guid);
4197 if (vdnum == DDF_NOTFOUND) {
4198 pr_err("%s: could not find VD %s\n", __func__,
4199 guid_str(guid));
4200 return -1;
4201 }
4202 if (del_from_conflist(&ddf->conflist, guid) == 0) {
4203 pr_err("%s: could not find conf %s\n", __func__,
4204 guid_str(guid));
4205 return -1;
4206 }
4207 for (dl = ddf->dlist; dl; dl = dl->next)
4208 for (i = 0; i < ddf->max_part; i++)
4209 if (dl->vlist[i] != NULL &&
4210 !memcmp(dl->vlist[i]->conf.guid, guid,
4211 DDF_GUID_LEN))
4212 dl->vlist[i] = NULL;
4213 memset(ddf->virt->entries[vdnum].guid, 0xff, DDF_GUID_LEN);
4214 dprintf("%s: deleted %s\n", __func__, guid_str(guid));
4215 return 0;
4216}
4217
4218static int kill_subarray_ddf(struct supertype *st)
4219{
4220 struct ddf_super *ddf = st->sb;
4221 /*
4222 * currentconf is set in container_content_ddf,
4223 * called with subarray arg
4224 */
4225 struct vcl *victim = ddf->currentconf;
4226 struct vd_config *conf;
4227 ddf->currentconf = NULL;
4228 unsigned int vdnum;
4229 if (!victim) {
4230 pr_err("%s: nothing to kill\n", __func__);
4231 return -1;
4232 }
4233 conf = &victim->conf;
4234 vdnum = find_vde_by_guid(ddf, conf->guid);
4235 if (vdnum == DDF_NOTFOUND) {
4236 pr_err("%s: could not find VD %s\n", __func__,
4237 guid_str(conf->guid));
4238 return -1;
4239 }
4240 if (st->update_tail) {
4241 struct virtual_disk *vd;
4242 int len = sizeof(struct virtual_disk)
4243 + sizeof(struct virtual_entry);
4244 vd = xmalloc(len);
4245 if (vd == NULL) {
4246 pr_err("%s: failed to allocate %d bytes\n", __func__,
4247 len);
4248 return -1;
4249 }
4250 memset(vd, 0 , len);
4251 vd->magic = DDF_VIRT_RECORDS_MAGIC;
4252 vd->populated_vdes = 0;
4253 memcpy(vd->entries[0].guid, conf->guid, DDF_GUID_LEN);
4254 /* we use DDF_state_deleted as marker */
4255 vd->entries[0].state = DDF_state_deleted;
4256 append_metadata_update(st, vd, len);
4257 } else
4258 _kill_subarray_ddf(ddf, conf->guid);
4259 return 0;
4260}
4261
c5943560 4262static void copy_matching_bvd(struct ddf_super *ddf,
4263 struct vd_config *conf,
4264 const struct metadata_update *update)
4265{
4266 unsigned int mppe =
4267 __be16_to_cpu(ddf->anchor.max_primary_element_entries);
4268 unsigned int len = ddf->conf_rec_len * 512;
4269 char *p;
4270 struct vd_config *vc;
4271 for (p = update->buf; p < update->buf + update->len; p += len) {
4272 vc = (struct vd_config *) p;
4273 if (vc->sec_elmnt_seq == conf->sec_elmnt_seq) {
4274 memcpy(conf->phys_refnum, vc->phys_refnum,
4275 mppe * (sizeof(__u32) + sizeof(__u64)));
4276 return;
4277 }
4278 }
4279 pr_err("%s: no match for BVD %d of %s in update\n", __func__,
4280 conf->sec_elmnt_seq, guid_str(conf->guid));
4281}
4282
88c164f4
NB		 4283static void ddf_process_update(struct supertype *st,
4284 struct metadata_update *update)
4285{
4286 /* Apply this update to the metadata.
4287 * The first 4 bytes are a DDF_*_MAGIC which guides
4288 * our actions.
4289 * Possible update are:
4290 * DDF_PHYS_RECORDS_MAGIC
4dd968cc
N		 4291 * Add a new physical device or remove an old one.
4292 * Changes to this record only happen implicitly.
88c164f4
NB		 4293 * used_pdes is the device number.
4294 * DDF_VIRT_RECORDS_MAGIC
4295 * Add a new VD. Possibly also change the 'access' bits.
4296 * populated_vdes is the entry number.
4297 * DDF_VD_CONF_MAGIC
4298 * New or updated VD. the VIRT_RECORD must already
4299 * exist. For an update, phys_refnum and lba_offset
4300 * (at least) are updated, and the VD_CONF must
4301 * be written to precisely those devices listed with
4302 * a phys_refnum.
4303 * DDF_SPARE_ASSIGN_MAGIC
4304 * replacement Spare Assignment Record... but for which device?
4305 *
4306 * So, e.g.:
4307 * - to create a new array, we send a VIRT_RECORD and
4308 * a VD_CONF. Then assemble and start the array.
4309 * - to activate a spare we send a VD_CONF to add the phys_refnum
4310 * and offset. This will also mark the spare as active with
4311 * a spare-assignment record.
4312 */
4313 struct ddf_super *ddf = st->sb;
4314 __u32 *magic = (__u32*)update->buf;
4315 struct phys_disk *pd;
4316 struct virtual_disk *vd;
4317 struct vd_config *vc;
4318 struct vcl *vcl;
4319 struct dl *dl;
f21e18ca 4320 unsigned int ent;
c5943560 4321 unsigned int pdnum, pd2, len;
88c164f4 4322
2c514b71 4323 dprintf("Process update %x\n", *magic);
7e1432fb 4324
88c164f4
NB		 4325 switch (*magic) {
4326 case DDF_PHYS_RECORDS_MAGIC:
4327
4328 if (update->len != (sizeof(struct phys_disk) +
4329 sizeof(struct phys_disk_entry)))
4330 return;
4331 pd = (struct phys_disk*)update->buf;
4332
4333 ent = __be16_to_cpu(pd->used_pdes);
4334 if (ent >= __be16_to_cpu(ddf->phys->max_pdes))
4335 return;
4dd968cc
N		 4336 if (pd->entries[0].state & __cpu_to_be16(DDF_Missing)) {
4337 struct dl **dlp;
4338 /* removing this disk. */
4339 ddf->phys->entries[ent].state |= __cpu_to_be16(DDF_Missing);
4340 for (dlp = &ddf->dlist; *dlp; dlp = &(*dlp)->next) {
4341 struct dl *dl = *dlp;
4342 if (dl->pdnum == (signed)ent) {
4343 close(dl->fd);
4344 dl->fd = -1;
4345 /* FIXME this doesn't free
4346 * dl->devname */
4347 update->space = dl;
4348 *dlp = dl->next;
4349 break;
4350 }
4351 }
7d5a7ff3 4352 ddf_set_updates_pending(ddf);
4dd968cc
N		 4353 return;
4354 }
88c164f4
NB		 4355 if (!all_ff(ddf->phys->entries[ent].guid))
4356 return;
4357 ddf->phys->entries[ent] = pd->entries[0];
4358 ddf->phys->used_pdes = __cpu_to_be16(1 +
613b0d17 4359 __be16_to_cpu(ddf->phys->used_pdes));
7d5a7ff3 4360 ddf_set_updates_pending(ddf);
2cc2983d
N		 4361 if (ddf->add_list) {
4362 struct active_array *a;
4363 struct dl *al = ddf->add_list;
4364 ddf->add_list = al->next;
4365
4366 al->next = ddf->dlist;
4367 ddf->dlist = al;
4368
4369 /* As a device has been added, we should check
4370 * for any degraded devices that might make
4371 * use of this spare */
4372 for (a = st->arrays ; a; a=a->next)
4373 a->check_degraded = 1;
4374 }
88c164f4
NB		 4375 break;
4376
4377 case DDF_VIRT_RECORDS_MAGIC:
4378
4379 if (update->len != (sizeof(struct virtual_disk) +
4380 sizeof(struct virtual_entry)))
4381 return;
4382 vd = (struct virtual_disk*)update->buf;
4383
f646805e 4384 if (vd->entries[0].state == DDF_state_deleted) {
4385 if (_kill_subarray_ddf(ddf, vd->entries[0].guid))
4386 return;
4387 } else {
4388
6a7e7ecc 4389 ent = find_vde_by_guid(ddf, vd->entries[0].guid);
4390 if (ent != DDF_NOTFOUND) {
4391 dprintf("%s: VD %s exists already in slot %d\n",
4392 __func__, guid_str(vd->entries[0].guid),
4393 ent);
4394 return;
4395 }
f646805e 4396 ent = find_unused_vde(ddf);
4397 if (ent == DDF_NOTFOUND)
4398 return;
4399 ddf->virt->entries[ent] = vd->entries[0];
4400 ddf->virt->populated_vdes =
4401 __cpu_to_be16(
4402 1 + __be16_to_cpu(
4403 ddf->virt->populated_vdes));
ed5ff7a2 4404 dprintf("%s: added VD %s in slot %d(s=%02x i=%02x)\n",
4405 __func__, guid_str(vd->entries[0].guid), ent,
4406 ddf->virt->entries[ent].state,
4407 ddf->virt->entries[ent].init_state);
f646805e 4408 }
7d5a7ff3 4409 ddf_set_updates_pending(ddf);
88c164f4
NB		 4410 break;
4411
4412 case DDF_VD_CONF_MAGIC:
88c164f4 4413 vc = (struct vd_config*)update->buf;
c5943560 4414 len = ddf->conf_rec_len * 512;
4415 if ((unsigned int)update->len != len * vc->sec_elmnt_count) {
4416 pr_err("%s: %s: insufficient data (%d) for %u BVDs\n",
4417 __func__, guid_str(vc->guid), update->len,
4418 vc->sec_elmnt_count);
4419 return;
4420 }
88c164f4
NB		 4421 for (vcl = ddf->conflist; vcl ; vcl = vcl->next)
4422 if (memcmp(vcl->conf.guid, vc->guid, DDF_GUID_LEN) == 0)
4423 break;
ed5ff7a2 4424 dprintf("%s: conf update for %s (%s)\n", __func__,
4425 guid_str(vc->guid), (vcl ? "old" : "new"));
88c164f4
NB		 4426 if (vcl) {
4427 /* An update, just copy the phys_refnum and lba_offset
4428 * fields
4429 */
c5943560 4430 unsigned int i;
4431 copy_matching_bvd(ddf, &vcl->conf, update);
4432 for (i = 1; i < vc->sec_elmnt_count; i++)
4433 copy_matching_bvd(ddf, vcl->other_bvds[i-1],
4434 update);
88c164f4
NB		 4435 } else {
4436 /* A new VD_CONF */
c5943560 4437 unsigned int i;
e6b9548d
DW		 4438 if (!update->space)
4439 return;
88c164f4
NB		 4440 vcl = update->space;
4441 update->space = NULL;
4442 vcl->next = ddf->conflist;
c5943560 4443 memcpy(&vcl->conf, vc, len);
fb9d0acb 4444 ent = find_vde_by_guid(ddf, vc->guid);
4445 if (ent == DDF_NOTFOUND)
4446 return;
4447 vcl->vcnum = ent;
88c164f4 4448 ddf->conflist = vcl;
c5943560 4449 for (i = 1; i < vc->sec_elmnt_count; i++)
4450 memcpy(vcl->other_bvds[i-1],
4451 update->buf + len * i, len);
88c164f4 4452 }
c7079c84
N		 4453 /* Set DDF_Transition on all Failed devices - to help
4454 * us detect those that are no longer in use
4455 */
4456 for (pdnum = 0; pdnum < __be16_to_cpu(ddf->phys->used_pdes); pdnum++)
4457 if (ddf->phys->entries[pdnum].state
4458 & __be16_to_cpu(DDF_Failed))
4459 ddf->phys->entries[pdnum].state
4460 |= __be16_to_cpu(DDF_Transition);
88c164f4
NB		 4461 /* Now make sure vlist is correct for each dl. */
4462 for (dl = ddf->dlist; dl; dl = dl->next) {
f21e18ca 4463 unsigned int vn = 0;
8401644c 4464 int in_degraded = 0;
5838fccd 4465 for (vcl = ddf->conflist; vcl ; vcl = vcl->next) {
4466 unsigned int dn, ibvd;
4467 const struct vd_config *conf;
4468 int vstate;
4469 dn = get_pd_index_from_refnum(vcl,
4470 dl->disk.refnum,
4471 ddf->mppe,
4472 &conf, &ibvd);
4473 if (dn == DDF_NOTFOUND)
4474 continue;
4475 dprintf("dev %d/%08x has %s (sec=%u) at %d\n",
ad60eea1 4476 dl->pdnum,
4477 __be32_to_cpu(dl->disk.refnum),
5838fccd 4478 guid_str(conf->guid),
4479 conf->sec_elmnt_seq, vn);
4480 /* Clear the Transition flag */
4481 if (ddf->phys->entries[dl->pdnum].state
4482 & __be16_to_cpu(DDF_Failed))
4483 ddf->phys->entries[dl->pdnum].state &=
4484 ~__be16_to_cpu(DDF_Transition);
4485 dl->vlist[vn++] = vcl;
4486 vstate = ddf->virt->entries[vcl->vcnum].state
4487 & DDF_state_mask;
4488 if (vstate == DDF_state_degraded ||
4489 vstate == DDF_state_part_optimal)
4490 in_degraded = 1;
4491 }
88c164f4
NB		 4492 while (vn < ddf->max_part)
4493 dl->vlist[vn++] = NULL;
7e1432fb
NB		 4494 if (dl->vlist[0]) {
4495 ddf->phys->entries[dl->pdnum].type &=
4496 ~__cpu_to_be16(DDF_Global_Spare);
8401644c
N		 4497 if (!(ddf->phys->entries[dl->pdnum].type &
4498 __cpu_to_be16(DDF_Active_in_VD))) {
613b0d17
N		 4499 ddf->phys->entries[dl->pdnum].type |=
4500 __cpu_to_be16(DDF_Active_in_VD);
4501 if (in_degraded)
4502 ddf->phys->entries[dl->pdnum].state |=
4503 __cpu_to_be16(DDF_Rebuilding);
4504 }
7e1432fb
NB		 4505 }
4506 if (dl->spare) {
4507 ddf->phys->entries[dl->pdnum].type &=
4508 ~__cpu_to_be16(DDF_Global_Spare);
4509 ddf->phys->entries[dl->pdnum].type |=
4510 __cpu_to_be16(DDF_Spare);
4511 }
4512 if (!dl->vlist[0] && !dl->spare) {
4513 ddf->phys->entries[dl->pdnum].type |=
4514 __cpu_to_be16(DDF_Global_Spare);
4515 ddf->phys->entries[dl->pdnum].type &=
4516 ~__cpu_to_be16(DDF_Spare |
4517 DDF_Active_in_VD);
4518 }
88c164f4 4519 }
c7079c84
N		 4520
4521 /* Now remove any 'Failed' devices that are not part
4522 * of any VD. They will have the Transition flag set.
4523 * Once done, we need to update all dl->pdnum numbers.
4524 */
4525 pd2 = 0;
4526 for (pdnum = 0; pdnum < __be16_to_cpu(ddf->phys->used_pdes); pdnum++)
4527 if ((ddf->phys->entries[pdnum].state
4528 & __be16_to_cpu(DDF_Failed))
4529 && (ddf->phys->entries[pdnum].state
4530 & __be16_to_cpu(DDF_Transition)))
4531 /* skip this one */;
4532 else if (pdnum == pd2)
4533 pd2++;
4534 else {
4535 ddf->phys->entries[pd2] = ddf->phys->entries[pdnum];
4536 for (dl = ddf->dlist; dl; dl = dl->next)
4537 if (dl->pdnum == (int)pdnum)
4538 dl->pdnum = pd2;
4539 pd2++;
4540 }
4541 ddf->phys->used_pdes = __cpu_to_be16(pd2);
4542 while (pd2 < pdnum) {
4543 memset(ddf->phys->entries[pd2].guid, 0xff, DDF_GUID_LEN);
4544 pd2++;
4545 }
4546
7d5a7ff3 4547 ddf_set_updates_pending(ddf);
88c164f4
NB		 4548 break;
4549 case DDF_SPARE_ASSIGN_MAGIC:
4550 default: break;
4551 }
4552}
4553
edd8d13c
NB		 4554static void ddf_prepare_update(struct supertype *st,
4555 struct metadata_update *update)
4556{
4557 /* This update arrived at managemon.
4558 * We are about to pass it to monitor.
4559 * If a malloc is needed, do it here.
4560 */
4561 struct ddf_super *ddf = st->sb;
4562 __u32 *magic = (__u32*)update->buf;
c5943560 4563 if (*magic == DDF_VD_CONF_MAGIC) {
4564 struct vcl *vcl;
4565 struct vd_config *conf = (struct vd_config *) update->buf;
e6b9548d 4566 if (posix_memalign(&update->space, 512,
613b0d17 4567 offsetof(struct vcl, conf)
c5943560 4568 + ddf->conf_rec_len * 512) != 0) {
4569 update->space = NULL;
4570 return;
4571 }
4572 vcl = update->space;
4573 vcl->conf.sec_elmnt_count = conf->sec_elmnt_count;
4574 if (alloc_other_bvds(ddf, vcl) != 0) {
4575 free(update->space);
e6b9548d 4576 update->space = NULL;
c5943560 4577 }
4578 }
edd8d13c
NB		 4579}
4580
7e1432fb
NB		 4581/*
4582 * Check if the array 'a' is degraded but not failed.
4583 * If it is, find as many spares as are available and needed and
4584 * arrange for their inclusion.
4585 * We only choose devices which are not already in the array,
4586 * and prefer those with a spare-assignment to this array.
4587 * otherwise we choose global spares - assuming always that
4588 * there is enough room.
4589 * For each spare that we assign, we return an 'mdinfo' which
4590 * describes the position for the device in the array.
4591 * We also add to 'updates' a DDF_VD_CONF_MAGIC update with
4592 * the new phys_refnum and lba_offset values.
4593 *
4594 * Only worry about BVDs at the moment.
4595 */
4596static struct mdinfo *ddf_activate_spare(struct active_array *a,
4597 struct metadata_update **updates)
4598{
4599 int working = 0;
4600 struct mdinfo *d;
4601 struct ddf_super *ddf = a->container->sb;
4602 int global_ok = 0;
4603 struct mdinfo *rv = NULL;
4604 struct mdinfo *di;
4605 struct metadata_update *mu;
4606 struct dl *dl;
4607 int i;
baba3f4e 4608 struct vcl *vcl;
7e1432fb 4609 struct vd_config *vc;
baba3f4e 4610 unsigned int n_bvd;
7e1432fb 4611
7e1432fb
NB		 4612 for (d = a->info.devs ; d ; d = d->next) {
4613 if ((d->curr_state & DS_FAULTY) &&
613b0d17 4614 d->state_fd >= 0)
7e1432fb
NB		 4615 /* wait for Removal to happen */
4616 return NULL;
4617 if (d->state_fd >= 0)
4618 working ++;
4619 }
4620
2c514b71
NB		 4621 dprintf("ddf_activate: working=%d (%d) level=%d\n", working, a->info.array.raid_disks,
4622 a->info.array.level);
7e1432fb
NB		 4623 if (working == a->info.array.raid_disks)
4624 return NULL; /* array not degraded */
4625 switch (a->info.array.level) {
4626 case 1:
4627 if (working == 0)
4628 return NULL; /* failed */
4629 break;
4630 case 4:
4631 case 5:
4632 if (working < a->info.array.raid_disks - 1)
4633 return NULL; /* failed */
4634 break;
4635 case 6:
4636 if (working < a->info.array.raid_disks - 2)
4637 return NULL; /* failed */
4638 break;
4639 default: /* concat or stripe */
4640 return NULL; /* failed */
4641 }
4642
4643 /* For each slot, if it is not working, find a spare */
4644 dl = ddf->dlist;
4645 for (i = 0; i < a->info.array.raid_disks; i++) {
4646 for (d = a->info.devs ; d ; d = d->next)
4647 if (d->disk.raid_disk == i)
4648 break;
2c514b71 4649 dprintf("found %d: %p %x\n", i, d, d?d->curr_state:0);
7e1432fb
NB		 4650 if (d && (d->state_fd >= 0))
4651 continue;
4652
4653 /* OK, this device needs recovery. Find a spare */
4654 again:
4655 for ( ; dl ; dl = dl->next) {
4656 unsigned long long esize;
4657 unsigned long long pos;
4658 struct mdinfo *d2;
4659 int is_global = 0;
4660 int is_dedicated = 0;
4661 struct extent *ex;
f21e18ca 4662 unsigned int j;
7e1432fb
NB		 4663 /* If in this array, skip */
4664 for (d2 = a->info.devs ; d2 ; d2 = d2->next)
7590d562
N		 4665 if (d2->state_fd >= 0 &&
4666 d2->disk.major == dl->major &&
7e1432fb 4667 d2->disk.minor == dl->minor) {
2c514b71 4668 dprintf("%x:%x already in array\n", dl->major, dl->minor);
7e1432fb
NB		 4669 break;
4670 }
4671 if (d2)
4672 continue;
4673 if (ddf->phys->entries[dl->pdnum].type &
4674 __cpu_to_be16(DDF_Spare)) {
4675 /* Check spare assign record */
4676 if (dl->spare) {
4677 if (dl->spare->type & DDF_spare_dedicated) {
4678 /* check spare_ents for guid */
4679 for (j = 0 ;
4680 j < __be16_to_cpu(dl->spare->populated);
4681 j++) {
4682 if (memcmp(dl->spare->spare_ents[j].guid,
4683 ddf->virt->entries[a->info.container_member].guid,
4684 DDF_GUID_LEN) == 0)
4685 is_dedicated = 1;
4686 }
4687 } else
4688 is_global = 1;
4689 }
4690 } else if (ddf->phys->entries[dl->pdnum].type &
4691 __cpu_to_be16(DDF_Global_Spare)) {
4692 is_global = 1;
e0e7aeaa
N		 4693 } else if (!(ddf->phys->entries[dl->pdnum].state &
4694 __cpu_to_be16(DDF_Failed))) {
4695 /* we can possibly use some of this */
4696 is_global = 1;
7e1432fb
NB		 4697 }
4698 if ( ! (is_dedicated ||
4699 (is_global && global_ok))) {
2c514b71 4700 dprintf("%x:%x not suitable: %d %d\n", dl->major, dl->minor,
613b0d17 4701 is_dedicated, is_global);
7e1432fb
NB		 4702 continue;
4703 }
4704
4705 /* We are allowed to use this device - is there space?
4706 * We need a->info.component_size sectors */
4707 ex = get_extents(ddf, dl);
4708 if (!ex) {
2c514b71 4709 dprintf("cannot get extents\n");
7e1432fb
NB		 4710 continue;
4711 }
4712 j = 0; pos = 0;
4713 esize = 0;
4714
4715 do {
4716 esize = ex[j].start - pos;
4717 if (esize >= a->info.component_size)
4718 break;
e5cc7d46
N		 4719 pos = ex[j].start + ex[j].size;
4720 j++;
4721 } while (ex[j-1].size);
7e1432fb
NB		 4722
4723 free(ex);
4724 if (esize < a->info.component_size) {
e5cc7d46
N		 4725 dprintf("%x:%x has no room: %llu %llu\n",
4726 dl->major, dl->minor,
2c514b71 4727 esize, a->info.component_size);
7e1432fb
NB		 4728 /* No room */
4729 continue;
4730 }
4731
4732 /* Cool, we have a device with some space at pos */
503975b9 4733 di = xcalloc(1, sizeof(*di));
7e1432fb
NB		 4734 di->disk.number = i;
4735 di->disk.raid_disk = i;
4736 di->disk.major = dl->major;
4737 di->disk.minor = dl->minor;
4738 di->disk.state = 0;
d23534e4 4739 di->recovery_start = 0;
7e1432fb
NB		 4740 di->data_offset = pos;
4741 di->component_size = a->info.component_size;
4742 di->container_member = dl->pdnum;
4743 di->next = rv;
4744 rv = di;
2c514b71
NB		 4745 dprintf("%x:%x to be %d at %llu\n", dl->major, dl->minor,
4746 i, pos);
7e1432fb
NB		 4747
4748 break;
4749 }
4750 if (!dl && ! global_ok) {
4751 /* not enough dedicated spares, try global */
4752 global_ok = 1;
4753 dl = ddf->dlist;
4754 goto again;
4755 }
4756 }
4757
4758 if (!rv)
4759 /* No spares found */
4760 return rv;
4761 /* Now 'rv' has a list of devices to return.
4762 * Create a metadata_update record to update the
4763 * phys_refnum and lba_offset values
4764 */
503975b9
N		 4765 mu = xmalloc(sizeof(*mu));
4766 if (posix_memalign(&mu->space, 512, sizeof(struct vcl)) != 0) {
79244939
DW		 4767 free(mu);
4768 mu = NULL;
4769 }
503975b9 4770 mu->buf = xmalloc(ddf->conf_rec_len * 512);
7590d562
N		 4771 mu->len = ddf->conf_rec_len * 512;
4772 mu->space = NULL;
f50ae22e 4773 mu->space_list = NULL;
7e1432fb 4774 mu->next = *updates;
baba3f4e 4775 vc = find_vdcr(ddf, a->info.container_member, di->disk.raid_disk,
4776 &n_bvd, &vcl);
7e1432fb
NB		 4777 memcpy(mu->buf, vc, ddf->conf_rec_len * 512);
4778
4779 vc = (struct vd_config*)mu->buf;
7e1432fb
NB		 4780 for (di = rv ; di ; di = di->next) {
4781 vc->phys_refnum[di->disk.raid_disk] =
4782 ddf->phys->entries[dl->pdnum].refnum;
57a66662 4783 LBA_OFFSET(ddf, vc)[di->disk.raid_disk]
4784 = __cpu_to_be64(di->data_offset);
7e1432fb
NB		 4785 }
4786 *updates = mu;
4787 return rv;
4788}
0e600426 4789#endif /* MDASSEMBLE */
7e1432fb 4790
b640a252
N		 4791static int ddf_level_to_layout(int level)
4792{
4793 switch(level) {
4794 case 0:
4795 case 1:
4796 return 0;
4797 case 5:
4798 return ALGORITHM_LEFT_SYMMETRIC;
4799 case 6:
4800 return ALGORITHM_ROTATING_N_CONTINUE;
4801 case 10:
4802 return 0x102;
4803 default:
4804 return UnSet;
4805 }
4806}
4807
30f58b22
DW		 4808static void default_geometry_ddf(struct supertype *st, int *level, int *layout, int *chunk)
4809{
4810 if (level && *level == UnSet)
4811 *level = LEVEL_CONTAINER;
4812
4813 if (level && layout && *layout == UnSet)
4814 *layout = ddf_level_to_layout(*level);
4815}
4816
a322f70c
DW		 4817struct superswitch super_ddf = {
4818#ifndef MDASSEMBLE
4819 .examine_super = examine_super_ddf,
4820 .brief_examine_super = brief_examine_super_ddf,
4737ae25 4821 .brief_examine_subarrays = brief_examine_subarrays_ddf,
bceedeec 4822 .export_examine_super = export_examine_super_ddf,
a322f70c
DW		 4823 .detail_super = detail_super_ddf,
4824 .brief_detail_super = brief_detail_super_ddf,
4825 .validate_geometry = validate_geometry_ddf,
78e44928 4826 .write_init_super = write_init_super_ddf,
0e600426 4827 .add_to_super = add_to_super_ddf,
4dd968cc 4828 .remove_from_super = remove_from_super_ddf,
2b959fbf 4829 .load_container = load_container_ddf,
74db60b0 4830 .copy_metadata = copy_metadata_ddf,
a322f70c
DW		 4831#endif
4832 .match_home = match_home_ddf,
4833 .uuid_from_super= uuid_from_super_ddf,
4834 .getinfo_super = getinfo_super_ddf,
4835 .update_super = update_super_ddf,
4836
4837 .avail_size = avail_size_ddf,
4838
a19c88b8
NB		 4839 .compare_super = compare_super_ddf,
4840
a322f70c 4841 .load_super = load_super_ddf,
ba7eb04f 4842 .init_super = init_super_ddf,
955e9ea1 4843 .store_super = store_super_ddf,
a322f70c
DW		 4844 .free_super = free_super_ddf,
4845 .match_metadata_desc = match_metadata_desc_ddf,
78e44928 4846 .container_content = container_content_ddf,
30f58b22 4847 .default_geometry = default_geometry_ddf,
f646805e 4848 .kill_subarray = kill_subarray_ddf,
a322f70c 4849
a322f70c 4850 .external = 1,
549e9569 4851
0e600426 4852#ifndef MDASSEMBLE
549e9569
NB		 4853/* for mdmon */
4854 .open_new = ddf_open_new,
ed9d66aa 4855 .set_array_state= ddf_set_array_state,
549e9569
NB		 4856 .set_disk = ddf_set_disk,
4857 .sync_metadata = ddf_sync_metadata,
88c164f4 4858 .process_update = ddf_process_update,
edd8d13c 4859 .prepare_update = ddf_prepare_update,
7e1432fb 4860 .activate_spare = ddf_activate_spare,
0e600426 4861#endif
4cce4069 4862 .name = "ddf",
a322f70c 4863};
Unnamed repository; edit this file 'description' to name the repository.