diff options
author | San Mehat | 2010-03-10 14:46:00 -0600 |
---|---|---|
committer | San Mehat | 2010-03-10 17:19:06 -0600 |
commit | a6391f1006b961ca89d1c79a826375380684a4de (patch) | |
tree | 50f5a2b2179d52cf24cb6ad09c4842d0404610e2 /libdiskconfig/diskconfig.c | |
parent | 732799eca9f2767996bc423503937c4c935bb630 (diff) | |
download | platform-system-core-a6391f1006b961ca89d1c79a826375380684a4de.tar.gz platform-system-core-a6391f1006b961ca89d1c79a826375380684a4de.tar.xz platform-system-core-a6391f1006b961ca89d1c79a826375380684a4de.zip |
system: libdiskconfig: Add libdiskconfig
Change-Id: Ie7a7b5d8016dec60cdfb17228c3f519789c98564
Signed-off-by: San Mehat <san@google.com>
Diffstat (limited to 'libdiskconfig/diskconfig.c')
-rw-r--r-- | libdiskconfig/diskconfig.c | 536 |
1 files changed, 536 insertions, 0 deletions
diff --git a/libdiskconfig/diskconfig.c b/libdiskconfig/diskconfig.c new file mode 100644 index 000000000..4dd8c5265 --- /dev/null +++ b/libdiskconfig/diskconfig.c | |||
@@ -0,0 +1,536 @@ | |||
1 | /* libs/diskconfig/diskconfig.c | ||
2 | * | ||
3 | * Copyright 2008, The Android Open Source Project | ||
4 | * | ||
5 | * Licensed under the Apache License, Version 2.0 (the "License"); | ||
6 | * you may not use this file except in compliance with the License. | ||
7 | * You may obtain a copy of the License at | ||
8 | * | ||
9 | * http://www.apache.org/licenses/LICENSE-2.0 | ||
10 | * | ||
11 | * Unless required by applicable law or agreed to in writing, software | ||
12 | * distributed under the License is distributed on an "AS IS" BASIS, | ||
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | ||
14 | * See the License for the specific language governing permissions and | ||
15 | * limitations under the License. | ||
16 | */ | ||
17 | |||
18 | #define LOG_TAG "diskconfig" | ||
19 | |||
20 | #include <errno.h> | ||
21 | #include <fcntl.h> | ||
22 | #include <stdio.h> | ||
23 | #include <stdlib.h> | ||
24 | #include <string.h> | ||
25 | #include <unistd.h> | ||
26 | #include <sys/ioctl.h> | ||
27 | #include <sys/stat.h> | ||
28 | |||
29 | #include <linux/fs.h> | ||
30 | |||
31 | #include <cutils/config_utils.h> | ||
32 | #include <cutils/log.h> | ||
33 | |||
34 | #include <diskconfig/diskconfig.h> | ||
35 | |||
36 | |||
37 | static int | ||
38 | parse_len(const char *str, uint64_t *plen) | ||
39 | { | ||
40 | char tmp[64]; | ||
41 | int len_str; | ||
42 | uint32_t multiple = 1; | ||
43 | |||
44 | strncpy(tmp, str, sizeof(tmp)); | ||
45 | tmp[sizeof(tmp)-1] = '\0'; | ||
46 | len_str = strlen(tmp); | ||
47 | if (!len_str) { | ||
48 | LOGE("Invalid disk length specified."); | ||
49 | return 1; | ||
50 | } | ||
51 | |||
52 | switch(tmp[len_str - 1]) { | ||
53 | case 'M': case 'm': | ||
54 | /* megabyte */ | ||
55 | multiple <<= 10; | ||
56 | case 'K': case 'k': | ||
57 | /* kilobytes */ | ||
58 | multiple <<= 10; | ||
59 | tmp[len_str - 1] = '\0'; | ||
60 | break; | ||
61 | default: | ||
62 | break; | ||
63 | } | ||
64 | |||
65 | *plen = strtoull(tmp, NULL, 0); | ||
66 | if (!*plen) { | ||
67 | LOGE("Invalid length specified: %s", str); | ||
68 | return 1; | ||
69 | } | ||
70 | |||
71 | if (*plen == (uint64_t)-1) { | ||
72 | if (multiple > 1) { | ||
73 | LOGE("Size modifier illegal when len is -1"); | ||
74 | return 1; | ||
75 | } | ||
76 | } else { | ||
77 | /* convert len to kilobytes */ | ||
78 | if (multiple > 1024) | ||
79 | multiple >>= 10; | ||
80 | *plen *= multiple; | ||
81 | |||
82 | if (*plen > 0xffffffffULL) { | ||
83 | LOGE("Length specified is too large!: %llu KB", *plen); | ||
84 | return 1; | ||
85 | } | ||
86 | } | ||
87 | |||
88 | return 0; | ||
89 | } | ||
90 | |||
91 | |||
92 | static int | ||
93 | load_partitions(cnode *root, struct disk_info *dinfo) | ||
94 | { | ||
95 | cnode *partnode; | ||
96 | |||
97 | dinfo->num_parts = 0; | ||
98 | for (partnode = root->first_child; partnode; partnode = partnode->next) { | ||
99 | struct part_info *pinfo = &dinfo->part_lst[dinfo->num_parts]; | ||
100 | const char *tmp; | ||
101 | |||
102 | /* bleh, i will leak memory here, but i DONT CARE since | ||
103 | * the only right thing to do when this function fails | ||
104 | * is to quit */ | ||
105 | pinfo->name = strdup(partnode->name); | ||
106 | |||
107 | if(config_bool(partnode, "active", 0)) | ||
108 | pinfo->flags |= PART_ACTIVE_FLAG; | ||
109 | |||
110 | if (!(tmp = config_str(partnode, "type", NULL))) { | ||
111 | LOGE("Partition type required: %s", pinfo->name); | ||
112 | return 1; | ||
113 | } | ||
114 | |||
115 | /* possible values are: linux, fat32 */ | ||
116 | if (!strcmp(tmp, "linux")) { | ||
117 | pinfo->type = PC_PART_TYPE_LINUX; | ||
118 | } else if (!strcmp(tmp, "fat32")) { | ||
119 | pinfo->type = PC_PART_TYPE_FAT32; | ||
120 | } else { | ||
121 | LOGE("Unsupported partition type found: %s", tmp); | ||
122 | return 1; | ||
123 | } | ||
124 | |||
125 | if ((tmp = config_str(partnode, "len", NULL)) != NULL) { | ||
126 | uint64_t len; | ||
127 | if (parse_len(tmp, &len)) | ||
128 | return 1; | ||
129 | pinfo->len_kb = (uint32_t) len; | ||
130 | } else | ||
131 | pinfo->len_kb = 0; | ||
132 | |||
133 | ++dinfo->num_parts; | ||
134 | } | ||
135 | |||
136 | return 0; | ||
137 | } | ||
138 | |||
139 | struct disk_info * | ||
140 | load_diskconfig(const char *fn, char *path_override) | ||
141 | { | ||
142 | struct disk_info *dinfo; | ||
143 | cnode *devroot; | ||
144 | cnode *partnode; | ||
145 | cnode *root = config_node("", ""); | ||
146 | const char *tmp; | ||
147 | |||
148 | if (!(dinfo = malloc(sizeof(struct disk_info)))) { | ||
149 | LOGE("Could not malloc disk_info"); | ||
150 | return NULL; | ||
151 | } | ||
152 | memset(dinfo, 0, sizeof(struct disk_info)); | ||
153 | |||
154 | if (!(dinfo->part_lst = malloc(MAX_NUM_PARTS * sizeof(struct part_info)))) { | ||
155 | LOGE("Could not malloc part_lst"); | ||
156 | goto fail; | ||
157 | } | ||
158 | memset(dinfo->part_lst, 0, | ||
159 | (MAX_NUM_PARTS * sizeof(struct part_info))); | ||
160 | |||
161 | config_load_file(root, fn); | ||
162 | if (root->first_child == NULL) { | ||
163 | LOGE("Could not read config file %s", fn); | ||
164 | goto fail; | ||
165 | } | ||
166 | |||
167 | if (!(devroot = config_find(root, "device"))) { | ||
168 | LOGE("Could not find device section in config file '%s'", fn); | ||
169 | goto fail; | ||
170 | } | ||
171 | |||
172 | |||
173 | if (!(tmp = config_str(devroot, "path", path_override))) { | ||
174 | LOGE("device path is requried"); | ||
175 | goto fail; | ||
176 | } | ||
177 | dinfo->device = strdup(tmp); | ||
178 | |||
179 | /* find the partition scheme */ | ||
180 | if (!(tmp = config_str(devroot, "scheme", NULL))) { | ||
181 | LOGE("partition scheme is required"); | ||
182 | goto fail; | ||
183 | } else if (!strcmp(tmp, "mbr")) { | ||
184 | dinfo->scheme = PART_SCHEME_MBR; | ||
185 | } else if (!strcmp(tmp, "gpt")) { | ||
186 | LOGE("'gpt' partition scheme not supported yet."); | ||
187 | goto fail; | ||
188 | } else { | ||
189 | LOGE("Unknown partition scheme specified: %s", tmp); | ||
190 | goto fail; | ||
191 | } | ||
192 | |||
193 | /* grab the sector size (in bytes) */ | ||
194 | tmp = config_str(devroot, "sector_size", "512"); | ||
195 | dinfo->sect_size = strtol(tmp, NULL, 0); | ||
196 | if (!dinfo->sect_size) { | ||
197 | LOGE("Invalid sector size: %s", tmp); | ||
198 | goto fail; | ||
199 | } | ||
200 | |||
201 | /* first lba where the partitions will start on disk */ | ||
202 | if (!(tmp = config_str(devroot, "start_lba", NULL))) { | ||
203 | LOGE("start_lba must be provided"); | ||
204 | goto fail; | ||
205 | } | ||
206 | |||
207 | if (!(dinfo->skip_lba = strtol(tmp, NULL, 0))) { | ||
208 | LOGE("Invalid starting LBA (or zero): %s", tmp); | ||
209 | goto fail; | ||
210 | } | ||
211 | |||
212 | /* Number of LBAs on disk */ | ||
213 | if (!(tmp = config_str(devroot, "num_lba", NULL))) { | ||
214 | LOGE("num_lba is required"); | ||
215 | goto fail; | ||
216 | } | ||
217 | dinfo->num_lba = strtoul(tmp, NULL, 0); | ||
218 | |||
219 | if (!(partnode = config_find(devroot, "partitions"))) { | ||
220 | LOGE("Device must specify partition list"); | ||
221 | goto fail; | ||
222 | } | ||
223 | |||
224 | if (load_partitions(partnode, dinfo)) | ||
225 | goto fail; | ||
226 | |||
227 | return dinfo; | ||
228 | |||
229 | fail: | ||
230 | if (dinfo->part_lst) | ||
231 | free(dinfo->part_lst); | ||
232 | if (dinfo->device) | ||
233 | free(dinfo->device); | ||
234 | free(dinfo); | ||
235 | return NULL; | ||
236 | } | ||
237 | |||
238 | static int | ||
239 | sync_ptable(int fd) | ||
240 | { | ||
241 | struct stat stat; | ||
242 | int rv; | ||
243 | |||
244 | sync(); | ||
245 | |||
246 | if (fstat(fd, &stat)) { | ||
247 | LOGE("Cannot stat, errno=%d.", errno); | ||
248 | return -1; | ||
249 | } | ||
250 | |||
251 | if (S_ISBLK(stat.st_mode) && ((rv = ioctl(fd, BLKRRPART, NULL)) < 0)) { | ||
252 | LOGE("Could not re-read partition table. REBOOT!. (errno=%d)", errno); | ||
253 | return -1; | ||
254 | } | ||
255 | |||
256 | return 0; | ||
257 | } | ||
258 | |||
259 | /* This function verifies that the disk info provided is valid, and if so, | ||
260 | * returns an open file descriptor. | ||
261 | * | ||
262 | * This does not necessarily mean that it will later be successfully written | ||
263 | * though. If we use the pc-bios partitioning scheme, we must use extended | ||
264 | * partitions, which eat up some hd space. If the user manually provisioned | ||
265 | * every single partition, but did not account for the extra needed space, | ||
266 | * then we will later fail. | ||
267 | * | ||
268 | * TODO: Make validation more complete. | ||
269 | */ | ||
270 | static int | ||
271 | validate(struct disk_info *dinfo) | ||
272 | { | ||
273 | int fd; | ||
274 | int sect_sz; | ||
275 | uint64_t disk_size; | ||
276 | uint64_t total_size; | ||
277 | int cnt; | ||
278 | struct stat stat; | ||
279 | |||
280 | if (!dinfo) | ||
281 | return -1; | ||
282 | |||
283 | if ((fd = open(dinfo->device, O_RDWR)) < 0) { | ||
284 | LOGE("Cannot open device '%s' (errno=%d)", dinfo->device, errno); | ||
285 | return -1; | ||
286 | } | ||
287 | |||
288 | if (fstat(fd, &stat)) { | ||
289 | LOGE("Cannot stat file '%s', errno=%d.", dinfo->device, errno); | ||
290 | goto fail; | ||
291 | } | ||
292 | |||
293 | |||
294 | /* XXX: Some of the code below is kind of redundant and should probably | ||
295 | * be refactored a little, but it will do for now. */ | ||
296 | |||
297 | /* Verify that we can operate on the device that was requested. | ||
298 | * We presently only support block devices and regular file images. */ | ||
299 | if (S_ISBLK(stat.st_mode)) { | ||
300 | /* get the sector size and make sure we agree */ | ||
301 | if (ioctl(fd, BLKSSZGET, §_sz) < 0) { | ||
302 | LOGE("Cannot get sector size (errno=%d)", errno); | ||
303 | goto fail; | ||
304 | } | ||
305 | |||
306 | if (!sect_sz || sect_sz != dinfo->sect_size) { | ||
307 | LOGE("Device sector size is zero or sector sizes do not match!"); | ||
308 | goto fail; | ||
309 | } | ||
310 | |||
311 | /* allow the user override the "disk size" if they provided num_lba */ | ||
312 | if (!dinfo->num_lba) { | ||
313 | if (ioctl(fd, BLKGETSIZE64, &disk_size) < 0) { | ||
314 | LOGE("Could not get block device size (errno=%d)", errno); | ||
315 | goto fail; | ||
316 | } | ||
317 | /* XXX: we assume that the disk has < 2^32 sectors :-) */ | ||
318 | dinfo->num_lba = (uint32_t)(disk_size / (uint64_t)dinfo->sect_size); | ||
319 | } else | ||
320 | disk_size = (uint64_t)dinfo->num_lba * (uint64_t)dinfo->sect_size; | ||
321 | } else if (S_ISREG(stat.st_mode)) { | ||
322 | LOGI("Requesting operation on a regular file, not block device."); | ||
323 | if (!dinfo->sect_size) { | ||
324 | LOGE("Sector size for regular file images cannot be zero"); | ||
325 | goto fail; | ||
326 | } | ||
327 | if (dinfo->num_lba) | ||
328 | disk_size = (uint64_t)dinfo->num_lba * (uint64_t)dinfo->sect_size; | ||
329 | else { | ||
330 | dinfo->num_lba = (uint32_t)(stat.st_size / dinfo->sect_size); | ||
331 | disk_size = (uint64_t)stat.st_size; | ||
332 | } | ||
333 | } else { | ||
334 | LOGE("Device does not refer to a regular file or a block device!"); | ||
335 | goto fail; | ||
336 | } | ||
337 | |||
338 | #if 1 | ||
339 | LOGV("Device/file %s: size=%llu bytes, num_lba=%u, sect_size=%d", | ||
340 | dinfo->device, disk_size, dinfo->num_lba, dinfo->sect_size); | ||
341 | #endif | ||
342 | |||
343 | /* since this is our offset into the disk, we start off with that as | ||
344 | * our size of needed partitions */ | ||
345 | total_size = dinfo->skip_lba * dinfo->sect_size; | ||
346 | |||
347 | /* add up all the partition sizes and make sure it fits */ | ||
348 | for (cnt = 0; cnt < dinfo->num_parts; ++cnt) { | ||
349 | struct part_info *part = &dinfo->part_lst[cnt]; | ||
350 | if (part->len_kb != (uint32_t)-1) { | ||
351 | total_size += part->len_kb * 1024; | ||
352 | } else if (part->len_kb == 0) { | ||
353 | LOGE("Zero-size partition '%s' is invalid.", part->name); | ||
354 | goto fail; | ||
355 | } else { | ||
356 | /* the partition requests the rest of the disk. */ | ||
357 | if (cnt + 1 != dinfo->num_parts) { | ||
358 | LOGE("Only the last partition in the list can request to fill " | ||
359 | "the rest of disk."); | ||
360 | goto fail; | ||
361 | } | ||
362 | } | ||
363 | |||
364 | if ((part->type != PC_PART_TYPE_LINUX) && | ||
365 | (part->type != PC_PART_TYPE_FAT32)) { | ||
366 | LOGE("Unknown partition type (0x%x) encountered for partition " | ||
367 | "'%s'\n", part->type, part->name); | ||
368 | goto fail; | ||
369 | } | ||
370 | } | ||
371 | |||
372 | /* only matters for disks, not files */ | ||
373 | if (S_ISBLK(stat.st_mode) && total_size > disk_size) { | ||
374 | LOGE("Total requested size of partitions (%llu) is greater than disk " | ||
375 | "size (%llu).", total_size, disk_size); | ||
376 | goto fail; | ||
377 | } | ||
378 | |||
379 | return fd; | ||
380 | |||
381 | fail: | ||
382 | close(fd); | ||
383 | return -1; | ||
384 | } | ||
385 | |||
386 | static int | ||
387 | validate_and_config(struct disk_info *dinfo, int *fd, struct write_list **lst) | ||
388 | { | ||
389 | *lst = NULL; | ||
390 | *fd = -1; | ||
391 | |||
392 | if ((*fd = validate(dinfo)) < 0) | ||
393 | return 1; | ||
394 | |||
395 | switch (dinfo->scheme) { | ||
396 | case PART_SCHEME_MBR: | ||
397 | *lst = config_mbr(dinfo); | ||
398 | return *lst == NULL; | ||
399 | case PART_SCHEME_GPT: | ||
400 | /* not supported yet */ | ||
401 | default: | ||
402 | LOGE("Uknown partition scheme."); | ||
403 | break; | ||
404 | } | ||
405 | |||
406 | close(*fd); | ||
407 | *lst = NULL; | ||
408 | return 1; | ||
409 | } | ||
410 | |||
411 | /* validate and process the disk layout configuration. | ||
412 | * This will cause an update to the partitions' start lba. | ||
413 | * | ||
414 | * Basically, this does the same thing as apply_disk_config in test mode, | ||
415 | * except that wlist_commit is not called to print out the data to be | ||
416 | * written. | ||
417 | */ | ||
418 | int | ||
419 | process_disk_config(struct disk_info *dinfo) | ||
420 | { | ||
421 | struct write_list *lst; | ||
422 | int fd; | ||
423 | |||
424 | if (validate_and_config(dinfo, &fd, &lst) != 0) | ||
425 | return 1; | ||
426 | |||
427 | close(fd); | ||
428 | wlist_free(lst); | ||
429 | return 0; | ||
430 | } | ||
431 | |||
432 | |||
433 | int | ||
434 | apply_disk_config(struct disk_info *dinfo, int test) | ||
435 | { | ||
436 | int fd; | ||
437 | struct write_list *wr_lst = NULL; | ||
438 | int rv; | ||
439 | |||
440 | if (validate_and_config(dinfo, &fd, &wr_lst) != 0) { | ||
441 | LOGE("Configuration is invalid."); | ||
442 | goto fail; | ||
443 | } | ||
444 | |||
445 | if ((rv = wlist_commit(fd, wr_lst, test)) >= 0) | ||
446 | rv = test ? 0 : sync_ptable(fd); | ||
447 | |||
448 | close(fd); | ||
449 | wlist_free(wr_lst); | ||
450 | return rv; | ||
451 | |||
452 | fail: | ||
453 | close(fd); | ||
454 | if (wr_lst) | ||
455 | wlist_free(wr_lst); | ||
456 | return 1; | ||
457 | } | ||
458 | |||
459 | int | ||
460 | dump_disk_config(struct disk_info *dinfo) | ||
461 | { | ||
462 | int cnt; | ||
463 | struct part_info *part; | ||
464 | |||
465 | printf("Device: %s\n", dinfo->device); | ||
466 | printf("Scheme: "); | ||
467 | switch (dinfo->scheme) { | ||
468 | case PART_SCHEME_MBR: | ||
469 | printf("MBR"); | ||
470 | break; | ||
471 | case PART_SCHEME_GPT: | ||
472 | printf("GPT (unsupported)"); | ||
473 | break; | ||
474 | default: | ||
475 | printf("Unknown"); | ||
476 | break; | ||
477 | } | ||
478 | printf ("\n"); | ||
479 | |||
480 | printf("Sector size: %d\n", dinfo->sect_size); | ||
481 | printf("Skip leading LBAs: %u\n", dinfo->skip_lba); | ||
482 | printf("Number of LBAs: %u\n", dinfo->num_lba); | ||
483 | printf("Partitions:\n"); | ||
484 | |||
485 | for (cnt = 0; cnt < dinfo->num_parts; ++cnt) { | ||
486 | part = &dinfo->part_lst[cnt]; | ||
487 | printf("\tname = %s\n", part->name); | ||
488 | printf("\t\tflags = %s\n", | ||
489 | part->flags & PART_ACTIVE_FLAG ? "Active" : "None"); | ||
490 | printf("\t\ttype = %s\n", | ||
491 | part->type == PC_PART_TYPE_LINUX ? "Linux" : "Unknown"); | ||
492 | if (part->len_kb == (uint32_t)-1) | ||
493 | printf("\t\tlen = rest of disk\n"); | ||
494 | else | ||
495 | printf("\t\tlen = %uKB\n", part->len_kb); | ||
496 | } | ||
497 | printf("Total number of partitions: %d\n", cnt); | ||
498 | printf("\n"); | ||
499 | |||
500 | return 0; | ||
501 | } | ||
502 | |||
503 | struct part_info * | ||
504 | find_part(struct disk_info *dinfo, const char *name) | ||
505 | { | ||
506 | struct part_info *pinfo; | ||
507 | int cnt; | ||
508 | |||
509 | for (cnt = 0; cnt < dinfo->num_parts; ++cnt) { | ||
510 | pinfo = &dinfo->part_lst[cnt]; | ||
511 | if (!strcmp(pinfo->name, name)) | ||
512 | return pinfo; | ||
513 | } | ||
514 | |||
515 | return NULL; | ||
516 | } | ||
517 | |||
518 | /* NOTE: If the returned ptr is non-NULL, it must be freed by the caller. */ | ||
519 | char * | ||
520 | find_part_device(struct disk_info *dinfo, const char *name) | ||
521 | { | ||
522 | switch (dinfo->scheme) { | ||
523 | case PART_SCHEME_MBR: | ||
524 | return find_mbr_part(dinfo, name); | ||
525 | case PART_SCHEME_GPT: | ||
526 | LOGE("GPT is presently not supported"); | ||
527 | break; | ||
528 | default: | ||
529 | LOGE("Unknown partition table scheme"); | ||
530 | break; | ||
531 | } | ||
532 | |||
533 | return NULL; | ||
534 | } | ||
535 | |||
536 | |||