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
;
884 pr_err("Failed to load secondary DDF header on %s\n",
886 if (super
->active
== NULL
)
891 static int load_ddf_global(int fd
, struct ddf_super
*super
, char *devname
)
894 ok
= load_section(fd
, super
, &super
->controller
,
895 super
->active
->controller_section_offset
,
896 super
->active
->controller_section_length
,
898 super
->phys
= load_section(fd
, super
, NULL
,
899 super
->active
->phys_section_offset
,
900 super
->active
->phys_section_length
,
902 super
->pdsize
= be32_to_cpu(super
->active
->phys_section_length
) * 512;
904 super
->virt
= load_section(fd
, super
, NULL
,
905 super
->active
->virt_section_offset
,
906 super
->active
->virt_section_length
,
908 super
->vdsize
= be32_to_cpu(super
->active
->virt_section_length
) * 512;
918 super
->conflist
= NULL
;
921 super
->max_part
= be16_to_cpu(super
->active
->max_partitions
);
922 super
->mppe
= be16_to_cpu(super
->active
->max_primary_element_entries
);
923 super
->conf_rec_len
= be16_to_cpu(super
->active
->config_record_len
);
927 #define DDF_UNUSED_BVD 0xff
928 static int alloc_other_bvds(const struct ddf_super
*ddf
, struct vcl
*vcl
)
930 unsigned int n_vds
= vcl
->conf
.sec_elmnt_count
- 1;
931 unsigned int i
, vdsize
;
934 vcl
->other_bvds
= NULL
;
937 vdsize
= ddf
->conf_rec_len
* 512;
938 if (posix_memalign(&p
, 512, n_vds
*
939 (vdsize
+ sizeof(struct vd_config
*))) != 0)
941 vcl
->other_bvds
= (struct vd_config
**) (p
+ n_vds
* vdsize
);
942 for (i
= 0; i
< n_vds
; i
++) {
943 vcl
->other_bvds
[i
] = p
+ i
* vdsize
;
944 memset(vcl
->other_bvds
[i
], 0, vdsize
);
945 vcl
->other_bvds
[i
]->sec_elmnt_seq
= DDF_UNUSED_BVD
;
950 static void add_other_bvd(struct vcl
*vcl
, struct vd_config
*vd
,
954 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
955 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== vd
->sec_elmnt_seq
)
958 if (i
< vcl
->conf
.sec_elmnt_count
-1) {
959 if (be32_to_cpu(vd
->seqnum
) <=
960 be32_to_cpu(vcl
->other_bvds
[i
]->seqnum
))
963 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
964 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== DDF_UNUSED_BVD
)
966 if (i
== vcl
->conf
.sec_elmnt_count
-1) {
967 pr_err("no space for sec level config %u, count is %u\n",
968 vd
->sec_elmnt_seq
, vcl
->conf
.sec_elmnt_count
);
972 memcpy(vcl
->other_bvds
[i
], vd
, len
);
975 static int load_ddf_local(int fd
, struct ddf_super
*super
,
976 char *devname
, int keep
)
982 unsigned int confsec
;
984 unsigned int max_virt_disks
= be16_to_cpu
985 (super
->active
->max_vd_entries
);
986 unsigned long long dsize
;
988 /* First the local disk info */
989 if (posix_memalign((void**)&dl
, 512,
991 (super
->max_part
) * sizeof(dl
->vlist
[0])) != 0) {
992 pr_err("%s could not allocate disk info buffer\n",
997 load_section(fd
, super
, &dl
->disk
,
998 super
->active
->data_section_offset
,
999 super
->active
->data_section_length
,
1001 dl
->devname
= devname
? xstrdup(devname
) : NULL
;
1004 dl
->major
= major(stb
.st_rdev
);
1005 dl
->minor
= minor(stb
.st_rdev
);
1006 dl
->next
= super
->dlist
;
1007 dl
->fd
= keep
? fd
: -1;
1010 if (get_dev_size(fd
, devname
, &dsize
))
1011 dl
->size
= dsize
>> 9;
1012 /* If the disks have different sizes, the LBAs will differ
1013 * between phys disks.
1014 * At this point here, the values in super->active must be valid
1015 * for this phys disk. */
1016 dl
->primary_lba
= super
->active
->primary_lba
;
1017 dl
->secondary_lba
= super
->active
->secondary_lba
;
1018 dl
->workspace_lba
= super
->active
->workspace_lba
;
1020 for (i
= 0 ; i
< super
->max_part
; i
++)
1021 dl
->vlist
[i
] = NULL
;
1024 for (i
= 0; i
< be16_to_cpu(super
->active
->max_pd_entries
); i
++)
1025 if (memcmp(super
->phys
->entries
[i
].guid
,
1026 dl
->disk
.guid
, DDF_GUID_LEN
) == 0)
1029 /* Now the config list. */
1030 /* 'conf' is an array of config entries, some of which are
1031 * probably invalid. Those which are good need to be copied into
1035 conf
= load_section(fd
, super
, super
->conf
,
1036 super
->active
->config_section_offset
,
1037 super
->active
->config_section_length
,
1042 confsec
< be32_to_cpu(super
->active
->config_section_length
);
1043 confsec
+= super
->conf_rec_len
) {
1044 struct vd_config
*vd
=
1045 (struct vd_config
*)((char*)conf
+ confsec
*512);
1048 if (be32_eq(vd
->magic
, DDF_SPARE_ASSIGN_MAGIC
)) {
1051 if (posix_memalign((void**)&dl
->spare
, 512,
1052 super
->conf_rec_len
*512) != 0) {
1053 pr_err("%s could not allocate spare info buf\n",
1058 memcpy(dl
->spare
, vd
, super
->conf_rec_len
*512);
1061 if (!be32_eq(vd
->magic
, DDF_VD_CONF_MAGIC
))
1063 for (vcl
= super
->conflist
; vcl
; vcl
= vcl
->next
) {
1064 if (memcmp(vcl
->conf
.guid
,
1065 vd
->guid
, DDF_GUID_LEN
) == 0)
1070 dl
->vlist
[vnum
++] = vcl
;
1071 if (vcl
->other_bvds
!= NULL
&&
1072 vcl
->conf
.sec_elmnt_seq
!= vd
->sec_elmnt_seq
) {
1073 add_other_bvd(vcl
, vd
, super
->conf_rec_len
*512);
1076 if (be32_to_cpu(vd
->seqnum
) <=
1077 be32_to_cpu(vcl
->conf
.seqnum
))
1080 if (posix_memalign((void**)&vcl
, 512,
1081 (super
->conf_rec_len
*512 +
1082 offsetof(struct vcl
, conf
))) != 0) {
1083 pr_err("%s could not allocate vcl buf\n",
1087 vcl
->next
= super
->conflist
;
1088 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
1089 vcl
->conf
.sec_elmnt_count
= vd
->sec_elmnt_count
;
1090 if (alloc_other_bvds(super
, vcl
) != 0) {
1091 pr_err("%s could not allocate other bvds\n",
1096 super
->conflist
= vcl
;
1097 dl
->vlist
[vnum
++] = vcl
;
1099 memcpy(&vcl
->conf
, vd
, super
->conf_rec_len
*512);
1100 for (i
=0; i
< max_virt_disks
; i
++)
1101 if (memcmp(super
->virt
->entries
[i
].guid
,
1102 vcl
->conf
.guid
, DDF_GUID_LEN
)==0)
1104 if (i
< max_virt_disks
)
1112 static int load_super_ddf_all(struct supertype
*st
, int fd
,
1113 void **sbp
, char *devname
);
1116 static void free_super_ddf(struct supertype
*st
);
1118 static int load_super_ddf(struct supertype
*st
, int fd
,
1121 unsigned long long dsize
;
1122 struct ddf_super
*super
;
1125 if (get_dev_size(fd
, devname
, &dsize
) == 0)
1128 if (!st
->ignore_hw_compat
&& test_partition(fd
))
1129 /* DDF is not allowed on partitions */
1132 /* 32M is a lower bound */
1133 if (dsize
<= 32*1024*1024) {
1135 pr_err("%s is too small for ddf: "
1136 "size is %llu sectors.\n",
1142 pr_err("%s is an odd size for ddf: "
1143 "size is %llu bytes.\n",
1150 if (posix_memalign((void**)&super
, 512, sizeof(*super
))!= 0) {
1151 pr_err("malloc of %zu failed.\n",
1155 memset(super
, 0, sizeof(*super
));
1157 rv
= load_ddf_headers(fd
, super
, devname
);
1163 /* Have valid headers and have chosen the best. Let's read in the rest*/
1165 rv
= load_ddf_global(fd
, super
, devname
);
1169 pr_err("Failed to load all information "
1170 "sections on %s\n", devname
);
1175 rv
= load_ddf_local(fd
, super
, devname
, 0);
1179 pr_err("Failed to load all information "
1180 "sections on %s\n", devname
);
1185 /* Should possibly check the sections .... */
1188 if (st
->ss
== NULL
) {
1189 st
->ss
= &super_ddf
;
1190 st
->minor_version
= 0;
1197 static void free_super_ddf(struct supertype
*st
)
1199 struct ddf_super
*ddf
= st
->sb
;
1205 while (ddf
->conflist
) {
1206 struct vcl
*v
= ddf
->conflist
;
1207 ddf
->conflist
= v
->next
;
1209 free(v
->block_sizes
);
1212 v->other_bvds[0] points to beginning of buffer,
1213 see alloc_other_bvds()
1215 free(v
->other_bvds
[0]);
1218 while (ddf
->dlist
) {
1219 struct dl
*d
= ddf
->dlist
;
1220 ddf
->dlist
= d
->next
;
1227 while (ddf
->add_list
) {
1228 struct dl
*d
= ddf
->add_list
;
1229 ddf
->add_list
= d
->next
;
1240 static struct supertype
*match_metadata_desc_ddf(char *arg
)
1242 /* 'ddf' only support containers */
1243 struct supertype
*st
;
1244 if (strcmp(arg
, "ddf") != 0 &&
1245 strcmp(arg
, "default") != 0
1249 st
= xcalloc(1, sizeof(*st
));
1250 st
->ss
= &super_ddf
;
1252 st
->minor_version
= 0;
1259 static mapping_t ddf_state
[] = {
1265 { "Partially Optimal", 5},
1271 static mapping_t ddf_init_state
[] = {
1272 { "Not Initialised", 0},
1273 { "QuickInit in Progress", 1},
1274 { "Fully Initialised", 2},
1278 static mapping_t ddf_access
[] = {
1282 { "Blocked (no access)", 3},
1286 static mapping_t ddf_level
[] = {
1287 { "RAID0", DDF_RAID0
},
1288 { "RAID1", DDF_RAID1
},
1289 { "RAID3", DDF_RAID3
},
1290 { "RAID4", DDF_RAID4
},
1291 { "RAID5", DDF_RAID5
},
1292 { "RAID1E",DDF_RAID1E
},
1293 { "JBOD", DDF_JBOD
},
1294 { "CONCAT",DDF_CONCAT
},
1295 { "RAID5E",DDF_RAID5E
},
1296 { "RAID5EE",DDF_RAID5EE
},
1297 { "RAID6", DDF_RAID6
},
1300 static mapping_t ddf_sec_level
[] = {
1301 { "Striped", DDF_2STRIPED
},
1302 { "Mirrored", DDF_2MIRRORED
},
1303 { "Concat", DDF_2CONCAT
},
1304 { "Spanned", DDF_2SPANNED
},
1309 static int all_ff(const char *guid
)
1312 for (i
= 0; i
< DDF_GUID_LEN
; i
++)
1313 if (guid
[i
] != (char)0xff)
1318 static const char *guid_str(const char *guid
)
1320 static char buf
[DDF_GUID_LEN
*2+1];
1323 for (i
= 0; i
< DDF_GUID_LEN
; i
++) {
1324 unsigned char c
= guid
[i
];
1325 if (c
>= 32 && c
< 127)
1326 p
+= sprintf(p
, "%c", c
);
1328 p
+= sprintf(p
, "%02x", c
);
1331 return (const char *) buf
;
1335 static void print_guid(char *guid
, int tstamp
)
1337 /* A GUIDs are part (or all) ASCII and part binary.
1338 * They tend to be space padded.
1339 * We print the GUID in HEX, then in parentheses add
1340 * any initial ASCII sequence, and a possible
1341 * time stamp from bytes 16-19
1343 int l
= DDF_GUID_LEN
;
1346 for (i
=0 ; i
<DDF_GUID_LEN
; i
++) {
1347 if ((i
&3)==0 && i
!= 0) printf(":");
1348 printf("%02X", guid
[i
]&255);
1352 while (l
&& guid
[l
-1] == ' ')
1354 for (i
=0 ; i
<l
; i
++) {
1355 if (guid
[i
] >= 0x20 && guid
[i
] < 0x7f)
1356 fputc(guid
[i
], stdout
);
1361 time_t then
= __be32_to_cpu(*(__u32
*)(guid
+16)) + DECADE
;
1364 tm
= localtime(&then
);
1365 strftime(tbuf
, 100, " %D %T",tm
);
1366 fputs(tbuf
, stdout
);
1371 static void examine_vd(int n
, struct ddf_super
*sb
, char *guid
)
1373 int crl
= sb
->conf_rec_len
;
1376 for (vcl
= sb
->conflist
; vcl
; vcl
= vcl
->next
) {
1378 struct vd_config
*vc
= &vcl
->conf
;
1380 if (!be32_eq(calc_crc(vc
, crl
*512), vc
->crc
))
1382 if (memcmp(vc
->guid
, guid
, DDF_GUID_LEN
) != 0)
1385 /* Ok, we know about this VD, let's give more details */
1386 printf(" Raid Devices[%d] : %d (", n
,
1387 be16_to_cpu(vc
->prim_elmnt_count
));
1388 for (i
= 0; i
< be16_to_cpu(vc
->prim_elmnt_count
); i
++) {
1390 int cnt
= be16_to_cpu(sb
->phys
->used_pdes
);
1391 for (j
=0; j
<cnt
; j
++)
1392 if (be32_eq(vc
->phys_refnum
[i
],
1393 sb
->phys
->entries
[j
].refnum
))
1402 if (vc
->chunk_shift
!= 255)
1403 printf(" Chunk Size[%d] : %d sectors\n", n
,
1404 1 << vc
->chunk_shift
);
1405 printf(" Raid Level[%d] : %s\n", n
,
1406 map_num(ddf_level
, vc
->prl
)?:"-unknown-");
1407 if (vc
->sec_elmnt_count
!= 1) {
1408 printf(" Secondary Position[%d] : %d of %d\n", n
,
1409 vc
->sec_elmnt_seq
, vc
->sec_elmnt_count
);
1410 printf(" Secondary Level[%d] : %s\n", n
,
1411 map_num(ddf_sec_level
, vc
->srl
) ?: "-unknown-");
1413 printf(" Device Size[%d] : %llu\n", n
,
1414 be64_to_cpu(vc
->blocks
)/2);
1415 printf(" Array Size[%d] : %llu\n", n
,
1416 be64_to_cpu(vc
->array_blocks
)/2);
1420 static void examine_vds(struct ddf_super
*sb
)
1422 int cnt
= be16_to_cpu(sb
->virt
->populated_vdes
);
1424 printf(" Virtual Disks : %d\n", cnt
);
1426 for (i
= 0; i
< be16_to_cpu(sb
->virt
->max_vdes
); i
++) {
1427 struct virtual_entry
*ve
= &sb
->virt
->entries
[i
];
1428 if (all_ff(ve
->guid
))
1431 printf(" VD GUID[%d] : ", i
); print_guid(ve
->guid
, 1);
1433 printf(" unit[%d] : %d\n", i
, be16_to_cpu(ve
->unit
));
1434 printf(" state[%d] : %s, %s%s\n", i
,
1435 map_num(ddf_state
, ve
->state
& 7),
1436 (ve
->state
& DDF_state_morphing
) ? "Morphing, ": "",
1437 (ve
->state
& DDF_state_inconsistent
)? "Not Consistent" : "Consistent");
1438 printf(" init state[%d] : %s\n", i
,
1439 map_num(ddf_init_state
, ve
->init_state
&DDF_initstate_mask
));
1440 printf(" access[%d] : %s\n", i
,
1441 map_num(ddf_access
, (ve
->init_state
& DDF_access_mask
) >> 6));
1442 printf(" Name[%d] : %.16s\n", i
, ve
->name
);
1443 examine_vd(i
, sb
, ve
->guid
);
1445 if (cnt
) printf("\n");
1448 static void examine_pds(struct ddf_super
*sb
)
1450 int cnt
= be16_to_cpu(sb
->phys
->used_pdes
);
1453 printf(" Physical Disks : %d\n", cnt
);
1454 printf(" Number RefNo Size Device Type/State\n");
1456 for (i
=0 ; i
<cnt
; i
++) {
1457 struct phys_disk_entry
*pd
= &sb
->phys
->entries
[i
];
1458 int type
= be16_to_cpu(pd
->type
);
1459 int state
= be16_to_cpu(pd
->state
);
1461 //printf(" PD GUID[%d] : ", i); print_guid(pd->guid, 0);
1463 printf(" %3d %08x ", i
,
1464 be32_to_cpu(pd
->refnum
));
1466 be64_to_cpu(pd
->config_size
)>>1);
1467 for (dl
= sb
->dlist
; dl
; dl
= dl
->next
) {
1468 if (be32_eq(dl
->disk
.refnum
, pd
->refnum
)) {
1469 char *dv
= map_dev(dl
->major
, dl
->minor
, 0);
1471 printf("%-15s", dv
);
1478 printf(" %s%s%s%s%s",
1479 (type
&2) ? "active":"",
1480 (type
&4) ? "Global-Spare":"",
1481 (type
&8) ? "spare" : "",
1482 (type
&16)? ", foreign" : "",
1483 (type
&32)? "pass-through" : "");
1484 if (state
& DDF_Failed
)
1485 /* This over-rides these three */
1486 state
&= ~(DDF_Online
|DDF_Rebuilding
|DDF_Transition
);
1487 printf("/%s%s%s%s%s%s%s",
1488 (state
&1)? "Online": "Offline",
1489 (state
&2)? ", Failed": "",
1490 (state
&4)? ", Rebuilding": "",
1491 (state
&8)? ", in-transition": "",
1492 (state
&16)? ", SMART-errors": "",
1493 (state
&32)? ", Unrecovered-Read-Errors": "",
1494 (state
&64)? ", Missing" : "");
1499 static void examine_super_ddf(struct supertype
*st
, char *homehost
)
1501 struct ddf_super
*sb
= st
->sb
;
1503 printf(" Magic : %08x\n", be32_to_cpu(sb
->anchor
.magic
));
1504 printf(" Version : %.8s\n", sb
->anchor
.revision
);
1505 printf("Controller GUID : "); print_guid(sb
->controller
.guid
, 0);
1507 printf(" Container GUID : "); print_guid(sb
->anchor
.guid
, 1);
1509 printf(" Seq : %08x\n", be32_to_cpu(sb
->active
->seq
));
1510 printf(" Redundant hdr : %s\n", be32_eq(sb
->secondary
.magic
,
1517 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1519 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4]);
1520 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4]);
1522 static unsigned int get_vd_num_of_subarray(struct supertype
*st
)
1525 * Figure out the VD number for this supertype.
1526 * Returns DDF_CONTAINER for the container itself,
1527 * and DDF_NOTFOUND on error.
1529 struct ddf_super
*ddf
= st
->sb
;
1534 if (*st
->container_devnm
== '\0')
1535 return DDF_CONTAINER
;
1537 sra
= sysfs_read(-1, st
->devnm
, GET_VERSION
);
1538 if (!sra
|| sra
->array
.major_version
!= -1 ||
1539 sra
->array
.minor_version
!= -2 ||
1540 !is_subarray(sra
->text_version
))
1541 return DDF_NOTFOUND
;
1543 sub
= strchr(sra
->text_version
+ 1, '/');
1545 vcnum
= strtoul(sub
+ 1, &end
, 10);
1546 if (sub
== NULL
|| *sub
== '\0' || *end
!= '\0' ||
1547 vcnum
>= be16_to_cpu(ddf
->active
->max_vd_entries
))
1548 return DDF_NOTFOUND
;
1553 static void brief_examine_super_ddf(struct supertype
*st
, int verbose
)
1555 /* We just write a generic DDF ARRAY entry
1559 getinfo_super_ddf(st
, &info
, NULL
);
1560 fname_from_uuid(st
, &info
, nbuf
, ':');
1562 printf("ARRAY metadata=ddf UUID=%s\n", nbuf
+ 5);
1565 static void brief_examine_subarrays_ddf(struct supertype
*st
, int verbose
)
1567 /* We just write a generic DDF ARRAY entry
1569 struct ddf_super
*ddf
= st
->sb
;
1573 getinfo_super_ddf(st
, &info
, NULL
);
1574 fname_from_uuid(st
, &info
, nbuf
, ':');
1576 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
1577 struct virtual_entry
*ve
= &ddf
->virt
->entries
[i
];
1580 if (all_ff(ve
->guid
))
1582 memcpy(vcl
.conf
.guid
, ve
->guid
, DDF_GUID_LEN
);
1583 ddf
->currentconf
=&vcl
;
1585 uuid_from_super_ddf(st
, info
.uuid
);
1586 fname_from_uuid(st
, &info
, nbuf1
, ':');
1587 printf("ARRAY container=%s member=%d UUID=%s\n",
1588 nbuf
+5, i
, nbuf1
+5);
1592 static void export_examine_super_ddf(struct supertype
*st
)
1596 getinfo_super_ddf(st
, &info
, NULL
);
1597 fname_from_uuid(st
, &info
, nbuf
, ':');
1598 printf("MD_METADATA=ddf\n");
1599 printf("MD_LEVEL=container\n");
1600 printf("MD_UUID=%s\n", nbuf
+5);
1601 printf("MD_DEVICES=%u\n",
1602 be16_to_cpu(((struct ddf_super
*)st
->sb
)->phys
->used_pdes
));
1605 static int copy_metadata_ddf(struct supertype
*st
, int from
, int to
)
1608 unsigned long long dsize
, offset
;
1610 struct ddf_header
*ddf
;
1613 /* The meta consists of an anchor, a primary, and a secondary.
1614 * This all lives at the end of the device.
1615 * So it is easiest to find the earliest of primary and
1616 * secondary, and copy everything from there.
1618 * Anchor is 512 from end It contains primary_lba and secondary_lba
1619 * we choose one of those
1622 if (posix_memalign(&buf
, 4096, 4096) != 0)
1625 if (!get_dev_size(from
, NULL
, &dsize
))
1628 if (lseek64(from
, dsize
-512, 0) < 0)
1630 if (read(from
, buf
, 512) != 512)
1633 if (!be32_eq(ddf
->magic
, DDF_HEADER_MAGIC
) ||
1634 !be32_eq(calc_crc(ddf
, 512), ddf
->crc
) ||
1635 (memcmp(ddf
->revision
, DDF_REVISION_0
, 8) != 0 &&
1636 memcmp(ddf
->revision
, DDF_REVISION_2
, 8) != 0))
1639 offset
= dsize
- 512;
1640 if ((be64_to_cpu(ddf
->primary_lba
) << 9) < offset
)
1641 offset
= be64_to_cpu(ddf
->primary_lba
) << 9;
1642 if ((be64_to_cpu(ddf
->secondary_lba
) << 9) < offset
)
1643 offset
= be64_to_cpu(ddf
->secondary_lba
) << 9;
1645 bytes
= dsize
- offset
;
1647 if (lseek64(from
, offset
, 0) < 0 ||
1648 lseek64(to
, offset
, 0) < 0)
1650 while (written
< bytes
) {
1651 int n
= bytes
- written
;
1654 if (read(from
, buf
, n
) != n
)
1656 if (write(to
, buf
, n
) != n
)
1667 static void detail_super_ddf(struct supertype
*st
, char *homehost
)
1670 * Could print DDF GUID
1671 * Need to find which array
1672 * If whole, briefly list all arrays
1677 static const char *vendors_with_variable_volume_UUID
[] = {
1681 static int volume_id_is_reliable(const struct ddf_super
*ddf
)
1683 int n
= sizeof(vendors_with_variable_volume_UUID
) /
1684 sizeof(vendors_with_variable_volume_UUID
[0]);
1686 for (i
= 0; i
< n
; i
++)
1687 if (!memcmp(ddf
->controller
.guid
,
1688 vendors_with_variable_volume_UUID
[i
], 8))
1693 static void uuid_of_ddf_subarray(const struct ddf_super
*ddf
,
1694 unsigned int vcnum
, int uuid
[4])
1696 char buf
[DDF_GUID_LEN
+18], sha
[20], *p
;
1697 struct sha1_ctx ctx
;
1698 if (volume_id_is_reliable(ddf
)) {
1699 uuid_from_ddf_guid(ddf
->virt
->entries
[vcnum
].guid
, uuid
);
1703 * Some fake RAID BIOSes (in particular, LSI ones) change the
1704 * VD GUID at every boot. These GUIDs are not suitable for
1705 * identifying an array. Luckily the header GUID appears to
1707 * We construct a pseudo-UUID from the header GUID and those
1708 * properties of the subarray that we expect to remain constant.
1710 memset(buf
, 0, sizeof(buf
));
1712 memcpy(p
, ddf
->anchor
.guid
, DDF_GUID_LEN
);
1714 memcpy(p
, ddf
->virt
->entries
[vcnum
].name
, 16);
1716 *((__u16
*) p
) = vcnum
;
1717 sha1_init_ctx(&ctx
);
1718 sha1_process_bytes(buf
, sizeof(buf
), &ctx
);
1719 sha1_finish_ctx(&ctx
, sha
);
1720 memcpy(uuid
, sha
, 4*4);
1723 static void brief_detail_super_ddf(struct supertype
*st
)
1727 struct ddf_super
*ddf
= st
->sb
;
1728 unsigned int vcnum
= get_vd_num_of_subarray(st
);
1729 if (vcnum
== DDF_CONTAINER
)
1730 uuid_from_super_ddf(st
, info
.uuid
);
1731 else if (vcnum
== DDF_NOTFOUND
)
1734 uuid_of_ddf_subarray(ddf
, vcnum
, info
.uuid
);
1735 fname_from_uuid(st
, &info
, nbuf
,':');
1736 printf(" UUID=%s", nbuf
+ 5);
1740 static int match_home_ddf(struct supertype
*st
, char *homehost
)
1742 /* It matches 'this' host if the controller is a
1743 * Linux-MD controller with vendor_data matching
1746 struct ddf_super
*ddf
= st
->sb
;
1751 len
= strlen(homehost
);
1753 return (memcmp(ddf
->controller
.guid
, T10
, 8) == 0 &&
1754 len
< sizeof(ddf
->controller
.vendor_data
) &&
1755 memcmp(ddf
->controller
.vendor_data
, homehost
,len
) == 0 &&
1756 ddf
->controller
.vendor_data
[len
] == 0);
1760 static int find_index_in_bvd(const struct ddf_super
*ddf
,
1761 const struct vd_config
*conf
, unsigned int n
,
1762 unsigned int *n_bvd
)
1765 * Find the index of the n-th valid physical disk in this BVD
1768 for (i
= 0, j
= 0; i
< ddf
->mppe
&&
1769 j
< be16_to_cpu(conf
->prim_elmnt_count
); i
++) {
1770 if (be32_to_cpu(conf
->phys_refnum
[i
]) != 0xffffffff) {
1778 dprintf("%s: couldn't find BVD member %u (total %u)\n",
1779 __func__
, n
, be16_to_cpu(conf
->prim_elmnt_count
));
1783 static struct vd_config
*find_vdcr(struct ddf_super
*ddf
, unsigned int inst
,
1785 unsigned int *n_bvd
, struct vcl
**vcl
)
1789 for (v
= ddf
->conflist
; v
; v
= v
->next
) {
1790 unsigned int nsec
, ibvd
= 0;
1791 struct vd_config
*conf
;
1792 if (inst
!= v
->vcnum
)
1795 if (conf
->sec_elmnt_count
== 1) {
1796 if (find_index_in_bvd(ddf
, conf
, n
, n_bvd
)) {
1802 if (v
->other_bvds
== NULL
) {
1803 pr_err("%s: BUG: other_bvds is NULL, nsec=%u\n",
1804 __func__
, conf
->sec_elmnt_count
);
1807 nsec
= n
/ be16_to_cpu(conf
->prim_elmnt_count
);
1808 if (conf
->sec_elmnt_seq
!= nsec
) {
1809 for (ibvd
= 1; ibvd
< conf
->sec_elmnt_count
; ibvd
++) {
1810 if (v
->other_bvds
[ibvd
-1]->sec_elmnt_seq
1814 if (ibvd
== conf
->sec_elmnt_count
)
1816 conf
= v
->other_bvds
[ibvd
-1];
1818 if (!find_index_in_bvd(ddf
, conf
,
1819 n
- nsec
*conf
->sec_elmnt_count
, n_bvd
))
1821 dprintf("%s: found disk %u as member %u in bvd %d of array %u\n"
1822 , __func__
, n
, *n_bvd
, ibvd
, inst
);
1827 pr_err("%s: Could't find disk %d in array %u\n", __func__
, n
, inst
);
1832 static int find_phys(const struct ddf_super
*ddf
, be32 phys_refnum
)
1834 /* Find the entry in phys_disk which has the given refnum
1835 * and return it's index
1838 for (i
= 0; i
< be16_to_cpu(ddf
->phys
->max_pdes
); i
++)
1839 if (be32_eq(ddf
->phys
->entries
[i
].refnum
, phys_refnum
))
1844 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4])
1847 struct sha1_ctx ctx
;
1848 sha1_init_ctx(&ctx
);
1849 sha1_process_bytes(guid
, DDF_GUID_LEN
, &ctx
);
1850 sha1_finish_ctx(&ctx
, buf
);
1851 memcpy(uuid
, buf
, 4*4);
1854 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4])
1856 /* The uuid returned here is used for:
1857 * uuid to put into bitmap file (Create, Grow)
1858 * uuid for backup header when saving critical section (Grow)
1859 * comparing uuids when re-adding a device into an array
1860 * In these cases the uuid required is that of the data-array,
1861 * not the device-set.
1862 * uuid to recognise same set when adding a missing device back
1863 * to an array. This is a uuid for the device-set.
1865 * For each of these we can make do with a truncated
1866 * or hashed uuid rather than the original, as long as
1868 * In the case of SVD we assume the BVD is of interest,
1869 * though that might be the case if a bitmap were made for
1870 * a mirrored SVD - worry about that later.
1871 * So we need to find the VD configuration record for the
1872 * relevant BVD and extract the GUID and Secondary_Element_Seq.
1873 * The first 16 bytes of the sha1 of these is used.
1875 struct ddf_super
*ddf
= st
->sb
;
1876 struct vcl
*vcl
= ddf
->currentconf
;
1879 uuid_of_ddf_subarray(ddf
, vcl
->vcnum
, uuid
);
1881 uuid_from_ddf_guid(ddf
->anchor
.guid
, uuid
);
1884 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1886 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1888 struct ddf_super
*ddf
= st
->sb
;
1889 int map_disks
= info
->array
.raid_disks
;
1892 if (ddf
->currentconf
) {
1893 getinfo_super_ddf_bvd(st
, info
, map
);
1896 memset(info
, 0, sizeof(*info
));
1898 info
->array
.raid_disks
= be16_to_cpu(ddf
->phys
->used_pdes
);
1899 info
->array
.level
= LEVEL_CONTAINER
;
1900 info
->array
.layout
= 0;
1901 info
->array
.md_minor
= -1;
1902 cptr
= (__u32
*)(ddf
->anchor
.guid
+ 16);
1903 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1905 info
->array
.utime
= 0;
1906 info
->array
.chunk_size
= 0;
1907 info
->container_enough
= 1;
1909 info
->disk
.major
= 0;
1910 info
->disk
.minor
= 0;
1912 info
->disk
.number
= be32_to_cpu(ddf
->dlist
->disk
.refnum
);
1913 info
->disk
.raid_disk
= find_phys(ddf
, ddf
->dlist
->disk
.refnum
);
1915 info
->data_offset
= be64_to_cpu(ddf
->phys
->
1916 entries
[info
->disk
.raid_disk
].
1918 info
->component_size
= ddf
->dlist
->size
- info
->data_offset
;
1920 info
->disk
.number
= -1;
1921 info
->disk
.raid_disk
= -1;
1922 // info->disk.raid_disk = find refnum in the table and use index;
1924 info
->disk
.state
= (1 << MD_DISK_SYNC
) | (1 << MD_DISK_ACTIVE
);
1926 info
->recovery_start
= MaxSector
;
1927 info
->reshape_active
= 0;
1928 info
->recovery_blocked
= 0;
1931 info
->array
.major_version
= -1;
1932 info
->array
.minor_version
= -2;
1933 strcpy(info
->text_version
, "ddf");
1934 info
->safe_mode_delay
= 0;
1936 uuid_from_super_ddf(st
, info
->uuid
);
1940 for (i
= 0 ; i
< map_disks
; i
++) {
1941 if (i
< info
->array
.raid_disks
&&
1942 (be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1944 !(be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1953 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1955 struct ddf_super
*ddf
= st
->sb
;
1956 struct vcl
*vc
= ddf
->currentconf
;
1957 int cd
= ddf
->currentdev
;
1961 int map_disks
= info
->array
.raid_disks
;
1963 struct vd_config
*conf
;
1965 memset(info
, 0, sizeof(*info
));
1966 if (layout_ddf2md(&vc
->conf
, &info
->array
) == -1)
1968 info
->array
.md_minor
= -1;
1969 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
1970 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1971 info
->array
.utime
= DECADE
+ be32_to_cpu(vc
->conf
.timestamp
);
1972 info
->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
1973 info
->custom_array_size
= 0;
1976 n_prim
= be16_to_cpu(conf
->prim_elmnt_count
);
1977 if (conf
->sec_elmnt_count
> 1 && cd
>= n_prim
) {
1978 int ibvd
= cd
/ n_prim
- 1;
1980 conf
= vc
->other_bvds
[ibvd
];
1983 if (cd
>= 0 && (unsigned)cd
< ddf
->mppe
) {
1985 be64_to_cpu(LBA_OFFSET(ddf
, conf
)[cd
]);
1986 if (vc
->block_sizes
)
1987 info
->component_size
= vc
->block_sizes
[cd
];
1989 info
->component_size
= be64_to_cpu(conf
->blocks
);
1992 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
1993 if (be32_eq(dl
->disk
.refnum
, conf
->phys_refnum
[cd
]))
1996 info
->disk
.major
= 0;
1997 info
->disk
.minor
= 0;
1998 info
->disk
.state
= 0;
2000 info
->disk
.major
= dl
->major
;
2001 info
->disk
.minor
= dl
->minor
;
2002 info
->disk
.raid_disk
= cd
+ conf
->sec_elmnt_seq
2003 * be16_to_cpu(conf
->prim_elmnt_count
);
2004 info
->disk
.number
= dl
->pdnum
;
2005 info
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
2008 info
->container_member
= ddf
->currentconf
->vcnum
;
2010 info
->recovery_start
= MaxSector
;
2011 info
->resync_start
= 0;
2012 info
->reshape_active
= 0;
2013 info
->recovery_blocked
= 0;
2014 if (!(ddf
->virt
->entries
[info
->container_member
].state
2015 & DDF_state_inconsistent
) &&
2016 (ddf
->virt
->entries
[info
->container_member
].init_state
2017 & DDF_initstate_mask
)
2019 info
->resync_start
= MaxSector
;
2021 uuid_from_super_ddf(st
, info
->uuid
);
2023 info
->array
.major_version
= -1;
2024 info
->array
.minor_version
= -2;
2025 sprintf(info
->text_version
, "/%s/%d",
2026 st
->container_devnm
,
2027 info
->container_member
);
2028 info
->safe_mode_delay
= DDF_SAFE_MODE_DELAY
;
2030 memcpy(info
->name
, ddf
->virt
->entries
[info
->container_member
].name
, 16);
2033 if (info
->name
[j
] == ' ')
2037 for (j
= 0; j
< map_disks
; j
++) {
2039 if (j
< info
->array
.raid_disks
) {
2040 int i
= find_phys(ddf
, vc
->conf
.phys_refnum
[j
]);
2042 (be16_to_cpu(ddf
->phys
->entries
[i
].state
)
2044 !(be16_to_cpu(ddf
->phys
->entries
[i
].state
)
2051 static int update_super_ddf(struct supertype
*st
, struct mdinfo
*info
,
2053 char *devname
, int verbose
,
2054 int uuid_set
, char *homehost
)
2056 /* For 'assemble' and 'force' we need to return non-zero if any
2057 * change was made. For others, the return value is ignored.
2058 * Update options are:
2059 * force-one : This device looks a bit old but needs to be included,
2060 * update age info appropriately.
2061 * assemble: clear any 'faulty' flag to allow this device to
2063 * force-array: Array is degraded but being forced, mark it clean
2064 * if that will be needed to assemble it.
2066 * newdev: not used ????
2067 * grow: Array has gained a new device - this is currently for
2069 * resync: mark as dirty so a resync will happen.
2070 * uuid: Change the uuid of the array to match what is given
2071 * homehost: update the recorded homehost
2072 * name: update the name - preserving the homehost
2073 * _reshape_progress: record new reshape_progress position.
2075 * Following are not relevant for this version:
2076 * sparc2.2 : update from old dodgey metadata
2077 * super-minor: change the preferred_minor number
2078 * summaries: update redundant counters.
2081 // struct ddf_super *ddf = st->sb;
2082 // struct vd_config *vd = find_vdcr(ddf, info->container_member);
2083 // struct virtual_entry *ve = find_ve(ddf);
2085 /* we don't need to handle "force-*" or "assemble" as
2086 * there is no need to 'trick' the kernel. We the metadata is
2087 * first updated to activate the array, all the implied modifications
2091 if (strcmp(update
, "grow") == 0) {
2093 } else if (strcmp(update
, "resync") == 0) {
2094 // info->resync_checkpoint = 0;
2095 } else if (strcmp(update
, "homehost") == 0) {
2096 /* homehost is stored in controller->vendor_data,
2097 * or it is when we are the vendor
2099 // if (info->vendor_is_local)
2100 // strcpy(ddf->controller.vendor_data, homehost);
2102 } else if (strcmp(update
, "name") == 0) {
2103 /* name is stored in virtual_entry->name */
2104 // memset(ve->name, ' ', 16);
2105 // strncpy(ve->name, info->name, 16);
2107 } else if (strcmp(update
, "_reshape_progress") == 0) {
2108 /* We don't support reshape yet */
2109 } else if (strcmp(update
, "assemble") == 0 ) {
2110 /* Do nothing, just succeed */
2115 // update_all_csum(ddf);
2120 static void make_header_guid(char *guid
)
2123 /* Create a DDF Header of Virtual Disk GUID */
2125 /* 24 bytes of fiction required.
2126 * first 8 are a 'vendor-id' - "Linux-MD"
2127 * next 8 are controller type.. how about 0X DEAD BEEF 0000 0000
2128 * Remaining 8 random number plus timestamp
2130 memcpy(guid
, T10
, sizeof(T10
));
2131 stamp
= cpu_to_be32(0xdeadbeef);
2132 memcpy(guid
+8, &stamp
, 4);
2133 stamp
= cpu_to_be32(0);
2134 memcpy(guid
+12, &stamp
, 4);
2135 stamp
= cpu_to_be32(time(0) - DECADE
);
2136 memcpy(guid
+16, &stamp
, 4);
2137 stamp
._v32
= random32();
2138 memcpy(guid
+20, &stamp
, 4);
2141 static unsigned int find_unused_vde(const struct ddf_super
*ddf
)
2144 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2145 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2148 return DDF_NOTFOUND
;
2151 static unsigned int find_vde_by_name(const struct ddf_super
*ddf
,
2156 return DDF_NOTFOUND
;
2157 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2158 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2160 if (!strncmp(name
, ddf
->virt
->entries
[i
].name
,
2161 sizeof(ddf
->virt
->entries
[i
].name
)))
2164 return DDF_NOTFOUND
;
2168 static unsigned int find_vde_by_guid(const struct ddf_super
*ddf
,
2172 if (guid
== NULL
|| all_ff(guid
))
2173 return DDF_NOTFOUND
;
2174 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++)
2175 if (!memcmp(ddf
->virt
->entries
[i
].guid
, guid
, DDF_GUID_LEN
))
2177 return DDF_NOTFOUND
;
2181 static int init_super_ddf_bvd(struct supertype
*st
,
2182 mdu_array_info_t
*info
,
2183 unsigned long long size
,
2184 char *name
, char *homehost
,
2185 int *uuid
, unsigned long long data_offset
);
2187 static int init_super_ddf(struct supertype
*st
,
2188 mdu_array_info_t
*info
,
2189 unsigned long long size
, char *name
, char *homehost
,
2190 int *uuid
, unsigned long long data_offset
)
2192 /* This is primarily called by Create when creating a new array.
2193 * We will then get add_to_super called for each component, and then
2194 * write_init_super called to write it out to each device.
2195 * For DDF, Create can create on fresh devices or on a pre-existing
2197 * To create on a pre-existing array a different method will be called.
2198 * This one is just for fresh drives.
2200 * We need to create the entire 'ddf' structure which includes:
2201 * DDF headers - these are easy.
2202 * Controller data - a Sector describing this controller .. not that
2203 * this is a controller exactly.
2204 * Physical Disk Record - one entry per device, so
2205 * leave plenty of space.
2206 * Virtual Disk Records - again, just leave plenty of space.
2207 * This just lists VDs, doesn't give details
2208 * Config records - describes the VDs that use this disk
2209 * DiskData - describes 'this' device.
2210 * BadBlockManagement - empty
2211 * Diag Space - empty
2212 * Vendor Logs - Could we put bitmaps here?
2215 struct ddf_super
*ddf
;
2218 int max_phys_disks
, max_virt_disks
;
2219 unsigned long long sector
;
2223 struct phys_disk
*pd
;
2224 struct virtual_disk
*vd
;
2226 if (data_offset
!= INVALID_SECTORS
) {
2227 pr_err("data-offset not supported by DDF\n");
2232 return init_super_ddf_bvd(st
, info
, size
, name
, homehost
, uuid
,
2235 if (posix_memalign((void**)&ddf
, 512, sizeof(*ddf
)) != 0) {
2236 pr_err("%s could not allocate superblock\n", __func__
);
2239 memset(ddf
, 0, sizeof(*ddf
));
2240 ddf
->dlist
= NULL
; /* no physical disks yet */
2241 ddf
->conflist
= NULL
; /* No virtual disks yet */
2245 /* zeroing superblock */
2249 /* At least 32MB *must* be reserved for the ddf. So let's just
2250 * start 32MB from the end, and put the primary header there.
2251 * Don't do secondary for now.
2252 * We don't know exactly where that will be yet as it could be
2253 * different on each device. To just set up the lengths.
2257 ddf
->anchor
.magic
= DDF_HEADER_MAGIC
;
2258 make_header_guid(ddf
->anchor
.guid
);
2260 memcpy(ddf
->anchor
.revision
, DDF_REVISION_2
, 8);
2261 ddf
->anchor
.seq
= cpu_to_be32(1);
2262 ddf
->anchor
.timestamp
= cpu_to_be32(time(0) - DECADE
);
2263 ddf
->anchor
.openflag
= 0xFF;
2264 ddf
->anchor
.foreignflag
= 0;
2265 ddf
->anchor
.enforcegroups
= 0; /* Is this best?? */
2266 ddf
->anchor
.pad0
= 0xff;
2267 memset(ddf
->anchor
.pad1
, 0xff, 12);
2268 memset(ddf
->anchor
.header_ext
, 0xff, 32);
2269 ddf
->anchor
.primary_lba
= cpu_to_be64(~(__u64
)0);
2270 ddf
->anchor
.secondary_lba
= cpu_to_be64(~(__u64
)0);
2271 ddf
->anchor
.type
= DDF_HEADER_ANCHOR
;
2272 memset(ddf
->anchor
.pad2
, 0xff, 3);
2273 ddf
->anchor
.workspace_len
= cpu_to_be32(32768); /* Must be reserved */
2274 /* Put this at bottom of 32M reserved.. */
2275 ddf
->anchor
.workspace_lba
= cpu_to_be64(~(__u64
)0);
2276 max_phys_disks
= 1023; /* Should be enough */
2277 ddf
->anchor
.max_pd_entries
= cpu_to_be16(max_phys_disks
);
2278 max_virt_disks
= 255;
2279 ddf
->anchor
.max_vd_entries
= cpu_to_be16(max_virt_disks
); /* ?? */
2280 ddf
->anchor
.max_partitions
= cpu_to_be16(64); /* ?? */
2283 ddf
->conf_rec_len
= 1 + ROUND_UP(ddf
->mppe
* (4+8), 512)/512;
2284 ddf
->anchor
.config_record_len
= cpu_to_be16(ddf
->conf_rec_len
);
2285 ddf
->anchor
.max_primary_element_entries
= cpu_to_be16(ddf
->mppe
);
2286 memset(ddf
->anchor
.pad3
, 0xff, 54);
2287 /* controller sections is one sector long immediately
2288 * after the ddf header */
2290 ddf
->anchor
.controller_section_offset
= cpu_to_be32(sector
);
2291 ddf
->anchor
.controller_section_length
= cpu_to_be32(1);
2294 /* phys is 8 sectors after that */
2295 pdsize
= ROUND_UP(sizeof(struct phys_disk
) +
2296 sizeof(struct phys_disk_entry
)*max_phys_disks
,
2298 switch(pdsize
/512) {
2299 case 2: case 8: case 32: case 128: case 512: break;
2302 ddf
->anchor
.phys_section_offset
= cpu_to_be32(sector
);
2303 ddf
->anchor
.phys_section_length
=
2304 cpu_to_be32(pdsize
/512); /* max_primary_element_entries/8 */
2305 sector
+= pdsize
/512;
2307 /* virt is another 32 sectors */
2308 vdsize
= ROUND_UP(sizeof(struct virtual_disk
) +
2309 sizeof(struct virtual_entry
) * max_virt_disks
,
2311 switch(vdsize
/512) {
2312 case 2: case 8: case 32: case 128: case 512: break;
2315 ddf
->anchor
.virt_section_offset
= cpu_to_be32(sector
);
2316 ddf
->anchor
.virt_section_length
=
2317 cpu_to_be32(vdsize
/512); /* max_vd_entries/8 */
2318 sector
+= vdsize
/512;
2320 clen
= ddf
->conf_rec_len
* (ddf
->max_part
+1);
2321 ddf
->anchor
.config_section_offset
= cpu_to_be32(sector
);
2322 ddf
->anchor
.config_section_length
= cpu_to_be32(clen
);
2325 ddf
->anchor
.data_section_offset
= cpu_to_be32(sector
);
2326 ddf
->anchor
.data_section_length
= cpu_to_be32(1);
2329 ddf
->anchor
.bbm_section_length
= cpu_to_be32(0);
2330 ddf
->anchor
.bbm_section_offset
= cpu_to_be32(0xFFFFFFFF);
2331 ddf
->anchor
.diag_space_length
= cpu_to_be32(0);
2332 ddf
->anchor
.diag_space_offset
= cpu_to_be32(0xFFFFFFFF);
2333 ddf
->anchor
.vendor_length
= cpu_to_be32(0);
2334 ddf
->anchor
.vendor_offset
= cpu_to_be32(0xFFFFFFFF);
2336 memset(ddf
->anchor
.pad4
, 0xff, 256);
2338 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
2339 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
2341 ddf
->primary
.openflag
= 1; /* I guess.. */
2342 ddf
->primary
.type
= DDF_HEADER_PRIMARY
;
2344 ddf
->secondary
.openflag
= 1; /* I guess.. */
2345 ddf
->secondary
.type
= DDF_HEADER_SECONDARY
;
2347 ddf
->active
= &ddf
->primary
;
2349 ddf
->controller
.magic
= DDF_CONTROLLER_MAGIC
;
2351 /* 24 more bytes of fiction required.
2352 * first 8 are a 'vendor-id' - "Linux-MD"
2353 * Remaining 16 are serial number.... maybe a hostname would do?
2355 memcpy(ddf
->controller
.guid
, T10
, sizeof(T10
));
2356 gethostname(hostname
, sizeof(hostname
));
2357 hostname
[sizeof(hostname
) - 1] = 0;
2358 hostlen
= strlen(hostname
);
2359 memcpy(ddf
->controller
.guid
+ 24 - hostlen
, hostname
, hostlen
);
2360 for (i
= strlen(T10
) ; i
+hostlen
< 24; i
++)
2361 ddf
->controller
.guid
[i
] = ' ';
2363 ddf
->controller
.type
.vendor_id
= cpu_to_be16(0xDEAD);
2364 ddf
->controller
.type
.device_id
= cpu_to_be16(0xBEEF);
2365 ddf
->controller
.type
.sub_vendor_id
= cpu_to_be16(0);
2366 ddf
->controller
.type
.sub_device_id
= cpu_to_be16(0);
2367 memcpy(ddf
->controller
.product_id
, "What Is My PID??", 16);
2368 memset(ddf
->controller
.pad
, 0xff, 8);
2369 memset(ddf
->controller
.vendor_data
, 0xff, 448);
2370 if (homehost
&& strlen(homehost
) < 440)
2371 strcpy((char*)ddf
->controller
.vendor_data
, homehost
);
2373 if (posix_memalign((void**)&pd
, 512, pdsize
) != 0) {
2374 pr_err("%s could not allocate pd\n", __func__
);
2378 ddf
->pdsize
= pdsize
;
2380 memset(pd
, 0xff, pdsize
);
2381 memset(pd
, 0, sizeof(*pd
));
2382 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2383 pd
->used_pdes
= cpu_to_be16(0);
2384 pd
->max_pdes
= cpu_to_be16(max_phys_disks
);
2385 memset(pd
->pad
, 0xff, 52);
2386 for (i
= 0; i
< max_phys_disks
; i
++)
2387 memset(pd
->entries
[i
].guid
, 0xff, DDF_GUID_LEN
);
2389 if (posix_memalign((void**)&vd
, 512, vdsize
) != 0) {
2390 pr_err("%s could not allocate vd\n", __func__
);
2394 ddf
->vdsize
= vdsize
;
2395 memset(vd
, 0, vdsize
);
2396 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
2397 vd
->populated_vdes
= cpu_to_be16(0);
2398 vd
->max_vdes
= cpu_to_be16(max_virt_disks
);
2399 memset(vd
->pad
, 0xff, 52);
2401 for (i
=0; i
<max_virt_disks
; i
++)
2402 memset(&vd
->entries
[i
], 0xff, sizeof(struct virtual_entry
));
2405 ddf_set_updates_pending(ddf
);
2409 static int chunk_to_shift(int chunksize
)
2411 return ffs(chunksize
/512)-1;
2416 unsigned long long start
, size
;
2418 static int cmp_extent(const void *av
, const void *bv
)
2420 const struct extent
*a
= av
;
2421 const struct extent
*b
= bv
;
2422 if (a
->start
< b
->start
)
2424 if (a
->start
> b
->start
)
2429 static struct extent
*get_extents(struct ddf_super
*ddf
, struct dl
*dl
)
2431 /* find a list of used extents on the give physical device
2432 * (dnum) of the given ddf.
2433 * Return a malloced array of 'struct extent'
2435 * FIXME ignore DDF_Legacy devices?
2441 __u16 state
= be16_to_cpu(ddf
->phys
->entries
[dl
->pdnum
].state
);
2443 if ((state
& (DDF_Online
|DDF_Failed
|DDF_Missing
)) != DDF_Online
)
2446 rv
= xmalloc(sizeof(struct extent
) * (ddf
->max_part
+ 2));
2448 for (i
= 0; i
< ddf
->max_part
; i
++) {
2449 const struct vd_config
*bvd
;
2451 struct vcl
*v
= dl
->vlist
[i
];
2453 get_pd_index_from_refnum(v
, dl
->disk
.refnum
, ddf
->mppe
,
2454 &bvd
, &ibvd
) == DDF_NOTFOUND
)
2456 rv
[n
].start
= be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[ibvd
]);
2457 rv
[n
].size
= be64_to_cpu(bvd
->blocks
);
2460 qsort(rv
, n
, sizeof(*rv
), cmp_extent
);
2462 rv
[n
].start
= be64_to_cpu(ddf
->phys
->entries
[dl
->pdnum
].config_size
);
2468 static int init_super_ddf_bvd(struct supertype
*st
,
2469 mdu_array_info_t
*info
,
2470 unsigned long long size
,
2471 char *name
, char *homehost
,
2472 int *uuid
, unsigned long long data_offset
)
2474 /* We are creating a BVD inside a pre-existing container.
2475 * so st->sb is already set.
2476 * We need to create a new vd_config and a new virtual_entry
2478 struct ddf_super
*ddf
= st
->sb
;
2479 unsigned int venum
, i
;
2480 struct virtual_entry
*ve
;
2482 struct vd_config
*vc
;
2484 if (find_vde_by_name(ddf
, name
) != DDF_NOTFOUND
) {
2485 pr_err("This ddf already has an array called %s\n", name
);
2488 venum
= find_unused_vde(ddf
);
2489 if (venum
== DDF_NOTFOUND
) {
2490 pr_err("Cannot find spare slot for virtual disk\n");
2493 ve
= &ddf
->virt
->entries
[venum
];
2495 /* A Virtual Disk GUID contains the T10 Vendor ID, controller type,
2496 * timestamp, random number
2498 make_header_guid(ve
->guid
);
2499 ve
->unit
= cpu_to_be16(info
->md_minor
);
2501 ve
->guid_crc
._v16
= crc32(0, (unsigned char *)ddf
->anchor
.guid
,
2503 ve
->type
= cpu_to_be16(0);
2504 ve
->state
= DDF_state_degraded
; /* Will be modified as devices are added */
2505 if (info
->state
& 1) /* clean */
2506 ve
->init_state
= DDF_init_full
;
2508 ve
->init_state
= DDF_init_not
;
2510 memset(ve
->pad1
, 0xff, 14);
2511 memset(ve
->name
, ' ', 16);
2513 strncpy(ve
->name
, name
, 16);
2514 ddf
->virt
->populated_vdes
=
2515 cpu_to_be16(be16_to_cpu(ddf
->virt
->populated_vdes
)+1);
2517 /* Now create a new vd_config */
2518 if (posix_memalign((void**)&vcl
, 512,
2519 (offsetof(struct vcl
, conf
) + ddf
->conf_rec_len
* 512)) != 0) {
2520 pr_err("%s could not allocate vd_config\n", __func__
);
2524 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
2527 vc
->magic
= DDF_VD_CONF_MAGIC
;
2528 memcpy(vc
->guid
, ve
->guid
, DDF_GUID_LEN
);
2529 vc
->timestamp
= cpu_to_be32(time(0)-DECADE
);
2530 vc
->seqnum
= cpu_to_be32(1);
2531 memset(vc
->pad0
, 0xff, 24);
2532 vc
->chunk_shift
= chunk_to_shift(info
->chunk_size
);
2533 if (layout_md2ddf(info
, vc
) == -1 ||
2534 be16_to_cpu(vc
->prim_elmnt_count
) > ddf
->mppe
) {
2535 pr_err("%s: unsupported RAID level/layout %d/%d with %d disks\n",
2536 __func__
, info
->level
, info
->layout
, info
->raid_disks
);
2540 vc
->sec_elmnt_seq
= 0;
2541 if (alloc_other_bvds(ddf
, vcl
) != 0) {
2542 pr_err("%s could not allocate other bvds\n",
2547 vc
->blocks
= cpu_to_be64(info
->size
* 2);
2548 vc
->array_blocks
= cpu_to_be64(
2549 calc_array_size(info
->level
, info
->raid_disks
, info
->layout
,
2550 info
->chunk_size
, info
->size
*2));
2551 memset(vc
->pad1
, 0xff, 8);
2552 vc
->spare_refs
[0] = cpu_to_be32(0xffffffff);
2553 vc
->spare_refs
[1] = cpu_to_be32(0xffffffff);
2554 vc
->spare_refs
[2] = cpu_to_be32(0xffffffff);
2555 vc
->spare_refs
[3] = cpu_to_be32(0xffffffff);
2556 vc
->spare_refs
[4] = cpu_to_be32(0xffffffff);
2557 vc
->spare_refs
[5] = cpu_to_be32(0xffffffff);
2558 vc
->spare_refs
[6] = cpu_to_be32(0xffffffff);
2559 vc
->spare_refs
[7] = cpu_to_be32(0xffffffff);
2560 memset(vc
->cache_pol
, 0, 8);
2562 memset(vc
->pad2
, 0xff, 3);
2563 memset(vc
->pad3
, 0xff, 52);
2564 memset(vc
->pad4
, 0xff, 192);
2565 memset(vc
->v0
, 0xff, 32);
2566 memset(vc
->v1
, 0xff, 32);
2567 memset(vc
->v2
, 0xff, 16);
2568 memset(vc
->v3
, 0xff, 16);
2569 memset(vc
->vendor
, 0xff, 32);
2571 memset(vc
->phys_refnum
, 0xff, 4*ddf
->mppe
);
2572 memset(vc
->phys_refnum
+ddf
->mppe
, 0x00, 8*ddf
->mppe
);
2574 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++) {
2575 memcpy(vcl
->other_bvds
[i
-1], vc
, ddf
->conf_rec_len
* 512);
2576 vcl
->other_bvds
[i
-1]->sec_elmnt_seq
= i
;
2579 vcl
->next
= ddf
->conflist
;
2580 ddf
->conflist
= vcl
;
2581 ddf
->currentconf
= vcl
;
2582 ddf_set_updates_pending(ddf
);
2588 static int get_svd_state(const struct ddf_super
*, const struct vcl
*);
2590 static void add_to_super_ddf_bvd(struct supertype
*st
,
2591 mdu_disk_info_t
*dk
, int fd
, char *devname
)
2593 /* fd and devname identify a device with-in the ddf container (st).
2594 * dk identifies a location in the new BVD.
2595 * We need to find suitable free space in that device and update
2596 * the phys_refnum and lba_offset for the newly created vd_config.
2597 * We might also want to update the type in the phys_disk
2600 * Alternately: fd == -1 and we have already chosen which device to
2601 * use and recorded in dlist->raid_disk;
2604 struct ddf_super
*ddf
= st
->sb
;
2605 struct vd_config
*vc
;
2607 unsigned long long blocks
, pos
, esize
;
2609 unsigned int raid_disk
= dk
->raid_disk
;
2612 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2613 if (dl
->raiddisk
== dk
->raid_disk
)
2616 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2617 if (dl
->major
== dk
->major
&&
2618 dl
->minor
== dk
->minor
)
2621 if (!dl
|| ! (dk
->state
& (1<<MD_DISK_SYNC
)))
2624 vc
= &ddf
->currentconf
->conf
;
2625 if (vc
->sec_elmnt_count
> 1) {
2626 unsigned int n
= be16_to_cpu(vc
->prim_elmnt_count
);
2628 vc
= ddf
->currentconf
->other_bvds
[raid_disk
/ n
- 1];
2632 ex
= get_extents(ddf
, dl
);
2637 blocks
= be64_to_cpu(vc
->blocks
);
2638 if (ddf
->currentconf
->block_sizes
)
2639 blocks
= ddf
->currentconf
->block_sizes
[dk
->raid_disk
];
2642 esize
= ex
[i
].start
- pos
;
2643 if (esize
>= blocks
)
2645 pos
= ex
[i
].start
+ ex
[i
].size
;
2647 } while (ex
[i
-1].size
);
2653 ddf
->currentdev
= dk
->raid_disk
;
2654 vc
->phys_refnum
[raid_disk
] = dl
->disk
.refnum
;
2655 LBA_OFFSET(ddf
, vc
)[raid_disk
] = cpu_to_be64(pos
);
2657 for (i
= 0; i
< ddf
->max_part
; i
++)
2658 if (dl
->vlist
[i
] == NULL
)
2660 if (i
== ddf
->max_part
)
2662 dl
->vlist
[i
] = ddf
->currentconf
;
2667 dl
->devname
= devname
;
2669 /* Check if we can mark array as optimal yet */
2670 i
= ddf
->currentconf
->vcnum
;
2671 ddf
->virt
->entries
[i
].state
=
2672 (ddf
->virt
->entries
[i
].state
& ~DDF_state_mask
)
2673 | get_svd_state(ddf
, ddf
->currentconf
);
2674 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
2675 cpu_to_be16(DDF_Global_Spare
));
2676 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
2677 cpu_to_be16(DDF_Active_in_VD
));
2678 dprintf("%s: added disk %d/%08x to VD %d/%s as disk %d\n",
2679 __func__
, dl
->pdnum
, be32_to_cpu(dl
->disk
.refnum
),
2680 ddf
->currentconf
->vcnum
, guid_str(vc
->guid
),
2682 ddf_set_updates_pending(ddf
);
2685 static unsigned int find_unused_pde(const struct ddf_super
*ddf
)
2688 for (i
= 0; i
< be16_to_cpu(ddf
->phys
->max_pdes
); i
++) {
2689 if (all_ff(ddf
->phys
->entries
[i
].guid
))
2692 return DDF_NOTFOUND
;
2695 /* add a device to a container, either while creating it or while
2696 * expanding a pre-existing container
2698 static int add_to_super_ddf(struct supertype
*st
,
2699 mdu_disk_info_t
*dk
, int fd
, char *devname
,
2700 unsigned long long data_offset
)
2702 struct ddf_super
*ddf
= st
->sb
;
2706 unsigned long long size
;
2707 struct phys_disk_entry
*pde
;
2712 if (ddf
->currentconf
) {
2713 add_to_super_ddf_bvd(st
, dk
, fd
, devname
);
2717 /* This is device numbered dk->number. We need to create
2718 * a phys_disk entry and a more detailed disk_data entry.
2721 n
= find_unused_pde(ddf
);
2722 if (n
== DDF_NOTFOUND
) {
2723 pr_err("%s: No free slot in array, cannot add disk\n",
2727 pde
= &ddf
->phys
->entries
[n
];
2728 get_dev_size(fd
, NULL
, &size
);
2729 if (size
<= 32*1024*1024) {
2730 pr_err("%s: device size must be at least 32MB\n",
2736 if (posix_memalign((void**)&dd
, 512,
2737 sizeof(*dd
) + sizeof(dd
->vlist
[0]) * ddf
->max_part
) != 0) {
2738 pr_err("%s could allocate buffer for new disk, aborting\n",
2742 dd
->major
= major(stb
.st_rdev
);
2743 dd
->minor
= minor(stb
.st_rdev
);
2744 dd
->devname
= devname
;
2748 dd
->disk
.magic
= DDF_PHYS_DATA_MAGIC
;
2750 tm
= localtime(&now
);
2751 sprintf(dd
->disk
.guid
, "%8s%04d%02d%02d",
2752 T10
, tm
->tm_year
+1900, tm
->tm_mon
+1, tm
->tm_mday
);
2753 tptr
= (__u32
*)(dd
->disk
.guid
+ 16);
2754 *tptr
++ = random32();
2758 /* Cannot be bothered finding a CRC of some irrelevant details*/
2759 dd
->disk
.refnum
._v32
= random32();
2760 for (i
= be16_to_cpu(ddf
->active
->max_pd_entries
);
2762 if (be32_eq(ddf
->phys
->entries
[i
-1].refnum
,
2767 dd
->disk
.forced_ref
= 1;
2768 dd
->disk
.forced_guid
= 1;
2769 memset(dd
->disk
.vendor
, ' ', 32);
2770 memcpy(dd
->disk
.vendor
, "Linux", 5);
2771 memset(dd
->disk
.pad
, 0xff, 442);
2772 for (i
= 0; i
< ddf
->max_part
; i
++)
2773 dd
->vlist
[i
] = NULL
;
2777 if (st
->update_tail
) {
2778 int len
= (sizeof(struct phys_disk
) +
2779 sizeof(struct phys_disk_entry
));
2780 struct phys_disk
*pd
;
2783 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2784 pd
->used_pdes
= cpu_to_be16(n
);
2785 pde
= &pd
->entries
[0];
2788 ddf
->phys
->used_pdes
= cpu_to_be16(
2789 1 + be16_to_cpu(ddf
->phys
->used_pdes
));
2791 memcpy(pde
->guid
, dd
->disk
.guid
, DDF_GUID_LEN
);
2792 pde
->refnum
= dd
->disk
.refnum
;
2793 pde
->type
= cpu_to_be16(DDF_Forced_PD_GUID
| DDF_Global_Spare
);
2794 pde
->state
= cpu_to_be16(DDF_Online
);
2797 * If there is already a device in dlist, try to reserve the same
2798 * amount of workspace. Otherwise, use 32MB.
2799 * We checked disk size above already.
2801 #define __calc_lba(new, old, lba, mb) do { \
2802 unsigned long long dif; \
2803 if ((old) != NULL) \
2804 dif = (old)->size - be64_to_cpu((old)->lba); \
2806 dif = (new)->size; \
2807 if ((new)->size > dif) \
2808 (new)->lba = cpu_to_be64((new)->size - dif); \
2810 (new)->lba = cpu_to_be64((new)->size - (mb*1024*2)); \
2812 __calc_lba(dd
, ddf
->dlist
, workspace_lba
, 32);
2813 __calc_lba(dd
, ddf
->dlist
, primary_lba
, 16);
2814 __calc_lba(dd
, ddf
->dlist
, secondary_lba
, 32);
2815 pde
->config_size
= dd
->workspace_lba
;
2817 sprintf(pde
->path
, "%17.17s","Information: nil") ;
2818 memset(pde
->pad
, 0xff, 6);
2820 if (st
->update_tail
) {
2821 dd
->next
= ddf
->add_list
;
2824 dd
->next
= ddf
->dlist
;
2826 ddf_set_updates_pending(ddf
);
2832 static int remove_from_super_ddf(struct supertype
*st
, mdu_disk_info_t
*dk
)
2834 struct ddf_super
*ddf
= st
->sb
;
2837 /* mdmon has noticed that this disk (dk->major/dk->minor) has
2838 * disappeared from the container.
2839 * We need to arrange that it disappears from the metadata and
2840 * internal data structures too.
2841 * Most of the work is done by ddf_process_update which edits
2842 * the metadata and closes the file handle and attaches the memory
2843 * where free_updates will free it.
2845 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2846 if (dl
->major
== dk
->major
&&
2847 dl
->minor
== dk
->minor
)
2852 if (st
->update_tail
) {
2853 int len
= (sizeof(struct phys_disk
) +
2854 sizeof(struct phys_disk_entry
));
2855 struct phys_disk
*pd
;
2858 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2859 pd
->used_pdes
= cpu_to_be16(dl
->pdnum
);
2860 pd
->entries
[0].state
= cpu_to_be16(DDF_Missing
);
2861 append_metadata_update(st
, pd
, len
);
2868 * This is the write_init_super method for a ddf container. It is
2869 * called when creating a container or adding another device to a
2872 #define NULL_CONF_SZ 4096
2874 static int __write_ddf_structure(struct dl
*d
, struct ddf_super
*ddf
, __u8 type
)
2876 unsigned long long sector
;
2877 struct ddf_header
*header
;
2878 int fd
, i
, n_config
, conf_size
, buf_size
;
2885 case DDF_HEADER_PRIMARY
:
2886 header
= &ddf
->primary
;
2887 sector
= be64_to_cpu(header
->primary_lba
);
2889 case DDF_HEADER_SECONDARY
:
2890 header
= &ddf
->secondary
;
2891 sector
= be64_to_cpu(header
->secondary_lba
);
2897 header
->type
= type
;
2898 header
->openflag
= 1;
2899 header
->crc
= calc_crc(header
, 512);
2901 lseek64(fd
, sector
<<9, 0);
2902 if (write(fd
, header
, 512) < 0)
2905 ddf
->controller
.crc
= calc_crc(&ddf
->controller
, 512);
2906 if (write(fd
, &ddf
->controller
, 512) < 0)
2909 ddf
->phys
->crc
= calc_crc(ddf
->phys
, ddf
->pdsize
);
2910 if (write(fd
, ddf
->phys
, ddf
->pdsize
) < 0)
2912 ddf
->virt
->crc
= calc_crc(ddf
->virt
, ddf
->vdsize
);
2913 if (write(fd
, ddf
->virt
, ddf
->vdsize
) < 0)
2916 /* Now write lots of config records. */
2917 n_config
= ddf
->max_part
;
2918 conf_size
= ddf
->conf_rec_len
* 512;
2920 buf_size
= conf_size
* (n_config
+ 1);
2922 if (posix_memalign((void**)&conf
, 512, buf_size
) != 0)
2926 for (i
= 0 ; i
<= n_config
; i
++) {
2928 struct vd_config
*vdc
= NULL
;
2929 if (i
== n_config
) {
2930 c
= (struct vcl
*)d
->spare
;
2937 get_pd_index_from_refnum(
2940 (const struct vd_config
**)&vdc
,
2944 dprintf("writing conf record %i on disk %08x for %s/%u\n",
2945 i
, be32_to_cpu(d
->disk
.refnum
),
2946 guid_str(vdc
->guid
),
2947 vdc
->sec_elmnt_seq
);
2948 vdc
->seqnum
= header
->seq
;
2949 vdc
->crc
= calc_crc(vdc
, conf_size
);
2950 memcpy(conf
+ i
*conf_size
, vdc
, conf_size
);
2952 memset(conf
+ i
*conf_size
, 0xff, conf_size
);
2954 if (write(fd
, conf
, buf_size
) != buf_size
)
2957 d
->disk
.crc
= calc_crc(&d
->disk
, 512);
2958 if (write(fd
, &d
->disk
, 512) < 0)
2963 header
->openflag
= 0;
2964 header
->crc
= calc_crc(header
, 512);
2966 lseek64(fd
, sector
<<9, 0);
2967 if (write(fd
, header
, 512) < 0)
2973 static int _write_super_to_disk(struct ddf_super
*ddf
, struct dl
*d
)
2975 unsigned long long size
;
2980 /* We need to fill in the primary, (secondary) and workspace
2981 * lba's in the headers, set their checksums,
2982 * Also checksum phys, virt....
2984 * Then write everything out, finally the anchor is written.
2986 get_dev_size(fd
, NULL
, &size
);
2988 if (be64_to_cpu(d
->workspace_lba
) != 0ULL)
2989 ddf
->anchor
.workspace_lba
= d
->workspace_lba
;
2991 ddf
->anchor
.workspace_lba
=
2992 cpu_to_be64(size
- 32*1024*2);
2993 if (be64_to_cpu(d
->primary_lba
) != 0ULL)
2994 ddf
->anchor
.primary_lba
= d
->primary_lba
;
2996 ddf
->anchor
.primary_lba
=
2997 cpu_to_be64(size
- 16*1024*2);
2998 if (be64_to_cpu(d
->secondary_lba
) != 0ULL)
2999 ddf
->anchor
.secondary_lba
= d
->secondary_lba
;
3001 ddf
->anchor
.secondary_lba
=
3002 cpu_to_be64(size
- 32*1024*2);
3003 ddf
->anchor
.seq
= ddf
->active
->seq
;
3004 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
3005 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
3007 ddf
->anchor
.openflag
= 0xFF; /* 'open' means nothing */
3008 ddf
->anchor
.seq
= cpu_to_be32(0xFFFFFFFF); /* no sequencing in anchor */
3009 ddf
->anchor
.crc
= calc_crc(&ddf
->anchor
, 512);
3011 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_PRIMARY
))
3014 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_SECONDARY
))
3017 lseek64(fd
, (size
-1)*512, SEEK_SET
);
3018 if (write(fd
, &ddf
->anchor
, 512) < 0)
3025 static int __write_init_super_ddf(struct supertype
*st
)
3027 struct ddf_super
*ddf
= st
->sb
;
3032 pr_state(ddf
, __func__
);
3034 /* try to write updated metadata,
3035 * if we catch a failure move on to the next disk
3037 for (d
= ddf
->dlist
; d
; d
=d
->next
) {
3039 successes
+= _write_super_to_disk(ddf
, d
);
3042 return attempts
!= successes
;
3045 static int write_init_super_ddf(struct supertype
*st
)
3047 struct ddf_super
*ddf
= st
->sb
;
3048 struct vcl
*currentconf
= ddf
->currentconf
;
3050 /* we are done with currentconf reset it to point st at the container */
3051 ddf
->currentconf
= NULL
;
3053 if (st
->update_tail
) {
3054 /* queue the virtual_disk and vd_config as metadata updates */
3055 struct virtual_disk
*vd
;
3056 struct vd_config
*vc
;
3061 int len
= (sizeof(struct phys_disk
) +
3062 sizeof(struct phys_disk_entry
));
3064 /* adding a disk to the container. */
3068 append_metadata_update(st
, ddf
->add_list
->mdupdate
, len
);
3069 ddf
->add_list
->mdupdate
= NULL
;
3073 /* Newly created VD */
3075 /* First the virtual disk. We have a slightly fake header */
3076 len
= sizeof(struct virtual_disk
) + sizeof(struct virtual_entry
);
3079 vd
->entries
[0] = ddf
->virt
->entries
[currentconf
->vcnum
];
3080 vd
->populated_vdes
= cpu_to_be16(currentconf
->vcnum
);
3081 append_metadata_update(st
, vd
, len
);
3083 /* Then the vd_config */
3084 len
= ddf
->conf_rec_len
* 512;
3085 tlen
= len
* currentconf
->conf
.sec_elmnt_count
;
3087 memcpy(vc
, ¤tconf
->conf
, len
);
3088 for (i
= 1; i
< currentconf
->conf
.sec_elmnt_count
; i
++)
3089 memcpy((char *)vc
+ i
*len
, currentconf
->other_bvds
[i
-1],
3091 append_metadata_update(st
, vc
, tlen
);
3093 /* FIXME I need to close the fds! */
3098 for (d
= ddf
->dlist
; d
; d
=d
->next
)
3099 while (Kill(d
->devname
, NULL
, 0, -1, 1) == 0);
3100 return __write_init_super_ddf(st
);
3106 static __u64
avail_size_ddf(struct supertype
*st
, __u64 devsize
,
3107 unsigned long long data_offset
)
3109 /* We must reserve the last 32Meg */
3110 if (devsize
<= 32*1024*2)
3112 return devsize
- 32*1024*2;
3117 static int reserve_space(struct supertype
*st
, int raiddisks
,
3118 unsigned long long size
, int chunk
,
3119 unsigned long long *freesize
)
3121 /* Find 'raiddisks' spare extents at least 'size' big (but
3122 * only caring about multiples of 'chunk') and remember
3124 * If the cannot be found, fail.
3127 struct ddf_super
*ddf
= st
->sb
;
3130 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3134 /* Now find largest extent on each device */
3135 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3136 struct extent
*e
= get_extents(ddf
, dl
);
3137 unsigned long long pos
= 0;
3140 unsigned long long minsize
= size
;
3148 unsigned long long esize
;
3149 esize
= e
[i
].start
- pos
;
3150 if (esize
>= minsize
) {
3154 pos
= e
[i
].start
+ e
[i
].size
;
3156 } while (e
[i
-1].size
);
3159 dl
->esize
= minsize
;
3163 if (cnt
< raiddisks
) {
3164 pr_err("not enough devices with space to create array.\n");
3165 return 0; /* No enough free spaces large enough */
3168 /* choose the largest size of which there are at least 'raiddisk' */
3169 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3171 if (dl
->esize
<= size
)
3173 /* This is bigger than 'size', see if there are enough */
3175 for (dl2
= ddf
->dlist
; dl2
; dl2
=dl2
->next
)
3176 if (dl2
->esize
>= dl
->esize
)
3178 if (cnt
>= raiddisks
)
3182 size
= size
/ chunk
;
3187 pr_err("not enough spare devices to create array.\n");
3191 /* We have a 'size' of which there are enough spaces.
3192 * We simply do a first-fit */
3194 for (dl
= ddf
->dlist
; dl
&& cnt
< raiddisks
; dl
=dl
->next
) {
3195 if (dl
->esize
< size
)
3205 validate_geometry_ddf_container(struct supertype
*st
,
3206 int level
, int layout
, int raiddisks
,
3207 int chunk
, unsigned long long size
,
3208 unsigned long long data_offset
,
3209 char *dev
, unsigned long long *freesize
,
3212 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3213 int level
, int layout
, int raiddisks
,
3214 int *chunk
, unsigned long long size
,
3215 unsigned long long data_offset
,
3216 char *dev
, unsigned long long *freesize
,
3219 static int validate_geometry_ddf(struct supertype
*st
,
3220 int level
, int layout
, int raiddisks
,
3221 int *chunk
, unsigned long long size
,
3222 unsigned long long data_offset
,
3223 char *dev
, unsigned long long *freesize
,
3230 /* ddf potentially supports lots of things, but it depends on
3231 * what devices are offered (and maybe kernel version?)
3232 * If given unused devices, we will make a container.
3233 * If given devices in a container, we will make a BVD.
3234 * If given BVDs, we make an SVD, changing all the GUIDs in the process.
3237 if (*chunk
== UnSet
)
3238 *chunk
= DEFAULT_CHUNK
;
3240 if (level
== -1000000) level
= LEVEL_CONTAINER
;
3241 if (level
== LEVEL_CONTAINER
) {
3242 /* Must be a fresh device to add to a container */
3243 return validate_geometry_ddf_container(st
, level
, layout
,
3245 size
, data_offset
, dev
,
3251 mdu_array_info_t array
= {
3252 .level
= level
, .layout
= layout
,
3253 .raid_disks
= raiddisks
3255 struct vd_config conf
;
3256 if (layout_md2ddf(&array
, &conf
) == -1) {
3258 pr_err("DDF does not support level %d /layout %d arrays with %d disks\n",
3259 level
, layout
, raiddisks
);
3262 /* Should check layout? etc */
3264 if (st
->sb
&& freesize
) {
3265 /* --create was given a container to create in.
3266 * So we need to check that there are enough
3267 * free spaces and return the amount of space.
3268 * We may as well remember which drives were
3269 * chosen so that add_to_super/getinfo_super
3272 return reserve_space(st
, raiddisks
, size
, *chunk
, freesize
);
3278 /* A container has already been opened, so we are
3279 * creating in there. Maybe a BVD, maybe an SVD.
3280 * Should make a distinction one day.
3282 return validate_geometry_ddf_bvd(st
, level
, layout
, raiddisks
,
3283 chunk
, size
, data_offset
, dev
,
3287 /* This is the first device for the array.
3288 * If it is a container, we read it in and do automagic allocations,
3289 * no other devices should be given.
3290 * Otherwise it must be a member device of a container, and we
3291 * do manual allocation.
3292 * Later we should check for a BVD and make an SVD.
3294 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3296 sra
= sysfs_read(fd
, NULL
, GET_VERSION
);
3298 if (sra
&& sra
->array
.major_version
== -1 &&
3299 strcmp(sra
->text_version
, "ddf") == 0) {
3302 /* find space for 'n' devices. */
3303 /* remember the devices */
3304 /* Somehow return the fact that we have enough */
3308 pr_err("ddf: Cannot create this array "
3309 "on device %s - a container is required.\n",
3313 if (errno
!= EBUSY
|| (fd
= open(dev
, O_RDONLY
, 0)) < 0) {
3315 pr_err("ddf: Cannot open %s: %s\n",
3316 dev
, strerror(errno
));
3319 /* Well, it is in use by someone, maybe a 'ddf' container. */
3320 cfd
= open_container(fd
);
3324 pr_err("ddf: Cannot use %s: %s\n",
3325 dev
, strerror(EBUSY
));
3328 sra
= sysfs_read(cfd
, NULL
, GET_VERSION
);
3330 if (sra
&& sra
->array
.major_version
== -1 &&
3331 strcmp(sra
->text_version
, "ddf") == 0) {
3332 /* This is a member of a ddf container. Load the container
3333 * and try to create a bvd
3335 struct ddf_super
*ddf
;
3336 if (load_super_ddf_all(st
, cfd
, (void **)&ddf
, NULL
) == 0) {
3338 strcpy(st
->container_devnm
, fd2devnm(cfd
));
3340 return validate_geometry_ddf_bvd(st
, level
, layout
,
3341 raiddisks
, chunk
, size
,
3347 } else /* device may belong to a different container */
3354 validate_geometry_ddf_container(struct supertype
*st
,
3355 int level
, int layout
, int raiddisks
,
3356 int chunk
, unsigned long long size
,
3357 unsigned long long data_offset
,
3358 char *dev
, unsigned long long *freesize
,
3362 unsigned long long ldsize
;
3364 if (level
!= LEVEL_CONTAINER
)
3369 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3372 pr_err("ddf: Cannot open %s: %s\n",
3373 dev
, strerror(errno
));
3376 if (!get_dev_size(fd
, dev
, &ldsize
)) {
3382 *freesize
= avail_size_ddf(st
, ldsize
>> 9, INVALID_SECTORS
);
3389 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3390 int level
, int layout
, int raiddisks
,
3391 int *chunk
, unsigned long long size
,
3392 unsigned long long data_offset
,
3393 char *dev
, unsigned long long *freesize
,
3397 struct ddf_super
*ddf
= st
->sb
;
3399 unsigned long long pos
= 0;
3400 unsigned long long maxsize
;
3403 /* ddf/bvd supports lots of things, but not containers */
3404 if (level
== LEVEL_CONTAINER
) {
3406 pr_err("DDF cannot create a container within an container\n");
3409 /* We must have the container info already read in. */
3414 /* General test: make sure there is space for
3415 * 'raiddisks' device extents of size 'size'.
3417 unsigned long long minsize
= size
;
3421 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3427 e
= get_extents(ddf
, dl
);
3430 unsigned long long esize
;
3431 esize
= e
[i
].start
- pos
;
3432 if (esize
>= minsize
)
3434 pos
= e
[i
].start
+ e
[i
].size
;
3436 } while (e
[i
-1].size
);
3441 if (dcnt
< raiddisks
) {
3443 pr_err("ddf: Not enough devices with "
3444 "space for this array (%d < %d)\n",
3450 /* This device must be a member of the set */
3451 if (stat(dev
, &stb
) < 0)
3453 if ((S_IFMT
& stb
.st_mode
) != S_IFBLK
)
3455 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
3456 if (dl
->major
== (int)major(stb
.st_rdev
) &&
3457 dl
->minor
== (int)minor(stb
.st_rdev
))
3462 pr_err("ddf: %s is not in the "
3467 e
= get_extents(ddf
, dl
);
3471 unsigned long long esize
;
3472 esize
= e
[i
].start
- pos
;
3473 if (esize
>= maxsize
)
3475 pos
= e
[i
].start
+ e
[i
].size
;
3477 } while (e
[i
-1].size
);
3478 *freesize
= maxsize
;
3484 static int load_super_ddf_all(struct supertype
*st
, int fd
,
3485 void **sbp
, char *devname
)
3488 struct ddf_super
*super
;
3489 struct mdinfo
*sd
, *best
= NULL
;
3495 sra
= sysfs_read(fd
, 0, GET_LEVEL
|GET_VERSION
|GET_DEVS
|GET_STATE
);
3498 if (sra
->array
.major_version
!= -1 ||
3499 sra
->array
.minor_version
!= -2 ||
3500 strcmp(sra
->text_version
, "ddf") != 0)
3503 if (posix_memalign((void**)&super
, 512, sizeof(*super
)) != 0)
3505 memset(super
, 0, sizeof(*super
));
3507 /* first, try each device, and choose the best ddf */
3508 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3510 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3511 dfd
= dev_open(nm
, O_RDONLY
);
3514 rv
= load_ddf_headers(dfd
, super
, NULL
);
3517 seq
= be32_to_cpu(super
->active
->seq
);
3518 if (super
->active
->openflag
)
3520 if (!best
|| seq
> bestseq
) {
3528 /* OK, load this ddf */
3529 sprintf(nm
, "%d:%d", best
->disk
.major
, best
->disk
.minor
);
3530 dfd
= dev_open(nm
, O_RDONLY
);
3533 load_ddf_headers(dfd
, super
, NULL
);
3534 load_ddf_global(dfd
, super
, NULL
);
3536 /* Now we need the device-local bits */
3537 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3540 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3541 dfd
= dev_open(nm
, O_RDWR
);
3544 rv
= load_ddf_headers(dfd
, super
, NULL
);
3546 rv
= load_ddf_local(dfd
, super
, NULL
, 1);
3552 if (st
->ss
== NULL
) {
3553 st
->ss
= &super_ddf
;
3554 st
->minor_version
= 0;
3557 strcpy(st
->container_devnm
, fd2devnm(fd
));
3561 static int load_container_ddf(struct supertype
*st
, int fd
,
3564 return load_super_ddf_all(st
, fd
, &st
->sb
, devname
);
3567 #endif /* MDASSEMBLE */
3569 static int check_secondary(const struct vcl
*vc
)
3571 const struct vd_config
*conf
= &vc
->conf
;
3574 /* The only DDF secondary RAID level md can support is
3575 * RAID 10, if the stripe sizes and Basic volume sizes
3577 * Other configurations could in theory be supported by exposing
3578 * the BVDs to user space and using device mapper for the secondary
3579 * mapping. So far we don't support that.
3582 __u64 sec_elements
[4] = {0, 0, 0, 0};
3583 #define __set_sec_seen(n) (sec_elements[(n)>>6] |= (1<<((n)&63)))
3584 #define __was_sec_seen(n) ((sec_elements[(n)>>6] & (1<<((n)&63))) != 0)
3586 if (vc
->other_bvds
== NULL
) {
3587 pr_err("No BVDs for secondary RAID found\n");
3590 if (conf
->prl
!= DDF_RAID1
) {
3591 pr_err("Secondary RAID level only supported for mirrored BVD\n");
3594 if (conf
->srl
!= DDF_2STRIPED
&& conf
->srl
!= DDF_2SPANNED
) {
3595 pr_err("Secondary RAID level %d is unsupported\n",
3599 __set_sec_seen(conf
->sec_elmnt_seq
);
3600 for (i
= 0; i
< conf
->sec_elmnt_count
-1; i
++) {
3601 const struct vd_config
*bvd
= vc
->other_bvds
[i
];
3602 if (bvd
->sec_elmnt_seq
== DDF_UNUSED_BVD
)
3604 if (bvd
->srl
!= conf
->srl
) {
3605 pr_err("Inconsistent secondary RAID level across BVDs\n");
3608 if (bvd
->prl
!= conf
->prl
) {
3609 pr_err("Different RAID levels for BVDs are unsupported\n");
3612 if (!be16_eq(bvd
->prim_elmnt_count
, conf
->prim_elmnt_count
)) {
3613 pr_err("All BVDs must have the same number of primary elements\n");
3616 if (bvd
->chunk_shift
!= conf
->chunk_shift
) {
3617 pr_err("Different strip sizes for BVDs are unsupported\n");
3620 if (!be64_eq(bvd
->array_blocks
, conf
->array_blocks
)) {
3621 pr_err("Different BVD sizes are unsupported\n");
3624 __set_sec_seen(bvd
->sec_elmnt_seq
);
3626 for (i
= 0; i
< conf
->sec_elmnt_count
; i
++) {
3627 if (!__was_sec_seen(i
)) {
3628 pr_err("BVD %d is missing\n", i
);
3635 static unsigned int get_pd_index_from_refnum(const struct vcl
*vc
,
3636 be32 refnum
, unsigned int nmax
,
3637 const struct vd_config
**bvd
,
3640 unsigned int i
, j
, n
, sec
, cnt
;
3642 cnt
= be16_to_cpu(vc
->conf
.prim_elmnt_count
);
3643 sec
= (vc
->conf
.sec_elmnt_count
== 1 ? 0 : vc
->conf
.sec_elmnt_seq
);
3645 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3646 /* j counts valid entries for this BVD */
3647 if (be32_to_cpu(vc
->conf
.phys_refnum
[i
]) != 0xffffffff)
3649 if (be32_eq(vc
->conf
.phys_refnum
[i
], refnum
)) {
3652 return sec
* cnt
+ j
- 1;
3655 if (vc
->other_bvds
== NULL
)
3658 for (n
= 1; n
< vc
->conf
.sec_elmnt_count
; n
++) {
3659 struct vd_config
*vd
= vc
->other_bvds
[n
-1];
3660 sec
= vd
->sec_elmnt_seq
;
3661 if (sec
== DDF_UNUSED_BVD
)
3663 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3664 if (be32_to_cpu(vd
->phys_refnum
[i
]) != 0xffffffff)
3666 if (be32_eq(vd
->phys_refnum
[i
], refnum
)) {
3669 return sec
* cnt
+ j
- 1;
3675 return DDF_NOTFOUND
;
3678 static struct mdinfo
*container_content_ddf(struct supertype
*st
, char *subarray
)
3680 /* Given a container loaded by load_super_ddf_all,
3681 * extract information about all the arrays into
3684 * For each vcl in conflist: create an mdinfo, fill it in,
3685 * then look for matching devices (phys_refnum) in dlist
3686 * and create appropriate device mdinfo.
3688 struct ddf_super
*ddf
= st
->sb
;
3689 struct mdinfo
*rest
= NULL
;
3692 for (vc
= ddf
->conflist
; vc
; vc
=vc
->next
)
3696 struct mdinfo
*this;
3702 (strtoul(subarray
, &ep
, 10) != vc
->vcnum
||
3706 if (vc
->conf
.sec_elmnt_count
> 1) {
3707 if (check_secondary(vc
) != 0)
3711 this = xcalloc(1, sizeof(*this));
3715 if (layout_ddf2md(&vc
->conf
, &this->array
))
3717 this->array
.md_minor
= -1;
3718 this->array
.major_version
= -1;
3719 this->array
.minor_version
= -2;
3720 this->safe_mode_delay
= DDF_SAFE_MODE_DELAY
;
3721 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
3722 this->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
3723 this->array
.utime
= DECADE
+
3724 be32_to_cpu(vc
->conf
.timestamp
);
3725 this->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
3728 if ((ddf
->virt
->entries
[i
].state
& DDF_state_inconsistent
) ||
3729 (ddf
->virt
->entries
[i
].init_state
& DDF_initstate_mask
) !=
3731 this->array
.state
= 0;
3732 this->resync_start
= 0;
3734 this->array
.state
= 1;
3735 this->resync_start
= MaxSector
;
3737 memcpy(this->name
, ddf
->virt
->entries
[i
].name
, 16);
3740 if (this->name
[j
] == ' ')
3743 memset(this->uuid
, 0, sizeof(this->uuid
));
3744 this->component_size
= be64_to_cpu(vc
->conf
.blocks
);
3745 this->array
.size
= this->component_size
/ 2;
3746 this->container_member
= i
;
3748 ddf
->currentconf
= vc
;
3749 uuid_from_super_ddf(st
, this->uuid
);
3751 ddf
->currentconf
= NULL
;
3753 sprintf(this->text_version
, "/%s/%d",
3754 st
->container_devnm
, this->container_member
);
3756 for (pd
= 0; pd
< be16_to_cpu(ddf
->phys
->used_pdes
); pd
++) {
3759 const struct vd_config
*bvd
;
3763 if (be32_to_cpu(ddf
->phys
->entries
[pd
].refnum
)
3767 stt
= be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
3768 if ((stt
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
3772 i
= get_pd_index_from_refnum(
3773 vc
, ddf
->phys
->entries
[pd
].refnum
,
3774 ddf
->mppe
, &bvd
, &iphys
);
3775 if (i
== DDF_NOTFOUND
)
3778 this->array
.working_disks
++;
3780 for (d
= ddf
->dlist
; d
; d
=d
->next
)
3781 if (be32_eq(d
->disk
.refnum
,
3782 ddf
->phys
->entries
[pd
].refnum
))
3785 /* Haven't found that one yet, maybe there are others */
3788 dev
= xcalloc(1, sizeof(*dev
));
3789 dev
->next
= this->devs
;
3792 dev
->disk
.number
= be32_to_cpu(d
->disk
.refnum
);
3793 dev
->disk
.major
= d
->major
;
3794 dev
->disk
.minor
= d
->minor
;
3795 dev
->disk
.raid_disk
= i
;
3796 dev
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
3797 dev
->recovery_start
= MaxSector
;
3799 dev
->events
= be32_to_cpu(ddf
->primary
.seq
);
3801 be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[iphys
]);
3802 dev
->component_size
= be64_to_cpu(bvd
->blocks
);
3804 strcpy(dev
->name
, d
->devname
);
3810 static int store_super_ddf(struct supertype
*st
, int fd
)
3812 struct ddf_super
*ddf
= st
->sb
;
3813 unsigned long long dsize
;
3820 if (!get_dev_size(fd
, NULL
, &dsize
))
3823 if (ddf
->dlist
|| ddf
->conflist
) {
3828 if (fstat(fd
, &sta
) == -1 || !S_ISBLK(sta
.st_mode
)) {
3829 pr_err("%s: file descriptor for invalid device\n",
3833 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3834 if (dl
->major
== (int)major(sta
.st_rdev
) &&
3835 dl
->minor
== (int)minor(sta
.st_rdev
))
3838 pr_err("%s: couldn't find disk %d/%d\n", __func__
,
3839 (int)major(sta
.st_rdev
),
3840 (int)minor(sta
.st_rdev
));
3845 ret
= (_write_super_to_disk(ddf
, dl
) != 1);
3850 if (posix_memalign(&buf
, 512, 512) != 0)
3852 memset(buf
, 0, 512);
3854 lseek64(fd
, dsize
-512, 0);
3855 rc
= write(fd
, buf
, 512);
3862 static int compare_super_ddf(struct supertype
*st
, struct supertype
*tst
)
3866 * 0 same, or first was empty, and second was copied
3867 * 1 second had wrong number
3869 * 3 wrong other info
3871 struct ddf_super
*first
= st
->sb
;
3872 struct ddf_super
*second
= tst
->sb
;
3873 struct dl
*dl1
, *dl2
;
3874 struct vcl
*vl1
, *vl2
;
3875 unsigned int max_vds
, max_pds
, pd
, vd
;
3883 if (memcmp(first
->anchor
.guid
, second
->anchor
.guid
, DDF_GUID_LEN
) != 0)
3886 if (!be32_eq(first
->anchor
.seq
, second
->anchor
.seq
)) {
3887 dprintf("%s: sequence number mismatch %u/%u\n", __func__
,
3888 be32_to_cpu(first
->anchor
.seq
),
3889 be32_to_cpu(second
->anchor
.seq
));
3892 if (first
->max_part
!= second
->max_part
||
3893 !be16_eq(first
->phys
->used_pdes
, second
->phys
->used_pdes
) ||
3894 !be16_eq(first
->virt
->populated_vdes
,
3895 second
->virt
->populated_vdes
)) {
3896 dprintf("%s: PD/VD number mismatch\n", __func__
);
3900 max_pds
= be16_to_cpu(first
->phys
->used_pdes
);
3901 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
3902 for (pd
= 0; pd
< max_pds
; pd
++)
3903 if (be32_eq(first
->phys
->entries
[pd
].refnum
,
3906 if (pd
== max_pds
) {
3907 dprintf("%s: no match for disk %08x\n", __func__
,
3908 be32_to_cpu(dl2
->disk
.refnum
));
3913 max_vds
= be16_to_cpu(first
->active
->max_vd_entries
);
3914 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3915 if (!be32_eq(vl2
->conf
.magic
, DDF_VD_CONF_MAGIC
))
3917 for (vd
= 0; vd
< max_vds
; vd
++)
3918 if (!memcmp(first
->virt
->entries
[vd
].guid
,
3919 vl2
->conf
.guid
, DDF_GUID_LEN
))
3921 if (vd
== max_vds
) {
3922 dprintf("%s: no match for VD config\n", __func__
);
3926 /* FIXME should I look at anything else? */
3929 At this point we are fairly sure that the meta data matches.
3930 But the new disk may contain additional local data.
3931 Add it to the super block.
3933 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3934 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
)
3935 if (!memcmp(vl1
->conf
.guid
, vl2
->conf
.guid
,
3939 if (vl1
->other_bvds
!= NULL
&&
3940 vl1
->conf
.sec_elmnt_seq
!=
3941 vl2
->conf
.sec_elmnt_seq
) {
3942 dprintf("%s: adding BVD %u\n", __func__
,
3943 vl2
->conf
.sec_elmnt_seq
);
3944 add_other_bvd(vl1
, &vl2
->conf
,
3945 first
->conf_rec_len
*512);
3950 if (posix_memalign((void **)&vl1
, 512,
3951 (first
->conf_rec_len
*512 +
3952 offsetof(struct vcl
, conf
))) != 0) {
3953 pr_err("%s could not allocate vcl buf\n",
3958 vl1
->next
= first
->conflist
;
3959 vl1
->block_sizes
= NULL
;
3960 memcpy(&vl1
->conf
, &vl2
->conf
, first
->conf_rec_len
*512);
3961 if (alloc_other_bvds(first
, vl1
) != 0) {
3962 pr_err("%s could not allocate other bvds\n",
3967 for (vd
= 0; vd
< max_vds
; vd
++)
3968 if (!memcmp(first
->virt
->entries
[vd
].guid
,
3969 vl1
->conf
.guid
, DDF_GUID_LEN
))
3972 dprintf("%s: added config for VD %u\n", __func__
, vl1
->vcnum
);
3973 first
->conflist
= vl1
;
3976 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
3977 for (dl1
= first
->dlist
; dl1
; dl1
= dl1
->next
)
3978 if (be32_eq(dl1
->disk
.refnum
, dl2
->disk
.refnum
))
3983 if (posix_memalign((void **)&dl1
, 512,
3984 sizeof(*dl1
) + (first
->max_part
) * sizeof(dl1
->vlist
[0]))
3986 pr_err("%s could not allocate disk info buffer\n",
3990 memcpy(dl1
, dl2
, sizeof(*dl1
));
3991 dl1
->mdupdate
= NULL
;
3992 dl1
->next
= first
->dlist
;
3994 for (pd
= 0; pd
< max_pds
; pd
++)
3995 if (be32_eq(first
->phys
->entries
[pd
].refnum
,
4000 if (posix_memalign((void **)&dl1
->spare
, 512,
4001 first
->conf_rec_len
*512) != 0) {
4002 pr_err("%s could not allocate spare info buf\n",
4006 memcpy(dl1
->spare
, dl2
->spare
, first
->conf_rec_len
*512);
4008 for (vd
= 0 ; vd
< first
->max_part
; vd
++) {
4009 if (!dl2
->vlist
[vd
]) {
4010 dl1
->vlist
[vd
] = NULL
;
4013 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
) {
4014 if (!memcmp(vl1
->conf
.guid
,
4015 dl2
->vlist
[vd
]->conf
.guid
,
4018 dl1
->vlist
[vd
] = vl1
;
4022 dprintf("%s: added disk %d: %08x\n", __func__
, dl1
->pdnum
,
4023 be32_to_cpu(dl1
->disk
.refnum
));
4031 * A new array 'a' has been started which claims to be instance 'inst'
4032 * within container 'c'.
4033 * We need to confirm that the array matches the metadata in 'c' so
4034 * that we don't corrupt any metadata.
4036 static int ddf_open_new(struct supertype
*c
, struct active_array
*a
, char *inst
)
4038 struct ddf_super
*ddf
= c
->sb
;
4042 static const char faulty
[] = "faulty";
4044 if (all_ff(ddf
->virt
->entries
[n
].guid
)) {
4045 pr_err("%s: subarray %d doesn't exist\n", __func__
, n
);
4048 dprintf("%s: new subarray %d, GUID: %s\n", __func__
, n
,
4049 guid_str(ddf
->virt
->entries
[n
].guid
));
4050 for (dev
= a
->info
.devs
; dev
; dev
= dev
->next
) {
4051 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4052 if (dl
->major
== dev
->disk
.major
&&
4053 dl
->minor
== dev
->disk
.minor
)
4056 pr_err("%s: device %d/%d of subarray %d not found in meta data\n",
4057 __func__
, dev
->disk
.major
, dev
->disk
.minor
, n
);
4060 if ((be16_to_cpu(ddf
->phys
->entries
[dl
->pdnum
].state
) &
4061 (DDF_Online
|DDF_Missing
|DDF_Failed
)) != DDF_Online
) {
4062 pr_err("%s: new subarray %d contains broken device %d/%d (%02x)\n",
4063 __func__
, n
, dl
->major
, dl
->minor
,
4065 ddf
->phys
->entries
[dl
->pdnum
].state
));
4066 if (write(dev
->state_fd
, faulty
, sizeof(faulty
)-1) !=
4068 pr_err("Write to state_fd failed\n");
4069 dev
->curr_state
= DS_FAULTY
;
4072 a
->info
.container_member
= n
;
4077 * The array 'a' is to be marked clean in the metadata.
4078 * If '->resync_start' is not ~(unsigned long long)0, then the array is only
4079 * clean up to the point (in sectors). If that cannot be recorded in the
4080 * metadata, then leave it as dirty.
4082 * For DDF, we need to clear the DDF_state_inconsistent bit in the
4083 * !global! virtual_disk.virtual_entry structure.
4085 static int ddf_set_array_state(struct active_array
*a
, int consistent
)
4087 struct ddf_super
*ddf
= a
->container
->sb
;
4088 int inst
= a
->info
.container_member
;
4089 int old
= ddf
->virt
->entries
[inst
].state
;
4090 if (consistent
== 2) {
4091 /* Should check if a recovery should be started FIXME */
4093 if (!is_resync_complete(&a
->info
))
4097 ddf
->virt
->entries
[inst
].state
&= ~DDF_state_inconsistent
;
4099 ddf
->virt
->entries
[inst
].state
|= DDF_state_inconsistent
;
4100 if (old
!= ddf
->virt
->entries
[inst
].state
)
4101 ddf_set_updates_pending(ddf
);
4103 old
= ddf
->virt
->entries
[inst
].init_state
;
4104 ddf
->virt
->entries
[inst
].init_state
&= ~DDF_initstate_mask
;
4105 if (is_resync_complete(&a
->info
))
4106 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_full
;
4107 else if (a
->info
.resync_start
== 0)
4108 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_not
;
4110 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_quick
;
4111 if (old
!= ddf
->virt
->entries
[inst
].init_state
)
4112 ddf_set_updates_pending(ddf
);
4114 dprintf("ddf mark %d/%s (%d) %s %llu\n", inst
,
4115 guid_str(ddf
->virt
->entries
[inst
].guid
), a
->curr_state
,
4116 consistent
?"clean":"dirty",
4117 a
->info
.resync_start
);
4121 static int get_bvd_state(const struct ddf_super
*ddf
,
4122 const struct vd_config
*vc
)
4124 unsigned int i
, n_bvd
, working
= 0;
4125 unsigned int n_prim
= be16_to_cpu(vc
->prim_elmnt_count
);
4127 for (i
= 0; i
< n_prim
; i
++) {
4128 if (!find_index_in_bvd(ddf
, vc
, i
, &n_bvd
))
4130 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
4133 st
= be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
4134 if ((st
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
4139 state
= DDF_state_degraded
;
4140 if (working
== n_prim
)
4141 state
= DDF_state_optimal
;
4147 state
= DDF_state_failed
;
4151 state
= DDF_state_failed
;
4152 else if (working
>= 2)
4153 state
= DDF_state_part_optimal
;
4157 if (working
< n_prim
- 1)
4158 state
= DDF_state_failed
;
4161 if (working
< n_prim
- 2)
4162 state
= DDF_state_failed
;
4163 else if (working
== n_prim
- 1)
4164 state
= DDF_state_part_optimal
;
4170 static int secondary_state(int state
, int other
, int seclevel
)
4172 if (state
== DDF_state_optimal
&& other
== DDF_state_optimal
)
4173 return DDF_state_optimal
;
4174 if (seclevel
== DDF_2MIRRORED
) {
4175 if (state
== DDF_state_optimal
|| other
== DDF_state_optimal
)
4176 return DDF_state_part_optimal
;
4177 if (state
== DDF_state_failed
&& other
== DDF_state_failed
)
4178 return DDF_state_failed
;
4179 return DDF_state_degraded
;
4181 if (state
== DDF_state_failed
|| other
== DDF_state_failed
)
4182 return DDF_state_failed
;
4183 if (state
== DDF_state_degraded
|| other
== DDF_state_degraded
)
4184 return DDF_state_degraded
;
4185 return DDF_state_part_optimal
;
4189 static int get_svd_state(const struct ddf_super
*ddf
, const struct vcl
*vcl
)
4191 int state
= get_bvd_state(ddf
, &vcl
->conf
);
4193 for (i
= 1; i
< vcl
->conf
.sec_elmnt_count
; i
++) {
4194 state
= secondary_state(
4196 get_bvd_state(ddf
, vcl
->other_bvds
[i
-1]),
4203 * The state of each disk is stored in the global phys_disk structure
4204 * in phys_disk.entries[n].state.
4205 * This makes various combinations awkward.
4206 * - When a device fails in any array, it must be failed in all arrays
4207 * that include a part of this device.
4208 * - When a component is rebuilding, we cannot include it officially in the
4209 * array unless this is the only array that uses the device.
4211 * So: when transitioning:
4212 * Online -> failed, just set failed flag. monitor will propagate
4213 * spare -> online, the device might need to be added to the array.
4214 * spare -> failed, just set failed. Don't worry if in array or not.
4216 static void ddf_set_disk(struct active_array
*a
, int n
, int state
)
4218 struct ddf_super
*ddf
= a
->container
->sb
;
4219 unsigned int inst
= a
->info
.container_member
, n_bvd
;
4221 struct vd_config
*vc
= find_vdcr(ddf
, inst
, (unsigned int)n
,
4227 dprintf("%s: %d to %x\n", __func__
, n
, state
);
4229 dprintf("ddf: cannot find instance %d!!\n", inst
);
4232 /* Find the matching slot in 'info'. */
4233 for (mdi
= a
->info
.devs
; mdi
; mdi
= mdi
->next
)
4234 if (mdi
->disk
.raid_disk
== n
)
4237 pr_err("%s: cannot find raid disk %d\n",
4242 /* and find the 'dl' entry corresponding to that. */
4243 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4244 if (mdi
->state_fd
>= 0 &&
4245 mdi
->disk
.major
== dl
->major
&&
4246 mdi
->disk
.minor
== dl
->minor
)
4249 pr_err("%s: cannot find raid disk %d (%d/%d)\n",
4251 mdi
->disk
.major
, mdi
->disk
.minor
);
4255 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
4256 if (pd
< 0 || pd
!= dl
->pdnum
) {
4257 /* disk doesn't currently exist or has changed.
4258 * If it is now in_sync, insert it. */
4259 dprintf("%s: phys disk not found for %d: %d/%d ref %08x\n",
4260 __func__
, dl
->pdnum
, dl
->major
, dl
->minor
,
4261 be32_to_cpu(dl
->disk
.refnum
));
4262 dprintf("%s: array %u disk %u ref %08x pd %d\n",
4263 __func__
, inst
, n_bvd
,
4264 be32_to_cpu(vc
->phys_refnum
[n_bvd
]), pd
);
4265 if ((state
& DS_INSYNC
) && ! (state
& DS_FAULTY
)) {
4266 pd
= dl
->pdnum
; /* FIXME: is this really correct ? */
4267 vc
->phys_refnum
[n_bvd
] = dl
->disk
.refnum
;
4268 LBA_OFFSET(ddf
, vc
)[n_bvd
] =
4269 cpu_to_be64(mdi
->data_offset
);
4270 be16_clear(ddf
->phys
->entries
[pd
].type
,
4271 cpu_to_be16(DDF_Global_Spare
));
4272 be16_set(ddf
->phys
->entries
[pd
].type
,
4273 cpu_to_be16(DDF_Active_in_VD
));
4274 ddf_set_updates_pending(ddf
);
4277 be16 old
= ddf
->phys
->entries
[pd
].state
;
4278 if (state
& DS_FAULTY
)
4279 be16_set(ddf
->phys
->entries
[pd
].state
,
4280 cpu_to_be16(DDF_Failed
));
4281 if (state
& DS_INSYNC
) {
4282 be16_set(ddf
->phys
->entries
[pd
].state
,
4283 cpu_to_be16(DDF_Online
));
4284 be16_clear(ddf
->phys
->entries
[pd
].state
,
4285 cpu_to_be16(DDF_Rebuilding
));
4287 if (!be16_eq(old
, ddf
->phys
->entries
[pd
].state
))
4288 ddf_set_updates_pending(ddf
);
4291 dprintf("ddf: set_disk %d (%08x) to %x->%02x\n", n
,
4292 be32_to_cpu(dl
->disk
.refnum
), state
,
4293 be16_to_cpu(ddf
->phys
->entries
[pd
].state
));
4295 /* Now we need to check the state of the array and update
4296 * virtual_disk.entries[n].state.
4297 * It needs to be one of "optimal", "degraded", "failed".
4298 * I don't understand 'deleted' or 'missing'.
4300 state
= get_svd_state(ddf
, vcl
);
4302 if (ddf
->virt
->entries
[inst
].state
!=
4303 ((ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4306 ddf
->virt
->entries
[inst
].state
=
4307 (ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4309 ddf_set_updates_pending(ddf
);
4314 static void ddf_sync_metadata(struct supertype
*st
)
4318 * Write all data to all devices.
4319 * Later, we might be able to track whether only local changes
4320 * have been made, or whether any global data has been changed,
4321 * but ddf is sufficiently weird that it probably always
4322 * changes global data ....
4324 struct ddf_super
*ddf
= st
->sb
;
4325 if (!ddf
->updates_pending
)
4327 ddf
->updates_pending
= 0;
4328 __write_init_super_ddf(st
);
4329 dprintf("ddf: sync_metadata\n");
4332 static int del_from_conflist(struct vcl
**list
, const char *guid
)
4336 for (p
= list
; p
&& *p
; p
= &((*p
)->next
))
4337 if (!memcmp((*p
)->conf
.guid
, guid
, DDF_GUID_LEN
)) {
4344 static int _kill_subarray_ddf(struct ddf_super
*ddf
, const char *guid
)
4347 unsigned int vdnum
, i
;
4348 vdnum
= find_vde_by_guid(ddf
, guid
);
4349 if (vdnum
== DDF_NOTFOUND
) {
4350 pr_err("%s: could not find VD %s\n", __func__
,
4354 if (del_from_conflist(&ddf
->conflist
, guid
) == 0) {
4355 pr_err("%s: could not find conf %s\n", __func__
,
4359 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4360 for (i
= 0; i
< ddf
->max_part
; i
++)
4361 if (dl
->vlist
[i
] != NULL
&&
4362 !memcmp(dl
->vlist
[i
]->conf
.guid
, guid
,
4364 dl
->vlist
[i
] = NULL
;
4365 memset(ddf
->virt
->entries
[vdnum
].guid
, 0xff, DDF_GUID_LEN
);
4366 dprintf("%s: deleted %s\n", __func__
, guid_str(guid
));
4370 static int kill_subarray_ddf(struct supertype
*st
)
4372 struct ddf_super
*ddf
= st
->sb
;
4374 * currentconf is set in container_content_ddf,
4375 * called with subarray arg
4377 struct vcl
*victim
= ddf
->currentconf
;
4378 struct vd_config
*conf
;
4379 ddf
->currentconf
= NULL
;
4382 pr_err("%s: nothing to kill\n", __func__
);
4385 conf
= &victim
->conf
;
4386 vdnum
= find_vde_by_guid(ddf
, conf
->guid
);
4387 if (vdnum
== DDF_NOTFOUND
) {
4388 pr_err("%s: could not find VD %s\n", __func__
,
4389 guid_str(conf
->guid
));
4392 if (st
->update_tail
) {
4393 struct virtual_disk
*vd
;
4394 int len
= sizeof(struct virtual_disk
)
4395 + sizeof(struct virtual_entry
);
4398 pr_err("%s: failed to allocate %d bytes\n", __func__
,
4402 memset(vd
, 0 , len
);
4403 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
4404 vd
->populated_vdes
= cpu_to_be16(0);
4405 memcpy(vd
->entries
[0].guid
, conf
->guid
, DDF_GUID_LEN
);
4406 /* we use DDF_state_deleted as marker */
4407 vd
->entries
[0].state
= DDF_state_deleted
;
4408 append_metadata_update(st
, vd
, len
);
4410 _kill_subarray_ddf(ddf
, conf
->guid
);
4411 ddf_set_updates_pending(ddf
);
4412 ddf_sync_metadata(st
);
4417 static void copy_matching_bvd(struct ddf_super
*ddf
,
4418 struct vd_config
*conf
,
4419 const struct metadata_update
*update
)
4422 be16_to_cpu(ddf
->anchor
.max_primary_element_entries
);
4423 unsigned int len
= ddf
->conf_rec_len
* 512;
4425 struct vd_config
*vc
;
4426 for (p
= update
->buf
; p
< update
->buf
+ update
->len
; p
+= len
) {
4427 vc
= (struct vd_config
*) p
;
4428 if (vc
->sec_elmnt_seq
== conf
->sec_elmnt_seq
) {
4429 memcpy(conf
->phys_refnum
, vc
->phys_refnum
,
4430 mppe
* (sizeof(__u32
) + sizeof(__u64
)));
4434 pr_err("%s: no match for BVD %d of %s in update\n", __func__
,
4435 conf
->sec_elmnt_seq
, guid_str(conf
->guid
));
4438 static void ddf_process_update(struct supertype
*st
,
4439 struct metadata_update
*update
)
4441 /* Apply this update to the metadata.
4442 * The first 4 bytes are a DDF_*_MAGIC which guides
4444 * Possible update are:
4445 * DDF_PHYS_RECORDS_MAGIC
4446 * Add a new physical device or remove an old one.
4447 * Changes to this record only happen implicitly.
4448 * used_pdes is the device number.
4449 * DDF_VIRT_RECORDS_MAGIC
4450 * Add a new VD. Possibly also change the 'access' bits.
4451 * populated_vdes is the entry number.
4453 * New or updated VD. the VIRT_RECORD must already
4454 * exist. For an update, phys_refnum and lba_offset
4455 * (at least) are updated, and the VD_CONF must
4456 * be written to precisely those devices listed with
4458 * DDF_SPARE_ASSIGN_MAGIC
4459 * replacement Spare Assignment Record... but for which device?
4462 * - to create a new array, we send a VIRT_RECORD and
4463 * a VD_CONF. Then assemble and start the array.
4464 * - to activate a spare we send a VD_CONF to add the phys_refnum
4465 * and offset. This will also mark the spare as active with
4466 * a spare-assignment record.
4468 struct ddf_super
*ddf
= st
->sb
;
4469 be32
*magic
= (be32
*)update
->buf
;
4470 struct phys_disk
*pd
;
4471 struct virtual_disk
*vd
;
4472 struct vd_config
*vc
;
4476 unsigned int pdnum
, pd2
, len
;
4478 dprintf("Process update %x\n", be32_to_cpu(*magic
));
4480 if (be32_eq(*magic
, DDF_PHYS_RECORDS_MAGIC
)) {
4482 if (update
->len
!= (sizeof(struct phys_disk
) +
4483 sizeof(struct phys_disk_entry
)))
4485 pd
= (struct phys_disk
*)update
->buf
;
4487 ent
= be16_to_cpu(pd
->used_pdes
);
4488 if (ent
>= be16_to_cpu(ddf
->phys
->max_pdes
))
4490 if (be16_and(pd
->entries
[0].state
, cpu_to_be16(DDF_Missing
))) {
4492 /* removing this disk. */
4493 be16_set(ddf
->phys
->entries
[ent
].state
,
4494 cpu_to_be16(DDF_Missing
));
4495 for (dlp
= &ddf
->dlist
; *dlp
; dlp
= &(*dlp
)->next
) {
4496 struct dl
*dl
= *dlp
;
4497 if (dl
->pdnum
== (signed)ent
) {
4500 /* FIXME this doesn't free
4507 ddf_set_updates_pending(ddf
);
4510 if (!all_ff(ddf
->phys
->entries
[ent
].guid
))
4512 ddf
->phys
->entries
[ent
] = pd
->entries
[0];
4513 ddf
->phys
->used_pdes
= cpu_to_be16
4514 (1 + be16_to_cpu(ddf
->phys
->used_pdes
));
4515 ddf_set_updates_pending(ddf
);
4516 if (ddf
->add_list
) {
4517 struct active_array
*a
;
4518 struct dl
*al
= ddf
->add_list
;
4519 ddf
->add_list
= al
->next
;
4521 al
->next
= ddf
->dlist
;
4524 /* As a device has been added, we should check
4525 * for any degraded devices that might make
4526 * use of this spare */
4527 for (a
= st
->arrays
; a
; a
=a
->next
)
4528 a
->check_degraded
= 1;
4530 } else if (be32_eq(*magic
, DDF_VIRT_RECORDS_MAGIC
)) {
4532 if (update
->len
!= (sizeof(struct virtual_disk
) +
4533 sizeof(struct virtual_entry
)))
4535 vd
= (struct virtual_disk
*)update
->buf
;
4537 if (vd
->entries
[0].state
== DDF_state_deleted
) {
4538 if (_kill_subarray_ddf(ddf
, vd
->entries
[0].guid
))
4542 ent
= find_vde_by_guid(ddf
, vd
->entries
[0].guid
);
4543 if (ent
!= DDF_NOTFOUND
) {
4544 dprintf("%s: VD %s exists already in slot %d\n",
4545 __func__
, guid_str(vd
->entries
[0].guid
),
4549 ent
= find_unused_vde(ddf
);
4550 if (ent
== DDF_NOTFOUND
)
4552 ddf
->virt
->entries
[ent
] = vd
->entries
[0];
4553 ddf
->virt
->populated_vdes
=
4556 ddf
->virt
->populated_vdes
));
4557 dprintf("%s: added VD %s in slot %d(s=%02x i=%02x)\n",
4558 __func__
, guid_str(vd
->entries
[0].guid
), ent
,
4559 ddf
->virt
->entries
[ent
].state
,
4560 ddf
->virt
->entries
[ent
].init_state
);
4562 ddf_set_updates_pending(ddf
);
4565 else if (be32_eq(*magic
, DDF_VD_CONF_MAGIC
)) {
4566 vc
= (struct vd_config
*)update
->buf
;
4567 len
= ddf
->conf_rec_len
* 512;
4568 if ((unsigned int)update
->len
!= len
* vc
->sec_elmnt_count
) {
4569 pr_err("%s: %s: insufficient data (%d) for %u BVDs\n",
4570 __func__
, guid_str(vc
->guid
), update
->len
,
4571 vc
->sec_elmnt_count
);
4574 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
)
4575 if (memcmp(vcl
->conf
.guid
, vc
->guid
, DDF_GUID_LEN
) == 0)
4577 dprintf("%s: conf update for %s (%s)\n", __func__
,
4578 guid_str(vc
->guid
), (vcl
? "old" : "new"));
4580 /* An update, just copy the phys_refnum and lba_offset
4585 copy_matching_bvd(ddf
, &vcl
->conf
, update
);
4586 for (k
= 0; k
< be16_to_cpu(vc
->prim_elmnt_count
); k
++)
4587 dprintf("BVD %u has %08x at %llu\n", 0,
4588 be32_to_cpu(vcl
->conf
.phys_refnum
[k
]),
4589 be64_to_cpu(LBA_OFFSET(ddf
,
4591 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++) {
4592 copy_matching_bvd(ddf
, vcl
->other_bvds
[i
-1],
4594 for (k
= 0; k
< be16_to_cpu(
4595 vc
->prim_elmnt_count
); k
++)
4596 dprintf("BVD %u has %08x at %llu\n", i
,
4598 (vcl
->other_bvds
[i
-1]->
4603 vcl
->other_bvds
[i
-1])[k
]));
4610 vcl
= update
->space
;
4611 update
->space
= NULL
;
4612 vcl
->next
= ddf
->conflist
;
4613 memcpy(&vcl
->conf
, vc
, len
);
4614 ent
= find_vde_by_guid(ddf
, vc
->guid
);
4615 if (ent
== DDF_NOTFOUND
)
4618 ddf
->conflist
= vcl
;
4619 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++)
4620 memcpy(vcl
->other_bvds
[i
-1],
4621 update
->buf
+ len
* i
, len
);
4623 /* Set DDF_Transition on all Failed devices - to help
4624 * us detect those that are no longer in use
4626 for (pdnum
= 0; pdnum
< be16_to_cpu(ddf
->phys
->used_pdes
);
4628 if (be16_and(ddf
->phys
->entries
[pdnum
].state
,
4629 cpu_to_be16(DDF_Failed
)))
4630 be16_set(ddf
->phys
->entries
[pdnum
].state
,
4631 cpu_to_be16(DDF_Transition
));
4632 /* Now make sure vlist is correct for each dl. */
4633 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
4634 unsigned int vn
= 0;
4635 int in_degraded
= 0;
4636 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
) {
4637 unsigned int dn
, ibvd
;
4638 const struct vd_config
*conf
;
4640 dn
= get_pd_index_from_refnum(vcl
,
4644 if (dn
== DDF_NOTFOUND
)
4646 dprintf("dev %d/%08x has %s (sec=%u) at %d\n",
4648 be32_to_cpu(dl
->disk
.refnum
),
4649 guid_str(conf
->guid
),
4650 conf
->sec_elmnt_seq
, vn
);
4651 /* Clear the Transition flag */
4653 (ddf
->phys
->entries
[dl
->pdnum
].state
,
4654 cpu_to_be16(DDF_Failed
)))
4655 be16_clear(ddf
->phys
4656 ->entries
[dl
->pdnum
].state
,
4657 cpu_to_be16(DDF_Transition
));
4658 dl
->vlist
[vn
++] = vcl
;
4659 vstate
= ddf
->virt
->entries
[vcl
->vcnum
].state
4661 if (vstate
== DDF_state_degraded
||
4662 vstate
== DDF_state_part_optimal
)
4665 while (vn
< ddf
->max_part
)
4666 dl
->vlist
[vn
++] = NULL
;
4668 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4669 cpu_to_be16(DDF_Global_Spare
));
4670 if (!be16_and(ddf
->phys
4671 ->entries
[dl
->pdnum
].type
,
4672 cpu_to_be16(DDF_Active_in_VD
))) {
4674 ->entries
[dl
->pdnum
].type
,
4675 cpu_to_be16(DDF_Active_in_VD
));
4678 ->entries
[dl
->pdnum
]
4685 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4686 cpu_to_be16(DDF_Global_Spare
));
4687 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
4688 cpu_to_be16(DDF_Spare
));
4690 if (!dl
->vlist
[0] && !dl
->spare
) {
4691 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
4692 cpu_to_be16(DDF_Global_Spare
));
4693 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4694 cpu_to_be16(DDF_Spare
));
4695 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4696 cpu_to_be16(DDF_Active_in_VD
));
4700 /* Now remove any 'Failed' devices that are not part
4701 * of any VD. They will have the Transition flag set.
4702 * Once done, we need to update all dl->pdnum numbers.
4705 for (pdnum
= 0; pdnum
< be16_to_cpu(ddf
->phys
->used_pdes
);
4707 if (be16_and(ddf
->phys
->entries
[pdnum
].state
,
4708 cpu_to_be16(DDF_Failed
))
4709 && be16_and(ddf
->phys
->entries
[pdnum
].state
,
4710 cpu_to_be16(DDF_Transition
))) {
4711 /* skip this one unless in dlist*/
4712 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4713 if (dl
->pdnum
== (int)pdnum
)
4721 ddf
->phys
->entries
[pd2
] =
4722 ddf
->phys
->entries
[pdnum
];
4723 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4724 if (dl
->pdnum
== (int)pdnum
)
4729 ddf
->phys
->used_pdes
= cpu_to_be16(pd2
);
4730 while (pd2
< pdnum
) {
4731 memset(ddf
->phys
->entries
[pd2
].guid
, 0xff,
4736 ddf_set_updates_pending(ddf
);
4738 /* case DDF_SPARE_ASSIGN_MAGIC */
4741 static void ddf_prepare_update(struct supertype
*st
,
4742 struct metadata_update
*update
)
4744 /* This update arrived at managemon.
4745 * We are about to pass it to monitor.
4746 * If a malloc is needed, do it here.
4748 struct ddf_super
*ddf
= st
->sb
;
4749 be32
*magic
= (be32
*)update
->buf
;
4750 if (be32_eq(*magic
, DDF_VD_CONF_MAGIC
)) {
4752 struct vd_config
*conf
= (struct vd_config
*) update
->buf
;
4753 if (posix_memalign(&update
->space
, 512,
4754 offsetof(struct vcl
, conf
)
4755 + ddf
->conf_rec_len
* 512) != 0) {
4756 update
->space
= NULL
;
4759 vcl
= update
->space
;
4760 vcl
->conf
.sec_elmnt_count
= conf
->sec_elmnt_count
;
4761 if (alloc_other_bvds(ddf
, vcl
) != 0) {
4762 free(update
->space
);
4763 update
->space
= NULL
;
4769 * Check degraded state of a RAID10.
4770 * returns 2 for good, 1 for degraded, 0 for failed, and -1 for error
4772 static int raid10_degraded(struct mdinfo
*info
)
4780 n_prim
= info
->array
.layout
& ~0x100;
4781 n_bvds
= info
->array
.raid_disks
/ n_prim
;
4782 found
= xmalloc(n_bvds
);
4785 memset(found
, 0, n_bvds
);
4786 for (d
= info
->devs
; d
; d
= d
->next
) {
4787 i
= d
->disk
.raid_disk
/ n_prim
;
4789 pr_err("%s: BUG: invalid raid disk\n", __func__
);
4792 if (d
->state_fd
> 0)
4796 for (i
= 0; i
< n_bvds
; i
++)
4798 dprintf("%s: BVD %d/%d failed\n", __func__
, i
, n_bvds
);
4801 } else if (found
[i
] < n_prim
) {
4802 dprintf("%s: BVD %d/%d degraded\n", __func__
, i
,
4812 * Check if the array 'a' is degraded but not failed.
4813 * If it is, find as many spares as are available and needed and
4814 * arrange for their inclusion.
4815 * We only choose devices which are not already in the array,
4816 * and prefer those with a spare-assignment to this array.
4817 * otherwise we choose global spares - assuming always that
4818 * there is enough room.
4819 * For each spare that we assign, we return an 'mdinfo' which
4820 * describes the position for the device in the array.
4821 * We also add to 'updates' a DDF_VD_CONF_MAGIC update with
4822 * the new phys_refnum and lba_offset values.
4824 * Only worry about BVDs at the moment.
4826 static struct mdinfo
*ddf_activate_spare(struct active_array
*a
,
4827 struct metadata_update
**updates
)
4831 struct ddf_super
*ddf
= a
->container
->sb
;
4833 struct mdinfo
*rv
= NULL
;
4835 struct metadata_update
*mu
;
4840 struct vd_config
*vc
;
4843 for (d
= a
->info
.devs
; d
; d
= d
->next
) {
4844 if ((d
->curr_state
& DS_FAULTY
) &&
4846 /* wait for Removal to happen */
4848 if (d
->state_fd
>= 0)
4852 dprintf("%s: working=%d (%d) level=%d\n", __func__
, working
,
4853 a
->info
.array
.raid_disks
,
4854 a
->info
.array
.level
);
4855 if (working
== a
->info
.array
.raid_disks
)
4856 return NULL
; /* array not degraded */
4857 switch (a
->info
.array
.level
) {
4860 return NULL
; /* failed */
4864 if (working
< a
->info
.array
.raid_disks
- 1)
4865 return NULL
; /* failed */
4868 if (working
< a
->info
.array
.raid_disks
- 2)
4869 return NULL
; /* failed */
4872 if (raid10_degraded(&a
->info
) < 1)
4875 default: /* concat or stripe */
4876 return NULL
; /* failed */
4879 /* For each slot, if it is not working, find a spare */
4881 for (i
= 0; i
< a
->info
.array
.raid_disks
; i
++) {
4882 for (d
= a
->info
.devs
; d
; d
= d
->next
)
4883 if (d
->disk
.raid_disk
== i
)
4885 dprintf("found %d: %p %x\n", i
, d
, d
?d
->curr_state
:0);
4886 if (d
&& (d
->state_fd
>= 0))
4889 /* OK, this device needs recovery. Find a spare */
4891 for ( ; dl
; dl
= dl
->next
) {
4892 unsigned long long esize
;
4893 unsigned long long pos
;
4896 int is_dedicated
= 0;
4899 be16 state
= ddf
->phys
->entries
[dl
->pdnum
].state
;
4901 cpu_to_be16(DDF_Failed
|DDF_Missing
)) ||
4903 cpu_to_be16(DDF_Online
)))
4906 /* If in this array, skip */
4907 for (d2
= a
->info
.devs
; d2
; d2
= d2
->next
)
4908 if (d2
->state_fd
>= 0 &&
4909 d2
->disk
.major
== dl
->major
&&
4910 d2
->disk
.minor
== dl
->minor
) {
4911 dprintf("%x:%x (%08x) already in array\n",
4912 dl
->major
, dl
->minor
,
4913 be32_to_cpu(dl
->disk
.refnum
));
4918 if (be16_and(ddf
->phys
->entries
[dl
->pdnum
].type
,
4919 cpu_to_be16(DDF_Spare
))) {
4920 /* Check spare assign record */
4922 if (dl
->spare
->type
& DDF_spare_dedicated
) {
4923 /* check spare_ents for guid */
4929 if (memcmp(dl
->spare
->spare_ents
[j
].guid
,
4930 ddf
->virt
->entries
[a
->info
.container_member
].guid
,
4937 } else if (be16_and(ddf
->phys
->entries
[dl
->pdnum
].type
,
4938 cpu_to_be16(DDF_Global_Spare
))) {
4940 } else if (!be16_and(ddf
->phys
4941 ->entries
[dl
->pdnum
].state
,
4942 cpu_to_be16(DDF_Failed
))) {
4943 /* we can possibly use some of this */
4946 if ( ! (is_dedicated
||
4947 (is_global
&& global_ok
))) {
4948 dprintf("%x:%x not suitable: %d %d\n", dl
->major
, dl
->minor
,
4949 is_dedicated
, is_global
);
4953 /* We are allowed to use this device - is there space?
4954 * We need a->info.component_size sectors */
4955 ex
= get_extents(ddf
, dl
);
4957 dprintf("cannot get extents\n");
4964 esize
= ex
[j
].start
- pos
;
4965 if (esize
>= a
->info
.component_size
)
4967 pos
= ex
[j
].start
+ ex
[j
].size
;
4969 } while (ex
[j
-1].size
);
4972 if (esize
< a
->info
.component_size
) {
4973 dprintf("%x:%x has no room: %llu %llu\n",
4974 dl
->major
, dl
->minor
,
4975 esize
, a
->info
.component_size
);
4980 /* Cool, we have a device with some space at pos */
4981 di
= xcalloc(1, sizeof(*di
));
4982 di
->disk
.number
= i
;
4983 di
->disk
.raid_disk
= i
;
4984 di
->disk
.major
= dl
->major
;
4985 di
->disk
.minor
= dl
->minor
;
4987 di
->recovery_start
= 0;
4988 di
->data_offset
= pos
;
4989 di
->component_size
= a
->info
.component_size
;
4990 di
->container_member
= dl
->pdnum
;
4993 dprintf("%x:%x (%08x) to be %d at %llu\n",
4994 dl
->major
, dl
->minor
,
4995 be32_to_cpu(dl
->disk
.refnum
), i
, pos
);
4999 if (!dl
&& ! global_ok
) {
5000 /* not enough dedicated spares, try global */
5008 /* No spares found */
5010 /* Now 'rv' has a list of devices to return.
5011 * Create a metadata_update record to update the
5012 * phys_refnum and lba_offset values
5014 vc
= find_vdcr(ddf
, a
->info
.container_member
, rv
->disk
.raid_disk
,
5019 mu
= xmalloc(sizeof(*mu
));
5020 if (posix_memalign(&mu
->space
, 512, sizeof(struct vcl
)) != 0) {
5025 mu
->len
= ddf
->conf_rec_len
* 512 * vcl
->conf
.sec_elmnt_count
;
5026 mu
->buf
= xmalloc(mu
->len
);
5028 mu
->space_list
= NULL
;
5029 mu
->next
= *updates
;
5030 memcpy(mu
->buf
, &vcl
->conf
, ddf
->conf_rec_len
* 512);
5031 for (j
= 1; j
< vcl
->conf
.sec_elmnt_count
; j
++)
5032 memcpy(mu
->buf
+ j
* ddf
->conf_rec_len
* 512,
5033 vcl
->other_bvds
[j
-1], ddf
->conf_rec_len
* 512);
5035 vc
= (struct vd_config
*)mu
->buf
;
5036 for (di
= rv
; di
; di
= di
->next
) {
5037 unsigned int i_sec
, i_prim
;
5038 i_sec
= di
->disk
.raid_disk
5039 / be16_to_cpu(vcl
->conf
.prim_elmnt_count
);
5040 i_prim
= di
->disk
.raid_disk
5041 % be16_to_cpu(vcl
->conf
.prim_elmnt_count
);
5042 vc
= (struct vd_config
*)(mu
->buf
5043 + i_sec
* ddf
->conf_rec_len
* 512);
5044 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
5045 if (dl
->major
== di
->disk
.major
5046 && dl
->minor
== di
->disk
.minor
)
5049 pr_err("%s: BUG: can't find disk %d (%d/%d)\n",
5050 __func__
, di
->disk
.raid_disk
,
5051 di
->disk
.major
, di
->disk
.minor
);
5054 vc
->phys_refnum
[i_prim
] = ddf
->phys
->entries
[dl
->pdnum
].refnum
;
5055 LBA_OFFSET(ddf
, vc
)[i_prim
] = cpu_to_be64(di
->data_offset
);
5056 dprintf("BVD %u gets %u: %08x at %llu\n", i_sec
, i_prim
,
5057 be32_to_cpu(vc
->phys_refnum
[i_prim
]),
5058 be64_to_cpu(LBA_OFFSET(ddf
, vc
)[i_prim
]));
5063 #endif /* MDASSEMBLE */
5065 static int ddf_level_to_layout(int level
)
5072 return ALGORITHM_LEFT_SYMMETRIC
;
5074 return ALGORITHM_ROTATING_N_CONTINUE
;
5082 static void default_geometry_ddf(struct supertype
*st
, int *level
, int *layout
, int *chunk
)
5084 if (level
&& *level
== UnSet
)
5085 *level
= LEVEL_CONTAINER
;
5087 if (level
&& layout
&& *layout
== UnSet
)
5088 *layout
= ddf_level_to_layout(*level
);
5091 struct superswitch super_ddf
= {
5093 .examine_super
= examine_super_ddf
,
5094 .brief_examine_super
= brief_examine_super_ddf
,
5095 .brief_examine_subarrays
= brief_examine_subarrays_ddf
,
5096 .export_examine_super
= export_examine_super_ddf
,
5097 .detail_super
= detail_super_ddf
,
5098 .brief_detail_super
= brief_detail_super_ddf
,
5099 .validate_geometry
= validate_geometry_ddf
,
5100 .write_init_super
= write_init_super_ddf
,
5101 .add_to_super
= add_to_super_ddf
,
5102 .remove_from_super
= remove_from_super_ddf
,
5103 .load_container
= load_container_ddf
,
5104 .copy_metadata
= copy_metadata_ddf
,
5105 .kill_subarray
= kill_subarray_ddf
,
5107 .match_home
= match_home_ddf
,
5108 .uuid_from_super
= uuid_from_super_ddf
,
5109 .getinfo_super
= getinfo_super_ddf
,
5110 .update_super
= update_super_ddf
,
5112 .avail_size
= avail_size_ddf
,
5114 .compare_super
= compare_super_ddf
,
5116 .load_super
= load_super_ddf
,
5117 .init_super
= init_super_ddf
,
5118 .store_super
= store_super_ddf
,
5119 .free_super
= free_super_ddf
,
5120 .match_metadata_desc
= match_metadata_desc_ddf
,
5121 .container_content
= container_content_ddf
,
5122 .default_geometry
= default_geometry_ddf
,
5128 .open_new
= ddf_open_new
,
5129 .set_array_state
= ddf_set_array_state
,
5130 .set_disk
= ddf_set_disk
,
5131 .sync_metadata
= ddf_sync_metadata
,
5132 .process_update
= ddf_process_update
,
5133 .prepare_update
= ddf_prepare_update
,
5134 .activate_spare
= ddf_activate_spare
,