diff options
Diffstat (limited to 'block/partitions/ldm.c')
-rw-r--r-- | block/partitions/ldm.c | 1570 |
1 files changed, 1570 insertions, 0 deletions
diff --git a/block/partitions/ldm.c b/block/partitions/ldm.c new file mode 100644 index 00000000000..bd8ae788f68 --- /dev/null +++ b/block/partitions/ldm.c | |||
@@ -0,0 +1,1570 @@ | |||
1 | /** | ||
2 | * ldm - Support for Windows Logical Disk Manager (Dynamic Disks) | ||
3 | * | ||
4 | * Copyright (C) 2001,2002 Richard Russon <ldm@flatcap.org> | ||
5 | * Copyright (c) 2001-2007 Anton Altaparmakov | ||
6 | * Copyright (C) 2001,2002 Jakob Kemi <jakob.kemi@telia.com> | ||
7 | * | ||
8 | * Documentation is available at http://www.linux-ntfs.org/doku.php?id=downloads | ||
9 | * | ||
10 | * This program is free software; you can redistribute it and/or modify it under | ||
11 | * the terms of the GNU General Public License as published by the Free Software | ||
12 | * Foundation; either version 2 of the License, or (at your option) any later | ||
13 | * version. | ||
14 | * | ||
15 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
16 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS | ||
17 | * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more | ||
18 | * details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License along with | ||
21 | * this program (in the main directory of the source in the file COPYING); if | ||
22 | * not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, | ||
23 | * Boston, MA 02111-1307 USA | ||
24 | */ | ||
25 | |||
26 | #include <linux/slab.h> | ||
27 | #include <linux/pagemap.h> | ||
28 | #include <linux/stringify.h> | ||
29 | #include <linux/kernel.h> | ||
30 | #include "ldm.h" | ||
31 | #include "check.h" | ||
32 | #include "msdos.h" | ||
33 | |||
34 | /** | ||
35 | * ldm_debug/info/error/crit - Output an error message | ||
36 | * @f: A printf format string containing the message | ||
37 | * @...: Variables to substitute into @f | ||
38 | * | ||
39 | * ldm_debug() writes a DEBUG level message to the syslog but only if the | ||
40 | * driver was compiled with debug enabled. Otherwise, the call turns into a NOP. | ||
41 | */ | ||
42 | #ifndef CONFIG_LDM_DEBUG | ||
43 | #define ldm_debug(...) do {} while (0) | ||
44 | #else | ||
45 | #define ldm_debug(f, a...) _ldm_printk (KERN_DEBUG, __func__, f, ##a) | ||
46 | #endif | ||
47 | |||
48 | #define ldm_crit(f, a...) _ldm_printk (KERN_CRIT, __func__, f, ##a) | ||
49 | #define ldm_error(f, a...) _ldm_printk (KERN_ERR, __func__, f, ##a) | ||
50 | #define ldm_info(f, a...) _ldm_printk (KERN_INFO, __func__, f, ##a) | ||
51 | |||
52 | static __printf(3, 4) | ||
53 | void _ldm_printk(const char *level, const char *function, const char *fmt, ...) | ||
54 | { | ||
55 | struct va_format vaf; | ||
56 | va_list args; | ||
57 | |||
58 | va_start (args, fmt); | ||
59 | |||
60 | vaf.fmt = fmt; | ||
61 | vaf.va = &args; | ||
62 | |||
63 | printk("%s%s(): %pV\n", level, function, &vaf); | ||
64 | |||
65 | va_end(args); | ||
66 | } | ||
67 | |||
68 | /** | ||
69 | * ldm_parse_hexbyte - Convert a ASCII hex number to a byte | ||
70 | * @src: Pointer to at least 2 characters to convert. | ||
71 | * | ||
72 | * Convert a two character ASCII hex string to a number. | ||
73 | * | ||
74 | * Return: 0-255 Success, the byte was parsed correctly | ||
75 | * -1 Error, an invalid character was supplied | ||
76 | */ | ||
77 | static int ldm_parse_hexbyte (const u8 *src) | ||
78 | { | ||
79 | unsigned int x; /* For correct wrapping */ | ||
80 | int h; | ||
81 | |||
82 | /* high part */ | ||
83 | x = h = hex_to_bin(src[0]); | ||
84 | if (h < 0) | ||
85 | return -1; | ||
86 | |||
87 | /* low part */ | ||
88 | h = hex_to_bin(src[1]); | ||
89 | if (h < 0) | ||
90 | return -1; | ||
91 | |||
92 | return (x << 4) + h; | ||
93 | } | ||
94 | |||
95 | /** | ||
96 | * ldm_parse_guid - Convert GUID from ASCII to binary | ||
97 | * @src: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba | ||
98 | * @dest: Memory block to hold binary GUID (16 bytes) | ||
99 | * | ||
100 | * N.B. The GUID need not be NULL terminated. | ||
101 | * | ||
102 | * Return: 'true' @dest contains binary GUID | ||
103 | * 'false' @dest contents are undefined | ||
104 | */ | ||
105 | static bool ldm_parse_guid (const u8 *src, u8 *dest) | ||
106 | { | ||
107 | static const int size[] = { 4, 2, 2, 2, 6 }; | ||
108 | int i, j, v; | ||
109 | |||
110 | if (src[8] != '-' || src[13] != '-' || | ||
111 | src[18] != '-' || src[23] != '-') | ||
112 | return false; | ||
113 | |||
114 | for (j = 0; j < 5; j++, src++) | ||
115 | for (i = 0; i < size[j]; i++, src+=2, *dest++ = v) | ||
116 | if ((v = ldm_parse_hexbyte (src)) < 0) | ||
117 | return false; | ||
118 | |||
119 | return true; | ||
120 | } | ||
121 | |||
122 | /** | ||
123 | * ldm_parse_privhead - Read the LDM Database PRIVHEAD structure | ||
124 | * @data: Raw database PRIVHEAD structure loaded from the device | ||
125 | * @ph: In-memory privhead structure in which to return parsed information | ||
126 | * | ||
127 | * This parses the LDM database PRIVHEAD structure supplied in @data and | ||
128 | * sets up the in-memory privhead structure @ph with the obtained information. | ||
129 | * | ||
130 | * Return: 'true' @ph contains the PRIVHEAD data | ||
131 | * 'false' @ph contents are undefined | ||
132 | */ | ||
133 | static bool ldm_parse_privhead(const u8 *data, struct privhead *ph) | ||
134 | { | ||
135 | bool is_vista = false; | ||
136 | |||
137 | BUG_ON(!data || !ph); | ||
138 | if (MAGIC_PRIVHEAD != get_unaligned_be64(data)) { | ||
139 | ldm_error("Cannot find PRIVHEAD structure. LDM database is" | ||
140 | " corrupt. Aborting."); | ||
141 | return false; | ||
142 | } | ||
143 | ph->ver_major = get_unaligned_be16(data + 0x000C); | ||
144 | ph->ver_minor = get_unaligned_be16(data + 0x000E); | ||
145 | ph->logical_disk_start = get_unaligned_be64(data + 0x011B); | ||
146 | ph->logical_disk_size = get_unaligned_be64(data + 0x0123); | ||
147 | ph->config_start = get_unaligned_be64(data + 0x012B); | ||
148 | ph->config_size = get_unaligned_be64(data + 0x0133); | ||
149 | /* Version 2.11 is Win2k/XP and version 2.12 is Vista. */ | ||
150 | if (ph->ver_major == 2 && ph->ver_minor == 12) | ||
151 | is_vista = true; | ||
152 | if (!is_vista && (ph->ver_major != 2 || ph->ver_minor != 11)) { | ||
153 | ldm_error("Expected PRIVHEAD version 2.11 or 2.12, got %d.%d." | ||
154 | " Aborting.", ph->ver_major, ph->ver_minor); | ||
155 | return false; | ||
156 | } | ||
157 | ldm_debug("PRIVHEAD version %d.%d (Windows %s).", ph->ver_major, | ||
158 | ph->ver_minor, is_vista ? "Vista" : "2000/XP"); | ||
159 | if (ph->config_size != LDM_DB_SIZE) { /* 1 MiB in sectors. */ | ||
160 | /* Warn the user and continue, carefully. */ | ||
161 | ldm_info("Database is normally %u bytes, it claims to " | ||
162 | "be %llu bytes.", LDM_DB_SIZE, | ||
163 | (unsigned long long)ph->config_size); | ||
164 | } | ||
165 | if ((ph->logical_disk_size == 0) || (ph->logical_disk_start + | ||
166 | ph->logical_disk_size > ph->config_start)) { | ||
167 | ldm_error("PRIVHEAD disk size doesn't match real disk size"); | ||
168 | return false; | ||
169 | } | ||
170 | if (!ldm_parse_guid(data + 0x0030, ph->disk_id)) { | ||
171 | ldm_error("PRIVHEAD contains an invalid GUID."); | ||
172 | return false; | ||
173 | } | ||
174 | ldm_debug("Parsed PRIVHEAD successfully."); | ||
175 | return true; | ||
176 | } | ||
177 | |||
178 | /** | ||
179 | * ldm_parse_tocblock - Read the LDM Database TOCBLOCK structure | ||
180 | * @data: Raw database TOCBLOCK structure loaded from the device | ||
181 | * @toc: In-memory toc structure in which to return parsed information | ||
182 | * | ||
183 | * This parses the LDM Database TOCBLOCK (table of contents) structure supplied | ||
184 | * in @data and sets up the in-memory tocblock structure @toc with the obtained | ||
185 | * information. | ||
186 | * | ||
187 | * N.B. The *_start and *_size values returned in @toc are not range-checked. | ||
188 | * | ||
189 | * Return: 'true' @toc contains the TOCBLOCK data | ||
190 | * 'false' @toc contents are undefined | ||
191 | */ | ||
192 | static bool ldm_parse_tocblock (const u8 *data, struct tocblock *toc) | ||
193 | { | ||
194 | BUG_ON (!data || !toc); | ||
195 | |||
196 | if (MAGIC_TOCBLOCK != get_unaligned_be64(data)) { | ||
197 | ldm_crit ("Cannot find TOCBLOCK, database may be corrupt."); | ||
198 | return false; | ||
199 | } | ||
200 | strncpy (toc->bitmap1_name, data + 0x24, sizeof (toc->bitmap1_name)); | ||
201 | toc->bitmap1_name[sizeof (toc->bitmap1_name) - 1] = 0; | ||
202 | toc->bitmap1_start = get_unaligned_be64(data + 0x2E); | ||
203 | toc->bitmap1_size = get_unaligned_be64(data + 0x36); | ||
204 | |||
205 | if (strncmp (toc->bitmap1_name, TOC_BITMAP1, | ||
206 | sizeof (toc->bitmap1_name)) != 0) { | ||
207 | ldm_crit ("TOCBLOCK's first bitmap is '%s', should be '%s'.", | ||
208 | TOC_BITMAP1, toc->bitmap1_name); | ||
209 | return false; | ||
210 | } | ||
211 | strncpy (toc->bitmap2_name, data + 0x46, sizeof (toc->bitmap2_name)); | ||
212 | toc->bitmap2_name[sizeof (toc->bitmap2_name) - 1] = 0; | ||
213 | toc->bitmap2_start = get_unaligned_be64(data + 0x50); | ||
214 | toc->bitmap2_size = get_unaligned_be64(data + 0x58); | ||
215 | if (strncmp (toc->bitmap2_name, TOC_BITMAP2, | ||
216 | sizeof (toc->bitmap2_name)) != 0) { | ||
217 | ldm_crit ("TOCBLOCK's second bitmap is '%s', should be '%s'.", | ||
218 | TOC_BITMAP2, toc->bitmap2_name); | ||
219 | return false; | ||
220 | } | ||
221 | ldm_debug ("Parsed TOCBLOCK successfully."); | ||
222 | return true; | ||
223 | } | ||
224 | |||
225 | /** | ||
226 | * ldm_parse_vmdb - Read the LDM Database VMDB structure | ||
227 | * @data: Raw database VMDB structure loaded from the device | ||
228 | * @vm: In-memory vmdb structure in which to return parsed information | ||
229 | * | ||
230 | * This parses the LDM Database VMDB structure supplied in @data and sets up | ||
231 | * the in-memory vmdb structure @vm with the obtained information. | ||
232 | * | ||
233 | * N.B. The *_start, *_size and *_seq values will be range-checked later. | ||
234 | * | ||
235 | * Return: 'true' @vm contains VMDB info | ||
236 | * 'false' @vm contents are undefined | ||
237 | */ | ||
238 | static bool ldm_parse_vmdb (const u8 *data, struct vmdb *vm) | ||
239 | { | ||
240 | BUG_ON (!data || !vm); | ||
241 | |||
242 | if (MAGIC_VMDB != get_unaligned_be32(data)) { | ||
243 | ldm_crit ("Cannot find the VMDB, database may be corrupt."); | ||
244 | return false; | ||
245 | } | ||
246 | |||
247 | vm->ver_major = get_unaligned_be16(data + 0x12); | ||
248 | vm->ver_minor = get_unaligned_be16(data + 0x14); | ||
249 | if ((vm->ver_major != 4) || (vm->ver_minor != 10)) { | ||
250 | ldm_error ("Expected VMDB version %d.%d, got %d.%d. " | ||
251 | "Aborting.", 4, 10, vm->ver_major, vm->ver_minor); | ||
252 | return false; | ||
253 | } | ||
254 | |||
255 | vm->vblk_size = get_unaligned_be32(data + 0x08); | ||
256 | if (vm->vblk_size == 0) { | ||
257 | ldm_error ("Illegal VBLK size"); | ||
258 | return false; | ||
259 | } | ||
260 | |||
261 | vm->vblk_offset = get_unaligned_be32(data + 0x0C); | ||
262 | vm->last_vblk_seq = get_unaligned_be32(data + 0x04); | ||
263 | |||
264 | ldm_debug ("Parsed VMDB successfully."); | ||
265 | return true; | ||
266 | } | ||
267 | |||
268 | /** | ||
269 | * ldm_compare_privheads - Compare two privhead objects | ||
270 | * @ph1: First privhead | ||
271 | * @ph2: Second privhead | ||
272 | * | ||
273 | * This compares the two privhead structures @ph1 and @ph2. | ||
274 | * | ||
275 | * Return: 'true' Identical | ||
276 | * 'false' Different | ||
277 | */ | ||
278 | static bool ldm_compare_privheads (const struct privhead *ph1, | ||
279 | const struct privhead *ph2) | ||
280 | { | ||
281 | BUG_ON (!ph1 || !ph2); | ||
282 | |||
283 | return ((ph1->ver_major == ph2->ver_major) && | ||
284 | (ph1->ver_minor == ph2->ver_minor) && | ||
285 | (ph1->logical_disk_start == ph2->logical_disk_start) && | ||
286 | (ph1->logical_disk_size == ph2->logical_disk_size) && | ||
287 | (ph1->config_start == ph2->config_start) && | ||
288 | (ph1->config_size == ph2->config_size) && | ||
289 | !memcmp (ph1->disk_id, ph2->disk_id, GUID_SIZE)); | ||
290 | } | ||
291 | |||
292 | /** | ||
293 | * ldm_compare_tocblocks - Compare two tocblock objects | ||
294 | * @toc1: First toc | ||
295 | * @toc2: Second toc | ||
296 | * | ||
297 | * This compares the two tocblock structures @toc1 and @toc2. | ||
298 | * | ||
299 | * Return: 'true' Identical | ||
300 | * 'false' Different | ||
301 | */ | ||
302 | static bool ldm_compare_tocblocks (const struct tocblock *toc1, | ||
303 | const struct tocblock *toc2) | ||
304 | { | ||
305 | BUG_ON (!toc1 || !toc2); | ||
306 | |||
307 | return ((toc1->bitmap1_start == toc2->bitmap1_start) && | ||
308 | (toc1->bitmap1_size == toc2->bitmap1_size) && | ||
309 | (toc1->bitmap2_start == toc2->bitmap2_start) && | ||
310 | (toc1->bitmap2_size == toc2->bitmap2_size) && | ||
311 | !strncmp (toc1->bitmap1_name, toc2->bitmap1_name, | ||
312 | sizeof (toc1->bitmap1_name)) && | ||
313 | !strncmp (toc1->bitmap2_name, toc2->bitmap2_name, | ||
314 | sizeof (toc1->bitmap2_name))); | ||
315 | } | ||
316 | |||
317 | /** | ||
318 | * ldm_validate_privheads - Compare the primary privhead with its backups | ||
319 | * @state: Partition check state including device holding the LDM Database | ||
320 | * @ph1: Memory struct to fill with ph contents | ||
321 | * | ||
322 | * Read and compare all three privheads from disk. | ||
323 | * | ||
324 | * The privheads on disk show the size and location of the main disk area and | ||
325 | * the configuration area (the database). The values are range-checked against | ||
326 | * @hd, which contains the real size of the disk. | ||
327 | * | ||
328 | * Return: 'true' Success | ||
329 | * 'false' Error | ||
330 | */ | ||
331 | static bool ldm_validate_privheads(struct parsed_partitions *state, | ||
332 | struct privhead *ph1) | ||
333 | { | ||
334 | static const int off[3] = { OFF_PRIV1, OFF_PRIV2, OFF_PRIV3 }; | ||
335 | struct privhead *ph[3] = { ph1 }; | ||
336 | Sector sect; | ||
337 | u8 *data; | ||
338 | bool result = false; | ||
339 | long num_sects; | ||
340 | int i; | ||
341 | |||
342 | BUG_ON (!state || !ph1); | ||
343 | |||
344 | ph[1] = kmalloc (sizeof (*ph[1]), GFP_KERNEL); | ||
345 | ph[2] = kmalloc (sizeof (*ph[2]), GFP_KERNEL); | ||
346 | if (!ph[1] || !ph[2]) { | ||
347 | ldm_crit ("Out of memory."); | ||
348 | goto out; | ||
349 | } | ||
350 | |||
351 | /* off[1 & 2] are relative to ph[0]->config_start */ | ||
352 | ph[0]->config_start = 0; | ||
353 | |||
354 | /* Read and parse privheads */ | ||
355 | for (i = 0; i < 3; i++) { | ||
356 | data = read_part_sector(state, ph[0]->config_start + off[i], | ||
357 | §); | ||
358 | if (!data) { | ||
359 | ldm_crit ("Disk read failed."); | ||
360 | goto out; | ||
361 | } | ||
362 | result = ldm_parse_privhead (data, ph[i]); | ||
363 | put_dev_sector (sect); | ||
364 | if (!result) { | ||
365 | ldm_error ("Cannot find PRIVHEAD %d.", i+1); /* Log again */ | ||
366 | if (i < 2) | ||
367 | goto out; /* Already logged */ | ||
368 | else | ||
369 | break; /* FIXME ignore for now, 3rd PH can fail on odd-sized disks */ | ||
370 | } | ||
371 | } | ||
372 | |||
373 | num_sects = state->bdev->bd_inode->i_size >> 9; | ||
374 | |||
375 | if ((ph[0]->config_start > num_sects) || | ||
376 | ((ph[0]->config_start + ph[0]->config_size) > num_sects)) { | ||
377 | ldm_crit ("Database extends beyond the end of the disk."); | ||
378 | goto out; | ||
379 | } | ||
380 | |||
381 | if ((ph[0]->logical_disk_start > ph[0]->config_start) || | ||
382 | ((ph[0]->logical_disk_start + ph[0]->logical_disk_size) | ||
383 | > ph[0]->config_start)) { | ||
384 | ldm_crit ("Disk and database overlap."); | ||
385 | goto out; | ||
386 | } | ||
387 | |||
388 | if (!ldm_compare_privheads (ph[0], ph[1])) { | ||
389 | ldm_crit ("Primary and backup PRIVHEADs don't match."); | ||
390 | goto out; | ||
391 | } | ||
392 | /* FIXME ignore this for now | ||
393 | if (!ldm_compare_privheads (ph[0], ph[2])) { | ||
394 | ldm_crit ("Primary and backup PRIVHEADs don't match."); | ||
395 | goto out; | ||
396 | }*/ | ||
397 | ldm_debug ("Validated PRIVHEADs successfully."); | ||
398 | result = true; | ||
399 | out: | ||
400 | kfree (ph[1]); | ||
401 | kfree (ph[2]); | ||
402 | return result; | ||
403 | } | ||
404 | |||
405 | /** | ||
406 | * ldm_validate_tocblocks - Validate the table of contents and its backups | ||
407 | * @state: Partition check state including device holding the LDM Database | ||
408 | * @base: Offset, into @state->bdev, of the database | ||
409 | * @ldb: Cache of the database structures | ||
410 | * | ||
411 | * Find and compare the four tables of contents of the LDM Database stored on | ||
412 | * @state->bdev and return the parsed information into @toc1. | ||
413 | * | ||
414 | * The offsets and sizes of the configs are range-checked against a privhead. | ||
415 | * | ||
416 | * Return: 'true' @toc1 contains validated TOCBLOCK info | ||
417 | * 'false' @toc1 contents are undefined | ||
418 | */ | ||
419 | static bool ldm_validate_tocblocks(struct parsed_partitions *state, | ||
420 | unsigned long base, struct ldmdb *ldb) | ||
421 | { | ||
422 | static const int off[4] = { OFF_TOCB1, OFF_TOCB2, OFF_TOCB3, OFF_TOCB4}; | ||
423 | struct tocblock *tb[4]; | ||
424 | struct privhead *ph; | ||
425 | Sector sect; | ||
426 | u8 *data; | ||
427 | int i, nr_tbs; | ||
428 | bool result = false; | ||
429 | |||
430 | BUG_ON(!state || !ldb); | ||
431 | ph = &ldb->ph; | ||
432 | tb[0] = &ldb->toc; | ||
433 | tb[1] = kmalloc(sizeof(*tb[1]) * 3, GFP_KERNEL); | ||
434 | if (!tb[1]) { | ||
435 | ldm_crit("Out of memory."); | ||
436 | goto err; | ||
437 | } | ||
438 | tb[2] = (struct tocblock*)((u8*)tb[1] + sizeof(*tb[1])); | ||
439 | tb[3] = (struct tocblock*)((u8*)tb[2] + sizeof(*tb[2])); | ||
440 | /* | ||
441 | * Try to read and parse all four TOCBLOCKs. | ||
442 | * | ||
443 | * Windows Vista LDM v2.12 does not always have all four TOCBLOCKs so | ||
444 | * skip any that fail as long as we get at least one valid TOCBLOCK. | ||
445 | */ | ||
446 | for (nr_tbs = i = 0; i < 4; i++) { | ||
447 | data = read_part_sector(state, base + off[i], §); | ||
448 | if (!data) { | ||
449 | ldm_error("Disk read failed for TOCBLOCK %d.", i); | ||
450 | continue; | ||
451 | } | ||
452 | if (ldm_parse_tocblock(data, tb[nr_tbs])) | ||
453 | nr_tbs++; | ||
454 | put_dev_sector(sect); | ||
455 | } | ||
456 | if (!nr_tbs) { | ||
457 | ldm_crit("Failed to find a valid TOCBLOCK."); | ||
458 | goto err; | ||
459 | } | ||
460 | /* Range check the TOCBLOCK against a privhead. */ | ||
461 | if (((tb[0]->bitmap1_start + tb[0]->bitmap1_size) > ph->config_size) || | ||
462 | ((tb[0]->bitmap2_start + tb[0]->bitmap2_size) > | ||
463 | ph->config_size)) { | ||
464 | ldm_crit("The bitmaps are out of range. Giving up."); | ||
465 | goto err; | ||
466 | } | ||
467 | /* Compare all loaded TOCBLOCKs. */ | ||
468 | for (i = 1; i < nr_tbs; i++) { | ||
469 | if (!ldm_compare_tocblocks(tb[0], tb[i])) { | ||
470 | ldm_crit("TOCBLOCKs 0 and %d do not match.", i); | ||
471 | goto err; | ||
472 | } | ||
473 | } | ||
474 | ldm_debug("Validated %d TOCBLOCKs successfully.", nr_tbs); | ||
475 | result = true; | ||
476 | err: | ||
477 | kfree(tb[1]); | ||
478 | return result; | ||
479 | } | ||
480 | |||
481 | /** | ||
482 | * ldm_validate_vmdb - Read the VMDB and validate it | ||
483 | * @state: Partition check state including device holding the LDM Database | ||
484 | * @base: Offset, into @bdev, of the database | ||
485 | * @ldb: Cache of the database structures | ||
486 | * | ||
487 | * Find the vmdb of the LDM Database stored on @bdev and return the parsed | ||
488 | * information in @ldb. | ||
489 | * | ||
490 | * Return: 'true' @ldb contains validated VBDB info | ||
491 | * 'false' @ldb contents are undefined | ||
492 | */ | ||
493 | static bool ldm_validate_vmdb(struct parsed_partitions *state, | ||
494 | unsigned long base, struct ldmdb *ldb) | ||
495 | { | ||
496 | Sector sect; | ||
497 | u8 *data; | ||
498 | bool result = false; | ||
499 | struct vmdb *vm; | ||
500 | struct tocblock *toc; | ||
501 | |||
502 | BUG_ON (!state || !ldb); | ||
503 | |||
504 | vm = &ldb->vm; | ||
505 | toc = &ldb->toc; | ||
506 | |||
507 | data = read_part_sector(state, base + OFF_VMDB, §); | ||
508 | if (!data) { | ||
509 | ldm_crit ("Disk read failed."); | ||
510 | return false; | ||
511 | } | ||
512 | |||
513 | if (!ldm_parse_vmdb (data, vm)) | ||
514 | goto out; /* Already logged */ | ||
515 | |||
516 | /* Are there uncommitted transactions? */ | ||
517 | if (get_unaligned_be16(data + 0x10) != 0x01) { | ||
518 | ldm_crit ("Database is not in a consistent state. Aborting."); | ||
519 | goto out; | ||
520 | } | ||
521 | |||
522 | if (vm->vblk_offset != 512) | ||
523 | ldm_info ("VBLKs start at offset 0x%04x.", vm->vblk_offset); | ||
524 | |||
525 | /* | ||
526 | * The last_vblkd_seq can be before the end of the vmdb, just make sure | ||
527 | * it is not out of bounds. | ||
528 | */ | ||
529 | if ((vm->vblk_size * vm->last_vblk_seq) > (toc->bitmap1_size << 9)) { | ||
530 | ldm_crit ("VMDB exceeds allowed size specified by TOCBLOCK. " | ||
531 | "Database is corrupt. Aborting."); | ||
532 | goto out; | ||
533 | } | ||
534 | |||
535 | result = true; | ||
536 | out: | ||
537 | put_dev_sector (sect); | ||
538 | return result; | ||
539 | } | ||
540 | |||
541 | |||
542 | /** | ||
543 | * ldm_validate_partition_table - Determine whether bdev might be a dynamic disk | ||
544 | * @state: Partition check state including device holding the LDM Database | ||
545 | * | ||
546 | * This function provides a weak test to decide whether the device is a dynamic | ||
547 | * disk or not. It looks for an MS-DOS-style partition table containing at | ||
548 | * least one partition of type 0x42 (formerly SFS, now used by Windows for | ||
549 | * dynamic disks). | ||
550 | * | ||
551 | * N.B. The only possible error can come from the read_part_sector and that is | ||
552 | * only likely to happen if the underlying device is strange. If that IS | ||
553 | * the case we should return zero to let someone else try. | ||
554 | * | ||
555 | * Return: 'true' @state->bdev is a dynamic disk | ||
556 | * 'false' @state->bdev is not a dynamic disk, or an error occurred | ||
557 | */ | ||
558 | static bool ldm_validate_partition_table(struct parsed_partitions *state) | ||
559 | { | ||
560 | Sector sect; | ||
561 | u8 *data; | ||
562 | struct partition *p; | ||
563 | int i; | ||
564 | bool result = false; | ||
565 | |||
566 | BUG_ON(!state); | ||
567 | |||
568 | data = read_part_sector(state, 0, §); | ||
569 | if (!data) { | ||
570 | ldm_info ("Disk read failed."); | ||
571 | return false; | ||
572 | } | ||
573 | |||
574 | if (*(__le16*) (data + 0x01FE) != cpu_to_le16 (MSDOS_LABEL_MAGIC)) | ||
575 | goto out; | ||
576 | |||
577 | p = (struct partition*)(data + 0x01BE); | ||
578 | for (i = 0; i < 4; i++, p++) | ||
579 | if (SYS_IND (p) == LDM_PARTITION) { | ||
580 | result = true; | ||
581 | break; | ||
582 | } | ||
583 | |||
584 | if (result) | ||
585 | ldm_debug ("Found W2K dynamic disk partition type."); | ||
586 | |||
587 | out: | ||
588 | put_dev_sector (sect); | ||
589 | return result; | ||
590 | } | ||
591 | |||
592 | /** | ||
593 | * ldm_get_disk_objid - Search a linked list of vblk's for a given Disk Id | ||
594 | * @ldb: Cache of the database structures | ||
595 | * | ||
596 | * The LDM Database contains a list of all partitions on all dynamic disks. | ||
597 | * The primary PRIVHEAD, at the beginning of the physical disk, tells us | ||
598 | * the GUID of this disk. This function searches for the GUID in a linked | ||
599 | * list of vblk's. | ||
600 | * | ||
601 | * Return: Pointer, A matching vblk was found | ||
602 | * NULL, No match, or an error | ||
603 | */ | ||
604 | static struct vblk * ldm_get_disk_objid (const struct ldmdb *ldb) | ||
605 | { | ||
606 | struct list_head *item; | ||
607 | |||
608 | BUG_ON (!ldb); | ||
609 | |||
610 | list_for_each (item, &ldb->v_disk) { | ||
611 | struct vblk *v = list_entry (item, struct vblk, list); | ||
612 | if (!memcmp (v->vblk.disk.disk_id, ldb->ph.disk_id, GUID_SIZE)) | ||
613 | return v; | ||
614 | } | ||
615 | |||
616 | return NULL; | ||
617 | } | ||
618 | |||
619 | /** | ||
620 | * ldm_create_data_partitions - Create data partitions for this device | ||
621 | * @pp: List of the partitions parsed so far | ||
622 | * @ldb: Cache of the database structures | ||
623 | * | ||
624 | * The database contains ALL the partitions for ALL disk groups, so we need to | ||
625 | * filter out this specific disk. Using the disk's object id, we can find all | ||
626 | * the partitions in the database that belong to this disk. | ||
627 | * | ||
628 | * Add each partition in our database, to the parsed_partitions structure. | ||
629 | * | ||
630 | * N.B. This function creates the partitions in the order it finds partition | ||
631 | * objects in the linked list. | ||
632 | * | ||
633 | * Return: 'true' Partition created | ||
634 | * 'false' Error, probably a range checking problem | ||
635 | */ | ||
636 | static bool ldm_create_data_partitions (struct parsed_partitions *pp, | ||
637 | const struct ldmdb *ldb) | ||
638 | { | ||
639 | struct list_head *item; | ||
640 | struct vblk *vb; | ||
641 | struct vblk *disk; | ||
642 | struct vblk_part *part; | ||
643 | int part_num = 1; | ||
644 | |||
645 | BUG_ON (!pp || !ldb); | ||
646 | |||
647 | disk = ldm_get_disk_objid (ldb); | ||
648 | if (!disk) { | ||
649 | ldm_crit ("Can't find the ID of this disk in the database."); | ||
650 | return false; | ||
651 | } | ||
652 | |||
653 | strlcat(pp->pp_buf, " [LDM]", PAGE_SIZE); | ||
654 | |||
655 | /* Create the data partitions */ | ||
656 | list_for_each (item, &ldb->v_part) { | ||
657 | vb = list_entry (item, struct vblk, list); | ||
658 | part = &vb->vblk.part; | ||
659 | |||
660 | if (part->disk_id != disk->obj_id) | ||
661 | continue; | ||
662 | |||
663 | put_partition (pp, part_num, ldb->ph.logical_disk_start + | ||
664 | part->start, part->size); | ||
665 | part_num++; | ||
666 | } | ||
667 | |||
668 | strlcat(pp->pp_buf, "\n", PAGE_SIZE); | ||
669 | return true; | ||
670 | } | ||
671 | |||
672 | |||
673 | /** | ||
674 | * ldm_relative - Calculate the next relative offset | ||
675 | * @buffer: Block of data being worked on | ||
676 | * @buflen: Size of the block of data | ||
677 | * @base: Size of the previous fixed width fields | ||
678 | * @offset: Cumulative size of the previous variable-width fields | ||
679 | * | ||
680 | * Because many of the VBLK fields are variable-width, it's necessary | ||
681 | * to calculate each offset based on the previous one and the length | ||
682 | * of the field it pointed to. | ||
683 | * | ||
684 | * Return: -1 Error, the calculated offset exceeded the size of the buffer | ||
685 | * n OK, a range-checked offset into buffer | ||
686 | */ | ||
687 | static int ldm_relative(const u8 *buffer, int buflen, int base, int offset) | ||
688 | { | ||
689 | |||
690 | base += offset; | ||
691 | if (!buffer || offset < 0 || base > buflen) { | ||
692 | if (!buffer) | ||
693 | ldm_error("!buffer"); | ||
694 | if (offset < 0) | ||
695 | ldm_error("offset (%d) < 0", offset); | ||
696 | if (base > buflen) | ||
697 | ldm_error("base (%d) > buflen (%d)", base, buflen); | ||
698 | return -1; | ||
699 | } | ||
700 | if (base + buffer[base] >= buflen) { | ||
701 | ldm_error("base (%d) + buffer[base] (%d) >= buflen (%d)", base, | ||
702 | buffer[base], buflen); | ||
703 | return -1; | ||
704 | } | ||
705 | return buffer[base] + offset + 1; | ||
706 | } | ||
707 | |||
708 | /** | ||
709 | * ldm_get_vnum - Convert a variable-width, big endian number, into cpu order | ||
710 | * @block: Pointer to the variable-width number to convert | ||
711 | * | ||
712 | * Large numbers in the LDM Database are often stored in a packed format. Each | ||
713 | * number is prefixed by a one byte width marker. All numbers in the database | ||
714 | * are stored in big-endian byte order. This function reads one of these | ||
715 | * numbers and returns the result | ||
716 | * | ||
717 | * N.B. This function DOES NOT perform any range checking, though the most | ||
718 | * it will read is eight bytes. | ||
719 | * | ||
720 | * Return: n A number | ||
721 | * 0 Zero, or an error occurred | ||
722 | */ | ||
723 | static u64 ldm_get_vnum (const u8 *block) | ||
724 | { | ||
725 | u64 tmp = 0; | ||
726 | u8 length; | ||
727 | |||
728 | BUG_ON (!block); | ||
729 | |||
730 | length = *block++; | ||
731 | |||
732 | if (length && length <= 8) | ||
733 | while (length--) | ||
734 | tmp = (tmp << 8) | *block++; | ||
735 | else | ||
736 | ldm_error ("Illegal length %d.", length); | ||
737 | |||
738 | return tmp; | ||
739 | } | ||
740 | |||
741 | /** | ||
742 | * ldm_get_vstr - Read a length-prefixed string into a buffer | ||
743 | * @block: Pointer to the length marker | ||
744 | * @buffer: Location to copy string to | ||
745 | * @buflen: Size of the output buffer | ||
746 | * | ||
747 | * Many of the strings in the LDM Database are not NULL terminated. Instead | ||
748 | * they are prefixed by a one byte length marker. This function copies one of | ||
749 | * these strings into a buffer. | ||
750 | * | ||
751 | * N.B. This function DOES NOT perform any range checking on the input. | ||
752 | * If the buffer is too small, the output will be truncated. | ||
753 | * | ||
754 | * Return: 0, Error and @buffer contents are undefined | ||
755 | * n, String length in characters (excluding NULL) | ||
756 | * buflen-1, String was truncated. | ||
757 | */ | ||
758 | static int ldm_get_vstr (const u8 *block, u8 *buffer, int buflen) | ||
759 | { | ||
760 | int length; | ||
761 | |||
762 | BUG_ON (!block || !buffer); | ||
763 | |||
764 | length = block[0]; | ||
765 | if (length >= buflen) { | ||
766 | ldm_error ("Truncating string %d -> %d.", length, buflen); | ||
767 | length = buflen - 1; | ||
768 | } | ||
769 | memcpy (buffer, block + 1, length); | ||
770 | buffer[length] = 0; | ||
771 | return length; | ||
772 | } | ||
773 | |||
774 | |||
775 | /** | ||
776 | * ldm_parse_cmp3 - Read a raw VBLK Component object into a vblk structure | ||
777 | * @buffer: Block of data being worked on | ||
778 | * @buflen: Size of the block of data | ||
779 | * @vb: In-memory vblk in which to return information | ||
780 | * | ||
781 | * Read a raw VBLK Component object (version 3) into a vblk structure. | ||
782 | * | ||
783 | * Return: 'true' @vb contains a Component VBLK | ||
784 | * 'false' @vb contents are not defined | ||
785 | */ | ||
786 | static bool ldm_parse_cmp3 (const u8 *buffer, int buflen, struct vblk *vb) | ||
787 | { | ||
788 | int r_objid, r_name, r_vstate, r_child, r_parent, r_stripe, r_cols, len; | ||
789 | struct vblk_comp *comp; | ||
790 | |||
791 | BUG_ON (!buffer || !vb); | ||
792 | |||
793 | r_objid = ldm_relative (buffer, buflen, 0x18, 0); | ||
794 | r_name = ldm_relative (buffer, buflen, 0x18, r_objid); | ||
795 | r_vstate = ldm_relative (buffer, buflen, 0x18, r_name); | ||
796 | r_child = ldm_relative (buffer, buflen, 0x1D, r_vstate); | ||
797 | r_parent = ldm_relative (buffer, buflen, 0x2D, r_child); | ||
798 | |||
799 | if (buffer[0x12] & VBLK_FLAG_COMP_STRIPE) { | ||
800 | r_stripe = ldm_relative (buffer, buflen, 0x2E, r_parent); | ||
801 | r_cols = ldm_relative (buffer, buflen, 0x2E, r_stripe); | ||
802 | len = r_cols; | ||
803 | } else { | ||
804 | r_stripe = 0; | ||
805 | r_cols = 0; | ||
806 | len = r_parent; | ||
807 | } | ||
808 | if (len < 0) | ||
809 | return false; | ||
810 | |||
811 | len += VBLK_SIZE_CMP3; | ||
812 | if (len != get_unaligned_be32(buffer + 0x14)) | ||
813 | return false; | ||
814 | |||
815 | comp = &vb->vblk.comp; | ||
816 | ldm_get_vstr (buffer + 0x18 + r_name, comp->state, | ||
817 | sizeof (comp->state)); | ||
818 | comp->type = buffer[0x18 + r_vstate]; | ||
819 | comp->children = ldm_get_vnum (buffer + 0x1D + r_vstate); | ||
820 | comp->parent_id = ldm_get_vnum (buffer + 0x2D + r_child); | ||
821 | comp->chunksize = r_stripe ? ldm_get_vnum (buffer+r_parent+0x2E) : 0; | ||
822 | |||
823 | return true; | ||
824 | } | ||
825 | |||
826 | /** | ||
827 | * ldm_parse_dgr3 - Read a raw VBLK Disk Group object into a vblk structure | ||
828 | * @buffer: Block of data being worked on | ||
829 | * @buflen: Size of the block of data | ||
830 | * @vb: In-memory vblk in which to return information | ||
831 | * | ||
832 | * Read a raw VBLK Disk Group object (version 3) into a vblk structure. | ||
833 | * | ||
834 | * Return: 'true' @vb contains a Disk Group VBLK | ||
835 | * 'false' @vb contents are not defined | ||
836 | */ | ||
837 | static int ldm_parse_dgr3 (const u8 *buffer, int buflen, struct vblk *vb) | ||
838 | { | ||
839 | int r_objid, r_name, r_diskid, r_id1, r_id2, len; | ||
840 | struct vblk_dgrp *dgrp; | ||
841 | |||
842 | BUG_ON (!buffer || !vb); | ||
843 | |||
844 | r_objid = ldm_relative (buffer, buflen, 0x18, 0); | ||
845 | r_name = ldm_relative (buffer, buflen, 0x18, r_objid); | ||
846 | r_diskid = ldm_relative (buffer, buflen, 0x18, r_name); | ||
847 | |||
848 | if (buffer[0x12] & VBLK_FLAG_DGR3_IDS) { | ||
849 | r_id1 = ldm_relative (buffer, buflen, 0x24, r_diskid); | ||
850 | r_id2 = ldm_relative (buffer, buflen, 0x24, r_id1); | ||
851 | len = r_id2; | ||
852 | } else { | ||
853 | r_id1 = 0; | ||
854 | r_id2 = 0; | ||
855 | len = r_diskid; | ||
856 | } | ||
857 | if (len < 0) | ||
858 | return false; | ||
859 | |||
860 | len += VBLK_SIZE_DGR3; | ||
861 | if (len != get_unaligned_be32(buffer + 0x14)) | ||
862 | return false; | ||
863 | |||
864 | dgrp = &vb->vblk.dgrp; | ||
865 | ldm_get_vstr (buffer + 0x18 + r_name, dgrp->disk_id, | ||
866 | sizeof (dgrp->disk_id)); | ||
867 | return true; | ||
868 | } | ||
869 | |||
870 | /** | ||
871 | * ldm_parse_dgr4 - Read a raw VBLK Disk Group object into a vblk structure | ||
872 | * @buffer: Block of data being worked on | ||
873 | * @buflen: Size of the block of data | ||
874 | * @vb: In-memory vblk in which to return information | ||
875 | * | ||
876 | * Read a raw VBLK Disk Group object (version 4) into a vblk structure. | ||
877 | * | ||
878 | * Return: 'true' @vb contains a Disk Group VBLK | ||
879 | * 'false' @vb contents are not defined | ||
880 | */ | ||
881 | static bool ldm_parse_dgr4 (const u8 *buffer, int buflen, struct vblk *vb) | ||
882 | { | ||
883 | char buf[64]; | ||
884 | int r_objid, r_name, r_id1, r_id2, len; | ||
885 | struct vblk_dgrp *dgrp; | ||
886 | |||
887 | BUG_ON (!buffer || !vb); | ||
888 | |||
889 | r_objid = ldm_relative (buffer, buflen, 0x18, 0); | ||
890 | r_name = ldm_relative (buffer, buflen, 0x18, r_objid); | ||
891 | |||
892 | if (buffer[0x12] & VBLK_FLAG_DGR4_IDS) { | ||
893 | r_id1 = ldm_relative (buffer, buflen, 0x44, r_name); | ||
894 | r_id2 = ldm_relative (buffer, buflen, 0x44, r_id1); | ||
895 | len = r_id2; | ||
896 | } else { | ||
897 | r_id1 = 0; | ||
898 | r_id2 = 0; | ||
899 | len = r_name; | ||
900 | } | ||
901 | if (len < 0) | ||
902 | return false; | ||
903 | |||
904 | len += VBLK_SIZE_DGR4; | ||
905 | if (len != get_unaligned_be32(buffer + 0x14)) | ||
906 | return false; | ||
907 | |||
908 | dgrp = &vb->vblk.dgrp; | ||
909 | |||
910 | ldm_get_vstr (buffer + 0x18 + r_objid, buf, sizeof (buf)); | ||
911 | return true; | ||
912 | } | ||
913 | |||
914 | /** | ||
915 | * ldm_parse_dsk3 - Read a raw VBLK Disk object into a vblk structure | ||
916 | * @buffer: Block of data being worked on | ||
917 | * @buflen: Size of the block of data | ||
918 | * @vb: In-memory vblk in which to return information | ||
919 | * | ||
920 | * Read a raw VBLK Disk object (version 3) into a vblk structure. | ||
921 | * | ||
922 | * Return: 'true' @vb contains a Disk VBLK | ||
923 | * 'false' @vb contents are not defined | ||
924 | */ | ||
925 | static bool ldm_parse_dsk3 (const u8 *buffer, int buflen, struct vblk *vb) | ||
926 | { | ||
927 | int r_objid, r_name, r_diskid, r_altname, len; | ||
928 | struct vblk_disk *disk; | ||
929 | |||
930 | BUG_ON (!buffer || !vb); | ||
931 | |||
932 | r_objid = ldm_relative (buffer, buflen, 0x18, 0); | ||
933 | r_name = ldm_relative (buffer, buflen, 0x18, r_objid); | ||
934 | r_diskid = ldm_relative (buffer, buflen, 0x18, r_name); | ||
935 | r_altname = ldm_relative (buffer, buflen, 0x18, r_diskid); | ||
936 | len = r_altname; | ||
937 | if (len < 0) | ||
938 | return false; | ||
939 | |||
940 | len += VBLK_SIZE_DSK3; | ||
941 | if (len != get_unaligned_be32(buffer + 0x14)) | ||
942 | return false; | ||
943 | |||
944 | disk = &vb->vblk.disk; | ||
945 | ldm_get_vstr (buffer + 0x18 + r_diskid, disk->alt_name, | ||
946 | sizeof (disk->alt_name)); | ||
947 | if (!ldm_parse_guid (buffer + 0x19 + r_name, disk->disk_id)) | ||
948 | return false; | ||
949 | |||
950 | return true; | ||
951 | } | ||
952 | |||
953 | /** | ||
954 | * ldm_parse_dsk4 - Read a raw VBLK Disk object into a vblk structure | ||
955 | * @buffer: Block of data being worked on | ||
956 | * @buflen: Size of the block of data | ||
957 | * @vb: In-memory vblk in which to return information | ||
958 | * | ||
959 | * Read a raw VBLK Disk object (version 4) into a vblk structure. | ||
960 | * | ||
961 | * Return: 'true' @vb contains a Disk VBLK | ||
962 | * 'false' @vb contents are not defined | ||
963 | */ | ||
964 | static bool ldm_parse_dsk4 (const u8 *buffer, int buflen, struct vblk *vb) | ||
965 | { | ||
966 | int r_objid, r_name, len; | ||
967 | struct vblk_disk *disk; | ||
968 | |||
969 | BUG_ON (!buffer || !vb); | ||
970 | |||
971 | r_objid = ldm_relative (buffer, buflen, 0x18, 0); | ||
972 | r_name = ldm_relative (buffer, buflen, 0x18, r_objid); | ||
973 | len = r_name; | ||
974 | if (len < 0) | ||
975 | return false; | ||
976 | |||
977 | len += VBLK_SIZE_DSK4; | ||
978 | if (len != get_unaligned_be32(buffer + 0x14)) | ||
979 | return false; | ||
980 | |||
981 | disk = &vb->vblk.disk; | ||
982 | memcpy (disk->disk_id, buffer + 0x18 + r_name, GUID_SIZE); | ||
983 | return true; | ||
984 | } | ||
985 | |||
986 | /** | ||
987 | * ldm_parse_prt3 - Read a raw VBLK Partition object into a vblk structure | ||
988 | * @buffer: Block of data being worked on | ||
989 | * @buflen: Size of the block of data | ||
990 | * @vb: In-memory vblk in which to return information | ||
991 | * | ||
992 | * Read a raw VBLK Partition object (version 3) into a vblk structure. | ||
993 | * | ||
994 | * Return: 'true' @vb contains a Partition VBLK | ||
995 | * 'false' @vb contents are not defined | ||
996 | */ | ||
997 | static bool ldm_parse_prt3(const u8 *buffer, int buflen, struct vblk *vb) | ||
998 | { | ||
999 | int r_objid, r_name, r_size, r_parent, r_diskid, r_index, len; | ||
1000 | struct vblk_part *part; | ||
1001 | |||
1002 | BUG_ON(!buffer || !vb); | ||
1003 | r_objid = ldm_relative(buffer, buflen, 0x18, 0); | ||
1004 | if (r_objid < 0) { | ||
1005 | ldm_error("r_objid %d < 0", r_objid); | ||
1006 | return false; | ||
1007 | } | ||
1008 | r_name = ldm_relative(buffer, buflen, 0x18, r_objid); | ||
1009 | if (r_name < 0) { | ||
1010 | ldm_error("r_name %d < 0", r_name); | ||
1011 | return false; | ||
1012 | } | ||
1013 | r_size = ldm_relative(buffer, buflen, 0x34, r_name); | ||
1014 | if (r_size < 0) { | ||
1015 | ldm_error("r_size %d < 0", r_size); | ||
1016 | return false; | ||
1017 | } | ||
1018 | r_parent = ldm_relative(buffer, buflen, 0x34, r_size); | ||
1019 | if (r_parent < 0) { | ||
1020 | ldm_error("r_parent %d < 0", r_parent); | ||
1021 | return false; | ||
1022 | } | ||
1023 | r_diskid = ldm_relative(buffer, buflen, 0x34, r_parent); | ||
1024 | if (r_diskid < 0) { | ||
1025 | ldm_error("r_diskid %d < 0", r_diskid); | ||
1026 | return false; | ||
1027 | } | ||
1028 | if (buffer[0x12] & VBLK_FLAG_PART_INDEX) { | ||
1029 | r_index = ldm_relative(buffer, buflen, 0x34, r_diskid); | ||
1030 | if (r_index < 0) { | ||
1031 | ldm_error("r_index %d < 0", r_index); | ||
1032 | return false; | ||
1033 | } | ||
1034 | len = r_index; | ||
1035 | } else { | ||
1036 | r_index = 0; | ||
1037 | len = r_diskid; | ||
1038 | } | ||
1039 | if (len < 0) { | ||
1040 | ldm_error("len %d < 0", len); | ||
1041 | return false; | ||
1042 | } | ||
1043 | len += VBLK_SIZE_PRT3; | ||
1044 | if (len > get_unaligned_be32(buffer + 0x14)) { | ||
1045 | ldm_error("len %d > BE32(buffer + 0x14) %d", len, | ||
1046 | get_unaligned_be32(buffer + 0x14)); | ||
1047 | return false; | ||
1048 | } | ||
1049 | part = &vb->vblk.part; | ||
1050 | part->start = get_unaligned_be64(buffer + 0x24 + r_name); | ||
1051 | part->volume_offset = get_unaligned_be64(buffer + 0x2C + r_name); | ||
1052 | part->size = ldm_get_vnum(buffer + 0x34 + r_name); | ||
1053 | part->parent_id = ldm_get_vnum(buffer + 0x34 + r_size); | ||
1054 | part->disk_id = ldm_get_vnum(buffer + 0x34 + r_parent); | ||
1055 | if (vb->flags & VBLK_FLAG_PART_INDEX) | ||
1056 | part->partnum = buffer[0x35 + r_diskid]; | ||
1057 | else | ||
1058 | part->partnum = 0; | ||
1059 | return true; | ||
1060 | } | ||
1061 | |||
1062 | /** | ||
1063 | * ldm_parse_vol5 - Read a raw VBLK Volume object into a vblk structure | ||
1064 | * @buffer: Block of data being worked on | ||
1065 | * @buflen: Size of the block of data | ||
1066 | * @vb: In-memory vblk in which to return information | ||
1067 | * | ||
1068 | * Read a raw VBLK Volume object (version 5) into a vblk structure. | ||
1069 | * | ||
1070 | * Return: 'true' @vb contains a Volume VBLK | ||
1071 | * 'false' @vb contents are not defined | ||
1072 | */ | ||
1073 | static bool ldm_parse_vol5(const u8 *buffer, int buflen, struct vblk *vb) | ||
1074 | { | ||
1075 | int r_objid, r_name, r_vtype, r_disable_drive_letter, r_child, r_size; | ||
1076 | int r_id1, r_id2, r_size2, r_drive, len; | ||
1077 | struct vblk_volu *volu; | ||
1078 | |||
1079 | BUG_ON(!buffer || !vb); | ||
1080 | r_objid = ldm_relative(buffer, buflen, 0x18, 0); | ||
1081 | if (r_objid < 0) { | ||
1082 | ldm_error("r_objid %d < 0", r_objid); | ||
1083 | return false; | ||
1084 | } | ||
1085 | r_name = ldm_relative(buffer, buflen, 0x18, r_objid); | ||
1086 | if (r_name < 0) { | ||
1087 | ldm_error("r_name %d < 0", r_name); | ||
1088 | return false; | ||
1089 | } | ||
1090 | r_vtype = ldm_relative(buffer, buflen, 0x18, r_name); | ||
1091 | if (r_vtype < 0) { | ||
1092 | ldm_error("r_vtype %d < 0", r_vtype); | ||
1093 | return false; | ||
1094 | } | ||
1095 | r_disable_drive_letter = ldm_relative(buffer, buflen, 0x18, r_vtype); | ||
1096 | if (r_disable_drive_letter < 0) { | ||
1097 | ldm_error("r_disable_drive_letter %d < 0", | ||
1098 | r_disable_drive_letter); | ||
1099 | return false; | ||
1100 | } | ||
1101 | r_child = ldm_relative(buffer, buflen, 0x2D, r_disable_drive_letter); | ||
1102 | if (r_child < 0) { | ||
1103 | ldm_error("r_child %d < 0", r_child); | ||
1104 | return false; | ||
1105 | } | ||
1106 | r_size = ldm_relative(buffer, buflen, 0x3D, r_child); | ||
1107 | if (r_size < 0) { | ||
1108 | ldm_error("r_size %d < 0", r_size); | ||
1109 | return false; | ||
1110 | } | ||
1111 | if (buffer[0x12] & VBLK_FLAG_VOLU_ID1) { | ||
1112 | r_id1 = ldm_relative(buffer, buflen, 0x52, r_size); | ||
1113 | if (r_id1 < 0) { | ||
1114 | ldm_error("r_id1 %d < 0", r_id1); | ||
1115 | return false; | ||
1116 | } | ||
1117 | } else | ||
1118 | r_id1 = r_size; | ||
1119 | if (buffer[0x12] & VBLK_FLAG_VOLU_ID2) { | ||
1120 | r_id2 = ldm_relative(buffer, buflen, 0x52, r_id1); | ||
1121 | if (r_id2 < 0) { | ||
1122 | ldm_error("r_id2 %d < 0", r_id2); | ||
1123 | return false; | ||
1124 | } | ||
1125 | } else | ||
1126 | r_id2 = r_id1; | ||
1127 | if (buffer[0x12] & VBLK_FLAG_VOLU_SIZE) { | ||
1128 | r_size2 = ldm_relative(buffer, buflen, 0x52, r_id2); | ||
1129 | if (r_size2 < 0) { | ||
1130 | ldm_error("r_size2 %d < 0", r_size2); | ||
1131 | return false; | ||
1132 | } | ||
1133 | } else | ||
1134 | r_size2 = r_id2; | ||
1135 | if (buffer[0x12] & VBLK_FLAG_VOLU_DRIVE) { | ||
1136 | r_drive = ldm_relative(buffer, buflen, 0x52, r_size2); | ||
1137 | if (r_drive < 0) { | ||
1138 | ldm_error("r_drive %d < 0", r_drive); | ||
1139 | return false; | ||
1140 | } | ||
1141 | } else | ||
1142 | r_drive = r_size2; | ||
1143 | len = r_drive; | ||
1144 | if (len < 0) { | ||
1145 | ldm_error("len %d < 0", len); | ||
1146 | return false; | ||
1147 | } | ||
1148 | len += VBLK_SIZE_VOL5; | ||
1149 | if (len > get_unaligned_be32(buffer + 0x14)) { | ||
1150 | ldm_error("len %d > BE32(buffer + 0x14) %d", len, | ||
1151 | get_unaligned_be32(buffer + 0x14)); | ||
1152 | return false; | ||
1153 | } | ||
1154 | volu = &vb->vblk.volu; | ||
1155 | ldm_get_vstr(buffer + 0x18 + r_name, volu->volume_type, | ||
1156 | sizeof(volu->volume_type)); | ||
1157 | memcpy(volu->volume_state, buffer + 0x18 + r_disable_drive_letter, | ||
1158 | sizeof(volu->volume_state)); | ||
1159 | volu->size = ldm_get_vnum(buffer + 0x3D + r_child); | ||
1160 | volu->partition_type = buffer[0x41 + r_size]; | ||
1161 | memcpy(volu->guid, buffer + 0x42 + r_size, sizeof(volu->guid)); | ||
1162 | if (buffer[0x12] & VBLK_FLAG_VOLU_DRIVE) { | ||
1163 | ldm_get_vstr(buffer + 0x52 + r_size, volu->drive_hint, | ||
1164 | sizeof(volu->drive_hint)); | ||
1165 | } | ||
1166 | return true; | ||
1167 | } | ||
1168 | |||
1169 | /** | ||
1170 | * ldm_parse_vblk - Read a raw VBLK object into a vblk structure | ||
1171 | * @buf: Block of data being worked on | ||
1172 | * @len: Size of the block of data | ||
1173 | * @vb: In-memory vblk in which to return information | ||
1174 | * | ||
1175 | * Read a raw VBLK object into a vblk structure. This function just reads the | ||
1176 | * information common to all VBLK types, then delegates the rest of the work to | ||
1177 | * helper functions: ldm_parse_*. | ||
1178 | * | ||
1179 | * Return: 'true' @vb contains a VBLK | ||
1180 | * 'false' @vb contents are not defined | ||
1181 | */ | ||
1182 | static bool ldm_parse_vblk (const u8 *buf, int len, struct vblk *vb) | ||
1183 | { | ||
1184 | bool result = false; | ||
1185 | int r_objid; | ||
1186 | |||
1187 | BUG_ON (!buf || !vb); | ||
1188 | |||
1189 | r_objid = ldm_relative (buf, len, 0x18, 0); | ||
1190 | if (r_objid < 0) { | ||
1191 | ldm_error ("VBLK header is corrupt."); | ||
1192 | return false; | ||
1193 | } | ||
1194 | |||
1195 | vb->flags = buf[0x12]; | ||
1196 | vb->type = buf[0x13]; | ||
1197 | vb->obj_id = ldm_get_vnum (buf + 0x18); | ||
1198 | ldm_get_vstr (buf+0x18+r_objid, vb->name, sizeof (vb->name)); | ||
1199 | |||
1200 | switch (vb->type) { | ||
1201 | case VBLK_CMP3: result = ldm_parse_cmp3 (buf, len, vb); break; | ||
1202 | case VBLK_DSK3: result = ldm_parse_dsk3 (buf, len, vb); break; | ||
1203 | case VBLK_DSK4: result = ldm_parse_dsk4 (buf, len, vb); break; | ||
1204 | case VBLK_DGR3: result = ldm_parse_dgr3 (buf, len, vb); break; | ||
1205 | case VBLK_DGR4: result = ldm_parse_dgr4 (buf, len, vb); break; | ||
1206 | case VBLK_PRT3: result = ldm_parse_prt3 (buf, len, vb); break; | ||
1207 | case VBLK_VOL5: result = ldm_parse_vol5 (buf, len, vb); break; | ||
1208 | } | ||
1209 | |||
1210 | if (result) | ||
1211 | ldm_debug ("Parsed VBLK 0x%llx (type: 0x%02x) ok.", | ||
1212 | (unsigned long long) vb->obj_id, vb->type); | ||
1213 | else | ||
1214 | ldm_error ("Failed to parse VBLK 0x%llx (type: 0x%02x).", | ||
1215 | (unsigned long long) vb->obj_id, vb->type); | ||
1216 | |||
1217 | return result; | ||
1218 | } | ||
1219 | |||
1220 | |||
1221 | /** | ||
1222 | * ldm_ldmdb_add - Adds a raw VBLK entry to the ldmdb database | ||
1223 | * @data: Raw VBLK to add to the database | ||
1224 | * @len: Size of the raw VBLK | ||
1225 | * @ldb: Cache of the database structures | ||
1226 | * | ||
1227 | * The VBLKs are sorted into categories. Partitions are also sorted by offset. | ||
1228 | * | ||
1229 | * N.B. This function does not check the validity of the VBLKs. | ||
1230 | * | ||
1231 | * Return: 'true' The VBLK was added | ||
1232 | * 'false' An error occurred | ||
1233 | */ | ||
1234 | static bool ldm_ldmdb_add (u8 *data, int len, struct ldmdb *ldb) | ||
1235 | { | ||
1236 | struct vblk *vb; | ||
1237 | struct list_head *item; | ||
1238 | |||
1239 | BUG_ON (!data || !ldb); | ||
1240 | |||
1241 | vb = kmalloc (sizeof (*vb), GFP_KERNEL); | ||
1242 | if (!vb) { | ||
1243 | ldm_crit ("Out of memory."); | ||
1244 | return false; | ||
1245 | } | ||
1246 | |||
1247 | if (!ldm_parse_vblk (data, len, vb)) { | ||
1248 | kfree(vb); | ||
1249 | return false; /* Already logged */ | ||
1250 | } | ||
1251 | |||
1252 | /* Put vblk into the correct list. */ | ||
1253 | switch (vb->type) { | ||
1254 | case VBLK_DGR3: | ||
1255 | case VBLK_DGR4: | ||
1256 | list_add (&vb->list, &ldb->v_dgrp); | ||
1257 | break; | ||
1258 | case VBLK_DSK3: | ||
1259 | case VBLK_DSK4: | ||
1260 | list_add (&vb->list, &ldb->v_disk); | ||
1261 | break; | ||
1262 | case VBLK_VOL5: | ||
1263 | list_add (&vb->list, &ldb->v_volu); | ||
1264 | break; | ||
1265 | case VBLK_CMP3: | ||
1266 | list_add (&vb->list, &ldb->v_comp); | ||
1267 | break; | ||
1268 | case VBLK_PRT3: | ||
1269 | /* Sort by the partition's start sector. */ | ||
1270 | list_for_each (item, &ldb->v_part) { | ||
1271 | struct vblk *v = list_entry (item, struct vblk, list); | ||
1272 | if ((v->vblk.part.disk_id == vb->vblk.part.disk_id) && | ||
1273 | (v->vblk.part.start > vb->vblk.part.start)) { | ||
1274 | list_add_tail (&vb->list, &v->list); | ||
1275 | return true; | ||
1276 | } | ||
1277 | } | ||
1278 | list_add_tail (&vb->list, &ldb->v_part); | ||
1279 | break; | ||
1280 | } | ||
1281 | return true; | ||
1282 | } | ||
1283 | |||
1284 | /** | ||
1285 | * ldm_frag_add - Add a VBLK fragment to a list | ||
1286 | * @data: Raw fragment to be added to the list | ||
1287 | * @size: Size of the raw fragment | ||
1288 | * @frags: Linked list of VBLK fragments | ||
1289 | * | ||
1290 | * Fragmented VBLKs may not be consecutive in the database, so they are placed | ||
1291 | * in a list so they can be pieced together later. | ||
1292 | * | ||
1293 | * Return: 'true' Success, the VBLK was added to the list | ||
1294 | * 'false' Error, a problem occurred | ||
1295 | */ | ||
1296 | static bool ldm_frag_add (const u8 *data, int size, struct list_head *frags) | ||
1297 | { | ||
1298 | struct frag *f; | ||
1299 | struct list_head *item; | ||
1300 | int rec, num, group; | ||
1301 | |||
1302 | BUG_ON (!data || !frags); | ||
1303 | |||
1304 | if (size < 2 * VBLK_SIZE_HEAD) { | ||
1305 | ldm_error("Value of size is to small."); | ||
1306 | return false; | ||
1307 | } | ||
1308 | |||
1309 | group = get_unaligned_be32(data + 0x08); | ||
1310 | rec = get_unaligned_be16(data + 0x0C); | ||
1311 | num = get_unaligned_be16(data + 0x0E); | ||
1312 | if ((num < 1) || (num > 4)) { | ||
1313 | ldm_error ("A VBLK claims to have %d parts.", num); | ||
1314 | return false; | ||
1315 | } | ||
1316 | if (rec >= num) { | ||
1317 | ldm_error("REC value (%d) exceeds NUM value (%d)", rec, num); | ||
1318 | return false; | ||
1319 | } | ||
1320 | |||
1321 | list_for_each (item, frags) { | ||
1322 | f = list_entry (item, struct frag, list); | ||
1323 | if (f->group == group) | ||
1324 | goto found; | ||
1325 | } | ||
1326 | |||
1327 | f = kmalloc (sizeof (*f) + size*num, GFP_KERNEL); | ||
1328 | if (!f) { | ||
1329 | ldm_crit ("Out of memory."); | ||
1330 | return false; | ||
1331 | } | ||
1332 | |||
1333 | f->group = group; | ||
1334 | f->num = num; | ||
1335 | f->rec = rec; | ||
1336 | f->map = 0xFF << num; | ||
1337 | |||
1338 | list_add_tail (&f->list, frags); | ||
1339 | found: | ||
1340 | if (rec >= f->num) { | ||
1341 | ldm_error("REC value (%d) exceeds NUM value (%d)", rec, f->num); | ||
1342 | return false; | ||
1343 | } | ||
1344 | |||
1345 | if (f->map & (1 << rec)) { | ||
1346 | ldm_error ("Duplicate VBLK, part %d.", rec); | ||
1347 | f->map &= 0x7F; /* Mark the group as broken */ | ||
1348 | return false; | ||
1349 | } | ||
1350 | |||
1351 | f->map |= (1 << rec); | ||
1352 | |||
1353 | data += VBLK_SIZE_HEAD; | ||
1354 | size -= VBLK_SIZE_HEAD; | ||
1355 | |||
1356 | memcpy (f->data+rec*(size-VBLK_SIZE_HEAD)+VBLK_SIZE_HEAD, data, size); | ||
1357 | |||
1358 | return true; | ||
1359 | } | ||
1360 | |||
1361 | /** | ||
1362 | * ldm_frag_free - Free a linked list of VBLK fragments | ||
1363 | * @list: Linked list of fragments | ||
1364 | * | ||
1365 | * Free a linked list of VBLK fragments | ||
1366 | * | ||
1367 | * Return: none | ||
1368 | */ | ||
1369 | static void ldm_frag_free (struct list_head *list) | ||
1370 | { | ||
1371 | struct list_head *item, *tmp; | ||
1372 | |||
1373 | BUG_ON (!list); | ||
1374 | |||
1375 | list_for_each_safe (item, tmp, list) | ||
1376 | kfree (list_entry (item, struct frag, list)); | ||
1377 | } | ||
1378 | |||
1379 | /** | ||
1380 | * ldm_frag_commit - Validate fragmented VBLKs and add them to the database | ||
1381 | * @frags: Linked list of VBLK fragments | ||
1382 | * @ldb: Cache of the database structures | ||
1383 | * | ||
1384 | * Now that all the fragmented VBLKs have been collected, they must be added to | ||
1385 | * the database for later use. | ||
1386 | * | ||
1387 | * Return: 'true' All the fragments we added successfully | ||
1388 | * 'false' One or more of the fragments we invalid | ||
1389 | */ | ||
1390 | static bool ldm_frag_commit (struct list_head *frags, struct ldmdb *ldb) | ||
1391 | { | ||
1392 | struct frag *f; | ||
1393 | struct list_head *item; | ||
1394 | |||
1395 | BUG_ON (!frags || !ldb); | ||
1396 | |||
1397 | list_for_each (item, frags) { | ||
1398 | f = list_entry (item, struct frag, list); | ||
1399 | |||
1400 | if (f->map != 0xFF) { | ||
1401 | ldm_error ("VBLK group %d is incomplete (0x%02x).", | ||
1402 | f->group, f->map); | ||
1403 | return false; | ||
1404 | } | ||
1405 | |||
1406 | if (!ldm_ldmdb_add (f->data, f->num*ldb->vm.vblk_size, ldb)) | ||
1407 | return false; /* Already logged */ | ||
1408 | } | ||
1409 | return true; | ||
1410 | } | ||
1411 | |||
1412 | /** | ||
1413 | * ldm_get_vblks - Read the on-disk database of VBLKs into memory | ||
1414 | * @state: Partition check state including device holding the LDM Database | ||
1415 | * @base: Offset, into @state->bdev, of the database | ||
1416 | * @ldb: Cache of the database structures | ||
1417 | * | ||
1418 | * To use the information from the VBLKs, they need to be read from the disk, | ||
1419 | * unpacked and validated. We cache them in @ldb according to their type. | ||
1420 | * | ||
1421 | * Return: 'true' All the VBLKs were read successfully | ||
1422 | * 'false' An error occurred | ||
1423 | */ | ||
1424 | static bool ldm_get_vblks(struct parsed_partitions *state, unsigned long base, | ||
1425 | struct ldmdb *ldb) | ||
1426 | { | ||
1427 | int size, perbuf, skip, finish, s, v, recs; | ||
1428 | u8 *data = NULL; | ||
1429 | Sector sect; | ||
1430 | bool result = false; | ||
1431 | LIST_HEAD (frags); | ||
1432 | |||
1433 | BUG_ON(!state || !ldb); | ||
1434 | |||
1435 | size = ldb->vm.vblk_size; | ||
1436 | perbuf = 512 / size; | ||
1437 | skip = ldb->vm.vblk_offset >> 9; /* Bytes to sectors */ | ||
1438 | finish = (size * ldb->vm.last_vblk_seq) >> 9; | ||
1439 | |||
1440 | for (s = skip; s < finish; s++) { /* For each sector */ | ||
1441 | data = read_part_sector(state, base + OFF_VMDB + s, §); | ||
1442 | if (!data) { | ||
1443 | ldm_crit ("Disk read failed."); | ||
1444 | goto out; | ||
1445 | } | ||
1446 | |||
1447 | for (v = 0; v < perbuf; v++, data+=size) { /* For each vblk */ | ||
1448 | if (MAGIC_VBLK != get_unaligned_be32(data)) { | ||
1449 | ldm_error ("Expected to find a VBLK."); | ||
1450 | goto out; | ||
1451 | } | ||
1452 | |||
1453 | recs = get_unaligned_be16(data + 0x0E); /* Number of records */ | ||
1454 | if (recs == 1) { | ||
1455 | if (!ldm_ldmdb_add (data, size, ldb)) | ||
1456 | goto out; /* Already logged */ | ||
1457 | } else if (recs > 1) { | ||
1458 | if (!ldm_frag_add (data, size, &frags)) | ||
1459 | goto out; /* Already logged */ | ||
1460 | } | ||
1461 | /* else Record is not in use, ignore it. */ | ||
1462 | } | ||
1463 | put_dev_sector (sect); | ||
1464 | data = NULL; | ||
1465 | } | ||
1466 | |||
1467 | result = ldm_frag_commit (&frags, ldb); /* Failures, already logged */ | ||
1468 | out: | ||
1469 | if (data) | ||
1470 | put_dev_sector (sect); | ||
1471 | ldm_frag_free (&frags); | ||
1472 | |||
1473 | return result; | ||
1474 | } | ||
1475 | |||
1476 | /** | ||
1477 | * ldm_free_vblks - Free a linked list of vblk's | ||
1478 | * @lh: Head of a linked list of struct vblk | ||
1479 | * | ||
1480 | * Free a list of vblk's and free the memory used to maintain the list. | ||
1481 | * | ||
1482 | * Return: none | ||
1483 | */ | ||
1484 | static void ldm_free_vblks (struct list_head *lh) | ||
1485 | { | ||
1486 | struct list_head *item, *tmp; | ||
1487 | |||
1488 | BUG_ON (!lh); | ||
1489 | |||
1490 | list_for_each_safe (item, tmp, lh) | ||
1491 | kfree (list_entry (item, struct vblk, list)); | ||
1492 | } | ||
1493 | |||
1494 | |||
1495 | /** | ||
1496 | * ldm_partition - Find out whether a device is a dynamic disk and handle it | ||
1497 | * @state: Partition check state including device holding the LDM Database | ||
1498 | * | ||
1499 | * This determines whether the device @bdev is a dynamic disk and if so creates | ||
1500 | * the partitions necessary in the gendisk structure pointed to by @hd. | ||
1501 | * | ||
1502 | * We create a dummy device 1, which contains the LDM database, and then create | ||
1503 | * each partition described by the LDM database in sequence as devices 2+. For | ||
1504 | * example, if the device is hda, we would have: hda1: LDM database, hda2, hda3, | ||
1505 | * and so on: the actual data containing partitions. | ||
1506 | * | ||
1507 | * Return: 1 Success, @state->bdev is a dynamic disk and we handled it | ||
1508 | * 0 Success, @state->bdev is not a dynamic disk | ||
1509 | * -1 An error occurred before enough information had been read | ||
1510 | * Or @state->bdev is a dynamic disk, but it may be corrupted | ||
1511 | */ | ||
1512 | int ldm_partition(struct parsed_partitions *state) | ||
1513 | { | ||
1514 | struct ldmdb *ldb; | ||
1515 | unsigned long base; | ||
1516 | int result = -1; | ||
1517 | |||
1518 | BUG_ON(!state); | ||
1519 | |||
1520 | /* Look for signs of a Dynamic Disk */ | ||
1521 | if (!ldm_validate_partition_table(state)) | ||
1522 | return 0; | ||
1523 | |||
1524 | ldb = kmalloc (sizeof (*ldb), GFP_KERNEL); | ||
1525 | if (!ldb) { | ||
1526 | ldm_crit ("Out of memory."); | ||
1527 | goto out; | ||
1528 | } | ||
1529 | |||
1530 | /* Parse and check privheads. */ | ||
1531 | if (!ldm_validate_privheads(state, &ldb->ph)) | ||
1532 | goto out; /* Already logged */ | ||
1533 | |||
1534 | /* All further references are relative to base (database start). */ | ||
1535 | base = ldb->ph.config_start; | ||
1536 | |||
1537 | /* Parse and check tocs and vmdb. */ | ||
1538 | if (!ldm_validate_tocblocks(state, base, ldb) || | ||
1539 | !ldm_validate_vmdb(state, base, ldb)) | ||
1540 | goto out; /* Already logged */ | ||
1541 | |||
1542 | /* Initialize vblk lists in ldmdb struct */ | ||
1543 | INIT_LIST_HEAD (&ldb->v_dgrp); | ||
1544 | INIT_LIST_HEAD (&ldb->v_disk); | ||
1545 | INIT_LIST_HEAD (&ldb->v_volu); | ||
1546 | INIT_LIST_HEAD (&ldb->v_comp); | ||
1547 | INIT_LIST_HEAD (&ldb->v_part); | ||
1548 | |||
1549 | if (!ldm_get_vblks(state, base, ldb)) { | ||
1550 | ldm_crit ("Failed to read the VBLKs from the database."); | ||
1551 | goto cleanup; | ||
1552 | } | ||
1553 | |||
1554 | /* Finally, create the data partition devices. */ | ||
1555 | if (ldm_create_data_partitions(state, ldb)) { | ||
1556 | ldm_debug ("Parsed LDM database successfully."); | ||
1557 | result = 1; | ||
1558 | } | ||
1559 | /* else Already logged */ | ||
1560 | |||
1561 | cleanup: | ||
1562 | ldm_free_vblks (&ldb->v_dgrp); | ||
1563 | ldm_free_vblks (&ldb->v_disk); | ||
1564 | ldm_free_vblks (&ldb->v_volu); | ||
1565 | ldm_free_vblks (&ldb->v_comp); | ||
1566 | ldm_free_vblks (&ldb->v_part); | ||
1567 | out: | ||
1568 | kfree (ldb); | ||
1569 | return result; | ||
1570 | } | ||