xref: /freebsd/stand/common/disk.c (revision 190cef3d52236565eb22e18b33e9e865ec634aa3)
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 __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 DEBUG(fmt, args...)	printf("%s: " fmt "\n" , __func__ , ## args)
42 #else
43 # define DEBUG(fmt, args...)
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 *
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 	sprintf(buf, "%ld%cB", (long)size, unit);
79 	return (buf);
80 }
81 
82 int
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 #define	PWIDTH	35
106 static int
107 ptable_print(void *arg, const char *pname, const struct ptable_entry *part)
108 {
109 	struct disk_devdesc dev;
110 	struct print_args *pa, bsd;
111 	struct open_disk *od;
112 	struct ptable *table;
113 	char line[80];
114 	int res;
115 
116 	pa = (struct print_args *)arg;
117 	od = (struct open_disk *)pa->dev->dd.d_opendata;
118 	sprintf(line, "  %s%s: %s", pa->prefix, pname,
119 	    parttype2str(part->type));
120 	if (pa->verbose)
121 		sprintf(line, "%-*s%s", PWIDTH, line,
122 		    display_size(part->end - part->start + 1,
123 		    od->sectorsize));
124 	strcat(line, "\n");
125 	if (pager_output(line))
126 		return 1;
127 	res = 0;
128 	if (part->type == PART_FREEBSD) {
129 		/* Open slice with BSD label */
130 		dev.dd.d_dev = pa->dev->dd.d_dev;
131 		dev.dd.d_unit = pa->dev->dd.d_unit;
132 		dev.d_slice = part->index;
133 		dev.d_partition = -1;
134 		if (disk_open(&dev, part->end - part->start + 1,
135 		    od->sectorsize) == 0) {
136 			table = ptable_open(&dev, part->end - part->start + 1,
137 			    od->sectorsize, ptblread);
138 			if (table != NULL) {
139 				sprintf(line, "  %s%s", pa->prefix, pname);
140 				bsd.dev = pa->dev;
141 				bsd.prefix = line;
142 				bsd.verbose = pa->verbose;
143 				res = ptable_iterate(table, &bsd, ptable_print);
144 				ptable_close(table);
145 			}
146 			disk_close(&dev);
147 		}
148 	}
149 
150 	return (res);
151 }
152 #undef PWIDTH
153 
154 int
155 disk_print(struct disk_devdesc *dev, char *prefix, int verbose)
156 {
157 	struct open_disk *od;
158 	struct print_args pa;
159 
160 	/* Disk should be opened */
161 	od = (struct open_disk *)dev->dd.d_opendata;
162 	pa.dev = dev;
163 	pa.prefix = prefix;
164 	pa.verbose = verbose;
165 	return (ptable_iterate(od->table, &pa, ptable_print));
166 }
167 
168 int
169 disk_read(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
170 {
171 	struct open_disk *od;
172 	int ret;
173 
174 	od = (struct open_disk *)dev->dd.d_opendata;
175 	ret = dev->dd.d_dev->dv_strategy(dev, F_READ, dev->d_offset + offset,
176 	    blocks * od->sectorsize, buf, NULL);
177 
178 	return (ret);
179 }
180 
181 int
182 disk_write(struct disk_devdesc *dev, void *buf, uint64_t offset, u_int blocks)
183 {
184 	struct open_disk *od;
185 	int ret;
186 
187 	od = (struct open_disk *)dev->dd.d_opendata;
188 	ret = dev->dd.d_dev->dv_strategy(dev, F_WRITE, dev->d_offset + offset,
189 	    blocks * od->sectorsize, buf, NULL);
190 
191 	return (ret);
192 }
193 
194 int
195 disk_ioctl(struct disk_devdesc *dev, u_long cmd, void *data)
196 {
197 	struct open_disk *od = dev->dd.d_opendata;
198 
199 	if (od == NULL)
200 		return (ENOTTY);
201 
202 	switch (cmd) {
203 	case DIOCGSECTORSIZE:
204 		*(u_int *)data = od->sectorsize;
205 		break;
206 	case DIOCGMEDIASIZE:
207 		if (dev->d_offset == 0)
208 			*(uint64_t *)data = od->mediasize;
209 		else
210 			*(uint64_t *)data = od->entrysize * od->sectorsize;
211 		break;
212 	default:
213 		return (ENOTTY);
214 	}
215 
216 	return (0);
217 }
218 
219 int
220 disk_open(struct disk_devdesc *dev, uint64_t mediasize, u_int sectorsize)
221 {
222 	struct disk_devdesc partdev;
223 	struct open_disk *od;
224 	struct ptable *table;
225 	struct ptable_entry part;
226 	int rc, slice, partition;
227 
228 	rc = 0;
229 	od = (struct open_disk *)malloc(sizeof(struct open_disk));
230 	if (od == NULL) {
231 		DEBUG("no memory");
232 		return (ENOMEM);
233 	}
234 	dev->dd.d_opendata = od;
235 	od->entrysize = 0;
236 	od->mediasize = mediasize;
237 	od->sectorsize = sectorsize;
238 	/*
239 	 * While we are reading disk metadata, make sure we do it relative
240 	 * to the start of the disk
241 	 */
242 	memcpy(&partdev, dev, sizeof(partdev));
243 	partdev.d_offset = 0;
244 	partdev.d_slice = -1;
245 	partdev.d_partition = -1;
246 
247 	dev->d_offset = 0;
248 	table = NULL;
249 	slice = dev->d_slice;
250 	partition = dev->d_partition;
251 
252 	DEBUG("%s unit %d, slice %d, partition %d => %p",
253 	    disk_fmtdev(dev), dev->dd.d_unit, dev->d_slice, dev->d_partition, od);
254 
255 	/* Determine disk layout. */
256 	od->table = ptable_open(&partdev, mediasize / sectorsize, sectorsize,
257 	    ptblread);
258 	if (od->table == NULL) {
259 		DEBUG("Can't read partition table");
260 		rc = ENXIO;
261 		goto out;
262 	}
263 
264 	if (ptable_getsize(od->table, &mediasize) != 0) {
265 		rc = ENXIO;
266 		goto out;
267 	}
268 	if (mediasize > od->mediasize) {
269 		od->mediasize = mediasize;
270 	}
271 
272 	if (ptable_gettype(od->table) == PTABLE_BSD &&
273 	    partition >= 0) {
274 		/* It doesn't matter what value has d_slice */
275 		rc = ptable_getpart(od->table, &part, partition);
276 		if (rc == 0) {
277 			dev->d_offset = part.start;
278 			od->entrysize = part.end - part.start + 1;
279 		}
280 	} else if (ptable_gettype(od->table) == PTABLE_ISO9660) {
281 		dev->d_offset = 0;
282 		od->entrysize = mediasize;
283 	} else if (slice >= 0) {
284 		/* Try to get information about partition */
285 		if (slice == 0)
286 			rc = ptable_getbestpart(od->table, &part);
287 		else
288 			rc = ptable_getpart(od->table, &part, slice);
289 		if (rc != 0) /* Partition doesn't exist */
290 			goto out;
291 		dev->d_offset = part.start;
292 		od->entrysize = part.end - part.start + 1;
293 		slice = part.index;
294 		if (ptable_gettype(od->table) == PTABLE_GPT) {
295 			partition = 255;
296 			goto out; /* Nothing more to do */
297 		} else if (partition == 255) {
298 			/*
299 			 * When we try to open GPT partition, but partition
300 			 * table isn't GPT, reset d_partition value to -1
301 			 * and try to autodetect appropriate value.
302 			 */
303 			partition = -1;
304 		}
305 		/*
306 		 * If d_partition < 0 and we are looking at a BSD slice,
307 		 * then try to read BSD label, otherwise return the
308 		 * whole MBR slice.
309 		 */
310 		if (partition == -1 &&
311 		    part.type != PART_FREEBSD)
312 			goto out;
313 		/* Try to read BSD label */
314 		table = ptable_open(dev, part.end - part.start + 1,
315 		    od->sectorsize, ptblread);
316 		if (table == NULL) {
317 			DEBUG("Can't read BSD label");
318 			rc = ENXIO;
319 			goto out;
320 		}
321 		/*
322 		 * If slice contains BSD label and d_partition < 0, then
323 		 * assume the 'a' partition. Otherwise just return the
324 		 * whole MBR slice, because it can contain ZFS.
325 		 */
326 		if (partition < 0) {
327 			if (ptable_gettype(table) != PTABLE_BSD)
328 				goto out;
329 			partition = 0;
330 		}
331 		rc = ptable_getpart(table, &part, partition);
332 		if (rc != 0)
333 			goto out;
334 		dev->d_offset += part.start;
335 		od->entrysize = part.end - part.start + 1;
336 	}
337 out:
338 	if (table != NULL)
339 		ptable_close(table);
340 
341 	if (rc != 0) {
342 		if (od->table != NULL)
343 			ptable_close(od->table);
344 		free(od);
345 		DEBUG("%s could not open", disk_fmtdev(dev));
346 	} else {
347 		/* Save the slice and partition number to the dev */
348 		dev->d_slice = slice;
349 		dev->d_partition = partition;
350 		DEBUG("%s offset %lld => %p", disk_fmtdev(dev),
351 		    (long long)dev->d_offset, od);
352 	}
353 	return (rc);
354 }
355 
356 int
357 disk_close(struct disk_devdesc *dev)
358 {
359 	struct open_disk *od;
360 
361 	od = (struct open_disk *)dev->dd.d_opendata;
362 	DEBUG("%s closed => %p", disk_fmtdev(dev), od);
363 	ptable_close(od->table);
364 	free(od);
365 	return (0);
366 }
367 
368 char*
369 disk_fmtdev(struct disk_devdesc *dev)
370 {
371 	static char buf[128];
372 	char *cp;
373 
374 	cp = buf + sprintf(buf, "%s%d", dev->dd.d_dev->dv_name, dev->dd.d_unit);
375 	if (dev->d_slice >= 0) {
376 #ifdef LOADER_GPT_SUPPORT
377 		if (dev->d_partition == 255) {
378 			sprintf(cp, "p%d:", dev->d_slice);
379 			return (buf);
380 		} else
381 #endif
382 #ifdef LOADER_MBR_SUPPORT
383 			cp += sprintf(cp, "s%d", dev->d_slice);
384 #endif
385 	}
386 	if (dev->d_partition >= 0)
387 		cp += sprintf(cp, "%c", dev->d_partition + 'a');
388 	strcat(cp, ":");
389 	return (buf);
390 }
391 
392 int
393 disk_parsedev(struct disk_devdesc *dev, const char *devspec, const char **path)
394 {
395 	int unit, slice, partition;
396 	const char *np;
397 	char *cp;
398 
399 	np = devspec;
400 	unit = slice = partition = -1;
401 	if (*np != '\0' && *np != ':') {
402 		unit = strtol(np, &cp, 10);
403 		if (cp == np)
404 			return (EUNIT);
405 #ifdef LOADER_GPT_SUPPORT
406 		if (*cp == 'p') {
407 			np = cp + 1;
408 			slice = strtol(np, &cp, 10);
409 			if (np == cp)
410 				return (ESLICE);
411 			/* we don't support nested partitions on GPT */
412 			if (*cp != '\0' && *cp != ':')
413 				return (EINVAL);
414 			partition = 255;
415 		} else
416 #endif
417 #ifdef LOADER_MBR_SUPPORT
418 		if (*cp == 's') {
419 			np = cp + 1;
420 			slice = strtol(np, &cp, 10);
421 			if (np == cp)
422 				return (ESLICE);
423 		}
424 #endif
425 		if (*cp != '\0' && *cp != ':') {
426 			partition = *cp - 'a';
427 			if (partition < 0)
428 				return (EPART);
429 			cp++;
430 		}
431 	} else
432 		return (EINVAL);
433 
434 	if (*cp != '\0' && *cp != ':')
435 		return (EINVAL);
436 	dev->dd.d_unit = unit;
437 	dev->d_slice = slice;
438 	dev->d_partition = partition;
439 	if (path != NULL)
440 		*path = (*cp == '\0') ? cp: cp + 1;
441 	return (0);
442 }
443