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