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 /* Primary Raid Level (PRL) */
62 #define DDF_RAID0 0x00
63 #define DDF_RAID1 0x01
64 #define DDF_RAID3 0x03
65 #define DDF_RAID4 0x04
66 #define DDF_RAID5 0x05
67 #define DDF_RAID1E 0x11
69 #define DDF_CONCAT 0x1f
70 #define DDF_RAID5E 0x15
71 #define DDF_RAID5EE 0x25
72 #define DDF_RAID6 0x06
74 /* Raid Level Qualifier (RLQ) */
75 #define DDF_RAID0_SIMPLE 0x00
76 #define DDF_RAID1_SIMPLE 0x00 /* just 2 devices in this plex */
77 #define DDF_RAID1_MULTI 0x01 /* exactly 3 devices in this plex */
78 #define DDF_RAID3_0 0x00 /* parity in first extent */
79 #define DDF_RAID3_N 0x01 /* parity in last extent */
80 #define DDF_RAID4_0 0x00 /* parity in first extent */
81 #define DDF_RAID4_N 0x01 /* parity in last extent */
82 /* these apply to raid5e and raid5ee as well */
83 #define DDF_RAID5_0_RESTART 0x00 /* same as 'right asymmetric' - layout 1 */
84 #define DDF_RAID6_0_RESTART 0x01 /* raid6 different from raid5 here!!! */
85 #define DDF_RAID5_N_RESTART 0x02 /* same as 'left asymmetric' - layout 0 */
86 #define DDF_RAID5_N_CONTINUE 0x03 /* same as 'left symmetric' - layout 2 */
88 #define DDF_RAID1E_ADJACENT 0x00 /* raid10 nearcopies==2 */
89 #define DDF_RAID1E_OFFSET 0x01 /* raid10 offsetcopies==2 */
91 /* Secondary RAID Level (SRL) */
92 #define DDF_2STRIPED 0x00 /* This is weirder than RAID0 !! */
93 #define DDF_2MIRRORED 0x01
94 #define DDF_2CONCAT 0x02
95 #define DDF_2SPANNED 0x03 /* This is also weird - be careful */
98 #define DDF_HEADER_MAGIC __cpu_to_be32(0xDE11DE11)
99 #define DDF_CONTROLLER_MAGIC __cpu_to_be32(0xAD111111)
100 #define DDF_PHYS_RECORDS_MAGIC __cpu_to_be32(0x22222222)
101 #define DDF_PHYS_DATA_MAGIC __cpu_to_be32(0x33333333)
102 #define DDF_VIRT_RECORDS_MAGIC __cpu_to_be32(0xDDDDDDDD)
103 #define DDF_VD_CONF_MAGIC __cpu_to_be32(0xEEEEEEEE)
104 #define DDF_SPARE_ASSIGN_MAGIC __cpu_to_be32(0x55555555)
105 #define DDF_VU_CONF_MAGIC __cpu_to_be32(0x88888888)
106 #define DDF_VENDOR_LOG_MAGIC __cpu_to_be32(0x01dBEEF0)
107 #define DDF_BBM_LOG_MAGIC __cpu_to_be32(0xABADB10C)
109 #define DDF_GUID_LEN 24
110 #define DDF_REVISION_0 "01.00.00"
111 #define DDF_REVISION_2 "01.02.00"
114 __u32 magic
; /* DDF_HEADER_MAGIC */
116 char guid
[DDF_GUID_LEN
];
117 char revision
[8]; /* 01.02.00 */
118 __u32 seq
; /* starts at '1' */
123 __u8 pad0
; /* 0xff */
124 __u8 pad1
[12]; /* 12 * 0xff */
125 /* 64 bytes so far */
126 __u8 header_ext
[32]; /* reserved: fill with 0xff */
130 __u8 pad2
[3]; /* 0xff */
131 __u32 workspace_len
; /* sectors for vendor space -
132 * at least 32768(sectors) */
134 __u16 max_pd_entries
; /* one of 15, 63, 255, 1023, 4095 */
135 __u16 max_vd_entries
; /* 2^(4,6,8,10,12)-1 : i.e. as above */
136 __u16 max_partitions
; /* i.e. max num of configuration
137 record entries per disk */
138 __u16 config_record_len
; /* 1 +ROUNDUP(max_primary_element_entries
140 __u16 max_primary_element_entries
; /* 16, 64, 256, 1024, or 4096 */
141 __u8 pad3
[54]; /* 0xff */
142 /* 192 bytes so far */
143 __u32 controller_section_offset
;
144 __u32 controller_section_length
;
145 __u32 phys_section_offset
;
146 __u32 phys_section_length
;
147 __u32 virt_section_offset
;
148 __u32 virt_section_length
;
149 __u32 config_section_offset
;
150 __u32 config_section_length
;
151 __u32 data_section_offset
;
152 __u32 data_section_length
;
153 __u32 bbm_section_offset
;
154 __u32 bbm_section_length
;
155 __u32 diag_space_offset
;
156 __u32 diag_space_length
;
159 /* 256 bytes so far */
160 __u8 pad4
[256]; /* 0xff */
164 #define DDF_HEADER_ANCHOR 0x00
165 #define DDF_HEADER_PRIMARY 0x01
166 #define DDF_HEADER_SECONDARY 0x02
168 /* The content of the 'controller section' - global scope */
169 struct ddf_controller_data
{
170 __u32 magic
; /* DDF_CONTROLLER_MAGIC */
172 char guid
[DDF_GUID_LEN
];
173 struct controller_type
{
180 __u8 pad
[8]; /* 0xff */
181 __u8 vendor_data
[448];
184 /* The content of phys_section - global scope */
186 __u32 magic
; /* DDF_PHYS_RECORDS_MAGIC */
191 struct phys_disk_entry
{
192 char guid
[DDF_GUID_LEN
];
196 __u64 config_size
; /* DDF structures must be after here */
197 char path
[18]; /* another horrible structure really */
202 /* phys_disk_entry.type is a bitmap - bigendian remember */
203 #define DDF_Forced_PD_GUID 1
204 #define DDF_Active_in_VD 2
205 #define DDF_Global_Spare 4 /* VD_CONF records are ignored */
206 #define DDF_Spare 8 /* overrides Global_spare */
207 #define DDF_Foreign 16
208 #define DDF_Legacy 32 /* no DDF on this device */
210 #define DDF_Interface_mask 0xf00
211 #define DDF_Interface_SCSI 0x100
212 #define DDF_Interface_SAS 0x200
213 #define DDF_Interface_SATA 0x300
214 #define DDF_Interface_FC 0x400
216 /* phys_disk_entry.state is a bigendian bitmap */
218 #define DDF_Failed 2 /* overrides 1,4,8 */
219 #define DDF_Rebuilding 4
220 #define DDF_Transition 8
222 #define DDF_ReadErrors 32
223 #define DDF_Missing 64
225 /* The content of the virt_section global scope */
226 struct virtual_disk
{
227 __u32 magic
; /* DDF_VIRT_RECORDS_MAGIC */
229 __u16 populated_vdes
;
232 struct virtual_entry
{
233 char guid
[DDF_GUID_LEN
];
235 __u16 pad0
; /* 0xffff */
245 /* virtual_entry.type is a bitmap - bigendian */
247 #define DDF_Enforce_Groups 2
248 #define DDF_Unicode 4
249 #define DDF_Owner_Valid 8
251 /* virtual_entry.state is a bigendian bitmap */
252 #define DDF_state_mask 0x7
253 #define DDF_state_optimal 0x0
254 #define DDF_state_degraded 0x1
255 #define DDF_state_deleted 0x2
256 #define DDF_state_missing 0x3
257 #define DDF_state_failed 0x4
258 #define DDF_state_part_optimal 0x5
260 #define DDF_state_morphing 0x8
261 #define DDF_state_inconsistent 0x10
263 /* virtual_entry.init_state is a bigendian bitmap */
264 #define DDF_initstate_mask 0x03
265 #define DDF_init_not 0x00
266 #define DDF_init_quick 0x01 /* initialisation is progress.
267 * i.e. 'state_inconsistent' */
268 #define DDF_init_full 0x02
270 #define DDF_access_mask 0xc0
271 #define DDF_access_rw 0x00
272 #define DDF_access_ro 0x80
273 #define DDF_access_blocked 0xc0
275 /* The content of the config_section - local scope
276 * It has multiple records each config_record_len sectors
277 * They can be vd_config or spare_assign
281 __u32 magic
; /* DDF_VD_CONF_MAGIC */
283 char guid
[DDF_GUID_LEN
];
287 __u16 prim_elmnt_count
;
288 __u8 chunk_shift
; /* 0 == 512, 1==1024 etc */
291 __u8 sec_elmnt_count
;
294 __u64 blocks
; /* blocks per component could be different
295 * on different component devices...(only
296 * for concat I hope) */
297 __u64 array_blocks
; /* blocks in array */
305 __u8 v0
[32]; /* reserved- 0xff */
306 __u8 v1
[32]; /* reserved- 0xff */
307 __u8 v2
[16]; /* reserved- 0xff */
308 __u8 v3
[16]; /* reserved- 0xff */
310 __u32 phys_refnum
[0]; /* refnum of each disk in sequence */
311 /*__u64 lba_offset[0]; LBA offset in each phys. Note extents in a
312 bvd are always the same size */
314 #define LBA_OFFSET(ddf, vd) ((__u64 *) &(vd)->phys_refnum[(ddf)->mppe])
316 /* vd_config.cache_pol[7] is a bitmap */
317 #define DDF_cache_writeback 1 /* else writethrough */
318 #define DDF_cache_wadaptive 2 /* only applies if writeback */
319 #define DDF_cache_readahead 4
320 #define DDF_cache_radaptive 8 /* only if doing read-ahead */
321 #define DDF_cache_ifnobatt 16 /* even to write cache if battery is poor */
322 #define DDF_cache_wallowed 32 /* enable write caching */
323 #define DDF_cache_rallowed 64 /* enable read caching */
325 struct spare_assign
{
326 __u32 magic
; /* DDF_SPARE_ASSIGN_MAGIC */
331 __u16 populated
; /* SAEs used */
332 __u16 max
; /* max SAEs */
334 struct spare_assign_entry
{
335 char guid
[DDF_GUID_LEN
];
336 __u16 secondary_element
;
340 /* spare_assign.type is a bitmap */
341 #define DDF_spare_dedicated 0x1 /* else global */
342 #define DDF_spare_revertible 0x2 /* else committable */
343 #define DDF_spare_active 0x4 /* else not active */
344 #define DDF_spare_affinity 0x8 /* enclosure affinity */
346 /* The data_section contents - local scope */
348 __u32 magic
; /* DDF_PHYS_DATA_MAGIC */
350 char guid
[DDF_GUID_LEN
];
351 __u32 refnum
; /* crc of some magic drive data ... */
352 __u8 forced_ref
; /* set when above was not result of magic */
353 __u8 forced_guid
; /* set if guid was forced rather than magic */
358 /* bbm_section content */
359 struct bad_block_log
{
366 struct mapped_block
{
367 __u64 defective_start
;
368 __u32 replacement_start
;
374 /* Struct for internally holding ddf structures */
375 /* The DDF structure stored on each device is potentially
376 * quite different, as some data is global and some is local.
377 * The global data is:
380 * - Physical disk records
381 * - Virtual disk records
383 * - Configuration records
384 * - Physical Disk data section
385 * ( and Bad block and vendor which I don't care about yet).
387 * The local data is parsed into separate lists as it is read
388 * and reconstructed for writing. This means that we only need
389 * to make config changes once and they are automatically
390 * propagated to all devices.
391 * Note that the ddf_super has space of the conf and disk data
392 * for this disk and also for a list of all such data.
393 * The list is only used for the superblock that is being
394 * built in Create or Assemble to describe the whole array.
397 struct ddf_header anchor
, primary
, secondary
;
398 struct ddf_controller_data controller
;
399 struct ddf_header
*active
;
400 struct phys_disk
*phys
;
401 struct virtual_disk
*virt
;
403 unsigned int max_part
, mppe
, conf_rec_len
;
411 unsigned int vcnum
; /* index into ->virt */
412 struct vd_config
**other_bvds
;
413 __u64
*block_sizes
; /* NULL if all the same */
416 struct vd_config conf
;
417 } *conflist
, *currentconf
;
426 unsigned long long size
; /* sectors */
427 unsigned long long primary_lba
; /* sectors */
428 unsigned long long secondary_lba
; /* sectors */
429 unsigned long long workspace_lba
; /* sectors */
430 int pdnum
; /* index in ->phys */
431 struct spare_assign
*spare
;
432 void *mdupdate
; /* hold metadata update */
434 /* These fields used by auto-layout */
435 int raiddisk
; /* slot to fill in autolayout */
439 struct disk_data disk
;
440 struct vcl
*vlist
[0]; /* max_part in size */
445 #define offsetof(t,f) ((size_t)&(((t*)0)->f))
449 static int all_ff(const char *guid
);
450 static void pr_state(struct ddf_super
*ddf
, const char *msg
)
453 dprintf("%s/%s: ", __func__
, msg
);
454 for (i
= 0; i
< __be16_to_cpu(ddf
->active
->max_vd_entries
); i
++) {
455 if (all_ff(ddf
->virt
->entries
[i
].guid
))
457 dprintf("%u(s=%02x i=%02x) ", i
,
458 ddf
->virt
->entries
[i
].state
,
459 ddf
->virt
->entries
[i
].init_state
);
464 static void pr_state(const struct ddf_super
*ddf
, const char *msg
) {}
467 #define ddf_set_updates_pending(x) \
468 do { (x)->updates_pending = 1; pr_state(x, __func__); } while (0)
470 static unsigned int get_pd_index_from_refnum(const struct vcl
*vc
,
471 __u32 refnum
, unsigned int nmax
,
472 const struct vd_config
**bvd
,
475 static unsigned int calc_crc(void *buf
, int len
)
477 /* crcs are always at the same place as in the ddf_header */
478 struct ddf_header
*ddf
= buf
;
479 __u32 oldcrc
= ddf
->crc
;
481 ddf
->crc
= 0xffffffff;
483 newcrc
= crc32(0, buf
, len
);
485 /* The crc is store (like everything) bigendian, so convert
486 * here for simplicity
488 return __cpu_to_be32(newcrc
);
491 #define DDF_INVALID_LEVEL 0xff
492 #define DDF_NO_SECONDARY 0xff
493 static int err_bad_md_layout(const mdu_array_info_t
*array
)
495 pr_err("RAID%d layout %x with %d disks is unsupported for DDF\n",
496 array
->level
, array
->layout
, array
->raid_disks
);
497 return DDF_INVALID_LEVEL
;
500 static int layout_md2ddf(const mdu_array_info_t
*array
,
501 struct vd_config
*conf
)
503 __u16 prim_elmnt_count
= __cpu_to_be16(array
->raid_disks
);
504 __u8 prl
= DDF_INVALID_LEVEL
, rlq
= 0;
505 __u8 sec_elmnt_count
= 1;
506 __u8 srl
= DDF_NO_SECONDARY
;
508 switch (array
->level
) {
513 rlq
= DDF_RAID0_SIMPLE
;
517 switch (array
->raid_disks
) {
519 rlq
= DDF_RAID1_SIMPLE
;
522 rlq
= DDF_RAID1_MULTI
;
525 return err_bad_md_layout(array
);
530 if (array
->layout
!= 0)
531 return err_bad_md_layout(array
);
536 switch (array
->layout
) {
537 case ALGORITHM_LEFT_ASYMMETRIC
:
538 rlq
= DDF_RAID5_N_RESTART
;
540 case ALGORITHM_RIGHT_ASYMMETRIC
:
541 rlq
= DDF_RAID5_0_RESTART
;
543 case ALGORITHM_LEFT_SYMMETRIC
:
544 rlq
= DDF_RAID5_N_CONTINUE
;
546 case ALGORITHM_RIGHT_SYMMETRIC
:
547 /* not mentioned in standard */
549 return err_bad_md_layout(array
);
554 switch (array
->layout
) {
555 case ALGORITHM_ROTATING_N_RESTART
:
556 rlq
= DDF_RAID5_N_RESTART
;
558 case ALGORITHM_ROTATING_ZERO_RESTART
:
559 rlq
= DDF_RAID6_0_RESTART
;
561 case ALGORITHM_ROTATING_N_CONTINUE
:
562 rlq
= DDF_RAID5_N_CONTINUE
;
565 return err_bad_md_layout(array
);
570 if (array
->raid_disks
% 2 == 0 && array
->layout
== 0x102) {
571 rlq
= DDF_RAID1_SIMPLE
;
572 prim_elmnt_count
= __cpu_to_be16(2);
573 sec_elmnt_count
= array
->raid_disks
/ 2;
574 } else if (array
->raid_disks
% 3 == 0
575 && array
->layout
== 0x103) {
576 rlq
= DDF_RAID1_MULTI
;
577 prim_elmnt_count
= __cpu_to_be16(3);
578 sec_elmnt_count
= array
->raid_disks
/ 3;
580 return err_bad_md_layout(array
);
585 return err_bad_md_layout(array
);
588 conf
->prim_elmnt_count
= prim_elmnt_count
;
591 conf
->sec_elmnt_count
= sec_elmnt_count
;
595 static int err_bad_ddf_layout(const struct vd_config
*conf
)
597 pr_err("DDF RAID %u qualifier %u with %u disks is unsupported\n",
598 conf
->prl
, conf
->rlq
, __be16_to_cpu(conf
->prim_elmnt_count
));
602 static int layout_ddf2md(const struct vd_config
*conf
,
603 mdu_array_info_t
*array
)
605 int level
= LEVEL_UNSUPPORTED
;
607 int raiddisks
= __be16_to_cpu(conf
->prim_elmnt_count
);
609 if (conf
->sec_elmnt_count
> 1) {
610 /* see also check_secondary() */
611 if (conf
->prl
!= DDF_RAID1
||
612 (conf
->srl
!= DDF_2STRIPED
&& conf
->srl
!= DDF_2SPANNED
)) {
613 pr_err("Unsupported secondary RAID level %u/%u\n",
614 conf
->prl
, conf
->srl
);
617 if (raiddisks
== 2 && conf
->rlq
== DDF_RAID1_SIMPLE
)
619 else if (raiddisks
== 3 && conf
->rlq
== DDF_RAID1_MULTI
)
622 return err_bad_ddf_layout(conf
);
623 raiddisks
*= conf
->sec_elmnt_count
;
630 level
= LEVEL_LINEAR
;
633 if (conf
->rlq
!= DDF_RAID0_SIMPLE
)
634 return err_bad_ddf_layout(conf
);
638 if (!((conf
->rlq
== DDF_RAID1_SIMPLE
&& raiddisks
== 2) ||
639 (conf
->rlq
== DDF_RAID1_MULTI
&& raiddisks
== 3)))
640 return err_bad_ddf_layout(conf
);
644 if (conf
->rlq
!= DDF_RAID4_N
)
645 return err_bad_ddf_layout(conf
);
650 case DDF_RAID5_N_RESTART
:
651 layout
= ALGORITHM_LEFT_ASYMMETRIC
;
653 case DDF_RAID5_0_RESTART
:
654 layout
= ALGORITHM_RIGHT_ASYMMETRIC
;
656 case DDF_RAID5_N_CONTINUE
:
657 layout
= ALGORITHM_LEFT_SYMMETRIC
;
660 return err_bad_ddf_layout(conf
);
666 case DDF_RAID5_N_RESTART
:
667 layout
= ALGORITHM_ROTATING_N_RESTART
;
669 case DDF_RAID6_0_RESTART
:
670 layout
= ALGORITHM_ROTATING_ZERO_RESTART
;
672 case DDF_RAID5_N_CONTINUE
:
673 layout
= ALGORITHM_ROTATING_N_CONTINUE
;
676 return err_bad_ddf_layout(conf
);
681 return err_bad_ddf_layout(conf
);
685 array
->level
= level
;
686 array
->layout
= layout
;
687 array
->raid_disks
= raiddisks
;
691 static int load_ddf_header(int fd
, unsigned long long lba
,
692 unsigned long long size
,
694 struct ddf_header
*hdr
, struct ddf_header
*anchor
)
696 /* read a ddf header (primary or secondary) from fd/lba
697 * and check that it is consistent with anchor
699 * magic, crc, guid, rev, and LBA's header_type, and
700 * everything after header_type must be the same
705 if (lseek64(fd
, lba
<<9, 0) < 0)
708 if (read(fd
, hdr
, 512) != 512)
711 if (hdr
->magic
!= DDF_HEADER_MAGIC
)
713 if (calc_crc(hdr
, 512) != hdr
->crc
)
715 if (memcmp(anchor
->guid
, hdr
->guid
, DDF_GUID_LEN
) != 0 ||
716 memcmp(anchor
->revision
, hdr
->revision
, 8) != 0 ||
717 anchor
->primary_lba
!= hdr
->primary_lba
||
718 anchor
->secondary_lba
!= hdr
->secondary_lba
||
720 memcmp(anchor
->pad2
, hdr
->pad2
, 512 -
721 offsetof(struct ddf_header
, pad2
)) != 0)
724 /* Looks good enough to me... */
728 static void *load_section(int fd
, struct ddf_super
*super
, void *buf
,
729 __u32 offset_be
, __u32 len_be
, int check
)
731 unsigned long long offset
= __be32_to_cpu(offset_be
);
732 unsigned long long len
= __be32_to_cpu(len_be
);
733 int dofree
= (buf
== NULL
);
736 if (len
!= 2 && len
!= 8 && len
!= 32
737 && len
!= 128 && len
!= 512)
743 /* All pre-allocated sections are a single block */
746 } else if (posix_memalign(&buf
, 512, len
<<9) != 0)
752 if (super
->active
->type
== 1)
753 offset
+= __be64_to_cpu(super
->active
->primary_lba
);
755 offset
+= __be64_to_cpu(super
->active
->secondary_lba
);
757 if ((unsigned long long)lseek64(fd
, offset
<<9, 0) != (offset
<<9)) {
762 if ((unsigned long long)read(fd
, buf
, len
<<9) != (len
<<9)) {
770 static int load_ddf_headers(int fd
, struct ddf_super
*super
, char *devname
)
772 unsigned long long dsize
;
774 get_dev_size(fd
, NULL
, &dsize
);
776 if (lseek64(fd
, dsize
-512, 0) < 0) {
778 pr_err("Cannot seek to anchor block on %s: %s\n",
779 devname
, strerror(errno
));
782 if (read(fd
, &super
->anchor
, 512) != 512) {
784 pr_err("Cannot read anchor block on %s: %s\n",
785 devname
, strerror(errno
));
788 if (super
->anchor
.magic
!= DDF_HEADER_MAGIC
) {
790 pr_err("no DDF anchor found on %s\n",
794 if (calc_crc(&super
->anchor
, 512) != super
->anchor
.crc
) {
796 pr_err("bad CRC on anchor on %s\n",
800 if (memcmp(super
->anchor
.revision
, DDF_REVISION_0
, 8) != 0 &&
801 memcmp(super
->anchor
.revision
, DDF_REVISION_2
, 8) != 0) {
803 pr_err("can only support super revision"
804 " %.8s and earlier, not %.8s on %s\n",
805 DDF_REVISION_2
, super
->anchor
.revision
,devname
);
808 super
->active
= NULL
;
809 if (load_ddf_header(fd
, __be64_to_cpu(super
->anchor
.primary_lba
),
811 &super
->primary
, &super
->anchor
) == 0) {
813 pr_err("Failed to load primary DDF header "
816 super
->active
= &super
->primary
;
817 if (load_ddf_header(fd
, __be64_to_cpu(super
->anchor
.secondary_lba
),
819 &super
->secondary
, &super
->anchor
)) {
820 if ((__be32_to_cpu(super
->primary
.seq
)
821 < __be32_to_cpu(super
->secondary
.seq
) &&
822 !super
->secondary
.openflag
)
823 || (__be32_to_cpu(super
->primary
.seq
)
824 == __be32_to_cpu(super
->secondary
.seq
) &&
825 super
->primary
.openflag
&& !super
->secondary
.openflag
)
826 || super
->active
== NULL
828 super
->active
= &super
->secondary
;
830 pr_err("Failed to load secondary DDF header on %s\n",
832 if (super
->active
== NULL
)
837 static int load_ddf_global(int fd
, struct ddf_super
*super
, char *devname
)
840 ok
= load_section(fd
, super
, &super
->controller
,
841 super
->active
->controller_section_offset
,
842 super
->active
->controller_section_length
,
844 super
->phys
= load_section(fd
, super
, NULL
,
845 super
->active
->phys_section_offset
,
846 super
->active
->phys_section_length
,
848 super
->pdsize
= __be32_to_cpu(super
->active
->phys_section_length
) * 512;
850 super
->virt
= load_section(fd
, super
, NULL
,
851 super
->active
->virt_section_offset
,
852 super
->active
->virt_section_length
,
854 super
->vdsize
= __be32_to_cpu(super
->active
->virt_section_length
) * 512;
864 super
->conflist
= NULL
;
867 super
->max_part
= __be16_to_cpu(super
->active
->max_partitions
);
868 super
->mppe
= __be16_to_cpu(super
->active
->max_primary_element_entries
);
869 super
->conf_rec_len
= __be16_to_cpu(super
->active
->config_record_len
);
873 #define DDF_UNUSED_BVD 0xff
874 static int alloc_other_bvds(const struct ddf_super
*ddf
, struct vcl
*vcl
)
876 unsigned int n_vds
= vcl
->conf
.sec_elmnt_count
- 1;
877 unsigned int i
, vdsize
;
880 vcl
->other_bvds
= NULL
;
883 vdsize
= ddf
->conf_rec_len
* 512;
884 if (posix_memalign(&p
, 512, n_vds
*
885 (vdsize
+ sizeof(struct vd_config
*))) != 0)
887 vcl
->other_bvds
= (struct vd_config
**) (p
+ n_vds
* vdsize
);
888 for (i
= 0; i
< n_vds
; i
++) {
889 vcl
->other_bvds
[i
] = p
+ i
* vdsize
;
890 memset(vcl
->other_bvds
[i
], 0, vdsize
);
891 vcl
->other_bvds
[i
]->sec_elmnt_seq
= DDF_UNUSED_BVD
;
896 static void add_other_bvd(struct vcl
*vcl
, struct vd_config
*vd
,
900 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
901 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== vd
->sec_elmnt_seq
)
904 if (i
< vcl
->conf
.sec_elmnt_count
-1) {
905 if (vd
->seqnum
<= vcl
->other_bvds
[i
]->seqnum
)
908 for (i
= 0; i
< vcl
->conf
.sec_elmnt_count
-1; i
++)
909 if (vcl
->other_bvds
[i
]->sec_elmnt_seq
== DDF_UNUSED_BVD
)
911 if (i
== vcl
->conf
.sec_elmnt_count
-1) {
912 pr_err("no space for sec level config %u, count is %u\n",
913 vd
->sec_elmnt_seq
, vcl
->conf
.sec_elmnt_count
);
917 memcpy(vcl
->other_bvds
[i
], vd
, len
);
920 static int load_ddf_local(int fd
, struct ddf_super
*super
,
921 char *devname
, int keep
)
927 unsigned int confsec
;
929 unsigned int max_virt_disks
= __be16_to_cpu(super
->active
->max_vd_entries
);
930 unsigned long long dsize
;
932 /* First the local disk info */
933 if (posix_memalign((void**)&dl
, 512,
935 (super
->max_part
) * sizeof(dl
->vlist
[0])) != 0) {
936 pr_err("%s could not allocate disk info buffer\n",
941 load_section(fd
, super
, &dl
->disk
,
942 super
->active
->data_section_offset
,
943 super
->active
->data_section_length
,
945 dl
->devname
= devname
? xstrdup(devname
) : NULL
;
948 dl
->major
= major(stb
.st_rdev
);
949 dl
->minor
= minor(stb
.st_rdev
);
950 dl
->next
= super
->dlist
;
951 dl
->fd
= keep
? fd
: -1;
954 if (get_dev_size(fd
, devname
, &dsize
))
955 dl
->size
= dsize
>> 9;
956 /* If the disks have different sizes, the LBAs will differ
957 * between phys disks.
958 * At this point here, the values in super->active must be valid
959 * for this phys disk. */
960 dl
->primary_lba
= super
->active
->primary_lba
;
961 dl
->secondary_lba
= super
->active
->secondary_lba
;
962 dl
->workspace_lba
= super
->active
->workspace_lba
;
964 for (i
= 0 ; i
< super
->max_part
; i
++)
968 for (i
= 0; i
< __be16_to_cpu(super
->active
->max_pd_entries
); i
++)
969 if (memcmp(super
->phys
->entries
[i
].guid
,
970 dl
->disk
.guid
, DDF_GUID_LEN
) == 0)
973 /* Now the config list. */
974 /* 'conf' is an array of config entries, some of which are
975 * probably invalid. Those which are good need to be copied into
979 conf
= load_section(fd
, super
, NULL
,
980 super
->active
->config_section_offset
,
981 super
->active
->config_section_length
,
986 confsec
< __be32_to_cpu(super
->active
->config_section_length
);
987 confsec
+= super
->conf_rec_len
) {
988 struct vd_config
*vd
=
989 (struct vd_config
*)((char*)conf
+ confsec
*512);
992 if (vd
->magic
== DDF_SPARE_ASSIGN_MAGIC
) {
995 if (posix_memalign((void**)&dl
->spare
, 512,
996 super
->conf_rec_len
*512) != 0) {
997 pr_err("%s could not allocate spare info buf\n",
1002 memcpy(dl
->spare
, vd
, super
->conf_rec_len
*512);
1005 if (vd
->magic
!= DDF_VD_CONF_MAGIC
)
1007 for (vcl
= super
->conflist
; vcl
; vcl
= vcl
->next
) {
1008 if (memcmp(vcl
->conf
.guid
,
1009 vd
->guid
, DDF_GUID_LEN
) == 0)
1014 dl
->vlist
[vnum
++] = vcl
;
1015 if (vcl
->other_bvds
!= NULL
&&
1016 vcl
->conf
.sec_elmnt_seq
!= vd
->sec_elmnt_seq
) {
1017 add_other_bvd(vcl
, vd
, super
->conf_rec_len
*512);
1020 if (__be32_to_cpu(vd
->seqnum
) <=
1021 __be32_to_cpu(vcl
->conf
.seqnum
))
1024 if (posix_memalign((void**)&vcl
, 512,
1025 (super
->conf_rec_len
*512 +
1026 offsetof(struct vcl
, conf
))) != 0) {
1027 pr_err("%s could not allocate vcl buf\n",
1031 vcl
->next
= super
->conflist
;
1032 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
1033 vcl
->conf
.sec_elmnt_count
= vd
->sec_elmnt_count
;
1034 if (alloc_other_bvds(super
, vcl
) != 0) {
1035 pr_err("%s could not allocate other bvds\n",
1040 super
->conflist
= vcl
;
1041 dl
->vlist
[vnum
++] = vcl
;
1043 memcpy(&vcl
->conf
, vd
, super
->conf_rec_len
*512);
1044 for (i
=0; i
< max_virt_disks
; i
++)
1045 if (memcmp(super
->virt
->entries
[i
].guid
,
1046 vcl
->conf
.guid
, DDF_GUID_LEN
)==0)
1048 if (i
< max_virt_disks
)
1057 static int load_super_ddf_all(struct supertype
*st
, int fd
,
1058 void **sbp
, char *devname
);
1061 static void free_super_ddf(struct supertype
*st
);
1063 static int load_super_ddf(struct supertype
*st
, int fd
,
1066 unsigned long long dsize
;
1067 struct ddf_super
*super
;
1070 if (get_dev_size(fd
, devname
, &dsize
) == 0)
1073 if (!st
->ignore_hw_compat
&& test_partition(fd
))
1074 /* DDF is not allowed on partitions */
1077 /* 32M is a lower bound */
1078 if (dsize
<= 32*1024*1024) {
1080 pr_err("%s is too small for ddf: "
1081 "size is %llu sectors.\n",
1087 pr_err("%s is an odd size for ddf: "
1088 "size is %llu bytes.\n",
1095 if (posix_memalign((void**)&super
, 512, sizeof(*super
))!= 0) {
1096 pr_err("malloc of %zu failed.\n",
1100 memset(super
, 0, sizeof(*super
));
1102 rv
= load_ddf_headers(fd
, super
, devname
);
1108 /* Have valid headers and have chosen the best. Let's read in the rest*/
1110 rv
= load_ddf_global(fd
, super
, devname
);
1114 pr_err("Failed to load all information "
1115 "sections on %s\n", devname
);
1120 rv
= load_ddf_local(fd
, super
, devname
, 0);
1124 pr_err("Failed to load all information "
1125 "sections on %s\n", devname
);
1130 /* Should possibly check the sections .... */
1133 if (st
->ss
== NULL
) {
1134 st
->ss
= &super_ddf
;
1135 st
->minor_version
= 0;
1142 static void free_super_ddf(struct supertype
*st
)
1144 struct ddf_super
*ddf
= st
->sb
;
1149 while (ddf
->conflist
) {
1150 struct vcl
*v
= ddf
->conflist
;
1151 ddf
->conflist
= v
->next
;
1153 free(v
->block_sizes
);
1156 v->other_bvds[0] points to beginning of buffer,
1157 see alloc_other_bvds()
1159 free(v
->other_bvds
[0]);
1162 while (ddf
->dlist
) {
1163 struct dl
*d
= ddf
->dlist
;
1164 ddf
->dlist
= d
->next
;
1171 while (ddf
->add_list
) {
1172 struct dl
*d
= ddf
->add_list
;
1173 ddf
->add_list
= d
->next
;
1184 static struct supertype
*match_metadata_desc_ddf(char *arg
)
1186 /* 'ddf' only support containers */
1187 struct supertype
*st
;
1188 if (strcmp(arg
, "ddf") != 0 &&
1189 strcmp(arg
, "default") != 0
1193 st
= xcalloc(1, sizeof(*st
));
1194 st
->ss
= &super_ddf
;
1196 st
->minor_version
= 0;
1203 static mapping_t ddf_state
[] = {
1209 { "Partially Optimal", 5},
1215 static mapping_t ddf_init_state
[] = {
1216 { "Not Initialised", 0},
1217 { "QuickInit in Progress", 1},
1218 { "Fully Initialised", 2},
1222 static mapping_t ddf_access
[] = {
1226 { "Blocked (no access)", 3},
1230 static mapping_t ddf_level
[] = {
1231 { "RAID0", DDF_RAID0
},
1232 { "RAID1", DDF_RAID1
},
1233 { "RAID3", DDF_RAID3
},
1234 { "RAID4", DDF_RAID4
},
1235 { "RAID5", DDF_RAID5
},
1236 { "RAID1E",DDF_RAID1E
},
1237 { "JBOD", DDF_JBOD
},
1238 { "CONCAT",DDF_CONCAT
},
1239 { "RAID5E",DDF_RAID5E
},
1240 { "RAID5EE",DDF_RAID5EE
},
1241 { "RAID6", DDF_RAID6
},
1244 static mapping_t ddf_sec_level
[] = {
1245 { "Striped", DDF_2STRIPED
},
1246 { "Mirrored", DDF_2MIRRORED
},
1247 { "Concat", DDF_2CONCAT
},
1248 { "Spanned", DDF_2SPANNED
},
1253 static int all_ff(const char *guid
)
1256 for (i
= 0; i
< DDF_GUID_LEN
; i
++)
1257 if (guid
[i
] != (char)0xff)
1263 static void print_guid(char *guid
, int tstamp
)
1265 /* A GUIDs are part (or all) ASCII and part binary.
1266 * They tend to be space padded.
1267 * We print the GUID in HEX, then in parentheses add
1268 * any initial ASCII sequence, and a possible
1269 * time stamp from bytes 16-19
1271 int l
= DDF_GUID_LEN
;
1274 for (i
=0 ; i
<DDF_GUID_LEN
; i
++) {
1275 if ((i
&3)==0 && i
!= 0) printf(":");
1276 printf("%02X", guid
[i
]&255);
1280 while (l
&& guid
[l
-1] == ' ')
1282 for (i
=0 ; i
<l
; i
++) {
1283 if (guid
[i
] >= 0x20 && guid
[i
] < 0x7f)
1284 fputc(guid
[i
], stdout
);
1289 time_t then
= __be32_to_cpu(*(__u32
*)(guid
+16)) + DECADE
;
1292 tm
= localtime(&then
);
1293 strftime(tbuf
, 100, " %D %T",tm
);
1294 fputs(tbuf
, stdout
);
1299 static const char *guid_str(const char *guid
)
1301 static char buf
[DDF_GUID_LEN
*2+1];
1304 for (i
= 0; i
< DDF_GUID_LEN
; i
++)
1305 p
+= sprintf(p
, "%02x", (unsigned char)guid
[i
]);
1307 return (const char *) buf
;
1310 static void examine_vd(int n
, struct ddf_super
*sb
, char *guid
)
1312 int crl
= sb
->conf_rec_len
;
1315 for (vcl
= sb
->conflist
; vcl
; vcl
= vcl
->next
) {
1317 struct vd_config
*vc
= &vcl
->conf
;
1319 if (calc_crc(vc
, crl
*512) != vc
->crc
)
1321 if (memcmp(vc
->guid
, guid
, DDF_GUID_LEN
) != 0)
1324 /* Ok, we know about this VD, let's give more details */
1325 printf(" Raid Devices[%d] : %d (", n
,
1326 __be16_to_cpu(vc
->prim_elmnt_count
));
1327 for (i
= 0; i
< __be16_to_cpu(vc
->prim_elmnt_count
); i
++) {
1329 int cnt
= __be16_to_cpu(sb
->phys
->used_pdes
);
1330 for (j
=0; j
<cnt
; j
++)
1331 if (vc
->phys_refnum
[i
] == sb
->phys
->entries
[j
].refnum
)
1340 if (vc
->chunk_shift
!= 255)
1341 printf(" Chunk Size[%d] : %d sectors\n", n
,
1342 1 << vc
->chunk_shift
);
1343 printf(" Raid Level[%d] : %s\n", n
,
1344 map_num(ddf_level
, vc
->prl
)?:"-unknown-");
1345 if (vc
->sec_elmnt_count
!= 1) {
1346 printf(" Secondary Position[%d] : %d of %d\n", n
,
1347 vc
->sec_elmnt_seq
, vc
->sec_elmnt_count
);
1348 printf(" Secondary Level[%d] : %s\n", n
,
1349 map_num(ddf_sec_level
, vc
->srl
) ?: "-unknown-");
1351 printf(" Device Size[%d] : %llu\n", n
,
1352 (unsigned long long)__be64_to_cpu(vc
->blocks
)/2);
1353 printf(" Array Size[%d] : %llu\n", n
,
1354 (unsigned long long)__be64_to_cpu(vc
->array_blocks
)/2);
1358 static void examine_vds(struct ddf_super
*sb
)
1360 int cnt
= __be16_to_cpu(sb
->virt
->populated_vdes
);
1362 printf(" Virtual Disks : %d\n", cnt
);
1364 for (i
= 0; i
< __be16_to_cpu(sb
->virt
->max_vdes
); i
++) {
1365 struct virtual_entry
*ve
= &sb
->virt
->entries
[i
];
1366 if (all_ff(ve
->guid
))
1369 printf(" VD GUID[%d] : ", i
); print_guid(ve
->guid
, 1);
1371 printf(" unit[%d] : %d\n", i
, __be16_to_cpu(ve
->unit
));
1372 printf(" state[%d] : %s, %s%s\n", i
,
1373 map_num(ddf_state
, ve
->state
& 7),
1374 (ve
->state
& 8) ? "Morphing, ": "",
1375 (ve
->state
& 16)? "Not Consistent" : "Consistent");
1376 printf(" init state[%d] : %s\n", i
,
1377 map_num(ddf_init_state
, ve
->init_state
&3));
1378 printf(" access[%d] : %s\n", i
,
1379 map_num(ddf_access
, (ve
->init_state
>>6) & 3));
1380 printf(" Name[%d] : %.16s\n", i
, ve
->name
);
1381 examine_vd(i
, sb
, ve
->guid
);
1383 if (cnt
) printf("\n");
1386 static void examine_pds(struct ddf_super
*sb
)
1388 int cnt
= __be16_to_cpu(sb
->phys
->used_pdes
);
1391 printf(" Physical Disks : %d\n", cnt
);
1392 printf(" Number RefNo Size Device Type/State\n");
1394 for (i
=0 ; i
<cnt
; i
++) {
1395 struct phys_disk_entry
*pd
= &sb
->phys
->entries
[i
];
1396 int type
= __be16_to_cpu(pd
->type
);
1397 int state
= __be16_to_cpu(pd
->state
);
1399 //printf(" PD GUID[%d] : ", i); print_guid(pd->guid, 0);
1401 printf(" %3d %08x ", i
,
1402 __be32_to_cpu(pd
->refnum
));
1404 (unsigned long long)__be64_to_cpu(pd
->config_size
)>>1);
1405 for (dl
= sb
->dlist
; dl
; dl
= dl
->next
) {
1406 if (dl
->disk
.refnum
== pd
->refnum
) {
1407 char *dv
= map_dev(dl
->major
, dl
->minor
, 0);
1409 printf("%-15s", dv
);
1416 printf(" %s%s%s%s%s",
1417 (type
&2) ? "active":"",
1418 (type
&4) ? "Global-Spare":"",
1419 (type
&8) ? "spare" : "",
1420 (type
&16)? ", foreign" : "",
1421 (type
&32)? "pass-through" : "");
1422 if (state
& DDF_Failed
)
1423 /* This over-rides these three */
1424 state
&= ~(DDF_Online
|DDF_Rebuilding
|DDF_Transition
);
1425 printf("/%s%s%s%s%s%s%s",
1426 (state
&1)? "Online": "Offline",
1427 (state
&2)? ", Failed": "",
1428 (state
&4)? ", Rebuilding": "",
1429 (state
&8)? ", in-transition": "",
1430 (state
&16)? ", SMART-errors": "",
1431 (state
&32)? ", Unrecovered-Read-Errors": "",
1432 (state
&64)? ", Missing" : "");
1437 static void examine_super_ddf(struct supertype
*st
, char *homehost
)
1439 struct ddf_super
*sb
= st
->sb
;
1441 printf(" Magic : %08x\n", __be32_to_cpu(sb
->anchor
.magic
));
1442 printf(" Version : %.8s\n", sb
->anchor
.revision
);
1443 printf("Controller GUID : "); print_guid(sb
->controller
.guid
, 0);
1445 printf(" Container GUID : "); print_guid(sb
->anchor
.guid
, 1);
1447 printf(" Seq : %08x\n", __be32_to_cpu(sb
->active
->seq
));
1448 printf(" Redundant hdr : %s\n", sb
->secondary
.magic
== DDF_HEADER_MAGIC
1454 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1456 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4]);
1457 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4]);
1459 static unsigned int get_vd_num_of_subarray(struct supertype
*st
)
1462 * Figure out the VD number for this supertype.
1463 * Returns DDF_CONTAINER for the container itself,
1464 * and DDF_NOTFOUND on error.
1466 struct ddf_super
*ddf
= st
->sb
;
1471 if (*st
->container_devnm
== '\0')
1472 return DDF_CONTAINER
;
1474 sra
= sysfs_read(-1, st
->devnm
, GET_VERSION
);
1475 if (!sra
|| sra
->array
.major_version
!= -1 ||
1476 sra
->array
.minor_version
!= -2 ||
1477 !is_subarray(sra
->text_version
))
1478 return DDF_NOTFOUND
;
1480 sub
= strchr(sra
->text_version
+ 1, '/');
1482 vcnum
= strtoul(sub
+ 1, &end
, 10);
1483 if (sub
== NULL
|| *sub
== '\0' || *end
!= '\0' ||
1484 vcnum
>= __be16_to_cpu(ddf
->active
->max_vd_entries
))
1485 return DDF_NOTFOUND
;
1490 static void brief_examine_super_ddf(struct supertype
*st
, int verbose
)
1492 /* We just write a generic DDF ARRAY entry
1496 getinfo_super_ddf(st
, &info
, NULL
);
1497 fname_from_uuid(st
, &info
, nbuf
, ':');
1499 printf("ARRAY metadata=ddf UUID=%s\n", nbuf
+ 5);
1502 static void brief_examine_subarrays_ddf(struct supertype
*st
, int verbose
)
1504 /* We just write a generic DDF ARRAY entry
1506 struct ddf_super
*ddf
= st
->sb
;
1510 getinfo_super_ddf(st
, &info
, NULL
);
1511 fname_from_uuid(st
, &info
, nbuf
, ':');
1513 for (i
= 0; i
< __be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
1514 struct virtual_entry
*ve
= &ddf
->virt
->entries
[i
];
1517 if (all_ff(ve
->guid
))
1519 memcpy(vcl
.conf
.guid
, ve
->guid
, DDF_GUID_LEN
);
1520 ddf
->currentconf
=&vcl
;
1521 uuid_from_super_ddf(st
, info
.uuid
);
1522 fname_from_uuid(st
, &info
, nbuf1
, ':');
1523 printf("ARRAY container=%s member=%d UUID=%s\n",
1524 nbuf
+5, i
, nbuf1
+5);
1528 static void export_examine_super_ddf(struct supertype
*st
)
1532 getinfo_super_ddf(st
, &info
, NULL
);
1533 fname_from_uuid(st
, &info
, nbuf
, ':');
1534 printf("MD_METADATA=ddf\n");
1535 printf("MD_LEVEL=container\n");
1536 printf("MD_UUID=%s\n", nbuf
+5);
1539 static int copy_metadata_ddf(struct supertype
*st
, int from
, int to
)
1542 unsigned long long dsize
, offset
;
1544 struct ddf_header
*ddf
;
1547 /* The meta consists of an anchor, a primary, and a secondary.
1548 * This all lives at the end of the device.
1549 * So it is easiest to find the earliest of primary and
1550 * secondary, and copy everything from there.
1552 * Anchor is 512 from end It contains primary_lba and secondary_lba
1553 * we choose one of those
1556 if (posix_memalign(&buf
, 4096, 4096) != 0)
1559 if (!get_dev_size(from
, NULL
, &dsize
))
1562 if (lseek64(from
, dsize
-512, 0) < 0)
1564 if (read(from
, buf
, 512) != 512)
1567 if (ddf
->magic
!= DDF_HEADER_MAGIC
||
1568 calc_crc(ddf
, 512) != ddf
->crc
||
1569 (memcmp(ddf
->revision
, DDF_REVISION_0
, 8) != 0 &&
1570 memcmp(ddf
->revision
, DDF_REVISION_2
, 8) != 0))
1573 offset
= dsize
- 512;
1574 if ((__be64_to_cpu(ddf
->primary_lba
) << 9) < offset
)
1575 offset
= __be64_to_cpu(ddf
->primary_lba
) << 9;
1576 if ((__be64_to_cpu(ddf
->secondary_lba
) << 9) < offset
)
1577 offset
= __be64_to_cpu(ddf
->secondary_lba
) << 9;
1579 bytes
= dsize
- offset
;
1581 if (lseek64(from
, offset
, 0) < 0 ||
1582 lseek64(to
, offset
, 0) < 0)
1584 while (written
< bytes
) {
1585 int n
= bytes
- written
;
1588 if (read(from
, buf
, n
) != n
)
1590 if (write(to
, buf
, n
) != n
)
1601 static void detail_super_ddf(struct supertype
*st
, char *homehost
)
1604 * Could print DDF GUID
1605 * Need to find which array
1606 * If whole, briefly list all arrays
1611 static void brief_detail_super_ddf(struct supertype
*st
)
1615 struct ddf_super
*ddf
= st
->sb
;
1616 unsigned int vcnum
= get_vd_num_of_subarray(st
);
1617 if (vcnum
== DDF_CONTAINER
)
1618 uuid_from_super_ddf(st
, info
.uuid
);
1619 else if (vcnum
== DDF_NOTFOUND
)
1622 uuid_from_ddf_guid(ddf
->virt
->entries
[vcnum
].guid
, info
.uuid
);
1623 fname_from_uuid(st
, &info
, nbuf
,':');
1624 printf(" UUID=%s", nbuf
+ 5);
1628 static int match_home_ddf(struct supertype
*st
, char *homehost
)
1630 /* It matches 'this' host if the controller is a
1631 * Linux-MD controller with vendor_data matching
1634 struct ddf_super
*ddf
= st
->sb
;
1639 len
= strlen(homehost
);
1641 return (memcmp(ddf
->controller
.guid
, T10
, 8) == 0 &&
1642 len
< sizeof(ddf
->controller
.vendor_data
) &&
1643 memcmp(ddf
->controller
.vendor_data
, homehost
,len
) == 0 &&
1644 ddf
->controller
.vendor_data
[len
] == 0);
1648 static int find_index_in_bvd(const struct ddf_super
*ddf
,
1649 const struct vd_config
*conf
, unsigned int n
,
1650 unsigned int *n_bvd
)
1653 * Find the index of the n-th valid physical disk in this BVD
1656 for (i
= 0, j
= 0; i
< ddf
->mppe
&&
1657 j
< __be16_to_cpu(conf
->prim_elmnt_count
); i
++) {
1658 if (conf
->phys_refnum
[i
] != 0xffffffff) {
1666 dprintf("%s: couldn't find BVD member %u (total %u)\n",
1667 __func__
, n
, __be16_to_cpu(conf
->prim_elmnt_count
));
1671 static struct vd_config
*find_vdcr(struct ddf_super
*ddf
, unsigned int inst
,
1673 unsigned int *n_bvd
, struct vcl
**vcl
)
1677 for (v
= ddf
->conflist
; v
; v
= v
->next
) {
1678 unsigned int nsec
, ibvd
;
1679 struct vd_config
*conf
;
1680 if (inst
!= v
->vcnum
)
1683 if (conf
->sec_elmnt_count
== 1) {
1684 if (find_index_in_bvd(ddf
, conf
, n
, n_bvd
)) {
1690 if (v
->other_bvds
== NULL
) {
1691 pr_err("%s: BUG: other_bvds is NULL, nsec=%u\n",
1692 __func__
, conf
->sec_elmnt_count
);
1695 nsec
= n
/ __be16_to_cpu(conf
->prim_elmnt_count
);
1696 if (conf
->sec_elmnt_seq
!= nsec
) {
1697 for (ibvd
= 1; ibvd
< conf
->sec_elmnt_count
; ibvd
++) {
1698 if (v
->other_bvds
[ibvd
-1]->sec_elmnt_seq
1702 if (ibvd
== conf
->sec_elmnt_count
)
1704 conf
= v
->other_bvds
[ibvd
-1];
1706 if (!find_index_in_bvd(ddf
, conf
,
1707 n
- nsec
*conf
->sec_elmnt_count
, n_bvd
))
1709 dprintf("%s: found disk %u as member %u in bvd %d of array %u\n"
1710 , __func__
, n
, *n_bvd
, ibvd
-1, inst
);
1715 pr_err("%s: Could't find disk %d in array %u\n", __func__
, n
, inst
);
1720 static int find_phys(const struct ddf_super
*ddf
, __u32 phys_refnum
)
1722 /* Find the entry in phys_disk which has the given refnum
1723 * and return it's index
1726 for (i
= 0; i
< __be16_to_cpu(ddf
->phys
->max_pdes
); i
++)
1727 if (ddf
->phys
->entries
[i
].refnum
== phys_refnum
)
1732 static void uuid_from_ddf_guid(const char *guid
, int uuid
[4])
1735 struct sha1_ctx ctx
;
1736 sha1_init_ctx(&ctx
);
1737 sha1_process_bytes(guid
, DDF_GUID_LEN
, &ctx
);
1738 sha1_finish_ctx(&ctx
, buf
);
1739 memcpy(uuid
, buf
, 4*4);
1742 static void uuid_from_super_ddf(struct supertype
*st
, int uuid
[4])
1744 /* The uuid returned here is used for:
1745 * uuid to put into bitmap file (Create, Grow)
1746 * uuid for backup header when saving critical section (Grow)
1747 * comparing uuids when re-adding a device into an array
1748 * In these cases the uuid required is that of the data-array,
1749 * not the device-set.
1750 * uuid to recognise same set when adding a missing device back
1751 * to an array. This is a uuid for the device-set.
1753 * For each of these we can make do with a truncated
1754 * or hashed uuid rather than the original, as long as
1756 * In the case of SVD we assume the BVD is of interest,
1757 * though that might be the case if a bitmap were made for
1758 * a mirrored SVD - worry about that later.
1759 * So we need to find the VD configuration record for the
1760 * relevant BVD and extract the GUID and Secondary_Element_Seq.
1761 * The first 16 bytes of the sha1 of these is used.
1763 struct ddf_super
*ddf
= st
->sb
;
1764 struct vcl
*vcl
= ddf
->currentconf
;
1768 guid
= vcl
->conf
.guid
;
1770 guid
= ddf
->anchor
.guid
;
1771 uuid_from_ddf_guid(guid
, uuid
);
1774 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
);
1776 static void getinfo_super_ddf(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1778 struct ddf_super
*ddf
= st
->sb
;
1779 int map_disks
= info
->array
.raid_disks
;
1782 if (ddf
->currentconf
) {
1783 getinfo_super_ddf_bvd(st
, info
, map
);
1786 memset(info
, 0, sizeof(*info
));
1788 info
->array
.raid_disks
= __be16_to_cpu(ddf
->phys
->used_pdes
);
1789 info
->array
.level
= LEVEL_CONTAINER
;
1790 info
->array
.layout
= 0;
1791 info
->array
.md_minor
= -1;
1792 cptr
= (__u32
*)(ddf
->anchor
.guid
+ 16);
1793 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1795 info
->array
.utime
= 0;
1796 info
->array
.chunk_size
= 0;
1797 info
->container_enough
= 1;
1799 info
->disk
.major
= 0;
1800 info
->disk
.minor
= 0;
1802 info
->disk
.number
= __be32_to_cpu(ddf
->dlist
->disk
.refnum
);
1803 info
->disk
.raid_disk
= find_phys(ddf
, ddf
->dlist
->disk
.refnum
);
1805 info
->data_offset
= __be64_to_cpu(ddf
->phys
->
1806 entries
[info
->disk
.raid_disk
].
1808 info
->component_size
= ddf
->dlist
->size
- info
->data_offset
;
1810 info
->disk
.number
= -1;
1811 info
->disk
.raid_disk
= -1;
1812 // info->disk.raid_disk = find refnum in the table and use index;
1814 info
->disk
.state
= (1 << MD_DISK_SYNC
) | (1 << MD_DISK_ACTIVE
);
1816 info
->recovery_start
= MaxSector
;
1817 info
->reshape_active
= 0;
1818 info
->recovery_blocked
= 0;
1821 info
->array
.major_version
= -1;
1822 info
->array
.minor_version
= -2;
1823 strcpy(info
->text_version
, "ddf");
1824 info
->safe_mode_delay
= 0;
1826 uuid_from_super_ddf(st
, info
->uuid
);
1830 for (i
= 0 ; i
< map_disks
; i
++) {
1831 if (i
< info
->array
.raid_disks
&&
1832 (__be16_to_cpu(ddf
->phys
->entries
[i
].state
) & DDF_Online
) &&
1833 !(__be16_to_cpu(ddf
->phys
->entries
[i
].state
) & DDF_Failed
))
1841 static void getinfo_super_ddf_bvd(struct supertype
*st
, struct mdinfo
*info
, char *map
)
1843 struct ddf_super
*ddf
= st
->sb
;
1844 struct vcl
*vc
= ddf
->currentconf
;
1845 int cd
= ddf
->currentdev
;
1849 int map_disks
= info
->array
.raid_disks
;
1851 struct vd_config
*conf
;
1853 memset(info
, 0, sizeof(*info
));
1854 if (layout_ddf2md(&vc
->conf
, &info
->array
) == -1)
1856 info
->array
.md_minor
= -1;
1857 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
1858 info
->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
1859 info
->array
.utime
= DECADE
+ __be32_to_cpu(vc
->conf
.timestamp
);
1860 info
->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
1861 info
->custom_array_size
= 0;
1864 n_prim
= __be16_to_cpu(conf
->prim_elmnt_count
);
1865 if (conf
->sec_elmnt_count
> 1 && cd
>= n_prim
) {
1866 int ibvd
= cd
/ n_prim
- 1;
1868 conf
= vc
->other_bvds
[ibvd
];
1871 if (cd
>= 0 && (unsigned)cd
< ddf
->mppe
) {
1873 __be64_to_cpu(LBA_OFFSET(ddf
, &vc
->conf
)[cd
]);
1874 if (vc
->block_sizes
)
1875 info
->component_size
= vc
->block_sizes
[cd
];
1877 info
->component_size
= __be64_to_cpu(vc
->conf
.blocks
);
1880 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
1881 if (dl
->disk
.refnum
== conf
->phys_refnum
[cd
])
1884 info
->disk
.major
= 0;
1885 info
->disk
.minor
= 0;
1886 info
->disk
.state
= 0;
1888 info
->disk
.major
= dl
->major
;
1889 info
->disk
.minor
= dl
->minor
;
1890 info
->disk
.raid_disk
= cd
+ conf
->sec_elmnt_seq
1891 * __be16_to_cpu(conf
->prim_elmnt_count
);
1892 info
->disk
.number
= dl
->pdnum
;
1893 info
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
1896 info
->container_member
= ddf
->currentconf
->vcnum
;
1898 info
->recovery_start
= MaxSector
;
1899 info
->resync_start
= 0;
1900 info
->reshape_active
= 0;
1901 info
->recovery_blocked
= 0;
1902 if (!(ddf
->virt
->entries
[info
->container_member
].state
1903 & DDF_state_inconsistent
) &&
1904 (ddf
->virt
->entries
[info
->container_member
].init_state
1905 & DDF_initstate_mask
)
1907 info
->resync_start
= MaxSector
;
1909 uuid_from_super_ddf(st
, info
->uuid
);
1911 info
->array
.major_version
= -1;
1912 info
->array
.minor_version
= -2;
1913 sprintf(info
->text_version
, "/%s/%d",
1914 st
->container_devnm
,
1915 info
->container_member
);
1916 info
->safe_mode_delay
= 200;
1918 memcpy(info
->name
, ddf
->virt
->entries
[info
->container_member
].name
, 16);
1921 if (info
->name
[j
] == ' ')
1925 for (j
= 0; j
< map_disks
; j
++) {
1927 if (j
< info
->array
.raid_disks
) {
1928 int i
= find_phys(ddf
, vc
->conf
.phys_refnum
[j
]);
1930 (__be16_to_cpu(ddf
->phys
->entries
[i
].state
) & DDF_Online
) &&
1931 !(__be16_to_cpu(ddf
->phys
->entries
[i
].state
) & DDF_Failed
))
1937 static int update_super_ddf(struct supertype
*st
, struct mdinfo
*info
,
1939 char *devname
, int verbose
,
1940 int uuid_set
, char *homehost
)
1942 /* For 'assemble' and 'force' we need to return non-zero if any
1943 * change was made. For others, the return value is ignored.
1944 * Update options are:
1945 * force-one : This device looks a bit old but needs to be included,
1946 * update age info appropriately.
1947 * assemble: clear any 'faulty' flag to allow this device to
1949 * force-array: Array is degraded but being forced, mark it clean
1950 * if that will be needed to assemble it.
1952 * newdev: not used ????
1953 * grow: Array has gained a new device - this is currently for
1955 * resync: mark as dirty so a resync will happen.
1956 * uuid: Change the uuid of the array to match what is given
1957 * homehost: update the recorded homehost
1958 * name: update the name - preserving the homehost
1959 * _reshape_progress: record new reshape_progress position.
1961 * Following are not relevant for this version:
1962 * sparc2.2 : update from old dodgey metadata
1963 * super-minor: change the preferred_minor number
1964 * summaries: update redundant counters.
1967 // struct ddf_super *ddf = st->sb;
1968 // struct vd_config *vd = find_vdcr(ddf, info->container_member);
1969 // struct virtual_entry *ve = find_ve(ddf);
1971 /* we don't need to handle "force-*" or "assemble" as
1972 * there is no need to 'trick' the kernel. We the metadata is
1973 * first updated to activate the array, all the implied modifications
1977 if (strcmp(update
, "grow") == 0) {
1979 } else if (strcmp(update
, "resync") == 0) {
1980 // info->resync_checkpoint = 0;
1981 } else if (strcmp(update
, "homehost") == 0) {
1982 /* homehost is stored in controller->vendor_data,
1983 * or it is when we are the vendor
1985 // if (info->vendor_is_local)
1986 // strcpy(ddf->controller.vendor_data, homehost);
1988 } else if (strcmp(update
, "name") == 0) {
1989 /* name is stored in virtual_entry->name */
1990 // memset(ve->name, ' ', 16);
1991 // strncpy(ve->name, info->name, 16);
1993 } else if (strcmp(update
, "_reshape_progress") == 0) {
1994 /* We don't support reshape yet */
1995 } else if (strcmp(update
, "assemble") == 0 ) {
1996 /* Do nothing, just succeed */
2001 // update_all_csum(ddf);
2006 static void make_header_guid(char *guid
)
2009 /* Create a DDF Header of Virtual Disk GUID */
2011 /* 24 bytes of fiction required.
2012 * first 8 are a 'vendor-id' - "Linux-MD"
2013 * next 8 are controller type.. how about 0X DEAD BEEF 0000 0000
2014 * Remaining 8 random number plus timestamp
2016 memcpy(guid
, T10
, sizeof(T10
));
2017 stamp
= __cpu_to_be32(0xdeadbeef);
2018 memcpy(guid
+8, &stamp
, 4);
2019 stamp
= __cpu_to_be32(0);
2020 memcpy(guid
+12, &stamp
, 4);
2021 stamp
= __cpu_to_be32(time(0) - DECADE
);
2022 memcpy(guid
+16, &stamp
, 4);
2024 memcpy(guid
+20, &stamp
, 4);
2027 static unsigned int find_unused_vde(const struct ddf_super
*ddf
)
2030 for (i
= 0; i
< __be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2031 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2034 return DDF_NOTFOUND
;
2037 static unsigned int find_vde_by_name(const struct ddf_super
*ddf
,
2042 return DDF_NOTFOUND
;
2043 for (i
= 0; i
< __be16_to_cpu(ddf
->virt
->max_vdes
); i
++) {
2044 if (all_ff(ddf
->virt
->entries
[i
].guid
))
2046 if (!strncmp(name
, ddf
->virt
->entries
[i
].name
,
2047 sizeof(ddf
->virt
->entries
[i
].name
)))
2050 return DDF_NOTFOUND
;
2053 static unsigned int find_vde_by_guid(const struct ddf_super
*ddf
,
2057 if (guid
== NULL
|| all_ff(guid
))
2058 return DDF_NOTFOUND
;
2059 for (i
= 0; i
< __be16_to_cpu(ddf
->virt
->max_vdes
); i
++)
2060 if (!memcmp(ddf
->virt
->entries
[i
].guid
, guid
, DDF_GUID_LEN
))
2062 return DDF_NOTFOUND
;
2065 static int init_super_ddf_bvd(struct supertype
*st
,
2066 mdu_array_info_t
*info
,
2067 unsigned long long size
,
2068 char *name
, char *homehost
,
2069 int *uuid
, unsigned long long data_offset
);
2071 static int init_super_ddf(struct supertype
*st
,
2072 mdu_array_info_t
*info
,
2073 unsigned long long size
, char *name
, char *homehost
,
2074 int *uuid
, unsigned long long data_offset
)
2076 /* This is primarily called by Create when creating a new array.
2077 * We will then get add_to_super called for each component, and then
2078 * write_init_super called to write it out to each device.
2079 * For DDF, Create can create on fresh devices or on a pre-existing
2081 * To create on a pre-existing array a different method will be called.
2082 * This one is just for fresh drives.
2084 * We need to create the entire 'ddf' structure which includes:
2085 * DDF headers - these are easy.
2086 * Controller data - a Sector describing this controller .. not that
2087 * this is a controller exactly.
2088 * Physical Disk Record - one entry per device, so
2089 * leave plenty of space.
2090 * Virtual Disk Records - again, just leave plenty of space.
2091 * This just lists VDs, doesn't give details
2092 * Config records - describes the VDs that use this disk
2093 * DiskData - describes 'this' device.
2094 * BadBlockManagement - empty
2095 * Diag Space - empty
2096 * Vendor Logs - Could we put bitmaps here?
2099 struct ddf_super
*ddf
;
2102 int max_phys_disks
, max_virt_disks
;
2103 unsigned long long sector
;
2107 struct phys_disk
*pd
;
2108 struct virtual_disk
*vd
;
2110 if (data_offset
!= INVALID_SECTORS
) {
2111 pr_err("data-offset not supported by DDF\n");
2116 return init_super_ddf_bvd(st
, info
, size
, name
, homehost
, uuid
,
2119 if (posix_memalign((void**)&ddf
, 512, sizeof(*ddf
)) != 0) {
2120 pr_err("%s could not allocate superblock\n", __func__
);
2123 memset(ddf
, 0, sizeof(*ddf
));
2124 ddf
->dlist
= NULL
; /* no physical disks yet */
2125 ddf
->conflist
= NULL
; /* No virtual disks yet */
2129 /* zeroing superblock */
2133 /* At least 32MB *must* be reserved for the ddf. So let's just
2134 * start 32MB from the end, and put the primary header there.
2135 * Don't do secondary for now.
2136 * We don't know exactly where that will be yet as it could be
2137 * different on each device. To just set up the lengths.
2141 ddf
->anchor
.magic
= DDF_HEADER_MAGIC
;
2142 make_header_guid(ddf
->anchor
.guid
);
2144 memcpy(ddf
->anchor
.revision
, DDF_REVISION_2
, 8);
2145 ddf
->anchor
.seq
= __cpu_to_be32(1);
2146 ddf
->anchor
.timestamp
= __cpu_to_be32(time(0) - DECADE
);
2147 ddf
->anchor
.openflag
= 0xFF;
2148 ddf
->anchor
.foreignflag
= 0;
2149 ddf
->anchor
.enforcegroups
= 0; /* Is this best?? */
2150 ddf
->anchor
.pad0
= 0xff;
2151 memset(ddf
->anchor
.pad1
, 0xff, 12);
2152 memset(ddf
->anchor
.header_ext
, 0xff, 32);
2153 ddf
->anchor
.primary_lba
= ~(__u64
)0;
2154 ddf
->anchor
.secondary_lba
= ~(__u64
)0;
2155 ddf
->anchor
.type
= DDF_HEADER_ANCHOR
;
2156 memset(ddf
->anchor
.pad2
, 0xff, 3);
2157 ddf
->anchor
.workspace_len
= __cpu_to_be32(32768); /* Must be reserved */
2158 ddf
->anchor
.workspace_lba
= ~(__u64
)0; /* Put this at bottom
2159 of 32M reserved.. */
2160 max_phys_disks
= 1023; /* Should be enough */
2161 ddf
->anchor
.max_pd_entries
= __cpu_to_be16(max_phys_disks
);
2162 max_virt_disks
= 255;
2163 ddf
->anchor
.max_vd_entries
= __cpu_to_be16(max_virt_disks
); /* ?? */
2164 ddf
->anchor
.max_partitions
= __cpu_to_be16(64); /* ?? */
2167 ddf
->conf_rec_len
= 1 + ROUND_UP(ddf
->mppe
* (4+8), 512)/512;
2168 ddf
->anchor
.config_record_len
= __cpu_to_be16(ddf
->conf_rec_len
);
2169 ddf
->anchor
.max_primary_element_entries
= __cpu_to_be16(ddf
->mppe
);
2170 memset(ddf
->anchor
.pad3
, 0xff, 54);
2171 /* controller sections is one sector long immediately
2172 * after the ddf header */
2174 ddf
->anchor
.controller_section_offset
= __cpu_to_be32(sector
);
2175 ddf
->anchor
.controller_section_length
= __cpu_to_be32(1);
2178 /* phys is 8 sectors after that */
2179 pdsize
= ROUND_UP(sizeof(struct phys_disk
) +
2180 sizeof(struct phys_disk_entry
)*max_phys_disks
,
2182 switch(pdsize
/512) {
2183 case 2: case 8: case 32: case 128: case 512: break;
2186 ddf
->anchor
.phys_section_offset
= __cpu_to_be32(sector
);
2187 ddf
->anchor
.phys_section_length
=
2188 __cpu_to_be32(pdsize
/512); /* max_primary_element_entries/8 */
2189 sector
+= pdsize
/512;
2191 /* virt is another 32 sectors */
2192 vdsize
= ROUND_UP(sizeof(struct virtual_disk
) +
2193 sizeof(struct virtual_entry
) * max_virt_disks
,
2195 switch(vdsize
/512) {
2196 case 2: case 8: case 32: case 128: case 512: break;
2199 ddf
->anchor
.virt_section_offset
= __cpu_to_be32(sector
);
2200 ddf
->anchor
.virt_section_length
=
2201 __cpu_to_be32(vdsize
/512); /* max_vd_entries/8 */
2202 sector
+= vdsize
/512;
2204 clen
= ddf
->conf_rec_len
* (ddf
->max_part
+1);
2205 ddf
->anchor
.config_section_offset
= __cpu_to_be32(sector
);
2206 ddf
->anchor
.config_section_length
= __cpu_to_be32(clen
);
2209 ddf
->anchor
.data_section_offset
= __cpu_to_be32(sector
);
2210 ddf
->anchor
.data_section_length
= __cpu_to_be32(1);
2213 ddf
->anchor
.bbm_section_length
= __cpu_to_be32(0);
2214 ddf
->anchor
.bbm_section_offset
= __cpu_to_be32(0xFFFFFFFF);
2215 ddf
->anchor
.diag_space_length
= __cpu_to_be32(0);
2216 ddf
->anchor
.diag_space_offset
= __cpu_to_be32(0xFFFFFFFF);
2217 ddf
->anchor
.vendor_length
= __cpu_to_be32(0);
2218 ddf
->anchor
.vendor_offset
= __cpu_to_be32(0xFFFFFFFF);
2220 memset(ddf
->anchor
.pad4
, 0xff, 256);
2222 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
2223 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
2225 ddf
->primary
.openflag
= 1; /* I guess.. */
2226 ddf
->primary
.type
= DDF_HEADER_PRIMARY
;
2228 ddf
->secondary
.openflag
= 1; /* I guess.. */
2229 ddf
->secondary
.type
= DDF_HEADER_SECONDARY
;
2231 ddf
->active
= &ddf
->primary
;
2233 ddf
->controller
.magic
= DDF_CONTROLLER_MAGIC
;
2235 /* 24 more bytes of fiction required.
2236 * first 8 are a 'vendor-id' - "Linux-MD"
2237 * Remaining 16 are serial number.... maybe a hostname would do?
2239 memcpy(ddf
->controller
.guid
, T10
, sizeof(T10
));
2240 gethostname(hostname
, sizeof(hostname
));
2241 hostname
[sizeof(hostname
) - 1] = 0;
2242 hostlen
= strlen(hostname
);
2243 memcpy(ddf
->controller
.guid
+ 24 - hostlen
, hostname
, hostlen
);
2244 for (i
= strlen(T10
) ; i
+hostlen
< 24; i
++)
2245 ddf
->controller
.guid
[i
] = ' ';
2247 ddf
->controller
.type
.vendor_id
= __cpu_to_be16(0xDEAD);
2248 ddf
->controller
.type
.device_id
= __cpu_to_be16(0xBEEF);
2249 ddf
->controller
.type
.sub_vendor_id
= 0;
2250 ddf
->controller
.type
.sub_device_id
= 0;
2251 memcpy(ddf
->controller
.product_id
, "What Is My PID??", 16);
2252 memset(ddf
->controller
.pad
, 0xff, 8);
2253 memset(ddf
->controller
.vendor_data
, 0xff, 448);
2254 if (homehost
&& strlen(homehost
) < 440)
2255 strcpy((char*)ddf
->controller
.vendor_data
, homehost
);
2257 if (posix_memalign((void**)&pd
, 512, pdsize
) != 0) {
2258 pr_err("%s could not allocate pd\n", __func__
);
2262 ddf
->pdsize
= pdsize
;
2264 memset(pd
, 0xff, pdsize
);
2265 memset(pd
, 0, sizeof(*pd
));
2266 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2267 pd
->used_pdes
= __cpu_to_be16(0);
2268 pd
->max_pdes
= __cpu_to_be16(max_phys_disks
);
2269 memset(pd
->pad
, 0xff, 52);
2270 for (i
= 0; i
< max_phys_disks
; i
++)
2271 memset(pd
->entries
[i
].guid
, 0xff, DDF_GUID_LEN
);
2273 if (posix_memalign((void**)&vd
, 512, vdsize
) != 0) {
2274 pr_err("%s could not allocate vd\n", __func__
);
2278 ddf
->vdsize
= vdsize
;
2279 memset(vd
, 0, vdsize
);
2280 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
2281 vd
->populated_vdes
= __cpu_to_be16(0);
2282 vd
->max_vdes
= __cpu_to_be16(max_virt_disks
);
2283 memset(vd
->pad
, 0xff, 52);
2285 for (i
=0; i
<max_virt_disks
; i
++)
2286 memset(&vd
->entries
[i
], 0xff, sizeof(struct virtual_entry
));
2289 ddf_set_updates_pending(ddf
);
2293 static int chunk_to_shift(int chunksize
)
2295 return ffs(chunksize
/512)-1;
2300 unsigned long long start
, size
;
2302 static int cmp_extent(const void *av
, const void *bv
)
2304 const struct extent
*a
= av
;
2305 const struct extent
*b
= bv
;
2306 if (a
->start
< b
->start
)
2308 if (a
->start
> b
->start
)
2313 static struct extent
*get_extents(struct ddf_super
*ddf
, struct dl
*dl
)
2315 /* find a list of used extents on the give physical device
2316 * (dnum) of the given ddf.
2317 * Return a malloced array of 'struct extent'
2319 * FIXME ignore DDF_Legacy devices?
2326 rv
= xmalloc(sizeof(struct extent
) * (ddf
->max_part
+ 2));
2328 for (i
= 0; i
< ddf
->max_part
; i
++) {
2329 const struct vd_config
*bvd
;
2331 struct vcl
*v
= dl
->vlist
[i
];
2333 get_pd_index_from_refnum(v
, dl
->disk
.refnum
, ddf
->mppe
,
2334 &bvd
, &ibvd
) == DDF_NOTFOUND
)
2336 rv
[n
].start
= __be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[ibvd
]);
2337 rv
[n
].size
= __be64_to_cpu(bvd
->blocks
);
2340 qsort(rv
, n
, sizeof(*rv
), cmp_extent
);
2342 rv
[n
].start
= __be64_to_cpu(ddf
->phys
->entries
[dl
->pdnum
].config_size
);
2348 static int init_super_ddf_bvd(struct supertype
*st
,
2349 mdu_array_info_t
*info
,
2350 unsigned long long size
,
2351 char *name
, char *homehost
,
2352 int *uuid
, unsigned long long data_offset
)
2354 /* We are creating a BVD inside a pre-existing container.
2355 * so st->sb is already set.
2356 * We need to create a new vd_config and a new virtual_entry
2358 struct ddf_super
*ddf
= st
->sb
;
2359 unsigned int venum
, i
;
2360 struct virtual_entry
*ve
;
2362 struct vd_config
*vc
;
2364 if (find_vde_by_name(ddf
, name
) != DDF_NOTFOUND
) {
2365 pr_err("This ddf already has an array called %s\n", name
);
2368 venum
= find_unused_vde(ddf
);
2369 if (venum
== DDF_NOTFOUND
) {
2370 pr_err("Cannot find spare slot for virtual disk\n");
2373 ve
= &ddf
->virt
->entries
[venum
];
2375 /* A Virtual Disk GUID contains the T10 Vendor ID, controller type,
2376 * timestamp, random number
2378 make_header_guid(ve
->guid
);
2379 ve
->unit
= __cpu_to_be16(info
->md_minor
);
2381 ve
->guid_crc
= crc32(0, (unsigned char*)ddf
->anchor
.guid
, DDF_GUID_LEN
);
2383 ve
->state
= DDF_state_degraded
; /* Will be modified as devices are added */
2384 if (info
->state
& 1) /* clean */
2385 ve
->init_state
= DDF_init_full
;
2387 ve
->init_state
= DDF_init_not
;
2389 memset(ve
->pad1
, 0xff, 14);
2390 memset(ve
->name
, ' ', 16);
2392 strncpy(ve
->name
, name
, 16);
2393 ddf
->virt
->populated_vdes
=
2394 __cpu_to_be16(__be16_to_cpu(ddf
->virt
->populated_vdes
)+1);
2396 /* Now create a new vd_config */
2397 if (posix_memalign((void**)&vcl
, 512,
2398 (offsetof(struct vcl
, conf
) + ddf
->conf_rec_len
* 512)) != 0) {
2399 pr_err("%s could not allocate vd_config\n", __func__
);
2403 vcl
->block_sizes
= NULL
; /* FIXME not for CONCAT */
2406 vc
->magic
= DDF_VD_CONF_MAGIC
;
2407 memcpy(vc
->guid
, ve
->guid
, DDF_GUID_LEN
);
2408 vc
->timestamp
= __cpu_to_be32(time(0)-DECADE
);
2409 vc
->seqnum
= __cpu_to_be32(1);
2410 memset(vc
->pad0
, 0xff, 24);
2411 vc
->chunk_shift
= chunk_to_shift(info
->chunk_size
);
2412 if (layout_md2ddf(info
, vc
) == -1 ||
2413 __be16_to_cpu(vc
->prim_elmnt_count
) > ddf
->mppe
) {
2414 pr_err("%s: unsupported RAID level/layout %d/%d with %d disks\n",
2415 __func__
, info
->level
, info
->layout
, info
->raid_disks
);
2419 vc
->sec_elmnt_seq
= 0;
2420 if (alloc_other_bvds(ddf
, vcl
) != 0) {
2421 pr_err("%s could not allocate other bvds\n",
2426 vc
->blocks
= __cpu_to_be64(info
->size
* 2);
2427 vc
->array_blocks
= __cpu_to_be64(
2428 calc_array_size(info
->level
, info
->raid_disks
, info
->layout
,
2429 info
->chunk_size
, info
->size
*2));
2430 memset(vc
->pad1
, 0xff, 8);
2431 vc
->spare_refs
[0] = 0xffffffff;
2432 vc
->spare_refs
[1] = 0xffffffff;
2433 vc
->spare_refs
[2] = 0xffffffff;
2434 vc
->spare_refs
[3] = 0xffffffff;
2435 vc
->spare_refs
[4] = 0xffffffff;
2436 vc
->spare_refs
[5] = 0xffffffff;
2437 vc
->spare_refs
[6] = 0xffffffff;
2438 vc
->spare_refs
[7] = 0xffffffff;
2439 memset(vc
->cache_pol
, 0, 8);
2441 memset(vc
->pad2
, 0xff, 3);
2442 memset(vc
->pad3
, 0xff, 52);
2443 memset(vc
->pad4
, 0xff, 192);
2444 memset(vc
->v0
, 0xff, 32);
2445 memset(vc
->v1
, 0xff, 32);
2446 memset(vc
->v2
, 0xff, 16);
2447 memset(vc
->v3
, 0xff, 16);
2448 memset(vc
->vendor
, 0xff, 32);
2450 memset(vc
->phys_refnum
, 0xff, 4*ddf
->mppe
);
2451 memset(vc
->phys_refnum
+ddf
->mppe
, 0x00, 8*ddf
->mppe
);
2453 for (i
= 1; i
< vc
->sec_elmnt_count
; i
++) {
2454 memcpy(vcl
->other_bvds
[i
-1], vc
, ddf
->conf_rec_len
* 512);
2455 vcl
->other_bvds
[i
-1]->sec_elmnt_seq
= i
;
2458 vcl
->next
= ddf
->conflist
;
2459 ddf
->conflist
= vcl
;
2460 ddf
->currentconf
= vcl
;
2461 ddf_set_updates_pending(ddf
);
2465 static int get_svd_state(const struct ddf_super
*, const struct vcl
*);
2468 static void add_to_super_ddf_bvd(struct supertype
*st
,
2469 mdu_disk_info_t
*dk
, int fd
, char *devname
)
2471 /* fd and devname identify a device with-in the ddf container (st).
2472 * dk identifies a location in the new BVD.
2473 * We need to find suitable free space in that device and update
2474 * the phys_refnum and lba_offset for the newly created vd_config.
2475 * We might also want to update the type in the phys_disk
2478 * Alternately: fd == -1 and we have already chosen which device to
2479 * use and recorded in dlist->raid_disk;
2482 struct ddf_super
*ddf
= st
->sb
;
2483 struct vd_config
*vc
;
2485 unsigned long long blocks
, pos
, esize
;
2487 unsigned int raid_disk
= dk
->raid_disk
;
2490 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2491 if (dl
->raiddisk
== dk
->raid_disk
)
2494 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2495 if (dl
->major
== dk
->major
&&
2496 dl
->minor
== dk
->minor
)
2499 if (!dl
|| ! (dk
->state
& (1<<MD_DISK_SYNC
)))
2502 vc
= &ddf
->currentconf
->conf
;
2503 if (vc
->sec_elmnt_count
> 1) {
2504 unsigned int n
= __be16_to_cpu(vc
->prim_elmnt_count
);
2506 vc
= ddf
->currentconf
->other_bvds
[raid_disk
/ n
- 1];
2510 ex
= get_extents(ddf
, dl
);
2515 blocks
= __be64_to_cpu(vc
->blocks
);
2516 if (ddf
->currentconf
->block_sizes
)
2517 blocks
= ddf
->currentconf
->block_sizes
[dk
->raid_disk
];
2520 esize
= ex
[i
].start
- pos
;
2521 if (esize
>= blocks
)
2523 pos
= ex
[i
].start
+ ex
[i
].size
;
2525 } while (ex
[i
-1].size
);
2531 ddf
->currentdev
= dk
->raid_disk
;
2532 vc
->phys_refnum
[raid_disk
] = dl
->disk
.refnum
;
2533 LBA_OFFSET(ddf
, vc
)[raid_disk
] = __cpu_to_be64(pos
);
2535 for (i
= 0; i
< ddf
->max_part
; i
++)
2536 if (dl
->vlist
[i
] == NULL
)
2538 if (i
== ddf
->max_part
)
2540 dl
->vlist
[i
] = ddf
->currentconf
;
2545 dl
->devname
= devname
;
2547 /* Check if we can mark array as optimal yet */
2548 i
= ddf
->currentconf
->vcnum
;
2549 ddf
->virt
->entries
[i
].state
=
2550 (ddf
->virt
->entries
[i
].state
& ~DDF_state_mask
)
2551 | get_svd_state(ddf
, ddf
->currentconf
);
2552 ddf
->phys
->entries
[dl
->pdnum
].type
&= ~__cpu_to_be16(DDF_Global_Spare
);
2553 ddf
->phys
->entries
[dl
->pdnum
].type
|= __cpu_to_be16(DDF_Active_in_VD
);
2554 ddf_set_updates_pending(ddf
);
2557 static unsigned int find_unused_pde(const struct ddf_super
*ddf
)
2560 for (i
= 0; i
< __be16_to_cpu(ddf
->phys
->max_pdes
); i
++) {
2561 if (all_ff(ddf
->phys
->entries
[i
].guid
))
2564 return DDF_NOTFOUND
;
2567 /* add a device to a container, either while creating it or while
2568 * expanding a pre-existing container
2570 static int add_to_super_ddf(struct supertype
*st
,
2571 mdu_disk_info_t
*dk
, int fd
, char *devname
,
2572 unsigned long long data_offset
)
2574 struct ddf_super
*ddf
= st
->sb
;
2578 unsigned long long size
;
2579 struct phys_disk_entry
*pde
;
2584 if (ddf
->currentconf
) {
2585 add_to_super_ddf_bvd(st
, dk
, fd
, devname
);
2589 /* This is device numbered dk->number. We need to create
2590 * a phys_disk entry and a more detailed disk_data entry.
2593 n
= find_unused_pde(ddf
);
2594 if (n
== DDF_NOTFOUND
) {
2595 pr_err("%s: No free slot in array, cannot add disk\n",
2599 pde
= &ddf
->phys
->entries
[n
];
2600 get_dev_size(fd
, NULL
, &size
);
2601 if (size
<= 32*1024*1024) {
2602 pr_err("%s: device size must be at least 32MB\n",
2608 if (posix_memalign((void**)&dd
, 512,
2609 sizeof(*dd
) + sizeof(dd
->vlist
[0]) * ddf
->max_part
) != 0) {
2610 pr_err("%s could allocate buffer for new disk, aborting\n",
2614 dd
->major
= major(stb
.st_rdev
);
2615 dd
->minor
= minor(stb
.st_rdev
);
2616 dd
->devname
= devname
;
2620 dd
->disk
.magic
= DDF_PHYS_DATA_MAGIC
;
2622 tm
= localtime(&now
);
2623 sprintf(dd
->disk
.guid
, "%8s%04d%02d%02d",
2624 T10
, tm
->tm_year
+1900, tm
->tm_mon
+1, tm
->tm_mday
);
2625 tptr
= (__u32
*)(dd
->disk
.guid
+ 16);
2626 *tptr
++ = random32();
2630 /* Cannot be bothered finding a CRC of some irrelevant details*/
2631 dd
->disk
.refnum
= random32();
2632 for (i
= __be16_to_cpu(ddf
->active
->max_pd_entries
);
2634 if (ddf
->phys
->entries
[i
-1].refnum
== dd
->disk
.refnum
)
2638 dd
->disk
.forced_ref
= 1;
2639 dd
->disk
.forced_guid
= 1;
2640 memset(dd
->disk
.vendor
, ' ', 32);
2641 memcpy(dd
->disk
.vendor
, "Linux", 5);
2642 memset(dd
->disk
.pad
, 0xff, 442);
2643 for (i
= 0; i
< ddf
->max_part
; i
++)
2644 dd
->vlist
[i
] = NULL
;
2648 if (st
->update_tail
) {
2649 int len
= (sizeof(struct phys_disk
) +
2650 sizeof(struct phys_disk_entry
));
2651 struct phys_disk
*pd
;
2654 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2655 pd
->used_pdes
= __cpu_to_be16(n
);
2656 pde
= &pd
->entries
[0];
2659 ddf
->phys
->used_pdes
= __cpu_to_be16(
2660 1 + __be16_to_cpu(ddf
->phys
->used_pdes
));
2662 memcpy(pde
->guid
, dd
->disk
.guid
, DDF_GUID_LEN
);
2663 pde
->refnum
= dd
->disk
.refnum
;
2664 pde
->type
= __cpu_to_be16(DDF_Forced_PD_GUID
| DDF_Global_Spare
);
2665 pde
->state
= __cpu_to_be16(DDF_Online
);
2668 * If there is already a device in dlist, try to reserve the same
2669 * amount of workspace. Otherwise, use 32MB.
2670 * We checked disk size above already.
2672 #define __calc_lba(new, old, lba, mb) do { \
2673 unsigned long long dif; \
2674 if ((old) != NULL) \
2675 dif = (old)->size - __be64_to_cpu((old)->lba); \
2677 dif = (new)->size; \
2678 if ((new)->size > dif) \
2679 (new)->lba = __cpu_to_be64((new)->size - dif); \
2681 (new)->lba = __cpu_to_be64((new)->size - (mb*1024*2)); \
2683 __calc_lba(dd
, ddf
->dlist
, workspace_lba
, 32);
2684 __calc_lba(dd
, ddf
->dlist
, primary_lba
, 16);
2685 __calc_lba(dd
, ddf
->dlist
, secondary_lba
, 32);
2686 pde
->config_size
= dd
->workspace_lba
;
2688 sprintf(pde
->path
, "%17.17s","Information: nil") ;
2689 memset(pde
->pad
, 0xff, 6);
2691 if (st
->update_tail
) {
2692 dd
->next
= ddf
->add_list
;
2695 dd
->next
= ddf
->dlist
;
2697 ddf_set_updates_pending(ddf
);
2703 static int remove_from_super_ddf(struct supertype
*st
, mdu_disk_info_t
*dk
)
2705 struct ddf_super
*ddf
= st
->sb
;
2708 /* mdmon has noticed that this disk (dk->major/dk->minor) has
2709 * disappeared from the container.
2710 * We need to arrange that it disappears from the metadata and
2711 * internal data structures too.
2712 * Most of the work is done by ddf_process_update which edits
2713 * the metadata and closes the file handle and attaches the memory
2714 * where free_updates will free it.
2716 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
2717 if (dl
->major
== dk
->major
&&
2718 dl
->minor
== dk
->minor
)
2723 if (st
->update_tail
) {
2724 int len
= (sizeof(struct phys_disk
) +
2725 sizeof(struct phys_disk_entry
));
2726 struct phys_disk
*pd
;
2729 pd
->magic
= DDF_PHYS_RECORDS_MAGIC
;
2730 pd
->used_pdes
= __cpu_to_be16(dl
->pdnum
);
2731 pd
->entries
[0].state
= __cpu_to_be16(DDF_Missing
);
2732 append_metadata_update(st
, pd
, len
);
2738 * This is the write_init_super method for a ddf container. It is
2739 * called when creating a container or adding another device to a
2742 #define NULL_CONF_SZ 4096
2744 static int __write_ddf_structure(struct dl
*d
, struct ddf_super
*ddf
, __u8 type
,
2747 unsigned long long sector
;
2748 struct ddf_header
*header
;
2749 int fd
, i
, n_config
, conf_size
;
2755 case DDF_HEADER_PRIMARY
:
2756 header
= &ddf
->primary
;
2757 sector
= __be64_to_cpu(header
->primary_lba
);
2759 case DDF_HEADER_SECONDARY
:
2760 header
= &ddf
->secondary
;
2761 sector
= __be64_to_cpu(header
->secondary_lba
);
2767 header
->type
= type
;
2768 header
->openflag
= 1;
2769 header
->crc
= calc_crc(header
, 512);
2771 lseek64(fd
, sector
<<9, 0);
2772 if (write(fd
, header
, 512) < 0)
2775 ddf
->controller
.crc
= calc_crc(&ddf
->controller
, 512);
2776 if (write(fd
, &ddf
->controller
, 512) < 0)
2779 ddf
->phys
->crc
= calc_crc(ddf
->phys
, ddf
->pdsize
);
2780 if (write(fd
, ddf
->phys
, ddf
->pdsize
) < 0)
2782 ddf
->virt
->crc
= calc_crc(ddf
->virt
, ddf
->vdsize
);
2783 if (write(fd
, ddf
->virt
, ddf
->vdsize
) < 0)
2786 /* Now write lots of config records. */
2787 n_config
= ddf
->max_part
;
2788 conf_size
= ddf
->conf_rec_len
* 512;
2789 for (i
= 0 ; i
<= n_config
; i
++) {
2791 struct vd_config
*vdc
= NULL
;
2792 if (i
== n_config
) {
2793 c
= (struct vcl
*)d
->spare
;
2800 get_pd_index_from_refnum(
2803 (const struct vd_config
**)&vdc
,
2807 dprintf("writing conf record %i on disk %08x for %s/%u\n",
2808 i
, d
->disk
.refnum
, guid_str(vdc
->guid
),
2809 vdc
->sec_elmnt_seq
);
2810 vdc
->seqnum
= header
->seq
;
2811 vdc
->crc
= calc_crc(vdc
, conf_size
);
2812 if (write(fd
, vdc
, conf_size
) < 0)
2815 unsigned int togo
= conf_size
;
2816 while (togo
> NULL_CONF_SZ
) {
2817 if (write(fd
, null_aligned
, NULL_CONF_SZ
) < 0)
2819 togo
-= NULL_CONF_SZ
;
2821 if (write(fd
, null_aligned
, togo
) < 0)
2828 d
->disk
.crc
= calc_crc(&d
->disk
, 512);
2829 if (write(fd
, &d
->disk
, 512) < 0)
2834 header
->openflag
= 0;
2835 header
->crc
= calc_crc(header
, 512);
2837 lseek64(fd
, sector
<<9, 0);
2838 if (write(fd
, header
, 512) < 0)
2844 static int __write_init_super_ddf(struct supertype
*st
)
2846 struct ddf_super
*ddf
= st
->sb
;
2850 unsigned long long size
;
2854 pr_state(ddf
, __func__
);
2855 if (posix_memalign((void**)&null_aligned
, 4096, NULL_CONF_SZ
) != 0) {
2858 memset(null_aligned
, 0xff, NULL_CONF_SZ
);
2860 seq
= ddf
->active
->seq
+ 1;
2862 /* try to write updated metadata,
2863 * if we catch a failure move on to the next disk
2865 for (d
= ddf
->dlist
; d
; d
=d
->next
) {
2872 /* We need to fill in the primary, (secondary) and workspace
2873 * lba's in the headers, set their checksums,
2874 * Also checksum phys, virt....
2876 * Then write everything out, finally the anchor is written.
2878 get_dev_size(fd
, NULL
, &size
);
2880 if (d
->workspace_lba
!= 0)
2881 ddf
->anchor
.workspace_lba
= d
->workspace_lba
;
2883 ddf
->anchor
.workspace_lba
=
2884 __cpu_to_be64(size
- 32*1024*2);
2885 if (d
->primary_lba
!= 0)
2886 ddf
->anchor
.primary_lba
= d
->primary_lba
;
2888 ddf
->anchor
.primary_lba
=
2889 __cpu_to_be64(size
- 16*1024*2);
2890 if (d
->secondary_lba
!= 0)
2891 ddf
->anchor
.secondary_lba
= d
->secondary_lba
;
2893 ddf
->anchor
.secondary_lba
=
2894 __cpu_to_be64(size
- 32*1024*2);
2895 ddf
->anchor
.seq
= seq
;
2896 memcpy(&ddf
->primary
, &ddf
->anchor
, 512);
2897 memcpy(&ddf
->secondary
, &ddf
->anchor
, 512);
2899 ddf
->anchor
.openflag
= 0xFF; /* 'open' means nothing */
2900 ddf
->anchor
.seq
= 0xFFFFFFFF; /* no sequencing in anchor */
2901 ddf
->anchor
.crc
= calc_crc(&ddf
->anchor
, 512);
2903 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_PRIMARY
,
2907 if (!__write_ddf_structure(d
, ddf
, DDF_HEADER_SECONDARY
,
2911 lseek64(fd
, (size
-1)*512, SEEK_SET
);
2912 if (write(fd
, &ddf
->anchor
, 512) < 0)
2918 return attempts
!= successes
;
2921 static int write_init_super_ddf(struct supertype
*st
)
2923 struct ddf_super
*ddf
= st
->sb
;
2924 struct vcl
*currentconf
= ddf
->currentconf
;
2926 /* we are done with currentconf reset it to point st at the container */
2927 ddf
->currentconf
= NULL
;
2929 if (st
->update_tail
) {
2930 /* queue the virtual_disk and vd_config as metadata updates */
2931 struct virtual_disk
*vd
;
2932 struct vd_config
*vc
;
2936 int len
= (sizeof(struct phys_disk
) +
2937 sizeof(struct phys_disk_entry
));
2939 /* adding a disk to the container. */
2943 append_metadata_update(st
, ddf
->add_list
->mdupdate
, len
);
2944 ddf
->add_list
->mdupdate
= NULL
;
2948 /* Newly created VD */
2950 /* First the virtual disk. We have a slightly fake header */
2951 len
= sizeof(struct virtual_disk
) + sizeof(struct virtual_entry
);
2954 vd
->entries
[0] = ddf
->virt
->entries
[currentconf
->vcnum
];
2955 vd
->populated_vdes
= __cpu_to_be16(currentconf
->vcnum
);
2956 append_metadata_update(st
, vd
, len
);
2958 /* Then the vd_config */
2959 len
= ddf
->conf_rec_len
* 512;
2961 memcpy(vc
, ¤tconf
->conf
, len
);
2962 append_metadata_update(st
, vc
, len
);
2964 /* FIXME I need to close the fds! */
2969 for (d
= ddf
->dlist
; d
; d
=d
->next
)
2970 while (Kill(d
->devname
, NULL
, 0, -1, 1) == 0);
2971 return __write_init_super_ddf(st
);
2977 static __u64
avail_size_ddf(struct supertype
*st
, __u64 devsize
,
2978 unsigned long long data_offset
)
2980 /* We must reserve the last 32Meg */
2981 if (devsize
<= 32*1024*2)
2983 return devsize
- 32*1024*2;
2988 static int reserve_space(struct supertype
*st
, int raiddisks
,
2989 unsigned long long size
, int chunk
,
2990 unsigned long long *freesize
)
2992 /* Find 'raiddisks' spare extents at least 'size' big (but
2993 * only caring about multiples of 'chunk') and remember
2995 * If the cannot be found, fail.
2998 struct ddf_super
*ddf
= st
->sb
;
3001 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3005 /* Now find largest extent on each device */
3006 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3007 struct extent
*e
= get_extents(ddf
, dl
);
3008 unsigned long long pos
= 0;
3011 unsigned long long minsize
= size
;
3019 unsigned long long esize
;
3020 esize
= e
[i
].start
- pos
;
3021 if (esize
>= minsize
) {
3025 pos
= e
[i
].start
+ e
[i
].size
;
3027 } while (e
[i
-1].size
);
3030 dl
->esize
= minsize
;
3034 if (cnt
< raiddisks
) {
3035 pr_err("not enough devices with space to create array.\n");
3036 return 0; /* No enough free spaces large enough */
3039 /* choose the largest size of which there are at least 'raiddisk' */
3040 for (dl
= ddf
->dlist
; dl
; dl
=dl
->next
) {
3042 if (dl
->esize
<= size
)
3044 /* This is bigger than 'size', see if there are enough */
3046 for (dl2
= ddf
->dlist
; dl2
; dl2
=dl2
->next
)
3047 if (dl2
->esize
>= dl
->esize
)
3049 if (cnt
>= raiddisks
)
3053 size
= size
/ chunk
;
3058 pr_err("not enough spare devices to create array.\n");
3062 /* We have a 'size' of which there are enough spaces.
3063 * We simply do a first-fit */
3065 for (dl
= ddf
->dlist
; dl
&& cnt
< raiddisks
; dl
=dl
->next
) {
3066 if (dl
->esize
< size
)
3076 validate_geometry_ddf_container(struct supertype
*st
,
3077 int level
, int layout
, int raiddisks
,
3078 int chunk
, unsigned long long size
,
3079 unsigned long long data_offset
,
3080 char *dev
, unsigned long long *freesize
,
3083 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3084 int level
, int layout
, int raiddisks
,
3085 int *chunk
, unsigned long long size
,
3086 unsigned long long data_offset
,
3087 char *dev
, unsigned long long *freesize
,
3090 static int validate_geometry_ddf(struct supertype
*st
,
3091 int level
, int layout
, int raiddisks
,
3092 int *chunk
, unsigned long long size
,
3093 unsigned long long data_offset
,
3094 char *dev
, unsigned long long *freesize
,
3101 /* ddf potentially supports lots of things, but it depends on
3102 * what devices are offered (and maybe kernel version?)
3103 * If given unused devices, we will make a container.
3104 * If given devices in a container, we will make a BVD.
3105 * If given BVDs, we make an SVD, changing all the GUIDs in the process.
3108 if (chunk
&& *chunk
== UnSet
)
3109 *chunk
= DEFAULT_CHUNK
;
3111 if (level
== -1000000) level
= LEVEL_CONTAINER
;
3112 if (level
== LEVEL_CONTAINER
) {
3113 /* Must be a fresh device to add to a container */
3114 return validate_geometry_ddf_container(st
, level
, layout
,
3115 raiddisks
, chunk
?*chunk
:0,
3116 size
, data_offset
, dev
,
3122 mdu_array_info_t array
= {
3123 .level
= level
, .layout
= layout
,
3124 .raid_disks
= raiddisks
3126 struct vd_config conf
;
3127 if (layout_md2ddf(&array
, &conf
) == -1) {
3129 pr_err("DDF does not support level %d /layout %d arrays with %d disks\n",
3130 level
, layout
, raiddisks
);
3133 /* Should check layout? etc */
3135 if (st
->sb
&& freesize
) {
3136 /* --create was given a container to create in.
3137 * So we need to check that there are enough
3138 * free spaces and return the amount of space.
3139 * We may as well remember which drives were
3140 * chosen so that add_to_super/getinfo_super
3143 return reserve_space(st
, raiddisks
, size
, chunk
?*chunk
:0, freesize
);
3149 /* A container has already been opened, so we are
3150 * creating in there. Maybe a BVD, maybe an SVD.
3151 * Should make a distinction one day.
3153 return validate_geometry_ddf_bvd(st
, level
, layout
, raiddisks
,
3154 chunk
, size
, data_offset
, dev
,
3158 /* This is the first device for the array.
3159 * If it is a container, we read it in and do automagic allocations,
3160 * no other devices should be given.
3161 * Otherwise it must be a member device of a container, and we
3162 * do manual allocation.
3163 * Later we should check for a BVD and make an SVD.
3165 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3167 sra
= sysfs_read(fd
, NULL
, GET_VERSION
);
3169 if (sra
&& sra
->array
.major_version
== -1 &&
3170 strcmp(sra
->text_version
, "ddf") == 0) {
3173 /* find space for 'n' devices. */
3174 /* remember the devices */
3175 /* Somehow return the fact that we have enough */
3179 pr_err("ddf: Cannot create this array "
3180 "on device %s - a container is required.\n",
3184 if (errno
!= EBUSY
|| (fd
= open(dev
, O_RDONLY
, 0)) < 0) {
3186 pr_err("ddf: Cannot open %s: %s\n",
3187 dev
, strerror(errno
));
3190 /* Well, it is in use by someone, maybe a 'ddf' container. */
3191 cfd
= open_container(fd
);
3195 pr_err("ddf: Cannot use %s: %s\n",
3196 dev
, strerror(EBUSY
));
3199 sra
= sysfs_read(cfd
, NULL
, GET_VERSION
);
3201 if (sra
&& sra
->array
.major_version
== -1 &&
3202 strcmp(sra
->text_version
, "ddf") == 0) {
3203 /* This is a member of a ddf container. Load the container
3204 * and try to create a bvd
3206 struct ddf_super
*ddf
;
3207 if (load_super_ddf_all(st
, cfd
, (void **)&ddf
, NULL
) == 0) {
3209 strcpy(st
->container_devnm
, fd2devnm(cfd
));
3211 return validate_geometry_ddf_bvd(st
, level
, layout
,
3212 raiddisks
, chunk
, size
,
3218 } else /* device may belong to a different container */
3225 validate_geometry_ddf_container(struct supertype
*st
,
3226 int level
, int layout
, int raiddisks
,
3227 int chunk
, unsigned long long size
,
3228 unsigned long long data_offset
,
3229 char *dev
, unsigned long long *freesize
,
3233 unsigned long long ldsize
;
3235 if (level
!= LEVEL_CONTAINER
)
3240 fd
= open(dev
, O_RDONLY
|O_EXCL
, 0);
3243 pr_err("ddf: Cannot open %s: %s\n",
3244 dev
, strerror(errno
));
3247 if (!get_dev_size(fd
, dev
, &ldsize
)) {
3253 *freesize
= avail_size_ddf(st
, ldsize
>> 9, INVALID_SECTORS
);
3260 static int validate_geometry_ddf_bvd(struct supertype
*st
,
3261 int level
, int layout
, int raiddisks
,
3262 int *chunk
, unsigned long long size
,
3263 unsigned long long data_offset
,
3264 char *dev
, unsigned long long *freesize
,
3268 struct ddf_super
*ddf
= st
->sb
;
3270 unsigned long long pos
= 0;
3271 unsigned long long maxsize
;
3274 /* ddf/bvd supports lots of things, but not containers */
3275 if (level
== LEVEL_CONTAINER
) {
3277 pr_err("DDF cannot create a container within an container\n");
3280 /* We must have the container info already read in. */
3285 /* General test: make sure there is space for
3286 * 'raiddisks' device extents of size 'size'.
3288 unsigned long long minsize
= size
;
3292 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3298 e
= get_extents(ddf
, dl
);
3301 unsigned long long esize
;
3302 esize
= e
[i
].start
- pos
;
3303 if (esize
>= minsize
)
3305 pos
= e
[i
].start
+ e
[i
].size
;
3307 } while (e
[i
-1].size
);
3312 if (dcnt
< raiddisks
) {
3314 pr_err("ddf: Not enough devices with "
3315 "space for this array (%d < %d)\n",
3321 /* This device must be a member of the set */
3322 if (stat(dev
, &stb
) < 0)
3324 if ((S_IFMT
& stb
.st_mode
) != S_IFBLK
)
3326 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
3327 if (dl
->major
== (int)major(stb
.st_rdev
) &&
3328 dl
->minor
== (int)minor(stb
.st_rdev
))
3333 pr_err("ddf: %s is not in the "
3338 e
= get_extents(ddf
, dl
);
3342 unsigned long long esize
;
3343 esize
= e
[i
].start
- pos
;
3344 if (esize
>= maxsize
)
3346 pos
= e
[i
].start
+ e
[i
].size
;
3348 } while (e
[i
-1].size
);
3349 *freesize
= maxsize
;
3355 static int load_super_ddf_all(struct supertype
*st
, int fd
,
3356 void **sbp
, char *devname
)
3359 struct ddf_super
*super
;
3360 struct mdinfo
*sd
, *best
= NULL
;
3366 sra
= sysfs_read(fd
, 0, GET_LEVEL
|GET_VERSION
|GET_DEVS
|GET_STATE
);
3369 if (sra
->array
.major_version
!= -1 ||
3370 sra
->array
.minor_version
!= -2 ||
3371 strcmp(sra
->text_version
, "ddf") != 0)
3374 if (posix_memalign((void**)&super
, 512, sizeof(*super
)) != 0)
3376 memset(super
, 0, sizeof(*super
));
3378 /* first, try each device, and choose the best ddf */
3379 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3381 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3382 dfd
= dev_open(nm
, O_RDONLY
);
3385 rv
= load_ddf_headers(dfd
, super
, NULL
);
3388 seq
= __be32_to_cpu(super
->active
->seq
);
3389 if (super
->active
->openflag
)
3391 if (!best
|| seq
> bestseq
) {
3399 /* OK, load this ddf */
3400 sprintf(nm
, "%d:%d", best
->disk
.major
, best
->disk
.minor
);
3401 dfd
= dev_open(nm
, O_RDONLY
);
3404 load_ddf_headers(dfd
, super
, NULL
);
3405 load_ddf_global(dfd
, super
, NULL
);
3407 /* Now we need the device-local bits */
3408 for (sd
= sra
->devs
; sd
; sd
= sd
->next
) {
3411 sprintf(nm
, "%d:%d", sd
->disk
.major
, sd
->disk
.minor
);
3412 dfd
= dev_open(nm
, O_RDWR
);
3415 rv
= load_ddf_headers(dfd
, super
, NULL
);
3417 rv
= load_ddf_local(dfd
, super
, NULL
, 1);
3423 if (st
->ss
== NULL
) {
3424 st
->ss
= &super_ddf
;
3425 st
->minor_version
= 0;
3428 strcpy(st
->container_devnm
, fd2devnm(fd
));
3432 static int load_container_ddf(struct supertype
*st
, int fd
,
3435 return load_super_ddf_all(st
, fd
, &st
->sb
, devname
);
3438 #endif /* MDASSEMBLE */
3440 static int check_secondary(const struct vcl
*vc
)
3442 const struct vd_config
*conf
= &vc
->conf
;
3445 /* The only DDF secondary RAID level md can support is
3446 * RAID 10, if the stripe sizes and Basic volume sizes
3448 * Other configurations could in theory be supported by exposing
3449 * the BVDs to user space and using device mapper for the secondary
3450 * mapping. So far we don't support that.
3453 __u64 sec_elements
[4] = {0, 0, 0, 0};
3454 #define __set_sec_seen(n) (sec_elements[(n)>>6] |= (1<<((n)&63)))
3455 #define __was_sec_seen(n) ((sec_elements[(n)>>6] & (1<<((n)&63))) != 0)
3457 if (vc
->other_bvds
== NULL
) {
3458 pr_err("No BVDs for secondary RAID found\n");
3461 if (conf
->prl
!= DDF_RAID1
) {
3462 pr_err("Secondary RAID level only supported for mirrored BVD\n");
3465 if (conf
->srl
!= DDF_2STRIPED
&& conf
->srl
!= DDF_2SPANNED
) {
3466 pr_err("Secondary RAID level %d is unsupported\n",
3470 __set_sec_seen(conf
->sec_elmnt_seq
);
3471 for (i
= 0; i
< conf
->sec_elmnt_count
-1; i
++) {
3472 const struct vd_config
*bvd
= vc
->other_bvds
[i
];
3473 if (bvd
->sec_elmnt_seq
== DDF_UNUSED_BVD
)
3475 if (bvd
->srl
!= conf
->srl
) {
3476 pr_err("Inconsistent secondary RAID level across BVDs\n");
3479 if (bvd
->prl
!= conf
->prl
) {
3480 pr_err("Different RAID levels for BVDs are unsupported\n");
3483 if (bvd
->prim_elmnt_count
!= conf
->prim_elmnt_count
) {
3484 pr_err("All BVDs must have the same number of primary elements\n");
3487 if (bvd
->chunk_shift
!= conf
->chunk_shift
) {
3488 pr_err("Different strip sizes for BVDs are unsupported\n");
3491 if (bvd
->array_blocks
!= conf
->array_blocks
) {
3492 pr_err("Different BVD sizes are unsupported\n");
3495 __set_sec_seen(bvd
->sec_elmnt_seq
);
3497 for (i
= 0; i
< conf
->sec_elmnt_count
; i
++) {
3498 if (!__was_sec_seen(i
)) {
3499 pr_err("BVD %d is missing\n", i
);
3506 static unsigned int get_pd_index_from_refnum(const struct vcl
*vc
,
3507 __u32 refnum
, unsigned int nmax
,
3508 const struct vd_config
**bvd
,
3511 unsigned int i
, j
, n
, sec
, cnt
;
3513 cnt
= __be16_to_cpu(vc
->conf
.prim_elmnt_count
);
3514 sec
= (vc
->conf
.sec_elmnt_count
== 1 ? 0 : vc
->conf
.sec_elmnt_seq
);
3516 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3517 /* j counts valid entries for this BVD */
3518 if (vc
->conf
.phys_refnum
[i
] != 0xffffffff)
3520 if (vc
->conf
.phys_refnum
[i
] == refnum
) {
3523 return sec
* cnt
+ j
- 1;
3526 if (vc
->other_bvds
== NULL
)
3529 for (n
= 1; n
< vc
->conf
.sec_elmnt_count
; n
++) {
3530 struct vd_config
*vd
= vc
->other_bvds
[n
-1];
3531 sec
= vd
->sec_elmnt_seq
;
3532 if (sec
== DDF_UNUSED_BVD
)
3534 for (i
= 0, j
= 0 ; i
< nmax
; i
++) {
3535 if (vd
->phys_refnum
[i
] != 0xffffffff)
3537 if (vd
->phys_refnum
[i
] == refnum
) {
3540 return sec
* cnt
+ j
- 1;
3546 return DDF_NOTFOUND
;
3549 static struct mdinfo
*container_content_ddf(struct supertype
*st
, char *subarray
)
3551 /* Given a container loaded by load_super_ddf_all,
3552 * extract information about all the arrays into
3555 * For each vcl in conflist: create an mdinfo, fill it in,
3556 * then look for matching devices (phys_refnum) in dlist
3557 * and create appropriate device mdinfo.
3559 struct ddf_super
*ddf
= st
->sb
;
3560 struct mdinfo
*rest
= NULL
;
3563 for (vc
= ddf
->conflist
; vc
; vc
=vc
->next
)
3567 struct mdinfo
*this;
3573 (strtoul(subarray
, &ep
, 10) != vc
->vcnum
||
3577 if (vc
->conf
.sec_elmnt_count
> 1) {
3578 if (check_secondary(vc
) != 0)
3582 this = xcalloc(1, sizeof(*this));
3586 if (layout_ddf2md(&vc
->conf
, &this->array
))
3588 this->array
.md_minor
= -1;
3589 this->array
.major_version
= -1;
3590 this->array
.minor_version
= -2;
3591 cptr
= (__u32
*)(vc
->conf
.guid
+ 16);
3592 this->array
.ctime
= DECADE
+ __be32_to_cpu(*cptr
);
3593 this->array
.utime
= DECADE
+
3594 __be32_to_cpu(vc
->conf
.timestamp
);
3595 this->array
.chunk_size
= 512 << vc
->conf
.chunk_shift
;
3598 if ((ddf
->virt
->entries
[i
].state
& DDF_state_inconsistent
) ||
3599 (ddf
->virt
->entries
[i
].init_state
& DDF_initstate_mask
) !=
3601 this->array
.state
= 0;
3602 this->resync_start
= 0;
3604 this->array
.state
= 1;
3605 this->resync_start
= MaxSector
;
3607 memcpy(this->name
, ddf
->virt
->entries
[i
].name
, 16);
3610 if (this->name
[j
] == ' ')
3613 memset(this->uuid
, 0, sizeof(this->uuid
));
3614 this->component_size
= __be64_to_cpu(vc
->conf
.blocks
);
3615 this->array
.size
= this->component_size
/ 2;
3616 this->container_member
= i
;
3618 ddf
->currentconf
= vc
;
3619 uuid_from_super_ddf(st
, this->uuid
);
3621 ddf
->currentconf
= NULL
;
3623 sprintf(this->text_version
, "/%s/%d",
3624 st
->container_devnm
, this->container_member
);
3626 for (pd
= 0; pd
< __be16_to_cpu(ddf
->phys
->used_pdes
); pd
++) {
3629 const struct vd_config
*bvd
;
3633 if (ddf
->phys
->entries
[pd
].refnum
== 0xFFFFFFFF)
3636 stt
= __be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
3637 if ((stt
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
3641 i
= get_pd_index_from_refnum(
3642 vc
, ddf
->phys
->entries
[pd
].refnum
,
3643 ddf
->mppe
, &bvd
, &iphys
);
3644 if (i
== DDF_NOTFOUND
)
3647 this->array
.working_disks
++;
3649 for (d
= ddf
->dlist
; d
; d
=d
->next
)
3650 if (d
->disk
.refnum
==
3651 ddf
->phys
->entries
[pd
].refnum
)
3654 /* Haven't found that one yet, maybe there are others */
3657 dev
= xcalloc(1, sizeof(*dev
));
3658 dev
->next
= this->devs
;
3661 dev
->disk
.number
= __be32_to_cpu(d
->disk
.refnum
);
3662 dev
->disk
.major
= d
->major
;
3663 dev
->disk
.minor
= d
->minor
;
3664 dev
->disk
.raid_disk
= i
;
3665 dev
->disk
.state
= (1<<MD_DISK_SYNC
)|(1<<MD_DISK_ACTIVE
);
3666 dev
->recovery_start
= MaxSector
;
3668 dev
->events
= __be32_to_cpu(ddf
->primary
.seq
);
3670 __be64_to_cpu(LBA_OFFSET(ddf
, bvd
)[iphys
]);
3671 dev
->component_size
= __be64_to_cpu(bvd
->blocks
);
3673 strcpy(dev
->name
, d
->devname
);
3679 static int store_super_ddf(struct supertype
*st
, int fd
)
3681 struct ddf_super
*ddf
= st
->sb
;
3682 unsigned long long dsize
;
3689 if (!get_dev_size(fd
, NULL
, &dsize
))
3692 if (ddf
->dlist
|| ddf
->conflist
) {
3697 if (fstat(fd
, &sta
) == -1 || !S_ISBLK(sta
.st_mode
)) {
3698 pr_err("%s: file descriptor for invalid device\n",
3702 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
3703 if (dl
->major
== (int)major(sta
.st_rdev
) &&
3704 dl
->minor
== (int)minor(sta
.st_rdev
))
3707 pr_err("%s: couldn't find disk %d/%d\n", __func__
,
3708 (int)major(sta
.st_rdev
),
3709 (int)minor(sta
.st_rdev
));
3713 For DDF, writing to just one disk makes no sense.
3714 We would run the risk of writing inconsistent meta data
3715 to the devices. So just call __write_init_super_ddf and
3716 write to all devices, including this one.
3717 Use the fd passed to this function, just in case dl->fd
3722 ret
= __write_init_super_ddf(st
);
3727 if (posix_memalign(&buf
, 512, 512) != 0)
3729 memset(buf
, 0, 512);
3731 lseek64(fd
, dsize
-512, 0);
3732 rc
= write(fd
, buf
, 512);
3739 static int compare_super_ddf(struct supertype
*st
, struct supertype
*tst
)
3743 * 0 same, or first was empty, and second was copied
3744 * 1 second had wrong number
3746 * 3 wrong other info
3748 struct ddf_super
*first
= st
->sb
;
3749 struct ddf_super
*second
= tst
->sb
;
3750 struct dl
*dl1
, *dl2
;
3751 struct vcl
*vl1
, *vl2
;
3752 unsigned int max_vds
, max_pds
, pd
, vd
;
3760 if (memcmp(first
->anchor
.guid
, second
->anchor
.guid
, DDF_GUID_LEN
) != 0)
3763 if (first
->anchor
.seq
!= second
->anchor
.seq
) {
3764 dprintf("%s: sequence number mismatch %u/%u\n", __func__
,
3765 __be32_to_cpu(first
->anchor
.seq
),
3766 __be32_to_cpu(second
->anchor
.seq
));
3769 if (first
->max_part
!= second
->max_part
||
3770 first
->phys
->used_pdes
!= second
->phys
->used_pdes
||
3771 first
->virt
->populated_vdes
!= second
->virt
->populated_vdes
) {
3772 dprintf("%s: PD/VD number mismatch\n", __func__
);
3776 max_pds
= __be16_to_cpu(first
->phys
->used_pdes
);
3777 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
3778 for (pd
= 0; pd
< max_pds
; pd
++)
3779 if (first
->phys
->entries
[pd
].refnum
== dl2
->disk
.refnum
)
3781 if (pd
== max_pds
) {
3782 dprintf("%s: no match for disk %08x\n", __func__
,
3783 __be32_to_cpu(dl2
->disk
.refnum
));
3788 max_vds
= __be16_to_cpu(first
->active
->max_vd_entries
);
3789 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3790 if (vl2
->conf
.magic
!= DDF_VD_CONF_MAGIC
)
3792 for (vd
= 0; vd
< max_vds
; vd
++)
3793 if (!memcmp(first
->virt
->entries
[vd
].guid
,
3794 vl2
->conf
.guid
, DDF_GUID_LEN
))
3796 if (vd
== max_vds
) {
3797 dprintf("%s: no match for VD config\n", __func__
);
3801 /* FIXME should I look at anything else? */
3804 At this point we are fairly sure that the meta data matches.
3805 But the new disk may contain additional local data.
3806 Add it to the super block.
3808 for (vl2
= second
->conflist
; vl2
; vl2
= vl2
->next
) {
3809 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
)
3810 if (!memcmp(vl1
->conf
.guid
, vl2
->conf
.guid
,
3814 if (vl1
->other_bvds
!= NULL
&&
3815 vl1
->conf
.sec_elmnt_seq
!=
3816 vl2
->conf
.sec_elmnt_seq
) {
3817 dprintf("%s: adding BVD %u\n", __func__
,
3818 vl2
->conf
.sec_elmnt_seq
);
3819 add_other_bvd(vl1
, &vl2
->conf
,
3820 first
->conf_rec_len
*512);
3825 if (posix_memalign((void **)&vl1
, 512,
3826 (first
->conf_rec_len
*512 +
3827 offsetof(struct vcl
, conf
))) != 0) {
3828 pr_err("%s could not allocate vcl buf\n",
3833 vl1
->next
= first
->conflist
;
3834 vl1
->block_sizes
= NULL
;
3835 memcpy(&vl1
->conf
, &vl2
->conf
, first
->conf_rec_len
*512);
3836 if (alloc_other_bvds(first
, vl1
) != 0) {
3837 pr_err("%s could not allocate other bvds\n",
3842 for (vd
= 0; vd
< max_vds
; vd
++)
3843 if (!memcmp(first
->virt
->entries
[vd
].guid
,
3844 vl1
->conf
.guid
, DDF_GUID_LEN
))
3847 dprintf("%s: added config for VD %u\n", __func__
, vl1
->vcnum
);
3848 first
->conflist
= vl1
;
3851 for (dl2
= second
->dlist
; dl2
; dl2
= dl2
->next
) {
3852 for (dl1
= first
->dlist
; dl1
; dl1
= dl1
->next
)
3853 if (dl1
->disk
.refnum
== dl2
->disk
.refnum
)
3858 if (posix_memalign((void **)&dl1
, 512,
3859 sizeof(*dl1
) + (first
->max_part
) * sizeof(dl1
->vlist
[0]))
3861 pr_err("%s could not allocate disk info buffer\n",
3865 memcpy(dl1
, dl2
, sizeof(*dl1
));
3866 dl1
->mdupdate
= NULL
;
3867 dl1
->next
= first
->dlist
;
3869 for (pd
= 0; pd
< max_pds
; pd
++)
3870 if (first
->phys
->entries
[pd
].refnum
== dl1
->disk
.refnum
)
3874 if (posix_memalign((void **)&dl1
->spare
, 512,
3875 first
->conf_rec_len
*512) != 0) {
3876 pr_err("%s could not allocate spare info buf\n",
3880 memcpy(dl1
->spare
, dl2
->spare
, first
->conf_rec_len
*512);
3882 for (vd
= 0 ; vd
< first
->max_part
; vd
++) {
3883 if (!dl2
->vlist
[vd
]) {
3884 dl1
->vlist
[vd
] = NULL
;
3887 for (vl1
= first
->conflist
; vl1
; vl1
= vl1
->next
) {
3888 if (!memcmp(vl1
->conf
.guid
,
3889 dl2
->vlist
[vd
]->conf
.guid
,
3892 dl1
->vlist
[vd
] = vl1
;
3896 dprintf("%s: added disk %d: %08x\n", __func__
, dl1
->pdnum
,
3905 * A new array 'a' has been started which claims to be instance 'inst'
3906 * within container 'c'.
3907 * We need to confirm that the array matches the metadata in 'c' so
3908 * that we don't corrupt any metadata.
3910 static int ddf_open_new(struct supertype
*c
, struct active_array
*a
, char *inst
)
3912 struct ddf_super
*ddf
= c
->sb
;
3914 if (all_ff(ddf
->virt
->entries
[n
].guid
)) {
3915 pr_err("%s: subarray %d doesn't exist\n", __func__
, n
);
3918 dprintf("ddf: open_new %d\n", n
);
3919 a
->info
.container_member
= n
;
3924 * The array 'a' is to be marked clean in the metadata.
3925 * If '->resync_start' is not ~(unsigned long long)0, then the array is only
3926 * clean up to the point (in sectors). If that cannot be recorded in the
3927 * metadata, then leave it as dirty.
3929 * For DDF, we need to clear the DDF_state_inconsistent bit in the
3930 * !global! virtual_disk.virtual_entry structure.
3932 static int ddf_set_array_state(struct active_array
*a
, int consistent
)
3934 struct ddf_super
*ddf
= a
->container
->sb
;
3935 int inst
= a
->info
.container_member
;
3936 int old
= ddf
->virt
->entries
[inst
].state
;
3937 if (consistent
== 2) {
3938 /* Should check if a recovery should be started FIXME */
3940 if (!is_resync_complete(&a
->info
))
3944 ddf
->virt
->entries
[inst
].state
&= ~DDF_state_inconsistent
;
3946 ddf
->virt
->entries
[inst
].state
|= DDF_state_inconsistent
;
3947 if (old
!= ddf
->virt
->entries
[inst
].state
)
3948 ddf_set_updates_pending(ddf
);
3950 old
= ddf
->virt
->entries
[inst
].init_state
;
3951 ddf
->virt
->entries
[inst
].init_state
&= ~DDF_initstate_mask
;
3952 if (is_resync_complete(&a
->info
))
3953 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_full
;
3954 else if (a
->info
.resync_start
== 0)
3955 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_not
;
3957 ddf
->virt
->entries
[inst
].init_state
|= DDF_init_quick
;
3958 if (old
!= ddf
->virt
->entries
[inst
].init_state
)
3959 ddf_set_updates_pending(ddf
);
3961 dprintf("ddf mark %d/%s (%d) %s %llu\n", inst
,
3962 guid_str(ddf
->virt
->entries
[inst
].guid
), a
->curr_state
,
3963 consistent
?"clean":"dirty",
3964 a
->info
.resync_start
);
3968 static int get_bvd_state(const struct ddf_super
*ddf
,
3969 const struct vd_config
*vc
)
3971 unsigned int i
, n_bvd
, working
= 0;
3972 unsigned int n_prim
= __be16_to_cpu(vc
->prim_elmnt_count
);
3974 for (i
= 0; i
< n_prim
; i
++) {
3975 if (!find_index_in_bvd(ddf
, vc
, i
, &n_bvd
))
3977 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
3980 st
= __be16_to_cpu(ddf
->phys
->entries
[pd
].state
);
3981 if ((st
& (DDF_Online
|DDF_Failed
|DDF_Rebuilding
))
3986 state
= DDF_state_degraded
;
3987 if (working
== n_prim
)
3988 state
= DDF_state_optimal
;
3994 state
= DDF_state_failed
;
3998 state
= DDF_state_failed
;
3999 else if (working
>= 2)
4000 state
= DDF_state_part_optimal
;
4004 if (working
< n_prim
- 1)
4005 state
= DDF_state_failed
;
4008 if (working
< n_prim
- 2)
4009 state
= DDF_state_failed
;
4010 else if (working
== n_prim
- 1)
4011 state
= DDF_state_part_optimal
;
4017 static int secondary_state(int state
, int other
, int seclevel
)
4019 if (state
== DDF_state_optimal
&& other
== DDF_state_optimal
)
4020 return DDF_state_optimal
;
4021 if (seclevel
== DDF_2MIRRORED
) {
4022 if (state
== DDF_state_optimal
|| other
== DDF_state_optimal
)
4023 return DDF_state_part_optimal
;
4024 if (state
== DDF_state_failed
&& other
== DDF_state_failed
)
4025 return DDF_state_failed
;
4026 return DDF_state_degraded
;
4028 if (state
== DDF_state_failed
|| other
== DDF_state_failed
)
4029 return DDF_state_failed
;
4030 if (state
== DDF_state_degraded
|| other
== DDF_state_degraded
)
4031 return DDF_state_degraded
;
4032 return DDF_state_part_optimal
;
4036 static int get_svd_state(const struct ddf_super
*ddf
, const struct vcl
*vcl
)
4038 int state
= get_bvd_state(ddf
, &vcl
->conf
);
4040 for (i
= 1; i
< vcl
->conf
.sec_elmnt_count
; i
++) {
4041 state
= secondary_state(
4043 get_bvd_state(ddf
, vcl
->other_bvds
[i
-1]),
4050 * The state of each disk is stored in the global phys_disk structure
4051 * in phys_disk.entries[n].state.
4052 * This makes various combinations awkward.
4053 * - When a device fails in any array, it must be failed in all arrays
4054 * that include a part of this device.
4055 * - When a component is rebuilding, we cannot include it officially in the
4056 * array unless this is the only array that uses the device.
4058 * So: when transitioning:
4059 * Online -> failed, just set failed flag. monitor will propagate
4060 * spare -> online, the device might need to be added to the array.
4061 * spare -> failed, just set failed. Don't worry if in array or not.
4063 static void ddf_set_disk(struct active_array
*a
, int n
, int state
)
4065 struct ddf_super
*ddf
= a
->container
->sb
;
4066 unsigned int inst
= a
->info
.container_member
, n_bvd
;
4068 struct vd_config
*vc
= find_vdcr(ddf
, inst
, (unsigned int)n
,
4075 dprintf("ddf: cannot find instance %d!!\n", inst
);
4078 /* Find the matching slot in 'info'. */
4079 for (mdi
= a
->info
.devs
; mdi
; mdi
= mdi
->next
)
4080 if (mdi
->disk
.raid_disk
== n
)
4085 /* and find the 'dl' entry corresponding to that. */
4086 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4087 if (mdi
->state_fd
>= 0 &&
4088 mdi
->disk
.major
== dl
->major
&&
4089 mdi
->disk
.minor
== dl
->minor
)
4094 pd
= find_phys(ddf
, vc
->phys_refnum
[n_bvd
]);
4095 if (pd
< 0 || pd
!= dl
->pdnum
) {
4096 /* disk doesn't currently exist or has changed.
4097 * If it is now in_sync, insert it. */
4098 dprintf("%s: phys disk not found for %d: %d/%d ref %08x\n",
4099 __func__
, dl
->pdnum
, dl
->major
, dl
->minor
,
4101 dprintf("%s: array %u disk %u ref %08x pd %d\n",
4102 __func__
, inst
, n_bvd
, vc
->phys_refnum
[n_bvd
], pd
);
4103 if ((state
& DS_INSYNC
) && ! (state
& DS_FAULTY
)) {
4104 pd
= dl
->pdnum
; /* FIXME: is this really correct ? */
4105 vc
->phys_refnum
[n_bvd
] = dl
->disk
.refnum
;
4106 LBA_OFFSET(ddf
, vc
)[n_bvd
] =
4107 __cpu_to_be64(mdi
->data_offset
);
4108 ddf
->phys
->entries
[pd
].type
&=
4109 ~__cpu_to_be16(DDF_Global_Spare
);
4110 ddf
->phys
->entries
[pd
].type
|=
4111 __cpu_to_be16(DDF_Active_in_VD
);
4112 ddf_set_updates_pending(ddf
);
4115 int old
= ddf
->phys
->entries
[pd
].state
;
4116 if (state
& DS_FAULTY
)
4117 ddf
->phys
->entries
[pd
].state
|= __cpu_to_be16(DDF_Failed
);
4118 if (state
& DS_INSYNC
) {
4119 ddf
->phys
->entries
[pd
].state
|= __cpu_to_be16(DDF_Online
);
4120 ddf
->phys
->entries
[pd
].state
&= __cpu_to_be16(~DDF_Rebuilding
);
4122 if (old
!= ddf
->phys
->entries
[pd
].state
)
4123 ddf_set_updates_pending(ddf
);
4126 dprintf("ddf: set_disk %d to %x\n", n
, state
);
4128 /* Now we need to check the state of the array and update
4129 * virtual_disk.entries[n].state.
4130 * It needs to be one of "optimal", "degraded", "failed".
4131 * I don't understand 'deleted' or 'missing'.
4133 state
= get_svd_state(ddf
, vcl
);
4135 if (ddf
->virt
->entries
[inst
].state
!=
4136 ((ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4139 ddf
->virt
->entries
[inst
].state
=
4140 (ddf
->virt
->entries
[inst
].state
& ~DDF_state_mask
)
4142 ddf_set_updates_pending(ddf
);
4147 static void ddf_sync_metadata(struct supertype
*st
)
4151 * Write all data to all devices.
4152 * Later, we might be able to track whether only local changes
4153 * have been made, or whether any global data has been changed,
4154 * but ddf is sufficiently weird that it probably always
4155 * changes global data ....
4157 struct ddf_super
*ddf
= st
->sb
;
4158 if (!ddf
->updates_pending
)
4160 ddf
->updates_pending
= 0;
4161 __write_init_super_ddf(st
);
4162 dprintf("ddf: sync_metadata\n");
4165 static int del_from_conflist(struct vcl
**list
, const char *guid
)
4169 for (p
= list
; p
&& *p
; p
= &((*p
)->next
))
4170 if (!memcmp((*p
)->conf
.guid
, guid
, DDF_GUID_LEN
)) {
4177 static int _kill_subarray_ddf(struct ddf_super
*ddf
, const char *guid
)
4180 unsigned int vdnum
, i
;
4181 vdnum
= find_vde_by_guid(ddf
, guid
);
4182 if (vdnum
== DDF_NOTFOUND
) {
4183 pr_err("%s: could not find VD %s\n", __func__
,
4187 if (del_from_conflist(&ddf
->conflist
, guid
) == 0) {
4188 pr_err("%s: could not find conf %s\n", __func__
,
4192 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4193 for (i
= 0; i
< ddf
->max_part
; i
++)
4194 if (dl
->vlist
[i
] != NULL
&&
4195 !memcmp(dl
->vlist
[i
]->conf
.guid
, guid
,
4197 dl
->vlist
[i
] = NULL
;
4198 memset(ddf
->virt
->entries
[vdnum
].guid
, 0xff, DDF_GUID_LEN
);
4199 dprintf("%s: deleted %s\n", __func__
, guid_str(guid
));
4203 static int kill_subarray_ddf(struct supertype
*st
)
4205 struct ddf_super
*ddf
= st
->sb
;
4207 * currentconf is set in container_content_ddf,
4208 * called with subarray arg
4210 struct vcl
*victim
= ddf
->currentconf
;
4211 struct vd_config
*conf
;
4212 ddf
->currentconf
= NULL
;
4215 pr_err("%s: nothing to kill\n", __func__
);
4218 conf
= &victim
->conf
;
4219 vdnum
= find_vde_by_guid(ddf
, conf
->guid
);
4220 if (vdnum
== DDF_NOTFOUND
) {
4221 pr_err("%s: could not find VD %s\n", __func__
,
4222 guid_str(conf
->guid
));
4225 if (st
->update_tail
) {
4226 struct virtual_disk
*vd
;
4227 int len
= sizeof(struct virtual_disk
)
4228 + sizeof(struct virtual_entry
);
4231 pr_err("%s: failed to allocate %d bytes\n", __func__
,
4235 memset(vd
, 0 , len
);
4236 vd
->magic
= DDF_VIRT_RECORDS_MAGIC
;
4237 vd
->populated_vdes
= 0;
4238 memcpy(vd
->entries
[0].guid
, conf
->guid
, DDF_GUID_LEN
);
4239 /* we use DDF_state_deleted as marker */
4240 vd
->entries
[0].state
= DDF_state_deleted
;
4241 append_metadata_update(st
, vd
, len
);
4243 _kill_subarray_ddf(ddf
, conf
->guid
);
4247 static void ddf_process_update(struct supertype
*st
,
4248 struct metadata_update
*update
)
4250 /* Apply this update to the metadata.
4251 * The first 4 bytes are a DDF_*_MAGIC which guides
4253 * Possible update are:
4254 * DDF_PHYS_RECORDS_MAGIC
4255 * Add a new physical device or remove an old one.
4256 * Changes to this record only happen implicitly.
4257 * used_pdes is the device number.
4258 * DDF_VIRT_RECORDS_MAGIC
4259 * Add a new VD. Possibly also change the 'access' bits.
4260 * populated_vdes is the entry number.
4262 * New or updated VD. the VIRT_RECORD must already
4263 * exist. For an update, phys_refnum and lba_offset
4264 * (at least) are updated, and the VD_CONF must
4265 * be written to precisely those devices listed with
4267 * DDF_SPARE_ASSIGN_MAGIC
4268 * replacement Spare Assignment Record... but for which device?
4271 * - to create a new array, we send a VIRT_RECORD and
4272 * a VD_CONF. Then assemble and start the array.
4273 * - to activate a spare we send a VD_CONF to add the phys_refnum
4274 * and offset. This will also mark the spare as active with
4275 * a spare-assignment record.
4277 struct ddf_super
*ddf
= st
->sb
;
4278 __u32
*magic
= (__u32
*)update
->buf
;
4279 struct phys_disk
*pd
;
4280 struct virtual_disk
*vd
;
4281 struct vd_config
*vc
;
4286 unsigned int pdnum
, pd2
;
4288 dprintf("Process update %x\n", *magic
);
4291 case DDF_PHYS_RECORDS_MAGIC
:
4293 if (update
->len
!= (sizeof(struct phys_disk
) +
4294 sizeof(struct phys_disk_entry
)))
4296 pd
= (struct phys_disk
*)update
->buf
;
4298 ent
= __be16_to_cpu(pd
->used_pdes
);
4299 if (ent
>= __be16_to_cpu(ddf
->phys
->max_pdes
))
4301 if (pd
->entries
[0].state
& __cpu_to_be16(DDF_Missing
)) {
4303 /* removing this disk. */
4304 ddf
->phys
->entries
[ent
].state
|= __cpu_to_be16(DDF_Missing
);
4305 for (dlp
= &ddf
->dlist
; *dlp
; dlp
= &(*dlp
)->next
) {
4306 struct dl
*dl
= *dlp
;
4307 if (dl
->pdnum
== (signed)ent
) {
4310 /* FIXME this doesn't free
4317 ddf_set_updates_pending(ddf
);
4320 if (!all_ff(ddf
->phys
->entries
[ent
].guid
))
4322 ddf
->phys
->entries
[ent
] = pd
->entries
[0];
4323 ddf
->phys
->used_pdes
= __cpu_to_be16(1 +
4324 __be16_to_cpu(ddf
->phys
->used_pdes
));
4325 ddf_set_updates_pending(ddf
);
4326 if (ddf
->add_list
) {
4327 struct active_array
*a
;
4328 struct dl
*al
= ddf
->add_list
;
4329 ddf
->add_list
= al
->next
;
4331 al
->next
= ddf
->dlist
;
4334 /* As a device has been added, we should check
4335 * for any degraded devices that might make
4336 * use of this spare */
4337 for (a
= st
->arrays
; a
; a
=a
->next
)
4338 a
->check_degraded
= 1;
4342 case DDF_VIRT_RECORDS_MAGIC
:
4344 if (update
->len
!= (sizeof(struct virtual_disk
) +
4345 sizeof(struct virtual_entry
)))
4347 vd
= (struct virtual_disk
*)update
->buf
;
4349 if (vd
->entries
[0].state
== DDF_state_deleted
) {
4350 if (_kill_subarray_ddf(ddf
, vd
->entries
[0].guid
))
4354 ent
= find_unused_vde(ddf
);
4355 if (ent
== DDF_NOTFOUND
)
4357 ddf
->virt
->entries
[ent
] = vd
->entries
[0];
4358 ddf
->virt
->populated_vdes
=
4361 ddf
->virt
->populated_vdes
));
4363 ddf_set_updates_pending(ddf
);
4366 case DDF_VD_CONF_MAGIC
:
4367 dprintf("len %d %d\n", update
->len
, ddf
->conf_rec_len
);
4369 mppe
= __be16_to_cpu(ddf
->anchor
.max_primary_element_entries
);
4370 if ((unsigned)update
->len
!= ddf
->conf_rec_len
* 512)
4372 vc
= (struct vd_config
*)update
->buf
;
4373 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
)
4374 if (memcmp(vcl
->conf
.guid
, vc
->guid
, DDF_GUID_LEN
) == 0)
4376 dprintf("vcl = %p\n", vcl
);
4378 /* An update, just copy the phys_refnum and lba_offset
4381 struct vd_config
*conf
= &vcl
->conf
;
4382 if (vcl
->other_bvds
!= NULL
&&
4383 conf
->sec_elmnt_seq
!= vc
->sec_elmnt_seq
) {
4385 for (i
= 1; i
< conf
->sec_elmnt_count
; i
++)
4386 if (vcl
->other_bvds
[i
-1]->sec_elmnt_seq
4387 == vc
->sec_elmnt_seq
)
4389 if (i
== conf
->sec_elmnt_count
) {
4390 pr_err("%s/DDF_VD_CONF_MAGIC: BVD %u not found\n",
4391 __func__
, vc
->sec_elmnt_seq
);
4394 conf
= vcl
->other_bvds
[i
-1];
4396 memcpy(conf
->phys_refnum
, vc
->phys_refnum
,
4397 mppe
* (sizeof(__u32
) + sizeof(__u64
)));
4402 vcl
= update
->space
;
4403 update
->space
= NULL
;
4404 vcl
->next
= ddf
->conflist
;
4405 memcpy(&vcl
->conf
, vc
, update
->len
);
4406 ent
= find_vde_by_guid(ddf
, vc
->guid
);
4407 if (ent
== DDF_NOTFOUND
)
4410 ddf
->conflist
= vcl
;
4412 /* Set DDF_Transition on all Failed devices - to help
4413 * us detect those that are no longer in use
4415 for (pdnum
= 0; pdnum
< __be16_to_cpu(ddf
->phys
->used_pdes
); pdnum
++)
4416 if (ddf
->phys
->entries
[pdnum
].state
4417 & __be16_to_cpu(DDF_Failed
))
4418 ddf
->phys
->entries
[pdnum
].state
4419 |= __be16_to_cpu(DDF_Transition
);
4420 /* Now make sure vlist is correct for each dl. */
4421 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
) {
4422 unsigned int vn
= 0;
4423 int in_degraded
= 0;
4424 for (vcl
= ddf
->conflist
; vcl
; vcl
= vcl
->next
) {
4425 unsigned int dn
, ibvd
;
4426 const struct vd_config
*conf
;
4428 dn
= get_pd_index_from_refnum(vcl
,
4432 if (dn
== DDF_NOTFOUND
)
4434 dprintf("dev %d/%08x has %s (sec=%u) at %d\n",
4435 dl
->pdnum
, dl
->disk
.refnum
,
4436 guid_str(conf
->guid
),
4437 conf
->sec_elmnt_seq
, vn
);
4438 /* Clear the Transition flag */
4439 if (ddf
->phys
->entries
[dl
->pdnum
].state
4440 & __be16_to_cpu(DDF_Failed
))
4441 ddf
->phys
->entries
[dl
->pdnum
].state
&=
4442 ~__be16_to_cpu(DDF_Transition
);
4443 dl
->vlist
[vn
++] = vcl
;
4444 vstate
= ddf
->virt
->entries
[vcl
->vcnum
].state
4446 if (vstate
== DDF_state_degraded
||
4447 vstate
== DDF_state_part_optimal
)
4450 while (vn
< ddf
->max_part
)
4451 dl
->vlist
[vn
++] = NULL
;
4453 ddf
->phys
->entries
[dl
->pdnum
].type
&=
4454 ~__cpu_to_be16(DDF_Global_Spare
);
4455 if (!(ddf
->phys
->entries
[dl
->pdnum
].type
&
4456 __cpu_to_be16(DDF_Active_in_VD
))) {
4457 ddf
->phys
->entries
[dl
->pdnum
].type
|=
4458 __cpu_to_be16(DDF_Active_in_VD
);
4460 ddf
->phys
->entries
[dl
->pdnum
].state
|=
4461 __cpu_to_be16(DDF_Rebuilding
);
4465 ddf
->phys
->entries
[dl
->pdnum
].type
&=
4466 ~__cpu_to_be16(DDF_Global_Spare
);
4467 ddf
->phys
->entries
[dl
->pdnum
].type
|=
4468 __cpu_to_be16(DDF_Spare
);
4470 if (!dl
->vlist
[0] && !dl
->spare
) {
4471 ddf
->phys
->entries
[dl
->pdnum
].type
|=
4472 __cpu_to_be16(DDF_Global_Spare
);
4473 ddf
->phys
->entries
[dl
->pdnum
].type
&=
4474 ~__cpu_to_be16(DDF_Spare
|
4479 /* Now remove any 'Failed' devices that are not part
4480 * of any VD. They will have the Transition flag set.
4481 * Once done, we need to update all dl->pdnum numbers.
4484 for (pdnum
= 0; pdnum
< __be16_to_cpu(ddf
->phys
->used_pdes
); pdnum
++)
4485 if ((ddf
->phys
->entries
[pdnum
].state
4486 & __be16_to_cpu(DDF_Failed
))
4487 && (ddf
->phys
->entries
[pdnum
].state
4488 & __be16_to_cpu(DDF_Transition
)))
4489 /* skip this one */;
4490 else if (pdnum
== pd2
)
4493 ddf
->phys
->entries
[pd2
] = ddf
->phys
->entries
[pdnum
];
4494 for (dl
= ddf
->dlist
; dl
; dl
= dl
->next
)
4495 if (dl
->pdnum
== (int)pdnum
)
4499 ddf
->phys
->used_pdes
= __cpu_to_be16(pd2
);
4500 while (pd2
< pdnum
) {
4501 memset(ddf
->phys
->entries
[pd2
].guid
, 0xff, DDF_GUID_LEN
);
4505 ddf_set_updates_pending(ddf
);
4507 case DDF_SPARE_ASSIGN_MAGIC
:
4512 static void ddf_prepare_update(struct supertype
*st
,
4513 struct metadata_update
*update
)
4515 /* This update arrived at managemon.
4516 * We are about to pass it to monitor.
4517 * If a malloc is needed, do it here.
4519 struct ddf_super
*ddf
= st
->sb
;
4520 __u32
*magic
= (__u32
*)update
->buf
;
4521 if (*magic
== DDF_VD_CONF_MAGIC
)
4522 if (posix_memalign(&update
->space
, 512,
4523 offsetof(struct vcl
, conf
)
4524 + ddf
->conf_rec_len
* 512) != 0)
4525 update
->space
= NULL
;
4529 * Check if the array 'a' is degraded but not failed.
4530 * If it is, find as many spares as are available and needed and
4531 * arrange for their inclusion.
4532 * We only choose devices which are not already in the array,
4533 * and prefer those with a spare-assignment to this array.
4534 * otherwise we choose global spares - assuming always that
4535 * there is enough room.
4536 * For each spare that we assign, we return an 'mdinfo' which
4537 * describes the position for the device in the array.
4538 * We also add to 'updates' a DDF_VD_CONF_MAGIC update with
4539 * the new phys_refnum and lba_offset values.
4541 * Only worry about BVDs at the moment.
4543 static struct mdinfo
*ddf_activate_spare(struct active_array
*a
,
4544 struct metadata_update
**updates
)
4548 struct ddf_super
*ddf
= a
->container
->sb
;
4550 struct mdinfo
*rv
= NULL
;
4552 struct metadata_update
*mu
;
4556 struct vd_config
*vc
;
4559 for (d
= a
->info
.devs
; d
; d
= d
->next
) {
4560 if ((d
->curr_state
& DS_FAULTY
) &&
4562 /* wait for Removal to happen */
4564 if (d
->state_fd
>= 0)
4568 dprintf("ddf_activate: working=%d (%d) level=%d\n", working
, a
->info
.array
.raid_disks
,
4569 a
->info
.array
.level
);
4570 if (working
== a
->info
.array
.raid_disks
)
4571 return NULL
; /* array not degraded */
4572 switch (a
->info
.array
.level
) {
4575 return NULL
; /* failed */
4579 if (working
< a
->info
.array
.raid_disks
- 1)
4580 return NULL
; /* failed */
4583 if (working
< a
->info
.array
.raid_disks
- 2)
4584 return NULL
; /* failed */
4586 default: /* concat or stripe */
4587 return NULL
; /* failed */
4590 /* For each slot, if it is not working, find a spare */
4592 for (i
= 0; i
< a
->info
.array
.raid_disks
; i
++) {
4593 for (d
= a
->info
.devs
; d
; d
= d
->next
)
4594 if (d
->disk
.raid_disk
== i
)
4596 dprintf("found %d: %p %x\n", i
, d
, d
?d
->curr_state
:0);
4597 if (d
&& (d
->state_fd
>= 0))
4600 /* OK, this device needs recovery. Find a spare */
4602 for ( ; dl
; dl
= dl
->next
) {
4603 unsigned long long esize
;
4604 unsigned long long pos
;
4607 int is_dedicated
= 0;
4610 /* If in this array, skip */
4611 for (d2
= a
->info
.devs
; d2
; d2
= d2
->next
)
4612 if (d2
->state_fd
>= 0 &&
4613 d2
->disk
.major
== dl
->major
&&
4614 d2
->disk
.minor
== dl
->minor
) {
4615 dprintf("%x:%x already in array\n", dl
->major
, dl
->minor
);
4620 if (ddf
->phys
->entries
[dl
->pdnum
].type
&
4621 __cpu_to_be16(DDF_Spare
)) {
4622 /* Check spare assign record */
4624 if (dl
->spare
->type
& DDF_spare_dedicated
) {
4625 /* check spare_ents for guid */
4627 j
< __be16_to_cpu(dl
->spare
->populated
);
4629 if (memcmp(dl
->spare
->spare_ents
[j
].guid
,
4630 ddf
->virt
->entries
[a
->info
.container_member
].guid
,
4637 } else if (ddf
->phys
->entries
[dl
->pdnum
].type
&
4638 __cpu_to_be16(DDF_Global_Spare
)) {
4640 } else if (!(ddf
->phys
->entries
[dl
->pdnum
].state
&
4641 __cpu_to_be16(DDF_Failed
))) {
4642 /* we can possibly use some of this */
4645 if ( ! (is_dedicated
||
4646 (is_global
&& global_ok
))) {
4647 dprintf("%x:%x not suitable: %d %d\n", dl
->major
, dl
->minor
,
4648 is_dedicated
, is_global
);
4652 /* We are allowed to use this device - is there space?
4653 * We need a->info.component_size sectors */
4654 ex
= get_extents(ddf
, dl
);
4656 dprintf("cannot get extents\n");
4663 esize
= ex
[j
].start
- pos
;
4664 if (esize
>= a
->info
.component_size
)
4666 pos
= ex
[j
].start
+ ex
[j
].size
;
4668 } while (ex
[j
-1].size
);
4671 if (esize
< a
->info
.component_size
) {
4672 dprintf("%x:%x has no room: %llu %llu\n",
4673 dl
->major
, dl
->minor
,
4674 esize
, a
->info
.component_size
);
4679 /* Cool, we have a device with some space at pos */
4680 di
= xcalloc(1, sizeof(*di
));
4681 di
->disk
.number
= i
;
4682 di
->disk
.raid_disk
= i
;
4683 di
->disk
.major
= dl
->major
;
4684 di
->disk
.minor
= dl
->minor
;
4686 di
->recovery_start
= 0;
4687 di
->data_offset
= pos
;
4688 di
->component_size
= a
->info
.component_size
;
4689 di
->container_member
= dl
->pdnum
;
4692 dprintf("%x:%x to be %d at %llu\n", dl
->major
, dl
->minor
,
4697 if (!dl
&& ! global_ok
) {
4698 /* not enough dedicated spares, try global */
4706 /* No spares found */
4708 /* Now 'rv' has a list of devices to return.
4709 * Create a metadata_update record to update the
4710 * phys_refnum and lba_offset values
4712 mu
= xmalloc(sizeof(*mu
));
4713 if (posix_memalign(&mu
->space
, 512, sizeof(struct vcl
)) != 0) {
4717 mu
->buf
= xmalloc(ddf
->conf_rec_len
* 512);
4718 mu
->len
= ddf
->conf_rec_len
* 512;
4720 mu
->space_list
= NULL
;
4721 mu
->next
= *updates
;
4722 vc
= find_vdcr(ddf
, a
->info
.container_member
, di
->disk
.raid_disk
,
4724 memcpy(mu
->buf
, vc
, ddf
->conf_rec_len
* 512);
4726 vc
= (struct vd_config
*)mu
->buf
;
4727 for (di
= rv
; di
; di
= di
->next
) {
4728 vc
->phys_refnum
[di
->disk
.raid_disk
] =
4729 ddf
->phys
->entries
[dl
->pdnum
].refnum
;
4730 LBA_OFFSET(ddf
, vc
)[di
->disk
.raid_disk
]
4731 = __cpu_to_be64(di
->data_offset
);
4736 #endif /* MDASSEMBLE */
4738 static int ddf_level_to_layout(int level
)
4745 return ALGORITHM_LEFT_SYMMETRIC
;
4747 return ALGORITHM_ROTATING_N_CONTINUE
;
4755 static void default_geometry_ddf(struct supertype
*st
, int *level
, int *layout
, int *chunk
)
4757 if (level
&& *level
== UnSet
)
4758 *level
= LEVEL_CONTAINER
;
4760 if (level
&& layout
&& *layout
== UnSet
)
4761 *layout
= ddf_level_to_layout(*level
);
4764 struct superswitch super_ddf
= {
4766 .examine_super
= examine_super_ddf
,
4767 .brief_examine_super
= brief_examine_super_ddf
,
4768 .brief_examine_subarrays
= brief_examine_subarrays_ddf
,
4769 .export_examine_super
= export_examine_super_ddf
,
4770 .detail_super
= detail_super_ddf
,
4771 .brief_detail_super
= brief_detail_super_ddf
,
4772 .validate_geometry
= validate_geometry_ddf
,
4773 .write_init_super
= write_init_super_ddf
,
4774 .add_to_super
= add_to_super_ddf
,
4775 .remove_from_super
= remove_from_super_ddf
,
4776 .load_container
= load_container_ddf
,
4777 .copy_metadata
= copy_metadata_ddf
,
4779 .match_home
= match_home_ddf
,
4780 .uuid_from_super
= uuid_from_super_ddf
,
4781 .getinfo_super
= getinfo_super_ddf
,
4782 .update_super
= update_super_ddf
,
4784 .avail_size
= avail_size_ddf
,
4786 .compare_super
= compare_super_ddf
,
4788 .load_super
= load_super_ddf
,
4789 .init_super
= init_super_ddf
,
4790 .store_super
= store_super_ddf
,
4791 .free_super
= free_super_ddf
,
4792 .match_metadata_desc
= match_metadata_desc_ddf
,
4793 .container_content
= container_content_ddf
,
4794 .default_geometry
= default_geometry_ddf
,
4795 .kill_subarray
= kill_subarray_ddf
,
4801 .open_new
= ddf_open_new
,
4802 .set_array_state
= ddf_set_array_state
,
4803 .set_disk
= ddf_set_disk
,
4804 .sync_metadata
= ddf_sync_metadata
,
4805 .process_update
= ddf_process_update
,
4806 .prepare_update
= ddf_prepare_update
,
4807 .activate_spare
= ddf_activate_spare
,