1/*-
2 * Copyright (c) 2011 Google, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: stable/11/stand/userboot/userboot/userboot_disk.c 332154 2018-04-06 21:37:25Z kevans $");
29
30/*
31 * Userboot disk image handling.
32 */
33
34#include <sys/disk.h>
35#include <stand.h>
36#include <stdarg.h>
37#include <bootstrap.h>
38
39#include "disk.h"
40#include "libuserboot.h"
41
42struct userdisk_info {
43	uint64_t	mediasize;
44	uint16_t	sectorsize;
45	int		ud_open;	/* reference counter */
46	void		*ud_bcache;	/* buffer cache data */
47};
48
49int userboot_disk_maxunit = 0;
50
51static int userdisk_maxunit = 0;
52static struct userdisk_info	*ud_info;
53
54static int	userdisk_init(void);
55static void	userdisk_cleanup(void);
56static int	userdisk_strategy(void *devdata, int flag, daddr_t dblk,
57		    size_t size, char *buf, size_t *rsize);
58static int	userdisk_realstrategy(void *devdata, int flag, daddr_t dblk,
59		    size_t size, char *buf, size_t *rsize);
60static int	userdisk_open(struct open_file *f, ...);
61static int	userdisk_close(struct open_file *f);
62static int	userdisk_ioctl(struct open_file *f, u_long cmd, void *data);
63static int	userdisk_print(int verbose);
64
65struct devsw userboot_disk = {
66	"disk",
67	DEVT_DISK,
68	userdisk_init,
69	userdisk_strategy,
70	userdisk_open,
71	userdisk_close,
72	userdisk_ioctl,
73	userdisk_print,
74	userdisk_cleanup
75};
76
77/*
78 * Initialize userdisk_info structure for each disk.
79 */
80static int
81userdisk_init(void)
82{
83	off_t mediasize;
84	u_int sectorsize;
85	int i;
86
87	userdisk_maxunit = userboot_disk_maxunit;
88	if (userdisk_maxunit > 0) {
89		ud_info = malloc(sizeof(*ud_info) * userdisk_maxunit);
90		if (ud_info == NULL)
91			return (ENOMEM);
92		for (i = 0; i < userdisk_maxunit; i++) {
93			if (CALLBACK(diskioctl, i, DIOCGSECTORSIZE,
94			    &sectorsize) != 0 || CALLBACK(diskioctl, i,
95			    DIOCGMEDIASIZE, &mediasize) != 0)
96				return (ENXIO);
97			ud_info[i].mediasize = mediasize;
98			ud_info[i].sectorsize = sectorsize;
99			ud_info[i].ud_open = 0;
100			ud_info[i].ud_bcache = NULL;
101		}
102	}
103	bcache_add_dev(userdisk_maxunit);
104	return(0);
105}
106
107static void
108userdisk_cleanup(void)
109{
110
111	if (userdisk_maxunit > 0)
112		free(ud_info);
113}
114
115/*
116 * Print information about disks
117 */
118static int
119userdisk_print(int verbose)
120{
121	struct disk_devdesc dev;
122	char line[80];
123	int i, ret = 0;
124
125	if (userdisk_maxunit == 0)
126		return (0);
127
128	printf("%s devices:", userboot_disk.dv_name);
129	if ((ret = pager_output("\n")) != 0)
130		return (ret);
131
132	for (i = 0; i < userdisk_maxunit; i++) {
133		snprintf(line, sizeof(line),
134		    "    disk%d:   Guest drive image\n", i);
135		ret = pager_output(line);
136		if (ret != 0)
137			break;
138		dev.dd.d_dev = &userboot_disk;
139		dev.dd.d_unit = i;
140		dev.d_slice = -1;
141		dev.d_partition = -1;
142		if (disk_open(&dev, ud_info[i].mediasize,
143		    ud_info[i].sectorsize) == 0) {
144			snprintf(line, sizeof(line), "    disk%d", i);
145			ret = disk_print(&dev, line, verbose);
146			disk_close(&dev);
147			if (ret != 0)
148				break;
149		}
150	}
151	return (ret);
152}
153
154/*
155 * Attempt to open the disk described by (dev) for use by (f).
156 */
157static int
158userdisk_open(struct open_file *f, ...)
159{
160	va_list			ap;
161	struct disk_devdesc	*dev;
162
163	va_start(ap, f);
164	dev = va_arg(ap, struct disk_devdesc *);
165	va_end(ap);
166
167	if (dev->dd.d_unit < 0 || dev->dd.d_unit >= userdisk_maxunit)
168		return (EIO);
169	ud_info[dev->dd.d_unit].ud_open++;
170	if (ud_info[dev->dd.d_unit].ud_bcache == NULL)
171		ud_info[dev->dd.d_unit].ud_bcache = bcache_allocate();
172	return (disk_open(dev, ud_info[dev->dd.d_unit].mediasize,
173	    ud_info[dev->dd.d_unit].sectorsize));
174}
175
176static int
177userdisk_close(struct open_file *f)
178{
179	struct disk_devdesc *dev;
180
181	dev = (struct disk_devdesc *)f->f_devdata;
182	ud_info[dev->dd.d_unit].ud_open--;
183	if (ud_info[dev->dd.d_unit].ud_open == 0) {
184		bcache_free(ud_info[dev->dd.d_unit].ud_bcache);
185		ud_info[dev->dd.d_unit].ud_bcache = NULL;
186	}
187	return (disk_close(dev));
188}
189
190static int
191userdisk_strategy(void *devdata, int rw, daddr_t dblk, size_t size,
192    char *buf, size_t *rsize)
193{
194	struct bcache_devdata bcd;
195	struct disk_devdesc *dev;
196
197	dev = (struct disk_devdesc *)devdata;
198	bcd.dv_strategy = userdisk_realstrategy;
199	bcd.dv_devdata = devdata;
200	bcd.dv_cache = ud_info[dev->dd.d_unit].ud_bcache;
201	return (bcache_strategy(&bcd, rw, dblk + dev->d_offset,
202	    size, buf, rsize));
203}
204
205static int
206userdisk_realstrategy(void *devdata, int rw, daddr_t dblk, size_t size,
207    char *buf, size_t *rsize)
208{
209	struct disk_devdesc *dev = devdata;
210	uint64_t	off;
211	size_t		resid;
212	int		rc;
213
214	rw &= F_MASK;
215	if (rw == F_WRITE)
216		return (EROFS);
217	if (rw != F_READ)
218		return (EINVAL);
219	if (rsize)
220		*rsize = 0;
221	off = dblk * ud_info[dev->dd.d_unit].sectorsize;
222	rc = CALLBACK(diskread, dev->dd.d_unit, off, buf, size, &resid);
223	if (rc)
224		return (rc);
225	if (rsize)
226		*rsize = size - resid;
227	return (0);
228}
229
230static int
231userdisk_ioctl(struct open_file *f, u_long cmd, void *data)
232{
233	struct disk_devdesc *dev;
234	int rc;
235
236	dev = (struct disk_devdesc *)f->f_devdata;
237	rc = disk_ioctl(dev, cmd, data);
238	if (rc != ENOTTY)
239		return (rc);
240
241	return (CALLBACK(diskioctl, dev->dd.d_unit, cmd, data));
242}
243