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 /* Default for safe_mode_delay. Same value as for IMSM.
52 static const int DDF_SAFE_MODE_DELAY
= 4000;
54 /* The DDF metadata handling.
55 * DDF metadata lives at the end of the device.
56 * The last 512 byte block provides an 'anchor' which is used to locate
57 * the rest of the metadata which usually lives immediately behind the anchor.
60 * - all multibyte numeric fields are bigendian.
61 * - all strings are space padded.
65 typedef struct __be16
{
68 #define be16_eq(x, y) ((x)._v16 == (y)._v16)
69 #define be16_and(x, y) ((x)._v16 & (y)._v16)
70 #define be16_or(x, y) ((x)._v16 | (y)._v16)
71 #define be16_clear(x, y) ((x)._v16 &= ~(y)._v16)
72 #define be16_set(x, y) ((x)._v16 |= (y)._v16)
74 typedef struct __be32
{
77 #define be32_eq(x, y) ((x)._v32 == (y)._v32)
79 typedef struct __be64
{
82 #define be64_eq(x, y) ((x)._v64 == (y)._v64)
84 #define be16_to_cpu(be) __be16_to_cpu((be)._v16)
85 static inline be16
cpu_to_be16(__u16 x
)
87 be16 be
= { ._v16
= __cpu_to_be16(x
) };
91 #define be32_to_cpu(be) __be32_to_cpu((be)._v32)
92 static inline be32
cpu_to_be32(__u32 x
)
94 be32 be
= { ._v32
= __cpu_to_be32(x
) };
98 #define be64_to_cpu(be) __be64_to_cpu((be)._v64)
99 static inline be64
cpu_to_be64(__u64 x
)
101 be64 be
= { ._v64
= __cpu_to_be64(x
) };
105 /* Primary Raid Level (PRL) */
106 #define DDF_RAID0 0x00
107 #define DDF_RAID1 0x01
108 #define DDF_RAID3 0x03
109 #define DDF_RAID4 0x04
110 #define DDF_RAID5 0x05
111 #define DDF_RAID1E 0x11
112 #define DDF_JBOD 0x0f
113 #define DDF_CONCAT 0x1f
114 #define DDF_RAID5E 0x15
115 #define DDF_RAID5EE 0x25
116 #define DDF_RAID6 0x06
118 /* Raid Level Qualifier (RLQ) */
119 #define DDF_RAID0_SIMPLE 0x00
120 #define DDF_RAID1_SIMPLE 0x00 /* just 2 devices in this plex */
121 #define DDF_RAID1_MULTI 0x01 /* exactly 3 devices in this plex */
122 #define DDF_RAID3_0 0x00 /* parity in first extent */
123 #define DDF_RAID3_N 0x01 /* parity in last extent */
124 #define DDF_RAID4_0 0x00 /* parity in first extent */
125 #define DDF_RAID4_N 0x01 /* parity in last extent */
126 /* these apply to raid5e and raid5ee as well */
127 #define DDF_RAID5_0_RESTART 0x00 /* same as 'right asymmetric' - layout 1 */
128 #define DDF_RAID6_0_RESTART 0x01 /* raid6 different from raid5 here!!! */
129 #define DDF_RAID5_N_RESTART 0x02 /* same as 'left asymmetric' - layout 0 */
130 #define DDF_RAID5_N_CONTINUE 0x03 /* same as 'left symmetric' - layout 2 */
132 #define DDF_RAID1E_ADJACENT 0x00 /* raid10 nearcopies==2 */
133 #define DDF_RAID1E_OFFSET 0x01 /* raid10 offsetcopies==2 */
135 /* Secondary RAID Level (SRL) */
136 #define DDF_2STRIPED 0x00 /* This is weirder than RAID0 !! */
137 #define DDF_2MIRRORED 0x01
138 #define DDF_2CONCAT 0x02
139 #define DDF_2SPANNED 0x03 /* This is also weird - be careful */
142 #define DDF_HEADER_MAGIC cpu_to_be32(0xDE11DE11)
143 #define DDF_CONTROLLER_MAGIC cpu_to_be32(0xAD111111)
144 #define DDF_PHYS_RECORDS_MAGIC cpu_to_be32(0x22222222)
145 #define DDF_PHYS_DATA_MAGIC cpu_to_be32(0x33333333)
146 #define DDF_VIRT_RECORDS_MAGIC cpu_to_be32(0xDDDDDDDD)
147 #define DDF_VD_CONF_MAGIC cpu_to_be32(0xEEEEEEEE)
148 #define DDF_SPARE_ASSIGN_MAGIC cpu_to_be32(0x55555555)
149 #define DDF_VU_CONF_MAGIC cpu_to_be32(0x88888888)
150 #define DDF_VENDOR_LOG_MAGIC cpu_to_be32(0x01dBEEF0)
151 #define DDF_BBM_LOG_MAGIC cpu_to_be32(0xABADB10C)
153 #define DDF_GUID_LEN 24
154 #define DDF_REVISION_0 "01.00.00"
155 #define DDF_REVISION_2 "01.02.00"
158 be32 magic
; /* DDF_HEADER_MAGIC */
160 char guid
[DDF_GUID_LEN
];
161 char revision
[8]; /* 01.02.00 */
162 be32 seq
; /* starts at '1' */
167 __u8 pad0
; /* 0xff */
168 __u8 pad1
[12]; /* 12 * 0xff */
169 /* 64 bytes so far */
170 __u8 header_ext
[32]; /* reserved: fill with 0xff */
174 __u8 pad2
[3]; /* 0xff */
175 be32 workspace_len
; /* sectors for vendor space -
176 * at least 32768(sectors) */
178 be16 max_pd_entries
; /* one of 15, 63, 255, 1023, 4095 */
179 be16 max_vd_entries
; /* 2^(4,6,8,10,12)-1 : i.e. as above */
180 be16 max_partitions
; /* i.e. max num of configuration
181 record entries per disk */
182 be16 config_record_len
; /* 1 +ROUNDUP(max_primary_element_entries
184 be16 max_primary_element_entries
; /* 16, 64, 256, 1024, or 4096 */
185 __u8 pad3
[54]; /* 0xff */
186 /* 192 bytes so far */
187 be32 controller_section_offset
;
188 be32 controller_section_length
;
189 be32 phys_section_offset
;
190 be32 phys_section_length
;
191 be32 virt_section_offset
;
192 be32 virt_section_length
;
193 be32 config_section_offset
;
194 be32 config_section_length
;
195 be32 data_section_offset
;
196 be32 data_section_length
;
197 be32 bbm_section_offset
;
198 be32 bbm_section_length
;
199 be32 diag_space_offset
;
200 be32 diag_space_length
;
203 /* 256 bytes so far */
204 __u8 pad4
[256]; /* 0xff */
208 #define DDF_HEADER_ANCHOR 0x00
209 #define DDF_HEADER_PRIMARY 0x01
210 #define DDF_HEADER_SECONDARY 0x02
212 /* The content of the 'controller section' - global scope */
213 struct ddf_controller_data
{
214 be32 magic
; /* DDF_CONTROLLER_MAGIC */
216 char guid
[DDF_GUID_LEN
];
217 struct controller_type
{
224 __u8 pad
[8]; /* 0xff */
225 __u8 vendor_data
[448];
228 /* The content of phys_section - global scope */
230 be32 magic
; /* DDF_PHYS_RECORDS_MAGIC */
235 struct phys_disk_entry
{
236 char guid
[DDF_GUID_LEN
];
240 be64 config_size
; /* DDF structures must be after here */
241 char path
[18]; /* another horrible structure really */
246 /* phys_disk_entry.type is a bitmap - bigendian remember */
247 #define DDF_Forced_PD_GUID 1
248 #define DDF_Active_in_VD 2
249 #define DDF_Global_Spare 4 /* VD_CONF records are ignored */
250 #define DDF_Spare 8 /* overrides Global_spare */
251 #define DDF_Foreign 16
252 #define DDF_Legacy 32 /* no DDF on this device */
254 #define DDF_Interface_mask 0xf00
255 #define DDF_Interface_SCSI 0x100
256 #define DDF_Interface_SAS 0x200
257 #define DDF_Interface_SATA 0x300
258 #define DDF_Interface_FC 0x400
260 /* phys_disk_entry.state is a bigendian bitmap */
262 #define DDF_Failed 2 /* overrides 1,4,8 */
263 #define DDF_Rebuilding 4
264 #define DDF_Transition 8
266 #define DDF_ReadErrors 32
267 #define DDF_Missing 64
269 /* The content of the virt_section global scope */
270 struct virtual_disk
{
271 be32 magic
; /* DDF_VIRT_RECORDS_MAGIC */
276 struct virtual_entry
{
277 char guid
[DDF_GUID_LEN
];
279 __u16 pad0
; /* 0xffff */
289 /* virtual_entry.type is a bitmap - bigendian */
291 #define DDF_Enforce_Groups 2
292 #define DDF_Unicode 4
293 #define DDF_Owner_Valid 8
295 /* virtual_entry.state is a bigendian bitmap */
296 #define DDF_state_mask 0x7
297 #define DDF_state_optimal 0x0
298 #define DDF_state_degraded 0x1
299 #define DDF_state_deleted 0x2
300 #define DDF_state_missing 0x3
301 #define DDF_state_failed 0x4
302 #define DDF_state_part_optimal 0x5
304 #define DDF_state_morphing 0x8
305 #define DDF_state_inconsistent 0x10
307 /* virtual_entry.init_state is a bigendian bitmap */
308 #define DDF_initstate_mask 0x03
309 #define DDF_init_not 0x00
310 #define DDF_init_quick 0x01 /* initialisation is progress.
311 * i.e. 'state_inconsistent' */
312 #define DDF_init_full 0x02
314 #define DDF_access_mask 0xc0
315 #define DDF_access_rw 0x00
316 #define DDF_access_ro 0x80
317 #define DDF_access_blocked 0xc0
319 /* The content of the config_section - local scope
320 * It has multiple records each config_record_len sectors
321 * They can be vd_config or spare_assign
325 be32 magic
; /* DDF_VD_CONF_MAGIC */
327 char guid
[DDF_GUID_LEN
];
331 be16 prim_elmnt_count
;
332 __u8 chunk_shift
; /* 0 == 512, 1==1024 etc */
335 __u8 sec_elmnt_count
;
338 be64 blocks
; /* blocks per component could be different
339 * on different component devices...(only
340 * for concat I hope) */
341 be64 array_blocks
; /* blocks in array */
349 __u8 v0
[32]; /* reserved- 0xff */
350 __u8 v1
[32]; /* reserved- 0xff */
351 __u8 v2
[16]; /* reserved- 0xff */
352 __u8 v3
[16]; /* reserved- 0xff */
354 be32 phys_refnum
[0]; /* refnum of each disk in sequence */
355 /*__u64 lba_offset[0]; LBA offset in each phys. Note extents in a
356 bvd are always the same size */
358 #define LBA_OFFSET(ddf, vd) ((be64 *) &(vd)->phys_refnum[(ddf)->mppe])
360 /* vd_config.cache_pol[7] is a bitmap */
361 #define DDF_cache_writeback 1 /* else writethrough */
362 #define DDF_cache_wadaptive 2 /* only applies if writeback */
363 #define DDF_cache_readahead 4
364 #define DDF_cache_radaptive 8 /* only if doing read-ahead */
365 #define DDF_cache_ifnobatt 16 /* even to write cache if battery is poor */
366 #define DDF_cache_wallowed 32 /* enable write caching */
367 #define DDF_cache_rallowed 64 /* enable read caching */
369 struct spare_assign
{
370 be32 magic
; /* DDF_SPARE_ASSIGN_MAGIC */
375 be16 populated
; /* SAEs used */
376 be16 max
; /* max SAEs */
378 struct spare_assign_entry
{
379 char guid
[DDF_GUID_LEN
];
380 be16 secondary_element
;
384 /* spare_assign.type is a bitmap */
385 #define DDF_spare_dedicated 0x1 /* else global */
386 #define DDF_spare_revertible 0x2 /* else committable */
387 #define DDF_spare_active 0x4 /* else not active */
388 #define DDF_spare_affinity 0x8 /* enclosure affinity */
390 /* The data_section contents - local scope */
392 be32 magic
; /* DDF_PHYS_DATA_MAGIC */
394 char guid
[DDF_GUID_LEN
];
395 be32 refnum
; /* crc of some magic drive data ... */
396 __u8 forced_ref
; /* set when above was not result of magic */
397 __u8 forced_guid
; /* set if guid was forced rather than magic */
402 /* bbm_section content */
403 struct bad_block_log
{
410 struct mapped_block
{
411 be64 defective_start
;
412 be32 replacement_start
;
418 /* Struct for internally holding ddf structures */
419 /* The DDF structure stored on each device is potentially
420 * quite different, as some data is global and some is local.
421 * The global data is:
424 * - Physical disk records
425 * - Virtual disk records
427 * - Configuration records
428 * - Physical Disk data section
429 * ( and Bad block and vendor which I don't care about yet).
431 * The local data is parsed into separate lists as it is read
432 * and reconstructed for writing. This means that we only need
433 * to make config changes once and they are automatically
434 * propagated to all devices.
435 * Note that the ddf_super has space of the conf and disk data
436 * for this disk and also for a list of all such data.
437 * The list is only used for the superblock that is being
438 * built in Create or Assemble to describe the whole array.
441 struct ddf_header anchor
, primary
, secondary
;
442 struct ddf_controller_data controller
;
443 struct ddf_header
*active
;
444 struct phys_disk
*phys
;
445 struct virtual_disk
*virt
;
448 unsigned int max_part
, mppe
, conf_rec_len
;
456 unsigned int vcnum
; /* index into ->virt */
457 struct vd_config
**other_bvds
;
458 __u64
*block_sizes
; /* NULL if all the same */
461 struct vd_config conf
;
462 } *conflist
, *currentconf
;
471 unsigned long long size
; /* sectors */
472 be64 primary_lba
; /* sectors */
473 be64 secondary_lba
; /* sectors */
474 be64 workspace_lba
; /* sectors */
475 int pdnum
; /* index in ->phys */
476 struct spare_assign
*spare
;
477 void *mdupdate
; /* hold metadata update */
479 /* These fields used by auto-layout */
480 int raiddisk
; /* slot to fill in autolayout */
484 struct disk_data disk
;
485 struct vcl
*vlist
[0]; /* max_part in size */
490 #define offsetof(t,f) ((size_t)&(((t*)0)->f))
494 static int all_ff(const char *guid
);
495 static void pr_state(struct ddf_super
*ddf
, const char *msg
)
498 dprintf("%s/%s: ", __func__
, msg
);
499 for (i
= 0; i
< be16_to_cpu(ddf
->active
->max_vd_entries
); i
++) {
500 if (all_ff(ddf
->virt
->entries
[i
].guid
))
502 dprintf("%u(s=%02x i=%02x) ", i
,
503 ddf
->virt
->entries
[i
].state
,
504 ddf
->virt
->entries
[i
].init_state
);
509 static void pr_state(const struct ddf_super
*ddf
, const char *msg
) {}
512 static void _ddf_set_updates_pending(struct ddf_super
*ddf
, const char *func
)
514 ddf
->updates_pending
= 1;
515 ddf
->active
->seq
= cpu_to_be32((be32_to_cpu(ddf
->active
->seq
)+1));
519 #define ddf_set_updates_pending(x) _ddf_set_updates_pending((x), __func__)
521 static unsigned int get_pd_index_from_refnum(const struct vcl
*vc
,
522 be32 refnum
, unsigned int nmax
,
523 const struct vd_config
**bvd
,
526 static be32
calc_crc(void *buf
, int len
)
528 /* crcs are always at the same place as in the ddf_header */
529 struct ddf_header
*ddf
= buf
;
530 be32 oldcrc
= ddf
->crc
;
532 ddf
->crc
= cpu_to_be32(0xffffffff);
534 newcrc
= crc32(0, buf
, len
);
536 /* The crc is store (like everything) bigendian, so convert
537 * here for simplicity
539 return cpu_to_be32(newcrc
);
542 #define DDF_INVALID_LEVEL 0xff
543 #define DDF_NO_SECONDARY 0xff
544 static int err_bad_md_layout(const mdu_array_info_t
*array
)
546 pr_err("RAID%d layout %x with %d disks is unsupported for DDF\n",
547 array
->level
, array
->layout
, array
->raid_disks
);
551 static int layout_md2ddf(const mdu_array_info_t
*array
,
552 struct vd_config
*conf
)
554 be16 prim_elmnt_count
= cpu_to_be16(array
->raid_disks
);
555 __u8 prl
= DDF_INVALID_LEVEL
, rlq
= 0;
556 __u8 sec_elmnt_count
= 1;
557 __u8 srl
= DDF_NO_SECONDARY
;
559 switch (array
->level
) {
564 rlq
= DDF_RAID0_SIMPLE
;
568 switch (array
->raid_disks
) {
570 rlq
= DDF_RAID1_SIMPLE
;
573 rlq
= DDF_RAID1_MULTI
;
576 return err_bad_md_layout(array
);
581 if (array
->layout
!= 0)
582 return err_bad_md_layout(array
);
587 switch (array
->layout
) {
588 case ALGORITHM_LEFT_ASYMMETRIC
:
589 rlq
= DDF_RAID5_N_RESTART
;
591 case ALGORITHM_RIGHT_ASYMMETRIC
:
592 rlq
= DDF_RAID5_0_RESTART
;
594 case ALGORITHM_LEFT_SYMMETRIC
:
595 rlq
= DDF_RAID5_N_CONTINUE
;
597 case ALGORITHM_RIGHT_SYMMETRIC
:
598 /* not mentioned in standard */
600 return err_bad_md_layout(array
);
605 switch (array
->layout
) {
606 case ALGORITHM_ROTATING_N_RESTART
:
607 rlq
= DDF_RAID5_N_RESTART
;
609 case ALGORITHM_ROTATING_ZERO_RESTART
:
610 rlq
= DDF_RAID6_0_RESTART
;
612 case ALGORITHM_ROTATING_N_CONTINUE
:
613 rlq
= DDF_RAID5_N_CONTINUE
;
616 return err_bad_md_layout(array
);
621 if (array
->raid_disks
% 2 == 0 && array
->layout
== 0x102) {
622 rlq
= DDF_RAID1_SIMPLE
;
623 prim_elmnt_count
= cpu_to_be16(2);
624 sec_elmnt_count
= array
->raid_disks
/ 2;
625 } else if (array
->raid_disks
% 3 == 0
626 && array
->layout
== 0x103) {
627 rlq
= DDF_RAID1_MULTI
;
628 prim_elmnt_count
= cpu_to_be16(3);
629 sec_elmnt_count
= array
->raid_disks
/ 3;
631 return err_bad_md_layout(array
);
636 return err_bad_md_layout(array
);
639 conf
->prim_elmnt_count
= prim_elmnt_count
;
642 conf
->sec_elmnt_count
= sec_elmnt_count
;
646 static int err_bad_ddf_layout(const struct vd_config
*conf
)
648 pr_err("DDF RAID %u qualifier %u with %u disks is unsupported\n",
649 conf
->prl
, conf
->rlq
, be16_to_cpu(conf
->prim_elmnt_count
));
653 static int layout_ddf2md(const struct vd_config
*conf
,
654 mdu_array_info_t
*array
)
656 int level
= LEVEL_UNSUPPORTED
;
658 int raiddisks
= be16_to_cpu(conf
->prim_elmnt_count
);
660 if (conf
->sec_elmnt_count
> 1) {
661 /* see also check_secondary() */
662 if (conf
->prl
!= DDF_RAID1
||
663 (conf
->srl
!= DDF_2STRIPED
&& conf
->srl
!= DDF_2SPANNED
)) {
664 pr_err("Unsupported secondary RAID level %u/%u\n",
665 conf
->prl
, conf
->srl
);
668 if (raiddisks
== 2 && conf
->rlq
== DDF_RAID1_SIMPLE
)
670 else if (raiddisks
== 3 && conf
->rlq
== DDF_RAID1_MULTI
)
673 return err_bad_ddf_layout(conf
);
674 raiddisks
*= conf
->sec_elmnt_count
;
681 level
= LEVEL_LINEAR
;
684 if (conf
->rlq
!= DDF_RAID0_SIMPLE
)
685 return err_bad_ddf_layout(conf
);
689 if (!((conf
->rlq
== DDF_RAID1_SIMPLE
&& raiddisks
== 2) ||
690 (conf
->rlq
== DDF_RAID1_MULTI
&& raiddisks
== 3)))
691 return err_bad_ddf_layout(conf
);
695 if (conf
->rlq
!= DDF_RAID4_N
)
696 return err_bad_ddf_layout(conf
);
701 case DDF_RAID5_N_RESTART
:
702 layout
= ALGORITHM_LEFT_ASYMMETRIC
;
704 case DDF_RAID5_0_RESTART
:
705 layout
= ALGORITHM_RIGHT_ASYMMETRIC
;
707 case DDF_RAID5_N_CONTINUE
:
708 layout
= ALGORITHM_LEFT_SYMMETRIC
;
711 return err_bad_ddf_layout(conf
);
717 case DDF_RAID5_N_RESTART
:
718 layout
= ALGORITHM_ROTATING_N_RESTART
;
720 case DDF_RAID6_0_RESTART
:
721 layout
= ALGORITHM_ROTATING_ZERO_RESTART
;
723 case DDF_RAID5_N_CONTINUE
:
724 layout
= ALGORITHM_ROTATING_N_CONTINUE
;
727 return err_bad_ddf_layout(conf
);
732 return err_bad_ddf_layout(conf
);
736 array
->level
= level
;
737 array
->layout
= layout
;
738 array
->raid_disks
= raiddisks
;
742 static int load_ddf_header(int fd
, unsigned long long lba
,
743 unsigned long long size
,
745 struct ddf_header
*hdr
, struct ddf_header
*anchor
)
747 /* read a ddf header (primary or secondary) from fd/lba
748 * and check that it is consistent with anchor
750 * magic, crc, guid, rev, and LBA's header_type, and
751 * everything after header_type must be the same
756 if (lseek64(fd
, lba
<<9, 0) < 0)
759 if (read(fd
, hdr
, 512) != 512)
762 if (!be32_eq(hdr
->magic
, DDF_HEADER_MAGIC
)) {
763 pr_err("%s: bad header magic\n", __func__
);
766 if (!be32_eq(calc_crc(hdr
, 512), hdr
->crc
)) {
767 pr_err("%s: bad CRC\n", __func__
);
770 if (memcmp(anchor
->guid
, hdr
->guid
, DDF_GUID_LEN
) != 0 ||
771 memcmp(anchor
->revision
, hdr
->revision
, 8) != 0 ||
772 !be64_eq(anchor
->primary_lba
, hdr
->primary_lba
) ||
773 !be64_eq(anchor
->secondary_lba
, hdr
->secondary_lba
) ||
775 memcmp(anchor
->pad2
, hdr
->pad2
, 512 -
776 offsetof(struct ddf_header
, pad2
)) != 0) {
777 pr_err("%s: header mismatch\n", __func__
);
781 /* Looks good enough to me... */
785 static void *load_section(int fd
, struct ddf_super
*super
, void *buf
,
786 be32 offset_be
, be32 len_be
, int check
)
788 unsigned long long offset
= be32_to_cpu(offset_be
);
789 unsigned long long len
= be32_to_cpu(len_be
);
790 int dofree
= (buf
== NULL
);
793 if (len
!= 2 && len
!= 8 && len
!= 32
794 && len
!= 128 && len
!= 512)
799 if (!buf
&& posix_memalign(&buf
, 512, len
<<9) != 0)
805 if (super
->active
->type
== 1)
806 offset
+= be64_to_cpu(super
->active
->primary_lba
);
808 offset
+= be64_to_cpu(super
->active
->secondary_lba
);
810 if ((unsigned long long)lseek64(fd
, offset
<<9, 0) != (offset
<<9)) {
815 if ((unsigned long long)read(fd
, buf
, len
<<9) != (len
<<9)) {
823 static int load_ddf_headers(int fd
, struct ddf_super
*super
, char *devname
)
825 unsigned long long dsize
;
827 get_dev_size(fd
, NULL
, &dsize
);
829 if (lseek64(fd
, dsize
-512, 0) < 0) {
831 pr_err("Cannot seek to anchor block on %s: %s\n",
832 devname
, strerror(errno
));
835 if (read(fd
, &super
->anchor
, 512) != 512) {
837 pr_err("Cannot read anchor block on %s: %s\n",
838 devname
, strerror(errno
));
841 if (!be32_eq(super
->anchor
.magic
, DDF_HEADER_MAGIC
)) {
843 pr_err("no DDF anchor found on %s\n",
847 if (!be32_eq(calc_crc(&super
->anchor
, 512), super
->anchor
.crc
)) {
849 pr_err("bad CRC on anchor on %s\n",
853 if (memcmp(super
->anchor
.revision
, DDF_REVISION_0
, 8) != 0 &&
854 memcmp(super
->anchor
.revision
, DDF_REVISION_2
, 8) != 0) {
856 pr_err("can only support super revision"
857 " %.8s and earlier, not %.8s on %s\n",
858 DDF_REVISION_2
, super
->anchor
.revision
,devname
);
861 super
->active
= NULL
;
862 if (load_ddf_header(fd
, be64_to_cpu(super
->anchor
.primary_lba
),
864 &super
->primary
, &super
->anchor
) == 0) {
866 pr_err("Failed to load primary DDF header "
869 super
->active
= &super
->primary
;
871 if (load_ddf_header(fd
, be64_to_cpu(super
->anchor
.secondary_lba
),
873 &super
->secondary
, &super
->anchor
)) {
874 if (super
->active
== NULL
875 || (be32_to_cpu(super
->primary
.seq
)
876 < be32_to_cpu(super
->secondary
.seq
) &&
877 !super
->secondary
.openflag
)
878 || (be32_to_cpu(super
->primary
.seq
)
879 == be32_to_cpu(super
->secondary
.seq
) &&
880 super
->primary
.openflag
&& !super
->secondary
.openflag
)
882 super
->active
= &super
->secondary
;
883 } else if (devname
&&
884 be64_to_cpu(super
->anchor
.secondary_lba
) != ~(__u64
)0)
885 pr_err("Failed to load secondary DDF header on %s\n",
887 if (super
->active
== NULL
)
892 static int load_ddf_global(int fd
, struct ddf_super
*super
, char *devname
)
895 ok
= load_section(fd
, super
, &super
->controller
,
896 super
->active
->controller_section_offset
,
897 super
->active
->controller_section_length
,
899 super
->phys
= load_section(fd
, super
, NULL
,
900 super
->active
->phys_section_offset
,
901 super
->active
->phys_section_length
,
903 super
->pdsize
= be32_to_cpu(super
->active
->phys_section_length
) * 512;
905 super
->virt
= load_section(fd
, super
, NULL
,
906 super
->active
->virt_section_offset
,
907 super
->active
->virt_section_length
,
909 super
->vdsize
= be32_to_cpu(super
->active
->virt_section_length
) * 512;
919 super
->conflist
= NULL
;
922 super
->max_part
= be16_to_cpu(super
->active
->max_partitions
);
923 super
->mppe
= be16_to_cpu(super
->active
->max_primary_element_entries
);
924 super
->conf_rec_len
= be16_to_cpu(super
->active
->config_record_len
);
928 #define DDF_UNUSED_BVD 0xff
929 static int alloc_other_bvds(const struct ddf_super
*ddf
, struct vcl
*vcl
)
931 unsigned int n_vds
= vcl
->conf
.sec_elmnt_count
- 1;
932 unsigned int i
, vdsize
;
935 vcl
->other_bvds
= NULL
;
938 vdsize
= ddf
->conf_rec_len
* 512;
939 if (posix_memalign(&p
, 512, n_vds
*
940 (vdsize
+ sizeof(struct vd_config
*))) != 0)
942 vcl
->other_bvds
= (struct vd_config
**) (p
+ n_vds
* vdsize
);
943 for (i
= 0; i
< n_vds
; i
++) {
944 vcl
->other_bvds
[i
] = p
+ i
* vdsize
;
945 memset(vcl
->other_bvds
[i
], 0, vdsize
);
946 vcl
->other_bvds
[i
]->sec_elmnt_seq
= DDF_UNUSED_BVD
;
951 static void add_other_bvd(struct vcl
*vcl
, struct vd_config
*vd
,
955 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
956 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== vd
->sec_elmnt_seq
)
959 if (i
< vcl
->conf
.sec_elmnt_count
-1) {
960 if (be32_to_cpu(vd
->seqnum
) <=
961 be32_to_cpu(vcl
->other_bvds
[i
]->seqnum
))
964 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
965 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== DDF_UNUSED_BVD
)
967 if (i
== vcl
->conf
.sec_elmnt_count
-1) {
968 pr_err("no space for sec level config %u, count is %u\n",
969 vd
->sec_elmnt_seq
, vcl
->conf
.sec_elmnt_count
);
973 memcpy(vcl
->other_bvds
[i
], vd
, len
);
976 static int load_ddf_local(int fd
, struct ddf_super
*super
,
977 char *devname
, int keep
)
983 unsigned int confsec
;
985 unsigned int max_virt_disks
= be16_to_cpu
986 (super
->active
->max_vd_entries
);
987 unsigned long long dsize
;
989 /* First the local disk info */
990 if (posix_memalign((void**)&dl
, 512,
992 (super
->max_part
) * sizeof(dl
->vlist
[0])) != 0) {
993 pr_err("%s could not allocate disk info buffer\n",
998 load_section(fd
, super
, &dl
->disk
,
999 super
->active
->data_section_offset
,
1000 super
->active
->data_section_length
,
1002 dl
->devname
= devname
? xstrdup(devname
) : NULL
;
1005 dl
->major
= major(stb
.st_rdev
);
1006 dl
->minor
= minor(stb
.st_rdev
);
1007 dl
->next
= super
->dlist
;
1008 dl
->fd
= keep
? fd
: -1;
1011 if (get_dev_size(fd
, devname
, &dsize
))
1012 dl
->size
= dsize
>> 9;
1013 /* If the disks have different sizes, the LBAs will differ
1014 * between phys disks.
1015 * At this point here, the values in super->active must be valid
1016 * for this phys disk. */
1017 dl
->primary_lba
= super
->active
->primary_lba
;
1018 dl
->secondary_lba
= super
->active
->secondary_lba
;
1019 dl
->workspace_lba
= super
->active
->workspace_lba
;
1021 for (i
= 0 ; i
< super
->max_part
; i
++)
1022 dl
->vlist
[i
] = NULL
;
1025 for (i
= 0; i
< be16_to_cpu(super
->active
->max_pd_entries
); i
++)
1026 if (memcmp(super
->phys
->entries
[i
].guid
,
1027 dl
->disk
.guid
, DDF_GUID_LEN
) == 0)
1030 /* Now the config list. */
1031 /* 'conf' is an array of config entries, some of which are
1032 * probably invalid. Those which are good need to be copied into
1036 conf
= load_section(fd
, super
, super
->conf
,
1037 super
->active
->config_section_offset
,
1038 super
->active
->config_section_length
,
1043 confsec
< be32_to_cpu(super
->active
->config_section_length
);
1044 confsec
+= super
->conf_rec_len
) {
1045 struct vd_config
*vd
=
1046 (struct vd_config
*)((char*)conf
+ confsec
*512);
1049 if (be32_eq(vd
->magic
, DDF_SPARE_ASSIGN_MAGIC
)) {
1052 if (posix_memalign((void**)&dl
->spare
, 512,
1053 super
->conf_rec_len
*512) != 0) {
1054 pr_err("%s could not allocate spare info buf\n",
1059 memcpy(dl
->spare
, vd
, super
->conf_rec_len
*512);
1062 if (!be32_eq(vd
->magic
, DDF_VD_CONF_MAGIC
))
1064 for (vcl
= super
->conflist
; vcl
; vcl
= vcl
->next
) {
1065 if (memcmp(vcl
->conf
.guid
,
1066 vd
->guid
, DDF_GUID_LEN
) == 0)
1071 dl
->vlist
[vnum
++] = vcl
;
1072 if (vcl
->other_bvds
!= NULL
&&
1073 vcl
->conf
.sec_elmnt_seq
!= vd
->sec_elmnt_seq
) {
1074 add_other_bvd(vcl
, vd
, super
->conf_rec_len
*512);
1077 if (be32_to_cpu(vd
->seqnum
) <=
1078 be32_to_cpu(vcl
->conf
.seqnum
))
1081 if (posix_memalign((void**)&vcl
, 512,
1082 (super
->conf_rec_len
*512 +
1083 offsetof(struct vcl
, conf
))) != 0) {
1084 pr_err("%s could not allocate vcl buf\n",
1088 vcl
->next
= super
->conflist
;
1089 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
1090 vcl
->conf
.sec_elmnt_count
= vd
->sec_elmnt_count
;
1091 if (alloc_other_bvds(super
, vcl
) != 0) {
1092 pr_err("%s could not allocate other bvds\n",
1097 super
->conflist
= vcl
;
1098 dl
->vlist
[vnum
++] = vcl
;
1100 memcpy(&vcl
->conf
, vd
, super
->conf_rec_len
*512);
1101 for (i
=0; i
< max_virt_disks
; i
++)
1102 if (memcmp(super
->virt
->entries
[i
].guid
,
1103 vcl
->conf
.guid
, DDF_GUID_LEN
)==0)
1105 if (i
< max_virt_disks
)
1113 static int load_super_ddf_all(struct supertype
*st
, int fd
,
1114 void **sbp
, char *devname
);
1117 static void free_super_ddf(struct supertype
*st
);
1119 static int load_super_ddf(struct supertype
*st
, int fd
,
1122 unsigned long long dsize
;
1123 struct ddf_super
*super
;
1126 if (get_dev_size(fd
, devname
, &dsize
) == 0)
1129 if (test_partition(fd
))
1130 /* DDF is not allowed on partitions */
1133 /* 32M is a lower bound */
1134 if (dsize
<= 32*1024*1024) {
1136 pr_err("%s is too small for ddf: "
1137 "size is %llu sectors.\n",
1143 pr_err("%s is an odd size for ddf: "
1144 "size is %llu bytes.\n",
1151 if (posix_memalign((void**)&super
, 512, sizeof(*super
))!= 0) {
1152 pr_err("malloc of %zu failed.\n",
1156 memset(super
, 0, sizeof(*super
));
1158 rv
= load_ddf_headers(fd
, super
, devname
);
1164 /* Have valid headers and have chosen the best. Let's read in the rest*/
1166 rv
= load_ddf_global(fd
, super
, devname
);
1170 pr_err("Failed to load all information "
1171 "sections on %s\n", devname
);
1176 rv
= load_ddf_local(fd
, super
, devname
, 0);
1180 pr_err("Failed to load all information "
1181 "sections on %s\n", devname
);
1186 /* Should possibly check the sections .... */
1189 if (st
->ss
== NULL
) {
1190 st
->ss
= &super_ddf
;
1191 st
->minor_version
= 0;
1198 static void free_super_ddf(struct supertype
*st
)
1200 struct ddf_super
*ddf
= st
->sb
;
1206 while (ddf
->conflist
) {
1207 struct vcl
*v
= ddf
->conflist
;
1208 ddf
->conflist
= v
->next
;
1210 free(v
->block_sizes
);
1213 v->other_bvds[0] points to beginning of buffer,
1214 see alloc_other_bvds()
1216 free(v
->other_bvds
[0]);
1219 while (ddf
->dlist
) {
1220 struct dl
*d
= ddf
->dlist
;
1221 ddf
->dlist
= d
->next
;
1228 while (ddf
->add_list
) {
1229 struct dl
*d
= ddf
->add_list
;
1230 ddf
->add_list
= d
->next
;
1241 static struct supertype
*match_metadata_desc_ddf(char *arg
)
1243 /* 'ddf' only support containers */
1244 struct supertype
*st
;
1245 if (strcmp(arg
, "ddf") != 0 &&
1246 strcmp(arg
, "default") != 0
1250 st
= xcalloc(1, sizeof(*st
));
1251 st
->ss
= &super_ddf
;
1253 st
->minor_version
= 0;
1260 static mapping_t ddf_state
[] = {
1266 { "Partially Optimal", 5},
1272 static mapping_t ddf_init_state
[] = {
1273 { "Not Initialised", 0},
1274 { "QuickInit in Progress", 1},
1275 { "Fully Initialised", 2},
1279 static mapping_t ddf_access
[] = {
1283 { "Blocked (no access)", 3},
1287 static mapping_t ddf_level
[] = {
1288 { "RAID0", DDF_RAID0
},
1289 { "RAID1", DDF_RAID1
},
1290 { "RAID3", DDF_RAID3
},
1291 { "RAID4", DDF_RAID4
},
1292 { "RAID5", DDF_RAID5
},
1293 { "RAID1E",DDF_RAID1E
},
1294 { "JBOD", DDF_JBOD
},
1295 { "CONCAT",DDF_CONCAT
},
1296 { "RAID5E",DDF_RAID5E
},
1297 { "RAID5EE",DDF_RAID5EE
},
1298 { "RAID6", DDF_RAID6
},
1301 static mapping_t ddf_sec_level
[] = {
1302 { "Striped", DDF_2STRIPED
},
1303 { "Mirrored", DDF_2MIRRORED
},
1304 { "Concat", DDF_2CONCAT
},
1305 { "Spanned", DDF_2SPANNED
},
1310 static int all_ff(const char *guid
)
1313 for (i
= 0; i
< DDF_GUID_LEN
; i
++)
1314 if (guid
[i
] != (char)0xff)
1319 static const char *guid_str(const char *guid
)
1321 static char buf
[DDF_GUID_LEN
*2+1];
1324 for (i
= 0; i
< DDF_GUID_LEN
; i
++) {
1325 unsigned char c
= guid
[i
];
1326 if (c
>= 32 && c
< 127)
1327 p
+= sprintf(p
, "%c", c
);
1329 p
+= sprintf(p
, "%02x", c
);
1332 return (const char *) buf
;
1336 static void print_guid(char *guid
, int tstamp
)
1338 /* A GUIDs are part (or all) ASCII and part binary.
1339 * They tend to be space padded.
1340 * We print the GUID in HEX, then in parentheses add
1341 * any initial ASCII sequence, and a possible
1342 * time stamp from bytes 16-19
1344 int l
= DDF_GUID_LEN
;
1347 for (i
=0 ; i
<DDF_GUID_LEN
; i
++) {
1348 if ((i
&3)==0 && i
!= 0) printf(":");
1349 printf("%02X", guid
[i
]&255);
1353 while (l
&& guid
[l
-1] == ' ')
1355 for (i
=0 ; i
<l
; i
++) {
1356 if (guid
[i
] >= 0x20 && guid
[i
] < 0x7f)
1357 fputc(guid
[i
], stdout
);
1362 time_t then
= __be32_to_cpu(*(__u32
*)(guid
+16)) + DECADE
;
1365 tm
= localtime(&then
);
1366 strftime(tbuf
, 100, " %D %T",tm
);
1367 fputs(tbuf
, stdout
);
1372 static void examine_vd(int n
, struct ddf_super
*sb
, char *guid
)
1374 int crl
= sb
->conf_rec_len
;
1377 for (vcl
= sb
->conflist
; vcl
; vcl
= vcl
->next
) {
1379 struct vd_config
*vc
= &vcl
->conf
;
1381 if (!be32_eq(calc_crc(vc
, crl
*512), vc
->crc
))
1383 if (memcmp(vc
->guid
, guid
, DDF_GUID_LEN
) != 0)
1386 /* Ok, we know about this VD, let's give more details */
1387 printf(" Raid Devices[%d] : %d (", n
,
1388 be16_to_cpu(vc
->prim_elmnt_count
));
1389 for (i
= 0; i
< be16_to_cpu(vc
->prim_elmnt_count
); i
++) {
1391 int cnt
= be16_to_cpu(sb
->phys
->used_pdes
);
1392 for (j
=0; j
<cnt
; j
++)
1393 if (be32_eq(vc
->phys_refnum
[i
],
1394 sb
->phys
->entries
[j
].refnum
))
1403 if (vc
->chunk_shift
!= 255)
1404 printf(" Chunk Size[%d] : %d sectors\n", n
,
1405 1 << vc
->chunk_shift
);
1406 printf(" Raid Level[%d] : %s\n", n
,
1407 map_num(ddf_level
, vc
->prl
)?:"-unknown-");
1408 if (vc
->sec_elmnt_count
!= 1) {
1409 printf(" Secondary Position[%d] : %d of %d\n", n
,
1410 vc
->sec_elmnt_seq
, vc
->sec_elmnt_count
);
1411 printf(" Secondary Level[%d] : %s\n", n
,
1412 map_num(ddf_sec_level
, vc
->srl
) ?: "-unknown-");
1414 printf(" Device Size[%d] : %llu\n", n
,
1415 be64_to_cpu(vc
->blocks
)/2);
1416 printf(" Array Size[%d] : %llu\n", n
,
1417 be64_to_cpu(vc
->array_blocks
)/2);
1421 static void examine_vds(struct ddf_super
*sb
)
1423 int cnt
= be16_to_cpu(sb
->virt
->populated_vdes
);
1425 printf(" Virtual Disks : %d\n", cnt
);
1427 for (i
= 0; i
< be16_to_cpu(sb
->virt
->max_vdes
); i
++) {
1428 struct virtual_entry
*ve
= &sb
->virt
->entries
[i
];
1429 if (all_ff(ve
->guid
))
1432 printf(" VD GUID[%d] : ", i
); print_guid(ve
->guid
, 1);
1434 printf(" unit[%d] : %d\n", i
, be16_to_cpu(ve
->unit
));
1435 printf(" state[%d] : %s, %s%s\n", i
,
1436 map_num(ddf_state
, ve
->state
& 7),
1437 (ve
->state
& DDF_state_morphing
) ? "Morphing, ": "",
1438 (ve
->state
& DDF_state_inconsistent
)? "Not Consistent" : "Consistent");
1439 printf(" init state[%d] : %s\n", i
,
1440 map_num(ddf_init_state
, ve
->init_state
&DDF_initstate_mask
));
1441 printf(" access[%d] : %s\n", i
,
1442 map_num(ddf_access
, (ve
->init_state
& DDF_access_mask
) >> 6));
1443 printf(" Name[%d] : %.16s\n", i
, ve
->name
);
1444 examine_vd(i
, sb
, ve
->guid
);
1446 if (cnt
) printf("\n");
1449 static void examine_pds(struct ddf_super
*sb
)
1451 int cnt
= be16_to_cpu(sb
->phys
->used_pdes
);
1454 printf(" Physical Disks : %d\n", cnt
);
1455 printf(" Number RefNo Size Device Type/State\n");
1457 for (i
=0 ; i
<cnt
; i
++) {
1458 struct phys_disk_entry
*pd
= &sb
->phys
->entries
[i
];
1459 int type
= be16_to_cpu(pd
->type
);
1460 int state
= be16_to_cpu(pd
->state
);
1462 //printf(" PD GUID[%d] : ", i); print_guid(pd->guid, 0);
1464 printf(" %3d %08x ", i
,
1465 be32_to_cpu(pd
->refnum
));
1467 be64_to_cpu(pd
->config_size
)>>1);
1468 for (dl
= sb
->dlist
; dl
; dl
= dl
->next
) {
1469 if (be32_eq(dl
->disk
.refnum
, pd
->refnum
)) {
1470 char *dv
= map_dev(dl
->major
, dl
->minor
, 0);
1472 printf("%-15s", dv
);
1479 printf(" %s%s%s%s%s",
1480 (type
&2) ? "active":"",
1481 (type
&4) ? "Global-Spare":"",
1482 (type
&8) ? "spare" : "",
1483 (type
&16)? ", foreign" : "",
1484 (type
&32)? "pass-through" : "");
1485 if (state
& DDF_Failed
)
1486 /* This over-rides these three */
1487 state
&= ~(DDF_Online
|DDF_Rebuilding
|DDF_Transition
);
1488 printf("/%s%s%s%s%s%s%s",
1489 (state
&1)? "Online": "Offline",
1490 (state
&2)? ", Failed": "",
1491 (state
&4)? ", Rebuilding": "",
1492 (state
&8)? ", in-transition": "",
1493 (state
&16)? ", SMART-errors": "",
1494 (state
&32)? ", Unrecovered-Read-Errors": "",
1495 (state
&64)? ", Missing" : "");
1500 static void examine_super_ddf(struct supertype
*st
, char *homehost
)
1502 struct ddf_super
*sb
= st
->sb
;
1504 printf(" Magic : %08x\n", be32_to_cpu(sb
->anchor
.magic
));
1505 printf(" Version : %.8s\n", sb
->anchor
.revision
);
1506 printf("Controller GUID : "); print_guid(sb
->controller
.guid
, 0);
1508 printf(" Container GUID : "); print_guid(sb
->anchor
.guid
, 1);
1510 printf(" Seq : %08x\n", be32_to_cpu(sb
->active
->seq
));
1511 printf(" Redundant hdr : %s\n", be32_eq(sb
->secondary
.magic
,
1518 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1520 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4]);
1521 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4]);
1522 static void _ddf_array_name(char *name
, const struct ddf_super
*ddf
, int i
);
1524 static unsigned int get_vd_num_of_subarray(struct supertype
*st
)
1527 * Figure out the VD number for this supertype.
1528 * Returns DDF_CONTAINER for the container itself,
1529 * and DDF_NOTFOUND on error.
1531 struct ddf_super
*ddf
= st
->sb
;
1536 if (*st
->container_devnm
== '\0')
1537 return DDF_CONTAINER
;
1539 sra
= sysfs_read(-1, st
->devnm
, GET_VERSION
);
1540 if (!sra
|| sra
->array
.major_version
!= -1 ||
1541 sra
->array
.minor_version
!= -2 ||
1542 !is_subarray(sra
->text_version
))
1543 return DDF_NOTFOUND
;
1545 sub
= strchr(sra
->text_version
+ 1, '/');
1547 vcnum
= strtoul(sub
+ 1, &end
, 10);
1548 if (sub
== NULL
|| *sub
== '\0' || *end
!= '\0' ||
1549 vcnum
>= be16_to_cpu(ddf
->active
->max_vd_entries
))
1550 return DDF_NOTFOUND
;
1555 static void brief_examine_super_ddf(struct supertype
*st
, int verbose
)
1557 /* We just write a generic DDF ARRAY entry
1561 getinfo_super_ddf(st
, &info
, NULL
);
1562 fname_from_uuid(st
, &info
, nbuf
, ':');
1564 printf("ARRAY metadata=ddf UUID=%s\n", nbuf
+ 5);
1567 static void brief_examine_subarrays_ddf(struct supertype
*st
, int verbose
)
1569 /* We just write a generic DDF ARRAY entry
1571 struct ddf_super
*ddf
= st
->sb
;
1575 getinfo_super_ddf(st
, &info
, NULL
);
1576 fname_from_uuid(st
, &info
, nbuf
, ':');
1578 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
1579 struct virtual_entry
*ve
= &ddf
->virt
->entries
[i
];
1583 if (all_ff(ve
->guid
))
1585 memcpy(vcl
.conf
.guid
, ve
->guid
, DDF_GUID_LEN
);
1586 ddf
->currentconf
=&vcl
;
1588 uuid_from_super_ddf(st
, info
.uuid
);
1589 fname_from_uuid(st
, &info
, nbuf1
, ':');
1590 _ddf_array_name(namebuf
, ddf
, i
);
1591 printf("ARRAY%s%s container=%s member=%d UUID=%s\n",
1592 namebuf
[0] == '\0' ? "" : " /dev/md/", namebuf
,
1593 nbuf
+5, i
, nbuf1
+5);
1597 static void export_examine_super_ddf(struct supertype
*st
)
1601 getinfo_super_ddf(st
, &info
, NULL
);
1602 fname_from_uuid(st
, &info
, nbuf
, ':');
1603 printf("MD_METADATA=ddf\n");
1604 printf("MD_LEVEL=container\n");
1605 printf("MD_UUID=%s\n", nbuf
+5);
1606 printf("MD_DEVICES=%u\n",
1607 be16_to_cpu(((struct ddf_super
*)st
->sb
)->phys
->used_pdes
));
1610 static int copy_metadata_ddf(struct supertype
*st
, int from
, int to
)
1613 unsigned long long dsize
, offset
;
1615 struct ddf_header
*ddf
;
1618 /* The meta consists of an anchor, a primary, and a secondary.
1619 * This all lives at the end of the device.
1620 * So it is easiest to find the earliest of primary and
1621 * secondary, and copy everything from there.
1623 * Anchor is 512 from end It contains primary_lba and secondary_lba
1624 * we choose one of those
1627 if (posix_memalign(&buf
, 4096, 4096) != 0)
1630 if (!get_dev_size(from
, NULL
, &dsize
))
1633 if (lseek64(from
, dsize
-512, 0) < 0)
1635 if (read(from
, buf
, 512) != 512)
1638 if (!be32_eq(ddf
->magic
, DDF_HEADER_MAGIC
) ||
1639 !be32_eq(calc_crc(ddf
, 512), ddf
->crc
) ||
1640 (memcmp(ddf
->revision
, DDF_REVISION_0
, 8) != 0 &&
1641 memcmp(ddf
->revision
, DDF_REVISION_2
, 8) != 0))
1644 offset
= dsize
- 512;
1645 if ((be64_to_cpu(ddf
->primary_lba
) << 9) < offset
)
1646 offset
= be64_to_cpu(ddf
->primary_lba
) << 9;
1647 if ((be64_to_cpu(ddf
->secondary_lba
) << 9) < offset
)
1648 offset
= be64_to_cpu(ddf
->secondary_lba
) << 9;
1650 bytes
= dsize
- offset
;
1652 if (lseek64(from
, offset
, 0) < 0 ||
1653 lseek64(to
, offset
, 0) < 0)
1655 while (written
< bytes
) {
1656 int n
= bytes
- written
;
1659 if (read(from
, buf
, n
) != n
)
1661 if (write(to
, buf
, n
) != n
)
1672 static void detail_super_ddf(struct supertype
*st
, char *homehost
)
1675 * Could print DDF GUID
1676 * Need to find which array
1677 * If whole, briefly list all arrays
1682 static const char *vendors_with_variable_volume_UUID
[] = {
1686 static int volume_id_is_reliable(const struct ddf_super
*ddf
)
1688 int n
= ARRAY_SIZE(vendors_with_variable_volume_UUID
);
1690 for (i
= 0; i
< n
; i
++)
1691 if (!memcmp(ddf
->controller
.guid
,
1692 vendors_with_variable_volume_UUID
[i
], 8))
1697 static void uuid_of_ddf_subarray(const struct ddf_super
*ddf
,
1698 unsigned int vcnum
, int uuid
[4])
1700 char buf
[DDF_GUID_LEN
+18], sha
[20], *p
;
1701 struct sha1_ctx ctx
;
1702 if (volume_id_is_reliable(ddf
)) {
1703 uuid_from_ddf_guid(ddf
->virt
->entries
[vcnum
].guid
, uuid
);
1707 * Some fake RAID BIOSes (in particular, LSI ones) change the
1708 * VD GUID at every boot. These GUIDs are not suitable for
1709 * identifying an array. Luckily the header GUID appears to
1711 * We construct a pseudo-UUID from the header GUID and those
1712 * properties of the subarray that we expect to remain constant.
1714 memset(buf
, 0, sizeof(buf
));
1716 memcpy(p
, ddf
->anchor
.guid
, DDF_GUID_LEN
);
1718 memcpy(p
, ddf
->virt
->entries
[vcnum
].name
, 16);
1720 *((__u16
*) p
) = vcnum
;
1721 sha1_init_ctx(&ctx
);
1722 sha1_process_bytes(buf
, sizeof(buf
), &ctx
);
1723 sha1_finish_ctx(&ctx
, sha
);
1724 memcpy(uuid
, sha
, 4*4);
1727 static void brief_detail_super_ddf(struct supertype
*st
)
1731 struct ddf_super
*ddf
= st
->sb
;
1732 unsigned int vcnum
= get_vd_num_of_subarray(st
);
1733 if (vcnum
== DDF_CONTAINER
)
1734 uuid_from_super_ddf(st
, info
.uuid
);
1735 else if (vcnum
== DDF_NOTFOUND
)
1738 uuid_of_ddf_subarray(ddf
, vcnum
, info
.uuid
);
1739 fname_from_uuid(st
, &info
, nbuf
,':');
1740 printf(" UUID=%s", nbuf
+ 5);
1744 static int match_home_ddf(struct supertype
*st
, char *homehost
)
1746 /* It matches 'this' host if the controller is a
1747 * Linux-MD controller with vendor_data matching
1750 struct ddf_super
*ddf
= st
->sb
;
1755 len
= strlen(homehost
);
1757 return (memcmp(ddf
->controller
.guid
, T10
, 8) == 0 &&
1758 len
< sizeof(ddf
->controller
.vendor_data
) &&
1759 memcmp(ddf
->controller
.vendor_data
, homehost
,len
) == 0 &&
1760 ddf
->controller
.vendor_data
[len
] == 0);
1764 static int find_index_in_bvd(const struct ddf_super
*ddf
,
1765 const struct vd_config
*conf
, unsigned int n
,
1766 unsigned int *n_bvd
)
1769 * Find the index of the n-th valid physical disk in this BVD
1772 for (i
= 0, j
= 0; i
< ddf
->mppe
&&
1773 j
< be16_to_cpu(conf
->prim_elmnt_count
); i
++) {
1774 if (be32_to_cpu(conf
->phys_refnum
[i
]) != 0xffffffff) {
1782 dprintf("%s: couldn't find BVD member %u (total %u)\n",
1783 __func__
, n
, be16_to_cpu(conf
->prim_elmnt_count
));
1787 static struct vd_config
*find_vdcr(struct ddf_super
*ddf
, unsigned int inst
,
1789 unsigned int *n_bvd
, struct vcl
**vcl
)
1793 for (v
= ddf
->conflist
; v
; v
= v
->next
) {
1794 unsigned int nsec
, ibvd
= 0;
1795 struct vd_config
*conf
;
1796 if (inst
!= v
->vcnum
)
1799 if (conf
->sec_elmnt_count
== 1) {
1800 if (find_index_in_bvd(ddf
, conf
, n
, n_bvd
)) {
1806 if (v
->other_bvds
== NULL
) {
1807 pr_err("%s: BUG: other_bvds is NULL, nsec=%u\n",
1808 __func__
, conf
->sec_elmnt_count
);
1811 nsec
= n
/ be16_to_cpu(conf
->prim_elmnt_count
);
1812 if (conf
->sec_elmnt_seq
!= nsec
) {
1813 for (ibvd
= 1; ibvd
< conf
->sec_elmnt_count
; ibvd
++) {
1814 if (v
->other_bvds
[ibvd
-1]->sec_elmnt_seq
1818 if (ibvd
== conf
->sec_elmnt_count
)
1820 conf
= v
->other_bvds
[ibvd
-1];
1822 if (!find_index_in_bvd(ddf
, conf
,
1823 n
- nsec
*conf
->sec_elmnt_count
, n_bvd
))
1825 dprintf("%s: found disk %u as member %u in bvd %d of array %u\n"
1826 , __func__
, n
, *n_bvd
, ibvd
, inst
);
1831 pr_err("%s: Could't find disk %d in array %u\n", __func__
, n
, inst
);
1836 static int find_phys(const struct ddf_super
*ddf
, be32 phys_refnum
)
1838 /* Find the entry in phys_disk which has the given refnum
1839 * and return it's index
1842 for (i
= 0; i
< be16_to_cpu(ddf
->phys
->max_pdes
); i
++)
1843 if (be32_eq(ddf
->phys
->entries
[i
].refnum
, phys_refnum
))
1848 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4])
1851 struct sha1_ctx ctx
;
1852 sha1_init_ctx(&ctx
);
1853 sha1_process_bytes(guid
, DDF_GUID_LEN
, &ctx
);
1854 sha1_finish_ctx(&ctx
, buf
);
1855 memcpy(uuid
, buf
, 4*4);
1858 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4])
1860 /* The uuid returned here is used for:
1861 * uuid to put into bitmap file (Create, Grow)
1862 * uuid for backup header when saving critical section (Grow)
1863 * comparing uuids when re-adding a device into an array
1864 * In these cases the uuid required is that of the data-array,
1865 * not the device-set.
1866 * uuid to recognise same set when adding a missing device back
1867 * to an array. This is a uuid for the device-set.
1869 * For each of these we can make do with a truncated
1870 * or hashed uuid rather than the original, as long as
1872 * In the case of SVD we assume the BVD is of interest,
1873 * though that might be the case if a bitmap were made for
1874 * a mirrored SVD - worry about that later.
1875 * So we need to find the VD configuration record for the
1876 * relevant BVD and extract the GUID and Secondary_Element_Seq.
1877 * The first 16 bytes of the sha1 of these is used.
1879 struct ddf_super
*ddf
= st
->sb
;
1880 struct vcl
*vcl
= ddf
->currentconf
;
1883 uuid_of_ddf_subarray(ddf
, vcl
->vcnum
, uuid
);
1885 uuid_from_ddf_guid(ddf
->anchor
.guid
, uuid
);
1888 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1890 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1892 struct ddf_super
*ddf
= st
->sb
;
1893 int map_disks
= info
->array
.raid_disks
;
1896 if (ddf
->currentconf
) {
1897 getinfo_super_ddf_bvd(st
, info
, map
);
1900 memset(info
, 0, sizeof(*info
));
1902 info
->array
.raid_disks
= be16_to_cpu(ddf
->phys
->used_pdes
);
1903 info
->array
.level
= LEVEL_CONTAINER
;
1904 info
->array
.layout
= 0;
1905 info
->array
.md_minor
= -1;
1906 cptr
= (__u32
*)(ddf
->anchor
.guid
+ 16);
1907 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1909 info
->array
.utime
= 0;
1910 info
->array
.chunk_size
= 0;
1911 info
->container_enough
= 1;
1913 info
->disk
.major
= 0;
1914 info
->disk
.minor
= 0;
1916 struct phys_disk_entry
*pde
= NULL
;
1917 info
->disk
.number
= be32_to_cpu(ddf
->dlist
->disk
.refnum
);
1918 info
->disk
.raid_disk
= find_phys(ddf
, ddf
->dlist
->disk
.refnum
);
1920 info
->data_offset
= be64_to_cpu(ddf
->phys
->
1921 entries
[info
->disk
.raid_disk
].
1923 info
->component_size
= ddf
->dlist
->size
- info
->data_offset
;
1924 if (info
->disk
.raid_disk
>= 0)
1925 pde
= ddf
->phys
->entries
+ info
->disk
.raid_disk
;
1927 !(be16_to_cpu(pde
->state
) & DDF_Failed
))
1928 info
->disk
.state
= (1 << MD_DISK_SYNC
) | (1 << MD_DISK_ACTIVE
);
1930 info
->disk
.state
= 1 << MD_DISK_FAULTY
;
1932 info
->disk
.number
= -1;
1933 info
->disk
.raid_disk
= -1;
1934 // info->disk.raid_disk = find refnum in the table and use index;
1935 info
->disk
.state
= (1 << MD_DISK_SYNC
) | (1 << MD_DISK_ACTIVE
);
1938 info
->recovery_start
= MaxSector
;
1939 info
->reshape_active
= 0;
1940 info
->recovery_blocked
= 0;
1943 info
->array
.major_version
= -1;
1944 info
->array
.minor_version
= -2;
1945 strcpy(info
->text_version
, "ddf");
1946 info
->safe_mode_delay
= 0;
1948 uuid_from_super_ddf(st
, info
->uuid
);
1952 for (i
= 0 ; i
< map_disks
; i
++) {
1953 if (i
< info
->array
.raid_disks
&&
1954 !(be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1963 /* size of name must be at least 17 bytes! */
1964 static void _ddf_array_name(char *name
, const struct ddf_super
*ddf
, int i
)
1967 memcpy(name
, ddf
->virt
->entries
[i
].name
, 16);
1969 for(j
= 0; j
< 16; j
++)
1974 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1976 struct ddf_super
*ddf
= st
->sb
;
1977 struct vcl
*vc
= ddf
->currentconf
;
1978 int cd
= ddf
->currentdev
;
1982 int map_disks
= info
->array
.raid_disks
;
1984 struct vd_config
*conf
;
1986 memset(info
, 0, sizeof(*info
));
1987 if (layout_ddf2md(&vc
->conf
, &info
->array
) == -1)
1989 info
->array
.md_minor
= -1;
1990 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
1991 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1992 info
->array
.utime
= DECADE
+ be32_to_cpu(vc
->conf
.timestamp
);
1993 info
->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
1994 info
->custom_array_size
= 0;
1997 n_prim
= be16_to_cpu(conf
->prim_elmnt_count
);
1998 if (conf
->sec_elmnt_count
> 1 && cd
>= n_prim
) {
1999 int ibvd
= cd
/ n_prim
- 1;
2001 conf
= vc
->other_bvds
[ibvd
];
2004 if (cd
>= 0 && (unsigned)cd
< ddf
->mppe
) {
2006 be64_to_cpu(LBA_OFFSET(ddf
, conf
)[cd
]);
2007 if (vc
->block_sizes
)
2008 info
->component_size
= vc
->block_sizes
[cd
];
2010 info
->component_size
= be64_to_cpu(conf
->blocks
);
2013 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2014 if (be32_eq(dl
->disk
.refnum
, conf
->phys_refnum
[cd
]))
2017 info
->disk
.major
= 0;
2018 info
->disk
.minor
= 0;
2019 info
->disk
.state
= 0;
2021 info
->disk
.major
= dl
->major
;
2022 info
->disk
.minor
= dl
->minor
;
2023 info
->disk
.raid_disk
= cd
+ conf
->sec_elmnt_seq
2024 * be16_to_cpu(conf
->prim_elmnt_count
);
2025 info
->disk
.number
= dl
->pdnum
;
2026 info
->disk
.state
= 0;
2027 if (info
->disk
.number
>= 0 &&
2028 (be16_to_cpu(ddf
->phys
->entries
[info
->disk
.number
].state
) & DDF_Online
) &&
2029 !(be16_to_cpu(ddf
->phys
->entries
[info
->disk
.number
].state
) & DDF_Failed
))
2030 info
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
2033 info
->container_member
= ddf
->currentconf
->vcnum
;
2035 info
->recovery_start
= MaxSector
;
2036 info
->resync_start
= 0;
2037 info
->reshape_active
= 0;
2038 info
->recovery_blocked
= 0;
2039 if (!(ddf
->virt
->entries
[info
->container_member
].state
2040 & DDF_state_inconsistent
) &&
2041 (ddf
->virt
->entries
[info
->container_member
].init_state
2042 & DDF_initstate_mask
)
2044 info
->resync_start
= MaxSector
;
2046 uuid_from_super_ddf(st
, info
->uuid
);
2048 info
->array
.major_version
= -1;
2049 info
->array
.minor_version
= -2;
2050 sprintf(info
->text_version
, "/%s/%d",
2051 st
->container_devnm
,
2052 info
->container_member
);
2053 info
->safe_mode_delay
= DDF_SAFE_MODE_DELAY
;
2055 _ddf_array_name(info
->name
, ddf
, info
->container_member
);
2058 for (j
= 0; j
< map_disks
; j
++) {
2060 if (j
< info
->array
.raid_disks
) {
2061 int i
= find_phys(ddf
, vc
->conf
.phys_refnum
[j
]);
2063 (be16_to_cpu(ddf
->phys
->entries
[i
].state
)
2065 !(be16_to_cpu(ddf
->phys
->entries
[i
].state
)
2072 static int update_super_ddf(struct supertype
*st
, struct mdinfo
*info
,
2074 char *devname
, int verbose
,
2075 int uuid_set
, char *homehost
)
2077 /* For 'assemble' and 'force' we need to return non-zero if any
2078 * change was made. For others, the return value is ignored.
2079 * Update options are:
2080 * force-one : This device looks a bit old but needs to be included,
2081 * update age info appropriately.
2082 * assemble: clear any 'faulty' flag to allow this device to
2084 * force-array: Array is degraded but being forced, mark it clean
2085 * if that will be needed to assemble it.
2087 * newdev: not used ????
2088 * grow: Array has gained a new device - this is currently for
2090 * resync: mark as dirty so a resync will happen.
2091 * uuid: Change the uuid of the array to match what is given
2092 * homehost: update the recorded homehost
2093 * name: update the name - preserving the homehost
2094 * _reshape_progress: record new reshape_progress position.
2096 * Following are not relevant for this version:
2097 * sparc2.2 : update from old dodgey metadata
2098 * super-minor: change the preferred_minor number
2099 * summaries: update redundant counters.
2102 // struct ddf_super *ddf = st->sb;
2103 // struct vd_config *vd = find_vdcr(ddf, info->container_member);
2104 // struct virtual_entry *ve = find_ve(ddf);
2106 /* we don't need to handle "force-*" or "assemble" as
2107 * there is no need to 'trick' the kernel. We the metadata is
2108 * first updated to activate the array, all the implied modifications
2112 if (strcmp(update
, "grow") == 0) {
2114 } else if (strcmp(update
, "resync") == 0) {
2115 // info->resync_checkpoint = 0;
2116 } else if (strcmp(update
, "homehost") == 0) {
2117 /* homehost is stored in controller->vendor_data,
2118 * or it is when we are the vendor
2120 // if (info->vendor_is_local)
2121 // strcpy(ddf->controller.vendor_data, homehost);
2123 } else if (strcmp(update
, "name") == 0) {
2124 /* name is stored in virtual_entry->name */
2125 // memset(ve->name, ' ', 16);
2126 // strncpy(ve->name, info->name, 16);
2128 } else if (strcmp(update
, "_reshape_progress") == 0) {
2129 /* We don't support reshape yet */
2130 } else if (strcmp(update
, "assemble") == 0 ) {
2131 /* Do nothing, just succeed */
2136 // update_all_csum(ddf);
2141 static void make_header_guid(char *guid
)
2144 /* Create a DDF Header of Virtual Disk GUID */
2146 /* 24 bytes of fiction required.
2147 * first 8 are a 'vendor-id' - "Linux-MD"
2148 * next 8 are controller type.. how about 0X DEAD BEEF 0000 0000
2149 * Remaining 8 random number plus timestamp
2151 memcpy(guid
, T10
, sizeof(T10
));
2152 stamp
= cpu_to_be32(0xdeadbeef);
2153 memcpy(guid
+8, &stamp
, 4);
2154 stamp
= cpu_to_be32(0);
2155 memcpy(guid
+12, &stamp
, 4);
2156 stamp
= cpu_to_be32(time(0) - DECADE
);
2157 memcpy(guid
+16, &stamp
, 4);
2158 stamp
._v32
= random32();
2159 memcpy(guid
+20, &stamp
, 4);
2162 static unsigned int find_unused_vde(const struct ddf_super
*ddf
)
2165 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2166 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2169 return DDF_NOTFOUND
;
2172 static unsigned int find_vde_by_name(const struct ddf_super
*ddf
,
2177 return DDF_NOTFOUND
;
2178 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2179 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2181 if (!strncmp(name
, ddf
->virt
->entries
[i
].name
,
2182 sizeof(ddf
->virt
->entries
[i
].name
)))
2185 return DDF_NOTFOUND
;
2189 static unsigned int find_vde_by_guid(const struct ddf_super
*ddf
,
2193 if (guid
== NULL
|| all_ff(guid
))
2194 return DDF_NOTFOUND
;
2195 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++)
2196 if (!memcmp(ddf
->virt
->entries
[i
].guid
, guid
, DDF_GUID_LEN
))
2198 return DDF_NOTFOUND
;
2202 static int init_super_ddf_bvd(struct supertype
*st
,
2203 mdu_array_info_t
*info
,
2204 unsigned long long size
,
2205 char *name
, char *homehost
,
2206 int *uuid
, unsigned long long data_offset
);
2208 static int init_super_ddf(struct supertype
*st
,
2209 mdu_array_info_t
*info
,
2210 unsigned long long size
, char *name
, char *homehost
,
2211 int *uuid
, unsigned long long data_offset
)
2213 /* This is primarily called by Create when creating a new array.
2214 * We will then get add_to_super called for each component, and then
2215 * write_init_super called to write it out to each device.
2216 * For DDF, Create can create on fresh devices or on a pre-existing
2218 * To create on a pre-existing array a different method will be called.
2219 * This one is just for fresh drives.
2221 * We need to create the entire 'ddf' structure which includes:
2222 * DDF headers - these are easy.
2223 * Controller data - a Sector describing this controller .. not that
2224 * this is a controller exactly.
2225 * Physical Disk Record - one entry per device, so
2226 * leave plenty of space.
2227 * Virtual Disk Records - again, just leave plenty of space.
2228 * This just lists VDs, doesn't give details
2229 * Config records - describes the VDs that use this disk
2230 * DiskData - describes 'this' device.
2231 * BadBlockManagement - empty
2232 * Diag Space - empty
2233 * Vendor Logs - Could we put bitmaps here?
2236 struct ddf_super
*ddf
;
2239 int max_phys_disks
, max_virt_disks
;
2240 unsigned long long sector
;
2244 struct phys_disk
*pd
;
2245 struct virtual_disk
*vd
;
2247 if (data_offset
!= INVALID_SECTORS
) {
2248 pr_err("data-offset not supported by DDF\n");
2253 return init_super_ddf_bvd(st
, info
, size
, name
, homehost
, uuid
,
2256 if (posix_memalign((void**)&ddf
, 512, sizeof(*ddf
)) != 0) {
2257 pr_err("%s could not allocate superblock\n", __func__
);
2260 memset(ddf
, 0, sizeof(*ddf
));
2261 ddf
->dlist
= NULL
; /* no physical disks yet */
2262 ddf
->conflist
= NULL
; /* No virtual disks yet */
2266 /* zeroing superblock */
2270 /* At least 32MB *must* be reserved for the ddf. So let's just
2271 * start 32MB from the end, and put the primary header there.
2272 * Don't do secondary for now.
2273 * We don't know exactly where that will be yet as it could be
2274 * different on each device. To just set up the lengths.
2278 ddf
->anchor
.magic
= DDF_HEADER_MAGIC
;
2279 make_header_guid(ddf
->anchor
.guid
);
2281 memcpy(ddf
->anchor
.revision
, DDF_REVISION_2
, 8);
2282 ddf
->anchor
.seq
= cpu_to_be32(1);
2283 ddf
->anchor
.timestamp
= cpu_to_be32(time(0) - DECADE
);
2284 ddf
->anchor
.openflag
= 0xFF;
2285 ddf
->anchor
.foreignflag
= 0;
2286 ddf
->anchor
.enforcegroups
= 0; /* Is this best?? */
2287 ddf
->anchor
.pad0
= 0xff;
2288 memset(ddf
->anchor
.pad1
, 0xff, 12);
2289 memset(ddf
->anchor
.header_ext
, 0xff, 32);
2290 ddf
->anchor
.primary_lba
= cpu_to_be64(~(__u64
)0);
2291 ddf
->anchor
.secondary_lba
= cpu_to_be64(~(__u64
)0);
2292 ddf
->anchor
.type
= DDF_HEADER_ANCHOR
;
2293 memset(ddf
->anchor
.pad2
, 0xff, 3);
2294 ddf
->anchor
.workspace_len
= cpu_to_be32(32768); /* Must be reserved */
2295 /* Put this at bottom of 32M reserved.. */
2296 ddf
->anchor
.workspace_lba
= cpu_to_be64(~(__u64
)0);
2297 max_phys_disks
= 1023; /* Should be enough */
2298 ddf
->anchor
.max_pd_entries
= cpu_to_be16(max_phys_disks
);
2299 max_virt_disks
= 255;
2300 ddf
->anchor
.max_vd_entries
= cpu_to_be16(max_virt_disks
); /* ?? */
2301 ddf
->anchor
.max_partitions
= cpu_to_be16(64); /* ?? */
2304 ddf
->conf_rec_len
= 1 + ROUND_UP(ddf
->mppe
* (4+8), 512)/512;
2305 ddf
->anchor
.config_record_len
= cpu_to_be16(ddf
->conf_rec_len
);
2306 ddf
->anchor
.max_primary_element_entries
= cpu_to_be16(ddf
->mppe
);
2307 memset(ddf
->anchor
.pad3
, 0xff, 54);
2308 /* controller sections is one sector long immediately
2309 * after the ddf header */
2311 ddf
->anchor
.controller_section_offset
= cpu_to_be32(sector
);
2312 ddf
->anchor
.controller_section_length
= cpu_to_be32(1);
2315 /* phys is 8 sectors after that */
2316 pdsize
= ROUND_UP(sizeof(struct phys_disk
) +
2317 sizeof(struct phys_disk_entry
)*max_phys_disks
,
2319 switch(pdsize
/512) {
2320 case 2: case 8: case 32: case 128: case 512: break;
2323 ddf
->anchor
.phys_section_offset
= cpu_to_be32(sector
);
2324 ddf
->anchor
.phys_section_length
=
2325 cpu_to_be32(pdsize
/512); /* max_primary_element_entries/8 */
2326 sector
+= pdsize
/512;
2328 /* virt is another 32 sectors */
2329 vdsize
= ROUND_UP(sizeof(struct virtual_disk
) +
2330 sizeof(struct virtual_entry
) * max_virt_disks
,
2332 switch(vdsize
/512) {
2333 case 2: case 8: case 32: case 128: case 512: break;
2336 ddf
->anchor
.virt_section_offset
= cpu_to_be32(sector
);
2337 ddf
->anchor
.virt_section_length
=
2338 cpu_to_be32(vdsize
/512); /* max_vd_entries/8 */
2339 sector
+= vdsize
/512;
2341 clen
= ddf
->conf_rec_len
* (ddf
->max_part
+1);
2342 ddf
->anchor
.config_section_offset
= cpu_to_be32(sector
);
2343 ddf
->anchor
.config_section_length
= cpu_to_be32(clen
);
2346 ddf
->anchor
.data_section_offset
= cpu_to_be32(sector
);
2347 ddf
->anchor
.data_section_length
= cpu_to_be32(1);
2350 ddf
->anchor
.bbm_section_length
= cpu_to_be32(0);
2351 ddf
->anchor
.bbm_section_offset
= cpu_to_be32(0xFFFFFFFF);
2352 ddf
->anchor
.diag_space_length
= cpu_to_be32(0);
2353 ddf
->anchor
.diag_space_offset
= cpu_to_be32(0xFFFFFFFF);
2354 ddf
->anchor
.vendor_length
= cpu_to_be32(0);
2355 ddf
->anchor
.vendor_offset
= cpu_to_be32(0xFFFFFFFF);
2357 memset(ddf
->anchor
.pad4
, 0xff, 256);
2359 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
2360 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
2362 ddf
->primary
.openflag
= 1; /* I guess.. */
2363 ddf
->primary
.type
= DDF_HEADER_PRIMARY
;
2365 ddf
->secondary
.openflag
= 1; /* I guess.. */
2366 ddf
->secondary
.type
= DDF_HEADER_SECONDARY
;
2368 ddf
->active
= &ddf
->primary
;
2370 ddf
->controller
.magic
= DDF_CONTROLLER_MAGIC
;
2372 /* 24 more bytes of fiction required.
2373 * first 8 are a 'vendor-id' - "Linux-MD"
2374 * Remaining 16 are serial number.... maybe a hostname would do?
2376 memcpy(ddf
->controller
.guid
, T10
, sizeof(T10
));
2377 gethostname(hostname
, sizeof(hostname
));
2378 hostname
[sizeof(hostname
) - 1] = 0;
2379 hostlen
= strlen(hostname
);
2380 memcpy(ddf
->controller
.guid
+ 24 - hostlen
, hostname
, hostlen
);
2381 for (i
= strlen(T10
) ; i
+hostlen
< 24; i
++)
2382 ddf
->controller
.guid
[i
] = ' ';
2384 ddf
->controller
.type
.vendor_id
= cpu_to_be16(0xDEAD);
2385 ddf
->controller
.type
.device_id
= cpu_to_be16(0xBEEF);
2386 ddf
->controller
.type
.sub_vendor_id
= cpu_to_be16(0);
2387 ddf
->controller
.type
.sub_device_id
= cpu_to_be16(0);
2388 memcpy(ddf
->controller
.product_id
, "What Is My PID??", 16);
2389 memset(ddf
->controller
.pad
, 0xff, 8);
2390 memset(ddf
->controller
.vendor_data
, 0xff, 448);
2391 if (homehost
&& strlen(homehost
) < 440)
2392 strcpy((char*)ddf
->controller
.vendor_data
, homehost
);
2394 if (posix_memalign((void**)&pd
, 512, pdsize
) != 0) {
2395 pr_err("%s could not allocate pd\n", __func__
);
2399 ddf
->pdsize
= pdsize
;
2401 memset(pd
, 0xff, pdsize
);
2402 memset(pd
, 0, sizeof(*pd
));
2403 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2404 pd
->used_pdes
= cpu_to_be16(0);
2405 pd
->max_pdes
= cpu_to_be16(max_phys_disks
);
2406 memset(pd
->pad
, 0xff, 52);
2407 for (i
= 0; i
< max_phys_disks
; i
++)
2408 memset(pd
->entries
[i
].guid
, 0xff, DDF_GUID_LEN
);
2410 if (posix_memalign((void**)&vd
, 512, vdsize
) != 0) {
2411 pr_err("%s could not allocate vd\n", __func__
);
2415 ddf
->vdsize
= vdsize
;
2416 memset(vd
, 0, vdsize
);
2417 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
2418 vd
->populated_vdes
= cpu_to_be16(0);
2419 vd
->max_vdes
= cpu_to_be16(max_virt_disks
);
2420 memset(vd
->pad
, 0xff, 52);
2422 for (i
=0; i
<max_virt_disks
; i
++)
2423 memset(&vd
->entries
[i
], 0xff, sizeof(struct virtual_entry
));
2426 ddf_set_updates_pending(ddf
);
2430 static int chunk_to_shift(int chunksize
)
2432 return ffs(chunksize
/512)-1;
2437 unsigned long long start
, size
;
2439 static int cmp_extent(const void *av
, const void *bv
)
2441 const struct extent
*a
= av
;
2442 const struct extent
*b
= bv
;
2443 if (a
->start
< b
->start
)
2445 if (a
->start
> b
->start
)
2450 static struct extent
*get_extents(struct ddf_super
*ddf
, struct dl
*dl
)
2452 /* find a list of used extents on the give physical device
2453 * (dnum) of the given ddf.
2454 * Return a malloced array of 'struct extent'
2456 * FIXME ignore DDF_Legacy devices?
2462 __u16 state
= be16_to_cpu(ddf
->phys
->entries
[dl
->pdnum
].state
);
2464 if ((state
& (DDF_Online
|DDF_Failed
|DDF_Missing
)) != DDF_Online
)
2467 rv
= xmalloc(sizeof(struct extent
) * (ddf
->max_part
+ 2));
2469 for (i
= 0; i
< ddf
->max_part
; i
++) {
2470 const struct vd_config
*bvd
;
2472 struct vcl
*v
= dl
->vlist
[i
];
2474 get_pd_index_from_refnum(v
, dl
->disk
.refnum
, ddf
->mppe
,
2475 &bvd
, &ibvd
) == DDF_NOTFOUND
)
2477 rv
[n
].start
= be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[ibvd
]);
2478 rv
[n
].size
= be64_to_cpu(bvd
->blocks
);
2481 qsort(rv
, n
, sizeof(*rv
), cmp_extent
);
2483 rv
[n
].start
= be64_to_cpu(ddf
->phys
->entries
[dl
->pdnum
].config_size
);
2489 static int init_super_ddf_bvd(struct supertype
*st
,
2490 mdu_array_info_t
*info
,
2491 unsigned long long size
,
2492 char *name
, char *homehost
,
2493 int *uuid
, unsigned long long data_offset
)
2495 /* We are creating a BVD inside a pre-existing container.
2496 * so st->sb is already set.
2497 * We need to create a new vd_config and a new virtual_entry
2499 struct ddf_super
*ddf
= st
->sb
;
2500 unsigned int venum
, i
;
2501 struct virtual_entry
*ve
;
2503 struct vd_config
*vc
;
2505 if (find_vde_by_name(ddf
, name
) != DDF_NOTFOUND
) {
2506 pr_err("This ddf already has an array called %s\n", name
);
2509 venum
= find_unused_vde(ddf
);
2510 if (venum
== DDF_NOTFOUND
) {
2511 pr_err("Cannot find spare slot for virtual disk\n");
2514 ve
= &ddf
->virt
->entries
[venum
];
2516 /* A Virtual Disk GUID contains the T10 Vendor ID, controller type,
2517 * timestamp, random number
2519 make_header_guid(ve
->guid
);
2520 ve
->unit
= cpu_to_be16(info
->md_minor
);
2522 ve
->guid_crc
._v16
= crc32(0, (unsigned char *)ddf
->anchor
.guid
,
2524 ve
->type
= cpu_to_be16(0);
2525 ve
->state
= DDF_state_degraded
; /* Will be modified as devices are added */
2526 if (info
->state
& 1) /* clean */
2527 ve
->init_state
= DDF_init_full
;
2529 ve
->init_state
= DDF_init_not
;
2531 memset(ve
->pad1
, 0xff, 14);
2532 memset(ve
->name
, ' ', 16);
2534 strncpy(ve
->name
, name
, 16);
2535 ddf
->virt
->populated_vdes
=
2536 cpu_to_be16(be16_to_cpu(ddf
->virt
->populated_vdes
)+1);
2538 /* Now create a new vd_config */
2539 if (posix_memalign((void**)&vcl
, 512,
2540 (offsetof(struct vcl
, conf
) + ddf
->conf_rec_len
* 512)) != 0) {
2541 pr_err("%s could not allocate vd_config\n", __func__
);
2545 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
2548 vc
->magic
= DDF_VD_CONF_MAGIC
;
2549 memcpy(vc
->guid
, ve
->guid
, DDF_GUID_LEN
);
2550 vc
->timestamp
= cpu_to_be32(time(0)-DECADE
);
2551 vc
->seqnum
= cpu_to_be32(1);
2552 memset(vc
->pad0
, 0xff, 24);
2553 vc
->chunk_shift
= chunk_to_shift(info
->chunk_size
);
2554 if (layout_md2ddf(info
, vc
) == -1 ||
2555 be16_to_cpu(vc
->prim_elmnt_count
) > ddf
->mppe
) {
2556 pr_err("%s: unsupported RAID level/layout %d/%d with %d disks\n",
2557 __func__
, info
->level
, info
->layout
, info
->raid_disks
);
2561 vc
->sec_elmnt_seq
= 0;
2562 if (alloc_other_bvds(ddf
, vcl
) != 0) {
2563 pr_err("%s could not allocate other bvds\n",
2568 vc
->blocks
= cpu_to_be64(info
->size
* 2);
2569 vc
->array_blocks
= cpu_to_be64(
2570 calc_array_size(info
->level
, info
->raid_disks
, info
->layout
,
2571 info
->chunk_size
, info
->size
*2));
2572 memset(vc
->pad1
, 0xff, 8);
2573 vc
->spare_refs
[0] = cpu_to_be32(0xffffffff);
2574 vc
->spare_refs
[1] = cpu_to_be32(0xffffffff);
2575 vc
->spare_refs
[2] = cpu_to_be32(0xffffffff);
2576 vc
->spare_refs
[3] = cpu_to_be32(0xffffffff);
2577 vc
->spare_refs
[4] = cpu_to_be32(0xffffffff);
2578 vc
->spare_refs
[5] = cpu_to_be32(0xffffffff);
2579 vc
->spare_refs
[6] = cpu_to_be32(0xffffffff);
2580 vc
->spare_refs
[7] = cpu_to_be32(0xffffffff);
2581 memset(vc
->cache_pol
, 0, 8);
2583 memset(vc
->pad2
, 0xff, 3);
2584 memset(vc
->pad3
, 0xff, 52);
2585 memset(vc
->pad4
, 0xff, 192);
2586 memset(vc
->v0
, 0xff, 32);
2587 memset(vc
->v1
, 0xff, 32);
2588 memset(vc
->v2
, 0xff, 16);
2589 memset(vc
->v3
, 0xff, 16);
2590 memset(vc
->vendor
, 0xff, 32);
2592 memset(vc
->phys_refnum
, 0xff, 4*ddf
->mppe
);
2593 memset(vc
->phys_refnum
+ddf
->mppe
, 0x00, 8*ddf
->mppe
);
2595 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++) {
2596 memcpy(vcl
->other_bvds
[i
-1], vc
, ddf
->conf_rec_len
* 512);
2597 vcl
->other_bvds
[i
-1]->sec_elmnt_seq
= i
;
2600 vcl
->next
= ddf
->conflist
;
2601 ddf
->conflist
= vcl
;
2602 ddf
->currentconf
= vcl
;
2603 ddf_set_updates_pending(ddf
);
2609 static int get_svd_state(const struct ddf_super
*, const struct vcl
*);
2611 static void add_to_super_ddf_bvd(struct supertype
*st
,
2612 mdu_disk_info_t
*dk
, int fd
, char *devname
)
2614 /* fd and devname identify a device with-in the ddf container (st).
2615 * dk identifies a location in the new BVD.
2616 * We need to find suitable free space in that device and update
2617 * the phys_refnum and lba_offset for the newly created vd_config.
2618 * We might also want to update the type in the phys_disk
2621 * Alternately: fd == -1 and we have already chosen which device to
2622 * use and recorded in dlist->raid_disk;
2625 struct ddf_super
*ddf
= st
->sb
;
2626 struct vd_config
*vc
;
2628 unsigned long long blocks
, pos
, esize
;
2630 unsigned int raid_disk
= dk
->raid_disk
;
2633 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2634 if (dl
->raiddisk
== dk
->raid_disk
)
2637 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2638 if (dl
->major
== dk
->major
&&
2639 dl
->minor
== dk
->minor
)
2642 if (!dl
|| ! (dk
->state
& (1<<MD_DISK_SYNC
)))
2645 vc
= &ddf
->currentconf
->conf
;
2646 if (vc
->sec_elmnt_count
> 1) {
2647 unsigned int n
= be16_to_cpu(vc
->prim_elmnt_count
);
2649 vc
= ddf
->currentconf
->other_bvds
[raid_disk
/ n
- 1];
2653 ex
= get_extents(ddf
, dl
);
2658 blocks
= be64_to_cpu(vc
->blocks
);
2659 if (ddf
->currentconf
->block_sizes
)
2660 blocks
= ddf
->currentconf
->block_sizes
[dk
->raid_disk
];
2663 esize
= ex
[i
].start
- pos
;
2664 if (esize
>= blocks
)
2666 pos
= ex
[i
].start
+ ex
[i
].size
;
2668 } while (ex
[i
-1].size
);
2674 ddf
->currentdev
= dk
->raid_disk
;
2675 vc
->phys_refnum
[raid_disk
] = dl
->disk
.refnum
;
2676 LBA_OFFSET(ddf
, vc
)[raid_disk
] = cpu_to_be64(pos
);
2678 for (i
= 0; i
< ddf
->max_part
; i
++)
2679 if (dl
->vlist
[i
] == NULL
)
2681 if (i
== ddf
->max_part
)
2683 dl
->vlist
[i
] = ddf
->currentconf
;
2688 dl
->devname
= devname
;
2690 /* Check if we can mark array as optimal yet */
2691 i
= ddf
->currentconf
->vcnum
;
2692 ddf
->virt
->entries
[i
].state
=
2693 (ddf
->virt
->entries
[i
].state
& ~DDF_state_mask
)
2694 | get_svd_state(ddf
, ddf
->currentconf
);
2695 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
2696 cpu_to_be16(DDF_Global_Spare
));
2697 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
2698 cpu_to_be16(DDF_Active_in_VD
));
2699 dprintf("%s: added disk %d/%08x to VD %d/%s as disk %d\n",
2700 __func__
, dl
->pdnum
, be32_to_cpu(dl
->disk
.refnum
),
2701 ddf
->currentconf
->vcnum
, guid_str(vc
->guid
),
2703 ddf_set_updates_pending(ddf
);
2706 static unsigned int find_unused_pde(const struct ddf_super
*ddf
)
2709 for (i
= 0; i
< be16_to_cpu(ddf
->phys
->max_pdes
); i
++) {
2710 if (all_ff(ddf
->phys
->entries
[i
].guid
))
2713 return DDF_NOTFOUND
;
2716 static void _set_config_size(struct phys_disk_entry
*pde
, const struct dl
*dl
)
2719 cfs
= min(dl
->size
- 32*1024*2ULL, be64_to_cpu(dl
->primary_lba
));
2720 t
= be64_to_cpu(dl
->secondary_lba
);
2724 * Some vendor DDF structures interpret workspace_lba
2725 * very differently then us. Make a sanity check on the value.
2727 t
= be64_to_cpu(dl
->workspace_lba
);
2729 __u64 wsp
= cfs
- t
;
2730 if (wsp
> 1024*1024*2ULL && wsp
> dl
->size
/ 16) {
2731 pr_err("%s: %x:%x: workspace size 0x%llx too big, ignoring\n",
2732 __func__
, dl
->major
, dl
->minor
, wsp
);
2736 pde
->config_size
= cpu_to_be64(cfs
);
2737 dprintf("%s: %x:%x config_size %llx, DDF structure is %llx blocks\n",
2738 __func__
, dl
->major
, dl
->minor
, cfs
, dl
->size
-cfs
);
2741 /* add a device to a container, either while creating it or while
2742 * expanding a pre-existing container
2744 static int add_to_super_ddf(struct supertype
*st
,
2745 mdu_disk_info_t
*dk
, int fd
, char *devname
,
2746 unsigned long long data_offset
)
2748 struct ddf_super
*ddf
= st
->sb
;
2752 unsigned long long size
;
2753 struct phys_disk_entry
*pde
;
2758 if (ddf
->currentconf
) {
2759 add_to_super_ddf_bvd(st
, dk
, fd
, devname
);
2763 /* This is device numbered dk->number. We need to create
2764 * a phys_disk entry and a more detailed disk_data entry.
2767 n
= find_unused_pde(ddf
);
2768 if (n
== DDF_NOTFOUND
) {
2769 pr_err("%s: No free slot in array, cannot add disk\n",
2773 pde
= &ddf
->phys
->entries
[n
];
2774 get_dev_size(fd
, NULL
, &size
);
2775 if (size
<= 32*1024*1024) {
2776 pr_err("%s: device size must be at least 32MB\n",
2782 if (posix_memalign((void**)&dd
, 512,
2783 sizeof(*dd
) + sizeof(dd
->vlist
[0]) * ddf
->max_part
) != 0) {
2784 pr_err("%s could allocate buffer for new disk, aborting\n",
2788 dd
->major
= major(stb
.st_rdev
);
2789 dd
->minor
= minor(stb
.st_rdev
);
2790 dd
->devname
= devname
;
2794 dd
->disk
.magic
= DDF_PHYS_DATA_MAGIC
;
2796 tm
= localtime(&now
);
2797 sprintf(dd
->disk
.guid
, "%8s%04d%02d%02d",
2798 T10
, tm
->tm_year
+1900, tm
->tm_mon
+1, tm
->tm_mday
);
2799 tptr
= (__u32
*)(dd
->disk
.guid
+ 16);
2800 *tptr
++ = random32();
2804 /* Cannot be bothered finding a CRC of some irrelevant details*/
2805 dd
->disk
.refnum
._v32
= random32();
2806 for (i
= be16_to_cpu(ddf
->active
->max_pd_entries
);
2808 if (be32_eq(ddf
->phys
->entries
[i
-1].refnum
,
2813 dd
->disk
.forced_ref
= 1;
2814 dd
->disk
.forced_guid
= 1;
2815 memset(dd
->disk
.vendor
, ' ', 32);
2816 memcpy(dd
->disk
.vendor
, "Linux", 5);
2817 memset(dd
->disk
.pad
, 0xff, 442);
2818 for (i
= 0; i
< ddf
->max_part
; i
++)
2819 dd
->vlist
[i
] = NULL
;
2823 if (st
->update_tail
) {
2824 int len
= (sizeof(struct phys_disk
) +
2825 sizeof(struct phys_disk_entry
));
2826 struct phys_disk
*pd
;
2829 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2830 pd
->used_pdes
= cpu_to_be16(n
);
2831 pde
= &pd
->entries
[0];
2834 ddf
->phys
->used_pdes
= cpu_to_be16(
2835 1 + be16_to_cpu(ddf
->phys
->used_pdes
));
2837 memcpy(pde
->guid
, dd
->disk
.guid
, DDF_GUID_LEN
);
2838 pde
->refnum
= dd
->disk
.refnum
;
2839 pde
->type
= cpu_to_be16(DDF_Forced_PD_GUID
| DDF_Global_Spare
);
2840 pde
->state
= cpu_to_be16(DDF_Online
);
2843 * If there is already a device in dlist, try to reserve the same
2844 * amount of workspace. Otherwise, use 32MB.
2845 * We checked disk size above already.
2847 #define __calc_lba(new, old, lba, mb) do { \
2848 unsigned long long dif; \
2849 if ((old) != NULL) \
2850 dif = (old)->size - be64_to_cpu((old)->lba); \
2852 dif = (new)->size; \
2853 if ((new)->size > dif) \
2854 (new)->lba = cpu_to_be64((new)->size - dif); \
2856 (new)->lba = cpu_to_be64((new)->size - (mb*1024*2)); \
2858 __calc_lba(dd
, ddf
->dlist
, workspace_lba
, 32);
2859 __calc_lba(dd
, ddf
->dlist
, primary_lba
, 16);
2860 if (ddf
->dlist
== NULL
||
2861 be64_to_cpu(ddf
->dlist
->secondary_lba
) != ~(__u64
)0)
2862 __calc_lba(dd
, ddf
->dlist
, secondary_lba
, 32);
2863 _set_config_size(pde
, dd
);
2865 sprintf(pde
->path
, "%17.17s","Information: nil") ;
2866 memset(pde
->pad
, 0xff, 6);
2868 if (st
->update_tail
) {
2869 dd
->next
= ddf
->add_list
;
2872 dd
->next
= ddf
->dlist
;
2874 ddf_set_updates_pending(ddf
);
2880 static int remove_from_super_ddf(struct supertype
*st
, mdu_disk_info_t
*dk
)
2882 struct ddf_super
*ddf
= st
->sb
;
2885 /* mdmon has noticed that this disk (dk->major/dk->minor) has
2886 * disappeared from the container.
2887 * We need to arrange that it disappears from the metadata and
2888 * internal data structures too.
2889 * Most of the work is done by ddf_process_update which edits
2890 * the metadata and closes the file handle and attaches the memory
2891 * where free_updates will free it.
2893 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2894 if (dl
->major
== dk
->major
&&
2895 dl
->minor
== dk
->minor
)
2900 if (st
->update_tail
) {
2901 int len
= (sizeof(struct phys_disk
) +
2902 sizeof(struct phys_disk_entry
));
2903 struct phys_disk
*pd
;
2906 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2907 pd
->used_pdes
= cpu_to_be16(dl
->pdnum
);
2908 pd
->entries
[0].state
= cpu_to_be16(DDF_Missing
);
2909 append_metadata_update(st
, pd
, len
);
2916 * This is the write_init_super method for a ddf container. It is
2917 * called when creating a container or adding another device to a
2920 #define NULL_CONF_SZ 4096
2922 static int __write_ddf_structure(struct dl
*d
, struct ddf_super
*ddf
, __u8 type
)
2924 unsigned long long sector
;
2925 struct ddf_header
*header
;
2926 int fd
, i
, n_config
, conf_size
, buf_size
;
2933 case DDF_HEADER_PRIMARY
:
2934 header
= &ddf
->primary
;
2935 sector
= be64_to_cpu(header
->primary_lba
);
2937 case DDF_HEADER_SECONDARY
:
2938 header
= &ddf
->secondary
;
2939 sector
= be64_to_cpu(header
->secondary_lba
);
2944 if (sector
== ~(__u64
)0)
2947 header
->type
= type
;
2948 header
->openflag
= 1;
2949 header
->crc
= calc_crc(header
, 512);
2951 lseek64(fd
, sector
<<9, 0);
2952 if (write(fd
, header
, 512) < 0)
2955 ddf
->controller
.crc
= calc_crc(&ddf
->controller
, 512);
2956 if (write(fd
, &ddf
->controller
, 512) < 0)
2959 ddf
->phys
->crc
= calc_crc(ddf
->phys
, ddf
->pdsize
);
2960 if (write(fd
, ddf
->phys
, ddf
->pdsize
) < 0)
2962 ddf
->virt
->crc
= calc_crc(ddf
->virt
, ddf
->vdsize
);
2963 if (write(fd
, ddf
->virt
, ddf
->vdsize
) < 0)
2966 /* Now write lots of config records. */
2967 n_config
= ddf
->max_part
;
2968 conf_size
= ddf
->conf_rec_len
* 512;
2970 buf_size
= conf_size
* (n_config
+ 1);
2972 if (posix_memalign((void**)&conf
, 512, buf_size
) != 0)
2976 for (i
= 0 ; i
<= n_config
; i
++) {
2978 struct vd_config
*vdc
= NULL
;
2979 if (i
== n_config
) {
2980 c
= (struct vcl
*)d
->spare
;
2987 get_pd_index_from_refnum(
2990 (const struct vd_config
**)&vdc
,
2994 dprintf("writing conf record %i on disk %08x for %s/%u\n",
2995 i
, be32_to_cpu(d
->disk
.refnum
),
2996 guid_str(vdc
->guid
),
2997 vdc
->sec_elmnt_seq
);
2998 vdc
->seqnum
= header
->seq
;
2999 vdc
->crc
= calc_crc(vdc
, conf_size
);
3000 memcpy(conf
+ i
*conf_size
, vdc
, conf_size
);
3002 memset(conf
+ i
*conf_size
, 0xff, conf_size
);
3004 if (write(fd
, conf
, buf_size
) != buf_size
)
3007 d
->disk
.crc
= calc_crc(&d
->disk
, 512);
3008 if (write(fd
, &d
->disk
, 512) < 0)
3013 header
->openflag
= 0;
3014 header
->crc
= calc_crc(header
, 512);
3016 lseek64(fd
, sector
<<9, 0);
3017 if (write(fd
, header
, 512) < 0)
3023 static int _write_super_to_disk(struct ddf_super
*ddf
, struct dl
*d
)
3025 unsigned long long size
;
3030 /* We need to fill in the primary, (secondary) and workspace
3031 * lba's in the headers, set their checksums,
3032 * Also checksum phys, virt....
3034 * Then write everything out, finally the anchor is written.
3036 get_dev_size(fd
, NULL
, &size
);
3038 if (be64_to_cpu(d
->workspace_lba
) != 0ULL)
3039 ddf
->anchor
.workspace_lba
= d
->workspace_lba
;
3041 ddf
->anchor
.workspace_lba
=
3042 cpu_to_be64(size
- 32*1024*2);
3043 if (be64_to_cpu(d
->primary_lba
) != 0ULL)
3044 ddf
->anchor
.primary_lba
= d
->primary_lba
;
3046 ddf
->anchor
.primary_lba
=
3047 cpu_to_be64(size
- 16*1024*2);
3048 if (be64_to_cpu(d
->secondary_lba
) != 0ULL)
3049 ddf
->anchor
.secondary_lba
= d
->secondary_lba
;
3051 ddf
->anchor
.secondary_lba
=
3052 cpu_to_be64(size
- 32*1024*2);
3053 ddf
->anchor
.seq
= ddf
->active
->seq
;
3054 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
3055 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
3057 ddf
->anchor
.openflag
= 0xFF; /* 'open' means nothing */
3058 ddf
->anchor
.seq
= cpu_to_be32(0xFFFFFFFF); /* no sequencing in anchor */
3059 ddf
->anchor
.crc
= calc_crc(&ddf
->anchor
, 512);
3061 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_PRIMARY
))
3064 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_SECONDARY
))
3067 lseek64(fd
, (size
-1)*512, SEEK_SET
);
3068 if (write(fd
, &ddf
->anchor
, 512) < 0)
3075 static int __write_init_super_ddf(struct supertype
*st
)
3077 struct ddf_super
*ddf
= st
->sb
;
3082 pr_state(ddf
, __func__
);
3084 /* try to write updated metadata,
3085 * if we catch a failure move on to the next disk
3087 for (d
= ddf
->dlist
; d
; d
=d
->next
) {
3089 successes
+= _write_super_to_disk(ddf
, d
);
3092 return attempts
!= successes
;
3095 static int write_init_super_ddf(struct supertype
*st
)
3097 struct ddf_super
*ddf
= st
->sb
;
3098 struct vcl
*currentconf
= ddf
->currentconf
;
3100 /* we are done with currentconf reset it to point st at the container */
3101 ddf
->currentconf
= NULL
;
3103 if (st
->update_tail
) {
3104 /* queue the virtual_disk and vd_config as metadata updates */
3105 struct virtual_disk
*vd
;
3106 struct vd_config
*vc
;
3111 int len
= (sizeof(struct phys_disk
) +
3112 sizeof(struct phys_disk_entry
));
3114 /* adding a disk to the container. */
3118 append_metadata_update(st
, ddf
->add_list
->mdupdate
, len
);
3119 ddf
->add_list
->mdupdate
= NULL
;
3123 /* Newly created VD */
3125 /* First the virtual disk. We have a slightly fake header */
3126 len
= sizeof(struct virtual_disk
) + sizeof(struct virtual_entry
);
3129 vd
->entries
[0] = ddf
->virt
->entries
[currentconf
->vcnum
];
3130 vd
->populated_vdes
= cpu_to_be16(currentconf
->vcnum
);
3131 append_metadata_update(st
, vd
, len
);
3133 /* Then the vd_config */
3134 len
= ddf
->conf_rec_len
* 512;
3135 tlen
= len
* currentconf
->conf
.sec_elmnt_count
;
3137 memcpy(vc
, ¤tconf
->conf
, len
);
3138 for (i
= 1; i
< currentconf
->conf
.sec_elmnt_count
; i
++)
3139 memcpy((char *)vc
+ i
*len
, currentconf
->other_bvds
[i
-1],
3141 append_metadata_update(st
, vc
, tlen
);
3143 /* FIXME I need to close the fds! */
3148 for (d
= ddf
->dlist
; d
; d
=d
->next
)
3149 while (Kill(d
->devname
, NULL
, 0, -1, 1) == 0);
3150 return __write_init_super_ddf(st
);
3156 static __u64
avail_size_ddf(struct supertype
*st
, __u64 devsize
,
3157 unsigned long long data_offset
)
3159 /* We must reserve the last 32Meg */
3160 if (devsize
<= 32*1024*2)
3162 return devsize
- 32*1024*2;
3167 static int reserve_space(struct supertype
*st
, int raiddisks
,
3168 unsigned long long size
, int chunk
,
3169 unsigned long long *freesize
)
3171 /* Find 'raiddisks' spare extents at least 'size' big (but
3172 * only caring about multiples of 'chunk') and remember
3174 * If the cannot be found, fail.
3177 struct ddf_super
*ddf
= st
->sb
;
3180 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3184 /* Now find largest extent on each device */
3185 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3186 struct extent
*e
= get_extents(ddf
, dl
);
3187 unsigned long long pos
= 0;
3190 unsigned long long minsize
= size
;
3198 unsigned long long esize
;
3199 esize
= e
[i
].start
- pos
;
3200 if (esize
>= minsize
) {
3204 pos
= e
[i
].start
+ e
[i
].size
;
3206 } while (e
[i
-1].size
);
3209 dl
->esize
= minsize
;
3213 if (cnt
< raiddisks
) {
3214 pr_err("not enough devices with space to create array.\n");
3215 return 0; /* No enough free spaces large enough */
3218 /* choose the largest size of which there are at least 'raiddisk' */
3219 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3221 if (dl
->esize
<= size
)
3223 /* This is bigger than 'size', see if there are enough */
3225 for (dl2
= ddf
->dlist
; dl2
; dl2
=dl2
->next
)
3226 if (dl2
->esize
>= dl
->esize
)
3228 if (cnt
>= raiddisks
)
3232 size
= size
/ chunk
;
3237 pr_err("not enough spare devices to create array.\n");
3241 /* We have a 'size' of which there are enough spaces.
3242 * We simply do a first-fit */
3244 for (dl
= ddf
->dlist
; dl
&& cnt
< raiddisks
; dl
=dl
->next
) {
3245 if (dl
->esize
< size
)
3255 validate_geometry_ddf_container(struct supertype
*st
,
3256 int level
, int layout
, int raiddisks
,
3257 int chunk
, unsigned long long size
,
3258 unsigned long long data_offset
,
3259 char *dev
, unsigned long long *freesize
,
3262 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3263 int level
, int layout
, int raiddisks
,
3264 int *chunk
, unsigned long long size
,
3265 unsigned long long data_offset
,
3266 char *dev
, unsigned long long *freesize
,
3269 static int validate_geometry_ddf(struct supertype
*st
,
3270 int level
, int layout
, int raiddisks
,
3271 int *chunk
, unsigned long long size
,
3272 unsigned long long data_offset
,
3273 char *dev
, unsigned long long *freesize
,
3280 /* ddf potentially supports lots of things, but it depends on
3281 * what devices are offered (and maybe kernel version?)
3282 * If given unused devices, we will make a container.
3283 * If given devices in a container, we will make a BVD.
3284 * If given BVDs, we make an SVD, changing all the GUIDs in the process.
3287 if (*chunk
== UnSet
)
3288 *chunk
= DEFAULT_CHUNK
;
3290 if (level
== -1000000) level
= LEVEL_CONTAINER
;
3291 if (level
== LEVEL_CONTAINER
) {
3292 /* Must be a fresh device to add to a container */
3293 return validate_geometry_ddf_container(st
, level
, layout
,
3295 size
, data_offset
, dev
,
3301 mdu_array_info_t array
= {
3302 .level
= level
, .layout
= layout
,
3303 .raid_disks
= raiddisks
3305 struct vd_config conf
;
3306 if (layout_md2ddf(&array
, &conf
) == -1) {
3308 pr_err("DDF does not support level %d /layout %d arrays with %d disks\n",
3309 level
, layout
, raiddisks
);
3312 /* Should check layout? etc */
3314 if (st
->sb
&& freesize
) {
3315 /* --create was given a container to create in.
3316 * So we need to check that there are enough
3317 * free spaces and return the amount of space.
3318 * We may as well remember which drives were
3319 * chosen so that add_to_super/getinfo_super
3322 return reserve_space(st
, raiddisks
, size
, *chunk
, freesize
);
3328 /* A container has already been opened, so we are
3329 * creating in there. Maybe a BVD, maybe an SVD.
3330 * Should make a distinction one day.
3332 return validate_geometry_ddf_bvd(st
, level
, layout
, raiddisks
,
3333 chunk
, size
, data_offset
, dev
,
3337 /* This is the first device for the array.
3338 * If it is a container, we read it in and do automagic allocations,
3339 * no other devices should be given.
3340 * Otherwise it must be a member device of a container, and we
3341 * do manual allocation.
3342 * Later we should check for a BVD and make an SVD.
3344 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3346 sra
= sysfs_read(fd
, NULL
, GET_VERSION
);
3348 if (sra
&& sra
->array
.major_version
== -1 &&
3349 strcmp(sra
->text_version
, "ddf") == 0) {
3352 /* find space for 'n' devices. */
3353 /* remember the devices */
3354 /* Somehow return the fact that we have enough */
3358 pr_err("ddf: Cannot create this array "
3359 "on device %s - a container is required.\n",
3363 if (errno
!= EBUSY
|| (fd
= open(dev
, O_RDONLY
, 0)) < 0) {
3365 pr_err("ddf: Cannot open %s: %s\n",
3366 dev
, strerror(errno
));
3369 /* Well, it is in use by someone, maybe a 'ddf' container. */
3370 cfd
= open_container(fd
);
3374 pr_err("ddf: Cannot use %s: %s\n",
3375 dev
, strerror(EBUSY
));
3378 sra
= sysfs_read(cfd
, NULL
, GET_VERSION
);
3380 if (sra
&& sra
->array
.major_version
== -1 &&
3381 strcmp(sra
->text_version
, "ddf") == 0) {
3382 /* This is a member of a ddf container. Load the container
3383 * and try to create a bvd
3385 struct ddf_super
*ddf
;
3386 if (load_super_ddf_all(st
, cfd
, (void **)&ddf
, NULL
) == 0) {
3388 strcpy(st
->container_devnm
, fd2devnm(cfd
));
3390 return validate_geometry_ddf_bvd(st
, level
, layout
,
3391 raiddisks
, chunk
, size
,
3397 } else /* device may belong to a different container */
3404 validate_geometry_ddf_container(struct supertype
*st
,
3405 int level
, int layout
, int raiddisks
,
3406 int chunk
, unsigned long long size
,
3407 unsigned long long data_offset
,
3408 char *dev
, unsigned long long *freesize
,
3412 unsigned long long ldsize
;
3414 if (level
!= LEVEL_CONTAINER
)
3419 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3422 pr_err("ddf: Cannot open %s: %s\n",
3423 dev
, strerror(errno
));
3426 if (!get_dev_size(fd
, dev
, &ldsize
)) {
3432 *freesize
= avail_size_ddf(st
, ldsize
>> 9, INVALID_SECTORS
);
3439 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3440 int level
, int layout
, int raiddisks
,
3441 int *chunk
, unsigned long long size
,
3442 unsigned long long data_offset
,
3443 char *dev
, unsigned long long *freesize
,
3447 struct ddf_super
*ddf
= st
->sb
;
3449 unsigned long long pos
= 0;
3450 unsigned long long maxsize
;
3453 /* ddf/bvd supports lots of things, but not containers */
3454 if (level
== LEVEL_CONTAINER
) {
3456 pr_err("DDF cannot create a container within an container\n");
3459 /* We must have the container info already read in. */
3464 /* General test: make sure there is space for
3465 * 'raiddisks' device extents of size 'size'.
3467 unsigned long long minsize
= size
;
3471 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3477 e
= get_extents(ddf
, dl
);
3480 unsigned long long esize
;
3481 esize
= e
[i
].start
- pos
;
3482 if (esize
>= minsize
)
3484 pos
= e
[i
].start
+ e
[i
].size
;
3486 } while (e
[i
-1].size
);
3491 if (dcnt
< raiddisks
) {
3493 pr_err("ddf: Not enough devices with "
3494 "space for this array (%d < %d)\n",
3500 /* This device must be a member of the set */
3501 if (stat(dev
, &stb
) < 0)
3503 if ((S_IFMT
& stb
.st_mode
) != S_IFBLK
)
3505 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
3506 if (dl
->major
== (int)major(stb
.st_rdev
) &&
3507 dl
->minor
== (int)minor(stb
.st_rdev
))
3512 pr_err("ddf: %s is not in the "
3517 e
= get_extents(ddf
, dl
);
3521 unsigned long long esize
;
3522 esize
= e
[i
].start
- pos
;
3523 if (esize
>= maxsize
)
3525 pos
= e
[i
].start
+ e
[i
].size
;
3527 } while (e
[i
-1].size
);
3528 *freesize
= maxsize
;
3534 static int load_super_ddf_all(struct supertype
*st
, int fd
,
3535 void **sbp
, char *devname
)
3538 struct ddf_super
*super
;
3539 struct mdinfo
*sd
, *best
= NULL
;
3545 sra
= sysfs_read(fd
, 0, GET_LEVEL
|GET_VERSION
|GET_DEVS
|GET_STATE
);
3548 if (sra
->array
.major_version
!= -1 ||
3549 sra
->array
.minor_version
!= -2 ||
3550 strcmp(sra
->text_version
, "ddf") != 0)
3553 if (posix_memalign((void**)&super
, 512, sizeof(*super
)) != 0)
3555 memset(super
, 0, sizeof(*super
));
3557 /* first, try each device, and choose the best ddf */
3558 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3560 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3561 dfd
= dev_open(nm
, O_RDONLY
);
3564 rv
= load_ddf_headers(dfd
, super
, NULL
);
3567 seq
= be32_to_cpu(super
->active
->seq
);
3568 if (super
->active
->openflag
)
3570 if (!best
|| seq
> bestseq
) {
3578 /* OK, load this ddf */
3579 sprintf(nm
, "%d:%d", best
->disk
.major
, best
->disk
.minor
);
3580 dfd
= dev_open(nm
, O_RDONLY
);
3583 load_ddf_headers(dfd
, super
, NULL
);
3584 load_ddf_global(dfd
, super
, NULL
);
3586 /* Now we need the device-local bits */
3587 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3590 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3591 dfd
= dev_open(nm
, O_RDWR
);
3594 rv
= load_ddf_headers(dfd
, super
, NULL
);
3596 rv
= load_ddf_local(dfd
, super
, NULL
, 1);
3602 if (st
->ss
== NULL
) {
3603 st
->ss
= &super_ddf
;
3604 st
->minor_version
= 0;
3607 strcpy(st
->container_devnm
, fd2devnm(fd
));
3611 static int load_container_ddf(struct supertype
*st
, int fd
,
3614 return load_super_ddf_all(st
, fd
, &st
->sb
, devname
);
3617 #endif /* MDASSEMBLE */
3619 static int check_secondary(const struct vcl
*vc
)
3621 const struct vd_config
*conf
= &vc
->conf
;
3624 /* The only DDF secondary RAID level md can support is
3625 * RAID 10, if the stripe sizes and Basic volume sizes
3627 * Other configurations could in theory be supported by exposing
3628 * the BVDs to user space and using device mapper for the secondary
3629 * mapping. So far we don't support that.
3632 __u64 sec_elements
[4] = {0, 0, 0, 0};
3633 #define __set_sec_seen(n) (sec_elements[(n)>>6] |= (1<<((n)&63)))
3634 #define __was_sec_seen(n) ((sec_elements[(n)>>6] & (1<<((n)&63))) != 0)
3636 if (vc
->other_bvds
== NULL
) {
3637 pr_err("No BVDs for secondary RAID found\n");
3640 if (conf
->prl
!= DDF_RAID1
) {
3641 pr_err("Secondary RAID level only supported for mirrored BVD\n");
3644 if (conf
->srl
!= DDF_2STRIPED
&& conf
->srl
!= DDF_2SPANNED
) {
3645 pr_err("Secondary RAID level %d is unsupported\n",
3649 __set_sec_seen(conf
->sec_elmnt_seq
);
3650 for (i
= 0; i
< conf
->sec_elmnt_count
-1; i
++) {
3651 const struct vd_config
*bvd
= vc
->other_bvds
[i
];
3652 if (bvd
->sec_elmnt_seq
== DDF_UNUSED_BVD
)
3654 if (bvd
->srl
!= conf
->srl
) {
3655 pr_err("Inconsistent secondary RAID level across BVDs\n");
3658 if (bvd
->prl
!= conf
->prl
) {
3659 pr_err("Different RAID levels for BVDs are unsupported\n");
3662 if (!be16_eq(bvd
->prim_elmnt_count
, conf
->prim_elmnt_count
)) {
3663 pr_err("All BVDs must have the same number of primary elements\n");
3666 if (bvd
->chunk_shift
!= conf
->chunk_shift
) {
3667 pr_err("Different strip sizes for BVDs are unsupported\n");
3670 if (!be64_eq(bvd
->array_blocks
, conf
->array_blocks
)) {
3671 pr_err("Different BVD sizes are unsupported\n");
3674 __set_sec_seen(bvd
->sec_elmnt_seq
);
3676 for (i
= 0; i
< conf
->sec_elmnt_count
; i
++) {
3677 if (!__was_sec_seen(i
)) {
3678 pr_err("BVD %d is missing\n", i
);
3685 static unsigned int get_pd_index_from_refnum(const struct vcl
*vc
,
3686 be32 refnum
, unsigned int nmax
,
3687 const struct vd_config
**bvd
,
3690 unsigned int i
, j
, n
, sec
, cnt
;
3692 cnt
= be16_to_cpu(vc
->conf
.prim_elmnt_count
);
3693 sec
= (vc
->conf
.sec_elmnt_count
== 1 ? 0 : vc
->conf
.sec_elmnt_seq
);
3695 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3696 /* j counts valid entries for this BVD */
3697 if (be32_to_cpu(vc
->conf
.phys_refnum
[i
]) != 0xffffffff)
3699 if (be32_eq(vc
->conf
.phys_refnum
[i
], refnum
)) {
3702 return sec
* cnt
+ j
- 1;
3705 if (vc
->other_bvds
== NULL
)
3708 for (n
= 1; n
< vc
->conf
.sec_elmnt_count
; n
++) {
3709 struct vd_config
*vd
= vc
->other_bvds
[n
-1];
3710 sec
= vd
->sec_elmnt_seq
;
3711 if (sec
== DDF_UNUSED_BVD
)
3713 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3714 if (be32_to_cpu(vd
->phys_refnum
[i
]) != 0xffffffff)
3716 if (be32_eq(vd
->phys_refnum
[i
], refnum
)) {
3719 return sec
* cnt
+ j
- 1;
3725 return DDF_NOTFOUND
;
3728 static struct mdinfo
*container_content_ddf(struct supertype
*st
, char *subarray
)
3730 /* Given a container loaded by load_super_ddf_all,
3731 * extract information about all the arrays into
3734 * For each vcl in conflist: create an mdinfo, fill it in,
3735 * then look for matching devices (phys_refnum) in dlist
3736 * and create appropriate device mdinfo.
3738 struct ddf_super
*ddf
= st
->sb
;
3739 struct mdinfo
*rest
= NULL
;
3742 for (vc
= ddf
->conflist
; vc
; vc
=vc
->next
)
3745 struct mdinfo
*this;
3751 (strtoul(subarray
, &ep
, 10) != vc
->vcnum
||
3755 if (vc
->conf
.sec_elmnt_count
> 1) {
3756 if (check_secondary(vc
) != 0)
3760 this = xcalloc(1, sizeof(*this));
3764 if (layout_ddf2md(&vc
->conf
, &this->array
))
3766 this->array
.md_minor
= -1;
3767 this->array
.major_version
= -1;
3768 this->array
.minor_version
= -2;
3769 this->safe_mode_delay
= DDF_SAFE_MODE_DELAY
;
3770 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
3771 this->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
3772 this->array
.utime
= DECADE
+
3773 be32_to_cpu(vc
->conf
.timestamp
);
3774 this->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
3777 if ((ddf
->virt
->entries
[i
].state
& DDF_state_inconsistent
) ||
3778 (ddf
->virt
->entries
[i
].init_state
& DDF_initstate_mask
) !=
3780 this->array
.state
= 0;
3781 this->resync_start
= 0;
3783 this->array
.state
= 1;
3784 this->resync_start
= MaxSector
;
3786 _ddf_array_name(this->name
, ddf
, i
);
3787 memset(this->uuid
, 0, sizeof(this->uuid
));
3788 this->component_size
= be64_to_cpu(vc
->conf
.blocks
);
3789 this->array
.size
= this->component_size
/ 2;
3790 this->container_member
= i
;
3792 ddf
->currentconf
= vc
;
3793 uuid_from_super_ddf(st
, this->uuid
);
3795 ddf
->currentconf
= NULL
;
3797 sprintf(this->text_version
, "/%s/%d",
3798 st
->container_devnm
, this->container_member
);
3800 for (pd
= 0; pd
< be16_to_cpu(ddf
->phys
->used_pdes
); pd
++) {
3803 const struct vd_config
*bvd
;
3807 if (be32_to_cpu(ddf
->phys
->entries
[pd
].refnum
)
3811 stt
= be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
3812 if ((stt
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
3816 i
= get_pd_index_from_refnum(
3817 vc
, ddf
->phys
->entries
[pd
].refnum
,
3818 ddf
->mppe
, &bvd
, &iphys
);
3819 if (i
== DDF_NOTFOUND
)
3822 this->array
.working_disks
++;
3824 for (d
= ddf
->dlist
; d
; d
=d
->next
)
3825 if (be32_eq(d
->disk
.refnum
,
3826 ddf
->phys
->entries
[pd
].refnum
))
3829 /* Haven't found that one yet, maybe there are others */
3832 dev
= xcalloc(1, sizeof(*dev
));
3833 dev
->next
= this->devs
;
3836 dev
->disk
.number
= be32_to_cpu(d
->disk
.refnum
);
3837 dev
->disk
.major
= d
->major
;
3838 dev
->disk
.minor
= d
->minor
;
3839 dev
->disk
.raid_disk
= i
;
3840 dev
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
3841 dev
->recovery_start
= MaxSector
;
3843 dev
->events
= be32_to_cpu(ddf
->primary
.seq
);
3845 be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[iphys
]);
3846 dev
->component_size
= be64_to_cpu(bvd
->blocks
);
3848 strcpy(dev
->name
, d
->devname
);
3854 static int store_super_ddf(struct supertype
*st
, int fd
)
3856 struct ddf_super
*ddf
= st
->sb
;
3857 unsigned long long dsize
;
3864 if (!get_dev_size(fd
, NULL
, &dsize
))
3867 if (ddf
->dlist
|| ddf
->conflist
) {
3872 if (fstat(fd
, &sta
) == -1 || !S_ISBLK(sta
.st_mode
)) {
3873 pr_err("%s: file descriptor for invalid device\n",
3877 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3878 if (dl
->major
== (int)major(sta
.st_rdev
) &&
3879 dl
->minor
== (int)minor(sta
.st_rdev
))
3882 pr_err("%s: couldn't find disk %d/%d\n", __func__
,
3883 (int)major(sta
.st_rdev
),
3884 (int)minor(sta
.st_rdev
));
3889 ret
= (_write_super_to_disk(ddf
, dl
) != 1);
3894 if (posix_memalign(&buf
, 512, 512) != 0)
3896 memset(buf
, 0, 512);
3898 lseek64(fd
, dsize
-512, 0);
3899 rc
= write(fd
, buf
, 512);
3906 static int compare_super_ddf(struct supertype
*st
, struct supertype
*tst
)
3910 * 0 same, or first was empty, and second was copied
3911 * 1 second had wrong number
3913 * 3 wrong other info
3915 struct ddf_super
*first
= st
->sb
;
3916 struct ddf_super
*second
= tst
->sb
;
3917 struct dl
*dl1
, *dl2
;
3918 struct vcl
*vl1
, *vl2
;
3919 unsigned int max_vds
, max_pds
, pd
, vd
;
3927 if (memcmp(first
->anchor
.guid
, second
->anchor
.guid
, DDF_GUID_LEN
) != 0)
3930 if (!be32_eq(first
->active
->seq
, second
->active
->seq
)) {
3931 dprintf("%s: sequence number mismatch %u<->%u\n", __func__
,
3932 be32_to_cpu(first
->active
->seq
),
3933 be32_to_cpu(second
->active
->seq
));
3936 if (first
->max_part
!= second
->max_part
||
3937 !be16_eq(first
->phys
->used_pdes
, second
->phys
->used_pdes
) ||
3938 !be16_eq(first
->virt
->populated_vdes
,
3939 second
->virt
->populated_vdes
)) {
3940 dprintf("%s: PD/VD number mismatch\n", __func__
);
3944 max_pds
= be16_to_cpu(first
->phys
->used_pdes
);
3945 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
3946 for (pd
= 0; pd
< max_pds
; pd
++)
3947 if (be32_eq(first
->phys
->entries
[pd
].refnum
,
3950 if (pd
== max_pds
) {
3951 dprintf("%s: no match for disk %08x\n", __func__
,
3952 be32_to_cpu(dl2
->disk
.refnum
));
3957 max_vds
= be16_to_cpu(first
->active
->max_vd_entries
);
3958 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3959 if (!be32_eq(vl2
->conf
.magic
, DDF_VD_CONF_MAGIC
))
3961 for (vd
= 0; vd
< max_vds
; vd
++)
3962 if (!memcmp(first
->virt
->entries
[vd
].guid
,
3963 vl2
->conf
.guid
, DDF_GUID_LEN
))
3965 if (vd
== max_vds
) {
3966 dprintf("%s: no match for VD config\n", __func__
);
3970 /* FIXME should I look at anything else? */
3973 At this point we are fairly sure that the meta data matches.
3974 But the new disk may contain additional local data.
3975 Add it to the super block.
3977 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3978 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
)
3979 if (!memcmp(vl1
->conf
.guid
, vl2
->conf
.guid
,
3983 if (vl1
->other_bvds
!= NULL
&&
3984 vl1
->conf
.sec_elmnt_seq
!=
3985 vl2
->conf
.sec_elmnt_seq
) {
3986 dprintf("%s: adding BVD %u\n", __func__
,
3987 vl2
->conf
.sec_elmnt_seq
);
3988 add_other_bvd(vl1
, &vl2
->conf
,
3989 first
->conf_rec_len
*512);
3994 if (posix_memalign((void **)&vl1
, 512,
3995 (first
->conf_rec_len
*512 +
3996 offsetof(struct vcl
, conf
))) != 0) {
3997 pr_err("%s could not allocate vcl buf\n",
4002 vl1
->next
= first
->conflist
;
4003 vl1
->block_sizes
= NULL
;
4004 memcpy(&vl1
->conf
, &vl2
->conf
, first
->conf_rec_len
*512);
4005 if (alloc_other_bvds(first
, vl1
) != 0) {
4006 pr_err("%s could not allocate other bvds\n",
4011 for (vd
= 0; vd
< max_vds
; vd
++)
4012 if (!memcmp(first
->virt
->entries
[vd
].guid
,
4013 vl1
->conf
.guid
, DDF_GUID_LEN
))
4016 dprintf("%s: added config for VD %u\n", __func__
, vl1
->vcnum
);
4017 first
->conflist
= vl1
;
4020 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
4021 for (dl1
= first
->dlist
; dl1
; dl1
= dl1
->next
)
4022 if (be32_eq(dl1
->disk
.refnum
, dl2
->disk
.refnum
))
4027 if (posix_memalign((void **)&dl1
, 512,
4028 sizeof(*dl1
) + (first
->max_part
) * sizeof(dl1
->vlist
[0]))
4030 pr_err("%s could not allocate disk info buffer\n",
4034 memcpy(dl1
, dl2
, sizeof(*dl1
));
4035 dl1
->mdupdate
= NULL
;
4036 dl1
->next
= first
->dlist
;
4038 for (pd
= 0; pd
< max_pds
; pd
++)
4039 if (be32_eq(first
->phys
->entries
[pd
].refnum
,
4044 if (posix_memalign((void **)&dl1
->spare
, 512,
4045 first
->conf_rec_len
*512) != 0) {
4046 pr_err("%s could not allocate spare info buf\n",
4050 memcpy(dl1
->spare
, dl2
->spare
, first
->conf_rec_len
*512);
4052 for (vd
= 0 ; vd
< first
->max_part
; vd
++) {
4053 if (!dl2
->vlist
[vd
]) {
4054 dl1
->vlist
[vd
] = NULL
;
4057 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
) {
4058 if (!memcmp(vl1
->conf
.guid
,
4059 dl2
->vlist
[vd
]->conf
.guid
,
4062 dl1
->vlist
[vd
] = vl1
;
4066 dprintf("%s: added disk %d: %08x\n", __func__
, dl1
->pdnum
,
4067 be32_to_cpu(dl1
->disk
.refnum
));
4075 * A new array 'a' has been started which claims to be instance 'inst'
4076 * within container 'c'.
4077 * We need to confirm that the array matches the metadata in 'c' so
4078 * that we don't corrupt any metadata.
4080 static int ddf_open_new(struct supertype
*c
, struct active_array
*a
, char *inst
)
4082 struct ddf_super
*ddf
= c
->sb
;
4086 static const char faulty
[] = "faulty";
4088 if (all_ff(ddf
->virt
->entries
[n
].guid
)) {
4089 pr_err("%s: subarray %d doesn't exist\n", __func__
, n
);
4092 dprintf("%s: new subarray %d, GUID: %s\n", __func__
, n
,
4093 guid_str(ddf
->virt
->entries
[n
].guid
));
4094 for (dev
= a
->info
.devs
; dev
; dev
= dev
->next
) {
4095 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4096 if (dl
->major
== dev
->disk
.major
&&
4097 dl
->minor
== dev
->disk
.minor
)
4100 pr_err("%s: device %d/%d of subarray %d not found in meta data\n",
4101 __func__
, dev
->disk
.major
, dev
->disk
.minor
, n
);
4104 if ((be16_to_cpu(ddf
->phys
->entries
[dl
->pdnum
].state
) &
4105 (DDF_Online
|DDF_Missing
|DDF_Failed
)) != DDF_Online
) {
4106 pr_err("%s: new subarray %d contains broken device %d/%d (%02x)\n",
4107 __func__
, n
, dl
->major
, dl
->minor
,
4109 ddf
->phys
->entries
[dl
->pdnum
].state
));
4110 if (write(dev
->state_fd
, faulty
, sizeof(faulty
)-1) !=
4112 pr_err("Write to state_fd failed\n");
4113 dev
->curr_state
= DS_FAULTY
;
4116 a
->info
.container_member
= n
;
4121 * The array 'a' is to be marked clean in the metadata.
4122 * If '->resync_start' is not ~(unsigned long long)0, then the array is only
4123 * clean up to the point (in sectors). If that cannot be recorded in the
4124 * metadata, then leave it as dirty.
4126 * For DDF, we need to clear the DDF_state_inconsistent bit in the
4127 * !global! virtual_disk.virtual_entry structure.
4129 static int ddf_set_array_state(struct active_array
*a
, int consistent
)
4131 struct ddf_super
*ddf
= a
->container
->sb
;
4132 int inst
= a
->info
.container_member
;
4133 int old
= ddf
->virt
->entries
[inst
].state
;
4134 if (consistent
== 2) {
4135 /* Should check if a recovery should be started FIXME */
4137 if (!is_resync_complete(&a
->info
))
4141 ddf
->virt
->entries
[inst
].state
&= ~DDF_state_inconsistent
;
4143 ddf
->virt
->entries
[inst
].state
|= DDF_state_inconsistent
;
4144 if (old
!= ddf
->virt
->entries
[inst
].state
)
4145 ddf_set_updates_pending(ddf
);
4147 old
= ddf
->virt
->entries
[inst
].init_state
;
4148 ddf
->virt
->entries
[inst
].init_state
&= ~DDF_initstate_mask
;
4149 if (is_resync_complete(&a
->info
))
4150 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_full
;
4151 else if (a
->info
.resync_start
== 0)
4152 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_not
;
4154 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_quick
;
4155 if (old
!= ddf
->virt
->entries
[inst
].init_state
)
4156 ddf_set_updates_pending(ddf
);
4158 dprintf("ddf mark %d/%s (%d) %s %llu\n", inst
,
4159 guid_str(ddf
->virt
->entries
[inst
].guid
), a
->curr_state
,
4160 consistent
?"clean":"dirty",
4161 a
->info
.resync_start
);
4165 static int get_bvd_state(const struct ddf_super
*ddf
,
4166 const struct vd_config
*vc
)
4168 unsigned int i
, n_bvd
, working
= 0;
4169 unsigned int n_prim
= be16_to_cpu(vc
->prim_elmnt_count
);
4171 for (i
= 0; i
< n_prim
; i
++) {
4172 if (!find_index_in_bvd(ddf
, vc
, i
, &n_bvd
))
4174 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
4177 st
= be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
4178 if ((st
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
4183 state
= DDF_state_degraded
;
4184 if (working
== n_prim
)
4185 state
= DDF_state_optimal
;
4191 state
= DDF_state_failed
;
4195 state
= DDF_state_failed
;
4196 else if (working
>= 2)
4197 state
= DDF_state_part_optimal
;
4201 if (working
< n_prim
- 1)
4202 state
= DDF_state_failed
;
4205 if (working
< n_prim
- 2)
4206 state
= DDF_state_failed
;
4207 else if (working
== n_prim
- 1)
4208 state
= DDF_state_part_optimal
;
4214 static int secondary_state(int state
, int other
, int seclevel
)
4216 if (state
== DDF_state_optimal
&& other
== DDF_state_optimal
)
4217 return DDF_state_optimal
;
4218 if (seclevel
== DDF_2MIRRORED
) {
4219 if (state
== DDF_state_optimal
|| other
== DDF_state_optimal
)
4220 return DDF_state_part_optimal
;
4221 if (state
== DDF_state_failed
&& other
== DDF_state_failed
)
4222 return DDF_state_failed
;
4223 return DDF_state_degraded
;
4225 if (state
== DDF_state_failed
|| other
== DDF_state_failed
)
4226 return DDF_state_failed
;
4227 if (state
== DDF_state_degraded
|| other
== DDF_state_degraded
)
4228 return DDF_state_degraded
;
4229 return DDF_state_part_optimal
;
4233 static int get_svd_state(const struct ddf_super
*ddf
, const struct vcl
*vcl
)
4235 int state
= get_bvd_state(ddf
, &vcl
->conf
);
4237 for (i
= 1; i
< vcl
->conf
.sec_elmnt_count
; i
++) {
4238 state
= secondary_state(
4240 get_bvd_state(ddf
, vcl
->other_bvds
[i
-1]),
4247 * The state of each disk is stored in the global phys_disk structure
4248 * in phys_disk.entries[n].state.
4249 * This makes various combinations awkward.
4250 * - When a device fails in any array, it must be failed in all arrays
4251 * that include a part of this device.
4252 * - When a component is rebuilding, we cannot include it officially in the
4253 * array unless this is the only array that uses the device.
4255 * So: when transitioning:
4256 * Online -> failed, just set failed flag. monitor will propagate
4257 * spare -> online, the device might need to be added to the array.
4258 * spare -> failed, just set failed. Don't worry if in array or not.
4260 static void ddf_set_disk(struct active_array
*a
, int n
, int state
)
4262 struct ddf_super
*ddf
= a
->container
->sb
;
4263 unsigned int inst
= a
->info
.container_member
, n_bvd
;
4265 struct vd_config
*vc
= find_vdcr(ddf
, inst
, (unsigned int)n
,
4271 dprintf("%s: %d to %x\n", __func__
, n
, state
);
4273 dprintf("ddf: cannot find instance %d!!\n", inst
);
4276 /* Find the matching slot in 'info'. */
4277 for (mdi
= a
->info
.devs
; mdi
; mdi
= mdi
->next
)
4278 if (mdi
->disk
.raid_disk
== n
)
4281 pr_err("%s: cannot find raid disk %d\n",
4286 /* and find the 'dl' entry corresponding to that. */
4287 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4288 if (mdi
->state_fd
>= 0 &&
4289 mdi
->disk
.major
== dl
->major
&&
4290 mdi
->disk
.minor
== dl
->minor
)
4293 pr_err("%s: cannot find raid disk %d (%d/%d)\n",
4295 mdi
->disk
.major
, mdi
->disk
.minor
);
4299 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
4300 if (pd
< 0 || pd
!= dl
->pdnum
) {
4301 /* disk doesn't currently exist or has changed.
4302 * If it is now in_sync, insert it. */
4303 dprintf("%s: phys disk not found for %d: %d/%d ref %08x\n",
4304 __func__
, dl
->pdnum
, dl
->major
, dl
->minor
,
4305 be32_to_cpu(dl
->disk
.refnum
));
4306 dprintf("%s: array %u disk %u ref %08x pd %d\n",
4307 __func__
, inst
, n_bvd
,
4308 be32_to_cpu(vc
->phys_refnum
[n_bvd
]), pd
);
4309 if ((state
& DS_INSYNC
) && ! (state
& DS_FAULTY
)) {
4310 pd
= dl
->pdnum
; /* FIXME: is this really correct ? */
4311 vc
->phys_refnum
[n_bvd
] = dl
->disk
.refnum
;
4312 LBA_OFFSET(ddf
, vc
)[n_bvd
] =
4313 cpu_to_be64(mdi
->data_offset
);
4314 be16_clear(ddf
->phys
->entries
[pd
].type
,
4315 cpu_to_be16(DDF_Global_Spare
));
4316 be16_set(ddf
->phys
->entries
[pd
].type
,
4317 cpu_to_be16(DDF_Active_in_VD
));
4318 ddf_set_updates_pending(ddf
);
4321 be16 old
= ddf
->phys
->entries
[pd
].state
;
4322 if (state
& DS_FAULTY
)
4323 be16_set(ddf
->phys
->entries
[pd
].state
,
4324 cpu_to_be16(DDF_Failed
));
4325 if (state
& DS_INSYNC
) {
4326 be16_set(ddf
->phys
->entries
[pd
].state
,
4327 cpu_to_be16(DDF_Online
));
4328 be16_clear(ddf
->phys
->entries
[pd
].state
,
4329 cpu_to_be16(DDF_Rebuilding
));
4331 if (!be16_eq(old
, ddf
->phys
->entries
[pd
].state
))
4332 ddf_set_updates_pending(ddf
);
4335 dprintf("ddf: set_disk %d (%08x) to %x->%02x\n", n
,
4336 be32_to_cpu(dl
->disk
.refnum
), state
,
4337 be16_to_cpu(ddf
->phys
->entries
[pd
].state
));
4339 /* Now we need to check the state of the array and update
4340 * virtual_disk.entries[n].state.
4341 * It needs to be one of "optimal", "degraded", "failed".
4342 * I don't understand 'deleted' or 'missing'.
4344 state
= get_svd_state(ddf
, vcl
);
4346 if (ddf
->virt
->entries
[inst
].state
!=
4347 ((ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4350 ddf
->virt
->entries
[inst
].state
=
4351 (ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4353 ddf_set_updates_pending(ddf
);
4358 static void ddf_sync_metadata(struct supertype
*st
)
4362 * Write all data to all devices.
4363 * Later, we might be able to track whether only local changes
4364 * have been made, or whether any global data has been changed,
4365 * but ddf is sufficiently weird that it probably always
4366 * changes global data ....
4368 struct ddf_super
*ddf
= st
->sb
;
4369 if (!ddf
->updates_pending
)
4371 ddf
->updates_pending
= 0;
4372 __write_init_super_ddf(st
);
4373 dprintf("ddf: sync_metadata\n");
4376 static int del_from_conflist(struct vcl
**list
, const char *guid
)
4380 for (p
= list
; p
&& *p
; p
= &((*p
)->next
))
4381 if (!memcmp((*p
)->conf
.guid
, guid
, DDF_GUID_LEN
)) {
4388 static int _kill_subarray_ddf(struct ddf_super
*ddf
, const char *guid
)
4391 unsigned int vdnum
, i
;
4392 vdnum
= find_vde_by_guid(ddf
, guid
);
4393 if (vdnum
== DDF_NOTFOUND
) {
4394 pr_err("%s: could not find VD %s\n", __func__
,
4398 if (del_from_conflist(&ddf
->conflist
, guid
) == 0) {
4399 pr_err("%s: could not find conf %s\n", __func__
,
4403 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4404 for (i
= 0; i
< ddf
->max_part
; i
++)
4405 if (dl
->vlist
[i
] != NULL
&&
4406 !memcmp(dl
->vlist
[i
]->conf
.guid
, guid
,
4408 dl
->vlist
[i
] = NULL
;
4409 memset(ddf
->virt
->entries
[vdnum
].guid
, 0xff, DDF_GUID_LEN
);
4410 dprintf("%s: deleted %s\n", __func__
, guid_str(guid
));
4414 static int kill_subarray_ddf(struct supertype
*st
)
4416 struct ddf_super
*ddf
= st
->sb
;
4418 * currentconf is set in container_content_ddf,
4419 * called with subarray arg
4421 struct vcl
*victim
= ddf
->currentconf
;
4422 struct vd_config
*conf
;
4423 ddf
->currentconf
= NULL
;
4426 pr_err("%s: nothing to kill\n", __func__
);
4429 conf
= &victim
->conf
;
4430 vdnum
= find_vde_by_guid(ddf
, conf
->guid
);
4431 if (vdnum
== DDF_NOTFOUND
) {
4432 pr_err("%s: could not find VD %s\n", __func__
,
4433 guid_str(conf
->guid
));
4436 if (st
->update_tail
) {
4437 struct virtual_disk
*vd
;
4438 int len
= sizeof(struct virtual_disk
)
4439 + sizeof(struct virtual_entry
);
4442 pr_err("%s: failed to allocate %d bytes\n", __func__
,
4446 memset(vd
, 0 , len
);
4447 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
4448 vd
->populated_vdes
= cpu_to_be16(0);
4449 memcpy(vd
->entries
[0].guid
, conf
->guid
, DDF_GUID_LEN
);
4450 /* we use DDF_state_deleted as marker */
4451 vd
->entries
[0].state
= DDF_state_deleted
;
4452 append_metadata_update(st
, vd
, len
);
4454 _kill_subarray_ddf(ddf
, conf
->guid
);
4455 ddf_set_updates_pending(ddf
);
4456 ddf_sync_metadata(st
);
4461 static void copy_matching_bvd(struct ddf_super
*ddf
,
4462 struct vd_config
*conf
,
4463 const struct metadata_update
*update
)
4466 be16_to_cpu(ddf
->anchor
.max_primary_element_entries
);
4467 unsigned int len
= ddf
->conf_rec_len
* 512;
4469 struct vd_config
*vc
;
4470 for (p
= update
->buf
; p
< update
->buf
+ update
->len
; p
+= len
) {
4471 vc
= (struct vd_config
*) p
;
4472 if (vc
->sec_elmnt_seq
== conf
->sec_elmnt_seq
) {
4473 memcpy(conf
->phys_refnum
, vc
->phys_refnum
,
4474 mppe
* (sizeof(__u32
) + sizeof(__u64
)));
4478 pr_err("%s: no match for BVD %d of %s in update\n", __func__
,
4479 conf
->sec_elmnt_seq
, guid_str(conf
->guid
));
4482 static void ddf_process_update(struct supertype
*st
,
4483 struct metadata_update
*update
)
4485 /* Apply this update to the metadata.
4486 * The first 4 bytes are a DDF_*_MAGIC which guides
4488 * Possible update are:
4489 * DDF_PHYS_RECORDS_MAGIC
4490 * Add a new physical device or remove an old one.
4491 * Changes to this record only happen implicitly.
4492 * used_pdes is the device number.
4493 * DDF_VIRT_RECORDS_MAGIC
4494 * Add a new VD. Possibly also change the 'access' bits.
4495 * populated_vdes is the entry number.
4497 * New or updated VD. the VIRT_RECORD must already
4498 * exist. For an update, phys_refnum and lba_offset
4499 * (at least) are updated, and the VD_CONF must
4500 * be written to precisely those devices listed with
4502 * DDF_SPARE_ASSIGN_MAGIC
4503 * replacement Spare Assignment Record... but for which device?
4506 * - to create a new array, we send a VIRT_RECORD and
4507 * a VD_CONF. Then assemble and start the array.
4508 * - to activate a spare we send a VD_CONF to add the phys_refnum
4509 * and offset. This will also mark the spare as active with
4510 * a spare-assignment record.
4512 struct ddf_super
*ddf
= st
->sb
;
4513 be32
*magic
= (be32
*)update
->buf
;
4514 struct phys_disk
*pd
;
4515 struct virtual_disk
*vd
;
4516 struct vd_config
*vc
;
4520 unsigned int pdnum
, pd2
, len
;
4522 dprintf("Process update %x\n", be32_to_cpu(*magic
));
4524 if (be32_eq(*magic
, DDF_PHYS_RECORDS_MAGIC
)) {
4526 if (update
->len
!= (sizeof(struct phys_disk
) +
4527 sizeof(struct phys_disk_entry
)))
4529 pd
= (struct phys_disk
*)update
->buf
;
4531 ent
= be16_to_cpu(pd
->used_pdes
);
4532 if (ent
>= be16_to_cpu(ddf
->phys
->max_pdes
))
4534 if (be16_and(pd
->entries
[0].state
, cpu_to_be16(DDF_Missing
))) {
4536 /* removing this disk. */
4537 be16_set(ddf
->phys
->entries
[ent
].state
,
4538 cpu_to_be16(DDF_Missing
));
4539 for (dlp
= &ddf
->dlist
; *dlp
; dlp
= &(*dlp
)->next
) {
4540 struct dl
*dl
= *dlp
;
4541 if (dl
->pdnum
== (signed)ent
) {
4544 /* FIXME this doesn't free
4551 ddf_set_updates_pending(ddf
);
4554 if (!all_ff(ddf
->phys
->entries
[ent
].guid
))
4556 ddf
->phys
->entries
[ent
] = pd
->entries
[0];
4557 ddf
->phys
->used_pdes
= cpu_to_be16
4558 (1 + be16_to_cpu(ddf
->phys
->used_pdes
));
4559 ddf_set_updates_pending(ddf
);
4560 if (ddf
->add_list
) {
4561 struct active_array
*a
;
4562 struct dl
*al
= ddf
->add_list
;
4563 ddf
->add_list
= al
->next
;
4565 al
->next
= ddf
->dlist
;
4568 /* As a device has been added, we should check
4569 * for any degraded devices that might make
4570 * use of this spare */
4571 for (a
= st
->arrays
; a
; a
=a
->next
)
4572 a
->check_degraded
= 1;
4574 } else if (be32_eq(*magic
, DDF_VIRT_RECORDS_MAGIC
)) {
4576 if (update
->len
!= (sizeof(struct virtual_disk
) +
4577 sizeof(struct virtual_entry
)))
4579 vd
= (struct virtual_disk
*)update
->buf
;
4581 if (vd
->entries
[0].state
== DDF_state_deleted
) {
4582 if (_kill_subarray_ddf(ddf
, vd
->entries
[0].guid
))
4586 ent
= find_vde_by_guid(ddf
, vd
->entries
[0].guid
);
4587 if (ent
!= DDF_NOTFOUND
) {
4588 dprintf("%s: VD %s exists already in slot %d\n",
4589 __func__
, guid_str(vd
->entries
[0].guid
),
4593 ent
= find_unused_vde(ddf
);
4594 if (ent
== DDF_NOTFOUND
)
4596 ddf
->virt
->entries
[ent
] = vd
->entries
[0];
4597 ddf
->virt
->populated_vdes
=
4600 ddf
->virt
->populated_vdes
));
4601 dprintf("%s: added VD %s in slot %d(s=%02x i=%02x)\n",
4602 __func__
, guid_str(vd
->entries
[0].guid
), ent
,
4603 ddf
->virt
->entries
[ent
].state
,
4604 ddf
->virt
->entries
[ent
].init_state
);
4606 ddf_set_updates_pending(ddf
);
4609 else if (be32_eq(*magic
, DDF_VD_CONF_MAGIC
)) {
4610 vc
= (struct vd_config
*)update
->buf
;
4611 len
= ddf
->conf_rec_len
* 512;
4612 if ((unsigned int)update
->len
!= len
* vc
->sec_elmnt_count
) {
4613 pr_err("%s: %s: insufficient data (%d) for %u BVDs\n",
4614 __func__
, guid_str(vc
->guid
), update
->len
,
4615 vc
->sec_elmnt_count
);
4618 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
)
4619 if (memcmp(vcl
->conf
.guid
, vc
->guid
, DDF_GUID_LEN
) == 0)
4621 dprintf("%s: conf update for %s (%s)\n", __func__
,
4622 guid_str(vc
->guid
), (vcl
? "old" : "new"));
4624 /* An update, just copy the phys_refnum and lba_offset
4629 copy_matching_bvd(ddf
, &vcl
->conf
, update
);
4630 for (k
= 0; k
< be16_to_cpu(vc
->prim_elmnt_count
); k
++)
4631 dprintf("BVD %u has %08x at %llu\n", 0,
4632 be32_to_cpu(vcl
->conf
.phys_refnum
[k
]),
4633 be64_to_cpu(LBA_OFFSET(ddf
,
4635 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++) {
4636 copy_matching_bvd(ddf
, vcl
->other_bvds
[i
-1],
4638 for (k
= 0; k
< be16_to_cpu(
4639 vc
->prim_elmnt_count
); k
++)
4640 dprintf("BVD %u has %08x at %llu\n", i
,
4642 (vcl
->other_bvds
[i
-1]->
4647 vcl
->other_bvds
[i
-1])[k
]));
4654 vcl
= update
->space
;
4655 update
->space
= NULL
;
4656 vcl
->next
= ddf
->conflist
;
4657 memcpy(&vcl
->conf
, vc
, len
);
4658 ent
= find_vde_by_guid(ddf
, vc
->guid
);
4659 if (ent
== DDF_NOTFOUND
)
4662 ddf
->conflist
= vcl
;
4663 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++)
4664 memcpy(vcl
->other_bvds
[i
-1],
4665 update
->buf
+ len
* i
, len
);
4667 /* Set DDF_Transition on all Failed devices - to help
4668 * us detect those that are no longer in use
4670 for (pdnum
= 0; pdnum
< be16_to_cpu(ddf
->phys
->used_pdes
);
4672 if (be16_and(ddf
->phys
->entries
[pdnum
].state
,
4673 cpu_to_be16(DDF_Failed
)))
4674 be16_set(ddf
->phys
->entries
[pdnum
].state
,
4675 cpu_to_be16(DDF_Transition
));
4676 /* Now make sure vlist is correct for each dl. */
4677 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
4678 unsigned int vn
= 0;
4679 int in_degraded
= 0;
4680 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
) {
4681 unsigned int dn
, ibvd
;
4682 const struct vd_config
*conf
;
4684 dn
= get_pd_index_from_refnum(vcl
,
4688 if (dn
== DDF_NOTFOUND
)
4690 dprintf("dev %d/%08x has %s (sec=%u) at %d\n",
4692 be32_to_cpu(dl
->disk
.refnum
),
4693 guid_str(conf
->guid
),
4694 conf
->sec_elmnt_seq
, vn
);
4695 /* Clear the Transition flag */
4697 (ddf
->phys
->entries
[dl
->pdnum
].state
,
4698 cpu_to_be16(DDF_Failed
)))
4699 be16_clear(ddf
->phys
4700 ->entries
[dl
->pdnum
].state
,
4701 cpu_to_be16(DDF_Transition
));
4702 dl
->vlist
[vn
++] = vcl
;
4703 vstate
= ddf
->virt
->entries
[vcl
->vcnum
].state
4705 if (vstate
== DDF_state_degraded
||
4706 vstate
== DDF_state_part_optimal
)
4709 while (vn
< ddf
->max_part
)
4710 dl
->vlist
[vn
++] = NULL
;
4712 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4713 cpu_to_be16(DDF_Global_Spare
));
4714 if (!be16_and(ddf
->phys
4715 ->entries
[dl
->pdnum
].type
,
4716 cpu_to_be16(DDF_Active_in_VD
))) {
4718 ->entries
[dl
->pdnum
].type
,
4719 cpu_to_be16(DDF_Active_in_VD
));
4722 ->entries
[dl
->pdnum
]
4729 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4730 cpu_to_be16(DDF_Global_Spare
));
4731 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
4732 cpu_to_be16(DDF_Spare
));
4734 if (!dl
->vlist
[0] && !dl
->spare
) {
4735 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
4736 cpu_to_be16(DDF_Global_Spare
));
4737 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4738 cpu_to_be16(DDF_Spare
));
4739 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4740 cpu_to_be16(DDF_Active_in_VD
));
4744 /* Now remove any 'Failed' devices that are not part
4745 * of any VD. They will have the Transition flag set.
4746 * Once done, we need to update all dl->pdnum numbers.
4749 for (pdnum
= 0; pdnum
< be16_to_cpu(ddf
->phys
->used_pdes
);
4751 if (be16_and(ddf
->phys
->entries
[pdnum
].state
,
4752 cpu_to_be16(DDF_Failed
))
4753 && be16_and(ddf
->phys
->entries
[pdnum
].state
,
4754 cpu_to_be16(DDF_Transition
))) {
4755 /* skip this one unless in dlist*/
4756 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4757 if (dl
->pdnum
== (int)pdnum
)
4765 ddf
->phys
->entries
[pd2
] =
4766 ddf
->phys
->entries
[pdnum
];
4767 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4768 if (dl
->pdnum
== (int)pdnum
)
4773 ddf
->phys
->used_pdes
= cpu_to_be16(pd2
);
4774 while (pd2
< pdnum
) {
4775 memset(ddf
->phys
->entries
[pd2
].guid
, 0xff,
4780 ddf_set_updates_pending(ddf
);
4782 /* case DDF_SPARE_ASSIGN_MAGIC */
4785 static void ddf_prepare_update(struct supertype
*st
,
4786 struct metadata_update
*update
)
4788 /* This update arrived at managemon.
4789 * We are about to pass it to monitor.
4790 * If a malloc is needed, do it here.
4792 struct ddf_super
*ddf
= st
->sb
;
4793 be32
*magic
= (be32
*)update
->buf
;
4794 if (be32_eq(*magic
, DDF_VD_CONF_MAGIC
)) {
4796 struct vd_config
*conf
= (struct vd_config
*) update
->buf
;
4797 if (posix_memalign(&update
->space
, 512,
4798 offsetof(struct vcl
, conf
)
4799 + ddf
->conf_rec_len
* 512) != 0) {
4800 update
->space
= NULL
;
4803 vcl
= update
->space
;
4804 vcl
->conf
.sec_elmnt_count
= conf
->sec_elmnt_count
;
4805 if (alloc_other_bvds(ddf
, vcl
) != 0) {
4806 free(update
->space
);
4807 update
->space
= NULL
;
4813 * Check degraded state of a RAID10.
4814 * returns 2 for good, 1 for degraded, 0 for failed, and -1 for error
4816 static int raid10_degraded(struct mdinfo
*info
)
4824 n_prim
= info
->array
.layout
& ~0x100;
4825 n_bvds
= info
->array
.raid_disks
/ n_prim
;
4826 found
= xmalloc(n_bvds
);
4829 memset(found
, 0, n_bvds
);
4830 for (d
= info
->devs
; d
; d
= d
->next
) {
4831 i
= d
->disk
.raid_disk
/ n_prim
;
4833 pr_err("%s: BUG: invalid raid disk\n", __func__
);
4836 if (d
->state_fd
> 0)
4840 for (i
= 0; i
< n_bvds
; i
++)
4842 dprintf("%s: BVD %d/%d failed\n", __func__
, i
, n_bvds
);
4845 } else if (found
[i
] < n_prim
) {
4846 dprintf("%s: BVD %d/%d degraded\n", __func__
, i
,
4856 * Check if the array 'a' is degraded but not failed.
4857 * If it is, find as many spares as are available and needed and
4858 * arrange for their inclusion.
4859 * We only choose devices which are not already in the array,
4860 * and prefer those with a spare-assignment to this array.
4861 * otherwise we choose global spares - assuming always that
4862 * there is enough room.
4863 * For each spare that we assign, we return an 'mdinfo' which
4864 * describes the position for the device in the array.
4865 * We also add to 'updates' a DDF_VD_CONF_MAGIC update with
4866 * the new phys_refnum and lba_offset values.
4868 * Only worry about BVDs at the moment.
4870 static struct mdinfo
*ddf_activate_spare(struct active_array
*a
,
4871 struct metadata_update
**updates
)
4875 struct ddf_super
*ddf
= a
->container
->sb
;
4877 struct mdinfo
*rv
= NULL
;
4879 struct metadata_update
*mu
;
4884 struct vd_config
*vc
;
4887 for (d
= a
->info
.devs
; d
; d
= d
->next
) {
4888 if ((d
->curr_state
& DS_FAULTY
) &&
4890 /* wait for Removal to happen */
4892 if (d
->state_fd
>= 0)
4896 dprintf("%s: working=%d (%d) level=%d\n", __func__
, working
,
4897 a
->info
.array
.raid_disks
,
4898 a
->info
.array
.level
);
4899 if (working
== a
->info
.array
.raid_disks
)
4900 return NULL
; /* array not degraded */
4901 switch (a
->info
.array
.level
) {
4904 return NULL
; /* failed */
4908 if (working
< a
->info
.array
.raid_disks
- 1)
4909 return NULL
; /* failed */
4912 if (working
< a
->info
.array
.raid_disks
- 2)
4913 return NULL
; /* failed */
4916 if (raid10_degraded(&a
->info
) < 1)
4919 default: /* concat or stripe */
4920 return NULL
; /* failed */
4923 /* For each slot, if it is not working, find a spare */
4925 for (i
= 0; i
< a
->info
.array
.raid_disks
; i
++) {
4926 for (d
= a
->info
.devs
; d
; d
= d
->next
)
4927 if (d
->disk
.raid_disk
== i
)
4929 dprintf("found %d: %p %x\n", i
, d
, d
?d
->curr_state
:0);
4930 if (d
&& (d
->state_fd
>= 0))
4933 /* OK, this device needs recovery. Find a spare */
4935 for ( ; dl
; dl
= dl
->next
) {
4936 unsigned long long esize
;
4937 unsigned long long pos
;
4940 int is_dedicated
= 0;
4943 be16 state
= ddf
->phys
->entries
[dl
->pdnum
].state
;
4945 cpu_to_be16(DDF_Failed
|DDF_Missing
)) ||
4947 cpu_to_be16(DDF_Online
)))
4950 /* If in this array, skip */
4951 for (d2
= a
->info
.devs
; d2
; d2
= d2
->next
)
4952 if (d2
->state_fd
>= 0 &&
4953 d2
->disk
.major
== dl
->major
&&
4954 d2
->disk
.minor
== dl
->minor
) {
4955 dprintf("%x:%x (%08x) already in array\n",
4956 dl
->major
, dl
->minor
,
4957 be32_to_cpu(dl
->disk
.refnum
));
4962 if (be16_and(ddf
->phys
->entries
[dl
->pdnum
].type
,
4963 cpu_to_be16(DDF_Spare
))) {
4964 /* Check spare assign record */
4966 if (dl
->spare
->type
& DDF_spare_dedicated
) {
4967 /* check spare_ents for guid */
4973 if (memcmp(dl
->spare
->spare_ents
[j
].guid
,
4974 ddf
->virt
->entries
[a
->info
.container_member
].guid
,
4981 } else if (be16_and(ddf
->phys
->entries
[dl
->pdnum
].type
,
4982 cpu_to_be16(DDF_Global_Spare
))) {
4984 } else if (!be16_and(ddf
->phys
4985 ->entries
[dl
->pdnum
].state
,
4986 cpu_to_be16(DDF_Failed
))) {
4987 /* we can possibly use some of this */
4990 if ( ! (is_dedicated
||
4991 (is_global
&& global_ok
))) {
4992 dprintf("%x:%x not suitable: %d %d\n", dl
->major
, dl
->minor
,
4993 is_dedicated
, is_global
);
4997 /* We are allowed to use this device - is there space?
4998 * We need a->info.component_size sectors */
4999 ex
= get_extents(ddf
, dl
);
5001 dprintf("cannot get extents\n");
5008 esize
= ex
[j
].start
- pos
;
5009 if (esize
>= a
->info
.component_size
)
5011 pos
= ex
[j
].start
+ ex
[j
].size
;
5013 } while (ex
[j
-1].size
);
5016 if (esize
< a
->info
.component_size
) {
5017 dprintf("%x:%x has no room: %llu %llu\n",
5018 dl
->major
, dl
->minor
,
5019 esize
, a
->info
.component_size
);
5024 /* Cool, we have a device with some space at pos */
5025 di
= xcalloc(1, sizeof(*di
));
5026 di
->disk
.number
= i
;
5027 di
->disk
.raid_disk
= i
;
5028 di
->disk
.major
= dl
->major
;
5029 di
->disk
.minor
= dl
->minor
;
5031 di
->recovery_start
= 0;
5032 di
->data_offset
= pos
;
5033 di
->component_size
= a
->info
.component_size
;
5034 di
->container_member
= dl
->pdnum
;
5037 dprintf("%x:%x (%08x) to be %d at %llu\n",
5038 dl
->major
, dl
->minor
,
5039 be32_to_cpu(dl
->disk
.refnum
), i
, pos
);
5043 if (!dl
&& ! global_ok
) {
5044 /* not enough dedicated spares, try global */
5052 /* No spares found */
5054 /* Now 'rv' has a list of devices to return.
5055 * Create a metadata_update record to update the
5056 * phys_refnum and lba_offset values
5058 vc
= find_vdcr(ddf
, a
->info
.container_member
, rv
->disk
.raid_disk
,
5063 mu
= xmalloc(sizeof(*mu
));
5064 if (posix_memalign(&mu
->space
, 512, sizeof(struct vcl
)) != 0) {
5069 mu
->len
= ddf
->conf_rec_len
* 512 * vcl
->conf
.sec_elmnt_count
;
5070 mu
->buf
= xmalloc(mu
->len
);
5072 mu
->space_list
= NULL
;
5073 mu
->next
= *updates
;
5074 memcpy(mu
->buf
, &vcl
->conf
, ddf
->conf_rec_len
* 512);
5075 for (j
= 1; j
< vcl
->conf
.sec_elmnt_count
; j
++)
5076 memcpy(mu
->buf
+ j
* ddf
->conf_rec_len
* 512,
5077 vcl
->other_bvds
[j
-1], ddf
->conf_rec_len
* 512);
5079 vc
= (struct vd_config
*)mu
->buf
;
5080 for (di
= rv
; di
; di
= di
->next
) {
5081 unsigned int i_sec
, i_prim
;
5082 i_sec
= di
->disk
.raid_disk
5083 / be16_to_cpu(vcl
->conf
.prim_elmnt_count
);
5084 i_prim
= di
->disk
.raid_disk
5085 % be16_to_cpu(vcl
->conf
.prim_elmnt_count
);
5086 vc
= (struct vd_config
*)(mu
->buf
5087 + i_sec
* ddf
->conf_rec_len
* 512);
5088 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
5089 if (dl
->major
== di
->disk
.major
5090 && dl
->minor
== di
->disk
.minor
)
5093 pr_err("%s: BUG: can't find disk %d (%d/%d)\n",
5094 __func__
, di
->disk
.raid_disk
,
5095 di
->disk
.major
, di
->disk
.minor
);
5098 vc
->phys_refnum
[i_prim
] = ddf
->phys
->entries
[dl
->pdnum
].refnum
;
5099 LBA_OFFSET(ddf
, vc
)[i_prim
] = cpu_to_be64(di
->data_offset
);
5100 dprintf("BVD %u gets %u: %08x at %llu\n", i_sec
, i_prim
,
5101 be32_to_cpu(vc
->phys_refnum
[i_prim
]),
5102 be64_to_cpu(LBA_OFFSET(ddf
, vc
)[i_prim
]));
5107 #endif /* MDASSEMBLE */
5109 static int ddf_level_to_layout(int level
)
5116 return ALGORITHM_LEFT_SYMMETRIC
;
5118 return ALGORITHM_ROTATING_N_CONTINUE
;
5126 static void default_geometry_ddf(struct supertype
*st
, int *level
, int *layout
, int *chunk
)
5128 if (level
&& *level
== UnSet
)
5129 *level
= LEVEL_CONTAINER
;
5131 if (level
&& layout
&& *layout
== UnSet
)
5132 *layout
= ddf_level_to_layout(*level
);
5135 struct superswitch super_ddf
= {
5137 .examine_super
= examine_super_ddf
,
5138 .brief_examine_super
= brief_examine_super_ddf
,
5139 .brief_examine_subarrays
= brief_examine_subarrays_ddf
,
5140 .export_examine_super
= export_examine_super_ddf
,
5141 .detail_super
= detail_super_ddf
,
5142 .brief_detail_super
= brief_detail_super_ddf
,
5143 .validate_geometry
= validate_geometry_ddf
,
5144 .write_init_super
= write_init_super_ddf
,
5145 .add_to_super
= add_to_super_ddf
,
5146 .remove_from_super
= remove_from_super_ddf
,
5147 .load_container
= load_container_ddf
,
5148 .copy_metadata
= copy_metadata_ddf
,
5149 .kill_subarray
= kill_subarray_ddf
,
5151 .match_home
= match_home_ddf
,
5152 .uuid_from_super
= uuid_from_super_ddf
,
5153 .getinfo_super
= getinfo_super_ddf
,
5154 .update_super
= update_super_ddf
,
5156 .avail_size
= avail_size_ddf
,
5158 .compare_super
= compare_super_ddf
,
5160 .load_super
= load_super_ddf
,
5161 .init_super
= init_super_ddf
,
5162 .store_super
= store_super_ddf
,
5163 .free_super
= free_super_ddf
,
5164 .match_metadata_desc
= match_metadata_desc_ddf
,
5165 .container_content
= container_content_ddf
,
5166 .default_geometry
= default_geometry_ddf
,
5172 .open_new
= ddf_open_new
,
5173 .set_array_state
= ddf_set_array_state
,
5174 .set_disk
= ddf_set_disk
,
5175 .sync_metadata
= ddf_sync_metadata
,
5176 .process_update
= ddf_process_update
,
5177 .prepare_update
= ddf_prepare_update
,
5178 .activate_spare
= ddf_activate_spare
,