2 * mdadm - manage Linux "md" devices aka RAID arrays.
4 * Copyright (C) 2006-2009 Neil Brown <neilb@suse.de>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * Email: <neil@brown.name>
24 * Specifications for DDF takes from Common RAID DDF Specification Revision 1.2
25 * (July 28 2006). Reused by permission of SNIA.
28 #define HAVE_STDINT_H 1
34 /* a non-official T10 name for creation GUIDs */
35 static char T10
[] = "Linux-MD";
37 /* DDF timestamps are 1980 based, so we need to add
38 * second-in-decade-of-seventies to convert to linux timestamps.
39 * 10 years with 2 leap years.
41 #define DECADE (3600*24*(365*10+2))
44 const unsigned char *buf
,
47 #define DDF_NOTFOUND (~0U)
48 #define DDF_CONTAINER (DDF_NOTFOUND-1)
50 /* The DDF metadata handling.
51 * DDF metadata lives at the end of the device.
52 * The last 512 byte block provides an 'anchor' which is used to locate
53 * the rest of the metadata which usually lives immediately behind the anchor.
56 * - all multibyte numeric fields are bigendian.
57 * - all strings are space padded.
61 typedef struct __be16
{
64 #define be16_eq(x, y) ((x)._v16 == (y)._v16)
65 #define be16_and(x, y) ((x)._v16 & (y)._v16)
66 #define be16_or(x, y) ((x)._v16 | (y)._v16)
67 #define be16_clear(x, y) ((x)._v16 &= ~(y)._v16)
68 #define be16_set(x, y) ((x)._v16 |= (y)._v16)
70 typedef struct __be32
{
73 #define be32_eq(x, y) ((x)._v32 == (y)._v32)
75 typedef struct __be64
{
78 #define be64_eq(x, y) ((x)._v64 == (y)._v64)
80 #define be16_to_cpu(be) __be16_to_cpu((be)._v16)
81 static inline be16
cpu_to_be16(__u16 x
)
83 be16 be
= { ._v16
= __cpu_to_be16(x
) };
87 #define be32_to_cpu(be) __be32_to_cpu((be)._v32)
88 static inline be32
cpu_to_be32(__u32 x
)
90 be32 be
= { ._v32
= __cpu_to_be32(x
) };
94 #define be64_to_cpu(be) __be64_to_cpu((be)._v64)
95 static inline be64
cpu_to_be64(__u64 x
)
97 be64 be
= { ._v64
= __cpu_to_be64(x
) };
101 /* Primary Raid Level (PRL) */
102 #define DDF_RAID0 0x00
103 #define DDF_RAID1 0x01
104 #define DDF_RAID3 0x03
105 #define DDF_RAID4 0x04
106 #define DDF_RAID5 0x05
107 #define DDF_RAID1E 0x11
108 #define DDF_JBOD 0x0f
109 #define DDF_CONCAT 0x1f
110 #define DDF_RAID5E 0x15
111 #define DDF_RAID5EE 0x25
112 #define DDF_RAID6 0x06
114 /* Raid Level Qualifier (RLQ) */
115 #define DDF_RAID0_SIMPLE 0x00
116 #define DDF_RAID1_SIMPLE 0x00 /* just 2 devices in this plex */
117 #define DDF_RAID1_MULTI 0x01 /* exactly 3 devices in this plex */
118 #define DDF_RAID3_0 0x00 /* parity in first extent */
119 #define DDF_RAID3_N 0x01 /* parity in last extent */
120 #define DDF_RAID4_0 0x00 /* parity in first extent */
121 #define DDF_RAID4_N 0x01 /* parity in last extent */
122 /* these apply to raid5e and raid5ee as well */
123 #define DDF_RAID5_0_RESTART 0x00 /* same as 'right asymmetric' - layout 1 */
124 #define DDF_RAID6_0_RESTART 0x01 /* raid6 different from raid5 here!!! */
125 #define DDF_RAID5_N_RESTART 0x02 /* same as 'left asymmetric' - layout 0 */
126 #define DDF_RAID5_N_CONTINUE 0x03 /* same as 'left symmetric' - layout 2 */
128 #define DDF_RAID1E_ADJACENT 0x00 /* raid10 nearcopies==2 */
129 #define DDF_RAID1E_OFFSET 0x01 /* raid10 offsetcopies==2 */
131 /* Secondary RAID Level (SRL) */
132 #define DDF_2STRIPED 0x00 /* This is weirder than RAID0 !! */
133 #define DDF_2MIRRORED 0x01
134 #define DDF_2CONCAT 0x02
135 #define DDF_2SPANNED 0x03 /* This is also weird - be careful */
138 #define DDF_HEADER_MAGIC cpu_to_be32(0xDE11DE11)
139 #define DDF_CONTROLLER_MAGIC cpu_to_be32(0xAD111111)
140 #define DDF_PHYS_RECORDS_MAGIC cpu_to_be32(0x22222222)
141 #define DDF_PHYS_DATA_MAGIC cpu_to_be32(0x33333333)
142 #define DDF_VIRT_RECORDS_MAGIC cpu_to_be32(0xDDDDDDDD)
143 #define DDF_VD_CONF_MAGIC cpu_to_be32(0xEEEEEEEE)
144 #define DDF_SPARE_ASSIGN_MAGIC cpu_to_be32(0x55555555)
145 #define DDF_VU_CONF_MAGIC cpu_to_be32(0x88888888)
146 #define DDF_VENDOR_LOG_MAGIC cpu_to_be32(0x01dBEEF0)
147 #define DDF_BBM_LOG_MAGIC cpu_to_be32(0xABADB10C)
149 #define DDF_GUID_LEN 24
150 #define DDF_REVISION_0 "01.00.00"
151 #define DDF_REVISION_2 "01.02.00"
154 be32 magic
; /* DDF_HEADER_MAGIC */
156 char guid
[DDF_GUID_LEN
];
157 char revision
[8]; /* 01.02.00 */
158 be32 seq
; /* starts at '1' */
163 __u8 pad0
; /* 0xff */
164 __u8 pad1
[12]; /* 12 * 0xff */
165 /* 64 bytes so far */
166 __u8 header_ext
[32]; /* reserved: fill with 0xff */
170 __u8 pad2
[3]; /* 0xff */
171 be32 workspace_len
; /* sectors for vendor space -
172 * at least 32768(sectors) */
174 be16 max_pd_entries
; /* one of 15, 63, 255, 1023, 4095 */
175 be16 max_vd_entries
; /* 2^(4,6,8,10,12)-1 : i.e. as above */
176 be16 max_partitions
; /* i.e. max num of configuration
177 record entries per disk */
178 be16 config_record_len
; /* 1 +ROUNDUP(max_primary_element_entries
180 be16 max_primary_element_entries
; /* 16, 64, 256, 1024, or 4096 */
181 __u8 pad3
[54]; /* 0xff */
182 /* 192 bytes so far */
183 be32 controller_section_offset
;
184 be32 controller_section_length
;
185 be32 phys_section_offset
;
186 be32 phys_section_length
;
187 be32 virt_section_offset
;
188 be32 virt_section_length
;
189 be32 config_section_offset
;
190 be32 config_section_length
;
191 be32 data_section_offset
;
192 be32 data_section_length
;
193 be32 bbm_section_offset
;
194 be32 bbm_section_length
;
195 be32 diag_space_offset
;
196 be32 diag_space_length
;
199 /* 256 bytes so far */
200 __u8 pad4
[256]; /* 0xff */
204 #define DDF_HEADER_ANCHOR 0x00
205 #define DDF_HEADER_PRIMARY 0x01
206 #define DDF_HEADER_SECONDARY 0x02
208 /* The content of the 'controller section' - global scope */
209 struct ddf_controller_data
{
210 be32 magic
; /* DDF_CONTROLLER_MAGIC */
212 char guid
[DDF_GUID_LEN
];
213 struct controller_type
{
220 __u8 pad
[8]; /* 0xff */
221 __u8 vendor_data
[448];
224 /* The content of phys_section - global scope */
226 be32 magic
; /* DDF_PHYS_RECORDS_MAGIC */
231 struct phys_disk_entry
{
232 char guid
[DDF_GUID_LEN
];
236 be64 config_size
; /* DDF structures must be after here */
237 char path
[18]; /* another horrible structure really */
242 /* phys_disk_entry.type is a bitmap - bigendian remember */
243 #define DDF_Forced_PD_GUID 1
244 #define DDF_Active_in_VD 2
245 #define DDF_Global_Spare 4 /* VD_CONF records are ignored */
246 #define DDF_Spare 8 /* overrides Global_spare */
247 #define DDF_Foreign 16
248 #define DDF_Legacy 32 /* no DDF on this device */
250 #define DDF_Interface_mask 0xf00
251 #define DDF_Interface_SCSI 0x100
252 #define DDF_Interface_SAS 0x200
253 #define DDF_Interface_SATA 0x300
254 #define DDF_Interface_FC 0x400
256 /* phys_disk_entry.state is a bigendian bitmap */
258 #define DDF_Failed 2 /* overrides 1,4,8 */
259 #define DDF_Rebuilding 4
260 #define DDF_Transition 8
262 #define DDF_ReadErrors 32
263 #define DDF_Missing 64
265 /* The content of the virt_section global scope */
266 struct virtual_disk
{
267 be32 magic
; /* DDF_VIRT_RECORDS_MAGIC */
272 struct virtual_entry
{
273 char guid
[DDF_GUID_LEN
];
275 __u16 pad0
; /* 0xffff */
285 /* virtual_entry.type is a bitmap - bigendian */
287 #define DDF_Enforce_Groups 2
288 #define DDF_Unicode 4
289 #define DDF_Owner_Valid 8
291 /* virtual_entry.state is a bigendian bitmap */
292 #define DDF_state_mask 0x7
293 #define DDF_state_optimal 0x0
294 #define DDF_state_degraded 0x1
295 #define DDF_state_deleted 0x2
296 #define DDF_state_missing 0x3
297 #define DDF_state_failed 0x4
298 #define DDF_state_part_optimal 0x5
300 #define DDF_state_morphing 0x8
301 #define DDF_state_inconsistent 0x10
303 /* virtual_entry.init_state is a bigendian bitmap */
304 #define DDF_initstate_mask 0x03
305 #define DDF_init_not 0x00
306 #define DDF_init_quick 0x01 /* initialisation is progress.
307 * i.e. 'state_inconsistent' */
308 #define DDF_init_full 0x02
310 #define DDF_access_mask 0xc0
311 #define DDF_access_rw 0x00
312 #define DDF_access_ro 0x80
313 #define DDF_access_blocked 0xc0
315 /* The content of the config_section - local scope
316 * It has multiple records each config_record_len sectors
317 * They can be vd_config or spare_assign
321 be32 magic
; /* DDF_VD_CONF_MAGIC */
323 char guid
[DDF_GUID_LEN
];
327 be16 prim_elmnt_count
;
328 __u8 chunk_shift
; /* 0 == 512, 1==1024 etc */
331 __u8 sec_elmnt_count
;
334 be64 blocks
; /* blocks per component could be different
335 * on different component devices...(only
336 * for concat I hope) */
337 be64 array_blocks
; /* blocks in array */
345 __u8 v0
[32]; /* reserved- 0xff */
346 __u8 v1
[32]; /* reserved- 0xff */
347 __u8 v2
[16]; /* reserved- 0xff */
348 __u8 v3
[16]; /* reserved- 0xff */
350 be32 phys_refnum
[0]; /* refnum of each disk in sequence */
351 /*__u64 lba_offset[0]; LBA offset in each phys. Note extents in a
352 bvd are always the same size */
354 #define LBA_OFFSET(ddf, vd) ((be64 *) &(vd)->phys_refnum[(ddf)->mppe])
356 /* vd_config.cache_pol[7] is a bitmap */
357 #define DDF_cache_writeback 1 /* else writethrough */
358 #define DDF_cache_wadaptive 2 /* only applies if writeback */
359 #define DDF_cache_readahead 4
360 #define DDF_cache_radaptive 8 /* only if doing read-ahead */
361 #define DDF_cache_ifnobatt 16 /* even to write cache if battery is poor */
362 #define DDF_cache_wallowed 32 /* enable write caching */
363 #define DDF_cache_rallowed 64 /* enable read caching */
365 struct spare_assign
{
366 be32 magic
; /* DDF_SPARE_ASSIGN_MAGIC */
371 be16 populated
; /* SAEs used */
372 be16 max
; /* max SAEs */
374 struct spare_assign_entry
{
375 char guid
[DDF_GUID_LEN
];
376 be16 secondary_element
;
380 /* spare_assign.type is a bitmap */
381 #define DDF_spare_dedicated 0x1 /* else global */
382 #define DDF_spare_revertible 0x2 /* else committable */
383 #define DDF_spare_active 0x4 /* else not active */
384 #define DDF_spare_affinity 0x8 /* enclosure affinity */
386 /* The data_section contents - local scope */
388 be32 magic
; /* DDF_PHYS_DATA_MAGIC */
390 char guid
[DDF_GUID_LEN
];
391 be32 refnum
; /* crc of some magic drive data ... */
392 __u8 forced_ref
; /* set when above was not result of magic */
393 __u8 forced_guid
; /* set if guid was forced rather than magic */
398 /* bbm_section content */
399 struct bad_block_log
{
406 struct mapped_block
{
407 be64 defective_start
;
408 be32 replacement_start
;
414 /* Struct for internally holding ddf structures */
415 /* The DDF structure stored on each device is potentially
416 * quite different, as some data is global and some is local.
417 * The global data is:
420 * - Physical disk records
421 * - Virtual disk records
423 * - Configuration records
424 * - Physical Disk data section
425 * ( and Bad block and vendor which I don't care about yet).
427 * The local data is parsed into separate lists as it is read
428 * and reconstructed for writing. This means that we only need
429 * to make config changes once and they are automatically
430 * propagated to all devices.
431 * Note that the ddf_super has space of the conf and disk data
432 * for this disk and also for a list of all such data.
433 * The list is only used for the superblock that is being
434 * built in Create or Assemble to describe the whole array.
437 struct ddf_header anchor
, primary
, secondary
;
438 struct ddf_controller_data controller
;
439 struct ddf_header
*active
;
440 struct phys_disk
*phys
;
441 struct virtual_disk
*virt
;
443 unsigned int max_part
, mppe
, conf_rec_len
;
451 unsigned int vcnum
; /* index into ->virt */
452 struct vd_config
**other_bvds
;
453 __u64
*block_sizes
; /* NULL if all the same */
456 struct vd_config conf
;
457 } *conflist
, *currentconf
;
466 unsigned long long size
; /* sectors */
467 be64 primary_lba
; /* sectors */
468 be64 secondary_lba
; /* sectors */
469 be64 workspace_lba
; /* sectors */
470 int pdnum
; /* index in ->phys */
471 struct spare_assign
*spare
;
472 void *mdupdate
; /* hold metadata update */
474 /* These fields used by auto-layout */
475 int raiddisk
; /* slot to fill in autolayout */
479 struct disk_data disk
;
480 struct vcl
*vlist
[0]; /* max_part in size */
485 #define offsetof(t,f) ((size_t)&(((t*)0)->f))
489 static int all_ff(const char *guid
);
490 static void pr_state(struct ddf_super
*ddf
, const char *msg
)
493 dprintf("%s/%s: ", __func__
, msg
);
494 for (i
= 0; i
< be16_to_cpu(ddf
->active
->max_vd_entries
); i
++) {
495 if (all_ff(ddf
->virt
->entries
[i
].guid
))
497 dprintf("%u(s=%02x i=%02x) ", i
,
498 ddf
->virt
->entries
[i
].state
,
499 ddf
->virt
->entries
[i
].init_state
);
504 static void pr_state(const struct ddf_super
*ddf
, const char *msg
) {}
507 static void _ddf_set_updates_pending(struct ddf_super
*ddf
, const char *func
)
509 ddf
->updates_pending
= 1;
510 ddf
->active
->seq
= cpu_to_be32((be32_to_cpu(ddf
->active
->seq
)+1));
514 #define ddf_set_updates_pending(x) _ddf_set_updates_pending((x), __func__)
516 static unsigned int get_pd_index_from_refnum(const struct vcl
*vc
,
517 be32 refnum
, unsigned int nmax
,
518 const struct vd_config
**bvd
,
521 static be32
calc_crc(void *buf
, int len
)
523 /* crcs are always at the same place as in the ddf_header */
524 struct ddf_header
*ddf
= buf
;
525 be32 oldcrc
= ddf
->crc
;
527 ddf
->crc
= cpu_to_be32(0xffffffff);
529 newcrc
= crc32(0, buf
, len
);
531 /* The crc is store (like everything) bigendian, so convert
532 * here for simplicity
534 return cpu_to_be32(newcrc
);
537 #define DDF_INVALID_LEVEL 0xff
538 #define DDF_NO_SECONDARY 0xff
539 static int err_bad_md_layout(const mdu_array_info_t
*array
)
541 pr_err("RAID%d layout %x with %d disks is unsupported for DDF\n",
542 array
->level
, array
->layout
, array
->raid_disks
);
546 static int layout_md2ddf(const mdu_array_info_t
*array
,
547 struct vd_config
*conf
)
549 be16 prim_elmnt_count
= cpu_to_be16(array
->raid_disks
);
550 __u8 prl
= DDF_INVALID_LEVEL
, rlq
= 0;
551 __u8 sec_elmnt_count
= 1;
552 __u8 srl
= DDF_NO_SECONDARY
;
554 switch (array
->level
) {
559 rlq
= DDF_RAID0_SIMPLE
;
563 switch (array
->raid_disks
) {
565 rlq
= DDF_RAID1_SIMPLE
;
568 rlq
= DDF_RAID1_MULTI
;
571 return err_bad_md_layout(array
);
576 if (array
->layout
!= 0)
577 return err_bad_md_layout(array
);
582 switch (array
->layout
) {
583 case ALGORITHM_LEFT_ASYMMETRIC
:
584 rlq
= DDF_RAID5_N_RESTART
;
586 case ALGORITHM_RIGHT_ASYMMETRIC
:
587 rlq
= DDF_RAID5_0_RESTART
;
589 case ALGORITHM_LEFT_SYMMETRIC
:
590 rlq
= DDF_RAID5_N_CONTINUE
;
592 case ALGORITHM_RIGHT_SYMMETRIC
:
593 /* not mentioned in standard */
595 return err_bad_md_layout(array
);
600 switch (array
->layout
) {
601 case ALGORITHM_ROTATING_N_RESTART
:
602 rlq
= DDF_RAID5_N_RESTART
;
604 case ALGORITHM_ROTATING_ZERO_RESTART
:
605 rlq
= DDF_RAID6_0_RESTART
;
607 case ALGORITHM_ROTATING_N_CONTINUE
:
608 rlq
= DDF_RAID5_N_CONTINUE
;
611 return err_bad_md_layout(array
);
616 if (array
->raid_disks
% 2 == 0 && array
->layout
== 0x102) {
617 rlq
= DDF_RAID1_SIMPLE
;
618 prim_elmnt_count
= cpu_to_be16(2);
619 sec_elmnt_count
= array
->raid_disks
/ 2;
620 } else if (array
->raid_disks
% 3 == 0
621 && array
->layout
== 0x103) {
622 rlq
= DDF_RAID1_MULTI
;
623 prim_elmnt_count
= cpu_to_be16(3);
624 sec_elmnt_count
= array
->raid_disks
/ 3;
626 return err_bad_md_layout(array
);
631 return err_bad_md_layout(array
);
634 conf
->prim_elmnt_count
= prim_elmnt_count
;
637 conf
->sec_elmnt_count
= sec_elmnt_count
;
641 static int err_bad_ddf_layout(const struct vd_config
*conf
)
643 pr_err("DDF RAID %u qualifier %u with %u disks is unsupported\n",
644 conf
->prl
, conf
->rlq
, be16_to_cpu(conf
->prim_elmnt_count
));
648 static int layout_ddf2md(const struct vd_config
*conf
,
649 mdu_array_info_t
*array
)
651 int level
= LEVEL_UNSUPPORTED
;
653 int raiddisks
= be16_to_cpu(conf
->prim_elmnt_count
);
655 if (conf
->sec_elmnt_count
> 1) {
656 /* see also check_secondary() */
657 if (conf
->prl
!= DDF_RAID1
||
658 (conf
->srl
!= DDF_2STRIPED
&& conf
->srl
!= DDF_2SPANNED
)) {
659 pr_err("Unsupported secondary RAID level %u/%u\n",
660 conf
->prl
, conf
->srl
);
663 if (raiddisks
== 2 && conf
->rlq
== DDF_RAID1_SIMPLE
)
665 else if (raiddisks
== 3 && conf
->rlq
== DDF_RAID1_MULTI
)
668 return err_bad_ddf_layout(conf
);
669 raiddisks
*= conf
->sec_elmnt_count
;
676 level
= LEVEL_LINEAR
;
679 if (conf
->rlq
!= DDF_RAID0_SIMPLE
)
680 return err_bad_ddf_layout(conf
);
684 if (!((conf
->rlq
== DDF_RAID1_SIMPLE
&& raiddisks
== 2) ||
685 (conf
->rlq
== DDF_RAID1_MULTI
&& raiddisks
== 3)))
686 return err_bad_ddf_layout(conf
);
690 if (conf
->rlq
!= DDF_RAID4_N
)
691 return err_bad_ddf_layout(conf
);
696 case DDF_RAID5_N_RESTART
:
697 layout
= ALGORITHM_LEFT_ASYMMETRIC
;
699 case DDF_RAID5_0_RESTART
:
700 layout
= ALGORITHM_RIGHT_ASYMMETRIC
;
702 case DDF_RAID5_N_CONTINUE
:
703 layout
= ALGORITHM_LEFT_SYMMETRIC
;
706 return err_bad_ddf_layout(conf
);
712 case DDF_RAID5_N_RESTART
:
713 layout
= ALGORITHM_ROTATING_N_RESTART
;
715 case DDF_RAID6_0_RESTART
:
716 layout
= ALGORITHM_ROTATING_ZERO_RESTART
;
718 case DDF_RAID5_N_CONTINUE
:
719 layout
= ALGORITHM_ROTATING_N_CONTINUE
;
722 return err_bad_ddf_layout(conf
);
727 return err_bad_ddf_layout(conf
);
731 array
->level
= level
;
732 array
->layout
= layout
;
733 array
->raid_disks
= raiddisks
;
737 static int load_ddf_header(int fd
, unsigned long long lba
,
738 unsigned long long size
,
740 struct ddf_header
*hdr
, struct ddf_header
*anchor
)
742 /* read a ddf header (primary or secondary) from fd/lba
743 * and check that it is consistent with anchor
745 * magic, crc, guid, rev, and LBA's header_type, and
746 * everything after header_type must be the same
751 if (lseek64(fd
, lba
<<9, 0) < 0)
754 if (read(fd
, hdr
, 512) != 512)
757 if (!be32_eq(hdr
->magic
, DDF_HEADER_MAGIC
))
759 if (!be32_eq(calc_crc(hdr
, 512), hdr
->crc
))
761 if (memcmp(anchor
->guid
, hdr
->guid
, DDF_GUID_LEN
) != 0 ||
762 memcmp(anchor
->revision
, hdr
->revision
, 8) != 0 ||
763 !be64_eq(anchor
->primary_lba
, hdr
->primary_lba
) ||
764 !be64_eq(anchor
->secondary_lba
, hdr
->secondary_lba
) ||
766 memcmp(anchor
->pad2
, hdr
->pad2
, 512 -
767 offsetof(struct ddf_header
, pad2
)) != 0)
770 /* Looks good enough to me... */
774 static void *load_section(int fd
, struct ddf_super
*super
, void *buf
,
775 be32 offset_be
, be32 len_be
, int check
)
777 unsigned long long offset
= be32_to_cpu(offset_be
);
778 unsigned long long len
= be32_to_cpu(len_be
);
779 int dofree
= (buf
== NULL
);
782 if (len
!= 2 && len
!= 8 && len
!= 32
783 && len
!= 128 && len
!= 512)
789 /* All pre-allocated sections are a single block */
792 } else if (posix_memalign(&buf
, 512, len
<<9) != 0)
798 if (super
->active
->type
== 1)
799 offset
+= be64_to_cpu(super
->active
->primary_lba
);
801 offset
+= be64_to_cpu(super
->active
->secondary_lba
);
803 if ((unsigned long long)lseek64(fd
, offset
<<9, 0) != (offset
<<9)) {
808 if ((unsigned long long)read(fd
, buf
, len
<<9) != (len
<<9)) {
816 static int load_ddf_headers(int fd
, struct ddf_super
*super
, char *devname
)
818 unsigned long long dsize
;
820 get_dev_size(fd
, NULL
, &dsize
);
822 if (lseek64(fd
, dsize
-512, 0) < 0) {
824 pr_err("Cannot seek to anchor block on %s: %s\n",
825 devname
, strerror(errno
));
828 if (read(fd
, &super
->anchor
, 512) != 512) {
830 pr_err("Cannot read anchor block on %s: %s\n",
831 devname
, strerror(errno
));
834 if (!be32_eq(super
->anchor
.magic
, DDF_HEADER_MAGIC
)) {
836 pr_err("no DDF anchor found on %s\n",
840 if (!be32_eq(calc_crc(&super
->anchor
, 512), super
->anchor
.crc
)) {
842 pr_err("bad CRC on anchor on %s\n",
846 if (memcmp(super
->anchor
.revision
, DDF_REVISION_0
, 8) != 0 &&
847 memcmp(super
->anchor
.revision
, DDF_REVISION_2
, 8) != 0) {
849 pr_err("can only support super revision"
850 " %.8s and earlier, not %.8s on %s\n",
851 DDF_REVISION_2
, super
->anchor
.revision
,devname
);
854 super
->active
= NULL
;
855 if (load_ddf_header(fd
, be64_to_cpu(super
->anchor
.primary_lba
),
857 &super
->primary
, &super
->anchor
) == 0) {
859 pr_err("Failed to load primary DDF header "
862 super
->active
= &super
->primary
;
864 if (load_ddf_header(fd
, be64_to_cpu(super
->anchor
.secondary_lba
),
866 &super
->secondary
, &super
->anchor
)) {
867 if (super
->active
== NULL
868 || (be32_to_cpu(super
->primary
.seq
)
869 < be32_to_cpu(super
->secondary
.seq
) &&
870 !super
->secondary
.openflag
)
871 || (be32_to_cpu(super
->primary
.seq
)
872 == be32_to_cpu(super
->secondary
.seq
) &&
873 super
->primary
.openflag
&& !super
->secondary
.openflag
)
875 super
->active
= &super
->secondary
;
877 pr_err("Failed to load secondary DDF header on %s\n",
879 if (super
->active
== NULL
)
884 static int load_ddf_global(int fd
, struct ddf_super
*super
, char *devname
)
887 ok
= load_section(fd
, super
, &super
->controller
,
888 super
->active
->controller_section_offset
,
889 super
->active
->controller_section_length
,
891 super
->phys
= load_section(fd
, super
, NULL
,
892 super
->active
->phys_section_offset
,
893 super
->active
->phys_section_length
,
895 super
->pdsize
= be32_to_cpu(super
->active
->phys_section_length
) * 512;
897 super
->virt
= load_section(fd
, super
, NULL
,
898 super
->active
->virt_section_offset
,
899 super
->active
->virt_section_length
,
901 super
->vdsize
= be32_to_cpu(super
->active
->virt_section_length
) * 512;
911 super
->conflist
= NULL
;
914 super
->max_part
= be16_to_cpu(super
->active
->max_partitions
);
915 super
->mppe
= be16_to_cpu(super
->active
->max_primary_element_entries
);
916 super
->conf_rec_len
= be16_to_cpu(super
->active
->config_record_len
);
920 #define DDF_UNUSED_BVD 0xff
921 static int alloc_other_bvds(const struct ddf_super
*ddf
, struct vcl
*vcl
)
923 unsigned int n_vds
= vcl
->conf
.sec_elmnt_count
- 1;
924 unsigned int i
, vdsize
;
927 vcl
->other_bvds
= NULL
;
930 vdsize
= ddf
->conf_rec_len
* 512;
931 if (posix_memalign(&p
, 512, n_vds
*
932 (vdsize
+ sizeof(struct vd_config
*))) != 0)
934 vcl
->other_bvds
= (struct vd_config
**) (p
+ n_vds
* vdsize
);
935 for (i
= 0; i
< n_vds
; i
++) {
936 vcl
->other_bvds
[i
] = p
+ i
* vdsize
;
937 memset(vcl
->other_bvds
[i
], 0, vdsize
);
938 vcl
->other_bvds
[i
]->sec_elmnt_seq
= DDF_UNUSED_BVD
;
943 static void add_other_bvd(struct vcl
*vcl
, struct vd_config
*vd
,
947 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
948 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== vd
->sec_elmnt_seq
)
951 if (i
< vcl
->conf
.sec_elmnt_count
-1) {
952 if (be32_to_cpu(vd
->seqnum
) <=
953 be32_to_cpu(vcl
->other_bvds
[i
]->seqnum
))
956 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
957 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== DDF_UNUSED_BVD
)
959 if (i
== vcl
->conf
.sec_elmnt_count
-1) {
960 pr_err("no space for sec level config %u, count is %u\n",
961 vd
->sec_elmnt_seq
, vcl
->conf
.sec_elmnt_count
);
965 memcpy(vcl
->other_bvds
[i
], vd
, len
);
968 static int load_ddf_local(int fd
, struct ddf_super
*super
,
969 char *devname
, int keep
)
975 unsigned int confsec
;
977 unsigned int max_virt_disks
= be16_to_cpu
978 (super
->active
->max_vd_entries
);
979 unsigned long long dsize
;
981 /* First the local disk info */
982 if (posix_memalign((void**)&dl
, 512,
984 (super
->max_part
) * sizeof(dl
->vlist
[0])) != 0) {
985 pr_err("%s could not allocate disk info buffer\n",
990 load_section(fd
, super
, &dl
->disk
,
991 super
->active
->data_section_offset
,
992 super
->active
->data_section_length
,
994 dl
->devname
= devname
? xstrdup(devname
) : NULL
;
997 dl
->major
= major(stb
.st_rdev
);
998 dl
->minor
= minor(stb
.st_rdev
);
999 dl
->next
= super
->dlist
;
1000 dl
->fd
= keep
? fd
: -1;
1003 if (get_dev_size(fd
, devname
, &dsize
))
1004 dl
->size
= dsize
>> 9;
1005 /* If the disks have different sizes, the LBAs will differ
1006 * between phys disks.
1007 * At this point here, the values in super->active must be valid
1008 * for this phys disk. */
1009 dl
->primary_lba
= super
->active
->primary_lba
;
1010 dl
->secondary_lba
= super
->active
->secondary_lba
;
1011 dl
->workspace_lba
= super
->active
->workspace_lba
;
1013 for (i
= 0 ; i
< super
->max_part
; i
++)
1014 dl
->vlist
[i
] = NULL
;
1017 for (i
= 0; i
< be16_to_cpu(super
->active
->max_pd_entries
); i
++)
1018 if (memcmp(super
->phys
->entries
[i
].guid
,
1019 dl
->disk
.guid
, DDF_GUID_LEN
) == 0)
1022 /* Now the config list. */
1023 /* 'conf' is an array of config entries, some of which are
1024 * probably invalid. Those which are good need to be copied into
1028 conf
= load_section(fd
, super
, NULL
,
1029 super
->active
->config_section_offset
,
1030 super
->active
->config_section_length
,
1035 confsec
< be32_to_cpu(super
->active
->config_section_length
);
1036 confsec
+= super
->conf_rec_len
) {
1037 struct vd_config
*vd
=
1038 (struct vd_config
*)((char*)conf
+ confsec
*512);
1041 if (be32_eq(vd
->magic
, DDF_SPARE_ASSIGN_MAGIC
)) {
1044 if (posix_memalign((void**)&dl
->spare
, 512,
1045 super
->conf_rec_len
*512) != 0) {
1046 pr_err("%s could not allocate spare info buf\n",
1051 memcpy(dl
->spare
, vd
, super
->conf_rec_len
*512);
1054 if (!be32_eq(vd
->magic
, DDF_VD_CONF_MAGIC
))
1056 for (vcl
= super
->conflist
; vcl
; vcl
= vcl
->next
) {
1057 if (memcmp(vcl
->conf
.guid
,
1058 vd
->guid
, DDF_GUID_LEN
) == 0)
1063 dl
->vlist
[vnum
++] = vcl
;
1064 if (vcl
->other_bvds
!= NULL
&&
1065 vcl
->conf
.sec_elmnt_seq
!= vd
->sec_elmnt_seq
) {
1066 add_other_bvd(vcl
, vd
, super
->conf_rec_len
*512);
1069 if (be32_to_cpu(vd
->seqnum
) <=
1070 be32_to_cpu(vcl
->conf
.seqnum
))
1073 if (posix_memalign((void**)&vcl
, 512,
1074 (super
->conf_rec_len
*512 +
1075 offsetof(struct vcl
, conf
))) != 0) {
1076 pr_err("%s could not allocate vcl buf\n",
1080 vcl
->next
= super
->conflist
;
1081 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
1082 vcl
->conf
.sec_elmnt_count
= vd
->sec_elmnt_count
;
1083 if (alloc_other_bvds(super
, vcl
) != 0) {
1084 pr_err("%s could not allocate other bvds\n",
1089 super
->conflist
= vcl
;
1090 dl
->vlist
[vnum
++] = vcl
;
1092 memcpy(&vcl
->conf
, vd
, super
->conf_rec_len
*512);
1093 for (i
=0; i
< max_virt_disks
; i
++)
1094 if (memcmp(super
->virt
->entries
[i
].guid
,
1095 vcl
->conf
.guid
, DDF_GUID_LEN
)==0)
1097 if (i
< max_virt_disks
)
1106 static int load_super_ddf_all(struct supertype
*st
, int fd
,
1107 void **sbp
, char *devname
);
1110 static void free_super_ddf(struct supertype
*st
);
1112 static int load_super_ddf(struct supertype
*st
, int fd
,
1115 unsigned long long dsize
;
1116 struct ddf_super
*super
;
1119 if (get_dev_size(fd
, devname
, &dsize
) == 0)
1122 if (!st
->ignore_hw_compat
&& test_partition(fd
))
1123 /* DDF is not allowed on partitions */
1126 /* 32M is a lower bound */
1127 if (dsize
<= 32*1024*1024) {
1129 pr_err("%s is too small for ddf: "
1130 "size is %llu sectors.\n",
1136 pr_err("%s is an odd size for ddf: "
1137 "size is %llu bytes.\n",
1144 if (posix_memalign((void**)&super
, 512, sizeof(*super
))!= 0) {
1145 pr_err("malloc of %zu failed.\n",
1149 memset(super
, 0, sizeof(*super
));
1151 rv
= load_ddf_headers(fd
, super
, devname
);
1157 /* Have valid headers and have chosen the best. Let's read in the rest*/
1159 rv
= load_ddf_global(fd
, super
, devname
);
1163 pr_err("Failed to load all information "
1164 "sections on %s\n", devname
);
1169 rv
= load_ddf_local(fd
, super
, devname
, 0);
1173 pr_err("Failed to load all information "
1174 "sections on %s\n", devname
);
1179 /* Should possibly check the sections .... */
1182 if (st
->ss
== NULL
) {
1183 st
->ss
= &super_ddf
;
1184 st
->minor_version
= 0;
1191 static void free_super_ddf(struct supertype
*st
)
1193 struct ddf_super
*ddf
= st
->sb
;
1198 while (ddf
->conflist
) {
1199 struct vcl
*v
= ddf
->conflist
;
1200 ddf
->conflist
= v
->next
;
1202 free(v
->block_sizes
);
1205 v->other_bvds[0] points to beginning of buffer,
1206 see alloc_other_bvds()
1208 free(v
->other_bvds
[0]);
1211 while (ddf
->dlist
) {
1212 struct dl
*d
= ddf
->dlist
;
1213 ddf
->dlist
= d
->next
;
1220 while (ddf
->add_list
) {
1221 struct dl
*d
= ddf
->add_list
;
1222 ddf
->add_list
= d
->next
;
1233 static struct supertype
*match_metadata_desc_ddf(char *arg
)
1235 /* 'ddf' only support containers */
1236 struct supertype
*st
;
1237 if (strcmp(arg
, "ddf") != 0 &&
1238 strcmp(arg
, "default") != 0
1242 st
= xcalloc(1, sizeof(*st
));
1243 st
->ss
= &super_ddf
;
1245 st
->minor_version
= 0;
1252 static mapping_t ddf_state
[] = {
1258 { "Partially Optimal", 5},
1264 static mapping_t ddf_init_state
[] = {
1265 { "Not Initialised", 0},
1266 { "QuickInit in Progress", 1},
1267 { "Fully Initialised", 2},
1271 static mapping_t ddf_access
[] = {
1275 { "Blocked (no access)", 3},
1279 static mapping_t ddf_level
[] = {
1280 { "RAID0", DDF_RAID0
},
1281 { "RAID1", DDF_RAID1
},
1282 { "RAID3", DDF_RAID3
},
1283 { "RAID4", DDF_RAID4
},
1284 { "RAID5", DDF_RAID5
},
1285 { "RAID1E",DDF_RAID1E
},
1286 { "JBOD", DDF_JBOD
},
1287 { "CONCAT",DDF_CONCAT
},
1288 { "RAID5E",DDF_RAID5E
},
1289 { "RAID5EE",DDF_RAID5EE
},
1290 { "RAID6", DDF_RAID6
},
1293 static mapping_t ddf_sec_level
[] = {
1294 { "Striped", DDF_2STRIPED
},
1295 { "Mirrored", DDF_2MIRRORED
},
1296 { "Concat", DDF_2CONCAT
},
1297 { "Spanned", DDF_2SPANNED
},
1302 static int all_ff(const char *guid
)
1305 for (i
= 0; i
< DDF_GUID_LEN
; i
++)
1306 if (guid
[i
] != (char)0xff)
1311 static const char *guid_str(const char *guid
)
1313 static char buf
[DDF_GUID_LEN
*2+1];
1316 for (i
= 0; i
< DDF_GUID_LEN
; i
++) {
1317 unsigned char c
= guid
[i
];
1318 if (c
>= 32 && c
< 127)
1319 p
+= sprintf(p
, "%c", c
);
1321 p
+= sprintf(p
, "%02x", c
);
1324 return (const char *) buf
;
1328 static void print_guid(char *guid
, int tstamp
)
1330 /* A GUIDs are part (or all) ASCII and part binary.
1331 * They tend to be space padded.
1332 * We print the GUID in HEX, then in parentheses add
1333 * any initial ASCII sequence, and a possible
1334 * time stamp from bytes 16-19
1336 int l
= DDF_GUID_LEN
;
1339 for (i
=0 ; i
<DDF_GUID_LEN
; i
++) {
1340 if ((i
&3)==0 && i
!= 0) printf(":");
1341 printf("%02X", guid
[i
]&255);
1345 while (l
&& guid
[l
-1] == ' ')
1347 for (i
=0 ; i
<l
; i
++) {
1348 if (guid
[i
] >= 0x20 && guid
[i
] < 0x7f)
1349 fputc(guid
[i
], stdout
);
1354 time_t then
= __be32_to_cpu(*(__u32
*)(guid
+16)) + DECADE
;
1357 tm
= localtime(&then
);
1358 strftime(tbuf
, 100, " %D %T",tm
);
1359 fputs(tbuf
, stdout
);
1364 static void examine_vd(int n
, struct ddf_super
*sb
, char *guid
)
1366 int crl
= sb
->conf_rec_len
;
1369 for (vcl
= sb
->conflist
; vcl
; vcl
= vcl
->next
) {
1371 struct vd_config
*vc
= &vcl
->conf
;
1373 if (!be32_eq(calc_crc(vc
, crl
*512), vc
->crc
))
1375 if (memcmp(vc
->guid
, guid
, DDF_GUID_LEN
) != 0)
1378 /* Ok, we know about this VD, let's give more details */
1379 printf(" Raid Devices[%d] : %d (", n
,
1380 be16_to_cpu(vc
->prim_elmnt_count
));
1381 for (i
= 0; i
< be16_to_cpu(vc
->prim_elmnt_count
); i
++) {
1383 int cnt
= be16_to_cpu(sb
->phys
->used_pdes
);
1384 for (j
=0; j
<cnt
; j
++)
1385 if (be32_eq(vc
->phys_refnum
[i
],
1386 sb
->phys
->entries
[j
].refnum
))
1395 if (vc
->chunk_shift
!= 255)
1396 printf(" Chunk Size[%d] : %d sectors\n", n
,
1397 1 << vc
->chunk_shift
);
1398 printf(" Raid Level[%d] : %s\n", n
,
1399 map_num(ddf_level
, vc
->prl
)?:"-unknown-");
1400 if (vc
->sec_elmnt_count
!= 1) {
1401 printf(" Secondary Position[%d] : %d of %d\n", n
,
1402 vc
->sec_elmnt_seq
, vc
->sec_elmnt_count
);
1403 printf(" Secondary Level[%d] : %s\n", n
,
1404 map_num(ddf_sec_level
, vc
->srl
) ?: "-unknown-");
1406 printf(" Device Size[%d] : %llu\n", n
,
1407 be64_to_cpu(vc
->blocks
)/2);
1408 printf(" Array Size[%d] : %llu\n", n
,
1409 be64_to_cpu(vc
->array_blocks
)/2);
1413 static void examine_vds(struct ddf_super
*sb
)
1415 int cnt
= be16_to_cpu(sb
->virt
->populated_vdes
);
1417 printf(" Virtual Disks : %d\n", cnt
);
1419 for (i
= 0; i
< be16_to_cpu(sb
->virt
->max_vdes
); i
++) {
1420 struct virtual_entry
*ve
= &sb
->virt
->entries
[i
];
1421 if (all_ff(ve
->guid
))
1424 printf(" VD GUID[%d] : ", i
); print_guid(ve
->guid
, 1);
1426 printf(" unit[%d] : %d\n", i
, be16_to_cpu(ve
->unit
));
1427 printf(" state[%d] : %s, %s%s\n", i
,
1428 map_num(ddf_state
, ve
->state
& 7),
1429 (ve
->state
& 8) ? "Morphing, ": "",
1430 (ve
->state
& 16)? "Not Consistent" : "Consistent");
1431 printf(" init state[%d] : %s\n", i
,
1432 map_num(ddf_init_state
, ve
->init_state
&3));
1433 printf(" access[%d] : %s\n", i
,
1434 map_num(ddf_access
, (ve
->init_state
>>6) & 3));
1435 printf(" Name[%d] : %.16s\n", i
, ve
->name
);
1436 examine_vd(i
, sb
, ve
->guid
);
1438 if (cnt
) printf("\n");
1441 static void examine_pds(struct ddf_super
*sb
)
1443 int cnt
= be16_to_cpu(sb
->phys
->used_pdes
);
1446 printf(" Physical Disks : %d\n", cnt
);
1447 printf(" Number RefNo Size Device Type/State\n");
1449 for (i
=0 ; i
<cnt
; i
++) {
1450 struct phys_disk_entry
*pd
= &sb
->phys
->entries
[i
];
1451 int type
= be16_to_cpu(pd
->type
);
1452 int state
= be16_to_cpu(pd
->state
);
1454 //printf(" PD GUID[%d] : ", i); print_guid(pd->guid, 0);
1456 printf(" %3d %08x ", i
,
1457 be32_to_cpu(pd
->refnum
));
1459 be64_to_cpu(pd
->config_size
)>>1);
1460 for (dl
= sb
->dlist
; dl
; dl
= dl
->next
) {
1461 if (be32_eq(dl
->disk
.refnum
, pd
->refnum
)) {
1462 char *dv
= map_dev(dl
->major
, dl
->minor
, 0);
1464 printf("%-15s", dv
);
1471 printf(" %s%s%s%s%s",
1472 (type
&2) ? "active":"",
1473 (type
&4) ? "Global-Spare":"",
1474 (type
&8) ? "spare" : "",
1475 (type
&16)? ", foreign" : "",
1476 (type
&32)? "pass-through" : "");
1477 if (state
& DDF_Failed
)
1478 /* This over-rides these three */
1479 state
&= ~(DDF_Online
|DDF_Rebuilding
|DDF_Transition
);
1480 printf("/%s%s%s%s%s%s%s",
1481 (state
&1)? "Online": "Offline",
1482 (state
&2)? ", Failed": "",
1483 (state
&4)? ", Rebuilding": "",
1484 (state
&8)? ", in-transition": "",
1485 (state
&16)? ", SMART-errors": "",
1486 (state
&32)? ", Unrecovered-Read-Errors": "",
1487 (state
&64)? ", Missing" : "");
1492 static void examine_super_ddf(struct supertype
*st
, char *homehost
)
1494 struct ddf_super
*sb
= st
->sb
;
1496 printf(" Magic : %08x\n", be32_to_cpu(sb
->anchor
.magic
));
1497 printf(" Version : %.8s\n", sb
->anchor
.revision
);
1498 printf("Controller GUID : "); print_guid(sb
->controller
.guid
, 0);
1500 printf(" Container GUID : "); print_guid(sb
->anchor
.guid
, 1);
1502 printf(" Seq : %08x\n", be32_to_cpu(sb
->active
->seq
));
1503 printf(" Redundant hdr : %s\n", be32_eq(sb
->secondary
.magic
,
1510 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1512 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4]);
1513 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4]);
1515 static unsigned int get_vd_num_of_subarray(struct supertype
*st
)
1518 * Figure out the VD number for this supertype.
1519 * Returns DDF_CONTAINER for the container itself,
1520 * and DDF_NOTFOUND on error.
1522 struct ddf_super
*ddf
= st
->sb
;
1527 if (*st
->container_devnm
== '\0')
1528 return DDF_CONTAINER
;
1530 sra
= sysfs_read(-1, st
->devnm
, GET_VERSION
);
1531 if (!sra
|| sra
->array
.major_version
!= -1 ||
1532 sra
->array
.minor_version
!= -2 ||
1533 !is_subarray(sra
->text_version
))
1534 return DDF_NOTFOUND
;
1536 sub
= strchr(sra
->text_version
+ 1, '/');
1538 vcnum
= strtoul(sub
+ 1, &end
, 10);
1539 if (sub
== NULL
|| *sub
== '\0' || *end
!= '\0' ||
1540 vcnum
>= be16_to_cpu(ddf
->active
->max_vd_entries
))
1541 return DDF_NOTFOUND
;
1546 static void brief_examine_super_ddf(struct supertype
*st
, int verbose
)
1548 /* We just write a generic DDF ARRAY entry
1552 getinfo_super_ddf(st
, &info
, NULL
);
1553 fname_from_uuid(st
, &info
, nbuf
, ':');
1555 printf("ARRAY metadata=ddf UUID=%s\n", nbuf
+ 5);
1558 static void brief_examine_subarrays_ddf(struct supertype
*st
, int verbose
)
1560 /* We just write a generic DDF ARRAY entry
1562 struct ddf_super
*ddf
= st
->sb
;
1566 getinfo_super_ddf(st
, &info
, NULL
);
1567 fname_from_uuid(st
, &info
, nbuf
, ':');
1569 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
1570 struct virtual_entry
*ve
= &ddf
->virt
->entries
[i
];
1573 if (all_ff(ve
->guid
))
1575 memcpy(vcl
.conf
.guid
, ve
->guid
, DDF_GUID_LEN
);
1576 ddf
->currentconf
=&vcl
;
1577 uuid_from_super_ddf(st
, info
.uuid
);
1578 fname_from_uuid(st
, &info
, nbuf1
, ':');
1579 printf("ARRAY container=%s member=%d UUID=%s\n",
1580 nbuf
+5, i
, nbuf1
+5);
1584 static void export_examine_super_ddf(struct supertype
*st
)
1588 getinfo_super_ddf(st
, &info
, NULL
);
1589 fname_from_uuid(st
, &info
, nbuf
, ':');
1590 printf("MD_METADATA=ddf\n");
1591 printf("MD_LEVEL=container\n");
1592 printf("MD_UUID=%s\n", nbuf
+5);
1595 static int copy_metadata_ddf(struct supertype
*st
, int from
, int to
)
1598 unsigned long long dsize
, offset
;
1600 struct ddf_header
*ddf
;
1603 /* The meta consists of an anchor, a primary, and a secondary.
1604 * This all lives at the end of the device.
1605 * So it is easiest to find the earliest of primary and
1606 * secondary, and copy everything from there.
1608 * Anchor is 512 from end It contains primary_lba and secondary_lba
1609 * we choose one of those
1612 if (posix_memalign(&buf
, 4096, 4096) != 0)
1615 if (!get_dev_size(from
, NULL
, &dsize
))
1618 if (lseek64(from
, dsize
-512, 0) < 0)
1620 if (read(from
, buf
, 512) != 512)
1623 if (!be32_eq(ddf
->magic
, DDF_HEADER_MAGIC
) ||
1624 !be32_eq(calc_crc(ddf
, 512), ddf
->crc
) ||
1625 (memcmp(ddf
->revision
, DDF_REVISION_0
, 8) != 0 &&
1626 memcmp(ddf
->revision
, DDF_REVISION_2
, 8) != 0))
1629 offset
= dsize
- 512;
1630 if ((be64_to_cpu(ddf
->primary_lba
) << 9) < offset
)
1631 offset
= be64_to_cpu(ddf
->primary_lba
) << 9;
1632 if ((be64_to_cpu(ddf
->secondary_lba
) << 9) < offset
)
1633 offset
= be64_to_cpu(ddf
->secondary_lba
) << 9;
1635 bytes
= dsize
- offset
;
1637 if (lseek64(from
, offset
, 0) < 0 ||
1638 lseek64(to
, offset
, 0) < 0)
1640 while (written
< bytes
) {
1641 int n
= bytes
- written
;
1644 if (read(from
, buf
, n
) != n
)
1646 if (write(to
, buf
, n
) != n
)
1657 static void detail_super_ddf(struct supertype
*st
, char *homehost
)
1660 * Could print DDF GUID
1661 * Need to find which array
1662 * If whole, briefly list all arrays
1667 static void brief_detail_super_ddf(struct supertype
*st
)
1671 struct ddf_super
*ddf
= st
->sb
;
1672 unsigned int vcnum
= get_vd_num_of_subarray(st
);
1673 if (vcnum
== DDF_CONTAINER
)
1674 uuid_from_super_ddf(st
, info
.uuid
);
1675 else if (vcnum
== DDF_NOTFOUND
)
1678 uuid_from_ddf_guid(ddf
->virt
->entries
[vcnum
].guid
, info
.uuid
);
1679 fname_from_uuid(st
, &info
, nbuf
,':');
1680 printf(" UUID=%s", nbuf
+ 5);
1684 static int match_home_ddf(struct supertype
*st
, char *homehost
)
1686 /* It matches 'this' host if the controller is a
1687 * Linux-MD controller with vendor_data matching
1690 struct ddf_super
*ddf
= st
->sb
;
1695 len
= strlen(homehost
);
1697 return (memcmp(ddf
->controller
.guid
, T10
, 8) == 0 &&
1698 len
< sizeof(ddf
->controller
.vendor_data
) &&
1699 memcmp(ddf
->controller
.vendor_data
, homehost
,len
) == 0 &&
1700 ddf
->controller
.vendor_data
[len
] == 0);
1704 static int find_index_in_bvd(const struct ddf_super
*ddf
,
1705 const struct vd_config
*conf
, unsigned int n
,
1706 unsigned int *n_bvd
)
1709 * Find the index of the n-th valid physical disk in this BVD
1712 for (i
= 0, j
= 0; i
< ddf
->mppe
&&
1713 j
< be16_to_cpu(conf
->prim_elmnt_count
); i
++) {
1714 if (be32_to_cpu(conf
->phys_refnum
[i
]) != 0xffffffff) {
1722 dprintf("%s: couldn't find BVD member %u (total %u)\n",
1723 __func__
, n
, be16_to_cpu(conf
->prim_elmnt_count
));
1727 static struct vd_config
*find_vdcr(struct ddf_super
*ddf
, unsigned int inst
,
1729 unsigned int *n_bvd
, struct vcl
**vcl
)
1733 for (v
= ddf
->conflist
; v
; v
= v
->next
) {
1734 unsigned int nsec
, ibvd
= 0;
1735 struct vd_config
*conf
;
1736 if (inst
!= v
->vcnum
)
1739 if (conf
->sec_elmnt_count
== 1) {
1740 if (find_index_in_bvd(ddf
, conf
, n
, n_bvd
)) {
1746 if (v
->other_bvds
== NULL
) {
1747 pr_err("%s: BUG: other_bvds is NULL, nsec=%u\n",
1748 __func__
, conf
->sec_elmnt_count
);
1751 nsec
= n
/ be16_to_cpu(conf
->prim_elmnt_count
);
1752 if (conf
->sec_elmnt_seq
!= nsec
) {
1753 for (ibvd
= 1; ibvd
< conf
->sec_elmnt_count
; ibvd
++) {
1754 if (v
->other_bvds
[ibvd
-1]->sec_elmnt_seq
1758 if (ibvd
== conf
->sec_elmnt_count
)
1760 conf
= v
->other_bvds
[ibvd
-1];
1762 if (!find_index_in_bvd(ddf
, conf
,
1763 n
- nsec
*conf
->sec_elmnt_count
, n_bvd
))
1765 dprintf("%s: found disk %u as member %u in bvd %d of array %u\n"
1766 , __func__
, n
, *n_bvd
, ibvd
, inst
);
1771 pr_err("%s: Could't find disk %d in array %u\n", __func__
, n
, inst
);
1776 static int find_phys(const struct ddf_super
*ddf
, be32 phys_refnum
)
1778 /* Find the entry in phys_disk which has the given refnum
1779 * and return it's index
1782 for (i
= 0; i
< be16_to_cpu(ddf
->phys
->max_pdes
); i
++)
1783 if (be32_eq(ddf
->phys
->entries
[i
].refnum
, phys_refnum
))
1788 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4])
1791 struct sha1_ctx ctx
;
1792 sha1_init_ctx(&ctx
);
1793 sha1_process_bytes(guid
, DDF_GUID_LEN
, &ctx
);
1794 sha1_finish_ctx(&ctx
, buf
);
1795 memcpy(uuid
, buf
, 4*4);
1798 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4])
1800 /* The uuid returned here is used for:
1801 * uuid to put into bitmap file (Create, Grow)
1802 * uuid for backup header when saving critical section (Grow)
1803 * comparing uuids when re-adding a device into an array
1804 * In these cases the uuid required is that of the data-array,
1805 * not the device-set.
1806 * uuid to recognise same set when adding a missing device back
1807 * to an array. This is a uuid for the device-set.
1809 * For each of these we can make do with a truncated
1810 * or hashed uuid rather than the original, as long as
1812 * In the case of SVD we assume the BVD is of interest,
1813 * though that might be the case if a bitmap were made for
1814 * a mirrored SVD - worry about that later.
1815 * So we need to find the VD configuration record for the
1816 * relevant BVD and extract the GUID and Secondary_Element_Seq.
1817 * The first 16 bytes of the sha1 of these is used.
1819 struct ddf_super
*ddf
= st
->sb
;
1820 struct vcl
*vcl
= ddf
->currentconf
;
1824 guid
= vcl
->conf
.guid
;
1826 guid
= ddf
->anchor
.guid
;
1827 uuid_from_ddf_guid(guid
, uuid
);
1830 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1832 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1834 struct ddf_super
*ddf
= st
->sb
;
1835 int map_disks
= info
->array
.raid_disks
;
1838 if (ddf
->currentconf
) {
1839 getinfo_super_ddf_bvd(st
, info
, map
);
1842 memset(info
, 0, sizeof(*info
));
1844 info
->array
.raid_disks
= be16_to_cpu(ddf
->phys
->used_pdes
);
1845 info
->array
.level
= LEVEL_CONTAINER
;
1846 info
->array
.layout
= 0;
1847 info
->array
.md_minor
= -1;
1848 cptr
= (__u32
*)(ddf
->anchor
.guid
+ 16);
1849 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1851 info
->array
.utime
= 0;
1852 info
->array
.chunk_size
= 0;
1853 info
->container_enough
= 1;
1855 info
->disk
.major
= 0;
1856 info
->disk
.minor
= 0;
1858 info
->disk
.number
= be32_to_cpu(ddf
->dlist
->disk
.refnum
);
1859 info
->disk
.raid_disk
= find_phys(ddf
, ddf
->dlist
->disk
.refnum
);
1861 info
->data_offset
= be64_to_cpu(ddf
->phys
->
1862 entries
[info
->disk
.raid_disk
].
1864 info
->component_size
= ddf
->dlist
->size
- info
->data_offset
;
1866 info
->disk
.number
= -1;
1867 info
->disk
.raid_disk
= -1;
1868 // info->disk.raid_disk = find refnum in the table and use index;
1870 info
->disk
.state
= (1 << MD_DISK_SYNC
) | (1 << MD_DISK_ACTIVE
);
1872 info
->recovery_start
= MaxSector
;
1873 info
->reshape_active
= 0;
1874 info
->recovery_blocked
= 0;
1877 info
->array
.major_version
= -1;
1878 info
->array
.minor_version
= -2;
1879 strcpy(info
->text_version
, "ddf");
1880 info
->safe_mode_delay
= 0;
1882 uuid_from_super_ddf(st
, info
->uuid
);
1886 for (i
= 0 ; i
< map_disks
; i
++) {
1887 if (i
< info
->array
.raid_disks
&&
1888 (be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1890 !(be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1899 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1901 struct ddf_super
*ddf
= st
->sb
;
1902 struct vcl
*vc
= ddf
->currentconf
;
1903 int cd
= ddf
->currentdev
;
1907 int map_disks
= info
->array
.raid_disks
;
1909 struct vd_config
*conf
;
1911 memset(info
, 0, sizeof(*info
));
1912 if (layout_ddf2md(&vc
->conf
, &info
->array
) == -1)
1914 info
->array
.md_minor
= -1;
1915 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
1916 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1917 info
->array
.utime
= DECADE
+ be32_to_cpu(vc
->conf
.timestamp
);
1918 info
->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
1919 info
->custom_array_size
= 0;
1922 n_prim
= be16_to_cpu(conf
->prim_elmnt_count
);
1923 if (conf
->sec_elmnt_count
> 1 && cd
>= n_prim
) {
1924 int ibvd
= cd
/ n_prim
- 1;
1926 conf
= vc
->other_bvds
[ibvd
];
1929 if (cd
>= 0 && (unsigned)cd
< ddf
->mppe
) {
1931 be64_to_cpu(LBA_OFFSET(ddf
, conf
)[cd
]);
1932 if (vc
->block_sizes
)
1933 info
->component_size
= vc
->block_sizes
[cd
];
1935 info
->component_size
= be64_to_cpu(conf
->blocks
);
1938 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
1939 if (be32_eq(dl
->disk
.refnum
, conf
->phys_refnum
[cd
]))
1942 info
->disk
.major
= 0;
1943 info
->disk
.minor
= 0;
1944 info
->disk
.state
= 0;
1946 info
->disk
.major
= dl
->major
;
1947 info
->disk
.minor
= dl
->minor
;
1948 info
->disk
.raid_disk
= cd
+ conf
->sec_elmnt_seq
1949 * be16_to_cpu(conf
->prim_elmnt_count
);
1950 info
->disk
.number
= dl
->pdnum
;
1951 info
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
1954 info
->container_member
= ddf
->currentconf
->vcnum
;
1956 info
->recovery_start
= MaxSector
;
1957 info
->resync_start
= 0;
1958 info
->reshape_active
= 0;
1959 info
->recovery_blocked
= 0;
1960 if (!(ddf
->virt
->entries
[info
->container_member
].state
1961 & DDF_state_inconsistent
) &&
1962 (ddf
->virt
->entries
[info
->container_member
].init_state
1963 & DDF_initstate_mask
)
1965 info
->resync_start
= MaxSector
;
1967 uuid_from_super_ddf(st
, info
->uuid
);
1969 info
->array
.major_version
= -1;
1970 info
->array
.minor_version
= -2;
1971 sprintf(info
->text_version
, "/%s/%d",
1972 st
->container_devnm
,
1973 info
->container_member
);
1974 info
->safe_mode_delay
= 200;
1976 memcpy(info
->name
, ddf
->virt
->entries
[info
->container_member
].name
, 16);
1979 if (info
->name
[j
] == ' ')
1983 for (j
= 0; j
< map_disks
; j
++) {
1985 if (j
< info
->array
.raid_disks
) {
1986 int i
= find_phys(ddf
, vc
->conf
.phys_refnum
[j
]);
1988 (be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1990 !(be16_to_cpu(ddf
->phys
->entries
[i
].state
)
1997 static int update_super_ddf(struct supertype
*st
, struct mdinfo
*info
,
1999 char *devname
, int verbose
,
2000 int uuid_set
, char *homehost
)
2002 /* For 'assemble' and 'force' we need to return non-zero if any
2003 * change was made. For others, the return value is ignored.
2004 * Update options are:
2005 * force-one : This device looks a bit old but needs to be included,
2006 * update age info appropriately.
2007 * assemble: clear any 'faulty' flag to allow this device to
2009 * force-array: Array is degraded but being forced, mark it clean
2010 * if that will be needed to assemble it.
2012 * newdev: not used ????
2013 * grow: Array has gained a new device - this is currently for
2015 * resync: mark as dirty so a resync will happen.
2016 * uuid: Change the uuid of the array to match what is given
2017 * homehost: update the recorded homehost
2018 * name: update the name - preserving the homehost
2019 * _reshape_progress: record new reshape_progress position.
2021 * Following are not relevant for this version:
2022 * sparc2.2 : update from old dodgey metadata
2023 * super-minor: change the preferred_minor number
2024 * summaries: update redundant counters.
2027 // struct ddf_super *ddf = st->sb;
2028 // struct vd_config *vd = find_vdcr(ddf, info->container_member);
2029 // struct virtual_entry *ve = find_ve(ddf);
2031 /* we don't need to handle "force-*" or "assemble" as
2032 * there is no need to 'trick' the kernel. We the metadata is
2033 * first updated to activate the array, all the implied modifications
2037 if (strcmp(update
, "grow") == 0) {
2039 } else if (strcmp(update
, "resync") == 0) {
2040 // info->resync_checkpoint = 0;
2041 } else if (strcmp(update
, "homehost") == 0) {
2042 /* homehost is stored in controller->vendor_data,
2043 * or it is when we are the vendor
2045 // if (info->vendor_is_local)
2046 // strcpy(ddf->controller.vendor_data, homehost);
2048 } else if (strcmp(update
, "name") == 0) {
2049 /* name is stored in virtual_entry->name */
2050 // memset(ve->name, ' ', 16);
2051 // strncpy(ve->name, info->name, 16);
2053 } else if (strcmp(update
, "_reshape_progress") == 0) {
2054 /* We don't support reshape yet */
2055 } else if (strcmp(update
, "assemble") == 0 ) {
2056 /* Do nothing, just succeed */
2061 // update_all_csum(ddf);
2066 static void make_header_guid(char *guid
)
2069 /* Create a DDF Header of Virtual Disk GUID */
2071 /* 24 bytes of fiction required.
2072 * first 8 are a 'vendor-id' - "Linux-MD"
2073 * next 8 are controller type.. how about 0X DEAD BEEF 0000 0000
2074 * Remaining 8 random number plus timestamp
2076 memcpy(guid
, T10
, sizeof(T10
));
2077 stamp
= cpu_to_be32(0xdeadbeef);
2078 memcpy(guid
+8, &stamp
, 4);
2079 stamp
= cpu_to_be32(0);
2080 memcpy(guid
+12, &stamp
, 4);
2081 stamp
= cpu_to_be32(time(0) - DECADE
);
2082 memcpy(guid
+16, &stamp
, 4);
2083 stamp
._v32
= random32();
2084 memcpy(guid
+20, &stamp
, 4);
2087 static unsigned int find_unused_vde(const struct ddf_super
*ddf
)
2090 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2091 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2094 return DDF_NOTFOUND
;
2097 static unsigned int find_vde_by_name(const struct ddf_super
*ddf
,
2102 return DDF_NOTFOUND
;
2103 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2104 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2106 if (!strncmp(name
, ddf
->virt
->entries
[i
].name
,
2107 sizeof(ddf
->virt
->entries
[i
].name
)))
2110 return DDF_NOTFOUND
;
2114 static unsigned int find_vde_by_guid(const struct ddf_super
*ddf
,
2118 if (guid
== NULL
|| all_ff(guid
))
2119 return DDF_NOTFOUND
;
2120 for (i
= 0; i
< be16_to_cpu(ddf
->virt
->max_vdes
); i
++)
2121 if (!memcmp(ddf
->virt
->entries
[i
].guid
, guid
, DDF_GUID_LEN
))
2123 return DDF_NOTFOUND
;
2127 static int init_super_ddf_bvd(struct supertype
*st
,
2128 mdu_array_info_t
*info
,
2129 unsigned long long size
,
2130 char *name
, char *homehost
,
2131 int *uuid
, unsigned long long data_offset
);
2133 static int init_super_ddf(struct supertype
*st
,
2134 mdu_array_info_t
*info
,
2135 unsigned long long size
, char *name
, char *homehost
,
2136 int *uuid
, unsigned long long data_offset
)
2138 /* This is primarily called by Create when creating a new array.
2139 * We will then get add_to_super called for each component, and then
2140 * write_init_super called to write it out to each device.
2141 * For DDF, Create can create on fresh devices or on a pre-existing
2143 * To create on a pre-existing array a different method will be called.
2144 * This one is just for fresh drives.
2146 * We need to create the entire 'ddf' structure which includes:
2147 * DDF headers - these are easy.
2148 * Controller data - a Sector describing this controller .. not that
2149 * this is a controller exactly.
2150 * Physical Disk Record - one entry per device, so
2151 * leave plenty of space.
2152 * Virtual Disk Records - again, just leave plenty of space.
2153 * This just lists VDs, doesn't give details
2154 * Config records - describes the VDs that use this disk
2155 * DiskData - describes 'this' device.
2156 * BadBlockManagement - empty
2157 * Diag Space - empty
2158 * Vendor Logs - Could we put bitmaps here?
2161 struct ddf_super
*ddf
;
2164 int max_phys_disks
, max_virt_disks
;
2165 unsigned long long sector
;
2169 struct phys_disk
*pd
;
2170 struct virtual_disk
*vd
;
2172 if (data_offset
!= INVALID_SECTORS
) {
2173 pr_err("data-offset not supported by DDF\n");
2178 return init_super_ddf_bvd(st
, info
, size
, name
, homehost
, uuid
,
2181 if (posix_memalign((void**)&ddf
, 512, sizeof(*ddf
)) != 0) {
2182 pr_err("%s could not allocate superblock\n", __func__
);
2185 memset(ddf
, 0, sizeof(*ddf
));
2186 ddf
->dlist
= NULL
; /* no physical disks yet */
2187 ddf
->conflist
= NULL
; /* No virtual disks yet */
2191 /* zeroing superblock */
2195 /* At least 32MB *must* be reserved for the ddf. So let's just
2196 * start 32MB from the end, and put the primary header there.
2197 * Don't do secondary for now.
2198 * We don't know exactly where that will be yet as it could be
2199 * different on each device. To just set up the lengths.
2203 ddf
->anchor
.magic
= DDF_HEADER_MAGIC
;
2204 make_header_guid(ddf
->anchor
.guid
);
2206 memcpy(ddf
->anchor
.revision
, DDF_REVISION_2
, 8);
2207 ddf
->anchor
.seq
= cpu_to_be32(1);
2208 ddf
->anchor
.timestamp
= cpu_to_be32(time(0) - DECADE
);
2209 ddf
->anchor
.openflag
= 0xFF;
2210 ddf
->anchor
.foreignflag
= 0;
2211 ddf
->anchor
.enforcegroups
= 0; /* Is this best?? */
2212 ddf
->anchor
.pad0
= 0xff;
2213 memset(ddf
->anchor
.pad1
, 0xff, 12);
2214 memset(ddf
->anchor
.header_ext
, 0xff, 32);
2215 ddf
->anchor
.primary_lba
= cpu_to_be64(~(__u64
)0);
2216 ddf
->anchor
.secondary_lba
= cpu_to_be64(~(__u64
)0);
2217 ddf
->anchor
.type
= DDF_HEADER_ANCHOR
;
2218 memset(ddf
->anchor
.pad2
, 0xff, 3);
2219 ddf
->anchor
.workspace_len
= cpu_to_be32(32768); /* Must be reserved */
2220 /* Put this at bottom of 32M reserved.. */
2221 ddf
->anchor
.workspace_lba
= cpu_to_be64(~(__u64
)0);
2222 max_phys_disks
= 1023; /* Should be enough */
2223 ddf
->anchor
.max_pd_entries
= cpu_to_be16(max_phys_disks
);
2224 max_virt_disks
= 255;
2225 ddf
->anchor
.max_vd_entries
= cpu_to_be16(max_virt_disks
); /* ?? */
2226 ddf
->anchor
.max_partitions
= cpu_to_be16(64); /* ?? */
2229 ddf
->conf_rec_len
= 1 + ROUND_UP(ddf
->mppe
* (4+8), 512)/512;
2230 ddf
->anchor
.config_record_len
= cpu_to_be16(ddf
->conf_rec_len
);
2231 ddf
->anchor
.max_primary_element_entries
= cpu_to_be16(ddf
->mppe
);
2232 memset(ddf
->anchor
.pad3
, 0xff, 54);
2233 /* controller sections is one sector long immediately
2234 * after the ddf header */
2236 ddf
->anchor
.controller_section_offset
= cpu_to_be32(sector
);
2237 ddf
->anchor
.controller_section_length
= cpu_to_be32(1);
2240 /* phys is 8 sectors after that */
2241 pdsize
= ROUND_UP(sizeof(struct phys_disk
) +
2242 sizeof(struct phys_disk_entry
)*max_phys_disks
,
2244 switch(pdsize
/512) {
2245 case 2: case 8: case 32: case 128: case 512: break;
2248 ddf
->anchor
.phys_section_offset
= cpu_to_be32(sector
);
2249 ddf
->anchor
.phys_section_length
=
2250 cpu_to_be32(pdsize
/512); /* max_primary_element_entries/8 */
2251 sector
+= pdsize
/512;
2253 /* virt is another 32 sectors */
2254 vdsize
= ROUND_UP(sizeof(struct virtual_disk
) +
2255 sizeof(struct virtual_entry
) * max_virt_disks
,
2257 switch(vdsize
/512) {
2258 case 2: case 8: case 32: case 128: case 512: break;
2261 ddf
->anchor
.virt_section_offset
= cpu_to_be32(sector
);
2262 ddf
->anchor
.virt_section_length
=
2263 cpu_to_be32(vdsize
/512); /* max_vd_entries/8 */
2264 sector
+= vdsize
/512;
2266 clen
= ddf
->conf_rec_len
* (ddf
->max_part
+1);
2267 ddf
->anchor
.config_section_offset
= cpu_to_be32(sector
);
2268 ddf
->anchor
.config_section_length
= cpu_to_be32(clen
);
2271 ddf
->anchor
.data_section_offset
= cpu_to_be32(sector
);
2272 ddf
->anchor
.data_section_length
= cpu_to_be32(1);
2275 ddf
->anchor
.bbm_section_length
= cpu_to_be32(0);
2276 ddf
->anchor
.bbm_section_offset
= cpu_to_be32(0xFFFFFFFF);
2277 ddf
->anchor
.diag_space_length
= cpu_to_be32(0);
2278 ddf
->anchor
.diag_space_offset
= cpu_to_be32(0xFFFFFFFF);
2279 ddf
->anchor
.vendor_length
= cpu_to_be32(0);
2280 ddf
->anchor
.vendor_offset
= cpu_to_be32(0xFFFFFFFF);
2282 memset(ddf
->anchor
.pad4
, 0xff, 256);
2284 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
2285 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
2287 ddf
->primary
.openflag
= 1; /* I guess.. */
2288 ddf
->primary
.type
= DDF_HEADER_PRIMARY
;
2290 ddf
->secondary
.openflag
= 1; /* I guess.. */
2291 ddf
->secondary
.type
= DDF_HEADER_SECONDARY
;
2293 ddf
->active
= &ddf
->primary
;
2295 ddf
->controller
.magic
= DDF_CONTROLLER_MAGIC
;
2297 /* 24 more bytes of fiction required.
2298 * first 8 are a 'vendor-id' - "Linux-MD"
2299 * Remaining 16 are serial number.... maybe a hostname would do?
2301 memcpy(ddf
->controller
.guid
, T10
, sizeof(T10
));
2302 gethostname(hostname
, sizeof(hostname
));
2303 hostname
[sizeof(hostname
) - 1] = 0;
2304 hostlen
= strlen(hostname
);
2305 memcpy(ddf
->controller
.guid
+ 24 - hostlen
, hostname
, hostlen
);
2306 for (i
= strlen(T10
) ; i
+hostlen
< 24; i
++)
2307 ddf
->controller
.guid
[i
] = ' ';
2309 ddf
->controller
.type
.vendor_id
= cpu_to_be16(0xDEAD);
2310 ddf
->controller
.type
.device_id
= cpu_to_be16(0xBEEF);
2311 ddf
->controller
.type
.sub_vendor_id
= cpu_to_be16(0);
2312 ddf
->controller
.type
.sub_device_id
= cpu_to_be16(0);
2313 memcpy(ddf
->controller
.product_id
, "What Is My PID??", 16);
2314 memset(ddf
->controller
.pad
, 0xff, 8);
2315 memset(ddf
->controller
.vendor_data
, 0xff, 448);
2316 if (homehost
&& strlen(homehost
) < 440)
2317 strcpy((char*)ddf
->controller
.vendor_data
, homehost
);
2319 if (posix_memalign((void**)&pd
, 512, pdsize
) != 0) {
2320 pr_err("%s could not allocate pd\n", __func__
);
2324 ddf
->pdsize
= pdsize
;
2326 memset(pd
, 0xff, pdsize
);
2327 memset(pd
, 0, sizeof(*pd
));
2328 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2329 pd
->used_pdes
= cpu_to_be16(0);
2330 pd
->max_pdes
= cpu_to_be16(max_phys_disks
);
2331 memset(pd
->pad
, 0xff, 52);
2332 for (i
= 0; i
< max_phys_disks
; i
++)
2333 memset(pd
->entries
[i
].guid
, 0xff, DDF_GUID_LEN
);
2335 if (posix_memalign((void**)&vd
, 512, vdsize
) != 0) {
2336 pr_err("%s could not allocate vd\n", __func__
);
2340 ddf
->vdsize
= vdsize
;
2341 memset(vd
, 0, vdsize
);
2342 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
2343 vd
->populated_vdes
= cpu_to_be16(0);
2344 vd
->max_vdes
= cpu_to_be16(max_virt_disks
);
2345 memset(vd
->pad
, 0xff, 52);
2347 for (i
=0; i
<max_virt_disks
; i
++)
2348 memset(&vd
->entries
[i
], 0xff, sizeof(struct virtual_entry
));
2351 ddf_set_updates_pending(ddf
);
2355 static int chunk_to_shift(int chunksize
)
2357 return ffs(chunksize
/512)-1;
2362 unsigned long long start
, size
;
2364 static int cmp_extent(const void *av
, const void *bv
)
2366 const struct extent
*a
= av
;
2367 const struct extent
*b
= bv
;
2368 if (a
->start
< b
->start
)
2370 if (a
->start
> b
->start
)
2375 static struct extent
*get_extents(struct ddf_super
*ddf
, struct dl
*dl
)
2377 /* find a list of used extents on the give physical device
2378 * (dnum) of the given ddf.
2379 * Return a malloced array of 'struct extent'
2381 * FIXME ignore DDF_Legacy devices?
2388 rv
= xmalloc(sizeof(struct extent
) * (ddf
->max_part
+ 2));
2390 for (i
= 0; i
< ddf
->max_part
; i
++) {
2391 const struct vd_config
*bvd
;
2393 struct vcl
*v
= dl
->vlist
[i
];
2395 get_pd_index_from_refnum(v
, dl
->disk
.refnum
, ddf
->mppe
,
2396 &bvd
, &ibvd
) == DDF_NOTFOUND
)
2398 rv
[n
].start
= be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[ibvd
]);
2399 rv
[n
].size
= be64_to_cpu(bvd
->blocks
);
2402 qsort(rv
, n
, sizeof(*rv
), cmp_extent
);
2404 rv
[n
].start
= be64_to_cpu(ddf
->phys
->entries
[dl
->pdnum
].config_size
);
2410 static int init_super_ddf_bvd(struct supertype
*st
,
2411 mdu_array_info_t
*info
,
2412 unsigned long long size
,
2413 char *name
, char *homehost
,
2414 int *uuid
, unsigned long long data_offset
)
2416 /* We are creating a BVD inside a pre-existing container.
2417 * so st->sb is already set.
2418 * We need to create a new vd_config and a new virtual_entry
2420 struct ddf_super
*ddf
= st
->sb
;
2421 unsigned int venum
, i
;
2422 struct virtual_entry
*ve
;
2424 struct vd_config
*vc
;
2426 if (find_vde_by_name(ddf
, name
) != DDF_NOTFOUND
) {
2427 pr_err("This ddf already has an array called %s\n", name
);
2430 venum
= find_unused_vde(ddf
);
2431 if (venum
== DDF_NOTFOUND
) {
2432 pr_err("Cannot find spare slot for virtual disk\n");
2435 ve
= &ddf
->virt
->entries
[venum
];
2437 /* A Virtual Disk GUID contains the T10 Vendor ID, controller type,
2438 * timestamp, random number
2440 make_header_guid(ve
->guid
);
2441 ve
->unit
= cpu_to_be16(info
->md_minor
);
2443 ve
->guid_crc
._v16
= crc32(0, (unsigned char *)ddf
->anchor
.guid
,
2445 ve
->type
= cpu_to_be16(0);
2446 ve
->state
= DDF_state_degraded
; /* Will be modified as devices are added */
2447 if (info
->state
& 1) /* clean */
2448 ve
->init_state
= DDF_init_full
;
2450 ve
->init_state
= DDF_init_not
;
2452 memset(ve
->pad1
, 0xff, 14);
2453 memset(ve
->name
, ' ', 16);
2455 strncpy(ve
->name
, name
, 16);
2456 ddf
->virt
->populated_vdes
=
2457 cpu_to_be16(be16_to_cpu(ddf
->virt
->populated_vdes
)+1);
2459 /* Now create a new vd_config */
2460 if (posix_memalign((void**)&vcl
, 512,
2461 (offsetof(struct vcl
, conf
) + ddf
->conf_rec_len
* 512)) != 0) {
2462 pr_err("%s could not allocate vd_config\n", __func__
);
2466 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
2469 vc
->magic
= DDF_VD_CONF_MAGIC
;
2470 memcpy(vc
->guid
, ve
->guid
, DDF_GUID_LEN
);
2471 vc
->timestamp
= cpu_to_be32(time(0)-DECADE
);
2472 vc
->seqnum
= cpu_to_be32(1);
2473 memset(vc
->pad0
, 0xff, 24);
2474 vc
->chunk_shift
= chunk_to_shift(info
->chunk_size
);
2475 if (layout_md2ddf(info
, vc
) == -1 ||
2476 be16_to_cpu(vc
->prim_elmnt_count
) > ddf
->mppe
) {
2477 pr_err("%s: unsupported RAID level/layout %d/%d with %d disks\n",
2478 __func__
, info
->level
, info
->layout
, info
->raid_disks
);
2482 vc
->sec_elmnt_seq
= 0;
2483 if (alloc_other_bvds(ddf
, vcl
) != 0) {
2484 pr_err("%s could not allocate other bvds\n",
2489 vc
->blocks
= cpu_to_be64(info
->size
* 2);
2490 vc
->array_blocks
= cpu_to_be64(
2491 calc_array_size(info
->level
, info
->raid_disks
, info
->layout
,
2492 info
->chunk_size
, info
->size
*2));
2493 memset(vc
->pad1
, 0xff, 8);
2494 vc
->spare_refs
[0] = cpu_to_be32(0xffffffff);
2495 vc
->spare_refs
[1] = cpu_to_be32(0xffffffff);
2496 vc
->spare_refs
[2] = cpu_to_be32(0xffffffff);
2497 vc
->spare_refs
[3] = cpu_to_be32(0xffffffff);
2498 vc
->spare_refs
[4] = cpu_to_be32(0xffffffff);
2499 vc
->spare_refs
[5] = cpu_to_be32(0xffffffff);
2500 vc
->spare_refs
[6] = cpu_to_be32(0xffffffff);
2501 vc
->spare_refs
[7] = cpu_to_be32(0xffffffff);
2502 memset(vc
->cache_pol
, 0, 8);
2504 memset(vc
->pad2
, 0xff, 3);
2505 memset(vc
->pad3
, 0xff, 52);
2506 memset(vc
->pad4
, 0xff, 192);
2507 memset(vc
->v0
, 0xff, 32);
2508 memset(vc
->v1
, 0xff, 32);
2509 memset(vc
->v2
, 0xff, 16);
2510 memset(vc
->v3
, 0xff, 16);
2511 memset(vc
->vendor
, 0xff, 32);
2513 memset(vc
->phys_refnum
, 0xff, 4*ddf
->mppe
);
2514 memset(vc
->phys_refnum
+ddf
->mppe
, 0x00, 8*ddf
->mppe
);
2516 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++) {
2517 memcpy(vcl
->other_bvds
[i
-1], vc
, ddf
->conf_rec_len
* 512);
2518 vcl
->other_bvds
[i
-1]->sec_elmnt_seq
= i
;
2521 vcl
->next
= ddf
->conflist
;
2522 ddf
->conflist
= vcl
;
2523 ddf
->currentconf
= vcl
;
2524 ddf_set_updates_pending(ddf
);
2530 static int get_svd_state(const struct ddf_super
*, const struct vcl
*);
2532 static void add_to_super_ddf_bvd(struct supertype
*st
,
2533 mdu_disk_info_t
*dk
, int fd
, char *devname
)
2535 /* fd and devname identify a device with-in the ddf container (st).
2536 * dk identifies a location in the new BVD.
2537 * We need to find suitable free space in that device and update
2538 * the phys_refnum and lba_offset for the newly created vd_config.
2539 * We might also want to update the type in the phys_disk
2542 * Alternately: fd == -1 and we have already chosen which device to
2543 * use and recorded in dlist->raid_disk;
2546 struct ddf_super
*ddf
= st
->sb
;
2547 struct vd_config
*vc
;
2549 unsigned long long blocks
, pos
, esize
;
2551 unsigned int raid_disk
= dk
->raid_disk
;
2554 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2555 if (dl
->raiddisk
== dk
->raid_disk
)
2558 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2559 if (dl
->major
== dk
->major
&&
2560 dl
->minor
== dk
->minor
)
2563 if (!dl
|| ! (dk
->state
& (1<<MD_DISK_SYNC
)))
2566 vc
= &ddf
->currentconf
->conf
;
2567 if (vc
->sec_elmnt_count
> 1) {
2568 unsigned int n
= be16_to_cpu(vc
->prim_elmnt_count
);
2570 vc
= ddf
->currentconf
->other_bvds
[raid_disk
/ n
- 1];
2574 ex
= get_extents(ddf
, dl
);
2579 blocks
= be64_to_cpu(vc
->blocks
);
2580 if (ddf
->currentconf
->block_sizes
)
2581 blocks
= ddf
->currentconf
->block_sizes
[dk
->raid_disk
];
2584 esize
= ex
[i
].start
- pos
;
2585 if (esize
>= blocks
)
2587 pos
= ex
[i
].start
+ ex
[i
].size
;
2589 } while (ex
[i
-1].size
);
2595 ddf
->currentdev
= dk
->raid_disk
;
2596 vc
->phys_refnum
[raid_disk
] = dl
->disk
.refnum
;
2597 LBA_OFFSET(ddf
, vc
)[raid_disk
] = cpu_to_be64(pos
);
2599 for (i
= 0; i
< ddf
->max_part
; i
++)
2600 if (dl
->vlist
[i
] == NULL
)
2602 if (i
== ddf
->max_part
)
2604 dl
->vlist
[i
] = ddf
->currentconf
;
2609 dl
->devname
= devname
;
2611 /* Check if we can mark array as optimal yet */
2612 i
= ddf
->currentconf
->vcnum
;
2613 ddf
->virt
->entries
[i
].state
=
2614 (ddf
->virt
->entries
[i
].state
& ~DDF_state_mask
)
2615 | get_svd_state(ddf
, ddf
->currentconf
);
2616 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
2617 cpu_to_be16(DDF_Global_Spare
));
2618 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
2619 cpu_to_be16(DDF_Active_in_VD
));
2620 dprintf("%s: added disk %d/%08x to VD %d/%s as disk %d\n",
2621 __func__
, dl
->pdnum
, be32_to_cpu(dl
->disk
.refnum
),
2622 ddf
->currentconf
->vcnum
, guid_str(vc
->guid
),
2624 ddf_set_updates_pending(ddf
);
2627 static unsigned int find_unused_pde(const struct ddf_super
*ddf
)
2630 for (i
= 0; i
< be16_to_cpu(ddf
->phys
->max_pdes
); i
++) {
2631 if (all_ff(ddf
->phys
->entries
[i
].guid
))
2634 return DDF_NOTFOUND
;
2637 /* add a device to a container, either while creating it or while
2638 * expanding a pre-existing container
2640 static int add_to_super_ddf(struct supertype
*st
,
2641 mdu_disk_info_t
*dk
, int fd
, char *devname
,
2642 unsigned long long data_offset
)
2644 struct ddf_super
*ddf
= st
->sb
;
2648 unsigned long long size
;
2649 struct phys_disk_entry
*pde
;
2654 if (ddf
->currentconf
) {
2655 add_to_super_ddf_bvd(st
, dk
, fd
, devname
);
2659 /* This is device numbered dk->number. We need to create
2660 * a phys_disk entry and a more detailed disk_data entry.
2663 n
= find_unused_pde(ddf
);
2664 if (n
== DDF_NOTFOUND
) {
2665 pr_err("%s: No free slot in array, cannot add disk\n",
2669 pde
= &ddf
->phys
->entries
[n
];
2670 get_dev_size(fd
, NULL
, &size
);
2671 if (size
<= 32*1024*1024) {
2672 pr_err("%s: device size must be at least 32MB\n",
2678 if (posix_memalign((void**)&dd
, 512,
2679 sizeof(*dd
) + sizeof(dd
->vlist
[0]) * ddf
->max_part
) != 0) {
2680 pr_err("%s could allocate buffer for new disk, aborting\n",
2684 dd
->major
= major(stb
.st_rdev
);
2685 dd
->minor
= minor(stb
.st_rdev
);
2686 dd
->devname
= devname
;
2690 dd
->disk
.magic
= DDF_PHYS_DATA_MAGIC
;
2692 tm
= localtime(&now
);
2693 sprintf(dd
->disk
.guid
, "%8s%04d%02d%02d",
2694 T10
, tm
->tm_year
+1900, tm
->tm_mon
+1, tm
->tm_mday
);
2695 tptr
= (__u32
*)(dd
->disk
.guid
+ 16);
2696 *tptr
++ = random32();
2700 /* Cannot be bothered finding a CRC of some irrelevant details*/
2701 dd
->disk
.refnum
._v32
= random32();
2702 for (i
= be16_to_cpu(ddf
->active
->max_pd_entries
);
2704 if (be32_eq(ddf
->phys
->entries
[i
-1].refnum
,
2709 dd
->disk
.forced_ref
= 1;
2710 dd
->disk
.forced_guid
= 1;
2711 memset(dd
->disk
.vendor
, ' ', 32);
2712 memcpy(dd
->disk
.vendor
, "Linux", 5);
2713 memset(dd
->disk
.pad
, 0xff, 442);
2714 for (i
= 0; i
< ddf
->max_part
; i
++)
2715 dd
->vlist
[i
] = NULL
;
2719 if (st
->update_tail
) {
2720 int len
= (sizeof(struct phys_disk
) +
2721 sizeof(struct phys_disk_entry
));
2722 struct phys_disk
*pd
;
2725 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2726 pd
->used_pdes
= cpu_to_be16(n
);
2727 pde
= &pd
->entries
[0];
2730 ddf
->phys
->used_pdes
= cpu_to_be16(
2731 1 + be16_to_cpu(ddf
->phys
->used_pdes
));
2733 memcpy(pde
->guid
, dd
->disk
.guid
, DDF_GUID_LEN
);
2734 pde
->refnum
= dd
->disk
.refnum
;
2735 pde
->type
= cpu_to_be16(DDF_Forced_PD_GUID
| DDF_Global_Spare
);
2736 pde
->state
= cpu_to_be16(DDF_Online
);
2739 * If there is already a device in dlist, try to reserve the same
2740 * amount of workspace. Otherwise, use 32MB.
2741 * We checked disk size above already.
2743 #define __calc_lba(new, old, lba, mb) do { \
2744 unsigned long long dif; \
2745 if ((old) != NULL) \
2746 dif = (old)->size - be64_to_cpu((old)->lba); \
2748 dif = (new)->size; \
2749 if ((new)->size > dif) \
2750 (new)->lba = cpu_to_be64((new)->size - dif); \
2752 (new)->lba = cpu_to_be64((new)->size - (mb*1024*2)); \
2754 __calc_lba(dd
, ddf
->dlist
, workspace_lba
, 32);
2755 __calc_lba(dd
, ddf
->dlist
, primary_lba
, 16);
2756 __calc_lba(dd
, ddf
->dlist
, secondary_lba
, 32);
2757 pde
->config_size
= dd
->workspace_lba
;
2759 sprintf(pde
->path
, "%17.17s","Information: nil") ;
2760 memset(pde
->pad
, 0xff, 6);
2762 if (st
->update_tail
) {
2763 dd
->next
= ddf
->add_list
;
2766 dd
->next
= ddf
->dlist
;
2768 ddf_set_updates_pending(ddf
);
2774 static int remove_from_super_ddf(struct supertype
*st
, mdu_disk_info_t
*dk
)
2776 struct ddf_super
*ddf
= st
->sb
;
2779 /* mdmon has noticed that this disk (dk->major/dk->minor) has
2780 * disappeared from the container.
2781 * We need to arrange that it disappears from the metadata and
2782 * internal data structures too.
2783 * Most of the work is done by ddf_process_update which edits
2784 * the metadata and closes the file handle and attaches the memory
2785 * where free_updates will free it.
2787 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2788 if (dl
->major
== dk
->major
&&
2789 dl
->minor
== dk
->minor
)
2794 if (st
->update_tail
) {
2795 int len
= (sizeof(struct phys_disk
) +
2796 sizeof(struct phys_disk_entry
));
2797 struct phys_disk
*pd
;
2800 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2801 pd
->used_pdes
= cpu_to_be16(dl
->pdnum
);
2802 pd
->entries
[0].state
= cpu_to_be16(DDF_Missing
);
2803 append_metadata_update(st
, pd
, len
);
2810 * This is the write_init_super method for a ddf container. It is
2811 * called when creating a container or adding another device to a
2814 #define NULL_CONF_SZ 4096
2816 static char *null_aligned
;
2817 static int __write_ddf_structure(struct dl
*d
, struct ddf_super
*ddf
, __u8 type
)
2819 unsigned long long sector
;
2820 struct ddf_header
*header
;
2821 int fd
, i
, n_config
, conf_size
;
2824 if (null_aligned
== NULL
) {
2825 if (posix_memalign((void **)&null_aligned
, 4096, NULL_CONF_SZ
)
2828 memset(null_aligned
, 0xff, NULL_CONF_SZ
);
2834 case DDF_HEADER_PRIMARY
:
2835 header
= &ddf
->primary
;
2836 sector
= be64_to_cpu(header
->primary_lba
);
2838 case DDF_HEADER_SECONDARY
:
2839 header
= &ddf
->secondary
;
2840 sector
= be64_to_cpu(header
->secondary_lba
);
2846 header
->type
= type
;
2847 header
->openflag
= 1;
2848 header
->crc
= calc_crc(header
, 512);
2850 lseek64(fd
, sector
<<9, 0);
2851 if (write(fd
, header
, 512) < 0)
2854 ddf
->controller
.crc
= calc_crc(&ddf
->controller
, 512);
2855 if (write(fd
, &ddf
->controller
, 512) < 0)
2858 ddf
->phys
->crc
= calc_crc(ddf
->phys
, ddf
->pdsize
);
2859 if (write(fd
, ddf
->phys
, ddf
->pdsize
) < 0)
2861 ddf
->virt
->crc
= calc_crc(ddf
->virt
, ddf
->vdsize
);
2862 if (write(fd
, ddf
->virt
, ddf
->vdsize
) < 0)
2865 /* Now write lots of config records. */
2866 n_config
= ddf
->max_part
;
2867 conf_size
= ddf
->conf_rec_len
* 512;
2868 for (i
= 0 ; i
<= n_config
; i
++) {
2870 struct vd_config
*vdc
= NULL
;
2871 if (i
== n_config
) {
2872 c
= (struct vcl
*)d
->spare
;
2879 get_pd_index_from_refnum(
2882 (const struct vd_config
**)&vdc
,
2886 dprintf("writing conf record %i on disk %08x for %s/%u\n",
2887 i
, be32_to_cpu(d
->disk
.refnum
),
2888 guid_str(vdc
->guid
),
2889 vdc
->sec_elmnt_seq
);
2890 vdc
->seqnum
= header
->seq
;
2891 vdc
->crc
= calc_crc(vdc
, conf_size
);
2892 if (write(fd
, vdc
, conf_size
) < 0)
2895 unsigned int togo
= conf_size
;
2896 while (togo
> NULL_CONF_SZ
) {
2897 if (write(fd
, null_aligned
, NULL_CONF_SZ
) < 0)
2899 togo
-= NULL_CONF_SZ
;
2901 if (write(fd
, null_aligned
, togo
) < 0)
2908 d
->disk
.crc
= calc_crc(&d
->disk
, 512);
2909 if (write(fd
, &d
->disk
, 512) < 0)
2914 header
->openflag
= 0;
2915 header
->crc
= calc_crc(header
, 512);
2917 lseek64(fd
, sector
<<9, 0);
2918 if (write(fd
, header
, 512) < 0)
2924 static int _write_super_to_disk(struct ddf_super
*ddf
, struct dl
*d
)
2926 unsigned long long size
;
2931 /* We need to fill in the primary, (secondary) and workspace
2932 * lba's in the headers, set their checksums,
2933 * Also checksum phys, virt....
2935 * Then write everything out, finally the anchor is written.
2937 get_dev_size(fd
, NULL
, &size
);
2939 if (be64_to_cpu(d
->workspace_lba
) != 0ULL)
2940 ddf
->anchor
.workspace_lba
= d
->workspace_lba
;
2942 ddf
->anchor
.workspace_lba
=
2943 cpu_to_be64(size
- 32*1024*2);
2944 if (be64_to_cpu(d
->primary_lba
) != 0ULL)
2945 ddf
->anchor
.primary_lba
= d
->primary_lba
;
2947 ddf
->anchor
.primary_lba
=
2948 cpu_to_be64(size
- 16*1024*2);
2949 if (be64_to_cpu(d
->secondary_lba
) != 0ULL)
2950 ddf
->anchor
.secondary_lba
= d
->secondary_lba
;
2952 ddf
->anchor
.secondary_lba
=
2953 cpu_to_be64(size
- 32*1024*2);
2954 ddf
->anchor
.seq
= ddf
->active
->seq
;
2955 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
2956 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
2958 ddf
->anchor
.openflag
= 0xFF; /* 'open' means nothing */
2959 ddf
->anchor
.seq
= cpu_to_be32(0xFFFFFFFF); /* no sequencing in anchor */
2960 ddf
->anchor
.crc
= calc_crc(&ddf
->anchor
, 512);
2962 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_PRIMARY
))
2965 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_SECONDARY
))
2968 lseek64(fd
, (size
-1)*512, SEEK_SET
);
2969 if (write(fd
, &ddf
->anchor
, 512) < 0)
2976 static int __write_init_super_ddf(struct supertype
*st
)
2978 struct ddf_super
*ddf
= st
->sb
;
2983 pr_state(ddf
, __func__
);
2985 /* try to write updated metadata,
2986 * if we catch a failure move on to the next disk
2988 for (d
= ddf
->dlist
; d
; d
=d
->next
) {
2990 successes
+= _write_super_to_disk(ddf
, d
);
2993 return attempts
!= successes
;
2996 static int write_init_super_ddf(struct supertype
*st
)
2998 struct ddf_super
*ddf
= st
->sb
;
2999 struct vcl
*currentconf
= ddf
->currentconf
;
3001 /* we are done with currentconf reset it to point st at the container */
3002 ddf
->currentconf
= NULL
;
3004 if (st
->update_tail
) {
3005 /* queue the virtual_disk and vd_config as metadata updates */
3006 struct virtual_disk
*vd
;
3007 struct vd_config
*vc
;
3012 int len
= (sizeof(struct phys_disk
) +
3013 sizeof(struct phys_disk_entry
));
3015 /* adding a disk to the container. */
3019 append_metadata_update(st
, ddf
->add_list
->mdupdate
, len
);
3020 ddf
->add_list
->mdupdate
= NULL
;
3024 /* Newly created VD */
3026 /* First the virtual disk. We have a slightly fake header */
3027 len
= sizeof(struct virtual_disk
) + sizeof(struct virtual_entry
);
3030 vd
->entries
[0] = ddf
->virt
->entries
[currentconf
->vcnum
];
3031 vd
->populated_vdes
= cpu_to_be16(currentconf
->vcnum
);
3032 append_metadata_update(st
, vd
, len
);
3034 /* Then the vd_config */
3035 len
= ddf
->conf_rec_len
* 512;
3036 tlen
= len
* currentconf
->conf
.sec_elmnt_count
;
3038 memcpy(vc
, ¤tconf
->conf
, len
);
3039 for (i
= 1; i
< currentconf
->conf
.sec_elmnt_count
; i
++)
3040 memcpy((char *)vc
+ i
*len
, currentconf
->other_bvds
[i
-1],
3042 append_metadata_update(st
, vc
, tlen
);
3044 /* FIXME I need to close the fds! */
3049 for (d
= ddf
->dlist
; d
; d
=d
->next
)
3050 while (Kill(d
->devname
, NULL
, 0, -1, 1) == 0);
3051 return __write_init_super_ddf(st
);
3057 static __u64
avail_size_ddf(struct supertype
*st
, __u64 devsize
,
3058 unsigned long long data_offset
)
3060 /* We must reserve the last 32Meg */
3061 if (devsize
<= 32*1024*2)
3063 return devsize
- 32*1024*2;
3068 static int reserve_space(struct supertype
*st
, int raiddisks
,
3069 unsigned long long size
, int chunk
,
3070 unsigned long long *freesize
)
3072 /* Find 'raiddisks' spare extents at least 'size' big (but
3073 * only caring about multiples of 'chunk') and remember
3075 * If the cannot be found, fail.
3078 struct ddf_super
*ddf
= st
->sb
;
3081 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3085 /* Now find largest extent on each device */
3086 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3087 struct extent
*e
= get_extents(ddf
, dl
);
3088 unsigned long long pos
= 0;
3091 unsigned long long minsize
= size
;
3099 unsigned long long esize
;
3100 esize
= e
[i
].start
- pos
;
3101 if (esize
>= minsize
) {
3105 pos
= e
[i
].start
+ e
[i
].size
;
3107 } while (e
[i
-1].size
);
3110 dl
->esize
= minsize
;
3114 if (cnt
< raiddisks
) {
3115 pr_err("not enough devices with space to create array.\n");
3116 return 0; /* No enough free spaces large enough */
3119 /* choose the largest size of which there are at least 'raiddisk' */
3120 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3122 if (dl
->esize
<= size
)
3124 /* This is bigger than 'size', see if there are enough */
3126 for (dl2
= ddf
->dlist
; dl2
; dl2
=dl2
->next
)
3127 if (dl2
->esize
>= dl
->esize
)
3129 if (cnt
>= raiddisks
)
3133 size
= size
/ chunk
;
3138 pr_err("not enough spare devices to create array.\n");
3142 /* We have a 'size' of which there are enough spaces.
3143 * We simply do a first-fit */
3145 for (dl
= ddf
->dlist
; dl
&& cnt
< raiddisks
; dl
=dl
->next
) {
3146 if (dl
->esize
< size
)
3156 validate_geometry_ddf_container(struct supertype
*st
,
3157 int level
, int layout
, int raiddisks
,
3158 int chunk
, unsigned long long size
,
3159 unsigned long long data_offset
,
3160 char *dev
, unsigned long long *freesize
,
3163 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3164 int level
, int layout
, int raiddisks
,
3165 int *chunk
, unsigned long long size
,
3166 unsigned long long data_offset
,
3167 char *dev
, unsigned long long *freesize
,
3170 static int validate_geometry_ddf(struct supertype
*st
,
3171 int level
, int layout
, int raiddisks
,
3172 int *chunk
, unsigned long long size
,
3173 unsigned long long data_offset
,
3174 char *dev
, unsigned long long *freesize
,
3181 /* ddf potentially supports lots of things, but it depends on
3182 * what devices are offered (and maybe kernel version?)
3183 * If given unused devices, we will make a container.
3184 * If given devices in a container, we will make a BVD.
3185 * If given BVDs, we make an SVD, changing all the GUIDs in the process.
3188 if (chunk
&& *chunk
== UnSet
)
3189 *chunk
= DEFAULT_CHUNK
;
3191 if (level
== -1000000) level
= LEVEL_CONTAINER
;
3192 if (level
== LEVEL_CONTAINER
) {
3193 /* Must be a fresh device to add to a container */
3194 return validate_geometry_ddf_container(st
, level
, layout
,
3195 raiddisks
, chunk
?*chunk
:0,
3196 size
, data_offset
, dev
,
3202 mdu_array_info_t array
= {
3203 .level
= level
, .layout
= layout
,
3204 .raid_disks
= raiddisks
3206 struct vd_config conf
;
3207 if (layout_md2ddf(&array
, &conf
) == -1) {
3209 pr_err("DDF does not support level %d /layout %d arrays with %d disks\n",
3210 level
, layout
, raiddisks
);
3213 /* Should check layout? etc */
3215 if (st
->sb
&& freesize
) {
3216 /* --create was given a container to create in.
3217 * So we need to check that there are enough
3218 * free spaces and return the amount of space.
3219 * We may as well remember which drives were
3220 * chosen so that add_to_super/getinfo_super
3223 return reserve_space(st
, raiddisks
, size
, chunk
?*chunk
:0, freesize
);
3229 /* A container has already been opened, so we are
3230 * creating in there. Maybe a BVD, maybe an SVD.
3231 * Should make a distinction one day.
3233 return validate_geometry_ddf_bvd(st
, level
, layout
, raiddisks
,
3234 chunk
, size
, data_offset
, dev
,
3238 /* This is the first device for the array.
3239 * If it is a container, we read it in and do automagic allocations,
3240 * no other devices should be given.
3241 * Otherwise it must be a member device of a container, and we
3242 * do manual allocation.
3243 * Later we should check for a BVD and make an SVD.
3245 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3247 sra
= sysfs_read(fd
, NULL
, GET_VERSION
);
3249 if (sra
&& sra
->array
.major_version
== -1 &&
3250 strcmp(sra
->text_version
, "ddf") == 0) {
3253 /* find space for 'n' devices. */
3254 /* remember the devices */
3255 /* Somehow return the fact that we have enough */
3259 pr_err("ddf: Cannot create this array "
3260 "on device %s - a container is required.\n",
3264 if (errno
!= EBUSY
|| (fd
= open(dev
, O_RDONLY
, 0)) < 0) {
3266 pr_err("ddf: Cannot open %s: %s\n",
3267 dev
, strerror(errno
));
3270 /* Well, it is in use by someone, maybe a 'ddf' container. */
3271 cfd
= open_container(fd
);
3275 pr_err("ddf: Cannot use %s: %s\n",
3276 dev
, strerror(EBUSY
));
3279 sra
= sysfs_read(cfd
, NULL
, GET_VERSION
);
3281 if (sra
&& sra
->array
.major_version
== -1 &&
3282 strcmp(sra
->text_version
, "ddf") == 0) {
3283 /* This is a member of a ddf container. Load the container
3284 * and try to create a bvd
3286 struct ddf_super
*ddf
;
3287 if (load_super_ddf_all(st
, cfd
, (void **)&ddf
, NULL
) == 0) {
3289 strcpy(st
->container_devnm
, fd2devnm(cfd
));
3291 return validate_geometry_ddf_bvd(st
, level
, layout
,
3292 raiddisks
, chunk
, size
,
3298 } else /* device may belong to a different container */
3305 validate_geometry_ddf_container(struct supertype
*st
,
3306 int level
, int layout
, int raiddisks
,
3307 int chunk
, unsigned long long size
,
3308 unsigned long long data_offset
,
3309 char *dev
, unsigned long long *freesize
,
3313 unsigned long long ldsize
;
3315 if (level
!= LEVEL_CONTAINER
)
3320 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3323 pr_err("ddf: Cannot open %s: %s\n",
3324 dev
, strerror(errno
));
3327 if (!get_dev_size(fd
, dev
, &ldsize
)) {
3333 *freesize
= avail_size_ddf(st
, ldsize
>> 9, INVALID_SECTORS
);
3340 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3341 int level
, int layout
, int raiddisks
,
3342 int *chunk
, unsigned long long size
,
3343 unsigned long long data_offset
,
3344 char *dev
, unsigned long long *freesize
,
3348 struct ddf_super
*ddf
= st
->sb
;
3350 unsigned long long pos
= 0;
3351 unsigned long long maxsize
;
3354 /* ddf/bvd supports lots of things, but not containers */
3355 if (level
== LEVEL_CONTAINER
) {
3357 pr_err("DDF cannot create a container within an container\n");
3360 /* We must have the container info already read in. */
3365 /* General test: make sure there is space for
3366 * 'raiddisks' device extents of size 'size'.
3368 unsigned long long minsize
= size
;
3372 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3378 e
= get_extents(ddf
, dl
);
3381 unsigned long long esize
;
3382 esize
= e
[i
].start
- pos
;
3383 if (esize
>= minsize
)
3385 pos
= e
[i
].start
+ e
[i
].size
;
3387 } while (e
[i
-1].size
);
3392 if (dcnt
< raiddisks
) {
3394 pr_err("ddf: Not enough devices with "
3395 "space for this array (%d < %d)\n",
3401 /* This device must be a member of the set */
3402 if (stat(dev
, &stb
) < 0)
3404 if ((S_IFMT
& stb
.st_mode
) != S_IFBLK
)
3406 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
3407 if (dl
->major
== (int)major(stb
.st_rdev
) &&
3408 dl
->minor
== (int)minor(stb
.st_rdev
))
3413 pr_err("ddf: %s is not in the "
3418 e
= get_extents(ddf
, dl
);
3422 unsigned long long esize
;
3423 esize
= e
[i
].start
- pos
;
3424 if (esize
>= maxsize
)
3426 pos
= e
[i
].start
+ e
[i
].size
;
3428 } while (e
[i
-1].size
);
3429 *freesize
= maxsize
;
3435 static int load_super_ddf_all(struct supertype
*st
, int fd
,
3436 void **sbp
, char *devname
)
3439 struct ddf_super
*super
;
3440 struct mdinfo
*sd
, *best
= NULL
;
3446 sra
= sysfs_read(fd
, 0, GET_LEVEL
|GET_VERSION
|GET_DEVS
|GET_STATE
);
3449 if (sra
->array
.major_version
!= -1 ||
3450 sra
->array
.minor_version
!= -2 ||
3451 strcmp(sra
->text_version
, "ddf") != 0)
3454 if (posix_memalign((void**)&super
, 512, sizeof(*super
)) != 0)
3456 memset(super
, 0, sizeof(*super
));
3458 /* first, try each device, and choose the best ddf */
3459 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3461 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3462 dfd
= dev_open(nm
, O_RDONLY
);
3465 rv
= load_ddf_headers(dfd
, super
, NULL
);
3468 seq
= be32_to_cpu(super
->active
->seq
);
3469 if (super
->active
->openflag
)
3471 if (!best
|| seq
> bestseq
) {
3479 /* OK, load this ddf */
3480 sprintf(nm
, "%d:%d", best
->disk
.major
, best
->disk
.minor
);
3481 dfd
= dev_open(nm
, O_RDONLY
);
3484 load_ddf_headers(dfd
, super
, NULL
);
3485 load_ddf_global(dfd
, super
, NULL
);
3487 /* Now we need the device-local bits */
3488 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3491 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3492 dfd
= dev_open(nm
, O_RDWR
);
3495 rv
= load_ddf_headers(dfd
, super
, NULL
);
3497 rv
= load_ddf_local(dfd
, super
, NULL
, 1);
3503 if (st
->ss
== NULL
) {
3504 st
->ss
= &super_ddf
;
3505 st
->minor_version
= 0;
3508 strcpy(st
->container_devnm
, fd2devnm(fd
));
3512 static int load_container_ddf(struct supertype
*st
, int fd
,
3515 return load_super_ddf_all(st
, fd
, &st
->sb
, devname
);
3518 #endif /* MDASSEMBLE */
3520 static int check_secondary(const struct vcl
*vc
)
3522 const struct vd_config
*conf
= &vc
->conf
;
3525 /* The only DDF secondary RAID level md can support is
3526 * RAID 10, if the stripe sizes and Basic volume sizes
3528 * Other configurations could in theory be supported by exposing
3529 * the BVDs to user space and using device mapper for the secondary
3530 * mapping. So far we don't support that.
3533 __u64 sec_elements
[4] = {0, 0, 0, 0};
3534 #define __set_sec_seen(n) (sec_elements[(n)>>6] |= (1<<((n)&63)))
3535 #define __was_sec_seen(n) ((sec_elements[(n)>>6] & (1<<((n)&63))) != 0)
3537 if (vc
->other_bvds
== NULL
) {
3538 pr_err("No BVDs for secondary RAID found\n");
3541 if (conf
->prl
!= DDF_RAID1
) {
3542 pr_err("Secondary RAID level only supported for mirrored BVD\n");
3545 if (conf
->srl
!= DDF_2STRIPED
&& conf
->srl
!= DDF_2SPANNED
) {
3546 pr_err("Secondary RAID level %d is unsupported\n",
3550 __set_sec_seen(conf
->sec_elmnt_seq
);
3551 for (i
= 0; i
< conf
->sec_elmnt_count
-1; i
++) {
3552 const struct vd_config
*bvd
= vc
->other_bvds
[i
];
3553 if (bvd
->sec_elmnt_seq
== DDF_UNUSED_BVD
)
3555 if (bvd
->srl
!= conf
->srl
) {
3556 pr_err("Inconsistent secondary RAID level across BVDs\n");
3559 if (bvd
->prl
!= conf
->prl
) {
3560 pr_err("Different RAID levels for BVDs are unsupported\n");
3563 if (!be16_eq(bvd
->prim_elmnt_count
, conf
->prim_elmnt_count
)) {
3564 pr_err("All BVDs must have the same number of primary elements\n");
3567 if (bvd
->chunk_shift
!= conf
->chunk_shift
) {
3568 pr_err("Different strip sizes for BVDs are unsupported\n");
3571 if (!be64_eq(bvd
->array_blocks
, conf
->array_blocks
)) {
3572 pr_err("Different BVD sizes are unsupported\n");
3575 __set_sec_seen(bvd
->sec_elmnt_seq
);
3577 for (i
= 0; i
< conf
->sec_elmnt_count
; i
++) {
3578 if (!__was_sec_seen(i
)) {
3579 pr_err("BVD %d is missing\n", i
);
3586 static unsigned int get_pd_index_from_refnum(const struct vcl
*vc
,
3587 be32 refnum
, unsigned int nmax
,
3588 const struct vd_config
**bvd
,
3591 unsigned int i
, j
, n
, sec
, cnt
;
3593 cnt
= be16_to_cpu(vc
->conf
.prim_elmnt_count
);
3594 sec
= (vc
->conf
.sec_elmnt_count
== 1 ? 0 : vc
->conf
.sec_elmnt_seq
);
3596 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3597 /* j counts valid entries for this BVD */
3598 if (be32_to_cpu(vc
->conf
.phys_refnum
[i
]) != 0xffffffff)
3600 if (be32_eq(vc
->conf
.phys_refnum
[i
], refnum
)) {
3603 return sec
* cnt
+ j
- 1;
3606 if (vc
->other_bvds
== NULL
)
3609 for (n
= 1; n
< vc
->conf
.sec_elmnt_count
; n
++) {
3610 struct vd_config
*vd
= vc
->other_bvds
[n
-1];
3611 sec
= vd
->sec_elmnt_seq
;
3612 if (sec
== DDF_UNUSED_BVD
)
3614 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3615 if (be32_to_cpu(vd
->phys_refnum
[i
]) != 0xffffffff)
3617 if (be32_eq(vd
->phys_refnum
[i
], refnum
)) {
3620 return sec
* cnt
+ j
- 1;
3626 return DDF_NOTFOUND
;
3629 static struct mdinfo
*container_content_ddf(struct supertype
*st
, char *subarray
)
3631 /* Given a container loaded by load_super_ddf_all,
3632 * extract information about all the arrays into
3635 * For each vcl in conflist: create an mdinfo, fill it in,
3636 * then look for matching devices (phys_refnum) in dlist
3637 * and create appropriate device mdinfo.
3639 struct ddf_super
*ddf
= st
->sb
;
3640 struct mdinfo
*rest
= NULL
;
3643 for (vc
= ddf
->conflist
; vc
; vc
=vc
->next
)
3647 struct mdinfo
*this;
3653 (strtoul(subarray
, &ep
, 10) != vc
->vcnum
||
3657 if (vc
->conf
.sec_elmnt_count
> 1) {
3658 if (check_secondary(vc
) != 0)
3662 this = xcalloc(1, sizeof(*this));
3666 if (layout_ddf2md(&vc
->conf
, &this->array
))
3668 this->array
.md_minor
= -1;
3669 this->array
.major_version
= -1;
3670 this->array
.minor_version
= -2;
3671 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
3672 this->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
3673 this->array
.utime
= DECADE
+
3674 be32_to_cpu(vc
->conf
.timestamp
);
3675 this->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
3678 if ((ddf
->virt
->entries
[i
].state
& DDF_state_inconsistent
) ||
3679 (ddf
->virt
->entries
[i
].init_state
& DDF_initstate_mask
) !=
3681 this->array
.state
= 0;
3682 this->resync_start
= 0;
3684 this->array
.state
= 1;
3685 this->resync_start
= MaxSector
;
3687 memcpy(this->name
, ddf
->virt
->entries
[i
].name
, 16);
3690 if (this->name
[j
] == ' ')
3693 memset(this->uuid
, 0, sizeof(this->uuid
));
3694 this->component_size
= be64_to_cpu(vc
->conf
.blocks
);
3695 this->array
.size
= this->component_size
/ 2;
3696 this->container_member
= i
;
3698 ddf
->currentconf
= vc
;
3699 uuid_from_super_ddf(st
, this->uuid
);
3701 ddf
->currentconf
= NULL
;
3703 sprintf(this->text_version
, "/%s/%d",
3704 st
->container_devnm
, this->container_member
);
3706 for (pd
= 0; pd
< be16_to_cpu(ddf
->phys
->used_pdes
); pd
++) {
3709 const struct vd_config
*bvd
;
3713 if (be32_to_cpu(ddf
->phys
->entries
[pd
].refnum
)
3717 stt
= be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
3718 if ((stt
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
3722 i
= get_pd_index_from_refnum(
3723 vc
, ddf
->phys
->entries
[pd
].refnum
,
3724 ddf
->mppe
, &bvd
, &iphys
);
3725 if (i
== DDF_NOTFOUND
)
3728 this->array
.working_disks
++;
3730 for (d
= ddf
->dlist
; d
; d
=d
->next
)
3731 if (be32_eq(d
->disk
.refnum
,
3732 ddf
->phys
->entries
[pd
].refnum
))
3735 /* Haven't found that one yet, maybe there are others */
3738 dev
= xcalloc(1, sizeof(*dev
));
3739 dev
->next
= this->devs
;
3742 dev
->disk
.number
= be32_to_cpu(d
->disk
.refnum
);
3743 dev
->disk
.major
= d
->major
;
3744 dev
->disk
.minor
= d
->minor
;
3745 dev
->disk
.raid_disk
= i
;
3746 dev
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
3747 dev
->recovery_start
= MaxSector
;
3749 dev
->events
= be32_to_cpu(ddf
->primary
.seq
);
3751 be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[iphys
]);
3752 dev
->component_size
= be64_to_cpu(bvd
->blocks
);
3754 strcpy(dev
->name
, d
->devname
);
3760 static int store_super_ddf(struct supertype
*st
, int fd
)
3762 struct ddf_super
*ddf
= st
->sb
;
3763 unsigned long long dsize
;
3770 if (!get_dev_size(fd
, NULL
, &dsize
))
3773 if (ddf
->dlist
|| ddf
->conflist
) {
3778 if (fstat(fd
, &sta
) == -1 || !S_ISBLK(sta
.st_mode
)) {
3779 pr_err("%s: file descriptor for invalid device\n",
3783 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3784 if (dl
->major
== (int)major(sta
.st_rdev
) &&
3785 dl
->minor
== (int)minor(sta
.st_rdev
))
3788 pr_err("%s: couldn't find disk %d/%d\n", __func__
,
3789 (int)major(sta
.st_rdev
),
3790 (int)minor(sta
.st_rdev
));
3795 ret
= (_write_super_to_disk(ddf
, dl
) != 1);
3800 if (posix_memalign(&buf
, 512, 512) != 0)
3802 memset(buf
, 0, 512);
3804 lseek64(fd
, dsize
-512, 0);
3805 rc
= write(fd
, buf
, 512);
3812 static int compare_super_ddf(struct supertype
*st
, struct supertype
*tst
)
3816 * 0 same, or first was empty, and second was copied
3817 * 1 second had wrong number
3819 * 3 wrong other info
3821 struct ddf_super
*first
= st
->sb
;
3822 struct ddf_super
*second
= tst
->sb
;
3823 struct dl
*dl1
, *dl2
;
3824 struct vcl
*vl1
, *vl2
;
3825 unsigned int max_vds
, max_pds
, pd
, vd
;
3833 if (memcmp(first
->anchor
.guid
, second
->anchor
.guid
, DDF_GUID_LEN
) != 0)
3836 if (!be32_eq(first
->anchor
.seq
, second
->anchor
.seq
)) {
3837 dprintf("%s: sequence number mismatch %u/%u\n", __func__
,
3838 be32_to_cpu(first
->anchor
.seq
),
3839 be32_to_cpu(second
->anchor
.seq
));
3842 if (first
->max_part
!= second
->max_part
||
3843 !be16_eq(first
->phys
->used_pdes
, second
->phys
->used_pdes
) ||
3844 !be16_eq(first
->virt
->populated_vdes
,
3845 second
->virt
->populated_vdes
)) {
3846 dprintf("%s: PD/VD number mismatch\n", __func__
);
3850 max_pds
= be16_to_cpu(first
->phys
->used_pdes
);
3851 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
3852 for (pd
= 0; pd
< max_pds
; pd
++)
3853 if (be32_eq(first
->phys
->entries
[pd
].refnum
,
3856 if (pd
== max_pds
) {
3857 dprintf("%s: no match for disk %08x\n", __func__
,
3858 be32_to_cpu(dl2
->disk
.refnum
));
3863 max_vds
= be16_to_cpu(first
->active
->max_vd_entries
);
3864 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3865 if (!be32_eq(vl2
->conf
.magic
, DDF_VD_CONF_MAGIC
))
3867 for (vd
= 0; vd
< max_vds
; vd
++)
3868 if (!memcmp(first
->virt
->entries
[vd
].guid
,
3869 vl2
->conf
.guid
, DDF_GUID_LEN
))
3871 if (vd
== max_vds
) {
3872 dprintf("%s: no match for VD config\n", __func__
);
3876 /* FIXME should I look at anything else? */
3879 At this point we are fairly sure that the meta data matches.
3880 But the new disk may contain additional local data.
3881 Add it to the super block.
3883 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3884 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
)
3885 if (!memcmp(vl1
->conf
.guid
, vl2
->conf
.guid
,
3889 if (vl1
->other_bvds
!= NULL
&&
3890 vl1
->conf
.sec_elmnt_seq
!=
3891 vl2
->conf
.sec_elmnt_seq
) {
3892 dprintf("%s: adding BVD %u\n", __func__
,
3893 vl2
->conf
.sec_elmnt_seq
);
3894 add_other_bvd(vl1
, &vl2
->conf
,
3895 first
->conf_rec_len
*512);
3900 if (posix_memalign((void **)&vl1
, 512,
3901 (first
->conf_rec_len
*512 +
3902 offsetof(struct vcl
, conf
))) != 0) {
3903 pr_err("%s could not allocate vcl buf\n",
3908 vl1
->next
= first
->conflist
;
3909 vl1
->block_sizes
= NULL
;
3910 memcpy(&vl1
->conf
, &vl2
->conf
, first
->conf_rec_len
*512);
3911 if (alloc_other_bvds(first
, vl1
) != 0) {
3912 pr_err("%s could not allocate other bvds\n",
3917 for (vd
= 0; vd
< max_vds
; vd
++)
3918 if (!memcmp(first
->virt
->entries
[vd
].guid
,
3919 vl1
->conf
.guid
, DDF_GUID_LEN
))
3922 dprintf("%s: added config for VD %u\n", __func__
, vl1
->vcnum
);
3923 first
->conflist
= vl1
;
3926 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
3927 for (dl1
= first
->dlist
; dl1
; dl1
= dl1
->next
)
3928 if (be32_eq(dl1
->disk
.refnum
, dl2
->disk
.refnum
))
3933 if (posix_memalign((void **)&dl1
, 512,
3934 sizeof(*dl1
) + (first
->max_part
) * sizeof(dl1
->vlist
[0]))
3936 pr_err("%s could not allocate disk info buffer\n",
3940 memcpy(dl1
, dl2
, sizeof(*dl1
));
3941 dl1
->mdupdate
= NULL
;
3942 dl1
->next
= first
->dlist
;
3944 for (pd
= 0; pd
< max_pds
; pd
++)
3945 if (be32_eq(first
->phys
->entries
[pd
].refnum
,
3950 if (posix_memalign((void **)&dl1
->spare
, 512,
3951 first
->conf_rec_len
*512) != 0) {
3952 pr_err("%s could not allocate spare info buf\n",
3956 memcpy(dl1
->spare
, dl2
->spare
, first
->conf_rec_len
*512);
3958 for (vd
= 0 ; vd
< first
->max_part
; vd
++) {
3959 if (!dl2
->vlist
[vd
]) {
3960 dl1
->vlist
[vd
] = NULL
;
3963 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
) {
3964 if (!memcmp(vl1
->conf
.guid
,
3965 dl2
->vlist
[vd
]->conf
.guid
,
3968 dl1
->vlist
[vd
] = vl1
;
3972 dprintf("%s: added disk %d: %08x\n", __func__
, dl1
->pdnum
,
3973 be32_to_cpu(dl1
->disk
.refnum
));
3981 * A new array 'a' has been started which claims to be instance 'inst'
3982 * within container 'c'.
3983 * We need to confirm that the array matches the metadata in 'c' so
3984 * that we don't corrupt any metadata.
3986 static int ddf_open_new(struct supertype
*c
, struct active_array
*a
, char *inst
)
3988 struct ddf_super
*ddf
= c
->sb
;
3990 if (all_ff(ddf
->virt
->entries
[n
].guid
)) {
3991 pr_err("%s: subarray %d doesn't exist\n", __func__
, n
);
3994 dprintf("ddf: open_new %d\n", n
);
3995 a
->info
.container_member
= n
;
4000 * The array 'a' is to be marked clean in the metadata.
4001 * If '->resync_start' is not ~(unsigned long long)0, then the array is only
4002 * clean up to the point (in sectors). If that cannot be recorded in the
4003 * metadata, then leave it as dirty.
4005 * For DDF, we need to clear the DDF_state_inconsistent bit in the
4006 * !global! virtual_disk.virtual_entry structure.
4008 static int ddf_set_array_state(struct active_array
*a
, int consistent
)
4010 struct ddf_super
*ddf
= a
->container
->sb
;
4011 int inst
= a
->info
.container_member
;
4012 int old
= ddf
->virt
->entries
[inst
].state
;
4013 if (consistent
== 2) {
4014 /* Should check if a recovery should be started FIXME */
4016 if (!is_resync_complete(&a
->info
))
4020 ddf
->virt
->entries
[inst
].state
&= ~DDF_state_inconsistent
;
4022 ddf
->virt
->entries
[inst
].state
|= DDF_state_inconsistent
;
4023 if (old
!= ddf
->virt
->entries
[inst
].state
)
4024 ddf_set_updates_pending(ddf
);
4026 old
= ddf
->virt
->entries
[inst
].init_state
;
4027 ddf
->virt
->entries
[inst
].init_state
&= ~DDF_initstate_mask
;
4028 if (is_resync_complete(&a
->info
))
4029 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_full
;
4030 else if (a
->info
.resync_start
== 0)
4031 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_not
;
4033 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_quick
;
4034 if (old
!= ddf
->virt
->entries
[inst
].init_state
)
4035 ddf_set_updates_pending(ddf
);
4037 dprintf("ddf mark %d/%s (%d) %s %llu\n", inst
,
4038 guid_str(ddf
->virt
->entries
[inst
].guid
), a
->curr_state
,
4039 consistent
?"clean":"dirty",
4040 a
->info
.resync_start
);
4044 static int get_bvd_state(const struct ddf_super
*ddf
,
4045 const struct vd_config
*vc
)
4047 unsigned int i
, n_bvd
, working
= 0;
4048 unsigned int n_prim
= be16_to_cpu(vc
->prim_elmnt_count
);
4050 for (i
= 0; i
< n_prim
; i
++) {
4051 if (!find_index_in_bvd(ddf
, vc
, i
, &n_bvd
))
4053 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
4056 st
= be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
4057 if ((st
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
4062 state
= DDF_state_degraded
;
4063 if (working
== n_prim
)
4064 state
= DDF_state_optimal
;
4070 state
= DDF_state_failed
;
4074 state
= DDF_state_failed
;
4075 else if (working
>= 2)
4076 state
= DDF_state_part_optimal
;
4080 if (working
< n_prim
- 1)
4081 state
= DDF_state_failed
;
4084 if (working
< n_prim
- 2)
4085 state
= DDF_state_failed
;
4086 else if (working
== n_prim
- 1)
4087 state
= DDF_state_part_optimal
;
4093 static int secondary_state(int state
, int other
, int seclevel
)
4095 if (state
== DDF_state_optimal
&& other
== DDF_state_optimal
)
4096 return DDF_state_optimal
;
4097 if (seclevel
== DDF_2MIRRORED
) {
4098 if (state
== DDF_state_optimal
|| other
== DDF_state_optimal
)
4099 return DDF_state_part_optimal
;
4100 if (state
== DDF_state_failed
&& other
== DDF_state_failed
)
4101 return DDF_state_failed
;
4102 return DDF_state_degraded
;
4104 if (state
== DDF_state_failed
|| other
== DDF_state_failed
)
4105 return DDF_state_failed
;
4106 if (state
== DDF_state_degraded
|| other
== DDF_state_degraded
)
4107 return DDF_state_degraded
;
4108 return DDF_state_part_optimal
;
4112 static int get_svd_state(const struct ddf_super
*ddf
, const struct vcl
*vcl
)
4114 int state
= get_bvd_state(ddf
, &vcl
->conf
);
4116 for (i
= 1; i
< vcl
->conf
.sec_elmnt_count
; i
++) {
4117 state
= secondary_state(
4119 get_bvd_state(ddf
, vcl
->other_bvds
[i
-1]),
4126 * The state of each disk is stored in the global phys_disk structure
4127 * in phys_disk.entries[n].state.
4128 * This makes various combinations awkward.
4129 * - When a device fails in any array, it must be failed in all arrays
4130 * that include a part of this device.
4131 * - When a component is rebuilding, we cannot include it officially in the
4132 * array unless this is the only array that uses the device.
4134 * So: when transitioning:
4135 * Online -> failed, just set failed flag. monitor will propagate
4136 * spare -> online, the device might need to be added to the array.
4137 * spare -> failed, just set failed. Don't worry if in array or not.
4139 static void ddf_set_disk(struct active_array
*a
, int n
, int state
)
4141 struct ddf_super
*ddf
= a
->container
->sb
;
4142 unsigned int inst
= a
->info
.container_member
, n_bvd
;
4144 struct vd_config
*vc
= find_vdcr(ddf
, inst
, (unsigned int)n
,
4151 dprintf("ddf: cannot find instance %d!!\n", inst
);
4154 /* Find the matching slot in 'info'. */
4155 for (mdi
= a
->info
.devs
; mdi
; mdi
= mdi
->next
)
4156 if (mdi
->disk
.raid_disk
== n
)
4161 /* and find the 'dl' entry corresponding to that. */
4162 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4163 if (mdi
->state_fd
>= 0 &&
4164 mdi
->disk
.major
== dl
->major
&&
4165 mdi
->disk
.minor
== dl
->minor
)
4170 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
4171 if (pd
< 0 || pd
!= dl
->pdnum
) {
4172 /* disk doesn't currently exist or has changed.
4173 * If it is now in_sync, insert it. */
4174 dprintf("%s: phys disk not found for %d: %d/%d ref %08x\n",
4175 __func__
, dl
->pdnum
, dl
->major
, dl
->minor
,
4176 be32_to_cpu(dl
->disk
.refnum
));
4177 dprintf("%s: array %u disk %u ref %08x pd %d\n",
4178 __func__
, inst
, n_bvd
,
4179 be32_to_cpu(vc
->phys_refnum
[n_bvd
]), pd
);
4180 if ((state
& DS_INSYNC
) && ! (state
& DS_FAULTY
)) {
4181 pd
= dl
->pdnum
; /* FIXME: is this really correct ? */
4182 vc
->phys_refnum
[n_bvd
] = dl
->disk
.refnum
;
4183 LBA_OFFSET(ddf
, vc
)[n_bvd
] =
4184 cpu_to_be64(mdi
->data_offset
);
4185 be16_clear(ddf
->phys
->entries
[pd
].type
,
4186 cpu_to_be16(DDF_Global_Spare
));
4187 be16_set(ddf
->phys
->entries
[pd
].type
,
4188 cpu_to_be16(DDF_Active_in_VD
));
4189 ddf_set_updates_pending(ddf
);
4192 be16 old
= ddf
->phys
->entries
[pd
].state
;
4193 if (state
& DS_FAULTY
)
4194 be16_set(ddf
->phys
->entries
[pd
].state
,
4195 cpu_to_be16(DDF_Failed
));
4196 if (state
& DS_INSYNC
) {
4197 be16_set(ddf
->phys
->entries
[pd
].state
,
4198 cpu_to_be16(DDF_Online
));
4199 be16_clear(ddf
->phys
->entries
[pd
].state
,
4200 cpu_to_be16(DDF_Rebuilding
));
4202 if (!be16_eq(old
, ddf
->phys
->entries
[pd
].state
))
4203 ddf_set_updates_pending(ddf
);
4206 dprintf("ddf: set_disk %d to %x\n", n
, state
);
4208 /* Now we need to check the state of the array and update
4209 * virtual_disk.entries[n].state.
4210 * It needs to be one of "optimal", "degraded", "failed".
4211 * I don't understand 'deleted' or 'missing'.
4213 state
= get_svd_state(ddf
, vcl
);
4215 if (ddf
->virt
->entries
[inst
].state
!=
4216 ((ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4219 ddf
->virt
->entries
[inst
].state
=
4220 (ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4222 ddf_set_updates_pending(ddf
);
4227 static void ddf_sync_metadata(struct supertype
*st
)
4231 * Write all data to all devices.
4232 * Later, we might be able to track whether only local changes
4233 * have been made, or whether any global data has been changed,
4234 * but ddf is sufficiently weird that it probably always
4235 * changes global data ....
4237 struct ddf_super
*ddf
= st
->sb
;
4238 if (!ddf
->updates_pending
)
4240 ddf
->updates_pending
= 0;
4241 __write_init_super_ddf(st
);
4242 dprintf("ddf: sync_metadata\n");
4245 static int del_from_conflist(struct vcl
**list
, const char *guid
)
4249 for (p
= list
; p
&& *p
; p
= &((*p
)->next
))
4250 if (!memcmp((*p
)->conf
.guid
, guid
, DDF_GUID_LEN
)) {
4257 static int _kill_subarray_ddf(struct ddf_super
*ddf
, const char *guid
)
4260 unsigned int vdnum
, i
;
4261 vdnum
= find_vde_by_guid(ddf
, guid
);
4262 if (vdnum
== DDF_NOTFOUND
) {
4263 pr_err("%s: could not find VD %s\n", __func__
,
4267 if (del_from_conflist(&ddf
->conflist
, guid
) == 0) {
4268 pr_err("%s: could not find conf %s\n", __func__
,
4272 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4273 for (i
= 0; i
< ddf
->max_part
; i
++)
4274 if (dl
->vlist
[i
] != NULL
&&
4275 !memcmp(dl
->vlist
[i
]->conf
.guid
, guid
,
4277 dl
->vlist
[i
] = NULL
;
4278 memset(ddf
->virt
->entries
[vdnum
].guid
, 0xff, DDF_GUID_LEN
);
4279 dprintf("%s: deleted %s\n", __func__
, guid_str(guid
));
4283 static int kill_subarray_ddf(struct supertype
*st
)
4285 struct ddf_super
*ddf
= st
->sb
;
4287 * currentconf is set in container_content_ddf,
4288 * called with subarray arg
4290 struct vcl
*victim
= ddf
->currentconf
;
4291 struct vd_config
*conf
;
4292 ddf
->currentconf
= NULL
;
4295 pr_err("%s: nothing to kill\n", __func__
);
4298 conf
= &victim
->conf
;
4299 vdnum
= find_vde_by_guid(ddf
, conf
->guid
);
4300 if (vdnum
== DDF_NOTFOUND
) {
4301 pr_err("%s: could not find VD %s\n", __func__
,
4302 guid_str(conf
->guid
));
4305 if (st
->update_tail
) {
4306 struct virtual_disk
*vd
;
4307 int len
= sizeof(struct virtual_disk
)
4308 + sizeof(struct virtual_entry
);
4311 pr_err("%s: failed to allocate %d bytes\n", __func__
,
4315 memset(vd
, 0 , len
);
4316 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
4317 vd
->populated_vdes
= cpu_to_be16(0);
4318 memcpy(vd
->entries
[0].guid
, conf
->guid
, DDF_GUID_LEN
);
4319 /* we use DDF_state_deleted as marker */
4320 vd
->entries
[0].state
= DDF_state_deleted
;
4321 append_metadata_update(st
, vd
, len
);
4323 _kill_subarray_ddf(ddf
, conf
->guid
);
4324 ddf_set_updates_pending(ddf
);
4325 ddf_sync_metadata(st
);
4330 static void copy_matching_bvd(struct ddf_super
*ddf
,
4331 struct vd_config
*conf
,
4332 const struct metadata_update
*update
)
4335 be16_to_cpu(ddf
->anchor
.max_primary_element_entries
);
4336 unsigned int len
= ddf
->conf_rec_len
* 512;
4338 struct vd_config
*vc
;
4339 for (p
= update
->buf
; p
< update
->buf
+ update
->len
; p
+= len
) {
4340 vc
= (struct vd_config
*) p
;
4341 if (vc
->sec_elmnt_seq
== conf
->sec_elmnt_seq
) {
4342 memcpy(conf
->phys_refnum
, vc
->phys_refnum
,
4343 mppe
* (sizeof(__u32
) + sizeof(__u64
)));
4347 pr_err("%s: no match for BVD %d of %s in update\n", __func__
,
4348 conf
->sec_elmnt_seq
, guid_str(conf
->guid
));
4351 static void ddf_process_update(struct supertype
*st
,
4352 struct metadata_update
*update
)
4354 /* Apply this update to the metadata.
4355 * The first 4 bytes are a DDF_*_MAGIC which guides
4357 * Possible update are:
4358 * DDF_PHYS_RECORDS_MAGIC
4359 * Add a new physical device or remove an old one.
4360 * Changes to this record only happen implicitly.
4361 * used_pdes is the device number.
4362 * DDF_VIRT_RECORDS_MAGIC
4363 * Add a new VD. Possibly also change the 'access' bits.
4364 * populated_vdes is the entry number.
4366 * New or updated VD. the VIRT_RECORD must already
4367 * exist. For an update, phys_refnum and lba_offset
4368 * (at least) are updated, and the VD_CONF must
4369 * be written to precisely those devices listed with
4371 * DDF_SPARE_ASSIGN_MAGIC
4372 * replacement Spare Assignment Record... but for which device?
4375 * - to create a new array, we send a VIRT_RECORD and
4376 * a VD_CONF. Then assemble and start the array.
4377 * - to activate a spare we send a VD_CONF to add the phys_refnum
4378 * and offset. This will also mark the spare as active with
4379 * a spare-assignment record.
4381 struct ddf_super
*ddf
= st
->sb
;
4382 be32
*magic
= (be32
*)update
->buf
;
4383 struct phys_disk
*pd
;
4384 struct virtual_disk
*vd
;
4385 struct vd_config
*vc
;
4389 unsigned int pdnum
, pd2
, len
;
4391 dprintf("Process update %x\n", be32_to_cpu(*magic
));
4393 if (be32_eq(*magic
, DDF_PHYS_RECORDS_MAGIC
)) {
4395 if (update
->len
!= (sizeof(struct phys_disk
) +
4396 sizeof(struct phys_disk_entry
)))
4398 pd
= (struct phys_disk
*)update
->buf
;
4400 ent
= be16_to_cpu(pd
->used_pdes
);
4401 if (ent
>= be16_to_cpu(ddf
->phys
->max_pdes
))
4403 if (be16_and(pd
->entries
[0].state
, cpu_to_be16(DDF_Missing
))) {
4405 /* removing this disk. */
4406 be16_set(ddf
->phys
->entries
[ent
].state
,
4407 cpu_to_be16(DDF_Missing
));
4408 for (dlp
= &ddf
->dlist
; *dlp
; dlp
= &(*dlp
)->next
) {
4409 struct dl
*dl
= *dlp
;
4410 if (dl
->pdnum
== (signed)ent
) {
4413 /* FIXME this doesn't free
4420 ddf_set_updates_pending(ddf
);
4423 if (!all_ff(ddf
->phys
->entries
[ent
].guid
))
4425 ddf
->phys
->entries
[ent
] = pd
->entries
[0];
4426 ddf
->phys
->used_pdes
= cpu_to_be16
4427 (1 + be16_to_cpu(ddf
->phys
->used_pdes
));
4428 ddf_set_updates_pending(ddf
);
4429 if (ddf
->add_list
) {
4430 struct active_array
*a
;
4431 struct dl
*al
= ddf
->add_list
;
4432 ddf
->add_list
= al
->next
;
4434 al
->next
= ddf
->dlist
;
4437 /* As a device has been added, we should check
4438 * for any degraded devices that might make
4439 * use of this spare */
4440 for (a
= st
->arrays
; a
; a
=a
->next
)
4441 a
->check_degraded
= 1;
4443 } else if (be32_eq(*magic
, DDF_VIRT_RECORDS_MAGIC
)) {
4445 if (update
->len
!= (sizeof(struct virtual_disk
) +
4446 sizeof(struct virtual_entry
)))
4448 vd
= (struct virtual_disk
*)update
->buf
;
4450 if (vd
->entries
[0].state
== DDF_state_deleted
) {
4451 if (_kill_subarray_ddf(ddf
, vd
->entries
[0].guid
))
4455 ent
= find_vde_by_guid(ddf
, vd
->entries
[0].guid
);
4456 if (ent
!= DDF_NOTFOUND
) {
4457 dprintf("%s: VD %s exists already in slot %d\n",
4458 __func__
, guid_str(vd
->entries
[0].guid
),
4462 ent
= find_unused_vde(ddf
);
4463 if (ent
== DDF_NOTFOUND
)
4465 ddf
->virt
->entries
[ent
] = vd
->entries
[0];
4466 ddf
->virt
->populated_vdes
=
4469 ddf
->virt
->populated_vdes
));
4470 dprintf("%s: added VD %s in slot %d(s=%02x i=%02x)\n",
4471 __func__
, guid_str(vd
->entries
[0].guid
), ent
,
4472 ddf
->virt
->entries
[ent
].state
,
4473 ddf
->virt
->entries
[ent
].init_state
);
4475 ddf_set_updates_pending(ddf
);
4478 else if (be32_eq(*magic
, DDF_VD_CONF_MAGIC
)) {
4479 vc
= (struct vd_config
*)update
->buf
;
4480 len
= ddf
->conf_rec_len
* 512;
4481 if ((unsigned int)update
->len
!= len
* vc
->sec_elmnt_count
) {
4482 pr_err("%s: %s: insufficient data (%d) for %u BVDs\n",
4483 __func__
, guid_str(vc
->guid
), update
->len
,
4484 vc
->sec_elmnt_count
);
4487 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
)
4488 if (memcmp(vcl
->conf
.guid
, vc
->guid
, DDF_GUID_LEN
) == 0)
4490 dprintf("%s: conf update for %s (%s)\n", __func__
,
4491 guid_str(vc
->guid
), (vcl
? "old" : "new"));
4493 /* An update, just copy the phys_refnum and lba_offset
4497 copy_matching_bvd(ddf
, &vcl
->conf
, update
);
4498 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++)
4499 copy_matching_bvd(ddf
, vcl
->other_bvds
[i
-1],
4506 vcl
= update
->space
;
4507 update
->space
= NULL
;
4508 vcl
->next
= ddf
->conflist
;
4509 memcpy(&vcl
->conf
, vc
, len
);
4510 ent
= find_vde_by_guid(ddf
, vc
->guid
);
4511 if (ent
== DDF_NOTFOUND
)
4514 ddf
->conflist
= vcl
;
4515 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++)
4516 memcpy(vcl
->other_bvds
[i
-1],
4517 update
->buf
+ len
* i
, len
);
4519 /* Set DDF_Transition on all Failed devices - to help
4520 * us detect those that are no longer in use
4522 for (pdnum
= 0; pdnum
< be16_to_cpu(ddf
->phys
->used_pdes
);
4524 if (be16_and(ddf
->phys
->entries
[pdnum
].state
,
4525 cpu_to_be16(DDF_Failed
)))
4526 be16_set(ddf
->phys
->entries
[pdnum
].state
,
4527 cpu_to_be16(DDF_Transition
));
4528 /* Now make sure vlist is correct for each dl. */
4529 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
4530 unsigned int vn
= 0;
4531 int in_degraded
= 0;
4532 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
) {
4533 unsigned int dn
, ibvd
;
4534 const struct vd_config
*conf
;
4536 dn
= get_pd_index_from_refnum(vcl
,
4540 if (dn
== DDF_NOTFOUND
)
4542 dprintf("dev %d/%08x has %s (sec=%u) at %d\n",
4544 be32_to_cpu(dl
->disk
.refnum
),
4545 guid_str(conf
->guid
),
4546 conf
->sec_elmnt_seq
, vn
);
4547 /* Clear the Transition flag */
4549 (ddf
->phys
->entries
[dl
->pdnum
].state
,
4550 cpu_to_be16(DDF_Failed
)))
4551 be16_clear(ddf
->phys
4552 ->entries
[dl
->pdnum
].state
,
4553 cpu_to_be16(DDF_Transition
));
4554 dl
->vlist
[vn
++] = vcl
;
4555 vstate
= ddf
->virt
->entries
[vcl
->vcnum
].state
4557 if (vstate
== DDF_state_degraded
||
4558 vstate
== DDF_state_part_optimal
)
4561 while (vn
< ddf
->max_part
)
4562 dl
->vlist
[vn
++] = NULL
;
4564 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4565 cpu_to_be16(DDF_Global_Spare
));
4566 if (!be16_and(ddf
->phys
4567 ->entries
[dl
->pdnum
].type
,
4568 cpu_to_be16(DDF_Active_in_VD
))) {
4570 ->entries
[dl
->pdnum
].type
,
4571 cpu_to_be16(DDF_Active_in_VD
));
4574 ->entries
[dl
->pdnum
]
4581 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4582 cpu_to_be16(DDF_Global_Spare
));
4583 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
4584 cpu_to_be16(DDF_Spare
));
4586 if (!dl
->vlist
[0] && !dl
->spare
) {
4587 be16_set(ddf
->phys
->entries
[dl
->pdnum
].type
,
4588 cpu_to_be16(DDF_Global_Spare
));
4589 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4590 cpu_to_be16(DDF_Spare
));
4591 be16_clear(ddf
->phys
->entries
[dl
->pdnum
].type
,
4592 cpu_to_be16(DDF_Active_in_VD
));
4596 /* Now remove any 'Failed' devices that are not part
4597 * of any VD. They will have the Transition flag set.
4598 * Once done, we need to update all dl->pdnum numbers.
4601 for (pdnum
= 0; pdnum
< be16_to_cpu(ddf
->phys
->used_pdes
);
4603 if (be16_and(ddf
->phys
->entries
[pdnum
].state
,
4604 cpu_to_be16(DDF_Failed
))
4605 && be16_and(ddf
->phys
->entries
[pdnum
].state
,
4606 cpu_to_be16(DDF_Transition
)))
4607 /* skip this one */;
4608 else if (pdnum
== pd2
)
4611 ddf
->phys
->entries
[pd2
] =
4612 ddf
->phys
->entries
[pdnum
];
4613 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4614 if (dl
->pdnum
== (int)pdnum
)
4618 ddf
->phys
->used_pdes
= cpu_to_be16(pd2
);
4619 while (pd2
< pdnum
) {
4620 memset(ddf
->phys
->entries
[pd2
].guid
, 0xff,
4625 ddf_set_updates_pending(ddf
);
4627 /* case DDF_SPARE_ASSIGN_MAGIC */
4630 static void ddf_prepare_update(struct supertype
*st
,
4631 struct metadata_update
*update
)
4633 /* This update arrived at managemon.
4634 * We are about to pass it to monitor.
4635 * If a malloc is needed, do it here.
4637 struct ddf_super
*ddf
= st
->sb
;
4638 be32
*magic
= (be32
*)update
->buf
;
4639 if (be32_eq(*magic
, DDF_VD_CONF_MAGIC
)) {
4641 struct vd_config
*conf
= (struct vd_config
*) update
->buf
;
4642 if (posix_memalign(&update
->space
, 512,
4643 offsetof(struct vcl
, conf
)
4644 + ddf
->conf_rec_len
* 512) != 0) {
4645 update
->space
= NULL
;
4648 vcl
= update
->space
;
4649 vcl
->conf
.sec_elmnt_count
= conf
->sec_elmnt_count
;
4650 if (alloc_other_bvds(ddf
, vcl
) != 0) {
4651 free(update
->space
);
4652 update
->space
= NULL
;
4658 * Check degraded state of a RAID10.
4659 * returns 2 for good, 1 for degraded, 0 for failed, and -1 for error
4661 static int raid10_degraded(struct mdinfo
*info
)
4665 struct mdinfo
*d
, *sra
;
4669 if (info
->array
.layout
== 0) {
4670 sra
= sysfs_read(-1, info
->sys_name
, GET_LAYOUT
);
4671 info
->array
.layout
= sra
->array
.layout
;
4675 n_prim
= info
->array
.layout
& ~0x100;
4676 n_bvds
= info
->array
.raid_disks
/ n_prim
;
4677 found
= xmalloc(n_bvds
);
4680 memset(found
, 0, n_bvds
);
4681 for (d
= info
->devs
; d
; d
= d
->next
) {
4682 i
= d
->disk
.raid_disk
/ n_prim
;
4684 pr_err("%s: BUG: invalid raid disk\n", __func__
);
4687 if (d
->state_fd
> 0)
4691 for (i
= 0; i
< n_bvds
; i
++)
4693 dprintf("%s: BVD %d/%d failed\n", __func__
, i
, n_bvds
);
4696 } else if (found
[i
] < n_prim
) {
4697 dprintf("%s: BVD %d/%d degraded\n", __func__
, i
,
4707 * Check if the array 'a' is degraded but not failed.
4708 * If it is, find as many spares as are available and needed and
4709 * arrange for their inclusion.
4710 * We only choose devices which are not already in the array,
4711 * and prefer those with a spare-assignment to this array.
4712 * otherwise we choose global spares - assuming always that
4713 * there is enough room.
4714 * For each spare that we assign, we return an 'mdinfo' which
4715 * describes the position for the device in the array.
4716 * We also add to 'updates' a DDF_VD_CONF_MAGIC update with
4717 * the new phys_refnum and lba_offset values.
4719 * Only worry about BVDs at the moment.
4721 static struct mdinfo
*ddf_activate_spare(struct active_array
*a
,
4722 struct metadata_update
**updates
)
4726 struct ddf_super
*ddf
= a
->container
->sb
;
4728 struct mdinfo
*rv
= NULL
;
4730 struct metadata_update
*mu
;
4735 struct vd_config
*vc
;
4738 for (d
= a
->info
.devs
; d
; d
= d
->next
) {
4739 if ((d
->curr_state
& DS_FAULTY
) &&
4741 /* wait for Removal to happen */
4743 if (d
->state_fd
>= 0)
4747 dprintf("%s: working=%d (%d) level=%d\n", __func__
, working
,
4748 a
->info
.array
.raid_disks
,
4749 a
->info
.array
.level
);
4750 if (working
== a
->info
.array
.raid_disks
)
4751 return NULL
; /* array not degraded */
4752 switch (a
->info
.array
.level
) {
4755 return NULL
; /* failed */
4759 if (working
< a
->info
.array
.raid_disks
- 1)
4760 return NULL
; /* failed */
4763 if (working
< a
->info
.array
.raid_disks
- 2)
4764 return NULL
; /* failed */
4767 if (raid10_degraded(&a
->info
) < 1)
4770 default: /* concat or stripe */
4771 return NULL
; /* failed */
4774 /* For each slot, if it is not working, find a spare */
4776 for (i
= 0; i
< a
->info
.array
.raid_disks
; i
++) {
4777 be16 state
= ddf
->phys
->entries
[dl
->pdnum
].state
;
4779 cpu_to_be16(DDF_Failed
|DDF_Missing
)) ||
4781 cpu_to_be16(DDF_Online
)))
4784 for (d
= a
->info
.devs
; d
; d
= d
->next
)
4785 if (d
->disk
.raid_disk
== i
)
4787 dprintf("found %d: %p %x\n", i
, d
, d
?d
->curr_state
:0);
4788 if (d
&& (d
->state_fd
>= 0))
4791 /* OK, this device needs recovery. Find a spare */
4793 for ( ; dl
; dl
= dl
->next
) {
4794 unsigned long long esize
;
4795 unsigned long long pos
;
4798 int is_dedicated
= 0;
4801 /* If in this array, skip */
4802 for (d2
= a
->info
.devs
; d2
; d2
= d2
->next
)
4803 if (d2
->state_fd
>= 0 &&
4804 d2
->disk
.major
== dl
->major
&&
4805 d2
->disk
.minor
== dl
->minor
) {
4806 dprintf("%x:%x already in array\n", dl
->major
, dl
->minor
);
4811 if (be16_and(ddf
->phys
->entries
[dl
->pdnum
].type
,
4812 cpu_to_be16(DDF_Spare
))) {
4813 /* Check spare assign record */
4815 if (dl
->spare
->type
& DDF_spare_dedicated
) {
4816 /* check spare_ents for guid */
4822 if (memcmp(dl
->spare
->spare_ents
[j
].guid
,
4823 ddf
->virt
->entries
[a
->info
.container_member
].guid
,
4830 } else if (be16_and(ddf
->phys
->entries
[dl
->pdnum
].type
,
4831 cpu_to_be16(DDF_Global_Spare
))) {
4833 } else if (!be16_and(ddf
->phys
4834 ->entries
[dl
->pdnum
].state
,
4835 cpu_to_be16(DDF_Failed
))) {
4836 /* we can possibly use some of this */
4839 if ( ! (is_dedicated
||
4840 (is_global
&& global_ok
))) {
4841 dprintf("%x:%x not suitable: %d %d\n", dl
->major
, dl
->minor
,
4842 is_dedicated
, is_global
);
4846 /* We are allowed to use this device - is there space?
4847 * We need a->info.component_size sectors */
4848 ex
= get_extents(ddf
, dl
);
4850 dprintf("cannot get extents\n");
4857 esize
= ex
[j
].start
- pos
;
4858 if (esize
>= a
->info
.component_size
)
4860 pos
= ex
[j
].start
+ ex
[j
].size
;
4862 } while (ex
[j
-1].size
);
4865 if (esize
< a
->info
.component_size
) {
4866 dprintf("%x:%x has no room: %llu %llu\n",
4867 dl
->major
, dl
->minor
,
4868 esize
, a
->info
.component_size
);
4873 /* Cool, we have a device with some space at pos */
4874 di
= xcalloc(1, sizeof(*di
));
4875 di
->disk
.number
= i
;
4876 di
->disk
.raid_disk
= i
;
4877 di
->disk
.major
= dl
->major
;
4878 di
->disk
.minor
= dl
->minor
;
4880 di
->recovery_start
= 0;
4881 di
->data_offset
= pos
;
4882 di
->component_size
= a
->info
.component_size
;
4883 di
->container_member
= dl
->pdnum
;
4886 dprintf("%x:%x to be %d at %llu\n", dl
->major
, dl
->minor
,
4891 if (!dl
&& ! global_ok
) {
4892 /* not enough dedicated spares, try global */
4900 /* No spares found */
4902 /* Now 'rv' has a list of devices to return.
4903 * Create a metadata_update record to update the
4904 * phys_refnum and lba_offset values
4906 vc
= find_vdcr(ddf
, a
->info
.container_member
, di
->disk
.raid_disk
,
4911 mu
= xmalloc(sizeof(*mu
));
4912 if (posix_memalign(&mu
->space
, 512, sizeof(struct vcl
)) != 0) {
4917 mu
->len
= ddf
->conf_rec_len
* 512 * vcl
->conf
.sec_elmnt_count
;
4918 mu
->buf
= xmalloc(mu
->len
);
4920 mu
->space_list
= NULL
;
4921 mu
->next
= *updates
;
4922 memcpy(mu
->buf
, &vcl
->conf
, ddf
->conf_rec_len
* 512);
4923 for (j
= 1; j
< vcl
->conf
.sec_elmnt_count
; j
++)
4924 memcpy(mu
->buf
+ j
* ddf
->conf_rec_len
* 512,
4925 vcl
->other_bvds
[j
-1], ddf
->conf_rec_len
* 512);
4927 vc
= (struct vd_config
*)mu
->buf
;
4928 for (di
= rv
; di
; di
= di
->next
) {
4929 unsigned int i_sec
, i_prim
;
4930 i_sec
= di
->disk
.raid_disk
4931 / be16_to_cpu(vcl
->conf
.prim_elmnt_count
);
4932 i_prim
= di
->disk
.raid_disk
4933 % be16_to_cpu(vcl
->conf
.prim_elmnt_count
);
4934 vc
= (struct vd_config
*)(mu
->buf
4935 + i_sec
* ddf
->conf_rec_len
* 512);
4936 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4937 if (dl
->major
== di
->disk
.major
4938 && dl
->minor
== di
->disk
.minor
)
4941 pr_err("%s: BUG: can't find disk %d (%d/%d)\n",
4942 __func__
, di
->disk
.raid_disk
,
4943 di
->disk
.major
, di
->disk
.minor
);
4946 vc
->phys_refnum
[i_prim
] = ddf
->phys
->entries
[dl
->pdnum
].refnum
;
4947 LBA_OFFSET(ddf
, vc
)[i_prim
] = cpu_to_be64(di
->data_offset
);
4952 #endif /* MDASSEMBLE */
4954 static int ddf_level_to_layout(int level
)
4961 return ALGORITHM_LEFT_SYMMETRIC
;
4963 return ALGORITHM_ROTATING_N_CONTINUE
;
4971 static void default_geometry_ddf(struct supertype
*st
, int *level
, int *layout
, int *chunk
)
4973 if (level
&& *level
== UnSet
)
4974 *level
= LEVEL_CONTAINER
;
4976 if (level
&& layout
&& *layout
== UnSet
)
4977 *layout
= ddf_level_to_layout(*level
);
4980 struct superswitch super_ddf
= {
4982 .examine_super
= examine_super_ddf
,
4983 .brief_examine_super
= brief_examine_super_ddf
,
4984 .brief_examine_subarrays
= brief_examine_subarrays_ddf
,
4985 .export_examine_super
= export_examine_super_ddf
,
4986 .detail_super
= detail_super_ddf
,
4987 .brief_detail_super
= brief_detail_super_ddf
,
4988 .validate_geometry
= validate_geometry_ddf
,
4989 .write_init_super
= write_init_super_ddf
,
4990 .add_to_super
= add_to_super_ddf
,
4991 .remove_from_super
= remove_from_super_ddf
,
4992 .load_container
= load_container_ddf
,
4993 .copy_metadata
= copy_metadata_ddf
,
4994 .kill_subarray
= kill_subarray_ddf
,
4996 .match_home
= match_home_ddf
,
4997 .uuid_from_super
= uuid_from_super_ddf
,
4998 .getinfo_super
= getinfo_super_ddf
,
4999 .update_super
= update_super_ddf
,
5001 .avail_size
= avail_size_ddf
,
5003 .compare_super
= compare_super_ddf
,
5005 .load_super
= load_super_ddf
,
5006 .init_super
= init_super_ddf
,
5007 .store_super
= store_super_ddf
,
5008 .free_super
= free_super_ddf
,
5009 .match_metadata_desc
= match_metadata_desc_ddf
,
5010 .container_content
= container_content_ddf
,
5011 .default_geometry
= default_geometry_ddf
,
5017 .open_new
= ddf_open_new
,
5018 .set_array_state
= ddf_set_array_state
,
5019 .set_disk
= ddf_set_disk
,
5020 .sync_metadata
= ddf_sync_metadata
,
5021 .process_update
= ddf_process_update
,
5022 .prepare_update
= ddf_prepare_update
,
5023 .activate_spare
= ddf_activate_spare
,