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