1235537Sgber/*- 2235537Sgber * Copyright (c) 2010-2012 Semihalf 3235537Sgber * Copyright (c) 2008, 2009 Reinoud Zandijk 4235537Sgber * All rights reserved. 5235537Sgber * 6235537Sgber * Redistribution and use in source and binary forms, with or without 7235537Sgber * modification, are permitted provided that the following conditions 8235537Sgber * are met: 9235537Sgber * 1. Redistributions of source code must retain the above copyright 10235537Sgber * notice, this list of conditions and the following disclaimer. 11235537Sgber * 2. Redistributions in binary form must reproduce the above copyright 12235537Sgber * notice, this list of conditions and the following disclaimer in the 13235537Sgber * documentation and/or other materials provided with the distribution. 14235537Sgber * 15235537Sgber * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16235537Sgber * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17235537Sgber * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18235537Sgber * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19235537Sgber * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20235537Sgber * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21235537Sgber * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22235537Sgber * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23235537Sgber * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24235537Sgber * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25235537Sgber * 26235537Sgber * From: NetBSD: nilfs_vnops.c,v 1.2 2009/08/26 03:40:48 elad 27235537Sgber */ 28235537Sgber 29235537Sgber#include <sys/cdefs.h> 30235537Sgber__FBSDID("$FreeBSD$"); 31235537Sgber 32235537Sgber#include <sys/param.h> 33235537Sgber#include <sys/systm.h> 34235537Sgber#include <sys/conf.h> 35235537Sgber#include <sys/kernel.h> 36235537Sgber#include <sys/lock.h> 37235537Sgber#include <sys/lockf.h> 38235537Sgber#include <sys/malloc.h> 39235537Sgber#include <sys/mount.h> 40235537Sgber#include <sys/mutex.h> 41235537Sgber#include <sys/namei.h> 42235537Sgber#include <sys/sysctl.h> 43235537Sgber#include <sys/unistd.h> 44235537Sgber#include <sys/vnode.h> 45235537Sgber#include <sys/buf.h> 46235537Sgber#include <sys/bio.h> 47235537Sgber#include <sys/fcntl.h> 48235537Sgber#include <sys/dirent.h> 49251171Sjeff#include <sys/rwlock.h> 50235537Sgber#include <sys/stat.h> 51235537Sgber#include <sys/priv.h> 52235537Sgber 53235537Sgber#include <vm/vm.h> 54235537Sgber#include <vm/vm_extern.h> 55235537Sgber#include <vm/vm_object.h> 56235537Sgber#include <vm/vnode_pager.h> 57235537Sgber 58235537Sgber#include <machine/_inttypes.h> 59235537Sgber 60235537Sgber#include <fs/nandfs/nandfs_mount.h> 61235537Sgber#include <fs/nandfs/nandfs.h> 62235537Sgber#include <fs/nandfs/nandfs_subr.h> 63235537Sgber 64235537Sgberextern uma_zone_t nandfs_node_zone; 65235537Sgberstatic void nandfs_read_filebuf(struct nandfs_node *, struct buf *); 66235537Sgberstatic void nandfs_itimes_locked(struct vnode *); 67235537Sgberstatic int nandfs_truncate(struct vnode *, uint64_t); 68235537Sgber 69235537Sgberstatic vop_pathconf_t nandfs_pathconf; 70235537Sgber 71235537Sgber#define UPDATE_CLOSE 0 72235537Sgber#define UPDATE_WAIT 0 73235537Sgber 74235537Sgberstatic int 75235537Sgbernandfs_inactive(struct vop_inactive_args *ap) 76235537Sgber{ 77235537Sgber struct vnode *vp = ap->a_vp; 78235537Sgber struct nandfs_node *node = VTON(vp); 79235537Sgber int error = 0; 80235537Sgber 81235537Sgber DPRINTF(VNCALL, ("%s: vp:%p node:%p\n", __func__, vp, node)); 82235537Sgber 83235537Sgber if (node == NULL) { 84235537Sgber DPRINTF(NODE, ("%s: inactive NULL node\n", __func__)); 85235537Sgber return (0); 86235537Sgber } 87235537Sgber 88235537Sgber if (node->nn_inode.i_mode != 0 && !(node->nn_inode.i_links_count)) { 89235537Sgber nandfs_truncate(vp, 0); 90235537Sgber error = nandfs_node_destroy(node); 91235537Sgber if (error) 92235537Sgber nandfs_error("%s: destroy node: %p\n", __func__, node); 93235537Sgber node->nn_flags = 0; 94235537Sgber vrecycle(vp); 95235537Sgber } 96235537Sgber 97235537Sgber return (error); 98235537Sgber} 99235537Sgber 100235537Sgberstatic int 101235537Sgbernandfs_reclaim(struct vop_reclaim_args *ap) 102235537Sgber{ 103235537Sgber struct vnode *vp = ap->a_vp; 104235537Sgber struct nandfs_node *nandfs_node = VTON(vp); 105235537Sgber struct nandfs_device *fsdev = nandfs_node->nn_nandfsdev; 106235537Sgber uint64_t ino = nandfs_node->nn_ino; 107235537Sgber 108235537Sgber DPRINTF(VNCALL, ("%s: vp:%p node:%p\n", __func__, vp, nandfs_node)); 109235537Sgber 110235537Sgber /* Invalidate all entries to a particular vnode. */ 111235537Sgber cache_purge(vp); 112235537Sgber 113235537Sgber /* Destroy the vm object and flush associated pages. */ 114235537Sgber vnode_destroy_vobject(vp); 115235537Sgber 116235537Sgber /* Remove from vfs hash if not system vnode */ 117235537Sgber if (!NANDFS_SYS_NODE(nandfs_node->nn_ino)) 118235537Sgber vfs_hash_remove(vp); 119235537Sgber 120235537Sgber /* Dispose all node knowledge */ 121235537Sgber nandfs_dispose_node(&nandfs_node); 122235537Sgber 123235537Sgber if (!NANDFS_SYS_NODE(ino)) 124235537Sgber NANDFS_WRITEUNLOCK(fsdev); 125235537Sgber 126235537Sgber return (0); 127235537Sgber} 128235537Sgber 129235537Sgberstatic int 130235537Sgbernandfs_read(struct vop_read_args *ap) 131235537Sgber{ 132235537Sgber register struct vnode *vp = ap->a_vp; 133235537Sgber register struct nandfs_node *node = VTON(vp); 134235537Sgber struct nandfs_device *nandfsdev = node->nn_nandfsdev; 135235537Sgber struct uio *uio = ap->a_uio; 136235537Sgber struct buf *bp; 137235537Sgber uint64_t size; 138235537Sgber uint32_t blocksize; 139235537Sgber off_t bytesinfile; 140235537Sgber ssize_t toread, off; 141235537Sgber daddr_t lbn; 142235537Sgber ssize_t resid; 143235537Sgber int error = 0; 144235537Sgber 145235537Sgber if (uio->uio_resid == 0) 146235537Sgber return (0); 147235537Sgber 148235537Sgber size = node->nn_inode.i_size; 149235537Sgber if (uio->uio_offset >= size) 150235537Sgber return (0); 151235537Sgber 152235537Sgber blocksize = nandfsdev->nd_blocksize; 153235537Sgber bytesinfile = size - uio->uio_offset; 154235537Sgber 155235537Sgber resid = omin(uio->uio_resid, bytesinfile); 156235537Sgber 157235537Sgber while (resid) { 158235537Sgber lbn = uio->uio_offset / blocksize; 159235537Sgber off = uio->uio_offset & (blocksize - 1); 160235537Sgber 161235537Sgber toread = omin(resid, blocksize - off); 162235537Sgber 163235537Sgber DPRINTF(READ, ("nandfs_read bn: 0x%jx toread: 0x%zx (0x%x)\n", 164235537Sgber (uintmax_t)lbn, toread, blocksize)); 165235537Sgber 166235537Sgber error = nandfs_bread(node, lbn, NOCRED, 0, &bp); 167235537Sgber if (error) { 168235537Sgber brelse(bp); 169235537Sgber break; 170235537Sgber } 171235537Sgber 172235537Sgber error = uiomove(bp->b_data + off, toread, uio); 173235537Sgber if (error) { 174235537Sgber brelse(bp); 175235537Sgber break; 176235537Sgber } 177235537Sgber 178235537Sgber brelse(bp); 179235537Sgber resid -= toread; 180235537Sgber } 181235537Sgber 182235537Sgber return (error); 183235537Sgber} 184235537Sgber 185235537Sgberstatic int 186235537Sgbernandfs_write(struct vop_write_args *ap) 187235537Sgber{ 188235537Sgber struct nandfs_device *fsdev; 189235537Sgber struct nandfs_node *node; 190235537Sgber struct vnode *vp; 191235537Sgber struct uio *uio; 192235537Sgber struct buf *bp; 193235537Sgber uint64_t file_size, vblk; 194235537Sgber uint32_t blocksize; 195235537Sgber ssize_t towrite, off; 196235537Sgber daddr_t lbn; 197235537Sgber ssize_t resid; 198235537Sgber int error, ioflag, modified; 199235537Sgber 200235537Sgber vp = ap->a_vp; 201235537Sgber uio = ap->a_uio; 202235537Sgber ioflag = ap->a_ioflag; 203235537Sgber node = VTON(vp); 204235537Sgber fsdev = node->nn_nandfsdev; 205235537Sgber 206235537Sgber if (nandfs_fs_full(fsdev)) 207235537Sgber return (ENOSPC); 208235537Sgber 209235537Sgber DPRINTF(WRITE, ("nandfs_write called %#zx at %#jx\n", 210235537Sgber uio->uio_resid, (uintmax_t)uio->uio_offset)); 211235537Sgber 212235537Sgber if (uio->uio_offset < 0) 213235537Sgber return (EINVAL); 214235537Sgber if (uio->uio_resid == 0) 215235537Sgber return (0); 216235537Sgber 217235537Sgber blocksize = fsdev->nd_blocksize; 218235537Sgber file_size = node->nn_inode.i_size; 219235537Sgber 220235537Sgber switch (vp->v_type) { 221235537Sgber case VREG: 222235537Sgber if (ioflag & IO_APPEND) 223235537Sgber uio->uio_offset = file_size; 224235537Sgber break; 225235537Sgber case VDIR: 226235537Sgber return (EISDIR); 227235537Sgber case VLNK: 228235537Sgber break; 229235537Sgber default: 230235537Sgber panic("%s: bad file type vp: %p", __func__, vp); 231235537Sgber } 232235537Sgber 233235537Sgber /* If explicitly asked to append, uio_offset can be wrong? */ 234235537Sgber if (ioflag & IO_APPEND) 235235537Sgber uio->uio_offset = file_size; 236235537Sgber 237235537Sgber resid = uio->uio_resid; 238235537Sgber modified = error = 0; 239235537Sgber 240235537Sgber while (uio->uio_resid) { 241235537Sgber lbn = uio->uio_offset / blocksize; 242235537Sgber off = uio->uio_offset & (blocksize - 1); 243235537Sgber 244235537Sgber towrite = omin(uio->uio_resid, blocksize - off); 245235537Sgber 246235537Sgber DPRINTF(WRITE, ("%s: lbn: 0x%jd toread: 0x%zx (0x%x)\n", 247235537Sgber __func__, (uintmax_t)lbn, towrite, blocksize)); 248235537Sgber 249235537Sgber error = nandfs_bmap_lookup(node, lbn, &vblk); 250235537Sgber if (error) 251235537Sgber break; 252235537Sgber 253235537Sgber DPRINTF(WRITE, ("%s: lbn: 0x%jd toread: 0x%zx (0x%x) " 254235537Sgber "vblk=%jx\n", __func__, (uintmax_t)lbn, towrite, blocksize, 255235537Sgber vblk)); 256235537Sgber 257235537Sgber if (vblk != 0) 258235537Sgber error = nandfs_bread(node, lbn, NOCRED, 0, &bp); 259235537Sgber else 260235537Sgber error = nandfs_bcreate(node, lbn, NOCRED, 0, &bp); 261235537Sgber 262235537Sgber DPRINTF(WRITE, ("%s: vp %p bread bp %p lbn %#jx\n", __func__, 263235537Sgber vp, bp, (uintmax_t)lbn)); 264235537Sgber if (error) { 265235537Sgber if (bp) 266235537Sgber brelse(bp); 267235537Sgber break; 268235537Sgber } 269235537Sgber 270235537Sgber error = uiomove((char *)bp->b_data + off, (int)towrite, uio); 271235537Sgber if (error) 272235537Sgber break; 273235537Sgber 274235537Sgber error = nandfs_dirty_buf(bp, 0); 275235537Sgber if (error) 276235537Sgber break; 277235537Sgber 278235537Sgber modified++; 279235537Sgber } 280235537Sgber 281235537Sgber /* XXX proper handling when only part of file was properly written */ 282235537Sgber if (modified) { 283235537Sgber if (resid > uio->uio_resid && ap->a_cred && 284235537Sgber ap->a_cred->cr_uid != 0) 285235537Sgber node->nn_inode.i_mode &= ~(ISUID | ISGID); 286235537Sgber 287235537Sgber if (file_size < uio->uio_offset + uio->uio_resid) { 288235537Sgber node->nn_inode.i_size = uio->uio_offset + 289235537Sgber uio->uio_resid; 290235537Sgber node->nn_flags |= IN_CHANGE | IN_UPDATE; 291235537Sgber vnode_pager_setsize(vp, uio->uio_offset + 292235537Sgber uio->uio_resid); 293235537Sgber nandfs_itimes(vp); 294235537Sgber } 295235537Sgber } 296235537Sgber 297235537Sgber DPRINTF(WRITE, ("%s: return:%d\n", __func__, error)); 298235537Sgber 299235537Sgber return (error); 300235537Sgber} 301235537Sgber 302235537Sgberstatic int 303235537Sgbernandfs_lookup(struct vop_cachedlookup_args *ap) 304235537Sgber{ 305235537Sgber struct vnode *dvp, **vpp; 306235537Sgber struct componentname *cnp; 307235537Sgber struct ucred *cred; 308235537Sgber struct thread *td; 309235537Sgber struct nandfs_node *dir_node, *node; 310235537Sgber struct nandfsmount *nmp; 311235537Sgber uint64_t ino, off; 312235537Sgber const char *name; 313235537Sgber int namelen, nameiop, islastcn, mounted_ro; 314235537Sgber int error, found; 315235537Sgber 316235537Sgber DPRINTF(VNCALL, ("%s\n", __func__)); 317235537Sgber 318235537Sgber dvp = ap->a_dvp; 319235537Sgber vpp = ap->a_vpp; 320235537Sgber *vpp = NULL; 321235537Sgber 322235537Sgber cnp = ap->a_cnp; 323235537Sgber cred = cnp->cn_cred; 324235537Sgber td = cnp->cn_thread; 325235537Sgber 326235537Sgber dir_node = VTON(dvp); 327235537Sgber nmp = dir_node->nn_nmp; 328235537Sgber 329235537Sgber /* Simplify/clarification flags */ 330235537Sgber nameiop = cnp->cn_nameiop; 331235537Sgber islastcn = cnp->cn_flags & ISLASTCN; 332235537Sgber mounted_ro = dvp->v_mount->mnt_flag & MNT_RDONLY; 333235537Sgber 334235537Sgber /* 335235537Sgber * If requesting a modify on the last path element on a read-only 336235537Sgber * filingsystem, reject lookup; 337235537Sgber */ 338235537Sgber if (islastcn && mounted_ro && (nameiop == DELETE || nameiop == RENAME)) 339235537Sgber return (EROFS); 340235537Sgber 341235537Sgber if (dir_node->nn_inode.i_links_count == 0) 342235537Sgber return (ENOENT); 343235537Sgber 344235537Sgber /* 345235537Sgber * Obviously, the file is not (anymore) in the namecache, we have to 346235537Sgber * search for it. There are three basic cases: '.', '..' and others. 347235537Sgber * 348235537Sgber * Following the guidelines of VOP_LOOKUP manpage and tmpfs. 349235537Sgber */ 350235537Sgber error = 0; 351235537Sgber if ((cnp->cn_namelen == 1) && (cnp->cn_nameptr[0] == '.')) { 352235537Sgber DPRINTF(LOOKUP, ("\tlookup '.'\n")); 353235537Sgber /* Special case 1 '.' */ 354235537Sgber VREF(dvp); 355235537Sgber *vpp = dvp; 356235537Sgber /* Done */ 357235537Sgber } else if (cnp->cn_flags & ISDOTDOT) { 358235537Sgber /* Special case 2 '..' */ 359235537Sgber DPRINTF(LOOKUP, ("\tlookup '..'\n")); 360235537Sgber 361235537Sgber /* Get our node */ 362235537Sgber name = ".."; 363235537Sgber namelen = 2; 364235537Sgber error = nandfs_lookup_name_in_dir(dvp, name, namelen, &ino, 365235537Sgber &found, &off); 366235537Sgber if (error) 367235537Sgber goto out; 368235537Sgber if (!found) 369235537Sgber error = ENOENT; 370235537Sgber 371235537Sgber /* First unlock parent */ 372235537Sgber VOP_UNLOCK(dvp, 0); 373235537Sgber 374235537Sgber if (error == 0) { 375235537Sgber DPRINTF(LOOKUP, ("\tfound '..'\n")); 376235537Sgber /* Try to create/reuse the node */ 377235537Sgber error = nandfs_get_node(nmp, ino, &node); 378235537Sgber 379235537Sgber if (!error) { 380235537Sgber DPRINTF(LOOKUP, 381235537Sgber ("\tnode retrieved/created OK\n")); 382235537Sgber *vpp = NTOV(node); 383235537Sgber } 384235537Sgber } 385235537Sgber 386235537Sgber /* Try to relock parent */ 387235537Sgber vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 388235537Sgber } else { 389235537Sgber DPRINTF(LOOKUP, ("\tlookup file\n")); 390235537Sgber /* All other files */ 391235537Sgber /* Look up filename in the directory returning its inode */ 392235537Sgber name = cnp->cn_nameptr; 393235537Sgber namelen = cnp->cn_namelen; 394235537Sgber error = nandfs_lookup_name_in_dir(dvp, name, namelen, 395235537Sgber &ino, &found, &off); 396235537Sgber if (error) 397235537Sgber goto out; 398235537Sgber if (!found) { 399235537Sgber DPRINTF(LOOKUP, ("\tNOT found\n")); 400235537Sgber /* 401235537Sgber * UGH, didn't find name. If we're creating or 402235537Sgber * renaming on the last name this is OK and we ought 403235537Sgber * to return EJUSTRETURN if its allowed to be created. 404235537Sgber */ 405235537Sgber error = ENOENT; 406235537Sgber if ((nameiop == CREATE || nameiop == RENAME) && 407235537Sgber islastcn) { 408235537Sgber error = VOP_ACCESS(dvp, VWRITE, cred, 409235537Sgber td); 410235537Sgber if (!error) { 411235537Sgber /* keep the component name */ 412235537Sgber cnp->cn_flags |= SAVENAME; 413235537Sgber error = EJUSTRETURN; 414235537Sgber } 415235537Sgber } 416235537Sgber /* Done */ 417235537Sgber } else { 418235537Sgber if (ino == NANDFS_WHT_INO) 419235537Sgber cnp->cn_flags |= ISWHITEOUT; 420235537Sgber 421235537Sgber if ((cnp->cn_flags & ISWHITEOUT) && 422235537Sgber (nameiop == LOOKUP)) 423235537Sgber return (ENOENT); 424235537Sgber 425235537Sgber if ((nameiop == DELETE) && islastcn) { 426235537Sgber if ((cnp->cn_flags & ISWHITEOUT) && 427235537Sgber (cnp->cn_flags & DOWHITEOUT)) { 428235537Sgber cnp->cn_flags |= SAVENAME; 429235537Sgber dir_node->nn_diroff = off; 430235537Sgber return (EJUSTRETURN); 431235537Sgber } 432235537Sgber 433235537Sgber error = VOP_ACCESS(dvp, VWRITE, cred, 434235537Sgber cnp->cn_thread); 435235537Sgber if (error) 436235537Sgber return (error); 437235537Sgber 438235537Sgber /* Try to create/reuse the node */ 439235537Sgber error = nandfs_get_node(nmp, ino, &node); 440235537Sgber if (!error) { 441235537Sgber *vpp = NTOV(node); 442235537Sgber node->nn_diroff = off; 443235537Sgber } 444235537Sgber 445235537Sgber if ((dir_node->nn_inode.i_mode & ISVTX) && 446235537Sgber cred->cr_uid != 0 && 447235537Sgber cred->cr_uid != dir_node->nn_inode.i_uid && 448235537Sgber node->nn_inode.i_uid != cred->cr_uid) { 449235537Sgber vput(*vpp); 450235537Sgber *vpp = NULL; 451235537Sgber return (EPERM); 452235537Sgber } 453235537Sgber } else if ((nameiop == RENAME) && islastcn) { 454235537Sgber error = VOP_ACCESS(dvp, VWRITE, cred, 455235537Sgber cnp->cn_thread); 456235537Sgber if (error) 457235537Sgber return (error); 458235537Sgber 459235537Sgber /* Try to create/reuse the node */ 460235537Sgber error = nandfs_get_node(nmp, ino, &node); 461235537Sgber if (!error) { 462235537Sgber *vpp = NTOV(node); 463235537Sgber node->nn_diroff = off; 464235537Sgber } 465235537Sgber } else { 466235537Sgber /* Try to create/reuse the node */ 467235537Sgber error = nandfs_get_node(nmp, ino, &node); 468235537Sgber if (!error) { 469235537Sgber *vpp = NTOV(node); 470235537Sgber node->nn_diroff = off; 471235537Sgber } 472235537Sgber } 473235537Sgber } 474235537Sgber } 475235537Sgber 476235537Sgberout: 477235537Sgber /* 478235537Sgber * Store result in the cache if requested. If we are creating a file, 479235537Sgber * the file might not be found and thus putting it into the namecache 480235537Sgber * might be seen as negative caching. 481235537Sgber */ 482276500Skib if ((cnp->cn_flags & MAKEENTRY) != 0) 483235537Sgber cache_enter(dvp, *vpp, cnp); 484235537Sgber 485235537Sgber return (error); 486235537Sgber 487235537Sgber} 488235537Sgber 489235537Sgberstatic int 490235537Sgbernandfs_getattr(struct vop_getattr_args *ap) 491235537Sgber{ 492235537Sgber struct vnode *vp = ap->a_vp; 493235537Sgber struct vattr *vap = ap->a_vap; 494235537Sgber struct nandfs_node *node = VTON(vp); 495235537Sgber struct nandfs_inode *inode = &node->nn_inode; 496235537Sgber 497235537Sgber DPRINTF(VNCALL, ("%s: vp: %p\n", __func__, vp)); 498235537Sgber nandfs_itimes(vp); 499235537Sgber 500235537Sgber /* Basic info */ 501235537Sgber VATTR_NULL(vap); 502235537Sgber vap->va_atime.tv_sec = inode->i_mtime; 503235537Sgber vap->va_atime.tv_nsec = inode->i_mtime_nsec; 504235537Sgber vap->va_mtime.tv_sec = inode->i_mtime; 505235537Sgber vap->va_mtime.tv_nsec = inode->i_mtime_nsec; 506235537Sgber vap->va_ctime.tv_sec = inode->i_ctime; 507235537Sgber vap->va_ctime.tv_nsec = inode->i_ctime_nsec; 508235537Sgber vap->va_type = IFTOVT(inode->i_mode); 509235537Sgber vap->va_mode = inode->i_mode & ~S_IFMT; 510235537Sgber vap->va_nlink = inode->i_links_count; 511235537Sgber vap->va_uid = inode->i_uid; 512235537Sgber vap->va_gid = inode->i_gid; 513235537Sgber vap->va_rdev = inode->i_special; 514235537Sgber vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; 515235537Sgber vap->va_fileid = node->nn_ino; 516235537Sgber vap->va_size = inode->i_size; 517235537Sgber vap->va_blocksize = node->nn_nandfsdev->nd_blocksize; 518235537Sgber vap->va_gen = 0; 519235537Sgber vap->va_flags = inode->i_flags; 520235537Sgber vap->va_bytes = inode->i_blocks * vap->va_blocksize; 521235537Sgber vap->va_filerev = 0; 522235537Sgber vap->va_vaflags = 0; 523235537Sgber 524235537Sgber return (0); 525235537Sgber} 526235537Sgber 527235537Sgberstatic int 528235537Sgbernandfs_vtruncbuf(struct vnode *vp, uint64_t nblks) 529235537Sgber{ 530235537Sgber struct nandfs_device *nffsdev; 531235537Sgber struct bufobj *bo; 532235537Sgber struct buf *bp, *nbp; 533235537Sgber 534235537Sgber bo = &vp->v_bufobj; 535235537Sgber nffsdev = VTON(vp)->nn_nandfsdev; 536235537Sgber 537235537Sgber ASSERT_VOP_LOCKED(vp, "nandfs_truncate"); 538235537Sgberrestart: 539235537Sgber BO_LOCK(bo); 540235537Sgberrestart_locked: 541235537Sgber TAILQ_FOREACH_SAFE(bp, &bo->bo_clean.bv_hd, b_bobufs, nbp) { 542235537Sgber if (bp->b_lblkno < nblks) 543235537Sgber continue; 544235537Sgber if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) 545235537Sgber goto restart_locked; 546235537Sgber 547235537Sgber bremfree(bp); 548235537Sgber bp->b_flags |= (B_INVAL | B_RELBUF); 549235537Sgber bp->b_flags &= ~(B_ASYNC | B_MANAGED); 550235537Sgber BO_UNLOCK(bo); 551235537Sgber brelse(bp); 552235537Sgber BO_LOCK(bo); 553235537Sgber } 554235537Sgber 555235537Sgber TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) { 556235537Sgber if (bp->b_lblkno < nblks) 557235537Sgber continue; 558235537Sgber if (BUF_LOCK(bp, 559235537Sgber LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK, 560251171Sjeff BO_LOCKPTR(bo)) == ENOLCK) 561235537Sgber goto restart; 562235537Sgber bp->b_flags |= (B_INVAL | B_RELBUF); 563235537Sgber bp->b_flags &= ~(B_ASYNC | B_MANAGED); 564235537Sgber brelse(bp); 565235537Sgber nandfs_dirty_bufs_decrement(nffsdev); 566235537Sgber BO_LOCK(bo); 567235537Sgber } 568235537Sgber 569235537Sgber BO_UNLOCK(bo); 570235537Sgber 571235537Sgber return (0); 572235537Sgber} 573235537Sgber 574235537Sgberstatic int 575235537Sgbernandfs_truncate(struct vnode *vp, uint64_t newsize) 576235537Sgber{ 577235537Sgber struct nandfs_device *nffsdev; 578235537Sgber struct nandfs_node *node; 579235537Sgber struct nandfs_inode *inode; 580235537Sgber struct buf *bp = NULL; 581235537Sgber uint64_t oblks, nblks, vblk, size, rest; 582235537Sgber int error; 583235537Sgber 584235537Sgber node = VTON(vp); 585235537Sgber nffsdev = node->nn_nandfsdev; 586235537Sgber inode = &node->nn_inode; 587235537Sgber 588235537Sgber /* Calculate end of file */ 589235537Sgber size = inode->i_size; 590235537Sgber 591235537Sgber if (newsize == size) { 592235537Sgber node->nn_flags |= IN_CHANGE | IN_UPDATE; 593235537Sgber nandfs_itimes(vp); 594235537Sgber return (0); 595235537Sgber } 596235537Sgber 597235537Sgber if (newsize > size) { 598235537Sgber inode->i_size = newsize; 599235537Sgber vnode_pager_setsize(vp, newsize); 600235537Sgber node->nn_flags |= IN_CHANGE | IN_UPDATE; 601235537Sgber nandfs_itimes(vp); 602235537Sgber return (0); 603235537Sgber } 604235537Sgber 605235537Sgber nblks = howmany(newsize, nffsdev->nd_blocksize); 606235537Sgber oblks = howmany(size, nffsdev->nd_blocksize); 607235537Sgber rest = newsize % nffsdev->nd_blocksize; 608235537Sgber 609235537Sgber if (rest) { 610235537Sgber error = nandfs_bmap_lookup(node, nblks - 1, &vblk); 611235537Sgber if (error) 612235537Sgber return (error); 613235537Sgber 614235537Sgber if (vblk != 0) 615235537Sgber error = nandfs_bread(node, nblks - 1, NOCRED, 0, &bp); 616235537Sgber else 617235537Sgber error = nandfs_bcreate(node, nblks - 1, NOCRED, 0, &bp); 618235537Sgber 619235537Sgber if (error) { 620235537Sgber if (bp) 621235537Sgber brelse(bp); 622235537Sgber return (error); 623235537Sgber } 624235537Sgber 625235537Sgber bzero((char *)bp->b_data + rest, 626235537Sgber (u_int)(nffsdev->nd_blocksize - rest)); 627235537Sgber error = nandfs_dirty_buf(bp, 0); 628235537Sgber if (error) 629235537Sgber return (error); 630235537Sgber } 631235537Sgber 632235537Sgber DPRINTF(VNCALL, ("%s: vp %p oblks %jx nblks %jx\n", __func__, vp, oblks, 633235537Sgber nblks)); 634235537Sgber 635235537Sgber error = nandfs_bmap_truncate_mapping(node, oblks - 1, nblks - 1); 636235537Sgber if (error) { 637235537Sgber if (bp) 638235537Sgber nandfs_undirty_buf(bp); 639235537Sgber return (error); 640235537Sgber } 641235537Sgber 642235537Sgber error = nandfs_vtruncbuf(vp, nblks); 643235537Sgber if (error) { 644235537Sgber if (bp) 645235537Sgber nandfs_undirty_buf(bp); 646235537Sgber return (error); 647235537Sgber } 648235537Sgber 649235537Sgber inode->i_size = newsize; 650235537Sgber vnode_pager_setsize(vp, newsize); 651235537Sgber node->nn_flags |= IN_CHANGE | IN_UPDATE; 652235537Sgber nandfs_itimes(vp); 653235537Sgber 654235537Sgber return (error); 655235537Sgber} 656235537Sgber 657235537Sgberstatic void 658235537Sgbernandfs_itimes_locked(struct vnode *vp) 659235537Sgber{ 660235537Sgber struct nandfs_node *node; 661235537Sgber struct nandfs_inode *inode; 662235537Sgber struct timespec ts; 663235537Sgber 664235537Sgber ASSERT_VI_LOCKED(vp, __func__); 665235537Sgber 666235537Sgber node = VTON(vp); 667235537Sgber inode = &node->nn_inode; 668235537Sgber 669235537Sgber if ((node->nn_flags & (IN_ACCESS | IN_CHANGE | IN_UPDATE)) == 0) 670235537Sgber return; 671235537Sgber 672235537Sgber if (((vp->v_mount->mnt_kern_flag & 673235537Sgber (MNTK_SUSPENDED | MNTK_SUSPEND)) == 0) || 674235537Sgber (node->nn_flags & (IN_CHANGE | IN_UPDATE))) 675235537Sgber node->nn_flags |= IN_MODIFIED; 676235537Sgber 677235537Sgber vfs_timestamp(&ts); 678235537Sgber if (node->nn_flags & IN_UPDATE) { 679235537Sgber inode->i_mtime = ts.tv_sec; 680235537Sgber inode->i_mtime_nsec = ts.tv_nsec; 681235537Sgber } 682235537Sgber if (node->nn_flags & IN_CHANGE) { 683235537Sgber inode->i_ctime = ts.tv_sec; 684235537Sgber inode->i_ctime_nsec = ts.tv_nsec; 685235537Sgber } 686235537Sgber 687235537Sgber node->nn_flags &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE); 688235537Sgber} 689235537Sgber 690235537Sgbervoid 691235537Sgbernandfs_itimes(struct vnode *vp) 692235537Sgber{ 693235537Sgber 694235537Sgber VI_LOCK(vp); 695235537Sgber nandfs_itimes_locked(vp); 696235537Sgber VI_UNLOCK(vp); 697235537Sgber} 698235537Sgber 699235537Sgberstatic int 700235537Sgbernandfs_chmod(struct vnode *vp, int mode, struct ucred *cred, struct thread *td) 701235537Sgber{ 702235537Sgber struct nandfs_node *node = VTON(vp); 703235537Sgber struct nandfs_inode *inode = &node->nn_inode; 704235537Sgber uint16_t nmode; 705235537Sgber int error = 0; 706235537Sgber 707235537Sgber DPRINTF(VNCALL, ("%s: vp %p, mode %x, cred %p, td %p\n", __func__, vp, 708235537Sgber mode, cred, td)); 709235537Sgber /* 710235537Sgber * To modify the permissions on a file, must possess VADMIN 711235537Sgber * for that file. 712235537Sgber */ 713235537Sgber if ((error = VOP_ACCESS(vp, VADMIN, cred, td))) 714235537Sgber return (error); 715235537Sgber 716235537Sgber /* 717235537Sgber * Privileged processes may set the sticky bit on non-directories, 718235537Sgber * as well as set the setgid bit on a file with a group that the 719235537Sgber * process is not a member of. Both of these are allowed in 720235537Sgber * jail(8). 721235537Sgber */ 722235537Sgber if (vp->v_type != VDIR && (mode & S_ISTXT)) { 723235537Sgber if (priv_check_cred(cred, PRIV_VFS_STICKYFILE, 0)) 724235537Sgber return (EFTYPE); 725235537Sgber } 726235537Sgber if (!groupmember(inode->i_gid, cred) && (mode & ISGID)) { 727235537Sgber error = priv_check_cred(cred, PRIV_VFS_SETGID, 0); 728235537Sgber if (error) 729235537Sgber return (error); 730235537Sgber } 731235537Sgber 732235537Sgber /* 733235537Sgber * Deny setting setuid if we are not the file owner. 734235537Sgber */ 735235537Sgber if ((mode & ISUID) && inode->i_uid != cred->cr_uid) { 736235537Sgber error = priv_check_cred(cred, PRIV_VFS_ADMIN, 0); 737235537Sgber if (error) 738235537Sgber return (error); 739235537Sgber } 740235537Sgber 741235537Sgber nmode = inode->i_mode; 742235537Sgber nmode &= ~ALLPERMS; 743235537Sgber nmode |= (mode & ALLPERMS); 744235537Sgber inode->i_mode = nmode; 745235537Sgber node->nn_flags |= IN_CHANGE; 746235537Sgber 747235537Sgber DPRINTF(VNCALL, ("%s: to mode %x\n", __func__, nmode)); 748235537Sgber 749235537Sgber return (error); 750235537Sgber} 751235537Sgber 752235537Sgberstatic int 753235537Sgbernandfs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred, 754235537Sgber struct thread *td) 755235537Sgber{ 756235537Sgber struct nandfs_node *node = VTON(vp); 757235537Sgber struct nandfs_inode *inode = &node->nn_inode; 758235537Sgber uid_t ouid; 759235537Sgber gid_t ogid; 760235537Sgber int error = 0; 761235537Sgber 762235537Sgber if (uid == (uid_t)VNOVAL) 763235537Sgber uid = inode->i_uid; 764235537Sgber if (gid == (gid_t)VNOVAL) 765235537Sgber gid = inode->i_gid; 766235537Sgber /* 767235537Sgber * To modify the ownership of a file, must possess VADMIN for that 768235537Sgber * file. 769235537Sgber */ 770235537Sgber if ((error = VOP_ACCESSX(vp, VWRITE_OWNER, cred, td))) 771235537Sgber return (error); 772235537Sgber /* 773235537Sgber * To change the owner of a file, or change the group of a file to a 774235537Sgber * group of which we are not a member, the caller must have 775235537Sgber * privilege. 776235537Sgber */ 777235537Sgber if (((uid != inode->i_uid && uid != cred->cr_uid) || 778235537Sgber (gid != inode->i_gid && !groupmember(gid, cred))) && 779235537Sgber (error = priv_check_cred(cred, PRIV_VFS_CHOWN, 0))) 780235537Sgber return (error); 781235537Sgber ogid = inode->i_gid; 782235537Sgber ouid = inode->i_uid; 783235537Sgber 784235537Sgber inode->i_gid = gid; 785235537Sgber inode->i_uid = uid; 786235537Sgber 787235537Sgber node->nn_flags |= IN_CHANGE; 788235537Sgber if ((inode->i_mode & (ISUID | ISGID)) && 789235537Sgber (ouid != uid || ogid != gid)) { 790235537Sgber if (priv_check_cred(cred, PRIV_VFS_RETAINSUGID, 0)) { 791235537Sgber inode->i_mode &= ~(ISUID | ISGID); 792235537Sgber } 793235537Sgber } 794235537Sgber DPRINTF(VNCALL, ("%s: vp %p, cred %p, td %p - ret OK\n", __func__, vp, 795235537Sgber cred, td)); 796235537Sgber return (0); 797235537Sgber} 798235537Sgber 799235537Sgberstatic int 800235537Sgbernandfs_setattr(struct vop_setattr_args *ap) 801235537Sgber{ 802235537Sgber struct vnode *vp = ap->a_vp; 803235537Sgber struct nandfs_node *node = VTON(vp); 804235537Sgber struct nandfs_inode *inode = &node->nn_inode; 805235537Sgber struct vattr *vap = ap->a_vap; 806235537Sgber struct ucred *cred = ap->a_cred; 807235537Sgber struct thread *td = curthread; 808235537Sgber uint32_t flags; 809235537Sgber int error = 0; 810235537Sgber 811235537Sgber if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || 812235537Sgber (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || 813235537Sgber (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) || 814235537Sgber (vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) { 815235537Sgber DPRINTF(VNCALL, ("%s: unsettable attribute\n", __func__)); 816235537Sgber return (EINVAL); 817235537Sgber } 818235537Sgber 819235537Sgber if (vap->va_flags != VNOVAL) { 820235537Sgber DPRINTF(VNCALL, ("%s: vp:%p td:%p flags:%lx\n", __func__, vp, 821235537Sgber td, vap->va_flags)); 822235537Sgber 823235537Sgber if (vp->v_mount->mnt_flag & MNT_RDONLY) 824235537Sgber return (EROFS); 825235537Sgber /* 826235537Sgber * Callers may only modify the file flags on objects they 827235537Sgber * have VADMIN rights for. 828235537Sgber */ 829235537Sgber if ((error = VOP_ACCESS(vp, VADMIN, cred, td))) 830235537Sgber return (error); 831235537Sgber /* 832235537Sgber * Unprivileged processes are not permitted to unset system 833235537Sgber * flags, or modify flags if any system flags are set. 834235537Sgber * Privileged non-jail processes may not modify system flags 835235537Sgber * if securelevel > 0 and any existing system flags are set. 836235537Sgber * Privileged jail processes behave like privileged non-jail 837235537Sgber * processes if the security.jail.chflags_allowed sysctl is 838235537Sgber * is non-zero; otherwise, they behave like unprivileged 839235537Sgber * processes. 840235537Sgber */ 841235537Sgber 842235537Sgber flags = inode->i_flags; 843235537Sgber if (!priv_check_cred(cred, PRIV_VFS_SYSFLAGS, 0)) { 844235537Sgber if (flags & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND)) { 845235537Sgber error = securelevel_gt(cred, 0); 846235537Sgber if (error) 847235537Sgber return (error); 848235537Sgber } 849235537Sgber /* Snapshot flag cannot be set or cleared */ 850235537Sgber if (((vap->va_flags & SF_SNAPSHOT) != 0 && 851235537Sgber (flags & SF_SNAPSHOT) == 0) || 852235537Sgber ((vap->va_flags & SF_SNAPSHOT) == 0 && 853235537Sgber (flags & SF_SNAPSHOT) != 0)) 854235537Sgber return (EPERM); 855235537Sgber 856235537Sgber inode->i_flags = vap->va_flags; 857235537Sgber } else { 858235537Sgber if (flags & (SF_NOUNLINK | SF_IMMUTABLE | SF_APPEND) || 859235537Sgber (vap->va_flags & UF_SETTABLE) != vap->va_flags) 860235537Sgber return (EPERM); 861235537Sgber 862235537Sgber flags &= SF_SETTABLE; 863235537Sgber flags |= (vap->va_flags & UF_SETTABLE); 864235537Sgber inode->i_flags = flags; 865235537Sgber } 866235537Sgber node->nn_flags |= IN_CHANGE; 867235537Sgber if (vap->va_flags & (IMMUTABLE | APPEND)) 868235537Sgber return (0); 869235537Sgber } 870235537Sgber if (inode->i_flags & (IMMUTABLE | APPEND)) 871235537Sgber return (EPERM); 872235537Sgber 873235537Sgber if (vap->va_size != (u_quad_t)VNOVAL) { 874235537Sgber DPRINTF(VNCALL, ("%s: vp:%p td:%p size:%jx\n", __func__, vp, td, 875235537Sgber (uintmax_t)vap->va_size)); 876235537Sgber 877235537Sgber switch (vp->v_type) { 878235537Sgber case VDIR: 879235537Sgber return (EISDIR); 880235537Sgber case VLNK: 881235537Sgber case VREG: 882235537Sgber if (vp->v_mount->mnt_flag & MNT_RDONLY) 883235537Sgber return (EROFS); 884235537Sgber if ((inode->i_flags & SF_SNAPSHOT) != 0) 885235537Sgber return (EPERM); 886235537Sgber break; 887235537Sgber default: 888235537Sgber return (0); 889235537Sgber } 890235537Sgber 891235537Sgber if (vap->va_size > node->nn_nandfsdev->nd_maxfilesize) 892235537Sgber return (EFBIG); 893235537Sgber 894235537Sgber KASSERT((vp->v_type == VREG), ("Set size %d", vp->v_type)); 895235537Sgber nandfs_truncate(vp, vap->va_size); 896235537Sgber node->nn_flags |= IN_CHANGE; 897235537Sgber 898235537Sgber return (0); 899235537Sgber } 900235537Sgber 901235537Sgber if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) { 902235537Sgber if (vp->v_mount->mnt_flag & MNT_RDONLY) 903235537Sgber return (EROFS); 904235537Sgber DPRINTF(VNCALL, ("%s: vp:%p td:%p uid/gid %x/%x\n", __func__, 905235537Sgber vp, td, vap->va_uid, vap->va_gid)); 906235537Sgber error = nandfs_chown(vp, vap->va_uid, vap->va_gid, cred, td); 907235537Sgber if (error) 908235537Sgber return (error); 909235537Sgber } 910235537Sgber 911235537Sgber if (vap->va_mode != (mode_t)VNOVAL) { 912235537Sgber if (vp->v_mount->mnt_flag & MNT_RDONLY) 913235537Sgber return (EROFS); 914235537Sgber DPRINTF(VNCALL, ("%s: vp:%p td:%p mode %x\n", __func__, vp, td, 915235537Sgber vap->va_mode)); 916235537Sgber 917235537Sgber error = nandfs_chmod(vp, (int)vap->va_mode, cred, td); 918235537Sgber if (error) 919235537Sgber return (error); 920235537Sgber } 921235537Sgber if (vap->va_atime.tv_sec != VNOVAL || 922235537Sgber vap->va_mtime.tv_sec != VNOVAL || 923235537Sgber vap->va_birthtime.tv_sec != VNOVAL) { 924235537Sgber DPRINTF(VNCALL, ("%s: vp:%p td:%p time a/m/b %jx/%jx/%jx\n", 925235537Sgber __func__, vp, td, (uintmax_t)vap->va_atime.tv_sec, 926235537Sgber (uintmax_t)vap->va_mtime.tv_sec, 927235537Sgber (uintmax_t)vap->va_birthtime.tv_sec)); 928235537Sgber 929235537Sgber if (vap->va_atime.tv_sec != VNOVAL) 930235537Sgber node->nn_flags |= IN_ACCESS; 931235537Sgber if (vap->va_mtime.tv_sec != VNOVAL) 932235537Sgber node->nn_flags |= IN_CHANGE | IN_UPDATE; 933235537Sgber if (vap->va_birthtime.tv_sec != VNOVAL) 934235537Sgber node->nn_flags |= IN_MODIFIED; 935235537Sgber nandfs_itimes(vp); 936235537Sgber return (0); 937235537Sgber } 938235537Sgber 939235537Sgber return (0); 940235537Sgber} 941235537Sgber 942235537Sgberstatic int 943235537Sgbernandfs_open(struct vop_open_args *ap) 944235537Sgber{ 945235537Sgber struct nandfs_node *node = VTON(ap->a_vp); 946235537Sgber uint64_t filesize; 947235537Sgber 948235537Sgber DPRINTF(VNCALL, ("nandfs_open called ap->a_mode %x\n", ap->a_mode)); 949235537Sgber 950235537Sgber if (ap->a_vp->v_type == VCHR || ap->a_vp->v_type == VBLK) 951235537Sgber return (EOPNOTSUPP); 952235537Sgber 953235537Sgber if ((node->nn_inode.i_flags & APPEND) && 954235537Sgber (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE) 955235537Sgber return (EPERM); 956235537Sgber 957235537Sgber filesize = node->nn_inode.i_size; 958235537Sgber vnode_create_vobject(ap->a_vp, filesize, ap->a_td); 959235537Sgber 960235537Sgber return (0); 961235537Sgber} 962235537Sgber 963235537Sgberstatic int 964235537Sgbernandfs_close(struct vop_close_args *ap) 965235537Sgber{ 966235537Sgber struct vnode *vp = ap->a_vp; 967235537Sgber struct nandfs_node *node = VTON(vp); 968235537Sgber 969235537Sgber DPRINTF(VNCALL, ("%s: vp %p node %p\n", __func__, vp, node)); 970235537Sgber 971235537Sgber mtx_lock(&vp->v_interlock); 972235537Sgber if (vp->v_usecount > 1) 973235537Sgber nandfs_itimes_locked(vp); 974235537Sgber mtx_unlock(&vp->v_interlock); 975235537Sgber 976235537Sgber return (0); 977235537Sgber} 978235537Sgber 979235537Sgberstatic int 980235537Sgbernandfs_check_possible(struct vnode *vp, struct vattr *vap, mode_t mode) 981235537Sgber{ 982235537Sgber 983235537Sgber /* Check if we are allowed to write */ 984235537Sgber switch (vap->va_type) { 985235537Sgber case VDIR: 986235537Sgber case VLNK: 987235537Sgber case VREG: 988235537Sgber /* 989235537Sgber * Normal nodes: check if we're on a read-only mounted 990235537Sgber * filingsystem and bomb out if we're trying to write. 991235537Sgber */ 992235537Sgber if ((mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) 993235537Sgber return (EROFS); 994235537Sgber break; 995235537Sgber case VBLK: 996235537Sgber case VCHR: 997235537Sgber case VSOCK: 998235537Sgber case VFIFO: 999235537Sgber /* 1000235537Sgber * Special nodes: even on read-only mounted filingsystems 1001235537Sgber * these are allowed to be written to if permissions allow. 1002235537Sgber */ 1003235537Sgber break; 1004235537Sgber default: 1005235537Sgber /* No idea what this is */ 1006235537Sgber return (EINVAL); 1007235537Sgber } 1008235537Sgber 1009235537Sgber /* Noone may write immutable files */ 1010235537Sgber if ((mode & VWRITE) && (VTON(vp)->nn_inode.i_flags & IMMUTABLE)) 1011235537Sgber return (EPERM); 1012235537Sgber 1013235537Sgber return (0); 1014235537Sgber} 1015235537Sgber 1016235537Sgberstatic int 1017235537Sgbernandfs_check_permitted(struct vnode *vp, struct vattr *vap, mode_t mode, 1018235537Sgber struct ucred *cred) 1019235537Sgber{ 1020235537Sgber 1021235537Sgber return (vaccess(vp->v_type, vap->va_mode, vap->va_uid, vap->va_gid, mode, 1022235537Sgber cred, NULL)); 1023235537Sgber} 1024235537Sgber 1025235537Sgberstatic int 1026235537Sgbernandfs_advlock(struct vop_advlock_args *ap) 1027235537Sgber{ 1028235537Sgber struct nandfs_node *nvp; 1029235537Sgber quad_t size; 1030235537Sgber 1031235537Sgber nvp = VTON(ap->a_vp); 1032235537Sgber size = nvp->nn_inode.i_size; 1033235537Sgber return (lf_advlock(ap, &(nvp->nn_lockf), size)); 1034235537Sgber} 1035235537Sgber 1036235537Sgberstatic int 1037235537Sgbernandfs_access(struct vop_access_args *ap) 1038235537Sgber{ 1039235537Sgber struct vnode *vp = ap->a_vp; 1040235537Sgber accmode_t accmode = ap->a_accmode; 1041235537Sgber struct ucred *cred = ap->a_cred; 1042235537Sgber struct vattr vap; 1043235537Sgber int error; 1044235537Sgber 1045235537Sgber DPRINTF(VNCALL, ("%s: vp:%p mode: %x\n", __func__, vp, accmode)); 1046235537Sgber 1047235537Sgber error = VOP_GETATTR(vp, &vap, NULL); 1048235537Sgber if (error) 1049235537Sgber return (error); 1050235537Sgber 1051235537Sgber error = nandfs_check_possible(vp, &vap, accmode); 1052235537Sgber if (error) { 1053235537Sgber return (error); 1054235537Sgber } 1055235537Sgber 1056235537Sgber error = nandfs_check_permitted(vp, &vap, accmode, cred); 1057235537Sgber 1058235537Sgber return (error); 1059235537Sgber} 1060235537Sgber 1061235537Sgberstatic int 1062235537Sgbernandfs_print(struct vop_print_args *ap) 1063235537Sgber{ 1064235537Sgber struct vnode *vp = ap->a_vp; 1065235537Sgber struct nandfs_node *nvp = VTON(vp); 1066235537Sgber 1067235537Sgber printf("\tvp=%p, nandfs_node=%p\n", vp, nvp); 1068235537Sgber printf("nandfs inode %#jx\n", (uintmax_t)nvp->nn_ino); 1069235537Sgber printf("flags = 0x%b\n", (u_int)nvp->nn_flags, PRINT_NODE_FLAGS); 1070235537Sgber 1071235537Sgber return (0); 1072235537Sgber} 1073235537Sgber 1074235537Sgberstatic void 1075235537Sgbernandfs_read_filebuf(struct nandfs_node *node, struct buf *bp) 1076235537Sgber{ 1077235537Sgber struct nandfs_device *nandfsdev = node->nn_nandfsdev; 1078235537Sgber struct buf *nbp; 1079235537Sgber nandfs_daddr_t vblk, pblk; 1080235537Sgber nandfs_lbn_t from; 1081235537Sgber uint32_t blocksize; 1082235537Sgber int error = 0; 1083235537Sgber int blk2dev = nandfsdev->nd_blocksize / DEV_BSIZE; 1084235537Sgber 1085235537Sgber /* 1086235537Sgber * Translate all the block sectors into a series of buffers to read 1087235537Sgber * asynchronously from the nandfs device. Note that this lookup may 1088235537Sgber * induce readin's too. 1089235537Sgber */ 1090235537Sgber 1091235537Sgber blocksize = nandfsdev->nd_blocksize; 1092235537Sgber if (bp->b_bcount / blocksize != 1) 1093235537Sgber panic("invalid b_count in bp %p\n", bp); 1094235537Sgber 1095235537Sgber from = bp->b_blkno; 1096235537Sgber 1097235537Sgber DPRINTF(READ, ("\tread in from inode %#jx blkno %#jx" 1098235537Sgber " count %#lx\n", (uintmax_t)node->nn_ino, from, 1099235537Sgber bp->b_bcount)); 1100235537Sgber 1101235537Sgber /* Get virtual block numbers for the vnode's buffer span */ 1102235537Sgber error = nandfs_bmap_lookup(node, from, &vblk); 1103235537Sgber if (error) { 1104235537Sgber bp->b_error = EINVAL; 1105235537Sgber bp->b_ioflags |= BIO_ERROR; 1106235537Sgber bufdone(bp); 1107235537Sgber return; 1108235537Sgber } 1109235537Sgber 1110235537Sgber /* Translate virtual block numbers to physical block numbers */ 1111235537Sgber error = nandfs_vtop(node, vblk, &pblk); 1112235537Sgber if (error) { 1113235537Sgber bp->b_error = EINVAL; 1114235537Sgber bp->b_ioflags |= BIO_ERROR; 1115235537Sgber bufdone(bp); 1116235537Sgber return; 1117235537Sgber } 1118235537Sgber 1119235537Sgber /* Issue translated blocks */ 1120235537Sgber bp->b_resid = bp->b_bcount; 1121235537Sgber 1122235537Sgber /* Note virtual block 0 marks not mapped */ 1123235537Sgber if (vblk == 0) { 1124235537Sgber vfs_bio_clrbuf(bp); 1125235537Sgber bufdone(bp); 1126235537Sgber return; 1127235537Sgber } 1128235537Sgber 1129235537Sgber nbp = bp; 1130235537Sgber nbp->b_blkno = pblk * blk2dev; 1131235537Sgber bp->b_iooffset = dbtob(nbp->b_blkno); 1132235537Sgber MPASS(bp->b_iooffset >= 0); 1133235537Sgber BO_STRATEGY(&nandfsdev->nd_devvp->v_bufobj, nbp); 1134235537Sgber nandfs_vblk_set(bp, vblk); 1135235537Sgber DPRINTF(READ, ("read_filebuf : ino %#jx blk %#jx -> " 1136235537Sgber "%#jx -> %#jx [bp %p]\n", (uintmax_t)node->nn_ino, 1137235537Sgber (uintmax_t)(from), (uintmax_t)vblk, 1138235537Sgber (uintmax_t)pblk, nbp)); 1139235537Sgber} 1140235537Sgber 1141235537Sgberstatic void 1142235537Sgbernandfs_write_filebuf(struct nandfs_node *node, struct buf *bp) 1143235537Sgber{ 1144235537Sgber struct nandfs_device *nandfsdev = node->nn_nandfsdev; 1145235537Sgber 1146235537Sgber bp->b_iooffset = dbtob(bp->b_blkno); 1147235537Sgber MPASS(bp->b_iooffset >= 0); 1148235537Sgber BO_STRATEGY(&nandfsdev->nd_devvp->v_bufobj, bp); 1149235537Sgber} 1150235537Sgber 1151235537Sgberstatic int 1152235537Sgbernandfs_strategy(struct vop_strategy_args *ap) 1153235537Sgber{ 1154235537Sgber struct vnode *vp = ap->a_vp; 1155235537Sgber struct buf *bp = ap->a_bp; 1156235537Sgber struct nandfs_node *node = VTON(vp); 1157235537Sgber 1158235537Sgber 1159235537Sgber /* check if we ought to be here */ 1160235537Sgber KASSERT((vp->v_type != VBLK && vp->v_type != VCHR), 1161235537Sgber ("nandfs_strategy on type %d", vp->v_type)); 1162235537Sgber 1163235537Sgber /* Translate if needed and pass on */ 1164235537Sgber if (bp->b_iocmd == BIO_READ) { 1165235537Sgber nandfs_read_filebuf(node, bp); 1166235537Sgber return (0); 1167235537Sgber } 1168235537Sgber 1169235537Sgber /* Send to segment collector */ 1170235537Sgber nandfs_write_filebuf(node, bp); 1171235537Sgber return (0); 1172235537Sgber} 1173235537Sgber 1174235537Sgberstatic int 1175235537Sgbernandfs_readdir(struct vop_readdir_args *ap) 1176235537Sgber{ 1177235537Sgber struct uio *uio = ap->a_uio; 1178235537Sgber struct vnode *vp = ap->a_vp; 1179235537Sgber struct nandfs_node *node = VTON(vp); 1180235537Sgber struct nandfs_dir_entry *ndirent; 1181235537Sgber struct dirent dirent; 1182235537Sgber struct buf *bp; 1183235537Sgber uint64_t file_size, diroffset, transoffset, blkoff; 1184235537Sgber uint64_t blocknr; 1185235537Sgber uint32_t blocksize = node->nn_nandfsdev->nd_blocksize; 1186235537Sgber uint8_t *pos, name_len; 1187235537Sgber int error; 1188235537Sgber 1189235537Sgber DPRINTF(READDIR, ("nandfs_readdir called\n")); 1190235537Sgber 1191235537Sgber if (vp->v_type != VDIR) 1192235537Sgber return (ENOTDIR); 1193235537Sgber 1194235537Sgber file_size = node->nn_inode.i_size; 1195235537Sgber DPRINTF(READDIR, ("nandfs_readdir filesize %jd resid %zd\n", 1196235537Sgber (uintmax_t)file_size, uio->uio_resid )); 1197235537Sgber 1198235537Sgber /* We are called just as long as we keep on pushing data in */ 1199235537Sgber error = 0; 1200235537Sgber if ((uio->uio_offset < file_size) && 1201235537Sgber (uio->uio_resid >= sizeof(struct dirent))) { 1202235537Sgber diroffset = uio->uio_offset; 1203235537Sgber transoffset = diroffset; 1204235537Sgber 1205235537Sgber blocknr = diroffset / blocksize; 1206235537Sgber blkoff = diroffset % blocksize; 1207235537Sgber error = nandfs_bread(node, blocknr, NOCRED, 0, &bp); 1208235537Sgber if (error) { 1209235537Sgber brelse(bp); 1210235537Sgber return (EIO); 1211235537Sgber } 1212235537Sgber while (diroffset < file_size) { 1213235537Sgber DPRINTF(READDIR, ("readdir : offset = %"PRIu64"\n", 1214235537Sgber diroffset)); 1215235537Sgber if (blkoff >= blocksize) { 1216235537Sgber blkoff = 0; blocknr++; 1217235537Sgber brelse(bp); 1218235537Sgber error = nandfs_bread(node, blocknr, NOCRED, 0, 1219235537Sgber &bp); 1220235537Sgber if (error) { 1221235537Sgber brelse(bp); 1222235537Sgber return (EIO); 1223235537Sgber } 1224235537Sgber } 1225235537Sgber 1226235537Sgber /* Read in one dirent */ 1227235537Sgber pos = (uint8_t *)bp->b_data + blkoff; 1228235537Sgber ndirent = (struct nandfs_dir_entry *)pos; 1229235537Sgber 1230235537Sgber name_len = ndirent->name_len; 1231235537Sgber memset(&dirent, 0, sizeof(struct dirent)); 1232235537Sgber dirent.d_fileno = ndirent->inode; 1233235537Sgber if (dirent.d_fileno) { 1234235537Sgber dirent.d_type = ndirent->file_type; 1235235537Sgber dirent.d_namlen = name_len; 1236235537Sgber strncpy(dirent.d_name, ndirent->name, name_len); 1237235537Sgber dirent.d_reclen = GENERIC_DIRSIZ(&dirent); 1238235537Sgber DPRINTF(READDIR, ("copying `%*.*s`\n", name_len, 1239235537Sgber name_len, dirent.d_name)); 1240235537Sgber } 1241235537Sgber 1242235537Sgber /* 1243235537Sgber * If there isn't enough space in the uio to return a 1244235537Sgber * whole dirent, break off read 1245235537Sgber */ 1246235537Sgber if (uio->uio_resid < GENERIC_DIRSIZ(&dirent)) 1247235537Sgber break; 1248235537Sgber 1249235537Sgber /* Transfer */ 1250235537Sgber if (dirent.d_fileno) 1251235537Sgber uiomove(&dirent, GENERIC_DIRSIZ(&dirent), uio); 1252235537Sgber 1253235537Sgber /* Advance */ 1254235537Sgber diroffset += ndirent->rec_len; 1255235537Sgber blkoff += ndirent->rec_len; 1256235537Sgber 1257235537Sgber /* Remember the last entry we transfered */ 1258235537Sgber transoffset = diroffset; 1259235537Sgber } 1260235537Sgber brelse(bp); 1261235537Sgber 1262235537Sgber /* Pass on last transfered offset */ 1263235537Sgber uio->uio_offset = transoffset; 1264235537Sgber } 1265235537Sgber 1266235537Sgber if (ap->a_eofflag) 1267235537Sgber *ap->a_eofflag = (uio->uio_offset >= file_size); 1268235537Sgber 1269235537Sgber return (error); 1270235537Sgber} 1271235537Sgber 1272235537Sgberstatic int 1273235537Sgbernandfs_dirempty(struct vnode *dvp, uint64_t parentino, struct ucred *cred) 1274235537Sgber{ 1275235537Sgber struct nandfs_node *dnode = VTON(dvp); 1276235537Sgber struct nandfs_dir_entry *dirent; 1277235537Sgber uint64_t file_size = dnode->nn_inode.i_size; 1278235537Sgber uint64_t blockcount = dnode->nn_inode.i_blocks; 1279235537Sgber uint64_t blocknr; 1280235537Sgber uint32_t blocksize = dnode->nn_nandfsdev->nd_blocksize; 1281235537Sgber uint32_t limit; 1282235537Sgber uint32_t off; 1283235537Sgber uint8_t *pos; 1284235537Sgber struct buf *bp; 1285235537Sgber int error; 1286235537Sgber 1287235537Sgber DPRINTF(LOOKUP, ("%s: dvp %p parentino %#jx cred %p\n", __func__, dvp, 1288235537Sgber (uintmax_t)parentino, cred)); 1289235537Sgber 1290235537Sgber KASSERT((file_size != 0), ("nandfs_dirempty for NULL dir %p", dvp)); 1291235537Sgber 1292235537Sgber blocknr = 0; 1293235537Sgber while (blocknr < blockcount) { 1294235537Sgber error = nandfs_bread(dnode, blocknr, NOCRED, 0, &bp); 1295235537Sgber if (error) { 1296235537Sgber brelse(bp); 1297235537Sgber return (0); 1298235537Sgber } 1299235537Sgber 1300235537Sgber pos = (uint8_t *)bp->b_data; 1301235537Sgber off = 0; 1302235537Sgber 1303235537Sgber if (blocknr == (blockcount - 1)) 1304235537Sgber limit = file_size % blocksize; 1305235537Sgber else 1306235537Sgber limit = blocksize; 1307235537Sgber 1308235537Sgber while (off < limit) { 1309235537Sgber dirent = (struct nandfs_dir_entry *)(pos + off); 1310235537Sgber off += dirent->rec_len; 1311235537Sgber 1312235537Sgber if (dirent->inode == 0) 1313235537Sgber continue; 1314235537Sgber 1315235537Sgber switch (dirent->name_len) { 1316235537Sgber case 0: 1317235537Sgber break; 1318235537Sgber case 1: 1319235537Sgber if (dirent->name[0] != '.') 1320235537Sgber goto notempty; 1321235537Sgber 1322235537Sgber KASSERT(dirent->inode == dnode->nn_ino, 1323235537Sgber (".'s inode does not match dir")); 1324235537Sgber break; 1325235537Sgber case 2: 1326235537Sgber if (dirent->name[0] != '.' && 1327235537Sgber dirent->name[1] != '.') 1328235537Sgber goto notempty; 1329235537Sgber 1330235537Sgber KASSERT(dirent->inode == parentino, 1331235537Sgber ("..'s inode does not match parent")); 1332235537Sgber break; 1333235537Sgber default: 1334235537Sgber goto notempty; 1335235537Sgber } 1336235537Sgber } 1337235537Sgber 1338235537Sgber brelse(bp); 1339235537Sgber blocknr++; 1340235537Sgber } 1341235537Sgber 1342235537Sgber return (1); 1343235537Sgbernotempty: 1344235537Sgber brelse(bp); 1345235537Sgber return (0); 1346235537Sgber} 1347235537Sgber 1348235537Sgberstatic int 1349235537Sgbernandfs_link(struct vop_link_args *ap) 1350235537Sgber{ 1351235537Sgber struct vnode *tdvp = ap->a_tdvp; 1352235537Sgber struct vnode *vp = ap->a_vp; 1353235537Sgber struct componentname *cnp = ap->a_cnp; 1354235537Sgber struct nandfs_node *node = VTON(vp); 1355235537Sgber struct nandfs_inode *inode = &node->nn_inode; 1356235537Sgber int error; 1357235537Sgber 1358235537Sgber if (inode->i_links_count >= LINK_MAX) 1359235537Sgber return (EMLINK); 1360235537Sgber 1361235537Sgber if (inode->i_flags & (IMMUTABLE | APPEND)) 1362235537Sgber return (EPERM); 1363235537Sgber 1364235537Sgber /* Update link count */ 1365235537Sgber inode->i_links_count++; 1366235537Sgber 1367235537Sgber /* Add dir entry */ 1368235537Sgber error = nandfs_add_dirent(tdvp, node->nn_ino, cnp->cn_nameptr, 1369235537Sgber cnp->cn_namelen, IFTODT(inode->i_mode)); 1370235537Sgber if (error) { 1371235537Sgber inode->i_links_count--; 1372235537Sgber } 1373235537Sgber 1374235537Sgber node->nn_flags |= IN_CHANGE; 1375235537Sgber nandfs_itimes(vp); 1376235537Sgber DPRINTF(VNCALL, ("%s: tdvp %p vp %p cnp %p\n", 1377235537Sgber __func__, tdvp, vp, cnp)); 1378235537Sgber 1379235537Sgber return (0); 1380235537Sgber} 1381235537Sgber 1382235537Sgberstatic int 1383235537Sgbernandfs_create(struct vop_create_args *ap) 1384235537Sgber{ 1385235537Sgber struct vnode *dvp = ap->a_dvp; 1386235537Sgber struct vnode **vpp = ap->a_vpp; 1387235537Sgber struct componentname *cnp = ap->a_cnp; 1388235537Sgber uint16_t mode = MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode); 1389235537Sgber struct nandfs_node *dir_node = VTON(dvp); 1390235537Sgber struct nandfsmount *nmp = dir_node->nn_nmp; 1391235537Sgber struct nandfs_node *node; 1392235537Sgber int error; 1393235537Sgber 1394235537Sgber DPRINTF(VNCALL, ("%s: dvp %p\n", __func__, dvp)); 1395235537Sgber 1396235537Sgber if (nandfs_fs_full(dir_node->nn_nandfsdev)) 1397235537Sgber return (ENOSPC); 1398235537Sgber 1399235537Sgber /* Create new vnode/inode */ 1400235537Sgber error = nandfs_node_create(nmp, &node, mode); 1401235537Sgber if (error) 1402235537Sgber return (error); 1403235537Sgber node->nn_inode.i_gid = dir_node->nn_inode.i_gid; 1404235537Sgber node->nn_inode.i_uid = cnp->cn_cred->cr_uid; 1405235537Sgber 1406235537Sgber /* Add new dir entry */ 1407235537Sgber error = nandfs_add_dirent(dvp, node->nn_ino, cnp->cn_nameptr, 1408235537Sgber cnp->cn_namelen, IFTODT(mode)); 1409235537Sgber if (error) { 1410235537Sgber if (nandfs_node_destroy(node)) { 1411235537Sgber nandfs_error("%s: error destroying node %p\n", 1412235537Sgber __func__, node); 1413235537Sgber } 1414235537Sgber return (error); 1415235537Sgber } 1416235537Sgber *vpp = NTOV(node); 1417276648Skib if ((cnp->cn_flags & MAKEENTRY) != 0) 1418276648Skib cache_enter(dvp, *vpp, cnp); 1419235537Sgber 1420235537Sgber DPRINTF(VNCALL, ("created file vp %p nandnode %p ino %jx\n", *vpp, node, 1421235537Sgber (uintmax_t)node->nn_ino)); 1422235537Sgber return (0); 1423235537Sgber} 1424235537Sgber 1425235537Sgberstatic int 1426235537Sgbernandfs_remove(struct vop_remove_args *ap) 1427235537Sgber{ 1428235537Sgber struct vnode *vp = ap->a_vp; 1429235537Sgber struct vnode *dvp = ap->a_dvp; 1430235537Sgber struct nandfs_node *node = VTON(vp); 1431235537Sgber struct nandfs_node *dnode = VTON(dvp); 1432235537Sgber struct componentname *cnp = ap->a_cnp; 1433235537Sgber 1434235537Sgber DPRINTF(VNCALL, ("%s: dvp %p vp %p nandnode %p ino %#jx link %d\n", 1435235537Sgber __func__, dvp, vp, node, (uintmax_t)node->nn_ino, 1436235537Sgber node->nn_inode.i_links_count)); 1437235537Sgber 1438235537Sgber if (vp->v_type == VDIR) 1439235537Sgber return (EISDIR); 1440235537Sgber 1441235537Sgber /* Files marked as immutable or append-only cannot be deleted. */ 1442235537Sgber if ((node->nn_inode.i_flags & (IMMUTABLE | APPEND | NOUNLINK)) || 1443235537Sgber (dnode->nn_inode.i_flags & APPEND)) 1444235537Sgber return (EPERM); 1445235537Sgber 1446235537Sgber nandfs_remove_dirent(dvp, node, cnp); 1447235537Sgber node->nn_inode.i_links_count--; 1448235537Sgber node->nn_flags |= IN_CHANGE; 1449235537Sgber 1450235537Sgber return (0); 1451235537Sgber} 1452235537Sgber 1453235537Sgber/* 1454235537Sgber * Check if source directory is in the path of the target directory. 1455235537Sgber * Target is supplied locked, source is unlocked. 1456235537Sgber * The target is always vput before returning. 1457235537Sgber */ 1458235537Sgberstatic int 1459235537Sgbernandfs_checkpath(struct nandfs_node *src, struct nandfs_node *dest, 1460235537Sgber struct ucred *cred) 1461235537Sgber{ 1462235537Sgber struct vnode *vp; 1463235537Sgber int error, rootino; 1464235537Sgber struct nandfs_dir_entry dirent; 1465235537Sgber 1466235537Sgber vp = NTOV(dest); 1467235537Sgber if (src->nn_ino == dest->nn_ino) { 1468235537Sgber error = EEXIST; 1469235537Sgber goto out; 1470235537Sgber } 1471235537Sgber rootino = NANDFS_ROOT_INO; 1472235537Sgber error = 0; 1473235537Sgber if (dest->nn_ino == rootino) 1474235537Sgber goto out; 1475235537Sgber 1476235537Sgber for (;;) { 1477235537Sgber if (vp->v_type != VDIR) { 1478235537Sgber error = ENOTDIR; 1479235537Sgber break; 1480235537Sgber } 1481235537Sgber 1482235537Sgber error = vn_rdwr(UIO_READ, vp, (caddr_t)&dirent, 1483235537Sgber NANDFS_DIR_REC_LEN(2), (off_t)0, UIO_SYSSPACE, 1484235537Sgber IO_NODELOCKED | IO_NOMACCHECK, cred, NOCRED, 1485235537Sgber NULL, NULL); 1486235537Sgber if (error != 0) 1487235537Sgber break; 1488235537Sgber if (dirent.name_len != 2 || 1489235537Sgber dirent.name[0] != '.' || 1490235537Sgber dirent.name[1] != '.') { 1491235537Sgber error = ENOTDIR; 1492235537Sgber break; 1493235537Sgber } 1494235537Sgber if (dirent.inode == src->nn_ino) { 1495235537Sgber error = EINVAL; 1496235537Sgber break; 1497235537Sgber } 1498235537Sgber if (dirent.inode == rootino) 1499235537Sgber break; 1500235537Sgber vput(vp); 1501235537Sgber if ((error = VFS_VGET(vp->v_mount, dirent.inode, 1502235537Sgber LK_EXCLUSIVE, &vp)) != 0) { 1503235537Sgber vp = NULL; 1504235537Sgber break; 1505235537Sgber } 1506235537Sgber } 1507235537Sgber 1508235537Sgberout: 1509235537Sgber if (error == ENOTDIR) 1510235537Sgber printf("checkpath: .. not a directory\n"); 1511235537Sgber if (vp != NULL) 1512235537Sgber vput(vp); 1513235537Sgber return (error); 1514235537Sgber} 1515235537Sgber 1516235537Sgberstatic int 1517235537Sgbernandfs_rename(struct vop_rename_args *ap) 1518235537Sgber{ 1519235537Sgber struct vnode *tvp = ap->a_tvp; 1520235537Sgber struct vnode *tdvp = ap->a_tdvp; 1521235537Sgber struct vnode *fvp = ap->a_fvp; 1522235537Sgber struct vnode *fdvp = ap->a_fdvp; 1523235537Sgber struct componentname *tcnp = ap->a_tcnp; 1524235537Sgber struct componentname *fcnp = ap->a_fcnp; 1525235537Sgber int doingdirectory = 0, oldparent = 0, newparent = 0; 1526235537Sgber int error = 0; 1527235537Sgber 1528235537Sgber struct nandfs_node *fdnode, *fnode, *fnode1; 1529235537Sgber struct nandfs_node *tdnode = VTON(tdvp); 1530235537Sgber struct nandfs_node *tnode; 1531235537Sgber 1532235537Sgber uint32_t tdflags, fflags, fdflags; 1533235537Sgber uint16_t mode; 1534235537Sgber 1535235537Sgber DPRINTF(VNCALL, ("%s: fdvp:%p fvp:%p tdvp:%p tdp:%p\n", __func__, fdvp, 1536235537Sgber fvp, tdvp, tvp)); 1537235537Sgber 1538235537Sgber /* 1539235537Sgber * Check for cross-device rename. 1540235537Sgber */ 1541235537Sgber if ((fvp->v_mount != tdvp->v_mount) || 1542235537Sgber (tvp && (fvp->v_mount != tvp->v_mount))) { 1543235537Sgber error = EXDEV; 1544235537Sgberabortit: 1545235537Sgber if (tdvp == tvp) 1546235537Sgber vrele(tdvp); 1547235537Sgber else 1548235537Sgber vput(tdvp); 1549235537Sgber if (tvp) 1550235537Sgber vput(tvp); 1551235537Sgber vrele(fdvp); 1552235537Sgber vrele(fvp); 1553235537Sgber return (error); 1554235537Sgber } 1555235537Sgber 1556235537Sgber tdflags = tdnode->nn_inode.i_flags; 1557235537Sgber if (tvp && 1558235537Sgber ((VTON(tvp)->nn_inode.i_flags & (NOUNLINK | IMMUTABLE | APPEND)) || 1559235537Sgber (tdflags & APPEND))) { 1560235537Sgber error = EPERM; 1561235537Sgber goto abortit; 1562235537Sgber } 1563235537Sgber 1564235537Sgber /* 1565235537Sgber * Renaming a file to itself has no effect. The upper layers should 1566235537Sgber * not call us in that case. Temporarily just warn if they do. 1567235537Sgber */ 1568235537Sgber if (fvp == tvp) { 1569235537Sgber printf("nandfs_rename: fvp == tvp (can't happen)\n"); 1570235537Sgber error = 0; 1571235537Sgber goto abortit; 1572235537Sgber } 1573235537Sgber 1574235537Sgber if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0) 1575235537Sgber goto abortit; 1576235537Sgber 1577235537Sgber fdnode = VTON(fdvp); 1578235537Sgber fnode = VTON(fvp); 1579235537Sgber 1580235537Sgber if (fnode->nn_inode.i_links_count >= LINK_MAX) { 1581235537Sgber VOP_UNLOCK(fvp, 0); 1582235537Sgber error = EMLINK; 1583235537Sgber goto abortit; 1584235537Sgber } 1585235537Sgber 1586235537Sgber fflags = fnode->nn_inode.i_flags; 1587235537Sgber fdflags = fdnode->nn_inode.i_flags; 1588235537Sgber 1589235537Sgber if ((fflags & (NOUNLINK | IMMUTABLE | APPEND)) || 1590235537Sgber (fdflags & APPEND)) { 1591235537Sgber VOP_UNLOCK(fvp, 0); 1592235537Sgber error = EPERM; 1593235537Sgber goto abortit; 1594235537Sgber } 1595235537Sgber 1596235537Sgber mode = fnode->nn_inode.i_mode; 1597235537Sgber if ((mode & S_IFMT) == S_IFDIR) { 1598235537Sgber /* 1599235537Sgber * Avoid ".", "..", and aliases of "." for obvious reasons. 1600235537Sgber */ 1601235537Sgber 1602235537Sgber if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || 1603235537Sgber (fdvp == fvp) || 1604235537Sgber ((fcnp->cn_flags | tcnp->cn_flags) & ISDOTDOT) || 1605235537Sgber (fnode->nn_flags & IN_RENAME)) { 1606235537Sgber VOP_UNLOCK(fvp, 0); 1607235537Sgber error = EINVAL; 1608235537Sgber goto abortit; 1609235537Sgber } 1610235537Sgber fnode->nn_flags |= IN_RENAME; 1611235537Sgber doingdirectory = 1; 1612235537Sgber DPRINTF(VNCALL, ("%s: doingdirectory dvp %p\n", __func__, 1613235537Sgber tdvp)); 1614235537Sgber oldparent = fdnode->nn_ino; 1615235537Sgber } 1616235537Sgber 1617235537Sgber vrele(fdvp); 1618235537Sgber 1619235537Sgber tnode = NULL; 1620235537Sgber if (tvp) 1621235537Sgber tnode = VTON(tvp); 1622235537Sgber 1623235537Sgber /* 1624235537Sgber * Bump link count on fvp while we are moving stuff around. If we 1625235537Sgber * crash before completing the work, the link count may be wrong 1626235537Sgber * but correctable. 1627235537Sgber */ 1628235537Sgber fnode->nn_inode.i_links_count++; 1629235537Sgber 1630235537Sgber /* Check for in path moving XXX */ 1631235537Sgber error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_thread); 1632235537Sgber VOP_UNLOCK(fvp, 0); 1633235537Sgber if (oldparent != tdnode->nn_ino) 1634235537Sgber newparent = tdnode->nn_ino; 1635235537Sgber if (doingdirectory && newparent) { 1636235537Sgber if (error) /* write access check above */ 1637235537Sgber goto bad; 1638235537Sgber if (tnode != NULL) 1639235537Sgber vput(tvp); 1640235537Sgber 1641235537Sgber error = nandfs_checkpath(fnode, tdnode, tcnp->cn_cred); 1642235537Sgber if (error) 1643235537Sgber goto out; 1644235537Sgber 1645235537Sgber VREF(tdvp); 1646235537Sgber error = relookup(tdvp, &tvp, tcnp); 1647235537Sgber if (error) 1648235537Sgber goto out; 1649235537Sgber vrele(tdvp); 1650235537Sgber tdnode = VTON(tdvp); 1651235537Sgber tnode = NULL; 1652235537Sgber if (tvp) 1653235537Sgber tnode = VTON(tvp); 1654235537Sgber } 1655235537Sgber 1656235537Sgber /* 1657235537Sgber * If the target doesn't exist, link the target to the source and 1658235537Sgber * unlink the source. Otherwise, rewrite the target directory to 1659235537Sgber * reference the source and remove the original entry. 1660235537Sgber */ 1661235537Sgber 1662235537Sgber if (tvp == NULL) { 1663235537Sgber /* 1664235537Sgber * Account for ".." in new directory. 1665235537Sgber */ 1666235537Sgber if (doingdirectory && fdvp != tdvp) 1667235537Sgber tdnode->nn_inode.i_links_count++; 1668235537Sgber 1669235537Sgber DPRINTF(VNCALL, ("%s: new entry in dvp:%p\n", __func__, tdvp)); 1670235537Sgber /* 1671235537Sgber * Add name in new directory. 1672235537Sgber */ 1673235537Sgber error = nandfs_add_dirent(tdvp, fnode->nn_ino, tcnp->cn_nameptr, 1674235537Sgber tcnp->cn_namelen, IFTODT(fnode->nn_inode.i_mode)); 1675235537Sgber if (error) { 1676235537Sgber if (doingdirectory && fdvp != tdvp) 1677235537Sgber tdnode->nn_inode.i_links_count--; 1678235537Sgber goto bad; 1679235537Sgber } 1680235537Sgber 1681235537Sgber vput(tdvp); 1682235537Sgber } else { 1683235537Sgber /* 1684235537Sgber * If the parent directory is "sticky", then the user must 1685235537Sgber * own the parent directory, or the destination of the rename, 1686235537Sgber * otherwise the destination may not be changed (except by 1687235537Sgber * root). This implements append-only directories. 1688235537Sgber */ 1689235537Sgber if ((tdnode->nn_inode.i_mode & S_ISTXT) && 1690235537Sgber tcnp->cn_cred->cr_uid != 0 && 1691235537Sgber tcnp->cn_cred->cr_uid != tdnode->nn_inode.i_uid && 1692235537Sgber tnode->nn_inode.i_uid != tcnp->cn_cred->cr_uid) { 1693235537Sgber error = EPERM; 1694235537Sgber goto bad; 1695235537Sgber } 1696235537Sgber /* 1697235537Sgber * Target must be empty if a directory and have no links 1698235537Sgber * to it. Also, ensure source and target are compatible 1699235537Sgber * (both directories, or both not directories). 1700235537Sgber */ 1701235537Sgber mode = tnode->nn_inode.i_mode; 1702235537Sgber if ((mode & S_IFMT) == S_IFDIR) { 1703235537Sgber if (!nandfs_dirempty(tvp, tdnode->nn_ino, 1704235537Sgber tcnp->cn_cred)) { 1705235537Sgber error = ENOTEMPTY; 1706235537Sgber goto bad; 1707235537Sgber } 1708235537Sgber if (!doingdirectory) { 1709235537Sgber error = ENOTDIR; 1710235537Sgber goto bad; 1711235537Sgber } 1712235537Sgber /* 1713235537Sgber * Update name cache since directory is going away. 1714235537Sgber */ 1715235537Sgber cache_purge(tdvp); 1716235537Sgber } else if (doingdirectory) { 1717235537Sgber error = EISDIR; 1718235537Sgber goto bad; 1719235537Sgber } 1720235537Sgber 1721235537Sgber DPRINTF(VNCALL, ("%s: update entry dvp:%p\n", __func__, tdvp)); 1722235537Sgber /* 1723235537Sgber * Change name tcnp in tdvp to point at fvp. 1724235537Sgber */ 1725235537Sgber error = nandfs_update_dirent(tdvp, fnode, tnode); 1726235537Sgber if (error) 1727235537Sgber goto bad; 1728235537Sgber 1729235537Sgber if (doingdirectory && !newparent) 1730235537Sgber tdnode->nn_inode.i_links_count--; 1731235537Sgber 1732235537Sgber vput(tdvp); 1733235537Sgber 1734235537Sgber tnode->nn_inode.i_links_count--; 1735235537Sgber vput(tvp); 1736235537Sgber tnode = NULL; 1737235537Sgber } 1738235537Sgber 1739235537Sgber /* 1740235537Sgber * Unlink the source. 1741235537Sgber */ 1742235537Sgber fcnp->cn_flags &= ~MODMASK; 1743235537Sgber fcnp->cn_flags |= LOCKPARENT | LOCKLEAF; 1744235537Sgber VREF(fdvp); 1745235537Sgber error = relookup(fdvp, &fvp, fcnp); 1746235537Sgber if (error == 0) 1747235537Sgber vrele(fdvp); 1748235537Sgber if (fvp != NULL) { 1749235537Sgber fnode1 = VTON(fvp); 1750235537Sgber fdnode = VTON(fdvp); 1751235537Sgber } else { 1752235537Sgber /* 1753235537Sgber * From name has disappeared. 1754235537Sgber */ 1755235537Sgber if (doingdirectory) 1756235537Sgber panic("nandfs_rename: lost dir entry"); 1757235537Sgber vrele(ap->a_fvp); 1758235537Sgber return (0); 1759235537Sgber } 1760235537Sgber 1761235537Sgber DPRINTF(VNCALL, ("%s: unlink source fnode:%p\n", __func__, fnode)); 1762235537Sgber 1763235537Sgber /* 1764235537Sgber * Ensure that the directory entry still exists and has not 1765235537Sgber * changed while the new name has been entered. If the source is 1766235537Sgber * a file then the entry may have been unlinked or renamed. In 1767235537Sgber * either case there is no further work to be done. If the source 1768235537Sgber * is a directory then it cannot have been rmdir'ed; its link 1769235537Sgber * count of three would cause a rmdir to fail with ENOTEMPTY. 1770235537Sgber * The IN_RENAME flag ensures that it cannot be moved by another 1771235537Sgber * rename. 1772235537Sgber */ 1773235537Sgber if (fnode != fnode1) { 1774235537Sgber if (doingdirectory) 1775235537Sgber panic("nandfs: lost dir entry"); 1776235537Sgber } else { 1777235537Sgber /* 1778235537Sgber * If the source is a directory with a 1779235537Sgber * new parent, the link count of the old 1780235537Sgber * parent directory must be decremented 1781235537Sgber * and ".." set to point to the new parent. 1782235537Sgber */ 1783235537Sgber if (doingdirectory && newparent) { 1784235537Sgber DPRINTF(VNCALL, ("%s: new parent %#jx -> %#jx\n", 1785235537Sgber __func__, (uintmax_t) oldparent, 1786235537Sgber (uintmax_t) newparent)); 1787235537Sgber error = nandfs_update_parent_dir(fvp, newparent); 1788235537Sgber if (!error) { 1789235537Sgber fdnode->nn_inode.i_links_count--; 1790235537Sgber fdnode->nn_flags |= IN_CHANGE; 1791235537Sgber } 1792235537Sgber } 1793235537Sgber error = nandfs_remove_dirent(fdvp, fnode, fcnp); 1794235537Sgber if (!error) { 1795235537Sgber fnode->nn_inode.i_links_count--; 1796235537Sgber fnode->nn_flags |= IN_CHANGE; 1797235537Sgber } 1798235537Sgber fnode->nn_flags &= ~IN_RENAME; 1799235537Sgber } 1800235537Sgber if (fdnode) 1801235537Sgber vput(fdvp); 1802235537Sgber if (fnode) 1803235537Sgber vput(fvp); 1804235537Sgber vrele(ap->a_fvp); 1805235537Sgber return (error); 1806235537Sgber 1807235537Sgberbad: 1808235537Sgber DPRINTF(VNCALL, ("%s: error:%d\n", __func__, error)); 1809235537Sgber if (tnode) 1810235537Sgber vput(NTOV(tnode)); 1811235537Sgber vput(NTOV(tdnode)); 1812235537Sgberout: 1813235537Sgber if (doingdirectory) 1814235537Sgber fnode->nn_flags &= ~IN_RENAME; 1815235537Sgber if (vn_lock(fvp, LK_EXCLUSIVE) == 0) { 1816235537Sgber fnode->nn_inode.i_links_count--; 1817235537Sgber fnode->nn_flags |= IN_CHANGE; 1818235537Sgber fnode->nn_flags &= ~IN_RENAME; 1819235537Sgber vput(fvp); 1820235537Sgber } else 1821235537Sgber vrele(fvp); 1822235537Sgber return (error); 1823235537Sgber} 1824235537Sgber 1825235537Sgberstatic int 1826235537Sgbernandfs_mkdir(struct vop_mkdir_args *ap) 1827235537Sgber{ 1828235537Sgber struct vnode *dvp = ap->a_dvp; 1829235537Sgber struct vnode **vpp = ap->a_vpp; 1830235537Sgber struct componentname *cnp = ap->a_cnp; 1831235537Sgber struct nandfs_node *dir_node = VTON(dvp); 1832235537Sgber struct nandfs_inode *dir_inode = &dir_node->nn_inode; 1833235537Sgber struct nandfs_node *node; 1834235537Sgber struct nandfsmount *nmp = dir_node->nn_nmp; 1835235537Sgber uint16_t mode = MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode); 1836235537Sgber int error; 1837235537Sgber 1838235537Sgber DPRINTF(VNCALL, ("%s: dvp %p\n", __func__, dvp)); 1839235537Sgber 1840235537Sgber if (nandfs_fs_full(dir_node->nn_nandfsdev)) 1841235537Sgber return (ENOSPC); 1842235537Sgber 1843235537Sgber if (dir_inode->i_links_count >= LINK_MAX) 1844235537Sgber return (EMLINK); 1845235537Sgber 1846235537Sgber error = nandfs_node_create(nmp, &node, mode); 1847235537Sgber if (error) 1848235537Sgber return (error); 1849235537Sgber 1850235537Sgber node->nn_inode.i_gid = dir_node->nn_inode.i_gid; 1851235537Sgber node->nn_inode.i_uid = cnp->cn_cred->cr_uid; 1852235537Sgber 1853235537Sgber *vpp = NTOV(node); 1854235537Sgber 1855235537Sgber error = nandfs_add_dirent(dvp, node->nn_ino, cnp->cn_nameptr, 1856235537Sgber cnp->cn_namelen, IFTODT(mode)); 1857235537Sgber if (error) { 1858235537Sgber vput(*vpp); 1859235537Sgber return (error); 1860235537Sgber } 1861235537Sgber 1862235537Sgber dir_node->nn_inode.i_links_count++; 1863235537Sgber dir_node->nn_flags |= IN_CHANGE; 1864235537Sgber 1865235537Sgber error = nandfs_init_dir(NTOV(node), node->nn_ino, dir_node->nn_ino); 1866235537Sgber if (error) { 1867235537Sgber vput(NTOV(node)); 1868235537Sgber return (error); 1869235537Sgber } 1870235537Sgber 1871235537Sgber DPRINTF(VNCALL, ("created dir vp %p nandnode %p ino %jx\n", *vpp, node, 1872235537Sgber (uintmax_t)node->nn_ino)); 1873235537Sgber return (0); 1874235537Sgber} 1875235537Sgber 1876235537Sgberstatic int 1877235537Sgbernandfs_mknod(struct vop_mknod_args *ap) 1878235537Sgber{ 1879235537Sgber struct vnode *dvp = ap->a_dvp; 1880235537Sgber struct vnode **vpp = ap->a_vpp; 1881235537Sgber struct vattr *vap = ap->a_vap; 1882235537Sgber uint16_t mode = MAKEIMODE(vap->va_type, vap->va_mode); 1883235537Sgber struct componentname *cnp = ap->a_cnp; 1884235537Sgber struct nandfs_node *dir_node = VTON(dvp); 1885235537Sgber struct nandfsmount *nmp = dir_node->nn_nmp; 1886235537Sgber struct nandfs_node *node; 1887235537Sgber int error; 1888235537Sgber 1889235537Sgber if (nandfs_fs_full(dir_node->nn_nandfsdev)) 1890235537Sgber return (ENOSPC); 1891235537Sgber 1892235537Sgber error = nandfs_node_create(nmp, &node, mode); 1893235537Sgber if (error) 1894235537Sgber return (error); 1895235537Sgber node->nn_inode.i_gid = dir_node->nn_inode.i_gid; 1896235537Sgber node->nn_inode.i_uid = cnp->cn_cred->cr_uid; 1897235537Sgber if (vap->va_rdev != VNOVAL) 1898235537Sgber node->nn_inode.i_special = vap->va_rdev; 1899235537Sgber 1900235537Sgber *vpp = NTOV(node); 1901235537Sgber 1902235537Sgber if (nandfs_add_dirent(dvp, node->nn_ino, cnp->cn_nameptr, 1903235537Sgber cnp->cn_namelen, IFTODT(mode))) { 1904235537Sgber vput(*vpp); 1905235537Sgber return (ENOTDIR); 1906235537Sgber } 1907235537Sgber 1908235537Sgber node->nn_flags |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 1909235537Sgber 1910235537Sgber return (0); 1911235537Sgber} 1912235537Sgber 1913235537Sgberstatic int 1914235537Sgbernandfs_symlink(struct vop_symlink_args *ap) 1915235537Sgber{ 1916235537Sgber struct vnode **vpp = ap->a_vpp; 1917235537Sgber struct vnode *dvp = ap->a_dvp; 1918235537Sgber uint16_t mode = MAKEIMODE(ap->a_vap->va_type, ap->a_vap->va_mode); 1919235537Sgber struct componentname *cnp = ap->a_cnp; 1920235537Sgber struct nandfs_node *dir_node = VTON(dvp); 1921235537Sgber struct nandfsmount *nmp = dir_node->nn_nmp; 1922235537Sgber struct nandfs_node *node; 1923235537Sgber int len, error; 1924235537Sgber 1925235537Sgber if (nandfs_fs_full(dir_node->nn_nandfsdev)) 1926235537Sgber return (ENOSPC); 1927235537Sgber 1928235537Sgber error = nandfs_node_create(nmp, &node, S_IFLNK | mode); 1929235537Sgber if (error) 1930235537Sgber return (error); 1931235537Sgber node->nn_inode.i_gid = dir_node->nn_inode.i_gid; 1932235537Sgber node->nn_inode.i_uid = cnp->cn_cred->cr_uid; 1933235537Sgber 1934235537Sgber *vpp = NTOV(node); 1935235537Sgber 1936235537Sgber if (nandfs_add_dirent(dvp, node->nn_ino, cnp->cn_nameptr, 1937235537Sgber cnp->cn_namelen, IFTODT(mode))) { 1938235537Sgber vput(*vpp); 1939235537Sgber return (ENOTDIR); 1940235537Sgber } 1941235537Sgber 1942235537Sgber 1943235537Sgber len = strlen(ap->a_target); 1944235537Sgber error = vn_rdwr(UIO_WRITE, *vpp, ap->a_target, len, (off_t)0, 1945235537Sgber UIO_SYSSPACE, IO_NODELOCKED | IO_NOMACCHECK, 1946235537Sgber cnp->cn_cred, NOCRED, NULL, NULL); 1947235537Sgber if (error) 1948235537Sgber vput(*vpp); 1949235537Sgber 1950235537Sgber return (error); 1951235537Sgber} 1952235537Sgber 1953235537Sgberstatic int 1954235537Sgbernandfs_readlink(struct vop_readlink_args *ap) 1955235537Sgber{ 1956235537Sgber struct vnode *vp = ap->a_vp; 1957235537Sgber 1958235537Sgber return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred)); 1959235537Sgber} 1960235537Sgber 1961235537Sgberstatic int 1962235537Sgbernandfs_rmdir(struct vop_rmdir_args *ap) 1963235537Sgber{ 1964235537Sgber struct vnode *vp = ap->a_vp; 1965235537Sgber struct vnode *dvp = ap->a_dvp; 1966235537Sgber struct componentname *cnp = ap->a_cnp; 1967235537Sgber struct nandfs_node *node, *dnode; 1968235537Sgber uint32_t dflag, flag; 1969235537Sgber int error = 0; 1970235537Sgber 1971235537Sgber node = VTON(vp); 1972235537Sgber dnode = VTON(dvp); 1973235537Sgber 1974235537Sgber /* Files marked as immutable or append-only cannot be deleted. */ 1975235537Sgber if ((node->nn_inode.i_flags & (IMMUTABLE | APPEND | NOUNLINK)) || 1976235537Sgber (dnode->nn_inode.i_flags & APPEND)) 1977235537Sgber return (EPERM); 1978235537Sgber 1979235537Sgber DPRINTF(VNCALL, ("%s: dvp %p vp %p nandnode %p ino %#jx\n", __func__, 1980235537Sgber dvp, vp, node, (uintmax_t)node->nn_ino)); 1981235537Sgber 1982235537Sgber if (node->nn_inode.i_links_count < 2) 1983235537Sgber return (EINVAL); 1984235537Sgber 1985235537Sgber if (!nandfs_dirempty(vp, dnode->nn_ino, cnp->cn_cred)) 1986235537Sgber return (ENOTEMPTY); 1987235537Sgber 1988235537Sgber /* Files marked as immutable or append-only cannot be deleted. */ 1989235537Sgber dflag = dnode->nn_inode.i_flags; 1990235537Sgber flag = node->nn_inode.i_flags; 1991235537Sgber if ((dflag & APPEND) || 1992235537Sgber (flag & (NOUNLINK | IMMUTABLE | APPEND))) { 1993235537Sgber return (EPERM); 1994235537Sgber } 1995235537Sgber 1996235537Sgber if (vp->v_mountedhere != 0) 1997235537Sgber return (EINVAL); 1998235537Sgber 1999235537Sgber nandfs_remove_dirent(dvp, node, cnp); 2000235537Sgber dnode->nn_inode.i_links_count -= 1; 2001235537Sgber dnode->nn_flags |= IN_CHANGE; 2002235537Sgber 2003235537Sgber cache_purge(dvp); 2004235537Sgber 2005235537Sgber error = nandfs_truncate(vp, (uint64_t)0); 2006235537Sgber if (error) 2007235537Sgber return (error); 2008235537Sgber 2009235537Sgber node->nn_inode.i_links_count -= 2; 2010235537Sgber node->nn_flags |= IN_CHANGE; 2011235537Sgber 2012235537Sgber cache_purge(vp); 2013235537Sgber 2014235537Sgber return (error); 2015235537Sgber} 2016235537Sgber 2017235537Sgberstatic int 2018235537Sgbernandfs_fsync(struct vop_fsync_args *ap) 2019235537Sgber{ 2020235537Sgber struct vnode *vp = ap->a_vp; 2021235537Sgber struct nandfs_node *node = VTON(vp); 2022235537Sgber int locked; 2023235537Sgber 2024235537Sgber DPRINTF(VNCALL, ("%s: vp %p nandnode %p ino %#jx\n", __func__, vp, 2025235537Sgber node, (uintmax_t)node->nn_ino)); 2026235537Sgber 2027235537Sgber /* 2028235537Sgber * Start syncing vnode only if inode was modified or 2029235537Sgber * there are some dirty buffers 2030235537Sgber */ 2031235537Sgber if (VTON(vp)->nn_flags & IN_MODIFIED || 2032235537Sgber vp->v_bufobj.bo_dirty.bv_cnt) { 2033235537Sgber locked = VOP_ISLOCKED(vp); 2034235537Sgber VOP_UNLOCK(vp, 0); 2035235537Sgber nandfs_wakeup_wait_sync(node->nn_nandfsdev, SYNCER_FSYNC); 2036235537Sgber VOP_LOCK(vp, locked | LK_RETRY); 2037235537Sgber } 2038235537Sgber 2039235537Sgber return (0); 2040235537Sgber} 2041235537Sgber 2042235537Sgberstatic int 2043235537Sgbernandfs_bmap(struct vop_bmap_args *ap) 2044235537Sgber{ 2045235537Sgber struct vnode *vp = ap->a_vp; 2046235537Sgber struct nandfs_node *nnode = VTON(vp); 2047235537Sgber struct nandfs_device *nandfsdev = nnode->nn_nandfsdev; 2048235537Sgber nandfs_daddr_t l2vmap, v2pmap; 2049235537Sgber int error; 2050235537Sgber int blk2dev = nandfsdev->nd_blocksize / DEV_BSIZE; 2051235537Sgber 2052235537Sgber DPRINTF(VNCALL, ("%s: vp %p nandnode %p ino %#jx\n", __func__, vp, 2053235537Sgber nnode, (uintmax_t)nnode->nn_ino)); 2054235537Sgber 2055235537Sgber if (ap->a_bop != NULL) 2056235537Sgber *ap->a_bop = &nandfsdev->nd_devvp->v_bufobj; 2057235537Sgber if (ap->a_bnp == NULL) 2058235537Sgber return (0); 2059235537Sgber if (ap->a_runp != NULL) 2060235537Sgber *ap->a_runp = 0; 2061235537Sgber if (ap->a_runb != NULL) 2062235537Sgber *ap->a_runb = 0; 2063235537Sgber 2064235537Sgber /* 2065235537Sgber * Translate all the block sectors into a series of buffers to read 2066235537Sgber * asynchronously from the nandfs device. Note that this lookup may 2067235537Sgber * induce readin's too. 2068235537Sgber */ 2069235537Sgber 2070235537Sgber /* Get virtual block numbers for the vnode's buffer span */ 2071235537Sgber error = nandfs_bmap_lookup(nnode, ap->a_bn, &l2vmap); 2072235537Sgber if (error) 2073235537Sgber return (-1); 2074235537Sgber 2075235537Sgber /* Translate virtual block numbers to physical block numbers */ 2076235537Sgber error = nandfs_vtop(nnode, l2vmap, &v2pmap); 2077235537Sgber if (error) 2078235537Sgber return (-1); 2079235537Sgber 2080235537Sgber /* Note virtual block 0 marks not mapped */ 2081235537Sgber if (l2vmap == 0) 2082235537Sgber *ap->a_bnp = -1; 2083235537Sgber else 2084235537Sgber *ap->a_bnp = v2pmap * blk2dev; /* in DEV_BSIZE */ 2085235537Sgber 2086235537Sgber DPRINTF(VNCALL, ("%s: vp %p nandnode %p ino %#jx lblk %jx -> blk %jx\n", 2087235537Sgber __func__, vp, nnode, (uintmax_t)nnode->nn_ino, (uintmax_t)ap->a_bn, 2088235537Sgber (uintmax_t)*ap->a_bnp )); 2089235537Sgber 2090235537Sgber return (0); 2091235537Sgber} 2092235537Sgber 2093235537Sgberstatic void 2094235537Sgbernandfs_force_syncer(struct nandfsmount *nmp) 2095235537Sgber{ 2096235537Sgber 2097235537Sgber nmp->nm_flags |= NANDFS_FORCE_SYNCER; 2098235537Sgber nandfs_wakeup_wait_sync(nmp->nm_nandfsdev, SYNCER_FFORCE); 2099235537Sgber} 2100235537Sgber 2101235537Sgberstatic int 2102235537Sgbernandfs_ioctl(struct vop_ioctl_args *ap) 2103235537Sgber{ 2104235537Sgber struct vnode *vp = ap->a_vp; 2105235537Sgber u_long command = ap->a_command; 2106235537Sgber caddr_t data = ap->a_data; 2107235537Sgber struct nandfs_node *node = VTON(vp); 2108235537Sgber struct nandfs_device *nandfsdev = node->nn_nandfsdev; 2109235537Sgber struct nandfsmount *nmp = node->nn_nmp; 2110235537Sgber uint64_t *tab, *cno; 2111235537Sgber struct nandfs_seg_stat *nss; 2112235537Sgber struct nandfs_cpmode *ncpm; 2113235537Sgber struct nandfs_argv *nargv; 2114235537Sgber struct nandfs_cpstat *ncp; 2115235537Sgber int error; 2116235537Sgber 2117235537Sgber DPRINTF(VNCALL, ("%s: %x\n", __func__, (uint32_t)command)); 2118235537Sgber 2119235537Sgber error = priv_check(ap->a_td, PRIV_VFS_MOUNT); 2120235537Sgber if (error) 2121235537Sgber return (error); 2122235537Sgber 2123235537Sgber if (nmp->nm_ronly) { 2124235537Sgber switch (command) { 2125235537Sgber case NANDFS_IOCTL_GET_FSINFO: 2126235537Sgber case NANDFS_IOCTL_GET_SUSTAT: 2127235537Sgber case NANDFS_IOCTL_GET_CPINFO: 2128235537Sgber case NANDFS_IOCTL_GET_CPSTAT: 2129235537Sgber case NANDFS_IOCTL_GET_SUINFO: 2130235537Sgber case NANDFS_IOCTL_GET_VINFO: 2131235537Sgber case NANDFS_IOCTL_GET_BDESCS: 2132235537Sgber break; 2133235537Sgber default: 2134235537Sgber return (EROFS); 2135235537Sgber } 2136235537Sgber } 2137235537Sgber 2138235537Sgber switch (command) { 2139235537Sgber case NANDFS_IOCTL_GET_FSINFO: 2140235537Sgber error = nandfs_get_fsinfo(nmp, (struct nandfs_fsinfo *)data); 2141235537Sgber break; 2142235537Sgber case NANDFS_IOCTL_GET_SUSTAT: 2143235537Sgber nss = (struct nandfs_seg_stat *)data; 2144235537Sgber error = nandfs_get_seg_stat(nandfsdev, nss); 2145235537Sgber break; 2146235537Sgber case NANDFS_IOCTL_CHANGE_CPMODE: 2147235537Sgber ncpm = (struct nandfs_cpmode *)data; 2148235537Sgber error = nandfs_chng_cpmode(nandfsdev->nd_cp_node, ncpm); 2149235537Sgber nandfs_force_syncer(nmp); 2150235537Sgber break; 2151235537Sgber case NANDFS_IOCTL_GET_CPINFO: 2152235537Sgber nargv = (struct nandfs_argv *)data; 2153235537Sgber error = nandfs_get_cpinfo_ioctl(nandfsdev->nd_cp_node, nargv); 2154235537Sgber break; 2155235537Sgber case NANDFS_IOCTL_DELETE_CP: 2156235537Sgber tab = (uint64_t *)data; 2157235537Sgber error = nandfs_delete_cp(nandfsdev->nd_cp_node, tab[0], tab[1]); 2158235537Sgber nandfs_force_syncer(nmp); 2159235537Sgber break; 2160235537Sgber case NANDFS_IOCTL_GET_CPSTAT: 2161235537Sgber ncp = (struct nandfs_cpstat *)data; 2162235537Sgber error = nandfs_get_cpstat(nandfsdev->nd_cp_node, ncp); 2163235537Sgber break; 2164235537Sgber case NANDFS_IOCTL_GET_SUINFO: 2165235537Sgber nargv = (struct nandfs_argv *)data; 2166235537Sgber error = nandfs_get_segment_info_ioctl(nandfsdev, nargv); 2167235537Sgber break; 2168235537Sgber case NANDFS_IOCTL_GET_VINFO: 2169235537Sgber nargv = (struct nandfs_argv *)data; 2170235537Sgber error = nandfs_get_dat_vinfo_ioctl(nandfsdev, nargv); 2171235537Sgber break; 2172235537Sgber case NANDFS_IOCTL_GET_BDESCS: 2173235537Sgber nargv = (struct nandfs_argv *)data; 2174235537Sgber error = nandfs_get_dat_bdescs_ioctl(nandfsdev, nargv); 2175235537Sgber break; 2176235537Sgber case NANDFS_IOCTL_SYNC: 2177235537Sgber cno = (uint64_t *)data; 2178235537Sgber nandfs_force_syncer(nmp); 2179235537Sgber *cno = nandfsdev->nd_last_cno; 2180235537Sgber error = 0; 2181235537Sgber break; 2182235537Sgber case NANDFS_IOCTL_MAKE_SNAP: 2183235537Sgber cno = (uint64_t *)data; 2184235537Sgber error = nandfs_make_snap(nandfsdev, cno); 2185235537Sgber nandfs_force_syncer(nmp); 2186235537Sgber break; 2187235537Sgber case NANDFS_IOCTL_DELETE_SNAP: 2188235537Sgber cno = (uint64_t *)data; 2189235537Sgber error = nandfs_delete_snap(nandfsdev, *cno); 2190235537Sgber nandfs_force_syncer(nmp); 2191235537Sgber break; 2192235537Sgber default: 2193235537Sgber error = ENOTTY; 2194235537Sgber break; 2195235537Sgber } 2196235537Sgber 2197235537Sgber return (error); 2198235537Sgber} 2199235537Sgber 2200235537Sgber/* 2201235537Sgber * Whiteout vnode call 2202235537Sgber */ 2203235537Sgberstatic int 2204235537Sgbernandfs_whiteout(struct vop_whiteout_args *ap) 2205235537Sgber{ 2206235537Sgber struct vnode *dvp = ap->a_dvp; 2207235537Sgber struct componentname *cnp = ap->a_cnp; 2208235537Sgber int error = 0; 2209235537Sgber 2210235537Sgber switch (ap->a_flags) { 2211235537Sgber case LOOKUP: 2212235537Sgber return (0); 2213235537Sgber case CREATE: 2214235537Sgber /* Create a new directory whiteout */ 2215235537Sgber#ifdef INVARIANTS 2216235537Sgber if ((cnp->cn_flags & SAVENAME) == 0) 2217235537Sgber panic("ufs_whiteout: missing name"); 2218235537Sgber#endif 2219235537Sgber error = nandfs_add_dirent(dvp, NANDFS_WHT_INO, cnp->cn_nameptr, 2220235537Sgber cnp->cn_namelen, DT_WHT); 2221235537Sgber break; 2222235537Sgber 2223235537Sgber case DELETE: 2224235537Sgber /* Remove an existing directory whiteout */ 2225235537Sgber cnp->cn_flags &= ~DOWHITEOUT; 2226235537Sgber error = nandfs_remove_dirent(dvp, NULL, cnp); 2227235537Sgber break; 2228235537Sgber default: 2229235537Sgber panic("nandf_whiteout: unknown op: %d", ap->a_flags); 2230235537Sgber } 2231235537Sgber 2232235537Sgber return (error); 2233235537Sgber} 2234235537Sgber 2235235537Sgberstatic int 2236235537Sgbernandfs_pathconf(struct vop_pathconf_args *ap) 2237235537Sgber{ 2238235537Sgber int error; 2239235537Sgber 2240235537Sgber error = 0; 2241235537Sgber switch (ap->a_name) { 2242235537Sgber case _PC_LINK_MAX: 2243235537Sgber *ap->a_retval = LINK_MAX; 2244235537Sgber break; 2245235537Sgber case _PC_NAME_MAX: 2246235537Sgber *ap->a_retval = NAME_MAX; 2247235537Sgber break; 2248235537Sgber case _PC_PATH_MAX: 2249235537Sgber *ap->a_retval = PATH_MAX; 2250235537Sgber break; 2251235537Sgber case _PC_PIPE_BUF: 2252235537Sgber *ap->a_retval = PIPE_BUF; 2253235537Sgber break; 2254235537Sgber case _PC_CHOWN_RESTRICTED: 2255235537Sgber *ap->a_retval = 1; 2256235537Sgber break; 2257235537Sgber case _PC_NO_TRUNC: 2258235537Sgber *ap->a_retval = 1; 2259235537Sgber break; 2260235537Sgber case _PC_ACL_EXTENDED: 2261235537Sgber *ap->a_retval = 0; 2262235537Sgber break; 2263235537Sgber case _PC_ALLOC_SIZE_MIN: 2264235537Sgber *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_bsize; 2265235537Sgber break; 2266235537Sgber case _PC_FILESIZEBITS: 2267235537Sgber *ap->a_retval = 64; 2268235537Sgber break; 2269235537Sgber case _PC_REC_INCR_XFER_SIZE: 2270235537Sgber *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize; 2271235537Sgber break; 2272235537Sgber case _PC_REC_MAX_XFER_SIZE: 2273235537Sgber *ap->a_retval = -1; /* means ``unlimited'' */ 2274235537Sgber break; 2275235537Sgber case _PC_REC_MIN_XFER_SIZE: 2276235537Sgber *ap->a_retval = ap->a_vp->v_mount->mnt_stat.f_iosize; 2277235537Sgber break; 2278235537Sgber default: 2279235537Sgber error = EINVAL; 2280235537Sgber break; 2281235537Sgber } 2282235537Sgber return (error); 2283235537Sgber} 2284235537Sgber 2285235537Sgberstatic int 2286235537Sgbernandfs_vnlock1(struct vop_lock1_args *ap) 2287235537Sgber{ 2288235537Sgber struct vnode *vp = ap->a_vp; 2289235537Sgber struct nandfs_node *node = VTON(vp); 2290235537Sgber int error, vi_locked; 2291235537Sgber 2292235537Sgber /* 2293235537Sgber * XXX can vnode go away while we are sleeping? 2294235537Sgber */ 2295235537Sgber vi_locked = mtx_owned(&vp->v_interlock); 2296235537Sgber if (vi_locked) 2297235537Sgber VI_UNLOCK(vp); 2298235537Sgber error = NANDFS_WRITELOCKFLAGS(node->nn_nandfsdev, 2299235537Sgber ap->a_flags & LK_NOWAIT); 2300235537Sgber if (vi_locked && !error) 2301235537Sgber VI_LOCK(vp); 2302235537Sgber if (error) 2303235537Sgber return (error); 2304235537Sgber 2305235537Sgber error = vop_stdlock(ap); 2306235537Sgber if (error) { 2307235537Sgber NANDFS_WRITEUNLOCK(node->nn_nandfsdev); 2308235537Sgber return (error); 2309235537Sgber } 2310235537Sgber 2311235537Sgber return (0); 2312235537Sgber} 2313235537Sgber 2314235537Sgberstatic int 2315235537Sgbernandfs_vnunlock(struct vop_unlock_args *ap) 2316235537Sgber{ 2317235537Sgber struct vnode *vp = ap->a_vp; 2318235537Sgber struct nandfs_node *node = VTON(vp); 2319235537Sgber int error; 2320235537Sgber 2321235537Sgber error = vop_stdunlock(ap); 2322235537Sgber if (error) 2323235537Sgber return (error); 2324235537Sgber 2325235537Sgber NANDFS_WRITEUNLOCK(node->nn_nandfsdev); 2326235537Sgber 2327235537Sgber return (0); 2328235537Sgber} 2329235537Sgber 2330235537Sgber/* 2331235537Sgber * Global vfs data structures 2332235537Sgber */ 2333235537Sgberstruct vop_vector nandfs_vnodeops = { 2334235537Sgber .vop_default = &default_vnodeops, 2335235537Sgber .vop_access = nandfs_access, 2336235537Sgber .vop_advlock = nandfs_advlock, 2337235537Sgber .vop_bmap = nandfs_bmap, 2338235537Sgber .vop_close = nandfs_close, 2339235537Sgber .vop_create = nandfs_create, 2340235537Sgber .vop_fsync = nandfs_fsync, 2341235537Sgber .vop_getattr = nandfs_getattr, 2342235537Sgber .vop_inactive = nandfs_inactive, 2343235537Sgber .vop_cachedlookup = nandfs_lookup, 2344235537Sgber .vop_ioctl = nandfs_ioctl, 2345235537Sgber .vop_link = nandfs_link, 2346235537Sgber .vop_lookup = vfs_cache_lookup, 2347235537Sgber .vop_mkdir = nandfs_mkdir, 2348235537Sgber .vop_mknod = nandfs_mknod, 2349235537Sgber .vop_open = nandfs_open, 2350235537Sgber .vop_pathconf = nandfs_pathconf, 2351235537Sgber .vop_print = nandfs_print, 2352235537Sgber .vop_read = nandfs_read, 2353235537Sgber .vop_readdir = nandfs_readdir, 2354235537Sgber .vop_readlink = nandfs_readlink, 2355235537Sgber .vop_reclaim = nandfs_reclaim, 2356235537Sgber .vop_remove = nandfs_remove, 2357235537Sgber .vop_rename = nandfs_rename, 2358235537Sgber .vop_rmdir = nandfs_rmdir, 2359235537Sgber .vop_whiteout = nandfs_whiteout, 2360235537Sgber .vop_write = nandfs_write, 2361235537Sgber .vop_setattr = nandfs_setattr, 2362235537Sgber .vop_strategy = nandfs_strategy, 2363235537Sgber .vop_symlink = nandfs_symlink, 2364235537Sgber .vop_lock1 = nandfs_vnlock1, 2365235537Sgber .vop_unlock = nandfs_vnunlock, 2366235537Sgber}; 2367235537Sgber 2368235537Sgberstruct vop_vector nandfs_system_vnodeops = { 2369235537Sgber .vop_default = &default_vnodeops, 2370235537Sgber .vop_close = nandfs_close, 2371235537Sgber .vop_inactive = nandfs_inactive, 2372235537Sgber .vop_reclaim = nandfs_reclaim, 2373235537Sgber .vop_strategy = nandfs_strategy, 2374235537Sgber .vop_fsync = nandfs_fsync, 2375235537Sgber .vop_bmap = nandfs_bmap, 2376235537Sgber .vop_access = VOP_PANIC, 2377235537Sgber .vop_advlock = VOP_PANIC, 2378235537Sgber .vop_create = VOP_PANIC, 2379235537Sgber .vop_getattr = VOP_PANIC, 2380235537Sgber .vop_cachedlookup = VOP_PANIC, 2381235537Sgber .vop_ioctl = VOP_PANIC, 2382235537Sgber .vop_link = VOP_PANIC, 2383235537Sgber .vop_lookup = VOP_PANIC, 2384235537Sgber .vop_mkdir = VOP_PANIC, 2385235537Sgber .vop_mknod = VOP_PANIC, 2386235537Sgber .vop_open = VOP_PANIC, 2387235537Sgber .vop_pathconf = VOP_PANIC, 2388235537Sgber .vop_print = VOP_PANIC, 2389235537Sgber .vop_read = VOP_PANIC, 2390235537Sgber .vop_readdir = VOP_PANIC, 2391235537Sgber .vop_readlink = VOP_PANIC, 2392235537Sgber .vop_remove = VOP_PANIC, 2393235537Sgber .vop_rename = VOP_PANIC, 2394235537Sgber .vop_rmdir = VOP_PANIC, 2395235537Sgber .vop_whiteout = VOP_PANIC, 2396235537Sgber .vop_write = VOP_PANIC, 2397235537Sgber .vop_setattr = VOP_PANIC, 2398235537Sgber .vop_symlink = VOP_PANIC, 2399235537Sgber}; 2400235537Sgber 2401235537Sgberstatic int 2402235537Sgbernandfsfifo_close(struct vop_close_args *ap) 2403235537Sgber{ 2404235537Sgber struct vnode *vp = ap->a_vp; 2405235537Sgber struct nandfs_node *node = VTON(vp); 2406235537Sgber 2407235537Sgber DPRINTF(VNCALL, ("%s: vp %p node %p\n", __func__, vp, node)); 2408235537Sgber 2409235537Sgber mtx_lock(&vp->v_interlock); 2410235537Sgber if (vp->v_usecount > 1) 2411235537Sgber nandfs_itimes_locked(vp); 2412235537Sgber mtx_unlock(&vp->v_interlock); 2413235537Sgber 2414235537Sgber return (fifo_specops.vop_close(ap)); 2415235537Sgber} 2416235537Sgber 2417235537Sgberstruct vop_vector nandfs_fifoops = { 2418235537Sgber .vop_default = &fifo_specops, 2419235537Sgber .vop_fsync = VOP_PANIC, 2420235537Sgber .vop_access = nandfs_access, 2421235537Sgber .vop_close = nandfsfifo_close, 2422235537Sgber .vop_getattr = nandfs_getattr, 2423235537Sgber .vop_inactive = nandfs_inactive, 2424235537Sgber .vop_print = nandfs_print, 2425235537Sgber .vop_read = VOP_PANIC, 2426235537Sgber .vop_reclaim = nandfs_reclaim, 2427235537Sgber .vop_setattr = nandfs_setattr, 2428235537Sgber .vop_write = VOP_PANIC, 2429235537Sgber .vop_lock1 = nandfs_vnlock1, 2430235537Sgber .vop_unlock = nandfs_vnunlock, 2431235537Sgber}; 2432235537Sgber 2433235537Sgberint 2434235537Sgbernandfs_vinit(struct vnode *vp, uint64_t ino) 2435235537Sgber{ 2436235537Sgber struct nandfs_node *node; 2437235537Sgber 2438235537Sgber ASSERT_VOP_LOCKED(vp, __func__); 2439235537Sgber 2440235537Sgber node = VTON(vp); 2441235537Sgber 2442235537Sgber /* Check if we're fetching the root */ 2443235537Sgber if (ino == NANDFS_ROOT_INO) 2444235537Sgber vp->v_vflag |= VV_ROOT; 2445235537Sgber 2446235537Sgber if (ino != NANDFS_GC_INO) 2447235537Sgber vp->v_type = IFTOVT(node->nn_inode.i_mode); 2448235537Sgber else 2449235537Sgber vp->v_type = VREG; 2450235537Sgber 2451235537Sgber if (vp->v_type == VFIFO) 2452235537Sgber vp->v_op = &nandfs_fifoops; 2453235537Sgber 2454235537Sgber return (0); 2455235537Sgber} 2456