780206341406995cfa1b1f08c03d3f7835017901
[thirdparty/mdadm.git] / super-ddf.c
1 /*
2  * mdadm - manage Linux "md" devices aka RAID arrays.
3  *
4  * Copyright (C) 2006-2014 Neil Brown <neilb@suse.de>
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 taken 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"
30 #include "mdmon.h"
31 #include "sha1.h"
32 #include <values.h>
33 #include <stddef.h>
34
35 /* a non-official T10 name for creation GUIDs */
36 static char T10[] = "Linux-MD";
37
38 /* DDF timestamps are 1980 based, so we need to add
39  * second-in-decade-of-seventies to convert to linux timestamps.
40  * 10 years with 2 leap years.
41  */
42 #define DECADE (3600*24*(365*10+2))
43 unsigned long crc32(
44         unsigned long crc,
45         const unsigned char *buf,
46         unsigned len);
47
48 #define DDF_NOTFOUND (~0U)
49 #define DDF_CONTAINER (DDF_NOTFOUND-1)
50
51 /* Default for safe_mode_delay. Same value as for IMSM.
52  */
53 static const int DDF_SAFE_MODE_DELAY = 4000;
54
55 /* The DDF metadata handling.
56  * DDF metadata lives at the end of the device.
57  * The last 512 byte block provides an 'anchor' which is used to locate
58  * the rest of the metadata which usually lives immediately behind the anchor.
59  *
60  * Note:
61  *  - all multibyte numeric fields are bigendian.
62  *  - all strings are space padded.
63  *
64  */
65
66 typedef struct __be16 {
67         __u16 _v16;
68 } be16;
69 #define be16_eq(x, y) ((x)._v16 == (y)._v16)
70 #define be16_and(x, y) ((x)._v16 & (y)._v16)
71 #define be16_or(x, y) ((x)._v16 | (y)._v16)
72 #define be16_clear(x, y) ((x)._v16 &= ~(y)._v16)
73 #define be16_set(x, y) ((x)._v16 |= (y)._v16)
74
75 typedef struct __be32 {
76         __u32 _v32;
77 } be32;
78 #define be32_eq(x, y) ((x)._v32 == (y)._v32)
79
80 typedef struct __be64 {
81         __u64 _v64;
82 } be64;
83 #define be64_eq(x, y) ((x)._v64 == (y)._v64)
84
85 #define be16_to_cpu(be) __be16_to_cpu((be)._v16)
86 static inline be16 cpu_to_be16(__u16 x)
87 {
88         be16 be = { ._v16 = __cpu_to_be16(x) };
89         return be;
90 }
91
92 #define be32_to_cpu(be) __be32_to_cpu((be)._v32)
93 static inline be32 cpu_to_be32(__u32 x)
94 {
95         be32 be = { ._v32 = __cpu_to_be32(x) };
96         return be;
97 }
98
99 #define be64_to_cpu(be) __be64_to_cpu((be)._v64)
100 static inline be64 cpu_to_be64(__u64 x)
101 {
102         be64 be = { ._v64 = __cpu_to_be64(x) };
103         return be;
104 }
105
106 /* Primary Raid Level (PRL) */
107 #define DDF_RAID0       0x00
108 #define DDF_RAID1       0x01
109 #define DDF_RAID3       0x03
110 #define DDF_RAID4       0x04
111 #define DDF_RAID5       0x05
112 #define DDF_RAID1E      0x11
113 #define DDF_JBOD        0x0f
114 #define DDF_CONCAT      0x1f
115 #define DDF_RAID5E      0x15
116 #define DDF_RAID5EE     0x25
117 #define DDF_RAID6       0x06
118
119 /* Raid Level Qualifier (RLQ) */
120 #define DDF_RAID0_SIMPLE        0x00
121 #define DDF_RAID1_SIMPLE        0x00 /* just 2 devices in this plex */
122 #define DDF_RAID1_MULTI         0x01 /* exactly 3 devices in this plex */
123 #define DDF_RAID3_0             0x00 /* parity in first extent */
124 #define DDF_RAID3_N             0x01 /* parity in last extent */
125 #define DDF_RAID4_0             0x00 /* parity in first extent */
126 #define DDF_RAID4_N             0x01 /* parity in last extent */
127 /* these apply to raid5e and raid5ee as well */
128 #define DDF_RAID5_0_RESTART     0x00 /* same as 'right asymmetric' - layout 1 */
129 #define DDF_RAID6_0_RESTART     0x01 /* raid6 different from raid5 here!!! */
130 #define DDF_RAID5_N_RESTART     0x02 /* same as 'left asymmetric' - layout 0 */
131 #define DDF_RAID5_N_CONTINUE    0x03 /* same as 'left symmetric' - layout 2 */
132
133 #define DDF_RAID1E_ADJACENT     0x00 /* raid10 nearcopies==2 */
134 #define DDF_RAID1E_OFFSET       0x01 /* raid10 offsetcopies==2 */
135
136 /* Secondary RAID Level (SRL) */
137 #define DDF_2STRIPED    0x00    /* This is weirder than RAID0 !! */
138 #define DDF_2MIRRORED   0x01
139 #define DDF_2CONCAT     0x02
140 #define DDF_2SPANNED    0x03    /* This is also weird - be careful */
141
142 /* Magic numbers */
143 #define DDF_HEADER_MAGIC        cpu_to_be32(0xDE11DE11)
144 #define DDF_CONTROLLER_MAGIC    cpu_to_be32(0xAD111111)
145 #define DDF_PHYS_RECORDS_MAGIC  cpu_to_be32(0x22222222)
146 #define DDF_PHYS_DATA_MAGIC     cpu_to_be32(0x33333333)
147 #define DDF_VIRT_RECORDS_MAGIC  cpu_to_be32(0xDDDDDDDD)
148 #define DDF_VD_CONF_MAGIC       cpu_to_be32(0xEEEEEEEE)
149 #define DDF_SPARE_ASSIGN_MAGIC  cpu_to_be32(0x55555555)
150 #define DDF_VU_CONF_MAGIC       cpu_to_be32(0x88888888)
151 #define DDF_VENDOR_LOG_MAGIC    cpu_to_be32(0x01dBEEF0)
152 #define DDF_BBM_LOG_MAGIC       cpu_to_be32(0xABADB10C)
153
154 #define DDF_GUID_LEN    24
155 #define DDF_REVISION_0  "01.00.00"
156 #define DDF_REVISION_2  "01.02.00"
157
158 struct ddf_header {
159         be32    magic;          /* DDF_HEADER_MAGIC */
160         be32    crc;
161         char    guid[DDF_GUID_LEN];
162         char    revision[8];    /* 01.02.00 */
163         be32    seq;            /* starts at '1' */
164         be32    timestamp;
165         __u8    openflag;
166         __u8    foreignflag;
167         __u8    enforcegroups;
168         __u8    pad0;           /* 0xff */
169         __u8    pad1[12];       /* 12 * 0xff */
170         /* 64 bytes so far */
171         __u8    header_ext[32]; /* reserved: fill with 0xff */
172         be64    primary_lba;
173         be64    secondary_lba;
174         __u8    type;
175         __u8    pad2[3];        /* 0xff */
176         be32    workspace_len;  /* sectors for vendor space -
177                                  * at least 32768(sectors) */
178         be64    workspace_lba;
179         be16    max_pd_entries; /* one of 15, 63, 255, 1023, 4095 */
180         be16    max_vd_entries; /* 2^(4,6,8,10,12)-1 : i.e. as above */
181         be16    max_partitions; /* i.e. max num of configuration
182                                    record entries per disk */
183         be16    config_record_len; /* 1 +ROUNDUP(max_primary_element_entries
184                                                  *12/512) */
185         be16    max_primary_element_entries; /* 16, 64, 256, 1024, or 4096 */
186         __u8    pad3[54];       /* 0xff */
187         /* 192 bytes so far */
188         be32    controller_section_offset;
189         be32    controller_section_length;
190         be32    phys_section_offset;
191         be32    phys_section_length;
192         be32    virt_section_offset;
193         be32    virt_section_length;
194         be32    config_section_offset;
195         be32    config_section_length;
196         be32    data_section_offset;
197         be32    data_section_length;
198         be32    bbm_section_offset;
199         be32    bbm_section_length;
200         be32    diag_space_offset;
201         be32    diag_space_length;
202         be32    vendor_offset;
203         be32    vendor_length;
204         /* 256 bytes so far */
205         __u8    pad4[256];      /* 0xff */
206 };
207
208 /* type field */
209 #define DDF_HEADER_ANCHOR       0x00
210 #define DDF_HEADER_PRIMARY      0x01
211 #define DDF_HEADER_SECONDARY    0x02
212
213 /* The content of the 'controller section' - global scope */
214 struct ddf_controller_data {
215         be32    magic;                  /* DDF_CONTROLLER_MAGIC */
216         be32    crc;
217         char    guid[DDF_GUID_LEN];
218         struct controller_type {
219                 be16 vendor_id;
220                 be16 device_id;
221                 be16 sub_vendor_id;
222                 be16 sub_device_id;
223         } type;
224         char    product_id[16];
225         __u8    pad[8]; /* 0xff */
226         __u8    vendor_data[448];
227 };
228
229 /* The content of phys_section - global scope */
230 struct phys_disk {
231         be32    magic;          /* DDF_PHYS_RECORDS_MAGIC */
232         be32    crc;
233         be16    used_pdes;      /* This is a counter, not a max - the list
234                                  * of used entries may not be dense */
235         be16    max_pdes;
236         __u8    pad[52];
237         struct phys_disk_entry {
238                 char    guid[DDF_GUID_LEN];
239                 be32    refnum;
240                 be16    type;
241                 be16    state;
242                 be64    config_size;    /* DDF structures must be after here */
243                 char    path[18];       /* Another horrible structure really
244                                          * but is "used for information
245                                          * purposes only" */
246                 __u8    pad[6];
247         } entries[0];
248 };
249
250 /* phys_disk_entry.type is a bitmap - bigendian remember */
251 #define DDF_Forced_PD_GUID              1
252 #define DDF_Active_in_VD                2
253 #define DDF_Global_Spare                4 /* VD_CONF records are ignored */
254 #define DDF_Spare                       8 /* overrides Global_spare */
255 #define DDF_Foreign                     16
256 #define DDF_Legacy                      32 /* no DDF on this device */
257
258 #define DDF_Interface_mask              0xf00
259 #define DDF_Interface_SCSI              0x100
260 #define DDF_Interface_SAS               0x200
261 #define DDF_Interface_SATA              0x300
262 #define DDF_Interface_FC                0x400
263
264 /* phys_disk_entry.state is a bigendian bitmap */
265 #define DDF_Online                      1
266 #define DDF_Failed                      2 /* overrides  1,4,8 */
267 #define DDF_Rebuilding                  4
268 #define DDF_Transition                  8
269 #define DDF_SMART                       16
270 #define DDF_ReadErrors                  32
271 #define DDF_Missing                     64
272
273 /* The content of the virt_section global scope */
274 struct virtual_disk {
275         be32    magic;          /* DDF_VIRT_RECORDS_MAGIC */
276         be32    crc;
277         be16    populated_vdes;
278         be16    max_vdes;
279         __u8    pad[52];
280         struct virtual_entry {
281                 char    guid[DDF_GUID_LEN];
282                 be16    unit;
283                 __u16   pad0;   /* 0xffff */
284                 be16    guid_crc;
285                 be16    type;
286                 __u8    state;
287                 __u8    init_state;
288                 __u8    pad1[14];
289                 char    name[16];
290         } entries[0];
291 };
292
293 /* virtual_entry.type is a bitmap - bigendian */
294 #define DDF_Shared              1
295 #define DDF_Enforce_Groups      2
296 #define DDF_Unicode             4
297 #define DDF_Owner_Valid         8
298
299 /* virtual_entry.state is a bigendian bitmap */
300 #define DDF_state_mask          0x7
301 #define DDF_state_optimal       0x0
302 #define DDF_state_degraded      0x1
303 #define DDF_state_deleted       0x2
304 #define DDF_state_missing       0x3
305 #define DDF_state_failed        0x4
306 #define DDF_state_part_optimal  0x5
307
308 #define DDF_state_morphing      0x8
309 #define DDF_state_inconsistent  0x10
310
311 /* virtual_entry.init_state is a bigendian bitmap */
312 #define DDF_initstate_mask      0x03
313 #define DDF_init_not            0x00
314 #define DDF_init_quick          0x01 /* initialisation is progress.
315                                       * i.e. 'state_inconsistent' */
316 #define DDF_init_full           0x02
317
318 #define DDF_access_mask         0xc0
319 #define DDF_access_rw           0x00
320 #define DDF_access_ro           0x80
321 #define DDF_access_blocked      0xc0
322
323 /* The content of the config_section - local scope
324  * It has multiple records each config_record_len sectors
325  * They can be vd_config or spare_assign
326  */
327
328 struct vd_config {
329         be32    magic;          /* DDF_VD_CONF_MAGIC */
330         be32    crc;
331         char    guid[DDF_GUID_LEN];
332         be32    timestamp;
333         be32    seqnum;
334         __u8    pad0[24];
335         be16    prim_elmnt_count;
336         __u8    chunk_shift;    /* 0 == 512, 1==1024 etc */
337         __u8    prl;
338         __u8    rlq;
339         __u8    sec_elmnt_count;
340         __u8    sec_elmnt_seq;
341         __u8    srl;
342         be64    blocks;         /* blocks per component could be different
343                                  * on different component devices...(only
344                                  * for concat I hope) */
345         be64    array_blocks;   /* blocks in array */
346         __u8    pad1[8];
347         be32    spare_refs[8];  /* This is used to detect missing spares.
348                                  * As we don't have an interface for that
349                                  * the values are ignored.
350                                  */
351         __u8    cache_pol[8];
352         __u8    bg_rate;
353         __u8    pad2[3];
354         __u8    pad3[52];
355         __u8    pad4[192];
356         __u8    v0[32]; /* reserved- 0xff */
357         __u8    v1[32]; /* reserved- 0xff */
358         __u8    v2[16]; /* reserved- 0xff */
359         __u8    v3[16]; /* reserved- 0xff */
360         __u8    vendor[32];
361         be32    phys_refnum[0]; /* refnum of each disk in sequence */
362       /*__u64   lba_offset[0];  LBA offset in each phys.  Note extents in a
363                                 bvd are always the same size */
364 };
365 #define LBA_OFFSET(ddf, vd) ((be64 *) &(vd)->phys_refnum[(ddf)->mppe])
366
367 /* vd_config.cache_pol[7] is a bitmap */
368 #define DDF_cache_writeback     1       /* else writethrough */
369 #define DDF_cache_wadaptive     2       /* only applies if writeback */
370 #define DDF_cache_readahead     4
371 #define DDF_cache_radaptive     8       /* only if doing read-ahead */
372 #define DDF_cache_ifnobatt      16      /* even to write cache if battery is poor */
373 #define DDF_cache_wallowed      32      /* enable write caching */
374 #define DDF_cache_rallowed      64      /* enable read caching */
375
376 struct spare_assign {
377         be32    magic;          /* DDF_SPARE_ASSIGN_MAGIC */
378         be32    crc;
379         be32    timestamp;
380         __u8    reserved[7];
381         __u8    type;
382         be16    populated;      /* SAEs used */
383         be16    max;            /* max SAEs */
384         __u8    pad[8];
385         struct spare_assign_entry {
386                 char    guid[DDF_GUID_LEN];
387                 be16    secondary_element;
388                 __u8    pad[6];
389         } spare_ents[0];
390 };
391 /* spare_assign.type is a bitmap */
392 #define DDF_spare_dedicated     0x1     /* else global */
393 #define DDF_spare_revertible    0x2     /* else committable */
394 #define DDF_spare_active        0x4     /* else not active */
395 #define DDF_spare_affinity      0x8     /* enclosure affinity */
396
397 /* The data_section contents - local scope */
398 struct disk_data {
399         be32    magic;          /* DDF_PHYS_DATA_MAGIC */
400         be32    crc;
401         char    guid[DDF_GUID_LEN];
402         be32    refnum;         /* crc of some magic drive data ... */
403         __u8    forced_ref;     /* set when above was not result of magic */
404         __u8    forced_guid;    /* set if guid was forced rather than magic */
405         __u8    vendor[32];
406         __u8    pad[442];
407 };
408
409 /* bbm_section content */
410 struct bad_block_log {
411         be32    magic;
412         be32    crc;
413         be16    entry_count;
414         be32    spare_count;
415         __u8    pad[10];
416         be64    first_spare;
417         struct mapped_block {
418                 be64    defective_start;
419                 be32    replacement_start;
420                 be16    remap_count;
421                 __u8    pad[2];
422         } entries[0];
423 };
424
425 /* Struct for internally holding ddf structures */
426 /* The DDF structure stored on each device is potentially
427  * quite different, as some data is global and some is local.
428  * The global data is:
429  *   - ddf header
430  *   - controller_data
431  *   - Physical disk records
432  *   - Virtual disk records
433  * The local data is:
434  *   - Configuration records
435  *   - Physical Disk data section
436  *  (  and Bad block and vendor which I don't care about yet).
437  *
438  * The local data is parsed into separate lists as it is read
439  * and reconstructed for writing.  This means that we only need
440  * to make config changes once and they are automatically
441  * propagated to all devices.
442  * The global (config and disk data) records are each in a list
443  * of separate data structures.  When writing we find the entry
444  * or entries applicable to the particular device.
445  */
446 struct ddf_super {
447         struct ddf_header       anchor, primary, secondary;
448         struct ddf_controller_data controller;
449         struct ddf_header       *active;
450         struct phys_disk        *phys;
451         struct virtual_disk     *virt;
452         char                    *conf;
453         int                     pdsize, vdsize;
454         unsigned int            max_part, mppe, conf_rec_len;
455         int                     currentdev;
456         int                     updates_pending;
457         struct vcl {
458                 union {
459                         char space[512];
460                         struct {
461                                 struct vcl      *next;
462                                 unsigned int    vcnum; /* index into ->virt */
463                                 /* For an array with a secondary level there are
464                                  * multiple vd_config structures, all with the same
465                                  * guid but with different sec_elmnt_seq.
466                                  * One of these structures is in 'conf' below.
467                                  * The others are in other_bvds, not in any
468                                  * particular order.
469                                  */
470                                 struct vd_config **other_bvds;
471                                 __u64           *block_sizes; /* NULL if all the same */
472                         };
473                 };
474                 struct vd_config conf;
475         } *conflist, *currentconf;
476         struct dl {
477                 union {
478                         char space[512];
479                         struct {
480                                 struct dl       *next;
481                                 int major, minor;
482                                 char *devname;
483                                 int fd;
484                                 unsigned long long size; /* sectors */
485                                 be64 primary_lba; /* sectors */
486                                 be64 secondary_lba; /* sectors */
487                                 be64 workspace_lba; /* sectors */
488                                 int pdnum;      /* index in ->phys */
489                                 struct spare_assign *spare;
490                                 void *mdupdate; /* hold metadata update */
491
492                                 /* These fields used by auto-layout */
493                                 int raiddisk; /* slot to fill in autolayout */
494                                 __u64 esize;
495                                 int displayed;
496                         };
497                 };
498                 struct disk_data disk;
499                 struct vcl *vlist[0]; /* max_part in size */
500         } *dlist, *add_list;
501 };
502
503 static int load_super_ddf_all(struct supertype *st, int fd,
504                               void **sbp, char *devname);
505 static int get_svd_state(const struct ddf_super *, const struct vcl *);
506 static int
507 validate_geometry_ddf_container(struct supertype *st,
508                                 int level, int layout, int raiddisks,
509                                 int chunk, unsigned long long size,
510                                 unsigned long long data_offset,
511                                 char *dev, unsigned long long *freesize,
512                                 int verbose);
513
514 static int validate_geometry_ddf_bvd(struct supertype *st,
515                                      int level, int layout, int raiddisks,
516                                      int *chunk, unsigned long long size,
517                                      unsigned long long data_offset,
518                                      char *dev, unsigned long long *freesize,
519                                      int verbose);
520
521 static void free_super_ddf(struct supertype *st);
522 static int all_ff(const char *guid);
523 static unsigned int get_pd_index_from_refnum(const struct vcl *vc,
524                                              be32 refnum, unsigned int nmax,
525                                              const struct vd_config **bvd,
526                                              unsigned int *idx);
527 static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *map);
528 static void uuid_from_ddf_guid(const char *guid, int uuid[4]);
529 static void uuid_from_super_ddf(struct supertype *st, int uuid[4]);
530 static void _ddf_array_name(char *name, const struct ddf_super *ddf, int i);
531 static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, char *map);
532 static int init_super_ddf_bvd(struct supertype *st,
533                               mdu_array_info_t *info,
534                               unsigned long long size,
535                               char *name, char *homehost,
536                               int *uuid, unsigned long long data_offset);
537
538 #if DEBUG
539 static void pr_state(struct ddf_super *ddf, const char *msg)
540 {
541         unsigned int i;
542         dprintf("%s: ", msg);
543         for (i = 0; i < be16_to_cpu(ddf->active->max_vd_entries); i++) {
544                 if (all_ff(ddf->virt->entries[i].guid))
545                         continue;
546                 dprintf_cont("%u(s=%02x i=%02x) ", i,
547                         ddf->virt->entries[i].state,
548                         ddf->virt->entries[i].init_state);
549         }
550         dprintf_cont("\n");
551 }
552 #else
553 static void pr_state(const struct ddf_super *ddf, const char *msg) {}
554 #endif
555
556 static void _ddf_set_updates_pending(struct ddf_super *ddf, struct vd_config *vc,
557                                      const char *func)
558 {
559         if (vc) {
560                 vc->timestamp = cpu_to_be32(time(0)-DECADE);
561                 vc->seqnum = cpu_to_be32(be32_to_cpu(vc->seqnum) + 1);
562         }
563         if (ddf->updates_pending)
564                 return;
565         ddf->updates_pending = 1;
566         ddf->active->seq = cpu_to_be32((be32_to_cpu(ddf->active->seq)+1));
567         pr_state(ddf, func);
568 }
569
570 #define ddf_set_updates_pending(x,v) _ddf_set_updates_pending((x), (v), __func__)
571
572 static be32 calc_crc(void *buf, int len)
573 {
574         /* crcs are always at the same place as in the ddf_header */
575         struct ddf_header *ddf = buf;
576         be32 oldcrc = ddf->crc;
577         __u32 newcrc;
578         ddf->crc = cpu_to_be32(0xffffffff);
579
580         newcrc = crc32(0, buf, len);
581         ddf->crc = oldcrc;
582         /* The crc is stored (like everything) bigendian, so convert
583          * here for simplicity
584          */
585         return cpu_to_be32(newcrc);
586 }
587
588 #define DDF_INVALID_LEVEL 0xff
589 #define DDF_NO_SECONDARY 0xff
590 static int err_bad_md_layout(const mdu_array_info_t *array)
591 {
592         pr_err("RAID%d layout %x with %d disks is unsupported for DDF\n",
593                array->level, array->layout, array->raid_disks);
594         return -1;
595 }
596
597 static int layout_md2ddf(const mdu_array_info_t *array,
598                          struct vd_config *conf)
599 {
600         be16 prim_elmnt_count = cpu_to_be16(array->raid_disks);
601         __u8 prl = DDF_INVALID_LEVEL, rlq = 0;
602         __u8 sec_elmnt_count = 1;
603         __u8 srl = DDF_NO_SECONDARY;
604
605         switch (array->level) {
606         case LEVEL_LINEAR:
607                 prl = DDF_CONCAT;
608                 break;
609         case 0:
610                 rlq = DDF_RAID0_SIMPLE;
611                 prl = DDF_RAID0;
612                 break;
613         case 1:
614                 switch (array->raid_disks) {
615                 case 2:
616                         rlq = DDF_RAID1_SIMPLE;
617                         break;
618                 case 3:
619                         rlq = DDF_RAID1_MULTI;
620                         break;
621                 default:
622                         return err_bad_md_layout(array);
623                 }
624                 prl = DDF_RAID1;
625                 break;
626         case 4:
627                 if (array->layout != 0)
628                         return err_bad_md_layout(array);
629                 rlq = DDF_RAID4_N;
630                 prl = DDF_RAID4;
631                 break;
632         case 5:
633                 switch (array->layout) {
634                 case ALGORITHM_LEFT_ASYMMETRIC:
635                         rlq = DDF_RAID5_N_RESTART;
636                         break;
637                 case ALGORITHM_RIGHT_ASYMMETRIC:
638                         rlq = DDF_RAID5_0_RESTART;
639                         break;
640                 case ALGORITHM_LEFT_SYMMETRIC:
641                         rlq = DDF_RAID5_N_CONTINUE;
642                         break;
643                 case ALGORITHM_RIGHT_SYMMETRIC:
644                         /* not mentioned in standard */
645                 default:
646                         return err_bad_md_layout(array);
647                 }
648                 prl = DDF_RAID5;
649                 break;
650         case 6:
651                 switch (array->layout) {
652                 case ALGORITHM_ROTATING_N_RESTART:
653                         rlq = DDF_RAID5_N_RESTART;
654                         break;
655                 case ALGORITHM_ROTATING_ZERO_RESTART:
656                         rlq = DDF_RAID6_0_RESTART;
657                         break;
658                 case ALGORITHM_ROTATING_N_CONTINUE:
659                         rlq = DDF_RAID5_N_CONTINUE;
660                         break;
661                 default:
662                         return err_bad_md_layout(array);
663                 }
664                 prl = DDF_RAID6;
665                 break;
666         case 10:
667                 if (array->raid_disks % 2 == 0 && array->layout == 0x102) {
668                         rlq = DDF_RAID1_SIMPLE;
669                         prim_elmnt_count =  cpu_to_be16(2);
670                         sec_elmnt_count = array->raid_disks / 2;
671                         srl = DDF_2SPANNED;
672                         prl = DDF_RAID1;
673                 } else if (array->raid_disks % 3 == 0 &&
674                            array->layout == 0x103) {
675                         rlq = DDF_RAID1_MULTI;
676                         prim_elmnt_count =  cpu_to_be16(3);
677                         sec_elmnt_count = array->raid_disks / 3;
678                         srl = DDF_2SPANNED;
679                         prl = DDF_RAID1;
680                 } else if (array->layout == 0x201) {
681                         prl = DDF_RAID1E;
682                         rlq = DDF_RAID1E_OFFSET;
683                 } else if (array->layout == 0x102) {
684                         prl = DDF_RAID1E;
685                         rlq = DDF_RAID1E_ADJACENT;
686                 } else
687                         return err_bad_md_layout(array);
688                 break;
689         default:
690                 return err_bad_md_layout(array);
691         }
692         conf->prl = prl;
693         conf->prim_elmnt_count = prim_elmnt_count;
694         conf->rlq = rlq;
695         conf->srl = srl;
696         conf->sec_elmnt_count = sec_elmnt_count;
697         return 0;
698 }
699
700 static int err_bad_ddf_layout(const struct vd_config *conf)
701 {
702         pr_err("DDF RAID %u qualifier %u with %u disks is unsupported\n",
703                conf->prl, conf->rlq, be16_to_cpu(conf->prim_elmnt_count));
704         return -1;
705 }
706
707 static int layout_ddf2md(const struct vd_config *conf,
708                          mdu_array_info_t *array)
709 {
710         int level = LEVEL_UNSUPPORTED;
711         int layout = 0;
712         int raiddisks = be16_to_cpu(conf->prim_elmnt_count);
713
714         if (conf->sec_elmnt_count > 1) {
715                 /* see also check_secondary() */
716                 if (conf->prl != DDF_RAID1 ||
717                     (conf->srl != DDF_2STRIPED && conf->srl != DDF_2SPANNED)) {
718                         pr_err("Unsupported secondary RAID level %u/%u\n",
719                                conf->prl, conf->srl);
720                         return -1;
721                 }
722                 if (raiddisks == 2 && conf->rlq == DDF_RAID1_SIMPLE)
723                         layout = 0x102;
724                 else if  (raiddisks == 3 && conf->rlq == DDF_RAID1_MULTI)
725                         layout = 0x103;
726                 else
727                         return err_bad_ddf_layout(conf);
728                 raiddisks *= conf->sec_elmnt_count;
729                 level = 10;
730                 goto good;
731         }
732
733         switch (conf->prl) {
734         case DDF_CONCAT:
735                 level = LEVEL_LINEAR;
736                 break;
737         case DDF_RAID0:
738                 if (conf->rlq != DDF_RAID0_SIMPLE)
739                         return err_bad_ddf_layout(conf);
740                 level = 0;
741                 break;
742         case DDF_RAID1:
743                 if (!((conf->rlq == DDF_RAID1_SIMPLE && raiddisks == 2) ||
744                       (conf->rlq == DDF_RAID1_MULTI && raiddisks == 3)))
745                         return err_bad_ddf_layout(conf);
746                 level = 1;
747                 break;
748         case DDF_RAID1E:
749                 if (conf->rlq == DDF_RAID1E_ADJACENT)
750                         layout = 0x102;
751                 else if (conf->rlq == DDF_RAID1E_OFFSET)
752                         layout = 0x201;
753                 else
754                         return err_bad_ddf_layout(conf);
755                 level = 10;
756                 break;
757         case DDF_RAID4:
758                 if (conf->rlq != DDF_RAID4_N)
759                         return err_bad_ddf_layout(conf);
760                 level = 4;
761                 break;
762         case DDF_RAID5:
763                 switch (conf->rlq) {
764                 case DDF_RAID5_N_RESTART:
765                         layout = ALGORITHM_LEFT_ASYMMETRIC;
766                         break;
767                 case DDF_RAID5_0_RESTART:
768                         layout = ALGORITHM_RIGHT_ASYMMETRIC;
769                         break;
770                 case DDF_RAID5_N_CONTINUE:
771                         layout = ALGORITHM_LEFT_SYMMETRIC;
772                         break;
773                 default:
774                         return err_bad_ddf_layout(conf);
775                 }
776                 level = 5;
777                 break;
778         case DDF_RAID6:
779                 switch (conf->rlq) {
780                 case DDF_RAID5_N_RESTART:
781                         layout = ALGORITHM_ROTATING_N_RESTART;
782                         break;
783                 case DDF_RAID6_0_RESTART:
784                         layout = ALGORITHM_ROTATING_ZERO_RESTART;
785                         break;
786                 case DDF_RAID5_N_CONTINUE:
787                         layout = ALGORITHM_ROTATING_N_CONTINUE;
788                         break;
789                 default:
790                         return err_bad_ddf_layout(conf);
791                 }
792                 level = 6;
793                 break;
794         default:
795                 return err_bad_ddf_layout(conf);
796         };
797
798 good:
799         array->level = level;
800         array->layout = layout;
801         array->raid_disks = raiddisks;
802         return 0;
803 }
804
805 static int load_ddf_header(int fd, unsigned long long lba,
806                            unsigned long long size,
807                            int type,
808                            struct ddf_header *hdr, struct ddf_header *anchor)
809 {
810         /* read a ddf header (primary or secondary) from fd/lba
811          * and check that it is consistent with anchor
812          * Need to check:
813          *   magic, crc, guid, rev, and LBA's header_type, and
814          *  everything after header_type must be the same
815          */
816         if (lba >= size-1)
817                 return 0;
818
819         if (lseek64(fd, lba<<9, 0) < 0)
820                 return 0;
821
822         if (read(fd, hdr, 512) != 512)
823                 return 0;
824
825         if (!be32_eq(hdr->magic, DDF_HEADER_MAGIC)) {
826                 pr_err("bad header magic\n");
827                 return 0;
828         }
829         if (!be32_eq(calc_crc(hdr, 512), hdr->crc)) {
830                 pr_err("bad CRC\n");
831                 return 0;
832         }
833         if (memcmp(anchor->guid, hdr->guid, DDF_GUID_LEN) != 0 ||
834             memcmp(anchor->revision, hdr->revision, 8) != 0 ||
835             !be64_eq(anchor->primary_lba, hdr->primary_lba) ||
836             !be64_eq(anchor->secondary_lba, hdr->secondary_lba) ||
837             hdr->type != type ||
838             memcmp(anchor->pad2, hdr->pad2, 512 -
839                    offsetof(struct ddf_header, pad2)) != 0) {
840                 pr_err("header mismatch\n");
841                 return 0;
842         }
843
844         /* Looks good enough to me... */
845         return 1;
846 }
847
848 static void *load_section(int fd, struct ddf_super *super, void *buf,
849                           be32 offset_be, be32 len_be, int check)
850 {
851         unsigned long long offset = be32_to_cpu(offset_be);
852         unsigned long long len = be32_to_cpu(len_be);
853         int dofree = (buf == NULL);
854
855         if (check)
856                 if (len != 2 && len != 8 && len != 32 &&
857                     len != 128 && len != 512)
858                         return NULL;
859
860         if (len > 1024)
861                 return NULL;
862         if (!buf && posix_memalign(&buf, 512, len<<9) != 0)
863                 buf = NULL;
864
865         if (!buf)
866                 return NULL;
867
868         if (super->active->type == 1)
869                 offset += be64_to_cpu(super->active->primary_lba);
870         else
871                 offset += be64_to_cpu(super->active->secondary_lba);
872
873         if ((unsigned long long)lseek64(fd, offset<<9, 0) != (offset<<9)) {
874                 if (dofree)
875                         free(buf);
876                 return NULL;
877         }
878         if ((unsigned long long)read(fd, buf, len<<9) != (len<<9)) {
879                 if (dofree)
880                         free(buf);
881                 return NULL;
882         }
883         return buf;
884 }
885
886 static int load_ddf_headers(int fd, struct ddf_super *super, char *devname)
887 {
888         unsigned long long dsize;
889
890         get_dev_size(fd, NULL, &dsize);
891
892         if (lseek64(fd, dsize-512, 0) < 0) {
893                 if (devname)
894                         pr_err("Cannot seek to anchor block on %s: %s\n",
895                                devname, strerror(errno));
896                 return 1;
897         }
898         if (read(fd, &super->anchor, 512) != 512) {
899                 if (devname)
900                         pr_err("Cannot read anchor block on %s: %s\n",
901                                devname, strerror(errno));
902                 return 1;
903         }
904         if (!be32_eq(super->anchor.magic, DDF_HEADER_MAGIC)) {
905                 if (devname)
906                         pr_err("no DDF anchor found on %s\n",
907                                 devname);
908                 return 2;
909         }
910         if (!be32_eq(calc_crc(&super->anchor, 512), super->anchor.crc)) {
911                 if (devname)
912                         pr_err("bad CRC on anchor on %s\n",
913                                 devname);
914                 return 2;
915         }
916         if (memcmp(super->anchor.revision, DDF_REVISION_0, 8) != 0 &&
917             memcmp(super->anchor.revision, DDF_REVISION_2, 8) != 0) {
918                 if (devname)
919                         pr_err("can only support super revision %.8s and earlier, not %.8s on %s\n",
920                                 DDF_REVISION_2, super->anchor.revision,devname);
921                 return 2;
922         }
923         super->active = NULL;
924         if (load_ddf_header(fd, be64_to_cpu(super->anchor.primary_lba),
925                             dsize >> 9,  1,
926                             &super->primary, &super->anchor) == 0) {
927                 if (devname)
928                         pr_err("Failed to load primary DDF header on %s\n", devname);
929         } else
930                 super->active = &super->primary;
931
932         if (load_ddf_header(fd, be64_to_cpu(super->anchor.secondary_lba),
933                             dsize >> 9,  2,
934                             &super->secondary, &super->anchor)) {
935                 if (super->active == NULL ||
936                     (be32_to_cpu(super->primary.seq)
937                      < be32_to_cpu(super->secondary.seq) &&
938                         !super->secondary.openflag) ||
939                     (be32_to_cpu(super->primary.seq) ==
940                      be32_to_cpu(super->secondary.seq) &&
941                         super->primary.openflag && !super->secondary.openflag))
942                         super->active = &super->secondary;
943         } else if (devname &&
944                    be64_to_cpu(super->anchor.secondary_lba) != ~(__u64)0)
945                 pr_err("Failed to load secondary DDF header on %s\n",
946                        devname);
947         if (super->active == NULL)
948                 return 2;
949         return 0;
950 }
951
952 static int load_ddf_global(int fd, struct ddf_super *super, char *devname)
953 {
954         void *ok;
955         ok = load_section(fd, super, &super->controller,
956                           super->active->controller_section_offset,
957                           super->active->controller_section_length,
958                           0);
959         super->phys = load_section(fd, super, NULL,
960                                    super->active->phys_section_offset,
961                                    super->active->phys_section_length,
962                                    1);
963         super->pdsize = be32_to_cpu(super->active->phys_section_length) * 512;
964
965         super->virt = load_section(fd, super, NULL,
966                                    super->active->virt_section_offset,
967                                    super->active->virt_section_length,
968                                    1);
969         super->vdsize = be32_to_cpu(super->active->virt_section_length) * 512;
970         if (!ok ||
971             !super->phys ||
972             !super->virt) {
973                 free(super->phys);
974                 free(super->virt);
975                 super->phys = NULL;
976                 super->virt = NULL;
977                 return 2;
978         }
979         super->conflist = NULL;
980         super->dlist = NULL;
981
982         super->max_part = be16_to_cpu(super->active->max_partitions);
983         super->mppe = be16_to_cpu(super->active->max_primary_element_entries);
984         super->conf_rec_len = be16_to_cpu(super->active->config_record_len);
985         return 0;
986 }
987
988 #define DDF_UNUSED_BVD 0xff
989 static int alloc_other_bvds(const struct ddf_super *ddf, struct vcl *vcl)
990 {
991         unsigned int n_vds = vcl->conf.sec_elmnt_count - 1;
992         unsigned int i, vdsize;
993         void *p;
994         if (n_vds == 0) {
995                 vcl->other_bvds = NULL;
996                 return 0;
997         }
998         vdsize = ddf->conf_rec_len * 512;
999         if (posix_memalign(&p, 512, n_vds *
1000                            (vdsize +  sizeof(struct vd_config *))) != 0)
1001                 return -1;
1002         vcl->other_bvds = (struct vd_config **) (p + n_vds * vdsize);
1003         for (i = 0; i < n_vds; i++) {
1004                 vcl->other_bvds[i] = p + i * vdsize;
1005                 memset(vcl->other_bvds[i], 0, vdsize);
1006                 vcl->other_bvds[i]->sec_elmnt_seq = DDF_UNUSED_BVD;
1007         }
1008         return 0;
1009 }
1010
1011 static void add_other_bvd(struct vcl *vcl, struct vd_config *vd,
1012                           unsigned int len)
1013 {
1014         int i;
1015         for (i = 0; i < vcl->conf.sec_elmnt_count-1; i++)
1016                 if (vcl->other_bvds[i]->sec_elmnt_seq == vd->sec_elmnt_seq)
1017                         break;
1018
1019         if (i < vcl->conf.sec_elmnt_count-1) {
1020                 if (be32_to_cpu(vd->seqnum) <=
1021                     be32_to_cpu(vcl->other_bvds[i]->seqnum))
1022                         return;
1023         } else {
1024                 for (i = 0; i < vcl->conf.sec_elmnt_count-1; i++)
1025                         if (vcl->other_bvds[i]->sec_elmnt_seq == DDF_UNUSED_BVD)
1026                                 break;
1027                 if (i == vcl->conf.sec_elmnt_count-1) {
1028                         pr_err("no space for sec level config %u, count is %u\n",
1029                                vd->sec_elmnt_seq, vcl->conf.sec_elmnt_count);
1030                         return;
1031                 }
1032         }
1033         memcpy(vcl->other_bvds[i], vd, len);
1034 }
1035
1036 static int load_ddf_local(int fd, struct ddf_super *super,
1037                           char *devname, int keep)
1038 {
1039         struct dl *dl;
1040         struct stat stb;
1041         char *conf;
1042         unsigned int i;
1043         unsigned int confsec;
1044         int vnum;
1045         unsigned int max_virt_disks =
1046                 be16_to_cpu(super->active->max_vd_entries);
1047         unsigned long long dsize;
1048
1049         /* First the local disk info */
1050         if (posix_memalign((void**)&dl, 512,
1051                            sizeof(*dl) +
1052                            (super->max_part) * sizeof(dl->vlist[0])) != 0) {
1053                 pr_err("could not allocate disk info buffer\n");
1054                 return 1;
1055         }
1056
1057         load_section(fd, super, &dl->disk,
1058                      super->active->data_section_offset,
1059                      super->active->data_section_length,
1060                      0);
1061         dl->devname = devname ? xstrdup(devname) : NULL;
1062
1063         fstat(fd, &stb);
1064         dl->major = major(stb.st_rdev);
1065         dl->minor = minor(stb.st_rdev);
1066         dl->next = super->dlist;
1067         dl->fd = keep ? fd : -1;
1068
1069         dl->size = 0;
1070         if (get_dev_size(fd, devname, &dsize))
1071                 dl->size = dsize >> 9;
1072         /* If the disks have different sizes, the LBAs will differ
1073          * between phys disks.
1074          * At this point here, the values in super->active must be valid
1075          * for this phys disk. */
1076         dl->primary_lba = super->active->primary_lba;
1077         dl->secondary_lba = super->active->secondary_lba;
1078         dl->workspace_lba = super->active->workspace_lba;
1079         dl->spare = NULL;
1080         for (i = 0 ; i < super->max_part ; i++)
1081                 dl->vlist[i] = NULL;
1082         super->dlist = dl;
1083         dl->pdnum = -1;
1084         for (i = 0; i < be16_to_cpu(super->active->max_pd_entries); i++)
1085                 if (memcmp(super->phys->entries[i].guid,
1086                            dl->disk.guid, DDF_GUID_LEN) == 0)
1087                         dl->pdnum = i;
1088
1089         /* Now the config list. */
1090         /* 'conf' is an array of config entries, some of which are
1091          * probably invalid.  Those which are good need to be copied into
1092          * the conflist
1093          */
1094
1095         conf = load_section(fd, super, super->conf,
1096                             super->active->config_section_offset,
1097                             super->active->config_section_length,
1098                             0);
1099         super->conf = conf;
1100         vnum = 0;
1101         for (confsec = 0;
1102              confsec < be32_to_cpu(super->active->config_section_length);
1103              confsec += super->conf_rec_len) {
1104                 struct vd_config *vd =
1105                         (struct vd_config *)((char*)conf + confsec*512);
1106                 struct vcl *vcl;
1107
1108                 if (be32_eq(vd->magic, DDF_SPARE_ASSIGN_MAGIC)) {
1109                         if (dl->spare)
1110                                 continue;
1111                         if (posix_memalign((void**)&dl->spare, 512,
1112                                            super->conf_rec_len*512) != 0) {
1113                                 pr_err("could not allocate spare info buf\n");
1114                                 return 1;
1115                         }
1116
1117                         memcpy(dl->spare, vd, super->conf_rec_len*512);
1118                         continue;
1119                 }
1120                 if (!be32_eq(vd->magic, DDF_VD_CONF_MAGIC))
1121                         /* Must be vendor-unique - I cannot handle those */
1122                         continue;
1123
1124                 for (vcl = super->conflist; vcl; vcl = vcl->next) {
1125                         if (memcmp(vcl->conf.guid,
1126                                    vd->guid, DDF_GUID_LEN) == 0)
1127                                 break;
1128                 }
1129
1130                 if (vcl) {
1131                         dl->vlist[vnum++] = vcl;
1132                         if (vcl->other_bvds != NULL &&
1133                             vcl->conf.sec_elmnt_seq != vd->sec_elmnt_seq) {
1134                                 add_other_bvd(vcl, vd, super->conf_rec_len*512);
1135                                 continue;
1136                         }
1137                         if (be32_to_cpu(vd->seqnum) <=
1138                             be32_to_cpu(vcl->conf.seqnum))
1139                                 continue;
1140                 } else {
1141                         if (posix_memalign((void**)&vcl, 512,
1142                                            (super->conf_rec_len*512 +
1143                                             offsetof(struct vcl, conf))) != 0) {
1144                                 pr_err("could not allocate vcl buf\n");
1145                                 return 1;
1146                         }
1147                         vcl->next = super->conflist;
1148                         vcl->block_sizes = NULL; /* FIXME not for CONCAT */
1149                         vcl->conf.sec_elmnt_count = vd->sec_elmnt_count;
1150                         if (alloc_other_bvds(super, vcl) != 0) {
1151                                 pr_err("could not allocate other bvds\n");
1152                                 free(vcl);
1153                                 return 1;
1154                         };
1155                         super->conflist = vcl;
1156                         dl->vlist[vnum++] = vcl;
1157                 }
1158                 memcpy(&vcl->conf, vd, super->conf_rec_len*512);
1159                 for (i=0; i < max_virt_disks ; i++)
1160                         if (memcmp(super->virt->entries[i].guid,
1161                                    vcl->conf.guid, DDF_GUID_LEN)==0)
1162                                 break;
1163                 if (i < max_virt_disks)
1164                         vcl->vcnum = i;
1165         }
1166
1167         return 0;
1168 }
1169
1170 static int load_super_ddf(struct supertype *st, int fd,
1171                           char *devname)
1172 {
1173         unsigned long long dsize;
1174         struct ddf_super *super;
1175         int rv;
1176
1177         if (get_dev_size(fd, devname, &dsize) == 0)
1178                 return 1;
1179
1180         if (test_partition(fd))
1181                 /* DDF is not allowed on partitions */
1182                 return 1;
1183
1184         /* 32M is a lower bound */
1185         if (dsize <= 32*1024*1024) {
1186                 if (devname)
1187                         pr_err("%s is too small for ddf: size is %llu sectors.\n",
1188                                devname, dsize>>9);
1189                 return 1;
1190         }
1191         if (dsize & 511) {
1192                 if (devname)
1193                         pr_err("%s is an odd size for ddf: size is %llu bytes.\n",
1194                                devname, dsize);
1195                 return 1;
1196         }
1197
1198         free_super_ddf(st);
1199
1200         if (posix_memalign((void**)&super, 512, sizeof(*super))!= 0) {
1201                 pr_err("malloc of %zu failed.\n",
1202                         sizeof(*super));
1203                 return 1;
1204         }
1205         memset(super, 0, sizeof(*super));
1206
1207         rv = load_ddf_headers(fd, super, devname);
1208         if (rv) {
1209                 free(super);
1210                 return rv;
1211         }
1212
1213         /* Have valid headers and have chosen the best. Let's read in the rest*/
1214
1215         rv = load_ddf_global(fd, super, devname);
1216
1217         if (rv) {
1218                 if (devname)
1219                         pr_err("Failed to load all information sections on %s\n", devname);
1220                 free(super);
1221                 return rv;
1222         }
1223
1224         rv = load_ddf_local(fd, super, devname, 0);
1225
1226         if (rv) {
1227                 if (devname)
1228                         pr_err("Failed to load all information sections on %s\n", devname);
1229                 free(super);
1230                 return rv;
1231         }
1232
1233         /* Should possibly check the sections .... */
1234
1235         st->sb = super;
1236         if (st->ss == NULL) {
1237                 st->ss = &super_ddf;
1238                 st->minor_version = 0;
1239                 st->max_devs = 512;
1240         }
1241         return 0;
1242
1243 }
1244
1245 static void free_super_ddf(struct supertype *st)
1246 {
1247         struct ddf_super *ddf = st->sb;
1248         if (ddf == NULL)
1249                 return;
1250         free(ddf->phys);
1251         free(ddf->virt);
1252         free(ddf->conf);
1253         while (ddf->conflist) {
1254                 struct vcl *v = ddf->conflist;
1255                 ddf->conflist = v->next;
1256                 if (v->block_sizes)
1257                         free(v->block_sizes);
1258                 if (v->other_bvds)
1259                         /*
1260                            v->other_bvds[0] points to beginning of buffer,
1261                            see alloc_other_bvds()
1262                         */
1263                         free(v->other_bvds[0]);
1264                 free(v);
1265         }
1266         while (ddf->dlist) {
1267                 struct dl *d = ddf->dlist;
1268                 ddf->dlist = d->next;
1269                 if (d->fd >= 0)
1270                         close(d->fd);
1271                 if (d->spare)
1272                         free(d->spare);
1273                 free(d);
1274         }
1275         while (ddf->add_list) {
1276                 struct dl *d = ddf->add_list;
1277                 ddf->add_list = d->next;
1278                 if (d->fd >= 0)
1279                         close(d->fd);
1280                 if (d->spare)
1281                         free(d->spare);
1282                 free(d);
1283         }
1284         free(ddf);
1285         st->sb = NULL;
1286 }
1287
1288 static struct supertype *match_metadata_desc_ddf(char *arg)
1289 {
1290         /* 'ddf' only supports containers */
1291         struct supertype *st;
1292         if (strcmp(arg, "ddf") != 0 &&
1293             strcmp(arg, "default") != 0
1294                 )
1295                 return NULL;
1296
1297         st = xcalloc(1, sizeof(*st));
1298         st->ss = &super_ddf;
1299         st->max_devs = 512;
1300         st->minor_version = 0;
1301         st->sb = NULL;
1302         return st;
1303 }
1304
1305 static mapping_t ddf_state[] = {
1306         { "Optimal", 0},
1307         { "Degraded", 1},
1308         { "Deleted", 2},
1309         { "Missing", 3},
1310         { "Failed", 4},
1311         { "Partially Optimal", 5},
1312         { "-reserved-", 6},
1313         { "-reserved-", 7},
1314         { NULL, 0}
1315 };
1316
1317 static mapping_t ddf_init_state[] = {
1318         { "Not Initialised", 0},
1319         { "QuickInit in Progress", 1},
1320         { "Fully Initialised", 2},
1321         { "*UNKNOWN*", 3},
1322         { NULL, 0}
1323 };
1324 static mapping_t ddf_access[] = {
1325         { "Read/Write", 0},
1326         { "Reserved", 1},
1327         { "Read Only", 2},
1328         { "Blocked (no access)", 3},
1329         { NULL ,0}
1330 };
1331
1332 static mapping_t ddf_level[] = {
1333         { "RAID0", DDF_RAID0},
1334         { "RAID1", DDF_RAID1},
1335         { "RAID3", DDF_RAID3},
1336         { "RAID4", DDF_RAID4},
1337         { "RAID5", DDF_RAID5},
1338         { "RAID1E",DDF_RAID1E},
1339         { "JBOD",  DDF_JBOD},
1340         { "CONCAT",DDF_CONCAT},
1341         { "RAID5E",DDF_RAID5E},
1342         { "RAID5EE",DDF_RAID5EE},
1343         { "RAID6", DDF_RAID6},
1344         { NULL, 0}
1345 };
1346 static mapping_t ddf_sec_level[] = {
1347         { "Striped", DDF_2STRIPED},
1348         { "Mirrored", DDF_2MIRRORED},
1349         { "Concat", DDF_2CONCAT},
1350         { "Spanned", DDF_2SPANNED},
1351         { NULL, 0}
1352 };
1353
1354 static int all_ff(const char *guid)
1355 {
1356         int i;
1357         for (i = 0; i < DDF_GUID_LEN; i++)
1358                 if (guid[i] != (char)0xff)
1359                         return 0;
1360         return 1;
1361 }
1362
1363 static const char *guid_str(const char *guid)
1364 {
1365         static char buf[DDF_GUID_LEN*2+1];
1366         int i;
1367         char *p = buf;
1368         for (i = 0; i < DDF_GUID_LEN; i++) {
1369                 unsigned char c = guid[i];
1370                 if (c >= 32 && c < 127)
1371                         p += sprintf(p, "%c", c);
1372                 else
1373                         p += sprintf(p, "%02x", c);
1374         }
1375         *p = '\0';
1376         return (const char *) buf;
1377 }
1378
1379 static void print_guid(char *guid, int tstamp)
1380 {
1381         /* A GUIDs are part (or all) ASCII and part binary.
1382          * They tend to be space padded.
1383          * We print the GUID in HEX, then in parentheses add
1384          * any initial ASCII sequence, and a possible
1385          * time stamp from bytes 16-19
1386          */
1387         int l = DDF_GUID_LEN;
1388         int i;
1389
1390         for (i=0 ; i<DDF_GUID_LEN ; i++) {
1391                 if ((i&3)==0 && i != 0) printf(":");
1392                 printf("%02X", guid[i]&255);
1393         }
1394
1395         printf("\n                  (");
1396         while (l && guid[l-1] == ' ')
1397                 l--;
1398         for (i=0 ; i<l ; i++) {
1399                 if (guid[i] >= 0x20 && guid[i] < 0x7f)
1400                         fputc(guid[i], stdout);
1401                 else
1402                         break;
1403         }
1404         if (tstamp) {
1405                 time_t then = __be32_to_cpu(*(__u32*)(guid+16)) + DECADE;
1406                 char tbuf[100];
1407                 struct tm *tm;
1408                 tm = localtime(&then);
1409                 strftime(tbuf, 100, " %D %T",tm);
1410                 fputs(tbuf, stdout);
1411         }
1412         printf(")");
1413 }
1414
1415 static void examine_vd(int n, struct ddf_super *sb, char *guid)
1416 {
1417         int crl = sb->conf_rec_len;
1418         struct vcl *vcl;
1419
1420         for (vcl = sb->conflist ; vcl ; vcl = vcl->next) {
1421                 unsigned int i;
1422                 struct vd_config *vc = &vcl->conf;
1423
1424                 if (!be32_eq(calc_crc(vc, crl*512), vc->crc))
1425                         continue;
1426                 if (memcmp(vc->guid, guid, DDF_GUID_LEN) != 0)
1427                         continue;
1428
1429                 /* Ok, we know about this VD, let's give more details */
1430                 printf(" Raid Devices[%d] : %d (", n,
1431                        be16_to_cpu(vc->prim_elmnt_count));
1432                 for (i = 0; i < be16_to_cpu(vc->prim_elmnt_count); i++) {
1433                         int j;
1434                         int cnt = be16_to_cpu(sb->phys->max_pdes);
1435                         for (j=0; j<cnt; j++)
1436                                 if (be32_eq(vc->phys_refnum[i],
1437                                             sb->phys->entries[j].refnum))
1438                                         break;
1439                         if (i) printf(" ");
1440                         if (j < cnt)
1441                                 printf("%d", j);
1442                         else
1443                                 printf("--");
1444                         printf("@%lluK", (unsigned long long) be64_to_cpu(LBA_OFFSET(sb, vc)[i])/2);
1445                 }
1446                 printf(")\n");
1447                 if (vc->chunk_shift != 255)
1448                         printf("   Chunk Size[%d] : %d sectors\n", n,
1449                                1 << vc->chunk_shift);
1450                 printf("   Raid Level[%d] : %s\n", n,
1451                        map_num(ddf_level, vc->prl)?:"-unknown-");
1452                 if (vc->sec_elmnt_count != 1) {
1453                         printf("  Secondary Position[%d] : %d of %d\n", n,
1454                                vc->sec_elmnt_seq, vc->sec_elmnt_count);
1455                         printf("  Secondary Level[%d] : %s\n", n,
1456                                map_num(ddf_sec_level, vc->srl) ?: "-unknown-");
1457                 }
1458                 printf("  Device Size[%d] : %llu\n", n,
1459                        be64_to_cpu(vc->blocks)/2);
1460                 printf("   Array Size[%d] : %llu\n", n,
1461                        be64_to_cpu(vc->array_blocks)/2);
1462         }
1463 }
1464
1465 static void examine_vds(struct ddf_super *sb)
1466 {
1467         int cnt = be16_to_cpu(sb->virt->populated_vdes);
1468         unsigned int i;
1469         printf("  Virtual Disks : %d\n", cnt);
1470
1471         for (i = 0; i < be16_to_cpu(sb->virt->max_vdes); i++) {
1472                 struct virtual_entry *ve = &sb->virt->entries[i];
1473                 if (all_ff(ve->guid))
1474                         continue;
1475                 printf("\n");
1476                 printf("      VD GUID[%d] : ", i); print_guid(ve->guid, 1);
1477                 printf("\n");
1478                 printf("         unit[%d] : %d\n", i, be16_to_cpu(ve->unit));
1479                 printf("        state[%d] : %s, %s%s\n", i,
1480                        map_num(ddf_state, ve->state & 7),
1481                        (ve->state & DDF_state_morphing) ? "Morphing, ": "",
1482                        (ve->state & DDF_state_inconsistent)? "Not Consistent" : "Consistent");
1483                 printf("   init state[%d] : %s\n", i,
1484                        map_num(ddf_init_state, ve->init_state&DDF_initstate_mask));
1485                 printf("       access[%d] : %s\n", i,
1486                        map_num(ddf_access, (ve->init_state & DDF_access_mask) >> 6));
1487                 printf("         Name[%d] : %.16s\n", i, ve->name);
1488                 examine_vd(i, sb, ve->guid);
1489         }
1490         if (cnt) printf("\n");
1491 }
1492
1493 static void examine_pds(struct ddf_super *sb)
1494 {
1495         int cnt = be16_to_cpu(sb->phys->max_pdes);
1496         int i;
1497         struct dl *dl;
1498         int unlisted = 0;
1499         printf(" Physical Disks : %d\n", cnt);
1500         printf("      Number    RefNo      Size       Device      Type/State\n");
1501
1502         for (dl = sb->dlist; dl; dl = dl->next)
1503                 dl->displayed = 0;
1504
1505         for (i=0 ; i<cnt ; i++) {
1506                 struct phys_disk_entry *pd = &sb->phys->entries[i];
1507                 int type = be16_to_cpu(pd->type);
1508                 int state = be16_to_cpu(pd->state);
1509
1510                 if (be32_to_cpu(pd->refnum) == 0xffffffff)
1511                         /* Not in use */
1512                         continue;
1513                 //printf("      PD GUID[%d] : ", i); print_guid(pd->guid, 0);
1514                 //printf("\n");
1515                 printf("       %3d    %08x  ", i,
1516                        be32_to_cpu(pd->refnum));
1517                 printf("%8lluK ",
1518                        be64_to_cpu(pd->config_size)>>1);
1519                 for (dl = sb->dlist; dl ; dl = dl->next) {
1520                         if (be32_eq(dl->disk.refnum, pd->refnum)) {
1521                                 char *dv = map_dev(dl->major, dl->minor, 0);
1522                                 if (dv) {
1523                                         printf("%-15s", dv);
1524                                         break;
1525                                 }
1526                         }
1527                 }
1528                 if (!dl)
1529                         printf("%15s","");
1530                 else
1531                         dl->displayed = 1;
1532                 printf(" %s%s%s%s%s",
1533                        (type&2) ? "active":"",
1534                        (type&4) ? "Global-Spare":"",
1535                        (type&8) ? "spare" : "",
1536                        (type&16)? ", foreign" : "",
1537                        (type&32)? "pass-through" : "");
1538                 if (state & DDF_Failed)
1539                         /* This over-rides these three */
1540                         state &= ~(DDF_Online|DDF_Rebuilding|DDF_Transition);
1541                 printf("/%s%s%s%s%s%s%s",
1542                        (state&1)? "Online": "Offline",
1543                        (state&2)? ", Failed": "",
1544                        (state&4)? ", Rebuilding": "",
1545                        (state&8)? ", in-transition": "",
1546                        (state&16)? ", SMART-errors": "",
1547                        (state&32)? ", Unrecovered-Read-Errors": "",
1548                        (state&64)? ", Missing" : "");
1549                 printf("\n");
1550         }
1551         for (dl = sb->dlist; dl; dl = dl->next) {
1552                 char *dv;
1553                 if (dl->displayed)
1554                         continue;
1555                 if (!unlisted)
1556                         printf(" Physical disks not in metadata!:\n");
1557                 unlisted = 1;
1558                 dv = map_dev(dl->major, dl->minor, 0);
1559                 printf("   %08x %s\n", be32_to_cpu(dl->disk.refnum),
1560                        dv ? dv : "-unknown-");
1561         }
1562         if (unlisted)
1563                 printf("\n");
1564 }
1565
1566 static void examine_super_ddf(struct supertype *st, char *homehost)
1567 {
1568         struct ddf_super *sb = st->sb;
1569
1570         printf("          Magic : %08x\n", be32_to_cpu(sb->anchor.magic));
1571         printf("        Version : %.8s\n", sb->anchor.revision);
1572         printf("Controller GUID : "); print_guid(sb->controller.guid, 0);
1573         printf("\n");
1574         printf(" Container GUID : "); print_guid(sb->anchor.guid, 1);
1575         printf("\n");
1576         printf("            Seq : %08x\n", be32_to_cpu(sb->active->seq));
1577         printf("  Redundant hdr : %s\n", (be32_eq(sb->secondary.magic,
1578                                                  DDF_HEADER_MAGIC)
1579                                           ?"yes" : "no"));
1580         examine_vds(sb);
1581         examine_pds(sb);
1582 }
1583
1584 static unsigned int get_vd_num_of_subarray(struct supertype *st)
1585 {
1586         /*
1587          * Figure out the VD number for this supertype.
1588          * Returns DDF_CONTAINER for the container itself,
1589          * and DDF_NOTFOUND on error.
1590          */
1591         struct ddf_super *ddf = st->sb;
1592         struct mdinfo *sra;
1593         char *sub, *end;
1594         unsigned int vcnum;
1595
1596         if (*st->container_devnm == '\0')
1597                 return DDF_CONTAINER;
1598
1599         sra = sysfs_read(-1, st->devnm, GET_VERSION);
1600         if (!sra || sra->array.major_version != -1 ||
1601             sra->array.minor_version != -2 ||
1602             !is_subarray(sra->text_version))
1603                 return DDF_NOTFOUND;
1604
1605         sub = strchr(sra->text_version + 1, '/');
1606         if (sub != NULL)
1607                 vcnum = strtoul(sub + 1, &end, 10);
1608         if (sub == NULL || *sub == '\0' || *end != '\0' ||
1609             vcnum >= be16_to_cpu(ddf->active->max_vd_entries))
1610                 return DDF_NOTFOUND;
1611
1612         return vcnum;
1613 }
1614
1615 static void brief_examine_super_ddf(struct supertype *st, int verbose)
1616 {
1617         /* We just write a generic DDF ARRAY entry
1618          */
1619         struct mdinfo info;
1620         char nbuf[64];
1621         getinfo_super_ddf(st, &info, NULL);
1622         fname_from_uuid(st, &info, nbuf, ':');
1623
1624         printf("ARRAY metadata=ddf UUID=%s\n", nbuf + 5);
1625 }
1626
1627 static void brief_examine_subarrays_ddf(struct supertype *st, int verbose)
1628 {
1629         /* We write a DDF ARRAY member entry for each vd, identifying container
1630          * by uuid and member by unit number and uuid.
1631          */
1632         struct ddf_super *ddf = st->sb;
1633         struct mdinfo info;
1634         unsigned int i;
1635         char nbuf[64];
1636         getinfo_super_ddf(st, &info, NULL);
1637         fname_from_uuid(st, &info, nbuf, ':');
1638
1639         for (i = 0; i < be16_to_cpu(ddf->virt->max_vdes); i++) {
1640                 struct virtual_entry *ve = &ddf->virt->entries[i];
1641                 struct vcl vcl;
1642                 char nbuf1[64];
1643                 char namebuf[17];
1644                 if (all_ff(ve->guid))
1645                         continue;
1646                 memcpy(vcl.conf.guid, ve->guid, DDF_GUID_LEN);
1647                 ddf->currentconf =&vcl;
1648                 vcl.vcnum = i;
1649                 uuid_from_super_ddf(st, info.uuid);
1650                 fname_from_uuid(st, &info, nbuf1, ':');
1651                 _ddf_array_name(namebuf, ddf, i);
1652                 printf("ARRAY%s%s container=%s member=%d UUID=%s\n",
1653                        namebuf[0] == '\0' ? "" : " /dev/md/", namebuf,
1654                        nbuf+5, i, nbuf1+5);
1655         }
1656 }
1657
1658 static void export_examine_super_ddf(struct supertype *st)
1659 {
1660         struct mdinfo info;
1661         char nbuf[64];
1662         getinfo_super_ddf(st, &info, NULL);
1663         fname_from_uuid(st, &info, nbuf, ':');
1664         printf("MD_METADATA=ddf\n");
1665         printf("MD_LEVEL=container\n");
1666         printf("MD_UUID=%s\n", nbuf+5);
1667         printf("MD_DEVICES=%u\n",
1668                 be16_to_cpu(((struct ddf_super *)st->sb)->phys->used_pdes));
1669 }
1670
1671 static int copy_metadata_ddf(struct supertype *st, int from, int to)
1672 {
1673         void *buf;
1674         unsigned long long dsize, offset;
1675         int bytes;
1676         struct ddf_header *ddf;
1677         int written = 0;
1678
1679         /* The meta consists of an anchor, a primary, and a secondary.
1680          * This all lives at the end of the device.
1681          * So it is easiest to find the earliest of primary and
1682          * secondary, and copy everything from there.
1683          *
1684          * Anchor is 512 from end.  It contains primary_lba and secondary_lba
1685          * we choose one of those
1686          */
1687
1688         if (posix_memalign(&buf, 4096, 4096) != 0)
1689                 return 1;
1690
1691         if (!get_dev_size(from, NULL, &dsize))
1692                 goto err;
1693
1694         if (lseek64(from, dsize-512, 0) < 0)
1695                 goto err;
1696         if (read(from, buf, 512) != 512)
1697                 goto err;
1698         ddf = buf;
1699         if (!be32_eq(ddf->magic, DDF_HEADER_MAGIC) ||
1700             !be32_eq(calc_crc(ddf, 512), ddf->crc) ||
1701             (memcmp(ddf->revision, DDF_REVISION_0, 8) != 0 &&
1702              memcmp(ddf->revision, DDF_REVISION_2, 8) != 0))
1703                 goto err;
1704
1705         offset = dsize - 512;
1706         if ((be64_to_cpu(ddf->primary_lba) << 9) < offset)
1707                 offset = be64_to_cpu(ddf->primary_lba) << 9;
1708         if ((be64_to_cpu(ddf->secondary_lba) << 9) < offset)
1709                 offset = be64_to_cpu(ddf->secondary_lba) << 9;
1710
1711         bytes = dsize - offset;
1712
1713         if (lseek64(from, offset, 0) < 0 ||
1714             lseek64(to, offset, 0) < 0)
1715                 goto err;
1716         while (written < bytes) {
1717                 int n = bytes - written;
1718                 if (n > 4096)
1719                         n = 4096;
1720                 if (read(from, buf, n) != n)
1721                         goto err;
1722                 if (write(to, buf, n) != n)
1723                         goto err;
1724                 written += n;
1725         }
1726         free(buf);
1727         return 0;
1728 err:
1729         free(buf);
1730         return 1;
1731 }
1732
1733 static void detail_super_ddf(struct supertype *st, char *homehost,
1734                              char *subarray)
1735 {
1736         struct ddf_super *sb = st->sb;
1737         int cnt = be16_to_cpu(sb->virt->populated_vdes);
1738
1739         printf("    Container GUID : "); print_guid(sb->anchor.guid, 1);
1740         printf("\n");
1741         printf("               Seq : %08x\n", be32_to_cpu(sb->active->seq));
1742         printf("     Virtual Disks : %d\n", cnt);
1743         printf("\n");
1744 }
1745
1746 static const char *vendors_with_variable_volume_UUID[] = {
1747         "LSI      ",
1748 };
1749
1750 static int volume_id_is_reliable(const struct ddf_super *ddf)
1751 {
1752         int n = ARRAY_SIZE(vendors_with_variable_volume_UUID);
1753         int i;
1754         for (i = 0; i < n; i++)
1755                 if (!memcmp(ddf->controller.guid,
1756                         vendors_with_variable_volume_UUID[i], 8))
1757                 return 0;
1758         return 1;
1759 }
1760
1761 static void uuid_of_ddf_subarray(const struct ddf_super *ddf,
1762                                  unsigned int vcnum, int uuid[4])
1763 {
1764         char buf[DDF_GUID_LEN+18], sha[20], *p;
1765         struct sha1_ctx ctx;
1766         if (volume_id_is_reliable(ddf)) {
1767                 uuid_from_ddf_guid(ddf->virt->entries[vcnum].guid, uuid);
1768                 return;
1769         }
1770         /*
1771          * Some fake RAID BIOSes (in particular, LSI ones) change the
1772          * VD GUID at every boot. These GUIDs are not suitable for
1773          * identifying an array. Luckily the header GUID appears to
1774          * remain constant.
1775          * We construct a pseudo-UUID from the header GUID and those
1776          * properties of the subarray that we expect to remain constant.
1777          */
1778         memset(buf, 0, sizeof(buf));
1779         p = buf;
1780         memcpy(p, ddf->anchor.guid, DDF_GUID_LEN);
1781         p += DDF_GUID_LEN;
1782         memcpy(p, ddf->virt->entries[vcnum].name, 16);
1783         p += 16;
1784         *((__u16 *) p) = vcnum;
1785         sha1_init_ctx(&ctx);
1786         sha1_process_bytes(buf, sizeof(buf), &ctx);
1787         sha1_finish_ctx(&ctx, sha);
1788         memcpy(uuid, sha, 4*4);
1789 }
1790
1791 static void brief_detail_super_ddf(struct supertype *st, char *subarray)
1792 {
1793         struct mdinfo info;
1794         char nbuf[64];
1795         struct ddf_super *ddf = st->sb;
1796         unsigned int vcnum = get_vd_num_of_subarray(st);
1797         if (vcnum == DDF_CONTAINER)
1798                 uuid_from_super_ddf(st, info.uuid);
1799         else if (vcnum == DDF_NOTFOUND)
1800                 return;
1801         else
1802                 uuid_of_ddf_subarray(ddf, vcnum, info.uuid);
1803         fname_from_uuid(st, &info, nbuf,':');
1804         printf(" UUID=%s", nbuf + 5);
1805 }
1806
1807 static int match_home_ddf(struct supertype *st, char *homehost)
1808 {
1809         /* It matches 'this' host if the controller is a
1810          * Linux-MD controller with vendor_data matching
1811          * the hostname.  It would be nice if we could
1812          * test against controller found in /sys or somewhere...
1813          */
1814         struct ddf_super *ddf = st->sb;
1815         unsigned int len;
1816
1817         if (!homehost)
1818                 return 0;
1819         len = strlen(homehost);
1820
1821         return (memcmp(ddf->controller.guid, T10, 8) == 0 &&
1822                 len < sizeof(ddf->controller.vendor_data) &&
1823                 memcmp(ddf->controller.vendor_data, homehost,len) == 0 &&
1824                 ddf->controller.vendor_data[len] == 0);
1825 }
1826
1827 static int find_index_in_bvd(const struct ddf_super *ddf,
1828                              const struct vd_config *conf, unsigned int n,
1829                              unsigned int *n_bvd)
1830 {
1831         /*
1832          * Find the index of the n-th valid physical disk in this BVD.
1833          * Unused entries can be sprinkled in with the used entries,
1834          * but don't count.
1835          */
1836         unsigned int i, j;
1837         for (i = 0, j = 0;
1838              i < ddf->mppe && j < be16_to_cpu(conf->prim_elmnt_count);
1839              i++) {
1840                 if (be32_to_cpu(conf->phys_refnum[i]) != 0xffffffff) {
1841                         if (n == j) {
1842                                 *n_bvd = i;
1843                                 return 1;
1844                         }
1845                         j++;
1846                 }
1847         }
1848         dprintf("couldn't find BVD member %u (total %u)\n",
1849                 n, be16_to_cpu(conf->prim_elmnt_count));
1850         return 0;
1851 }
1852
1853 /* Given a member array instance number, and a raid disk within that instance,
1854  * find the vd_config structure.  The offset of the given disk in the phys_refnum
1855  * table is returned in n_bvd.
1856  * For two-level members with a secondary raid level the vd_config for
1857  * the appropriate BVD is returned.
1858  * The return value is always &vlc->conf, where vlc is returned in last pointer.
1859  */
1860 static struct vd_config *find_vdcr(struct ddf_super *ddf, unsigned int inst,
1861                                    unsigned int n,
1862                                    unsigned int *n_bvd, struct vcl **vcl)
1863 {
1864         struct vcl *v;
1865
1866         for (v = ddf->conflist; v; v = v->next) {
1867                 unsigned int nsec, ibvd = 0;
1868                 struct vd_config *conf;
1869                 if (inst != v->vcnum)
1870                         continue;
1871                 conf = &v->conf;
1872                 if (conf->sec_elmnt_count == 1) {
1873                         if (find_index_in_bvd(ddf, conf, n, n_bvd)) {
1874                                 *vcl = v;
1875                                 return conf;
1876                         } else
1877                                 goto bad;
1878                 }
1879                 if (v->other_bvds == NULL) {
1880                         pr_err("BUG: other_bvds is NULL, nsec=%u\n",
1881                                conf->sec_elmnt_count);
1882                         goto bad;
1883                 }
1884                 nsec = n / be16_to_cpu(conf->prim_elmnt_count);
1885                 if (conf->sec_elmnt_seq != nsec) {
1886                         for (ibvd = 1; ibvd < conf->sec_elmnt_count; ibvd++) {
1887                                 if (v->other_bvds[ibvd-1]->sec_elmnt_seq ==
1888                                     nsec)
1889                                         break;
1890                         }
1891                         if (ibvd == conf->sec_elmnt_count)
1892                                 goto bad;
1893                         conf = v->other_bvds[ibvd-1];
1894                 }
1895                 if (!find_index_in_bvd(ddf, conf,
1896                                        n - nsec*conf->sec_elmnt_count, n_bvd))
1897                         goto bad;
1898                 dprintf("found disk %u as member %u in bvd %d of array %u\n",
1899                         n, *n_bvd, ibvd, inst);
1900                 *vcl = v;
1901                 return conf;
1902         }
1903 bad:
1904         pr_err("Couldn't find disk %d in array %u\n", n, inst);
1905         return NULL;
1906 }
1907
1908 static int find_phys(const struct ddf_super *ddf, be32 phys_refnum)
1909 {
1910         /* Find the entry in phys_disk which has the given refnum
1911          * and return it's index
1912          */
1913         unsigned int i;
1914         for (i = 0; i < be16_to_cpu(ddf->phys->max_pdes); i++)
1915                 if (be32_eq(ddf->phys->entries[i].refnum, phys_refnum))
1916                         return i;
1917         return -1;
1918 }
1919
1920 static void uuid_from_ddf_guid(const char *guid, int uuid[4])
1921 {
1922         char buf[20];
1923         struct sha1_ctx ctx;
1924         sha1_init_ctx(&ctx);
1925         sha1_process_bytes(guid, DDF_GUID_LEN, &ctx);
1926         sha1_finish_ctx(&ctx, buf);
1927         memcpy(uuid, buf, 4*4);
1928 }
1929
1930 static void uuid_from_super_ddf(struct supertype *st, int uuid[4])
1931 {
1932         /* The uuid returned here is used for:
1933          *  uuid to put into bitmap file (Create, Grow)
1934          *  uuid for backup header when saving critical section (Grow)
1935          *  comparing uuids when re-adding a device into an array
1936          *    In these cases the uuid required is that of the data-array,
1937          *    not the device-set.
1938          *  uuid to recognise same set when adding a missing device back
1939          *    to an array.   This is a uuid for the device-set.
1940          *
1941          * For each of these we can make do with a truncated
1942          * or hashed uuid rather than the original, as long as
1943          * everyone agrees.
1944          * In the case of SVD we assume the BVD is of interest,
1945          * though that might be the case if a bitmap were made for
1946          * a mirrored SVD - worry about that later.
1947          * So we need to find the VD configuration record for the
1948          * relevant BVD and extract the GUID and Secondary_Element_Seq.
1949          * The first 16 bytes of the sha1 of these is used.
1950          */
1951         struct ddf_super *ddf = st->sb;
1952         struct vcl *vcl = ddf->currentconf;
1953
1954         if (vcl)
1955                 uuid_of_ddf_subarray(ddf, vcl->vcnum, uuid);
1956         else
1957                 uuid_from_ddf_guid(ddf->anchor.guid, uuid);
1958 }
1959
1960 static void getinfo_super_ddf(struct supertype *st, struct mdinfo *info, char *map)
1961 {
1962         struct ddf_super *ddf = st->sb;
1963         int map_disks = info->array.raid_disks;
1964         __u32 *cptr;
1965
1966         if (ddf->currentconf) {
1967                 getinfo_super_ddf_bvd(st, info, map);
1968                 return;
1969         }
1970         memset(info, 0, sizeof(*info));
1971
1972         info->array.raid_disks    = be16_to_cpu(ddf->phys->used_pdes);
1973         info->array.level         = LEVEL_CONTAINER;
1974         info->array.layout        = 0;
1975         info->array.md_minor      = -1;
1976         cptr = (__u32 *)(ddf->anchor.guid + 16);
1977         info->array.ctime         = DECADE + __be32_to_cpu(*cptr);
1978
1979         info->array.chunk_size    = 0;
1980         info->container_enough    = 1;
1981
1982         info->disk.major          = 0;
1983         info->disk.minor          = 0;
1984         if (ddf->dlist) {
1985                 struct phys_disk_entry *pde = NULL;
1986                 info->disk.number = be32_to_cpu(ddf->dlist->disk.refnum);
1987                 info->disk.raid_disk = find_phys(ddf, ddf->dlist->disk.refnum);
1988
1989                 info->data_offset = be64_to_cpu(ddf->phys->
1990                                                   entries[info->disk.raid_disk].
1991                                                   config_size);
1992                 info->component_size = ddf->dlist->size - info->data_offset;
1993                 if (info->disk.raid_disk >= 0)
1994                         pde = ddf->phys->entries + info->disk.raid_disk;
1995                 if (pde &&
1996                     !(be16_to_cpu(pde->state) & DDF_Failed) &&
1997                     !(be16_to_cpu(pde->state) & DDF_Missing))
1998                         info->disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
1999                 else
2000                         info->disk.state = 1 << MD_DISK_FAULTY;
2001
2002         } else {
2003                 /* There should always be a dlist, but just in case...*/
2004                 info->disk.number = -1;
2005                 info->disk.raid_disk = -1;
2006                 info->disk.state = (1 << MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE);
2007         }
2008         info->events = be32_to_cpu(ddf->active->seq);
2009         info->array.utime = DECADE + be32_to_cpu(ddf->active->timestamp);
2010
2011         info->recovery_start = MaxSector;
2012         info->reshape_active = 0;
2013         info->recovery_blocked = 0;
2014         info->name[0] = 0;
2015
2016         info->array.major_version = -1;
2017         info->array.minor_version = -2;
2018         strcpy(info->text_version, "ddf");
2019         info->safe_mode_delay = 0;
2020
2021         uuid_from_super_ddf(st, info->uuid);
2022
2023         if (map) {
2024                 int i, e = 0;
2025                 int max = be16_to_cpu(ddf->phys->max_pdes);
2026                 for (i = e = 0 ; i < map_disks ; i++, e++) {
2027                         while (e < max &&
2028                                be32_to_cpu(ddf->phys->entries[e].refnum) == 0xffffffff)
2029                                 e++;
2030                         if (i < info->array.raid_disks && e < max &&
2031                             !(be16_to_cpu(ddf->phys->entries[e].state) &
2032                               DDF_Failed))
2033                                 map[i] = 1;
2034                         else
2035                                 map[i] = 0;
2036                 }
2037         }
2038 }
2039
2040 /* size of name must be at least 17 bytes! */
2041 static void _ddf_array_name(char *name, const struct ddf_super *ddf, int i)
2042 {
2043         int j;
2044         memcpy(name, ddf->virt->entries[i].name, 16);
2045         name[16] = 0;
2046         for(j = 0; j < 16; j++)
2047                 if (name[j] == ' ')
2048                         name[j] = 0;
2049 }
2050
2051 static void getinfo_super_ddf_bvd(struct supertype *st, struct mdinfo *info, char *map)
2052 {
2053         struct ddf_super *ddf = st->sb;
2054         struct vcl *vc = ddf->currentconf;
2055         int cd = ddf->currentdev;
2056         int n_prim;
2057         int j;
2058         struct dl *dl = NULL;
2059         int map_disks = info->array.raid_disks;
2060         __u32 *cptr;
2061         struct vd_config *conf;
2062
2063         memset(info, 0, sizeof(*info));
2064         if (layout_ddf2md(&vc->conf, &info->array) == -1)
2065                 return;
2066         info->array.md_minor      = -1;
2067         cptr = (__u32 *)(vc->conf.guid + 16);
2068         info->array.ctime         = DECADE + __be32_to_cpu(*cptr);
2069         info->array.utime         = DECADE + be32_to_cpu(vc->conf.timestamp);
2070         info->array.chunk_size    = 512 << vc->conf.chunk_shift;
2071         info->custom_array_size   = be64_to_cpu(vc->conf.array_blocks);
2072
2073         conf = &vc->conf;
2074         n_prim = be16_to_cpu(conf->prim_elmnt_count);
2075         if (conf->sec_elmnt_count > 1 && cd >= n_prim) {
2076                 int ibvd = cd / n_prim - 1;
2077                 cd %= n_prim;
2078                 conf = vc->other_bvds[ibvd];
2079         }
2080
2081         if (cd >= 0 && (unsigned)cd < ddf->mppe) {
2082                 info->data_offset =
2083                         be64_to_cpu(LBA_OFFSET(ddf, conf)[cd]);
2084                 if (vc->block_sizes)
2085                         info->component_size = vc->block_sizes[cd];
2086                 else
2087                         info->component_size = be64_to_cpu(conf->blocks);
2088
2089                 for (dl = ddf->dlist; dl ; dl = dl->next)
2090                         if (be32_eq(dl->disk.refnum, conf->phys_refnum[cd]))
2091                                 break;
2092         }
2093
2094         info->disk.major = 0;
2095         info->disk.minor = 0;
2096         info->disk.state = 0;
2097         if (dl && dl->pdnum >= 0) {
2098                 info->disk.major = dl->major;
2099                 info->disk.minor = dl->minor;
2100                 info->disk.raid_disk = cd + conf->sec_elmnt_seq
2101                         * be16_to_cpu(conf->prim_elmnt_count);
2102                 info->disk.number = dl->pdnum;
2103                 info->disk.state = 0;
2104                 if (info->disk.number >= 0 &&
2105                     (be16_to_cpu(ddf->phys->entries[info->disk.number].state) & DDF_Online) &&
2106                     !(be16_to_cpu(ddf->phys->entries[info->disk.number].state) & DDF_Failed))
2107                         info->disk.state = (1<<MD_DISK_SYNC)|(1<<MD_DISK_ACTIVE);
2108                 info->events = be32_to_cpu(ddf->active->seq);
2109         }
2110
2111         info->container_member = ddf->currentconf->vcnum;
2112
2113         info->recovery_start = MaxSector;
2114         info->resync_start = 0;
2115         info->reshape_active = 0;
2116         info->recovery_blocked = 0;
2117         if (!(ddf->virt->entries[info->container_member].state &
2118               DDF_state_inconsistent) &&
2119             (ddf->virt->entries[info->container_member].init_state &
2120              DDF_initstate_mask) == DDF_init_full)
2121                 info->resync_start = MaxSector;
2122
2123         uuid_from_super_ddf(st, info->uuid);
2124
2125         info->array.major_version = -1;
2126         info->array.minor_version = -2;
2127         sprintf(info->text_version, "/%s/%d",
2128                 st->container_devnm,
2129                 info->container_member);
2130         info->safe_mode_delay = DDF_SAFE_MODE_DELAY;
2131
2132         _ddf_array_name(info->name, ddf, info->container_member);
2133
2134         if (map)
2135                 for (j = 0; j < map_disks; j++) {
2136                         map[j] = 0;
2137                         if (j < info->array.raid_disks) {
2138                                 int i = find_phys(ddf, vc->conf.phys_refnum[j]);
2139                                 if (i >= 0 &&
2140                                     (be16_to_cpu(ddf->phys->entries[i].state)
2141                                      & DDF_Online) &&
2142                                     !(be16_to_cpu(ddf->phys->entries[i].state)
2143                                       & DDF_Failed))
2144                                         map[i] = 1;
2145                         }
2146                 }
2147 }
2148
2149 static int update_super_ddf(struct supertype *st, struct mdinfo *info,
2150                             char *update,
2151                             char *devname, int verbose,
2152                             int uuid_set, char *homehost)
2153 {
2154         /* For 'assemble' and 'force' we need to return non-zero if any
2155          * change was made.  For others, the return value is ignored.
2156          * Update options are:
2157          *  force-one : This device looks a bit old but needs to be included,
2158          *        update age info appropriately.
2159          *  assemble: clear any 'faulty' flag to allow this device to
2160          *              be assembled.
2161          *  force-array: Array is degraded but being forced, mark it clean
2162          *         if that will be needed to assemble it.
2163          *
2164          *  newdev:  not used ????
2165          *  grow:  Array has gained a new device - this is currently for
2166          *              linear only
2167          *  resync: mark as dirty so a resync will happen.
2168          *  uuid:  Change the uuid of the array to match what is given
2169          *  homehost:  update the recorded homehost
2170          *  name:  update the name - preserving the homehost
2171          *  _reshape_progress: record new reshape_progress position.
2172          *
2173          * Following are not relevant for this version:
2174          *  sparc2.2 : update from old dodgey metadata
2175          *  super-minor: change the preferred_minor number
2176          *  summaries:  update redundant counters.
2177          */
2178         int rv = 0;
2179 //      struct ddf_super *ddf = st->sb;
2180 //      struct vd_config *vd = find_vdcr(ddf, info->container_member);
2181 //      struct virtual_entry *ve = find_ve(ddf);
2182
2183         /* we don't need to handle "force-*" or "assemble" as
2184          * there is no need to 'trick' the kernel.  When the metadata is
2185          * first updated to activate the array, all the implied modifications
2186          * will just happen.
2187          */
2188
2189         if (strcmp(update, "grow") == 0) {
2190                 /* FIXME */
2191         } else if (strcmp(update, "resync") == 0) {
2192 //              info->resync_checkpoint = 0;
2193         } else if (strcmp(update, "homehost") == 0) {
2194                 /* homehost is stored in controller->vendor_data,
2195                  * or it is when we are the vendor
2196                  */
2197 //              if (info->vendor_is_local)
2198 //                      strcpy(ddf->controller.vendor_data, homehost);
2199                 rv = -1;
2200         } else if (strcmp(update, "name") == 0) {
2201                 /* name is stored in virtual_entry->name */
2202 //              memset(ve->name, ' ', 16);
2203 //              strncpy(ve->name, info->name, 16);
2204                 rv = -1;
2205         } else if (strcmp(update, "_reshape_progress") == 0) {
2206                 /* We don't support reshape yet */
2207         } else if (strcmp(update, "assemble") == 0 ) {
2208                 /* Do nothing, just succeed */
2209                 rv = 0;
2210         } else
2211                 rv = -1;
2212
2213 //      update_all_csum(ddf);
2214
2215         return rv;
2216 }
2217
2218 static void make_header_guid(char *guid)
2219 {
2220         be32 stamp;
2221         /* Create a DDF Header of Virtual Disk GUID */
2222
2223         /* 24 bytes of fiction required.
2224          * first 8 are a 'vendor-id'  - "Linux-MD"
2225          * next 8 are controller type.. how about 0X DEAD BEEF 0000 0000
2226          * Remaining 8 random number plus timestamp
2227          */
2228         memcpy(guid, T10, sizeof(T10));
2229         stamp = cpu_to_be32(0xdeadbeef);
2230         memcpy(guid+8, &stamp, 4);
2231         stamp = cpu_to_be32(0);
2232         memcpy(guid+12, &stamp, 4);
2233         stamp = cpu_to_be32(time(0) - DECADE);
2234         memcpy(guid+16, &stamp, 4);
2235         stamp._v32 = random32();
2236         memcpy(guid+20, &stamp, 4);
2237 }
2238
2239 static unsigned int find_unused_vde(const struct ddf_super *ddf)
2240 {
2241         unsigned int i;
2242         for (i = 0; i < be16_to_cpu(ddf->virt->max_vdes); i++) {
2243                 if (all_ff(ddf->virt->entries[i].guid))
2244                         return i;
2245         }
2246         return DDF_NOTFOUND;
2247 }
2248
2249 static unsigned int find_vde_by_name(const struct ddf_super *ddf,
2250                                      const char *name)
2251 {
2252         unsigned int i;
2253         if (name == NULL)
2254                 return DDF_NOTFOUND;
2255         for (i = 0; i < be16_to_cpu(ddf->virt->max_vdes); i++) {
2256                 if (all_ff(ddf->virt->entries[i].guid))
2257                         continue;
2258                 if (!strncmp(name, ddf->virt->entries[i].name,
2259                              sizeof(ddf->virt->entries[i].name)))
2260                         return i;
2261         }
2262         return DDF_NOTFOUND;
2263 }
2264
2265 static unsigned int find_vde_by_guid(const struct ddf_super *ddf,
2266                                      const char *guid)
2267 {
2268         unsigned int i;
2269         if (guid == NULL || all_ff(guid))
2270                 return DDF_NOTFOUND;
2271         for (i = 0; i < be16_to_cpu(ddf->virt->max_vdes); i++)
2272                 if (!memcmp(ddf->virt->entries[i].guid, guid, DDF_GUID_LEN))
2273                         return i;
2274         return DDF_NOTFOUND;
2275 }
2276
2277 static int init_super_ddf(struct supertype *st,
2278                           mdu_array_info_t *info,
2279                           struct shape *s, char *name, char *homehost,
2280                           int *uuid, unsigned long long data_offset)
2281 {
2282         /* This is primarily called by Create when creating a new array.
2283          * We will then get add_to_super called for each component, and then
2284          * write_init_super called to write it out to each device.
2285          * For DDF, Create can create on fresh devices or on a pre-existing
2286          * array.
2287          * To create on a pre-existing array a different method will be called.
2288          * This one is just for fresh drives.
2289          *
2290          * We need to create the entire 'ddf' structure which includes:
2291          *  DDF headers - these are easy.
2292          *  Controller data - a Sector describing this controller .. not that
2293          *                    this is a controller exactly.
2294          *  Physical Disk Record - one entry per device, so
2295          *                         leave plenty of space.
2296          *  Virtual Disk Records - again, just leave plenty of space.
2297          *                         This just lists VDs, doesn't give details.
2298          *  Config records - describe the VDs that use this disk
2299          *  DiskData  - describes 'this' device.
2300          *  BadBlockManagement - empty
2301          *  Diag Space - empty
2302          *  Vendor Logs - Could we put bitmaps here?
2303          *
2304          */
2305         struct ddf_super *ddf;
2306         char hostname[17];
2307         int hostlen;
2308         int max_phys_disks, max_virt_disks;
2309         unsigned long long sector;
2310         int clen;
2311         int i;
2312         int pdsize, vdsize;
2313         struct phys_disk *pd;
2314         struct virtual_disk *vd;
2315
2316         if (st->sb)
2317                 return init_super_ddf_bvd(st, info, s->size, name, homehost, uuid,
2318                                           data_offset);
2319
2320         if (posix_memalign((void**)&ddf, 512, sizeof(*ddf)) != 0) {
2321                 pr_err("could not allocate superblock\n");
2322                 return 0;
2323         }
2324         memset(ddf, 0, sizeof(*ddf));
2325         st->sb = ddf;
2326
2327         if (info == NULL) {
2328                 /* zeroing superblock */
2329                 return 0;
2330         }
2331
2332         /* At least 32MB *must* be reserved for the ddf.  So let's just
2333          * start 32MB from the end, and put the primary header there.
2334          * Don't do secondary for now.
2335          * We don't know exactly where that will be yet as it could be
2336          * different on each device.  So just set up the lengths.
2337          */
2338
2339         ddf->anchor.magic = DDF_HEADER_MAGIC;
2340         make_header_guid(ddf->anchor.guid);
2341
2342         memcpy(ddf->anchor.revision, DDF_REVISION_2, 8);
2343         ddf->anchor.seq = cpu_to_be32(1);
2344         ddf->anchor.timestamp = cpu_to_be32(time(0) - DECADE);
2345         ddf->anchor.openflag = 0xFF;
2346         ddf->anchor.foreignflag = 0;
2347         ddf->anchor.enforcegroups = 0; /* Is this best?? */
2348         ddf->anchor.pad0 = 0xff;
2349         memset(ddf->anchor.pad1, 0xff, 12);
2350         memset(ddf->anchor.header_ext, 0xff, 32);
2351         ddf->anchor.primary_lba = cpu_to_be64(~(__u64)0);
2352         ddf->anchor.secondary_lba = cpu_to_be64(~(__u64)0);
2353         ddf->anchor.type = DDF_HEADER_ANCHOR;
2354         memset(ddf->anchor.pad2, 0xff, 3);
2355         ddf->anchor.workspace_len = cpu_to_be32(32768); /* Must be reserved */
2356         /* Put this at bottom of 32M reserved.. */
2357         ddf->anchor.workspace_lba = cpu_to_be64(~(__u64)0);
2358         max_phys_disks = 1023;   /* Should be enough, 4095 is also allowed */
2359         ddf->anchor.max_pd_entries = cpu_to_be16(max_phys_disks);
2360         max_virt_disks = 255; /* 15, 63, 255, 1024, 4095 are all allowed */
2361         ddf->anchor.max_vd_entries = cpu_to_be16(max_virt_disks);
2362         ddf->max_part = 64;
2363         ddf->anchor.max_partitions = cpu_to_be16(ddf->max_part);
2364         ddf->mppe = 256; /* 16, 64, 256, 1024, 4096 are all allowed */
2365         ddf->conf_rec_len = 1 + ROUND_UP(ddf->mppe * (4+8), 512)/512;
2366         ddf->anchor.config_record_len = cpu_to_be16(ddf->conf_rec_len);
2367         ddf->anchor.max_primary_element_entries = cpu_to_be16(ddf->mppe);
2368         memset(ddf->anchor.pad3, 0xff, 54);
2369         /* Controller section is one sector long immediately
2370          * after the ddf header */
2371         sector = 1;
2372         ddf->anchor.controller_section_offset = cpu_to_be32(sector);
2373         ddf->anchor.controller_section_length = cpu_to_be32(1);
2374         sector += 1;
2375
2376         /* phys is 8 sectors after that */
2377         pdsize = ROUND_UP(sizeof(struct phys_disk) +
2378                           sizeof(struct phys_disk_entry)*max_phys_disks,
2379                           512);
2380         switch(pdsize/512) {
2381         case 2: case 8: case 32: case 128: case 512: break;
2382         default: abort();
2383         }
2384         ddf->anchor.phys_section_offset = cpu_to_be32(sector);
2385         ddf->anchor.phys_section_length =
2386                 cpu_to_be32(pdsize/512); /* max_primary_element_entries/8 */
2387         sector += pdsize/512;
2388
2389         /* virt is another 32 sectors */
2390         vdsize = ROUND_UP(sizeof(struct virtual_disk) +
2391                           sizeof(struct virtual_entry) * max_virt_disks,
2392                           512);
2393         switch(vdsize/512) {
2394         case 2: case 8: case 32: case 128: case 512: break;
2395         default: abort();
2396         }
2397         ddf->anchor.virt_section_offset = cpu_to_be32(sector);
2398         ddf->anchor.virt_section_length =
2399                 cpu_to_be32(vdsize/512); /* max_vd_entries/8 */
2400         sector += vdsize/512;
2401
2402         clen = ddf->conf_rec_len * (ddf->max_part+1);
2403         ddf->anchor.config_section_offset = cpu_to_be32(sector);
2404         ddf->anchor.config_section_length = cpu_to_be32(clen);
2405         sector += clen;
2406
2407         ddf->anchor.data_section_offset = cpu_to_be32(sector);
2408         ddf->anchor.data_section_length = cpu_to_be32(1);
2409         sector += 1;
2410
2411         ddf->anchor.bbm_section_length = cpu_to_be32(0);
2412         ddf->anchor.bbm_section_offset = cpu_to_be32(0xFFFFFFFF);
2413         ddf->anchor.diag_space_length = cpu_to_be32(0);
2414         ddf->anchor.diag_space_offset = cpu_to_be32(0xFFFFFFFF);
2415         ddf->anchor.vendor_length = cpu_to_be32(0);
2416         ddf->anchor.vendor_offset = cpu_to_be32(0xFFFFFFFF);
2417
2418         memset(ddf->anchor.pad4, 0xff, 256);
2419
2420         memcpy(&ddf->primary, &ddf->anchor, 512);
2421         memcpy(&ddf->secondary, &ddf->anchor, 512);
2422
2423         ddf->primary.openflag = 1; /* I guess.. */
2424         ddf->primary.type = DDF_HEADER_PRIMARY;
2425
2426         ddf->secondary.openflag = 1; /* I guess.. */
2427         ddf->secondary.type = DDF_HEADER_SECONDARY;
2428
2429         ddf->active = &ddf->primary;
2430
2431         ddf->controller.magic = DDF_CONTROLLER_MAGIC;
2432
2433         /* 24 more bytes of fiction required.
2434          * first 8 are a 'vendor-id'  - "Linux-MD"
2435          * Remaining 16 are serial number.... maybe a hostname would do?
2436          */
2437         memcpy(ddf->controller.guid, T10, sizeof(T10));
2438         gethostname(hostname, sizeof(hostname));
2439         hostname[sizeof(hostname) - 1] = 0;
2440         hostlen = strlen(hostname);
2441         memcpy(ddf->controller.guid + 24 - hostlen, hostname, hostlen);
2442         for (i = strlen(T10) ; i+hostlen < 24; i++)
2443                 ddf->controller.guid[i] = ' ';
2444
2445         ddf->controller.type.vendor_id = cpu_to_be16(0xDEAD);
2446         ddf->controller.type.device_id = cpu_to_be16(0xBEEF);
2447         ddf->controller.type.sub_vendor_id = cpu_to_be16(0);
2448         ddf->controller.type.sub_device_id = cpu_to_be16(0);
2449         memcpy(ddf->controller.product_id, "What Is My PID??", 16);
2450         memset(ddf->controller.pad, 0xff, 8);
2451         memset(ddf->controller.vendor_data, 0xff, 448);
2452         if (homehost && strlen(homehost) < 440)
2453                 strcpy((char*)ddf->controller.vendor_data, homehost);
2454
2455         if (posix_memalign((void**)&pd, 512, pdsize) != 0) {
2456                 pr_err("could not allocate pd\n");
2457                 return 0;
2458         }
2459         ddf->phys = pd;
2460         ddf->pdsize = pdsize;
2461
2462         memset(pd, 0xff, pdsize);
2463         memset(pd, 0, sizeof(*pd));
2464         pd->magic = DDF_PHYS_RECORDS_MAGIC;
2465         pd->used_pdes = cpu_to_be16(0);
2466         pd->max_pdes = cpu_to_be16(max_phys_disks);
2467         memset(pd->pad, 0xff, 52);
2468         for (i = 0; i < max_phys_disks; i++)
2469                 memset(pd->entries[i].guid, 0xff, DDF_GUID_LEN);
2470
2471         if (posix_memalign((void**)&vd, 512, vdsize) != 0) {
2472                 pr_err("could not allocate vd\n");
2473                 return 0;
2474         }
2475         ddf->virt = vd;
2476         ddf->vdsize = vdsize;
2477         memset(vd, 0, vdsize);
2478         vd->magic = DDF_VIRT_RECORDS_MAGIC;
2479         vd->populated_vdes = cpu_to_be16(0);
2480         vd->max_vdes = cpu_to_be16(max_virt_disks);
2481         memset(vd->pad, 0xff, 52);
2482
2483         for (i=0; i<max_virt_disks; i++)
2484                 memset(&vd->entries[i], 0xff, sizeof(struct virtual_entry));
2485
2486         st->sb = ddf;
2487         ddf_set_updates_pending(ddf, NULL);
2488         return 1;
2489 }
2490
2491 static int chunk_to_shift(int chunksize)
2492 {
2493         return ffs(chunksize/512)-1;
2494 }
2495
2496 struct extent {
2497         unsigned long long start, size;
2498 };
2499 static int cmp_extent(const void *av, const void *bv)
2500 {
2501         const struct extent *a = av;
2502         const struct extent *b = bv;
2503         if (a->start < b->start)
2504                 return -1;
2505         if (a->start > b->start)
2506                 return 1;
2507         return 0;
2508 }
2509
2510 static struct extent *get_extents(struct ddf_super *ddf, struct dl *dl)
2511 {
2512         /* Find a list of used extents on the given physical device
2513          * (dnum) of the given ddf.
2514          * Return a malloced array of 'struct extent'
2515          */
2516         struct extent *rv;
2517         int n = 0;
2518         unsigned int i;
2519         __u16 state;
2520
2521         if (dl->pdnum < 0)
2522                 return NULL;
2523         state = be16_to_cpu(ddf->phys->entries[dl->pdnum].state);
2524
2525         if ((state & (DDF_Online|DDF_Failed|DDF_Missing)) != DDF_Online)
2526                 return NULL;
2527
2528         rv = xmalloc(sizeof(struct extent) * (ddf->max_part + 2));
2529
2530         for (i = 0; i < ddf->max_part; i++) {
2531                 const struct vd_config *bvd;
2532                 unsigned int ibvd;
2533                 struct vcl *v = dl->vlist[i];
2534                 if (v == NULL ||
2535                     get_pd_index_from_refnum(v, dl->disk.refnum, ddf->mppe,
2536                                              &bvd, &ibvd) == DDF_NOTFOUND)
2537                         continue;
2538                 rv[n].start = be64_to_cpu(LBA_OFFSET(ddf, bvd)[ibvd]);
2539                 rv[n].size = be64_to_cpu(bvd->blocks);
2540                 n++;
2541         }
2542         qsort(rv, n, sizeof(*rv), cmp_extent);
2543
2544         rv[n].start = be64_to_cpu(ddf->phys->entries[dl->pdnum].config_size);
2545         rv[n].size = 0;
2546         return rv;
2547 }
2548
2549 static unsigned long long find_space(
2550         struct ddf_super *ddf, struct dl *dl,
2551         unsigned long long data_offset,
2552         unsigned long long *size)
2553 {
2554         /* Find if the requested amount of space is available.
2555          * If it is, return start.
2556          * If not, set *size to largest space.
2557          * If data_offset != INVALID_SECTORS, then the space must start
2558          * at this location.
2559          */
2560         struct extent *e = get_extents(ddf, dl);
2561         int i = 0;
2562         unsigned long long pos = 0;
2563         unsigned long long max_size = 0;
2564
2565         if (!e) {
2566                 *size = 0;
2567                 return INVALID_SECTORS;
2568         }
2569         do {
2570                 unsigned long long esize = e[i].start - pos;
2571                 if (data_offset != INVALID_SECTORS &&
2572                     pos <= data_offset &&
2573                     e[i].start > data_offset) {
2574                         pos = data_offset;
2575                         esize = e[i].start - pos;
2576                 }
2577                 if (data_offset != INVALID_SECTORS &&
2578                     pos != data_offset) {
2579                         i++;
2580                         continue;
2581                 }
2582                 if (esize >= *size) {
2583                         /* Found! */
2584                         free(e);
2585                         return pos;
2586                 }
2587                 if (esize > max_size)
2588                         max_size = esize;
2589                 pos = e[i].start + e[i].size;
2590                 i++;
2591         } while (e[i-1].size);
2592         *size = max_size;
2593         free(e);
2594         return INVALID_SECTORS;
2595 }
2596
2597 static int init_super_ddf_bvd(struct supertype *st,
2598                               mdu_array_info_t *info,
2599                               unsigned long long size,
2600                               char *name, char *homehost,
2601                               int *uuid, unsigned long long data_offset)
2602 {
2603         /* We are creating a BVD inside a pre-existing container.
2604          * so st->sb is already set.
2605          * We need to create a new vd_config and a new virtual_entry
2606          */
2607         struct ddf_super *ddf = st->sb;
2608         unsigned int venum, i;
2609         struct virtual_entry *ve;
2610         struct vcl *vcl;
2611         struct vd_config *vc;
2612
2613         if (find_vde_by_name(ddf, name) != DDF_NOTFOUND) {
2614                 pr_err("This ddf already has an array called %s\n", name);
2615                 return 0;
2616         }
2617         venum = find_unused_vde(ddf);
2618         if (venum == DDF_NOTFOUND) {
2619                 pr_err("Cannot find spare slot for virtual disk\n");
2620                 return 0;
2621         }
2622         ve = &ddf->virt->entries[venum];
2623
2624         /* A Virtual Disk GUID contains the T10 Vendor ID, controller type,
2625          * timestamp, random number
2626          */
2627         make_header_guid(ve->guid);
2628         ve->unit = cpu_to_be16(info->md_minor);
2629         ve->pad0 = 0xFFFF;
2630         ve->guid_crc._v16 = crc32(0, (unsigned char *)ddf->anchor.guid,
2631                                   DDF_GUID_LEN);
2632         ve->type = cpu_to_be16(0);
2633         ve->state = DDF_state_degraded; /* Will be modified as devices are added */
2634         if (info->state & 1) /* clean */
2635                 ve->init_state = DDF_init_full;
2636         else
2637                 ve->init_state = DDF_init_not;
2638
2639         memset(ve->pad1, 0xff, 14);
2640         memset(ve->name, ' ', 16);
2641         if (name)
2642                 strncpy(ve->name, name, 16);
2643         ddf->virt->populated_vdes =
2644                 cpu_to_be16(be16_to_cpu(ddf->virt->populated_vdes)+1);
2645
2646         /* Now create a new vd_config */
2647         if (posix_memalign((void**)&vcl, 512,
2648                            (offsetof(struct vcl, conf) + ddf->conf_rec_len * 512)) != 0) {
2649                 pr_err("could not allocate vd_config\n");
2650                 return 0;
2651         }
2652         vcl->vcnum = venum;
2653         vcl->block_sizes = NULL; /* FIXME not for CONCAT */
2654         vc = &vcl->conf;
2655
2656         vc->magic = DDF_VD_CONF_MAGIC;
2657         memcpy(vc->guid, ve->guid, DDF_GUID_LEN);
2658         vc->timestamp = cpu_to_be32(time(0)-DECADE);
2659         vc->seqnum = cpu_to_be32(1);
2660         memset(vc->pad0, 0xff, 24);
2661         vc->chunk_shift = chunk_to_shift(info->chunk_size);
2662         if (layout_md2ddf(info, vc) == -1 ||
2663                 be16_to_cpu(vc->prim_elmnt_count) > ddf->mppe) {
2664                 pr_err("unsupported RAID level/layout %d/%d with %d disks\n",
2665                        info->level, info->layout, info->raid_disks);
2666                 free(vcl);
2667                 return 0;
2668         }
2669         vc->sec_elmnt_seq = 0;
2670         if (alloc_other_bvds(ddf, vcl) != 0) {
2671                 pr_err("could not allocate other bvds\n");
2672                 free(vcl);
2673                 return 0;
2674         }
2675         vc->blocks = cpu_to_be64(size * 2);
2676         vc->array_blocks = cpu_to_be64(
2677                 calc_array_size(info->level, info->raid_disks, info->layout,
2678                                 info->chunk_size, size * 2));
2679         memset(vc->pad1, 0xff, 8);
2680         vc->spare_refs[0] = cpu_to_be32(0xffffffff);
2681         vc->spare_refs[1] = cpu_to_be32(0xffffffff);
2682         vc->spare_refs[2] = cpu_to_be32(0xffffffff);
2683         vc->spare_refs[3] = cpu_to_be32(0xffffffff);
2684         vc->spare_refs[4] = cpu_to_be32(0xffffffff);
2685         vc->spare_refs[5] = cpu_to_be32(0xffffffff);
2686         vc->spare_refs[6] = cpu_to_be32(0xffffffff);
2687         vc->spare_refs[7] = cpu_to_be32(0xffffffff);
2688         memset(vc->cache_pol, 0, 8);
2689         vc->bg_rate = 0x80;
2690         memset(vc->pad2, 0xff, 3);
2691         memset(vc->pad3, 0xff, 52);
2692         memset(vc->pad4, 0xff, 192);
2693         memset(vc->v0, 0xff, 32);
2694         memset(vc->v1, 0xff, 32);
2695         memset(vc->v2, 0xff, 16);
2696         memset(vc->v3, 0xff, 16);
2697         memset(vc->vendor, 0xff, 32);
2698
2699         memset(vc->phys_refnum, 0xff, 4*ddf->mppe);
2700         memset(vc->phys_refnum+ddf->mppe, 0x00, 8*ddf->mppe);
2701
2702         for (i = 1; i < vc->sec_elmnt_count; i++) {
2703                 memcpy(vcl->other_bvds[i-1], vc, ddf->conf_rec_len * 512);
2704                 vcl->other_bvds[i-1]->sec_elmnt_seq = i;
2705         }
2706
2707         vcl->next = ddf->conflist;
2708         ddf->conflist = vcl;
2709         ddf->currentconf = vcl;
2710         ddf_set_updates_pending(ddf, NULL);
2711         return 1;
2712 }
2713
2714 static void add_to_super_ddf_bvd(struct supertype *st,
2715                                  mdu_disk_info_t *dk, int fd, char *devname,
2716                                  unsigned long long data_offset)
2717 {
2718         /* fd and devname identify a device within the ddf container (st).
2719          * dk identifies a location in the new BVD.
2720          * We need to find suitable free space in that device and update
2721          * the phys_refnum and lba_offset for the newly created vd_config.
2722          * We might also want to update the type in the phys_disk
2723          * section.
2724          *
2725          * Alternately: fd == -1 and we have already chosen which device to
2726          * use and recorded in dlist->raid_disk;
2727          */
2728         struct dl *dl;
2729         struct ddf_super *ddf = st->sb;
2730         struct vd_config *vc;
2731         unsigned int i;
2732         unsigned long long blocks, pos;
2733         unsigned int raid_disk = dk->raid_disk;
2734
2735         if (fd == -1) {
2736                 for (dl = ddf->dlist; dl ; dl = dl->next)
2737                         if (dl->raiddisk == dk->raid_disk)
2738                                 break;
2739         } else {
2740                 for (dl = ddf->dlist; dl ; dl = dl->next)
2741                         if (dl->major == dk->major &&
2742                             dl->minor == dk->minor)
2743                                 break;
2744         }
2745         if (!dl || dl->pdnum < 0 || ! (dk->state & (1<<MD_DISK_SYNC)))
2746                 return;
2747
2748         vc = &ddf->currentconf->conf;
2749         if (vc->sec_elmnt_count > 1) {
2750                 unsigned int n = be16_to_cpu(vc->prim_elmnt_count);
2751                 if (raid_disk >= n)
2752                         vc = ddf->currentconf->other_bvds[raid_disk / n - 1];
2753                 raid_disk %= n;
2754         }
2755
2756         blocks = be64_to_cpu(vc->blocks);
2757         if (ddf->currentconf->block_sizes)
2758                 blocks = ddf->currentconf->block_sizes[dk->raid_disk];
2759
2760         pos = find_space(ddf, dl, data_offset, &blocks);
2761         if (pos == INVALID_SECTORS)
2762                 return;
2763
2764         ddf->currentdev = dk->raid_disk;
2765         vc->phys_refnum[raid_disk] = dl->disk.refnum;
2766         LBA_OFFSET(ddf, vc)[raid_disk] = cpu_to_be64(pos);
2767
2768         for (i = 0; i < ddf->max_part ; i++)
2769                 if (dl->vlist[i] == NULL)
2770                         break;
2771         if (i == ddf->max_part)
2772                 return;
2773         dl->vlist[i] = ddf->currentconf;
2774
2775         if (fd >= 0)
2776                 dl->fd = fd;
2777         if (devname)
2778                 dl->devname = devname;
2779
2780         /* Check if we can mark array as optimal yet */
2781         i = ddf->currentconf->vcnum;
2782         ddf->virt->entries[i].state =
2783                 (ddf->virt->entries[i].state & ~DDF_state_mask)
2784                 | get_svd_state(ddf, ddf->currentconf);
2785         be16_clear(ddf->phys->entries[dl->pdnum].type,
2786                    cpu_to_be16(DDF_Global_Spare));
2787         be16_set(ddf->phys->entries[dl->pdnum].type,
2788                  cpu_to_be16(DDF_Active_in_VD));
2789         dprintf("added disk %d/%08x to VD %d/%s as disk %d\n",
2790                 dl->pdnum, be32_to_cpu(dl->disk.refnum),
2791                 ddf->currentconf->vcnum, guid_str(vc->guid),
2792                 dk->raid_disk);
2793         ddf_set_updates_pending(ddf, vc);
2794 }
2795
2796 static unsigned int find_unused_pde(const struct ddf_super *ddf)
2797 {
2798         unsigned int i;
2799         for (i = 0; i < be16_to_cpu(ddf->phys->max_pdes); i++) {
2800                 if (all_ff(ddf->phys->entries[i].guid))
2801                         return i;
2802         }
2803         return DDF_NOTFOUND;
2804 }
2805
2806 static void _set_config_size(struct phys_disk_entry *pde, const struct dl *dl)
2807 {
2808         __u64 cfs, t;
2809         cfs = min(dl->size - 32*1024*2ULL, be64_to_cpu(dl->primary_lba));
2810         t = be64_to_cpu(dl->secondary_lba);
2811         if (t != ~(__u64)0)
2812                 cfs = min(cfs, t);
2813         /*
2814          * Some vendor DDF structures interpret workspace_lba
2815          * very differently than we do: Make a sanity check on the value.
2816          */
2817         t = be64_to_cpu(dl->workspace_lba);
2818         if (t < cfs) {
2819                 __u64 wsp = cfs - t;
2820                 if (wsp > 1024*1024*2ULL && wsp > dl->size / 16) {
2821                         pr_err("%x:%x: workspace size 0x%llx too big, ignoring\n",
2822                                dl->major, dl->minor, (unsigned long long)wsp);
2823                 } else
2824                         cfs = t;
2825         }
2826         pde->config_size = cpu_to_be64(cfs);
2827         dprintf("%x:%x config_size %llx, DDF structure is %llx blocks\n",
2828                 dl->major, dl->minor,
2829                 (unsigned long long)cfs, (unsigned long long)(dl->size-cfs));
2830 }
2831
2832 /* Add a device to a container, either while creating it or while
2833  * expanding a pre-existing container
2834  */
2835 static int add_to_super_ddf(struct supertype *st,
2836                             mdu_disk_info_t *dk, int fd, char *devname,
2837                             unsigned long long data_offset)
2838 {
2839         struct ddf_super *ddf = st->sb;
2840         struct dl *dd;
2841         time_t now;
2842         struct tm *tm;
2843         unsigned long long size;
2844         struct phys_disk_entry *pde;
2845         unsigned int n, i;
2846         struct stat stb;
2847         __u32 *tptr;
2848
2849         if (ddf->currentconf) {
2850                 add_to_super_ddf_bvd(st, dk, fd, devname, data_offset);
2851                 return 0;
2852         }
2853
2854         /* This is device numbered dk->number.  We need to create
2855          * a phys_disk entry and a more detailed disk_data entry.
2856          */
2857         fstat(fd, &stb);
2858         n = find_unused_pde(ddf);
2859         if (n == DDF_NOTFOUND) {
2860                 pr_err("No free slot in array, cannot add disk\n");
2861                 return 1;
2862         }
2863         pde = &ddf->phys->entries[n];
2864         get_dev_size(fd, NULL, &size);
2865         if (size <= 32*1024*1024) {
2866                 pr_err("device size must be at least 32MB\n");
2867                 return 1;
2868         }
2869         size >>= 9;
2870
2871         if (posix_memalign((void**)&dd, 512,
2872                            sizeof(*dd) + sizeof(dd->vlist[0]) * ddf->max_part) != 0) {
2873                 pr_err("could allocate buffer for new disk, aborting\n");
2874                 return 1;
2875         }
2876         dd->major = major(stb.st_rdev);
2877         dd->minor = minor(stb.st_rdev);
2878         dd->devname = devname;
2879         dd->fd = fd;
2880         dd->spare = NULL;
2881
2882         dd->disk.magic = DDF_PHYS_DATA_MAGIC;
2883         now = time(0);
2884         tm = localtime(&now);
2885         sprintf(dd->disk.guid, "%8s%04d%02d%02d", T10,
2886                 (__u16)tm->tm_year+1900,
2887                 (__u8)tm->tm_mon+1, (__u8)tm->tm_mday);
2888         tptr = (__u32 *)(dd->disk.guid + 16);
2889         *tptr++ = random32();
2890         *tptr = random32();
2891
2892         do {
2893                 /* Cannot be bothered finding a CRC of some irrelevant details*/
2894                 dd->disk.refnum._v32 = random32();
2895                 for (i = be16_to_cpu(ddf->active->max_pd_entries);
2896                      i > 0; i--)
2897                         if (be32_eq(ddf->phys->entries[i-1].refnum,
2898                                     dd->disk.refnum))
2899                                 break;
2900         } while (i > 0);
2901
2902         dd->disk.forced_ref = 1;
2903         dd->disk.forced_guid = 1;
2904         memset(dd->disk.vendor, ' ', 32);
2905         memcpy(dd->disk.vendor, "Linux", 5);
2906         memset(dd->disk.pad, 0xff, 442);
2907         for (i = 0; i < ddf->max_part ; i++)
2908                 dd->vlist[i] = NULL;
2909
2910         dd->pdnum = n;
2911
2912         if (st->update_tail) {
2913                 int len = (sizeof(struct phys_disk) +
2914                            sizeof(struct phys_disk_entry));
2915                 struct phys_disk *pd;
2916
2917                 pd = xmalloc(len);
2918                 pd->magic = DDF_PHYS_RECORDS_MAGIC;
2919                 pd->used_pdes = cpu_to_be16(n);
2920                 pde = &pd->entries[0];
2921                 dd->mdupdate = pd;
2922         } else
2923                 ddf->phys->used_pdes = cpu_to_be16(
2924                         1 + be16_to_cpu(ddf->phys->used_pdes));
2925
2926         memcpy(pde->guid, dd->disk.guid, DDF_GUID_LEN);
2927         pde->refnum = dd->disk.refnum;
2928         pde->type = cpu_to_be16(DDF_Forced_PD_GUID | DDF_Global_Spare);
2929         pde->state = cpu_to_be16(DDF_Online);
2930         dd->size = size;
2931         /*
2932          * If there is already a device in dlist, try to reserve the same
2933          * amount of workspace. Otherwise, use 32MB.
2934          * We checked disk size above already.
2935          */
2936 #define __calc_lba(new, old, lba, mb) do { \
2937                 unsigned long long dif; \
2938                 if ((old) != NULL) \
2939                         dif = (old)->size - be64_to_cpu((old)->lba); \
2940                 else \
2941                         dif = (new)->size; \
2942                 if ((new)->size > dif) \
2943                         (new)->lba = cpu_to_be64((new)->size - dif); \
2944                 else \
2945                         (new)->lba = cpu_to_be64((new)->size - (mb*1024*2)); \
2946         } while (0)
2947         __calc_lba(dd, ddf->dlist, workspace_lba, 32);
2948         __calc_lba(dd, ddf->dlist, primary_lba, 16);
2949         if (ddf->dlist == NULL ||
2950             be64_to_cpu(ddf->dlist->secondary_lba) != ~(__u64)0)
2951                 __calc_lba(dd, ddf->dlist, secondary_lba, 32);
2952         _set_config_size(pde, dd);
2953
2954         sprintf(pde->path, "%17.17s","Information: nil") ;
2955         memset(pde->pad, 0xff, 6);
2956
2957         if (st->update_tail) {
2958                 dd->next = ddf->add_list;
2959                 ddf->add_list = dd;
2960         } else {
2961                 dd->next = ddf->dlist;
2962                 ddf->dlist = dd;
2963                 ddf_set_updates_pending(ddf, NULL);
2964         }
2965
2966         return 0;
2967 }
2968
2969 static int remove_from_super_ddf(struct supertype *st, mdu_disk_info_t *dk)
2970 {
2971         struct ddf_super *ddf = st->sb;
2972         struct dl *dl;
2973
2974         /* mdmon has noticed that this disk (dk->major/dk->minor) has
2975          * disappeared from the container.
2976          * We need to arrange that it disappears from the metadata and
2977          * internal data structures too.
2978          * Most of the work is done by ddf_process_update which edits
2979          * the metadata and closes the file handle and attaches the memory
2980          * where free_updates will free it.
2981          */
2982         for (dl = ddf->dlist; dl ; dl = dl->next)
2983                 if (dl->major == dk->major &&
2984                     dl->minor == dk->minor)
2985                         break;
2986         if (!dl || dl->pdnum < 0)
2987                 return -1;
2988
2989         if (st->update_tail) {
2990                 int len = (sizeof(struct phys_disk) +
2991                            sizeof(struct phys_disk_entry));
2992                 struct phys_disk *pd;
2993
2994                 pd = xmalloc(len);
2995                 pd->magic = DDF_PHYS_RECORDS_MAGIC;
2996                 pd->used_pdes = cpu_to_be16(dl->pdnum);
2997                 pd->entries[0].state = cpu_to_be16(DDF_Missing);
2998                 append_metadata_update(st, pd, len);
2999         }
3000         return 0;
3001 }
3002
3003 /*
3004  * This is the write_init_super method for a ddf container.  It is
3005  * called when creating a container or adding another device to a
3006  * container.
3007  */
3008
3009 static int __write_ddf_structure(struct dl *d, struct ddf_super *ddf, __u8 type)
3010 {
3011         unsigned long long sector;
3012         struct ddf_header *header;
3013         int fd, i, n_config, conf_size, buf_size;
3014         int ret = 0;
3015         char *conf;
3016
3017         fd = d->fd;
3018
3019         switch (type) {
3020         case DDF_HEADER_PRIMARY:
3021                 header = &ddf->primary;
3022                 sector = be64_to_cpu(header->primary_lba);
3023                 break;
3024         case DDF_HEADER_SECONDARY:
3025                 header = &ddf->secondary;
3026                 sector = be64_to_cpu(header->secondary_lba);
3027                 break;
3028         default:
3029                 return 0;
3030         }
3031         if (sector == ~(__u64)0)
3032                 return 0;
3033
3034         header->type = type;
3035         header->openflag = 1;
3036         header->crc = calc_crc(header, 512);
3037
3038         lseek64(fd, sector<<9, 0);
3039         if (write(fd, header, 512) < 0)
3040                 goto out;
3041
3042         ddf->controller.crc = calc_crc(&ddf->controller, 512);
3043         if (write(fd, &ddf->controller, 512) < 0)
3044                 goto out;
3045
3046         ddf->phys->crc = calc_crc(ddf->phys, ddf->pdsize);
3047         if (write(fd, ddf->phys, ddf->pdsize) < 0)
3048                 goto out;
3049         ddf->virt->crc = calc_crc(ddf->virt, ddf->vdsize);
3050         if (write(fd, ddf->virt, ddf->vdsize) < 0)
3051                 goto out;
3052
3053         /* Now write lots of config records. */
3054         n_config = ddf->max_part;
3055         conf_size = ddf->conf_rec_len * 512;
3056         conf = ddf->conf;
3057         buf_size = conf_size * (n_config + 1);
3058         if (!conf) {
3059                 if (posix_memalign((void**)&conf, 512, buf_size) != 0)
3060                         goto out;
3061                 ddf->conf = conf;
3062         }
3063         for (i = 0 ; i <= n_config ; i++) {
3064                 struct vcl *c;
3065                 struct vd_config *vdc = NULL;
3066                 if (i == n_config) {
3067                         c = (struct vcl *)d->spare;
3068                         if (c)
3069                                 vdc = &c->conf;
3070                 } else {
3071                         unsigned int dummy;
3072                         c = d->vlist[i];
3073                         if (c)
3074                                 get_pd_index_from_refnum(
3075                                         c, d->disk.refnum,
3076                                         ddf->mppe,
3077                                         (const struct vd_config **)&vdc,
3078                                         &dummy);
3079                 }
3080                 if (vdc) {
3081                         dprintf("writing conf record %i on disk %08x for %s/%u\n",
3082                                 i, be32_to_cpu(d->disk.refnum),
3083                                 guid_str(vdc->guid),
3084                                 vdc->sec_elmnt_seq);
3085                         vdc->crc = calc_crc(vdc, conf_size);
3086                         memcpy(conf + i*conf_size, vdc, conf_size);
3087                 } else
3088                         memset(conf + i*conf_size, 0xff, conf_size);
3089         }
3090         if (write(fd, conf, buf_size) != buf_size)
3091                 goto out;
3092
3093         d->disk.crc = calc_crc(&d->disk, 512);
3094         if (write(fd, &d->disk, 512) < 0)
3095                 goto out;
3096
3097         ret = 1;
3098 out:
3099         header->openflag = 0;
3100         header->crc = calc_crc(header, 512);
3101
3102         lseek64(fd, sector<<9, 0);
3103         if (write(fd, header, 512) < 0)
3104                 ret = 0;
3105
3106         return ret;
3107 }
3108
3109 static int _write_super_to_disk(struct ddf_super *ddf, struct dl *d)
3110 {
3111         unsigned long long size;
3112         int fd = d->fd;
3113         if (fd < 0)
3114                 return 0;
3115
3116         /* We need to fill in the primary, (secondary) and workspace
3117          * lba's in the headers, set their checksums,
3118          * Also checksum phys, virt....
3119          *
3120          * Then write everything out, finally the anchor is written.
3121          */
3122         get_dev_size(fd, NULL, &size);
3123         size /= 512;
3124         memcpy(&ddf->anchor, ddf->active, 512);
3125         if (be64_to_cpu(d->workspace_lba) != 0ULL)
3126                 ddf->anchor.workspace_lba = d->workspace_lba;
3127         else
3128                 ddf->anchor.workspace_lba =
3129                         cpu_to_be64(size - 32*1024*2);
3130         if (be64_to_cpu(d->primary_lba) != 0ULL)
3131                 ddf->anchor.primary_lba = d->primary_lba;
3132         else
3133                 ddf->anchor.primary_lba =
3134                         cpu_to_be64(size - 16*1024*2);
3135         if (be64_to_cpu(d->secondary_lba) != 0ULL)
3136                 ddf->anchor.secondary_lba = d->secondary_lba;
3137         else
3138                 ddf->anchor.secondary_lba =
3139                         cpu_to_be64(size - 32*1024*2);
3140         ddf->anchor.timestamp = cpu_to_be32(time(0) - DECADE);
3141         memcpy(&ddf->primary, &ddf->anchor, 512);
3142         memcpy(&ddf->secondary, &ddf->anchor, 512);
3143
3144         ddf->anchor.type = DDF_HEADER_ANCHOR;
3145         ddf->anchor.openflag = 0xFF; /* 'open' means nothing */
3146         ddf->anchor.seq = cpu_to_be32(0xFFFFFFFF); /* no sequencing in anchor */
3147         ddf->anchor.crc = calc_crc(&ddf->anchor, 512);
3148
3149         if (!__write_ddf_structure(d, ddf, DDF_HEADER_PRIMARY))
3150                 return 0;
3151
3152         if (!__write_ddf_structure(d, ddf, DDF_HEADER_SECONDARY))
3153                 return 0;
3154
3155         lseek64(fd, (size-1)*512, SEEK_SET);
3156         if (write(fd, &ddf->anchor, 512) < 0)
3157                 return 0;
3158
3159         return 1;
3160 }
3161
3162 static int __write_init_super_ddf(struct supertype *st)
3163 {
3164         struct ddf_super *ddf = st->sb;
3165         struct dl *d;
3166         int attempts = 0;
3167         int successes = 0;
3168
3169         pr_state(ddf, __func__);
3170
3171         /* try to write updated metadata,
3172          * if we catch a failure move on to the next disk
3173          */
3174         for (d = ddf->dlist; d; d=d->next) {
3175                 attempts++;
3176                 successes += _write_super_to_disk(ddf, d);
3177         }
3178
3179         return attempts != successes;
3180 }
3181
3182 static int write_init_super_ddf(struct supertype *st)
3183 {
3184         struct ddf_super *ddf = st->sb;
3185         struct vcl *currentconf = ddf->currentconf;
3186
3187         /* We are done with currentconf - reset it so st refers to the container */
3188         ddf->currentconf = NULL;
3189
3190         if (st->update_tail) {
3191                 /* queue the virtual_disk and vd_config as metadata updates */
3192                 struct virtual_disk *vd;
3193                 struct vd_config *vc;
3194                 int len, tlen;
3195                 unsigned int i;
3196
3197                 if (!currentconf) {
3198                         /* Must be adding a physical disk to the container */
3199                         int len = (sizeof(struct phys_disk) +
3200                                    sizeof(struct phys_disk_entry));
3201
3202                         /* adding a disk to the container. */
3203                         if (!ddf->add_list)
3204                                 return 0;
3205
3206                         append_metadata_update(st, ddf->add_list->mdupdate, len);
3207                         ddf->add_list->mdupdate = NULL;
3208                         return 0;
3209                 }
3210
3211                 /* Newly created VD */
3212
3213                 /* First the virtual disk.  We have a slightly fake header */
3214                 len = sizeof(struct virtual_disk) + sizeof(struct virtual_entry);
3215                 vd = xmalloc(len);
3216                 *vd = *ddf->virt;
3217                 vd->entries[0] = ddf->virt->entries[currentconf->vcnum];
3218                 vd->populated_vdes = cpu_to_be16(currentconf->vcnum);
3219                 append_metadata_update(st, vd, len);
3220
3221                 /* Then the vd_config */
3222                 len = ddf->conf_rec_len * 512;
3223                 tlen = len * currentconf->conf.sec_elmnt_count;
3224                 vc = xmalloc(tlen);
3225                 memcpy(vc, &currentconf->conf, len);
3226                 for (i = 1; i < currentconf->conf.sec_elmnt_count; i++)
3227                         memcpy((char *)vc + i*len, currentconf->other_bvds[i-1],
3228                                len);
3229                 append_metadata_update(st, vc, tlen);
3230
3231                 return 0;
3232         } else {
3233                 struct dl *d;
3234                 if (!currentconf)
3235                         for (d = ddf->dlist; d; d=d->next)
3236                                 while (Kill(d->devname, NULL, 0, -1, 1) == 0);
3237                 /* Note: we don't close the fd's now, but a subsequent
3238                  * ->free_super() will
3239                  */
3240                 return __write_init_super_ddf(st);
3241         }
3242 }
3243
3244 static __u64 avail_size_ddf(struct supertype *st, __u64 devsize,
3245                             unsigned long long data_offset)
3246 {
3247         /* We must reserve the last 32Meg */
3248         if (devsize <= 32*1024*2)
3249                 return 0;
3250         return devsize - 32*1024*2;
3251 }
3252
3253 static int reserve_space(struct supertype *st, int raiddisks,
3254                          unsigned long long size, int chunk,
3255                          unsigned long long data_offset,
3256                          unsigned long long *freesize)
3257 {
3258         /* Find 'raiddisks' spare extents at least 'size' big (but
3259          * only caring about multiples of 'chunk') and remember
3260          * them.   If size==0, find the largest size possible.
3261          * Report available size in *freesize
3262          * If space cannot be found, fail.
3263          */
3264         struct dl *dl;
3265         struct ddf_super *ddf = st->sb;
3266         int cnt = 0;
3267
3268         for (dl = ddf->dlist; dl ; dl=dl->next) {
3269                 dl->raiddisk = -1;
3270                 dl->esize = 0;
3271         }
3272         /* Now find largest extent on each device */
3273         for (dl = ddf->dlist ; dl ; dl=dl->next) {
3274                 unsigned long long minsize = ULLONG_MAX;
3275
3276                 find_space(ddf, dl, data_offset, &minsize);
3277                 if (minsize >= size && minsize >= (unsigned)chunk) {
3278                         cnt++;
3279                         dl->esize = minsize;
3280                 }
3281         }
3282         if (cnt < raiddisks) {
3283                 pr_err("not enough devices with space to create array.\n");
3284                 return 0; /* No enough free spaces large enough */
3285         }
3286         if (size == 0) {
3287                 /* choose the largest size of which there are at least 'raiddisk' */
3288                 for (dl = ddf->dlist ; dl ; dl=dl->next) {
3289                         struct dl *dl2;
3290                         if (dl->esize <= size)
3291                                 continue;
3292                         /* This is bigger than 'size', see if there are enough */
3293                         cnt = 0;
3294                         for (dl2 = ddf->dlist; dl2 ; dl2=dl2->next)
3295                                 if (dl2->esize >= dl->esize)
3296                                         cnt++;
3297                         if (cnt >= raiddisks)
3298                                 size = dl->esize;
3299                 }
3300                 if (chunk) {
3301                         size = size / chunk;
3302                         size *= chunk;
3303                 }
3304                 *freesize = size;
3305                 if (size < 32) {
3306                         pr_err("not enough spare devices to create array.\n");
3307                         return 0;
3308                 }
3309         }
3310         /* We have a 'size' of which there are enough spaces.
3311          * We simply do a first-fit */
3312         cnt = 0;
3313         for (dl = ddf->dlist ; dl && cnt < raiddisks ; dl=dl->next) {
3314                 if (dl->esize < size)
3315                         continue;
3316
3317                 dl->raiddisk = cnt;
3318                 cnt++;
3319         }
3320         return 1;
3321 }
3322
3323 static int validate_geometry_ddf(struct supertype *st,
3324                                  int level, int layout, int raiddisks,
3325                                  int *chunk, unsigned long long size,
3326                                  unsigned long long data_offset,
3327                                  char *dev, unsigned long long *freesize,
3328                                  int consistency_policy, int verbose)
3329 {
3330         int fd;
3331         struct mdinfo *sra;
3332         int cfd;
3333
3334         /* ddf potentially supports lots of things, but it depends on
3335          * what devices are offered (and maybe kernel version?)
3336          * If given unused devices, we will make a container.
3337          * If given devices in a container, we will make a BVD.
3338          * If given BVDs, we make an SVD, changing all the GUIDs in the process.
3339          */
3340
3341         if (*chunk == UnSet)
3342                 *chunk = DEFAULT_CHUNK;
3343
3344         if (level == LEVEL_NONE)
3345                 level = LEVEL_CONTAINER;
3346         if (level == LEVEL_CONTAINER) {
3347                 /* Must be a fresh device to add to a container */
3348                 return validate_geometry_ddf_container(st, level, layout,
3349                                                        raiddisks, *chunk,
3350                                                        size, data_offset, dev,
3351                                                        freesize,
3352                                                        verbose);
3353         }
3354
3355         if (!dev) {
3356                 mdu_array_info_t array = {
3357                         .level = level,
3358                         .layout = layout,
3359                         .raid_disks = raiddisks
3360                 };
3361                 struct vd_config conf;
3362                 if (layout_md2ddf(&array, &conf) == -1) {
3363                         if (verbose)
3364                                 pr_err("DDF does not support level %d /layout %d arrays with %d disks\n",
3365                                        level, layout, raiddisks);
3366                         return 0;
3367                 }
3368                 /* Should check layout? etc */
3369
3370                 if (st->sb && freesize) {
3371                         /* --create was given a container to create in.
3372                          * So we need to check that there are enough
3373                          * free spaces and return the amount of space.
3374                          * We may as well remember which drives were
3375                          * chosen so that add_to_super/getinfo_super
3376                          * can return them.
3377                          */
3378                         return reserve_space(st, raiddisks, size, *chunk,
3379                                              data_offset, freesize);
3380                 }
3381                 return 1;
3382         }
3383
3384         if (st->sb) {
3385                 /* A container has already been opened, so we are
3386                  * creating in there.  Maybe a BVD, maybe an SVD.
3387                  * Should make a distinction one day.
3388                  */
3389                 return validate_geometry_ddf_bvd(st, level, layout, raiddisks,
3390                                                  chunk, size, data_offset, dev,
3391                                                  freesize,
3392                                                  verbose);
3393         }
3394         /* This is the first device for the array.
3395          * If it is a container, we read it in and do automagic allocations,
3396          * no other devices should be given.
3397          * Otherwise it must be a member device of a container, and we
3398          * do manual allocation.
3399          * Later we should check for a BVD and make an SVD.
3400          */
3401         fd = open(dev, O_RDONLY|O_EXCL, 0);
3402         if (fd >= 0) {
3403                 close(fd);
3404                 /* Just a bare device, no good to us */
3405                 if (verbose)
3406                         pr_err("ddf: Cannot create this array on device %s - a container is required.\n",
3407                                dev);
3408                 return 0;
3409         }
3410         if (errno != EBUSY || (fd = open(dev, O_RDONLY, 0)) < 0) {
3411                 if (verbose)
3412                         pr_err("ddf: Cannot open %s: %s\n",
3413                                dev, strerror(errno));
3414                 return 0;
3415         }
3416         /* Well, it is in use by someone, maybe a 'ddf' container. */
3417         cfd = open_container(fd);
3418         if (cfd < 0) {
3419                 close(fd);
3420                 if (verbose)
3421                         pr_err("ddf: Cannot use %s: %s\n",
3422                                dev, strerror(EBUSY));
3423                 return 0;
3424         }
3425         sra = sysfs_read(cfd, NULL, GET_VERSION);
3426         close(fd);
3427         if (sra && sra->array.major_version == -1 &&
3428             strcmp(sra->text_version, "ddf") == 0) {
3429                 /* This is a member of a ddf container.  Load the container
3430                  * and try to create a bvd
3431                  */
3432                 struct ddf_super *ddf;
3433                 if (load_super_ddf_all(st, cfd, (void **)&ddf, NULL) == 0) {
3434                         st->sb = ddf;
3435                         strcpy(st->container_devnm, fd2devnm(cfd));
3436                         close(cfd);
3437                         return validate_geometry_ddf_bvd(st, level, layout,
3438                                                          raiddisks, chunk, size,
3439                                                          data_offset,
3440                                                          dev, freesize,
3441                                                          verbose);
3442                 }
3443                 close(cfd);
3444         } else /* device may belong to a different container */
3445                 return 0;
3446
3447         return 1;
3448 }
3449
3450 static int
3451 validate_geometry_ddf_container(struct supertype *st,
3452                                 int level, int layout, int raiddisks,
3453                                 int chunk, unsigned long long size,
3454                                 unsigned long long data_offset,
3455                                 char *dev, unsigned long long *freesize,
3456                                 int verbose)
3457 {
3458         int fd;
3459         unsigned long long ldsize;
3460
3461         if (level != LEVEL_CONTAINER)
3462                 return 0;
3463         if (!dev)
3464                 return 1;
3465
3466         fd = open(dev, O_RDONLY|O_EXCL, 0);
3467         if (fd < 0) {
3468                 if (verbose)
3469                         pr_err("ddf: Cannot open %s: %s\n",
3470                                dev, strerror(errno));
3471                 return 0;
3472         }
3473         if (!get_dev_size(fd, dev, &ldsize)) {
3474                 close(fd);
3475                 return 0;
3476         }
3477         close(fd);
3478
3479         *freesize = avail_size_ddf(st, ldsize >> 9, INVALID_SECTORS);
3480         if (*freesize == 0)
3481                 return 0;
3482
3483         return 1;
3484 }
3485
3486 static int validate_geometry_ddf_bvd(struct supertype *st,
3487                                      int level, int layout, int raiddisks,
3488                                      int *chunk, unsigned long long size,
3489                                      unsigned long long data_offset,
3490                                      char *dev, unsigned long long *freesize,
3491                                      int verbose)
3492 {
3493         dev_t rdev;
3494         struct ddf_super *ddf = st->sb;
3495         struct dl *dl;
3496         unsigned long long maxsize;
3497         /* ddf/bvd supports lots of things, but not containers */
3498         if (level == LEVEL_CONTAINER) {
3499                 if (verbose)
3500                         pr_err("DDF cannot create a container within an container\n");
3501                 return 0;
3502         }
3503         /* We must have the container info already read in. */
3504         if (!ddf)
3505                 return 0;
3506
3507         if (!dev) {
3508                 /* General test:  make sure there is space for
3509                  * 'raiddisks' device extents of size 'size'.
3510                  */
3511                 unsigned long long minsize = size;
3512                 int dcnt = 0;
3513                 if (minsize == 0)
3514                         minsize = 8;
3515                 for (dl = ddf->dlist; dl ; dl = dl->next) {
3516                         if (find_space(ddf, dl, data_offset, &minsize) !=
3517                             INVALID_SECTORS)
3518                                 dcnt++;
3519                 }
3520                 if (dcnt < raiddisks) {
3521                         if (verbose)
3522                                 pr_err("ddf: Not enough devices with space for this array (%d < %d)\n",
3523                                        dcnt, raiddisks);
3524                         return 0;
3525                 }
3526                 return 1;
3527         }
3528         /* This device must be a member of the set */
3529         if (!stat_is_blkdev(dev, &rdev))
3530                 return 0;
3531         for (dl = ddf->dlist ; dl ; dl = dl->next) {
3532                 if (dl->major == (int)major(rdev) &&
3533                     dl->minor == (int)minor(rdev))
3534                         break;
3535         }
3536         if (!dl) {
3537                 if (verbose)
3538                         pr_err("ddf: %s is not in the same DDF set\n",
3539                                dev);
3540                 return 0;
3541         }
3542         maxsize = ULLONG_MAX;
3543         find_space(ddf, dl, data_offset, &maxsize);
3544         *freesize = maxsize;
3545
3546         return 1;
3547 }
3548
3549 static int load_super_ddf_all(struct supertype *st, int fd,
3550                               void **sbp, char *devname)
3551 {
3552         struct mdinfo *sra;
3553         struct ddf_super *super;
3554         struct mdinfo *sd, *best = NULL;
3555         int bestseq = 0;
3556         int seq;
3557         char nm[20];
3558         int dfd;
3559
3560         sra = sysfs_read(fd, NULL, GET_LEVEL|GET_VERSION|GET_DEVS|GET_STATE);
3561         if (!sra)
3562                 return 1;
3563         if (sra->array.major_version != -1 ||
3564             sra->array.minor_version != -2 ||
3565             strcmp(sra->text_version, "ddf") != 0)
3566                 return 1;
3567
3568         if (posix_memalign((void**)&super, 512, sizeof(*super)) != 0)
3569                 return 1;
3570         memset(super, 0, sizeof(*super));
3571
3572         /* first, try each device, and choose the best ddf */
3573         for (sd = sra->devs ; sd ; sd = sd->next) {
3574                 int rv;
3575                 sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
3576                 dfd = dev_open(nm, O_RDONLY);
3577                 if (dfd < 0)
3578                         return 2;
3579                 rv = load_ddf_headers(dfd, super, NULL);
3580                 close(dfd);
3581                 if (rv == 0) {
3582                         seq = be32_to_cpu(super->active->seq);
3583                         if (super->active->openflag)
3584                                 seq--;
3585                         if (!best || seq > bestseq) {
3586                                 bestseq = seq;
3587                                 best = sd;
3588                         }
3589                 }
3590         }
3591         if (!best)
3592                 return 1;
3593         /* OK, load this ddf */
3594         sprintf(nm, "%d:%d", best->disk.major, best->disk.minor);
3595         dfd = dev_open(nm, O_RDONLY);
3596         if (dfd < 0)
3597                 return 1;
3598         load_ddf_headers(dfd, super, NULL);
3599         load_ddf_global(dfd, super, NULL);
3600         close(dfd);
3601         /* Now we need the device-local bits */
3602         for (sd = sra->devs ; sd ; sd = sd->next) {
3603                 int rv;
3604
3605                 sprintf(nm, "%d:%d", sd->disk.major, sd->disk.minor);
3606                 dfd = dev_open(nm, O_RDWR);
3607                 if (dfd < 0)
3608                         return 2;
3609                 rv = load_ddf_headers(dfd, super, NULL);
3610                 if (rv == 0)
3611                         rv = load_ddf_local(dfd, super, NULL, 1);
3612                 if (rv)
3613                         return 1;
3614         }
3615
3616         *sbp = super;
3617         if (st->ss == NULL) {
3618                 st->ss = &super_ddf;
3619                 st->minor_version = 0;
3620                 st->max_devs = 512;
3621         }
3622         strcpy(st->container_devnm, fd2devnm(fd));
3623         return 0;
3624 }
3625
3626 static int load_container_ddf(struct supertype *st, int fd,
3627                               char *devname)
3628 {
3629         return load_super_ddf_all(st, fd, &st->sb, devname);
3630 }
3631
3632 static int check_secondary(const struct vcl *vc)
3633 {
3634         const struct vd_config *conf = &vc->conf;
3635         int i;
3636
3637         /* The only DDF secondary RAID level md can support is
3638          * RAID 10, if the stripe sizes and Basic volume sizes
3639          * are all equal.
3640          * Other configurations could in theory be supported by exposing
3641          * the BVDs to user space and using device mapper for the secondary
3642          * mapping. So far we don't support that.
3643          */
3644
3645         __u64 sec_elements[4] = {0, 0, 0, 0};
3646 #define __set_sec_seen(n) (sec_elements[(n)>>6] |= (1<<((n)&63)))
3647 #define __was_sec_seen(n) ((sec_elements[(n)>>6] & (1<<((n)&63))) != 0)
3648
3649         if (vc->other_bvds == NULL) {
3650                 pr_err("No BVDs for secondary RAID found\n");
3651                 return -1;
3652         }
3653         if (conf->prl != DDF_RAID1) {
3654                 pr_err("Secondary RAID level only supported for mirrored BVD\n");
3655                 return -1;
3656         }
3657         if (conf->srl != DDF_2STRIPED && conf->srl != DDF_2SPANNED) {
3658                 pr_err("Secondary RAID level %d is unsupported\n",
3659                        conf->srl);
3660                 return -1;
3661         }
3662         __set_sec_seen(conf->sec_elmnt_seq);
3663         for (i = 0; i < conf->sec_elmnt_count-1; i++) {
3664                 const struct vd_config *bvd = vc->other_bvds[i];
3665                 if (bvd->sec_elmnt_seq == DDF_UNUSED_BVD)
3666                         continue;
3667                 if (bvd->srl != conf->srl) {
3668                         pr_err("Inconsistent secondary RAID level across BVDs\n");
3669                         return -1;
3670                 }
3671                 if (bvd->prl != conf->prl) {
3672                         pr_err("Different RAID levels for BVDs are unsupported\n");
3673                         return -1;
3674                 }
3675                 if (!be16_eq(bvd->prim_elmnt_count, conf->prim_elmnt_count)) {
3676                         pr_err("All BVDs must have the same number of primary elements\n");
3677                         return -1;
3678                 }
3679                 if (bvd->chunk_shift != conf->chunk_shift) {
3680                         pr_err("Different strip sizes for BVDs are unsupported\n");
3681                         return -1;
3682                 }
3683                 if (!be64_eq(bvd->array_blocks, conf->array_blocks)) {
3684                         pr_err("Different BVD sizes are unsupported\n");
3685                         return -1;
3686                 }
3687                 __set_sec_seen(bvd->sec_elmnt_seq);
3688         }
3689         for (i = 0; i < conf->sec_elmnt_count; i++) {
3690                 if (!__was_sec_seen(i)) {
3691                         /* pr_err("BVD %d is missing\n", i); */
3692                         return -1;
3693                 }
3694         }
3695         return 0;
3696 }
3697
3698 static unsigned int get_pd_index_from_refnum(const struct vcl *vc,
3699                                              be32 refnum, unsigned int nmax,
3700                                              const struct vd_config **bvd,
3701                                              unsigned int *idx)
3702 {
3703         unsigned int i, j, n, sec, cnt;
3704
3705         cnt = be16_to_cpu(vc->conf.prim_elmnt_count);
3706         sec = (vc->conf.sec_elmnt_count == 1 ? 0 : vc->conf.sec_elmnt_seq);
3707
3708         for (i = 0, j = 0 ; i < nmax ; i++) {
3709                 /* j counts valid entries for this BVD */
3710                 if (be32_eq(vc->conf.phys_refnum[i], refnum)) {
3711                         *bvd = &vc->conf;
3712                         *idx = i;
3713                         return sec * cnt + j;
3714                 }
3715                 if (be32_to_cpu(vc->conf.phys_refnum[i]) != 0xffffffff)
3716                         j++;
3717         }
3718         if (vc->other_bvds == NULL)
3719                 goto bad;
3720
3721         for (n = 1; n < vc->conf.sec_elmnt_count; n++) {
3722                 struct vd_config *vd = vc->other_bvds[n-1];
3723                 sec = vd->sec_elmnt_seq;
3724                 if (sec == DDF_UNUSED_BVD)
3725                         continue;
3726                 for (i = 0, j = 0 ; i < nmax ; i++) {
3727                         if (be32_eq(vd->phys_refnum[i], refnum)) {
3728                                 *bvd = vd;
3729                                 *idx = i;
3730                                 return sec * cnt + j;
3731                         }
3732                         if (be32_to_cpu(vd->phys_refnum[i]) != 0xffffffff)
3733                                 j++;
3734                 }
3735         }
3736 bad:
3737         *bvd = NULL;
3738         return DDF_NOTFOUND;
3739 }
3740
3741 static struct mdinfo *container_content_ddf(struct supertype *st, char *subarray)
3742 {
3743         /* Given a container loaded by load_super_ddf_all,
3744          * extract information about all the arrays into
3745          * an mdinfo tree.
3746          *
3747          * For each vcl in conflist: create an mdinfo, fill it in,
3748          *  then look for matching devices (phys_refnum) in dlist
3749          *  and create appropriate device mdinfo.
3750          */
3751         struct ddf_super *ddf = st->sb;
3752         struct mdinfo *rest = NULL;
3753         struct vcl *vc;
3754
3755         for (vc = ddf->conflist ; vc ; vc=vc->next) {
3756                 unsigned int i;
3757                 struct mdinfo *this;
3758                 char *ep;
3759                 __u32 *cptr;
3760                 unsigned int pd;
3761
3762                 if (subarray &&
3763                     (strtoul(subarray, &ep, 10) != vc->vcnum ||
3764                      *ep != '\0'))
3765                         continue;
3766
3767                 if (vc->conf.sec_elmnt_count > 1) {
3768                         if (check_secondary(vc) != 0)
3769                                 continue;
3770                 }
3771
3772                 this = xcalloc(1, sizeof(*this));
3773                 this->next = rest;
3774                 rest = this;
3775
3776                 if (layout_ddf2md(&vc->conf, &this->array))
3777                         continue;
3778                 this->array.md_minor      = -1;
3779                 this->array.major_version = -1;
3780                 this->array.minor_version = -2;
3781                 this->safe_mode_delay     = DDF_SAFE_MODE_DELAY;
3782                 cptr = (__u32 *)(vc->conf.guid + 16);
3783                 this->array.ctime         = DECADE + __be32_to_cpu(*cptr);
3784                 this->array.utime         = DECADE +
3785                         be32_to_cpu(vc->conf.timestamp);
3786                 this->array.chunk_size    = 512 << vc->conf.chunk_shift;
3787
3788                 i = vc->vcnum;
3789                 if ((ddf->virt->entries[i].state & DDF_state_inconsistent) ||
3790                     (ddf->virt->entries[i].init_state & DDF_initstate_mask) !=
3791                     DDF_init_full) {
3792                         this->array.state = 0;
3793                         this->resync_start = 0;
3794                 } else {
3795                         this->array.state = 1;
3796                         this->resync_start = MaxSector;
3797                 }
3798                 _ddf_array_name(this->name, ddf, i);
3799                 memset(this->uuid, 0, sizeof(this->uuid));
3800                 this->component_size      = be64_to_cpu(vc->conf.blocks);
3801                 this->array.size          = this->component_size / 2;
3802                 this->container_member    = i;
3803
3804                 ddf->currentconf = vc;
3805                 uuid_from_super_ddf(st, this->uuid);
3806                 if (!subarray)
3807                         ddf->currentconf = NULL;