sys/fs/v7fs/v7fs_vnops.c

   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
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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
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
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
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
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
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
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 }