2 * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
3 * Copyright (c) 2012 Andrey V. Elsukov <ae@FreeBSD.org>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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.
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
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
32 #include <sys/queue.h>
35 #include <bootstrap.h>
41 # define DEBUG(fmt, args...) printf("%s: " fmt "\n" , __func__ , ## args)
43 # define DEBUG(fmt, args...)
54 struct disk_devdesc *dev;
59 /* Convert size to a human-readable number. */
61 display_size(uint64_t size, u_int sectorsize)
66 size = size * sectorsize / 1024;
68 if (size >= 10485760000LL) {
71 } else if (size >= 10240000) {
74 } else if (size >= 10000) {
78 sprintf(buf, "%ld%cB", (long)size, unit);
83 ptblread(void *d, void *buf, size_t blocks, uint64_t offset)
85 struct disk_devdesc *dev;
88 dev = (struct disk_devdesc *)d;
89 od = (struct open_disk *)dev->d_opendata;
92 * As the GPT backup partition is located at the end of the disk,
93 * to avoid reading past disk end, flag bcache not to use RA.
95 return (dev->d_dev->dv_strategy(dev, F_READ | F_NORA, offset,
96 blocks * od->sectorsize, (char *)buf, NULL));
101 ptable_print(void *arg, const char *pname, const struct ptable_entry *part)
103 struct disk_devdesc dev;
104 struct print_args *pa, bsd;
105 struct open_disk *od;
106 struct ptable *table;
110 pa = (struct print_args *)arg;
111 od = (struct open_disk *)pa->dev->d_opendata;
112 sprintf(line, " %s%s: %s", pa->prefix, pname,
113 parttype2str(part->type));
115 sprintf(line, "%-*s%s", PWIDTH, line,
116 display_size(part->end - part->start + 1,
119 if (pager_output(line))
122 if (part->type == PART_FREEBSD) {
123 /* Open slice with BSD label */
124 dev.d_dev = pa->dev->d_dev;
125 dev.d_unit = pa->dev->d_unit;
126 dev.d_slice = part->index;
127 dev.d_partition = -1;
128 if (disk_open(&dev, part->end - part->start + 1,
129 od->sectorsize) == 0) {
130 table = ptable_open(&dev, part->end - part->start + 1,
131 od->sectorsize, ptblread);
133 sprintf(line, " %s%s", pa->prefix, pname);
136 bsd.verbose = pa->verbose;
137 res = ptable_iterate(table, &bsd, ptable_print);
149 disk_print(struct disk_devdesc *dev, char *prefix, int verbose)
151 struct open_disk *od;
152 struct print_args pa;
154 /* Disk should be opened */
155 od = (struct open_disk *)dev->d_opendata;
158 pa.verbose = verbose;
159 return (ptable_iterate(od->table, &pa, ptable_print));
163 disk_read(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
165 struct open_disk *od;
168 od = (struct open_disk *)dev->d_opendata;
169 ret = dev->d_dev->dv_strategy(dev, F_READ, dev->d_offset + offset,
170 blocks * od->sectorsize, buf, NULL);
176 disk_write(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
178 struct open_disk *od;
181 od = (struct open_disk *)dev->d_opendata;
182 ret = dev->d_dev->dv_strategy(dev, F_WRITE, dev->d_offset + offset,
183 blocks * od->sectorsize, buf, NULL);
189 disk_ioctl(struct disk_devdesc *dev, u_long cmd, void *data)
191 struct open_disk *od = dev->d_opendata;
197 case DIOCGSECTORSIZE:
198 *(u_int *)data = od->sectorsize;
201 if (dev->d_offset == 0)
202 *(uint64_t *)data = od->mediasize;
204 *(uint64_t *)data = od->entrysize * od->sectorsize;
214 disk_open(struct disk_devdesc *dev, uint64_t mediasize, u_int sectorsize)
216 struct open_disk *od;
217 struct ptable *table;
218 struct ptable_entry part;
219 int rc, slice, partition;
223 * While we are reading disk metadata, make sure we do it relative
224 * to the start of the disk
228 slice = dev->d_slice;
229 partition = dev->d_partition;
230 od = (struct open_disk *)malloc(sizeof(struct open_disk));
235 dev->d_opendata = od;
237 od->mediasize = mediasize;
238 od->sectorsize = sectorsize;
239 DEBUG("%s unit %d, slice %d, partition %d => %p",
240 disk_fmtdev(dev), dev->d_unit, dev->d_slice, dev->d_partition, od);
242 /* Determine disk layout. */
243 od->table = ptable_open(dev, mediasize / sectorsize, sectorsize,
245 if (od->table == NULL) {
246 DEBUG("Can't read partition table");
251 if (ptable_getsize(od->table, &mediasize) != 0) {
255 if (mediasize > od->mediasize) {
256 od->mediasize = mediasize;
259 if (ptable_gettype(od->table) == PTABLE_BSD &&
261 /* It doesn't matter what value has d_slice */
262 rc = ptable_getpart(od->table, &part, partition);
264 dev->d_offset = part.start;
265 od->entrysize = part.end - part.start + 1;
267 } else if (slice >= 0) {
268 /* Try to get information about partition */
270 rc = ptable_getbestpart(od->table, &part);
272 rc = ptable_getpart(od->table, &part, slice);
273 if (rc != 0) /* Partition doesn't exist */
275 dev->d_offset = part.start;
276 od->entrysize = part.end - part.start + 1;
278 if (ptable_gettype(od->table) == PTABLE_GPT) {
280 goto out; /* Nothing more to do */
281 } else if (partition == 255) {
283 * When we try to open GPT partition, but partition
284 * table isn't GPT, reset d_partition value to -1
285 * and try to autodetect appropriate value.
290 * If d_partition < 0 and we are looking at a BSD slice,
291 * then try to read BSD label, otherwise return the
294 if (partition == -1 &&
295 part.type != PART_FREEBSD)
297 /* Try to read BSD label */
298 table = ptable_open(dev, part.end - part.start + 1,
299 od->sectorsize, ptblread);
301 DEBUG("Can't read BSD label");
306 * If slice contains BSD label and d_partition < 0, then
307 * assume the 'a' partition. Otherwise just return the
308 * whole MBR slice, because it can contain ZFS.
311 if (ptable_gettype(table) != PTABLE_BSD)
315 rc = ptable_getpart(table, &part, partition);
318 dev->d_offset += part.start;
319 od->entrysize = part.end - part.start + 1;
326 if (od->table != NULL)
327 ptable_close(od->table);
329 DEBUG("%s could not open", disk_fmtdev(dev));
331 /* Save the slice and partition number to the dev */
332 dev->d_slice = slice;
333 dev->d_partition = partition;
334 DEBUG("%s offset %lld => %p", disk_fmtdev(dev),
335 (long long)dev->d_offset, od);
341 disk_close(struct disk_devdesc *dev)
343 struct open_disk *od;
345 od = (struct open_disk *)dev->d_opendata;
346 DEBUG("%s closed => %p", disk_fmtdev(dev), od);
347 ptable_close(od->table);
353 disk_fmtdev(struct disk_devdesc *dev)
355 static char buf[128];
358 cp = buf + sprintf(buf, "%s%d", dev->d_dev->dv_name, dev->d_unit);
359 if (dev->d_slice >= 0) {
360 #ifdef LOADER_GPT_SUPPORT
361 if (dev->d_partition == 255) {
362 sprintf(cp, "p%d:", dev->d_slice);
366 #ifdef LOADER_MBR_SUPPORT
367 cp += sprintf(cp, "s%d", dev->d_slice);
370 if (dev->d_partition >= 0)
371 cp += sprintf(cp, "%c", dev->d_partition + 'a');
377 disk_parsedev(struct disk_devdesc *dev, const char *devspec, const char **path)
379 int unit, slice, partition;
384 unit = slice = partition = -1;
385 if (*np != '\0' && *np != ':') {
386 unit = strtol(np, &cp, 10);
389 #ifdef LOADER_GPT_SUPPORT
392 slice = strtol(np, &cp, 10);
395 /* we don't support nested partitions on GPT */
396 if (*cp != '\0' && *cp != ':')
401 #ifdef LOADER_MBR_SUPPORT
404 slice = strtol(np, &cp, 10);
409 if (*cp != '\0' && *cp != ':') {
410 partition = *cp - 'a';
418 if (*cp != '\0' && *cp != ':')
421 dev->d_slice = slice;
422 dev->d_partition = partition;
424 *path = (*cp == '\0') ? cp: cp + 1;