1 /*-
2 * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3 * Copyright (c) 2012 Andrey V. Elsukov <ae@FreeBSD.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29 #include <sys/disk.h>
30 #include <sys/queue.h>
31 #include <stand.h>
32 #include <stdarg.h>
33 #include <bootstrap.h>
34 #include <part.h>
35 #include <assert.h>
36
37 #include "disk.h"
38
39 #ifdef DISK_DEBUG
40 # define DPRINTF(fmt, args...) printf("%s: " fmt "\n" , __func__ , ## args)
41 #else
42 # define DPRINTF(fmt, args...) ((void)0)
43 #endif
44
45 struct open_disk {
46 struct ptable *table;
47 uint64_t mediasize;
48 uint64_t entrysize;
49 u_int sectorsize;
50 };
51
52 struct print_args {
53 struct disk_devdesc *dev;
54 const char *prefix;
55 int verbose;
56 };
57
58 /* Convert size to a human-readable number. */
59 static char *
display_size(uint64_t size,u_int sectorsize)60 display_size(uint64_t size, u_int sectorsize)
61 {
62 static char buf[80];
63 char unit;
64
65 size = size * sectorsize / 1024;
66 unit = 'K';
67 if (size >= 10485760000LL) {
68 size /= 1073741824;
69 unit = 'T';
70 } else if (size >= 10240000) {
71 size /= 1048576;
72 unit = 'G';
73 } else if (size >= 10000) {
74 size /= 1024;
75 unit = 'M';
76 }
77 snprintf(buf, sizeof(buf), "%4ld%cB", (long)size, unit);
78 return (buf);
79 }
80
81 int
ptblread(void * d,void * buf,size_t blocks,uint64_t offset)82 ptblread(void *d, void *buf, size_t blocks, uint64_t offset)
83 {
84 struct disk_devdesc *dev;
85 struct open_disk *od;
86
87 dev = (struct disk_devdesc *)d;
88 od = (struct open_disk *)dev->dd.d_opendata;
89
90 /*
91 * The strategy function assumes the offset is in units of 512 byte
92 * sectors. For larger sector sizes, we need to adjust the offset to
93 * match the actual sector size.
94 */
95 offset *= (od->sectorsize / 512);
96 /*
97 * As the GPT backup partition is located at the end of the disk,
98 * to avoid reading past disk end, flag bcache not to use RA.
99 */
100 return (dev->dd.d_dev->dv_strategy(dev, F_READ | F_NORA, offset,
101 blocks * od->sectorsize, (char *)buf, NULL));
102 }
103
104 static int
ptable_print(void * arg,const char * pname,const struct ptable_entry * part)105 ptable_print(void *arg, const char *pname, const struct ptable_entry *part)
106 {
107 struct disk_devdesc dev;
108 struct print_args *pa, bsd;
109 struct open_disk *od;
110 struct ptable *table;
111 char line[80];
112 int res;
113 u_int sectsize;
114 uint64_t partsize;
115
116 pa = (struct print_args *)arg;
117 od = (struct open_disk *)pa->dev->dd.d_opendata;
118 sectsize = od->sectorsize;
119 partsize = part->end - part->start + 1;
120 snprintf(line, sizeof(line), " %s%s: %s", pa->prefix, pname,
121 parttype2str(part->type));
122 if (pager_output(line))
123 return (1);
124
125 if (pa->verbose) {
126 /* Emit extra tab when the line is shorter than 3 tab stops */
127 if (strlen(line) < 24)
128 (void) pager_output("\t");
129
130 snprintf(line, sizeof(line), "\t%s",
131 display_size(partsize, sectsize));
132 if (pager_output(line))
133 return (1);
134 }
135 if (pager_output("\n"))
136 return (1);
137
138 res = 0;
139 if (part->type == PART_FREEBSD) {
140 /* Open slice with BSD label */
141 dev.dd.d_dev = pa->dev->dd.d_dev;
142 dev.dd.d_unit = pa->dev->dd.d_unit;
143 dev.d_slice = part->index;
144 dev.d_partition = D_PARTNONE;
145 if (disk_open(&dev, partsize, sectsize) == 0) {
146 table = ptable_open(&dev, partsize, sectsize, ptblread);
147 if (table != NULL) {
148 snprintf(line, sizeof(line), " %s%s",
149 pa->prefix, pname);
150 bsd.dev = pa->dev;
151 bsd.prefix = line;
152 bsd.verbose = pa->verbose;
153 res = ptable_iterate(table, &bsd, ptable_print);
154 ptable_close(table);
155 }
156 disk_close(&dev);
157 }
158 }
159
160 return (res);
161 }
162
163 int
disk_print(struct disk_devdesc * dev,char * prefix,int verbose)164 disk_print(struct disk_devdesc *dev, char *prefix, int verbose)
165 {
166 struct open_disk *od;
167 struct print_args pa;
168
169 /* Disk should be opened */
170 od = (struct open_disk *)dev->dd.d_opendata;
171 pa.dev = dev;
172 pa.prefix = prefix;
173 pa.verbose = verbose;
174 return (ptable_iterate(od->table, &pa, ptable_print));
175 }
176
177 int
disk_read(struct disk_devdesc * dev,void * buf,uint64_t offset,u_int blocks)178 disk_read(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
179 {
180 struct open_disk *od;
181 int ret;
182
183 od = (struct open_disk *)dev->dd.d_opendata;
184 ret = dev->dd.d_dev->dv_strategy(dev, F_READ, dev->d_offset + offset,
185 blocks * od->sectorsize, buf, NULL);
186
187 return (ret);
188 }
189
190 int
disk_write(struct disk_devdesc * dev,void * buf,uint64_t offset,u_int blocks)191 disk_write(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
192 {
193 struct open_disk *od;
194 int ret;
195
196 od = (struct open_disk *)dev->dd.d_opendata;
197 ret = dev->dd.d_dev->dv_strategy(dev, F_WRITE, dev->d_offset + offset,
198 blocks * od->sectorsize, buf, NULL);
199
200 return (ret);
201 }
202
203 int
disk_ioctl(struct disk_devdesc * dev,u_long cmd,void * data)204 disk_ioctl(struct disk_devdesc *dev, u_long cmd, void *data)
205 {
206 struct open_disk *od = dev->dd.d_opendata;
207
208 if (od == NULL)
209 return (ENOTTY);
210
211 switch (cmd) {
212 case DIOCGSECTORSIZE:
213 *(u_int *)data = od->sectorsize;
214 break;
215 case DIOCGMEDIASIZE:
216 if (dev->d_offset == 0)
217 *(uint64_t *)data = od->mediasize;
218 else
219 *(uint64_t *)data = od->entrysize * od->sectorsize;
220 break;
221 default:
222 return (ENOTTY);
223 }
224
225 return (0);
226 }
227
228 int
disk_open(struct disk_devdesc * dev,uint64_t mediasize,u_int sectorsize)229 disk_open(struct disk_devdesc *dev, uint64_t mediasize, u_int sectorsize)
230 {
231 struct disk_devdesc partdev;
232 struct open_disk *od;
233 struct ptable *table;
234 struct ptable_entry part;
235 int rc, slice, partition;
236
237 if (sectorsize == 0) {
238 DPRINTF("unknown sector size");
239 return (ENXIO);
240 }
241 rc = 0;
242 od = (struct open_disk *)malloc(sizeof(struct open_disk));
243 if (od == NULL) {
244 DPRINTF("no memory");
245 return (ENOMEM);
246 }
247 dev->dd.d_opendata = od;
248 od->entrysize = 0;
249 od->mediasize = mediasize;
250 od->sectorsize = sectorsize;
251 /*
252 * While we are reading disk metadata, make sure we do it relative
253 * to the start of the disk
254 */
255 memcpy(&partdev, dev, sizeof(partdev));
256 partdev.d_offset = 0;
257 partdev.d_slice = D_SLICENONE;
258 partdev.d_partition = D_PARTNONE;
259
260 dev->d_offset = 0;
261 table = NULL;
262 slice = dev->d_slice;
263 partition = dev->d_partition;
264
265 DPRINTF("%s unit %d, slice %d, partition %d => %p", disk_fmtdev(dev),
266 dev->dd.d_unit, dev->d_slice, dev->d_partition, od);
267
268 /* Determine disk layout. */
269 od->table = ptable_open(&partdev, mediasize / sectorsize, sectorsize,
270 ptblread);
271 if (od->table == NULL) {
272 DPRINTF("Can't read partition table");
273 rc = ENXIO;
274 goto out;
275 }
276
277 if (ptable_getsize(od->table, &mediasize) != 0) {
278 rc = ENXIO;
279 goto out;
280 }
281 od->mediasize = mediasize;
282
283 if (ptable_gettype(od->table) == PTABLE_BSD &&
284 partition >= 0) {
285 /* It doesn't matter what value has d_slice */
286 rc = ptable_getpart(od->table, &part, partition);
287 if (rc == 0) {
288 dev->d_offset = part.start;
289 od->entrysize = part.end - part.start + 1;
290 }
291 } else if (ptable_gettype(od->table) == PTABLE_ISO9660) {
292 dev->d_offset = 0;
293 od->entrysize = mediasize;
294 } else if (slice >= 0) {
295 /* Try to get information about partition */
296 if (slice == 0)
297 rc = ptable_getbestpart(od->table, &part);
298 else
299 rc = ptable_getpart(od->table, &part, slice);
300 if (rc != 0) /* Partition doesn't exist */
301 goto out;
302 dev->d_offset = part.start;
303 od->entrysize = part.end - part.start + 1;
304 slice = part.index;
305 if (ptable_gettype(od->table) == PTABLE_GPT) {
306 partition = D_PARTISGPT;
307 goto out; /* Nothing more to do */
308 } else if (partition == D_PARTISGPT) {
309 /*
310 * When we try to open GPT partition, but partition
311 * table isn't GPT, reset partition value to
312 * D_PARTWILD and try to autodetect appropriate value.
313 */
314 partition = D_PARTWILD;
315 }
316
317 /*
318 * If partition is D_PARTNONE, then disk_open() was called
319 * to open raw MBR slice.
320 */
321 if (partition == D_PARTNONE)
322 goto out;
323
324 /*
325 * If partition is D_PARTWILD and we are looking at a BSD slice,
326 * then try to read BSD label, otherwise return the
327 * whole MBR slice.
328 */
329 if (partition == D_PARTWILD &&
330 part.type != PART_FREEBSD)
331 goto out;
332 /* Try to read BSD label */
333 table = ptable_open(dev, part.end - part.start + 1,
334 od->sectorsize, ptblread);
335 if (table == NULL) {
336 DPRINTF("Can't read BSD label");
337 rc = ENXIO;
338 goto out;
339 }
340 /*
341 * If slice contains BSD label and partition < 0, then
342 * assume the 'a' partition. Otherwise just return the
343 * whole MBR slice, because it can contain ZFS.
344 */
345 if (partition < 0) {
346 if (ptable_gettype(table) != PTABLE_BSD)
347 goto out;
348 partition = 0;
349 }
350 rc = ptable_getpart(table, &part, partition);
351 if (rc != 0)
352 goto out;
353 dev->d_offset += part.start;
354 od->entrysize = part.end - part.start + 1;
355 }
356 out:
357 if (table != NULL)
358 ptable_close(table);
359
360 if (rc != 0) {
361 if (od->table != NULL)
362 ptable_close(od->table);
363 free(od);
364 DPRINTF("%s could not open", disk_fmtdev(dev));
365 } else {
366 /* Save the slice and partition number to the dev */
367 dev->d_slice = slice;
368 dev->d_partition = partition;
369 DPRINTF("%s offset %lld => %p", disk_fmtdev(dev),
370 (long long)dev->d_offset, od);
371 }
372 return (rc);
373 }
374
375 int
disk_close(struct disk_devdesc * dev)376 disk_close(struct disk_devdesc *dev)
377 {
378 struct open_disk *od;
379
380 od = (struct open_disk *)dev->dd.d_opendata;
381 DPRINTF("%s closed => %p", disk_fmtdev(dev), od);
382 ptable_close(od->table);
383 free(od);
384 return (0);
385 }
386
387 char *
disk_fmtdev(struct devdesc * vdev)388 disk_fmtdev(struct devdesc *vdev)
389 {
390 struct disk_devdesc *dev = (struct disk_devdesc *)vdev;
391 static char buf[128];
392 char *cp;
393
394 assert(vdev->d_dev->dv_type == DEVT_DISK);
395 cp = buf + sprintf(buf, "%s%d", dev->dd.d_dev->dv_name, dev->dd.d_unit);
396 if (dev->d_slice > D_SLICENONE) {
397 #ifdef LOADER_GPT_SUPPORT
398 if (dev->d_partition == D_PARTISGPT) {
399 sprintf(cp, "p%d:", dev->d_slice);
400 return (buf);
401 } else
402 #endif
403 #ifdef LOADER_MBR_SUPPORT
404 cp += sprintf(cp, "s%d", dev->d_slice);
405 #endif
406 }
407 if (dev->d_partition > D_PARTNONE)
408 cp += sprintf(cp, "%c", dev->d_partition + 'a');
409 strcat(cp, ":");
410 return (buf);
411 }
412
413 int
disk_parsedev(struct devdesc ** idev,const char * devspec,const char ** path)414 disk_parsedev(struct devdesc **idev, const char *devspec, const char **path)
415 {
416 int unit, slice, partition;
417 const char *np;
418 char *cp;
419 struct disk_devdesc *dev;
420
421 np = devspec + 4; /* Skip the leading 'disk' */
422 unit = -1;
423 /*
424 * If there is path/file info after the device info, then any missing
425 * slice or partition info should be considered a request to search for
426 * an appropriate partition. Otherwise we want to open the raw device
427 * itself and not try to fill in missing info by searching.
428 */
429 if ((cp = strchr(np, ':')) != NULL && cp[1] != '\0') {
430 slice = D_SLICEWILD;
431 partition = D_PARTWILD;
432 } else {
433 slice = D_SLICENONE;
434 partition = D_PARTNONE;
435 }
436
437 if (*np != '\0' && *np != ':') {
438 unit = strtol(np, &cp, 10);
439 if (cp == np)
440 return (EUNIT);
441 #ifdef LOADER_GPT_SUPPORT
442 if (*cp == 'p') {
443 np = cp + 1;
444 slice = strtol(np, &cp, 10);
445 if (np == cp)
446 return (ESLICE);
447 /* we don't support nested partitions on GPT */
448 if (*cp != '\0' && *cp != ':')
449 return (EINVAL);
450 partition = D_PARTISGPT;
451 } else
452 #endif
453 #ifdef LOADER_MBR_SUPPORT
454 if (*cp == 's') {
455 np = cp + 1;
456 slice = strtol(np, &cp, 10);
457 if (np == cp)
458 return (ESLICE);
459 }
460 #endif
461 if (*cp != '\0' && *cp != ':') {
462 partition = *cp - 'a';
463 if (partition < 0)
464 return (EPART);
465 cp++;
466 }
467 } else
468 return (EINVAL);
469
470 if (*cp != '\0' && *cp != ':')
471 return (EINVAL);
472 dev = malloc(sizeof(*dev));
473 if (dev == NULL)
474 return (ENOMEM);
475 dev->dd.d_unit = unit;
476 dev->d_slice = slice;
477 dev->d_partition = partition;
478 *idev = &dev->dd;
479 if (path != NULL)
480 *path = (*cp == '\0') ? cp: cp + 1;
481 return (0);
482 }
483