2 * mdadm - manage Linux "md" devices aka RAID arrays.
4 * Copyright (C) 2006-2009 Neil Brown <neilb@suse.de>
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.
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.
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
22 * Email: <neil@brown.name>
24 * Specifications for DDF takes from Common RAID DDF Specification Revision 1.2
25 * (July 28 2006). Reused by permission of SNIA.
28 #define HAVE_STDINT_H 1
34 /* a non-official T10 name for creation GUIDs */
35 static char T10
[] = "Linux-MD";
37 /* DDF timestamps are 1980 based, so we need to add
38 * second-in-decade-of-seventies to convert to linux timestamps.
39 * 10 years with 2 leap years.
41 #define DECADE (3600*24*(365*10+2))
44 const unsigned char *buf
,
47 #define DDF_NOTFOUND (~0U)
48 #define DDF_CONTAINER (DDF_NOTFOUND-1)
50 /* The DDF metadata handling.
51 * DDF metadata lives at the end of the device.
52 * The last 512 byte block provides an 'anchor' which is used to locate
53 * the rest of the metadata which usually lives immediately behind the anchor.
56 * - all multibyte numeric fields are bigendian.
57 * - all strings are space padded.
61 typedef struct __be16
{
64 #define be16_eq(x, y) ((x)._v16 == (y)._v16)
65 #define be16_and(x, y) ((x)._v16 & (y)._v16)
66 #define be16_or(x, y) ((x)._v16 | (y)._v16)
67 #define be16_clear(x, y) ((x)._v16 &= ~(y)._v16)
68 #define be16_set(x, y) ((x)._v16 |= (y)._v16)
70 typedef struct __be32
{
73 #define be32_eq(x, y) ((x)._v32 == (y)._v32)
75 typedef struct __be64
{
78 #define be64_eq(x, y) ((x)._v64 == (y)._v64)
80 #define be16_to_cpu(be) __be16_to_cpu((be)._v16)
81 static inline be16
cpu_to_be16(__u16 x
)
83 be16 be
= { ._v16
= __cpu_to_be16(x
) };
87 #define be32_to_cpu(be) __be32_to_cpu((be)._v32)
88 static inline be32
cpu_to_be32(__u32 x
)
90 be32 be
= { ._v32
= __cpu_to_be32(x
) };
94 #define be64_to_cpu(be) __be64_to_cpu((be)._v64)
95 static inline be64
cpu_to_be64(__u64 x
)
97 be64 be
= { ._v64
= __cpu_to_be64(x
) };
101 /* Primary Raid Level (PRL) */
102 #define DDF_RAID0 0x00
103 #define DDF_RAID1 0x01
104 #define DDF_RAID3 0x03
105 #define DDF_RAID4 0x04
106 #define DDF_RAID5 0x05
107 #define DDF_RAID1E 0x11
108 #define DDF_JBOD 0x0f
109 #define DDF_CONCAT 0x1f
110 #define DDF_RAID5E 0x15
111 #define DDF_RAID5EE 0x25
112 #define DDF_RAID6 0x06
114 /* Raid Level Qualifier (RLQ) */
115 #define DDF_RAID0_SIMPLE 0x00
116 #define DDF_RAID1_SIMPLE 0x00 /* just 2 devices in this plex */
117 #define DDF_RAID1_MULTI 0x01 /* exactly 3 devices in this plex */
118 #define DDF_RAID3_0 0x00 /* parity in first extent */
119 #define DDF_RAID3_N 0x01 /* parity in last extent */
120 #define DDF_RAID4_0 0x00 /* parity in first extent */
121 #define DDF_RAID4_N 0x01 /* parity in last extent */
122 /* these apply to raid5e and raid5ee as well */
123 #define DDF_RAID5_0_RESTART 0x00 /* same as 'right asymmetric' - layout 1 */
124 #define DDF_RAID6_0_RESTART 0x01 /* raid6 different from raid5 here!!! */
125 #define DDF_RAID5_N_RESTART 0x02 /* same as 'left asymmetric' - layout 0 */
126 #define DDF_RAID5_N_CONTINUE 0x03 /* same as 'left symmetric' - layout 2 */
128 #define DDF_RAID1E_ADJACENT 0x00 /* raid10 nearcopies==2 */
129 #define DDF_RAID1E_OFFSET 0x01 /* raid10 offsetcopies==2 */
131 /* Secondary RAID Level (SRL) */
132 #define DDF_2STRIPED 0x00 /* This is weirder than RAID0 !! */
133 #define DDF_2MIRRORED 0x01
134 #define DDF_2CONCAT 0x02
135 #define DDF_2SPANNED 0x03 /* This is also weird - be careful */
138 #define DDF_HEADER_MAGIC cpu_to_be32(0xDE11DE11)
139 #define DDF_CONTROLLER_MAGIC cpu_to_be32(0xAD111111)
140 #define DDF_PHYS_RECORDS_MAGIC cpu_to_be32(0x22222222)
141 #define DDF_PHYS_DATA_MAGIC cpu_to_be32(0x33333333)
142 #define DDF_VIRT_RECORDS_MAGIC cpu_to_be32(0xDDDDDDDD)
143 #define DDF_VD_CONF_MAGIC cpu_to_be32(0xEEEEEEEE)
144 #define DDF_SPARE_ASSIGN_MAGIC cpu_to_be32(0x55555555)
145 #define DDF_VU_CONF_MAGIC cpu_to_be32(0x88888888)
146 #define DDF_VENDOR_LOG_MAGIC cpu_to_be32(0x01dBEEF0)
147 #define DDF_BBM_LOG_MAGIC cpu_to_be32(0xABADB10C)
149 #define DDF_GUID_LEN 24
150 #define DDF_REVISION_0 "01.00.00"
151 #define DDF_REVISION_2 "01.02.00"
154 be32 magic
; /* DDF_HEADER_MAGIC */
156 char guid
[DDF_GUID_LEN
];
157 char revision
[8]; /* 01.02.00 */
158 be32 seq
; /* starts at '1' */
163 __u8 pad0
; /* 0xff */
164 __u8 pad1
[12]; /* 12 * 0xff */
165 /* 64 bytes so far */
166 __u8 header_ext
[32]; /* reserved: fill with 0xff */
170 __u8 pad2
[3]; /* 0xff */
171 be32 workspace_len
; /* sectors for vendor space -
172 * at least 32768(sectors) */
174 be16 max_pd_entries
; /* one of 15, 63, 255, 1023, 4095 */
175 be16 max_vd_entries
; /* 2^(4,6,8,10,12)-1 : i.e. as above */
176 be16 max_partitions
; /* i.e. max num of configuration
177 record entries per disk */
178 be16 config_record_len
; /* 1 +ROUNDUP(max_primary_element_entries
180 be16 max_primary_element_entries
; /* 16, 64, 256, 1024, or 4096 */
181 __u8 pad3
[54]; /* 0xff */
182 /* 192 bytes so far */
183 be32 controller_section_offset
;
184 be32 controller_section_length
;
185 be32 phys_section_offset
;
186 be32 phys_section_length
;
187 be32 virt_section_offset
;
188 be32 virt_section_length
;
189 be32 config_section_offset
;
190 be32 config_section_length
;
191 be32 data_section_offset
;
192 be32 data_section_length
;
193 be32 bbm_section_offset
;
194 be32 bbm_section_length
;
195 be32 diag_space_offset
;
196 be32 diag_space_length
;
199 /* 256 bytes so far */
200 __u8 pad4
[256]; /* 0xff */
204 #define DDF_HEADER_ANCHOR 0x00
205 #define DDF_HEADER_PRIMARY 0x01
206 #define DDF_HEADER_SECONDARY 0x02
208 /* The content of the 'controller section' - global scope */
209 struct ddf_controller_data
{
210 be32 magic
; /* DDF_CONTROLLER_MAGIC */
212 char guid
[DDF_GUID_LEN
];
213 struct controller_type
{
220 __u8 pad
[8]; /* 0xff */
221 __u8 vendor_data
[448];
224 /* The content of phys_section - global scope */
226 be32 magic
; /* DDF_PHYS_RECORDS_MAGIC */
231 struct phys_disk_entry
{
232 char guid
[DDF_GUID_LEN
];
236 be64 config_size
; /* DDF structures must be after here */
237 char path
[18]; /* another horrible structure really */
242 /* phys_disk_entry.type is a bitmap - bigendian remember */
243 #define DDF_Forced_PD_GUID 1
244 #define DDF_Active_in_VD 2
245 #define DDF_Global_Spare 4 /* VD_CONF records are ignored */
246 #define DDF_Spare 8 /* overrides Global_spare */
247 #define DDF_Foreign 16
248 #define DDF_Legacy 32 /* no DDF on this device */
250 #define DDF_Interface_mask 0xf00
251 #define DDF_Interface_SCSI 0x100
252 #define DDF_Interface_SAS 0x200
253 #define DDF_Interface_SATA 0x300
254 #define DDF_Interface_FC 0x400
256 /* phys_disk_entry.state is a bigendian bitmap */
258 #define DDF_Failed 2 /* overrides 1,4,8 */
259 #define DDF_Rebuilding 4
260 #define DDF_Transition 8
262 #define DDF_ReadErrors 32
263 #define DDF_Missing 64
265 /* The content of the virt_section global scope */
266 struct virtual_disk
{
267 be32 magic
; /* DDF_VIRT_RECORDS_MAGIC */
272 struct virtual_entry
{
273 char guid
[DDF_GUID_LEN
];
275 __u16 pad0
; /* 0xffff */
285 /* virtual_entry.type is a bitmap - bigendian */
287 #define DDF_Enforce_Groups 2
288 #define DDF_Unicode 4
289 #define DDF_Owner_Valid 8
291 /* virtual_entry.state is a bigendian bitmap */
292 #define DDF_state_mask 0x7
293 #define DDF_state_optimal 0x0
294 #define DDF_state_degraded 0x1
295 #define DDF_state_deleted 0x2
296 #define DDF_state_missing 0x3
297 #define DDF_state_failed 0x4
298 #define DDF_state_part_optimal 0x5
300 #define DDF_state_morphing 0x8
301 #define DDF_state_inconsistent 0x10
303 /* virtual_entry.init_state is a bigendian bitmap */
304 #define DDF_initstate_mask 0x03
305 #define DDF_init_not 0x00
306 #define DDF_init_quick 0x01 /* initialisation is progress.
307 * i.e. 'state_inconsistent' */
308 #define DDF_init_full 0x02
310 #define DDF_access_mask 0xc0
311 #define DDF_access_rw 0x00
312 #define DDF_access_ro 0x80
313 #define DDF_access_blocked 0xc0
315 /* The content of the config_section - local scope
316 * It has multiple records each config_record_len sectors
317 * They can be vd_config or spare_assign
321 be32 magic
; /* DDF_VD_CONF_MAGIC */
323 char guid
[DDF_GUID_LEN
];
327 be16 prim_elmnt_count
;
328 __u8 chunk_shift
; /* 0 == 512, 1==1024 etc */
331 __u8 sec_elmnt_count
;
334 be64 blocks
; /* blocks per component could be different
335 * on different component devices...(only
336 * for concat I hope) */
337 be64 array_blocks
; /* blocks in array */
345 __u8 v0
[32]; /* reserved- 0xff */
346 __u8 v1
[32]; /* reserved- 0xff */
347 __u8 v2
[16]; /* reserved- 0xff */
348 __u8 v3
[16]; /* reserved- 0xff */
350 be32 phys_refnum
[0]; /* refnum of each disk in sequence */
351 /*__u64 lba_offset[0]; LBA offset in each phys. Note extents in a
352 bvd are always the same size */
354 #define LBA_OFFSET(ddf, vd) ((be64 *) &(vd)->phys_refnum[(ddf)->mppe])
356 /* vd_config.cache_pol[7] is a bitmap */
357 #define DDF_cache_writeback 1 /* else writethrough */
358 #define DDF_cache_wadaptive 2 /* only applies if writeback */
359 #define DDF_cache_readahead 4
360 #define DDF_cache_radaptive 8 /* only if doing read-ahead */
361 #define DDF_cache_ifnobatt 16 /* even to write cache if battery is poor */
362 #define DDF_cache_wallowed 32 /* enable write caching */
363 #define DDF_cache_rallowed 64 /* enable read caching */
365 struct spare_assign
{
366 be32 magic
; /* DDF_SPARE_ASSIGN_MAGIC */
371 be16 populated
; /* SAEs used */
372 be16 max
; /* max SAEs */
374 struct spare_assign_entry
{
375 char guid
[DDF_GUID_LEN
];
376 be16 secondary_element
;
380 /* spare_assign.type is a bitmap */
381 #define DDF_spare_dedicated 0x1 /* else global */
382 #define DDF_spare_revertible 0x2 /* else committable */
383 #define DDF_spare_active 0x4 /* else not active */
384 #define DDF_spare_affinity 0x8 /* enclosure affinity */
386 /* The data_section contents - local scope */
388 be32 magic
; /* DDF_PHYS_DATA_MAGIC */
390 char guid
[DDF_GUID_LEN
];
391 be32 refnum
; /* crc of some magic drive data ... */
392 __u8 forced_ref
; /* set when above was not result of magic */
393 __u8 forced_guid
; /* set if guid was forced rather than magic */
398 /* bbm_section content */
399 struct bad_block_log
{
406 struct mapped_block
{
407 be64 defective_start
;
408 be32 replacement_start
;
414 /* Struct for internally holding ddf structures */
415 /* The DDF structure stored on each device is potentially
416 * quite different, as some data is global and some is local.
417 * The global data is:
420 * - Physical disk records
421 * - Virtual disk records
423 * - Configuration records
424 * - Physical Disk data section
425 * ( and Bad block and vendor which I don't care about yet).
427 * The local data is parsed into separate lists as it is read
428 * and reconstructed for writing. This means that we only need
429 * to make config changes once and they are automatically
430 * propagated to all devices.
431 * Note that the ddf_super has space of the conf and disk data
432 * for this disk and also for a list of all such data.
433 * The list is only used for the superblock that is being
434 * built in Create or Assemble to describe the whole array.
437 struct ddf_header anchor
, primary
, secondary
;
438 struct ddf_controller_data controller
;
439 struct ddf_header
*active
;
440 struct phys_disk
*phys
;
441 struct virtual_disk
*virt
;
443 unsigned int max_part
, mppe
, conf_rec_len
;
451 unsigned int vcnum
; /* index into ->virt */
452 struct vd_config
**other_bvds
;
453 __u64
*block_sizes
; /* NULL if all the same */
456 struct vd_config conf
;
457 } *conflist
, *currentconf
;
466 unsigned long long size
; /* sectors */
467 be64 primary_lba
; /* sectors */
468 be64 secondary_lba
; /* sectors */
469 be64 workspace_lba
; /* sectors */
470 int pdnum
; /* index in ->phys */
471 struct spare_assign
*spare
;
472 void *mdupdate
; /* hold metadata update */
474 /* These fields used by auto-layout */
475 int raiddisk
; /* slot to fill in autolayout */
479 struct disk_data disk
;
480 struct vcl
*vlist
[0]; /* max_part in size */
485 #define offsetof(t,f) ((size_t)&(((t*)0)->f))
489 static int all_ff(const char *guid
);
490 static void pr_state(struct ddf_super
*ddf
, const char *msg
)
493 dprintf("%s/%s: ", __func__
, msg
);
494 for (i
= 0; i
< be16_to_cpu(ddf
->active
->max_vd_entries
); i
++) {
495 if (all_ff(ddf
->virt
->entries
[i
].guid
))
497 dprintf("%u(s=%02x i=%02x) ", i
,
498 ddf
->virt
->entries
[i
].state
,
499 ddf
->virt
->entries
[i
].init_state
);
504 static void pr_state(const struct ddf_super
*ddf
, const char *msg
) {}
507 static void _ddf_set_updates_pending(struct ddf_super
*ddf
, const char *func
)
509 ddf
->updates_pending
= 1;
510 ddf
->active
->seq
= cpu_to_be32((be32_to_cpu(ddf
->active
->seq
)+1));
514 #define ddf_set_updates_pending(x) _ddf_set_updates_pending((x), __func__)
516 static unsigned int get_pd_index_from_refnum(const struct vcl
*vc
,
517 be32 refnum
, unsigned int nmax
,
518 const struct vd_config
**bvd
,
521 static be32
calc_crc(void *buf
, int len
)
523 /* crcs are always at the same place as in the ddf_header */
524 struct ddf_header
*ddf
= buf
;
525 be32 oldcrc
= ddf
->crc
;
527 ddf
->crc
= cpu_to_be32(0xffffffff);
529 newcrc
= crc32(0, buf
, len
);
531 /* The crc is store (like everything) bigendian, so convert
532 * here for simplicity
534 return cpu_to_be32(newcrc
);
537 #define DDF_INVALID_LEVEL 0xff
538 #define DDF_NO_SECONDARY 0xff
539 static int err_bad_md_layout(const mdu_array_info_t
*array
)
541 pr_err("RAID%d layout %x with %d disks is unsupported for DDF\n",
542 array
->level
, array
->layout
, array
->raid_disks
);
546 static int layout_md2ddf(const mdu_array_info_t
*array
,
547 struct vd_config
*conf
)
549 be16 prim_elmnt_count
= cpu_to_be16(array
->raid_disks
);
550 __u8 prl
= DDF_INVALID_LEVEL
, rlq
= 0;
551 __u8 sec_elmnt_count
= 1;
552 __u8 srl
= DDF_NO_SECONDARY
;
554 switch (array
->level
) {
559 rlq
= DDF_RAID0_SIMPLE
;
563 switch (array
->raid_disks
) {
565 rlq
= DDF_RAID1_SIMPLE
;
568 rlq
= DDF_RAID1_MULTI
;
571 return err_bad_md_layout(array
);
576 if (array
->layout
!= 0)
577 return err_bad_md_layout(array
);
582 switch (array
->layout
) {
583 case ALGORITHM_LEFT_ASYMMETRIC
:
584 rlq
= DDF_RAID5_N_RESTART
;
586 case ALGORITHM_RIGHT_ASYMMETRIC
:
587 rlq
= DDF_RAID5_0_RESTART
;
589 case ALGORITHM_LEFT_SYMMETRIC
:
590 rlq
= DDF_RAID5_N_CONTINUE
;
592 case ALGORITHM_RIGHT_SYMMETRIC
:
593 /* not mentioned in standard */
595 return err_bad_md_layout(array
);
600 switch (array
->layout
) {
601 case ALGORITHM_ROTATING_N_RESTART
:
602 rlq
= DDF_RAID5_N_RESTART
;
604 case ALGORITHM_ROTATING_ZERO_RESTART
:
605 rlq
= DDF_RAID6_0_RESTART
;
607 case ALGORITHM_ROTATING_N_CONTINUE
:
608 rlq
= DDF_RAID5_N_CONTINUE
;
611 return err_bad_md_layout(array
);
616 if (array
->raid_disks
% 2 == 0 && array
->layout
== 0x102) {
617 rlq
= DDF_RAID1_SIMPLE
;
618 prim_elmnt_count
= cpu_to_be16(2);
619 sec_elmnt_count
= array
->raid_disks
/ 2;
620 } else if (array
->raid_disks
% 3 == 0
621 && array
->layout
== 0x103) {
622 rlq
= DDF_RAID1_MULTI
;
623 prim_elmnt_count
= cpu_to_be16(3);
624 sec_elmnt_count
= array
->raid_disks
/ 3;
626 return err_bad_md_layout(array
);
631 return err_bad_md_layout(array
);
634 conf
->prim_elmnt_count
= prim_elmnt_count
;
637 conf
->sec_elmnt_count
= sec_elmnt_count
;
641 static int err_bad_ddf_layout(const struct vd_config
*conf
)
643 pr_err("DDF RAID %u qualifier %u with %u disks is unsupported\n",
644 conf
->prl
, conf
->rlq
, be16_to_cpu(conf
->prim_elmnt_count
));
648 static int layout_ddf2md(const struct vd_config
*conf
,
649 mdu_array_info_t
*array
)
651 int level
= LEVEL_UNSUPPORTED
;
653 int raiddisks
= be16_to_cpu(conf
->prim_elmnt_count
);
655 if (conf
->sec_elmnt_count
> 1) {
656 /* see also check_secondary() */
657 if (conf
->prl
!= DDF_RAID1
||
658 (conf
->srl
!= DDF_2STRIPED
&& conf
->srl
!= DDF_2SPANNED
)) {
659 pr_err("Unsupported secondary RAID level %u/%u\n",
660 conf
->prl
, conf
->srl
);
663 if (raiddisks
== 2 && conf
->rlq
== DDF_RAID1_SIMPLE
)
665 else if (raiddisks
== 3 && conf
->rlq
== DDF_RAID1_MULTI
)
668 return err_bad_ddf_layout(conf
);
669 raiddisks
*= conf
->sec_elmnt_count
;
676 level
= LEVEL_LINEAR
;
679 if (conf
->rlq
!= DDF_RAID0_SIMPLE
)
680 return err_bad_ddf_layout(conf
);
684 if (!((conf
->rlq
== DDF_RAID1_SIMPLE
&& raiddisks
== 2) ||
685 (conf
->rlq
== DDF_RAID1_MULTI
&& raiddisks
== 3)))
686 return err_bad_ddf_layout(conf
);
690 if (conf
->rlq
!= DDF_RAID4_N
)
691 return err_bad_ddf_layout(conf
);
696 case DDF_RAID5_N_RESTART
:
697 layout
= ALGORITHM_LEFT_ASYMMETRIC
;
699 case DDF_RAID5_0_RESTART
:
700 layout
= ALGORITHM_RIGHT_ASYMMETRIC
;
702 case DDF_RAID5_N_CONTINUE
:
703 layout
= ALGORITHM_LEFT_SYMMETRIC
;
706 return err_bad_ddf_layout(conf
);
712 case DDF_RAID5_N_RESTART
:
713 layout
= ALGORITHM_ROTATING_N_RESTART
;
715 case DDF_RAID6_0_RESTART
:
716 layout
= ALGORITHM_ROTATING_ZERO_RESTART
;
718 case DDF_RAID5_N_CONTINUE
:
719 layout
= ALGORITHM_ROTATING_N_CONTINUE
;
722 return err_bad_ddf_layout(conf
);
727 return err_bad_ddf_layout(conf
);
731 array
->level
= level
;
732 array
->layout
= layout
;
733 array
->raid_disks
= raiddisks
;
737 static int load_ddf_header(int fd
, unsigned long long lba
,
738 unsigned long long size
,
740 struct ddf_header
*hdr
, struct ddf_header
*anchor
)
742 /* read a ddf header (primary or secondary) from fd/lba
743 * and check that it is consistent with anchor
745 * magic, crc, guid, rev, and LBA's header_type, and
746 * everything after header_type must be the same
751 if (lseek64(fd
, lba
<<9, 0) < 0)
754 if (read(fd
, hdr
, 512) != 512)
757 if (!be32_eq(hdr
->magic
, DDF_HEADER_MAGIC
)) {
758 pr_err("%s: bad header magic\n", __func__
);
761 if (!be32_eq(calc_crc(hdr
, 512), hdr
->crc
)) {
762 pr_err("%s: bad CRC\n", __func__
);
765 if (memcmp(anchor
->guid
, hdr
->guid
, DDF_GUID_LEN
) != 0 ||
766 memcmp(anchor
->revision
, hdr
->revision
, 8) != 0 ||
767 !be64_eq(anchor
->primary_lba
, hdr
->primary_lba
) ||
768 !be64_eq(anchor
->secondary_lba
, hdr
->secondary_lba
) ||
770 memcmp(anchor
->pad2
, hdr
->pad2
, 512 -
771 offsetof(struct ddf_header
, pad2
)) != 0) {
772 pr_err("%s: header mismatch\n", __func__
);
776 /* Looks good enough to me... */
780 static void *load_section(int fd
, struct ddf_super
*super
, void *buf
,
781 be32 offset_be
, be32 len_be
, int check
)
783 unsigned long long offset
= be32_to_cpu(offset_be
);
784 unsigned long long len
= be32_to_cpu(len_be
);
785 int dofree
= (buf
== NULL
);
788 if (len
!= 2 && len
!= 8 && len
!= 32
789 && len
!= 128 && len
!= 512)
795 /* All pre-allocated sections are a single block */
798 } else if (posix_memalign(&buf
, 512, len
<<9) != 0)
804 if (super
->active
->type
== 1)
805 offset
+= be64_to_cpu(super
->active
->primary_lba
);
807 offset
+= be64_to_cpu(super
->active
->secondary_lba
);
809 if ((unsigned long long)lseek64(fd
, offset
<<9, 0) != (offset
<<9)) {
814 if ((unsigned long long)read(fd
, buf
, len
<<9) != (len
<<9)) {
822 static int load_ddf_headers(int fd
, struct ddf_super
*super
, char *devname
)
824 unsigned long long dsize
;
826 get_dev_size(fd
, NULL
, &dsize
);
828 if (lseek64(fd
, dsize
-512, 0) < 0) {
830 pr_err("Cannot seek to anchor block on %s: %s\n",
831 devname
, strerror(errno
));
834 if (read(fd
, &super
->anchor
, 512) != 512) {
836 pr_err("Cannot read anchor block on %s: %s\n",
837 devname
, strerror(errno
));
840 if (!be32_eq(super
->anchor
.magic
, DDF_HEADER_MAGIC
)) {
842 pr_err("no DDF anchor found on %s\n",
846 if (!be32_eq(calc_crc(&super
->anchor
, 512), super
->anchor
.crc
)) {
848 pr_err("bad CRC on anchor on %s\n",
852 if (memcmp(super
->anchor
.revision
, DDF_REVISION_0
, 8) != 0 &&
853 memcmp(super
->anchor
.revision
, DDF_REVISION_2
, 8) != 0) {
855 pr_err("can only support super revision"
856 " %.8s and earlier, not %.8s on %s\n",
857 DDF_REVISION_2
, super
->anchor
.revision
,devname
);
860 super
->active
= NULL
;
861 if (load_ddf_header(fd
, be64_to_cpu(super
->anchor
.primary_lba
),
863 &super
->primary
, &super
->anchor
) == 0) {
865 pr_err("Failed to load primary DDF header "
868 super
->active
= &super
->primary
;
870 if (load_ddf_header(fd
, be64_to_cpu(super
->anchor
.secondary_lba
),
872 &super
->secondary
, &super
->anchor
)) {
873 if (super
->active
== NULL
874 || (be32_to_cpu(super
->primary
.seq
)
875 < be32_to_cpu(super
->secondary
.seq
) &&
876 !super
->secondary
.openflag
)
877 || (be32_to_cpu(super
->primary
.seq
)
878 == be32_to_cpu(super
->secondary
.seq
) &&
879 super
->primary
.openflag
&& !super
->secondary
.openflag
)
881 super
->active
= &super
->secondary
;
883 pr_err("Failed to load secondary DDF header on %s\n",
885 if (super
->active
== NULL
)
890 static int load_ddf_global(int fd
, struct ddf_super
*super
, char *devname
)
893 ok
= load_section(fd
, super
, &super
->controller
,
894 super
->active
->controller_section_offset
,
895 super
->active
->controller_section_length
,
897 super
->phys
= load_section(fd
, super
, NULL
,
898 super
->active
->phys_section_offset
,
899 super
->active
->phys_section_length
,
901 super
->pdsize
= be32_to_cpu(super
->active
->phys_section_length
) * 512;
903 super
->virt
= load_section(fd
, super
, NULL
,
904 super
->active
->virt_section_offset
,
905 super
->active
->virt_section_length
,
907 super
->vdsize
= be32_to_cpu(super
->active
->virt_section_length
) * 512;
917 super
->conflist
= NULL
;
920 super
->max_part
= be16_to_cpu(super
->active
->max_partitions
);
921 super
->mppe
= be16_to_cpu(super
->active
->max_primary_element_entries
);
922 super
->conf_rec_len
= be16_to_cpu(super
->active
->config_record_len
);
926 #define DDF_UNUSED_BVD 0xff
927 static int alloc_other_bvds(const struct ddf_super
*ddf
, struct vcl
*vcl
)
929 unsigned int n_vds
= vcl
->conf
.sec_elmnt_count
- 1;
930 unsigned int i
, vdsize
;
933 vcl
->other_bvds
= NULL
;
936 vdsize
= ddf
->conf_rec_len
* 512;
937 if (posix_memalign(&p
, 512, n_vds
*
938 (vdsize
+ sizeof(struct vd_config
*))) != 0)
940 vcl
->other_bvds
= (struct vd_config
**) (p
+ n_vds
* vdsize
);
941 for (i
= 0; i
< n_vds
; i
++) {
942 vcl
->other_bvds
[i
] = p
+ i
* vdsize
;
943 memset(vcl
->other_bvds
[i
], 0, vdsize
);
944 vcl
->other_bvds
[i
]->sec_elmnt_seq
= DDF_UNUSED_BVD
;
949 static void add_other_bvd(struct vcl
*vcl
, struct vd_config
*vd
,
953 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
954 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== vd
->sec_elmnt_seq
)
957 if (i
< vcl
->conf
.sec_elmnt_count
-1) {
958 if (be32_to_cpu(vd
->seqnum
) <=
959 be32_to_cpu(vcl
->other_bvds
[i
]->seqnum
))
962 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
963 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== DDF_UNUSED_BVD
)
965 if (i
== vcl
->conf
.sec_elmnt_count
-1) {
966 pr_err("no space for sec level config %u, count is %u\n",
967 vd
->sec_elmnt_seq
, vcl
->conf
.sec_elmnt_count
);
971 memcpy(vcl
->other_bvds
[i
], vd
, len
);
974 static int load_ddf_local(int fd
, struct ddf_super
*super
,
975 char *devname
, int keep
)
981 unsigned int confsec
;
983 unsigned int max_virt_disks
= be16_to_cpu
984 (super
->active
->max_vd_entries
);
985 unsigned long long dsize
;
987 /* First the local disk info */
988 if (posix_memalign((void**)&dl
, 512,
990 (super
->max_part
) * sizeof(dl
->vlist
[0])) != 0) {
991 pr_err("%s could not allocate disk info buffer\n",
996 load_section(fd
, super
, &dl
->disk
,
997 super
->active
->data_section_offset
,
998 super
->active
->data_section_length
,
1000 dl
->devname
= devname
? xstrdup(devname
) : NULL
;
1003 dl
->major
= major(stb
.st_rdev
);
1004 dl
->minor
= minor(stb
.st_rdev
);
1005 dl
->next
= super
->dlist
;
1006 dl
->fd
= keep
? fd
: -1;
1009 if (get_dev_size(fd
, devname
, &dsize
))
1010 dl
->size
= dsize
>> 9;
1011 /* If the disks have different sizes, the LBAs will differ
1012 * between phys disks.
1013 * At this point here, the values in super->active must be valid
1014 * for this phys disk. */
1015 dl
->primary_lba
= super
->active
->primary_lba
;
1016 dl
->secondary_lba
= super
->active
->secondary_lba
;
1017 dl
->workspace_lba
= super
->active
->workspace_lba
;
1019 for (i
= 0 ; i
< super
->max_part
; i
++)
1020 dl
->vlist
[i
] = NULL
;
1023 for (i
= 0; i
< be16_to_cpu(super
->active
->max_pd_entries
); i
++)
1024 if (memcmp(super
->phys
->entries
[i
].guid
,
1025 dl
->disk
.guid
, DDF_GUID_LEN
) == 0)
1028 /* Now the config list. */
1029 /* 'conf' is an array of config entries, some of which are
1030 * probably invalid. Those which are good need to be copied into
1034 conf
= load_section(fd
, super
, NULL
,
1035 super
->active
->config_section_offset
,
1036 super
->active
->config_section_length
,
1041 confsec
< be32_to_cpu(super
->active
->config_section_length
);
1042 confsec
+= super
->conf_rec_len
) {
1043 struct vd_config
*vd
=
1044 (struct vd_config
*)((char*)conf
+ confsec
*512);
1047 if (be32_eq(vd
->magic
, DDF_SPARE_ASSIGN_MAGIC
)) {
1050 if (posix_memalign((void**)&dl
->spare
, 512,
1051 super
->conf_rec_len
*512) != 0) {
1052 pr_err("%s could not allocate spare info buf\n",
1057 memcpy(dl
->spare
, vd
, super
->conf_rec_len
*512);
1060 if (!be32_eq(vd
->magic
, DDF_VD_CONF_MAGIC
))
1062 for (vcl
= super
->conflist
; vcl
; vcl
= vcl
->next
) {
1063 if (memcmp(vcl
->conf
.guid
,
1064 vd
->guid
, DDF_GUID_LEN
) == 0)
1069 dl
->vlist
[vnum
++] = vcl
;
1070 if (vcl
->other_bvds
!= NULL
&&
1071 vcl
->conf
.sec_elmnt_seq
!= vd
->sec_elmnt_seq
) {
1072 add_other_bvd(vcl
, vd
, super
->conf_rec_len
*512);
1075 if (be32_to_cpu(vd
->seqnum
) <=
1076 be32_to_cpu(vcl
->conf
.seqnum
))
1079 if (posix_memalign((void**)&vcl
, 512,
1080 (super
->conf_rec_len
*512 +
1081 offsetof(struct vcl
, conf
))) != 0) {
1082 pr_err("%s could not allocate vcl buf\n",
1086 vcl
->next
= super
->conflist
;
1087 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
1088 vcl
->conf
.sec_elmnt_count
= vd
->sec_elmnt_count
;
1089 if (alloc_other_bvds(super
, vcl
) != 0) {
1090 pr_err("%s could not allocate other bvds\n",
1095 super
->conflist
= vcl
;
1096 dl
->vlist
[vnum
++] = vcl
;
1098 memcpy(&vcl
->conf
, vd
, super
->conf_rec_len
*512);
1099 for (i
=0; i
< max_virt_disks
; i
++)
1100 if (memcmp(super
->virt
->entries
[i
].guid
,
1101 vcl
->conf
.guid
, DDF_GUID_LEN
)==0)
1103 if (i
< max_virt_disks
)
1112 static int load_super_ddf_all(struct supertype
*st
, int fd
,
1113 void **sbp
, char *devname
);
1116 static void free_super_ddf(struct supertype
*st
);
1118 static int load_super_ddf(struct supertype
*st
, int fd
,
1121 unsigned long long dsize
;
1122 struct ddf_super
*super
;
1125 if (get_dev_size(fd
, devname
, &dsize
) == 0)
1128 if (!st
->ignore_hw_compat
&& test_partition(fd
))
1129 /* DDF is not allowed on partitions */
1132 /* 32M is a lower bound */
1133 if (dsize
<= 32*1024*1024) {
1135 pr_err("%s is too small for ddf: "
1136 "size is %llu sectors.\n",
1142 pr_err("%s is an odd size for ddf: "
1143 "size is %llu bytes.\n",
1150 if (posix_memalign((void**)&super
, 512, sizeof(*super
))!= 0) {
1151 pr_err("malloc of %zu failed.\n",
1155 memset(super
, 0, sizeof(*super
));
1157 rv
= load_ddf_headers(fd
, super
, devname
);
1163 /* Have valid headers and have chosen the best. Let's read in the rest*/
1165 rv
= load_ddf_global(fd
, super
, devname
);
1169 pr_err("Failed to load all information "
1170 "sections on %s\n", devname
);
1175 rv
= load_ddf_local(fd
, super
, devname
, 0);
1179 pr_err("Failed to load all information "
1180 "sections on %s\n", devname
);
1185 /* Should possibly check the sections .... */
1188 if (st
->ss
== NULL
) {
1189 st
->ss
= &super_ddf
;
1190 st
->minor_version
= 0;
1197 static void free_super_ddf(struct supertype
*st
)
1199 struct ddf_super
*ddf
= st
->sb
;
1204 while (ddf
->conflist
) {
1205 struct vcl
*v
= ddf
->conflist
;
1206 ddf
->conflist
= v
->next
;
1208 free(v
->block_sizes
);
1211 v->other_bvds[0] points to beginning of buffer,
1212 see alloc_other_bvds()
1214 free(v
->other_bvds
[0]);
1217 while (ddf
->dlist
) {
1218 struct dl
*d
= ddf
->dlist
;
1219 ddf
->dlist
= d
->next
;
1226 while (ddf
->add_list
) {
1227 struct dl
*d
= ddf
->add_list
;
1228 ddf
->add_list
= d
->next
;
1239 static struct supertype
*match_metadata_desc_ddf(char *arg
)
1241 /* 'ddf' only support containers */
1242 struct supertype
*st
;
1243 if (strcmp(arg
, "ddf") != 0 &&
1244 strcmp(arg
, "default") != 0
1248 st
= xcalloc(1, sizeof(*st
));
1249 st
->ss
= &super_ddf
;
1251 st
->minor_version
= 0;
1258 static mapping_t ddf_state
[] = {
1264 { "Partially Optimal", 5},
1270 static mapping_t ddf_init_state
[] = {
1271 { "Not Initialised", 0},
1272 { "QuickInit in Progress", 1},
1273 { "Fully Initialised", 2},
1277 static mapping_t ddf_access
[] = {
1281 { "Blocked (no access)", 3},
1285 static mapping_t ddf_level
[] = {
1286 { "RAID0", DDF_RAID0
},
1287 { "RAID1", DDF_RAID1
},
1288 { "RAID3", DDF_RAID3
},
1289 { "RAID4", DDF_RAID4
},
1290 { "RAID5", DDF_RAID5
},
1291 { "RAID1E",DDF_RAID1E
},
1292 { "JBOD", DDF_JBOD
},
1293 { "CONCAT",DDF_CONCAT
},
1294 { "RAID5E",DDF_RAID5E
},
1295 { "RAID5EE",DDF_RAID5EE
},
1296 { "RAID6", DDF_RAID6
},
1299 static mapping_t ddf_sec_level
[] = {
1300 { "Striped", DDF_2STRIPED
},
1301 { "Mirrored", DDF_2MIRRORED
},
1302 { "Concat", DDF_2CONCAT
},
1303 { "Spanned", DDF_2SPANNED
},
1308 static int all_ff(const char *guid
)
1311 for (i
= 0; i
< DDF_GUID_LEN
; i
++)
1312 if (guid
[i
] != (char)0xff)
1317 static const char *guid_str(const char *guid
)
1319 static char buf
[DDF_GUID_LEN
*2+1];
1322 for (i
= 0; i
< DDF_GUID_LEN
; i
++) {
1323 unsigned char c
= guid
[i
];
1324 if (c
>= 32 && c
< 127)
1325 p
+= sprintf(p
, "%c", c
);
1327 p
+= sprintf(p
, "%02x", c
);
1330 return (const char *) buf
;
1334 static void print_guid(char *guid
, int tstamp
)
1336 /* A GUIDs are part (or all) ASCII and part binary.
1337 * They tend to be space padded.
1338 * We print the GUID in HEX, then in parentheses add
1339 * any initial ASCII sequence, and a possible
1340 * time stamp from bytes 16-19
1342 int l
= DDF_GUID_LEN
;
1345 for (i
=0 ; i
<DDF_GUID_LEN
; i
++) {
1346 if ((i
&3)==0 && i
!= 0) printf(":");
1347 printf("%02X", guid
[i
]&255);
1351 while (l
&& guid
[l
-1] == ' ')
1353 for (i
=0 ; i
<l
; i
++) {
1354 if (guid
[i
] >= 0x20 && guid
[i
] < 0x7f)
1355 fputc(guid
[i
], stdout
);
1360 time_t then
= __be32_to_cpu(*(__u32
*)(guid
+16)) + DECADE
;
1363 tm
= localtime(&then
);
1364 strftime(tbuf
, 100, " %D %T",tm
);
1365 fputs(tbuf
, stdout
);
1370 static void examine_vd(int n
, struct ddf_super
*sb
, char *guid
)
1372 int crl
= sb
->conf_rec_len
;
1375 for (vcl
= sb
->conflist
; vcl
; vcl
= vcl
->next
) {
1377 struct vd_config
*vc
= &vcl
->conf
;
1379 if (!be32_eq(calc_crc(vc
, crl
*512), vc
->crc
))
1381 if (memcmp(vc
->guid
, guid
, DDF_GUID_LEN
) != 0)
1384 /* Ok, we know about this VD, let's give more details */
1385 printf(" Raid Devices[%d] : %d (", n
,
1386 be16_to_cpu(vc
->prim_elmnt_count
));
1387 for (i
= 0; i
< be16_to_cpu(vc
->prim_elmnt_count
); i
++) {
1389 int cnt
= be16_to_cpu(sb
->phys
->used_pdes
);
1390 for (j
=0; j
<cnt
; j
++)
1391 if (be32_eq(vc
->phys_refnum
[i
],
1392 sb
->phys
->entries
[j
].refnum
))
1401 if (vc
->chunk_shift
!= 255)
1402 printf(" Chunk Size[%d] : %d sectors\n", n
,
1403 1 << vc
->chunk_shift
);
1404 printf(" Raid Level[%d] : %s\n", n
,
1405 map_num(ddf_level
, vc
->prl
)?:"-unknown-");
1406 if (vc
->sec_elmnt_count
!= 1) {
1407 printf(" Secondary Position[%d] : %d of %d\n", n
,
1408 vc
->sec_elmnt_seq
, vc
->sec_elmnt_count
);
1409 printf(" Secondary Level[%d] : %s\n", n
,
1410 map_num(ddf_sec_level
, vc
->srl
) ?: "-unknown-");
1412 printf(" Device Size[%d] : %llu\n", n
,
1413 be64_to_cpu(vc
->blocks
)/2);
1414 printf(" Array Size[%d] : %llu\n", n
,
1415 be64_to_cpu(vc
->array_blocks
)/2);
1419 static void examine_vds(struct ddf_super
*sb
)
1421 int cnt
= be16_to_cpu(sb
->virt
->populated_vdes
);
1423 printf(" Virtual Disks : %d\n", cnt
);
1425 for (i
= 0; i
< be16_to_cpu(sb
->virt
->max_vdes
); i
++) {
1426 struct virtual_entry
*ve
= &sb
->virt
->entries
[i
];
1427 if (all_ff(ve
->guid
))
1430 printf(" VD GUID[%d] : ", i
); print_guid(ve
->guid
, 1);
1432 printf(" unit[%d] : %d\n", i
, be16_to_cpu(ve
->unit
));
1433 printf(" state[%d] : %s, %s%s\n", i
,
1434 map_num(ddf_state
, ve
->state
& 7),
1435 (ve
->state
& DDF_state_morphing
) ? "Morphing, ": "",
1436 (ve
->state
& DDF_state_inconsistent
)? "Not Consistent" : "Consistent");
1437 printf(" init state[%d] : %s\n", i
,
1438 map_num(ddf_init_state
, ve
->init_state
&DDF_initstate_mask
));
1439 printf(" access[%d] : %s\n", i
,
1440 map_num(ddf_access
, (ve
->init_state
& DDF_access_mask
) >> 6));
1441 printf(" Name[%d] : %.16s\n", i
, ve
->name
);
1442 examine_vd(i
, sb
, ve
->guid
);
1444 if (cnt
) printf("\n");
1447 static void examine_pds(struct ddf_super
*sb
)
1449 int cnt
= be16_to_cpu(sb
->phys
->used_pdes
);
1452 printf(" Physical Disks : %d\n", cnt
);
1453 printf(" Number RefNo Size Device Type/State\n");
1455 for (i
=0 ; i
<cnt
; i
++) {
1456 struct phys_disk_entry
*pd
= &sb
->phys
->entries
[i
];
1457 int type
= be16_to_cpu(pd
->type
);
1458 int state
= be16_to_cpu(pd
->state
);
1460 //printf(" PD GUID[%d] : ", i); print_guid(pd->guid, 0);
1462 printf(" %3d %08x ", i
,
1463 be32_to_cpu(pd
->refnum
));
1465 be64_to_cpu(pd
->config_size
)>>1);
1466 for (dl
= sb
->dlist
; dl
; dl
= dl
->next
) {
1467 if (be32_eq(dl
->disk
.refnum
, pd
->refnum
)) {
1468 char *dv
= map_dev(dl
->major
, dl
->minor
, 0);
1470 printf("%-15s", dv
);
1477 printf(" %s%s%s%s%s",
1478 (type
&2) ? "active":"",
1479 (type
&4) ? "Global-Spare":"",
1480 (type
&8) ? "spare" : "",
1481 (type
&16)? ", foreign" : "",
1482 (type
&32)? "pass-through" : "");
1483 if (state
& DDF_Failed
)
1484 /* This over-rides these three */
1485 state
&= ~(DDF_Online
|DDF_Rebuilding
|DDF_Transition
);
1486 printf("/%s%s%s%s%s%s%s",
1487 (state
&1)? "Online": "Offline",
1488 (state
&2)? ", Failed": "",
1489 (state
&4)? ", Rebuilding": "",
1490 (state
&8)? ", in-transition": "",
1491 (state
&16)? ", SMART-errors": "",
1492 (state
&32)? ", Unrecovered-Read-Errors": "",
1493 (state
&64)? ", Missing" : "");
1498 static void examine_super_ddf(struct supertype
*st
, char *homehost
)
1500 struct ddf_super
*sb
= st
->sb
;
1502 printf(" Magic : %08x\n", be32_to_cpu(sb
->anchor
.magic
));
1503 printf(" Version : %.8s\n", sb
->anchor
.revision
);
1504 printf("Controller GUID : "); print_guid(sb
->controller
.guid
, 0);
1506 printf(" Container GUID : "); print_guid(sb
->anchor
.guid
, 1);
1508 printf(" Seq : %08x\n", be32_to_cpu(sb
->active
->seq
));
1509 printf(" Redundant hdr : %s\n", be32_eq(sb
->secondary
.magic
,
1516 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1518 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4]);
1519 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4]);
1521 static unsigned int get_vd_num_of_subarray(struct supertype
*st
)
1524 * Figure out the VD number for this supertype.
1525 * Returns DDF_CONTAINER for the container itself,
1526 * and DDF_NOTFOUND on error.
1528 struct ddf_super
*ddf
= st
->sb
;
1533 if (*st
->container_devnm
== '\0')
1534 return DDF_CONTAINER
;
1536 sra
= sysfs_read(-1, st
->devnm
, GET_VERSION
);
1537 if (!sra
|| sra
->array
.major_version
!= -1 ||
1538 sra
->array
.minor_version
!= -2 ||
1539 !is_subarray(sra
->text_version
))
1540 return DDF_NOTFOUND
;
1542 sub
= strchr(sra
->text_version
+ 1, '/');
1544 vcnum
= strtoul(sub
+ 1, &end
, 10);
1545 if (sub
== NULL
|| *sub
== '\0' || *end
!= '\0' ||
1546 vcnum
>= be16_to_cpu(ddf
->active
->max_vd_entries
))
1547 return DDF_NOTFOUND
;
1552 static void brief_examine_super_ddf(struct supertype
*st
, int verbose
)
1554 /* We just write a generic DDF ARRAY entry
1558 getinfo_super_ddf(st
, &info
, NULL
);
1559 fname_from_uuid(st
, &info
, nbuf
, ':');
1561 printf("ARRAY metadata=ddf UUID=%s\n", nbuf
+ 5);
1564 static void brief_examine_subarrays_ddf(struct supertype
*st
, int verbose
)
1566 /* We just write a generic DDF ARRAY entry
1568 struct ddf_super
*ddf
= st
->sb
;
1572 getinfo_super_ddf(st
, &info
, NULL
);
1573 fname_from_uuid(st
, &info
, nbuf
, ':');
1575 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
1576 struct virtual_entry
*ve
= &ddf
->virt
->entries
[i
];
1579 if (all_ff(ve
->guid
))
1581 memcpy(vcl
.conf
.guid
, ve
->guid
, DDF_GUID_LEN
);
1582 ddf
->currentconf
=&vcl
;
1583 uuid_from_super_ddf(st
, info
.uuid
);
1584 fname_from_uuid(st
, &info
, nbuf1
, ':');
1585 printf("ARRAY container=%s member=%d UUID=%s\n",
1586 nbuf
+5, i
, nbuf1
+5);
1590 static void export_examine_super_ddf(struct supertype
*st
)
1594 getinfo_super_ddf(st
, &info
, NULL
);
1595 fname_from_uuid(st
, &info
, nbuf
, ':');
1596 printf("MD_METADATA=ddf\n");
1597 printf("MD_LEVEL=container\n");
1598 printf("MD_UUID=%s\n", nbuf
+5);
1601 static int copy_metadata_ddf(struct supertype
*st
, int from
, int to
)
1604 unsigned long long dsize
, offset
;
1606 struct ddf_header
*ddf
;
1609 /* The meta consists of an anchor, a primary, and a secondary.
1610 * This all lives at the end of the device.
1611 * So it is easiest to find the earliest of primary and
1612 * secondary, and copy everything from there.
1614 * Anchor is 512 from end It contains primary_lba and secondary_lba
1615 * we choose one of those
1618 if (posix_memalign(&buf
, 4096, 4096) != 0)
1621 if (!get_dev_size(from
, NULL
, &dsize
))
1624 if (lseek64(from
, dsize
-512, 0) < 0)
1626 if (read(from
, buf
, 512) != 512)
1629 if (!be32_eq(ddf
->magic
, DDF_HEADER_MAGIC
) ||
1630 !be32_eq(calc_crc(ddf
, 512), ddf
->crc
) ||
1631 (memcmp(ddf
->revision
, DDF_REVISION_0
, 8) != 0 &&
1632 memcmp(ddf
->revision
, DDF_REVISION_2
, 8) != 0))
1635 offset
= dsize
- 512;
1636 if ((be64_to_cpu(ddf
->primary_lba
) << 9) < offset
)
1637 offset
= be64_to_cpu(ddf
->primary_lba
) << 9;
1638 if ((be64_to_cpu(ddf
->secondary_lba
) << 9) < offset
)
1639 offset
= be64_to_cpu(ddf
->secondary_lba
) << 9;
1641 bytes
= dsize
- offset
;
1643 if (lseek64(from
, offset
, 0) < 0 ||
1644 lseek64(to
, offset
, 0) < 0)
1646 while (written
< bytes
) {
1647 int n
= bytes
- written
;
1650 if (read(from
, buf
, n
) != n
)
1652 if (write(to
, buf
, n
) != n
)
1663 static void detail_super_ddf(struct supertype
*st
, char *homehost
)
1666 * Could print DDF GUID
1667 * Need to find which array
1668 * If whole, briefly list all arrays
1673 static void brief_detail_super_ddf(struct supertype
*st
)
1677 struct ddf_super
*ddf
= st
->sb
;
1678 unsigned int vcnum
= get_vd_num_of_subarray(st
);
1679 if (vcnum
== DDF_CONTAINER
)
1680 uuid_from_super_ddf(st
, info
.uuid
);
1681 else if (vcnum
== DDF_NOTFOUND
)
1684 uuid_from_ddf_guid(ddf
->virt
->entries
[vcnum
].guid
, info
.uuid
);
1685 fname_from_uuid(st
, &info
, nbuf
,':');
1686 printf(" UUID=%s", nbuf
+ 5);
1690 static int match_home_ddf(struct supertype
*st
, char *homehost
)
1692 /* It matches 'this' host if the controller is a
1693 * Linux-MD controller with vendor_data matching
1696 struct ddf_super
*ddf
= st
->sb
;
1701 len
= strlen(homehost
);
1703 return (memcmp(ddf
->controller
.guid
, T10
, 8) == 0 &&
1704 len
< sizeof(ddf
->controller
.vendor_data
) &&
1705 memcmp(ddf
->controller
.vendor_data
, homehost
,len
) == 0 &&
1706 ddf
->controller
.vendor_data
[len
] == 0);
1710 static int find_index_in_bvd(const struct ddf_super
*ddf
,
1711 const struct vd_config
*conf
, unsigned int n
,
1712 unsigned int *n_bvd
)
1715 * Find the index of the n-th valid physical disk in this BVD
1718 for (i
= 0, j
= 0; i
< ddf
->mppe
&&
1719 j
< be16_to_cpu(conf
->prim_elmnt_count
); i
++) {
1720 if (be32_to_cpu(conf
->phys_refnum
[i
]) != 0xffffffff) {
1728 dprintf("%s: couldn't find BVD member %u (total %u)\n",
1729 __func__
, n
, be16_to_cpu(conf
->prim_elmnt_count
));
1733 static struct vd_config
*find_vdcr(struct ddf_super
*ddf
, unsigned int inst
,
1735 unsigned int *n_bvd
, struct vcl
**vcl
)
1739 for (v
= ddf
->conflist
; v
; v
= v
->next
) {
1740 unsigned int nsec
, ibvd
= 0;
1741 struct vd_config
*conf
;
1742 if (inst
!= v
->vcnum
)
1745 if (conf
->sec_elmnt_count
== 1) {
1746 if (find_index_in_bvd(ddf
, conf
, n
, n_bvd
)) {
1752 if (v
->other_bvds
== NULL
) {
1753 pr_err("%s: BUG: other_bvds is NULL, nsec=%u\n",
1754 __func__
, conf
->sec_elmnt_count
);
1757 nsec
= n
/ be16_to_cpu(conf
->prim_elmnt_count
);
1758 if (conf
->sec_elmnt_seq
!= nsec
) {
1759 for (ibvd
= 1; ibvd
< conf
->sec_elmnt_count
; ibvd
++) {
1760 if (v
->other_bvds
[ibvd
-1]->sec_elmnt_seq
1764 if (ibvd
== conf
->sec_elmnt_count
)
1766 conf
= v
->other_bvds
[ibvd
-1];
1768 if (!find_index_in_bvd(ddf
, conf
,
1769 n
- nsec
*conf
->sec_elmnt_count
, n_bvd
))
1771 dprintf("%s: found disk %u as member %u in bvd %d of array %u\n"
1772 , __func__
, n
, *n_bvd
, ibvd
, inst
);
1777 pr_err("%s: Could't find disk %d in array %u\n", __func__
, n
, inst
);
1782 static int find_phys(const struct ddf_super
*ddf
, be32 phys_refnum
)
1784 /* Find the entry in phys_disk which has the given refnum
1785 * and return it's index
1788 for (i
= 0; i
< be16_to_cpu(ddf
->phys
->max_pdes
); i
++)
1789 if (be32_eq(ddf
->phys
->entries
[i
].refnum
, phys_refnum
))
1794 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4])
1797 struct sha1_ctx ctx
;
1798 sha1_init_ctx(&ctx
);
1799 sha1_process_bytes(guid
, DDF_GUID_LEN
, &ctx
);
1800 sha1_finish_ctx(&ctx
, buf
);
1801 memcpy(uuid
, buf
, 4*4);
1804 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4])
1806 /* The uuid returned here is used for:
1807 * uuid to put into bitmap file (Create, Grow)
1808 * uuid for backup header when saving critical section (Grow)
1809 * comparing uuids when re-adding a device into an array
1810 * In these cases the uuid required is that of the data-array,
1811 * not the device-set.
1812 * uuid to recognise same set when adding a missing device back
1813 * to an array. This is a uuid for the device-set.
1815 * For each of these we can make do with a truncated
1816 * or hashed uuid rather than the original, as long as
1818 * In the case of SVD we assume the BVD is of interest,
1819 * though that might be the case if a bitmap were made for
1820 * a mirrored SVD - worry about that later.
1821 * So we need to find the VD configuration record for the
1822 * relevant BVD and extract the GUID and Secondary_Element_Seq.
1823 * The first 16 bytes of the sha1 of these is used.
1825 struct ddf_super
*ddf
= st
->sb
;
1826 struct vcl
*vcl
= ddf
->currentconf
;
1830 guid
= vcl
->conf
.guid
;
1832 guid
= ddf
->anchor
.guid
;
1833 uuid_from_ddf_guid(guid
, uuid
);
1836 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1838 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1840 struct ddf_super
*ddf
= st
->sb
;
1841 int map_disks
= info
->array
.raid_disks
;
1844 if (ddf
->currentconf
) {
1845 getinfo_super_ddf_bvd(st
, info
, map
);
1848 memset(info
, 0, sizeof(*info
));
1850 info
->array
.raid_disks
= be16_to_cpu(ddf
->phys
->used_pdes
);
1851 info
->array
.level
= LEVEL_CONTAINER
;
1852 info
->array
.layout
= 0;
1853 info
->array
.md_minor
= -1;
1854 cptr
= (__u32
*)(ddf
->anchor
.guid
+ 16);
1855 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1857 info
->array
.utime
= 0;
1858 info
->array
.chunk_size
= 0;
1859 info
->container_enough
= 1;
1861 info
->disk
.major
= 0;
1862 info
->disk
.minor
= 0;
1864 info
->disk
.number
= be32_to_cpu(ddf
->dlist
->disk
.refnum
);
1865 info
->disk
.raid_disk
= find_phys(ddf
, ddf
->dlist
->disk
.refnum
);
1867 info
->data_offset
= be64_to_cpu(ddf
->phys
->
1868 entries
[info
->disk
.raid_disk
].
1870 info
->component_size
= ddf
->dlist
->size
- info
->data_offset
;
1872 info
->disk
.number
= -1;
1873 info
->disk
.raid_disk
= -1;
1874 // info->disk.raid_disk = find refnum in the table and use index;
1876 info
->disk
.state
= (1 << MD_DISK_SYNC
) | (1 << MD_DISK_ACTIVE
);
1878 info
->recovery_start
= MaxSector
;
1879 info
->reshape_active
= 0;
1880 info
->recovery_blocked
= 0;
1883 info
->array
.major_version
= -1;
1884 info
->array
.minor_version
= -2;
1885 strcpy(info
->text_version
, "ddf");
1886 info
->safe_mode_delay
= 0;
1888 uuid_from_super_ddf(st
, info
->uuid
);
1892 for (i
= 0 ; i
< map_disks
; i
++) {
1893 if (i
< info
->array
.raid_disks
&&
1894 (be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1896 !(be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1905 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1907 struct ddf_super
*ddf
= st
->sb
;
1908 struct vcl
*vc
= ddf
->currentconf
;
1909 int cd
= ddf
->currentdev
;
1913 int map_disks
= info
->array
.raid_disks
;
1915 struct vd_config
*conf
;
1917 memset(info
, 0, sizeof(*info
));
1918 if (layout_ddf2md(&vc
->conf
, &info
->array
) == -1)
1920 info
->array
.md_minor
= -1;
1921 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
1922 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1923 info
->array
.utime
= DECADE
+ be32_to_cpu(vc
->conf
.timestamp
);
1924 info
->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
1925 info
->custom_array_size
= 0;
1928 n_prim
= be16_to_cpu(conf
->prim_elmnt_count
);
1929 if (conf
->sec_elmnt_count
> 1 && cd
>= n_prim
) {
1930 int ibvd
= cd
/ n_prim
- 1;
1932 conf
= vc
->other_bvds
[ibvd
];
1935 if (cd
>= 0 && (unsigned)cd
< ddf
->mppe
) {
1937 be64_to_cpu(LBA_OFFSET(ddf
, conf
)[cd
]);
1938 if (vc
->block_sizes
)
1939 info
->component_size
= vc
->block_sizes
[cd
];
1941 info
->component_size
= be64_to_cpu(conf
->blocks
);
1944 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
1945 if (be32_eq(dl
->disk
.refnum
, conf
->phys_refnum
[cd
]))
1948 info
->disk
.major
= 0;
1949 info
->disk
.minor
= 0;
1950 info
->disk
.state
= 0;
1952 info
->disk
.major
= dl
->major
;
1953 info
->disk
.minor
= dl
->minor
;
1954 info
->disk
.raid_disk
= cd
+ conf
->sec_elmnt_seq
1955 * be16_to_cpu(conf
->prim_elmnt_count
);
1956 info
->disk
.number
= dl
->pdnum
;
1957 info
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
1960 info
->container_member
= ddf
->currentconf
->vcnum
;
1962 info
->recovery_start
= MaxSector
;
1963 info
->resync_start
= 0;
1964 info
->reshape_active
= 0;
1965 info
->recovery_blocked
= 0;
1966 if (!(ddf
->virt
->entries
[info
->container_member
].state
1967 & DDF_state_inconsistent
) &&
1968 (ddf
->virt
->entries
[info
->container_member
].init_state
1969 & DDF_initstate_mask
)
1971 info
->resync_start
= MaxSector
;
1973 uuid_from_super_ddf(st
, info
->uuid
);
1975 info
->array
.major_version
= -1;
1976 info
->array
.minor_version
= -2;
1977 sprintf(info
->text_version
, "/%s/%d",
1978 st
->container_devnm
,
1979 info
->container_member
);
1980 info
->safe_mode_delay
= 200;
1982 memcpy(info
->name
, ddf
->virt
->entries
[info
->container_member
].name
, 16);
1985 if (info
->name
[j
] == ' ')
1989 for (j
= 0; j
< map_disks
; j
++) {
1991 if (j
< info
->array
.raid_disks
) {
1992 int i
= find_phys(ddf
, vc
->conf
.phys_refnum
[j
]);
1994 (be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1996 !(be16_to_cpu(ddf
->phys
->entries
[i
].state
)
2003 static int update_super_ddf(struct supertype
*st
, struct mdinfo
*info
,
2005 char *devname
, int verbose
,
2006 int uuid_set
, char *homehost
)
2008 /* For 'assemble' and 'force' we need to return non-zero if any
2009 * change was made. For others, the return value is ignored.
2010 * Update options are:
2011 * force-one : This device looks a bit old but needs to be included,
2012 * update age info appropriately.
2013 * assemble: clear any 'faulty' flag to allow this device to
2015 * force-array: Array is degraded but being forced, mark it clean
2016 * if that will be needed to assemble it.
2018 * newdev: not used ????
2019 * grow: Array has gained a new device - this is currently for
2021 * resync: mark as dirty so a resync will happen.
2022 * uuid: Change the uuid of the array to match what is given
2023 * homehost: update the recorded homehost
2024 * name: update the name - preserving the homehost
2025 * _reshape_progress: record new reshape_progress position.
2027 * Following are not relevant for this version:
2028 * sparc2.2 : update from old dodgey metadata
2029 * super-minor: change the preferred_minor number
2030 * summaries: update redundant counters.
2033 // struct ddf_super *ddf = st->sb;
2034 // struct vd_config *vd = find_vdcr(ddf, info->container_member);
2035 // struct virtual_entry *ve = find_ve(ddf);
2037 /* we don't need to handle "force-*" or "assemble" as
2038 * there is no need to 'trick' the kernel. We the metadata is
2039 * first updated to activate the array, all the implied modifications
2043 if (strcmp(update
, "grow") == 0) {
2045 } else if (strcmp(update
, "resync") == 0) {
2046 // info->resync_checkpoint = 0;
2047 } else if (strcmp(update
, "homehost") == 0) {
2048 /* homehost is stored in controller->vendor_data,
2049 * or it is when we are the vendor
2051 // if (info->vendor_is_local)
2052 // strcpy(ddf->controller.vendor_data, homehost);
2054 } else if (strcmp(update
, "name") == 0) {
2055 /* name is stored in virtual_entry->name */
2056 // memset(ve->name, ' ', 16);
2057 // strncpy(ve->name, info->name, 16);
2059 } else if (strcmp(update
, "_reshape_progress") == 0) {
2060 /* We don't support reshape yet */
2061 } else if (strcmp(update
, "assemble") == 0 ) {
2062 /* Do nothing, just succeed */
2067 // update_all_csum(ddf);
2072 static void make_header_guid(char *guid
)
2075 /* Create a DDF Header of Virtual Disk GUID */
2077 /* 24 bytes of fiction required.
2078 * first 8 are a 'vendor-id' - "Linux-MD"
2079 * next 8 are controller type.. how about 0X DEAD BEEF 0000 0000
2080 * Remaining 8 random number plus timestamp
2082 memcpy(guid
, T10
, sizeof(T10
));
2083 stamp
= cpu_to_be32(0xdeadbeef);
2084 memcpy(guid
+8, &stamp
, 4);
2085 stamp
= cpu_to_be32(0);
2086 memcpy(guid
+12, &stamp
, 4);
2087 stamp
= cpu_to_be32(time(0) - DECADE
);
2088 memcpy(guid
+16, &stamp
, 4);
2089 stamp
._v32
= random32();
2090 memcpy(guid
+20, &stamp
, 4);
2093 static unsigned int find_unused_vde(const struct ddf_super
*ddf
)
2096 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2097 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2100 return DDF_NOTFOUND
;
2103 static unsigned int find_vde_by_name(const struct ddf_super
*ddf
,
2108 return DDF_NOTFOUND
;
2109 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2110 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2112 if (!strncmp(name
, ddf
->virt
->entries
[i
].name
,
2113 sizeof(ddf
->virt
->entries
[i
].name
)))
2116 return DDF_NOTFOUND
;
2120 static unsigned int find_vde_by_guid(const struct ddf_super
*ddf
,
2124 if (guid
== NULL
|| all_ff(guid
))
2125 return DDF_NOTFOUND
;
2126 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++)
2127 if (!memcmp(ddf
->virt
->entries
[i
].guid
, guid
, DDF_GUID_LEN
))
2129 return DDF_NOTFOUND
;
2133 static int init_super_ddf_bvd(struct supertype
*st
,
2134 mdu_array_info_t
*info
,
2135 unsigned long long size
,
2136 char *name
, char *homehost
,
2137 int *uuid
, unsigned long long data_offset
);
2139 static int init_super_ddf(struct supertype
*st
,
2140 mdu_array_info_t
*info
,
2141 unsigned long long size
, char *name
, char *homehost
,
2142 int *uuid
, unsigned long long data_offset
)
2144 /* This is primarily called by Create when creating a new array.
2145 * We will then get add_to_super called for each component, and then
2146 * write_init_super called to write it out to each device.
2147 * For DDF, Create can create on fresh devices or on a pre-existing
2149 * To create on a pre-existing array a different method will be called.
2150 * This one is just for fresh drives.
2152 * We need to create the entire 'ddf' structure which includes:
2153 * DDF headers - these are easy.
2154 * Controller data - a Sector describing this controller .. not that
2155 * this is a controller exactly.
2156 * Physical Disk Record - one entry per device, so
2157 * leave plenty of space.
2158 * Virtual Disk Records - again, just leave plenty of space.
2159 * This just lists VDs, doesn't give details
2160 * Config records - describes the VDs that use this disk
2161 * DiskData - describes 'this' device.
2162 * BadBlockManagement - empty
2163 * Diag Space - empty
2164 * Vendor Logs - Could we put bitmaps here?
2167 struct ddf_super
*ddf
;
2170 int max_phys_disks
, max_virt_disks
;
2171 unsigned long long sector
;
2175 struct phys_disk
*pd
;
2176 struct virtual_disk
*vd
;
2178 if (data_offset
!= INVALID_SECTORS
) {
2179 pr_err("data-offset not supported by DDF\n");
2184 return init_super_ddf_bvd(st
, info
, size
, name
, homehost
, uuid
,
2187 if (posix_memalign((void**)&ddf
, 512, sizeof(*ddf
)) != 0) {
2188 pr_err("%s could not allocate superblock\n", __func__
);
2191 memset(ddf
, 0, sizeof(*ddf
));
2192 ddf
->dlist
= NULL
; /* no physical disks yet */
2193 ddf
->conflist
= NULL
; /* No virtual disks yet */
2197 /* zeroing superblock */
2201 /* At least 32MB *must* be reserved for the ddf. So let's just
2202 * start 32MB from the end, and put the primary header there.
2203 * Don't do secondary for now.
2204 * We don't know exactly where that will be yet as it could be
2205 * different on each device. To just set up the lengths.
2209 ddf
->anchor
.magic
= DDF_HEADER_MAGIC
;
2210 make_header_guid(ddf
->anchor
.guid
);
2212 memcpy(ddf
->anchor
.revision
, DDF_REVISION_2
, 8);
2213 ddf
->anchor
.seq
= cpu_to_be32(1);
2214 ddf
->anchor
.timestamp
= cpu_to_be32(time(0) - DECADE
);
2215 ddf
->anchor
.openflag
= 0xFF;
2216 ddf
->anchor
.foreignflag
= 0;
2217 ddf
->anchor
.enforcegroups
= 0; /* Is this best?? */
2218 ddf
->anchor
.pad0
= 0xff;
2219 memset(ddf
->anchor
.pad1
, 0xff, 12);
2220 memset(ddf
->anchor
.header_ext
, 0xff, 32);
2221 ddf
->anchor
.primary_lba
= cpu_to_be64(~(__u64
)0);
2222 ddf
->anchor
.secondary_lba
= cpu_to_be64(~(__u64
)0);
2223 ddf
->anchor
.type
= DDF_HEADER_ANCHOR
;
2224 memset(ddf
->anchor
.pad2
, 0xff, 3);
2225 ddf
->anchor
.workspace_len
= cpu_to_be32(32768); /* Must be reserved */
2226 /* Put this at bottom of 32M reserved.. */
2227 ddf
->anchor
.workspace_lba
= cpu_to_be64(~(__u64
)0);
2228 max_phys_disks
= 1023; /* Should be enough */
2229 ddf
->anchor
.max_pd_entries
= cpu_to_be16(max_phys_disks
);
2230 max_virt_disks
= 255;
2231 ddf
->anchor
.max_vd_entries
= cpu_to_be16(max_virt_disks
); /* ?? */
2232 ddf
->anchor
.max_partitions
= cpu_to_be16(64); /* ?? */
2235 ddf
->conf_rec_len
= 1 + ROUND_UP(ddf
->mppe
* (4+8), 512)/512;
2236 ddf
->anchor
.config_record_len
= cpu_to_be16(ddf
->conf_rec_len
);
2237 ddf
->anchor
.max_primary_element_entries
= cpu_to_be16(ddf
->mppe
);
2238 memset(ddf
->anchor
.pad3
, 0xff, 54);
2239 /* controller sections is one sector long immediately
2240 * after the ddf header */
2242 ddf
->anchor
.controller_section_offset
= cpu_to_be32(sector
);
2243 ddf
->anchor
.controller_section_length
= cpu_to_be32(1);
2246 /* phys is 8 sectors after that */
2247 pdsize
= ROUND_UP(sizeof(struct phys_disk
) +
2248 sizeof(struct phys_disk_entry
)*max_phys_disks
,
2250 switch(pdsize
/512) {
2251 case 2: case 8: case 32: case 128: case 512: break;
2254 ddf
->anchor
.phys_section_offset
= cpu_to_be32(sector
);
2255 ddf
->anchor
.phys_section_length
=
2256 cpu_to_be32(pdsize
/512); /* max_primary_element_entries/8 */
2257 sector
+= pdsize
/512;
2259 /* virt is another 32 sectors */
2260 vdsize
= ROUND_UP(sizeof(struct virtual_disk
) +
2261 sizeof(struct virtual_entry
) * max_virt_disks
,
2263 switch(vdsize
/512) {
2264 case 2: case 8: case 32: case 128: case 512: break;
2267 ddf
->anchor
.virt_section_offset
= cpu_to_be32(sector
);
2268 ddf
->anchor
.virt_section_length
=
2269 cpu_to_be32(vdsize
/512); /* max_vd_entries/8 */
2270 sector
+= vdsize
/512;
2272 clen
= ddf
->conf_rec_len
* (ddf
->max_part
+1);
2273 ddf
->anchor
.config_section_offset
= cpu_to_be32(sector
);
2274 ddf
->anchor
.config_section_length
= cpu_to_be32(clen
);
2277 ddf
->anchor
.data_section_offset
= cpu_to_be32(sector
);
2278 ddf
->anchor
.data_section_length
= cpu_to_be32(1);
2281 ddf
->anchor
.bbm_section_length
= cpu_to_be32(0);
2282 ddf
->anchor
.bbm_section_offset
= cpu_to_be32(0xFFFFFFFF);
2283 ddf
->anchor
.diag_space_length
= cpu_to_be32(0);
2284 ddf
->anchor
.diag_space_offset
= cpu_to_be32(0xFFFFFFFF);
2285 ddf
->anchor
.vendor_length
= cpu_to_be32(0);
2286 ddf
->anchor
.vendor_offset
= cpu_to_be32(0xFFFFFFFF);
2288 memset(ddf
->anchor
.pad4
, 0xff, 256);
2290 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
2291 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
2293 ddf
->primary
.openflag
= 1; /* I guess.. */
2294 ddf
->primary
.type
= DDF_HEADER_PRIMARY
;
2296 ddf
->secondary
.openflag
= 1; /* I guess.. */
2297 ddf
->secondary
.type
= DDF_HEADER_SECONDARY
;
2299 ddf
->active
= &ddf
->primary
;
2301 ddf
->controller
.magic
= DDF_CONTROLLER_MAGIC
;
2303 /* 24 more bytes of fiction required.
2304 * first 8 are a 'vendor-id' - "Linux-MD"
2305 * Remaining 16 are serial number.... maybe a hostname would do?
2307 memcpy(ddf
->controller
.guid
, T10
, sizeof(T10
));
2308 gethostname(hostname
, sizeof(hostname
));
2309 hostname
[sizeof(hostname
) - 1] = 0;
2310 hostlen
= strlen(hostname
);
2311 memcpy(ddf
->controller
.guid
+ 24 - hostlen
, hostname
, hostlen
);
2312 for (i
= strlen(T10
) ; i
+hostlen
< 24; i
++)
2313 ddf
->controller
.guid
[i
] = ' ';
2315 ddf
->controller
.type
.vendor_id
= cpu_to_be16(0xDEAD);
2316 ddf
->controller
.type
.device_id
= cpu_to_be16(0xBEEF);
2317 ddf
->controller
.type
.sub_vendor_id
= cpu_to_be16(0);
2318 ddf
->controller
.type
.sub_device_id
= cpu_to_be16(0);
2319 memcpy(ddf
->controller
.product_id
, "What Is My PID??", 16);
2320 memset(ddf
->controller
.pad
, 0xff, 8);
2321 memset(ddf
->controller
.vendor_data
, 0xff, 448);
2322 if (homehost
&& strlen(homehost
) < 440)
2323 strcpy((char*)ddf
->controller
.vendor_data
, homehost
);
2325 if (posix_memalign((void**)&pd
, 512, pdsize
) != 0) {
2326 pr_err("%s could not allocate pd\n", __func__
);
2330 ddf
->pdsize
= pdsize
;
2332 memset(pd
, 0xff, pdsize
);
2333 memset(pd
, 0, sizeof(*pd
));
2334 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2335 pd
->used_pdes
= cpu_to_be16(0);
2336 pd
->max_pdes
= cpu_to_be16(max_phys_disks
);
2337 memset(pd
->pad
, 0xff, 52);
2338 for (i
= 0; i
< max_phys_disks
; i
++)
2339 memset(pd
->entries
[i
].guid
, 0xff, DDF_GUID_LEN
);
2341 if (posix_memalign((void**)&vd
, 512, vdsize
) != 0) {
2342 pr_err("%s could not allocate vd\n", __func__
);
2346 ddf
->vdsize
= vdsize
;
2347 memset(vd
, 0, vdsize
);
2348 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
2349 vd
->populated_vdes
= cpu_to_be16(0);
2350 vd
->max_vdes
= cpu_to_be16(max_virt_disks
);
2351 memset(vd
->pad
, 0xff, 52);
2353 for (i
=0; i
<max_virt_disks
; i
++)
2354 memset(&vd
->entries
[i
], 0xff, sizeof(struct virtual_entry
));
2357 ddf_set_updates_pending(ddf
);
2361 static int chunk_to_shift(int chunksize
)
2363 return ffs(chunksize
/512)-1;
2368 unsigned long long start
, size
;
2370 static int cmp_extent(const void *av
, const void *bv
)
2372 const struct extent
*a
= av
;
2373 const struct extent
*b
= bv
;
2374 if (a
->start
< b
->start
)
2376 if (a
->start
> b
->start
)
2381 static struct extent
*get_extents(struct ddf_super
*ddf
, struct dl
*dl
)
2383 /* find a list of used extents on the give physical device
2384 * (dnum) of the given ddf.
2385 * Return a malloced array of 'struct extent'
2387 * FIXME ignore DDF_Legacy devices?
2394 rv
= xmalloc(sizeof(struct extent
) * (ddf
->max_part
+ 2));
2396 for (i
= 0; i
< ddf
->max_part
; i
++) {
2397 const struct vd_config
*bvd
;
2399 struct vcl
*v
= dl
->vlist
[i
];
2401 get_pd_index_from_refnum(v
, dl
->disk
.refnum
, ddf
->mppe
,
2402 &bvd
, &ibvd
) == DDF_NOTFOUND
)
2404 rv
[n
].start
= be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[ibvd
]);
2405 rv
[n
].size
= be64_to_cpu(bvd
->blocks
);
2408 qsort(rv
, n
, sizeof(*rv
), cmp_extent
);
2410 rv
[n
].start
= be64_to_cpu(ddf
->phys
->entries
[dl
->pdnum
].config_size
);
2416 static int init_super_ddf_bvd(struct supertype
*st
,
2417 mdu_array_info_t
*info
,
2418 unsigned long long size
,
2419 char *name
, char *homehost
,
2420 int *uuid
, unsigned long long data_offset
)
2422 /* We are creating a BVD inside a pre-existing container.
2423 * so st->sb is already set.
2424 * We need to create a new vd_config and a new virtual_entry
2426 struct ddf_super
*ddf
= st
->sb
;
2427 unsigned int venum
, i
;
2428 struct virtual_entry
*ve
;
2430 struct vd_config
*vc
;
2432 if (find_vde_by_name(ddf
, name
) != DDF_NOTFOUND
) {
2433 pr_err("This ddf already has an array called %s\n", name
);
2436 venum
= find_unused_vde(ddf
);
2437 if (venum
== DDF_NOTFOUND
) {
2438 pr_err("Cannot find spare slot for virtual disk\n");
2441 ve
= &ddf
->virt
->entries
[venum
];
2443 /* A Virtual Disk GUID contains the T10 Vendor ID, controller type,
2444 * timestamp, random number
2446 make_header_guid(ve
->guid
);
2447 ve
->unit
= cpu_to_be16(info
->md_minor
);
2449 ve
->guid_crc
._v16
= crc32(0, (unsigned char *)ddf
->anchor
.guid
,
2451 ve
->type
= cpu_to_be16(0);
2452 ve
->state
= DDF_state_degraded
; /* Will be modified as devices are added */
2453 if (info
->state
& 1) /* clean */
2454 ve
->init_state
= DDF_init_full
;
2456 ve
->init_state
= DDF_init_not
;
2458 memset(ve
->pad1
, 0xff, 14);
2459 memset(ve
->name
, ' ', 16);
2461 strncpy(ve
->name
, name
, 16);
2462 ddf
->virt
->populated_vdes
=
2463 cpu_to_be16(be16_to_cpu(ddf
->virt
->populated_vdes
)+1);
2465 /* Now create a new vd_config */
2466 if (posix_memalign((void**)&vcl
, 512,
2467 (offsetof(struct vcl
, conf
) + ddf
->conf_rec_len
* 512)) != 0) {
2468 pr_err("%s could not allocate vd_config\n", __func__
);
2472 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
2475 vc
->magic
= DDF_VD_CONF_MAGIC
;
2476 memcpy(vc
->guid
, ve
->guid
, DDF_GUID_LEN
);
2477 vc
->timestamp
= cpu_to_be32(time(0)-DECADE
);
2478 vc
->seqnum
= cpu_to_be32(1);
2479 memset(vc
->pad0
, 0xff, 24);
2480 vc
->chunk_shift
= chunk_to_shift(info
->chunk_size
);
2481 if (layout_md2ddf(info
, vc
) == -1 ||
2482 be16_to_cpu(vc
->prim_elmnt_count
) > ddf
->mppe
) {
2483 pr_err("%s: unsupported RAID level/layout %d/%d with %d disks\n",
2484 __func__
, info
->level
, info
->layout
, info
->raid_disks
);
2488 vc
->sec_elmnt_seq
= 0;
2489 if (alloc_other_bvds(ddf
, vcl
) != 0) {
2490 pr_err("%s could not allocate other bvds\n",
2495 vc
->blocks
= cpu_to_be64(info
->size
* 2);
2496 vc
->array_blocks
= cpu_to_be64(
2497 calc_array_size(info
->level
, info
->raid_disks
, info
->layout
,
2498 info
->chunk_size
, info
->size
*2));
2499 memset(vc
->pad1
, 0xff, 8);
2500 vc
->spare_refs
[0] = cpu_to_be32(0xffffffff);
2501 vc
->spare_refs
[1] = cpu_to_be32(0xffffffff);
2502 vc
->spare_refs
[2] = cpu_to_be32(0xffffffff);
2503 vc
->spare_refs
[3] = cpu_to_be32(0xffffffff);
2504 vc
->spare_refs
[4] = cpu_to_be32(0xffffffff);
2505 vc
->spare_refs
[5] = cpu_to_be32(0xffffffff);
2506 vc
->spare_refs
[6] = cpu_to_be32(0xffffffff);
2507 vc
->spare_refs
[7] = cpu_to_be32(0xffffffff);
2508 memset(vc
->cache_pol
, 0, 8);
2510 memset(vc
->pad2
, 0xff, 3);
2511 memset(vc
->pad3
, 0xff, 52);
2512 memset(vc
->pad4
, 0xff, 192);
2513 memset(vc
->v0
, 0xff, 32);
2514 memset(vc
->v1
, 0xff, 32);
2515 memset(vc
->v2
, 0xff, 16);
2516 memset(vc
->v3
, 0xff, 16);
2517 memset(vc
->vendor
, 0xff, 32);
2519 memset(vc
->phys_refnum
, 0xff, 4*ddf
->mppe
);
2520 memset(vc
->phys_refnum
+ddf
->mppe
, 0x00, 8*ddf
->mppe
);
2522 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++) {
2523 memcpy(vcl
->other_bvds
[i
-1], vc
, ddf
->conf_rec_len
* 512);
2524 vcl
->other_bvds
[i
-1]->sec_elmnt_seq
= i
;
2527 vcl
->next
= ddf
->conflist
;
2528 ddf
->conflist
= vcl
;
2529 ddf
->currentconf
= vcl
;
2530 ddf_set_updates_pending(ddf
);
2536 static int get_svd_state(const struct ddf_super
*, const struct vcl
*);
2538 static void add_to_super_ddf_bvd(struct supertype
*st
,
2539 mdu_disk_info_t
*dk
, int fd
, char *devname
)
2541 /* fd and devname identify a device with-in the ddf container (st).
2542 * dk identifies a location in the new BVD.
2543 * We need to find suitable free space in that device and update
2544 * the phys_refnum and lba_offset for the newly created vd_config.
2545 * We might also want to update the type in the phys_disk
2548 * Alternately: fd == -1 and we have already chosen which device to
2549 * use and recorded in dlist->raid_disk;
2552 struct ddf_super
*ddf
= st
->sb
;
2553 struct vd_config
*vc
;
2555 unsigned long long blocks
, pos
, esize
;
2557 unsigned int raid_disk
= dk
->raid_disk
;
2560 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2561 if (dl
->raiddisk
== dk
->raid_disk
)
2564 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2565 if (dl
->major
== dk
->major
&&
2566 dl
->minor
== dk
->minor
)
2569 if (!dl
|| ! (dk
->state
& (1<<MD_DISK_SYNC
)))
2572 vc
= &ddf
->currentconf
->conf
;
2573 if (vc
->sec_elmnt_count
> 1) {
2574 unsigned int n
= be16_to_cpu(vc
->prim_elmnt_count
);
2576 vc
= ddf
->currentconf
->other_bvds
[raid_disk
/ n
- 1];
2580 ex
= get_extents(ddf
, dl
);
2585 blocks
= be64_to_cpu(vc
->blocks
);
2586 if (ddf
->currentconf
->block_sizes
)
2587 blocks
= ddf
->currentconf
->block_sizes
[dk
->raid_disk
];
2590 esize
= ex
[i
].start
- pos
;
2591 if (esize
>= blocks
)
2593 pos
= ex
[i
].start
+ ex
[i
].size
;
2595 } while (ex
[i
-1].size
);
2601 ddf
->currentdev
= dk
->raid_disk
;
2602 vc
->phys_refnum
[raid_disk
] = dl
->disk
.refnum
;
2603 LBA_OFFSET(ddf
, vc
)[raid_disk
] = cpu_to_be64(pos
);
2605 for (i
= 0; i
< ddf
->max_part
; i
++)
2606 if (dl
->vlist
[i
] == NULL
)
2608 if (i
== ddf
->max_part
)
2610 dl
->vlist
[i
] = ddf
->currentconf
;
2615 dl
->devname
= devname
;
2617 /* Check if we can mark array as optimal yet */
2618 i
= ddf
->currentconf
->vcnum
;
2619 ddf
->virt
->entries
[i
].state
=
2620 (ddf
->virt
->entries
[i
].state
& ~DDF_state_mask
)
2621 | get_svd_state(ddf
, ddf
->currentconf
);
2622 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
2623 cpu_to_be16(DDF_Global_Spare
));
2624 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
2625 cpu_to_be16(DDF_Active_in_VD
));
2626 dprintf("%s: added disk %d/%08x to VD %d/%s as disk %d\n",
2627 __func__
, dl
->pdnum
, be32_to_cpu(dl
->disk
.refnum
),
2628 ddf
->currentconf
->vcnum
, guid_str(vc
->guid
),
2630 ddf_set_updates_pending(ddf
);
2633 static unsigned int find_unused_pde(const struct ddf_super
*ddf
)
2636 for (i
= 0; i
< be16_to_cpu(ddf
->phys
->max_pdes
); i
++) {
2637 if (all_ff(ddf
->phys
->entries
[i
].guid
))
2640 return DDF_NOTFOUND
;
2643 /* add a device to a container, either while creating it or while
2644 * expanding a pre-existing container
2646 static int add_to_super_ddf(struct supertype
*st
,
2647 mdu_disk_info_t
*dk
, int fd
, char *devname
,
2648 unsigned long long data_offset
)
2650 struct ddf_super
*ddf
= st
->sb
;
2654 unsigned long long size
;
2655 struct phys_disk_entry
*pde
;
2660 if (ddf
->currentconf
) {
2661 add_to_super_ddf_bvd(st
, dk
, fd
, devname
);
2665 /* This is device numbered dk->number. We need to create
2666 * a phys_disk entry and a more detailed disk_data entry.
2669 n
= find_unused_pde(ddf
);
2670 if (n
== DDF_NOTFOUND
) {
2671 pr_err("%s: No free slot in array, cannot add disk\n",
2675 pde
= &ddf
->phys
->entries
[n
];
2676 get_dev_size(fd
, NULL
, &size
);
2677 if (size
<= 32*1024*1024) {
2678 pr_err("%s: device size must be at least 32MB\n",
2684 if (posix_memalign((void**)&dd
, 512,
2685 sizeof(*dd
) + sizeof(dd
->vlist
[0]) * ddf
->max_part
) != 0) {
2686 pr_err("%s could allocate buffer for new disk, aborting\n",
2690 dd
->major
= major(stb
.st_rdev
);
2691 dd
->minor
= minor(stb
.st_rdev
);
2692 dd
->devname
= devname
;
2696 dd
->disk
.magic
= DDF_PHYS_DATA_MAGIC
;
2698 tm
= localtime(&now
);
2699 sprintf(dd
->disk
.guid
, "%8s%04d%02d%02d",
2700 T10
, tm
->tm_year
+1900, tm
->tm_mon
+1, tm
->tm_mday
);
2701 tptr
= (__u32
*)(dd
->disk
.guid
+ 16);
2702 *tptr
++ = random32();
2706 /* Cannot be bothered finding a CRC of some irrelevant details*/
2707 dd
->disk
.refnum
._v32
= random32();
2708 for (i
= be16_to_cpu(ddf
->active
->max_pd_entries
);
2710 if (be32_eq(ddf
->phys
->entries
[i
-1].refnum
,
2715 dd
->disk
.forced_ref
= 1;
2716 dd
->disk
.forced_guid
= 1;
2717 memset(dd
->disk
.vendor
, ' ', 32);
2718 memcpy(dd
->disk
.vendor
, "Linux", 5);
2719 memset(dd
->disk
.pad
, 0xff, 442);
2720 for (i
= 0; i
< ddf
->max_part
; i
++)
2721 dd
->vlist
[i
] = NULL
;
2725 if (st
->update_tail
) {
2726 int len
= (sizeof(struct phys_disk
) +
2727 sizeof(struct phys_disk_entry
));
2728 struct phys_disk
*pd
;
2731 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2732 pd
->used_pdes
= cpu_to_be16(n
);
2733 pde
= &pd
->entries
[0];
2736 ddf
->phys
->used_pdes
= cpu_to_be16(
2737 1 + be16_to_cpu(ddf
->phys
->used_pdes
));
2739 memcpy(pde
->guid
, dd
->disk
.guid
, DDF_GUID_LEN
);
2740 pde
->refnum
= dd
->disk
.refnum
;
2741 pde
->type
= cpu_to_be16(DDF_Forced_PD_GUID
| DDF_Global_Spare
);
2742 pde
->state
= cpu_to_be16(DDF_Online
);
2745 * If there is already a device in dlist, try to reserve the same
2746 * amount of workspace. Otherwise, use 32MB.
2747 * We checked disk size above already.
2749 #define __calc_lba(new, old, lba, mb) do { \
2750 unsigned long long dif; \
2751 if ((old) != NULL) \
2752 dif = (old)->size - be64_to_cpu((old)->lba); \
2754 dif = (new)->size; \
2755 if ((new)->size > dif) \
2756 (new)->lba = cpu_to_be64((new)->size - dif); \
2758 (new)->lba = cpu_to_be64((new)->size - (mb*1024*2)); \
2760 __calc_lba(dd
, ddf
->dlist
, workspace_lba
, 32);
2761 __calc_lba(dd
, ddf
->dlist
, primary_lba
, 16);
2762 __calc_lba(dd
, ddf
->dlist
, secondary_lba
, 32);
2763 pde
->config_size
= dd
->workspace_lba
;
2765 sprintf(pde
->path
, "%17.17s","Information: nil") ;
2766 memset(pde
->pad
, 0xff, 6);
2768 if (st
->update_tail
) {
2769 dd
->next
= ddf
->add_list
;
2772 dd
->next
= ddf
->dlist
;
2774 ddf_set_updates_pending(ddf
);
2780 static int remove_from_super_ddf(struct supertype
*st
, mdu_disk_info_t
*dk
)
2782 struct ddf_super
*ddf
= st
->sb
;
2785 /* mdmon has noticed that this disk (dk->major/dk->minor) has
2786 * disappeared from the container.
2787 * We need to arrange that it disappears from the metadata and
2788 * internal data structures too.
2789 * Most of the work is done by ddf_process_update which edits
2790 * the metadata and closes the file handle and attaches the memory
2791 * where free_updates will free it.
2793 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2794 if (dl
->major
== dk
->major
&&
2795 dl
->minor
== dk
->minor
)
2800 if (st
->update_tail
) {
2801 int len
= (sizeof(struct phys_disk
) +
2802 sizeof(struct phys_disk_entry
));
2803 struct phys_disk
*pd
;
2806 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2807 pd
->used_pdes
= cpu_to_be16(dl
->pdnum
);
2808 pd
->entries
[0].state
= cpu_to_be16(DDF_Missing
);
2809 append_metadata_update(st
, pd
, len
);
2816 * This is the write_init_super method for a ddf container. It is
2817 * called when creating a container or adding another device to a
2820 #define NULL_CONF_SZ 4096
2822 static char *null_aligned
;
2823 static int __write_ddf_structure(struct dl
*d
, struct ddf_super
*ddf
, __u8 type
)
2825 unsigned long long sector
;
2826 struct ddf_header
*header
;
2827 int fd
, i
, n_config
, conf_size
;
2830 if (null_aligned
== NULL
) {
2831 if (posix_memalign((void **)&null_aligned
, 4096, NULL_CONF_SZ
)
2834 memset(null_aligned
, 0xff, NULL_CONF_SZ
);
2840 case DDF_HEADER_PRIMARY
:
2841 header
= &ddf
->primary
;
2842 sector
= be64_to_cpu(header
->primary_lba
);
2844 case DDF_HEADER_SECONDARY
:
2845 header
= &ddf
->secondary
;
2846 sector
= be64_to_cpu(header
->secondary_lba
);
2852 header
->type
= type
;
2853 header
->openflag
= 1;
2854 header
->crc
= calc_crc(header
, 512);
2856 lseek64(fd
, sector
<<9, 0);
2857 if (write(fd
, header
, 512) < 0)
2860 ddf
->controller
.crc
= calc_crc(&ddf
->controller
, 512);
2861 if (write(fd
, &ddf
->controller
, 512) < 0)
2864 ddf
->phys
->crc
= calc_crc(ddf
->phys
, ddf
->pdsize
);
2865 if (write(fd
, ddf
->phys
, ddf
->pdsize
) < 0)
2867 ddf
->virt
->crc
= calc_crc(ddf
->virt
, ddf
->vdsize
);
2868 if (write(fd
, ddf
->virt
, ddf
->vdsize
) < 0)
2871 /* Now write lots of config records. */
2872 n_config
= ddf
->max_part
;
2873 conf_size
= ddf
->conf_rec_len
* 512;
2874 for (i
= 0 ; i
<= n_config
; i
++) {
2876 struct vd_config
*vdc
= NULL
;
2877 if (i
== n_config
) {
2878 c
= (struct vcl
*)d
->spare
;
2885 get_pd_index_from_refnum(
2888 (const struct vd_config
**)&vdc
,
2892 dprintf("writing conf record %i on disk %08x for %s/%u\n",
2893 i
, be32_to_cpu(d
->disk
.refnum
),
2894 guid_str(vdc
->guid
),
2895 vdc
->sec_elmnt_seq
);
2896 vdc
->seqnum
= header
->seq
;
2897 vdc
->crc
= calc_crc(vdc
, conf_size
);
2898 if (write(fd
, vdc
, conf_size
) < 0)
2901 unsigned int togo
= conf_size
;
2902 while (togo
> NULL_CONF_SZ
) {
2903 if (write(fd
, null_aligned
, NULL_CONF_SZ
) < 0)
2905 togo
-= NULL_CONF_SZ
;
2907 if (write(fd
, null_aligned
, togo
) < 0)
2914 d
->disk
.crc
= calc_crc(&d
->disk
, 512);
2915 if (write(fd
, &d
->disk
, 512) < 0)
2920 header
->openflag
= 0;
2921 header
->crc
= calc_crc(header
, 512);
2923 lseek64(fd
, sector
<<9, 0);
2924 if (write(fd
, header
, 512) < 0)
2930 static int _write_super_to_disk(struct ddf_super
*ddf
, struct dl
*d
)
2932 unsigned long long size
;
2937 /* We need to fill in the primary, (secondary) and workspace
2938 * lba's in the headers, set their checksums,
2939 * Also checksum phys, virt....
2941 * Then write everything out, finally the anchor is written.
2943 get_dev_size(fd
, NULL
, &size
);
2945 if (be64_to_cpu(d
->workspace_lba
) != 0ULL)
2946 ddf
->anchor
.workspace_lba
= d
->workspace_lba
;
2948 ddf
->anchor
.workspace_lba
=
2949 cpu_to_be64(size
- 32*1024*2);
2950 if (be64_to_cpu(d
->primary_lba
) != 0ULL)
2951 ddf
->anchor
.primary_lba
= d
->primary_lba
;
2953 ddf
->anchor
.primary_lba
=
2954 cpu_to_be64(size
- 16*1024*2);
2955 if (be64_to_cpu(d
->secondary_lba
) != 0ULL)
2956 ddf
->anchor
.secondary_lba
= d
->secondary_lba
;
2958 ddf
->anchor
.secondary_lba
=
2959 cpu_to_be64(size
- 32*1024*2);
2960 ddf
->anchor
.seq
= ddf
->active
->seq
;
2961 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
2962 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
2964 ddf
->anchor
.openflag
= 0xFF; /* 'open' means nothing */
2965 ddf
->anchor
.seq
= cpu_to_be32(0xFFFFFFFF); /* no sequencing in anchor */
2966 ddf
->anchor
.crc
= calc_crc(&ddf
->anchor
, 512);
2968 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_PRIMARY
))
2971 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_SECONDARY
))
2974 lseek64(fd
, (size
-1)*512, SEEK_SET
);
2975 if (write(fd
, &ddf
->anchor
, 512) < 0)
2982 static int __write_init_super_ddf(struct supertype
*st
)
2984 struct ddf_super
*ddf
= st
->sb
;
2989 pr_state(ddf
, __func__
);
2991 /* try to write updated metadata,
2992 * if we catch a failure move on to the next disk
2994 for (d
= ddf
->dlist
; d
; d
=d
->next
) {
2996 successes
+= _write_super_to_disk(ddf
, d
);
2999 return attempts
!= successes
;
3002 static int write_init_super_ddf(struct supertype
*st
)
3004 struct ddf_super
*ddf
= st
->sb
;
3005 struct vcl
*currentconf
= ddf
->currentconf
;
3007 /* we are done with currentconf reset it to point st at the container */
3008 ddf
->currentconf
= NULL
;
3010 if (st
->update_tail
) {
3011 /* queue the virtual_disk and vd_config as metadata updates */
3012 struct virtual_disk
*vd
;
3013 struct vd_config
*vc
;
3018 int len
= (sizeof(struct phys_disk
) +
3019 sizeof(struct phys_disk_entry
));
3021 /* adding a disk to the container. */
3025 append_metadata_update(st
, ddf
->add_list
->mdupdate
, len
);
3026 ddf
->add_list
->mdupdate
= NULL
;
3030 /* Newly created VD */
3032 /* First the virtual disk. We have a slightly fake header */
3033 len
= sizeof(struct virtual_disk
) + sizeof(struct virtual_entry
);
3036 vd
->entries
[0] = ddf
->virt
->entries
[currentconf
->vcnum
];
3037 vd
->populated_vdes
= cpu_to_be16(currentconf
->vcnum
);
3038 append_metadata_update(st
, vd
, len
);
3040 /* Then the vd_config */
3041 len
= ddf
->conf_rec_len
* 512;
3042 tlen
= len
* currentconf
->conf
.sec_elmnt_count
;
3044 memcpy(vc
, ¤tconf
->conf
, len
);
3045 for (i
= 1; i
< currentconf
->conf
.sec_elmnt_count
; i
++)
3046 memcpy((char *)vc
+ i
*len
, currentconf
->other_bvds
[i
-1],
3048 append_metadata_update(st
, vc
, tlen
);
3050 /* FIXME I need to close the fds! */
3055 for (d
= ddf
->dlist
; d
; d
=d
->next
)
3056 while (Kill(d
->devname
, NULL
, 0, -1, 1) == 0);
3057 return __write_init_super_ddf(st
);
3063 static __u64
avail_size_ddf(struct supertype
*st
, __u64 devsize
,
3064 unsigned long long data_offset
)
3066 /* We must reserve the last 32Meg */
3067 if (devsize
<= 32*1024*2)
3069 return devsize
- 32*1024*2;
3074 static int reserve_space(struct supertype
*st
, int raiddisks
,
3075 unsigned long long size
, int chunk
,
3076 unsigned long long *freesize
)
3078 /* Find 'raiddisks' spare extents at least 'size' big (but
3079 * only caring about multiples of 'chunk') and remember
3081 * If the cannot be found, fail.
3084 struct ddf_super
*ddf
= st
->sb
;
3087 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3091 /* Now find largest extent on each device */
3092 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3093 struct extent
*e
= get_extents(ddf
, dl
);
3094 unsigned long long pos
= 0;
3097 unsigned long long minsize
= size
;
3105 unsigned long long esize
;
3106 esize
= e
[i
].start
- pos
;
3107 if (esize
>= minsize
) {
3111 pos
= e
[i
].start
+ e
[i
].size
;
3113 } while (e
[i
-1].size
);
3116 dl
->esize
= minsize
;
3120 if (cnt
< raiddisks
) {
3121 pr_err("not enough devices with space to create array.\n");
3122 return 0; /* No enough free spaces large enough */
3125 /* choose the largest size of which there are at least 'raiddisk' */
3126 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3128 if (dl
->esize
<= size
)
3130 /* This is bigger than 'size', see if there are enough */
3132 for (dl2
= ddf
->dlist
; dl2
; dl2
=dl2
->next
)
3133 if (dl2
->esize
>= dl
->esize
)
3135 if (cnt
>= raiddisks
)
3139 size
= size
/ chunk
;
3144 pr_err("not enough spare devices to create array.\n");
3148 /* We have a 'size' of which there are enough spaces.
3149 * We simply do a first-fit */
3151 for (dl
= ddf
->dlist
; dl
&& cnt
< raiddisks
; dl
=dl
->next
) {
3152 if (dl
->esize
< size
)
3162 validate_geometry_ddf_container(struct supertype
*st
,
3163 int level
, int layout
, int raiddisks
,
3164 int chunk
, unsigned long long size
,
3165 unsigned long long data_offset
,
3166 char *dev
, unsigned long long *freesize
,
3169 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3170 int level
, int layout
, int raiddisks
,
3171 int *chunk
, unsigned long long size
,
3172 unsigned long long data_offset
,
3173 char *dev
, unsigned long long *freesize
,
3176 static int validate_geometry_ddf(struct supertype
*st
,
3177 int level
, int layout
, int raiddisks
,
3178 int *chunk
, unsigned long long size
,
3179 unsigned long long data_offset
,
3180 char *dev
, unsigned long long *freesize
,
3187 /* ddf potentially supports lots of things, but it depends on
3188 * what devices are offered (and maybe kernel version?)
3189 * If given unused devices, we will make a container.
3190 * If given devices in a container, we will make a BVD.
3191 * If given BVDs, we make an SVD, changing all the GUIDs in the process.
3194 if (*chunk
== UnSet
)
3195 *chunk
= DEFAULT_CHUNK
;
3197 if (level
== -1000000) level
= LEVEL_CONTAINER
;
3198 if (level
== LEVEL_CONTAINER
) {
3199 /* Must be a fresh device to add to a container */
3200 return validate_geometry_ddf_container(st
, level
, layout
,
3202 size
, data_offset
, dev
,
3208 mdu_array_info_t array
= {
3209 .level
= level
, .layout
= layout
,
3210 .raid_disks
= raiddisks
3212 struct vd_config conf
;
3213 if (layout_md2ddf(&array
, &conf
) == -1) {
3215 pr_err("DDF does not support level %d /layout %d arrays with %d disks\n",
3216 level
, layout
, raiddisks
);
3219 /* Should check layout? etc */
3221 if (st
->sb
&& freesize
) {
3222 /* --create was given a container to create in.
3223 * So we need to check that there are enough
3224 * free spaces and return the amount of space.
3225 * We may as well remember which drives were
3226 * chosen so that add_to_super/getinfo_super
3229 return reserve_space(st
, raiddisks
, size
, *chunk
, freesize
);
3235 /* A container has already been opened, so we are
3236 * creating in there. Maybe a BVD, maybe an SVD.
3237 * Should make a distinction one day.
3239 return validate_geometry_ddf_bvd(st
, level
, layout
, raiddisks
,
3240 chunk
, size
, data_offset
, dev
,
3244 /* This is the first device for the array.
3245 * If it is a container, we read it in and do automagic allocations,
3246 * no other devices should be given.
3247 * Otherwise it must be a member device of a container, and we
3248 * do manual allocation.
3249 * Later we should check for a BVD and make an SVD.
3251 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3253 sra
= sysfs_read(fd
, NULL
, GET_VERSION
);
3255 if (sra
&& sra
->array
.major_version
== -1 &&
3256 strcmp(sra
->text_version
, "ddf") == 0) {
3259 /* find space for 'n' devices. */
3260 /* remember the devices */
3261 /* Somehow return the fact that we have enough */
3265 pr_err("ddf: Cannot create this array "
3266 "on device %s - a container is required.\n",
3270 if (errno
!= EBUSY
|| (fd
= open(dev
, O_RDONLY
, 0)) < 0) {
3272 pr_err("ddf: Cannot open %s: %s\n",
3273 dev
, strerror(errno
));
3276 /* Well, it is in use by someone, maybe a 'ddf' container. */
3277 cfd
= open_container(fd
);
3281 pr_err("ddf: Cannot use %s: %s\n",
3282 dev
, strerror(EBUSY
));
3285 sra
= sysfs_read(cfd
, NULL
, GET_VERSION
);
3287 if (sra
&& sra
->array
.major_version
== -1 &&
3288 strcmp(sra
->text_version
, "ddf") == 0) {
3289 /* This is a member of a ddf container. Load the container
3290 * and try to create a bvd
3292 struct ddf_super
*ddf
;
3293 if (load_super_ddf_all(st
, cfd
, (void **)&ddf
, NULL
) == 0) {
3295 strcpy(st
->container_devnm
, fd2devnm(cfd
));
3297 return validate_geometry_ddf_bvd(st
, level
, layout
,
3298 raiddisks
, chunk
, size
,
3304 } else /* device may belong to a different container */
3311 validate_geometry_ddf_container(struct supertype
*st
,
3312 int level
, int layout
, int raiddisks
,
3313 int chunk
, unsigned long long size
,
3314 unsigned long long data_offset
,
3315 char *dev
, unsigned long long *freesize
,
3319 unsigned long long ldsize
;
3321 if (level
!= LEVEL_CONTAINER
)
3326 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3329 pr_err("ddf: Cannot open %s: %s\n",
3330 dev
, strerror(errno
));
3333 if (!get_dev_size(fd
, dev
, &ldsize
)) {
3339 *freesize
= avail_size_ddf(st
, ldsize
>> 9, INVALID_SECTORS
);
3346 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3347 int level
, int layout
, int raiddisks
,
3348 int *chunk
, unsigned long long size
,
3349 unsigned long long data_offset
,
3350 char *dev
, unsigned long long *freesize
,
3354 struct ddf_super
*ddf
= st
->sb
;
3356 unsigned long long pos
= 0;
3357 unsigned long long maxsize
;
3360 /* ddf/bvd supports lots of things, but not containers */
3361 if (level
== LEVEL_CONTAINER
) {
3363 pr_err("DDF cannot create a container within an container\n");
3366 /* We must have the container info already read in. */
3371 /* General test: make sure there is space for
3372 * 'raiddisks' device extents of size 'size'.
3374 unsigned long long minsize
= size
;
3378 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3384 e
= get_extents(ddf
, dl
);
3387 unsigned long long esize
;
3388 esize
= e
[i
].start
- pos
;
3389 if (esize
>= minsize
)
3391 pos
= e
[i
].start
+ e
[i
].size
;
3393 } while (e
[i
-1].size
);
3398 if (dcnt
< raiddisks
) {
3400 pr_err("ddf: Not enough devices with "
3401 "space for this array (%d < %d)\n",
3407 /* This device must be a member of the set */
3408 if (stat(dev
, &stb
) < 0)
3410 if ((S_IFMT
& stb
.st_mode
) != S_IFBLK
)
3412 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
3413 if (dl
->major
== (int)major(stb
.st_rdev
) &&
3414 dl
->minor
== (int)minor(stb
.st_rdev
))
3419 pr_err("ddf: %s is not in the "
3424 e
= get_extents(ddf
, dl
);
3428 unsigned long long esize
;
3429 esize
= e
[i
].start
- pos
;
3430 if (esize
>= maxsize
)
3432 pos
= e
[i
].start
+ e
[i
].size
;
3434 } while (e
[i
-1].size
);
3435 *freesize
= maxsize
;
3441 static int load_super_ddf_all(struct supertype
*st
, int fd
,
3442 void **sbp
, char *devname
)
3445 struct ddf_super
*super
;
3446 struct mdinfo
*sd
, *best
= NULL
;
3452 sra
= sysfs_read(fd
, 0, GET_LEVEL
|GET_VERSION
|GET_DEVS
|GET_STATE
);
3455 if (sra
->array
.major_version
!= -1 ||
3456 sra
->array
.minor_version
!= -2 ||
3457 strcmp(sra
->text_version
, "ddf") != 0)
3460 if (posix_memalign((void**)&super
, 512, sizeof(*super
)) != 0)
3462 memset(super
, 0, sizeof(*super
));
3464 /* first, try each device, and choose the best ddf */
3465 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3467 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3468 dfd
= dev_open(nm
, O_RDONLY
);
3471 rv
= load_ddf_headers(dfd
, super
, NULL
);
3474 seq
= be32_to_cpu(super
->active
->seq
);
3475 if (super
->active
->openflag
)
3477 if (!best
|| seq
> bestseq
) {
3485 /* OK, load this ddf */
3486 sprintf(nm
, "%d:%d", best
->disk
.major
, best
->disk
.minor
);
3487 dfd
= dev_open(nm
, O_RDONLY
);
3490 load_ddf_headers(dfd
, super
, NULL
);
3491 load_ddf_global(dfd
, super
, NULL
);
3493 /* Now we need the device-local bits */
3494 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3497 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3498 dfd
= dev_open(nm
, O_RDWR
);
3501 rv
= load_ddf_headers(dfd
, super
, NULL
);
3503 rv
= load_ddf_local(dfd
, super
, NULL
, 1);
3509 if (st
->ss
== NULL
) {
3510 st
->ss
= &super_ddf
;
3511 st
->minor_version
= 0;
3514 strcpy(st
->container_devnm
, fd2devnm(fd
));
3518 static int load_container_ddf(struct supertype
*st
, int fd
,
3521 return load_super_ddf_all(st
, fd
, &st
->sb
, devname
);
3524 #endif /* MDASSEMBLE */
3526 static int check_secondary(const struct vcl
*vc
)
3528 const struct vd_config
*conf
= &vc
->conf
;
3531 /* The only DDF secondary RAID level md can support is
3532 * RAID 10, if the stripe sizes and Basic volume sizes
3534 * Other configurations could in theory be supported by exposing
3535 * the BVDs to user space and using device mapper for the secondary
3536 * mapping. So far we don't support that.
3539 __u64 sec_elements
[4] = {0, 0, 0, 0};
3540 #define __set_sec_seen(n) (sec_elements[(n)>>6] |= (1<<((n)&63)))
3541 #define __was_sec_seen(n) ((sec_elements[(n)>>6] & (1<<((n)&63))) != 0)
3543 if (vc
->other_bvds
== NULL
) {
3544 pr_err("No BVDs for secondary RAID found\n");
3547 if (conf
->prl
!= DDF_RAID1
) {
3548 pr_err("Secondary RAID level only supported for mirrored BVD\n");
3551 if (conf
->srl
!= DDF_2STRIPED
&& conf
->srl
!= DDF_2SPANNED
) {
3552 pr_err("Secondary RAID level %d is unsupported\n",
3556 __set_sec_seen(conf
->sec_elmnt_seq
);
3557 for (i
= 0; i
< conf
->sec_elmnt_count
-1; i
++) {
3558 const struct vd_config
*bvd
= vc
->other_bvds
[i
];
3559 if (bvd
->sec_elmnt_seq
== DDF_UNUSED_BVD
)
3561 if (bvd
->srl
!= conf
->srl
) {
3562 pr_err("Inconsistent secondary RAID level across BVDs\n");
3565 if (bvd
->prl
!= conf
->prl
) {
3566 pr_err("Different RAID levels for BVDs are unsupported\n");
3569 if (!be16_eq(bvd
->prim_elmnt_count
, conf
->prim_elmnt_count
)) {
3570 pr_err("All BVDs must have the same number of primary elements\n");
3573 if (bvd
->chunk_shift
!= conf
->chunk_shift
) {
3574 pr_err("Different strip sizes for BVDs are unsupported\n");
3577 if (!be64_eq(bvd
->array_blocks
, conf
->array_blocks
)) {
3578 pr_err("Different BVD sizes are unsupported\n");
3581 __set_sec_seen(bvd
->sec_elmnt_seq
);
3583 for (i
= 0; i
< conf
->sec_elmnt_count
; i
++) {
3584 if (!__was_sec_seen(i
)) {
3585 pr_err("BVD %d is missing\n", i
);
3592 static unsigned int get_pd_index_from_refnum(const struct vcl
*vc
,
3593 be32 refnum
, unsigned int nmax
,
3594 const struct vd_config
**bvd
,
3597 unsigned int i
, j
, n
, sec
, cnt
;
3599 cnt
= be16_to_cpu(vc
->conf
.prim_elmnt_count
);
3600 sec
= (vc
->conf
.sec_elmnt_count
== 1 ? 0 : vc
->conf
.sec_elmnt_seq
);
3602 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3603 /* j counts valid entries for this BVD */
3604 if (be32_to_cpu(vc
->conf
.phys_refnum
[i
]) != 0xffffffff)
3606 if (be32_eq(vc
->conf
.phys_refnum
[i
], refnum
)) {
3609 return sec
* cnt
+ j
- 1;
3612 if (vc
->other_bvds
== NULL
)
3615 for (n
= 1; n
< vc
->conf
.sec_elmnt_count
; n
++) {
3616 struct vd_config
*vd
= vc
->other_bvds
[n
-1];
3617 sec
= vd
->sec_elmnt_seq
;
3618 if (sec
== DDF_UNUSED_BVD
)
3620 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3621 if (be32_to_cpu(vd
->phys_refnum
[i
]) != 0xffffffff)
3623 if (be32_eq(vd
->phys_refnum
[i
], refnum
)) {
3626 return sec
* cnt
+ j
- 1;
3632 return DDF_NOTFOUND
;
3635 static struct mdinfo
*container_content_ddf(struct supertype
*st
, char *subarray
)
3637 /* Given a container loaded by load_super_ddf_all,
3638 * extract information about all the arrays into
3641 * For each vcl in conflist: create an mdinfo, fill it in,
3642 * then look for matching devices (phys_refnum) in dlist
3643 * and create appropriate device mdinfo.
3645 struct ddf_super
*ddf
= st
->sb
;
3646 struct mdinfo
*rest
= NULL
;
3649 for (vc
= ddf
->conflist
; vc
; vc
=vc
->next
)
3653 struct mdinfo
*this;
3659 (strtoul(subarray
, &ep
, 10) != vc
->vcnum
||
3663 if (vc
->conf
.sec_elmnt_count
> 1) {
3664 if (check_secondary(vc
) != 0)
3668 this = xcalloc(1, sizeof(*this));
3672 if (layout_ddf2md(&vc
->conf
, &this->array
))
3674 this->array
.md_minor
= -1;
3675 this->array
.major_version
= -1;
3676 this->array
.minor_version
= -2;
3677 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
3678 this->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
3679 this->array
.utime
= DECADE
+
3680 be32_to_cpu(vc
->conf
.timestamp
);
3681 this->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
3684 if ((ddf
->virt
->entries
[i
].state
& DDF_state_inconsistent
) ||
3685 (ddf
->virt
->entries
[i
].init_state
& DDF_initstate_mask
) !=
3687 this->array
.state
= 0;
3688 this->resync_start
= 0;
3690 this->array
.state
= 1;
3691 this->resync_start
= MaxSector
;
3693 memcpy(this->name
, ddf
->virt
->entries
[i
].name
, 16);
3696 if (this->name
[j
] == ' ')
3699 memset(this->uuid
, 0, sizeof(this->uuid
));
3700 this->component_size
= be64_to_cpu(vc
->conf
.blocks
);
3701 this->array
.size
= this->component_size
/ 2;
3702 this->container_member
= i
;
3704 ddf
->currentconf
= vc
;
3705 uuid_from_super_ddf(st
, this->uuid
);
3707 ddf
->currentconf
= NULL
;
3709 sprintf(this->text_version
, "/%s/%d",
3710 st
->container_devnm
, this->container_member
);
3712 for (pd
= 0; pd
< be16_to_cpu(ddf
->phys
->used_pdes
); pd
++) {
3715 const struct vd_config
*bvd
;
3719 if (be32_to_cpu(ddf
->phys
->entries
[pd
].refnum
)
3723 stt
= be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
3724 if ((stt
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
3728 i
= get_pd_index_from_refnum(
3729 vc
, ddf
->phys
->entries
[pd
].refnum
,
3730 ddf
->mppe
, &bvd
, &iphys
);
3731 if (i
== DDF_NOTFOUND
)
3734 this->array
.working_disks
++;
3736 for (d
= ddf
->dlist
; d
; d
=d
->next
)
3737 if (be32_eq(d
->disk
.refnum
,
3738 ddf
->phys
->entries
[pd
].refnum
))
3741 /* Haven't found that one yet, maybe there are others */
3744 dev
= xcalloc(1, sizeof(*dev
));
3745 dev
->next
= this->devs
;
3748 dev
->disk
.number
= be32_to_cpu(d
->disk
.refnum
);
3749 dev
->disk
.major
= d
->major
;
3750 dev
->disk
.minor
= d
->minor
;
3751 dev
->disk
.raid_disk
= i
;
3752 dev
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
3753 dev
->recovery_start
= MaxSector
;
3755 dev
->events
= be32_to_cpu(ddf
->primary
.seq
);
3757 be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[iphys
]);
3758 dev
->component_size
= be64_to_cpu(bvd
->blocks
);
3760 strcpy(dev
->name
, d
->devname
);
3766 static int store_super_ddf(struct supertype
*st
, int fd
)
3768 struct ddf_super
*ddf
= st
->sb
;
3769 unsigned long long dsize
;
3776 if (!get_dev_size(fd
, NULL
, &dsize
))
3779 if (ddf
->dlist
|| ddf
->conflist
) {
3784 if (fstat(fd
, &sta
) == -1 || !S_ISBLK(sta
.st_mode
)) {
3785 pr_err("%s: file descriptor for invalid device\n",
3789 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3790 if (dl
->major
== (int)major(sta
.st_rdev
) &&
3791 dl
->minor
== (int)minor(sta
.st_rdev
))
3794 pr_err("%s: couldn't find disk %d/%d\n", __func__
,
3795 (int)major(sta
.st_rdev
),
3796 (int)minor(sta
.st_rdev
));
3801 ret
= (_write_super_to_disk(ddf
, dl
) != 1);
3806 if (posix_memalign(&buf
, 512, 512) != 0)
3808 memset(buf
, 0, 512);
3810 lseek64(fd
, dsize
-512, 0);
3811 rc
= write(fd
, buf
, 512);
3818 static int compare_super_ddf(struct supertype
*st
, struct supertype
*tst
)
3822 * 0 same, or first was empty, and second was copied
3823 * 1 second had wrong number
3825 * 3 wrong other info
3827 struct ddf_super
*first
= st
->sb
;
3828 struct ddf_super
*second
= tst
->sb
;
3829 struct dl
*dl1
, *dl2
;
3830 struct vcl
*vl1
, *vl2
;
3831 unsigned int max_vds
, max_pds
, pd
, vd
;
3839 if (memcmp(first
->anchor
.guid
, second
->anchor
.guid
, DDF_GUID_LEN
) != 0)
3842 if (!be32_eq(first
->anchor
.seq
, second
->anchor
.seq
)) {
3843 dprintf("%s: sequence number mismatch %u/%u\n", __func__
,
3844 be32_to_cpu(first
->anchor
.seq
),
3845 be32_to_cpu(second
->anchor
.seq
));
3848 if (first
->max_part
!= second
->max_part
||
3849 !be16_eq(first
->phys
->used_pdes
, second
->phys
->used_pdes
) ||
3850 !be16_eq(first
->virt
->populated_vdes
,
3851 second
->virt
->populated_vdes
)) {
3852 dprintf("%s: PD/VD number mismatch\n", __func__
);
3856 max_pds
= be16_to_cpu(first
->phys
->used_pdes
);
3857 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
3858 for (pd
= 0; pd
< max_pds
; pd
++)
3859 if (be32_eq(first
->phys
->entries
[pd
].refnum
,
3862 if (pd
== max_pds
) {
3863 dprintf("%s: no match for disk %08x\n", __func__
,
3864 be32_to_cpu(dl2
->disk
.refnum
));
3869 max_vds
= be16_to_cpu(first
->active
->max_vd_entries
);
3870 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3871 if (!be32_eq(vl2
->conf
.magic
, DDF_VD_CONF_MAGIC
))
3873 for (vd
= 0; vd
< max_vds
; vd
++)
3874 if (!memcmp(first
->virt
->entries
[vd
].guid
,
3875 vl2
->conf
.guid
, DDF_GUID_LEN
))
3877 if (vd
== max_vds
) {
3878 dprintf("%s: no match for VD config\n", __func__
);
3882 /* FIXME should I look at anything else? */
3885 At this point we are fairly sure that the meta data matches.
3886 But the new disk may contain additional local data.
3887 Add it to the super block.
3889 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3890 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
)
3891 if (!memcmp(vl1
->conf
.guid
, vl2
->conf
.guid
,
3895 if (vl1
->other_bvds
!= NULL
&&
3896 vl1
->conf
.sec_elmnt_seq
!=
3897 vl2
->conf
.sec_elmnt_seq
) {
3898 dprintf("%s: adding BVD %u\n", __func__
,
3899 vl2
->conf
.sec_elmnt_seq
);
3900 add_other_bvd(vl1
, &vl2
->conf
,
3901 first
->conf_rec_len
*512);
3906 if (posix_memalign((void **)&vl1
, 512,
3907 (first
->conf_rec_len
*512 +
3908 offsetof(struct vcl
, conf
))) != 0) {
3909 pr_err("%s could not allocate vcl buf\n",
3914 vl1
->next
= first
->conflist
;
3915 vl1
->block_sizes
= NULL
;
3916 memcpy(&vl1
->conf
, &vl2
->conf
, first
->conf_rec_len
*512);
3917 if (alloc_other_bvds(first
, vl1
) != 0) {
3918 pr_err("%s could not allocate other bvds\n",
3923 for (vd
= 0; vd
< max_vds
; vd
++)
3924 if (!memcmp(first
->virt
->entries
[vd
].guid
,
3925 vl1
->conf
.guid
, DDF_GUID_LEN
))
3928 dprintf("%s: added config for VD %u\n", __func__
, vl1
->vcnum
);
3929 first
->conflist
= vl1
;
3932 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
3933 for (dl1
= first
->dlist
; dl1
; dl1
= dl1
->next
)
3934 if (be32_eq(dl1
->disk
.refnum
, dl2
->disk
.refnum
))
3939 if (posix_memalign((void **)&dl1
, 512,
3940 sizeof(*dl1
) + (first
->max_part
) * sizeof(dl1
->vlist
[0]))
3942 pr_err("%s could not allocate disk info buffer\n",
3946 memcpy(dl1
, dl2
, sizeof(*dl1
));
3947 dl1
->mdupdate
= NULL
;
3948 dl1
->next
= first
->dlist
;
3950 for (pd
= 0; pd
< max_pds
; pd
++)
3951 if (be32_eq(first
->phys
->entries
[pd
].refnum
,
3956 if (posix_memalign((void **)&dl1
->spare
, 512,
3957 first
->conf_rec_len
*512) != 0) {
3958 pr_err("%s could not allocate spare info buf\n",
3962 memcpy(dl1
->spare
, dl2
->spare
, first
->conf_rec_len
*512);
3964 for (vd
= 0 ; vd
< first
->max_part
; vd
++) {
3965 if (!dl2
->vlist
[vd
]) {
3966 dl1
->vlist
[vd
] = NULL
;
3969 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
) {
3970 if (!memcmp(vl1
->conf
.guid
,
3971 dl2
->vlist
[vd
]->conf
.guid
,
3974 dl1
->vlist
[vd
] = vl1
;
3978 dprintf("%s: added disk %d: %08x\n", __func__
, dl1
->pdnum
,
3979 be32_to_cpu(dl1
->disk
.refnum
));
3987 * A new array 'a' has been started which claims to be instance 'inst'
3988 * within container 'c'.
3989 * We need to confirm that the array matches the metadata in 'c' so
3990 * that we don't corrupt any metadata.
3992 static int ddf_open_new(struct supertype
*c
, struct active_array
*a
, char *inst
)
3994 struct ddf_super
*ddf
= c
->sb
;
3996 if (all_ff(ddf
->virt
->entries
[n
].guid
)) {
3997 pr_err("%s: subarray %d doesn't exist\n", __func__
, n
);
4000 dprintf("ddf: open_new %d\n", n
);
4001 a
->info
.container_member
= n
;
4006 * The array 'a' is to be marked clean in the metadata.
4007 * If '->resync_start' is not ~(unsigned long long)0, then the array is only
4008 * clean up to the point (in sectors). If that cannot be recorded in the
4009 * metadata, then leave it as dirty.
4011 * For DDF, we need to clear the DDF_state_inconsistent bit in the
4012 * !global! virtual_disk.virtual_entry structure.
4014 static int ddf_set_array_state(struct active_array
*a
, int consistent
)
4016 struct ddf_super
*ddf
= a
->container
->sb
;
4017 int inst
= a
->info
.container_member
;
4018 int old
= ddf
->virt
->entries
[inst
].state
;
4019 if (consistent
== 2) {
4020 /* Should check if a recovery should be started FIXME */
4022 if (!is_resync_complete(&a
->info
))
4026 ddf
->virt
->entries
[inst
].state
&= ~DDF_state_inconsistent
;
4028 ddf
->virt
->entries
[inst
].state
|= DDF_state_inconsistent
;
4029 if (old
!= ddf
->virt
->entries
[inst
].state
)
4030 ddf_set_updates_pending(ddf
);
4032 old
= ddf
->virt
->entries
[inst
].init_state
;
4033 ddf
->virt
->entries
[inst
].init_state
&= ~DDF_initstate_mask
;
4034 if (is_resync_complete(&a
->info
))
4035 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_full
;
4036 else if (a
->info
.resync_start
== 0)
4037 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_not
;
4039 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_quick
;
4040 if (old
!= ddf
->virt
->entries
[inst
].init_state
)
4041 ddf_set_updates_pending(ddf
);
4043 dprintf("ddf mark %d/%s (%d) %s %llu\n", inst
,
4044 guid_str(ddf
->virt
->entries
[inst
].guid
), a
->curr_state
,
4045 consistent
?"clean":"dirty",
4046 a
->info
.resync_start
);
4050 static int get_bvd_state(const struct ddf_super
*ddf
,
4051 const struct vd_config
*vc
)
4053 unsigned int i
, n_bvd
, working
= 0;
4054 unsigned int n_prim
= be16_to_cpu(vc
->prim_elmnt_count
);
4056 for (i
= 0; i
< n_prim
; i
++) {
4057 if (!find_index_in_bvd(ddf
, vc
, i
, &n_bvd
))
4059 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
4062 st
= be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
4063 if ((st
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
4068 state
= DDF_state_degraded
;
4069 if (working
== n_prim
)
4070 state
= DDF_state_optimal
;
4076 state
= DDF_state_failed
;
4080 state
= DDF_state_failed
;
4081 else if (working
>= 2)
4082 state
= DDF_state_part_optimal
;
4086 if (working
< n_prim
- 1)
4087 state
= DDF_state_failed
;
4090 if (working
< n_prim
- 2)
4091 state
= DDF_state_failed
;
4092 else if (working
== n_prim
- 1)
4093 state
= DDF_state_part_optimal
;
4099 static int secondary_state(int state
, int other
, int seclevel
)
4101 if (state
== DDF_state_optimal
&& other
== DDF_state_optimal
)
4102 return DDF_state_optimal
;
4103 if (seclevel
== DDF_2MIRRORED
) {
4104 if (state
== DDF_state_optimal
|| other
== DDF_state_optimal
)
4105 return DDF_state_part_optimal
;
4106 if (state
== DDF_state_failed
&& other
== DDF_state_failed
)
4107 return DDF_state_failed
;
4108 return DDF_state_degraded
;
4110 if (state
== DDF_state_failed
|| other
== DDF_state_failed
)
4111 return DDF_state_failed
;
4112 if (state
== DDF_state_degraded
|| other
== DDF_state_degraded
)
4113 return DDF_state_degraded
;
4114 return DDF_state_part_optimal
;
4118 static int get_svd_state(const struct ddf_super
*ddf
, const struct vcl
*vcl
)
4120 int state
= get_bvd_state(ddf
, &vcl
->conf
);
4122 for (i
= 1; i
< vcl
->conf
.sec_elmnt_count
; i
++) {
4123 state
= secondary_state(
4125 get_bvd_state(ddf
, vcl
->other_bvds
[i
-1]),
4132 * The state of each disk is stored in the global phys_disk structure
4133 * in phys_disk.entries[n].state.
4134 * This makes various combinations awkward.
4135 * - When a device fails in any array, it must be failed in all arrays
4136 * that include a part of this device.
4137 * - When a component is rebuilding, we cannot include it officially in the
4138 * array unless this is the only array that uses the device.
4140 * So: when transitioning:
4141 * Online -> failed, just set failed flag. monitor will propagate
4142 * spare -> online, the device might need to be added to the array.
4143 * spare -> failed, just set failed. Don't worry if in array or not.
4145 static void ddf_set_disk(struct active_array
*a
, int n
, int state
)
4147 struct ddf_super
*ddf
= a
->container
->sb
;
4148 unsigned int inst
= a
->info
.container_member
, n_bvd
;
4150 struct vd_config
*vc
= find_vdcr(ddf
, inst
, (unsigned int)n
,
4156 dprintf("%s: %d to %x\n", __func__
, n
, state
);
4158 dprintf("ddf: cannot find instance %d!!\n", inst
);
4161 /* Find the matching slot in 'info'. */
4162 for (mdi
= a
->info
.devs
; mdi
; mdi
= mdi
->next
)
4163 if (mdi
->disk
.raid_disk
== n
)
4166 pr_err("%s: cannot find raid disk %d\n",
4171 /* and find the 'dl' entry corresponding to that. */
4172 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4173 if (mdi
->state_fd
>= 0 &&
4174 mdi
->disk
.major
== dl
->major
&&
4175 mdi
->disk
.minor
== dl
->minor
)
4178 pr_err("%s: cannot find raid disk %d (%d/%d)\n",
4180 mdi
->disk
.major
, mdi
->disk
.minor
);
4184 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
4185 if (pd
< 0 || pd
!= dl
->pdnum
) {
4186 /* disk doesn't currently exist or has changed.
4187 * If it is now in_sync, insert it. */
4188 dprintf("%s: phys disk not found for %d: %d/%d ref %08x\n",
4189 __func__
, dl
->pdnum
, dl
->major
, dl
->minor
,
4190 be32_to_cpu(dl
->disk
.refnum
));
4191 dprintf("%s: array %u disk %u ref %08x pd %d\n",
4192 __func__
, inst
, n_bvd
,
4193 be32_to_cpu(vc
->phys_refnum
[n_bvd
]), pd
);
4194 if ((state
& DS_INSYNC
) && ! (state
& DS_FAULTY
)) {
4195 pd
= dl
->pdnum
; /* FIXME: is this really correct ? */
4196 vc
->phys_refnum
[n_bvd
] = dl
->disk
.refnum
;
4197 LBA_OFFSET(ddf
, vc
)[n_bvd
] =
4198 cpu_to_be64(mdi
->data_offset
);
4199 be16_clear(ddf
->phys
->entries
[pd
].type
,
4200 cpu_to_be16(DDF_Global_Spare
));
4201 be16_set(ddf
->phys
->entries
[pd
].type
,
4202 cpu_to_be16(DDF_Active_in_VD
));
4203 ddf_set_updates_pending(ddf
);
4206 be16 old
= ddf
->phys
->entries
[pd
].state
;
4207 if (state
& DS_FAULTY
)
4208 be16_set(ddf
->phys
->entries
[pd
].state
,
4209 cpu_to_be16(DDF_Failed
));
4210 if (state
& DS_INSYNC
) {
4211 be16_set(ddf
->phys
->entries
[pd
].state
,
4212 cpu_to_be16(DDF_Online
));
4213 be16_clear(ddf
->phys
->entries
[pd
].state
,
4214 cpu_to_be16(DDF_Rebuilding
));
4216 if (!be16_eq(old
, ddf
->phys
->entries
[pd
].state
))
4217 ddf_set_updates_pending(ddf
);
4220 dprintf("ddf: set_disk %d (%08x) to %x->%02x\n", n
,
4221 be32_to_cpu(dl
->disk
.refnum
), state
,
4222 be16_to_cpu(ddf
->phys
->entries
[pd
].state
));
4224 /* Now we need to check the state of the array and update
4225 * virtual_disk.entries[n].state.
4226 * It needs to be one of "optimal", "degraded", "failed".
4227 * I don't understand 'deleted' or 'missing'.
4229 state
= get_svd_state(ddf
, vcl
);
4231 if (ddf
->virt
->entries
[inst
].state
!=
4232 ((ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4235 ddf
->virt
->entries
[inst
].state
=
4236 (ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4238 ddf_set_updates_pending(ddf
);
4243 static void ddf_sync_metadata(struct supertype
*st
)
4247 * Write all data to all devices.
4248 * Later, we might be able to track whether only local changes
4249 * have been made, or whether any global data has been changed,
4250 * but ddf is sufficiently weird that it probably always
4251 * changes global data ....
4253 struct ddf_super
*ddf
= st
->sb
;
4254 if (!ddf
->updates_pending
)
4256 ddf
->updates_pending
= 0;
4257 __write_init_super_ddf(st
);
4258 dprintf("ddf: sync_metadata\n");
4261 static int del_from_conflist(struct vcl
**list
, const char *guid
)
4265 for (p
= list
; p
&& *p
; p
= &((*p
)->next
))
4266 if (!memcmp((*p
)->conf
.guid
, guid
, DDF_GUID_LEN
)) {
4273 static int _kill_subarray_ddf(struct ddf_super
*ddf
, const char *guid
)
4276 unsigned int vdnum
, i
;
4277 vdnum
= find_vde_by_guid(ddf
, guid
);
4278 if (vdnum
== DDF_NOTFOUND
) {
4279 pr_err("%s: could not find VD %s\n", __func__
,
4283 if (del_from_conflist(&ddf
->conflist
, guid
) == 0) {
4284 pr_err("%s: could not find conf %s\n", __func__
,
4288 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4289 for (i
= 0; i
< ddf
->max_part
; i
++)
4290 if (dl
->vlist
[i
] != NULL
&&
4291 !memcmp(dl
->vlist
[i
]->conf
.guid
, guid
,
4293 dl
->vlist
[i
] = NULL
;
4294 memset(ddf
->virt
->entries
[vdnum
].guid
, 0xff, DDF_GUID_LEN
);
4295 dprintf("%s: deleted %s\n", __func__
, guid_str(guid
));
4299 static int kill_subarray_ddf(struct supertype
*st
)
4301 struct ddf_super
*ddf
= st
->sb
;
4303 * currentconf is set in container_content_ddf,
4304 * called with subarray arg
4306 struct vcl
*victim
= ddf
->currentconf
;
4307 struct vd_config
*conf
;
4308 ddf
->currentconf
= NULL
;
4311 pr_err("%s: nothing to kill\n", __func__
);
4314 conf
= &victim
->conf
;
4315 vdnum
= find_vde_by_guid(ddf
, conf
->guid
);
4316 if (vdnum
== DDF_NOTFOUND
) {
4317 pr_err("%s: could not find VD %s\n", __func__
,
4318 guid_str(conf
->guid
));
4321 if (st
->update_tail
) {
4322 struct virtual_disk
*vd
;
4323 int len
= sizeof(struct virtual_disk
)
4324 + sizeof(struct virtual_entry
);
4327 pr_err("%s: failed to allocate %d bytes\n", __func__
,
4331 memset(vd
, 0 , len
);
4332 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
4333 vd
->populated_vdes
= cpu_to_be16(0);
4334 memcpy(vd
->entries
[0].guid
, conf
->guid
, DDF_GUID_LEN
);
4335 /* we use DDF_state_deleted as marker */
4336 vd
->entries
[0].state
= DDF_state_deleted
;
4337 append_metadata_update(st
, vd
, len
);
4339 _kill_subarray_ddf(ddf
, conf
->guid
);
4340 ddf_set_updates_pending(ddf
);
4341 ddf_sync_metadata(st
);
4346 static void copy_matching_bvd(struct ddf_super
*ddf
,
4347 struct vd_config
*conf
,
4348 const struct metadata_update
*update
)
4351 be16_to_cpu(ddf
->anchor
.max_primary_element_entries
);
4352 unsigned int len
= ddf
->conf_rec_len
* 512;
4354 struct vd_config
*vc
;
4355 for (p
= update
->buf
; p
< update
->buf
+ update
->len
; p
+= len
) {
4356 vc
= (struct vd_config
*) p
;
4357 if (vc
->sec_elmnt_seq
== conf
->sec_elmnt_seq
) {
4358 memcpy(conf
->phys_refnum
, vc
->phys_refnum
,
4359 mppe
* (sizeof(__u32
) + sizeof(__u64
)));
4363 pr_err("%s: no match for BVD %d of %s in update\n", __func__
,
4364 conf
->sec_elmnt_seq
, guid_str(conf
->guid
));
4367 static void ddf_process_update(struct supertype
*st
,
4368 struct metadata_update
*update
)
4370 /* Apply this update to the metadata.
4371 * The first 4 bytes are a DDF_*_MAGIC which guides
4373 * Possible update are:
4374 * DDF_PHYS_RECORDS_MAGIC
4375 * Add a new physical device or remove an old one.
4376 * Changes to this record only happen implicitly.
4377 * used_pdes is the device number.
4378 * DDF_VIRT_RECORDS_MAGIC
4379 * Add a new VD. Possibly also change the 'access' bits.
4380 * populated_vdes is the entry number.
4382 * New or updated VD. the VIRT_RECORD must already
4383 * exist. For an update, phys_refnum and lba_offset
4384 * (at least) are updated, and the VD_CONF must
4385 * be written to precisely those devices listed with
4387 * DDF_SPARE_ASSIGN_MAGIC
4388 * replacement Spare Assignment Record... but for which device?
4391 * - to create a new array, we send a VIRT_RECORD and
4392 * a VD_CONF. Then assemble and start the array.
4393 * - to activate a spare we send a VD_CONF to add the phys_refnum
4394 * and offset. This will also mark the spare as active with
4395 * a spare-assignment record.
4397 struct ddf_super
*ddf
= st
->sb
;
4398 be32
*magic
= (be32
*)update
->buf
;
4399 struct phys_disk
*pd
;
4400 struct virtual_disk
*vd
;
4401 struct vd_config
*vc
;
4405 unsigned int pdnum
, pd2
, len
;
4407 dprintf("Process update %x\n", be32_to_cpu(*magic
));
4409 if (be32_eq(*magic
, DDF_PHYS_RECORDS_MAGIC
)) {
4411 if (update
->len
!= (sizeof(struct phys_disk
) +
4412 sizeof(struct phys_disk_entry
)))
4414 pd
= (struct phys_disk
*)update
->buf
;
4416 ent
= be16_to_cpu(pd
->used_pdes
);
4417 if (ent
>= be16_to_cpu(ddf
->phys
->max_pdes
))
4419 if (be16_and(pd
->entries
[0].state
, cpu_to_be16(DDF_Missing
))) {
4421 /* removing this disk. */
4422 be16_set(ddf
->phys
->entries
[ent
].state
,
4423 cpu_to_be16(DDF_Missing
));
4424 for (dlp
= &ddf
->dlist
; *dlp
; dlp
= &(*dlp
)->next
) {
4425 struct dl
*dl
= *dlp
;
4426 if (dl
->pdnum
== (signed)ent
) {
4429 /* FIXME this doesn't free
4436 ddf_set_updates_pending(ddf
);
4439 if (!all_ff(ddf
->phys
->entries
[ent
].guid
))
4441 ddf
->phys
->entries
[ent
] = pd
->entries
[0];
4442 ddf
->phys
->used_pdes
= cpu_to_be16
4443 (1 + be16_to_cpu(ddf
->phys
->used_pdes
));
4444 ddf_set_updates_pending(ddf
);
4445 if (ddf
->add_list
) {
4446 struct active_array
*a
;
4447 struct dl
*al
= ddf
->add_list
;
4448 ddf
->add_list
= al
->next
;
4450 al
->next
= ddf
->dlist
;
4453 /* As a device has been added, we should check
4454 * for any degraded devices that might make
4455 * use of this spare */
4456 for (a
= st
->arrays
; a
; a
=a
->next
)
4457 a
->check_degraded
= 1;
4459 } else if (be32_eq(*magic
, DDF_VIRT_RECORDS_MAGIC
)) {
4461 if (update
->len
!= (sizeof(struct virtual_disk
) +
4462 sizeof(struct virtual_entry
)))
4464 vd
= (struct virtual_disk
*)update
->buf
;
4466 if (vd
->entries
[0].state
== DDF_state_deleted
) {
4467 if (_kill_subarray_ddf(ddf
, vd
->entries
[0].guid
))
4471 ent
= find_vde_by_guid(ddf
, vd
->entries
[0].guid
);
4472 if (ent
!= DDF_NOTFOUND
) {
4473 dprintf("%s: VD %s exists already in slot %d\n",
4474 __func__
, guid_str(vd
->entries
[0].guid
),
4478 ent
= find_unused_vde(ddf
);
4479 if (ent
== DDF_NOTFOUND
)
4481 ddf
->virt
->entries
[ent
] = vd
->entries
[0];
4482 ddf
->virt
->populated_vdes
=
4485 ddf
->virt
->populated_vdes
));
4486 dprintf("%s: added VD %s in slot %d(s=%02x i=%02x)\n",
4487 __func__
, guid_str(vd
->entries
[0].guid
), ent
,
4488 ddf
->virt
->entries
[ent
].state
,
4489 ddf
->virt
->entries
[ent
].init_state
);
4491 ddf_set_updates_pending(ddf
);
4494 else if (be32_eq(*magic
, DDF_VD_CONF_MAGIC
)) {
4495 vc
= (struct vd_config
*)update
->buf
;
4496 len
= ddf
->conf_rec_len
* 512;
4497 if ((unsigned int)update
->len
!= len
* vc
->sec_elmnt_count
) {
4498 pr_err("%s: %s: insufficient data (%d) for %u BVDs\n",
4499 __func__
, guid_str(vc
->guid
), update
->len
,
4500 vc
->sec_elmnt_count
);
4503 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
)
4504 if (memcmp(vcl
->conf
.guid
, vc
->guid
, DDF_GUID_LEN
) == 0)
4506 dprintf("%s: conf update for %s (%s)\n", __func__
,
4507 guid_str(vc
->guid
), (vcl
? "old" : "new"));
4509 /* An update, just copy the phys_refnum and lba_offset
4514 copy_matching_bvd(ddf
, &vcl
->conf
, update
);
4515 for (k
= 0; k
< be16_to_cpu(vc
->prim_elmnt_count
); k
++)
4516 dprintf("BVD %u has %08x at %llu\n", 0,
4517 be32_to_cpu(vcl
->conf
.phys_refnum
[k
]),
4518 be64_to_cpu(LBA_OFFSET(ddf
,
4520 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++) {
4521 copy_matching_bvd(ddf
, vcl
->other_bvds
[i
-1],
4523 for (k
= 0; k
< be16_to_cpu(
4524 vc
->prim_elmnt_count
); k
++)
4525 dprintf("BVD %u has %08x at %llu\n", i
,
4527 (vcl
->other_bvds
[i
-1]->
4532 vcl
->other_bvds
[i
-1])[k
]));
4539 vcl
= update
->space
;
4540 update
->space
= NULL
;
4541 vcl
->next
= ddf
->conflist
;
4542 memcpy(&vcl
->conf
, vc
, len
);
4543 ent
= find_vde_by_guid(ddf
, vc
->guid
);
4544 if (ent
== DDF_NOTFOUND
)
4547 ddf
->conflist
= vcl
;
4548 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++)
4549 memcpy(vcl
->other_bvds
[i
-1],
4550 update
->buf
+ len
* i
, len
);
4552 /* Set DDF_Transition on all Failed devices - to help
4553 * us detect those that are no longer in use
4555 for (pdnum
= 0; pdnum
< be16_to_cpu(ddf
->phys
->used_pdes
);
4557 if (be16_and(ddf
->phys
->entries
[pdnum
].state
,
4558 cpu_to_be16(DDF_Failed
)))
4559 be16_set(ddf
->phys
->entries
[pdnum
].state
,
4560 cpu_to_be16(DDF_Transition
));
4561 /* Now make sure vlist is correct for each dl. */
4562 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
4563 unsigned int vn
= 0;
4564 int in_degraded
= 0;
4565 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
) {
4566 unsigned int dn
, ibvd
;
4567 const struct vd_config
*conf
;
4569 dn
= get_pd_index_from_refnum(vcl
,
4573 if (dn
== DDF_NOTFOUND
)
4575 dprintf("dev %d/%08x has %s (sec=%u) at %d\n",
4577 be32_to_cpu(dl
->disk
.refnum
),
4578 guid_str(conf
->guid
),
4579 conf
->sec_elmnt_seq
, vn
);
4580 /* Clear the Transition flag */
4582 (ddf
->phys
->entries
[dl
->pdnum
].state
,
4583 cpu_to_be16(DDF_Failed
)))
4584 be16_clear(ddf
->phys
4585 ->entries
[dl
->pdnum
].state
,
4586 cpu_to_be16(DDF_Transition
));
4587 dl
->vlist
[vn
++] = vcl
;
4588 vstate
= ddf
->virt
->entries
[vcl
->vcnum
].state
4590 if (vstate
== DDF_state_degraded
||
4591 vstate
== DDF_state_part_optimal
)
4594 while (vn
< ddf
->max_part
)
4595 dl
->vlist
[vn
++] = NULL
;
4597 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4598 cpu_to_be16(DDF_Global_Spare
));
4599 if (!be16_and(ddf
->phys
4600 ->entries
[dl
->pdnum
].type
,
4601 cpu_to_be16(DDF_Active_in_VD
))) {
4603 ->entries
[dl
->pdnum
].type
,
4604 cpu_to_be16(DDF_Active_in_VD
));
4607 ->entries
[dl
->pdnum
]
4614 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4615 cpu_to_be16(DDF_Global_Spare
));
4616 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
4617 cpu_to_be16(DDF_Spare
));
4619 if (!dl
->vlist
[0] && !dl
->spare
) {
4620 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
4621 cpu_to_be16(DDF_Global_Spare
));
4622 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4623 cpu_to_be16(DDF_Spare
));
4624 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4625 cpu_to_be16(DDF_Active_in_VD
));
4629 /* Now remove any 'Failed' devices that are not part
4630 * of any VD. They will have the Transition flag set.
4631 * Once done, we need to update all dl->pdnum numbers.
4634 for (pdnum
= 0; pdnum
< be16_to_cpu(ddf
->phys
->used_pdes
);
4636 if (be16_and(ddf
->phys
->entries
[pdnum
].state
,
4637 cpu_to_be16(DDF_Failed
))
4638 && be16_and(ddf
->phys
->entries
[pdnum
].state
,
4639 cpu_to_be16(DDF_Transition
)))
4640 /* skip this one */;
4641 else if (pdnum
== pd2
)
4644 ddf
->phys
->entries
[pd2
] =
4645 ddf
->phys
->entries
[pdnum
];
4646 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4647 if (dl
->pdnum
== (int)pdnum
)
4651 ddf
->phys
->used_pdes
= cpu_to_be16(pd2
);
4652 while (pd2
< pdnum
) {
4653 memset(ddf
->phys
->entries
[pd2
].guid
, 0xff,
4658 ddf_set_updates_pending(ddf
);
4660 /* case DDF_SPARE_ASSIGN_MAGIC */
4663 static void ddf_prepare_update(struct supertype
*st
,
4664 struct metadata_update
*update
)
4666 /* This update arrived at managemon.
4667 * We are about to pass it to monitor.
4668 * If a malloc is needed, do it here.
4670 struct ddf_super
*ddf
= st
->sb
;
4671 be32
*magic
= (be32
*)update
->buf
;
4672 if (be32_eq(*magic
, DDF_VD_CONF_MAGIC
)) {
4674 struct vd_config
*conf
= (struct vd_config
*) update
->buf
;
4675 if (posix_memalign(&update
->space
, 512,
4676 offsetof(struct vcl
, conf
)
4677 + ddf
->conf_rec_len
* 512) != 0) {
4678 update
->space
= NULL
;
4681 vcl
= update
->space
;
4682 vcl
->conf
.sec_elmnt_count
= conf
->sec_elmnt_count
;
4683 if (alloc_other_bvds(ddf
, vcl
) != 0) {
4684 free(update
->space
);
4685 update
->space
= NULL
;
4691 * Check degraded state of a RAID10.
4692 * returns 2 for good, 1 for degraded, 0 for failed, and -1 for error
4694 static int raid10_degraded(struct mdinfo
*info
)
4698 struct mdinfo
*d
, *sra
;
4702 if (info
->array
.layout
== 0) {
4703 sra
= sysfs_read(-1, info
->sys_name
, GET_LAYOUT
);
4704 info
->array
.layout
= sra
->array
.layout
;
4708 n_prim
= info
->array
.layout
& ~0x100;
4709 n_bvds
= info
->array
.raid_disks
/ n_prim
;
4710 found
= xmalloc(n_bvds
);
4713 memset(found
, 0, n_bvds
);
4714 for (d
= info
->devs
; d
; d
= d
->next
) {
4715 i
= d
->disk
.raid_disk
/ n_prim
;
4717 pr_err("%s: BUG: invalid raid disk\n", __func__
);
4720 if (d
->state_fd
> 0)
4724 for (i
= 0; i
< n_bvds
; i
++)
4726 dprintf("%s: BVD %d/%d failed\n", __func__
, i
, n_bvds
);
4729 } else if (found
[i
] < n_prim
) {
4730 dprintf("%s: BVD %d/%d degraded\n", __func__
, i
,
4740 * Check if the array 'a' is degraded but not failed.
4741 * If it is, find as many spares as are available and needed and
4742 * arrange for their inclusion.
4743 * We only choose devices which are not already in the array,
4744 * and prefer those with a spare-assignment to this array.
4745 * otherwise we choose global spares - assuming always that
4746 * there is enough room.
4747 * For each spare that we assign, we return an 'mdinfo' which
4748 * describes the position for the device in the array.
4749 * We also add to 'updates' a DDF_VD_CONF_MAGIC update with
4750 * the new phys_refnum and lba_offset values.
4752 * Only worry about BVDs at the moment.
4754 static struct mdinfo
*ddf_activate_spare(struct active_array
*a
,
4755 struct metadata_update
**updates
)
4759 struct ddf_super
*ddf
= a
->container
->sb
;
4761 struct mdinfo
*rv
= NULL
;
4763 struct metadata_update
*mu
;
4768 struct vd_config
*vc
;
4771 for (d
= a
->info
.devs
; d
; d
= d
->next
) {
4772 if ((d
->curr_state
& DS_FAULTY
) &&
4774 /* wait for Removal to happen */
4776 if (d
->state_fd
>= 0)
4780 dprintf("%s: working=%d (%d) level=%d\n", __func__
, working
,
4781 a
->info
.array
.raid_disks
,
4782 a
->info
.array
.level
);
4783 if (working
== a
->info
.array
.raid_disks
)
4784 return NULL
; /* array not degraded */
4785 switch (a
->info
.array
.level
) {
4788 return NULL
; /* failed */
4792 if (working
< a
->info
.array
.raid_disks
- 1)
4793 return NULL
; /* failed */
4796 if (working
< a
->info
.array
.raid_disks
- 2)
4797 return NULL
; /* failed */
4800 if (raid10_degraded(&a
->info
) < 1)
4803 default: /* concat or stripe */
4804 return NULL
; /* failed */
4807 /* For each slot, if it is not working, find a spare */
4809 for (i
= 0; i
< a
->info
.array
.raid_disks
; i
++) {
4810 for (d
= a
->info
.devs
; d
; d
= d
->next
)
4811 if (d
->disk
.raid_disk
== i
)
4813 dprintf("found %d: %p %x\n", i
, d
, d
?d
->curr_state
:0);
4814 if (d
&& (d
->state_fd
>= 0))
4817 /* OK, this device needs recovery. Find a spare */
4819 for ( ; dl
; dl
= dl
->next
) {
4820 unsigned long long esize
;
4821 unsigned long long pos
;
4824 int is_dedicated
= 0;
4827 be16 state
= ddf
->phys
->entries
[dl
->pdnum
].state
;
4829 cpu_to_be16(DDF_Failed
|DDF_Missing
)) ||
4831 cpu_to_be16(DDF_Online
)))
4834 /* If in this array, skip */
4835 for (d2
= a
->info
.devs
; d2
; d2
= d2
->next
)
4836 if (d2
->state_fd
>= 0 &&
4837 d2
->disk
.major
== dl
->major
&&
4838 d2
->disk
.minor
== dl
->minor
) {
4839 dprintf("%x:%x (%08x) already in array\n",
4840 dl
->major
, dl
->minor
,
4841 be32_to_cpu(dl
->disk
.refnum
));
4846 if (be16_and(ddf
->phys
->entries
[dl
->pdnum
].type
,
4847 cpu_to_be16(DDF_Spare
))) {
4848 /* Check spare assign record */
4850 if (dl
->spare
->type
& DDF_spare_dedicated
) {
4851 /* check spare_ents for guid */
4857 if (memcmp(dl
->spare
->spare_ents
[j
].guid
,
4858 ddf
->virt
->entries
[a
->info
.container_member
].guid
,
4865 } else if (be16_and(ddf
->phys
->entries
[dl
->pdnum
].type
,
4866 cpu_to_be16(DDF_Global_Spare
))) {
4868 } else if (!be16_and(ddf
->phys
4869 ->entries
[dl
->pdnum
].state
,
4870 cpu_to_be16(DDF_Failed
))) {
4871 /* we can possibly use some of this */
4874 if ( ! (is_dedicated
||
4875 (is_global
&& global_ok
))) {
4876 dprintf("%x:%x not suitable: %d %d\n", dl
->major
, dl
->minor
,
4877 is_dedicated
, is_global
);
4881 /* We are allowed to use this device - is there space?
4882 * We need a->info.component_size sectors */
4883 ex
= get_extents(ddf
, dl
);
4885 dprintf("cannot get extents\n");
4892 esize
= ex
[j
].start
- pos
;
4893 if (esize
>= a
->info
.component_size
)
4895 pos
= ex
[j
].start
+ ex
[j
].size
;
4897 } while (ex
[j
-1].size
);
4900 if (esize
< a
->info
.component_size
) {
4901 dprintf("%x:%x has no room: %llu %llu\n",
4902 dl
->major
, dl
->minor
,
4903 esize
, a
->info
.component_size
);
4908 /* Cool, we have a device with some space at pos */
4909 di
= xcalloc(1, sizeof(*di
));
4910 di
->disk
.number
= i
;
4911 di
->disk
.raid_disk
= i
;
4912 di
->disk
.major
= dl
->major
;
4913 di
->disk
.minor
= dl
->minor
;
4915 di
->recovery_start
= 0;
4916 di
->data_offset
= pos
;
4917 di
->component_size
= a
->info
.component_size
;
4918 di
->container_member
= dl
->pdnum
;
4921 dprintf("%x:%x (%08x) to be %d at %llu\n",
4922 dl
->major
, dl
->minor
,
4923 be32_to_cpu(dl
->disk
.refnum
), i
, pos
);
4927 if (!dl
&& ! global_ok
) {
4928 /* not enough dedicated spares, try global */
4936 /* No spares found */
4938 /* Now 'rv' has a list of devices to return.
4939 * Create a metadata_update record to update the
4940 * phys_refnum and lba_offset values
4942 vc
= find_vdcr(ddf
, a
->info
.container_member
, di
->disk
.raid_disk
,
4947 mu
= xmalloc(sizeof(*mu
));
4948 if (posix_memalign(&mu
->space
, 512, sizeof(struct vcl
)) != 0) {
4953 mu
->len
= ddf
->conf_rec_len
* 512 * vcl
->conf
.sec_elmnt_count
;
4954 mu
->buf
= xmalloc(mu
->len
);
4956 mu
->space_list
= NULL
;
4957 mu
->next
= *updates
;
4958 memcpy(mu
->buf
, &vcl
->conf
, ddf
->conf_rec_len
* 512);
4959 for (j
= 1; j
< vcl
->conf
.sec_elmnt_count
; j
++)
4960 memcpy(mu
->buf
+ j
* ddf
->conf_rec_len
* 512,
4961 vcl
->other_bvds
[j
-1], ddf
->conf_rec_len
* 512);
4963 vc
= (struct vd_config
*)mu
->buf
;
4964 for (di
= rv
; di
; di
= di
->next
) {
4965 unsigned int i_sec
, i_prim
;
4966 i_sec
= di
->disk
.raid_disk
4967 / be16_to_cpu(vcl
->conf
.prim_elmnt_count
);
4968 i_prim
= di
->disk
.raid_disk
4969 % be16_to_cpu(vcl
->conf
.prim_elmnt_count
);
4970 vc
= (struct vd_config
*)(mu
->buf
4971 + i_sec
* ddf
->conf_rec_len
* 512);
4972 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4973 if (dl
->major
== di
->disk
.major
4974 && dl
->minor
== di
->disk
.minor
)
4977 pr_err("%s: BUG: can't find disk %d (%d/%d)\n",
4978 __func__
, di
->disk
.raid_disk
,
4979 di
->disk
.major
, di
->disk
.minor
);
4982 vc
->phys_refnum
[i_prim
] = ddf
->phys
->entries
[dl
->pdnum
].refnum
;
4983 LBA_OFFSET(ddf
, vc
)[i_prim
] = cpu_to_be64(di
->data_offset
);
4984 dprintf("BVD %u gets %u: %08x at %llu\n", i_sec
, i_prim
,
4985 be32_to_cpu(vc
->phys_refnum
[i_prim
]),
4986 be64_to_cpu(LBA_OFFSET(ddf
, vc
)[i_prim
]));
4991 #endif /* MDASSEMBLE */
4993 static int ddf_level_to_layout(int level
)
5000 return ALGORITHM_LEFT_SYMMETRIC
;
5002 return ALGORITHM_ROTATING_N_CONTINUE
;
5010 static void default_geometry_ddf(struct supertype
*st
, int *level
, int *layout
, int *chunk
)
5012 if (level
&& *level
== UnSet
)
5013 *level
= LEVEL_CONTAINER
;
5015 if (level
&& layout
&& *layout
== UnSet
)
5016 *layout
= ddf_level_to_layout(*level
);
5019 struct superswitch super_ddf
= {
5021 .examine_super
= examine_super_ddf
,
5022 .brief_examine_super
= brief_examine_super_ddf
,
5023 .brief_examine_subarrays
= brief_examine_subarrays_ddf
,
5024 .export_examine_super
= export_examine_super_ddf
,
5025 .detail_super
= detail_super_ddf
,
5026 .brief_detail_super
= brief_detail_super_ddf
,
5027 .validate_geometry
= validate_geometry_ddf
,
5028 .write_init_super
= write_init_super_ddf
,
5029 .add_to_super
= add_to_super_ddf
,
5030 .remove_from_super
= remove_from_super_ddf
,
5031 .load_container
= load_container_ddf
,
5032 .copy_metadata
= copy_metadata_ddf
,
5033 .kill_subarray
= kill_subarray_ddf
,
5035 .match_home
= match_home_ddf
,
5036 .uuid_from_super
= uuid_from_super_ddf
,
5037 .getinfo_super
= getinfo_super_ddf
,
5038 .update_super
= update_super_ddf
,
5040 .avail_size
= avail_size_ddf
,
5042 .compare_super
= compare_super_ddf
,
5044 .load_super
= load_super_ddf
,
5045 .init_super
= init_super_ddf
,
5046 .store_super
= store_super_ddf
,
5047 .free_super
= free_super_ddf
,
5048 .match_metadata_desc
= match_metadata_desc_ddf
,
5049 .container_content
= container_content_ddf
,
5050 .default_geometry
= default_geometry_ddf
,
5056 .open_new
= ddf_open_new
,
5057 .set_array_state
= ddf_set_array_state
,
5058 .set_disk
= ddf_set_disk
,
5059 .sync_metadata
= ddf_sync_metadata
,
5060 .process_update
= ddf_process_update
,
5061 .prepare_update
= ddf_prepare_update
,
5062 .activate_spare
= ddf_activate_spare
,