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 DPRINTF(fmt, args...)	printf("%s: " fmt "\n" , __func__ , ## args)
42#else
43# define DPRINTF(fmt, args...)	((void)0)
44#endif
45
46struct open_disk {
47	struct ptable		*table;
48	uint64_t		mediasize;
49	uint64_t		entrysize;
50	u_int			sectorsize;
51};
52
53struct print_args {
54	struct disk_devdesc	*dev;
55	const char		*prefix;
56	int			verbose;
57};
58
59/* Convert size to a human-readable number. */
60static char *
61display_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
82int
83ptblread(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
105static int
106ptable_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
164int
165disk_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
178int
179disk_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
191int
192disk_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
204int
205disk_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
229int
230disk_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	}
357out:
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
376int
377disk_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
388char*
389disk_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
412int
413disk_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