sys/fs/nandfs/nandfs_vnops.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2010-2012 Semihalf
   5  * Copyright (c) 2008, 2009 Reinoud Zandijk
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * From: NetBSD: nilfs_vnops.c,v 1.2 2009/08/26 03:40:48 elad
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/conf.h>
  37 #include <sys/kernel.h>
  38 #include <sys/lock.h>
  39 #include <sys/lockf.h>
  40 #include <sys/malloc.h>
  41 #include <sys/mount.h>
  42 #include <sys/mutex.h>
  43 #include <sys/namei.h>
  44 #include <sys/sysctl.h>
  45 #include <sys/unistd.h>
  46 #include <sys/vnode.h>
  47 #include <sys/buf.h>
  48 #include <sys/bio.h>
  49 #include <sys/fcntl.h>
  50 #include <sys/dirent.h>
  51 #include <sys/rwlock.h>
  52 #include <sys/stat.h>
  53 #include <sys/priv.h>
  54
  55 #include <vm/vm.h>
  56 #include <vm/vm_extern.h>
  57 #include <vm/vm_object.h>
  58 #include <vm/vnode_pager.h>
  59
  60 #include <machine/_inttypes.h>
  61
  62 #include <fs/nandfs/nandfs_mount.h>
  63 #include <fs/nandfs/nandfs.h>
  64 #include <fs/nandfs/nandfs_subr.h>
  65
  66 extern uma_zone_t nandfs_node_zone;
  67 static void nandfs_read_filebuf(struct nandfs_node *, struct buf *);
  68 static void nandfs_itimes_locked(struct vnode *);
  69 static int nandfs_truncate(struct vnode *, uint64_t);
  70
  71 static vop_pathconf_t   nandfs_pathconf;
  72
  73 #define UPDATE_CLOSE 0
  74 #define UPDATE_WAIT 0
  75
  76 static int
  77 nandfs_inactive(struct vop_inactive_args *ap)
  78 {
  79         struct vnode *vp = ap->a_vp;
  80         struct nandfs_node *node = VTON(vp);
  81         int error = 0;
  82
  83         DPRINTF(VNCALL, ("%s: vp:%p node:%p\n", __func__, vp, node));
  84
  85         if (node == NULL) {
  86                 DPRINTF(NODE, ("%s: inactive NULL node\n", __func__));
  87                 return (0);
  88         }
  89
  90         if (node->nn_inode.i_mode != 0 && !(node->nn_inode.i_links_count)) {
  91                 nandfs_truncate(vp, 0);
  92                 error = nandfs_node_destroy(node);
  93                 if (error)
  94                         nandfs_error("%s: destroy node: %p\n", __func__, node);
  95                 node->nn_flags = 0;
  96                 vrecycle(vp);
  97         }
  98
  99         return (error);
 100 }
 101
 102 static int
 103 nandfs_reclaim(struct vop_reclaim_args *ap)
 104 {
 105         struct vnode *vp = ap->a_vp;
 106         struct nandfs_node *nandfs_node = VTON(vp);
 107         struct nandfs_device *fsdev = nandfs_node->nn_nandfsdev;
 108         uint64_t ino = nandfs_node->nn_ino;
 109
 110         DPRINTF(VNCALL, ("%s: vp:%p node:%p\n", __func__, vp, nandfs_node));
 111
 112         /* Invalidate all entries to a particular vnode. */
 113         cache_purge(vp);
 114
 115         /* Destroy the vm object and flush associated pages. */
 116         vnode_destroy_vobject(vp);
 117
 118         /* Remove from vfs hash if not system vnode */
 119         if (!NANDFS_SYS_NODE(nandfs_node->nn_ino))
 120                 vfs_hash_remove(vp);
 121
 122         /* Dispose all node knowledge */
 123         nandfs_dispose_node(&nandfs_node);
 124
 125         if (!NANDFS_SYS_NODE(ino))
 126                 NANDFS_WRITEUNLOCK(fsdev);
 127
 128         return (0);
 129 }
 130
 131 static int
 132 nandfs_read(struct vop_read_args *ap)
 133 {
 134         struct vnode *vp = ap->a_vp;
 135         struct nandfs_node *node = VTON(vp);
 136         struct nandfs_device *nandfsdev = node->nn_nandfsdev;
 137         struct uio *uio = ap->a_uio;
 138         struct buf *bp;
 139         uint64_t size;
 140         uint32_t blocksize;
 141         off_t bytesinfile;
 142         ssize_t toread, off;
 143         daddr_t lbn;
 144         ssize_t resid;
 145         int error = 0;
 146
 147         if (uio->uio_resid == 0)
 148                 return (0);
 149
 150         size = node->nn_inode.i_size;
 151         if (uio->uio_offset >= size)
 152                 return (0);
 153
 154         blocksize = nandfsdev->nd_blocksize;
 155         bytesinfile = size - uio->uio_offset;
 156
 157         resid = omin(uio->uio_resid, bytesinfile);
 158
 159         while (resid) {
 160                 lbn = uio->uio_offset / blocksize;
 161                 off = uio->uio_offset & (blocksize - 1);
 162
 163                 toread = omin(resid, blocksize - off);
 164
 165                 DPRINTF(READ, ("nandfs_read bn: 0x%jx toread: 0x%zx (0x%x)\n",
 166                     (uintmax_t)lbn, toread, blocksize));
 167
 168                 error = nandfs_bread(node, lbn, NOCRED, 0, &bp);
 169                 if (error) {
 170                         brelse(bp);
 171                         break;
 172                 }
 173
 174                 error = uiomove(bp->b_data + off, toread, uio);
 175                 if (error) {
 176                         brelse(bp);
 177                         break;
 178                 }
 179
 180                 brelse(bp);
 181                 resid -= toread;
 182         }
 183
 184         return (error);
 185 }
 186
 187 static int
 188 nandfs_write(struct vop_write_args *ap)
 189 {
 190         struct nandfs_device *fsdev;
 191         struct nandfs_node *node;
 192         struct vnode *vp;
 193         struct uio *uio;
 194         struct buf *bp;
 195         uint64_t file_size, vblk;
 196         uint32_t blocksize;
 197         ssize_t towrite, off;
 198         daddr_t lbn;
 199         ssize_t resid;
 200         int error, ioflag, modified;
 201
 202         vp = ap->a_vp;
 203         uio = ap->a_uio;
 204         ioflag = ap->a_ioflag;
 205         node = VTON(vp);
 206         fsdev = node->nn_nandfsdev;
 207
 208         if (nandfs_fs_full(fsdev))
 209                 return (ENOSPC);
 210
 211         DPRINTF(WRITE, ("nandfs_write called %#zx at %#jx\n",
 212             uio->uio_resid, (uintmax_t)uio->uio_offset));
 213
 214         if (uio->uio_offset < 0)
 215                 return (EINVAL);
 216         if (uio->uio_resid == 0)
 217                 return (0);
 218
 219         blocksize = fsdev->nd_blocksize;
 220         file_size = node->nn_inode.i_size;
 221
 222         switch (vp->v_type) {
 223         case VREG:
 224                 if (ioflag & IO_APPEND)
 225                         uio->uio_offset = file_size;
 226                 break;
 227         case VDIR:
 228                 return (EISDIR);
 229         case VLNK:
 230                 break;
 231         default:
 232                 panic("%s: bad file type vp: %p", __func__, vp);
 233         }
 234
 235         /* If explicitly asked to append, uio_offset can be wrong? */
 236         if (ioflag & IO_APPEND)
 237                 uio->uio_offset = file_size;
 238
 239         resid = uio->uio_resid;
 240         modified = error = 0;
 241
 242         while (uio->uio_resid) {
 243                 lbn = uio->uio_offset / blocksize;
 244                 off = uio->uio_offset & (blocksize - 1);
 245
 246                 towrite = omin(uio->uio_resid, blocksize - off);
 247
 248                 DPRINTF(WRITE, ("%s: lbn: 0x%jd toread: 0x%zx (0x%x)\n",
 249                     __func__, (uintmax_t)lbn, towrite, blocksize));
 250
 251                 error = nandfs_bmap_lookup(node, lbn, &vblk);
 252                 if (error)
 253                         break;
 254
 255                 DPRINTF(WRITE, ("%s: lbn: 0x%jd toread: 0x%zx (0x%x) "
 256                     "vblk=%jx\n", __func__, (uintmax_t)lbn, towrite, blocksize,
 257                     vblk));
 258
 259                 if (vblk != 0)
 260                         error = nandfs_bread(node, lbn, NOCRED, 0, &bp);
 261                 else
 262                         error = nandfs_bcreate(node, lbn, NOCRED, 0, &bp);
 263
 264                 DPRINTF(WRITE, ("%s: vp %p bread bp %p lbn %#jx\n", __func__,
 265                     vp, bp, (uintmax_t)lbn));
 266                 if (error) {
 267                         if (bp)
 268                                 brelse(bp);
 269                         break;
 270                 }
 271
 272                 error = uiomove((char *)bp->b_data + off, (int)towrite, uio);
 273                 if (error)
 274                         break;
 275
 276                 error = nandfs_dirty_buf(bp, 0);
 277                 if (error)
 278                         break;
 279
 280                 modified++;
 281         }
 282
 283         /* XXX proper handling when only part of file was properly written */
 284         if (modified) {
 285                 if (resid > uio->uio_resid && ap->a_cred &&
 286                     ap->a_cred->cr_uid != 0)
 287                         node->nn_inode.i_mode &= ~(ISUID | ISGID);
 288
 289                 if (file_size < uio->uio_offset + uio->uio_resid) {
 290                         node->nn_inode.i_size = uio->uio_offset +
 291                             uio->uio_resid;
 292                         node->nn_flags |= IN_CHANGE | IN_UPDATE;
 293                         vnode_pager_setsize(vp, uio->uio_offset +
 294                             uio->uio_resid);
 295                         nandfs_itimes(vp);
 296                 }
 297         }
 298
 299         DPRINTF(WRITE, ("%s: return:%d\n", __func__, error));
 300
 301         return (error);
 302 }
 303
 304 static int
 305 nandfs_lookup(struct vop_cachedlookup_args *ap)
 306 {
 307         struct vnode *dvp, **vpp;
 308         struct componentname *cnp;
 309         struct ucred *cred;
 310         struct thread *td;
 311         struct nandfs_node *dir_node, *node;
 312         struct nandfsmount *nmp;
 313         uint64_t ino, off;
 314         const char *name;
 315         int namelen, nameiop, islastcn, mounted_ro;
 316         int error, found;
 317
 318         DPRINTF(VNCALL, ("%s\n", __func__));
 319
 320         dvp = ap->a_dvp;
 321         vpp = ap->a_vpp;
 322         *vpp = NULL;
 323
 324         cnp = ap->a_cnp;
 325         cred = cnp->cn_cred;
 326         td = cnp->cn_thread;
 327
 328         dir_node = VTON(dvp);
 329         nmp = dir_node->nn_nmp;
 330
 331         /* Simplify/clarification flags */
 332         nameiop = cnp->cn_nameiop;
 333         islastcn = cnp->cn_flags & ISLASTCN;
 334         mounted_ro = dvp->v_mount->mnt_flag & MNT_RDONLY;
 335
 336         /*
 337          * If requesting a modify on the last path element on a read-only
 338          * filingsystem, reject lookup;
 339          */
 340         if (islastcn && mounted_ro && (nameiop == DELETE || nameiop == RENAME))
 341                 return (EROFS);
 342
 343         if (dir_node->nn_inode.i_links_count == 0)
 344                 return (ENOENT);
 345
 346         /*
 347          * Obviously, the file is not (anymore) in the namecache, we have to
 348          * search for it. There are three basic cases: '.', '..' and others.
 349          *
 350          * Following the guidelines of VOP_LOOKUP manpage and tmpfs.
 351          */
 352         error = 0;
 353         if ((cnp->cn_namelen == 1) && (cnp->cn_nameptr[0] == '.')) {
 354                 DPRINTF(LOOKUP, ("\tlookup '.'\n"));
 355                 /* Special case 1 '.' */
 356                 VREF(dvp);
 357                 *vpp = dvp;
 358                 /* Done */
 359         } else if (cnp->cn_flags & ISDOTDOT) {
 360                 /* Special case 2 '..' */
 361                 DPRINTF(LOOKUP, ("\tlookup '..'\n"));
 362
 363                 /* Get our node */
 364                 name = "..";
 365                 namelen = 2;
 366                 error = nandfs_lookup_name_in_dir(dvp, name, namelen, &ino,
 367                     &found, &off);
 368                 if (error)
 369                         goto out;
 370                 if (!found)
 371                         error = ENOENT;
 372
 373                 /* First unlock parent */
 374                 VOP_UNLOCK(dvp, 0);
 375
 376                 if (error == 0) {
 377                         DPRINTF(LOOKUP, ("\tfound '..'\n"));
 378                         /* Try to create/reuse the node */
 379                         error = nandfs_get_node(nmp, ino, &node);
 380
 381                         if (!error) {
 382                                 DPRINTF(LOOKUP,
 383                                     ("\tnode retrieved/created OK\n"));
 384                                 *vpp = NTOV(node);
 385                         }
 386                 }
 387
 388                 /* Try to relock parent */
 389                 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
 390         } else {
 391                 DPRINTF(LOOKUP, ("\tlookup file\n"));
 392                 /* All other files */
 393                 /* Look up filename in the directory returning its inode */
 394                 name = cnp->cn_nameptr;
 395                 namelen = cnp->cn_namelen;
 396                 error = nandfs_lookup_name_in_dir(dvp, name, namelen,
 397                     &ino, &found, &off);
 398                 if (error)
 399                         goto out;
 400                 if (!found) {
 401                         DPRINTF(LOOKUP, ("\tNOT found\n"));
 402                         /*
 403                          * UGH, didn't find name. If we're creating or
 404                          * renaming on the last name this is OK and we ought
 405                          * to return EJUSTRETURN if its allowed to be created.
 406                          */
 407                         error = ENOENT;
 408                         if ((nameiop == CREATE || nameiop == RENAME) &&
 409                             islastcn) {
 410                                 error = VOP_ACCESS(dvp, VWRITE, cred, td);
 411                                 if (!error) {
 412                                         /* keep the component name */
 413                                         cnp->cn_flags |= SAVENAME;
 414                                         error = EJUSTRETURN;
 415                                 }
 416                         }
 417                         /* Done */
 418                 } else {
 419                         if (ino == NANDFS_WHT_INO)
 420                                 cnp->cn_flags |= ISWHITEOUT;
 421
 422                         if ((cnp->cn_flags & ISWHITEOUT) &&
 423                             (nameiop == LOOKUP))
 424                                 return (ENOENT);
 425
 426                         if ((nameiop == DELETE) && islastcn) {
 427                                 if ((cnp->cn_flags & ISWHITEOUT) &&
 428                                     (cnp->cn_flags & DOWHITEOUT)) {
 429                                         cnp->cn_flags |= SAVENAME;
 430                                         dir_node->nn_diroff = off;
 431                                         return (EJUSTRETURN);
 432                                 }
 433
 434                                 error = VOP_ACCESS(dvp, VWRITE, cred,
 435                                     cnp->cn_thread);
 436                                 if (error)
 437                                         return (error);
 438
 439                                 /* Try to create/reuse the node */
 440                                 error = nandfs_get_node(nmp, ino, &node);
 441                                 if (!error) {
 442                                         *vpp = NTOV(node);
 443                                         node->nn_diroff = off;
 444                                 }
 445
 446                                 if ((dir_node->nn_inode.i_mode & ISVTX) &&
 447                                     cred->cr_uid != 0 &&
 448                                     cred->cr_uid != dir_node->nn_inode.i_uid &&
 449                                     node->nn_inode.i_uid != cred->cr_uid) {
 450                                         vput(*vpp);
 451                                         *vpp = NULL;
 452                                         return (EPERM);
 453                                 }
 454                         } else if ((nameiop == RENAME) && islastcn) {
 455                                 error = VOP_ACCESS(dvp, VWRITE, cred,
 456                                     cnp->cn_thread);
 457                                 if (error)
 458                                         return (error);
 459
 460                                 /* Try to create/reuse the node */
 461                                 error = nandfs_get_node(nmp, ino, &node);
 462                                 if (!error) {
 463                                         *vpp = NTOV(node);
 464                                         node->nn_diroff = off;
 465                                 }
 466                         } else {
 467                                 /* Try to create/reuse the node */
 468                                 error = nandfs_get_node(nmp, ino, &node);
 469                                 if (!error) {
 470                                         *vpp = NTOV(node);
 471                                         node->nn_diroff = off;
 472                                 }
 473                         }
 474                 }
 475         }
 476
 477 out:
 478         /*
 479          * Store result in the cache if requested. If we are creating a file,
 480          * the file might not be found and thus putting it into the namecache
 481          * might be seen as negative caching.
 482          */
 483         if ((cnp->cn_flags & MAKEENTRY) != 0)
 484                 cache_enter(dvp, *vpp, cnp);
 485
 486         return (error);
 487
 488 }
 489
 490 static int
 491 nandfs_getattr(struct vop_getattr_args *ap)
 492 {
 493         struct vnode *vp = ap->a_vp;
 494         struct vattr *vap = ap->a_vap;
 495         struct nandfs_node *node = VTON(vp);
 496         struct nandfs_inode *inode = &node->nn_inode;
 497
 498         DPRINTF(VNCALL, ("%s: vp: %p\n", __func__, vp));
 499         nandfs_itimes(vp);
 500
 501         /* Basic info */
 502         VATTR_NULL(vap);
 503         vap->va_atime.tv_sec = inode->i_mtime;
 504         vap->va_atime.tv_nsec = inode->i_mtime_nsec;
 505         vap->va_mtime.tv_sec = inode->i_mtime;
 506         vap->va_mtime.tv_nsec = inode->i_mtime_nsec;
 507         vap->va_ctime.tv_sec = inode->i_ctime;
 508         vap->va_ctime.tv_nsec = inode->i_ctime_nsec;
 509         vap->va_type = IFTOVT(inode->i_mode);
 510         vap->va_mode = inode->i_mode & ~S_IFMT;
 511         vap->va_nlink = inode->i_links_count;
 512         vap->va_uid = inode->i_uid;
 513         vap->va_gid = inode->i_gid;
 514         vap->va_rdev = inode->i_special;
 515         vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
 516         vap->va_fileid = node->nn_ino;
 517         vap->va_size = inode->i_size;
 518         vap->va_blocksize = node->nn_nandfsdev->nd_blocksize;
 519         vap->va_gen = 0;
 520         vap->va_flags = inode->i_flags;
 521         vap->va_bytes = inode->i_blocks * vap->va_blocksize;
 522         vap->va_filerev = 0;
 523         vap->va_vaflags = 0;
 524
 525         return (0);
 526 }
 527
 528 static int
 529 nandfs_vtruncbuf(struct vnode *vp, uint64_t nblks)
 530 {
 531         struct nandfs_device *nffsdev;
 532         struct bufobj *bo;
 533         struct buf *bp, *nbp;
 534
 535         bo = &vp->v_bufobj;
 536         nffsdev = VTON(vp)->nn_nandfsdev;
 537
 538         ASSERT_VOP_LOCKED(vp, "nandfs_truncate");
 539 restart:
 540         BO_LOCK(bo);
 541 restart_locked:
 542         TAILQ_FOREACH_SAFE(bp, &bo->bo_clean.bv_hd, b_bobufs, nbp) {
 543                 if (bp->b_lblkno < nblks)
 544                         continue;
 545                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL))
 546                         goto restart_locked;
 547
 548                 bremfree(bp);
 549                 bp->b_flags |= (B_INVAL | B_RELBUF);
 550                 bp->b_flags &= ~(B_ASYNC | B_MANAGED);
 551                 BO_UNLOCK(bo);
 552                 brelse(bp);
 553                 BO_LOCK(bo);
 554         }
 555
 556         TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
 557                 if (bp->b_lblkno < nblks)
 558                         continue;
 559                 if (BUF_LOCK(bp,
 560                     LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
 561                     BO_LOCKPTR(bo)) == ENOLCK)
 562                         goto restart;
 563                 bp->b_flags |= (B_INVAL | B_RELBUF);
 564                 bp->b_flags &= ~(B_ASYNC | B_MANAGED);
 565                 brelse(bp);
 566                 nandfs_dirty_bufs_decrement(nffsdev);
 567                 BO_LOCK(bo);
 568         }
 569
 570         BO_UNLOCK(bo);
 571
 572         return (0);
 573 }
 574
 575 static int
 576 nandfs_truncate(struct vnode *vp, uint64_t newsize)
 577 {
 578         struct nandfs_device *nffsdev;
 579         struct nandfs_node *node;
 580         struct nandfs_inode *inode;
 581         struct buf *bp = NULL;
 582         uint64_t oblks, nblks, vblk, size, rest;
 583         int error;
 584
 585         node = VTON(vp);
 586         nffsdev = node->nn_nandfsdev;
 587         inode = &node->nn_inode;
 588
 589         /* Calculate end of file */
 590         size = inode->i_size;
 591
 592         if (newsize == size) {
 593                 node->nn_flags |= IN_CHANGE | IN_UPDATE;
 594                 nandfs_itimes(vp);
 595                 return (0);
 596         }
 597
 598         if (newsize > size) {
 599                 inode->i_size = newsize;
 600                 vnode_pager_setsize(vp, newsize);
 601                 node->nn_flags |= IN_CHANGE | IN_UPDATE;
 602                 nandfs_itimes(vp);
 603                 return (0);
 604         }
 605
 606         nblks = howmany(newsize, nffsdev->nd_blocksize);
 607         oblks = howmany(size, nffsdev->nd_blocksize);
 608         rest = newsize % nffsdev->nd_blocksize;
 609
 610         if (rest) {
 611                 error = nandfs_bmap_lookup(node, nblks - 1, &vblk);
 612                 if (error)
 613                         return (error);
 614
 615                 if (vblk != 0)
 616                         error = nandfs_bread(node, nblks - 1, NOCRED, 0, &bp);
 617                 else
 618                         error = nandfs_bcreate(node, nblks - 1, NOCRED, 0, &bp);
 619
 620                 if (error) {
 621                         if (bp)
 622                                 brelse(bp);
 623                         return (error);
 624                 }
 625
 626                 bzero((char *)bp->b_data + rest,
 627                     (u_int)(nffsdev->nd_blocksize - rest));
 628                 error = nandfs_dirty_buf(bp, 0);
 629                 if (error)
 630                         return (error);
 631         }
 632
 633         DPRINTF(VNCALL, ("%s: vp %p oblks %jx nblks %jx\n", __func__, vp, oblks,
 634             nblks));
 635
 636         error = nandfs_bmap_truncate_mapping(node, oblks - 1, nblks - 1);
 637         if (error) {
 638                 if (bp)
 639                         nandfs_undirty_buf(bp);
 640                 return (error);
 641         }
 642
 643         error = nandfs_vtruncbuf(vp, nblks);
 644         if (error) {
 645                 if (bp)
 646                         nandfs_undirty_buf(bp);
 647                 return (error);
 648         }
 649
 650         inode->i_size = newsize;
 651         vnode_pager_setsize(vp, newsize);
 652         node->nn_flags |= IN_CHANGE | IN_UPDATE;
 653         nandfs_itimes(vp);
 654
 655         return (error);
 656 }
 657
 658 static void
 659 nandfs_itimes_locked(struct vnode *vp)
 660 {
 661         struct nandfs_node *node;
 662         struct nandfs_inode *inode;
 663         struct timespec ts;
 664
 665         ASSERT_VI_LOCKED(vp, __func__);
 666
 667         node = VTON(vp);
 668         inode = &node->nn_inode;
 669
 670         if ((node->nn_flags & (IN_ACCESS | IN_CHANGE | IN_UPDATE)) == 0)
 671                 return;
 672
 673         if (((vp->v_mount->mnt_kern_flag &
 674             (MNTK_SUSPENDED | MNTK_SUSPEND)) == 0) ||
 675             (node->nn_flags & (IN_CHANGE | IN_UPDATE)))
 676                 node->nn_flags |= IN_MODIFIED;
 677
 678         vfs_timestamp(&ts);
 679         if (node->nn_flags & IN_UPDATE) {
 680                 inode->i_mtime = ts.tv_sec;
 681                 inode->i_mtime_nsec = ts.tv_nsec;
 682         }
 683         if (node->nn_flags & IN_CHANGE) {
 684                 inode->i_ctime = ts.tv_sec;
 685                 inode->i_ctime_nsec = ts.tv_nsec;
 686         }
 687
 688         node->nn_flags &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE);
 689 }
 690
 691 void
 692 nandfs_itimes(struct vnode *vp)
 693 {
 694
 695         VI_LOCK(vp);
 696         nandfs_itimes_locked(vp);
 697         VI_UNLOCK(vp);
 698 }
 699
 700 static int
 701 nandfs_chmod(struct vnode *vp, int mode, struct ucred *cred, struct thread *td)
 702 {
 703         struct nandfs_node *node = VTON(vp);
 704         struct nandfs_inode *inode = &node->nn_inode;
 705         uint16_t nmode;
 706         int error = 0;
 707
 708         DPRINTF(VNCALL, ("%s: vp %p, mode %x, cred %p, td %p\n", __func__, vp,
 709             mode, cred, td));
 710         /*
 711          * To modify the permissions on a file, must possess VADMIN
 712          * for that file.
 713          */
 714         if ((error = VOP_ACCESS(vp, VADMIN, cred, td)))
 715                 return (error);
 716
 717         /*
 718          * Privileged processes may set the sticky bit on non-directories,
 719          * as well as set the setgid bit on a file with a group that the
 720          * process is not a member of. Both of these are allowed in
 721          * jail(8).
 722          */
 723         if (vp->v_type != VDIR && (mode & S_ISTXT)) {
 724                 if (priv_check_cred(cred, PRIV_VFS_STICKYFILE, 0))
 725                         return (EFTYPE);
 726         }
 727         if (!groupmember(inode->i_gid, cred) && (mode & ISGID)) {
 728                 error = priv_check_cred(cred, PRIV_VFS_SETGID, 0);
 729                 if (error)
 730                         return (error);
 731         }
 732
 733         /*
 734          * Deny setting setuid if we are not the file owner.
 735          */
 736         if ((mode & ISUID) && inode->i_uid != cred->cr_uid) {
 737                 error = priv_check_cred(cred, PRIV_VFS_ADMIN, 0);
 738                 if (error)
 739                         return (error);
 740         }
 741
 742         nmode = inode->i_mode;
 743         nmode &= ~ALLPERMS;
 744         nmode |= (mode & ALLPERMS);
 745         inode->i_mode = nmode;
 746         node->nn_flags |= IN_CHANGE;
 747
 748         DPRINTF(VNCALL, ("%s: to mode %x\n", __func__, nmode));
 749
 750         return (error);
 751 }
 752
 753 static int
 754 nandfs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred,
 755     struct thread *td)
 756 {
 757         struct nandfs_node *node = VTON(vp);
 758         struct nandfs_inode *inode = &node->nn_inode;
 759         uid_t ouid;
 760         gid_t ogid;
 761         int error = 0;
 762
 763         if (uid == (uid_t)VNOVAL)
 764                 uid = inode->i_uid;
 765         if (gid == (gid_t)VNOVAL)
 766                 gid = inode->i_gid;
 767         /*
 768          * To modify the ownership of a file, must possess VADMIN for that
 769          * file.
 770          */
 771         if ((error = VOP_ACCESSX(vp, VWRITE_OWNER, cred, td)))
 772                 return (error);
 773         /*
 774          * To change the owner of a file, or change the group of a file to a
 775          * group of which we are not a member, the caller must have
 776          * privilege.
 777          */
 778         if (((uid != inode->i_uid && uid != cred->cr_uid) ||
 779             (gid != inode->i_gid && !groupmember(gid, cred))) &&
 780             (error = priv_check_cred(cred, PRIV_VFS_CHOWN, 0)))
 781                 return (error);
 782         ogid = inode->i_gid;
 783         ouid = inode->i_uid;
 784
 785         inode->i_gid = gid;
 786         inode->i_uid = uid;
 787
 788         node->nn_flags |= IN_CHANGE;
 789         if ((inode->i_mode & (ISUID | ISGID)) &&
 790             (ouid != uid || ogid != gid)) {
 791                 if (priv_check_cred(cred, PRIV_VFS_RETAINSUGID, 0))
 792                         inode->i_mode &= ~(ISUID | ISGID);
 793         }
 794         DPRINTF(VNCALL, ("%s: vp %p, cred %p, td %p - ret OK\n", __func__, vp,
 795             cred, td));
 796         return (0);
 797 }
 798
 799 static int
 800 nandfs_setattr(struct vop_setattr_args *ap)
 801 {
 802         struct vnode *vp = ap->a_vp;
 803         struct nandfs_node *node = VTON(vp);
 804         struct nandfs_inode *inode = &node->nn_inode;
 805         struct vattr *vap = ap->a_vap;
 806         struct ucred *cred = ap->a_cred;
 807         struct thread *td = curthread;
 808         uint32_t flags;
 809         int error = 0;
 810
 811         if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
 812             (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
 813             (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
 814             (vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
 815                 DPRINTF(VNCALL, ("%s: unsettable attribute\n", __func__));
 816                 return (EINVAL);
 817         }
 818
 819         if (vap->va_flags != VNOVAL) {
 820                 DPRINTF(VNCALL, ("%s: vp:%p td:%p flags:%lx\n", __func__, vp,
 821                     td, vap->va_flags));
 822
 823                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
 824                         return (EROFS);
 825                 /*
 826                  * Callers may only modify the file flags on objects they
 827                  * have VADMIN rights for.
 828                  */
 829                 if ((error = VOP_ACCESS(vp, VADMIN, cred, td)))
 830                         return (error);
 831                 /*
 832                  * Unprivileged processes are not permitted to unset system
 833                  * flags, or modify flags if any system flags are set.
 834                  * Privileged non-jail processes may not modify system flags
 835                  * if securelevel > 0 and any existing system flags are set.
 836                  * Privileged jail processes behave like privileged non-jail
 837                  * processes if the PR_ALLOW_CHFLAGS permission bit is set;
 838                  * otherwise, they behave like unprivileged processes.
 839                  */
 840
 841                 flags = inode->i_flags;
 842                 if (!priv_check_cred(cred, PRIV_VFS_SYSFLAGS, 0)) {
 843                         if (flags & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND)) {
 844                                 error = securelevel_gt(cred, 0);
 845                                 if (error)
 846                                         return (error);
 847                         }
 848                         /* Snapshot flag cannot be set or cleared */
 849                         if (((vap->va_flags & SF_SNAPSHOT) != 0 &&
 850                             (flags & SF_SNAPSHOT) == 0) ||
 851                             ((vap->va_flags & SF_SNAPSHOT) == 0 &&
 852                             (flags & SF_SNAPSHOT) != 0))
 853                                 return (EPERM);
 854
 855                         inode->i_flags = vap->va_flags;
 856                 } else {
 857                         if (flags & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND) ||
 858                             (vap->va_flags & UF_SETTABLE) != vap->va_flags)
 859                                 return (EPERM);
 860
 861                         flags &= SF_SETTABLE;
 862                         flags |= (vap->va_flags & UF_SETTABLE);
 863                         inode->i_flags = flags;
 864                 }
 865                 node->nn_flags |= IN_CHANGE;
 866                 if (vap->va_flags & (IMMUTABLE | APPEND))
 867                         return (0);
 868         }
 869         if (inode->i_flags & (IMMUTABLE | APPEND))
 870                 return (EPERM);
 871
 872         if (vap->va_size != (u_quad_t)VNOVAL) {
 873                 DPRINTF(VNCALL, ("%s: vp:%p td:%p size:%jx\n", __func__, vp, td,
 874                     (uintmax_t)vap->va_size));
 875
 876                 switch (vp->v_type) {
 877                 case VDIR:
 878                         return (EISDIR);
 879                 case VLNK:
 880                 case VREG:
 881                         if (vp->v_mount->mnt_flag & MNT_RDONLY)
 882                                 return (EROFS);
 883                         if ((inode->i_flags & SF_SNAPSHOT) != 0)
 884                                 return (EPERM);
 885                         break;
 886                 default:
 887                         return (0);
 888                 }
 889
 890                 if (vap->va_size > node->nn_nandfsdev->nd_maxfilesize)
 891                         return (EFBIG);
 892
 893                 KASSERT((vp->v_type == VREG), ("Set size %d", vp->v_type));
 894                 nandfs_truncate(vp, vap->va_size);
 895                 node->nn_flags |= IN_CHANGE;
 896
 897                 return (0);
 898         }
 899
 900         if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
 901                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
 902                         return (EROFS);
 903                 DPRINTF(VNCALL, ("%s: vp:%p td:%p uid/gid %x/%x\n", __func__,
 904                     vp, td, vap->va_uid, vap->va_gid));
 905                 error = nandfs_chown(vp, vap->va_uid, vap->va_gid, cred, td);
 906                 if (error)
 907                         return (error);
 908         }
 909
 910         if (vap->va_mode != (mode_t)VNOVAL) {
 911                 if (vp->v_mount->mnt_flag & MNT_RDONLY)
 912                         return (EROFS);
 913                 DPRINTF(VNCALL, ("%s: vp:%p td:%p mode %x\n", __func__, vp, td,
 914                     vap->va_mode));
 915
 916                 error = nandfs_chmod(vp, (int)vap->va_mode, cred, td);
 917                 if (error)
 918                         return (error);
 919         }
 920         if (vap->va_atime.tv_sec != VNOVAL ||
 921             vap->va_mtime.tv_sec != VNOVAL ||
 922             vap->va_birthtime.tv_sec != VNOVAL) {
 923                 DPRINTF(VNCALL, ("%s: vp:%p td:%p time a/m/b %jx/%jx/%jx\n",
 924                     __func__, vp, td, (uintmax_t)vap->va_atime.tv_sec,
 925                     (uintmax_t)vap->va_mtime.tv_sec,
 926                     (uintmax_t)vap->va_birthtime.tv_sec));
 927
 928                 if (vap->va_atime.tv_sec != VNOVAL)
 929                         node->nn_flags |= IN_ACCESS;
 930                 if (vap->va_mtime.tv_sec != VNOVAL)
 931                         node->nn_flags |= IN_CHANGE | IN_UPDATE;
 932                 if (vap->va_birthtime.tv_sec != VNOVAL)
 933                         node->nn_flags |= IN_MODIFIED;
 934                 nandfs_itimes(vp);
 935                 return (0);
 936         }
 937
 938         return (0);
 939 }
 940
 941 static int
 942 nandfs_open(struct vop_open_args *ap)
 943 {
 944         struct nandfs_node *node = VTON(ap->a_vp);
 945         uint64_t filesize;
 946
 947         DPRINTF(VNCALL, ("nandfs_open called ap->a_mode %x\n", ap->a_mode));
 948
 949         if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK)
 950                 return (EOPNOTSUPP);
 951
 952         if ((node->nn_inode.i_flags & APPEND) &&
 953             (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
 954                 return (EPERM);
 955
 956         filesize = node->nn_inode.i_size;
 957         vnode_create_vobject(ap->a_vp, filesize, ap->a_td);
 958
 959         return (0);
 960 }
 961
 962 static int
 963 nandfs_close(struct vop_close_args *ap)
 964 {
 965         struct vnode *vp = ap->a_vp;
 966         struct nandfs_node *node = VTON(vp);
 967
 968         DPRINTF(VNCALL, ("%s: vp %p node %p\n", __func__, vp, node));
 969
 970         mtx_lock(&vp->v_interlock);
 971         if (vp->v_usecount > 1)
 972                 nandfs_itimes_locked(vp);
 973         mtx_unlock(&vp->v_interlock);
 974
 975         return (0);
 976 }
 977
 978 static int
 979 nandfs_check_possible(struct vnode *vp, struct vattr *vap, mode_t mode)
 980 {
 981
 982         /* Check if we are allowed to write */
 983         switch (vap->va_type) {
 984         case VDIR:
 985         case VLNK:
 986         case VREG:
 987                 /*
 988                  * Normal nodes: check if we're on a read-only mounted
 989                  * filingsystem and bomb out if we're trying to write.
 990                  */
 991                 if ((mode & VMODIFY_PERMS) && (vp->v_mount->mnt_flag & MNT_RDONLY))
 992                         return (EROFS);
 993                 break;
 994         case VBLK:
 995         case VCHR:
 996         case VSOCK:
 997         case VFIFO:
 998                 /*
 999                  * Special nodes: even on read-only mounted filingsystems
1000                  * these are allowed to be written to if permissions allow.
1001                  */
1002                 break;
1003         default:
1004                 /* No idea what this is */
1005                 return (EINVAL);
1006         }
1007
1008         /* No one may write immutable files */
1009         if ((mode & VWRITE) && (VTON(vp)->nn_inode.i_flags & IMMUTABLE))
1010                 return (EPERM);
1011
1012         return (0);
1013 }
1014
1015 static int
1016 nandfs_check_permitted(struct vnode *vp, struct vattr *vap, mode_t mode,
1017     struct ucred *cred)
1018 {
1019
1020         return (vaccess(vp->v_type, vap->va_mode, vap->va_uid, vap->va_gid, mode,
1021             cred, NULL));
1022 }
1023
1024 static int
1025 nandfs_advlock(struct vop_advlock_args *ap)
1026 {
1027         struct nandfs_node *nvp;
1028         quad_t size;
1029
1030         nvp = VTON(ap->a_vp);
1031         size = nvp->nn_inode.i_size;
1032         return (lf_advlock(ap, &(nvp->nn_lockf), size));
1033 }
1034
1035 static int
1036 nandfs_access(struct vop_access_args *ap)
1037 {
1038         struct vnode *vp = ap->a_vp;
1039         accmode_t accmode = ap->a_accmode;
1040         struct ucred *cred = ap->a_cred;
1041         struct vattr vap;
1042         int error;
1043
1044         DPRINTF(VNCALL, ("%s: vp:%p mode: %x\n", __func__, vp, accmode));
1045
1046         error = VOP_GETATTR(vp, &vap, NULL);
1047         if (error)
1048                 return (error);
1049
1050         error = nandfs_check_possible(vp, &vap, accmode);
1051         if (error)
1052                 return (error);
1053
1054         error = nandfs_check_permitted(vp, &vap, accmode, cred);
1055
1056         return (error);
1057 }
1058
1059 static int
1060 nandfs_print(struct vop_print_args *ap)
1061 {
1062         struct vnode *vp = ap->a_vp;
1063         struct nandfs_node *nvp = VTON(vp);
1064
1065         printf("\tvp=%p, nandfs_node=%p\n", vp, nvp);
1066         printf("nandfs inode %#jx\n", (uintmax_t)nvp->nn_ino);
1067         printf("flags = 0x%b\n", (u_int)nvp->nn_flags, PRINT_NODE_FLAGS);
1068
1069         return (0);
1070 }
1071
1072 static void
1073 nandfs_read_filebuf(struct nandfs_node *node, struct buf *bp)
1074 {
1075         struct nandfs_device *nandfsdev = node->nn_nandfsdev;
1076         struct buf *nbp;
1077         nandfs_daddr_t vblk, pblk;
1078         nandfs_lbn_t from;
1079         uint32_t blocksize;
1080         int error = 0;
1081         int blk2dev = nandfsdev->nd_blocksize / DEV_BSIZE;
1082
1083         /*
1084          * Translate all the block sectors into a series of buffers to read
1085          * asynchronously from the nandfs device. Note that this lookup may
1086          * induce readin's too.
1087          */
1088
1089         blocksize = nandfsdev->nd_blocksize;
1090         if (bp->b_bcount / blocksize != 1)
1091                 panic("invalid b_count in bp %p\n", bp);
1092
1093         from = bp->b_blkno;
1094
1095         DPRINTF(READ, ("\tread in from inode %#jx blkno %#jx"
1096             " count %#lx\n", (uintmax_t)node->nn_ino, from,
1097             bp->b_bcount));
1098
1099         /* Get virtual block numbers for the vnode's buffer span */
1100         error = nandfs_bmap_lookup(node, from, &vblk);
1101         if (error) {
1102                 bp->b_error = EINVAL;
1103                 bp->b_ioflags |= BIO_ERROR;
1104                 bufdone(bp);
1105                 return;
1106         }
1107
1108         /* Translate virtual block numbers to physical block numbers */
1109         error = nandfs_vtop(node, vblk, &pblk);
1110         if (error) {
1111                 bp->b_error = EINVAL;
1112                 bp->b_ioflags |= BIO_ERROR;
1113                 bufdone(bp);
1114                 return;
1115         }
1116
1117         /* Issue translated blocks */
1118         bp->b_resid = bp->b_bcount;
1119
1120         /* Note virtual block 0 marks not mapped */
1121         if (vblk == 0) {
1122                 vfs_bio_clrbuf(bp);
1123                 bufdone(bp);
1124                 return;
1125         }
1126
1127         nbp = bp;
1128         nbp->b_blkno = pblk * blk2dev;
1129         bp->b_iooffset = dbtob(nbp->b_blkno);
1130         MPASS(bp->b_iooffset >= 0);
1131         BO_STRATEGY(&nandfsdev->nd_devvp->v_bufobj, nbp);
1132         nandfs_vblk_set(bp, vblk);
1133         DPRINTF(READ, ("read_filebuf : ino %#jx blk %#jx -> "
1134             "%#jx -> %#jx [bp %p]\n", (uintmax_t)node->nn_ino,
1135             (uintmax_t)(from), (uintmax_t)vblk,
1136             (uintmax_t)pblk, nbp));
1137 }
1138
1139 static void
1140 nandfs_write_filebuf(struct nandfs_node *node, struct buf *bp)
1141 {
1142         struct nandfs_device *nandfsdev = node->nn_nandfsdev;
1143
1144         bp->b_iooffset = dbtob(bp->b_blkno);
1145         MPASS(bp->b_iooffset >= 0);
1146         BO_STRATEGY(&nandfsdev->nd_devvp->v_bufobj, bp);
1147 }
1148
1149 static int
1150 nandfs_strategy(struct vop_strategy_args *ap)
1151 {
1152         struct vnode *vp = ap->a_vp;
1153         struct buf *bp = ap->a_bp;
1154         struct nandfs_node *node = VTON(vp);
1155
1156
1157         /* check if we ought to be here */
1158         KASSERT((vp->v_type != VBLK && vp->v_type != VCHR),
1159             ("nandfs_strategy on type %d", vp->v_type));
1160
1161         /* Translate if needed and pass on */
1162         if (bp->b_iocmd == BIO_READ) {
1163                 nandfs_read_filebuf(node, bp);
1164                 return (0);
1165         }
1166
1167         /* Send to segment collector */
1168         nandfs_write_filebuf(node, bp);
1169         return (0);
1170 }
1171
1172 static int
1173 nandfs_readdir(struct vop_readdir_args *ap)
1174 {
1175         struct uio *uio = ap->a_uio;
1176         struct vnode *vp = ap->a_vp;
1177         struct nandfs_node *node = VTON(vp);
1178         struct nandfs_dir_entry *ndirent;
1179         struct dirent dirent;
1180         struct buf *bp;
1181         uint64_t file_size, diroffset, transoffset, blkoff;
1182         uint64_t blocknr;
1183         uint32_t blocksize = node->nn_nandfsdev->nd_blocksize;
1184         uint8_t *pos, name_len;
1185         int error;
1186
1187         DPRINTF(READDIR, ("nandfs_readdir called\n"));
1188
1189         if (vp->v_type != VDIR)
1190                 return (ENOTDIR);
1191
1192         file_size = node->nn_inode.i_size;
1193         DPRINTF(READDIR, ("nandfs_readdir filesize %jd resid %zd\n",
1194             (uintmax_t)file_size, uio->uio_resid ));
1195
1196         /* We are called just as long as we keep on pushing data in */
1197         error = 0;
1198         if ((uio->uio_offset < file_size) &&
1199             (uio->uio_resid >= sizeof(struct dirent))) {
1200                 diroffset = uio->uio_offset;
1201                 transoffset = diroffset;
1202
1203                 blocknr = diroffset / blocksize;
1204                 blkoff = diroffset % blocksize;
1205                 error = nandfs_bread(node, blocknr, NOCRED, 0, &bp);
1206                 if (error) {
1207                         brelse(bp);
1208                         return (EIO);
1209                 }
1210                 while (diroffset < file_size) {
1211                         DPRINTF(READDIR, ("readdir : offset = %"PRIu64"\n",
1212                             diroffset));
1213                         if (blkoff >= blocksize) {
1214                                 blkoff = 0; blocknr++;
1215                                 brelse(bp);
1216                                 error = nandfs_bread(node, blocknr, NOCRED, 0,
1217                                     &bp);
1218                                 if (error) {
1219                                         brelse(bp);
1220                                         return (EIO);
1221                                 }
1222                         }
1223
1224                         /* Read in one dirent */
1225                         pos = (uint8_t *)bp->b_data + blkoff;
1226                         ndirent = (struct nandfs_dir_entry *)pos;
1227
1228                         name_len = ndirent->name_len;
1229                         memset(&dirent, 0, sizeof(struct dirent));
1230                         dirent.d_fileno = ndirent->inode;
1231                         if (dirent.d_fileno) {
1232                                 dirent.d_type = ndirent->file_type;
1233                                 dirent.d_namlen = name_len;
1234                                 strncpy(dirent.d_name, ndirent->name, name_len);
1235                                 dirent.d_reclen = GENERIC_DIRSIZ(&dirent);
1236                                 DPRINTF(READDIR, ("copying `%*.*s`\n", name_len,
1237                                     name_len, dirent.d_name));
1238                         }
1239
1240                         /*
1241                          * If there isn't enough space in the uio to return a
1242                          * whole dirent, break off read
1243                          */
1244                         if (uio->uio_resid < GENERIC_DIRSIZ(&dirent))
1245                                 break;
1246
1247                         /* Transfer */
1248                         if (dirent.d_fileno)
1249                                 uiomove(&dirent, GENERIC_DIRSIZ(&dirent), uio);
1250
1251                         /* Advance */
1252                         diroffset += ndirent->rec_len;
1253                         blkoff += ndirent->rec_len;
1254
1255                         /* Remember the last entry we transferred */
1256                         transoffset = diroffset;
1257                 }
1258                 brelse(bp);
1259
1260                 /* Pass on last transferred offset */
1261                 uio->uio_offset = transoffset;
1262         }
1263
1264         if (ap->a_eofflag)
1265                 *ap->a_eofflag = (uio->uio_offset >= file_size);
1266
1267         return (error);
1268 }
1269
1270 static int
1271 nandfs_dirempty(struct vnode *dvp, uint64_t parentino, struct ucred *cred)
1272 {
1273         struct nandfs_node *dnode = VTON(dvp);
1274         struct nandfs_dir_entry *dirent;
1275         uint64_t file_size = dnode->nn_inode.i_size;
1276         uint64_t blockcount = dnode->nn_inode.i_blocks;
1277         uint64_t blocknr;
1278         uint32_t blocksize = dnode->nn_nandfsdev->nd_blocksize;
1279         uint32_t limit;
1280         uint32_t off;
1281         uint8_t *pos;
1282         struct buf *bp;
1283         int error;
1284
1285         DPRINTF(LOOKUP, ("%s: dvp %p parentino %#jx cred %p\n", __func__, dvp,
1286             (uintmax_t)parentino, cred));
1287
1288         KASSERT((file_size != 0), ("nandfs_dirempty for NULL dir %p", dvp));
1289
1290         blocknr = 0;
1291         while (blocknr < blockcount) {
1292                 error = nandfs_bread(dnode, blocknr, NOCRED, 0, &bp);
1293                 if (error) {
1294                         brelse(bp);
1295                         return (0);
1296                 }
1297
1298                 pos = (uint8_t *)bp->b_data;
1299                 off = 0;
1300
1301                 if (blocknr == (blockcount - 1))
1302                         limit = file_size % blocksize;
1303                 else
1304                         limit = blocksize;
1305
1306                 while (off < limit) {
1307                         dirent = (struct nandfs_dir_entry *)(pos + off);
1308                         off += dirent->rec_len;
1309
1310                         if (dirent->inode == 0)
1311                                 continue;
1312
1313                         switch (dirent->name_len) {
1314                         case 0:
1315                                 break;
1316                         case 1:
1317                                 if (dirent->name[0] != '.')
1318                                         goto notempty;
1319
1320                                 KASSERT(dirent->inode == dnode->nn_ino,
1321                                     (".'s inode does not match dir"));
1322                                 break;
1323                         case 2:
1324                                 if (dirent->name[0] != '.' &&
1325                                     dirent->name[1] != '.')
1326                                         goto notempty;
1327
1328                                 KASSERT(dirent->inode == parentino,
1329                                     ("..'s inode does not match parent"));
1330                                 break;
1331                         default:
1332                                 goto notempty;
1333                         }
1334                 }
1335
1336                 brelse(bp);
1337                 blocknr++;
1338         }
1339
1340         return (1);
1341 notempty:
1342         brelse(bp);
1343         return (0);
1344 }
1345
1346 static int
1347 nandfs_link(struct vop_link_args *ap)
1348 {
1349         struct vnode *tdvp = ap->a_tdvp;
1350         struct vnode *vp = ap->a_vp;
1351         struct componentname *cnp = ap->a_cnp;
1352         struct nandfs_node *node = VTON(vp);
1353         struct nandfs_inode *inode = &node->nn_inode;
1354         int error;
1355
1356         if (inode->i_links_count >= NANDFS_LINK_MAX)
1357                 return (EMLINK);
1358
1359         if (inode->i_flags & (IMMUTABLE | APPEND))
1360                 return (EPERM);
1361
1362         /* Update link count */
1363         inode->i_links_count++;
1364
1365         /* Add dir entry */
1366         error = nandfs_add_dirent(tdvp, node->nn_ino, cnp->cn_nameptr,
1367             cnp->cn_namelen, IFTODT(inode->i_mode));
1368         if (error) {
1369                 inode->i_links_count--;
1370         }
1371
1372         node->nn_flags |= IN_CHANGE;
1373         nandfs_itimes(vp);
1374         DPRINTF(VNCALL, ("%s: tdvp %p vp %p cnp %p\n",
1375             __func__, tdvp, vp, cnp));
1376
1377         return (0);
1378 }
1379
1380 static int
1381 nandfs_create(struct vop_create_args *ap)
1382 {
1383         struct vnode *dvp = ap->a_dvp;
1384         struct vnode **vpp = ap->a_vpp;
1385         struct componentname *cnp = ap->a_cnp;
1386         uint16_t mode = MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode);
1387         struct nandfs_node *dir_node = VTON(dvp);
1388         struct nandfsmount *nmp = dir_node->nn_nmp;
1389         struct nandfs_node *node;
1390         int error;
1391
1392         DPRINTF(VNCALL, ("%s: dvp %p\n", __func__, dvp));
1393
1394         if (nandfs_fs_full(dir_node->nn_nandfsdev))
1395                 return (ENOSPC);
1396
1397         /* Create new vnode/inode */
1398         error = nandfs_node_create(nmp, &node, mode);
1399         if (error)
1400                 return (error);
1401         node->nn_inode.i_gid = dir_node->nn_inode.i_gid;
1402         node->nn_inode.i_uid = cnp->cn_cred->cr_uid;
1403
1404         /* Add new dir entry */
1405         error = nandfs_add_dirent(dvp, node->nn_ino, cnp->cn_nameptr,
1406             cnp->cn_namelen, IFTODT(mode));
1407         if (error) {
1408                 if (nandfs_node_destroy(node)) {
1409                         nandfs_error("%s: error destroying node %p\n",
1410                             __func__, node);
1411                 }
1412                 return (error);
1413         }
1414         *vpp = NTOV(node);
1415         if ((cnp->cn_flags & MAKEENTRY) != 0)
1416                 cache_enter(dvp, *vpp, cnp);
1417
1418         DPRINTF(VNCALL, ("created file vp %p nandnode %p ino %jx\n", *vpp, node,
1419             (uintmax_t)node->nn_ino));
1420         return (0);
1421 }
1422
1423 static int
1424 nandfs_remove(struct vop_remove_args *ap)
1425 {
1426         struct vnode *vp = ap->a_vp;
1427         struct vnode *dvp = ap->a_dvp;
1428         struct nandfs_node *node = VTON(vp);
1429         struct nandfs_node *dnode = VTON(dvp);
1430         struct componentname *cnp = ap->a_cnp;
1431
1432         DPRINTF(VNCALL, ("%s: dvp %p vp %p nandnode %p ino %#jx link %d\n",
1433             __func__, dvp, vp, node, (uintmax_t)node->nn_ino,
1434             node->nn_inode.i_links_count));
1435
1436         if (vp->v_type == VDIR)
1437                 return (EISDIR);
1438
1439         /* Files marked as immutable or append-only cannot be deleted. */
1440         if ((node->nn_inode.i_flags & (IMMUTABLE | APPEND | NOUNLINK)) ||
1441             (dnode->nn_inode.i_flags & APPEND))
1442                 return (EPERM);
1443
1444         nandfs_remove_dirent(dvp, node, cnp);
1445         node->nn_inode.i_links_count--;
1446         node->nn_flags |= IN_CHANGE;
1447
1448         return (0);
1449 }
1450
1451 /*
1452  * Check if source directory is in the path of the target directory.
1453  * Target is supplied locked, source is unlocked.
1454  * The target is always vput before returning.
1455  */
1456 static int
1457 nandfs_checkpath(struct nandfs_node *src, struct nandfs_node *dest,
1458     struct ucred *cred)
1459 {
1460         struct vnode *vp;
1461         int error, rootino;
1462         struct nandfs_dir_entry dirent;
1463
1464         vp = NTOV(dest);
1465         if (src->nn_ino == dest->nn_ino) {
1466                 error = EEXIST;
1467                 goto out;
1468         }
1469         rootino = NANDFS_ROOT_INO;
1470         error = 0;
1471         if (dest->nn_ino == rootino)
1472                 goto out;
1473
1474         for (;;) {
1475                 if (vp->v_type != VDIR) {
1476                         error = ENOTDIR;
1477                         break;
1478                 }
1479
1480                 error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirent,
1481                     NANDFS_DIR_REC_LEN(2), (off_t)0, UIO_SYSSPACE,
1482                     IO_NODELOCKED | IO_NOMACCHECK, cred, NOCRED,
1483                     NULL, NULL);
1484                 if (error != 0)
1485                         break;
1486                 if (dirent.name_len != 2 ||
1487                     dirent.name[0] != '.' ||
1488                     dirent.name[1] != '.') {
1489                         error = ENOTDIR;
1490                         break;
1491                 }
1492                 if (dirent.inode == src->nn_ino) {
1493                         error = EINVAL;
1494                         break;
1495                 }
1496                 if (dirent.inode == rootino)
1497                         break;
1498                 vput(vp);
1499                 if ((error = VFS_VGET(vp->v_mount, dirent.inode,
1500                     LK_EXCLUSIVE, &vp)) != 0) {
1501                         vp = NULL;
1502                         break;
1503                 }
1504         }
1505
1506 out:
1507         if (error == ENOTDIR)
1508                 printf("checkpath: .. not a directory\n");
1509         if (vp != NULL)
1510                 vput(vp);
1511         return (error);
1512 }
1513
1514 static int
1515 nandfs_rename(struct vop_rename_args *ap)
1516 {
1517         struct vnode *tvp = ap->a_tvp;
1518         struct vnode *tdvp = ap->a_tdvp;
1519         struct vnode *fvp = ap->a_fvp;
1520         struct vnode *fdvp = ap->a_fdvp;
1521         struct componentname *tcnp = ap->a_tcnp;
1522         struct componentname *fcnp = ap->a_fcnp;
1523         int doingdirectory = 0, oldparent = 0, newparent = 0;
1524         int error = 0;
1525
1526         struct nandfs_node *fdnode, *fnode, *fnode1;
1527         struct nandfs_node *tdnode = VTON(tdvp);
1528         struct nandfs_node *tnode;
1529
1530         uint32_t tdflags, fflags, fdflags;
1531         uint16_t mode;
1532
1533         DPRINTF(VNCALL, ("%s: fdvp:%p fvp:%p tdvp:%p tdp:%p\n", __func__, fdvp,
1534             fvp, tdvp, tvp));
1535
1536         /*
1537          * Check for cross-device rename.
1538          */
1539         if ((fvp->v_mount != tdvp->v_mount) ||
1540             (tvp && (fvp->v_mount != tvp->v_mount))) {
1541                 error = EXDEV;
1542 abortit:
1543                 if (tdvp == tvp)
1544                         vrele(tdvp);
1545                 else
1546                         vput(tdvp);
1547                 if (tvp)
1548                         vput(tvp);
1549                 vrele(fdvp);
1550                 vrele(fvp);
1551                 return (error);
1552         }
1553
1554         tdflags = tdnode->nn_inode.i_flags;
1555         if (tvp &&
1556             ((VTON(tvp)->nn_inode.i_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
1557             (tdflags & APPEND))) {
1558                 error = EPERM;
1559                 goto abortit;
1560         }
1561
1562         /*
1563          * Renaming a file to itself has no effect.  The upper layers should
1564          * not call us in that case.  Temporarily just warn if they do.
1565          */
1566         if (fvp == tvp) {
1567                 printf("nandfs_rename: fvp == tvp (can't happen)\n");
1568                 error = 0;
1569                 goto abortit;
1570         }
1571
1572         if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
1573                 goto abortit;
1574
1575         fdnode = VTON(fdvp);
1576         fnode = VTON(fvp);
1577
1578         if (fnode->nn_inode.i_links_count >= NANDFS_LINK_MAX) {
1579                 VOP_UNLOCK(fvp, 0);
1580                 error = EMLINK;
1581                 goto abortit;
1582         }
1583
1584         fflags = fnode->nn_inode.i_flags;
1585         fdflags = fdnode->nn_inode.i_flags;
1586
1587         if ((fflags & (NOUNLINK | IMMUTABLE | APPEND)) ||
1588             (fdflags & APPEND)) {
1589                 VOP_UNLOCK(fvp, 0);
1590                 error = EPERM;
1591                 goto abortit;
1592         }
1593
1594         mode = fnode->nn_inode.i_mode;
1595         if ((mode & S_IFMT) == S_IFDIR) {
1596                 /*
1597                  * Avoid ".", "..", and aliases of "." for obvious reasons.
1598                  */
1599
1600                 if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') ||
1601                     (fdvp == fvp) ||
1602                     ((fcnp->cn_flags | tcnp->cn_flags) & ISDOTDOT) ||
1603                     (fnode->nn_flags & IN_RENAME)) {
1604                         VOP_UNLOCK(fvp, 0);
1605                         error = EINVAL;
1606                         goto abortit;
1607                 }
1608                 fnode->nn_flags |= IN_RENAME;
1609                 doingdirectory = 1;
1610                 DPRINTF(VNCALL, ("%s: doingdirectory dvp %p\n", __func__,
1611                     tdvp));
1612                 oldparent = fdnode->nn_ino;
1613         }
1614
1615         vrele(fdvp);
1616
1617         tnode = NULL;
1618         if (tvp)
1619                 tnode = VTON(tvp);
1620
1621         /*
1622          * Bump link count on fvp while we are moving stuff around. If we
1623          * crash before completing the work, the link count may be wrong
1624          * but correctable.
1625          */
1626         fnode->nn_inode.i_links_count++;
1627
1628         /* Check for in path moving XXX */
1629         error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_thread);
1630         VOP_UNLOCK(fvp, 0);
1631         if (oldparent != tdnode->nn_ino)
1632                 newparent = tdnode->nn_ino;
1633         if (doingdirectory && newparent) {
1634                 if (error)      /* write access check above */
1635                         goto bad;
1636                 if (tnode != NULL)
1637                         vput(tvp);
1638
1639                 error = nandfs_checkpath(fnode, tdnode, tcnp->cn_cred);
1640                 if (error)
1641                         goto out;
1642
1643                 VREF(tdvp);
1644                 error = relookup(tdvp, &tvp, tcnp);
1645                 if (error)
1646                         goto out;
1647                 vrele(tdvp);
1648                 tdnode = VTON(tdvp);
1649                 tnode = NULL;
1650                 if (tvp)
1651                         tnode = VTON(tvp);
1652         }
1653
1654         /*
1655          * If the target doesn't exist, link the target to the source and
1656          * unlink the source. Otherwise, rewrite the target directory to
1657          * reference the source and remove the original entry.
1658          */
1659
1660         if (tvp == NULL) {
1661                 /*
1662                  * Account for ".." in new directory.
1663                  */
1664                 if (doingdirectory && fdvp != tdvp)
1665                         tdnode->nn_inode.i_links_count++;
1666
1667                 DPRINTF(VNCALL, ("%s: new entry in dvp:%p\n", __func__, tdvp));
1668                 /*
1669                  * Add name in new directory.
1670                  */
1671                 error = nandfs_add_dirent(tdvp, fnode->nn_ino, tcnp->cn_nameptr,
1672                     tcnp->cn_namelen, IFTODT(fnode->nn_inode.i_mode));
1673                 if (error) {
1674                         if (doingdirectory && fdvp != tdvp)
1675                                 tdnode->nn_inode.i_links_count--;
1676                         goto bad;
1677                 }
1678
1679                 vput(tdvp);
1680         } else {
1681                 /*
1682                  * If the parent directory is "sticky", then the user must
1683                  * own the parent directory, or the destination of the rename,
1684                  * otherwise the destination may not be changed (except by
1685                  * root). This implements append-only directories.
1686                  */
1687                 if ((tdnode->nn_inode.i_mode & S_ISTXT) &&
1688                     tcnp->cn_cred->cr_uid != 0 &&
1689                     tcnp->cn_cred->cr_uid != tdnode->nn_inode.i_uid &&
1690                     tnode->nn_inode.i_uid != tcnp->cn_cred->cr_uid) {
1691                         error = EPERM;
1692                         goto bad;
1693                 }
1694                 /*
1695                  * Target must be empty if a directory and have no links
1696                  * to it. Also, ensure source and target are compatible
1697                  * (both directories, or both not directories).
1698                  */
1699                 mode = tnode->nn_inode.i_mode;
1700                 if ((mode & S_IFMT) == S_IFDIR) {
1701                         if (!nandfs_dirempty(tvp, tdnode->nn_ino,
1702                             tcnp->cn_cred)) {
1703                                 error = ENOTEMPTY;
1704                                 goto bad;
1705                         }
1706                         if (!doingdirectory) {
1707                                 error = ENOTDIR;
1708                                 goto bad;
1709                         }
1710                         /*
1711                          * Update name cache since directory is going away.
1712                          */
1713                         cache_purge(tdvp);
1714                 } else if (doingdirectory) {
1715                         error = EISDIR;
1716                         goto bad;
1717                 }
1718
1719                 DPRINTF(VNCALL, ("%s: update entry dvp:%p\n", __func__, tdvp));
1720                 /*
1721                  * Change name tcnp in tdvp to point at fvp.
1722                  */
1723                 error = nandfs_update_dirent(tdvp, fnode, tnode);
1724                 if (error)
1725                         goto bad;
1726
1727                 if (doingdirectory && !newparent)
1728                         tdnode->nn_inode.i_links_count--;
1729
1730                 vput(tdvp);
1731
1732                 tnode->nn_inode.i_links_count--;
1733                 vput(tvp);
1734                 tnode = NULL;
1735         }
1736
1737         /*
1738          * Unlink the source.
1739          */
1740         fcnp->cn_flags &= ~MODMASK;
1741         fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
1742         VREF(fdvp);
1743         error = relookup(fdvp, &fvp, fcnp);
1744         if (error == 0)
1745                 vrele(fdvp);
1746         if (fvp != NULL) {
1747                 fnode1 = VTON(fvp);
1748                 fdnode = VTON(fdvp);
1749         } else {
1750                 /*
1751                  * From name has disappeared.
1752                  */
1753                 if (doingdirectory)
1754                         panic("nandfs_rename: lost dir entry");
1755                 vrele(ap->a_fvp);
1756                 return (0);
1757         }
1758
1759         DPRINTF(VNCALL, ("%s: unlink source fnode:%p\n", __func__, fnode));
1760
1761         /*
1762          * Ensure that the directory entry still exists and has not
1763          * changed while the new name has been entered. If the source is
1764          * a file then the entry may have been unlinked or renamed. In
1765          * either case there is no further work to be done. If the source
1766          * is a directory then it cannot have been rmdir'ed; its link
1767          * count of three would cause a rmdir to fail with ENOTEMPTY.
1768          * The IN_RENAME flag ensures that it cannot be moved by another
1769          * rename.
1770          */
1771         if (fnode != fnode1) {
1772                 if (doingdirectory)
1773                         panic("nandfs: lost dir entry");
1774         } else {
1775                 /*
1776                  * If the source is a directory with a
1777                  * new parent, the link count of the old
1778                  * parent directory must be decremented
1779                  * and ".." set to point to the new parent.
1780                  */
1781                 if (doingdirectory && newparent) {
1782                         DPRINTF(VNCALL, ("%s: new parent %#jx -> %#jx\n",
1783                             __func__, (uintmax_t) oldparent,
1784                             (uintmax_t) newparent));
1785                         error = nandfs_update_parent_dir(fvp, newparent);
1786                         if (!error) {
1787                                 fdnode->nn_inode.i_links_count--;
1788                                 fdnode->nn_flags |= IN_CHANGE;
1789                         }
1790                 }
1791                 error = nandfs_remove_dirent(fdvp, fnode, fcnp);
1792                 if (!error) {
1793                         fnode->nn_inode.i_links_count--;
1794                         fnode->nn_flags |= IN_CHANGE;
1795                 }
1796                 fnode->nn_flags &= ~IN_RENAME;
1797         }
1798         if (fdnode)
1799                 vput(fdvp);
1800         if (fnode)
1801                 vput(fvp);
1802         vrele(ap->a_fvp);
1803         return (error);
1804
1805 bad:
1806         DPRINTF(VNCALL, ("%s: error:%d\n", __func__, error));
1807         if (tnode)
1808                 vput(NTOV(tnode));
1809         vput(NTOV(tdnode));
1810 out:
1811         if (doingdirectory)
1812                 fnode->nn_flags &= ~IN_RENAME;
1813         if (vn_lock(fvp, LK_EXCLUSIVE) == 0) {
1814                 fnode->nn_inode.i_links_count--;
1815                 fnode->nn_flags |= IN_CHANGE;
1816                 fnode->nn_flags &= ~IN_RENAME;
1817                 vput(fvp);
1818         } else
1819                 vrele(fvp);
1820         return (error);
1821 }
1822
1823 static int
1824 nandfs_mkdir(struct vop_mkdir_args *ap)
1825 {
1826         struct vnode *dvp = ap->a_dvp;
1827         struct vnode **vpp = ap->a_vpp;
1828         struct componentname *cnp = ap->a_cnp;
1829         struct nandfs_node *dir_node = VTON(dvp);
1830         struct nandfs_inode *dir_inode = &dir_node->nn_inode;
1831         struct nandfs_node *node;
1832         struct nandfsmount *nmp = dir_node->nn_nmp;
1833         uint16_t mode = MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode);
1834         int error;
1835
1836         DPRINTF(VNCALL, ("%s: dvp %p\n", __func__, dvp));
1837
1838         if (nandfs_fs_full(dir_node->nn_nandfsdev))
1839                 return (ENOSPC);
1840
1841         if (dir_inode->i_links_count >= NANDFS_LINK_MAX)
1842                 return (EMLINK);
1843
1844         error = nandfs_node_create(nmp, &node, mode);
1845         if (error)
1846                 return (error);
1847
1848         node->nn_inode.i_gid = dir_node->nn_inode.i_gid;
1849         node->nn_inode.i_uid = cnp->cn_cred->cr_uid;
1850
1851         *vpp = NTOV(node);
1852
1853         error = nandfs_add_dirent(dvp, node->nn_ino, cnp->cn_nameptr,
1854             cnp->cn_namelen, IFTODT(mode));
1855         if (error) {
1856                 vput(*vpp);
1857                 return (error);
1858         }
1859
1860         dir_node->nn_inode.i_links_count++;
1861         dir_node->nn_flags |= IN_CHANGE;
1862
1863         error = nandfs_init_dir(NTOV(node), node->nn_ino, dir_node->nn_ino);
1864         if (error) {
1865                 vput(NTOV(node));
1866                 return (error);
1867         }
1868
1869         DPRINTF(VNCALL, ("created dir vp %p nandnode %p ino %jx\n", *vpp, node,
1870             (uintmax_t)node->nn_ino));
1871         return (0);
1872 }
1873
1874 static int
1875 nandfs_mknod(struct vop_mknod_args *ap)
1876 {
1877         struct vnode *dvp = ap->a_dvp;
1878         struct vnode **vpp = ap->a_vpp;
1879         struct vattr *vap = ap->a_vap;
1880         uint16_t mode = MAKEIMODE(vap->va_type, vap->va_mode);
1881         struct componentname *cnp = ap->a_cnp;
1882         struct nandfs_node *dir_node = VTON(dvp);
1883         struct nandfsmount *nmp = dir_node->nn_nmp;
1884         struct nandfs_node *node;
1885         int error;
1886
1887         if (nandfs_fs_full(dir_node->nn_nandfsdev))
1888                 return (ENOSPC);
1889
1890         error = nandfs_node_create(nmp, &node, mode);
1891         if (error)
1892                 return (error);
1893         node->nn_inode.i_gid = dir_node->nn_inode.i_gid;
1894         node->nn_inode.i_uid = cnp->cn_cred->cr_uid;
1895         if (vap->va_rdev != VNOVAL)
1896                 node->nn_inode.i_special = vap->va_rdev;
1897
1898         *vpp = NTOV(node);
1899
1900         if (nandfs_add_dirent(dvp, node->nn_ino, cnp->cn_nameptr,
1901             cnp->cn_namelen, IFTODT(mode))) {
1902                 vput(*vpp);
1903                 return (ENOTDIR);
1904         }
1905
1906         node->nn_flags |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
1907
1908         return (0);
1909 }
1910
1911 static int
1912 nandfs_symlink(struct vop_symlink_args *ap)
1913 {
1914         struct vnode **vpp = ap->a_vpp;
1915         struct vnode *dvp = ap->a_dvp;
1916         uint16_t mode = MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode);
1917         struct componentname *cnp = ap->a_cnp;
1918         struct nandfs_node *dir_node = VTON(dvp);
1919         struct nandfsmount *nmp = dir_node->nn_nmp;
1920         struct nandfs_node *node;
1921         int len, error;
1922
1923         if (nandfs_fs_full(dir_node->nn_nandfsdev))
1924                 return (ENOSPC);
1925
1926         error = nandfs_node_create(nmp, &node, S_IFLNK | mode);
1927         if (error)
1928                 return (error);
1929         node->nn_inode.i_gid = dir_node->nn_inode.i_gid;
1930         node->nn_inode.i_uid = cnp->cn_cred->cr_uid;
1931
1932         *vpp = NTOV(node);
1933
1934         if (nandfs_add_dirent(dvp, node->nn_ino, cnp->cn_nameptr,
1935             cnp->cn_namelen, IFTODT(mode))) {
1936                 vput(*vpp);
1937                 return (ENOTDIR);
1938         }
1939
1940
1941         len = strlen(ap->a_target);
1942         error = vn_rdwr(UIO_WRITE, *vpp, ap->a_target, len, (off_t)0,
1943             UIO_SYSSPACE, IO_NODELOCKED | IO_NOMACCHECK,
1944             cnp->cn_cred, NOCRED, NULL, NULL);
1945         if (error)
1946                 vput(*vpp);
1947
1948         return (error);
1949 }
1950
1951 static int
1952 nandfs_readlink(struct vop_readlink_args *ap)
1953 {
1954         struct vnode *vp = ap->a_vp;
1955
1956         return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred));
1957 }
1958
1959 static int
1960 nandfs_rmdir(struct vop_rmdir_args *ap)
1961 {
1962         struct vnode *vp = ap->a_vp;
1963         struct vnode *dvp = ap->a_dvp;
1964         struct componentname *cnp = ap->a_cnp;
1965         struct nandfs_node *node, *dnode;
1966         uint32_t dflag, flag;
1967         int error = 0;
1968
1969         node = VTON(vp);
1970         dnode = VTON(dvp);
1971
1972         /* Files marked as immutable or append-only cannot be deleted. */
1973         if ((node->nn_inode.i_flags & (IMMUTABLE | APPEND | NOUNLINK)) ||
1974             (dnode->nn_inode.i_flags & APPEND))
1975                 return (EPERM);
1976
1977         DPRINTF(VNCALL, ("%s: dvp %p vp %p nandnode %p ino %#jx\n", __func__,
1978             dvp, vp, node, (uintmax_t)node->nn_ino));
1979
1980         if (node->nn_inode.i_links_count < 2)
1981                 return (EINVAL);
1982
1983         if (!nandfs_dirempty(vp, dnode->nn_ino, cnp->cn_cred))
1984                 return (ENOTEMPTY);
1985
1986         /* Files marked as immutable or append-only cannot be deleted. */
1987         dflag = dnode->nn_inode.i_flags;
1988         flag = node->nn_inode.i_flags;
1989         if ((dflag & APPEND) ||
1990             (flag & (NOUNLINK | IMMUTABLE | APPEND))) {
1991                 return (EPERM);
1992         }
1993
1994         if (vp->v_mountedhere != 0)
1995                 return (EINVAL);
1996
1997         nandfs_remove_dirent(dvp, node, cnp);
1998         dnode->nn_inode.i_links_count -= 1;
1999         dnode->nn_flags |= IN_CHANGE;
2000
2001         cache_purge(dvp);
2002
2003         error = nandfs_truncate(vp, (uint64_t)0);
2004         if (error)
2005                 return (error);
2006
2007         node->nn_inode.i_links_count -= 2;
2008         node->nn_flags |= IN_CHANGE;
2009
2010         cache_purge(vp);
2011
2012         return (error);
2013 }
2014
2015 static int
2016 nandfs_fsync(struct vop_fsync_args *ap)
2017 {
2018         struct vnode *vp = ap->a_vp;
2019         struct nandfs_node *node = VTON(vp);
2020         int locked;
2021
2022         DPRINTF(VNCALL, ("%s: vp %p nandnode %p ino %#jx\n", __func__, vp,
2023             node, (uintmax_t)node->nn_ino));
2024
2025         /*
2026          * Start syncing vnode only if inode was modified or
2027          * there are some dirty buffers
2028          */
2029         if (VTON(vp)->nn_flags & IN_MODIFIED ||
2030             vp->v_bufobj.bo_dirty.bv_cnt) {
2031                 locked = VOP_ISLOCKED(vp);
2032                 VOP_UNLOCK(vp, 0);
2033                 nandfs_wakeup_wait_sync(node->nn_nandfsdev, SYNCER_FSYNC);
2034                 VOP_LOCK(vp, locked | LK_RETRY);
2035         }
2036
2037         return (0);
2038 }
2039
2040 static int
2041 nandfs_bmap(struct vop_bmap_args *ap)
2042 {
2043         struct vnode *vp = ap->a_vp;
2044         struct nandfs_node *nnode = VTON(vp);
2045         struct nandfs_device *nandfsdev = nnode->nn_nandfsdev;
2046         nandfs_daddr_t l2vmap, v2pmap;
2047         int error;
2048         int blk2dev = nandfsdev->nd_blocksize / DEV_BSIZE;
2049
2050         DPRINTF(VNCALL, ("%s: vp %p nandnode %p ino %#jx\n", __func__, vp,
2051             nnode, (uintmax_t)nnode->nn_ino));
2052
2053         if (ap->a_bop != NULL)
2054                 *ap->a_bop = &nandfsdev->nd_devvp->v_bufobj;
2055         if (ap->a_bnp == NULL)
2056                 return (0);
2057         if (ap->a_runp != NULL)
2058                 *ap->a_runp = 0;
2059         if (ap->a_runb != NULL)
2060                 *ap->a_runb = 0;
2061
2062         /*
2063          * Translate all the block sectors into a series of buffers to read
2064          * asynchronously from the nandfs device. Note that this lookup may
2065          * induce readin's too.
2066          */
2067
2068         /* Get virtual block numbers for the vnode's buffer span */
2069         error = nandfs_bmap_lookup(nnode, ap->a_bn, &l2vmap);
2070         if (error)
2071                 return (-1);
2072
2073         /* Translate virtual block numbers to physical block numbers */
2074         error = nandfs_vtop(nnode, l2vmap, &v2pmap);
2075         if (error)
2076                 return (-1);
2077
2078         /* Note virtual block 0 marks not mapped */
2079         if (l2vmap == 0)
2080                 *ap->a_bnp = -1;
2081         else
2082                 *ap->a_bnp = v2pmap * blk2dev;  /* in DEV_BSIZE */
2083
2084         DPRINTF(VNCALL, ("%s: vp %p nandnode %p ino %#jx lblk %jx -> blk %jx\n",
2085             __func__, vp, nnode, (uintmax_t)nnode->nn_ino, (uintmax_t)ap->a_bn,
2086             (uintmax_t)*ap->a_bnp ));
2087
2088         return (0);
2089 }
2090
2091 static void
2092 nandfs_force_syncer(struct nandfsmount *nmp)
2093 {
2094
2095         nmp->nm_flags |= NANDFS_FORCE_SYNCER;
2096         nandfs_wakeup_wait_sync(nmp->nm_nandfsdev, SYNCER_FFORCE);
2097 }
2098
2099 static int
2100 nandfs_ioctl(struct vop_ioctl_args *ap)
2101 {
2102         struct vnode *vp = ap->a_vp;
2103         u_long command = ap->a_command;
2104         caddr_t data = ap->a_data;
2105         struct nandfs_node *node = VTON(vp);
2106         struct nandfs_device *nandfsdev = node->nn_nandfsdev;
2107         struct nandfsmount *nmp = node->nn_nmp;
2108         uint64_t *tab, *cno;
2109         struct nandfs_seg_stat *nss;
2110         struct nandfs_cpmode *ncpm;
2111         struct nandfs_argv *nargv;
2112         struct nandfs_cpstat *ncp;
2113         int error;
2114
2115         DPRINTF(VNCALL, ("%s: %x\n", __func__, (uint32_t)command));
2116
2117         error = priv_check(ap->a_td, PRIV_VFS_MOUNT);
2118         if (error)
2119                 return (error);
2120
2121         if (nmp->nm_ronly) {
2122                 switch (command) {
2123                 case NANDFS_IOCTL_GET_FSINFO:
2124                 case NANDFS_IOCTL_GET_SUSTAT:
2125                 case NANDFS_IOCTL_GET_CPINFO:
2126                 case NANDFS_IOCTL_GET_CPSTAT:
2127                 case NANDFS_IOCTL_GET_SUINFO:
2128                 case NANDFS_IOCTL_GET_VINFO:
2129                 case NANDFS_IOCTL_GET_BDESCS:
2130                         break;
2131                 default:
2132                         return (EROFS);
2133                 }
2134         }
2135
2136         switch (command) {
2137         case NANDFS_IOCTL_GET_FSINFO:
2138                 error = nandfs_get_fsinfo(nmp, (struct nandfs_fsinfo *)data);
2139                 break;
2140         case NANDFS_IOCTL_GET_SUSTAT:
2141                 nss = (struct nandfs_seg_stat *)data;
2142                 error = nandfs_get_seg_stat(nandfsdev, nss);
2143                 break;
2144         case NANDFS_IOCTL_CHANGE_CPMODE:
2145                 ncpm = (struct nandfs_cpmode *)data;
2146                 error = nandfs_chng_cpmode(nandfsdev->nd_cp_node, ncpm);
2147                 nandfs_force_syncer(nmp);
2148                 break;
2149         case NANDFS_IOCTL_GET_CPINFO:
2150                 nargv = (struct nandfs_argv *)data;
2151                 error = nandfs_get_cpinfo_ioctl(nandfsdev->nd_cp_node, nargv);
2152                 break;
2153         case NANDFS_IOCTL_DELETE_CP:
2154                 tab = (uint64_t *)data;
2155                 error = nandfs_delete_cp(nandfsdev->nd_cp_node, tab[0], tab[1]);
2156                 nandfs_force_syncer(nmp);
2157                 break;
2158         case NANDFS_IOCTL_GET_CPSTAT:
2159                 ncp = (struct nandfs_cpstat *)data;
2160                 error = nandfs_get_cpstat(nandfsdev->nd_cp_node, ncp);
2161                 break;
2162         case NANDFS_IOCTL_GET_SUINFO:
2163                 nargv = (struct nandfs_argv *)data;
2164                 error = nandfs_get_segment_info_ioctl(nandfsdev, nargv);
2165                 break;
2166         case NANDFS_IOCTL_GET_VINFO:
2167                 nargv = (struct nandfs_argv *)data;
2168                 error = nandfs_get_dat_vinfo_ioctl(nandfsdev, nargv);
2169                 break;
2170         case NANDFS_IOCTL_GET_BDESCS:
2171                 nargv = (struct nandfs_argv *)data;
2172                 error = nandfs_get_dat_bdescs_ioctl(nandfsdev, nargv);
2173                 break;
2174         case NANDFS_IOCTL_SYNC:
2175                 cno = (uint64_t *)data;
2176                 nandfs_force_syncer(nmp);
2177                 *cno = nandfsdev->nd_last_cno;
2178                 error = 0;
2179                 break;
2180         case NANDFS_IOCTL_MAKE_SNAP:
2181                 cno = (uint64_t *)data;
2182                 error = nandfs_make_snap(nandfsdev, cno);
2183                 nandfs_force_syncer(nmp);
2184                 break;
2185         case NANDFS_IOCTL_DELETE_SNAP:
2186                 cno = (uint64_t *)data;
2187                 error = nandfs_delete_snap(nandfsdev, *cno);
2188                 nandfs_force_syncer(nmp);
2189                 break;
2190         default:
2191                 error = ENOTTY;
2192                 break;
2193         }
2194
2195         return (error);
2196 }
2197
2198 /*
2199  * Whiteout vnode call
2200  */
2201 static int
2202 nandfs_whiteout(struct vop_whiteout_args *ap)
2203 {
2204         struct vnode *dvp = ap->a_dvp;
2205         struct componentname *cnp = ap->a_cnp;
2206         int error = 0;
2207
2208         switch (ap->a_flags) {
2209         case LOOKUP:
2210                 return (0);
2211         case CREATE:
2212                 /* Create a new directory whiteout */
2213 #ifdef INVARIANTS
2214                 if ((cnp->cn_flags & SAVENAME) == 0)
2215                         panic("nandfs_whiteout: missing name");
2216 #endif
2217                 error = nandfs_add_dirent(dvp, NANDFS_WHT_INO, cnp->cn_nameptr,
2218                     cnp->cn_namelen, DT_WHT);
2219                 break;
2220
2221         case DELETE:
2222                 /* Remove an existing directory whiteout */
2223                 cnp->cn_flags &= ~DOWHITEOUT;
2224                 error = nandfs_remove_dirent(dvp, NULL, cnp);
2225                 break;
2226         default:
2227                 panic("nandf_whiteout: unknown op: %d", ap->a_flags);
2228         }
2229
2230         return (error);
2231 }
2232
2233 static int
2234 nandfs_pathconf(struct vop_pathconf_args *ap)
2235 {
2236         int error;
2237
2238         error = 0;
2239         switch (ap->a_name) {
2240         case _PC_LINK_MAX:
2241                 *ap->a_retval = NANDFS_LINK_MAX;
2242                 break;
2243         case _PC_NAME_MAX:
2244                 *ap->a_retval = NANDFS_NAME_LEN;
2245                 break;
2246         case _PC_PIPE_BUF:
2247                 if (ap->a_vp->v_type == VDIR || ap->a_vp->v_type == VFIFO)
2248                         *ap->a_retval = PIPE_BUF;
2249                 else
2250                         error = EINVAL;
2251                 break;
2252         case _PC_CHOWN_RESTRICTED:
2253                 *ap->a_retval = 1;
2254                 break;
2255         case _PC_NO_TRUNC:
2256                 *ap->a_retval = 1;
2257                 break;
2258         case _PC_ACL_EXTENDED:
2259                 *ap->a_retval = 0;
2260                 break;
2261         case _PC_ALLOC_SIZE_MIN:
2262                 *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_bsize;
2263                 break;
2264         case _PC_FILESIZEBITS:
2265                 *ap->a_retval = 64;
2266                 break;
2267         case _PC_REC_INCR_XFER_SIZE:
2268                 *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize;
2269                 break;
2270         case _PC_REC_MAX_XFER_SIZE:
2271                 *ap->a_retval = -1; /* means ``unlimited'' */
2272                 break;
2273         case _PC_REC_MIN_XFER_SIZE:
2274                 *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize;
2275                 break;
2276         default:
2277                 error = vop_stdpathconf(ap);
2278                 break;
2279         }
2280         return (error);
2281 }
2282
2283 static int
2284 nandfs_vnlock1(struct vop_lock1_args *ap)
2285 {
2286         struct vnode *vp = ap->a_vp;
2287         struct nandfs_node *node = VTON(vp);
2288         int error, vi_locked;
2289
2290         /*
2291          * XXX can vnode go away while we are sleeping?
2292          */
2293         vi_locked = mtx_owned(&vp->v_interlock);
2294         if (vi_locked)
2295                 VI_UNLOCK(vp);
2296         error = NANDFS_WRITELOCKFLAGS(node->nn_nandfsdev,
2297             ap->a_flags & LK_NOWAIT);
2298         if (vi_locked && !error)
2299                 VI_LOCK(vp);
2300         if (error)
2301                 return (error);
2302
2303         error = vop_stdlock(ap);
2304         if (error) {
2305                 NANDFS_WRITEUNLOCK(node->nn_nandfsdev);
2306                 return (error);
2307         }
2308
2309         return (0);
2310 }
2311
2312 static int
2313 nandfs_vnunlock(struct vop_unlock_args *ap)
2314 {
2315         struct vnode *vp = ap->a_vp;
2316         struct nandfs_node *node = VTON(vp);
2317         int error;
2318
2319         error = vop_stdunlock(ap);
2320         if (error)
2321                 return (error);
2322
2323         NANDFS_WRITEUNLOCK(node->nn_nandfsdev);
2324
2325         return (0);
2326 }
2327
2328 /*
2329  * Global vfs data structures
2330  */
2331 struct vop_vector nandfs_vnodeops = {
2332         .vop_default =          &default_vnodeops,
2333         .vop_access =           nandfs_access,
2334         .vop_advlock =          nandfs_advlock,
2335         .vop_bmap =             nandfs_bmap,
2336         .vop_close =            nandfs_close,
2337         .vop_create =           nandfs_create,
2338         .vop_fsync =            nandfs_fsync,
2339         .vop_getattr =          nandfs_getattr,
2340         .vop_inactive =         nandfs_inactive,
2341         .vop_cachedlookup =     nandfs_lookup,
2342         .vop_ioctl =            nandfs_ioctl,
2343         .vop_link =             nandfs_link,
2344         .vop_lookup =           vfs_cache_lookup,
2345         .vop_mkdir =            nandfs_mkdir,
2346         .vop_mknod =            nandfs_mknod,
2347         .vop_open =             nandfs_open,
2348         .vop_pathconf =         nandfs_pathconf,
2349         .vop_print =            nandfs_print,
2350         .vop_read =             nandfs_read,
2351         .vop_readdir =          nandfs_readdir,
2352         .vop_readlink =         nandfs_readlink,
2353         .vop_reclaim =          nandfs_reclaim,
2354         .vop_remove =           nandfs_remove,
2355         .vop_rename =           nandfs_rename,
2356         .vop_rmdir =            nandfs_rmdir,
2357         .vop_whiteout =         nandfs_whiteout,
2358         .vop_write =            nandfs_write,
2359         .vop_setattr =          nandfs_setattr,
2360         .vop_strategy =         nandfs_strategy,
2361         .vop_symlink =          nandfs_symlink,
2362         .vop_lock1 =            nandfs_vnlock1,
2363         .vop_unlock =           nandfs_vnunlock,
2364 };
2365
2366 struct vop_vector nandfs_system_vnodeops = {
2367         .vop_default =          &default_vnodeops,
2368         .vop_close =            nandfs_close,
2369         .vop_inactive =         nandfs_inactive,
2370         .vop_reclaim =          nandfs_reclaim,
2371         .vop_strategy =         nandfs_strategy,
2372         .vop_fsync =            nandfs_fsync,
2373         .vop_bmap =             nandfs_bmap,
2374         .vop_access =           VOP_PANIC,
2375         .vop_advlock =          VOP_PANIC,
2376         .vop_create =           VOP_PANIC,
2377         .vop_getattr =          VOP_PANIC,
2378         .vop_cachedlookup =     VOP_PANIC,
2379         .vop_ioctl =            VOP_PANIC,
2380         .vop_link =             VOP_PANIC,
2381         .vop_lookup =           VOP_PANIC,
2382         .vop_mkdir =            VOP_PANIC,
2383         .vop_mknod =            VOP_PANIC,
2384         .vop_open =             VOP_PANIC,
2385         .vop_pathconf =         VOP_PANIC,
2386         .vop_print =            VOP_PANIC,
2387         .vop_read =             VOP_PANIC,
2388         .vop_readdir =          VOP_PANIC,
2389         .vop_readlink =         VOP_PANIC,
2390         .vop_remove =           VOP_PANIC,
2391         .vop_rename =           VOP_PANIC,
2392         .vop_rmdir =            VOP_PANIC,
2393         .vop_whiteout =         VOP_PANIC,
2394         .vop_write =            VOP_PANIC,
2395         .vop_setattr =          VOP_PANIC,
2396         .vop_symlink =          VOP_PANIC,
2397 };
2398
2399 static int
2400 nandfsfifo_close(struct vop_close_args *ap)
2401 {
2402         struct vnode *vp = ap->a_vp;
2403         struct nandfs_node *node = VTON(vp);
2404
2405         DPRINTF(VNCALL, ("%s: vp %p node %p\n", __func__, vp, node));
2406
2407         mtx_lock(&vp->v_interlock);
2408         if (vp->v_usecount > 1)
2409                 nandfs_itimes_locked(vp);
2410         mtx_unlock(&vp->v_interlock);
2411
2412         return (fifo_specops.vop_close(ap));
2413 }
2414
2415 struct vop_vector nandfs_fifoops = {
2416         .vop_default =          &fifo_specops,
2417         .vop_fsync =            VOP_PANIC,
2418         .vop_access =           nandfs_access,
2419         .vop_close =            nandfsfifo_close,
2420         .vop_getattr =          nandfs_getattr,
2421         .vop_inactive =         nandfs_inactive,
2422         .vop_pathconf =         nandfs_pathconf,
2423         .vop_print =            nandfs_print,
2424         .vop_read =             VOP_PANIC,
2425         .vop_reclaim =          nandfs_reclaim,
2426         .vop_setattr =          nandfs_setattr,
2427         .vop_write =            VOP_PANIC,
2428         .vop_lock1 =            nandfs_vnlock1,
2429         .vop_unlock =           nandfs_vnunlock,
2430 };
2431
2432 int
2433 nandfs_vinit(struct vnode *vp, uint64_t ino)
2434 {
2435         struct nandfs_node *node;
2436
2437         ASSERT_VOP_LOCKED(vp, __func__);
2438
2439         node = VTON(vp);
2440
2441         /* Check if we're fetching the root */
2442         if (ino == NANDFS_ROOT_INO)
2443                 vp->v_vflag |= VV_ROOT;
2444
2445         if (ino != NANDFS_GC_INO)
2446                 vp->v_type = IFTOVT(node->nn_inode.i_mode);
2447         else
2448                 vp->v_type = VREG;
2449
2450         if (vp->v_type == VFIFO)
2451                 vp->v_op = &nandfs_fifoops;
2452
2453         return (0);
2454 }