1 /* $NetBSD: v7fs_vnops.c,v 1.21 2015/04/20 23:03:08 riastradh Exp $ */
2
3 /*-
4 * Copyright (c) 2004, 2011 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by UCHIYAMA Yasushi.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: v7fs_vnops.c,v 1.21 2015/04/20 23:03:08 riastradh Exp $");
34 #if defined _KERNEL_OPT
35 #include "opt_v7fs.h"
36 #endif
37
38 #include <sys/param.h>
39 #include <sys/kernel.h>
40 #include <sys/resource.h>
41 #include <sys/vnode.h>
42 #include <sys/namei.h>
43 #include <sys/dirent.h>
44 #include <sys/kmem.h>
45 #include <sys/lockf.h>
46 #include <sys/unistd.h>
47 #include <sys/fcntl.h>
48 #include <sys/kauth.h>
49 #include <sys/buf.h>
50 #include <sys/stat.h> /*APPEND */
51 #include <miscfs/genfs/genfs.h>
52
53 #include <fs/v7fs/v7fs.h>
54 #include <fs/v7fs/v7fs_impl.h>
55 #include <fs/v7fs/v7fs_inode.h>
56 #include <fs/v7fs/v7fs_dirent.h>
57 #include <fs/v7fs/v7fs_file.h>
58 #include <fs/v7fs/v7fs_datablock.h>
59 #include <fs/v7fs/v7fs_extern.h>
60
61 #ifdef V7FS_VNOPS_DEBUG
62 #define DPRINTF(fmt, args...) printf("%s: " fmt, __func__, ##args)
63 #else
64 #define DPRINTF(arg...) ((void)0)
65 #endif
66
67 static v7fs_mode_t vtype_to_v7fs_mode(enum vtype);
68 static uint8_t v7fs_mode_to_d_type(v7fs_mode_t);
69
70 static v7fs_mode_t
vtype_to_v7fs_mode(enum vtype type)71 vtype_to_v7fs_mode(enum vtype type)
72 {
73 /* Convert Vnode types to V7FS types (sys/vnode.h)*/
74 v7fs_mode_t table[] = { 0, V7FS_IFREG, V7FS_IFDIR, V7FS_IFBLK,
75 V7FS_IFCHR, V7FSBSD_IFLNK, V7FSBSD_IFSOCK,
76 V7FSBSD_IFFIFO };
77 return table[type];
78 }
79
80 static uint8_t
v7fs_mode_to_d_type(v7fs_mode_t mode)81 v7fs_mode_to_d_type(v7fs_mode_t mode)
82 {
83 /* Convert V7FS types to dirent d_type (sys/dirent.h)*/
84
85 return (mode & V7FS_IFMT) >> 12;
86 }
87
88 int
v7fs_lookup(void * v)89 v7fs_lookup(void *v)
90 {
91 struct vop_lookup_v2_args /* {
92 struct vnode *a_dvp;
93 struct vnode **a_vpp;
94 struct componentname *a_cnp;
95 } */ *a = v;
96 struct vnode *dvp = a->a_dvp;
97 struct v7fs_node *parent_node = dvp->v_data;
98 struct v7fs_inode *parent = &parent_node->inode;
99 struct v7fs_self *fs = parent_node->v7fsmount->core;/* my filesystem */
100 struct vnode *vpp;
101 struct componentname *cnp = a->a_cnp;
102 int nameiop = cnp->cn_nameiop;
103 const char *name = cnp->cn_nameptr;
104 int namelen = cnp->cn_namelen;
105 int flags = cnp->cn_flags;
106 bool isdotdot = flags & ISDOTDOT;
107 bool islastcn = flags & ISLASTCN;
108 v7fs_ino_t ino;
109 int error;
110 #ifdef V7FS_VNOPS_DEBUG
111 const char *opname[] = { "LOOKUP", "CREATE", "DELETE", "RENAME" };
112 #endif
113 DPRINTF("'%s' op=%s flags=%d parent=%d %o %dbyte\n", name,
114 opname[nameiop], cnp->cn_flags, parent->inode_number, parent->mode,
115 parent->filesize);
116
117 *a->a_vpp = 0;
118
119 /* Check directory permission for search */
120 if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred))) {
121 DPRINTF("***perm.\n");
122 return error;
123 }
124
125 /* Deny last component write operation on a read-only mount */
126 if (islastcn && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
127 (nameiop == DELETE || nameiop == RENAME)) {
128 DPRINTF("***ROFS.\n");
129 return EROFS;
130 }
131
132 /* No lookup on removed directory */
133 if (v7fs_inode_nlink(parent) == 0)
134 return ENOENT;
135
136 /* "." */
137 if (namelen == 1 && name[0] == '.') {
138 if ((nameiop == RENAME) && islastcn) {
139 return EISDIR; /* t_vnops rename_dir(3) */
140 }
141 vref(dvp); /* v_usecount++ */
142 *a->a_vpp = dvp;
143 DPRINTF("done.(.)\n");
144 return 0;
145 }
146
147 /* ".." and reguler file. */
148 if ((error = v7fs_file_lookup_by_name(fs, parent, name, &ino))) {
149 /* Not found. Tell this entry be able to allocate. */
150 if (((nameiop == CREATE) || (nameiop == RENAME)) && islastcn) {
151 /* Check directory permission to allocate. */
152 if ((error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred))) {
153 DPRINTF("access denied. (%s)\n", name);
154 return error;
155 }
156 DPRINTF("EJUSTRETURN op=%d (%s)\n", nameiop, name);
157 return EJUSTRETURN;
158 }
159 DPRINTF("lastcn=%d\n", flags & ISLASTCN);
160 return error;
161 }
162
163 if ((nameiop == DELETE) && islastcn) {
164 if ((error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred))) {
165 DPRINTF("access denied. (%s)\n", name);
166 return error;
167 }
168 }
169
170 /* Entry found. Allocate v-node */
171 // Check permissions?
172 vpp = 0;
173 if (isdotdot) {
174 VOP_UNLOCK(dvp); /* preserve reference count. (not vput) */
175 }
176 DPRINTF("enter vget\n");
177 if ((error = v7fs_vget(dvp->v_mount, ino, &vpp))) {
178 DPRINTF("***can't get vnode.\n");
179 return error;
180 }
181 DPRINTF("exit vget\n");
182 if (isdotdot) {
183 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
184 }
185 if (vpp != dvp)
186 VOP_UNLOCK(vpp);
187 *a->a_vpp = vpp;
188 DPRINTF("done.(%s)\n", name);
189
190 return 0;
191 }
192
193 int
v7fs_create(void * v)194 v7fs_create(void *v)
195 {
196 struct vop_create_v3_args /* {
197 struct vnode *a_dvp;
198 struct vnode **a_vpp;
199 struct componentname *a_cnp;
200 struct vattr *a_vap;
201 } */ *a = v;
202 struct v7fs_node *parent_node = a->a_dvp->v_data;
203 struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
204 struct v7fs_self *fs = v7fsmount->core;
205 struct mount *mp = v7fsmount->mountp;
206 struct v7fs_fileattr attr;
207 struct vattr *va = a->a_vap;
208 kauth_cred_t cr = a->a_cnp->cn_cred;
209 v7fs_ino_t ino;
210 int error = 0;
211
212 DPRINTF("%s parent#%d\n", a->a_cnp->cn_nameptr,
213 parent_node->inode.inode_number);
214 KDASSERT((va->va_type == VREG) || (va->va_type == VSOCK));
215
216 memset(&attr, 0, sizeof(attr));
217 attr.uid = kauth_cred_geteuid(cr);
218 attr.gid = kauth_cred_getegid(cr);
219 attr.mode = va->va_mode | vtype_to_v7fs_mode (va->va_type);
220 attr.device = 0;
221
222 /* Allocate disk entry. and register its entry to parent directory. */
223 if ((error = v7fs_file_allocate(fs, &parent_node->inode,
224 a->a_cnp->cn_nameptr, &attr, &ino))) {
225 DPRINTF("v7fs_file_allocate failed.\n");
226 return error;
227 }
228 /* Sync dirent size change. */
229 uvm_vnp_setsize(a->a_dvp, v7fs_inode_filesize(&parent_node->inode));
230
231 /* Get myself vnode. */
232 *a->a_vpp = 0;
233 if ((error = v7fs_vget(mp, ino, a->a_vpp))) {
234 DPRINTF("v7fs_vget failed.\n");
235 return error;
236 }
237
238 /* Scheduling update time. real update by v7fs_update */
239 struct v7fs_node *newnode = (*a->a_vpp)->v_data;
240 newnode->update_ctime = true;
241 newnode->update_mtime = true;
242 newnode->update_atime = true;
243 DPRINTF("allocated %s->#%d\n", a->a_cnp->cn_nameptr, ino);
244
245 if (error == 0)
246 VOP_UNLOCK(*a->a_vpp);
247
248 return error;
249 }
250
251 int
v7fs_mknod(void * v)252 v7fs_mknod(void *v)
253 {
254 struct vop_mknod_v3_args /* {
255 struct vnode *a_dvp;
256 struct vnode **a_vpp;
257 struct componentname *a_cnp;
258 struct vattr *a_vap;
259 } */ *a = v;
260 struct componentname *cnp = a->a_cnp;
261 kauth_cred_t cr = cnp->cn_cred;
262 struct vnode *dvp = a->a_dvp;
263 struct vattr *va = a->a_vap;
264 struct v7fs_node *parent_node = dvp->v_data;
265 struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
266 struct v7fs_self *fs = v7fsmount->core;
267 struct mount *mp = v7fsmount->mountp;
268 struct v7fs_fileattr attr;
269
270 v7fs_ino_t ino;
271 int error = 0;
272
273 DPRINTF("%s %06o %lx %d\n", cnp->cn_nameptr, va->va_mode,
274 (long)va->va_rdev, va->va_type);
275 memset(&attr, 0, sizeof(attr));
276 attr.uid = kauth_cred_geteuid(cr);
277 attr.gid = kauth_cred_getegid(cr);
278 attr.mode = va->va_mode | vtype_to_v7fs_mode(va->va_type);
279 attr.device = va->va_rdev;
280
281 if ((error = v7fs_file_allocate(fs, &parent_node->inode,
282 cnp->cn_nameptr, &attr, &ino)))
283 return error;
284 /* Sync dirent size change. */
285 uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));
286
287 if ((error = v7fs_vget(mp, ino, a->a_vpp))) {
288 DPRINTF("can't get vnode.\n");
289 return error;
290 }
291 struct v7fs_node *newnode = (*a->a_vpp)->v_data;
292 newnode->update_ctime = true;
293 newnode->update_mtime = true;
294 newnode->update_atime = true;
295
296 if (error == 0)
297 VOP_UNLOCK(*a->a_vpp);
298
299 return error;
300 }
301
302 int
v7fs_open(void * v)303 v7fs_open(void *v)
304 {
305 struct vop_open_args /* {
306 struct vnode *a_vp;
307 int a_mode;
308 kauth_cred_t a_cred;
309 } */ *a = v;
310
311 struct vnode *vp = a->a_vp;
312 struct v7fs_node *v7node = vp->v_data;
313 struct v7fs_inode *inode = &v7node->inode;
314
315 DPRINTF("inode %d\n", inode->inode_number);
316 /* Append mode file pointer is managed by kernel. */
317 if (inode->append_mode &&
318 ((a->a_mode & (FWRITE | O_APPEND)) == FWRITE)) {
319 DPRINTF("file is already opened by append mode.\n");
320 return EPERM;
321 }
322
323 return 0;
324 }
325
326 int
v7fs_close(void * v)327 v7fs_close(void *v)
328 {
329 struct vop_close_args /* {
330 struct vnodeop_desc *a_desc;
331 struct vnode *a_vp;
332 int a_fflag;
333 kauth_cred_t a_cred;
334 } */ *a = v;
335 struct vnode *vp = a->a_vp;
336 #ifdef V7FS_VNOPS_DEBUG
337 struct v7fs_node *v7node = vp->v_data;
338 struct v7fs_inode *inode = &v7node->inode;
339 #endif
340 DPRINTF("#%d (i)%dbyte (v)%zubyte\n", inode->inode_number,
341 v7fs_inode_filesize(inode), vp->v_size);
342
343 /* Update timestamp */
344 v7fs_update(vp, 0, 0, UPDATE_WAIT);
345
346 return 0;
347 }
348
349 static int
v7fs_check_possible(struct vnode * vp,struct v7fs_node * v7node,mode_t mode)350 v7fs_check_possible(struct vnode *vp, struct v7fs_node *v7node,
351 mode_t mode)
352 {
353
354 if (!(mode & VWRITE))
355 return 0;
356
357 switch (vp->v_type) {
358 default:
359 /* special file is always writable. */
360 return 0;
361 case VDIR:
362 case VLNK:
363 case VREG:
364 break;
365 }
366
367 return vp->v_mount->mnt_flag & MNT_RDONLY ? EROFS : 0;
368 }
369
370 static int
v7fs_check_permitted(struct vnode * vp,struct v7fs_node * v7node,mode_t mode,kauth_cred_t cred)371 v7fs_check_permitted(struct vnode *vp, struct v7fs_node *v7node,
372 mode_t mode, kauth_cred_t cred)
373 {
374
375 struct v7fs_inode *inode = &v7node->inode;
376
377 return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(mode,
378 vp->v_type, inode->mode), vp, NULL, genfs_can_access(vp->v_type,
379 inode->mode, inode->uid, inode->gid, mode, cred));
380 }
381
382 int
v7fs_access(void * v)383 v7fs_access(void *v)
384 {
385 struct vop_access_args /* {
386 struct vnode *a_vp;
387 int a_mode;
388 kauth_cred_t a_cred;
389 } */ *ap = v;
390 struct vnode *vp = ap->a_vp;
391 struct v7fs_node *v7node = vp->v_data;
392 int error;
393
394 error = v7fs_check_possible(vp, v7node, ap->a_mode);
395 if (error)
396 return error;
397
398 error = v7fs_check_permitted(vp, v7node, ap->a_mode, ap->a_cred);
399
400 return error;
401 }
402
403 int
v7fs_getattr(void * v)404 v7fs_getattr(void *v)
405 {
406 struct vop_getattr_args /* {
407 struct vnode *a_vp;
408 struct vattr *a_vap;
409 kauth_cred_t a_cred;
410 } */ *ap = v;
411 struct vnode *vp = ap->a_vp;
412 struct v7fs_node *v7node = vp->v_data;
413 struct v7fs_inode *inode = &v7node->inode;
414 struct v7fs_mount *v7fsmount = v7node->v7fsmount;
415 struct vattr *vap = ap->a_vap;
416
417 DPRINTF("\n");
418 vap->va_type = vp->v_type;
419 vap->va_mode = inode->mode;
420 vap->va_nlink = inode->nlink;
421 vap->va_uid = inode->uid;
422 vap->va_gid = inode->gid;
423 vap->va_fsid = v7fsmount->devvp->v_rdev;
424 vap->va_fileid = inode->inode_number;
425 vap->va_size = vp->v_size;
426 if (vp->v_type == VLNK) {
427 /* Ajust for trailing NUL. */
428 KASSERT(vap->va_size > 0);
429 vap->va_size -= 1;
430 }
431 vap->va_atime.tv_sec = inode->atime;
432 vap->va_mtime.tv_sec = inode->mtime;
433 vap->va_ctime.tv_sec = inode->ctime;
434 vap->va_birthtime.tv_sec = 0;
435 vap->va_gen = 1;
436 vap->va_flags = inode->append_mode ? SF_APPEND : 0;
437 vap->va_rdev = inode->device;
438 vap->va_bytes = vap->va_size; /* No sparse support. */
439 vap->va_filerev = 0;
440 vap->va_vaflags = 0;
441 /* PAGE_SIZE is larger than sizeof(struct dirent). OK.
442 getcwd_scandir()@vfs_getcwd.c */
443 vap->va_blocksize = PAGE_SIZE;
444
445 return 0;
446 }
447
448 int
v7fs_setattr(void * v)449 v7fs_setattr(void *v)
450 {
451 struct vop_setattr_args /* {
452 struct vnode *a_vp;
453 struct vattr *a_vap;
454 kauth_cred_t a_cred;
455 struct proc *p;
456 } */ *ap = v;
457 struct vnode *vp = ap->a_vp;
458 struct vattr *vap = ap->a_vap;
459 struct v7fs_node *v7node = vp->v_data;
460 struct v7fs_self *fs = v7node->v7fsmount->core;
461 struct v7fs_inode *inode = &v7node->inode;
462 kauth_cred_t cred = ap->a_cred;
463 struct timespec *acc, *mod;
464 int error = 0;
465 acc = mod = NULL;
466
467 DPRINTF("\n");
468
469 if (vp->v_mount->mnt_flag & MNT_RDONLY) {
470 switch (vp->v_type) {
471 default:
472 /* special file is always writable. */
473 break;
474 case VDIR:
475 case VLNK:
476 case VREG:
477 DPRINTF("read-only mount\n");
478 return EROFS;
479 }
480 }
481
482 if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
483 (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
484 (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
485 ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
486 DPRINTF("invalid request\n");
487 return EINVAL;
488 }
489 /* File pointer mode. */
490 if (vap->va_flags != VNOVAL) {
491 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_FLAGS,
492 vp, NULL, genfs_can_chflags(cred, vp->v_type, inode->uid,
493 false));
494 if (error)
495 return error;
496 inode->append_mode = vap->va_flags & SF_APPEND;
497 }
498
499 /* File size change. */
500 if ((vap->va_size != VNOVAL) && (vp->v_type == VREG)) {
501 error = v7fs_datablock_size_change(fs, vap->va_size, inode);
502 if (error == 0)
503 uvm_vnp_setsize(vp, vap->va_size);
504 }
505 uid_t uid = inode->uid;
506 gid_t gid = inode->gid;
507
508 if (vap->va_uid != (uid_t)VNOVAL) {
509 uid = vap->va_uid;
510 error = kauth_authorize_vnode(cred,
511 KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL,
512 genfs_can_chown(cred, inode->uid, inode->gid, uid,
513 gid));
514 if (error)
515 return error;
516 inode->uid = uid;
517 }
518 if (vap->va_gid != (uid_t)VNOVAL) {
519 gid = vap->va_gid;
520 error = kauth_authorize_vnode(cred,
521 KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL,
522 genfs_can_chown(cred, inode->uid, inode->gid, uid,
523 gid));
524 if (error)
525 return error;
526 inode->gid = gid;
527 }
528 if (vap->va_mode != (mode_t)VNOVAL) {
529 mode_t mode = vap->va_mode;
530 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY,
531 vp, NULL, genfs_can_chmod(vp->v_type, cred, inode->uid, inode->gid,
532 mode));
533 if (error) {
534 return error;
535 }
536 v7fs_inode_chmod(inode, mode);
537 }
538 if ((vap->va_atime.tv_sec != VNOVAL) ||
539 (vap->va_mtime.tv_sec != VNOVAL) ||
540 (vap->va_ctime.tv_sec != VNOVAL)) {
541 error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp,
542 NULL, genfs_can_chtimes(vp, vap->va_vaflags, inode->uid,
543 cred));
544 if (error)
545 return error;
546
547 if (vap->va_atime.tv_sec != VNOVAL) {
548 acc = &vap->va_atime;
549 }
550 if (vap->va_mtime.tv_sec != VNOVAL) {
551 mod = &vap->va_mtime;
552 v7node->update_mtime = true;
553 }
554 if (vap->va_ctime.tv_sec != VNOVAL) {
555 v7node->update_ctime = true;
556 }
557 }
558
559 v7node->update_atime = true;
560 v7fs_update(vp, acc, mod, 0);
561
562 return error;
563 }
564
565 int
v7fs_read(void * v)566 v7fs_read(void *v)
567 {
568 struct vop_read_args /* {
569 struct vnode *a_vp;
570 struct uio *a_uio;
571 int a_ioflag;
572 kauth_cred_t a_cred;
573 } */ *a = v;
574 struct vnode *vp = a->a_vp;
575 struct uio *uio = a->a_uio;
576 struct v7fs_node *v7node = vp->v_data;
577 struct v7fs_inode *inode = &v7node->inode;
578 vsize_t sz, filesz = v7fs_inode_filesize(inode);
579 const int advice = IO_ADV_DECODE(a->a_ioflag);
580 int error = 0;
581
582 DPRINTF("type=%d inode=%d\n", vp->v_type, v7node->inode.inode_number);
583
584 while (uio->uio_resid > 0) {
585 if ((sz = MIN(filesz - uio->uio_offset, uio->uio_resid)) == 0)
586 break;
587
588 error = ubc_uiomove(&vp->v_uobj, uio, sz, advice, UBC_READ |
589 UBC_PARTIALOK | UBC_UNMAP_FLAG(v));
590 if (error) {
591 break;
592 }
593 DPRINTF("read %zubyte\n", sz);
594 }
595 v7node->update_atime = true;
596
597 return error;
598 }
599
600 int
v7fs_write(void * v)601 v7fs_write(void *v)
602 {
603 struct vop_write_args /* {
604 struct vnode *a_vp;
605 struct uio *a_uio;
606 int a_ioflag;
607 kauth_cred_t a_cred;
608 } */ *a = v;
609 struct vnode *vp = a->a_vp;
610 struct uio *uio = a->a_uio;
611 int advice = IO_ADV_DECODE(a->a_ioflag);
612 struct v7fs_node *v7node = vp->v_data;
613 struct v7fs_inode *inode = &v7node->inode;
614 struct v7fs_self *fs = v7node->v7fsmount->core;
615 vsize_t sz;
616 int error = 0;
617
618 if (uio->uio_resid == 0)
619 return 0;
620
621 sz = v7fs_inode_filesize(inode);
622 DPRINTF("(i)%ld (v)%zu ofs=%zu + res=%zu = %zu\n", sz, vp->v_size,
623 uio->uio_offset, uio->uio_resid, uio->uio_offset + uio->uio_resid);
624
625 /* Append mode file offset is managed by kernel. */
626 if (a->a_ioflag & IO_APPEND)
627 uio->uio_offset = sz;
628
629 /* If write region is over filesize, expand. */
630 size_t newsize= uio->uio_offset + uio->uio_resid;
631 ssize_t expand = newsize - sz;
632 if (expand > 0) {
633 if ((error = v7fs_datablock_expand(fs, inode, expand)))
634 return error;
635 uvm_vnp_setsize(vp, newsize);
636 }
637
638 while (uio->uio_resid > 0) {
639 sz = uio->uio_resid;
640 if ((error = ubc_uiomove(&vp->v_uobj, uio, sz, advice,
641 UBC_WRITE | UBC_UNMAP_FLAG(v))))
642 break;
643 DPRINTF("write %zubyte\n", sz);
644 }
645 v7node->update_mtime = true;
646
647 return error;
648 }
649
650 int
v7fs_fsync(void * v)651 v7fs_fsync(void *v)
652 {
653 struct vop_fsync_args /* {
654 struct vnode *a_vp;
655 kauth_cred_t a_cred;
656 int a_flags;
657 off_t offlo;
658 off_t offhi;
659 } */ *a = v;
660 struct vnode *vp = a->a_vp;
661 int error, wait;
662
663 DPRINTF("%p\n", a->a_vp);
664 if (a->a_flags & FSYNC_CACHE) {
665 return EOPNOTSUPP;
666 }
667
668 wait = (a->a_flags & FSYNC_WAIT);
669 error = vflushbuf(vp, a->a_flags);
670
671 if (error == 0 && (a->a_flags & FSYNC_DATAONLY) == 0)
672 error = v7fs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0);
673
674 return error;
675 }
676
677 int
v7fs_remove(void * v)678 v7fs_remove(void *v)
679 {
680 struct vop_remove_args /* {
681 struct vnodeop_desc *a_desc;
682 struct vnode * a_dvp;
683 struct vnode * a_vp;
684 struct componentname * a_cnp;
685 } */ *a = v;
686 struct v7fs_node *parent_node = a->a_dvp->v_data;
687 struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
688 struct vnode *vp = a->a_vp;
689 struct vnode *dvp = a->a_dvp;
690 struct v7fs_inode *inode = &((struct v7fs_node *)vp->v_data)->inode;
691 struct v7fs_self *fs = v7fsmount->core;
692 int error = 0;
693
694 DPRINTF("delete %s\n", a->a_cnp->cn_nameptr);
695
696 if (vp->v_type == VDIR) {
697 error = EPERM;
698 goto out;
699 }
700
701 if ((error = v7fs_file_deallocate(fs, &parent_node->inode,
702 a->a_cnp->cn_nameptr))) {
703 DPRINTF("v7fs_file_delete failed.\n");
704 goto out;
705 }
706 error = v7fs_inode_load(fs, inode, inode->inode_number);
707 if (error)
708 goto out;
709 /* Sync dirent size change. */
710 uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));
711
712 out:
713 if (dvp == vp)
714 vrele(vp); /* v_usecount-- of unlocked vp */
715 else
716 vput(vp); /* unlock vp and then v_usecount-- */
717 vput(dvp);
718
719 return error;
720 }
721
722 int
v7fs_link(void * v)723 v7fs_link(void *v)
724 {
725 struct vop_link_v2_args /* {
726 struct vnode *a_dvp;
727 struct vnode *a_vp;
728 struct componentname *a_cnp;
729 } */ *a = v;
730 struct vnode *dvp = a->a_dvp;
731 struct vnode *vp = a->a_vp;
732 struct v7fs_node *parent_node = dvp->v_data;
733 struct v7fs_node *node = vp->v_data;
734 struct v7fs_inode *parent = &parent_node->inode;
735 struct v7fs_inode *p = &node->inode;
736 struct v7fs_self *fs = node->v7fsmount->core;
737 struct componentname *cnp = a->a_cnp;
738 int error = 0;
739
740 DPRINTF("%p\n", vp);
741 /* Lock soruce file */
742 if ((error = vn_lock(vp, LK_EXCLUSIVE))) {
743 DPRINTF("lock failed. %p\n", vp);
744 VOP_ABORTOP(dvp, cnp);
745 goto unlock;
746 }
747 error = v7fs_file_link(fs, parent, p, cnp->cn_nameptr);
748 /* Sync dirent size change. */
749 uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));
750
751 VOP_UNLOCK(vp);
752 unlock:
753 return error;
754 }
755
756 int
v7fs_rename(void * v)757 v7fs_rename(void *v)
758 {
759 struct vop_rename_args /* {
760 struct vnode *a_fdvp; from parent-directory
761 struct vnode *a_fvp; from file
762 struct componentname *a_fcnp;
763 struct vnode *a_tdvp; to parent-directory
764 struct vnode *a_tvp; to file
765 struct componentname *a_tcnp;
766 } */ *a = v;
767 struct vnode *fvp = a->a_fvp;
768 struct vnode *tvp = a->a_tvp;
769 struct vnode *fdvp = a->a_fdvp;
770 struct vnode *tdvp = a->a_tdvp;
771 struct v7fs_node *parent_from = fdvp->v_data;
772 struct v7fs_node *parent_to = tdvp->v_data;
773 struct v7fs_node *v7node = fvp->v_data;
774 struct v7fs_self *fs = v7node->v7fsmount->core;
775 const char *from_name = a->a_fcnp->cn_nameptr;
776 const char *to_name = a->a_tcnp->cn_nameptr;
777 int error;
778
779 DPRINTF("%s->%s %p %p\n", from_name, to_name, fvp, tvp);
780
781 if ((fvp->v_mount != tdvp->v_mount) ||
782 (tvp && (fvp->v_mount != tvp->v_mount))) {
783 error = EXDEV;
784 DPRINTF("cross-device link\n");
785 goto out;
786 }
787 // XXXsource file lock?
788 error = v7fs_file_rename(fs, &parent_from->inode, from_name,
789 &parent_to->inode, to_name);
790 /* 'to file' inode may be changed. (hard-linked and it is cached.)
791 t_vnops rename_reg_nodir */
792 if (error == 0 && tvp) {
793 struct v7fs_inode *inode =
794 &((struct v7fs_node *)tvp->v_data)->inode;
795
796 error = v7fs_inode_load(fs, inode, inode->inode_number);
797 uvm_vnp_setsize(tvp, v7fs_inode_filesize(inode));
798 }
799 /* Sync dirent size change. */
800 uvm_vnp_setsize(tdvp, v7fs_inode_filesize(&parent_to->inode));
801 uvm_vnp_setsize(fdvp, v7fs_inode_filesize(&parent_from->inode));
802 out:
803 if (tvp)
804 vput(tvp); /* locked on entry */
805 if (tdvp == tvp)
806 vrele(tdvp);
807 else
808 vput(tdvp);
809 vrele(fdvp);
810 vrele(fvp);
811
812 return error;
813 }
814
815 int
v7fs_mkdir(void * v)816 v7fs_mkdir(void *v)
817 {
818 struct vop_mkdir_v3_args /* {
819 struct vnode *a_dvp;
820 struct vnode **a_vpp;
821 struct componentname *a_cnp;
822 struct vattr *a_vap;
823 } */ *a = v;
824 struct componentname *cnp = a->a_cnp;
825 kauth_cred_t cr = cnp->cn_cred;
826 struct vnode *dvp = a->a_dvp;
827 struct vattr *va = a->a_vap;
828 struct v7fs_node *parent_node = dvp->v_data;
829 struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
830 struct v7fs_self *fs = v7fsmount->core;
831 struct v7fs_fileattr attr;
832 struct mount *mp = v7fsmount->mountp;
833 v7fs_ino_t ino;
834 int error = 0;
835
836 DPRINTF("\n");
837 memset(&attr, 0, sizeof(attr));
838 attr.uid = kauth_cred_geteuid(cr);
839 attr.gid = kauth_cred_getegid(cr);
840 attr.mode = va->va_mode | vtype_to_v7fs_mode(va->va_type);
841
842 if ((error = v7fs_file_allocate(fs, &parent_node->inode,
843 cnp->cn_nameptr, &attr, &ino)))
844 return error;
845 /* Sync dirent size change. */
846 uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));
847
848 if ((error = v7fs_vget(mp, ino, a->a_vpp))) {
849 DPRINTF("can't get vnode.\n");
850 }
851 struct v7fs_node *newnode = (*a->a_vpp)->v_data;
852 newnode->update_ctime = true;
853 newnode->update_mtime = true;
854 newnode->update_atime = true;
855
856 if (error == 0)
857 VOP_UNLOCK(*a->a_vpp);
858
859 return error;
860 }
861
862 int
v7fs_rmdir(void * v)863 v7fs_rmdir(void *v)
864 {
865 struct vop_rmdir_args /* {
866 struct vnode *a_dvp;
867 struct vnode *a_vp;
868 struct componentname *a_cnp;
869 } */ *a = v;
870 struct vnode *vp = a->a_vp;
871 struct vnode *dvp = a->a_dvp;
872 struct v7fs_node *parent_node = dvp->v_data;
873 struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
874 struct v7fs_inode *inode = &((struct v7fs_node *)vp->v_data)->inode;
875 struct v7fs_self *fs = v7fsmount->core;
876 int error = 0;
877
878 DPRINTF("delete %s\n", a->a_cnp->cn_nameptr);
879
880 KDASSERT(vp->v_type == VDIR);
881
882 if ((error = v7fs_file_deallocate(fs, &parent_node->inode,
883 a->a_cnp->cn_nameptr))) {
884 DPRINTF("v7fs_directory_deallocate failed.\n");
885 goto out;
886 }
887 error = v7fs_inode_load(fs, inode, inode->inode_number);
888 if (error)
889 goto out;
890 uvm_vnp_setsize(vp, v7fs_inode_filesize(inode));
891 /* Sync dirent size change. */
892 uvm_vnp_setsize(dvp, v7fs_inode_filesize(&parent_node->inode));
893 out:
894 vput(vp);
895 vput(dvp);
896
897 return error;
898 }
899
900 struct v7fs_readdir_arg {
901 struct dirent *dp;
902 struct uio *uio;
903 int start;
904 int end;
905 int cnt;
906 };
907 static int readdir_subr(struct v7fs_self *, void *, v7fs_daddr_t, size_t);
908
909 int
readdir_subr(struct v7fs_self * fs,void * ctx,v7fs_daddr_t blk,size_t sz)910 readdir_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)
911 {
912 struct v7fs_readdir_arg *p = (struct v7fs_readdir_arg *)ctx;
913 struct v7fs_dirent *dir;
914 struct dirent *dp = p->dp;
915 struct v7fs_inode inode;
916 char filename[V7FS_NAME_MAX + 1];
917 int i, n;
918 int error = 0;
919 void *buf;
920
921 if (!(buf = scratch_read(fs, blk)))
922 return EIO;
923 dir = (struct v7fs_dirent *)buf;
924
925 n = sz / sizeof(*dir);
926
927 for (i = 0; (i < n) && (p->cnt < p->end); i++, dir++, p->cnt++) {
928 if (p->cnt < p->start)
929 continue;
930
931 if ((error = v7fs_inode_load(fs, &inode, dir->inode_number)))
932 break;
933
934 v7fs_dirent_filename(filename, dir->name);
935
936 DPRINTF("inode=%d name=%s %s\n", dir->inode_number, filename,
937 v7fs_inode_isdir(&inode) ? "DIR" : "FILE");
938 memset(dp, 0, sizeof(*dp));
939 dp->d_fileno = dir->inode_number;
940 dp->d_type = v7fs_mode_to_d_type(inode.mode);
941 dp->d_namlen = strlen(filename);
942 strcpy(dp->d_name, filename);
943 dp->d_reclen = sizeof(*dp);
944 if ((error = uiomove(dp, dp->d_reclen, p->uio))) {
945 DPRINTF("uiomove failed.\n");
946 break;
947 }
948 }
949 scratch_free(fs, buf);
950
951 if (p->cnt == p->end)
952 return V7FS_ITERATOR_BREAK;
953
954 return error;
955 }
956
957 int
v7fs_readdir(void * v)958 v7fs_readdir(void *v)
959 {
960 struct vop_readdir_args /* {
961 struct vnode *a_vp;
962 struct uio *a_uio;
963 kauth_cred_t a_cred;
964 int *a_eofflag;
965 off_t **a_cookies;
966 int *a_ncookies;
967 } */ *a = v;
968 struct uio *uio = a->a_uio;
969 struct vnode *vp = a->a_vp;
970 struct v7fs_node *v7node = vp->v_data;
971 struct v7fs_inode *inode = &v7node->inode;
972 struct v7fs_self *fs = v7node->v7fsmount->core;
973 struct dirent *dp;
974 int error;
975
976 DPRINTF("offset=%zu residue=%zu\n", uio->uio_offset, uio->uio_resid);
977
978 KDASSERT(vp->v_type == VDIR);
979 KDASSERT(uio->uio_offset >= 0);
980 KDASSERT(v7fs_inode_isdir(inode));
981
982 struct v7fs_readdir_arg arg;
983 arg.start = uio->uio_offset / sizeof(*dp);
984 arg.end = arg.start + uio->uio_resid / sizeof(*dp);
985 if (arg.start == arg.end) {/* user buffer has not enuf space. */
986 DPRINTF("uio buffer too small\n");
987 return ENOMEM;
988 }
989 dp = kmem_zalloc(sizeof(*dp), KM_SLEEP);
990 arg.cnt = 0;
991 arg.dp = dp;
992 arg.uio = uio;
993
994 *a->a_eofflag = false;
995 error = v7fs_datablock_foreach(fs, inode, readdir_subr, &arg);
996 if (error == V7FS_ITERATOR_END) {
997 *a->a_eofflag = true;
998 }
999 if (error < 0)
1000 error = 0;
1001
1002 kmem_free(dp, sizeof(*dp));
1003
1004 return error;
1005 }
1006
1007 int
v7fs_inactive(void * v)1008 v7fs_inactive(void *v)
1009 {
1010 struct vop_inactive_args /* {
1011 struct vnode *a_vp;
1012 bool *a_recycle;
1013 } */ *a = v;
1014 struct vnode *vp = a->a_vp;
1015 struct v7fs_node *v7node = vp->v_data;
1016 struct v7fs_inode *inode = &v7node->inode;
1017
1018 DPRINTF("%p #%d\n", vp, inode->inode_number);
1019 if (v7fs_inode_nlink(inode) > 0) {
1020 v7fs_update(vp, 0, 0, UPDATE_WAIT);
1021 *a->a_recycle = false;
1022 } else {
1023 *a->a_recycle = true;
1024 }
1025
1026 VOP_UNLOCK(vp);
1027
1028 return 0;
1029 }
1030
1031 int
v7fs_reclaim(void * v)1032 v7fs_reclaim(void *v)
1033 {
1034 /*This vnode is no longer referenced by kernel. */
1035 extern struct pool v7fs_node_pool;
1036 struct vop_reclaim_args /* {
1037 struct vnode *a_vp;
1038 } */ *a = v;
1039 struct vnode *vp = a->a_vp;
1040 struct v7fs_node *v7node = vp->v_data;
1041 struct v7fs_self *fs = v7node->v7fsmount->core;
1042 struct v7fs_inode *inode = &v7node->inode;
1043
1044 DPRINTF("%p #%d\n", vp, inode->inode_number);
1045 if (v7fs_inode_nlink(inode) == 0) {
1046 v7fs_datablock_size_change(fs, 0, inode);
1047 DPRINTF("remove datablock\n");
1048 v7fs_inode_deallocate(fs, inode->inode_number);
1049 DPRINTF("remove inode\n");
1050 }
1051 vcache_remove(vp->v_mount,
1052 &inode->inode_number, sizeof(inode->inode_number));
1053 genfs_node_destroy(vp);
1054 pool_put(&v7fs_node_pool, v7node);
1055 mutex_enter(vp->v_interlock);
1056 vp->v_data = NULL;
1057 mutex_exit(vp->v_interlock);
1058
1059 return 0;
1060 }
1061
1062 int
v7fs_bmap(void * v)1063 v7fs_bmap(void *v)
1064 {
1065 struct vop_bmap_args /* {
1066 struct vnode *a_vp;
1067 daddr_t a_bn;
1068 struct vnode **a_vpp;
1069 daddr_t *a_bnp;
1070 int *a_runp;
1071 } */ *a = v;
1072 struct vnode *vp = a->a_vp;
1073 struct v7fs_node *v7node = vp->v_data;
1074 struct v7fs_mount *v7fsmount = v7node->v7fsmount;
1075 struct v7fs_self *fs = v7node->v7fsmount->core;
1076 struct v7fs_inode *inode = &v7node->inode;
1077 int error = 0;
1078
1079 DPRINTF("inode=%d offset=%zu %p\n", inode->inode_number, a->a_bn, vp);
1080 DPRINTF("filesize: %d\n", inode->filesize);
1081 if (!a->a_bnp)
1082 return 0;
1083
1084 v7fs_daddr_t blk;
1085 if (!(blk = v7fs_datablock_last(fs, inode,
1086 (a->a_bn + 1) << V7FS_BSHIFT))) {
1087 /* +1 converts block # to file offset. */
1088 return ENOSPC;
1089 }
1090
1091 *a->a_bnp = blk;
1092
1093 if (a->a_vpp)
1094 *a->a_vpp = v7fsmount->devvp;
1095 if (a->a_runp)
1096 *a->a_runp = 0; /*XXX TODO */
1097
1098 DPRINTF("%d %zu->%zu status=%d\n", inode->inode_number, a->a_bn,
1099 *a->a_bnp, error);
1100
1101 return error;
1102 }
1103
1104 int
v7fs_strategy(void * v)1105 v7fs_strategy(void *v)
1106 {
1107 struct vop_strategy_args /* {
1108 struct vnode *a_vp;
1109 struct buf *a_bp;
1110 } */ *a = v;
1111 struct buf *b = a->a_bp;
1112 struct vnode *vp = a->a_vp;
1113 struct v7fs_node *v7node = vp->v_data;
1114 struct v7fs_mount *v7fsmount = v7node->v7fsmount;
1115 int error;
1116
1117 DPRINTF("%p\n", vp);
1118 KDASSERT(vp->v_type == VREG);
1119 if (b->b_blkno == b->b_lblkno) {
1120 error = VOP_BMAP(vp, b->b_lblkno, NULL, &b->b_blkno, NULL);
1121 if (error) {
1122 b->b_error = error;
1123 biodone(b);
1124 return error;
1125 }
1126 if ((long)b->b_blkno == -1)
1127 clrbuf(b);
1128 }
1129 if ((long)b->b_blkno == -1) {
1130 biodone(b);
1131 return 0;
1132 }
1133
1134 return VOP_STRATEGY(v7fsmount->devvp, b);
1135 }
1136
1137 int
v7fs_print(void * v)1138 v7fs_print(void *v)
1139 {
1140 struct vop_print_args /* {
1141 struct vnode *a_vp;
1142 } */ *a = v;
1143 struct v7fs_node *v7node = a->a_vp->v_data;
1144
1145 v7fs_inode_dump(&v7node->inode);
1146
1147 return 0;
1148 }
1149
1150 int
v7fs_advlock(void * v)1151 v7fs_advlock(void *v)
1152 {
1153 struct vop_advlock_args /* {
1154 struct vnode *a_vp;
1155 void *a_id;
1156 int a_op;
1157 struct flock *a_fl;
1158 int a_flags;
1159 } */ *a = v;
1160 struct v7fs_node *v7node = a->a_vp->v_data;
1161
1162 DPRINTF("op=%d\n", a->a_op);
1163
1164 return lf_advlock(a, &v7node->lockf,
1165 v7fs_inode_filesize(&v7node->inode));
1166 }
1167
1168 int
v7fs_pathconf(void * v)1169 v7fs_pathconf(void *v)
1170 {
1171 struct vop_pathconf_args /* {
1172 struct vnode *a_vp;
1173 int a_name;
1174 register_t *a_retval;
1175 } */ *a = v;
1176 int err = 0;
1177
1178 DPRINTF("%p\n", a->a_vp);
1179
1180 switch (a->a_name) {
1181 case _PC_LINK_MAX:
1182 *a->a_retval = V7FS_LINK_MAX;
1183 break;
1184 case _PC_NAME_MAX:
1185 *a->a_retval = V7FS_NAME_MAX;
1186 break;
1187 case _PC_PATH_MAX:
1188 *a->a_retval = V7FS_PATH_MAX;
1189 break;
1190 case _PC_CHOWN_RESTRICTED:
1191 *a->a_retval = 1;
1192 break;
1193 case _PC_NO_TRUNC:
1194 *a->a_retval = 0;
1195 break;
1196 case _PC_SYNC_IO:
1197 *a->a_retval = 1;
1198 break;
1199 case _PC_FILESIZEBITS:
1200 *a->a_retval = 30; /* ~1G */
1201 break;
1202 case _PC_SYMLINK_MAX:
1203 *a->a_retval = V7FSBSD_MAXSYMLINKLEN;
1204 break;
1205 case _PC_2_SYMLINKS:
1206 *a->a_retval = 1;
1207 break;
1208 default:
1209 err = EINVAL;
1210 break;
1211 }
1212
1213 return err;
1214 }
1215
1216 int
v7fs_update(struct vnode * vp,const struct timespec * acc,const struct timespec * mod,int flags)1217 v7fs_update(struct vnode *vp, const struct timespec *acc,
1218 const struct timespec *mod, int flags)
1219 {
1220 struct v7fs_node *v7node = vp->v_data;
1221 struct v7fs_inode *inode = &v7node->inode;
1222 struct v7fs_self *fs = v7node->v7fsmount->core;
1223 bool update = false;
1224
1225 DPRINTF("%p %zu %d\n", vp, vp->v_size, v7fs_inode_filesize(inode));
1226 KDASSERT(vp->v_size == v7fs_inode_filesize(inode));
1227
1228 if (v7node->update_atime) {
1229 inode->atime = acc ? acc->tv_sec : time_second;
1230 v7node->update_atime = false;
1231 update = true;
1232 }
1233 if (v7node->update_ctime) {
1234 inode->ctime = time_second;
1235 v7node->update_ctime = false;
1236 update = true;
1237 }
1238 if (v7node->update_mtime) {
1239 inode->mtime = mod ? mod->tv_sec : time_second;
1240 v7node->update_mtime = false;
1241 update = true;
1242 }
1243
1244 if (update)
1245 v7fs_inode_writeback(fs, inode);
1246
1247 return 0;
1248 }
1249
1250 int
v7fs_symlink(void * v)1251 v7fs_symlink(void *v)
1252 {
1253 struct vop_symlink_v3_args /* {
1254 struct vnode *a_dvp;
1255 struct vnode **a_vpp;
1256 struct componentname *a_cnp;
1257 struct vattr *a_vap;
1258 char *a_target;
1259 } */ *a = v;
1260 struct v7fs_node *parent_node = a->a_dvp->v_data;
1261 struct v7fs_mount *v7fsmount = parent_node->v7fsmount;
1262 struct v7fs_self *fs = v7fsmount->core;
1263 struct vattr *va = a->a_vap;
1264 kauth_cred_t cr = a->a_cnp->cn_cred;
1265 struct componentname *cnp = a->a_cnp;
1266 struct v7fs_fileattr attr;
1267 v7fs_ino_t ino;
1268 const char *from = a->a_target;
1269 const char *to = cnp->cn_nameptr;
1270 size_t len = strlen(from) + 1;
1271 int error = 0;
1272
1273 if (len > V7FS_BSIZE) { /* limited to 512byte pathname */
1274 DPRINTF("too long pathname.");
1275 return ENAMETOOLONG;
1276 }
1277
1278 memset(&attr, 0, sizeof(attr));
1279 attr.uid = kauth_cred_geteuid(cr);
1280 attr.gid = kauth_cred_getegid(cr);
1281 attr.mode = va->va_mode | vtype_to_v7fs_mode(va->va_type);
1282
1283 if ((error = v7fs_file_allocate
1284 (fs, &parent_node->inode, to, &attr, &ino))) {
1285 return error;
1286 }
1287 /* Sync dirent size change. */
1288 uvm_vnp_setsize(a->a_dvp, v7fs_inode_filesize(&parent_node->inode));
1289
1290 /* Get myself vnode. */
1291 if ((error = v7fs_vget(v7fsmount->mountp, ino, a->a_vpp))) {
1292 DPRINTF("can't get vnode.\n");
1293 }
1294
1295 struct v7fs_node *newnode = (*a->a_vpp)->v_data;
1296 struct v7fs_inode *p = &newnode->inode;
1297 v7fs_file_symlink(fs, p, from);
1298 uvm_vnp_setsize(*a->a_vpp, v7fs_inode_filesize(p));
1299
1300 newnode->update_ctime = true;
1301 newnode->update_mtime = true;
1302 newnode->update_atime = true;
1303
1304 if (error == 0)
1305 VOP_UNLOCK(*a->a_vpp);
1306
1307 return error;
1308 }
1309
1310 int
v7fs_readlink(void * v)1311 v7fs_readlink(void *v)
1312 {
1313 struct vop_readlink_args /* {
1314 struct vnode *a_vp;
1315 struct uio *a_uio;
1316 kauth_cred_t a_cred;
1317 } */ *a = v;
1318 struct uio *uio = a->a_uio;
1319 struct vnode *vp = a->a_vp;
1320 struct v7fs_node *v7node = vp->v_data;
1321 struct v7fs_inode *inode = &v7node->inode;
1322 struct v7fs_self *fs = v7node->v7fsmount->core;
1323 int error = 0;
1324
1325 KDASSERT(vp->v_type == VLNK);
1326 KDASSERT(uio->uio_offset >= 0);
1327 KDASSERT(v7fs_inode_islnk(inode));
1328
1329 v7fs_daddr_t blk = inode->addr[0];
1330 void *buf;
1331 if (!(buf = scratch_read(fs, blk))) {
1332 error = EIO;
1333 goto error_exit;
1334 }
1335
1336 if ((error = uiomove(buf, strlen(buf), uio))) {
1337 DPRINTF("uiomove failed.\n");
1338 }
1339 scratch_free(fs, buf);
1340
1341 error_exit:
1342 return error;
1343 }
1344