xref: /freebsd/stand/common/vdisk.c (revision 15f0b8c3) 
1 /*-
2  * Copyright 2019 Toomas Soome <tsoome@me.com>
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23  * SUCH DAMAGE.
24  */
25 
26 #include <sys/cdefs.h>
27 __FBSDID("$FreeBSD$");
28 
29 #include <stand.h>
30 #include <stdarg.h>
31 #include <machine/_inttypes.h>
32 #include <bootstrap.h>
33 #include <sys/disk.h>
34 #include <sys/errno.h>
35 #include <sys/queue.h>
36 #include <sys/param.h>
37 #include <disk.h>
38 
39 static int vdisk_init(void);
40 static int vdisk_strategy(void *, int, daddr_t, size_t, char *, size_t *);
41 static int vdisk_open(struct open_file *, ...);
42 static int vdisk_close(struct open_file *);
43 static int vdisk_ioctl(struct open_file *, u_long, void *);
44 static int vdisk_print(int);
45 
46 struct devsw vdisk_dev = {
47 	.dv_name = "vdisk",
48 	.dv_type = DEVT_DISK,
49 	.dv_init = vdisk_init,
50 	.dv_strategy = vdisk_strategy,
51 	.dv_open = vdisk_open,
52 	.dv_close = vdisk_close,
53 	.dv_ioctl = vdisk_ioctl,
54 	.dv_print = vdisk_print,
55 	.dv_cleanup = nullsys,
56 	.dv_fmtdev = disk_fmtdev,
57 	.dv_parsedev = disk_parsedev,
58 };
59 
60 typedef STAILQ_HEAD(vdisk_info_list, vdisk_info) vdisk_info_list_t;
61 
62 typedef struct vdisk_info
63 {
64 	STAILQ_ENTRY(vdisk_info)	vdisk_link; /* link in device list */
65 	char			*vdisk_path;
66 	int			vdisk_unit;
67 	int			vdisk_fd;
68 	uint64_t		vdisk_size;	/* size in bytes */
69 	uint32_t		vdisk_sectorsz;
70 	uint32_t		vdisk_open;	/* reference counter */
71 } vdisk_info_t;
72 
73 static vdisk_info_list_t vdisk_list;	/* list of mapped vdisks. */
74 
75 static vdisk_info_t *
76 vdisk_get_info(struct devdesc *dev)
77 {
78 	vdisk_info_t *vd;
79 
80 	STAILQ_FOREACH(vd, &vdisk_list, vdisk_link) {
81 		if (vd->vdisk_unit == dev->d_unit)
82 			return (vd);
83 	}
84 	return (vd);
85 }
86 
87 COMMAND_SET(map_vdisk, "map-vdisk", "map file as virtual disk", command_mapvd);
88 
89 static int
90 command_mapvd(int argc, char *argv[])
91 {
92 	vdisk_info_t *vd, *p;
93 	struct stat sb;
94 
95 	if (argc != 2) {
96 		printf("usage: %s filename\n", argv[0]);
97 		return (CMD_ERROR);
98 	}
99 
100 	STAILQ_FOREACH(vd, &vdisk_list, vdisk_link) {
101 		if (strcmp(vd->vdisk_path, argv[1]) == 0) {
102 			printf("%s: file %s is already mapped as %s%d\n",
103 			    argv[0], argv[1], vdisk_dev.dv_name,
104 			    vd->vdisk_unit);
105 			return (CMD_ERROR);
106 		}
107 	}
108 
109 	if (stat(argv[1], &sb) < 0) {
110 		/*
111 		 * ENOSYS is really ENOENT because we did try to walk
112 		 * through devsw list to try to open this file.
113 		 */
114 		if (errno == ENOSYS)
115 			errno = ENOENT;
116 
117 		printf("%s: stat failed: %s\n", argv[0], strerror(errno));
118 		return (CMD_ERROR);
119 	}
120 
121 	/*
122 	 * Avoid mapping small files.
123 	 */
124 	if (sb.st_size < 1024 * 1024) {
125 		printf("%s: file %s is too small.\n", argv[0], argv[1]);
126 		return (CMD_ERROR);
127 	}
128 
129 	vd = calloc(1, sizeof (*vd));
130 	if (vd == NULL) {
131 		printf("%s: out of memory\n", argv[0]);
132 		return (CMD_ERROR);
133 	}
134 	vd->vdisk_path = strdup(argv[1]);
135 	if (vd->vdisk_path == NULL) {
136 		free (vd);
137 		printf("%s: out of memory\n", argv[0]);
138 		return (CMD_ERROR);
139 	}
140 	vd->vdisk_fd = open(vd->vdisk_path, O_RDONLY);
141 	if (vd->vdisk_fd < 0) {
142 		printf("%s: open failed: %s\n", argv[0], strerror(errno));
143 		free(vd->vdisk_path);
144 		free(vd);
145 		return (CMD_ERROR);
146 	}
147 
148 	vd->vdisk_size = sb.st_size;
149 	vd->vdisk_sectorsz = DEV_BSIZE;
150 	STAILQ_FOREACH(p, &vdisk_list, vdisk_link) {
151 		vdisk_info_t *n;
152 		if (p->vdisk_unit == vd->vdisk_unit) {
153 			vd->vdisk_unit++;
154 			continue;
155 		}
156 		n = STAILQ_NEXT(p, vdisk_link);
157 		if (p->vdisk_unit < vd->vdisk_unit) {
158 			if (n == NULL) {
159 				/* p is last elem */
160 				STAILQ_INSERT_TAIL(&vdisk_list, vd, vdisk_link);
161 				break;
162 			}
163 			if (n->vdisk_unit > vd->vdisk_unit) {
164 				/* p < vd < n */
165 				STAILQ_INSERT_AFTER(&vdisk_list, p, vd,
166 				    vdisk_link);
167 				break;
168 			}
169 			/* else n < vd or n == vd */
170 			vd->vdisk_unit++;
171 			continue;
172 		}
173 		/* p > vd only if p is the first element */
174 		STAILQ_INSERT_HEAD(&vdisk_list, vd, vdisk_link);
175 		break;
176 	}
177 
178 	/* if the list was empty or contiguous */
179 	if (p == NULL)
180 		STAILQ_INSERT_TAIL(&vdisk_list, vd, vdisk_link);
181 
182 	printf("%s: file %s is mapped as %s%d\n", argv[0], vd->vdisk_path,
183 	    vdisk_dev.dv_name, vd->vdisk_unit);
184 	return (CMD_OK);
185 }
186 
187 COMMAND_SET(unmap_vdisk, "unmap-vdisk", "unmap virtual disk", command_unmapvd);
188 
189 /*
190  * unmap-vdisk vdiskX
191  */
192 static int
193 command_unmapvd(int argc, char *argv[])
194 {
195 	size_t len;
196 	vdisk_info_t *vd;
197 	long unit;
198 	char *end;
199 
200 	if (argc != 2) {
201 		printf("usage: %s %sN\n", argv[0], vdisk_dev.dv_name);
202 		return (CMD_ERROR);
203 	}
204 
205 	len = strlen(vdisk_dev.dv_name);
206 	if (strncmp(vdisk_dev.dv_name, argv[1], len) != 0) {
207 		printf("%s: unknown device %s\n", argv[0], argv[1]);
208 		return (CMD_ERROR);
209 	}
210 	errno = 0;
211 	unit = strtol(argv[1] + len, &end, 10);
212 	if (errno != 0 || (*end != '\0' && strcmp(end, ":") != 0)) {
213 		printf("%s: unknown device %s\n", argv[0], argv[1]);
214 		return (CMD_ERROR);
215 	}
216 
217 	STAILQ_FOREACH(vd, &vdisk_list, vdisk_link) {
218 		if (vd->vdisk_unit == unit)
219 			break;
220 	}
221 
222 	if (vd == NULL) {
223 		printf("%s: unknown device %s\n", argv[0], argv[1]);
224 		return (CMD_ERROR);
225 	}
226 
227 	if (vd->vdisk_open != 0) {
228 		printf("%s: %s is in use, unable to unmap.\n",
229 		    argv[0], argv[1]);
230 		return (CMD_ERROR);
231 	}
232 
233 	STAILQ_REMOVE(&vdisk_list, vd, vdisk_info, vdisk_link);
234 	(void) close(vd->vdisk_fd);
235 	printf("%s (%s) unmapped\n", argv[1], vd->vdisk_path);
236 	free(vd->vdisk_path);
237 	free(vd);
238 
239 	return (CMD_OK);
240 }
241 
242 static int
243 vdisk_init(void)
244 {
245 	STAILQ_INIT(&vdisk_list);
246 	return (0);
247 }
248 
249 static int
250 vdisk_strategy(void *devdata, int rw, daddr_t blk, size_t size,
251     char *buf, size_t *rsize)
252 {
253 	struct disk_devdesc *dev;
254 	vdisk_info_t *vd;
255 	ssize_t rv;
256 
257 	dev = devdata;
258 	if (dev == NULL)
259 		return (EINVAL);
260 	vd = vdisk_get_info((struct devdesc *)dev);
261 	if (vd == NULL)
262 		return (EINVAL);
263 
264 	if (size == 0 || (size % 512) != 0)
265 		return (EIO);
266 
267 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
268 		daddr_t offset;
269 
270 		offset = dev->d_offset * vd->vdisk_sectorsz;
271 		offset /= 512;
272 		blk += offset;
273 	}
274 	if (lseek(vd->vdisk_fd, blk << 9, SEEK_SET) == -1)
275 		return (EIO);
276 
277 	errno = 0;
278 	switch (rw & F_MASK) {
279 	case F_READ:
280 		rv = read(vd->vdisk_fd, buf, size);
281 		break;
282 	case F_WRITE:
283 		rv = write(vd->vdisk_fd, buf, size);
284 		break;
285 	default:
286 		return (ENOSYS);
287 	}
288 
289 	if (errno == 0 && rsize != NULL) {
290 		*rsize = rv;
291 	}
292 	return (errno);
293 }
294 
295 static int
296 vdisk_open(struct open_file *f, ...)
297 {
298 	va_list args;
299 	struct disk_devdesc *dev;
300 	vdisk_info_t *vd;
301 	int rc = 0;
302 
303 	va_start(args, f);
304 	dev = va_arg(args, struct disk_devdesc *);
305 	va_end(args);
306 	if (dev == NULL)
307 		return (EINVAL);
308 	vd = vdisk_get_info((struct devdesc *)dev);
309 	if (vd == NULL)
310 		return (EINVAL);
311 
312 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
313 		rc = disk_open(dev, vd->vdisk_size, vd->vdisk_sectorsz);
314 	}
315 	if (rc == 0)
316 		vd->vdisk_open++;
317 	return (rc);
318 }
319 
320 static int
321 vdisk_close(struct open_file *f)
322 {
323 	struct disk_devdesc *dev;
324 	vdisk_info_t *vd;
325 
326 	dev = (struct disk_devdesc *)(f->f_devdata);
327 	if (dev == NULL)
328 		return (EINVAL);
329 	vd = vdisk_get_info((struct devdesc *)dev);
330 	if (vd == NULL)
331 		return (EINVAL);
332 
333 	vd->vdisk_open--;
334 	if (dev->dd.d_dev->dv_type == DEVT_DISK)
335 		return (disk_close(dev));
336 	return (0);
337 }
338 
339 static int
340 vdisk_ioctl(struct open_file *f, u_long cmd, void *data)
341 {
342 	struct disk_devdesc *dev;
343 	vdisk_info_t *vd;
344 	int rc;
345 
346 	dev = (struct disk_devdesc *)(f->f_devdata);
347 	if (dev == NULL)
348 		return (EINVAL);
349 	vd = vdisk_get_info((struct devdesc *)dev);
350 	if (vd == NULL)
351 		return (EINVAL);
352 
353 	if (dev->dd.d_dev->dv_type == DEVT_DISK) {
354 		rc = disk_ioctl(dev, cmd, data);
355 		if (rc != ENOTTY)
356 			return (rc);
357 	}
358 
359 	switch (cmd) {
360 	case DIOCGSECTORSIZE:
361 		*(u_int *)data = vd->vdisk_sectorsz;
362 		break;
363 	case DIOCGMEDIASIZE:
364 		*(uint64_t *)data = vd->vdisk_size;
365 		break;
366 	default:
367 		return (ENOTTY);
368 	}
369 	return (0);
370 }
371 
372 static int
373 vdisk_print(int verbose)
374 {
375 	int ret = 0;
376 	vdisk_info_t *vd;
377 	char line[80];
378 
379 	if (STAILQ_EMPTY(&vdisk_list))
380 		return (ret);
381 
382 	printf("%s devices:", vdisk_dev.dv_name);
383 	if ((ret = pager_output("\n")) != 0)
384 		return (ret);
385 
386 	STAILQ_FOREACH(vd, &vdisk_list, vdisk_link) {
387 		struct disk_devdesc vd_dev;
388 
389 		if (verbose) {
390 			printf("  %s", vd->vdisk_path);
391 			if ((ret = pager_output("\n")) != 0)
392 				break;
393 		}
394 		snprintf(line, sizeof(line),
395 		    "    %s%d", vdisk_dev.dv_name, vd->vdisk_unit);
396 		printf("%s:    %" PRIu64 " X %u blocks", line,
397 		    vd->vdisk_size / vd->vdisk_sectorsz,
398 		    vd->vdisk_sectorsz);
399 		if ((ret = pager_output("\n")) != 0)
400 			break;
401 
402 		vd_dev.dd.d_dev = &vdisk_dev;
403 		vd_dev.dd.d_unit = vd->vdisk_unit;
404 		vd_dev.d_slice = -1;
405 		vd_dev.d_partition = -1;
406 
407 		ret = disk_open(&vd_dev, vd->vdisk_size, vd->vdisk_sectorsz);
408 		if (ret == 0) {
409 			ret = disk_print(&vd_dev, line, verbose);
410 			disk_close(&vd_dev);
411 			if (ret != 0)
412 				break;
413 		} else {
414 			ret = 0;
415 		}
416 	}
417 
418 	return (ret);
419 }
420