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