]> git.saurik.com Git - apple/xnu.git/blob - bsd/dev/vn/vn.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-6153.41.3.tar.gz
[apple/xnu.git] / bsd / dev / vn / vn.c
1 /*
2 * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29 /*
30 * Copyright (c) 1988 University of Utah.
31 * Copyright (c) 1990, 1993
32 * The Regents of the University of California. All rights reserved.
33 *
34 * This code is derived from software contributed to Berkeley by
35 * the Systems Programming Group of the University of Utah Computer
36 * Science Department.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. All advertising materials mentioning features or use of this software
47 * must display the following acknowledgement:
48 * This product includes software developed by the University of
49 * California, Berkeley and its contributors.
50 * 4. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 * from: Utah Hdr: vn.c 1.13 94/04/02
67 *
68 * from: @(#)vn.c 8.6 (Berkeley) 4/1/94
69 * $FreeBSD: src/sys/dev/vn/vn.c,v 1.105.2.4 2001/11/18 07:11:00 dillon Exp $
70 */
71
72 /*
73 * Vnode disk driver.
74 *
75 * Block/character interface to a vnode. Allows one to treat a file
76 * as a disk (e.g. build a filesystem in it, mount it, etc.).
77 *
78 * NOTE 1: This uses the vnop_blockmap/vnop_strategy interface to the vnode
79 * instead of a simple VOP_RDWR. We do this to avoid distorting the
80 * local buffer cache.
81 *
82 * NOTE 2: There is a security issue involved with this driver.
83 * Once mounted all access to the contents of the "mapped" file via
84 * the special file is controlled by the permissions on the special
85 * file, the protection of the mapped file is ignored (effectively,
86 * by using root credentials in all transactions).
87 *
88 * NOTE 3: Doesn't interact with leases, should it?
89 */
90
91 #include "vndevice.h"
92
93 #if NVNDEVICE > 0
94
95 #include <sys/param.h>
96 #include <sys/systm.h>
97 #include <sys/kernel.h>
98 #include <sys/mount.h>
99 #include <sys/namei.h>
100 #include <sys/proc.h>
101 #include <sys/kauth.h>
102 #include <sys/buf.h>
103 #include <sys/malloc.h>
104 #include <sys/vnode_internal.h>
105 #include <sys/fcntl.h>
106 #include <sys/conf.h>
107 #include <sys/disk.h>
108 #include <sys/stat.h>
109 #include <sys/conf.h>
110 #include <sys/uio_internal.h>
111
112 #include <sys/vnioctl.h>
113
114 #include <sys/vm.h>
115
116 #include <vm/vm_pager.h>
117 #include <mach/memory_object_types.h>
118
119 #include <miscfs/devfs/devfs.h>
120
121
122 #include "shadow.h"
123 static void
124 vndevice_do_init(void);
125
126 static ioctl_fcn_t vnioctl_chr;
127 static ioctl_fcn_t vnioctl_blk;
128 static open_close_fcn_t vnopen;
129 static open_close_fcn_t vnclose;
130 static psize_fcn_t vnsize;
131 static strategy_fcn_t vnstrategy;
132 static read_write_fcn_t vnread;
133 static read_write_fcn_t vnwrite;
134
135 static int vndevice_bdev_major;
136 static int vndevice_cdev_major;
137
138 /*
139 * cdevsw
140 * D_DISK we want to look like a disk
141 * D_CANFREE We support B_FREEBUF
142 */
143
144 static struct bdevsw vn_bdevsw = {
145 .d_open = vnopen,
146 .d_close = vnclose,
147 .d_strategy = vnstrategy,
148 .d_ioctl = vnioctl_blk,
149 .d_dump = eno_dump,
150 .d_psize = vnsize,
151 .d_type = D_DISK,
152 };
153
154 static struct cdevsw vn_cdevsw = {
155 .d_open = vnopen,
156 .d_close = vnclose,
157 .d_read = vnread,
158 .d_write = vnwrite,
159 .d_ioctl = vnioctl_chr,
160 .d_stop = eno_stop,
161 .d_reset = eno_reset,
162 .d_ttys = NULL,
163 .d_select = eno_select,
164 .d_mmap = eno_mmap,
165 .d_strategy = eno_strat,
166 .d_reserved_1 = eno_getc,
167 .d_reserved_2 = eno_putc,
168 .d_type = D_DISK,
169 };
170
171 struct vn_softc {
172 u_int64_t sc_fsize; /* file size in bytes */
173 u_int64_t sc_size; /* size of vn, sc_secsize scale */
174 int sc_flags; /* flags */
175 u_int32_t sc_secsize; /* sector size */
176 struct vnode *sc_vp; /* vnode if not NULL */
177 uint32_t sc_vid;
178 int sc_open_flags;
179 struct vnode *sc_shadow_vp; /* shadow vnode if not NULL */
180 uint32_t sc_shadow_vid;
181 shadow_map_t * sc_shadow_map; /* shadow map if not NULL */
182 kauth_cred_t sc_cred; /* credentials */
183 u_int32_t sc_options; /* options */
184 void * sc_bdev;
185 void * sc_cdev;
186 } vn_table[NVNDEVICE];
187
188 #define ROOT_IMAGE_UNIT 0
189
190 /* sc_flags */
191 #define VNF_INITED 0x01
192 #define VNF_READONLY 0x02
193
194 static u_int32_t vn_options;
195
196 #define IFOPT(vn, opt) if (((vn)->sc_options|vn_options) & (opt))
197 #define TESTOPT(vn, opt) (((vn)->sc_options|vn_options) & (opt))
198
199 static int setcred(struct vnode * vp, kauth_cred_t cred);
200 static void vnclear(struct vn_softc *vn, vfs_context_t ctx);
201 static void vn_ioctl_to_64(struct vn_ioctl_32 *from, struct vn_ioctl_64 *to);
202 void vndevice_init(void);
203 int vndevice_root_image(char * path, char devname[], dev_t * dev_p);
204
205 static int
206 vniocattach_file(struct vn_softc *vn,
207 struct vn_ioctl_64 *vniop,
208 dev_t dev,
209 int in_kernel,
210 proc_t p);
211 static int
212 vniocattach_shadow(struct vn_softc * vn,
213 struct vn_ioctl_64 *vniop,
214 dev_t dev,
215 int in_kernel,
216 proc_t p);
217 static __inline__ int
218 vnunit(dev_t dev)
219 {
220 return minor(dev);
221 }
222
223 static int
224 vnclose(__unused dev_t dev, __unused int flags,
225 __unused int devtype, __unused proc_t p)
226 {
227 return 0;
228 }
229
230 static int
231 vnopen(dev_t dev, int flags, __unused int devtype, __unused proc_t p)
232 {
233 struct vn_softc *vn;
234 int unit;
235
236 unit = vnunit(dev);
237 if (vnunit(dev) >= NVNDEVICE) {
238 return ENXIO;
239 }
240 vn = vn_table + unit;
241 if ((flags & FWRITE) && (vn->sc_flags & VNF_READONLY)) {
242 return EACCES;
243 }
244
245 return 0;
246 }
247
248 static int
249 file_io(struct vnode * vp, vfs_context_t ctx,
250 enum uio_rw op, char * base, off_t offset, user_ssize_t count,
251 user_ssize_t * resid)
252 {
253 uio_t auio;
254 int error;
255 char uio_buf[UIO_SIZEOF(1)];
256
257 auio = uio_createwithbuffer(1, offset, UIO_SYSSPACE, op,
258 &uio_buf[0], sizeof(uio_buf));
259 uio_addiov(auio, CAST_USER_ADDR_T(base), count);
260 if (op == UIO_READ) {
261 error = VNOP_READ(vp, auio, IO_SYNC, ctx);
262 } else {
263 error = VNOP_WRITE(vp, auio, IO_SYNC, ctx);
264 }
265
266 if (resid != NULL) {
267 *resid = uio_resid(auio);
268 }
269 return error;
270 }
271
272 static __inline__ off_t
273 block_round(off_t o, int blocksize)
274 {
275 return (o + blocksize - 1) / blocksize;
276 }
277
278 static __inline__ off_t
279 block_truncate(off_t o, int blocksize)
280 {
281 return o / blocksize;
282 }
283
284 static __inline__ int
285 block_remainder(off_t o, int blocksize)
286 {
287 return o % blocksize;
288 }
289
290 static int
291 vnread_shadow(struct vn_softc * vn, struct uio *uio, int ioflag,
292 vfs_context_t ctx)
293 {
294 u_int32_t blocksize = vn->sc_secsize;
295 int error = 0;
296 off_t offset;
297 user_ssize_t resid;
298 off_t orig_offset;
299 user_ssize_t orig_resid;
300
301 orig_resid = resid = uio_resid(uio);
302 orig_offset = offset = uio_offset(uio);
303
304 while (resid > 0) {
305 u_int32_t remainder;
306 u_int32_t this_block_number;
307 u_int32_t this_block_count;
308 off_t this_offset;
309 user_ssize_t this_resid;
310 struct vnode * vp;
311
312 /* figure out which blocks to read */
313 remainder = block_remainder(offset, blocksize);
314 if (shadow_map_read(vn->sc_shadow_map,
315 block_truncate(offset, blocksize),
316 block_round(resid + remainder, blocksize),
317 &this_block_number, &this_block_count)) {
318 vp = vn->sc_shadow_vp;
319 } else {
320 vp = vn->sc_vp;
321 }
322
323 /* read the blocks (or parts thereof) */
324 this_offset = (off_t)this_block_number * blocksize + remainder;
325 uio_setoffset(uio, this_offset);
326 this_resid = this_block_count * blocksize - remainder;
327 if (this_resid > resid) {
328 this_resid = resid;
329 }
330 uio_setresid(uio, this_resid);
331 error = VNOP_READ(vp, uio, ioflag, ctx);
332 if (error) {
333 break;
334 }
335
336 /* figure out how much we actually read */
337 this_resid -= uio_resid(uio);
338 if (this_resid == 0) {
339 printf("vn device: vnread_shadow zero length read\n");
340 break;
341 }
342 resid -= this_resid;
343 offset += this_resid;
344 }
345 uio_setresid(uio, resid);
346 uio_setoffset(uio, offset);
347 return error;
348 }
349
350 static int
351 vncopy_block_to_shadow(struct vn_softc * vn, vfs_context_t ctx,
352 u_int32_t file_block, u_int32_t shadow_block)
353 {
354 int error;
355 char * tmpbuf;
356
357 tmpbuf = _MALLOC(vn->sc_secsize, M_TEMP, M_WAITOK);
358 if (tmpbuf == NULL) {
359 return ENOMEM;
360 }
361 /* read one block from file at file_block offset */
362 error = file_io(vn->sc_vp, ctx, UIO_READ,
363 tmpbuf, (off_t)file_block * vn->sc_secsize,
364 vn->sc_secsize, NULL);
365 if (error) {
366 goto done;
367 }
368 /* write one block to shadow file at shadow_block offset */
369 error = file_io(vn->sc_shadow_vp, ctx, UIO_WRITE,
370 tmpbuf, (off_t)shadow_block * vn->sc_secsize,
371 vn->sc_secsize, NULL);
372 done:
373 FREE(tmpbuf, M_TEMP);
374 return error;
375 }
376
377 enum {
378 FLAGS_FIRST_BLOCK_PARTIAL = 0x1,
379 FLAGS_LAST_BLOCK_PARTIAL = 0x2
380 };
381
382 static int
383 vnwrite_shadow(struct vn_softc * vn, struct uio *uio, int ioflag,
384 vfs_context_t ctx)
385 {
386 u_int32_t blocksize = vn->sc_secsize;
387 int error = 0;
388 user_ssize_t resid;
389 off_t offset;
390
391 resid = uio_resid(uio);
392 offset = uio_offset(uio);
393
394 while (resid > 0) {
395 int flags = 0;
396 u_int32_t offset_block_number;
397 u_int32_t remainder;
398 u_int32_t resid_block_count;
399 u_int32_t shadow_block_count;
400 u_int32_t shadow_block_number;
401 user_ssize_t this_resid;
402
403 /* figure out which blocks to write */
404 offset_block_number = block_truncate(offset, blocksize);
405 remainder = block_remainder(offset, blocksize);
406 resid_block_count = block_round(resid + remainder, blocksize);
407 /* figure out if the first or last blocks are partial writes */
408 if (remainder > 0
409 && !shadow_map_is_written(vn->sc_shadow_map,
410 offset_block_number)) {
411 /* the first block is a partial write */
412 flags |= FLAGS_FIRST_BLOCK_PARTIAL;
413 }
414 if (resid_block_count > 1
415 && !shadow_map_is_written(vn->sc_shadow_map,
416 offset_block_number
417 + resid_block_count - 1)
418 && block_remainder(offset + resid, blocksize) > 0) {
419 /* the last block is a partial write */
420 flags |= FLAGS_LAST_BLOCK_PARTIAL;
421 }
422 if (shadow_map_write(vn->sc_shadow_map,
423 offset_block_number, resid_block_count,
424 &shadow_block_number,
425 &shadow_block_count)) {
426 /* shadow file is growing */
427 #if 0
428 /* truncate the file to its new length before write */
429 off_t size;
430 size = (off_t)shadow_map_shadow_size(vn->sc_shadow_map)
431 * vn->sc_secsize;
432 vnode_setsize(vn->sc_shadow_vp, size, IO_SYNC, ctx);
433 #endif
434 }
435 /* write the blocks (or parts thereof) */
436 uio_setoffset(uio, (off_t)
437 shadow_block_number * blocksize + remainder);
438 this_resid = (off_t)shadow_block_count * blocksize - remainder;
439 if (this_resid >= resid) {
440 this_resid = resid;
441 if ((flags & FLAGS_LAST_BLOCK_PARTIAL) != 0) {
442 /* copy the last block to the shadow */
443 u_int32_t d;
444 u_int32_t s;
445
446 s = offset_block_number
447 + resid_block_count - 1;
448 d = shadow_block_number
449 + shadow_block_count - 1;
450 error = vncopy_block_to_shadow(vn, ctx, s, d);
451 if (error) {
452 printf("vnwrite_shadow: failed to copy"
453 " block %u to shadow block %u\n",
454 s, d);
455 break;
456 }
457 }
458 }
459 uio_setresid(uio, this_resid);
460 if ((flags & FLAGS_FIRST_BLOCK_PARTIAL) != 0) {
461 /* copy the first block to the shadow */
462 error = vncopy_block_to_shadow(vn, ctx,
463 offset_block_number,
464 shadow_block_number);
465 if (error) {
466 printf("vnwrite_shadow: failed to"
467 " copy block %u to shadow block %u\n",
468 offset_block_number,
469 shadow_block_number);
470 break;
471 }
472 }
473 error = VNOP_WRITE(vn->sc_shadow_vp, uio, ioflag, ctx);
474 if (error) {
475 break;
476 }
477 /* figure out how much we actually wrote */
478 this_resid -= uio_resid(uio);
479 if (this_resid == 0) {
480 printf("vn device: vnwrite_shadow zero length write\n");
481 break;
482 }
483 resid -= this_resid;
484 offset += this_resid;
485 }
486 uio_setresid(uio, resid);
487 uio_setoffset(uio, offset);
488 return error;
489 }
490
491 static int
492 vnread(dev_t dev, struct uio *uio, int ioflag)
493 {
494 struct vfs_context context;
495 int error = 0;
496 off_t offset;
497 proc_t p;
498 user_ssize_t resid;
499 struct vn_softc * vn;
500 int unit;
501
502 unit = vnunit(dev);
503 if (vnunit(dev) >= NVNDEVICE) {
504 return ENXIO;
505 }
506 p = current_proc();
507 vn = vn_table + unit;
508 if ((vn->sc_flags & VNF_INITED) == 0) {
509 error = ENXIO;
510 goto done;
511 }
512
513 context.vc_thread = current_thread();
514 context.vc_ucred = vn->sc_cred;
515
516 error = vnode_getwithvid(vn->sc_vp, vn->sc_vid);
517 if (error != 0) {
518 /* the vnode is no longer available, abort */
519 error = ENXIO;
520 vnclear(vn, &context);
521 goto done;
522 }
523
524 resid = uio_resid(uio);
525 offset = uio_offset(uio);
526
527 /*
528 * If out of bounds return an error. If at the EOF point,
529 * simply read less.
530 */
531 if (offset >= (off_t)vn->sc_fsize) {
532 if (offset > (off_t)vn->sc_fsize) {
533 error = EINVAL;
534 }
535 goto done;
536 }
537 /*
538 * If the request crosses EOF, truncate the request.
539 */
540 if ((offset + resid) > (off_t)vn->sc_fsize) {
541 resid = vn->sc_fsize - offset;
542 uio_setresid(uio, resid);
543 }
544
545 if (vn->sc_shadow_vp != NULL) {
546 error = vnode_getwithvid(vn->sc_shadow_vp,
547 vn->sc_shadow_vid);
548 if (error != 0) {
549 /* the vnode is no longer available, abort */
550 error = ENXIO;
551 vnode_put(vn->sc_vp);
552 vnclear(vn, &context);
553 goto done;
554 }
555 error = vnread_shadow(vn, uio, ioflag, &context);
556 vnode_put(vn->sc_shadow_vp);
557 } else {
558 error = VNOP_READ(vn->sc_vp, uio, ioflag, &context);
559 }
560 vnode_put(vn->sc_vp);
561 done:
562 return error;
563 }
564
565 static int
566 vnwrite(dev_t dev, struct uio *uio, int ioflag)
567 {
568 struct vfs_context context;
569 int error;
570 off_t offset;
571 proc_t p;
572 user_ssize_t resid;
573 struct vn_softc * vn;
574 int unit;
575
576 unit = vnunit(dev);
577 if (vnunit(dev) >= NVNDEVICE) {
578 return ENXIO;
579 }
580 p = current_proc();
581 vn = vn_table + unit;
582 if ((vn->sc_flags & VNF_INITED) == 0) {
583 error = ENXIO;
584 goto done;
585 }
586 if (vn->sc_flags & VNF_READONLY) {
587 error = EROFS;
588 goto done;
589 }
590
591 context.vc_thread = current_thread();
592 context.vc_ucred = vn->sc_cred;
593
594 error = vnode_getwithvid(vn->sc_vp, vn->sc_vid);
595 if (error != 0) {
596 /* the vnode is no longer available, abort */
597 error = ENXIO;
598 vnclear(vn, &context);
599 goto done;
600 }
601 resid = uio_resid(uio);
602 offset = uio_offset(uio);
603
604 /*
605 * If out of bounds return an error. If at the EOF point,
606 * simply write less.
607 */
608 if (offset >= (off_t)vn->sc_fsize) {
609 if (offset > (off_t)vn->sc_fsize) {
610 error = EINVAL;
611 }
612 goto done;
613 }
614 /*
615 * If the request crosses EOF, truncate the request.
616 */
617 if ((offset + resid) > (off_t)vn->sc_fsize) {
618 resid = (off_t)vn->sc_fsize - offset;
619 uio_setresid(uio, resid);
620 }
621
622 if (vn->sc_shadow_vp != NULL) {
623 error = vnode_getwithvid(vn->sc_shadow_vp,
624 vn->sc_shadow_vid);
625 if (error != 0) {
626 /* the vnode is no longer available, abort */
627 error = ENXIO;
628 vnode_put(vn->sc_vp);
629 vnclear(vn, &context);
630 goto done;
631 }
632 error = vnwrite_shadow(vn, uio, ioflag, &context);
633 vnode_put(vn->sc_shadow_vp);
634 } else {
635 error = VNOP_WRITE(vn->sc_vp, uio, ioflag, &context);
636 }
637 vnode_put(vn->sc_vp);
638 done:
639 return error;
640 }
641
642 static int
643 shadow_read(struct vn_softc * vn, struct buf * bp, char * base,
644 vfs_context_t ctx)
645 {
646 u_int32_t blocksize = vn->sc_secsize;
647 int error = 0;
648 u_int32_t offset;
649 boolean_t read_shadow;
650 u_int32_t resid;
651 u_int32_t start = 0;
652
653 offset = buf_blkno(bp);
654 resid = buf_resid(bp) / blocksize;
655 while (resid > 0) {
656 user_ssize_t temp_resid;
657 u_int32_t this_offset;
658 u_int32_t this_resid;
659 struct vnode * vp;
660
661 read_shadow = shadow_map_read(vn->sc_shadow_map,
662 offset, resid,
663 &this_offset, &this_resid);
664 if (read_shadow) {
665 vp = vn->sc_shadow_vp;
666 } else {
667 vp = vn->sc_vp;
668 }
669 error = file_io(vp, ctx, UIO_READ, base + start,
670 (off_t)this_offset * blocksize,
671 (user_ssize_t)this_resid * blocksize,
672 &temp_resid);
673 if (error) {
674 break;
675 }
676 this_resid -= (temp_resid / blocksize);
677 if (this_resid == 0) {
678 printf("vn device: shadow_read zero length read\n");
679 break;
680 }
681 resid -= this_resid;
682 offset += this_resid;
683 start += this_resid * blocksize;
684 }
685 buf_setresid(bp, resid * blocksize);
686 return error;
687 }
688
689 static int
690 shadow_write(struct vn_softc * vn, struct buf * bp, char * base,
691 vfs_context_t ctx)
692 {
693 u_int32_t blocksize = vn->sc_secsize;
694 int error = 0;
695 u_int32_t offset;
696 boolean_t shadow_grew;
697 u_int32_t resid;
698 u_int32_t start = 0;
699
700 offset = buf_blkno(bp);
701 resid = buf_resid(bp) / blocksize;
702 while (resid > 0) {
703 user_ssize_t temp_resid;
704 u_int32_t this_offset;
705 u_int32_t this_resid;
706
707 shadow_grew = shadow_map_write(vn->sc_shadow_map,
708 offset, resid,
709 &this_offset, &this_resid);
710 if (shadow_grew) {
711 #if 0
712 off_t size;
713 /* truncate the file to its new length before write */
714 size = (off_t)shadow_map_shadow_size(vn->sc_shadow_map)
715 * blocksize;
716 vnode_setsize(vn->sc_shadow_vp, size, IO_SYNC, ctx);
717 #endif
718 }
719 error = file_io(vn->sc_shadow_vp, ctx, UIO_WRITE,
720 base + start,
721 (off_t)this_offset * blocksize,
722 (user_ssize_t)this_resid * blocksize,
723 &temp_resid);
724 if (error) {
725 break;
726 }
727 this_resid -= (temp_resid / blocksize);
728 if (this_resid == 0) {
729 printf("vn device: shadow_write zero length write\n");
730 break;
731 }
732 resid -= this_resid;
733 offset += this_resid;
734 start += this_resid * blocksize;
735 }
736 buf_setresid(bp, resid * blocksize);
737 return error;
738 }
739
740 static int
741 vn_readwrite_io(struct vn_softc * vn, struct buf * bp, vfs_context_t ctx)
742 {
743 int error = 0;
744 char * iov_base;
745 caddr_t vaddr;
746
747 if (buf_map(bp, &vaddr)) {
748 panic("vn device: buf_map failed");
749 }
750 iov_base = (char *)vaddr;
751
752 if (vn->sc_shadow_vp == NULL) {
753 user_ssize_t temp_resid;
754
755 error = file_io(vn->sc_vp, ctx,
756 buf_flags(bp) & B_READ ? UIO_READ : UIO_WRITE,
757 iov_base,
758 (off_t)buf_blkno(bp) * vn->sc_secsize,
759 buf_resid(bp), &temp_resid);
760 buf_setresid(bp, temp_resid);
761 } else {
762 if (buf_flags(bp) & B_READ) {
763 error = shadow_read(vn, bp, iov_base, ctx);
764 } else {
765 error = shadow_write(vn, bp, iov_base, ctx);
766 }
767 }
768 buf_unmap(bp);
769
770 return error;
771 }
772
773 static void
774 vnstrategy(struct buf *bp)
775 {
776 struct vn_softc *vn;
777 int error = 0;
778 long sz; /* in sc_secsize chunks */
779 daddr64_t blk_num;
780 struct vnode * shadow_vp = NULL;
781 struct vnode * vp = NULL;
782 struct vfs_context context;
783
784 vn = vn_table + vnunit(buf_device(bp));
785 if ((vn->sc_flags & VNF_INITED) == 0) {
786 error = ENXIO;
787 goto done;
788 }
789
790 context.vc_thread = current_thread();
791 context.vc_ucred = vn->sc_cred;
792
793 buf_setresid(bp, buf_count(bp));
794 /*
795 * Check for required alignment. Transfers must be a valid
796 * multiple of the sector size.
797 */
798 blk_num = buf_blkno(bp);
799 if (buf_count(bp) % vn->sc_secsize != 0) {
800 error = EINVAL;
801 goto done;
802 }
803 sz = howmany(buf_count(bp), vn->sc_secsize);
804
805 /*
806 * If out of bounds return an error. If at the EOF point,
807 * simply read or write less.
808 */
809 if (blk_num >= 0 && (u_int64_t)blk_num >= vn->sc_size) {
810 if (blk_num > 0 && (u_int64_t)blk_num > vn->sc_size) {
811 error = EINVAL;
812 }
813 goto done;
814 }
815 /*
816 * If the request crosses EOF, truncate the request.
817 */
818 if ((blk_num + sz) > 0 && ((u_int64_t)(blk_num + sz)) > vn->sc_size) {
819 buf_setcount(bp, (vn->sc_size - blk_num) * vn->sc_secsize);
820 buf_setresid(bp, buf_count(bp));
821 }
822 vp = vn->sc_vp;
823 if (vp == NULL) {
824 error = ENXIO;
825 goto done;
826 }
827
828 error = vnode_getwithvid(vp, vn->sc_vid);
829 if (error != 0) {
830 /* the vnode is no longer available, abort */
831 error = ENXIO;
832 vnclear(vn, &context);
833 goto done;
834 }
835 shadow_vp = vn->sc_shadow_vp;
836 if (shadow_vp != NULL) {
837 error = vnode_getwithvid(shadow_vp,
838 vn->sc_shadow_vid);
839 if (error != 0) {
840 /* the vnode is no longer available, abort */
841 error = ENXIO;
842 vnode_put(vn->sc_vp);
843 vnclear(vn, &context);
844 goto done;
845 }
846 }
847
848 error = vn_readwrite_io(vn, bp, &context);
849 vnode_put(vp);
850 if (shadow_vp != NULL) {
851 vnode_put(shadow_vp);
852 }
853
854 done:
855 if (error) {
856 buf_seterror(bp, error);
857 }
858 buf_biodone(bp);
859 return;
860 }
861
862 /* ARGSUSED */
863 static int
864 vnioctl(dev_t dev, u_long cmd, caddr_t data,
865 __unused int flag, proc_t p,
866 int is_char)
867 {
868 struct vn_softc *vn;
869 struct vn_ioctl_64 *viop;
870 int error;
871 u_int32_t *f;
872 u_int64_t * o;
873 int unit;
874 struct vfsioattr ioattr;
875 struct vn_ioctl_64 user_vnio;
876 struct vfs_context context;
877
878 unit = vnunit(dev);
879 if (vnunit(dev) >= NVNDEVICE) {
880 return ENXIO;
881 }
882
883 vn = vn_table + unit;
884 error = proc_suser(p);
885 if (error) {
886 goto done;
887 }
888
889 context.vc_thread = current_thread();
890 context.vc_ucred = vn->sc_cred;
891
892 viop = (struct vn_ioctl_64 *)data;
893 f = (u_int32_t *)data;
894 o = (u_int64_t *)data;
895 switch (cmd) {
896 #ifdef __LP64__
897 case VNIOCDETACH32:
898 case VNIOCDETACH:
899 #else
900 case VNIOCDETACH:
901 case VNIOCDETACH64:
902 #endif
903 case DKIOCGETBLOCKSIZE:
904 case DKIOCSETBLOCKSIZE:
905 case DKIOCGETMAXBLOCKCOUNTREAD:
906 case DKIOCGETMAXBLOCKCOUNTWRITE:
907 case DKIOCGETMAXSEGMENTCOUNTREAD:
908 case DKIOCGETMAXSEGMENTCOUNTWRITE:
909 case DKIOCGETMAXSEGMENTBYTECOUNTREAD:
910 case DKIOCGETMAXSEGMENTBYTECOUNTWRITE:
911 case DKIOCGETBLOCKCOUNT:
912 if ((vn->sc_flags & VNF_INITED) == 0) {
913 error = ENXIO;
914 goto done;
915 }
916 break;
917 default:
918 break;
919 }
920
921 if (vn->sc_vp != NULL) {
922 vfs_ioattr(vnode_mount(vn->sc_vp), &ioattr);
923 } else {
924 bzero(&ioattr, sizeof(ioattr));
925 }
926
927 switch (cmd) {
928 case DKIOCISVIRTUAL:
929 *f = 1;
930 break;
931 case DKIOCGETMAXBLOCKCOUNTREAD:
932 *o = ioattr.io_maxreadcnt / vn->sc_secsize;
933 break;
934 case DKIOCGETMAXBLOCKCOUNTWRITE:
935 *o = ioattr.io_maxwritecnt / vn->sc_secsize;
936 break;
937 case DKIOCGETMAXBYTECOUNTREAD:
938 *o = ioattr.io_maxreadcnt;
939 break;
940 case DKIOCGETMAXBYTECOUNTWRITE:
941 *o = ioattr.io_maxwritecnt;
942 break;
943 case DKIOCGETMAXSEGMENTCOUNTREAD:
944 *o = ioattr.io_segreadcnt;
945 break;
946 case DKIOCGETMAXSEGMENTCOUNTWRITE:
947 *o = ioattr.io_segwritecnt;
948 break;
949 case DKIOCGETMAXSEGMENTBYTECOUNTREAD:
950 *o = ioattr.io_maxsegreadsize;
951 break;
952 case DKIOCGETMAXSEGMENTBYTECOUNTWRITE:
953 *o = ioattr.io_maxsegwritesize;
954 break;
955 case DKIOCGETBLOCKSIZE:
956 *f = vn->sc_secsize;
957 break;
958 case DKIOCSETBLOCKSIZE:
959 if (is_char) {
960 /* can only set block size on block device */
961 error = ENODEV;
962 break;
963 }
964 if (*f < DEV_BSIZE) {
965 error = EINVAL;
966 break;
967 }
968 if (vn->sc_shadow_vp != NULL) {
969 if (*f == (unsigned)vn->sc_secsize) {
970 break;
971 }
972 /* can't change the block size if already shadowing */
973 error = EBUSY;
974 break;
975 }
976 vn->sc_secsize = *f;
977 /* recompute the size in terms of the new blocksize */
978 vn->sc_size = vn->sc_fsize / vn->sc_secsize;
979 break;
980 case DKIOCISWRITABLE:
981 *f = 1;
982 break;
983 case DKIOCGETBLOCKCOUNT:
984 *o = vn->sc_size;
985 break;
986 #ifdef __LP64__
987 case VNIOCSHADOW32:
988 case VNIOCSHADOW:
989 #else
990 case VNIOCSHADOW:
991 case VNIOCSHADOW64:
992 #endif
993 if (vn->sc_shadow_vp != NULL) {
994 error = EBUSY;
995 break;
996 }
997 if (vn->sc_vp == NULL) {
998 /* much be attached before we can shadow */
999 error = EINVAL;
1000 break;
1001 }
1002 if (!proc_is64bit(p)) {
1003 /* downstream code expects LP64 version of vn_ioctl structure */
1004 vn_ioctl_to_64((struct vn_ioctl_32 *)viop, &user_vnio);
1005 viop = &user_vnio;
1006 }
1007 if (viop->vn_file == USER_ADDR_NULL) {
1008 error = EINVAL;
1009 break;
1010 }
1011 error = vniocattach_shadow(vn, viop, dev, 0, p);
1012 break;
1013
1014 #ifdef __LP64__
1015 case VNIOCATTACH32:
1016 case VNIOCATTACH:
1017 #else
1018 case VNIOCATTACH:
1019 case VNIOCATTACH64:
1020 #endif
1021 if (is_char) {
1022 /* attach only on block device */
1023 error = ENODEV;
1024 break;
1025 }
1026 if (vn->sc_flags & VNF_INITED) {
1027 error = EBUSY;
1028 break;
1029 }
1030 if (!proc_is64bit(p)) {
1031 /* downstream code expects LP64 version of vn_ioctl structure */
1032 vn_ioctl_to_64((struct vn_ioctl_32 *)viop, &user_vnio);
1033 viop = &user_vnio;
1034 }
1035 if (viop->vn_file == USER_ADDR_NULL) {
1036 error = EINVAL;
1037 break;
1038 }
1039 error = vniocattach_file(vn, viop, dev, 0, p);
1040 break;
1041
1042 #ifdef __LP64__
1043 case VNIOCDETACH32:
1044 case VNIOCDETACH:
1045 #else
1046 case VNIOCDETACH:
1047 case VNIOCDETACH64:
1048 #endif
1049 if (is_char) {
1050 /* detach only on block device */
1051 error = ENODEV;
1052 break;
1053 }
1054 /* Note: spec_open won't open a mounted block device */
1055
1056 /*
1057 * XXX handle i/o in progress. Return EBUSY, or wait, or
1058 * flush the i/o.
1059 * XXX handle multiple opens of the device. Return EBUSY,
1060 * or revoke the fd's.
1061 * How are these problems handled for removable and failing
1062 * hardware devices? (Hint: They are not)
1063 */
1064 vnclear(vn, &context);
1065 break;
1066
1067 case VNIOCGSET:
1068 vn_options |= *f;
1069 *f = vn_options;
1070 break;
1071
1072 case VNIOCGCLEAR:
1073 vn_options &= ~(*f);
1074 *f = vn_options;
1075 break;
1076
1077 case VNIOCUSET:
1078 vn->sc_options |= *f;
1079 *f = vn->sc_options;
1080 break;
1081
1082 case VNIOCUCLEAR:
1083 vn->sc_options &= ~(*f);
1084 *f = vn->sc_options;
1085 break;
1086
1087 default:
1088 error = ENOTTY;
1089 break;
1090 }
1091 done:
1092 return error;
1093 }
1094
1095 static int
1096 vnioctl_chr(dev_t dev, u_long cmd, caddr_t data, int flag, proc_t p)
1097 {
1098 return vnioctl(dev, cmd, data, flag, p, TRUE);
1099 }
1100
1101 static int
1102 vnioctl_blk(dev_t dev, u_long cmd, caddr_t data, int flag, proc_t p)
1103 {
1104 return vnioctl(dev, cmd, data, flag, p, FALSE);
1105 }
1106
1107 /*
1108 * vniocattach_file:
1109 *
1110 * Attach a file to a VN partition. Return the size in the vn_size
1111 * field.
1112 */
1113
1114 static int
1115 vniocattach_file(struct vn_softc *vn,
1116 struct vn_ioctl_64 *vniop,
1117 dev_t dev,
1118 int in_kernel,
1119 proc_t p)
1120 {
1121 dev_t cdev;
1122 vfs_context_t ctx = vfs_context_current();
1123 kauth_cred_t cred;
1124 struct nameidata nd;
1125 off_t file_size;
1126 int error, flags;
1127
1128 flags = FREAD | FWRITE;
1129 if (in_kernel) {
1130 NDINIT(&nd, LOOKUP, OP_OPEN, FOLLOW, UIO_SYSSPACE, vniop->vn_file, ctx);
1131 } else {
1132 NDINIT(&nd, LOOKUP, OP_OPEN, FOLLOW,
1133 (IS_64BIT_PROCESS(p) ? UIO_USERSPACE64 : UIO_USERSPACE32),
1134 vniop->vn_file, ctx);
1135 }
1136 /* vn_open gives both long- and short-term references */
1137 error = vn_open(&nd, flags, 0);
1138 if (error) {
1139 if (error != EACCES && error != EPERM && error != EROFS) {
1140 return error;
1141 }
1142 flags &= ~FWRITE;
1143 if (in_kernel) {
1144 NDINIT(&nd, LOOKUP, OP_OPEN, FOLLOW, UIO_SYSSPACE,
1145 vniop->vn_file, ctx);
1146 } else {
1147 NDINIT(&nd, LOOKUP, OP_OPEN, FOLLOW,
1148 (IS_64BIT_PROCESS(p) ? UIO_USERSPACE64 : UIO_USERSPACE32),
1149 vniop->vn_file, ctx);
1150 }
1151 error = vn_open(&nd, flags, 0);
1152 if (error) {
1153 return error;
1154 }
1155 }
1156 if (nd.ni_vp->v_type != VREG) {
1157 error = EINVAL;
1158 } else {
1159 error = vnode_size(nd.ni_vp, &file_size, ctx);
1160 }
1161 if (error != 0) {
1162 (void) vn_close(nd.ni_vp, flags, ctx);
1163 vnode_put(nd.ni_vp);
1164 return error;
1165 }
1166 cred = kauth_cred_proc_ref(p);
1167 nd.ni_vp->v_flag |= VNOCACHE_DATA;
1168 error = setcred(nd.ni_vp, cred);
1169 if (error) {
1170 (void)vn_close(nd.ni_vp, flags, ctx);
1171 vnode_put(nd.ni_vp);
1172 kauth_cred_unref(&cred);
1173 return error;
1174 }
1175 vn->sc_secsize = DEV_BSIZE;
1176 vn->sc_fsize = file_size;
1177 vn->sc_size = file_size / vn->sc_secsize;
1178 vn->sc_vp = nd.ni_vp;
1179 vn->sc_vid = vnode_vid(nd.ni_vp);
1180 vn->sc_open_flags = flags;
1181 vn->sc_cred = cred;
1182 cdev = makedev(vndevice_cdev_major, minor(dev));
1183 vn->sc_cdev = devfs_make_node(cdev, DEVFS_CHAR,
1184 UID_ROOT, GID_OPERATOR,
1185 0600, "rvn%d",
1186 minor(dev));
1187 vn->sc_flags |= VNF_INITED;
1188 if (flags == FREAD) {
1189 vn->sc_flags |= VNF_READONLY;
1190 }
1191 /* lose the short-term reference */
1192 vnode_put(nd.ni_vp);
1193 return 0;
1194 }
1195
1196 static int
1197 vniocattach_shadow(struct vn_softc *vn, struct vn_ioctl_64 *vniop,
1198 __unused dev_t dev, int in_kernel, proc_t p)
1199 {
1200 vfs_context_t ctx = vfs_context_current();
1201 struct nameidata nd;
1202 int error, flags;
1203 shadow_map_t * map;
1204 off_t file_size;
1205
1206 flags = FREAD | FWRITE;
1207 if (in_kernel) {
1208 NDINIT(&nd, LOOKUP, OP_OPEN, FOLLOW, UIO_SYSSPACE, vniop->vn_file, ctx);
1209 } else {
1210 NDINIT(&nd, LOOKUP, OP_OPEN, FOLLOW,
1211 (IS_64BIT_PROCESS(p) ? UIO_USERSPACE64 : UIO_USERSPACE32),
1212 vniop->vn_file, ctx);
1213 }
1214 /* vn_open gives both long- and short-term references */
1215 error = vn_open(&nd, flags, 0);
1216 if (error) {
1217 /* shadow MUST be writable! */
1218 return error;
1219 }
1220 if (nd.ni_vp->v_type != VREG
1221 || (error = vnode_size(nd.ni_vp, &file_size, ctx))) {
1222 (void)vn_close(nd.ni_vp, flags, ctx);
1223 vnode_put(nd.ni_vp);
1224 return error ? error : EINVAL;
1225 }
1226 map = shadow_map_create(vn->sc_fsize, file_size,
1227 0, vn->sc_secsize);
1228 if (map == NULL) {
1229 (void)vn_close(nd.ni_vp, flags, ctx);
1230 vnode_put(nd.ni_vp);
1231 vn->sc_shadow_vp = NULL;
1232 return ENOMEM;
1233 }
1234 vn->sc_shadow_vp = nd.ni_vp;
1235 vn->sc_shadow_vid = vnode_vid(nd.ni_vp);
1236 vn->sc_shadow_vp->v_flag |= VNOCACHE_DATA;
1237 vn->sc_shadow_map = map;
1238 vn->sc_flags &= ~VNF_READONLY; /* we're now read/write */
1239
1240 /* lose the short-term reference */
1241 vnode_put(nd.ni_vp);
1242 return 0;
1243 }
1244
1245 int
1246 vndevice_root_image(char * path, char devname[], dev_t * dev_p)
1247 {
1248 int error = 0;
1249 struct vn_softc * vn;
1250 struct vn_ioctl_64 vnio;
1251
1252 vnio.vn_file = CAST_USER_ADDR_T(path);
1253 vnio.vn_size = 0;
1254
1255 vn = vn_table + ROOT_IMAGE_UNIT;
1256 *dev_p = makedev(vndevice_bdev_major,
1257 ROOT_IMAGE_UNIT);
1258 snprintf(devname, 16, "vn%d", ROOT_IMAGE_UNIT);
1259 error = vniocattach_file(vn, &vnio, *dev_p, 1, current_proc());
1260 return error;
1261 }
1262
1263 /*
1264 * Duplicate the current processes' credentials. Since we are called only
1265 * as the result of a SET ioctl and only root can do that, any future access
1266 * to this "disk" is essentially as root. Note that credentials may change
1267 * if some other uid can write directly to the mapped file (NFS).
1268 */
1269 static int
1270 setcred(struct vnode * vp, kauth_cred_t cred)
1271 {
1272 char *tmpbuf;
1273 int error = 0;
1274 struct vfs_context context;
1275
1276 /*
1277 * Horrible kludge to establish credentials for NFS XXX.
1278 */
1279 context.vc_thread = current_thread();
1280 context.vc_ucred = cred;
1281 tmpbuf = _MALLOC(DEV_BSIZE, M_TEMP, M_WAITOK);
1282 error = file_io(vp, &context, UIO_READ, tmpbuf, 0, DEV_BSIZE, NULL);
1283 FREE(tmpbuf, M_TEMP);
1284 return error;
1285 }
1286
1287 void
1288 vnclear(struct vn_softc *vn, vfs_context_t ctx)
1289 {
1290 if (vn->sc_vp != NULL) {
1291 /* release long-term reference */
1292 (void)vn_close(vn->sc_vp, vn->sc_open_flags, ctx);
1293 vn->sc_vp = NULL;
1294 }
1295 if (vn->sc_shadow_vp != NULL) {
1296 /* release long-term reference */
1297 (void)vn_close(vn->sc_shadow_vp, FREAD | FWRITE, ctx);
1298 vn->sc_shadow_vp = NULL;
1299 }
1300 if (vn->sc_shadow_map != NULL) {
1301 shadow_map_free(vn->sc_shadow_map);
1302 vn->sc_shadow_map = NULL;
1303 }
1304 vn->sc_flags &= ~(VNF_INITED | VNF_READONLY);
1305 if (vn->sc_cred) {
1306 kauth_cred_unref(&vn->sc_cred);
1307 }
1308 vn->sc_size = 0;
1309 vn->sc_fsize = 0;
1310 if (vn->sc_cdev) {
1311 devfs_remove(vn->sc_cdev);
1312 vn->sc_cdev = NULL;
1313 }
1314 }
1315
1316 static int
1317 vnsize(dev_t dev)
1318 {
1319 int secsize;
1320 struct vn_softc *vn;
1321 int unit;
1322
1323 unit = vnunit(dev);
1324 if (vnunit(dev) >= NVNDEVICE) {
1325 return -1;
1326 }
1327
1328 vn = vn_table + unit;
1329 if ((vn->sc_flags & VNF_INITED) == 0) {
1330 secsize = -1;
1331 } else {
1332 secsize = vn->sc_secsize;
1333 }
1334
1335 return secsize;
1336 }
1337
1338 #define CDEV_MAJOR -1
1339 #define BDEV_MAJOR -1
1340 static int vndevice_inited = 0;
1341
1342 void
1343 vndevice_init(void)
1344 {
1345 if (vndevice_inited) {
1346 return;
1347 }
1348
1349 vndevice_do_init();
1350 }
1351
1352 static void
1353 vndevice_do_init( void )
1354 {
1355 int i;
1356
1357 vndevice_bdev_major = bdevsw_add(BDEV_MAJOR, &vn_bdevsw);
1358
1359 if (vndevice_bdev_major < 0) {
1360 printf("vndevice_init: bdevsw_add() returned %d\n",
1361 vndevice_bdev_major);
1362 return;
1363 }
1364 vndevice_cdev_major = cdevsw_add_with_bdev(CDEV_MAJOR, &vn_cdevsw,
1365 vndevice_bdev_major);
1366 if (vndevice_cdev_major < 0) {
1367 printf("vndevice_init: cdevsw_add() returned %d\n",
1368 vndevice_cdev_major);
1369 return;
1370 }
1371 for (i = 0; i < NVNDEVICE; i++) {
1372 dev_t dev = makedev(vndevice_bdev_major, i);
1373 vn_table[i].sc_bdev = devfs_make_node(dev, DEVFS_BLOCK,
1374 UID_ROOT, GID_OPERATOR,
1375 0600, "vn%d",
1376 i);
1377 if (vn_table[i].sc_bdev == NULL) {
1378 printf("vninit: devfs_make_node failed!\n");
1379 }
1380 }
1381 }
1382
1383 static void
1384 vn_ioctl_to_64(struct vn_ioctl_32 *from, struct vn_ioctl_64 *to)
1385 {
1386 to->vn_file = CAST_USER_ADDR_T(from->vn_file);
1387 to->vn_size = from->vn_size;
1388 to->vn_control = from->vn_control;
1389 }
1390
1391 #endif /* NVNDEVICE */
mirror of XNU