upstream/illumos/illumos-gate: comparison usr/src/uts/common/fs/cachefs/cachefs

equal deleted inserted replaced

-:60af2e048340
+:1f18b17afbef
 static int cachefs_getsecattr_connected(vnode_t *vp, vsecattr_t *vsec, int flag,
 cred_t *cr);
 static int cachefs_getsecattr_disconnected(vnode_t *vp, vsecattr_t *vsec,
 int flag, cred_t *cr);
-static int	cachefs_dump(struct vnode *, caddr_t, int, int,
+static int	cachefs_dump(struct vnode *, caddr_t, offset_t, offset_t,
 			caller_context_t *);
 static int	cachefs_pageio(struct vnode *, page_t *,
 		    u_offset_t, size_t, int, cred_t *, caller_context_t *);
 static int	cachefs_writepage(struct vnode *vp, caddr_t base,
 		    int tcount, struct uio *uiop);
 int
 cachefs_init_vnops(char *name)
 {
 	return (vn_make_ops(name,
-		    cachefs_vnodeops_template, &cachefs_vnodeops));
+	    cachefs_vnodeops_template, &cachefs_vnodeops));
 }
 struct vnodeops *
 cachefs_getvnodeops(void)
 {
 			 * credentials don't match the creds in the
 			 * cnode disallow writing while disconnected.
 			 */
 			if (crcmp(cp->c_cred, CRED()) != 0 &&
 			    secpolicy_vnode_access(CRED(), *vpp,
-					    cp->c_attr.va_uid, VWRITE) != 0) {
+			    cp->c_attr.va_uid, VWRITE) != 0) {
 				mutex_exit(&cp->c_statelock);
 				connected = 1;
 				continue;
 			}
 			/* to get here, we know that the WRITE flag is on */
 			/* pass open to the back file */
 			if (cp->c_backvp) {
 				cp->c_flags &= ~CN_NEEDOPEN;
 				CFS_DPRINT_BACKFS_NFSV4(fscp,
-					("cachefs_open (nfsv4): cnode %p, "
+				    ("cachefs_open (nfsv4): cnode %p, "
-					"backvp %p\n", cp, cp->c_backvp));
+				    "backvp %p\n", cp, cp->c_backvp));
 				error = VOP_OPEN(&cp->c_backvp, flag, cr, ct);
 				if (CFS_TIMEOUT(fscp, error)) {
 					mutex_exit(&cp->c_statelock);
 					cachefs_cd_release(fscp);
 					held = 0;
 			if (fscp->fs_cdconnected != CFS_CD_CONNECTED)
 				goto out;
 			mutex_enter(&cp->c_statelock);
 			if (cp->c_backvp) {
 				CFS_DPRINT_BACKFS_NFSV4(fscp,
-					("cachefs_close (nfsv4): cnode %p, "
+				    ("cachefs_close (nfsv4): cnode %p, "
-					"backvp %p\n", cp, cp->c_backvp));
+				    "backvp %p\n", cp, cp->c_backvp));
 				error = VOP_CLOSE(cp->c_backvp, flag, count,
 				    offset, cr, ct);
 				if (CFS_TIMEOUT(fscp, error)) {
 					mutex_exit(&cp->c_statelock);
 					cachefs_cd_release(fscp);
 			/* always call VOP_CLOSE() for back fs vnode */
 		}
 		/* force dirty data to stable storage */
 		else if ((vp->v_type == VREG) && (flag & FWRITE) &&
-				!CFS_ISFS_BACKFS_NFSV4(fscp)) {
+		    !CFS_ISFS_BACKFS_NFSV4(fscp)) {
 			/* clean the cachefs pages synchronously */
 			error = cachefs_putpage_common(vp, (offset_t)0,
 			    0, 0, cr);
 			if (CFS_TIMEOUT(fscp, error)) {
 				if (fscp->fs_cdconnected == CFS_CD_CONNECTED) {
 		goto out;
 	}
 	if (MANDLOCK(vp, cp->c_attr.va_mode)) {
 		error = chklock(vp, FREAD, (offset_t)uiop->uio_loffset,
-			    uiop->uio_resid, uiop->uio_fmode, ct);
+		    uiop->uio_resid, uiop->uio_fmode, ct);
 		if (error)
 			return (error);
 	}
 	/*
 			n = diff;
 		base = segmap_getmapflt(segkmap, vp, off, (uint_t)n, 1, S_READ);
 		error = segmap_fault(kas.a_hat, segkmap, base, n,
-			F_SOFTLOCK, S_READ);
+		    F_SOFTLOCK, S_READ);
 		if (error) {
 			(void) segmap_release(segkmap, base, 0);
 			if (FC_CODE(error) == FC_OBJERR)
 				error =  FC_ERRNO(error);
 			else
 				error = EIO;
 			break;
 		}
 		error = uiomove(base+mapoff, n, UIO_READ, uiop);
 		(void) segmap_fault(kas.a_hat, segkmap, base, n,
-				F_SOFTUNLOCK, S_READ);
+		    F_SOFTUNLOCK, S_READ);
 		if (error == 0) {
 			/*
 			 * if we read a whole page(s), or to eof,
 			 *  we won't need this page(s) again soon.
 			 */
 			if (n + mapoff == MAXBSIZE ||
-				uiop->uio_loffset == cp->c_size)
+			    uiop->uio_loffset == cp->c_size)
 				flags |= SM_DONTNEED;
 		}
 		(void) segmap_release(segkmap, base, flags);
 	} while (error == 0 && uiop->uio_resid > 0);
 out:
 #ifdef CFSDEBUG
 	CFS_DEBUG(CFSDEBUG_VOPS)
 		printf("cachefs_read: EXIT error %d resid %ld\n", error,
-			uiop->uio_resid);
+		    uiop->uio_resid);
 #endif
 	return (error);
 }
 /*
 	mutex_enter(&cp->c_statelock);
 	backvp = cp->c_backvp;
 	mutex_exit(&cp->c_statelock);
 	CFS_DPRINT_BACKFS_NFSV4(fscp, ("cachefs_read_backfs_nfsv4: cnode %p, "
-					"backvp %p\n", cp, backvp));
+	    "backvp %p\n", cp, backvp));
 	(void) VOP_RWLOCK(backvp, V_WRITELOCK_FALSE, ct);
 	error = VOP_READ(backvp, uiop, ioflag, cr, ct);
 	VOP_RWUNLOCK(backvp, V_WRITELOCK_FALSE, ct);
 #ifdef CFSDEBUG
 	CFS_DEBUG(CFSDEBUG_VOPS)
 		printf(
 		"cachefs_write: ENTER vp %p offset %llu count %ld cflags %x\n",
-			(void *)vp, uiop->uio_loffset, uiop->uio_resid,
+		    (void *)vp, uiop->uio_loffset, uiop->uio_resid,
-			cp->c_flags);
+		    cp->c_flags);
 #endif
 	if (getzoneid() != GLOBAL_ZONEID) {
 		error = EPERM;
 		goto out;
 	}
 		goto out2;
 	}
 	if (MANDLOCK(vp, cp->c_attr.va_mode)) {
 		error = chklock(vp, FWRITE, (offset_t)uiop->uio_loffset,
-			    uiop->uio_resid, uiop->uio_fmode, ct);
+		    uiop->uio_resid, uiop->uio_fmode, ct);
 		if (error)
 			goto out;
 	}
 	if (ioflag & FAPPEND) {
 	mutex_enter(&cp->c_statelock);
 	backvp = cp->c_backvp;
 	mutex_exit(&cp->c_statelock);
 	CFS_DPRINT_BACKFS_NFSV4(fscp, ("cachefs_write_backfs_nfsv4: cnode %p, "
-					"backvp %p\n", cp, backvp));
+	    "backvp %p\n", cp, backvp));
 	(void) VOP_RWLOCK(backvp, V_WRITELOCK_TRUE, ct);
 	error = VOP_WRITE(backvp, uiop, ioflag, cr, ct);
 	VOP_RWUNLOCK(backvp, V_WRITELOCK_TRUE, ct);
 	return (error);
 		 * if we are going to rewrite the entire mapping
 		 * or if we are going to write to or beyond the current
 		 * end of file from the beginning of the mapping.
 		 */
 		if ((offset > (lastpage_off + PAGEOFFSET)) ||
-			((cp->c_size == 0) && (offset < PAGESIZE)) ||
+		    ((cp->c_size == 0) && (offset < PAGESIZE)) ||
-			((uintptr_t)base & PAGEOFFSET) == 0 && (n == PAGESIZE ||
+		    ((uintptr_t)base & PAGEOFFSET) == 0 && (n == PAGESIZE ||
-			((offset + n) >= cp->c_size))) {
+		    ((offset + n) >= cp->c_size))) {
 			pagecreate = 1;
 			/*
 			 * segmap_pagecreate() returns 1 if it calls
 			 * page_create_va() to allocate any pages.
 			 * Unlock the page allocated by page_create_va()
 			 * in segmap_pagecreate()
 			 */
 			if (newpage)
 				segmap_pageunlock(segkmap,
-					(caddr_t)((uintptr_t)base &
+				    (caddr_t)((uintptr_t)base &
-						(uintptr_t)PAGEMASK),
+				    (uintptr_t)PAGEMASK),
-					PAGESIZE, S_WRITE);
+				    PAGESIZE, S_WRITE);
 		} else {
 			/*
 			 * KLUDGE ! Use segmap_fault instead of faulting and
 			 * using as_fault() to avoid a recursive readers lock
 			 * on kas.
 				 * we make here.
 				 */
 				if (cachefs_charge_page(cp, offset) == 0) {
 					cachefs_update_allocmap(cp,
 					    offset & (offset_t)PAGEMASK,
-							(size_t)PAGESIZE);
+					    (size_t)PAGESIZE);
 				}
 				/* else we ran out of space */
 				else {
 					/* nocache file if connected */
 	 * there is less file space allocated than a whole
 	 * page, we'll shorten the i/o request below.
 	 */
 	pp = pvn_write_kluster(vp, pp, &iooff, &iolen, lbn_off,
-			roundup(bsize, PAGESIZE), flags);
+	    roundup(bsize, PAGESIZE), flags);
 	/*
 	 * The CN_CMODINPROG flag makes sure that we use a correct
 	 * value of c_size, below.  CN_CMODINPROG is set in
 	 * cachefs_writepage().  When CN_CMODINPROG is set it
 	    RLIM64_INFINITY, cr, &resid);
 	if (error) {
 #ifdef CFSDEBUG
 		CFS_DEBUG(CFSDEBUG_VOPS | CFSDEBUG_BACK)
 			printf("cachefspush: error %d cr %p\n",
-				error, (void *)cr);
+			    error, (void *)cr);
 #endif
 		bp->b_flags |= B_ERROR;
 	}
 	VN_RELE(backvp);
 out:
 		}
 	}
 	(void) cachefs_update_allocmap(cp, iooff, iolen);
 	cp->c_flags |= (CN_UPDATED | CN_NEED_FRONT_SYNC |
-		CN_POPULATION_PENDING);
+	    CN_POPULATION_PENDING);
 	if (fscp->fs_cdconnected != CFS_CD_CONNECTED) {
 		gethrestime(&cp->c_metadata.md_localmtime);
 		cp->c_metadata.md_flags |= MD_LOCALMTIME;
 	}
 	return (error);
 }
 /*ARGSUSED*/
 static int
-cachefs_dump(struct vnode *vp, caddr_t foo1, int foo2, int foo3,
+cachefs_dump(struct vnode *vp, caddr_t foo1, offset_t foo2, offset_t foo3,
 caller_context_t *ct)
 {
 	return (ENOSYS); /* should we panic if we get here? */
 }
 		/*
 		 * Assert NFSv4 only allows the daemonid and getstats
 		 * daemon requests
 		 */
 		ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0 ||
-			STRUCT_FGET(dcmd, d_cmd) == CFSDCMD_DAEMONID ||
+		    STRUCT_FGET(dcmd, d_cmd) == CFSDCMD_DAEMONID ||
-			STRUCT_FGET(dcmd, d_cmd) == CFSDCMD_GETSTATS);
+		    STRUCT_FGET(dcmd, d_cmd) == CFSDCMD_GETSTATS);
 		/* get the routine to execute */
 		dcmd_routine = NULL;
 		switch (STRUCT_FGET(dcmd, d_cmd)) {
 		case CFSDCMD_DAEMONID:
 	mutex_enter(&cp->c_statelock);
 	backvp = cp->c_backvp;
 	mutex_exit(&cp->c_statelock);
 	CFS_DPRINT_BACKFS_NFSV4(fscp, ("cachefs_getattr_backfs_nfsv4: cnode %p,"
-					" backvp %p\n", cp, backvp));
+	    " backvp %p\n", cp, backvp));
 	error = VOP_GETATTR(backvp, vap, flags, cr, ct);
 	/* Update attributes */
 	cp->c_attr = *vap;
 	if (mask & AT_SIZE && !CFS_ISFS_BACKFS_NFSV4(fscp)) {
 		bcnt = (uint_t)(cp->c_size & PAGEOFFSET);
 		if (bcnt)
 			pvn_vpzero(vp, cp->c_size, PAGESIZE - bcnt);
 		(void) pvn_vplist_dirty(vp, cp->c_size, cachefs_push,
-			B_TRUNC | B_INVAL, cr);
+		    B_TRUNC | B_INVAL, cr);
 	}
 out:
 	rw_exit(&cp->c_rwlock);
 	error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr);
 	if (error)
 		goto out;
 	CFS_DPRINT_BACKFS_NFSV4(fscp, ("cachefs_setattr (nfsv4): cnode %p, "
-					"backvp %p\n", cp, cp->c_backvp));
+	    "backvp %p\n", cp, cp->c_backvp));
 	error = VOP_SETATTR(cp->c_backvp, vap, flags, cr, ct);
 	if (error) {
 		goto out;
 	}
 	/* primary concern is to keep this routine as much like ufs_setattr */
 	mutex_enter(&cp->c_statelock);
 	error = secpolicy_vnode_setattr(cr, vp, vap, &cp->c_attr, flags,
-			    cachefs_access_local, cp);
+	    cachefs_access_local, cp);
 	if (error)
 		goto out;
 	mask = vap->va_mask;
 			if (error)
 				goto out;
 		}
 		CFS_DPRINT_BACKFS_NFSV4(fscp,
-			("cachefs_access (nfsv4): cnode %p, backvp %p\n",
+		    ("cachefs_access (nfsv4): cnode %p, backvp %p\n",
-			cp, cp->c_backvp));
+		    cp, cp->c_backvp));
 		error = VOP_ACCESS(cp->c_backvp, mode, flags, cr, NULL);
 		/*
 		 * even though we don't `need' the ACL to do access
 		 * via the backvp, we should cache it here to make our
 		}
 		if (cp->c_metadata.md_flags & MD_POPULATED) {
 			/* read symlink data from frontfile */
 			uiop->uio_offset = 0;
 			(void) VOP_RWLOCK(cp->c_frontvp,
-						V_WRITELOCK_FALSE, NULL);
+			    V_WRITELOCK_FALSE, NULL);
 			error = VOP_READ(cp->c_frontvp, uiop, 0, kcred, NULL);
 			VOP_RWUNLOCK(cp->c_frontvp, V_WRITELOCK_FALSE, NULL);
 			/* XXX KLUDGE! correct for insidious 0-len symlink */
 			if (cp->c_size != 0) {
 		}
 		if (cp->c_metadata.md_flags & MD_POPULATED) {
 			/* read symlink data from frontfile */
 			uiop->uio_offset = 0;
 			(void) VOP_RWLOCK(cp->c_frontvp,
-						V_WRITELOCK_FALSE, NULL);
+			    V_WRITELOCK_FALSE, NULL);
 			error = VOP_READ(cp->c_frontvp, uiop, 0, kcred, NULL);
 			VOP_RWUNLOCK(cp->c_frontvp, V_WRITELOCK_FALSE, NULL);
 			readcache = 1;
 			goto out;
 		}
 		if ((fscp->fs_cdconnected == CFS_CD_CONNECTED) &&
 		    cp->c_backvp) {
 			mutex_enter(&cp->c_statelock);
 			if (cp->c_backvp) {
 				CFS_DPRINT_BACKFS_NFSV4(fscp,
-					("cachefs_fsync (nfsv4): cnode %p, "
+				    ("cachefs_fsync (nfsv4): cnode %p, "
-					"backvp %p\n", cp, cp->c_backvp));
+				    "backvp %p\n", cp, cp->c_backvp));
 				error = VOP_FSYNC(cp->c_backvp, syncflag, cr,
 				    ct);
 				if (CFS_TIMEOUT(fscp, error)) {
 					mutex_exit(&cp->c_statelock);
 					cachefs_cd_release(fscp);
 	fscache_t *fscp = C_TO_FSCACHE(cp);
 #ifdef CFSDEBUG
 	CFS_DEBUG(CFSDEBUG_VOPS)
 		printf("c_sync_metadata: ENTER cp %p cflag %x\n",
-			(void *)cp, cp->c_flags);
+		    (void *)cp, cp->c_flags);
 #endif
 	mutex_enter(&cp->c_statelock);
 	if ((cp->c_flags & CN_UPDATED) == 0)
 		goto out;
 			if (error) {
 				cp->c_metadata.md_timestamp.tv_sec = 0;
 			} else {
 				va.va_mask = AT_MTIME;
 				error = VOP_GETATTR(cp->c_frontvp, &va, 0,
-					kcred, NULL);
+				    kcred, NULL);
 				if (error)
 					goto out;
 				cp->c_metadata.md_timestamp = va.va_mtime;
 				cp->c_flags &=
-				~(CN_NEED_FRONT_SYNC | CN_POPULATION_PENDING);
+				    ~(CN_NEED_FRONT_SYNC |
+				    CN_POPULATION_PENDING);
 			}
 		} else {
 			cp->c_flags &=
-				~(CN_NEED_FRONT_SYNC | CN_POPULATION_PENDING);
+			    ~(CN_NEED_FRONT_SYNC | CN_POPULATION_PENDING);
 		}
 	}
 	/*
 	 * XXX tony: How can CN_ALLOC_PENDING still be set??
 	 * XXX tony: How can CN_UPDATED not be set?????
 	 */
 	if ((cp->c_flags & CN_ALLOC_PENDING) == 0 &&
-			(cp->c_flags & CN_UPDATED)) {
+	    (cp->c_flags & CN_UPDATED)) {
 		error = filegrp_write_metadata(fgp, &cp->c_id,
-				&cp->c_metadata);
+		    &cp->c_metadata);
 		if (error)
 			goto out;
 	}
 out:
 	if (error) {
 	mutex_exit(&cp->c_statelock);
 #ifdef CFSDEBUG
 	CFS_DEBUG(CFSDEBUG_VOPS)
 		printf("c_sync_metadata: EXIT cp %p cflag %x\n",
-			(void *)cp, cp->c_flags);
+		    (void *)cp, cp->c_flags);
 #endif
 	return (error);
 }
 	/* by now we have a valid cached front file that we can search */
 	ASSERT((dcp->c_flags & CN_ASYNC_POPULATE) == 0);
 	error = cachefs_dir_look(dcp, nm, &cookie, &flag,
-			&d_offset, &cid);
+	    &d_offset, &cid);
 	mutex_exit(&dcp->c_statelock);
 	if (error) {
 		/* if the entry does not have the fid, go get it */
 		if (error == EINVAL) {
 		if (error)
 			goto out;
 	}
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_lookup (nfsv4): dcp %p, dbackvp %p, name %s\n",
+	    ("cachefs_lookup (nfsv4): dcp %p, dbackvp %p, name %s\n",
-		dcp, dcp->c_backvp, nm));
+	    dcp, dcp->c_backvp, nm));
 	error = VOP_LOOKUP(dcp->c_backvp, nm, &backvp, (struct pathname *)NULL,
 	    0, (vnode_t *)NULL, cr, NULL, NULL, NULL);
 	if (error)
 		goto out;
 	if (IS_DEVVP(backvp)) {
 	mutex_exit(&dcp->c_statelock);
 	/* create the cnode */
 	if (error == 0) {
 		error = cachefs_cnode_make(&cid, fscp,
-					(valid_fid ? &cookie : NULL),
+		    (valid_fid ? &cookie : NULL),
-					&va, backvp, cr, 0, &cp);
+		    &va, backvp, cr, 0, &cp);
 		if (error == 0) {
 			*vpp = CTOV(cp);
 		}
 	}
 		}
 	}
 	/* create the file on the back fs */
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_create (nfsv4): dcp %p, dbackvp %p,"
+	    ("cachefs_create (nfsv4): dcp %p, dbackvp %p,"
-		"name %s\n", dcp, dcp->c_backvp, nm));
+	    "name %s\n", dcp, dcp->c_backvp, nm));
 	error = VOP_CREATE(dcp->c_backvp, nm, vap, exclusive, mode,
 	    &devvp, cr, 0, NULL, NULL);
 	mutex_exit(&dcp->c_statelock);
 	if (error)
 		goto out;
 	/* make the cnode */
 	cid.cid_fileno = va.va_nodeid;
 	cid.cid_flags = 0;
 	error = cachefs_cnode_make(&cid, fscp, (valid_fid ? &cookie : NULL),
-					&va, tvp, cr, 0, &ncp);
+	    &va, tvp, cr, 0, &ncp);
 	if (error)
 		goto out;
 	*vpp = CTOV(ncp);
 				connected = 0;
 				continue;
 			}
 		} else {
 			error = cachefs_remove_disconnected(dvp, nm, cr,
-				vp);
+			    vp);
 			if (CFS_TIMEOUT(fscp, error)) {
 				connected = 1;
 				continue;
 			}
 		}
 	mutex_enter(&dcp->c_statelock);
 	dbackvp = dcp->c_backvp;
 	mutex_exit(&dcp->c_statelock);
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_remove (nfsv4): dcp %p, dbackvp %p, name %s\n",
+	    ("cachefs_remove (nfsv4): dcp %p, dbackvp %p, name %s\n",
-		dcp, dbackvp, nm));
+	    dcp, dbackvp, nm));
 	error = VOP_REMOVE(dbackvp, nm, cr, NULL, 0);
 	if (error) {
 		mutex_exit(&cp->c_statelock);
 		goto out;
 	}
 	int connected = 0;
 #ifdef CFSDEBUG
 	CFS_DEBUG(CFSDEBUG_VOPS)
 		printf("cachefs_link: ENTER fvp %p tdvp %p tnm %s\n",
-			(void *)fvp, (void *)tdvp, tnm);
+		    (void *)fvp, (void *)tdvp, tnm);
 #endif
 	if (getzoneid() != GLOBAL_ZONEID) {
 		error = EPERM;
 		goto out;
 				connected = 0;
 				continue;
 			}
 		} else {
 			error = cachefs_link_disconnected(tdvp, fvp, tnm,
-				cr);
+			    cr);
 			if (CFS_TIMEOUT(fscp, error)) {
 				connected = 1;
 				continue;
 			}
 		}
 #endif
 out:
 #ifdef CFSDEBUG
 	CFS_DEBUG(CFSDEBUG_VOPS)
 		printf("cachefs_link: EXIT fvp %p tdvp %p tnm %s\n",
-			(void *)fvp, (void *)tdvp, tnm);
+		    (void *)fvp, (void *)tdvp, tnm);
 #endif
 	return (error);
 }
 static int
 		VN_HOLD(backvp);
 	}
 	/* perform the link on the back fs */
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_link (nfsv4): tdcp %p, tdbackvp %p, "
+	    ("cachefs_link (nfsv4): tdcp %p, tdbackvp %p, "
-		"name %s\n", tdcp, tdcp->c_backvp, tnm));
+	    "name %s\n", tdcp, tdcp->c_backvp, tnm));
 	error = VOP_LINK(tdcp->c_backvp, backvp, tnm, cr, NULL, 0);
 	if (error) {
 		mutex_exit(&tdcp->c_statelock);
 		goto out;
 	}
 	/*
 	 * if the fs NOFILL or NOCACHE flags are on, then the old and new
 	 * directory cnodes better indicate NOCACHE mode as well.
 	 */
-	ASSERT
+	ASSERT(
-	    ((fscp->fs_cache->c_flags & (CACHE_NOFILL | CACHE_NOCACHE)) == 0 ||
+	    (fscp->fs_cache->c_flags & (CACHE_NOFILL | CACHE_NOCACHE)) == 0 ||
 	    ((VTOC(odvp)->c_flags & CN_NOCACHE) &&
 	    (VTOC(ndvp)->c_flags & CN_NOCACHE)));
 	/*
 	 * Cachefs only provides pass-through support for NFSv4,
 			}
 		}
 		/* get the cnode if file being deleted */
 		error = cachefs_lookup_common(ndvp, nnm, &delvp, NULL, 0,
-			NULL, cr);
+		    NULL, cr);
 		if (error) {
 			delvp = NULL;
 			if (fscp->fs_cdconnected == CFS_CD_CONNECTED) {
 				if (CFS_TIMEOUT(fscp, error)) {
 					cachefs_cd_release(fscp);
 			}
 		}
 		if (fscp->fs_cdconnected == CFS_CD_CONNECTED) {
 			error = cachefs_rename_connected(odvp, onm,
-				ndvp, nnm, cr, delvp);
+			    ndvp, nnm, cr, delvp);
 			if (CFS_TIMEOUT(fscp, error)) {
 				cachefs_cd_release(fscp);
 				held = 0;
 				cachefs_cd_timedout(fscp);
 				connected = 0;
 				continue;
 			}
 		} else {
 			error = cachefs_rename_disconnected(odvp, onm,
-				ndvp, nnm, cr, delvp);
+			    ndvp, nnm, cr, delvp);
 			if (CFS_TIMEOUT(fscp, error)) {
 				connected = 1;
 				continue;
 			}
 		}
 		}
 	}
 	/* do the rename on the back fs */
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_rename (nfsv4): odcp %p, odbackvp %p, "
+	    ("cachefs_rename (nfsv4): odcp %p, odbackvp %p, "
-		" ndcp %p, ndbackvp %p, onm %s, nnm %s\n",
+	    " ndcp %p, ndbackvp %p, onm %s, nnm %s\n",
-		odcp, odcp->c_backvp, ndcp, ndcp->c_backvp, onm, nnm));
+	    odcp, odcp->c_backvp, ndcp, ndcp->c_backvp, onm, nnm));
 	error = VOP_RENAME(odcp->c_backvp, onm, ndcp->c_backvp, nnm, cr, NULL,
 	    0);
 	if (error)
 		goto out;
 	gotdirent = 0;
 	cookiep = NULL;
 	if (CFS_ISFS_NONSHARED(fscp) &&
 	    (odcp->c_metadata.md_flags & MD_POPULATED)) {
 		error = cachefs_dir_look(odcp, onm, &cookie,
-			NULL, NULL, &cid);
+		    NULL, NULL, &cid);
 		if (error == 0 || error == EINVAL) {
 			gotdirent = 1;
 			if (error == 0)
 				cookiep = &cookie;
 		} else {
 		rw_enter(&dcp->c_rwlock, RW_WRITER);
 		held = 1;
 		if (fscp->fs_cdconnected == CFS_CD_CONNECTED) {
 			error = cachefs_mkdir_connected(dvp, nm, vap,
-				vpp, cr);
+			    vpp, cr);
 			if (CFS_TIMEOUT(fscp, error)) {
 				rw_exit(&dcp->c_rwlock);
 				cachefs_cd_release(fscp);
 				held = 0;
 				cachefs_cd_timedout(fscp);
 				connected = 0;
 				continue;
 			}
 		} else {
 			error = cachefs_mkdir_disconnected(dvp, nm, vap,
-				vpp, cr);
+			    vpp, cr);
 			if (CFS_TIMEOUT(fscp, error)) {
 				connected = 1;
 				continue;
 			}
 		}
 	}
 	dircid = dcp->c_id;
 	/* make the dir on the back fs */
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_mkdir (nfsv4): dcp %p, dbackvp %p, "
+	    ("cachefs_mkdir (nfsv4): dcp %p, dbackvp %p, "
-		"name %s\n", dcp, dcp->c_backvp, nm));
+	    "name %s\n", dcp, dcp->c_backvp, nm));
 	error = VOP_MKDIR(dcp->c_backvp, nm, vap, &vp, cr, NULL, 0, NULL);
 	mutex_exit(&dcp->c_statelock);
 	if (error) {
 		goto out;
 	}
 		goto out;
 	}
 	cid.cid_flags = 0;
 	cid.cid_fileno = attr.va_nodeid;
 	error = cachefs_cnode_make(&cid, fscp, (valid_fid ? &cookie : NULL),
-					&attr, vp, cr, 0, &newcp);
+	    &attr, vp, cr, 0, &newcp);
 	if (error) {
 		goto out;
 	}
 	ASSERT(CTOV(newcp)->v_type == VDIR);
 	*vpp = CTOV(newcp);
 	}
 	cachefs_modified(dcp);
 	/* enter the new file in the directory */
 	error = cachefs_dir_enter(dcp, nm, &newcp->c_metadata.md_cookie,
-		&newcp->c_id, SM_ASYNC);
+	    &newcp->c_id, SM_ASYNC);
 	if (error) {
 		mutex_exit(&dcp->c_statelock);
 		goto out;
 	}
 			break;
 		}
 		if (fscp->fs_cdconnected == CFS_CD_CONNECTED) {
 			error = cachefs_rmdir_connected(dvp, nm, cdir,
-				cr, vp);
+			    cr, vp);
 			if (CFS_TIMEOUT(fscp, error)) {
 				cachefs_cd_release(fscp);
 				held = 0;
 				cachefs_cd_timedout(fscp);
 				connected = 0;
 				continue;
 			}
 		} else {
 			error = cachefs_rmdir_disconnected(dvp, nm, cdir,
-				cr, vp);
+			    cr, vp);
 			if (CFS_TIMEOUT(fscp, error)) {
 				connected = 1;
 				continue;
 			}
 		}
 	if (error)
 		goto out;
 	/* rmdir on the back fs */
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_rmdir (nfsv4): dcp %p, dbackvp %p, "
+	    ("cachefs_rmdir (nfsv4): dcp %p, dbackvp %p, "
-		"name %s\n", dcp, dcp->c_backvp, nm));
+	    "name %s\n", dcp, dcp->c_backvp, nm));
 	error = VOP_RMDIR(dcp->c_backvp, nm, cdir, cr, NULL, 0);
 	if (error)
 		goto out;
 	/* if the dir is populated, remove the entry from it */
 		rw_enter(&dcp->c_rwlock, RW_WRITER);
 		held = 1;
 		if (fscp->fs_cdconnected == CFS_CD_CONNECTED) {
 			error = cachefs_symlink_connected(dvp, lnm, tva,
-				tnm, cr);
+			    tnm, cr);
 			if (CFS_TIMEOUT(fscp, error)) {
 				rw_exit(&dcp->c_rwlock);
 				cachefs_cd_release(fscp);
 				held = 0;
 				cachefs_cd_timedout(fscp);
 				connected = 0;
 				continue;
 			}
 		} else {
 			error = cachefs_symlink_disconnected(dvp, lnm, tva,
-				tnm, cr);
+			    tnm, cr);
 			if (CFS_TIMEOUT(fscp, error)) {
 				connected = 1;
 				continue;
 			}
 		}
 	if (error) {
 		mutex_exit(&dcp->c_statelock);
 		goto out;
 	}
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_symlink (nfsv4): dcp %p, dbackvp %p, "
+	    ("cachefs_symlink (nfsv4): dcp %p, dbackvp %p, "
-		"lnm %s, tnm %s\n", dcp, dcp->c_backvp, lnm, tnm));
+	    "lnm %s, tnm %s\n", dcp, dcp->c_backvp, lnm, tnm));
 	error = VOP_SYMLINK(dcp->c_backvp, lnm, tva, tnm, cr, NULL, 0);
 	if (error) {
 		mutex_exit(&dcp->c_statelock);
 		goto out;
 	}
 	}
 	mutex_exit(&dcp->c_statelock);
 	/* make the cnode for the sym link */
 	error = cachefs_cnode_make(&cid, fscp, (valid_fid ? &cookie : NULL),
-						&va, backvp, cr, 0, &newcp);
+	    &va, backvp, cr, 0, &newcp);
 	if (error) {
 		ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0);
 		cachefs_nocache(dcp);
 		error = 0;
 		goto out;
 		mutex_exit(&dcp->c_statelock);
 		goto out;
 	}
 	cachefs_modified(dcp);
 	error = cachefs_dir_enter(dcp, lnm, &newcp->c_metadata.md_cookie,
-		&newcp->c_id, SM_ASYNC);
+	    &newcp->c_id, SM_ASYNC);
 	if (error) {
 		mutex_exit(&dcp->c_statelock);
 		goto out;
 	}
 		break;
 	}
 	if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_READDIR))
 		cachefs_log_readdir(cachep, error, fscp->fs_cfsvfsp,
-		&dcp->c_metadata.md_cookie, dcp->c_id.cid_fileno,
+		    &dcp->c_metadata.md_cookie, dcp->c_id.cid_fileno,
-		crgetuid(cr), uiop->uio_loffset, *eofp);
+		    crgetuid(cr), uiop->uio_loffset, *eofp);
 	if (held) {
 		rw_exit(&dcp->c_rwlock);
 		cachefs_cd_release(fscp);
 	}
 	    CFS_ISFS_BACKFS_NFSV4(fscp) ||
 	    (dcp->c_flags & (CN_NOCACHE | CN_ASYNC_POPULATE)) ||
 	    ((dcp->c_metadata.md_flags & MD_POPULATED) == 0)) {
 		if (error && !(dcp->c_flags & CN_NOCACHE) &&
-			!CFS_ISFS_BACKFS_NFSV4(fscp))
+		    !CFS_ISFS_BACKFS_NFSV4(fscp))
 			cachefs_nocache(dcp);
 		/* get the back vp */
 		if (dcp->c_backvp == NULL) {
 			error = cachefs_getbackvp(fscp, dcp);
 		if (fscp->fs_inum_size > 0) {
 			error = cachefs_readback_translate(dcp, uiop, cr, eofp);
 		} else {
 			/* do the dir read from the back fs */
 			(void) VOP_RWLOCK(dcp->c_backvp,
-						V_WRITELOCK_FALSE, NULL);
+			    V_WRITELOCK_FALSE, NULL);
 			CFS_DPRINT_BACKFS_NFSV4(fscp,
-				("cachefs_readdir (nfsv4): "
+			    ("cachefs_readdir (nfsv4): "
-				"dcp %p, dbackvp %p\n", dcp, dcp->c_backvp));
+			    "dcp %p, dbackvp %p\n", dcp, dcp->c_backvp));
 			error = VOP_READDIR(dcp->c_backvp, uiop, cr, eofp,
 			    NULL, 0);
 			VOP_RWUNLOCK(dcp->c_backvp, V_WRITELOCK_FALSE, NULL);
 		}
 	}
 	/* Call backfilesystem if NFSv4 */
 	if (CFS_ISFS_BACKFS_NFSV4(fscp)) {
 		error = cachefs_getpage_backfs_nfsv4(vp, off, len, protp, pl,
-						plsz, seg, addr, rw, cr);
+		    plsz, seg, addr, rw, cr);
 		goto out;
 	}
 	/* XXX sam: make this do an async populate? */
 	if (pl == NULL) {
 		 * cachefs_write()
 		 * operation the local file size might not be extended yet.
 		 * In this case we want to be able to return pages of zeroes.
 		 */
 		if ((u_offset_t)off + len >
-			((cp->c_size + PAGEOFFSET) & (offset_t)PAGEMASK)) {
+		    ((cp->c_size + PAGEOFFSET) & (offset_t)PAGEMASK)) {
 			if (seg != segkmap) {
 				error = EFAULT;
 				break;
 			}
 		}
 	mutex_enter(&cp->c_statelock);
 	backvp = cp->c_backvp;
 	mutex_exit(&cp->c_statelock);
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_getpage_backfs_nfsv4: cnode %p, backvp %p\n",
+	    ("cachefs_getpage_backfs_nfsv4: cnode %p, backvp %p\n",
-		cp, backvp));
+	    cp, backvp));
 	error = VOP_GETPAGE(backvp, off, len, protp, pl, plsz, seg,
-				    addr, rw, cr, NULL);
+	    addr, rw, cr, NULL);
 	return (error);
 }
 /*
 				error = cachefs_getbackvp(fscp, cp);
 				if (error)
 					goto out;
 			}
 			error = VOP_GETPAGE(cp->c_backvp, off,
-					PAGESIZE, protp, ourpl, PAGESIZE, seg,
+			    PAGESIZE, protp, ourpl, PAGESIZE, seg,
-					addr, S_READ, cr, NULL);
+			    addr, S_READ, cr, NULL);
 			/*
 			 * backfs returns EFAULT when we are trying for a
 			 * page beyond EOF but cachefs has the knowledge that
 			 * it is not beyond EOF be cause cp->c_size is
 			 * greater then the offset requested.
 					popsize = PAGESIZE;
 				}
 			}
 			/* else XXX assert CN_NOCACHE? */
 			error = VOP_GETPAGE(cp->c_backvp, (offset_t)off,
-					PAGESIZE, protp, ourpl, popsize,
+			    PAGESIZE, protp, ourpl, popsize,
-					seg, addr, S_READ, cr, NULL);
+			    seg, addr, S_READ, cr, NULL);
 			if (error)
 				goto out;
 			fscp->fs_stats.st_misses++;
 		} else {
 			if (cp->c_flags & CN_POPULATION_PENDING) {
 			error = cachefs_getbackvp(fscp, cp);
 			if (error)
 				goto out;
 		}
 		error = VOP_GETPAGE(cp->c_backvp, (offset_t)off,
-			PAGESIZE, protp, ourpl, PAGESIZE, seg,
+		    PAGESIZE, protp, ourpl, PAGESIZE, seg,
-			addr, S_READ, cr, NULL);
+		    addr, S_READ, cr, NULL);
 		if (error)
 			goto out;
 		if (have_statelock) {
 			mutex_exit(&cp->c_statelock);
 	mutex_enter(&cp->c_statelock);
 	backvp = cp->c_backvp;
 	mutex_exit(&cp->c_statelock);
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_putpage_backfs_nfsv4: cnode %p, backvp %p\n",
+	    ("cachefs_putpage_backfs_nfsv4: cnode %p, backvp %p\n",
-		cp, backvp));
+	    cp, backvp));
 	error = VOP_PUTPAGE(backvp, off, len, flags, cr, NULL);
 	return (error);
 }
 		 * Do a range from [off...off + len] looking for pages
 		 * to deal with.
 		 */
 		eoff = (u_offset_t)off + len;
 		for (io_off = off; io_off < eoff && io_off < cp->c_size;
-			io_off += io_len) {
+		    io_off += io_len) {
 			/*
 			 * If we are not invalidating, synchronously
 			 * freeing or writing pages use the routine
 			 * page_lookup_nowait() to prevent reclaiming
 			 * them from the free list.
 			 */
 			if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) {
 				pp = page_lookup(vp, io_off,
-					(flags & (B_INVAL | B_FREE)) ?
+				    (flags & (B_INVAL | B_FREE)) ?
-					    SE_EXCL : SE_SHARED);
+				    SE_EXCL : SE_SHARED);
 			} else {
 				/* XXX this looks like dead code */
 				pp = page_lookup_nowait(vp, io_off,
-					(flags & B_FREE) ? SE_EXCL : SE_SHARED);
+				    (flags & B_FREE) ? SE_EXCL : SE_SHARED);
 			}
 			if (pp == NULL || pvn_getdirty(pp, flags) == 0)
 				io_len = PAGESIZE;
 			else {
 				error = cachefs_push(vp, pp, &io_off,
-					&io_len, flags, cr);
+				    &io_len, flags, cr);
 				if (error != 0)
 					break;
 				/*
 				 * "io_off" and "io_len" are returned as
 				 * the range of pages we actually wrote.
 #ifdef CFSDEBUG
 	u_offset_t offx = (u_offset_t)off;
 	CFS_DEBUG(CFSDEBUG_VOPS)
 		printf("cachefs_map: ENTER vp %p off %lld len %lu flags %d\n",
-			(void *)vp, offx, len, flags);
+		    (void *)vp, offx, len, flags);
 #endif
 	if (getzoneid() != GLOBAL_ZONEID) {
 		error = EPERM;
 		goto out;
 	}
 #endif
 	/* call backfilesystem if NFSv4 */
 	if (CFS_ISFS_BACKFS_NFSV4(fscp)) {
 		error = cachefs_map_backfs_nfsv4(vp, off, as, addrp, len, prot,
-						maxprot, flags, cr);
+		    maxprot, flags, cr);
 		goto out;
 	}
 	writing = (prot & PROT_WRITE && ((flags & MAP_PRIVATE) == 0));
 	mutex_enter(&cp->c_statelock);
 	backvp = cp->c_backvp;
 	mutex_exit(&cp->c_statelock);
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_map_backfs_nfsv4: cnode %p, backvp %p\n",
+	    ("cachefs_map_backfs_nfsv4: cnode %p, backvp %p\n",
-		cp, backvp));
+	    cp, backvp));
 	error = VOP_MAP(backvp, off, as, addrp, len, prot, maxprot, flags, cr,
 	    NULL);
 	return (error);
 }
 			}
 		}
 		/* do lock on the back file */
 		CFS_DPRINT_BACKFS_NFSV4(fscp,
-			("cachefs_frlock (nfsv4): cp %p, backvp %p\n",
+		    ("cachefs_frlock (nfsv4): cp %p, backvp %p\n",
-			cp, backvp));
+		    cp, backvp));
 		error = VOP_FRLOCK(backvp, cmd, bfp, flag, offset, NULL, cr,
 		    ct);
 		VN_RELE(backvp);
 		if (CFS_TIMEOUT(fscp, error)) {
 			connected = 1;
 		return (EINVAL);
 	/* call backfilesystem if NFSv4 */
 	if (CFS_ISFS_BACKFS_NFSV4(fscp)) {
 		error = cachefs_space_backfs_nfsv4(vp, cmd, bfp, flag,
-						offset, cr, ct);
+		    offset, cr, ct);
 		goto out;
 	}
 	if ((error = convoff(vp, bfp, 0, offset)) == 0) {
 		ASSERT(bfp->l_start >= 0);
 	mutex_enter(&cp->c_statelock);
 	backvp = cp->c_backvp;
 	mutex_exit(&cp->c_statelock);
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_space_backfs_nfsv4: cnode %p, backvp %p\n",
+	    ("cachefs_space_backfs_nfsv4: cnode %p, backvp %p\n",
-		cp, backvp));
+	    cp, backvp));
 	error = VOP_SPACE(backvp, cmd, bfp, flag, offset, cr, ct);
 	return (error);
 }
 		goto out;
 	}
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_setsecattr (nfsv4): cp %p, backvp %p",
+	    ("cachefs_setsecattr (nfsv4): cp %p, backvp %p",
-		cp, cp->c_backvp));
+	    cp, cp->c_backvp));
 	error = VOP_SETSECATTR(cp->c_backvp, vsec, flag, cr, NULL);
 	if (error) {
 		goto out;
 	}
 	int held = 0;
 	int error = 0;
 #ifdef CFSDEBUG
 	CFS_DEBUG(CFSDEBUG_VOPS)
-	    printf("cachefs_setsecattr: ENTER vp %p\n", (void *)vp);
+		printf("cachefs_setsecattr: ENTER vp %p\n", (void *)vp);
 #endif
 	if (getzoneid() != GLOBAL_ZONEID) {
 		error = EPERM;
 		goto out;
 	}
 	mutex_exit(&cp->c_statelock);
 	ASSERT((error != 0) || (backvp != NULL));
 	if (error == 0) {
 		CFS_DPRINT_BACKFS_NFSV4(fscp,
-			("cachefs_shrlock (nfsv4): cp %p, backvp %p",
+		    ("cachefs_shrlock (nfsv4): cp %p, backvp %p",
-			cp, backvp));
+		    cp, backvp));
 		error = VOP_SHRLOCK(backvp, cmd, shr, flag, cr, ct);
 	}
 out:
 #ifdef CFSDEBUG
 		error = cachefs_getbackvp(fscp, cp);
 	if (error)
 		goto out;
 	CFS_DPRINT_BACKFS_NFSV4(fscp,
-		("cachefs_getsecattr (nfsv4): cp %p, backvp %p",
+	    ("cachefs_getsecattr (nfsv4): cp %p, backvp %p",
-		cp, cp->c_backvp));
+	    cp, cp->c_backvp));
 	error = VOP_GETSECATTR(cp->c_backvp, vsec, flag, cr, NULL);
 	if (error)
 		goto out;
 	if (((fscp->fs_info.fi_mntflags & CFS_NOACL) == 0) &&
 		for (i = 0; i < vsecp->vsa_aclcnt; i++) {
 			aclp = ((aclent_t *)vsecp->vsa_aclentp) + i;
 			switch (aclp->a_type) {
 			case CLASS_OBJ:
 				cp->c_metadata.md_aclclass =
-			    aclp->a_perm;
+				    aclp->a_perm;
 				/*FALLTHROUGH*/
 			case USER_OBJ:
 			case GROUP_OBJ:
 			case OTHER_OBJ:
 				aclp->a_perm = 06;
 		va.va_type = VDIR;
 		va.va_mask = AT_TYPE | AT_MODE |
 		    AT_UID | AT_GID;
 		error =
 		    VOP_MKDIR(cp->c_filegrp->fg_dirvp,
-			name, &va, &cp->c_acldirvp, kcred, NULL, 0, NULL);
+		    name, &va, &cp->c_acldirvp, kcred, NULL, 0, NULL);
 		if (error != 0)
 			goto out;
 	}
 	ASSERT(cp->c_acldirvp != NULL);
 			 */
 			owner = aclp->a_id;
 			if (crgetuid(cr) == owner) {
 				error = ACL_MODE_CHECK(mode, aclp->a_perm << 6,
-							cr, cp);
+				    cr, cp);
 				goto out;
 			}
 			break;
 		case CLASS_OBJ:
 		aclp = ((aclent_t *)vsec.vsa_aclentp) + i;
 		switch (aclp->a_type) {
 		case USER:
 			if (crgetuid(cr) == aclp->a_id) {
 				error = ACL_MODE_CHECK(mode,
-					(aclp->a_perm & mask) << 6, cr, cp);
+				    (aclp->a_perm & mask) << 6, cr, cp);
 				goto out;
 			}
 			break;
 		case GROUP_OBJ:
 			if (groupmember(aclp->a_id, cr)) {
 				++ngroup;
 				gperm |= aclp->a_perm;
 				if (! ismask) {
 					error = ACL_MODE_CHECK(mode,
-							aclp->a_perm << 6,
+					    aclp->a_perm << 6,
-							cr, cp);
+					    cr, cp);
 					goto out;
 				}
 			}
 			break;
 			break;
 		case OTHER_OBJ:
 			if (ngroup == 0) {
 				error = ACL_MODE_CHECK(mode, aclp->a_perm << 6,
-						cr, cp);
+				    cr, cp);
 				goto out;
 			}
 			break;
 		default:

changeset 6264	1f18b17afbef
parent 6036	c98c367c32cb
child 7240	c4957ab6a78e