1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 24 */ 25 26 #include <sys/param.h> 27 #include <sys/types.h> 28 #include <sys/systm.h> 29 #include <sys/cred.h> 30 #include <sys/proc.h> 31 #include <sys/user.h> 32 #include <sys/time.h> 33 #include <sys/vnode.h> 34 #include <sys/vfs.h> 35 #include <sys/vfs_opreg.h> 36 #include <sys/file.h> 37 #include <sys/filio.h> 38 #include <sys/uio.h> 39 #include <sys/buf.h> 40 #include <sys/mman.h> 41 #include <sys/tiuser.h> 42 #include <sys/pathname.h> 43 #include <sys/dirent.h> 44 #include <sys/conf.h> 45 #include <sys/debug.h> 46 #include <sys/vmsystm.h> 47 #include <sys/fcntl.h> 48 #include <sys/flock.h> 49 #include <sys/swap.h> 50 #include <sys/errno.h> 51 #include <sys/sysmacros.h> 52 #include <sys/disp.h> 53 #include <sys/kmem.h> 54 #include <sys/cmn_err.h> 55 #include <sys/vtrace.h> 56 #include <sys/mount.h> 57 #include <sys/bootconf.h> 58 #include <sys/dnlc.h> 59 #include <sys/stat.h> 60 #include <sys/acl.h> 61 #include <sys/policy.h> 62 #include <rpc/types.h> 63 64 #include <vm/hat.h> 65 #include <vm/as.h> 66 #include <vm/page.h> 67 #include <vm/pvn.h> 68 #include <vm/seg.h> 69 #include <vm/seg_map.h> 70 #include <vm/seg_vn.h> 71 #include <vm/rm.h> 72 #include <sys/fs/cachefs_fs.h> 73 #include <sys/fs/cachefs_dir.h> 74 #include <sys/fs/cachefs_dlog.h> 75 #include <sys/fs/cachefs_ioctl.h> 76 #include <sys/fs/cachefs_log.h> 77 #include <fs/fs_subr.h> 78 79 int cachefs_dnlc; /* use dnlc, debugging */ 80 81 static void cachefs_attr_setup(vattr_t *srcp, vattr_t *targp, cnode_t *cp, 82 cred_t *cr); 83 static void cachefs_creategid(cnode_t *dcp, cnode_t *newcp, vattr_t *vap, 84 cred_t *cr); 85 static void cachefs_createacl(cnode_t *dcp, cnode_t *newcp); 86 static int cachefs_getaclfromcache(cnode_t *cp, vsecattr_t *vsec); 87 static int cachefs_getacldirvp(cnode_t *cp); 88 static void cachefs_acl2perm(cnode_t *cp, vsecattr_t *vsec); 89 static int cachefs_access_local(void *cp, int mode, cred_t *cr); 90 static int cachefs_acl_access(struct cnode *cp, int mode, cred_t *cr); 91 static int cachefs_push_connected(vnode_t *vp, struct buf *bp, size_t iolen, 92 u_offset_t iooff, cred_t *cr); 93 static int cachefs_push_front(vnode_t *vp, struct buf *bp, size_t iolen, 94 u_offset_t iooff, cred_t *cr); 95 static int cachefs_setattr_connected(vnode_t *vp, vattr_t *vap, int flags, 96 cred_t *cr, caller_context_t *ct); 97 static int cachefs_setattr_disconnected(vnode_t *vp, vattr_t *vap, 98 int flags, cred_t *cr, caller_context_t *ct); 99 static int cachefs_access_connected(struct vnode *vp, int mode, 100 int flags, cred_t *cr); 101 static int cachefs_lookup_back(vnode_t *dvp, char *nm, vnode_t **vpp, 102 cred_t *cr); 103 static int cachefs_symlink_connected(vnode_t *dvp, char *lnm, vattr_t *tva, 104 char *tnm, cred_t *cr); 105 static int cachefs_symlink_disconnected(vnode_t *dvp, char *lnm, 106 vattr_t *tva, char *tnm, cred_t *cr); 107 static int cachefs_link_connected(vnode_t *tdvp, vnode_t *fvp, char *tnm, 108 cred_t *cr); 109 static int cachefs_link_disconnected(vnode_t *tdvp, vnode_t *fvp, 110 char *tnm, cred_t *cr); 111 static int cachefs_mkdir_connected(vnode_t *dvp, char *nm, vattr_t *vap, 112 vnode_t **vpp, cred_t *cr); 113 static int cachefs_mkdir_disconnected(vnode_t *dvp, char *nm, vattr_t *vap, 114 vnode_t **vpp, cred_t *cr); 115 static int cachefs_stickyrmchk(struct cnode *dcp, struct cnode *cp, cred_t *cr); 116 static int cachefs_rmdir_connected(vnode_t *dvp, char *nm, 117 vnode_t *cdir, cred_t *cr, vnode_t *vp); 118 static int cachefs_rmdir_disconnected(vnode_t *dvp, char *nm, 119 vnode_t *cdir, cred_t *cr, vnode_t *vp); 120 static char *cachefs_newname(void); 121 static int cachefs_remove_dolink(vnode_t *dvp, vnode_t *vp, char *nm, 122 cred_t *cr); 123 static int cachefs_rename_connected(vnode_t *odvp, char *onm, 124 vnode_t *ndvp, char *nnm, cred_t *cr, vnode_t *delvp); 125 static int cachefs_rename_disconnected(vnode_t *odvp, char *onm, 126 vnode_t *ndvp, char *nnm, cred_t *cr, vnode_t *delvp); 127 static int cachefs_readdir_connected(vnode_t *vp, uio_t *uiop, cred_t *cr, 128 int *eofp); 129 static int cachefs_readdir_disconnected(vnode_t *vp, uio_t *uiop, 130 cred_t *cr, int *eofp); 131 static int cachefs_readback_translate(cnode_t *cp, uio_t *uiop, 132 cred_t *cr, int *eofp); 133 134 static int cachefs_setattr_common(vnode_t *vp, vattr_t *vap, int flags, 135 cred_t *cr, caller_context_t *ct); 136 137 static int cachefs_open(struct vnode **, int, cred_t *, 138 caller_context_t *); 139 static int cachefs_close(struct vnode *, int, int, offset_t, 140 cred_t *, caller_context_t *); 141 static int cachefs_read(struct vnode *, struct uio *, int, cred_t *, 142 caller_context_t *); 143 static int cachefs_write(struct vnode *, struct uio *, int, cred_t *, 144 caller_context_t *); 145 static int cachefs_ioctl(struct vnode *, int, intptr_t, int, cred_t *, 146 int *, caller_context_t *); 147 static int cachefs_getattr(struct vnode *, struct vattr *, int, 148 cred_t *, caller_context_t *); 149 static int cachefs_setattr(struct vnode *, struct vattr *, 150 int, cred_t *, caller_context_t *); 151 static int cachefs_access(struct vnode *, int, int, cred_t *, 152 caller_context_t *); 153 static int cachefs_lookup(struct vnode *, char *, struct vnode **, 154 struct pathname *, int, struct vnode *, cred_t *, 155 caller_context_t *, int *, pathname_t *); 156 static int cachefs_create(struct vnode *, char *, struct vattr *, 157 enum vcexcl, int, struct vnode **, cred_t *, int, 158 caller_context_t *, vsecattr_t *); 159 static int cachefs_create_connected(vnode_t *dvp, char *nm, 160 vattr_t *vap, enum vcexcl exclusive, int mode, 161 vnode_t **vpp, cred_t *cr); 162 static int cachefs_create_disconnected(vnode_t *dvp, char *nm, 163 vattr_t *vap, enum vcexcl exclusive, int mode, 164 vnode_t **vpp, cred_t *cr); 165 static int cachefs_remove(struct vnode *, char *, cred_t *, 166 caller_context_t *, int); 167 static int cachefs_link(struct vnode *, struct vnode *, char *, 168 cred_t *, caller_context_t *, int); 169 static int cachefs_rename(struct vnode *, char *, struct vnode *, 170 char *, cred_t *, caller_context_t *, int); 171 static int cachefs_mkdir(struct vnode *, char *, struct 172 vattr *, struct vnode **, cred_t *, caller_context_t *, 173 int, vsecattr_t *); 174 static int cachefs_rmdir(struct vnode *, char *, struct vnode *, 175 cred_t *, caller_context_t *, int); 176 static int cachefs_readdir(struct vnode *, struct uio *, 177 cred_t *, int *, caller_context_t *, int); 178 static int cachefs_symlink(struct vnode *, char *, struct vattr *, 179 char *, cred_t *, caller_context_t *, int); 180 static int cachefs_readlink(struct vnode *, struct uio *, cred_t *, 181 caller_context_t *); 182 static int cachefs_readlink_connected(vnode_t *vp, uio_t *uiop, cred_t *cr); 183 static int cachefs_readlink_disconnected(vnode_t *vp, uio_t *uiop); 184 static int cachefs_fsync(struct vnode *, int, cred_t *, 185 caller_context_t *); 186 static void cachefs_inactive(struct vnode *, cred_t *, caller_context_t *); 187 static int cachefs_fid(struct vnode *, struct fid *, caller_context_t *); 188 static int cachefs_rwlock(struct vnode *, int, caller_context_t *); 189 static void cachefs_rwunlock(struct vnode *, int, caller_context_t *); 190 static int cachefs_seek(struct vnode *, offset_t, offset_t *, 191 caller_context_t *); 192 static int cachefs_frlock(struct vnode *, int, struct flock64 *, 193 int, offset_t, struct flk_callback *, cred_t *, 194 caller_context_t *); 195 static int cachefs_space(struct vnode *, int, struct flock64 *, int, 196 offset_t, cred_t *, caller_context_t *); 197 static int cachefs_realvp(struct vnode *, struct vnode **, 198 caller_context_t *); 199 static int cachefs_getpage(struct vnode *, offset_t, size_t, uint_t *, 200 struct page *[], size_t, struct seg *, caddr_t, 201 enum seg_rw, cred_t *, caller_context_t *); 202 static int cachefs_getapage(struct vnode *, u_offset_t, size_t, uint_t *, 203 struct page *[], size_t, struct seg *, caddr_t, 204 enum seg_rw, cred_t *); 205 static int cachefs_getapage_back(struct vnode *, u_offset_t, size_t, 206 uint_t *, struct page *[], size_t, struct seg *, caddr_t, 207 enum seg_rw, cred_t *); 208 static int cachefs_putpage(struct vnode *, offset_t, size_t, int, 209 cred_t *, caller_context_t *); 210 static int cachefs_map(struct vnode *, offset_t, struct as *, 211 caddr_t *, size_t, uchar_t, uchar_t, uint_t, cred_t *, 212 caller_context_t *); 213 static int cachefs_addmap(struct vnode *, offset_t, struct as *, 214 caddr_t, size_t, uchar_t, uchar_t, uint_t, cred_t *, 215 caller_context_t *); 216 static int cachefs_delmap(struct vnode *, offset_t, struct as *, 217 caddr_t, size_t, uint_t, uint_t, uint_t, cred_t *, 218 caller_context_t *); 219 static int cachefs_setsecattr(vnode_t *vp, vsecattr_t *vsec, 220 int flag, cred_t *cr, caller_context_t *); 221 static int cachefs_getsecattr(vnode_t *vp, vsecattr_t *vsec, 222 int flag, cred_t *cr, caller_context_t *); 223 static int cachefs_shrlock(vnode_t *, int, struct shrlock *, int, 224 cred_t *, caller_context_t *); 225 static int cachefs_getsecattr_connected(vnode_t *vp, vsecattr_t *vsec, int flag, 226 cred_t *cr); 227 static int cachefs_getsecattr_disconnected(vnode_t *vp, vsecattr_t *vsec, 228 int flag, cred_t *cr); 229 230 static int cachefs_dump(struct vnode *, caddr_t, offset_t, offset_t, 231 caller_context_t *); 232 static int cachefs_pageio(struct vnode *, page_t *, 233 u_offset_t, size_t, int, cred_t *, caller_context_t *); 234 static int cachefs_writepage(struct vnode *vp, caddr_t base, 235 int tcount, struct uio *uiop); 236 static int cachefs_pathconf(vnode_t *, int, ulong_t *, cred_t *, 237 caller_context_t *); 238 239 static int cachefs_read_backfs_nfsv4(vnode_t *vp, uio_t *uiop, int ioflag, 240 cred_t *cr, caller_context_t *ct); 241 static int cachefs_write_backfs_nfsv4(vnode_t *vp, uio_t *uiop, int ioflag, 242 cred_t *cr, caller_context_t *ct); 243 static int cachefs_getattr_backfs_nfsv4(vnode_t *vp, vattr_t *vap, 244 int flags, cred_t *cr, caller_context_t *ct); 245 static int cachefs_remove_backfs_nfsv4(vnode_t *dvp, char *nm, cred_t *cr, 246 vnode_t *vp); 247 static int cachefs_getpage_backfs_nfsv4(struct vnode *vp, offset_t off, 248 size_t len, uint_t *protp, struct page *pl[], 249 size_t plsz, struct seg *seg, caddr_t addr, 250 enum seg_rw rw, cred_t *cr); 251 static int cachefs_putpage_backfs_nfsv4(vnode_t *vp, offset_t off, 252 size_t len, int flags, cred_t *cr); 253 static int cachefs_map_backfs_nfsv4(struct vnode *vp, offset_t off, 254 struct as *as, caddr_t *addrp, size_t len, uchar_t prot, 255 uchar_t maxprot, uint_t flags, cred_t *cr); 256 static int cachefs_space_backfs_nfsv4(struct vnode *vp, int cmd, 257 struct flock64 *bfp, int flag, offset_t offset, 258 cred_t *cr, caller_context_t *ct); 259 260 struct vnodeops *cachefs_vnodeops; 261 262 static const fs_operation_def_t cachefs_vnodeops_template[] = { 263 VOPNAME_OPEN, { .vop_open = cachefs_open }, 264 VOPNAME_CLOSE, { .vop_close = cachefs_close }, 265 VOPNAME_READ, { .vop_read = cachefs_read }, 266 VOPNAME_WRITE, { .vop_write = cachefs_write }, 267 VOPNAME_IOCTL, { .vop_ioctl = cachefs_ioctl }, 268 VOPNAME_GETATTR, { .vop_getattr = cachefs_getattr }, 269 VOPNAME_SETATTR, { .vop_setattr = cachefs_setattr }, 270 VOPNAME_ACCESS, { .vop_access = cachefs_access }, 271 VOPNAME_LOOKUP, { .vop_lookup = cachefs_lookup }, 272 VOPNAME_CREATE, { .vop_create = cachefs_create }, 273 VOPNAME_REMOVE, { .vop_remove = cachefs_remove }, 274 VOPNAME_LINK, { .vop_link = cachefs_link }, 275 VOPNAME_RENAME, { .vop_rename = cachefs_rename }, 276 VOPNAME_MKDIR, { .vop_mkdir = cachefs_mkdir }, 277 VOPNAME_RMDIR, { .vop_rmdir = cachefs_rmdir }, 278 VOPNAME_READDIR, { .vop_readdir = cachefs_readdir }, 279 VOPNAME_SYMLINK, { .vop_symlink = cachefs_symlink }, 280 VOPNAME_READLINK, { .vop_readlink = cachefs_readlink }, 281 VOPNAME_FSYNC, { .vop_fsync = cachefs_fsync }, 282 VOPNAME_INACTIVE, { .vop_inactive = cachefs_inactive }, 283 VOPNAME_FID, { .vop_fid = cachefs_fid }, 284 VOPNAME_RWLOCK, { .vop_rwlock = cachefs_rwlock }, 285 VOPNAME_RWUNLOCK, { .vop_rwunlock = cachefs_rwunlock }, 286 VOPNAME_SEEK, { .vop_seek = cachefs_seek }, 287 VOPNAME_FRLOCK, { .vop_frlock = cachefs_frlock }, 288 VOPNAME_SPACE, { .vop_space = cachefs_space }, 289 VOPNAME_REALVP, { .vop_realvp = cachefs_realvp }, 290 VOPNAME_GETPAGE, { .vop_getpage = cachefs_getpage }, 291 VOPNAME_PUTPAGE, { .vop_putpage = cachefs_putpage }, 292 VOPNAME_MAP, { .vop_map = cachefs_map }, 293 VOPNAME_ADDMAP, { .vop_addmap = cachefs_addmap }, 294 VOPNAME_DELMAP, { .vop_delmap = cachefs_delmap }, 295 VOPNAME_DUMP, { .vop_dump = cachefs_dump }, 296 VOPNAME_PATHCONF, { .vop_pathconf = cachefs_pathconf }, 297 VOPNAME_PAGEIO, { .vop_pageio = cachefs_pageio }, 298 VOPNAME_SETSECATTR, { .vop_setsecattr = cachefs_setsecattr }, 299 VOPNAME_GETSECATTR, { .vop_getsecattr = cachefs_getsecattr }, 300 VOPNAME_SHRLOCK, { .vop_shrlock = cachefs_shrlock }, 301 NULL, NULL 302 }; 303 304 /* forward declarations of statics */ 305 static void cachefs_modified(cnode_t *cp); 306 static int cachefs_modified_alloc(cnode_t *cp); 307 308 int 309 cachefs_init_vnops(char *name) 310 { 311 return (vn_make_ops(name, 312 cachefs_vnodeops_template, &cachefs_vnodeops)); 313 } 314 315 struct vnodeops * 316 cachefs_getvnodeops(void) 317 { 318 return (cachefs_vnodeops); 319 } 320 321 static int 322 cachefs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct) 323 { 324 int error = 0; 325 cnode_t *cp = VTOC(*vpp); 326 fscache_t *fscp = C_TO_FSCACHE(cp); 327 int held = 0; 328 int type; 329 int connected = 0; 330 331 #ifdef CFSDEBUG 332 CFS_DEBUG(CFSDEBUG_VOPS) 333 printf("cachefs_open: ENTER vpp %p flag %x\n", 334 (void *)vpp, flag); 335 #endif 336 if (getzoneid() != GLOBAL_ZONEID) { 337 error = EPERM; 338 goto out; 339 } 340 if ((flag & FWRITE) && 341 ((*vpp)->v_type == VDIR || (*vpp)->v_type == VLNK)) { 342 error = EISDIR; 343 goto out; 344 } 345 346 /* 347 * Cachefs only provides pass-through support for NFSv4, 348 * and all vnode operations are passed through to the 349 * back file system. For NFSv4 pass-through to work, only 350 * connected operation is supported, the cnode backvp must 351 * exist, and cachefs optional (eg., disconnectable) flags 352 * are turned off. Assert these conditions to ensure that 353 * the backfilesystem is called for the open operation. 354 */ 355 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 356 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 357 358 for (;;) { 359 /* get (or renew) access to the file system */ 360 if (held) { 361 /* Won't loop with NFSv4 connected behavior */ 362 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 363 cachefs_cd_release(fscp); 364 held = 0; 365 } 366 error = cachefs_cd_access(fscp, connected, 0); 367 if (error) 368 goto out; 369 held = 1; 370 371 mutex_enter(&cp->c_statelock); 372 373 /* grab creds if we do not have any yet */ 374 if (cp->c_cred == NULL) { 375 crhold(cr); 376 cp->c_cred = cr; 377 } 378 cp->c_flags |= CN_NEEDOPEN; 379 380 /* if we are disconnected */ 381 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 382 /* if we cannot write to the file system */ 383 if ((flag & FWRITE) && CFS_ISFS_WRITE_AROUND(fscp)) { 384 mutex_exit(&cp->c_statelock); 385 connected = 1; 386 continue; 387 } 388 /* 389 * Allow read only requests to continue 390 */ 391 if ((flag & (FWRITE|FREAD)) == FREAD) { 392 /* track the flag for opening the backvp */ 393 cp->c_rdcnt++; 394 mutex_exit(&cp->c_statelock); 395 error = 0; 396 break; 397 } 398 399 /* 400 * check credentials - if this procs 401 * credentials don't match the creds in the 402 * cnode disallow writing while disconnected. 403 */ 404 if (crcmp(cp->c_cred, CRED()) != 0 && 405 secpolicy_vnode_access2(CRED(), *vpp, 406 cp->c_attr.va_uid, 0, VWRITE) != 0) { 407 mutex_exit(&cp->c_statelock); 408 connected = 1; 409 continue; 410 } 411 /* to get here, we know that the WRITE flag is on */ 412 cp->c_wrcnt++; 413 if (flag & FREAD) 414 cp->c_rdcnt++; 415 } 416 417 /* else if we are connected */ 418 else { 419 /* if cannot use the cached copy of the file */ 420 if ((flag & FWRITE) && CFS_ISFS_WRITE_AROUND(fscp) && 421 ((cp->c_flags & CN_NOCACHE) == 0)) 422 cachefs_nocache(cp); 423 424 /* pass open to the back file */ 425 if (cp->c_backvp) { 426 cp->c_flags &= ~CN_NEEDOPEN; 427 CFS_DPRINT_BACKFS_NFSV4(fscp, 428 ("cachefs_open (nfsv4): cnode %p, " 429 "backvp %p\n", cp, cp->c_backvp)); 430 error = VOP_OPEN(&cp->c_backvp, flag, cr, ct); 431 if (CFS_TIMEOUT(fscp, error)) { 432 mutex_exit(&cp->c_statelock); 433 cachefs_cd_release(fscp); 434 held = 0; 435 cachefs_cd_timedout(fscp); 436 continue; 437 } else if (error) { 438 mutex_exit(&cp->c_statelock); 439 break; 440 } 441 } else { 442 /* backvp will be VOP_OPEN'd later */ 443 if (flag & FREAD) 444 cp->c_rdcnt++; 445 if (flag & FWRITE) 446 cp->c_wrcnt++; 447 } 448 449 /* 450 * Now perform a consistency check on the file. 451 * If strict consistency then force a check to 452 * the backfs even if the timeout has not expired 453 * for close-to-open consistency. 454 */ 455 type = 0; 456 if (fscp->fs_consttype == CFS_FS_CONST_STRICT) 457 type = C_BACK_CHECK; 458 error = CFSOP_CHECK_COBJECT(fscp, cp, type, cr); 459 if (CFS_TIMEOUT(fscp, error)) { 460 mutex_exit(&cp->c_statelock); 461 cachefs_cd_release(fscp); 462 held = 0; 463 cachefs_cd_timedout(fscp); 464 continue; 465 } 466 } 467 mutex_exit(&cp->c_statelock); 468 break; 469 } 470 if (held) 471 cachefs_cd_release(fscp); 472 out: 473 #ifdef CFS_CD_DEBUG 474 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 475 #endif 476 #ifdef CFSDEBUG 477 CFS_DEBUG(CFSDEBUG_VOPS) 478 printf("cachefs_open: EXIT vpp %p error %d\n", 479 (void *)vpp, error); 480 #endif 481 return (error); 482 } 483 484 /* ARGSUSED */ 485 static int 486 cachefs_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr, 487 caller_context_t *ct) 488 { 489 int error = 0; 490 cnode_t *cp = VTOC(vp); 491 fscache_t *fscp = C_TO_FSCACHE(cp); 492 int held = 0; 493 int connected = 0; 494 int close_cnt = 1; 495 cachefscache_t *cachep; 496 497 #ifdef CFSDEBUG 498 CFS_DEBUG(CFSDEBUG_VOPS) 499 printf("cachefs_close: ENTER vp %p\n", (void *)vp); 500 #endif 501 /* 502 * Cachefs only provides pass-through support for NFSv4, 503 * and all vnode operations are passed through to the 504 * back file system. For NFSv4 pass-through to work, only 505 * connected operation is supported, the cnode backvp must 506 * exist, and cachefs optional (eg., disconnectable) flags 507 * are turned off. Assert these conditions to ensure that 508 * the backfilesystem is called for the close operation. 509 */ 510 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 511 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 512 513 /* 514 * File could have been passed in or inherited from the global zone, so 515 * we don't want to flat out reject the request; we'll just leave things 516 * the way they are and let the backfs (NFS) deal with it. 517 */ 518 /* get rid of any local locks */ 519 if (CFS_ISFS_LLOCK(fscp)) { 520 (void) cleanlocks(vp, ttoproc(curthread)->p_pid, 0); 521 } 522 523 /* clean up if this is the daemon closing down */ 524 if ((fscp->fs_cddaemonid == ttoproc(curthread)->p_pid) && 525 ((ttoproc(curthread)->p_pid) != 0) && 526 (vp == fscp->fs_rootvp) && 527 (count == 1)) { 528 mutex_enter(&fscp->fs_cdlock); 529 fscp->fs_cddaemonid = 0; 530 if (fscp->fs_dlogfile) 531 fscp->fs_cdconnected = CFS_CD_DISCONNECTED; 532 else 533 fscp->fs_cdconnected = CFS_CD_CONNECTED; 534 cv_broadcast(&fscp->fs_cdwaitcv); 535 mutex_exit(&fscp->fs_cdlock); 536 if (fscp->fs_flags & CFS_FS_ROOTFS) { 537 cachep = fscp->fs_cache; 538 mutex_enter(&cachep->c_contentslock); 539 ASSERT(cachep->c_rootdaemonid != 0); 540 cachep->c_rootdaemonid = 0; 541 mutex_exit(&cachep->c_contentslock); 542 } 543 return (0); 544 } 545 546 for (;;) { 547 /* get (or renew) access to the file system */ 548 if (held) { 549 /* Won't loop with NFSv4 connected behavior */ 550 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 551 cachefs_cd_release(fscp); 552 held = 0; 553 } 554 error = cachefs_cd_access(fscp, connected, 0); 555 if (error) 556 goto out; 557 held = 1; 558 connected = 0; 559 560 /* if not the last close */ 561 if (count > 1) { 562 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) 563 goto out; 564 mutex_enter(&cp->c_statelock); 565 if (cp->c_backvp) { 566 CFS_DPRINT_BACKFS_NFSV4(fscp, 567 ("cachefs_close (nfsv4): cnode %p, " 568 "backvp %p\n", cp, cp->c_backvp)); 569 error = VOP_CLOSE(cp->c_backvp, flag, count, 570 offset, cr, ct); 571 if (CFS_TIMEOUT(fscp, error)) { 572 mutex_exit(&cp->c_statelock); 573 cachefs_cd_release(fscp); 574 held = 0; 575 cachefs_cd_timedout(fscp); 576 continue; 577 } 578 } 579 mutex_exit(&cp->c_statelock); 580 goto out; 581 } 582 583 /* 584 * If the file is an unlinked file, then flush the lookup 585 * cache so that inactive will be called if this is 586 * the last reference. It will invalidate all of the 587 * cached pages, without writing them out. Writing them 588 * out is not required because they will be written to a 589 * file which will be immediately removed. 590 */ 591 if (cp->c_unldvp != NULL) { 592 dnlc_purge_vp(vp); 593 mutex_enter(&cp->c_statelock); 594 error = cp->c_error; 595 cp->c_error = 0; 596 mutex_exit(&cp->c_statelock); 597 /* always call VOP_CLOSE() for back fs vnode */ 598 } 599 600 /* force dirty data to stable storage */ 601 else if ((vp->v_type == VREG) && (flag & FWRITE) && 602 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 603 /* clean the cachefs pages synchronously */ 604 error = cachefs_putpage_common(vp, (offset_t)0, 605 0, 0, cr); 606 if (CFS_TIMEOUT(fscp, error)) { 607 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 608 cachefs_cd_release(fscp); 609 held = 0; 610 cachefs_cd_timedout(fscp); 611 continue; 612 } else { 613 connected = 1; 614 continue; 615 } 616 } 617 618 /* if no space left in cache, wait until connected */ 619 if ((error == ENOSPC) && 620 (fscp->fs_cdconnected != CFS_CD_CONNECTED)) { 621 connected = 1; 622 continue; 623 } 624 625 /* clear the cnode error if putpage worked */ 626 if ((error == 0) && cp->c_error) { 627 mutex_enter(&cp->c_statelock); 628 cp->c_error = 0; 629 mutex_exit(&cp->c_statelock); 630 } 631 632 /* if any other important error */ 633 if (cp->c_error) { 634 /* get rid of the pages */ 635 (void) cachefs_putpage_common(vp, 636 (offset_t)0, 0, B_INVAL | B_FORCE, cr); 637 dnlc_purge_vp(vp); 638 } 639 } 640 641 mutex_enter(&cp->c_statelock); 642 if (cp->c_backvp && 643 (fscp->fs_cdconnected == CFS_CD_CONNECTED)) { 644 error = VOP_CLOSE(cp->c_backvp, flag, close_cnt, 645 offset, cr, ct); 646 if (CFS_TIMEOUT(fscp, error)) { 647 mutex_exit(&cp->c_statelock); 648 cachefs_cd_release(fscp); 649 held = 0; 650 cachefs_cd_timedout(fscp); 651 /* don't decrement the vnode counts again */ 652 close_cnt = 0; 653 continue; 654 } 655 } 656 mutex_exit(&cp->c_statelock); 657 break; 658 } 659 660 mutex_enter(&cp->c_statelock); 661 if (!error) 662 error = cp->c_error; 663 cp->c_error = 0; 664 mutex_exit(&cp->c_statelock); 665 666 out: 667 if (held) 668 cachefs_cd_release(fscp); 669 #ifdef CFS_CD_DEBUG 670 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 671 #endif 672 673 #ifdef CFSDEBUG 674 CFS_DEBUG(CFSDEBUG_VOPS) 675 printf("cachefs_close: EXIT vp %p\n", (void *)vp); 676 #endif 677 return (error); 678 } 679 680 /*ARGSUSED*/ 681 static int 682 cachefs_read(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr, 683 caller_context_t *ct) 684 { 685 struct cnode *cp = VTOC(vp); 686 fscache_t *fscp = C_TO_FSCACHE(cp); 687 register u_offset_t off; 688 register int mapoff; 689 register caddr_t base; 690 int n; 691 offset_t diff; 692 uint_t flags = 0; 693 int error = 0; 694 695 #if 0 696 if (vp->v_flag & VNOCACHE) 697 flags = SM_INVAL; 698 #endif 699 if (getzoneid() != GLOBAL_ZONEID) 700 return (EPERM); 701 if (vp->v_type != VREG) 702 return (EISDIR); 703 704 ASSERT(RW_READ_HELD(&cp->c_rwlock)); 705 706 if (uiop->uio_resid == 0) 707 return (0); 708 709 710 if (uiop->uio_loffset < (offset_t)0) 711 return (EINVAL); 712 713 /* 714 * Call backfilesystem to read if NFSv4, the cachefs code 715 * does the read from the back filesystem asynchronously 716 * which is not supported by pass-through functionality. 717 */ 718 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { 719 error = cachefs_read_backfs_nfsv4(vp, uiop, ioflag, cr, ct); 720 goto out; 721 } 722 723 if (MANDLOCK(vp, cp->c_attr.va_mode)) { 724 error = chklock(vp, FREAD, (offset_t)uiop->uio_loffset, 725 uiop->uio_resid, uiop->uio_fmode, ct); 726 if (error) 727 return (error); 728 } 729 730 /* 731 * Sit in a loop and transfer (uiomove) the data in up to 732 * MAXBSIZE chunks. Each chunk is mapped into the kernel's 733 * address space as needed and then released. 734 */ 735 do { 736 /* 737 * off Offset of current MAXBSIZE chunk 738 * mapoff Offset within the current chunk 739 * n Number of bytes to move from this chunk 740 * base kernel address of mapped in chunk 741 */ 742 off = uiop->uio_loffset & (offset_t)MAXBMASK; 743 mapoff = uiop->uio_loffset & MAXBOFFSET; 744 n = MAXBSIZE - mapoff; 745 if (n > uiop->uio_resid) 746 n = (uint_t)uiop->uio_resid; 747 748 /* perform consistency check */ 749 error = cachefs_cd_access(fscp, 0, 0); 750 if (error) 751 break; 752 mutex_enter(&cp->c_statelock); 753 error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr); 754 diff = cp->c_size - uiop->uio_loffset; 755 mutex_exit(&cp->c_statelock); 756 if (CFS_TIMEOUT(fscp, error)) { 757 cachefs_cd_release(fscp); 758 cachefs_cd_timedout(fscp); 759 error = 0; 760 continue; 761 } 762 cachefs_cd_release(fscp); 763 764 if (error) 765 break; 766 767 if (diff <= (offset_t)0) 768 break; 769 if (diff < (offset_t)n) 770 n = diff; 771 772 base = segmap_getmapflt(segkmap, vp, off, (uint_t)n, 1, S_READ); 773 774 error = segmap_fault(kas.a_hat, segkmap, base, n, 775 F_SOFTLOCK, S_READ); 776 if (error) { 777 (void) segmap_release(segkmap, base, 0); 778 if (FC_CODE(error) == FC_OBJERR) 779 error = FC_ERRNO(error); 780 else 781 error = EIO; 782 break; 783 } 784 error = uiomove(base+mapoff, n, UIO_READ, uiop); 785 (void) segmap_fault(kas.a_hat, segkmap, base, n, 786 F_SOFTUNLOCK, S_READ); 787 if (error == 0) { 788 /* 789 * if we read a whole page(s), or to eof, 790 * we won't need this page(s) again soon. 791 */ 792 if (n + mapoff == MAXBSIZE || 793 uiop->uio_loffset == cp->c_size) 794 flags |= SM_DONTNEED; 795 } 796 (void) segmap_release(segkmap, base, flags); 797 } while (error == 0 && uiop->uio_resid > 0); 798 799 out: 800 #ifdef CFSDEBUG 801 CFS_DEBUG(CFSDEBUG_VOPS) 802 printf("cachefs_read: EXIT error %d resid %ld\n", error, 803 uiop->uio_resid); 804 #endif 805 return (error); 806 } 807 808 /* 809 * cachefs_read_backfs_nfsv4 810 * 811 * Call NFSv4 back filesystem to handle the read (cachefs 812 * pass-through support for NFSv4). 813 */ 814 static int 815 cachefs_read_backfs_nfsv4(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr, 816 caller_context_t *ct) 817 { 818 cnode_t *cp = VTOC(vp); 819 fscache_t *fscp = C_TO_FSCACHE(cp); 820 vnode_t *backvp; 821 int error; 822 823 /* 824 * For NFSv4 pass-through to work, only connected operation 825 * is supported, the cnode backvp must exist, and cachefs 826 * optional (eg., disconnectable) flags are turned off. Assert 827 * these conditions for the read operation. 828 */ 829 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 830 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 831 832 /* Call backfs vnode op after extracting backvp */ 833 mutex_enter(&cp->c_statelock); 834 backvp = cp->c_backvp; 835 mutex_exit(&cp->c_statelock); 836 837 CFS_DPRINT_BACKFS_NFSV4(fscp, ("cachefs_read_backfs_nfsv4: cnode %p, " 838 "backvp %p\n", cp, backvp)); 839 840 (void) VOP_RWLOCK(backvp, V_WRITELOCK_FALSE, ct); 841 error = VOP_READ(backvp, uiop, ioflag, cr, ct); 842 VOP_RWUNLOCK(backvp, V_WRITELOCK_FALSE, ct); 843 844 /* Increment cache miss counter */ 845 fscp->fs_stats.st_misses++; 846 847 return (error); 848 } 849 850 /*ARGSUSED*/ 851 static int 852 cachefs_write(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr, 853 caller_context_t *ct) 854 { 855 struct cnode *cp = VTOC(vp); 856 fscache_t *fscp = C_TO_FSCACHE(cp); 857 int error = 0; 858 u_offset_t off; 859 caddr_t base; 860 uint_t bsize; 861 uint_t flags; 862 int n, on; 863 rlim64_t limit = uiop->uio_llimit; 864 ssize_t resid; 865 offset_t offset; 866 offset_t remainder; 867 868 #ifdef CFSDEBUG 869 CFS_DEBUG(CFSDEBUG_VOPS) 870 printf( 871 "cachefs_write: ENTER vp %p offset %llu count %ld cflags %x\n", 872 (void *)vp, uiop->uio_loffset, uiop->uio_resid, 873 cp->c_flags); 874 #endif 875 if (getzoneid() != GLOBAL_ZONEID) { 876 error = EPERM; 877 goto out; 878 } 879 if (vp->v_type != VREG) { 880 error = EISDIR; 881 goto out; 882 } 883 884 ASSERT(RW_WRITE_HELD(&cp->c_rwlock)); 885 886 if (uiop->uio_resid == 0) { 887 goto out; 888 } 889 890 /* Call backfilesystem to write if NFSv4 */ 891 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { 892 error = cachefs_write_backfs_nfsv4(vp, uiop, ioflag, cr, ct); 893 goto out2; 894 } 895 896 if (MANDLOCK(vp, cp->c_attr.va_mode)) { 897 error = chklock(vp, FWRITE, (offset_t)uiop->uio_loffset, 898 uiop->uio_resid, uiop->uio_fmode, ct); 899 if (error) 900 goto out; 901 } 902 903 if (ioflag & FAPPEND) { 904 for (;;) { 905 /* do consistency check to get correct file size */ 906 error = cachefs_cd_access(fscp, 0, 1); 907 if (error) 908 goto out; 909 mutex_enter(&cp->c_statelock); 910 error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr); 911 uiop->uio_loffset = cp->c_size; 912 mutex_exit(&cp->c_statelock); 913 if (CFS_TIMEOUT(fscp, error)) { 914 cachefs_cd_release(fscp); 915 cachefs_cd_timedout(fscp); 916 continue; 917 } 918 cachefs_cd_release(fscp); 919 if (error) 920 goto out; 921 break; 922 } 923 } 924 925 if (limit == RLIM64_INFINITY || limit > MAXOFFSET_T) 926 limit = MAXOFFSET_T; 927 928 if (uiop->uio_loffset >= limit) { 929 proc_t *p = ttoproc(curthread); 930 931 mutex_enter(&p->p_lock); 932 (void) rctl_action(rctlproc_legacy[RLIMIT_FSIZE], p->p_rctls, 933 p, RCA_UNSAFE_SIGINFO); 934 mutex_exit(&p->p_lock); 935 error = EFBIG; 936 goto out; 937 } 938 if (uiop->uio_loffset > fscp->fs_offmax) { 939 error = EFBIG; 940 goto out; 941 } 942 943 if (limit > fscp->fs_offmax) 944 limit = fscp->fs_offmax; 945 946 if (uiop->uio_loffset < (offset_t)0) { 947 error = EINVAL; 948 goto out; 949 } 950 951 offset = uiop->uio_loffset + uiop->uio_resid; 952 /* 953 * Check to make sure that the process will not exceed 954 * its limit on file size. It is okay to write up to 955 * the limit, but not beyond. Thus, the write which 956 * reaches the limit will be short and the next write 957 * will return an error. 958 */ 959 remainder = 0; 960 if (offset > limit) { 961 remainder = (int)(offset - (u_offset_t)limit); 962 uiop->uio_resid = limit - uiop->uio_loffset; 963 if (uiop->uio_resid <= 0) { 964 proc_t *p = ttoproc(curthread); 965 966 uiop->uio_resid += remainder; 967 mutex_enter(&p->p_lock); 968 (void) rctl_action(rctlproc_legacy[RLIMIT_FSIZE], 969 p->p_rctls, p, RCA_UNSAFE_SIGINFO); 970 mutex_exit(&p->p_lock); 971 error = EFBIG; 972 goto out; 973 } 974 } 975 976 resid = uiop->uio_resid; 977 offset = uiop->uio_loffset; 978 bsize = vp->v_vfsp->vfs_bsize; 979 980 /* loop around and do the write in MAXBSIZE chunks */ 981 do { 982 /* mapping offset */ 983 off = uiop->uio_loffset & (offset_t)MAXBMASK; 984 on = uiop->uio_loffset & MAXBOFFSET; /* Rel. offset */ 985 n = MAXBSIZE - on; 986 if (n > uiop->uio_resid) 987 n = (int)uiop->uio_resid; 988 989 /* 990 * Touch the page and fault it in if it is not in 991 * core before segmap_getmapflt can lock it. This 992 * is to avoid the deadlock if the buffer is mapped 993 * to the same file through mmap which we want to 994 * write to. 995 */ 996 uio_prefaultpages((long)n, uiop); 997 998 base = segmap_getmap(segkmap, vp, off); 999 error = cachefs_writepage(vp, (base + on), n, uiop); 1000 if (error == 0) { 1001 flags = 0; 1002 /* 1003 * Have written a whole block.Start an 1004 * asynchronous write and mark the buffer to 1005 * indicate that it won't be needed again 1006 * soon. 1007 */ 1008 if (n + on == bsize) { 1009 flags = SM_WRITE |SM_ASYNC |SM_DONTNEED; 1010 } 1011 #if 0 1012 /* XXX need to understand this */ 1013 if ((ioflag & (FSYNC|FDSYNC)) || 1014 (cp->c_backvp && vn_has_flocks(cp->c_backvp))) { 1015 flags &= ~SM_ASYNC; 1016 flags |= SM_WRITE; 1017 } 1018 #else 1019 if (ioflag & (FSYNC|FDSYNC)) { 1020 flags &= ~SM_ASYNC; 1021 flags |= SM_WRITE; 1022 } 1023 #endif 1024 error = segmap_release(segkmap, base, flags); 1025 } else { 1026 (void) segmap_release(segkmap, base, 0); 1027 } 1028 } while (error == 0 && uiop->uio_resid > 0); 1029 1030 out: 1031 if (error == EINTR && (ioflag & (FSYNC|FDSYNC))) { 1032 uiop->uio_resid = resid; 1033 uiop->uio_loffset = offset; 1034 } else 1035 uiop->uio_resid += remainder; 1036 1037 out2: 1038 #ifdef CFSDEBUG 1039 CFS_DEBUG(CFSDEBUG_VOPS) 1040 printf("cachefs_write: EXIT error %d\n", error); 1041 #endif 1042 return (error); 1043 } 1044 1045 /* 1046 * cachefs_write_backfs_nfsv4 1047 * 1048 * Call NFSv4 back filesystem to handle the write (cachefs 1049 * pass-through support for NFSv4). 1050 */ 1051 static int 1052 cachefs_write_backfs_nfsv4(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr, 1053 caller_context_t *ct) 1054 { 1055 cnode_t *cp = VTOC(vp); 1056 fscache_t *fscp = C_TO_FSCACHE(cp); 1057 vnode_t *backvp; 1058 int error; 1059 1060 /* 1061 * For NFSv4 pass-through to work, only connected operation 1062 * is supported, the cnode backvp must exist, and cachefs 1063 * optional (eg., disconnectable) flags are turned off. Assert 1064 * these conditions for the read operation. 1065 */ 1066 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 1067 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 1068 1069 /* Call backfs vnode op after extracting the backvp */ 1070 mutex_enter(&cp->c_statelock); 1071 backvp = cp->c_backvp; 1072 mutex_exit(&cp->c_statelock); 1073 1074 CFS_DPRINT_BACKFS_NFSV4(fscp, ("cachefs_write_backfs_nfsv4: cnode %p, " 1075 "backvp %p\n", cp, backvp)); 1076 (void) VOP_RWLOCK(backvp, V_WRITELOCK_TRUE, ct); 1077 error = VOP_WRITE(backvp, uiop, ioflag, cr, ct); 1078 VOP_RWUNLOCK(backvp, V_WRITELOCK_TRUE, ct); 1079 1080 return (error); 1081 } 1082 1083 /* 1084 * see if we've charged ourselves for frontfile data at 1085 * the given offset. If not, allocate a block for it now. 1086 */ 1087 static int 1088 cachefs_charge_page(struct cnode *cp, u_offset_t offset) 1089 { 1090 u_offset_t blockoff; 1091 int error; 1092 int inc; 1093 1094 ASSERT(MUTEX_HELD(&cp->c_statelock)); 1095 /*LINTED*/ 1096 ASSERT(PAGESIZE <= MAXBSIZE); 1097 1098 error = 0; 1099 blockoff = offset & (offset_t)MAXBMASK; 1100 1101 /* get the front file if necessary so allocblocks works */ 1102 if ((cp->c_frontvp == NULL) && 1103 ((cp->c_flags & CN_NOCACHE) == 0)) { 1104 (void) cachefs_getfrontfile(cp); 1105 } 1106 if (cp->c_flags & CN_NOCACHE) 1107 return (1); 1108 1109 if (cachefs_check_allocmap(cp, blockoff)) 1110 return (0); 1111 1112 for (inc = PAGESIZE; inc < MAXBSIZE; inc += PAGESIZE) 1113 if (cachefs_check_allocmap(cp, blockoff+inc)) 1114 return (0); 1115 1116 error = cachefs_allocblocks(C_TO_FSCACHE(cp)->fs_cache, 1, 1117 cp->c_metadata.md_rltype); 1118 if (error == 0) { 1119 cp->c_metadata.md_frontblks++; 1120 cp->c_flags |= CN_UPDATED; 1121 } 1122 return (error); 1123 } 1124 1125 /* 1126 * Called only by cachefs_write to write 1 page or less of data. 1127 * base - base address kernel addr space 1128 * tcount - Total bytes to move - < MAXBSIZE 1129 */ 1130 static int 1131 cachefs_writepage(vnode_t *vp, caddr_t base, int tcount, uio_t *uiop) 1132 { 1133 struct cnode *cp = VTOC(vp); 1134 fscache_t *fscp = C_TO_FSCACHE(cp); 1135 register int n; 1136 register u_offset_t offset; 1137 int error = 0, terror; 1138 extern struct as kas; 1139 u_offset_t lastpage_off; 1140 int pagecreate = 0; 1141 int newpage; 1142 1143 #ifdef CFSDEBUG 1144 CFS_DEBUG(CFSDEBUG_VOPS) 1145 printf( 1146 "cachefs_writepage: ENTER vp %p offset %llu len %ld\\\n", 1147 (void *)vp, uiop->uio_loffset, uiop->uio_resid); 1148 #endif 1149 1150 /* 1151 * Move bytes in PAGESIZE chunks. We must avoid spanning pages in 1152 * uiomove() because page faults may cause the cache to be invalidated 1153 * out from under us. 1154 */ 1155 do { 1156 offset = uiop->uio_loffset; 1157 lastpage_off = (cp->c_size - 1) & (offset_t)PAGEMASK; 1158 1159 /* 1160 * If not connected then need to make sure we have space 1161 * to perform the write. We could make this check 1162 * a little tighter by only doing it if we are growing the file. 1163 */ 1164 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 1165 error = cachefs_allocblocks(fscp->fs_cache, 1, 1166 cp->c_metadata.md_rltype); 1167 if (error) 1168 break; 1169 cachefs_freeblocks(fscp->fs_cache, 1, 1170 cp->c_metadata.md_rltype); 1171 } 1172 1173 /* 1174 * n is the number of bytes required to satisfy the request 1175 * or the number of bytes to fill out the page. 1176 */ 1177 n = (int)(PAGESIZE - ((uintptr_t)base & PAGEOFFSET)); 1178 if (n > tcount) 1179 n = tcount; 1180 1181 /* 1182 * The number of bytes of data in the last page can not 1183 * be accurately be determined while page is being 1184 * uiomove'd to and the size of the file being updated. 1185 * Thus, inform threads which need to know accurately 1186 * how much data is in the last page of the file. They 1187 * will not do the i/o immediately, but will arrange for 1188 * the i/o to happen later when this modify operation 1189 * will have finished. 1190 * 1191 * in similar NFS code, this is done right before the 1192 * uiomove(), which is best. but here in cachefs, we 1193 * have two uiomove()s, so we must do it here. 1194 */ 1195 ASSERT(!(cp->c_flags & CN_CMODINPROG)); 1196 mutex_enter(&cp->c_statelock); 1197 cp->c_flags |= CN_CMODINPROG; 1198 cp->c_modaddr = (offset & (offset_t)MAXBMASK); 1199 mutex_exit(&cp->c_statelock); 1200 1201 /* 1202 * Check to see if we can skip reading in the page 1203 * and just allocate the memory. We can do this 1204 * if we are going to rewrite the entire mapping 1205 * or if we are going to write to or beyond the current 1206 * end of file from the beginning of the mapping. 1207 */ 1208 if ((offset > (lastpage_off + PAGEOFFSET)) || 1209 ((cp->c_size == 0) && (offset < PAGESIZE)) || 1210 ((uintptr_t)base & PAGEOFFSET) == 0 && (n == PAGESIZE || 1211 ((offset + n) >= cp->c_size))) { 1212 pagecreate = 1; 1213 1214 /* 1215 * segmap_pagecreate() returns 1 if it calls 1216 * page_create_va() to allocate any pages. 1217 */ 1218 newpage = segmap_pagecreate(segkmap, 1219 (caddr_t)((uintptr_t)base & (uintptr_t)PAGEMASK), 1220 PAGESIZE, 0); 1221 /* do not zero page if we are overwriting all of it */ 1222 if (!((((uintptr_t)base & PAGEOFFSET) == 0) && 1223 (n == PAGESIZE))) { 1224 (void) kzero((void *) 1225 ((uintptr_t)base & (uintptr_t)PAGEMASK), 1226 PAGESIZE); 1227 } 1228 error = uiomove(base, n, UIO_WRITE, uiop); 1229 1230 /* 1231 * Unlock the page allocated by page_create_va() 1232 * in segmap_pagecreate() 1233 */ 1234 if (newpage) 1235 segmap_pageunlock(segkmap, 1236 (caddr_t)((uintptr_t)base & 1237 (uintptr_t)PAGEMASK), 1238 PAGESIZE, S_WRITE); 1239 } else { 1240 /* 1241 * KLUDGE ! Use segmap_fault instead of faulting and 1242 * using as_fault() to avoid a recursive readers lock 1243 * on kas. 1244 */ 1245 error = segmap_fault(kas.a_hat, segkmap, (caddr_t) 1246 ((uintptr_t)base & (uintptr_t)PAGEMASK), 1247 PAGESIZE, F_SOFTLOCK, S_WRITE); 1248 if (error) { 1249 if (FC_CODE(error) == FC_OBJERR) 1250 error = FC_ERRNO(error); 1251 else 1252 error = EIO; 1253 break; 1254 } 1255 error = uiomove(base, n, UIO_WRITE, uiop); 1256 (void) segmap_fault(kas.a_hat, segkmap, (caddr_t) 1257 ((uintptr_t)base & (uintptr_t)PAGEMASK), 1258 PAGESIZE, F_SOFTUNLOCK, S_WRITE); 1259 } 1260 n = (int)(uiop->uio_loffset - offset); /* n = # bytes written */ 1261 base += n; 1262 tcount -= n; 1263 1264 /* get access to the file system */ 1265 if ((terror = cachefs_cd_access(fscp, 0, 1)) != 0) { 1266 error = terror; 1267 break; 1268 } 1269 1270 /* 1271 * cp->c_attr.va_size is the maximum number of 1272 * bytes known to be in the file. 1273 * Make sure it is at least as high as the 1274 * last byte we just wrote into the buffer. 1275 */ 1276 mutex_enter(&cp->c_statelock); 1277 if (cp->c_size < uiop->uio_loffset) { 1278 cp->c_size = uiop->uio_loffset; 1279 } 1280 if (cp->c_size != cp->c_attr.va_size) { 1281 cp->c_attr.va_size = cp->c_size; 1282 cp->c_flags |= CN_UPDATED; 1283 } 1284 /* c_size is now correct, so we can clear modinprog */ 1285 cp->c_flags &= ~CN_CMODINPROG; 1286 if (error == 0) { 1287 cp->c_flags |= CDIRTY; 1288 if (pagecreate && (cp->c_flags & CN_NOCACHE) == 0) { 1289 /* 1290 * if we're not in NOCACHE mode 1291 * (i.e., single-writer), we update the 1292 * allocmap here rather than waiting until 1293 * cachefspush is called. This prevents 1294 * getpage from clustering up pages from 1295 * the backfile and stomping over the changes 1296 * we make here. 1297 */ 1298 if (cachefs_charge_page(cp, offset) == 0) { 1299 cachefs_update_allocmap(cp, 1300 offset & (offset_t)PAGEMASK, 1301 (size_t)PAGESIZE); 1302 } 1303 1304 /* else we ran out of space */ 1305 else { 1306 /* nocache file if connected */ 1307 if (fscp->fs_cdconnected == 1308 CFS_CD_CONNECTED) 1309 cachefs_nocache(cp); 1310 /* 1311 * If disconnected then cannot 1312 * nocache the file. Let it have 1313 * the space. 1314 */ 1315 else { 1316 cp->c_metadata.md_frontblks++; 1317 cp->c_flags |= CN_UPDATED; 1318 cachefs_update_allocmap(cp, 1319 offset & (offset_t)PAGEMASK, 1320 (size_t)PAGESIZE); 1321 } 1322 } 1323 } 1324 } 1325 mutex_exit(&cp->c_statelock); 1326 cachefs_cd_release(fscp); 1327 } while (tcount > 0 && error == 0); 1328 1329 if (cp->c_flags & CN_CMODINPROG) { 1330 /* XXX assert error != 0? FC_ERRNO() makes this more risky. */ 1331 mutex_enter(&cp->c_statelock); 1332 cp->c_flags &= ~CN_CMODINPROG; 1333 mutex_exit(&cp->c_statelock); 1334 } 1335 1336 #ifdef CFS_CD_DEBUG 1337 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 1338 #endif 1339 1340 #ifdef CFSDEBUG 1341 CFS_DEBUG(CFSDEBUG_VOPS) 1342 printf("cachefs_writepage: EXIT error %d\n", error); 1343 #endif 1344 1345 return (error); 1346 } 1347 1348 /* 1349 * Pushes out pages to the back and/or front file system. 1350 */ 1351 static int 1352 cachefs_push(vnode_t *vp, page_t *pp, u_offset_t *offp, size_t *lenp, 1353 int flags, cred_t *cr) 1354 { 1355 struct cnode *cp = VTOC(vp); 1356 struct buf *bp; 1357 int error; 1358 fscache_t *fscp = C_TO_FSCACHE(cp); 1359 u_offset_t iooff; 1360 size_t iolen; 1361 u_offset_t lbn; 1362 u_offset_t lbn_off; 1363 uint_t bsize; 1364 1365 ASSERT((flags & B_ASYNC) == 0); 1366 ASSERT(!vn_is_readonly(vp)); 1367 ASSERT(pp != NULL); 1368 ASSERT(cr != NULL); 1369 1370 bsize = MAX(vp->v_vfsp->vfs_bsize, PAGESIZE); 1371 lbn = pp->p_offset / bsize; 1372 lbn_off = lbn * bsize; 1373 1374 /* 1375 * Find a kluster that fits in one block, or in 1376 * one page if pages are bigger than blocks. If 1377 * there is less file space allocated than a whole 1378 * page, we'll shorten the i/o request below. 1379 */ 1380 1381 pp = pvn_write_kluster(vp, pp, &iooff, &iolen, lbn_off, 1382 roundup(bsize, PAGESIZE), flags); 1383 1384 /* 1385 * The CN_CMODINPROG flag makes sure that we use a correct 1386 * value of c_size, below. CN_CMODINPROG is set in 1387 * cachefs_writepage(). When CN_CMODINPROG is set it 1388 * indicates that a uiomove() is in progress and the c_size 1389 * has not been made consistent with the new size of the 1390 * file. When the uiomove() completes the c_size is updated 1391 * and the CN_CMODINPROG flag is cleared. 1392 * 1393 * The CN_CMODINPROG flag makes sure that cachefs_push_front 1394 * and cachefs_push_connected see a consistent value of 1395 * c_size. Without this handshaking, it is possible that 1396 * these routines will pick up the old value of c_size before 1397 * the uiomove() in cachefs_writepage() completes. This will 1398 * result in the vn_rdwr() being too small, and data loss. 1399 * 1400 * More precisely, there is a window between the time the 1401 * uiomove() completes and the time the c_size is updated. If 1402 * a VOP_PUTPAGE() operation intervenes in this window, the 1403 * page will be picked up, because it is dirty; it will be 1404 * unlocked, unless it was pagecreate'd. When the page is 1405 * picked up as dirty, the dirty bit is reset 1406 * (pvn_getdirty()). In cachefs_push_connected(), c_size is 1407 * checked. This will still be the old size. Therefore, the 1408 * page will not be written out to the correct length, and the 1409 * page will be clean, so the data may disappear. 1410 */ 1411 if (cp->c_flags & CN_CMODINPROG) { 1412 mutex_enter(&cp->c_statelock); 1413 if ((cp->c_flags & CN_CMODINPROG) && 1414 cp->c_modaddr + MAXBSIZE > iooff && 1415 cp->c_modaddr < iooff + iolen) { 1416 page_t *plist; 1417 1418 /* 1419 * A write is in progress for this region of 1420 * the file. If we did not detect 1421 * CN_CMODINPROG here then this path through 1422 * cachefs_push_connected() would eventually 1423 * do the vn_rdwr() and may not write out all 1424 * of the data in the pages. We end up losing 1425 * data. So we decide to set the modified bit 1426 * on each page in the page list and mark the 1427 * cnode with CDIRTY. This push will be 1428 * restarted at some later time. 1429 */ 1430 1431 plist = pp; 1432 while (plist != NULL) { 1433 pp = plist; 1434 page_sub(&plist, pp); 1435 hat_setmod(pp); 1436 page_io_unlock(pp); 1437 page_unlock(pp); 1438 } 1439 cp->c_flags |= CDIRTY; 1440 mutex_exit(&cp->c_statelock); 1441 if (offp) 1442 *offp = iooff; 1443 if (lenp) 1444 *lenp = iolen; 1445 return (0); 1446 } 1447 mutex_exit(&cp->c_statelock); 1448 } 1449 1450 /* 1451 * Set the pages up for pageout. 1452 */ 1453 bp = pageio_setup(pp, iolen, CTOV(cp), B_WRITE | flags); 1454 if (bp == NULL) { 1455 1456 /* 1457 * currently, there is no way for pageio_setup() to 1458 * return NULL, since it uses its own scheme for 1459 * kmem_alloc()ing that shouldn't return NULL, and 1460 * since pageio_setup() itself dereferences the thing 1461 * it's about to return. still, we need to be ready 1462 * in case this ever does start happening. 1463 */ 1464 1465 error = ENOMEM; 1466 goto writedone; 1467 } 1468 /* 1469 * pageio_setup should have set b_addr to 0. This 1470 * is correct since we want to do I/O on a page 1471 * boundary. bp_mapin will use this addr to calculate 1472 * an offset, and then set b_addr to the kernel virtual 1473 * address it allocated for us. 1474 */ 1475 bp->b_edev = 0; 1476 bp->b_dev = 0; 1477 bp->b_lblkno = (diskaddr_t)lbtodb(iooff); 1478 bp_mapin(bp); 1479 1480 iolen = cp->c_size - ldbtob(bp->b_blkno); 1481 if (iolen > bp->b_bcount) 1482 iolen = bp->b_bcount; 1483 1484 /* if connected */ 1485 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 1486 /* write to the back file first */ 1487 error = cachefs_push_connected(vp, bp, iolen, iooff, cr); 1488 1489 /* write to the front file if allowed */ 1490 if ((error == 0) && CFS_ISFS_NONSHARED(fscp) && 1491 ((cp->c_flags & CN_NOCACHE) == 0)) { 1492 /* try to write to the front file */ 1493 (void) cachefs_push_front(vp, bp, iolen, iooff, cr); 1494 } 1495 } 1496 1497 /* else if disconnected */ 1498 else { 1499 /* try to write to the front file */ 1500 error = cachefs_push_front(vp, bp, iolen, iooff, cr); 1501 } 1502 1503 bp_mapout(bp); 1504 pageio_done(bp); 1505 1506 writedone: 1507 1508 pvn_write_done(pp, ((error) ? B_ERROR : 0) | B_WRITE | flags); 1509 if (offp) 1510 *offp = iooff; 1511 if (lenp) 1512 *lenp = iolen; 1513 1514 /* XXX ask bob mastors how to fix this someday */ 1515 mutex_enter(&cp->c_statelock); 1516 if (error) { 1517 if (error == ENOSPC) { 1518 if ((fscp->fs_cdconnected == CFS_CD_CONNECTED) || 1519 CFS_ISFS_SOFT(fscp)) { 1520 CFSOP_INVALIDATE_COBJECT(fscp, cp, cr); 1521 cp->c_error = error; 1522 } 1523 } else if ((CFS_TIMEOUT(fscp, error) == 0) && 1524 (error != EINTR)) { 1525 CFSOP_INVALIDATE_COBJECT(fscp, cp, cr); 1526 cp->c_error = error; 1527 } 1528 } else if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 1529 CFSOP_MODIFY_COBJECT(fscp, cp, cr); 1530 } 1531 mutex_exit(&cp->c_statelock); 1532 1533 return (error); 1534 } 1535 1536 /* 1537 * Pushes out pages to the back file system. 1538 */ 1539 static int 1540 cachefs_push_connected(vnode_t *vp, struct buf *bp, size_t iolen, 1541 u_offset_t iooff, cred_t *cr) 1542 { 1543 struct cnode *cp = VTOC(vp); 1544 int error = 0; 1545 int mode = 0; 1546 fscache_t *fscp = C_TO_FSCACHE(cp); 1547 ssize_t resid; 1548 vnode_t *backvp; 1549 1550 /* get the back file if necessary */ 1551 mutex_enter(&cp->c_statelock); 1552 if (cp->c_backvp == NULL) { 1553 error = cachefs_getbackvp(fscp, cp); 1554 if (error) { 1555 mutex_exit(&cp->c_statelock); 1556 goto out; 1557 } 1558 } 1559 backvp = cp->c_backvp; 1560 VN_HOLD(backvp); 1561 mutex_exit(&cp->c_statelock); 1562 1563 if (CFS_ISFS_NONSHARED(fscp) && CFS_ISFS_SNR(fscp)) 1564 mode = FSYNC; 1565 1566 /* write to the back file */ 1567 error = bp->b_error = vn_rdwr(UIO_WRITE, backvp, bp->b_un.b_addr, 1568 iolen, iooff, UIO_SYSSPACE, mode, 1569 RLIM64_INFINITY, cr, &resid); 1570 if (error) { 1571 #ifdef CFSDEBUG 1572 CFS_DEBUG(CFSDEBUG_VOPS | CFSDEBUG_BACK) 1573 printf("cachefspush: error %d cr %p\n", 1574 error, (void *)cr); 1575 #endif 1576 bp->b_flags |= B_ERROR; 1577 } 1578 VN_RELE(backvp); 1579 out: 1580 return (error); 1581 } 1582 1583 /* 1584 * Pushes out pages to the front file system. 1585 * Called for both connected and disconnected states. 1586 */ 1587 static int 1588 cachefs_push_front(vnode_t *vp, struct buf *bp, size_t iolen, 1589 u_offset_t iooff, cred_t *cr) 1590 { 1591 struct cnode *cp = VTOC(vp); 1592 fscache_t *fscp = C_TO_FSCACHE(cp); 1593 int error = 0; 1594 ssize_t resid; 1595 u_offset_t popoff; 1596 off_t commit = 0; 1597 uint_t seq; 1598 enum cachefs_rl_type type; 1599 vnode_t *frontvp = NULL; 1600 1601 mutex_enter(&cp->c_statelock); 1602 1603 if (!CFS_ISFS_NONSHARED(fscp)) { 1604 error = ETIMEDOUT; 1605 goto out; 1606 } 1607 1608 /* get the front file if necessary */ 1609 if ((cp->c_frontvp == NULL) && 1610 ((cp->c_flags & CN_NOCACHE) == 0)) { 1611 (void) cachefs_getfrontfile(cp); 1612 } 1613 if (cp->c_flags & CN_NOCACHE) { 1614 error = ETIMEDOUT; 1615 goto out; 1616 } 1617 1618 /* if disconnected, needs to be populated and have good attributes */ 1619 if ((fscp->fs_cdconnected != CFS_CD_CONNECTED) && 1620 (((cp->c_metadata.md_flags & MD_POPULATED) == 0) || 1621 (cp->c_metadata.md_flags & MD_NEEDATTRS))) { 1622 error = ETIMEDOUT; 1623 goto out; 1624 } 1625 1626 for (popoff = iooff; popoff < (iooff + iolen); popoff += MAXBSIZE) { 1627 if (cachefs_charge_page(cp, popoff)) { 1628 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 1629 cachefs_nocache(cp); 1630 goto out; 1631 } else { 1632 error = ENOSPC; 1633 goto out; 1634 } 1635 } 1636 } 1637 1638 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 1639 /* log the first putpage to a file */ 1640 if ((cp->c_metadata.md_flags & MD_PUTPAGE) == 0) { 1641 /* uses open's creds if we have them */ 1642 if (cp->c_cred) 1643 cr = cp->c_cred; 1644 1645 if ((cp->c_metadata.md_flags & MD_MAPPING) == 0) { 1646 error = cachefs_dlog_cidmap(fscp); 1647 if (error) { 1648 error = ENOSPC; 1649 goto out; 1650 } 1651 cp->c_metadata.md_flags |= MD_MAPPING; 1652 } 1653 1654 commit = cachefs_dlog_modify(fscp, cp, cr, &seq); 1655 if (commit == 0) { 1656 /* out of space */ 1657 error = ENOSPC; 1658 goto out; 1659 } 1660 1661 cp->c_metadata.md_seq = seq; 1662 type = cp->c_metadata.md_rltype; 1663 cachefs_modified(cp); 1664 cp->c_metadata.md_flags |= MD_PUTPAGE; 1665 cp->c_metadata.md_flags &= ~MD_PUSHDONE; 1666 cp->c_flags |= CN_UPDATED; 1667 } 1668 1669 /* subsequent putpages just get a new sequence number */ 1670 else { 1671 /* but only if it matters */ 1672 if (cp->c_metadata.md_seq != fscp->fs_dlogseq) { 1673 seq = cachefs_dlog_seqnext(fscp); 1674 if (seq == 0) { 1675 error = ENOSPC; 1676 goto out; 1677 } 1678 cp->c_metadata.md_seq = seq; 1679 cp->c_flags |= CN_UPDATED; 1680 /* XXX maybe should do write_metadata here */ 1681 } 1682 } 1683 } 1684 1685 frontvp = cp->c_frontvp; 1686 VN_HOLD(frontvp); 1687 mutex_exit(&cp->c_statelock); 1688 error = bp->b_error = vn_rdwr(UIO_WRITE, frontvp, 1689 bp->b_un.b_addr, iolen, iooff, UIO_SYSSPACE, 0, 1690 RLIM64_INFINITY, kcred, &resid); 1691 mutex_enter(&cp->c_statelock); 1692 VN_RELE(frontvp); 1693 frontvp = NULL; 1694 if (error) { 1695 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 1696 cachefs_nocache(cp); 1697 error = 0; 1698 goto out; 1699 } else { 1700 goto out; 1701 } 1702 } 1703 1704 (void) cachefs_update_allocmap(cp, iooff, iolen); 1705 cp->c_flags |= (CN_UPDATED | CN_NEED_FRONT_SYNC | 1706 CN_POPULATION_PENDING); 1707 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 1708 gethrestime(&cp->c_metadata.md_localmtime); 1709 cp->c_metadata.md_flags |= MD_LOCALMTIME; 1710 } 1711 1712 out: 1713 if (commit) { 1714 /* commit the log record */ 1715 ASSERT(fscp->fs_cdconnected == CFS_CD_DISCONNECTED); 1716 if (cachefs_dlog_commit(fscp, commit, error)) { 1717 /*EMPTY*/ 1718 /* XXX fix on panic */ 1719 } 1720 } 1721 1722 if (error && commit) { 1723 cp->c_metadata.md_flags &= ~MD_PUTPAGE; 1724 cachefs_rlent_moveto(fscp->fs_cache, type, 1725 cp->c_metadata.md_rlno, cp->c_metadata.md_frontblks); 1726 cp->c_metadata.md_rltype = type; 1727 cp->c_flags |= CN_UPDATED; 1728 } 1729 mutex_exit(&cp->c_statelock); 1730 return (error); 1731 } 1732 1733 /*ARGSUSED*/ 1734 static int 1735 cachefs_dump(struct vnode *vp, caddr_t foo1, offset_t foo2, offset_t foo3, 1736 caller_context_t *ct) 1737 { 1738 return (ENOSYS); /* should we panic if we get here? */ 1739 } 1740 1741 /*ARGSUSED*/ 1742 static int 1743 cachefs_ioctl(struct vnode *vp, int cmd, intptr_t arg, int flag, cred_t *cred, 1744 int *rvalp, caller_context_t *ct) 1745 { 1746 int error; 1747 struct cnode *cp = VTOC(vp); 1748 struct fscache *fscp = C_TO_FSCACHE(cp); 1749 struct cachefscache *cachep; 1750 extern kmutex_t cachefs_cachelock; 1751 extern cachefscache_t *cachefs_cachelist; 1752 cachefsio_pack_t *packp; 1753 STRUCT_DECL(cachefsio_dcmd, dcmd); 1754 int inlen, outlen; /* LP64: generic int for struct in/out len */ 1755 void *dinp, *doutp; 1756 int (*dcmd_routine)(vnode_t *, void *, void *); 1757 1758 if (getzoneid() != GLOBAL_ZONEID) 1759 return (EPERM); 1760 1761 /* 1762 * Cachefs only provides pass-through support for NFSv4, 1763 * and all vnode operations are passed through to the 1764 * back file system. For NFSv4 pass-through to work, only 1765 * connected operation is supported, the cnode backvp must 1766 * exist, and cachefs optional (eg., disconnectable) flags 1767 * are turned off. Assert these conditions which ensure 1768 * that only a subset of the ioctls are "truly supported" 1769 * for NFSv4 (these are CFSDCMD_DAEMONID and CFSDCMD_GETSTATS. 1770 * The packing operations are meaningless since there is 1771 * no caching for NFSv4, and the called functions silently 1772 * return if the backfilesystem is NFSv4. The daemon 1773 * commands except for those above are essentially used 1774 * for disconnectable operation support (including log 1775 * rolling), so in each called function, we assert that 1776 * NFSv4 is not in use. The _FIO* calls (except _FIOCOD) 1777 * are from "cfsfstype" which is not a documented 1778 * command. However, the command is visible in 1779 * /usr/lib/fs/cachefs so the commands are simply let 1780 * through (don't seem to impact pass-through functionality). 1781 */ 1782 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 1783 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 1784 1785 switch (cmd) { 1786 case CACHEFSIO_PACK: 1787 packp = cachefs_kmem_alloc(sizeof (cachefsio_pack_t), KM_SLEEP); 1788 error = xcopyin((void *)arg, packp, sizeof (cachefsio_pack_t)); 1789 if (!error) 1790 error = cachefs_pack(vp, packp->p_name, cred); 1791 cachefs_kmem_free(packp, sizeof (cachefsio_pack_t)); 1792 break; 1793 1794 case CACHEFSIO_UNPACK: 1795 packp = cachefs_kmem_alloc(sizeof (cachefsio_pack_t), KM_SLEEP); 1796 error = xcopyin((void *)arg, packp, sizeof (cachefsio_pack_t)); 1797 if (!error) 1798 error = cachefs_unpack(vp, packp->p_name, cred); 1799 cachefs_kmem_free(packp, sizeof (cachefsio_pack_t)); 1800 break; 1801 1802 case CACHEFSIO_PACKINFO: 1803 packp = cachefs_kmem_alloc(sizeof (cachefsio_pack_t), KM_SLEEP); 1804 error = xcopyin((void *)arg, packp, sizeof (cachefsio_pack_t)); 1805 if (!error) 1806 error = cachefs_packinfo(vp, packp->p_name, 1807 &packp->p_status, cred); 1808 if (!error) 1809 error = xcopyout(packp, (void *)arg, 1810 sizeof (cachefsio_pack_t)); 1811 cachefs_kmem_free(packp, sizeof (cachefsio_pack_t)); 1812 break; 1813 1814 case CACHEFSIO_UNPACKALL: 1815 error = cachefs_unpackall(vp); 1816 break; 1817 1818 case CACHEFSIO_DCMD: 1819 /* 1820 * This is a private interface between the cachefsd and 1821 * this file system. 1822 */ 1823 1824 /* must be root to use these commands */ 1825 if (secpolicy_fs_config(cred, vp->v_vfsp) != 0) 1826 return (EPERM); 1827 1828 /* get the command packet */ 1829 STRUCT_INIT(dcmd, flag & DATAMODEL_MASK); 1830 error = xcopyin((void *)arg, STRUCT_BUF(dcmd), 1831 SIZEOF_STRUCT(cachefsio_dcmd, DATAMODEL_NATIVE)); 1832 if (error) 1833 return (error); 1834 1835 /* copy in the data for the operation */ 1836 dinp = NULL; 1837 if ((inlen = STRUCT_FGET(dcmd, d_slen)) > 0) { 1838 dinp = cachefs_kmem_alloc(inlen, KM_SLEEP); 1839 error = xcopyin(STRUCT_FGETP(dcmd, d_sdata), dinp, 1840 inlen); 1841 if (error) 1842 return (error); 1843 } 1844 1845 /* allocate space for the result */ 1846 doutp = NULL; 1847 if ((outlen = STRUCT_FGET(dcmd, d_rlen)) > 0) 1848 doutp = cachefs_kmem_alloc(outlen, KM_SLEEP); 1849 1850 /* 1851 * Assert NFSv4 only allows the daemonid and getstats 1852 * daemon requests 1853 */ 1854 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0 || 1855 STRUCT_FGET(dcmd, d_cmd) == CFSDCMD_DAEMONID || 1856 STRUCT_FGET(dcmd, d_cmd) == CFSDCMD_GETSTATS); 1857 1858 /* get the routine to execute */ 1859 dcmd_routine = NULL; 1860 switch (STRUCT_FGET(dcmd, d_cmd)) { 1861 case CFSDCMD_DAEMONID: 1862 dcmd_routine = cachefs_io_daemonid; 1863 break; 1864 case CFSDCMD_STATEGET: 1865 dcmd_routine = cachefs_io_stateget; 1866 break; 1867 case CFSDCMD_STATESET: 1868 dcmd_routine = cachefs_io_stateset; 1869 break; 1870 case CFSDCMD_XWAIT: 1871 dcmd_routine = cachefs_io_xwait; 1872 break; 1873 case CFSDCMD_EXISTS: 1874 dcmd_routine = cachefs_io_exists; 1875 break; 1876 case CFSDCMD_LOSTFOUND: 1877 dcmd_routine = cachefs_io_lostfound; 1878 break; 1879 case CFSDCMD_GETINFO: 1880 dcmd_routine = cachefs_io_getinfo; 1881 break; 1882 case CFSDCMD_CIDTOFID: 1883 dcmd_routine = cachefs_io_cidtofid; 1884 break; 1885 case CFSDCMD_GETATTRFID: 1886 dcmd_routine = cachefs_io_getattrfid; 1887 break; 1888 case CFSDCMD_GETATTRNAME: 1889 dcmd_routine = cachefs_io_getattrname; 1890 break; 1891 case CFSDCMD_GETSTATS: 1892 dcmd_routine = cachefs_io_getstats; 1893 break; 1894 case CFSDCMD_ROOTFID: 1895 dcmd_routine = cachefs_io_rootfid; 1896 break; 1897 case CFSDCMD_CREATE: 1898 dcmd_routine = cachefs_io_create; 1899 break; 1900 case CFSDCMD_REMOVE: 1901 dcmd_routine = cachefs_io_remove; 1902 break; 1903 case CFSDCMD_LINK: 1904 dcmd_routine = cachefs_io_link; 1905 break; 1906 case CFSDCMD_RENAME: 1907 dcmd_routine = cachefs_io_rename; 1908 break; 1909 case CFSDCMD_MKDIR: 1910 dcmd_routine = cachefs_io_mkdir; 1911 break; 1912 case CFSDCMD_RMDIR: 1913 dcmd_routine = cachefs_io_rmdir; 1914 break; 1915 case CFSDCMD_SYMLINK: 1916 dcmd_routine = cachefs_io_symlink; 1917 break; 1918 case CFSDCMD_SETATTR: 1919 dcmd_routine = cachefs_io_setattr; 1920 break; 1921 case CFSDCMD_SETSECATTR: 1922 dcmd_routine = cachefs_io_setsecattr; 1923 break; 1924 case CFSDCMD_PUSHBACK: 1925 dcmd_routine = cachefs_io_pushback; 1926 break; 1927 default: 1928 error = ENOTTY; 1929 break; 1930 } 1931 1932 /* execute the routine */ 1933 if (dcmd_routine) 1934 error = (*dcmd_routine)(vp, dinp, doutp); 1935 1936 /* copy out the result */ 1937 if ((error == 0) && doutp) 1938 error = xcopyout(doutp, STRUCT_FGETP(dcmd, d_rdata), 1939 outlen); 1940 1941 /* free allocated memory */ 1942 if (dinp) 1943 cachefs_kmem_free(dinp, inlen); 1944 if (doutp) 1945 cachefs_kmem_free(doutp, outlen); 1946 1947 break; 1948 1949 case _FIOCOD: 1950 if (secpolicy_fs_config(cred, vp->v_vfsp) != 0) { 1951 error = EPERM; 1952 break; 1953 } 1954 1955 error = EBUSY; 1956 if (arg) { 1957 /* non-zero arg means do all filesystems */ 1958 mutex_enter(&cachefs_cachelock); 1959 for (cachep = cachefs_cachelist; cachep != NULL; 1960 cachep = cachep->c_next) { 1961 mutex_enter(&cachep->c_fslistlock); 1962 for (fscp = cachep->c_fslist; 1963 fscp != NULL; 1964 fscp = fscp->fs_next) { 1965 if (CFS_ISFS_CODCONST(fscp)) { 1966 gethrestime(&fscp->fs_cod_time); 1967 error = 0; 1968 } 1969 } 1970 mutex_exit(&cachep->c_fslistlock); 1971 } 1972 mutex_exit(&cachefs_cachelock); 1973 } else { 1974 if (CFS_ISFS_CODCONST(fscp)) { 1975 gethrestime(&fscp->fs_cod_time); 1976 error = 0; 1977 } 1978 } 1979 break; 1980 1981 case _FIOSTOPCACHE: 1982 error = cachefs_stop_cache(cp); 1983 break; 1984 1985 default: 1986 error = ENOTTY; 1987 break; 1988 } 1989 1990 /* return the result */ 1991 return (error); 1992 } 1993 1994 ino64_t 1995 cachefs_fileno_conflict(fscache_t *fscp, ino64_t old) 1996 { 1997 ino64_t new; 1998 1999 ASSERT(MUTEX_HELD(&fscp->fs_fslock)); 2000 2001 for (;;) { 2002 fscp->fs_info.fi_localfileno++; 2003 if (fscp->fs_info.fi_localfileno == 0) 2004 fscp->fs_info.fi_localfileno = 3; 2005 fscp->fs_flags |= CFS_FS_DIRTYINFO; 2006 2007 new = fscp->fs_info.fi_localfileno; 2008 if (! cachefs_fileno_inuse(fscp, new)) 2009 break; 2010 } 2011 2012 cachefs_inum_register(fscp, old, new); 2013 cachefs_inum_register(fscp, new, 0); 2014 return (new); 2015 } 2016 2017 /*ARGSUSED*/ 2018 static int 2019 cachefs_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 2020 caller_context_t *ct) 2021 { 2022 struct cnode *cp = VTOC(vp); 2023 fscache_t *fscp = C_TO_FSCACHE(cp); 2024 int error = 0; 2025 int held = 0; 2026 int connected = 0; 2027 2028 #ifdef CFSDEBUG 2029 CFS_DEBUG(CFSDEBUG_VOPS) 2030 printf("cachefs_getattr: ENTER vp %p\n", (void *)vp); 2031 #endif 2032 2033 if (getzoneid() != GLOBAL_ZONEID) 2034 return (EPERM); 2035 2036 /* Call backfilesystem getattr if NFSv4 */ 2037 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { 2038 error = cachefs_getattr_backfs_nfsv4(vp, vap, flags, cr, ct); 2039 goto out; 2040 } 2041 2042 /* 2043 * If it has been specified that the return value will 2044 * just be used as a hint, and we are only being asked 2045 * for size, fsid or rdevid, then return the client's 2046 * notion of these values without checking to make sure 2047 * that the attribute cache is up to date. 2048 * The whole point is to avoid an over the wire GETATTR 2049 * call. 2050 */ 2051 if (flags & ATTR_HINT) { 2052 if (vap->va_mask == 2053 (vap->va_mask & (AT_SIZE | AT_FSID | AT_RDEV))) { 2054 if (vap->va_mask | AT_SIZE) 2055 vap->va_size = cp->c_size; 2056 /* 2057 * Return the FSID of the cachefs filesystem, 2058 * not the back filesystem 2059 */ 2060 if (vap->va_mask | AT_FSID) 2061 vap->va_fsid = vp->v_vfsp->vfs_dev; 2062 if (vap->va_mask | AT_RDEV) 2063 vap->va_rdev = cp->c_attr.va_rdev; 2064 return (0); 2065 } 2066 } 2067 2068 /* 2069 * Only need to flush pages if asking for the mtime 2070 * and if there any dirty pages. 2071 */ 2072 if (vap->va_mask & AT_MTIME) { 2073 /*EMPTY*/ 2074 #if 0 2075 /* 2076 * XXX bob: stolen from nfs code, need to do something similar 2077 */ 2078 rp = VTOR(vp); 2079 if ((rp->r_flags & RDIRTY) || rp->r_iocnt > 0) 2080 (void) nfs3_putpage(vp, (offset_t)0, 0, 0, cr); 2081 #endif 2082 } 2083 2084 for (;;) { 2085 /* get (or renew) access to the file system */ 2086 if (held) { 2087 cachefs_cd_release(fscp); 2088 held = 0; 2089 } 2090 error = cachefs_cd_access(fscp, connected, 0); 2091 if (error) 2092 goto out; 2093 held = 1; 2094 2095 /* 2096 * If it has been specified that the return value will 2097 * just be used as a hint, and we are only being asked 2098 * for size, fsid or rdevid, then return the client's 2099 * notion of these values without checking to make sure 2100 * that the attribute cache is up to date. 2101 * The whole point is to avoid an over the wire GETATTR 2102 * call. 2103 */ 2104 if (flags & ATTR_HINT) { 2105 if (vap->va_mask == 2106 (vap->va_mask & (AT_SIZE | AT_FSID | AT_RDEV))) { 2107 if (vap->va_mask | AT_SIZE) 2108 vap->va_size = cp->c_size; 2109 /* 2110 * Return the FSID of the cachefs filesystem, 2111 * not the back filesystem 2112 */ 2113 if (vap->va_mask | AT_FSID) 2114 vap->va_fsid = vp->v_vfsp->vfs_dev; 2115 if (vap->va_mask | AT_RDEV) 2116 vap->va_rdev = cp->c_attr.va_rdev; 2117 goto out; 2118 } 2119 } 2120 2121 mutex_enter(&cp->c_statelock); 2122 if ((cp->c_metadata.md_flags & MD_NEEDATTRS) && 2123 (fscp->fs_cdconnected != CFS_CD_CONNECTED)) { 2124 mutex_exit(&cp->c_statelock); 2125 connected = 1; 2126 continue; 2127 } 2128 2129 error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr); 2130 if (CFS_TIMEOUT(fscp, error)) { 2131 mutex_exit(&cp->c_statelock); 2132 cachefs_cd_release(fscp); 2133 held = 0; 2134 cachefs_cd_timedout(fscp); 2135 continue; 2136 } 2137 if (error) { 2138 mutex_exit(&cp->c_statelock); 2139 break; 2140 } 2141 2142 /* check for fileno conflict */ 2143 if ((fscp->fs_inum_size > 0) && 2144 ((cp->c_metadata.md_flags & MD_LOCALFILENO) == 0)) { 2145 ino64_t fakenum; 2146 2147 mutex_exit(&cp->c_statelock); 2148 mutex_enter(&fscp->fs_fslock); 2149 fakenum = cachefs_inum_real2fake(fscp, 2150 cp->c_attr.va_nodeid); 2151 if (fakenum == 0) { 2152 fakenum = cachefs_fileno_conflict(fscp, 2153 cp->c_attr.va_nodeid); 2154 } 2155 mutex_exit(&fscp->fs_fslock); 2156 2157 mutex_enter(&cp->c_statelock); 2158 cp->c_metadata.md_flags |= MD_LOCALFILENO; 2159 cp->c_metadata.md_localfileno = fakenum; 2160 cp->c_flags |= CN_UPDATED; 2161 } 2162 2163 /* copy out the attributes */ 2164 *vap = cp->c_attr; 2165 2166 /* 2167 * return the FSID of the cachefs filesystem, 2168 * not the back filesystem 2169 */ 2170 vap->va_fsid = vp->v_vfsp->vfs_dev; 2171 2172 /* return our idea of the size */ 2173 if (cp->c_size > vap->va_size) 2174 vap->va_size = cp->c_size; 2175 2176 /* overwrite with our version of fileno and timestamps */ 2177 vap->va_nodeid = cp->c_metadata.md_localfileno; 2178 vap->va_mtime = cp->c_metadata.md_localmtime; 2179 vap->va_ctime = cp->c_metadata.md_localctime; 2180 2181 mutex_exit(&cp->c_statelock); 2182 break; 2183 } 2184 out: 2185 if (held) 2186 cachefs_cd_release(fscp); 2187 #ifdef CFS_CD_DEBUG 2188 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 2189 #endif 2190 2191 #ifdef CFSDEBUG 2192 CFS_DEBUG(CFSDEBUG_VOPS) 2193 printf("cachefs_getattr: EXIT error = %d\n", error); 2194 #endif 2195 return (error); 2196 } 2197 2198 /* 2199 * cachefs_getattr_backfs_nfsv4 2200 * 2201 * Call NFSv4 back filesystem to handle the getattr (cachefs 2202 * pass-through support for NFSv4). 2203 */ 2204 static int 2205 cachefs_getattr_backfs_nfsv4(vnode_t *vp, vattr_t *vap, 2206 int flags, cred_t *cr, caller_context_t *ct) 2207 { 2208 cnode_t *cp = VTOC(vp); 2209 fscache_t *fscp = C_TO_FSCACHE(cp); 2210 vnode_t *backvp; 2211 int error; 2212 2213 /* 2214 * For NFSv4 pass-through to work, only connected operation 2215 * is supported, the cnode backvp must exist, and cachefs 2216 * optional (eg., disconnectable) flags are turned off. Assert 2217 * these conditions for the getattr operation. 2218 */ 2219 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 2220 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 2221 2222 /* Call backfs vnode op after extracting backvp */ 2223 mutex_enter(&cp->c_statelock); 2224 backvp = cp->c_backvp; 2225 mutex_exit(&cp->c_statelock); 2226 2227 CFS_DPRINT_BACKFS_NFSV4(fscp, ("cachefs_getattr_backfs_nfsv4: cnode %p," 2228 " backvp %p\n", cp, backvp)); 2229 error = VOP_GETATTR(backvp, vap, flags, cr, ct); 2230 2231 /* Update attributes */ 2232 cp->c_attr = *vap; 2233 2234 /* 2235 * return the FSID of the cachefs filesystem, 2236 * not the back filesystem 2237 */ 2238 vap->va_fsid = vp->v_vfsp->vfs_dev; 2239 2240 return (error); 2241 } 2242 2243 /*ARGSUSED4*/ 2244 static int 2245 cachefs_setattr( 2246 vnode_t *vp, 2247 vattr_t *vap, 2248 int flags, 2249 cred_t *cr, 2250 caller_context_t *ct) 2251 { 2252 cnode_t *cp = VTOC(vp); 2253 fscache_t *fscp = C_TO_FSCACHE(cp); 2254 int error; 2255 int connected; 2256 int held = 0; 2257 2258 if (getzoneid() != GLOBAL_ZONEID) 2259 return (EPERM); 2260 2261 /* 2262 * Cachefs only provides pass-through support for NFSv4, 2263 * and all vnode operations are passed through to the 2264 * back file system. For NFSv4 pass-through to work, only 2265 * connected operation is supported, the cnode backvp must 2266 * exist, and cachefs optional (eg., disconnectable) flags 2267 * are turned off. Assert these conditions to ensure that 2268 * the backfilesystem is called for the setattr operation. 2269 */ 2270 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 2271 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 2272 2273 connected = 0; 2274 for (;;) { 2275 /* drop hold on file system */ 2276 if (held) { 2277 /* Won't loop with NFSv4 connected behavior */ 2278 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 2279 cachefs_cd_release(fscp); 2280 held = 0; 2281 } 2282 2283 /* acquire access to the file system */ 2284 error = cachefs_cd_access(fscp, connected, 1); 2285 if (error) 2286 break; 2287 held = 1; 2288 2289 /* perform the setattr */ 2290 error = cachefs_setattr_common(vp, vap, flags, cr, ct); 2291 if (error) { 2292 /* if connected */ 2293 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 2294 if (CFS_TIMEOUT(fscp, error)) { 2295 cachefs_cd_release(fscp); 2296 held = 0; 2297 cachefs_cd_timedout(fscp); 2298 connected = 0; 2299 continue; 2300 } 2301 } 2302 2303 /* else must be disconnected */ 2304 else { 2305 if (CFS_TIMEOUT(fscp, error)) { 2306 connected = 1; 2307 continue; 2308 } 2309 } 2310 } 2311 break; 2312 } 2313 2314 if (held) { 2315 cachefs_cd_release(fscp); 2316 } 2317 #ifdef CFS_CD_DEBUG 2318 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 2319 #endif 2320 return (error); 2321 } 2322 2323 static int 2324 cachefs_setattr_common( 2325 vnode_t *vp, 2326 vattr_t *vap, 2327 int flags, 2328 cred_t *cr, 2329 caller_context_t *ct) 2330 { 2331 cnode_t *cp = VTOC(vp); 2332 fscache_t *fscp = C_TO_FSCACHE(cp); 2333 cachefscache_t *cachep = fscp->fs_cache; 2334 uint_t mask = vap->va_mask; 2335 int error = 0; 2336 uint_t bcnt; 2337 2338 /* Cannot set these attributes. */ 2339 if (mask & AT_NOSET) 2340 return (EINVAL); 2341 2342 /* 2343 * Truncate file. Must have write permission and not be a directory. 2344 */ 2345 if (mask & AT_SIZE) { 2346 if (vp->v_type == VDIR) { 2347 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_TRUNCATE)) 2348 cachefs_log_truncate(cachep, EISDIR, 2349 fscp->fs_cfsvfsp, 2350 &cp->c_metadata.md_cookie, 2351 cp->c_id.cid_fileno, 2352 crgetuid(cr), vap->va_size); 2353 return (EISDIR); 2354 } 2355 } 2356 2357 /* 2358 * Gotta deal with one special case here, where we're setting the 2359 * size of the file. First, we zero out part of the page after the 2360 * new size of the file. Then we toss (not write) all pages after 2361 * page in which the new offset occurs. Note that the NULL passed 2362 * in instead of a putapage() fn parameter is correct, since 2363 * no dirty pages will be found (B_TRUNC | B_INVAL). 2364 */ 2365 2366 rw_enter(&cp->c_rwlock, RW_WRITER); 2367 2368 /* sync dirty pages */ 2369 if (!CFS_ISFS_BACKFS_NFSV4(fscp)) { 2370 error = cachefs_putpage_common(vp, (offset_t)0, 0, 0, cr); 2371 if (error == EINTR) 2372 goto out; 2373 } 2374 error = 0; 2375 2376 /* if connected */ 2377 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 2378 error = cachefs_setattr_connected(vp, vap, flags, cr, ct); 2379 } 2380 /* else must be disconnected */ 2381 else { 2382 error = cachefs_setattr_disconnected(vp, vap, flags, cr, ct); 2383 } 2384 if (error) 2385 goto out; 2386 2387 /* 2388 * If the file size has been changed then 2389 * toss whole pages beyond the end of the file and zero 2390 * the portion of the last page that is beyond the end of the file. 2391 */ 2392 if (mask & AT_SIZE && !CFS_ISFS_BACKFS_NFSV4(fscp)) { 2393 bcnt = (uint_t)(cp->c_size & PAGEOFFSET); 2394 if (bcnt) 2395 pvn_vpzero(vp, cp->c_size, PAGESIZE - bcnt); 2396 (void) pvn_vplist_dirty(vp, cp->c_size, cachefs_push, 2397 B_TRUNC | B_INVAL, cr); 2398 } 2399 2400 out: 2401 rw_exit(&cp->c_rwlock); 2402 2403 if ((mask & AT_SIZE) && 2404 (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_TRUNCATE))) 2405 cachefs_log_truncate(cachep, error, fscp->fs_cfsvfsp, 2406 &cp->c_metadata.md_cookie, cp->c_id.cid_fileno, 2407 crgetuid(cr), vap->va_size); 2408 2409 return (error); 2410 } 2411 2412 static int 2413 cachefs_setattr_connected( 2414 vnode_t *vp, 2415 vattr_t *vap, 2416 int flags, 2417 cred_t *cr, 2418 caller_context_t *ct) 2419 { 2420 cnode_t *cp = VTOC(vp); 2421 fscache_t *fscp = C_TO_FSCACHE(cp); 2422 uint_t mask = vap->va_mask; 2423 int error = 0; 2424 int setsize; 2425 2426 mutex_enter(&cp->c_statelock); 2427 2428 if (cp->c_backvp == NULL) { 2429 error = cachefs_getbackvp(fscp, cp); 2430 if (error) 2431 goto out; 2432 } 2433 2434 error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr); 2435 if (error) 2436 goto out; 2437 2438 CFS_DPRINT_BACKFS_NFSV4(fscp, ("cachefs_setattr (nfsv4): cnode %p, " 2439 "backvp %p\n", cp, cp->c_backvp)); 2440 error = VOP_SETATTR(cp->c_backvp, vap, flags, cr, ct); 2441 if (error) { 2442 goto out; 2443 } 2444 2445 /* if the size of the file is being changed */ 2446 if (mask & AT_SIZE) { 2447 cp->c_size = vap->va_size; 2448 error = 0; 2449 setsize = 0; 2450 2451 /* see if okay to try to set the file size */ 2452 if (((cp->c_flags & CN_NOCACHE) == 0) && 2453 CFS_ISFS_NONSHARED(fscp)) { 2454 /* okay to set size if file is populated */ 2455 if (cp->c_metadata.md_flags & MD_POPULATED) 2456 setsize = 1; 2457 2458 /* 2459 * Okay to set size if front file exists and setting 2460 * file size to zero. 2461 */ 2462 if ((cp->c_metadata.md_flags & MD_FILE) && 2463 (vap->va_size == 0)) 2464 setsize = 1; 2465 } 2466 2467 /* if okay to try to set the file size */ 2468 if (setsize) { 2469 error = 0; 2470 if (cp->c_frontvp == NULL) 2471 error = cachefs_getfrontfile(cp); 2472 if (error == 0) 2473 error = cachefs_frontfile_size(cp, cp->c_size); 2474 } else if (cp->c_metadata.md_flags & MD_FILE) { 2475 /* make sure file gets nocached */ 2476 error = EEXIST; 2477 } 2478 2479 /* if we have to nocache the file */ 2480 if (error) { 2481 if ((cp->c_flags & CN_NOCACHE) == 0 && 2482 !CFS_ISFS_BACKFS_NFSV4(fscp)) 2483 cachefs_nocache(cp); 2484 error = 0; 2485 } 2486 } 2487 2488 cp->c_flags |= CN_UPDATED; 2489 2490 /* XXX bob: given what modify_cobject does this seems unnecessary */ 2491 cp->c_attr.va_mask = AT_ALL; 2492 error = VOP_GETATTR(cp->c_backvp, &cp->c_attr, 0, cr, ct); 2493 if (error) 2494 goto out; 2495 2496 cp->c_attr.va_size = MAX(cp->c_attr.va_size, cp->c_size); 2497 cp->c_size = cp->c_attr.va_size; 2498 2499 CFSOP_MODIFY_COBJECT(fscp, cp, cr); 2500 out: 2501 mutex_exit(&cp->c_statelock); 2502 return (error); 2503 } 2504 2505 /* 2506 * perform the setattr on the local file system 2507 */ 2508 /*ARGSUSED4*/ 2509 static int 2510 cachefs_setattr_disconnected( 2511 vnode_t *vp, 2512 vattr_t *vap, 2513 int flags, 2514 cred_t *cr, 2515 caller_context_t *ct) 2516 { 2517 cnode_t *cp = VTOC(vp); 2518 fscache_t *fscp = C_TO_FSCACHE(cp); 2519 int mask; 2520 int error; 2521 int newfile; 2522 off_t commit = 0; 2523 2524 if (CFS_ISFS_WRITE_AROUND(fscp)) 2525 return (ETIMEDOUT); 2526 2527 /* if we do not have good attributes */ 2528 if (cp->c_metadata.md_flags & MD_NEEDATTRS) 2529 return (ETIMEDOUT); 2530 2531 /* primary concern is to keep this routine as much like ufs_setattr */ 2532 2533 mutex_enter(&cp->c_statelock); 2534 2535 error = secpolicy_vnode_setattr(cr, vp, vap, &cp->c_attr, flags, 2536 cachefs_access_local, cp); 2537 2538 if (error) 2539 goto out; 2540 2541 mask = vap->va_mask; 2542 2543 /* if changing the size of the file */ 2544 if (mask & AT_SIZE) { 2545 if (vp->v_type == VDIR) { 2546 error = EISDIR; 2547 goto out; 2548 } 2549 2550 if (vp->v_type == VFIFO) { 2551 error = 0; 2552 goto out; 2553 } 2554 2555 if ((vp->v_type != VREG) && 2556 !((vp->v_type == VLNK) && (vap->va_size == 0))) { 2557 error = EINVAL; 2558 goto out; 2559 } 2560 2561 if (vap->va_size > fscp->fs_offmax) { 2562 error = EFBIG; 2563 goto out; 2564 } 2565 2566 /* if the file is not populated and we are not truncating it */ 2567 if (((cp->c_metadata.md_flags & MD_POPULATED) == 0) && 2568 (vap->va_size != 0)) { 2569 error = ETIMEDOUT; 2570 goto out; 2571 } 2572 2573 if ((cp->c_metadata.md_flags & MD_MAPPING) == 0) { 2574 error = cachefs_dlog_cidmap(fscp); 2575 if (error) { 2576 error = ENOSPC; 2577 goto out; 2578 } 2579 cp->c_metadata.md_flags |= MD_MAPPING; 2580 } 2581 2582 /* log the operation */ 2583 commit = cachefs_dlog_setattr(fscp, vap, flags, cp, cr); 2584 if (commit == 0) { 2585 error = ENOSPC; 2586 goto out; 2587 } 2588 cp->c_flags &= ~CN_NOCACHE; 2589 2590 /* special case truncating fast sym links */ 2591 if ((vp->v_type == VLNK) && 2592 (cp->c_metadata.md_flags & MD_FASTSYMLNK)) { 2593 /* XXX how can we get here */ 2594 /* XXX should update mtime */ 2595 cp->c_size = 0; 2596 error = 0; 2597 goto out; 2598 } 2599 2600 /* get the front file, this may create one */ 2601 newfile = (cp->c_metadata.md_flags & MD_FILE) ? 0 : 1; 2602 if (cp->c_frontvp == NULL) { 2603 error = cachefs_getfrontfile(cp); 2604 if (error) 2605 goto out; 2606 } 2607 ASSERT(cp->c_frontvp); 2608 if (newfile && (cp->c_flags & CN_UPDATED)) { 2609 /* allocate space for the metadata */ 2610 ASSERT((cp->c_flags & CN_ALLOC_PENDING) == 0); 2611 ASSERT((cp->c_filegrp->fg_flags & CFS_FG_ALLOC_ATTR) 2612 == 0); 2613 error = filegrp_write_metadata(cp->c_filegrp, 2614 &cp->c_id, &cp->c_metadata); 2615 if (error) 2616 goto out; 2617 } 2618 2619 /* change the size of the front file */ 2620 error = cachefs_frontfile_size(cp, vap->va_size); 2621 if (error) 2622 goto out; 2623 cp->c_attr.va_size = cp->c_size = vap->va_size; 2624 gethrestime(&cp->c_metadata.md_localmtime); 2625 cp->c_metadata.md_flags |= MD_POPULATED | MD_LOCALMTIME; 2626 cachefs_modified(cp); 2627 cp->c_flags |= CN_UPDATED; 2628 } 2629 2630 if (mask & AT_MODE) { 2631 /* mark as modified */ 2632 if (cachefs_modified_alloc(cp)) { 2633 error = ENOSPC; 2634 goto out; 2635 } 2636 2637 if ((cp->c_metadata.md_flags & MD_MAPPING) == 0) { 2638 error = cachefs_dlog_cidmap(fscp); 2639 if (error) { 2640 error = ENOSPC; 2641 goto out; 2642 } 2643 cp->c_metadata.md_flags |= MD_MAPPING; 2644 } 2645 2646 /* log the operation if not already logged */ 2647 if (commit == 0) { 2648 commit = cachefs_dlog_setattr(fscp, vap, flags, cp, cr); 2649 if (commit == 0) { 2650 error = ENOSPC; 2651 goto out; 2652 } 2653 } 2654 2655 cp->c_attr.va_mode &= S_IFMT; 2656 cp->c_attr.va_mode |= vap->va_mode & ~S_IFMT; 2657 gethrestime(&cp->c_metadata.md_localctime); 2658 cp->c_metadata.md_flags |= MD_LOCALCTIME; 2659 cp->c_flags |= CN_UPDATED; 2660 } 2661 2662 if (mask & (AT_UID|AT_GID)) { 2663 2664 /* mark as modified */ 2665 if (cachefs_modified_alloc(cp)) { 2666 error = ENOSPC; 2667 goto out; 2668 } 2669 2670 if ((cp->c_metadata.md_flags & MD_MAPPING) == 0) { 2671 error = cachefs_dlog_cidmap(fscp); 2672 if (error) { 2673 error = ENOSPC; 2674 goto out; 2675 } 2676 cp->c_metadata.md_flags |= MD_MAPPING; 2677 } 2678 2679 /* log the operation if not already logged */ 2680 if (commit == 0) { 2681 commit = cachefs_dlog_setattr(fscp, vap, flags, cp, cr); 2682 if (commit == 0) { 2683 error = ENOSPC; 2684 goto out; 2685 } 2686 } 2687 2688 if (mask & AT_UID) 2689 cp->c_attr.va_uid = vap->va_uid; 2690 2691 if (mask & AT_GID) 2692 cp->c_attr.va_gid = vap->va_gid; 2693 gethrestime(&cp->c_metadata.md_localctime); 2694 cp->c_metadata.md_flags |= MD_LOCALCTIME; 2695 cp->c_flags |= CN_UPDATED; 2696 } 2697 2698 2699 if (mask & (AT_MTIME|AT_ATIME)) { 2700 /* mark as modified */ 2701 if (cachefs_modified_alloc(cp)) { 2702 error = ENOSPC; 2703 goto out; 2704 } 2705 2706 if ((cp->c_metadata.md_flags & MD_MAPPING) == 0) { 2707 error = cachefs_dlog_cidmap(fscp); 2708 if (error) { 2709 error = ENOSPC; 2710 goto out; 2711 } 2712 cp->c_metadata.md_flags |= MD_MAPPING; 2713 } 2714 2715 /* log the operation if not already logged */ 2716 if (commit == 0) { 2717 commit = cachefs_dlog_setattr(fscp, vap, flags, cp, cr); 2718 if (commit == 0) { 2719 error = ENOSPC; 2720 goto out; 2721 } 2722 } 2723 2724 if (mask & AT_MTIME) { 2725 cp->c_metadata.md_localmtime = vap->va_mtime; 2726 cp->c_metadata.md_flags |= MD_LOCALMTIME; 2727 } 2728 if (mask & AT_ATIME) 2729 cp->c_attr.va_atime = vap->va_atime; 2730 gethrestime(&cp->c_metadata.md_localctime); 2731 cp->c_metadata.md_flags |= MD_LOCALCTIME; 2732 cp->c_flags |= CN_UPDATED; 2733 } 2734 2735 out: 2736 mutex_exit(&cp->c_statelock); 2737 2738 /* commit the log entry */ 2739 if (commit) { 2740 if (cachefs_dlog_commit(fscp, commit, error)) { 2741 /*EMPTY*/ 2742 /* XXX bob: fix on panic */ 2743 } 2744 } 2745 return (error); 2746 } 2747 2748 /* ARGSUSED */ 2749 static int 2750 cachefs_access(vnode_t *vp, int mode, int flags, cred_t *cr, 2751 caller_context_t *ct) 2752 { 2753 cnode_t *cp = VTOC(vp); 2754 fscache_t *fscp = C_TO_FSCACHE(cp); 2755 int error; 2756 int held = 0; 2757 int connected = 0; 2758 2759 #ifdef CFSDEBUG 2760 CFS_DEBUG(CFSDEBUG_VOPS) 2761 printf("cachefs_access: ENTER vp %p\n", (void *)vp); 2762 #endif 2763 if (getzoneid() != GLOBAL_ZONEID) { 2764 error = EPERM; 2765 goto out; 2766 } 2767 2768 /* 2769 * Cachefs only provides pass-through support for NFSv4, 2770 * and all vnode operations are passed through to the 2771 * back file system. For NFSv4 pass-through to work, only 2772 * connected operation is supported, the cnode backvp must 2773 * exist, and cachefs optional (eg., disconnectable) flags 2774 * are turned off. Assert these conditions to ensure that 2775 * the backfilesystem is called for the access operation. 2776 */ 2777 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 2778 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 2779 2780 for (;;) { 2781 /* get (or renew) access to the file system */ 2782 if (held) { 2783 /* Won't loop with NFSv4 connected behavior */ 2784 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 2785 cachefs_cd_release(fscp); 2786 held = 0; 2787 } 2788 error = cachefs_cd_access(fscp, connected, 0); 2789 if (error) 2790 break; 2791 held = 1; 2792 2793 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 2794 error = cachefs_access_connected(vp, mode, flags, 2795 cr); 2796 if (CFS_TIMEOUT(fscp, error)) { 2797 cachefs_cd_release(fscp); 2798 held = 0; 2799 cachefs_cd_timedout(fscp); 2800 connected = 0; 2801 continue; 2802 } 2803 } else { 2804 mutex_enter(&cp->c_statelock); 2805 error = cachefs_access_local(cp, mode, cr); 2806 mutex_exit(&cp->c_statelock); 2807 if (CFS_TIMEOUT(fscp, error)) { 2808 if (cachefs_cd_access_miss(fscp)) { 2809 mutex_enter(&cp->c_statelock); 2810 if (cp->c_backvp == NULL) { 2811 (void) cachefs_getbackvp(fscp, 2812 cp); 2813 } 2814 mutex_exit(&cp->c_statelock); 2815 error = cachefs_access_connected(vp, 2816 mode, flags, cr); 2817 if (!CFS_TIMEOUT(fscp, error)) 2818 break; 2819 delay(5*hz); 2820 connected = 0; 2821 continue; 2822 } 2823 connected = 1; 2824 continue; 2825 } 2826 } 2827 break; 2828 } 2829 if (held) 2830 cachefs_cd_release(fscp); 2831 #ifdef CFS_CD_DEBUG 2832 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 2833 #endif 2834 out: 2835 #ifdef CFSDEBUG 2836 CFS_DEBUG(CFSDEBUG_VOPS) 2837 printf("cachefs_access: EXIT error = %d\n", error); 2838 #endif 2839 return (error); 2840 } 2841 2842 static int 2843 cachefs_access_connected(struct vnode *vp, int mode, int flags, cred_t *cr) 2844 { 2845 cnode_t *cp = VTOC(vp); 2846 fscache_t *fscp = C_TO_FSCACHE(cp); 2847 int error = 0; 2848 2849 mutex_enter(&cp->c_statelock); 2850 2851 /* Make sure the cnode attrs are valid first. */ 2852 error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr); 2853 if (error) 2854 goto out; 2855 2856 /* see if can do a local file system check */ 2857 if ((fscp->fs_info.fi_mntflags & CFS_ACCESS_BACKFS) == 0 && 2858 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 2859 error = cachefs_access_local(cp, mode, cr); 2860 goto out; 2861 } 2862 2863 /* else do a remote file system check */ 2864 else { 2865 if (cp->c_backvp == NULL) { 2866 error = cachefs_getbackvp(fscp, cp); 2867 if (error) 2868 goto out; 2869 } 2870 2871 CFS_DPRINT_BACKFS_NFSV4(fscp, 2872 ("cachefs_access (nfsv4): cnode %p, backvp %p\n", 2873 cp, cp->c_backvp)); 2874 error = VOP_ACCESS(cp->c_backvp, mode, flags, cr, NULL); 2875 2876 /* 2877 * even though we don't `need' the ACL to do access 2878 * via the backvp, we should cache it here to make our 2879 * behavior more reasonable if we go disconnected. 2880 */ 2881 2882 if (((fscp->fs_info.fi_mntflags & CFS_NOACL) == 0) && 2883 (cachefs_vtype_aclok(vp)) && 2884 ((cp->c_flags & CN_NOCACHE) == 0) && 2885 (!CFS_ISFS_BACKFS_NFSV4(fscp)) && 2886 ((cp->c_metadata.md_flags & MD_ACL) == 0)) 2887 (void) cachefs_cacheacl(cp, NULL); 2888 } 2889 out: 2890 /* 2891 * If NFS returned ESTALE, mark this cnode as stale, so that 2892 * the vn_open retry will read the file anew from backfs 2893 */ 2894 if (error == ESTALE) 2895 cachefs_cnode_stale(cp); 2896 2897 mutex_exit(&cp->c_statelock); 2898 return (error); 2899 } 2900 2901 /* 2902 * CFS has a fastsymlink scheme. If the size of the link is < C_FSL_SIZE, then 2903 * the link is placed in the metadata itself (no front file is allocated). 2904 */ 2905 /*ARGSUSED*/ 2906 static int 2907 cachefs_readlink(vnode_t *vp, uio_t *uiop, cred_t *cr, caller_context_t *ct) 2908 { 2909 int error = 0; 2910 cnode_t *cp = VTOC(vp); 2911 fscache_t *fscp = C_TO_FSCACHE(cp); 2912 cachefscache_t *cachep = fscp->fs_cache; 2913 int held = 0; 2914 int connected = 0; 2915 2916 if (getzoneid() != GLOBAL_ZONEID) 2917 return (EPERM); 2918 2919 if (vp->v_type != VLNK) 2920 return (EINVAL); 2921 2922 /* 2923 * Cachefs only provides pass-through support for NFSv4, 2924 * and all vnode operations are passed through to the 2925 * back file system. For NFSv4 pass-through to work, only 2926 * connected operation is supported, the cnode backvp must 2927 * exist, and cachefs optional (eg., disconnectable) flags 2928 * are turned off. Assert these conditions to ensure that 2929 * the backfilesystem is called for the readlink operation. 2930 */ 2931 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 2932 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 2933 2934 for (;;) { 2935 /* get (or renew) access to the file system */ 2936 if (held) { 2937 /* Won't loop with NFSv4 connected behavior */ 2938 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 2939 cachefs_cd_release(fscp); 2940 held = 0; 2941 } 2942 error = cachefs_cd_access(fscp, connected, 0); 2943 if (error) 2944 break; 2945 held = 1; 2946 2947 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 2948 /* 2949 * since readlink_connected will call stuffsymlink 2950 * on success, have to serialize access 2951 */ 2952 if (!rw_tryenter(&cp->c_rwlock, RW_WRITER)) { 2953 cachefs_cd_release(fscp); 2954 rw_enter(&cp->c_rwlock, RW_WRITER); 2955 error = cachefs_cd_access(fscp, connected, 0); 2956 if (error) { 2957 held = 0; 2958 rw_exit(&cp->c_rwlock); 2959 break; 2960 } 2961 } 2962 error = cachefs_readlink_connected(vp, uiop, cr); 2963 rw_exit(&cp->c_rwlock); 2964 if (CFS_TIMEOUT(fscp, error)) { 2965 cachefs_cd_release(fscp); 2966 held = 0; 2967 cachefs_cd_timedout(fscp); 2968 connected = 0; 2969 continue; 2970 } 2971 } else { 2972 error = cachefs_readlink_disconnected(vp, uiop); 2973 if (CFS_TIMEOUT(fscp, error)) { 2974 if (cachefs_cd_access_miss(fscp)) { 2975 /* as above */ 2976 if (!rw_tryenter(&cp->c_rwlock, 2977 RW_WRITER)) { 2978 cachefs_cd_release(fscp); 2979 rw_enter(&cp->c_rwlock, 2980 RW_WRITER); 2981 error = cachefs_cd_access(fscp, 2982 connected, 0); 2983 if (error) { 2984 held = 0; 2985 rw_exit(&cp->c_rwlock); 2986 break; 2987 } 2988 } 2989 error = cachefs_readlink_connected(vp, 2990 uiop, cr); 2991 rw_exit(&cp->c_rwlock); 2992 if (!CFS_TIMEOUT(fscp, error)) 2993 break; 2994 delay(5*hz); 2995 connected = 0; 2996 continue; 2997 } 2998 connected = 1; 2999 continue; 3000 } 3001 } 3002 break; 3003 } 3004 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_READLINK)) 3005 cachefs_log_readlink(cachep, error, fscp->fs_cfsvfsp, 3006 &cp->c_metadata.md_cookie, cp->c_id.cid_fileno, 3007 crgetuid(cr), cp->c_size); 3008 3009 if (held) 3010 cachefs_cd_release(fscp); 3011 #ifdef CFS_CD_DEBUG 3012 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 3013 #endif 3014 3015 /* 3016 * The over the wire error for attempting to readlink something 3017 * other than a symbolic link is ENXIO. However, we need to 3018 * return EINVAL instead of ENXIO, so we map it here. 3019 */ 3020 return (error == ENXIO ? EINVAL : error); 3021 } 3022 3023 static int 3024 cachefs_readlink_connected(vnode_t *vp, uio_t *uiop, cred_t *cr) 3025 { 3026 int error; 3027 cnode_t *cp = VTOC(vp); 3028 fscache_t *fscp = C_TO_FSCACHE(cp); 3029 caddr_t buf; 3030 int buflen; 3031 int readcache = 0; 3032 3033 mutex_enter(&cp->c_statelock); 3034 3035 error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr); 3036 if (error) 3037 goto out; 3038 3039 /* if the sym link is cached as a fast sym link */ 3040 if (cp->c_metadata.md_flags & MD_FASTSYMLNK) { 3041 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 3042 error = uiomove(cp->c_metadata.md_allocinfo, 3043 MIN(cp->c_size, uiop->uio_resid), UIO_READ, uiop); 3044 #ifdef CFSDEBUG 3045 readcache = 1; 3046 goto out; 3047 #else /* CFSDEBUG */ 3048 /* XXX KLUDGE! correct for insidious 0-len symlink */ 3049 if (cp->c_size != 0) { 3050 readcache = 1; 3051 goto out; 3052 } 3053 #endif /* CFSDEBUG */ 3054 } 3055 3056 /* if the sym link is cached in a front file */ 3057 if (cp->c_metadata.md_flags & MD_POPULATED) { 3058 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 3059 ASSERT(cp->c_metadata.md_flags & MD_FILE); 3060 if (cp->c_frontvp == NULL) { 3061 (void) cachefs_getfrontfile(cp); 3062 } 3063 if (cp->c_metadata.md_flags & MD_POPULATED) { 3064 /* read symlink data from frontfile */ 3065 uiop->uio_offset = 0; 3066 (void) VOP_RWLOCK(cp->c_frontvp, 3067 V_WRITELOCK_FALSE, NULL); 3068 error = VOP_READ(cp->c_frontvp, uiop, 0, kcred, NULL); 3069 VOP_RWUNLOCK(cp->c_frontvp, V_WRITELOCK_FALSE, NULL); 3070 3071 /* XXX KLUDGE! correct for insidious 0-len symlink */ 3072 if (cp->c_size != 0) { 3073 readcache = 1; 3074 goto out; 3075 } 3076 } 3077 } 3078 3079 /* get the sym link contents from the back fs */ 3080 error = cachefs_readlink_back(cp, cr, &buf, &buflen); 3081 if (error) 3082 goto out; 3083 3084 /* copy the contents out to the user */ 3085 error = uiomove(buf, MIN(buflen, uiop->uio_resid), UIO_READ, uiop); 3086 3087 /* 3088 * try to cache the sym link, note that its a noop if NOCACHE is set 3089 * or if NFSv4 pass-through is enabled. 3090 */ 3091 if (cachefs_stuffsymlink(cp, buf, buflen)) { 3092 cachefs_nocache(cp); 3093 } 3094 3095 cachefs_kmem_free(buf, MAXPATHLEN); 3096 3097 out: 3098 mutex_exit(&cp->c_statelock); 3099 if (error == 0) { 3100 if (readcache) 3101 fscp->fs_stats.st_hits++; 3102 else 3103 fscp->fs_stats.st_misses++; 3104 } 3105 return (error); 3106 } 3107 3108 static int 3109 cachefs_readlink_disconnected(vnode_t *vp, uio_t *uiop) 3110 { 3111 int error; 3112 cnode_t *cp = VTOC(vp); 3113 fscache_t *fscp = C_TO_FSCACHE(cp); 3114 int readcache = 0; 3115 3116 mutex_enter(&cp->c_statelock); 3117 3118 /* if the sym link is cached as a fast sym link */ 3119 if (cp->c_metadata.md_flags & MD_FASTSYMLNK) { 3120 error = uiomove(cp->c_metadata.md_allocinfo, 3121 MIN(cp->c_size, uiop->uio_resid), UIO_READ, uiop); 3122 readcache = 1; 3123 goto out; 3124 } 3125 3126 /* if the sym link is cached in a front file */ 3127 if (cp->c_metadata.md_flags & MD_POPULATED) { 3128 ASSERT(cp->c_metadata.md_flags & MD_FILE); 3129 if (cp->c_frontvp == NULL) { 3130 (void) cachefs_getfrontfile(cp); 3131 } 3132 if (cp->c_metadata.md_flags & MD_POPULATED) { 3133 /* read symlink data from frontfile */ 3134 uiop->uio_offset = 0; 3135 (void) VOP_RWLOCK(cp->c_frontvp, 3136 V_WRITELOCK_FALSE, NULL); 3137 error = VOP_READ(cp->c_frontvp, uiop, 0, kcred, NULL); 3138 VOP_RWUNLOCK(cp->c_frontvp, V_WRITELOCK_FALSE, NULL); 3139 readcache = 1; 3140 goto out; 3141 } 3142 } 3143 error = ETIMEDOUT; 3144 3145 out: 3146 mutex_exit(&cp->c_statelock); 3147 if (error == 0) { 3148 if (readcache) 3149 fscp->fs_stats.st_hits++; 3150 else 3151 fscp->fs_stats.st_misses++; 3152 } 3153 return (error); 3154 } 3155 3156 /*ARGSUSED*/ 3157 static int 3158 cachefs_fsync(vnode_t *vp, int syncflag, cred_t *cr, caller_context_t *ct) 3159 { 3160 cnode_t *cp = VTOC(vp); 3161 int error = 0; 3162 fscache_t *fscp = C_TO_FSCACHE(cp); 3163 int held = 0; 3164 int connected = 0; 3165 3166 #ifdef CFSDEBUG 3167 CFS_DEBUG(CFSDEBUG_VOPS) 3168 printf("cachefs_fsync: ENTER vp %p\n", (void *)vp); 3169 #endif 3170 3171 if (getzoneid() != GLOBAL_ZONEID) { 3172 error = EPERM; 3173 goto out; 3174 } 3175 3176 if (fscp->fs_backvfsp && fscp->fs_backvfsp->vfs_flag & VFS_RDONLY) 3177 goto out; 3178 3179 /* 3180 * Cachefs only provides pass-through support for NFSv4, 3181 * and all vnode operations are passed through to the 3182 * back file system. For NFSv4 pass-through to work, only 3183 * connected operation is supported, the cnode backvp must 3184 * exist, and cachefs optional (eg., disconnectable) flags 3185 * are turned off. Assert these conditions to ensure that 3186 * the backfilesystem is called for the fsync operation. 3187 */ 3188 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 3189 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 3190 3191 for (;;) { 3192 /* get (or renew) access to the file system */ 3193 if (held) { 3194 /* Won't loop with NFSv4 connected behavior */ 3195 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 3196 cachefs_cd_release(fscp); 3197 held = 0; 3198 } 3199 error = cachefs_cd_access(fscp, connected, 1); 3200 if (error) 3201 break; 3202 held = 1; 3203 connected = 0; 3204 3205 /* if a regular file, write out the pages */ 3206 if ((vp->v_type == VREG) && vn_has_cached_data(vp) && 3207 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 3208 error = cachefs_putpage_common(vp, (offset_t)0, 3209 0, 0, cr); 3210 if (CFS_TIMEOUT(fscp, error)) { 3211 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 3212 cachefs_cd_release(fscp); 3213 held = 0; 3214 cachefs_cd_timedout(fscp); 3215 continue; 3216 } else { 3217 connected = 1; 3218 continue; 3219 } 3220 } 3221 3222 /* if no space left in cache, wait until connected */ 3223 if ((error == ENOSPC) && 3224 (fscp->fs_cdconnected != CFS_CD_CONNECTED)) { 3225 connected = 1; 3226 continue; 3227 } 3228 3229 /* clear the cnode error if putpage worked */ 3230 if ((error == 0) && cp->c_error) { 3231 mutex_enter(&cp->c_statelock); 3232 cp->c_error = 0; 3233 mutex_exit(&cp->c_statelock); 3234 } 3235 3236 if (error) 3237 break; 3238 } 3239 3240 /* if connected, sync the backvp */ 3241 if ((fscp->fs_cdconnected == CFS_CD_CONNECTED) && 3242 cp->c_backvp) { 3243 mutex_enter(&cp->c_statelock); 3244 if (cp->c_backvp) { 3245 CFS_DPRINT_BACKFS_NFSV4(fscp, 3246 ("cachefs_fsync (nfsv4): cnode %p, " 3247 "backvp %p\n", cp, cp->c_backvp)); 3248 error = VOP_FSYNC(cp->c_backvp, syncflag, cr, 3249 ct); 3250 if (CFS_TIMEOUT(fscp, error)) { 3251 mutex_exit(&cp->c_statelock); 3252 cachefs_cd_release(fscp); 3253 held = 0; 3254 cachefs_cd_timedout(fscp); 3255 continue; 3256 } else if (error && (error != EINTR)) 3257 cp->c_error = error; 3258 } 3259 mutex_exit(&cp->c_statelock); 3260 } 3261 3262 /* sync the metadata and the front file to the front fs */ 3263 if (!CFS_ISFS_BACKFS_NFSV4(fscp)) { 3264 error = cachefs_sync_metadata(cp); 3265 if (error && 3266 (fscp->fs_cdconnected == CFS_CD_CONNECTED)) 3267 error = 0; 3268 } 3269 break; 3270 } 3271 3272 if (error == 0) 3273 error = cp->c_error; 3274 3275 if (held) 3276 cachefs_cd_release(fscp); 3277 3278 out: 3279 #ifdef CFS_CD_DEBUG 3280 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 3281 #endif 3282 3283 #ifdef CFSDEBUG 3284 CFS_DEBUG(CFSDEBUG_VOPS) 3285 printf("cachefs_fsync: EXIT vp %p\n", (void *)vp); 3286 #endif 3287 return (error); 3288 } 3289 3290 /* 3291 * Called from cachefs_inactive(), to make sure all the data goes out to disk. 3292 */ 3293 int 3294 cachefs_sync_metadata(cnode_t *cp) 3295 { 3296 int error = 0; 3297 struct filegrp *fgp; 3298 struct vattr va; 3299 fscache_t *fscp = C_TO_FSCACHE(cp); 3300 3301 #ifdef CFSDEBUG 3302 CFS_DEBUG(CFSDEBUG_VOPS) 3303 printf("c_sync_metadata: ENTER cp %p cflag %x\n", 3304 (void *)cp, cp->c_flags); 3305 #endif 3306 3307 mutex_enter(&cp->c_statelock); 3308 if ((cp->c_flags & CN_UPDATED) == 0) 3309 goto out; 3310 if (cp->c_flags & (CN_STALE | CN_DESTROY)) 3311 goto out; 3312 fgp = cp->c_filegrp; 3313 if ((fgp->fg_flags & CFS_FG_WRITE) == 0) 3314 goto out; 3315 if (CFS_ISFS_BACKFS_NFSV4(fscp)) 3316 goto out; 3317 3318 if (fgp->fg_flags & CFS_FG_ALLOC_ATTR) { 3319 mutex_exit(&cp->c_statelock); 3320 error = filegrp_allocattr(fgp); 3321 mutex_enter(&cp->c_statelock); 3322 if (error) { 3323 error = 0; 3324 goto out; 3325 } 3326 } 3327 3328 if (cp->c_flags & CN_ALLOC_PENDING) { 3329 error = filegrp_create_metadata(fgp, &cp->c_metadata, 3330 &cp->c_id); 3331 if (error) 3332 goto out; 3333 cp->c_flags &= ~CN_ALLOC_PENDING; 3334 } 3335 3336 if (cp->c_flags & CN_NEED_FRONT_SYNC) { 3337 if (cp->c_frontvp != NULL) { 3338 error = VOP_FSYNC(cp->c_frontvp, FSYNC, kcred, NULL); 3339 if (error) { 3340 cp->c_metadata.md_timestamp.tv_sec = 0; 3341 } else { 3342 va.va_mask = AT_MTIME; 3343 error = VOP_GETATTR(cp->c_frontvp, &va, 0, 3344 kcred, NULL); 3345 if (error) 3346 goto out; 3347 cp->c_metadata.md_timestamp = va.va_mtime; 3348 cp->c_flags &= 3349 ~(CN_NEED_FRONT_SYNC | 3350 CN_POPULATION_PENDING); 3351 } 3352 } else { 3353 cp->c_flags &= 3354 ~(CN_NEED_FRONT_SYNC | CN_POPULATION_PENDING); 3355 } 3356 } 3357 3358 /* 3359 * XXX tony: How can CN_ALLOC_PENDING still be set?? 3360 * XXX tony: How can CN_UPDATED not be set????? 3361 */ 3362 if ((cp->c_flags & CN_ALLOC_PENDING) == 0 && 3363 (cp->c_flags & CN_UPDATED)) { 3364 error = filegrp_write_metadata(fgp, &cp->c_id, 3365 &cp->c_metadata); 3366 if (error) 3367 goto out; 3368 } 3369 out: 3370 if (error) { 3371 /* XXX modified files? */ 3372 if (cp->c_metadata.md_rlno) { 3373 cachefs_removefrontfile(&cp->c_metadata, 3374 &cp->c_id, fgp); 3375 cachefs_rlent_moveto(C_TO_FSCACHE(cp)->fs_cache, 3376 CACHEFS_RL_FREE, cp->c_metadata.md_rlno, 0); 3377 cp->c_metadata.md_rlno = 0; 3378 cp->c_metadata.md_rltype = CACHEFS_RL_NONE; 3379 if (cp->c_frontvp) { 3380 VN_RELE(cp->c_frontvp); 3381 cp->c_frontvp = NULL; 3382 } 3383 } 3384 if ((cp->c_flags & CN_ALLOC_PENDING) == 0) 3385 (void) filegrp_destroy_metadata(fgp, &cp->c_id); 3386 cp->c_flags |= CN_ALLOC_PENDING; 3387 cachefs_nocache(cp); 3388 } 3389 /* 3390 * we clear the updated bit even on errors because a retry 3391 * will probably fail also. 3392 */ 3393 cp->c_flags &= ~CN_UPDATED; 3394 mutex_exit(&cp->c_statelock); 3395 3396 #ifdef CFSDEBUG 3397 CFS_DEBUG(CFSDEBUG_VOPS) 3398 printf("c_sync_metadata: EXIT cp %p cflag %x\n", 3399 (void *)cp, cp->c_flags); 3400 #endif 3401 3402 return (error); 3403 } 3404 3405 /* 3406 * This is the vop entry point for inactivating a vnode. 3407 * It just queues the request for the async thread which 3408 * calls cachefs_inactive. 3409 * Because of the dnlc, it is not safe to grab most locks here. 3410 */ 3411 /*ARGSUSED*/ 3412 static void 3413 cachefs_inactive(struct vnode *vp, cred_t *cr, caller_context_t *ct) 3414 { 3415 cnode_t *cp; 3416 struct cachefs_req *rp; 3417 fscache_t *fscp; 3418 3419 #ifdef CFSDEBUG 3420 CFS_DEBUG(CFSDEBUG_VOPS) 3421 printf("cachefs_inactive: ENTER vp %p\n", (void *)vp); 3422 #endif 3423 3424 cp = VTOC(vp); 3425 fscp = C_TO_FSCACHE(cp); 3426 3427 ASSERT((cp->c_flags & CN_IDLE) == 0); 3428 3429 /* 3430 * Cachefs only provides pass-through support for NFSv4, 3431 * and all vnode operations are passed through to the 3432 * back file system. For NFSv4 pass-through to work, only 3433 * connected operation is supported, the cnode backvp must 3434 * exist, and cachefs optional (eg., disconnectable) flags 3435 * are turned off. Assert these conditions to ensure that 3436 * the backfilesystem is called for the inactive operation. 3437 */ 3438 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 3439 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 3440 3441 /* vn_rele() set the v_count == 1 */ 3442 3443 cp->c_ipending = 1; 3444 3445 rp = kmem_cache_alloc(cachefs_req_cache, KM_SLEEP); 3446 rp->cfs_cmd = CFS_IDLE; 3447 rp->cfs_cr = cr; 3448 crhold(rp->cfs_cr); 3449 rp->cfs_req_u.cu_idle.ci_vp = vp; 3450 cachefs_addqueue(rp, &(C_TO_FSCACHE(cp)->fs_workq)); 3451 3452 #ifdef CFSDEBUG 3453 CFS_DEBUG(CFSDEBUG_VOPS) 3454 printf("cachefs_inactive: EXIT vp %p\n", (void *)vp); 3455 #endif 3456 } 3457 3458 /* ARGSUSED */ 3459 static int 3460 cachefs_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, 3461 struct pathname *pnp, int flags, vnode_t *rdir, cred_t *cr, 3462 caller_context_t *ct, int *direntflags, pathname_t *realpnp) 3463 3464 { 3465 int error = 0; 3466 cnode_t *dcp = VTOC(dvp); 3467 fscache_t *fscp = C_TO_FSCACHE(dcp); 3468 int held = 0; 3469 int connected = 0; 3470 3471 #ifdef CFSDEBUG 3472 CFS_DEBUG(CFSDEBUG_VOPS) 3473 printf("cachefs_lookup: ENTER dvp %p nm %s\n", (void *)dvp, nm); 3474 #endif 3475 3476 if (getzoneid() != GLOBAL_ZONEID) { 3477 error = EPERM; 3478 goto out; 3479 } 3480 3481 /* 3482 * Cachefs only provides pass-through support for NFSv4, 3483 * and all vnode operations are passed through to the 3484 * back file system. For NFSv4 pass-through to work, only 3485 * connected operation is supported, the cnode backvp must 3486 * exist, and cachefs optional (eg., disconnectable) flags 3487 * are turned off. Assert these conditions to ensure that 3488 * the backfilesystem is called for the lookup operation. 3489 */ 3490 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 3491 CFS_BACKFS_NFSV4_ASSERT_CNODE(dcp); 3492 3493 for (;;) { 3494 /* get (or renew) access to the file system */ 3495 if (held) { 3496 /* Won't loop with NFSv4 connected behavior */ 3497 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 3498 cachefs_cd_release(fscp); 3499 held = 0; 3500 } 3501 error = cachefs_cd_access(fscp, connected, 0); 3502 if (error) 3503 break; 3504 held = 1; 3505 3506 error = cachefs_lookup_common(dvp, nm, vpp, pnp, 3507 flags, rdir, cr); 3508 if (CFS_TIMEOUT(fscp, error)) { 3509 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 3510 cachefs_cd_release(fscp); 3511 held = 0; 3512 cachefs_cd_timedout(fscp); 3513 connected = 0; 3514 continue; 3515 } else { 3516 if (cachefs_cd_access_miss(fscp)) { 3517 rw_enter(&dcp->c_rwlock, RW_READER); 3518 error = cachefs_lookup_back(dvp, nm, 3519 vpp, cr); 3520 rw_exit(&dcp->c_rwlock); 3521 if (!CFS_TIMEOUT(fscp, error)) 3522 break; 3523 delay(5*hz); 3524 connected = 0; 3525 continue; 3526 } 3527 connected = 1; 3528 continue; 3529 } 3530 } 3531 break; 3532 } 3533 if (held) 3534 cachefs_cd_release(fscp); 3535 3536 if (error == 0 && IS_DEVVP(*vpp)) { 3537 struct vnode *newvp; 3538 newvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cr); 3539 VN_RELE(*vpp); 3540 if (newvp == NULL) { 3541 error = ENOSYS; 3542 } else { 3543 *vpp = newvp; 3544 } 3545 } 3546 3547 #ifdef CFS_CD_DEBUG 3548 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 3549 #endif 3550 out: 3551 #ifdef CFSDEBUG 3552 CFS_DEBUG(CFSDEBUG_VOPS) 3553 printf("cachefs_lookup: EXIT error = %d\n", error); 3554 #endif 3555 3556 return (error); 3557 } 3558 3559 /* ARGSUSED */ 3560 int 3561 cachefs_lookup_common(vnode_t *dvp, char *nm, vnode_t **vpp, 3562 struct pathname *pnp, int flags, vnode_t *rdir, cred_t *cr) 3563 { 3564 int error = 0; 3565 cnode_t *cp, *dcp = VTOC(dvp); 3566 fscache_t *fscp = C_TO_FSCACHE(dcp); 3567 struct fid cookie; 3568 u_offset_t d_offset; 3569 struct cachefs_req *rp; 3570 cfs_cid_t cid, dircid; 3571 uint_t flag; 3572 uint_t uncached = 0; 3573 3574 *vpp = NULL; 3575 3576 /* 3577 * If lookup is for "", just return dvp. Don't need 3578 * to send it over the wire, look it up in the dnlc, 3579 * or perform any access checks. 3580 */ 3581 if (*nm == '\0') { 3582 VN_HOLD(dvp); 3583 *vpp = dvp; 3584 return (0); 3585 } 3586 3587 /* can't do lookups in non-directories */ 3588 if (dvp->v_type != VDIR) 3589 return (ENOTDIR); 3590 3591 /* perform access check, also does consistency check if connected */ 3592 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 3593 error = cachefs_access_connected(dvp, VEXEC, 0, cr); 3594 } else { 3595 mutex_enter(&dcp->c_statelock); 3596 error = cachefs_access_local(dcp, VEXEC, cr); 3597 mutex_exit(&dcp->c_statelock); 3598 } 3599 if (error) 3600 return (error); 3601 3602 /* 3603 * If lookup is for ".", just return dvp. Don't need 3604 * to send it over the wire or look it up in the dnlc, 3605 * just need to check access. 3606 */ 3607 if (strcmp(nm, ".") == 0) { 3608 VN_HOLD(dvp); 3609 *vpp = dvp; 3610 return (0); 3611 } 3612 3613 /* check the dnlc */ 3614 *vpp = (vnode_t *)dnlc_lookup(dvp, nm); 3615 if (*vpp) 3616 return (0); 3617 3618 /* read lock the dir before starting the search */ 3619 rw_enter(&dcp->c_rwlock, RW_READER); 3620 3621 mutex_enter(&dcp->c_statelock); 3622 dircid = dcp->c_id; 3623 3624 dcp->c_usage++; 3625 3626 /* if front file is not usable, lookup on the back fs */ 3627 if ((dcp->c_flags & (CN_NOCACHE | CN_ASYNC_POPULATE)) || 3628 CFS_ISFS_BACKFS_NFSV4(fscp) || 3629 ((dcp->c_filegrp->fg_flags & CFS_FG_READ) == 0)) { 3630 mutex_exit(&dcp->c_statelock); 3631 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) 3632 error = cachefs_lookup_back(dvp, nm, vpp, cr); 3633 else 3634 error = ETIMEDOUT; 3635 goto out; 3636 } 3637 3638 /* if the front file is not populated, try to populate it */ 3639 if ((dcp->c_metadata.md_flags & MD_POPULATED) == 0) { 3640 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 3641 error = ETIMEDOUT; 3642 mutex_exit(&dcp->c_statelock); 3643 goto out; 3644 } 3645 3646 if (cachefs_async_okay()) { 3647 /* cannot populate if cache is not writable */ 3648 ASSERT((dcp->c_flags & 3649 (CN_ASYNC_POPULATE | CN_NOCACHE)) == 0); 3650 dcp->c_flags |= CN_ASYNC_POPULATE; 3651 3652 rp = kmem_cache_alloc(cachefs_req_cache, KM_SLEEP); 3653 rp->cfs_cmd = CFS_POPULATE; 3654 rp->cfs_req_u.cu_populate.cpop_vp = dvp; 3655 rp->cfs_cr = cr; 3656 3657 crhold(cr); 3658 VN_HOLD(dvp); 3659 3660 cachefs_addqueue(rp, &fscp->fs_workq); 3661 } else if (fscp->fs_info.fi_mntflags & CFS_NOACL) { 3662 error = cachefs_dir_fill(dcp, cr); 3663 if (error != 0) { 3664 mutex_exit(&dcp->c_statelock); 3665 goto out; 3666 } 3667 } 3668 /* no populate if too many asyncs and we have to cache ACLs */ 3669 3670 mutex_exit(&dcp->c_statelock); 3671 3672 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) 3673 error = cachefs_lookup_back(dvp, nm, vpp, cr); 3674 else 3675 error = ETIMEDOUT; 3676 goto out; 3677 } 3678 3679 /* by now we have a valid cached front file that we can search */ 3680 3681 ASSERT((dcp->c_flags & CN_ASYNC_POPULATE) == 0); 3682 error = cachefs_dir_look(dcp, nm, &cookie, &flag, 3683 &d_offset, &cid); 3684 mutex_exit(&dcp->c_statelock); 3685 3686 if (error) { 3687 /* if the entry does not have the fid, go get it */ 3688 if (error == EINVAL) { 3689 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) 3690 error = cachefs_lookup_back(dvp, nm, vpp, cr); 3691 else 3692 error = ETIMEDOUT; 3693 } 3694 3695 /* errors other than does not exist */ 3696 else if (error != ENOENT) { 3697 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) 3698 error = cachefs_lookup_back(dvp, nm, vpp, cr); 3699 else 3700 error = ETIMEDOUT; 3701 } 3702 goto out; 3703 } 3704 3705 /* 3706 * Else we found the entry in the cached directory. 3707 * Make a cnode for it. 3708 */ 3709 error = cachefs_cnode_make(&cid, fscp, &cookie, NULL, NULL, 3710 cr, 0, &cp); 3711 if (error == ESTALE) { 3712 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 3713 mutex_enter(&dcp->c_statelock); 3714 cachefs_nocache(dcp); 3715 mutex_exit(&dcp->c_statelock); 3716 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 3717 error = cachefs_lookup_back(dvp, nm, vpp, cr); 3718 uncached = 1; 3719 } else 3720 error = ETIMEDOUT; 3721 } else if (error == 0) { 3722 *vpp = CTOV(cp); 3723 } 3724 3725 out: 3726 if (error == 0) { 3727 /* put the entry in the dnlc */ 3728 if (cachefs_dnlc) 3729 dnlc_enter(dvp, nm, *vpp); 3730 3731 /* save the cid of the parent so can find the name */ 3732 cp = VTOC(*vpp); 3733 if (bcmp(&cp->c_metadata.md_parent, &dircid, 3734 sizeof (cfs_cid_t)) != 0) { 3735 mutex_enter(&cp->c_statelock); 3736 cp->c_metadata.md_parent = dircid; 3737 cp->c_flags |= CN_UPDATED; 3738 mutex_exit(&cp->c_statelock); 3739 } 3740 } 3741 3742 rw_exit(&dcp->c_rwlock); 3743 if (uncached && dcp->c_metadata.md_flags & MD_PACKED) 3744 (void) cachefs_pack_common(dvp, cr); 3745 return (error); 3746 } 3747 3748 /* 3749 * Called from cachefs_lookup_common when the back file system needs to be 3750 * examined to perform the lookup. 3751 */ 3752 static int 3753 cachefs_lookup_back(vnode_t *dvp, char *nm, vnode_t **vpp, 3754 cred_t *cr) 3755 { 3756 int error = 0; 3757 cnode_t *cp, *dcp = VTOC(dvp); 3758 fscache_t *fscp = C_TO_FSCACHE(dcp); 3759 vnode_t *backvp = NULL; 3760 struct vattr va; 3761 struct fid cookie; 3762 cfs_cid_t cid; 3763 uint32_t valid_fid; 3764 3765 mutex_enter(&dcp->c_statelock); 3766 3767 /* do a lookup on the back FS to get the back vnode */ 3768 if (dcp->c_backvp == NULL) { 3769 error = cachefs_getbackvp(fscp, dcp); 3770 if (error) 3771 goto out; 3772 } 3773 3774 CFS_DPRINT_BACKFS_NFSV4(fscp, 3775 ("cachefs_lookup (nfsv4): dcp %p, dbackvp %p, name %s\n", 3776 dcp, dcp->c_backvp, nm)); 3777 error = VOP_LOOKUP(dcp->c_backvp, nm, &backvp, (struct pathname *)NULL, 3778 0, (vnode_t *)NULL, cr, NULL, NULL, NULL); 3779 if (error) 3780 goto out; 3781 if (IS_DEVVP(backvp)) { 3782 struct vnode *devvp = backvp; 3783 3784 if (VOP_REALVP(devvp, &backvp, NULL) == 0) { 3785 VN_HOLD(backvp); 3786 VN_RELE(devvp); 3787 } 3788 } 3789 3790 /* get the fid and attrs from the back fs */ 3791 valid_fid = (CFS_ISFS_BACKFS_NFSV4(fscp) ? FALSE : TRUE); 3792 error = cachefs_getcookie(backvp, &cookie, &va, cr, valid_fid); 3793 if (error) 3794 goto out; 3795 3796 cid.cid_fileno = va.va_nodeid; 3797 cid.cid_flags = 0; 3798 3799 #if 0 3800 /* XXX bob: this is probably no longer necessary */ 3801 /* if the directory entry was incomplete, we can complete it now */ 3802 if ((dcp->c_metadata.md_flags & MD_POPULATED) && 3803 ((dcp->c_flags & CN_ASYNC_POPULATE) == 0) && 3804 (dcp->c_filegrp->fg_flags & CFS_FG_WRITE)) { 3805 cachefs_dir_modentry(dcp, d_offset, &cookie, &cid); 3806 } 3807 #endif 3808 3809 out: 3810 mutex_exit(&dcp->c_statelock); 3811 3812 /* create the cnode */ 3813 if (error == 0) { 3814 error = cachefs_cnode_make(&cid, fscp, 3815 (valid_fid ? &cookie : NULL), 3816 &va, backvp, cr, 0, &cp); 3817 if (error == 0) { 3818 *vpp = CTOV(cp); 3819 } 3820 } 3821 3822 if (backvp) 3823 VN_RELE(backvp); 3824 3825 return (error); 3826 } 3827 3828 /*ARGSUSED7*/ 3829 static int 3830 cachefs_create(vnode_t *dvp, char *nm, vattr_t *vap, 3831 vcexcl_t exclusive, int mode, vnode_t **vpp, cred_t *cr, int flag, 3832 caller_context_t *ct, vsecattr_t *vsecp) 3833 3834 { 3835 cnode_t *dcp = VTOC(dvp); 3836 fscache_t *fscp = C_TO_FSCACHE(dcp); 3837 cachefscache_t *cachep = fscp->fs_cache; 3838 int error; 3839 int connected = 0; 3840 int held = 0; 3841 3842 #ifdef CFSDEBUG 3843 CFS_DEBUG(CFSDEBUG_VOPS) 3844 printf("cachefs_create: ENTER dvp %p, nm %s\n", 3845 (void *)dvp, nm); 3846 #endif 3847 if (getzoneid() != GLOBAL_ZONEID) { 3848 error = EPERM; 3849 goto out; 3850 } 3851 3852 /* 3853 * Cachefs only provides pass-through support for NFSv4, 3854 * and all vnode operations are passed through to the 3855 * back file system. For NFSv4 pass-through to work, only 3856 * connected operation is supported, the cnode backvp must 3857 * exist, and cachefs optional (eg., disconnectable) flags 3858 * are turned off. Assert these conditions to ensure that 3859 * the backfilesystem is called for the create operation. 3860 */ 3861 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 3862 CFS_BACKFS_NFSV4_ASSERT_CNODE(dcp); 3863 3864 for (;;) { 3865 /* get (or renew) access to the file system */ 3866 if (held) { 3867 /* Won't loop with NFSv4 connected behavior */ 3868 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 3869 cachefs_cd_release(fscp); 3870 held = 0; 3871 } 3872 error = cachefs_cd_access(fscp, connected, 1); 3873 if (error) 3874 break; 3875 held = 1; 3876 3877 /* 3878 * if we are connected, perform the remote portion of the 3879 * create. 3880 */ 3881 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 3882 error = cachefs_create_connected(dvp, nm, vap, 3883 exclusive, mode, vpp, cr); 3884 if (CFS_TIMEOUT(fscp, error)) { 3885 cachefs_cd_release(fscp); 3886 held = 0; 3887 cachefs_cd_timedout(fscp); 3888 connected = 0; 3889 continue; 3890 } else if (error) { 3891 break; 3892 } 3893 } 3894 3895 /* else we must be disconnected */ 3896 else { 3897 error = cachefs_create_disconnected(dvp, nm, vap, 3898 exclusive, mode, vpp, cr); 3899 if (CFS_TIMEOUT(fscp, error)) { 3900 connected = 1; 3901 continue; 3902 } else if (error) { 3903 break; 3904 } 3905 } 3906 break; 3907 } 3908 3909 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_CREATE)) { 3910 fid_t *fidp = NULL; 3911 ino64_t fileno = 0; 3912 cnode_t *cp = NULL; 3913 if (error == 0) 3914 cp = VTOC(*vpp); 3915 3916 if (cp != NULL) { 3917 fidp = &cp->c_metadata.md_cookie; 3918 fileno = cp->c_id.cid_fileno; 3919 } 3920 cachefs_log_create(cachep, error, fscp->fs_cfsvfsp, 3921 fidp, fileno, crgetuid(cr)); 3922 } 3923 3924 if (held) 3925 cachefs_cd_release(fscp); 3926 3927 if (error == 0 && CFS_ISFS_NONSHARED(fscp)) 3928 (void) cachefs_pack(dvp, nm, cr); 3929 if (error == 0 && IS_DEVVP(*vpp)) { 3930 struct vnode *spcvp; 3931 3932 spcvp = specvp(*vpp, (*vpp)->v_rdev, (*vpp)->v_type, cr); 3933 VN_RELE(*vpp); 3934 if (spcvp == NULL) { 3935 error = ENOSYS; 3936 } else { 3937 *vpp = spcvp; 3938 } 3939 } 3940 3941 #ifdef CFS_CD_DEBUG 3942 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 3943 #endif 3944 out: 3945 #ifdef CFSDEBUG 3946 CFS_DEBUG(CFSDEBUG_VOPS) 3947 printf("cachefs_create: EXIT error %d\n", error); 3948 #endif 3949 return (error); 3950 } 3951 3952 3953 static int 3954 cachefs_create_connected(vnode_t *dvp, char *nm, vattr_t *vap, 3955 enum vcexcl exclusive, int mode, vnode_t **vpp, cred_t *cr) 3956 { 3957 cnode_t *dcp = VTOC(dvp); 3958 fscache_t *fscp = C_TO_FSCACHE(dcp); 3959 int error; 3960 vnode_t *tvp = NULL; 3961 vnode_t *devvp; 3962 fid_t cookie; 3963 vattr_t va; 3964 cnode_t *ncp; 3965 cfs_cid_t cid; 3966 vnode_t *vp; 3967 uint32_t valid_fid; 3968 3969 /* special case if file already exists */ 3970 error = cachefs_lookup_common(dvp, nm, &vp, NULL, 0, NULL, cr); 3971 if (CFS_TIMEOUT(fscp, error)) 3972 return (error); 3973 if (error == 0) { 3974 if (exclusive == EXCL) 3975 error = EEXIST; 3976 else if (vp->v_type == VDIR && (mode & VWRITE)) 3977 error = EISDIR; 3978 else if ((error = 3979 cachefs_access_connected(vp, mode, 0, cr)) == 0) { 3980 if ((vap->va_mask & AT_SIZE) && (vp->v_type == VREG)) { 3981 vap->va_mask = AT_SIZE; 3982 error = cachefs_setattr_common(vp, vap, 0, 3983 cr, NULL); 3984 } 3985 } 3986 if (error) { 3987 VN_RELE(vp); 3988 } else 3989 *vpp = vp; 3990 return (error); 3991 } 3992 3993 rw_enter(&dcp->c_rwlock, RW_WRITER); 3994 mutex_enter(&dcp->c_statelock); 3995 3996 /* consistency check the directory */ 3997 error = CFSOP_CHECK_COBJECT(fscp, dcp, 0, cr); 3998 if (error) { 3999 mutex_exit(&dcp->c_statelock); 4000 goto out; 4001 } 4002 4003 /* get the backvp if necessary */ 4004 if (dcp->c_backvp == NULL) { 4005 error = cachefs_getbackvp(fscp, dcp); 4006 if (error) { 4007 mutex_exit(&dcp->c_statelock); 4008 goto out; 4009 } 4010 } 4011 4012 /* create the file on the back fs */ 4013 CFS_DPRINT_BACKFS_NFSV4(fscp, 4014 ("cachefs_create (nfsv4): dcp %p, dbackvp %p," 4015 "name %s\n", dcp, dcp->c_backvp, nm)); 4016 error = VOP_CREATE(dcp->c_backvp, nm, vap, exclusive, mode, 4017 &devvp, cr, 0, NULL, NULL); 4018 mutex_exit(&dcp->c_statelock); 4019 if (error) 4020 goto out; 4021 if (VOP_REALVP(devvp, &tvp, NULL) == 0) { 4022 VN_HOLD(tvp); 4023 VN_RELE(devvp); 4024 } else { 4025 tvp = devvp; 4026 } 4027 4028 /* get the fid and attrs from the back fs */ 4029 valid_fid = (CFS_ISFS_BACKFS_NFSV4(fscp) ? FALSE : TRUE); 4030 error = cachefs_getcookie(tvp, &cookie, &va, cr, valid_fid); 4031 if (error) 4032 goto out; 4033 4034 /* make the cnode */ 4035 cid.cid_fileno = va.va_nodeid; 4036 cid.cid_flags = 0; 4037 error = cachefs_cnode_make(&cid, fscp, (valid_fid ? &cookie : NULL), 4038 &va, tvp, cr, 0, &ncp); 4039 if (error) 4040 goto out; 4041 4042 *vpp = CTOV(ncp); 4043 4044 /* enter it in the parent directory */ 4045 mutex_enter(&dcp->c_statelock); 4046 if (CFS_ISFS_NONSHARED(fscp) && 4047 (dcp->c_metadata.md_flags & MD_POPULATED)) { 4048 /* see if entry already exists */ 4049 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 4050 error = cachefs_dir_look(dcp, nm, NULL, NULL, NULL, NULL); 4051 if (error == ENOENT) { 4052 /* entry, does not exist, add the new file */ 4053 error = cachefs_dir_enter(dcp, nm, &ncp->c_cookie, 4054 &ncp->c_id, SM_ASYNC); 4055 if (error) { 4056 cachefs_nocache(dcp); 4057 error = 0; 4058 } 4059 /* XXX should this be done elsewhere, too? */ 4060 dnlc_enter(dvp, nm, *vpp); 4061 } else { 4062 /* entry exists or some other problem */ 4063 cachefs_nocache(dcp); 4064 error = 0; 4065 } 4066 } 4067 CFSOP_MODIFY_COBJECT(fscp, dcp, cr); 4068 mutex_exit(&dcp->c_statelock); 4069 4070 out: 4071 rw_exit(&dcp->c_rwlock); 4072 if (tvp) 4073 VN_RELE(tvp); 4074 4075 return (error); 4076 } 4077 4078 static int 4079 cachefs_create_disconnected(vnode_t *dvp, char *nm, vattr_t *vap, 4080 enum vcexcl exclusive, int mode, vnode_t **vpp, cred_t *cr) 4081 { 4082 cnode_t *dcp = VTOC(dvp); 4083 cnode_t *cp; 4084 cnode_t *ncp = NULL; 4085 vnode_t *vp; 4086 fscache_t *fscp = C_TO_FSCACHE(dcp); 4087 int error = 0; 4088 struct vattr va; 4089 timestruc_t current_time; 4090 off_t commit = 0; 4091 fid_t cookie; 4092 cfs_cid_t cid; 4093 4094 rw_enter(&dcp->c_rwlock, RW_WRITER); 4095 mutex_enter(&dcp->c_statelock); 4096 4097 /* give up if the directory is not populated */ 4098 if ((dcp->c_metadata.md_flags & MD_POPULATED) == 0) { 4099 mutex_exit(&dcp->c_statelock); 4100 rw_exit(&dcp->c_rwlock); 4101 return (ETIMEDOUT); 4102 } 4103 4104 /* special case if file already exists */ 4105 error = cachefs_dir_look(dcp, nm, &cookie, NULL, NULL, &cid); 4106 if (error == EINVAL) { 4107 mutex_exit(&dcp->c_statelock); 4108 rw_exit(&dcp->c_rwlock); 4109 return (ETIMEDOUT); 4110 } 4111 if (error == 0) { 4112 mutex_exit(&dcp->c_statelock); 4113 rw_exit(&dcp->c_rwlock); 4114 error = cachefs_cnode_make(&cid, fscp, &cookie, NULL, NULL, 4115 cr, 0, &cp); 4116 if (error) { 4117 return (error); 4118 } 4119 vp = CTOV(cp); 4120 4121 if (cp->c_metadata.md_flags & MD_NEEDATTRS) 4122 error = ETIMEDOUT; 4123 else if (exclusive == EXCL) 4124 error = EEXIST; 4125 else if (vp->v_type == VDIR && (mode & VWRITE)) 4126 error = EISDIR; 4127 else { 4128 mutex_enter(&cp->c_statelock); 4129 error = cachefs_access_local(cp, mode, cr); 4130 mutex_exit(&cp->c_statelock); 4131 if (!error) { 4132 if ((vap->va_mask & AT_SIZE) && 4133 (vp->v_type == VREG)) { 4134 vap->va_mask = AT_SIZE; 4135 error = cachefs_setattr_common(vp, 4136 vap, 0, cr, NULL); 4137 } 4138 } 4139 } 4140 if (error) { 4141 VN_RELE(vp); 4142 } else 4143 *vpp = vp; 4144 return (error); 4145 } 4146 4147 /* give up if cannot modify the cache */ 4148 if (CFS_ISFS_WRITE_AROUND(fscp)) { 4149 mutex_exit(&dcp->c_statelock); 4150 error = ETIMEDOUT; 4151 goto out; 4152 } 4153 4154 /* check access */ 4155 if (error = cachefs_access_local(dcp, VWRITE, cr)) { 4156 mutex_exit(&dcp->c_statelock); 4157 goto out; 4158 } 4159 4160 /* mark dir as modified */ 4161 cachefs_modified(dcp); 4162 mutex_exit(&dcp->c_statelock); 4163 4164 /* must be privileged to set sticky bit */ 4165 if ((vap->va_mode & VSVTX) && secpolicy_vnode_stky_modify(cr) != 0) 4166 vap->va_mode &= ~VSVTX; 4167 4168 /* make up a reasonable set of attributes */ 4169 cachefs_attr_setup(vap, &va, dcp, cr); 4170 4171 /* create the cnode */ 4172 error = cachefs_cnode_create(fscp, &va, 0, &ncp); 4173 if (error) 4174 goto out; 4175 4176 mutex_enter(&ncp->c_statelock); 4177 4178 /* get the front file now instead of later */ 4179 if (vap->va_type == VREG) { 4180 error = cachefs_getfrontfile(ncp); 4181 if (error) { 4182 mutex_exit(&ncp->c_statelock); 4183 goto out; 4184 } 4185 ASSERT(ncp->c_frontvp != NULL); 4186 ASSERT((ncp->c_flags & CN_ALLOC_PENDING) == 0); 4187 ncp->c_metadata.md_flags |= MD_POPULATED; 4188 } else { 4189 ASSERT(ncp->c_flags & CN_ALLOC_PENDING); 4190 if (ncp->c_filegrp->fg_flags & CFS_FG_ALLOC_ATTR) { 4191 (void) filegrp_allocattr(ncp->c_filegrp); 4192 } 4193 error = filegrp_create_metadata(ncp->c_filegrp, 4194 &ncp->c_metadata, &ncp->c_id); 4195 if (error) { 4196 mutex_exit(&ncp->c_statelock); 4197 goto out; 4198 } 4199 ncp->c_flags &= ~CN_ALLOC_PENDING; 4200 } 4201 mutex_enter(&dcp->c_statelock); 4202 cachefs_creategid(dcp, ncp, vap, cr); 4203 cachefs_createacl(dcp, ncp); 4204 mutex_exit(&dcp->c_statelock); 4205 4206 /* set times on the file */ 4207 gethrestime(¤t_time); 4208 ncp->c_metadata.md_vattr.va_atime = current_time; 4209 ncp->c_metadata.md_localctime = current_time; 4210 ncp->c_metadata.md_localmtime = current_time; 4211 ncp->c_metadata.md_flags |= MD_LOCALMTIME | MD_LOCALCTIME; 4212 4213 /* reserve space for the daemon cid mapping */ 4214 error = cachefs_dlog_cidmap(fscp); 4215 if (error) { 4216 mutex_exit(&ncp->c_statelock); 4217 goto out; 4218 } 4219 ncp->c_metadata.md_flags |= MD_MAPPING; 4220 4221 /* mark the new file as modified */ 4222 if (cachefs_modified_alloc(ncp)) { 4223 mutex_exit(&ncp->c_statelock); 4224 error = ENOSPC; 4225 goto out; 4226 } 4227 ncp->c_flags |= CN_UPDATED; 4228 4229 /* 4230 * write the metadata now rather than waiting until 4231 * inactive so that if there's no space we can let 4232 * the caller know. 4233 */ 4234 ASSERT((ncp->c_flags & CN_ALLOC_PENDING) == 0); 4235 ASSERT((ncp->c_filegrp->fg_flags & CFS_FG_ALLOC_ATTR) == 0); 4236 error = filegrp_write_metadata(ncp->c_filegrp, 4237 &ncp->c_id, &ncp->c_metadata); 4238 if (error) { 4239 mutex_exit(&ncp->c_statelock); 4240 goto out; 4241 } 4242 4243 /* log the operation */ 4244 commit = cachefs_dlog_create(fscp, dcp, nm, vap, exclusive, 4245 mode, ncp, 0, cr); 4246 if (commit == 0) { 4247 mutex_exit(&ncp->c_statelock); 4248 error = ENOSPC; 4249 goto out; 4250 } 4251 4252 mutex_exit(&ncp->c_statelock); 4253 4254 mutex_enter(&dcp->c_statelock); 4255 4256 /* update parent dir times */ 4257 dcp->c_metadata.md_localmtime = current_time; 4258 dcp->c_metadata.md_flags |= MD_LOCALMTIME; 4259 dcp->c_flags |= CN_UPDATED; 4260 4261 /* enter new file name in the parent directory */ 4262 if (dcp->c_metadata.md_flags & MD_POPULATED) { 4263 error = cachefs_dir_enter(dcp, nm, &ncp->c_cookie, 4264 &ncp->c_id, 0); 4265 if (error) { 4266 cachefs_nocache(dcp); 4267 mutex_exit(&dcp->c_statelock); 4268 error = ETIMEDOUT; 4269 goto out; 4270 } 4271 dnlc_enter(dvp, nm, CTOV(ncp)); 4272 } else { 4273 mutex_exit(&dcp->c_statelock); 4274 error = ETIMEDOUT; 4275 goto out; 4276 } 4277 mutex_exit(&dcp->c_statelock); 4278 4279 out: 4280 rw_exit(&dcp->c_rwlock); 4281 4282 if (commit) { 4283 if (cachefs_dlog_commit(fscp, commit, error)) { 4284 /*EMPTY*/ 4285 /* XXX bob: fix on panic */ 4286 } 4287 } 4288 if (error) { 4289 /* destroy the cnode we created */ 4290 if (ncp) { 4291 mutex_enter(&ncp->c_statelock); 4292 ncp->c_flags |= CN_DESTROY; 4293 mutex_exit(&ncp->c_statelock); 4294 VN_RELE(CTOV(ncp)); 4295 } 4296 } else { 4297 *vpp = CTOV(ncp); 4298 } 4299 return (error); 4300 } 4301 4302 /*ARGSUSED*/ 4303 static int 4304 cachefs_remove(vnode_t *dvp, char *nm, cred_t *cr, caller_context_t *ct, 4305 int flags) 4306 { 4307 cnode_t *dcp = VTOC(dvp); 4308 fscache_t *fscp = C_TO_FSCACHE(dcp); 4309 cachefscache_t *cachep = fscp->fs_cache; 4310 int error = 0; 4311 int held = 0; 4312 int connected = 0; 4313 size_t namlen; 4314 vnode_t *vp = NULL; 4315 int vfslock = 0; 4316 4317 #ifdef CFSDEBUG 4318 CFS_DEBUG(CFSDEBUG_VOPS) 4319 printf("cachefs_remove: ENTER dvp %p name %s\n", 4320 (void *)dvp, nm); 4321 #endif 4322 if (getzoneid() != GLOBAL_ZONEID) { 4323 error = EPERM; 4324 goto out; 4325 } 4326 4327 if (fscp->fs_cache->c_flags & (CACHE_NOFILL | CACHE_NOCACHE)) 4328 ASSERT(dcp->c_flags & CN_NOCACHE); 4329 4330 /* 4331 * Cachefs only provides pass-through support for NFSv4, 4332 * and all vnode operations are passed through to the 4333 * back file system. For NFSv4 pass-through to work, only 4334 * connected operation is supported, the cnode backvp must 4335 * exist, and cachefs optional (eg., disconnectable) flags 4336 * are turned off. Assert these conditions to ensure that 4337 * the backfilesystem is called for the remove operation. 4338 */ 4339 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 4340 CFS_BACKFS_NFSV4_ASSERT_CNODE(dcp); 4341 4342 for (;;) { 4343 if (vfslock) { 4344 vn_vfsunlock(vp); 4345 vfslock = 0; 4346 } 4347 if (vp) { 4348 VN_RELE(vp); 4349 vp = NULL; 4350 } 4351 4352 /* get (or renew) access to the file system */ 4353 if (held) { 4354 /* Won't loop with NFSv4 connected behavior */ 4355 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 4356 cachefs_cd_release(fscp); 4357 held = 0; 4358 } 4359 error = cachefs_cd_access(fscp, connected, 1); 4360 if (error) 4361 break; 4362 held = 1; 4363 4364 /* if disconnected, do some extra error checking */ 4365 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 4366 /* check permissions */ 4367 mutex_enter(&dcp->c_statelock); 4368 error = cachefs_access_local(dcp, (VEXEC|VWRITE), cr); 4369 mutex_exit(&dcp->c_statelock); 4370 if (CFS_TIMEOUT(fscp, error)) { 4371 connected = 1; 4372 continue; 4373 } 4374 if (error) 4375 break; 4376 4377 namlen = strlen(nm); 4378 if (namlen == 0) { 4379 error = EINVAL; 4380 break; 4381 } 4382 4383 /* cannot remove . and .. */ 4384 if (nm[0] == '.') { 4385 if (namlen == 1) { 4386 error = EINVAL; 4387 break; 4388 } else if (namlen == 2 && nm[1] == '.') { 4389 error = EEXIST; 4390 break; 4391 } 4392 } 4393 4394 } 4395 4396 /* get the cnode of the file to delete */ 4397 error = cachefs_lookup_common(dvp, nm, &vp, NULL, 0, NULL, cr); 4398 if (error) { 4399 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 4400 if (CFS_TIMEOUT(fscp, error)) { 4401 cachefs_cd_release(fscp); 4402 held = 0; 4403 cachefs_cd_timedout(fscp); 4404 connected = 0; 4405 continue; 4406 } 4407 } else { 4408 if (CFS_TIMEOUT(fscp, error)) { 4409 connected = 1; 4410 continue; 4411 } 4412 } 4413 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_REMOVE)) { 4414 struct fid foo; 4415 4416 bzero(&foo, sizeof (foo)); 4417 cachefs_log_remove(cachep, error, 4418 fscp->fs_cfsvfsp, &foo, 0, crgetuid(cr)); 4419 } 4420 break; 4421 } 4422 4423 if (vp->v_type == VDIR) { 4424 /* must be privileged to remove dirs with unlink() */ 4425 if ((error = secpolicy_fs_linkdir(cr, vp->v_vfsp)) != 0) 4426 break; 4427 4428 /* see ufs_dirremove for why this is done, mount race */ 4429 if (vn_vfswlock(vp)) { 4430 error = EBUSY; 4431 break; 4432 } 4433 vfslock = 1; 4434 if (vn_mountedvfs(vp) != NULL) { 4435 error = EBUSY; 4436 break; 4437 } 4438 } 4439 4440 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 4441 error = cachefs_remove_connected(dvp, nm, cr, vp); 4442 if (CFS_TIMEOUT(fscp, error)) { 4443 cachefs_cd_release(fscp); 4444 held = 0; 4445 cachefs_cd_timedout(fscp); 4446 connected = 0; 4447 continue; 4448 } 4449 } else { 4450 error = cachefs_remove_disconnected(dvp, nm, cr, 4451 vp); 4452 if (CFS_TIMEOUT(fscp, error)) { 4453 connected = 1; 4454 continue; 4455 } 4456 } 4457 break; 4458 } 4459 4460 #if 0 4461 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_REMOVE)) 4462 cachefs_log_remove(cachep, error, fscp->fs_cfsvfsp, 4463 &cp->c_metadata.md_cookie, cp->c_id.cid_fileno, 4464 crgetuid(cr)); 4465 #endif 4466 4467 if (held) 4468 cachefs_cd_release(fscp); 4469 4470 if (vfslock) 4471 vn_vfsunlock(vp); 4472 4473 if (vp) 4474 VN_RELE(vp); 4475 4476 #ifdef CFS_CD_DEBUG 4477 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 4478 #endif 4479 out: 4480 #ifdef CFSDEBUG 4481 CFS_DEBUG(CFSDEBUG_VOPS) 4482 printf("cachefs_remove: EXIT dvp %p\n", (void *)dvp); 4483 #endif 4484 4485 return (error); 4486 } 4487 4488 int 4489 cachefs_remove_connected(vnode_t *dvp, char *nm, cred_t *cr, vnode_t *vp) 4490 { 4491 cnode_t *dcp = VTOC(dvp); 4492 cnode_t *cp = VTOC(vp); 4493 fscache_t *fscp = C_TO_FSCACHE(dcp); 4494 int error = 0; 4495 4496 /* 4497 * Acquire the rwlock (WRITER) on the directory to prevent other 4498 * activity on the directory. 4499 */ 4500 rw_enter(&dcp->c_rwlock, RW_WRITER); 4501 4502 /* purge dnlc of this entry so can get accurate vnode count */ 4503 dnlc_purge_vp(vp); 4504 4505 /* 4506 * If the cnode is active, make a link to the file 4507 * so operations on the file will continue. 4508 */ 4509 if ((vp->v_type != VDIR) && 4510 !((vp->v_count == 1) || ((vp->v_count == 2) && cp->c_ipending))) { 4511 error = cachefs_remove_dolink(dvp, vp, nm, cr); 4512 if (error) 4513 goto out; 4514 } 4515 4516 /* else call backfs NFSv4 handler if NFSv4 */ 4517 else if (CFS_ISFS_BACKFS_NFSV4(fscp)) { 4518 error = cachefs_remove_backfs_nfsv4(dvp, nm, cr, vp); 4519 goto out; 4520 } 4521 4522 /* else drop the backvp so nfs does not do rename */ 4523 else if (cp->c_backvp) { 4524 mutex_enter(&cp->c_statelock); 4525 if (cp->c_backvp) { 4526 VN_RELE(cp->c_backvp); 4527 cp->c_backvp = NULL; 4528 } 4529 mutex_exit(&cp->c_statelock); 4530 } 4531 4532 mutex_enter(&dcp->c_statelock); 4533 4534 /* get the backvp */ 4535 if (dcp->c_backvp == NULL) { 4536 error = cachefs_getbackvp(fscp, dcp); 4537 if (error) { 4538 mutex_exit(&dcp->c_statelock); 4539 goto out; 4540 } 4541 } 4542 4543 /* check directory consistency */ 4544 error = CFSOP_CHECK_COBJECT(fscp, dcp, 0, cr); 4545 if (error) { 4546 mutex_exit(&dcp->c_statelock); 4547 goto out; 4548 } 4549 4550 /* perform the remove on the back fs */ 4551 error = VOP_REMOVE(dcp->c_backvp, nm, cr, NULL, 0); 4552 if (error) { 4553 mutex_exit(&dcp->c_statelock); 4554 goto out; 4555 } 4556 4557 /* the dir has been modified */ 4558 CFSOP_MODIFY_COBJECT(fscp, dcp, cr); 4559 4560 /* remove the entry from the populated directory */ 4561 if (CFS_ISFS_NONSHARED(fscp) && 4562 (dcp->c_metadata.md_flags & MD_POPULATED)) { 4563 error = cachefs_dir_rmentry(dcp, nm); 4564 if (error) { 4565 cachefs_nocache(dcp); 4566 error = 0; 4567 } 4568 } 4569 mutex_exit(&dcp->c_statelock); 4570 4571 /* fix up the file we deleted */ 4572 mutex_enter(&cp->c_statelock); 4573 if (cp->c_attr.va_nlink == 1) 4574 cp->c_flags |= CN_DESTROY; 4575 else 4576 cp->c_flags |= CN_UPDATED; 4577 4578 cp->c_attr.va_nlink--; 4579 CFSOP_MODIFY_COBJECT(fscp, cp, cr); 4580 mutex_exit(&cp->c_statelock); 4581 4582 out: 4583 rw_exit(&dcp->c_rwlock); 4584 return (error); 4585 } 4586 4587 /* 4588 * cachefs_remove_backfs_nfsv4 4589 * 4590 * Call NFSv4 back filesystem to handle the remove (cachefs 4591 * pass-through support for NFSv4). 4592 */ 4593 int 4594 cachefs_remove_backfs_nfsv4(vnode_t *dvp, char *nm, cred_t *cr, vnode_t *vp) 4595 { 4596 cnode_t *dcp = VTOC(dvp); 4597 cnode_t *cp = VTOC(vp); 4598 vnode_t *dbackvp; 4599 fscache_t *fscp = C_TO_FSCACHE(dcp); 4600 int error = 0; 4601 4602 /* 4603 * For NFSv4 pass-through to work, only connected operation 4604 * is supported, the cnode backvp must exist, and cachefs 4605 * optional (eg., disconnectable) flags are turned off. Assert 4606 * these conditions for the getattr operation. 4607 */ 4608 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 4609 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 4610 4611 /* Should hold the directory readwrite lock to update directory */ 4612 ASSERT(RW_WRITE_HELD(&dcp->c_rwlock)); 4613 4614 /* 4615 * Update attributes for directory. Note that 4616 * CFSOP_CHECK_COBJECT asserts for c_statelock being 4617 * held, so grab it before calling the routine. 4618 */ 4619 mutex_enter(&dcp->c_statelock); 4620 error = CFSOP_CHECK_COBJECT(fscp, dcp, 0, cr); 4621 mutex_exit(&dcp->c_statelock); 4622 if (error) 4623 goto out; 4624 4625 /* 4626 * Update attributes for cp. Note that CFSOP_CHECK_COBJECT 4627 * asserts for c_statelock being held, so grab it before 4628 * calling the routine. 4629 */ 4630 mutex_enter(&cp->c_statelock); 4631 error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr); 4632 if (error) { 4633 mutex_exit(&cp->c_statelock); 4634 goto out; 4635 } 4636 4637 /* 4638 * Drop the backvp so nfs if the link count is 1 so that 4639 * nfs does not do rename. Ensure that we will destroy the cnode 4640 * since this cnode no longer contains the backvp. Note that we 4641 * maintain lock on this cnode to prevent change till the remove 4642 * completes, otherwise other operations will encounter an ESTALE 4643 * if they try to use the cnode with CN_DESTROY set (see 4644 * cachefs_get_backvp()), or change the state of the cnode 4645 * while we're removing it. 4646 */ 4647 if (cp->c_attr.va_nlink == 1) { 4648 /* 4649 * The unldvp information is created for the case 4650 * when there is more than one reference on the 4651 * vnode when a remove operation is called. If the 4652 * remove itself was holding a reference to the 4653 * vnode, then a subsequent remove will remove the 4654 * backvp, so we need to get rid of the unldvp 4655 * before removing the backvp. An alternate would 4656 * be to simply ignore the remove and let the 4657 * inactivation routine do the deletion of the 4658 * unldvp. 4659 */ 4660 if (cp->c_unldvp) { 4661 VN_RELE(cp->c_unldvp); 4662 cachefs_kmem_free(cp->c_unlname, MAXNAMELEN); 4663 crfree(cp->c_unlcred); 4664 cp->c_unldvp = NULL; 4665 cp->c_unlcred = NULL; 4666 } 4667 cp->c_flags |= CN_DESTROY; 4668 cp->c_attr.va_nlink = 0; 4669 VN_RELE(cp->c_backvp); 4670 cp->c_backvp = NULL; 4671 } 4672 4673 /* perform the remove on back fs after extracting directory backvp */ 4674 mutex_enter(&dcp->c_statelock); 4675 dbackvp = dcp->c_backvp; 4676 mutex_exit(&dcp->c_statelock); 4677 4678 CFS_DPRINT_BACKFS_NFSV4(fscp, 4679 ("cachefs_remove (nfsv4): dcp %p, dbackvp %p, name %s\n", 4680 dcp, dbackvp, nm)); 4681 error = VOP_REMOVE(dbackvp, nm, cr, NULL, 0); 4682 if (error) { 4683 mutex_exit(&cp->c_statelock); 4684 goto out; 4685 } 4686 4687 /* fix up the file we deleted, if not destroying the cnode */ 4688 if ((cp->c_flags & CN_DESTROY) == 0) { 4689 cp->c_attr.va_nlink--; 4690 cp->c_flags |= CN_UPDATED; 4691 } 4692 4693 mutex_exit(&cp->c_statelock); 4694 4695 out: 4696 return (error); 4697 } 4698 4699 int 4700 cachefs_remove_disconnected(vnode_t *dvp, char *nm, cred_t *cr, 4701 vnode_t *vp) 4702 { 4703 cnode_t *dcp = VTOC(dvp); 4704 cnode_t *cp = VTOC(vp); 4705 fscache_t *fscp = C_TO_FSCACHE(dcp); 4706 int error = 0; 4707 off_t commit = 0; 4708 timestruc_t current_time; 4709 4710 if (CFS_ISFS_WRITE_AROUND(fscp)) 4711 return (ETIMEDOUT); 4712 4713 if (cp->c_metadata.md_flags & MD_NEEDATTRS) 4714 return (ETIMEDOUT); 4715 4716 /* 4717 * Acquire the rwlock (WRITER) on the directory to prevent other 4718 * activity on the directory. 4719 */ 4720 rw_enter(&dcp->c_rwlock, RW_WRITER); 4721 4722 /* dir must be populated */ 4723 if ((dcp->c_metadata.md_flags & MD_POPULATED) == 0) { 4724 error = ETIMEDOUT; 4725 goto out; 4726 } 4727 4728 mutex_enter(&dcp->c_statelock); 4729 mutex_enter(&cp->c_statelock); 4730 4731 error = cachefs_stickyrmchk(dcp, cp, cr); 4732 4733 mutex_exit(&cp->c_statelock); 4734 mutex_exit(&dcp->c_statelock); 4735 if (error) 4736 goto out; 4737 4738 /* purge dnlc of this entry so can get accurate vnode count */ 4739 dnlc_purge_vp(vp); 4740 4741 /* 4742 * If the cnode is active, make a link to the file 4743 * so operations on the file will continue. 4744 */ 4745 if ((vp->v_type != VDIR) && 4746 !((vp->v_count == 1) || ((vp->v_count == 2) && cp->c_ipending))) { 4747 error = cachefs_remove_dolink(dvp, vp, nm, cr); 4748 if (error) 4749 goto out; 4750 } 4751 4752 if (cp->c_attr.va_nlink > 1) { 4753 mutex_enter(&cp->c_statelock); 4754 if (cachefs_modified_alloc(cp)) { 4755 mutex_exit(&cp->c_statelock); 4756 error = ENOSPC; 4757 goto out; 4758 } 4759 if ((cp->c_metadata.md_flags & MD_MAPPING) == 0) { 4760 error = cachefs_dlog_cidmap(fscp); 4761 if (error) { 4762 mutex_exit(&cp->c_statelock); 4763 error = ENOSPC; 4764 goto out; 4765 } 4766 cp->c_metadata.md_flags |= MD_MAPPING; 4767 cp->c_flags |= CN_UPDATED; 4768 } 4769 mutex_exit(&cp->c_statelock); 4770 } 4771 4772 /* log the remove */ 4773 commit = cachefs_dlog_remove(fscp, dcp, nm, cp, cr); 4774 if (commit == 0) { 4775 error = ENOSPC; 4776 goto out; 4777 } 4778 4779 /* remove the file from the dir */ 4780 mutex_enter(&dcp->c_statelock); 4781 if ((dcp->c_metadata.md_flags & MD_POPULATED) == 0) { 4782 mutex_exit(&dcp->c_statelock); 4783 error = ETIMEDOUT; 4784 goto out; 4785 4786 } 4787 cachefs_modified(dcp); 4788 error = cachefs_dir_rmentry(dcp, nm); 4789 if (error) { 4790 mutex_exit(&dcp->c_statelock); 4791 if (error == ENOTDIR) 4792 error = ETIMEDOUT; 4793 goto out; 4794 } 4795 4796 /* update parent dir times */ 4797 gethrestime(¤t_time); 4798 dcp->c_metadata.md_localctime = current_time; 4799 dcp->c_metadata.md_localmtime = current_time; 4800 dcp->c_metadata.md_flags |= MD_LOCALCTIME | MD_LOCALMTIME; 4801 dcp->c_flags |= CN_UPDATED; 4802 mutex_exit(&dcp->c_statelock); 4803 4804 /* adjust file we are deleting */ 4805 mutex_enter(&cp->c_statelock); 4806 cp->c_attr.va_nlink--; 4807 cp->c_metadata.md_localctime = current_time; 4808 cp->c_metadata.md_flags |= MD_LOCALCTIME; 4809 if (cp->c_attr.va_nlink == 0) { 4810 cp->c_flags |= CN_DESTROY; 4811 } else { 4812 cp->c_flags |= CN_UPDATED; 4813 } 4814 mutex_exit(&cp->c_statelock); 4815 4816 out: 4817 if (commit) { 4818 /* commit the log entry */ 4819 if (cachefs_dlog_commit(fscp, commit, error)) { 4820 /*EMPTY*/ 4821 /* XXX bob: fix on panic */ 4822 } 4823 } 4824 4825 rw_exit(&dcp->c_rwlock); 4826 return (error); 4827 } 4828 4829 /*ARGSUSED*/ 4830 static int 4831 cachefs_link(vnode_t *tdvp, vnode_t *fvp, char *tnm, cred_t *cr, 4832 caller_context_t *ct, int flags) 4833 { 4834 fscache_t *fscp = VFS_TO_FSCACHE(tdvp->v_vfsp); 4835 cnode_t *tdcp = VTOC(tdvp); 4836 struct vnode *realvp; 4837 int error = 0; 4838 int held = 0; 4839 int connected = 0; 4840 4841 #ifdef CFSDEBUG 4842 CFS_DEBUG(CFSDEBUG_VOPS) 4843 printf("cachefs_link: ENTER fvp %p tdvp %p tnm %s\n", 4844 (void *)fvp, (void *)tdvp, tnm); 4845 #endif 4846 4847 if (getzoneid() != GLOBAL_ZONEID) { 4848 error = EPERM; 4849 goto out; 4850 } 4851 4852 if (fscp->fs_cache->c_flags & (CACHE_NOFILL | CACHE_NOCACHE)) 4853 ASSERT(tdcp->c_flags & CN_NOCACHE); 4854 4855 if (VOP_REALVP(fvp, &realvp, ct) == 0) { 4856 fvp = realvp; 4857 } 4858 4859 /* 4860 * Cachefs only provides pass-through support for NFSv4, 4861 * and all vnode operations are passed through to the 4862 * back file system. For NFSv4 pass-through to work, only 4863 * connected operation is supported, the cnode backvp must 4864 * exist, and cachefs optional (eg., disconnectable) flags 4865 * are turned off. Assert these conditions to ensure that 4866 * the backfilesystem is called for the link operation. 4867 */ 4868 4869 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 4870 CFS_BACKFS_NFSV4_ASSERT_CNODE(tdcp); 4871 4872 for (;;) { 4873 /* get (or renew) access to the file system */ 4874 if (held) { 4875 /* Won't loop with NFSv4 connected behavior */ 4876 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 4877 rw_exit(&tdcp->c_rwlock); 4878 cachefs_cd_release(fscp); 4879 held = 0; 4880 } 4881 error = cachefs_cd_access(fscp, connected, 1); 4882 if (error) 4883 break; 4884 rw_enter(&tdcp->c_rwlock, RW_WRITER); 4885 held = 1; 4886 4887 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 4888 error = cachefs_link_connected(tdvp, fvp, tnm, cr); 4889 if (CFS_TIMEOUT(fscp, error)) { 4890 rw_exit(&tdcp->c_rwlock); 4891 cachefs_cd_release(fscp); 4892 held = 0; 4893 cachefs_cd_timedout(fscp); 4894 connected = 0; 4895 continue; 4896 } 4897 } else { 4898 error = cachefs_link_disconnected(tdvp, fvp, tnm, 4899 cr); 4900 if (CFS_TIMEOUT(fscp, error)) { 4901 connected = 1; 4902 continue; 4903 } 4904 } 4905 break; 4906 } 4907 4908 if (held) { 4909 rw_exit(&tdcp->c_rwlock); 4910 cachefs_cd_release(fscp); 4911 } 4912 4913 #ifdef CFS_CD_DEBUG 4914 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 4915 #endif 4916 out: 4917 #ifdef CFSDEBUG 4918 CFS_DEBUG(CFSDEBUG_VOPS) 4919 printf("cachefs_link: EXIT fvp %p tdvp %p tnm %s\n", 4920 (void *)fvp, (void *)tdvp, tnm); 4921 #endif 4922 return (error); 4923 } 4924 4925 static int 4926 cachefs_link_connected(vnode_t *tdvp, vnode_t *fvp, char *tnm, cred_t *cr) 4927 { 4928 cnode_t *tdcp = VTOC(tdvp); 4929 cnode_t *fcp = VTOC(fvp); 4930 fscache_t *fscp = VFS_TO_FSCACHE(tdvp->v_vfsp); 4931 int error = 0; 4932 vnode_t *backvp = NULL; 4933 4934 if (tdcp != fcp) { 4935 mutex_enter(&fcp->c_statelock); 4936 4937 if (fcp->c_backvp == NULL) { 4938 error = cachefs_getbackvp(fscp, fcp); 4939 if (error) { 4940 mutex_exit(&fcp->c_statelock); 4941 goto out; 4942 } 4943 } 4944 4945 error = CFSOP_CHECK_COBJECT(fscp, fcp, 0, cr); 4946 if (error) { 4947 mutex_exit(&fcp->c_statelock); 4948 goto out; 4949 } 4950 backvp = fcp->c_backvp; 4951 VN_HOLD(backvp); 4952 mutex_exit(&fcp->c_statelock); 4953 } 4954 4955 mutex_enter(&tdcp->c_statelock); 4956 4957 /* get backvp of target directory */ 4958 if (tdcp->c_backvp == NULL) { 4959 error = cachefs_getbackvp(fscp, tdcp); 4960 if (error) { 4961 mutex_exit(&tdcp->c_statelock); 4962 goto out; 4963 } 4964 } 4965 4966 /* consistency check target directory */ 4967 error = CFSOP_CHECK_COBJECT(fscp, tdcp, 0, cr); 4968 if (error) { 4969 mutex_exit(&tdcp->c_statelock); 4970 goto out; 4971 } 4972 if (backvp == NULL) { 4973 backvp = tdcp->c_backvp; 4974 VN_HOLD(backvp); 4975 } 4976 4977 /* perform the link on the back fs */ 4978 CFS_DPRINT_BACKFS_NFSV4(fscp, 4979 ("cachefs_link (nfsv4): tdcp %p, tdbackvp %p, " 4980 "name %s\n", tdcp, tdcp->c_backvp, tnm)); 4981 error = VOP_LINK(tdcp->c_backvp, backvp, tnm, cr, NULL, 0); 4982 if (error) { 4983 mutex_exit(&tdcp->c_statelock); 4984 goto out; 4985 } 4986 4987 CFSOP_MODIFY_COBJECT(fscp, tdcp, cr); 4988 4989 /* if the dir is populated, add the new link */ 4990 if (CFS_ISFS_NONSHARED(fscp) && 4991 (tdcp->c_metadata.md_flags & MD_POPULATED)) { 4992 error = cachefs_dir_enter(tdcp, tnm, &fcp->c_cookie, 4993 &fcp->c_id, SM_ASYNC); 4994 if (error) { 4995 cachefs_nocache(tdcp); 4996 error = 0; 4997 } 4998 } 4999 mutex_exit(&tdcp->c_statelock); 5000 5001 /* get the new link count on the file */ 5002 mutex_enter(&fcp->c_statelock); 5003 fcp->c_flags |= CN_UPDATED; 5004 CFSOP_MODIFY_COBJECT(fscp, fcp, cr); 5005 if (fcp->c_backvp == NULL) { 5006 error = cachefs_getbackvp(fscp, fcp); 5007 if (error) { 5008 mutex_exit(&fcp->c_statelock); 5009 goto out; 5010 } 5011 } 5012 5013 /* XXX bob: given what modify_cobject does this seems unnecessary */ 5014 fcp->c_attr.va_mask = AT_ALL; 5015 error = VOP_GETATTR(fcp->c_backvp, &fcp->c_attr, 0, cr, NULL); 5016 mutex_exit(&fcp->c_statelock); 5017 out: 5018 if (backvp) 5019 VN_RELE(backvp); 5020 5021 return (error); 5022 } 5023 5024 static int 5025 cachefs_link_disconnected(vnode_t *tdvp, vnode_t *fvp, char *tnm, 5026 cred_t *cr) 5027 { 5028 cnode_t *tdcp = VTOC(tdvp); 5029 cnode_t *fcp = VTOC(fvp); 5030 fscache_t *fscp = VFS_TO_FSCACHE(tdvp->v_vfsp); 5031 int error = 0; 5032 timestruc_t current_time; 5033 off_t commit = 0; 5034 5035 if (fvp->v_type == VDIR && secpolicy_fs_linkdir(cr, fvp->v_vfsp) != 0 || 5036 fcp->c_attr.va_uid != crgetuid(cr) && secpolicy_basic_link(cr) != 0) 5037 return (EPERM); 5038 5039 if (CFS_ISFS_WRITE_AROUND(fscp)) 5040 return (ETIMEDOUT); 5041 5042 if (fcp->c_metadata.md_flags & MD_NEEDATTRS) 5043 return (ETIMEDOUT); 5044 5045 mutex_enter(&tdcp->c_statelock); 5046 5047 /* check permissions */ 5048 if (error = cachefs_access_local(tdcp, (VEXEC|VWRITE), cr)) { 5049 mutex_exit(&tdcp->c_statelock); 5050 goto out; 5051 } 5052 5053 /* the directory front file must be populated */ 5054 if ((tdcp->c_metadata.md_flags & MD_POPULATED) == 0) { 5055 error = ETIMEDOUT; 5056 mutex_exit(&tdcp->c_statelock); 5057 goto out; 5058 } 5059 5060 /* make sure tnm does not already exist in the directory */ 5061 error = cachefs_dir_look(tdcp, tnm, NULL, NULL, NULL, NULL); 5062 if (error == ENOTDIR) { 5063 error = ETIMEDOUT; 5064 mutex_exit(&tdcp->c_statelock); 5065 goto out; 5066 } 5067 if (error != ENOENT) { 5068 error = EEXIST; 5069 mutex_exit(&tdcp->c_statelock); 5070 goto out; 5071 } 5072 5073 mutex_enter(&fcp->c_statelock); 5074 5075 /* create a mapping for the file if necessary */ 5076 if ((fcp->c_metadata.md_flags & MD_MAPPING) == 0) { 5077 error = cachefs_dlog_cidmap(fscp); 5078 if (error) { 5079 mutex_exit(&fcp->c_statelock); 5080 mutex_exit(&tdcp->c_statelock); 5081 error = ENOSPC; 5082 goto out; 5083 } 5084 fcp->c_metadata.md_flags |= MD_MAPPING; 5085 fcp->c_flags |= CN_UPDATED; 5086 } 5087 5088 /* mark file as modified */ 5089 if (cachefs_modified_alloc(fcp)) { 5090 mutex_exit(&fcp->c_statelock); 5091 mutex_exit(&tdcp->c_statelock); 5092 error = ENOSPC; 5093 goto out; 5094 } 5095 mutex_exit(&fcp->c_statelock); 5096 5097 /* log the operation */ 5098 commit = cachefs_dlog_link(fscp, tdcp, tnm, fcp, cr); 5099 if (commit == 0) { 5100 mutex_exit(&tdcp->c_statelock); 5101 error = ENOSPC; 5102 goto out; 5103 } 5104 5105 gethrestime(¤t_time); 5106 5107 /* make the new link */ 5108 cachefs_modified(tdcp); 5109 error = cachefs_dir_enter(tdcp, tnm, &fcp->c_cookie, 5110 &fcp->c_id, SM_ASYNC); 5111 if (error) { 5112 error = 0; 5113 mutex_exit(&tdcp->c_statelock); 5114 goto out; 5115 } 5116 5117 /* Update mtime/ctime of parent dir */ 5118 tdcp->c_metadata.md_localmtime = current_time; 5119 tdcp->c_metadata.md_localctime = current_time; 5120 tdcp->c_metadata.md_flags |= MD_LOCALCTIME | MD_LOCALMTIME; 5121 tdcp->c_flags |= CN_UPDATED; 5122 mutex_exit(&tdcp->c_statelock); 5123 5124 /* update the file we linked to */ 5125 mutex_enter(&fcp->c_statelock); 5126 fcp->c_attr.va_nlink++; 5127 fcp->c_metadata.md_localctime = current_time; 5128 fcp->c_metadata.md_flags |= MD_LOCALCTIME; 5129 fcp->c_flags |= CN_UPDATED; 5130 mutex_exit(&fcp->c_statelock); 5131 5132 out: 5133 if (commit) { 5134 /* commit the log entry */ 5135 if (cachefs_dlog_commit(fscp, commit, error)) { 5136 /*EMPTY*/ 5137 /* XXX bob: fix on panic */ 5138 } 5139 } 5140 5141 return (error); 5142 } 5143 5144 /* 5145 * Serialize all renames in CFS, to avoid deadlocks - We have to hold two 5146 * cnodes atomically. 5147 */ 5148 kmutex_t cachefs_rename_lock; 5149 5150 /*ARGSUSED*/ 5151 static int 5152 cachefs_rename(vnode_t *odvp, char *onm, vnode_t *ndvp, 5153 char *nnm, cred_t *cr, caller_context_t *ct, int flags) 5154 { 5155 fscache_t *fscp = C_TO_FSCACHE(VTOC(odvp)); 5156 cachefscache_t *cachep = fscp->fs_cache; 5157 int error = 0; 5158 int held = 0; 5159 int connected = 0; 5160 vnode_t *delvp = NULL; 5161 vnode_t *tvp = NULL; 5162 int vfslock = 0; 5163 struct vnode *realvp; 5164 5165 if (getzoneid() != GLOBAL_ZONEID) 5166 return (EPERM); 5167 5168 if (VOP_REALVP(ndvp, &realvp, ct) == 0) 5169 ndvp = realvp; 5170 5171 /* 5172 * if the fs NOFILL or NOCACHE flags are on, then the old and new 5173 * directory cnodes better indicate NOCACHE mode as well. 5174 */ 5175 ASSERT( 5176 (fscp->fs_cache->c_flags & (CACHE_NOFILL | CACHE_NOCACHE)) == 0 || 5177 ((VTOC(odvp)->c_flags & CN_NOCACHE) && 5178 (VTOC(ndvp)->c_flags & CN_NOCACHE))); 5179 5180 /* 5181 * Cachefs only provides pass-through support for NFSv4, 5182 * and all vnode operations are passed through to the 5183 * back file system. For NFSv4 pass-through to work, only 5184 * connected operation is supported, the cnode backvp must 5185 * exist, and cachefs optional (eg., disconnectable) flags 5186 * are turned off. Assert these conditions to ensure that 5187 * the backfilesystem is called for the rename operation. 5188 */ 5189 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 5190 CFS_BACKFS_NFSV4_ASSERT_CNODE(VTOC(odvp)); 5191 CFS_BACKFS_NFSV4_ASSERT_CNODE(VTOC(ndvp)); 5192 5193 for (;;) { 5194 if (vfslock) { 5195 vn_vfsunlock(delvp); 5196 vfslock = 0; 5197 } 5198 if (delvp) { 5199 VN_RELE(delvp); 5200 delvp = NULL; 5201 } 5202 5203 /* get (or renew) access to the file system */ 5204 if (held) { 5205 /* Won't loop for NFSv4 connected support */ 5206 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 5207 cachefs_cd_release(fscp); 5208 held = 0; 5209 } 5210 error = cachefs_cd_access(fscp, connected, 1); 5211 if (error) 5212 break; 5213 held = 1; 5214 5215 /* sanity check */ 5216 if ((odvp->v_type != VDIR) || (ndvp->v_type != VDIR)) { 5217 error = EINVAL; 5218 break; 5219 } 5220 5221 /* cannot rename from or to . or .. */ 5222 if (strcmp(onm, ".") == 0 || strcmp(onm, "..") == 0 || 5223 strcmp(nnm, ".") == 0 || strcmp(nnm, "..") == 0) { 5224 error = EINVAL; 5225 break; 5226 } 5227 5228 if (odvp != ndvp) { 5229 /* 5230 * if moving a directory, its notion 5231 * of ".." will change 5232 */ 5233 error = cachefs_lookup_common(odvp, onm, &tvp, 5234 NULL, 0, NULL, cr); 5235 if (error == 0) { 5236 ASSERT(tvp != NULL); 5237 if (tvp->v_type == VDIR) { 5238 cnode_t *cp = VTOC(tvp); 5239 5240 dnlc_remove(tvp, ".."); 5241 5242 mutex_enter(&cp->c_statelock); 5243 CFSOP_MODIFY_COBJECT(fscp, cp, cr); 5244 mutex_exit(&cp->c_statelock); 5245 } 5246 } else { 5247 tvp = NULL; 5248 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 5249 if (CFS_TIMEOUT(fscp, error)) { 5250 cachefs_cd_release(fscp); 5251 held = 0; 5252 cachefs_cd_timedout(fscp); 5253 connected = 0; 5254 continue; 5255 } 5256 } else { 5257 if (CFS_TIMEOUT(fscp, error)) { 5258 connected = 1; 5259 continue; 5260 } 5261 } 5262 break; 5263 } 5264 } 5265 5266 /* get the cnode if file being deleted */ 5267 error = cachefs_lookup_common(ndvp, nnm, &delvp, NULL, 0, 5268 NULL, cr); 5269 if (error) { 5270 delvp = NULL; 5271 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 5272 if (CFS_TIMEOUT(fscp, error)) { 5273 cachefs_cd_release(fscp); 5274 held = 0; 5275 cachefs_cd_timedout(fscp); 5276 connected = 0; 5277 continue; 5278 } 5279 } else { 5280 if (CFS_TIMEOUT(fscp, error)) { 5281 connected = 1; 5282 continue; 5283 } 5284 } 5285 if (error != ENOENT) 5286 break; 5287 } 5288 5289 if (delvp && delvp->v_type == VDIR) { 5290 /* see ufs_dirremove for why this is done, mount race */ 5291 if (vn_vfswlock(delvp)) { 5292 error = EBUSY; 5293 break; 5294 } 5295 vfslock = 1; 5296 if (vn_mountedvfs(delvp) != NULL) { 5297 error = EBUSY; 5298 break; 5299 } 5300 } 5301 5302 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 5303 error = cachefs_rename_connected(odvp, onm, 5304 ndvp, nnm, cr, delvp); 5305 if (CFS_TIMEOUT(fscp, error)) { 5306 cachefs_cd_release(fscp); 5307 held = 0; 5308 cachefs_cd_timedout(fscp); 5309 connected = 0; 5310 continue; 5311 } 5312 } else { 5313 error = cachefs_rename_disconnected(odvp, onm, 5314 ndvp, nnm, cr, delvp); 5315 if (CFS_TIMEOUT(fscp, error)) { 5316 connected = 1; 5317 continue; 5318 } 5319 } 5320 break; 5321 } 5322 5323 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_RENAME)) { 5324 struct fid gone; 5325 5326 bzero(&gone, sizeof (gone)); 5327 gone.fid_len = MAXFIDSZ; 5328 if (delvp != NULL) 5329 (void) VOP_FID(delvp, &gone, ct); 5330 5331 cachefs_log_rename(cachep, error, fscp->fs_cfsvfsp, 5332 &gone, 0, (delvp != NULL), crgetuid(cr)); 5333 } 5334 5335 if (held) 5336 cachefs_cd_release(fscp); 5337 5338 if (vfslock) 5339 vn_vfsunlock(delvp); 5340 5341 if (delvp) 5342 VN_RELE(delvp); 5343 if (tvp) 5344 VN_RELE(tvp); 5345 5346 #ifdef CFS_CD_DEBUG 5347 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 5348 #endif 5349 return (error); 5350 } 5351 5352 static int 5353 cachefs_rename_connected(vnode_t *odvp, char *onm, vnode_t *ndvp, 5354 char *nnm, cred_t *cr, vnode_t *delvp) 5355 { 5356 cnode_t *odcp = VTOC(odvp); 5357 cnode_t *ndcp = VTOC(ndvp); 5358 vnode_t *revp = NULL; 5359 cnode_t *recp; 5360 cnode_t *delcp; 5361 fscache_t *fscp = C_TO_FSCACHE(odcp); 5362 int error = 0; 5363 struct fid cookie; 5364 struct fid *cookiep; 5365 cfs_cid_t cid; 5366 int gotdirent; 5367 5368 /* find the file we are renaming */ 5369 error = cachefs_lookup_common(odvp, onm, &revp, NULL, 0, NULL, cr); 5370 if (error) 5371 return (error); 5372 recp = VTOC(revp); 5373 5374 /* 5375 * To avoid deadlock, we acquire this global rename lock before 5376 * we try to get the locks for the source and target directories. 5377 */ 5378 mutex_enter(&cachefs_rename_lock); 5379 rw_enter(&odcp->c_rwlock, RW_WRITER); 5380 if (odcp != ndcp) { 5381 rw_enter(&ndcp->c_rwlock, RW_WRITER); 5382 } 5383 mutex_exit(&cachefs_rename_lock); 5384 5385 ASSERT((odcp->c_flags & CN_ASYNC_POP_WORKING) == 0); 5386 ASSERT((ndcp->c_flags & CN_ASYNC_POP_WORKING) == 0); 5387 5388 mutex_enter(&odcp->c_statelock); 5389 if (odcp->c_backvp == NULL) { 5390 error = cachefs_getbackvp(fscp, odcp); 5391 if (error) { 5392 mutex_exit(&odcp->c_statelock); 5393 goto out; 5394 } 5395 } 5396 5397 error = CFSOP_CHECK_COBJECT(fscp, odcp, 0, cr); 5398 if (error) { 5399 mutex_exit(&odcp->c_statelock); 5400 goto out; 5401 } 5402 mutex_exit(&odcp->c_statelock); 5403 5404 if (odcp != ndcp) { 5405 mutex_enter(&ndcp->c_statelock); 5406 if (ndcp->c_backvp == NULL) { 5407 error = cachefs_getbackvp(fscp, ndcp); 5408 if (error) { 5409 mutex_exit(&ndcp->c_statelock); 5410 goto out; 5411 } 5412 } 5413 5414 error = CFSOP_CHECK_COBJECT(fscp, ndcp, 0, cr); 5415 if (error) { 5416 mutex_exit(&ndcp->c_statelock); 5417 goto out; 5418 } 5419 mutex_exit(&ndcp->c_statelock); 5420 } 5421 5422 /* if a file is being deleted because of this rename */ 5423 if (delvp) { 5424 /* if src and dest file are same */ 5425 if (delvp == revp) { 5426 error = 0; 5427 goto out; 5428 } 5429 5430 /* 5431 * If the cnode is active, make a link to the file 5432 * so operations on the file will continue. 5433 */ 5434 dnlc_purge_vp(delvp); 5435 delcp = VTOC(delvp); 5436 if ((delvp->v_type != VDIR) && 5437 !((delvp->v_count == 1) || 5438 ((delvp->v_count == 2) && delcp->c_ipending))) { 5439 error = cachefs_remove_dolink(ndvp, delvp, nnm, cr); 5440 if (error) 5441 goto out; 5442 } 5443 } 5444 5445 /* do the rename on the back fs */ 5446 CFS_DPRINT_BACKFS_NFSV4(fscp, 5447 ("cachefs_rename (nfsv4): odcp %p, odbackvp %p, " 5448 " ndcp %p, ndbackvp %p, onm %s, nnm %s\n", 5449 odcp, odcp->c_backvp, ndcp, ndcp->c_backvp, onm, nnm)); 5450 error = VOP_RENAME(odcp->c_backvp, onm, ndcp->c_backvp, nnm, cr, NULL, 5451 0); 5452 if (error) 5453 goto out; 5454 5455 /* purge mappings to file in the old directory */ 5456 dnlc_purge_vp(odvp); 5457 5458 /* purge mappings in the new dir if we deleted a file */ 5459 if (delvp && (odvp != ndvp)) 5460 dnlc_purge_vp(ndvp); 5461 5462 /* update the file we just deleted */ 5463 if (delvp) { 5464 mutex_enter(&delcp->c_statelock); 5465 if (delcp->c_attr.va_nlink == 1) { 5466 delcp->c_flags |= CN_DESTROY; 5467 } else { 5468 delcp->c_flags |= CN_UPDATED; 5469 } 5470 delcp->c_attr.va_nlink--; 5471 CFSOP_MODIFY_COBJECT(fscp, delcp, cr); 5472 mutex_exit(&delcp->c_statelock); 5473 } 5474 5475 /* find the entry in the old directory */ 5476 mutex_enter(&odcp->c_statelock); 5477 gotdirent = 0; 5478 cookiep = NULL; 5479 if (CFS_ISFS_NONSHARED(fscp) && 5480 (odcp->c_metadata.md_flags & MD_POPULATED)) { 5481 error = cachefs_dir_look(odcp, onm, &cookie, 5482 NULL, NULL, &cid); 5483 if (error == 0 || error == EINVAL) { 5484 gotdirent = 1; 5485 if (error == 0) 5486 cookiep = &cookie; 5487 } else { 5488 cachefs_inval_object(odcp); 5489 } 5490 } 5491 error = 0; 5492 5493 /* remove the directory entry from the old directory */ 5494 if (gotdirent) { 5495 error = cachefs_dir_rmentry(odcp, onm); 5496 if (error) { 5497 cachefs_nocache(odcp); 5498 error = 0; 5499 } 5500 } 5501 CFSOP_MODIFY_COBJECT(fscp, odcp, cr); 5502 mutex_exit(&odcp->c_statelock); 5503 5504 /* install the directory entry in the new directory */ 5505 mutex_enter(&ndcp->c_statelock); 5506 if (CFS_ISFS_NONSHARED(fscp) && 5507 (ndcp->c_metadata.md_flags & MD_POPULATED)) { 5508 error = 1; 5509 if (gotdirent) { 5510 ASSERT(cid.cid_fileno != 0); 5511 error = 0; 5512 if (delvp) { 5513 error = cachefs_dir_rmentry(ndcp, nnm); 5514 } 5515 if (error == 0) { 5516 error = cachefs_dir_enter(ndcp, nnm, cookiep, 5517 &cid, SM_ASYNC); 5518 } 5519 } 5520 if (error) { 5521 cachefs_nocache(ndcp); 5522 error = 0; 5523 } 5524 } 5525 if (odcp != ndcp) 5526 CFSOP_MODIFY_COBJECT(fscp, ndcp, cr); 5527 mutex_exit(&ndcp->c_statelock); 5528 5529 /* ctime of renamed file has changed */ 5530 mutex_enter(&recp->c_statelock); 5531 CFSOP_MODIFY_COBJECT(fscp, recp, cr); 5532 mutex_exit(&recp->c_statelock); 5533 5534 out: 5535 if (odcp != ndcp) 5536 rw_exit(&ndcp->c_rwlock); 5537 rw_exit(&odcp->c_rwlock); 5538 5539 VN_RELE(revp); 5540 5541 return (error); 5542 } 5543 5544 static int 5545 cachefs_rename_disconnected(vnode_t *odvp, char *onm, vnode_t *ndvp, 5546 char *nnm, cred_t *cr, vnode_t *delvp) 5547 { 5548 cnode_t *odcp = VTOC(odvp); 5549 cnode_t *ndcp = VTOC(ndvp); 5550 cnode_t *delcp = NULL; 5551 vnode_t *revp = NULL; 5552 cnode_t *recp; 5553 fscache_t *fscp = C_TO_FSCACHE(odcp); 5554 int error = 0; 5555 struct fid cookie; 5556 struct fid *cookiep; 5557 cfs_cid_t cid; 5558 off_t commit = 0; 5559 timestruc_t current_time; 5560 5561 if (CFS_ISFS_WRITE_AROUND(fscp)) 5562 return (ETIMEDOUT); 5563 5564 /* find the file we are renaming */ 5565 error = cachefs_lookup_common(odvp, onm, &revp, NULL, 0, NULL, cr); 5566 if (error) 5567 return (error); 5568 recp = VTOC(revp); 5569 5570 /* 5571 * To avoid deadlock, we acquire this global rename lock before 5572 * we try to get the locks for the source and target directories. 5573 */ 5574 mutex_enter(&cachefs_rename_lock); 5575 rw_enter(&odcp->c_rwlock, RW_WRITER); 5576 if (odcp != ndcp) { 5577 rw_enter(&ndcp->c_rwlock, RW_WRITER); 5578 } 5579 mutex_exit(&cachefs_rename_lock); 5580 5581 if (recp->c_metadata.md_flags & MD_NEEDATTRS) { 5582 error = ETIMEDOUT; 5583 goto out; 5584 } 5585 5586 if ((recp->c_metadata.md_flags & MD_MAPPING) == 0) { 5587 mutex_enter(&recp->c_statelock); 5588 if ((recp->c_metadata.md_flags & MD_MAPPING) == 0) { 5589 error = cachefs_dlog_cidmap(fscp); 5590 if (error) { 5591 mutex_exit(&recp->c_statelock); 5592 error = ENOSPC; 5593 goto out; 5594 } 5595 recp->c_metadata.md_flags |= MD_MAPPING; 5596 recp->c_flags |= CN_UPDATED; 5597 } 5598 mutex_exit(&recp->c_statelock); 5599 } 5600 5601 /* check permissions */ 5602 /* XXX clean up this mutex junk sometime */ 5603 mutex_enter(&odcp->c_statelock); 5604 error = cachefs_access_local(odcp, (VEXEC|VWRITE), cr); 5605 mutex_exit(&odcp->c_statelock); 5606 if (error != 0) 5607 goto out; 5608 mutex_enter(&ndcp->c_statelock); 5609 error = cachefs_access_local(ndcp, (VEXEC|VWRITE), cr); 5610 mutex_exit(&ndcp->c_statelock); 5611 if (error != 0) 5612 goto out; 5613 mutex_enter(&odcp->c_statelock); 5614 error = cachefs_stickyrmchk(odcp, recp, cr); 5615 mutex_exit(&odcp->c_statelock); 5616 if (error != 0) 5617 goto out; 5618 5619 /* dirs must be populated */ 5620 if (((odcp->c_metadata.md_flags & MD_POPULATED) == 0) || 5621 ((ndcp->c_metadata.md_flags & MD_POPULATED) == 0)) { 5622 error = ETIMEDOUT; 5623 goto out; 5624 } 5625 5626 /* for now do not allow moving dirs because could cause cycles */ 5627 if ((((revp->v_type == VDIR) && (odvp != ndvp))) || 5628 (revp == odvp)) { 5629 error = ETIMEDOUT; 5630 goto out; 5631 } 5632 5633 /* if a file is being deleted because of this rename */ 5634 if (delvp) { 5635 delcp = VTOC(delvp); 5636 5637 /* if src and dest file are the same */ 5638 if (delvp == revp) { 5639 error = 0; 5640 goto out; 5641 } 5642 5643 if (delcp->c_metadata.md_flags & MD_NEEDATTRS) { 5644 error = ETIMEDOUT; 5645 goto out; 5646 } 5647 5648 /* if there are hard links to this file */ 5649 if (delcp->c_attr.va_nlink > 1) { 5650 mutex_enter(&delcp->c_statelock); 5651 if (cachefs_modified_alloc(delcp)) { 5652 mutex_exit(&delcp->c_statelock); 5653 error = ENOSPC; 5654 goto out; 5655 } 5656 5657 if ((delcp->c_metadata.md_flags & MD_MAPPING) == 0) { 5658 error = cachefs_dlog_cidmap(fscp); 5659 if (error) { 5660 mutex_exit(&delcp->c_statelock); 5661 error = ENOSPC; 5662 goto out; 5663 } 5664 delcp->c_metadata.md_flags |= MD_MAPPING; 5665 delcp->c_flags |= CN_UPDATED; 5666 } 5667 mutex_exit(&delcp->c_statelock); 5668 } 5669 5670 /* make sure we can delete file */ 5671 mutex_enter(&ndcp->c_statelock); 5672 error = cachefs_stickyrmchk(ndcp, delcp, cr); 5673 mutex_exit(&ndcp->c_statelock); 5674 if (error != 0) 5675 goto out; 5676 5677 /* 5678 * If the cnode is active, make a link to the file 5679 * so operations on the file will continue. 5680 */ 5681 dnlc_purge_vp(delvp); 5682 if ((delvp->v_type != VDIR) && 5683 !((delvp->v_count == 1) || 5684 ((delvp->v_count == 2) && delcp->c_ipending))) { 5685 error = cachefs_remove_dolink(ndvp, delvp, nnm, cr); 5686 if (error) 5687 goto out; 5688 } 5689 } 5690 5691 /* purge mappings to file in the old directory */ 5692 dnlc_purge_vp(odvp); 5693 5694 /* purge mappings in the new dir if we deleted a file */ 5695 if (delvp && (odvp != ndvp)) 5696 dnlc_purge_vp(ndvp); 5697 5698 /* find the entry in the old directory */ 5699 mutex_enter(&odcp->c_statelock); 5700 if ((odcp->c_metadata.md_flags & MD_POPULATED) == 0) { 5701 mutex_exit(&odcp->c_statelock); 5702 error = ETIMEDOUT; 5703 goto out; 5704 } 5705 cookiep = NULL; 5706 error = cachefs_dir_look(odcp, onm, &cookie, NULL, NULL, &cid); 5707 if (error == 0 || error == EINVAL) { 5708 if (error == 0) 5709 cookiep = &cookie; 5710 } else { 5711 mutex_exit(&odcp->c_statelock); 5712 if (error == ENOTDIR) 5713 error = ETIMEDOUT; 5714 goto out; 5715 } 5716 error = 0; 5717 5718 /* write the log entry */ 5719 commit = cachefs_dlog_rename(fscp, odcp, onm, ndcp, nnm, cr, 5720 recp, delcp); 5721 if (commit == 0) { 5722 mutex_exit(&odcp->c_statelock); 5723 error = ENOSPC; 5724 goto out; 5725 } 5726 5727 /* remove the directory entry from the old directory */ 5728 cachefs_modified(odcp); 5729 error = cachefs_dir_rmentry(odcp, onm); 5730 if (error) { 5731 mutex_exit(&odcp->c_statelock); 5732 if (error == ENOTDIR) 5733 error = ETIMEDOUT; 5734 goto out; 5735 } 5736 mutex_exit(&odcp->c_statelock); 5737 5738 /* install the directory entry in the new directory */ 5739 mutex_enter(&ndcp->c_statelock); 5740 error = ENOTDIR; 5741 if (ndcp->c_metadata.md_flags & MD_POPULATED) { 5742 ASSERT(cid.cid_fileno != 0); 5743 cachefs_modified(ndcp); 5744 error = 0; 5745 if (delvp) { 5746 error = cachefs_dir_rmentry(ndcp, nnm); 5747 } 5748 if (error == 0) { 5749 error = cachefs_dir_enter(ndcp, nnm, cookiep, 5750 &cid, SM_ASYNC); 5751 } 5752 } 5753 if (error) { 5754 cachefs_nocache(ndcp); 5755 mutex_exit(&ndcp->c_statelock); 5756 mutex_enter(&odcp->c_statelock); 5757 cachefs_nocache(odcp); 5758 mutex_exit(&odcp->c_statelock); 5759 if (error == ENOTDIR) 5760 error = ETIMEDOUT; 5761 goto out; 5762 } 5763 mutex_exit(&ndcp->c_statelock); 5764 5765 gethrestime(¤t_time); 5766 5767 /* update the file we just deleted */ 5768 if (delvp) { 5769 mutex_enter(&delcp->c_statelock); 5770 delcp->c_attr.va_nlink--; 5771 delcp->c_metadata.md_localctime = current_time; 5772 delcp->c_metadata.md_flags |= MD_LOCALCTIME; 5773 if (delcp->c_attr.va_nlink == 0) { 5774 delcp->c_flags |= CN_DESTROY; 5775 } else { 5776 delcp->c_flags |= CN_UPDATED; 5777 } 5778 mutex_exit(&delcp->c_statelock); 5779 } 5780 5781 /* update the file we renamed */ 5782 mutex_enter(&recp->c_statelock); 5783 recp->c_metadata.md_localctime = current_time; 5784 recp->c_metadata.md_flags |= MD_LOCALCTIME; 5785 recp->c_flags |= CN_UPDATED; 5786 mutex_exit(&recp->c_statelock); 5787 5788 /* update the source directory */ 5789 mutex_enter(&odcp->c_statelock); 5790 odcp->c_metadata.md_localctime = current_time; 5791 odcp->c_metadata.md_localmtime = current_time; 5792 odcp->c_metadata.md_flags |= MD_LOCALCTIME | MD_LOCALMTIME; 5793 odcp->c_flags |= CN_UPDATED; 5794 mutex_exit(&odcp->c_statelock); 5795 5796 /* update the destination directory */ 5797 if (odcp != ndcp) { 5798 mutex_enter(&ndcp->c_statelock); 5799 ndcp->c_metadata.md_localctime = current_time; 5800 ndcp->c_metadata.md_localmtime = current_time; 5801 ndcp->c_metadata.md_flags |= MD_LOCALCTIME | MD_LOCALMTIME; 5802 ndcp->c_flags |= CN_UPDATED; 5803 mutex_exit(&ndcp->c_statelock); 5804 } 5805 5806 out: 5807 if (commit) { 5808 /* commit the log entry */ 5809 if (cachefs_dlog_commit(fscp, commit, error)) { 5810 /*EMPTY*/ 5811 /* XXX bob: fix on panic */ 5812 } 5813 } 5814 5815 if (odcp != ndcp) 5816 rw_exit(&ndcp->c_rwlock); 5817 rw_exit(&odcp->c_rwlock); 5818 5819 VN_RELE(revp); 5820 5821 return (error); 5822 } 5823 5824 /*ARGSUSED*/ 5825 static int 5826 cachefs_mkdir(vnode_t *dvp, char *nm, vattr_t *vap, vnode_t **vpp, 5827 cred_t *cr, caller_context_t *ct, int flags, vsecattr_t *vsecp) 5828 { 5829 cnode_t *dcp = VTOC(dvp); 5830 fscache_t *fscp = C_TO_FSCACHE(dcp); 5831 cachefscache_t *cachep = fscp->fs_cache; 5832 int error = 0; 5833 int held = 0; 5834 int connected = 0; 5835 5836 #ifdef CFSDEBUG 5837 CFS_DEBUG(CFSDEBUG_VOPS) 5838 printf("cachefs_mkdir: ENTER dvp %p\n", (void *)dvp); 5839 #endif 5840 5841 if (getzoneid() != GLOBAL_ZONEID) { 5842 error = EPERM; 5843 goto out; 5844 } 5845 5846 if (fscp->fs_cache->c_flags & (CACHE_NOFILL | CACHE_NOCACHE)) 5847 ASSERT(dcp->c_flags & CN_NOCACHE); 5848 5849 /* 5850 * Cachefs only provides pass-through support for NFSv4, 5851 * and all vnode operations are passed through to the 5852 * back file system. For NFSv4 pass-through to work, only 5853 * connected operation is supported, the cnode backvp must 5854 * exist, and cachefs optional (eg., disconnectable) flags 5855 * are turned off. Assert these conditions to ensure that 5856 * the backfilesystem is called for the mkdir operation. 5857 */ 5858 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 5859 CFS_BACKFS_NFSV4_ASSERT_CNODE(dcp); 5860 5861 for (;;) { 5862 /* get (or renew) access to the file system */ 5863 if (held) { 5864 /* Won't loop with NFSv4 connected behavior */ 5865 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 5866 rw_exit(&dcp->c_rwlock); 5867 cachefs_cd_release(fscp); 5868 held = 0; 5869 } 5870 error = cachefs_cd_access(fscp, connected, 1); 5871 if (error) 5872 break; 5873 rw_enter(&dcp->c_rwlock, RW_WRITER); 5874 held = 1; 5875 5876 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 5877 error = cachefs_mkdir_connected(dvp, nm, vap, 5878 vpp, cr); 5879 if (CFS_TIMEOUT(fscp, error)) { 5880 rw_exit(&dcp->c_rwlock); 5881 cachefs_cd_release(fscp); 5882 held = 0; 5883 cachefs_cd_timedout(fscp); 5884 connected = 0; 5885 continue; 5886 } 5887 } else { 5888 error = cachefs_mkdir_disconnected(dvp, nm, vap, 5889 vpp, cr); 5890 if (CFS_TIMEOUT(fscp, error)) { 5891 connected = 1; 5892 continue; 5893 } 5894 } 5895 break; 5896 } 5897 5898 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_MKDIR)) { 5899 fid_t *fidp = NULL; 5900 ino64_t fileno = 0; 5901 cnode_t *cp = NULL; 5902 if (error == 0) 5903 cp = VTOC(*vpp); 5904 5905 if (cp != NULL) { 5906 fidp = &cp->c_metadata.md_cookie; 5907 fileno = cp->c_id.cid_fileno; 5908 } 5909 5910 cachefs_log_mkdir(cachep, error, fscp->fs_cfsvfsp, 5911 fidp, fileno, crgetuid(cr)); 5912 } 5913 5914 if (held) { 5915 rw_exit(&dcp->c_rwlock); 5916 cachefs_cd_release(fscp); 5917 } 5918 if (error == 0 && CFS_ISFS_NONSHARED(fscp)) 5919 (void) cachefs_pack(dvp, nm, cr); 5920 5921 #ifdef CFS_CD_DEBUG 5922 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 5923 #endif 5924 out: 5925 #ifdef CFSDEBUG 5926 CFS_DEBUG(CFSDEBUG_VOPS) 5927 printf("cachefs_mkdir: EXIT error = %d\n", error); 5928 #endif 5929 return (error); 5930 } 5931 5932 static int 5933 cachefs_mkdir_connected(vnode_t *dvp, char *nm, vattr_t *vap, 5934 vnode_t **vpp, cred_t *cr) 5935 { 5936 cnode_t *newcp = NULL, *dcp = VTOC(dvp); 5937 struct vnode *vp = NULL; 5938 int error = 0; 5939 fscache_t *fscp = C_TO_FSCACHE(dcp); 5940 struct fid cookie; 5941 struct vattr attr; 5942 cfs_cid_t cid, dircid; 5943 uint32_t valid_fid; 5944 5945 if (fscp->fs_cache->c_flags & (CACHE_NOFILL | CACHE_NOCACHE)) 5946 ASSERT(dcp->c_flags & CN_NOCACHE); 5947 5948 mutex_enter(&dcp->c_statelock); 5949 5950 /* get backvp of dir */ 5951 if (dcp->c_backvp == NULL) { 5952 error = cachefs_getbackvp(fscp, dcp); 5953 if (error) { 5954 mutex_exit(&dcp->c_statelock); 5955 goto out; 5956 } 5957 } 5958 5959 /* consistency check the directory */ 5960 error = CFSOP_CHECK_COBJECT(fscp, dcp, 0, cr); 5961 if (error) { 5962 mutex_exit(&dcp->c_statelock); 5963 goto out; 5964 } 5965 dircid = dcp->c_id; 5966 5967 /* make the dir on the back fs */ 5968 CFS_DPRINT_BACKFS_NFSV4(fscp, 5969 ("cachefs_mkdir (nfsv4): dcp %p, dbackvp %p, " 5970 "name %s\n", dcp, dcp->c_backvp, nm)); 5971 error = VOP_MKDIR(dcp->c_backvp, nm, vap, &vp, cr, NULL, 0, NULL); 5972 mutex_exit(&dcp->c_statelock); 5973 if (error) { 5974 goto out; 5975 } 5976 5977 /* get the cookie and make the cnode */ 5978 attr.va_mask = AT_ALL; 5979 valid_fid = (CFS_ISFS_BACKFS_NFSV4(fscp) ? FALSE : TRUE); 5980 error = cachefs_getcookie(vp, &cookie, &attr, cr, valid_fid); 5981 if (error) { 5982 goto out; 5983 } 5984 cid.cid_flags = 0; 5985 cid.cid_fileno = attr.va_nodeid; 5986 error = cachefs_cnode_make(&cid, fscp, (valid_fid ? &cookie : NULL), 5987 &attr, vp, cr, 0, &newcp); 5988 if (error) { 5989 goto out; 5990 } 5991 ASSERT(CTOV(newcp)->v_type == VDIR); 5992 *vpp = CTOV(newcp); 5993 5994 /* if the dir is populated, add the new entry */ 5995 mutex_enter(&dcp->c_statelock); 5996 if (CFS_ISFS_NONSHARED(fscp) && 5997 (dcp->c_metadata.md_flags & MD_POPULATED)) { 5998 error = cachefs_dir_enter(dcp, nm, &cookie, &newcp->c_id, 5999 SM_ASYNC); 6000 if (error) { 6001 cachefs_nocache(dcp); 6002 error = 0; 6003 } 6004 } 6005 dcp->c_attr.va_nlink++; 6006 dcp->c_flags |= CN_UPDATED; 6007 CFSOP_MODIFY_COBJECT(fscp, dcp, cr); 6008 mutex_exit(&dcp->c_statelock); 6009 6010 /* XXX bob: should we do a filldir here? or just add . and .. */ 6011 /* maybe should kick off an async filldir so caller does not wait */ 6012 6013 /* put the entry in the dnlc */ 6014 if (cachefs_dnlc) 6015 dnlc_enter(dvp, nm, *vpp); 6016 6017 /* save the fileno of the parent so can find the name */ 6018 if (bcmp(&newcp->c_metadata.md_parent, &dircid, 6019 sizeof (cfs_cid_t)) != 0) { 6020 mutex_enter(&newcp->c_statelock); 6021 newcp->c_metadata.md_parent = dircid; 6022 newcp->c_flags |= CN_UPDATED; 6023 mutex_exit(&newcp->c_statelock); 6024 } 6025 out: 6026 if (vp) 6027 VN_RELE(vp); 6028 6029 return (error); 6030 } 6031 6032 static int 6033 cachefs_mkdir_disconnected(vnode_t *dvp, char *nm, vattr_t *vap, 6034 vnode_t **vpp, cred_t *cr) 6035 { 6036 cnode_t *dcp = VTOC(dvp); 6037 fscache_t *fscp = C_TO_FSCACHE(dcp); 6038 int error; 6039 cnode_t *newcp = NULL; 6040 struct vattr va; 6041 timestruc_t current_time; 6042 off_t commit = 0; 6043 char *s; 6044 int namlen; 6045 6046 /* don't allow '/' characters in pathname component */ 6047 for (s = nm, namlen = 0; *s; s++, namlen++) 6048 if (*s == '/') 6049 return (EACCES); 6050 if (namlen == 0) 6051 return (EINVAL); 6052 6053 if (CFS_ISFS_WRITE_AROUND(fscp)) 6054 return (ETIMEDOUT); 6055 6056 mutex_enter(&dcp->c_statelock); 6057 6058 /* check permissions */ 6059 if (error = cachefs_access_local(dcp, (VEXEC|VWRITE), cr)) { 6060 mutex_exit(&dcp->c_statelock); 6061 goto out; 6062 } 6063 6064 /* the directory front file must be populated */ 6065 if ((dcp->c_metadata.md_flags & MD_POPULATED) == 0) { 6066 error = ETIMEDOUT; 6067 mutex_exit(&dcp->c_statelock); 6068 goto out; 6069 } 6070 6071 /* make sure nm does not already exist in the directory */ 6072 error = cachefs_dir_look(dcp, nm, NULL, NULL, NULL, NULL); 6073 if (error == ENOTDIR) { 6074 error = ETIMEDOUT; 6075 mutex_exit(&dcp->c_statelock); 6076 goto out; 6077 } 6078 if (error != ENOENT) { 6079 error = EEXIST; 6080 mutex_exit(&dcp->c_statelock); 6081 goto out; 6082 } 6083 6084 /* make up a reasonable set of attributes */ 6085 cachefs_attr_setup(vap, &va, dcp, cr); 6086 va.va_type = VDIR; 6087 va.va_mode |= S_IFDIR; 6088 va.va_nlink = 2; 6089 6090 mutex_exit(&dcp->c_statelock); 6091 6092 /* create the cnode */ 6093 error = cachefs_cnode_create(fscp, &va, 0, &newcp); 6094 if (error) 6095 goto out; 6096 6097 mutex_enter(&newcp->c_statelock); 6098 6099 error = cachefs_dlog_cidmap(fscp); 6100 if (error) { 6101 mutex_exit(&newcp->c_statelock); 6102 goto out; 6103 } 6104 6105 cachefs_creategid(dcp, newcp, vap, cr); 6106 mutex_enter(&dcp->c_statelock); 6107 cachefs_createacl(dcp, newcp); 6108 mutex_exit(&dcp->c_statelock); 6109 gethrestime(¤t_time); 6110 newcp->c_metadata.md_vattr.va_atime = current_time; 6111 newcp->c_metadata.md_localctime = current_time; 6112 newcp->c_metadata.md_localmtime = current_time; 6113 newcp->c_metadata.md_flags |= MD_MAPPING | MD_LOCALMTIME | 6114 MD_LOCALCTIME; 6115 newcp->c_flags |= CN_UPDATED; 6116 6117 /* make a front file for the new directory, add . and .. */ 6118 error = cachefs_dir_new(dcp, newcp); 6119 if (error) { 6120 mutex_exit(&newcp->c_statelock); 6121 goto out; 6122 } 6123 cachefs_modified(newcp); 6124 6125 /* 6126 * write the metadata now rather than waiting until 6127 * inactive so that if there's no space we can let 6128 * the caller know. 6129 */ 6130 ASSERT(newcp->c_frontvp); 6131 ASSERT((newcp->c_filegrp->fg_flags & CFS_FG_ALLOC_ATTR) == 0); 6132 ASSERT((newcp->c_flags & CN_ALLOC_PENDING) == 0); 6133 error = filegrp_write_metadata(newcp->c_filegrp, 6134 &newcp->c_id, &newcp->c_metadata); 6135 if (error) { 6136 mutex_exit(&newcp->c_statelock); 6137 goto out; 6138 } 6139 mutex_exit(&newcp->c_statelock); 6140 6141 /* log the operation */ 6142 commit = cachefs_dlog_mkdir(fscp, dcp, newcp, nm, &va, cr); 6143 if (commit == 0) { 6144 error = ENOSPC; 6145 goto out; 6146 } 6147 6148 mutex_enter(&dcp->c_statelock); 6149 6150 /* make sure directory is still populated */ 6151 if ((dcp->c_metadata.md_flags & MD_POPULATED) == 0) { 6152 mutex_exit(&dcp->c_statelock); 6153 error = ETIMEDOUT; 6154 goto out; 6155 } 6156 cachefs_modified(dcp); 6157 6158 /* enter the new file in the directory */ 6159 error = cachefs_dir_enter(dcp, nm, &newcp->c_metadata.md_cookie, 6160 &newcp->c_id, SM_ASYNC); 6161 if (error) { 6162 mutex_exit(&dcp->c_statelock); 6163 goto out; 6164 } 6165 6166 /* update parent dir times */ 6167 dcp->c_metadata.md_localctime = current_time; 6168 dcp->c_metadata.md_localmtime = current_time; 6169 dcp->c_metadata.md_flags |= MD_LOCALCTIME | MD_LOCALMTIME; 6170 dcp->c_attr.va_nlink++; 6171 dcp->c_flags |= CN_UPDATED; 6172 mutex_exit(&dcp->c_statelock); 6173 6174 out: 6175 if (commit) { 6176 /* commit the log entry */ 6177 if (cachefs_dlog_commit(fscp, commit, error)) { 6178 /*EMPTY*/ 6179 /* XXX bob: fix on panic */ 6180 } 6181 } 6182 if (error) { 6183 if (newcp) { 6184 mutex_enter(&newcp->c_statelock); 6185 newcp->c_flags |= CN_DESTROY; 6186 mutex_exit(&newcp->c_statelock); 6187 VN_RELE(CTOV(newcp)); 6188 } 6189 } else { 6190 *vpp = CTOV(newcp); 6191 } 6192 return (error); 6193 } 6194 6195 /*ARGSUSED*/ 6196 static int 6197 cachefs_rmdir(vnode_t *dvp, char *nm, vnode_t *cdir, cred_t *cr, 6198 caller_context_t *ct, int flags) 6199 { 6200 cnode_t *dcp = VTOC(dvp); 6201 fscache_t *fscp = C_TO_FSCACHE(dcp); 6202 cachefscache_t *cachep = fscp->fs_cache; 6203 int error = 0; 6204 int held = 0; 6205 int connected = 0; 6206 size_t namlen; 6207 vnode_t *vp = NULL; 6208 int vfslock = 0; 6209 6210 #ifdef CFSDEBUG 6211 CFS_DEBUG(CFSDEBUG_VOPS) 6212 printf("cachefs_rmdir: ENTER vp %p\n", (void *)dvp); 6213 #endif 6214 6215 if (getzoneid() != GLOBAL_ZONEID) { 6216 error = EPERM; 6217 goto out; 6218 } 6219 6220 if (fscp->fs_cache->c_flags & (CACHE_NOFILL | CACHE_NOCACHE)) 6221 ASSERT(dcp->c_flags & CN_NOCACHE); 6222 6223 /* 6224 * Cachefs only provides pass-through support for NFSv4, 6225 * and all vnode operations are passed through to the 6226 * back file system. For NFSv4 pass-through to work, only 6227 * connected operation is supported, the cnode backvp must 6228 * exist, and cachefs optional (eg., disconnectable) flags 6229 * are turned off. Assert these conditions to ensure that 6230 * the backfilesystem is called for the rmdir operation. 6231 */ 6232 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 6233 CFS_BACKFS_NFSV4_ASSERT_CNODE(dcp); 6234 6235 for (;;) { 6236 if (vfslock) { 6237 vn_vfsunlock(vp); 6238 vfslock = 0; 6239 } 6240 if (vp) { 6241 VN_RELE(vp); 6242 vp = NULL; 6243 } 6244 6245 /* get (or renew) access to the file system */ 6246 if (held) { 6247 /* Won't loop with NFSv4 connected behavior */ 6248 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 6249 cachefs_cd_release(fscp); 6250 held = 0; 6251 } 6252 error = cachefs_cd_access(fscp, connected, 1); 6253 if (error) 6254 break; 6255 held = 1; 6256 6257 /* if disconnected, do some extra error checking */ 6258 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 6259 /* check permissions */ 6260 mutex_enter(&dcp->c_statelock); 6261 error = cachefs_access_local(dcp, (VEXEC|VWRITE), cr); 6262 mutex_exit(&dcp->c_statelock); 6263 if (CFS_TIMEOUT(fscp, error)) { 6264 connected = 1; 6265 continue; 6266 } 6267 if (error) 6268 break; 6269 6270 namlen = strlen(nm); 6271 if (namlen == 0) { 6272 error = EINVAL; 6273 break; 6274 } 6275 6276 /* cannot remove . and .. */ 6277 if (nm[0] == '.') { 6278 if (namlen == 1) { 6279 error = EINVAL; 6280 break; 6281 } else if (namlen == 2 && nm[1] == '.') { 6282 error = EEXIST; 6283 break; 6284 } 6285 } 6286 6287 } 6288 6289 /* get the cnode of the dir to remove */ 6290 error = cachefs_lookup_common(dvp, nm, &vp, NULL, 0, NULL, cr); 6291 if (error) { 6292 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 6293 if (CFS_TIMEOUT(fscp, error)) { 6294 cachefs_cd_release(fscp); 6295 held = 0; 6296 cachefs_cd_timedout(fscp); 6297 connected = 0; 6298 continue; 6299 } 6300 } else { 6301 if (CFS_TIMEOUT(fscp, error)) { 6302 connected = 1; 6303 continue; 6304 } 6305 } 6306 break; 6307 } 6308 6309 /* must be a dir */ 6310 if (vp->v_type != VDIR) { 6311 error = ENOTDIR; 6312 break; 6313 } 6314 6315 /* must not be current dir */ 6316 if (VOP_CMP(vp, cdir, ct)) { 6317 error = EINVAL; 6318 break; 6319 } 6320 6321 /* see ufs_dirremove for why this is done, mount race */ 6322 if (vn_vfswlock(vp)) { 6323 error = EBUSY; 6324 break; 6325 } 6326 vfslock = 1; 6327 if (vn_mountedvfs(vp) != NULL) { 6328 error = EBUSY; 6329 break; 6330 } 6331 6332 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 6333 error = cachefs_rmdir_connected(dvp, nm, cdir, 6334 cr, vp); 6335 if (CFS_TIMEOUT(fscp, error)) { 6336 cachefs_cd_release(fscp); 6337 held = 0; 6338 cachefs_cd_timedout(fscp); 6339 connected = 0; 6340 continue; 6341 } 6342 } else { 6343 error = cachefs_rmdir_disconnected(dvp, nm, cdir, 6344 cr, vp); 6345 if (CFS_TIMEOUT(fscp, error)) { 6346 connected = 1; 6347 continue; 6348 } 6349 } 6350 break; 6351 } 6352 6353 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_RMDIR)) { 6354 ino64_t fileno = 0; 6355 fid_t *fidp = NULL; 6356 cnode_t *cp = NULL; 6357 if (vp) 6358 cp = VTOC(vp); 6359 6360 if (cp != NULL) { 6361 fidp = &cp->c_metadata.md_cookie; 6362 fileno = cp->c_id.cid_fileno; 6363 } 6364 6365 cachefs_log_rmdir(cachep, error, fscp->fs_cfsvfsp, 6366 fidp, fileno, crgetuid(cr)); 6367 } 6368 6369 if (held) { 6370 cachefs_cd_release(fscp); 6371 } 6372 6373 if (vfslock) 6374 vn_vfsunlock(vp); 6375 6376 if (vp) 6377 VN_RELE(vp); 6378 6379 #ifdef CFS_CD_DEBUG 6380 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 6381 #endif 6382 out: 6383 #ifdef CFSDEBUG 6384 CFS_DEBUG(CFSDEBUG_VOPS) 6385 printf("cachefs_rmdir: EXIT error = %d\n", error); 6386 #endif 6387 6388 return (error); 6389 } 6390 6391 static int 6392 cachefs_rmdir_connected(vnode_t *dvp, char *nm, vnode_t *cdir, cred_t *cr, 6393 vnode_t *vp) 6394 { 6395 cnode_t *dcp = VTOC(dvp); 6396 cnode_t *cp = VTOC(vp); 6397 int error = 0; 6398 fscache_t *fscp = C_TO_FSCACHE(dcp); 6399 6400 rw_enter(&dcp->c_rwlock, RW_WRITER); 6401 mutex_enter(&dcp->c_statelock); 6402 mutex_enter(&cp->c_statelock); 6403 6404 if (dcp->c_backvp == NULL) { 6405 error = cachefs_getbackvp(fscp, dcp); 6406 if (error) { 6407 goto out; 6408 } 6409 } 6410 6411 error = CFSOP_CHECK_COBJECT(fscp, dcp, 0, cr); 6412 if (error) 6413 goto out; 6414 6415 /* rmdir on the back fs */ 6416 CFS_DPRINT_BACKFS_NFSV4(fscp, 6417 ("cachefs_rmdir (nfsv4): dcp %p, dbackvp %p, " 6418 "name %s\n", dcp, dcp->c_backvp, nm)); 6419 error = VOP_RMDIR(dcp->c_backvp, nm, cdir, cr, NULL, 0); 6420 if (error) 6421 goto out; 6422 6423 /* if the dir is populated, remove the entry from it */ 6424 if (CFS_ISFS_NONSHARED(fscp) && 6425 (dcp->c_metadata.md_flags & MD_POPULATED)) { 6426 error = cachefs_dir_rmentry(dcp, nm); 6427 if (error) { 6428 cachefs_nocache(dcp); 6429 error = 0; 6430 } 6431 } 6432 6433 /* 6434 * *if* the (hard) link count goes to 0, then we set the CDESTROY 6435 * flag on the cnode. The cached object will then be destroyed 6436 * at inactive time where the chickens come home to roost :-) 6437 * The link cnt for directories is bumped down by 2 'cause the "." 6438 * entry has to be elided too ! The link cnt for the parent goes down 6439 * by 1 (because of ".."). 6440 */ 6441 cp->c_attr.va_nlink -= 2; 6442 dcp->c_attr.va_nlink--; 6443 if (cp->c_attr.va_nlink == 0) { 6444 cp->c_flags |= CN_DESTROY; 6445 } else { 6446 cp->c_flags |= CN_UPDATED; 6447 } 6448 dcp->c_flags |= CN_UPDATED; 6449 6450 dnlc_purge_vp(vp); 6451 CFSOP_MODIFY_COBJECT(fscp, dcp, cr); 6452 6453 out: 6454 mutex_exit(&cp->c_statelock); 6455 mutex_exit(&dcp->c_statelock); 6456 rw_exit(&dcp->c_rwlock); 6457 6458 return (error); 6459 } 6460 6461 static int 6462 /*ARGSUSED*/ 6463 cachefs_rmdir_disconnected(vnode_t *dvp, char *nm, vnode_t *cdir, 6464 cred_t *cr, vnode_t *vp) 6465 { 6466 cnode_t *dcp = VTOC(dvp); 6467 cnode_t *cp = VTOC(vp); 6468 fscache_t *fscp = C_TO_FSCACHE(dcp); 6469 int error = 0; 6470 off_t commit = 0; 6471 timestruc_t current_time; 6472 6473 if (CFS_ISFS_WRITE_AROUND(fscp)) 6474 return (ETIMEDOUT); 6475 6476 rw_enter(&dcp->c_rwlock, RW_WRITER); 6477 mutex_enter(&dcp->c_statelock); 6478 mutex_enter(&cp->c_statelock); 6479 6480 /* both directories must be populated */ 6481 if (((dcp->c_metadata.md_flags & MD_POPULATED) == 0) || 6482 ((cp->c_metadata.md_flags & MD_POPULATED) == 0)) { 6483 error = ETIMEDOUT; 6484 goto out; 6485 } 6486 6487 /* if sticky bit set on the dir, more access checks to perform */ 6488 if (error = cachefs_stickyrmchk(dcp, cp, cr)) { 6489 goto out; 6490 } 6491 6492 /* make sure dir is empty */ 6493 if (cp->c_attr.va_nlink > 2) { 6494 error = cachefs_dir_empty(cp); 6495 if (error) { 6496 if (error == ENOTDIR) 6497 error = ETIMEDOUT; 6498 goto out; 6499 } 6500 cachefs_modified(cp); 6501 } 6502 cachefs_modified(dcp); 6503 6504 /* log the operation */ 6505 commit = cachefs_dlog_rmdir(fscp, dcp, nm, cp, cr); 6506 if (commit == 0) { 6507 error = ENOSPC; 6508 goto out; 6509 } 6510 6511 /* remove name from parent dir */ 6512 error = cachefs_dir_rmentry(dcp, nm); 6513 if (error == ENOTDIR) { 6514 error = ETIMEDOUT; 6515 goto out; 6516 } 6517 if (error) 6518 goto out; 6519 6520 gethrestime(¤t_time); 6521 6522 /* update deleted dir values */ 6523 cp->c_attr.va_nlink -= 2; 6524 if (cp->c_attr.va_nlink == 0) 6525 cp->c_flags |= CN_DESTROY; 6526 else { 6527 cp->c_metadata.md_localctime = current_time; 6528 cp->c_metadata.md_flags |= MD_LOCALCTIME; 6529 cp->c_flags |= CN_UPDATED; 6530 } 6531 6532 /* update parent values */ 6533 dcp->c_metadata.md_localctime = current_time; 6534 dcp->c_metadata.md_localmtime = current_time; 6535 dcp->c_metadata.md_flags |= MD_LOCALCTIME | MD_LOCALMTIME; 6536 dcp->c_attr.va_nlink--; 6537 dcp->c_flags |= CN_UPDATED; 6538 6539 out: 6540 mutex_exit(&cp->c_statelock); 6541 mutex_exit(&dcp->c_statelock); 6542 rw_exit(&dcp->c_rwlock); 6543 if (commit) { 6544 /* commit the log entry */ 6545 if (cachefs_dlog_commit(fscp, commit, error)) { 6546 /*EMPTY*/ 6547 /* XXX bob: fix on panic */ 6548 } 6549 dnlc_purge_vp(vp); 6550 } 6551 return (error); 6552 } 6553 6554 /*ARGSUSED*/ 6555 static int 6556 cachefs_symlink(vnode_t *dvp, char *lnm, vattr_t *tva, 6557 char *tnm, cred_t *cr, caller_context_t *ct, int flags) 6558 { 6559 cnode_t *dcp = VTOC(dvp); 6560 fscache_t *fscp = C_TO_FSCACHE(dcp); 6561 cachefscache_t *cachep = fscp->fs_cache; 6562 int error = 0; 6563 int held = 0; 6564 int connected = 0; 6565 6566 #ifdef CFSDEBUG 6567 CFS_DEBUG(CFSDEBUG_VOPS) 6568 printf("cachefs_symlink: ENTER dvp %p lnm %s tnm %s\n", 6569 (void *)dvp, lnm, tnm); 6570 #endif 6571 6572 if (getzoneid() != GLOBAL_ZONEID) { 6573 error = EPERM; 6574 goto out; 6575 } 6576 6577 if (fscp->fs_cache->c_flags & CACHE_NOCACHE) 6578 ASSERT(dcp->c_flags & CN_NOCACHE); 6579 6580 /* 6581 * Cachefs only provides pass-through support for NFSv4, 6582 * and all vnode operations are passed through to the 6583 * back file system. For NFSv4 pass-through to work, only 6584 * connected operation is supported, the cnode backvp must 6585 * exist, and cachefs optional (eg., disconnectable) flags 6586 * are turned off. Assert these conditions to ensure that 6587 * the backfilesystem is called for the symlink operation. 6588 */ 6589 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 6590 CFS_BACKFS_NFSV4_ASSERT_CNODE(dcp); 6591 6592 for (;;) { 6593 /* get (or renew) access to the file system */ 6594 if (held) { 6595 /* Won't loop with NFSv4 connected behavior */ 6596 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 6597 rw_exit(&dcp->c_rwlock); 6598 cachefs_cd_release(fscp); 6599 held = 0; 6600 } 6601 error = cachefs_cd_access(fscp, connected, 1); 6602 if (error) 6603 break; 6604 rw_enter(&dcp->c_rwlock, RW_WRITER); 6605 held = 1; 6606 6607 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 6608 error = cachefs_symlink_connected(dvp, lnm, tva, 6609 tnm, cr); 6610 if (CFS_TIMEOUT(fscp, error)) { 6611 rw_exit(&dcp->c_rwlock); 6612 cachefs_cd_release(fscp); 6613 held = 0; 6614 cachefs_cd_timedout(fscp); 6615 connected = 0; 6616 continue; 6617 } 6618 } else { 6619 error = cachefs_symlink_disconnected(dvp, lnm, tva, 6620 tnm, cr); 6621 if (CFS_TIMEOUT(fscp, error)) { 6622 connected = 1; 6623 continue; 6624 } 6625 } 6626 break; 6627 } 6628 6629 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_SYMLINK)) 6630 cachefs_log_symlink(cachep, error, fscp->fs_cfsvfsp, 6631 &dcp->c_metadata.md_cookie, dcp->c_id.cid_fileno, 6632 crgetuid(cr), (uint_t)strlen(tnm)); 6633 6634 if (held) { 6635 rw_exit(&dcp->c_rwlock); 6636 cachefs_cd_release(fscp); 6637 } 6638 6639 #ifdef CFS_CD_DEBUG 6640 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 6641 #endif 6642 out: 6643 #ifdef CFSDEBUG 6644 CFS_DEBUG(CFSDEBUG_VOPS) 6645 printf("cachefs_symlink: EXIT error = %d\n", error); 6646 #endif 6647 return (error); 6648 } 6649 6650 static int 6651 cachefs_symlink_connected(vnode_t *dvp, char *lnm, vattr_t *tva, 6652 char *tnm, cred_t *cr) 6653 { 6654 cnode_t *dcp = VTOC(dvp); 6655 fscache_t *fscp = C_TO_FSCACHE(dcp); 6656 int error = 0; 6657 vnode_t *backvp = NULL; 6658 cnode_t *newcp = NULL; 6659 struct vattr va; 6660 struct fid cookie; 6661 cfs_cid_t cid; 6662 uint32_t valid_fid; 6663 6664 mutex_enter(&dcp->c_statelock); 6665 6666 if (dcp->c_backvp == NULL) { 6667 error = cachefs_getbackvp(fscp, dcp); 6668 if (error) { 6669 cachefs_nocache(dcp); 6670 mutex_exit(&dcp->c_statelock); 6671 goto out; 6672 } 6673 } 6674 6675 error = CFSOP_CHECK_COBJECT(fscp, dcp, 0, cr); 6676 if (error) { 6677 mutex_exit(&dcp->c_statelock); 6678 goto out; 6679 } 6680 CFS_DPRINT_BACKFS_NFSV4(fscp, 6681 ("cachefs_symlink (nfsv4): dcp %p, dbackvp %p, " 6682 "lnm %s, tnm %s\n", dcp, dcp->c_backvp, lnm, tnm)); 6683 error = VOP_SYMLINK(dcp->c_backvp, lnm, tva, tnm, cr, NULL, 0); 6684 if (error) { 6685 mutex_exit(&dcp->c_statelock); 6686 goto out; 6687 } 6688 if ((dcp->c_filegrp->fg_flags & CFS_FG_WRITE) == 0 && 6689 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 6690 cachefs_nocache(dcp); 6691 mutex_exit(&dcp->c_statelock); 6692 goto out; 6693 } 6694 6695 CFSOP_MODIFY_COBJECT(fscp, dcp, cr); 6696 6697 /* lookup the symlink we just created and get its fid and attrs */ 6698 (void) VOP_LOOKUP(dcp->c_backvp, lnm, &backvp, NULL, 0, NULL, cr, 6699 NULL, NULL, NULL); 6700 if (backvp == NULL) { 6701 if (CFS_ISFS_BACKFS_NFSV4(fscp) == 0) 6702 cachefs_nocache(dcp); 6703 mutex_exit(&dcp->c_statelock); 6704 goto out; 6705 } 6706 6707 valid_fid = (CFS_ISFS_BACKFS_NFSV4(fscp) ? FALSE : TRUE); 6708 error = cachefs_getcookie(backvp, &cookie, &va, cr, valid_fid); 6709 if (error) { 6710 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 6711 error = 0; 6712 cachefs_nocache(dcp); 6713 mutex_exit(&dcp->c_statelock); 6714 goto out; 6715 } 6716 cid.cid_fileno = va.va_nodeid; 6717 cid.cid_flags = 0; 6718 6719 /* if the dir is cached, add the symlink to it */ 6720 if (CFS_ISFS_NONSHARED(fscp) && 6721 (dcp->c_metadata.md_flags & MD_POPULATED)) { 6722 error = cachefs_dir_enter(dcp, lnm, &cookie, &cid, SM_ASYNC); 6723 if (error) { 6724 cachefs_nocache(dcp); 6725 error = 0; 6726 } 6727 } 6728 mutex_exit(&dcp->c_statelock); 6729 6730 /* make the cnode for the sym link */ 6731 error = cachefs_cnode_make(&cid, fscp, (valid_fid ? &cookie : NULL), 6732 &va, backvp, cr, 0, &newcp); 6733 if (error) { 6734 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 6735 cachefs_nocache(dcp); 6736 error = 0; 6737 goto out; 6738 } 6739 6740 /* try to cache the symlink contents */ 6741 rw_enter(&newcp->c_rwlock, RW_WRITER); 6742 mutex_enter(&newcp->c_statelock); 6743 6744 /* 6745 * try to cache the sym link, note that its a noop if NOCACHE 6746 * or NFSv4 is set 6747 */ 6748 error = cachefs_stuffsymlink(newcp, tnm, (int)newcp->c_size); 6749 if (error) { 6750 cachefs_nocache(newcp); 6751 error = 0; 6752 } 6753 mutex_exit(&newcp->c_statelock); 6754 rw_exit(&newcp->c_rwlock); 6755 6756 out: 6757 if (backvp) 6758 VN_RELE(backvp); 6759 if (newcp) 6760 VN_RELE(CTOV(newcp)); 6761 return (error); 6762 } 6763 6764 static int 6765 cachefs_symlink_disconnected(vnode_t *dvp, char *lnm, vattr_t *tva, 6766 char *tnm, cred_t *cr) 6767 { 6768 cnode_t *dcp = VTOC(dvp); 6769 fscache_t *fscp = C_TO_FSCACHE(dcp); 6770 int error; 6771 cnode_t *newcp = NULL; 6772 struct vattr va; 6773 timestruc_t current_time; 6774 off_t commit = 0; 6775 6776 if (CFS_ISFS_WRITE_AROUND(fscp)) 6777 return (ETIMEDOUT); 6778 6779 mutex_enter(&dcp->c_statelock); 6780 6781 /* check permissions */ 6782 if (error = cachefs_access_local(dcp, (VEXEC|VWRITE), cr)) { 6783 mutex_exit(&dcp->c_statelock); 6784 goto out; 6785 } 6786 6787 /* the directory front file must be populated */ 6788 if ((dcp->c_metadata.md_flags & MD_POPULATED) == 0) { 6789 error = ETIMEDOUT; 6790 mutex_exit(&dcp->c_statelock); 6791 goto out; 6792 } 6793 6794 /* make sure lnm does not already exist in the directory */ 6795 error = cachefs_dir_look(dcp, lnm, NULL, NULL, NULL, NULL); 6796 if (error == ENOTDIR) { 6797 error = ETIMEDOUT; 6798 mutex_exit(&dcp->c_statelock); 6799 goto out; 6800 } 6801 if (error != ENOENT) { 6802 error = EEXIST; 6803 mutex_exit(&dcp->c_statelock); 6804 goto out; 6805 } 6806 6807 /* make up a reasonable set of attributes */ 6808 cachefs_attr_setup(tva, &va, dcp, cr); 6809 va.va_type = VLNK; 6810 va.va_mode |= S_IFLNK; 6811 va.va_size = strlen(tnm); 6812 6813 mutex_exit(&dcp->c_statelock); 6814 6815 /* create the cnode */ 6816 error = cachefs_cnode_create(fscp, &va, 0, &newcp); 6817 if (error) 6818 goto out; 6819 6820 rw_enter(&newcp->c_rwlock, RW_WRITER); 6821 mutex_enter(&newcp->c_statelock); 6822 6823 error = cachefs_dlog_cidmap(fscp); 6824 if (error) { 6825 mutex_exit(&newcp->c_statelock); 6826 rw_exit(&newcp->c_rwlock); 6827 error = ENOSPC; 6828 goto out; 6829 } 6830 6831 cachefs_creategid(dcp, newcp, tva, cr); 6832 mutex_enter(&dcp->c_statelock); 6833 cachefs_createacl(dcp, newcp); 6834 mutex_exit(&dcp->c_statelock); 6835 gethrestime(¤t_time); 6836 newcp->c_metadata.md_vattr.va_atime = current_time; 6837 newcp->c_metadata.md_localctime = current_time; 6838 newcp->c_metadata.md_localmtime = current_time; 6839 newcp->c_metadata.md_flags |= MD_MAPPING | MD_LOCALMTIME | 6840 MD_LOCALCTIME; 6841 newcp->c_flags |= CN_UPDATED; 6842 6843 /* log the operation */ 6844 commit = cachefs_dlog_symlink(fscp, dcp, newcp, lnm, tva, tnm, cr); 6845 if (commit == 0) { 6846 mutex_exit(&newcp->c_statelock); 6847 rw_exit(&newcp->c_rwlock); 6848 error = ENOSPC; 6849 goto out; 6850 } 6851 6852 /* store the symlink contents */ 6853 error = cachefs_stuffsymlink(newcp, tnm, (int)newcp->c_size); 6854 if (error) { 6855 mutex_exit(&newcp->c_statelock); 6856 rw_exit(&newcp->c_rwlock); 6857 goto out; 6858 } 6859 if (cachefs_modified_alloc(newcp)) { 6860 mutex_exit(&newcp->c_statelock); 6861 rw_exit(&newcp->c_rwlock); 6862 error = ENOSPC; 6863 goto out; 6864 } 6865 6866 /* 6867 * write the metadata now rather than waiting until 6868 * inactive so that if there's no space we can let 6869 * the caller know. 6870 */ 6871 if (newcp->c_flags & CN_ALLOC_PENDING) { 6872 if (newcp->c_filegrp->fg_flags & CFS_FG_ALLOC_ATTR) { 6873 (void) filegrp_allocattr(newcp->c_filegrp); 6874 } 6875 error = filegrp_create_metadata(newcp->c_filegrp, 6876 &newcp->c_metadata, &newcp->c_id); 6877 if (error) { 6878 mutex_exit(&newcp->c_statelock); 6879 rw_exit(&newcp->c_rwlock); 6880 goto out; 6881 } 6882 newcp->c_flags &= ~CN_ALLOC_PENDING; 6883 } 6884 error = filegrp_write_metadata(newcp->c_filegrp, 6885 &newcp->c_id, &newcp->c_metadata); 6886 if (error) { 6887 mutex_exit(&newcp->c_statelock); 6888 rw_exit(&newcp->c_rwlock); 6889 goto out; 6890 } 6891 mutex_exit(&newcp->c_statelock); 6892 rw_exit(&newcp->c_rwlock); 6893 6894 mutex_enter(&dcp->c_statelock); 6895 6896 /* enter the new file in the directory */ 6897 if ((dcp->c_metadata.md_flags & MD_POPULATED) == 0) { 6898 error = ETIMEDOUT; 6899 mutex_exit(&dcp->c_statelock); 6900 goto out; 6901 } 6902 cachefs_modified(dcp); 6903 error = cachefs_dir_enter(dcp, lnm, &newcp->c_metadata.md_cookie, 6904 &newcp->c_id, SM_ASYNC); 6905 if (error) { 6906 mutex_exit(&dcp->c_statelock); 6907 goto out; 6908 } 6909 6910 /* update parent dir times */ 6911 dcp->c_metadata.md_localctime = current_time; 6912 dcp->c_metadata.md_localmtime = current_time; 6913 dcp->c_metadata.md_flags |= MD_LOCALMTIME | MD_LOCALCTIME; 6914 dcp->c_flags |= CN_UPDATED; 6915 mutex_exit(&dcp->c_statelock); 6916 6917 out: 6918 if (commit) { 6919 /* commit the log entry */ 6920 if (cachefs_dlog_commit(fscp, commit, error)) { 6921 /*EMPTY*/ 6922 /* XXX bob: fix on panic */ 6923 } 6924 } 6925 6926 if (error) { 6927 if (newcp) { 6928 mutex_enter(&newcp->c_statelock); 6929 newcp->c_flags |= CN_DESTROY; 6930 mutex_exit(&newcp->c_statelock); 6931 } 6932 } 6933 if (newcp) { 6934 VN_RELE(CTOV(newcp)); 6935 } 6936 6937 return (error); 6938 } 6939 6940 /*ARGSUSED*/ 6941 static int 6942 cachefs_readdir(vnode_t *vp, uio_t *uiop, cred_t *cr, int *eofp, 6943 caller_context_t *ct, int flags) 6944 { 6945 cnode_t *dcp = VTOC(vp); 6946 fscache_t *fscp = C_TO_FSCACHE(dcp); 6947 cachefscache_t *cachep = fscp->fs_cache; 6948 int error = 0; 6949 int held = 0; 6950 int connected = 0; 6951 6952 #ifdef CFSDEBUG 6953 CFS_DEBUG(CFSDEBUG_VOPS) 6954 printf("cachefs_readdir: ENTER vp %p\n", (void *)vp); 6955 #endif 6956 if (getzoneid() != GLOBAL_ZONEID) { 6957 error = EPERM; 6958 goto out; 6959 } 6960 6961 /* 6962 * Cachefs only provides pass-through support for NFSv4, 6963 * and all vnode operations are passed through to the 6964 * back file system. For NFSv4 pass-through to work, only 6965 * connected operation is supported, the cnode backvp must 6966 * exist, and cachefs optional (eg., disconnectable) flags 6967 * are turned off. Assert these conditions to ensure that 6968 * the backfilesystem is called for the readdir operation. 6969 */ 6970 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 6971 CFS_BACKFS_NFSV4_ASSERT_CNODE(dcp); 6972 6973 for (;;) { 6974 /* get (or renew) access to the file system */ 6975 if (held) { 6976 /* Won't loop with NFSv4 connected behavior */ 6977 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 6978 rw_exit(&dcp->c_rwlock); 6979 cachefs_cd_release(fscp); 6980 held = 0; 6981 } 6982 error = cachefs_cd_access(fscp, connected, 0); 6983 if (error) 6984 break; 6985 rw_enter(&dcp->c_rwlock, RW_READER); 6986 held = 1; 6987 6988 /* quit if link count of zero (posix) */ 6989 if (dcp->c_attr.va_nlink == 0) { 6990 if (eofp) 6991 *eofp = 1; 6992 error = 0; 6993 break; 6994 } 6995 6996 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 6997 error = cachefs_readdir_connected(vp, uiop, cr, 6998 eofp); 6999 if (CFS_TIMEOUT(fscp, error)) { 7000 rw_exit(&dcp->c_rwlock); 7001 cachefs_cd_release(fscp); 7002 held = 0; 7003 cachefs_cd_timedout(fscp); 7004 connected = 0; 7005 continue; 7006 } 7007 } else { 7008 error = cachefs_readdir_disconnected(vp, uiop, cr, 7009 eofp); 7010 if (CFS_TIMEOUT(fscp, error)) { 7011 if (cachefs_cd_access_miss(fscp)) { 7012 error = cachefs_readdir_connected(vp, 7013 uiop, cr, eofp); 7014 if (!CFS_TIMEOUT(fscp, error)) 7015 break; 7016 delay(5*hz); 7017 connected = 0; 7018 continue; 7019 } 7020 connected = 1; 7021 continue; 7022 } 7023 } 7024 break; 7025 } 7026 7027 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_READDIR)) 7028 cachefs_log_readdir(cachep, error, fscp->fs_cfsvfsp, 7029 &dcp->c_metadata.md_cookie, dcp->c_id.cid_fileno, 7030 crgetuid(cr), uiop->uio_loffset, *eofp); 7031 7032 if (held) { 7033 rw_exit(&dcp->c_rwlock); 7034 cachefs_cd_release(fscp); 7035 } 7036 7037 #ifdef CFS_CD_DEBUG 7038 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 7039 #endif 7040 out: 7041 #ifdef CFSDEBUG 7042 CFS_DEBUG(CFSDEBUG_VOPS) 7043 printf("cachefs_readdir: EXIT error = %d\n", error); 7044 #endif 7045 7046 return (error); 7047 } 7048 7049 static int 7050 cachefs_readdir_connected(vnode_t *vp, uio_t *uiop, cred_t *cr, int *eofp) 7051 { 7052 cnode_t *dcp = VTOC(vp); 7053 int error; 7054 fscache_t *fscp = C_TO_FSCACHE(dcp); 7055 struct cachefs_req *rp; 7056 7057 mutex_enter(&dcp->c_statelock); 7058 7059 /* check directory consistency */ 7060 error = CFSOP_CHECK_COBJECT(fscp, dcp, 0, cr); 7061 if (error) 7062 goto out; 7063 dcp->c_usage++; 7064 7065 /* if dir was modified, toss old contents */ 7066 if (dcp->c_metadata.md_flags & MD_INVALREADDIR) { 7067 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 7068 cachefs_inval_object(dcp); 7069 } 7070 7071 error = 0; 7072 if (((dcp->c_metadata.md_flags & MD_POPULATED) == 0) && 7073 ((dcp->c_flags & (CN_ASYNC_POPULATE | CN_NOCACHE)) == 0) && 7074 !CFS_ISFS_BACKFS_NFSV4(fscp) && 7075 (fscp->fs_cdconnected == CFS_CD_CONNECTED)) { 7076 7077 if (cachefs_async_okay()) { 7078 7079 /* 7080 * Set up asynchronous request to fill this 7081 * directory. 7082 */ 7083 7084 dcp->c_flags |= CN_ASYNC_POPULATE; 7085 7086 rp = kmem_cache_alloc(cachefs_req_cache, KM_SLEEP); 7087 rp->cfs_cmd = CFS_POPULATE; 7088 rp->cfs_req_u.cu_populate.cpop_vp = vp; 7089 rp->cfs_cr = cr; 7090 7091 crhold(cr); 7092 VN_HOLD(vp); 7093 7094 cachefs_addqueue(rp, &fscp->fs_workq); 7095 } else { 7096 error = cachefs_dir_fill(dcp, cr); 7097 if (error != 0) 7098 cachefs_nocache(dcp); 7099 } 7100 } 7101 7102 /* if front file is populated */ 7103 if (((dcp->c_flags & (CN_NOCACHE | CN_ASYNC_POPULATE)) == 0) && 7104 !CFS_ISFS_BACKFS_NFSV4(fscp) && 7105 (dcp->c_metadata.md_flags & MD_POPULATED)) { 7106 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 7107 error = cachefs_dir_read(dcp, uiop, eofp); 7108 if (error == 0) 7109 fscp->fs_stats.st_hits++; 7110 } 7111 7112 /* if front file could not be used */ 7113 if ((error != 0) || 7114 CFS_ISFS_BACKFS_NFSV4(fscp) || 7115 (dcp->c_flags & (CN_NOCACHE | CN_ASYNC_POPULATE)) || 7116 ((dcp->c_metadata.md_flags & MD_POPULATED) == 0)) { 7117 7118 if (error && !(dcp->c_flags & CN_NOCACHE) && 7119 !CFS_ISFS_BACKFS_NFSV4(fscp)) 7120 cachefs_nocache(dcp); 7121 7122 /* get the back vp */ 7123 if (dcp->c_backvp == NULL) { 7124 error = cachefs_getbackvp(fscp, dcp); 7125 if (error) 7126 goto out; 7127 } 7128 7129 if (fscp->fs_inum_size > 0) { 7130 error = cachefs_readback_translate(dcp, uiop, cr, eofp); 7131 } else { 7132 /* do the dir read from the back fs */ 7133 (void) VOP_RWLOCK(dcp->c_backvp, 7134 V_WRITELOCK_FALSE, NULL); 7135 CFS_DPRINT_BACKFS_NFSV4(fscp, 7136 ("cachefs_readdir (nfsv4): " 7137 "dcp %p, dbackvp %p\n", dcp, dcp->c_backvp)); 7138 error = VOP_READDIR(dcp->c_backvp, uiop, cr, eofp, 7139 NULL, 0); 7140 VOP_RWUNLOCK(dcp->c_backvp, V_WRITELOCK_FALSE, NULL); 7141 } 7142 7143 if (error == 0) 7144 fscp->fs_stats.st_misses++; 7145 } 7146 7147 out: 7148 mutex_exit(&dcp->c_statelock); 7149 7150 return (error); 7151 } 7152 7153 static int 7154 cachefs_readback_translate(cnode_t *cp, uio_t *uiop, cred_t *cr, int *eofp) 7155 { 7156 int error = 0; 7157 fscache_t *fscp = C_TO_FSCACHE(cp); 7158 caddr_t buffy = NULL; 7159 int buffysize = MAXBSIZE; 7160 caddr_t chrp, end; 7161 ino64_t newinum; 7162 struct dirent64 *de; 7163 uio_t uioin; 7164 iovec_t iov; 7165 7166 ASSERT(cp->c_backvp != NULL); 7167 ASSERT(fscp->fs_inum_size > 0); 7168 7169 if (uiop->uio_resid < buffysize) 7170 buffysize = (int)uiop->uio_resid; 7171 buffy = cachefs_kmem_alloc(buffysize, KM_SLEEP); 7172 7173 iov.iov_base = buffy; 7174 iov.iov_len = buffysize; 7175 uioin.uio_iov = &iov; 7176 uioin.uio_iovcnt = 1; 7177 uioin.uio_segflg = UIO_SYSSPACE; 7178 uioin.uio_fmode = 0; 7179 uioin.uio_extflg = UIO_COPY_CACHED; 7180 uioin.uio_loffset = uiop->uio_loffset; 7181 uioin.uio_resid = buffysize; 7182 7183 (void) VOP_RWLOCK(cp->c_backvp, V_WRITELOCK_FALSE, NULL); 7184 error = VOP_READDIR(cp->c_backvp, &uioin, cr, eofp, NULL, 0); 7185 VOP_RWUNLOCK(cp->c_backvp, V_WRITELOCK_FALSE, NULL); 7186 7187 if (error != 0) 7188 goto out; 7189 7190 end = buffy + buffysize - uioin.uio_resid; 7191 7192 mutex_exit(&cp->c_statelock); 7193 mutex_enter(&fscp->fs_fslock); 7194 7195 7196 for (chrp = buffy; chrp < end; chrp += de->d_reclen) { 7197 de = (dirent64_t *)chrp; 7198 newinum = cachefs_inum_real2fake(fscp, de->d_ino); 7199 if (newinum == 0) 7200 newinum = cachefs_fileno_conflict(fscp, de->d_ino); 7201 de->d_ino = newinum; 7202 } 7203 mutex_exit(&fscp->fs_fslock); 7204 mutex_enter(&cp->c_statelock); 7205 7206 error = uiomove(buffy, end - buffy, UIO_READ, uiop); 7207 uiop->uio_loffset = uioin.uio_loffset; 7208 7209 out: 7210 7211 if (buffy != NULL) 7212 cachefs_kmem_free(buffy, buffysize); 7213 7214 return (error); 7215 } 7216 7217 static int 7218 /*ARGSUSED*/ 7219 cachefs_readdir_disconnected(vnode_t *vp, uio_t *uiop, cred_t *cr, 7220 int *eofp) 7221 { 7222 cnode_t *dcp = VTOC(vp); 7223 int error; 7224 7225 mutex_enter(&dcp->c_statelock); 7226 if ((dcp->c_metadata.md_flags & MD_POPULATED) == 0) { 7227 error = ETIMEDOUT; 7228 } else { 7229 error = cachefs_dir_read(dcp, uiop, eofp); 7230 if (error == ENOTDIR) 7231 error = ETIMEDOUT; 7232 } 7233 mutex_exit(&dcp->c_statelock); 7234 7235 return (error); 7236 } 7237 7238 /*ARGSUSED*/ 7239 static int 7240 cachefs_fid(struct vnode *vp, struct fid *fidp, caller_context_t *ct) 7241 { 7242 int error = 0; 7243 struct cnode *cp = VTOC(vp); 7244 fscache_t *fscp = C_TO_FSCACHE(cp); 7245 7246 /* 7247 * Cachefs only provides pass-through support for NFSv4, 7248 * and all vnode operations are passed through to the 7249 * back file system. For NFSv4 pass-through to work, only 7250 * connected operation is supported, the cnode backvp must 7251 * exist, and cachefs optional (eg., disconnectable) flags 7252 * are turned off. Assert these conditions, then bail 7253 * as NFSv4 doesn't support VOP_FID. 7254 */ 7255 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 7256 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 7257 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { 7258 return (ENOTSUP); 7259 } 7260 7261 mutex_enter(&cp->c_statelock); 7262 if (fidp->fid_len < cp->c_metadata.md_cookie.fid_len) { 7263 fidp->fid_len = cp->c_metadata.md_cookie.fid_len; 7264 error = ENOSPC; 7265 } else { 7266 bcopy(cp->c_metadata.md_cookie.fid_data, fidp->fid_data, 7267 cp->c_metadata.md_cookie.fid_len); 7268 fidp->fid_len = cp->c_metadata.md_cookie.fid_len; 7269 } 7270 mutex_exit(&cp->c_statelock); 7271 return (error); 7272 } 7273 7274 /* ARGSUSED2 */ 7275 static int 7276 cachefs_rwlock(struct vnode *vp, int write_lock, caller_context_t *ctp) 7277 { 7278 cnode_t *cp = VTOC(vp); 7279 7280 /* 7281 * XXX - This is ifdef'ed out for now. The problem - 7282 * getdents() acquires the read version of rwlock, then we come 7283 * into cachefs_readdir() and that wants to acquire the write version 7284 * of this lock (if its going to populate the directory). This is 7285 * a problem, this can be solved by introducing another lock in the 7286 * cnode. 7287 */ 7288 /* XXX */ 7289 if (vp->v_type != VREG) 7290 return (-1); 7291 if (write_lock) 7292 rw_enter(&cp->c_rwlock, RW_WRITER); 7293 else 7294 rw_enter(&cp->c_rwlock, RW_READER); 7295 return (write_lock); 7296 } 7297 7298 /* ARGSUSED */ 7299 static void 7300 cachefs_rwunlock(struct vnode *vp, int write_lock, caller_context_t *ctp) 7301 { 7302 cnode_t *cp = VTOC(vp); 7303 if (vp->v_type != VREG) 7304 return; 7305 rw_exit(&cp->c_rwlock); 7306 } 7307 7308 /* ARGSUSED */ 7309 static int 7310 cachefs_seek(struct vnode *vp, offset_t ooff, offset_t *noffp, 7311 caller_context_t *ct) 7312 { 7313 return (0); 7314 } 7315 7316 static int cachefs_lostpage = 0; 7317 /* 7318 * Return all the pages from [off..off+len] in file 7319 */ 7320 /*ARGSUSED*/ 7321 static int 7322 cachefs_getpage(struct vnode *vp, offset_t off, size_t len, 7323 uint_t *protp, struct page *pl[], size_t plsz, struct seg *seg, 7324 caddr_t addr, enum seg_rw rw, cred_t *cr, caller_context_t *ct) 7325 { 7326 cnode_t *cp = VTOC(vp); 7327 int error; 7328 fscache_t *fscp = C_TO_FSCACHE(cp); 7329 cachefscache_t *cachep = fscp->fs_cache; 7330 int held = 0; 7331 int connected = 0; 7332 7333 #ifdef CFSDEBUG 7334 u_offset_t offx = (u_offset_t)off; 7335 7336 CFS_DEBUG(CFSDEBUG_VOPS) 7337 printf("cachefs_getpage: ENTER vp %p off %lld len %lu rw %d\n", 7338 (void *)vp, offx, len, rw); 7339 #endif 7340 if (getzoneid() != GLOBAL_ZONEID) { 7341 error = EPERM; 7342 goto out; 7343 } 7344 7345 if (vp->v_flag & VNOMAP) { 7346 error = ENOSYS; 7347 goto out; 7348 } 7349 7350 /* Call backfilesystem if NFSv4 */ 7351 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { 7352 error = cachefs_getpage_backfs_nfsv4(vp, off, len, protp, pl, 7353 plsz, seg, addr, rw, cr); 7354 goto out; 7355 } 7356 7357 /* XXX sam: make this do an async populate? */ 7358 if (pl == NULL) { 7359 error = 0; 7360 goto out; 7361 } 7362 if (protp != NULL) 7363 *protp = PROT_ALL; 7364 7365 for (;;) { 7366 /* get (or renew) access to the file system */ 7367 if (held) { 7368 cachefs_cd_release(fscp); 7369 held = 0; 7370 } 7371 error = cachefs_cd_access(fscp, connected, 0); 7372 if (error) 7373 break; 7374 held = 1; 7375 7376 /* 7377 * If we are getting called as a side effect of a 7378 * cachefs_write() 7379 * operation the local file size might not be extended yet. 7380 * In this case we want to be able to return pages of zeroes. 7381 */ 7382 if ((u_offset_t)off + len > 7383 ((cp->c_size + PAGEOFFSET) & (offset_t)PAGEMASK)) { 7384 if (seg != segkmap) { 7385 error = EFAULT; 7386 break; 7387 } 7388 } 7389 error = pvn_getpages(cachefs_getapage, vp, (u_offset_t)off, 7390 len, protp, pl, plsz, seg, addr, rw, cr); 7391 if (error == 0) 7392 break; 7393 7394 if (((cp->c_flags & CN_NOCACHE) && (error == ENOSPC)) || 7395 error == EAGAIN) { 7396 connected = 0; 7397 continue; 7398 } 7399 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 7400 if (CFS_TIMEOUT(fscp, error)) { 7401 cachefs_cd_release(fscp); 7402 held = 0; 7403 cachefs_cd_timedout(fscp); 7404 connected = 0; 7405 continue; 7406 } 7407 } else { 7408 if (CFS_TIMEOUT(fscp, error)) { 7409 if (cachefs_cd_access_miss(fscp)) { 7410 error = pvn_getpages( 7411 cachefs_getapage_back, vp, 7412 (u_offset_t)off, len, protp, pl, 7413 plsz, seg, addr, rw, cr); 7414 if (!CFS_TIMEOUT(fscp, error) && 7415 (error != EAGAIN)) 7416 break; 7417 delay(5*hz); 7418 connected = 0; 7419 continue; 7420 } 7421 connected = 1; 7422 continue; 7423 } 7424 } 7425 break; 7426 } 7427 7428 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_GETPAGE)) 7429 cachefs_log_getpage(cachep, error, vp->v_vfsp, 7430 &cp->c_metadata.md_cookie, cp->c_id.cid_fileno, 7431 crgetuid(cr), off, len); 7432 7433 if (held) { 7434 cachefs_cd_release(fscp); 7435 } 7436 7437 out: 7438 #ifdef CFS_CD_DEBUG 7439 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 7440 #endif 7441 #ifdef CFSDEBUG 7442 CFS_DEBUG(CFSDEBUG_VOPS) 7443 printf("cachefs_getpage: EXIT vp %p error %d\n", 7444 (void *)vp, error); 7445 #endif 7446 return (error); 7447 } 7448 7449 /* 7450 * cachefs_getpage_backfs_nfsv4 7451 * 7452 * Call NFSv4 back filesystem to handle the getpage (cachefs 7453 * pass-through support for NFSv4). 7454 */ 7455 static int 7456 cachefs_getpage_backfs_nfsv4(struct vnode *vp, offset_t off, size_t len, 7457 uint_t *protp, struct page *pl[], size_t plsz, 7458 struct seg *seg, caddr_t addr, enum seg_rw rw, 7459 cred_t *cr) 7460 { 7461 cnode_t *cp = VTOC(vp); 7462 fscache_t *fscp = C_TO_FSCACHE(cp); 7463 vnode_t *backvp; 7464 int error; 7465 7466 /* 7467 * For NFSv4 pass-through to work, only connected operation is 7468 * supported, the cnode backvp must exist, and cachefs optional 7469 * (eg., disconnectable) flags are turned off. Assert these 7470 * conditions for the getpage operation. 7471 */ 7472 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 7473 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 7474 7475 /* Call backfs vnode op after extracting backvp */ 7476 mutex_enter(&cp->c_statelock); 7477 backvp = cp->c_backvp; 7478 mutex_exit(&cp->c_statelock); 7479 7480 CFS_DPRINT_BACKFS_NFSV4(fscp, 7481 ("cachefs_getpage_backfs_nfsv4: cnode %p, backvp %p\n", 7482 cp, backvp)); 7483 error = VOP_GETPAGE(backvp, off, len, protp, pl, plsz, seg, 7484 addr, rw, cr, NULL); 7485 7486 return (error); 7487 } 7488 7489 /* 7490 * Called from pvn_getpages to get a particular page. 7491 */ 7492 /*ARGSUSED*/ 7493 static int 7494 cachefs_getapage(struct vnode *vp, u_offset_t off, size_t len, uint_t *protp, 7495 struct page *pl[], size_t plsz, struct seg *seg, caddr_t addr, 7496 enum seg_rw rw, cred_t *cr) 7497 { 7498 cnode_t *cp = VTOC(vp); 7499 page_t **ppp, *pp = NULL; 7500 fscache_t *fscp = C_TO_FSCACHE(cp); 7501 cachefscache_t *cachep = fscp->fs_cache; 7502 int error = 0; 7503 struct page **ourpl; 7504 struct page *ourstackpl[17]; /* see ASSERT() below for 17 */ 7505 int index = 0; 7506 int downgrade; 7507 int have_statelock = 0; 7508 u_offset_t popoff; 7509 size_t popsize = 0; 7510 7511 /*LINTED*/ 7512 ASSERT(((DEF_POP_SIZE / PAGESIZE) + 1) <= 17); 7513 7514 if (fscp->fs_info.fi_popsize > DEF_POP_SIZE) 7515 ourpl = cachefs_kmem_alloc(sizeof (struct page *) * 7516 ((fscp->fs_info.fi_popsize / PAGESIZE) + 1), KM_SLEEP); 7517 else 7518 ourpl = ourstackpl; 7519 7520 ourpl[0] = NULL; 7521 off = off & (offset_t)PAGEMASK; 7522 again: 7523 /* 7524 * Look for the page 7525 */ 7526 if (page_exists(vp, off) == 0) { 7527 /* 7528 * Need to do work to get the page. 7529 * Grab our lock because we are going to 7530 * modify the state of the cnode. 7531 */ 7532 if (! have_statelock) { 7533 mutex_enter(&cp->c_statelock); 7534 have_statelock = 1; 7535 } 7536 /* 7537 * If we're in NOCACHE mode, we will need a backvp 7538 */ 7539 if (cp->c_flags & CN_NOCACHE) { 7540 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 7541 error = ETIMEDOUT; 7542 goto out; 7543 } 7544 if (cp->c_backvp == NULL) { 7545 error = cachefs_getbackvp(fscp, cp); 7546 if (error) 7547 goto out; 7548 } 7549 error = VOP_GETPAGE(cp->c_backvp, off, 7550 PAGESIZE, protp, ourpl, PAGESIZE, seg, 7551 addr, S_READ, cr, NULL); 7552 /* 7553 * backfs returns EFAULT when we are trying for a 7554 * page beyond EOF but cachefs has the knowledge that 7555 * it is not beyond EOF be cause cp->c_size is 7556 * greater then the offset requested. 7557 */ 7558 if (error == EFAULT) { 7559 error = 0; 7560 pp = page_create_va(vp, off, PAGESIZE, 7561 PG_EXCL | PG_WAIT, seg, addr); 7562 if (pp == NULL) 7563 goto again; 7564 pagezero(pp, 0, PAGESIZE); 7565 pvn_plist_init(pp, pl, plsz, off, PAGESIZE, rw); 7566 goto out; 7567 } 7568 if (error) 7569 goto out; 7570 goto getpages; 7571 } 7572 /* 7573 * We need a front file. If we can't get it, 7574 * put the cnode in NOCACHE mode and try again. 7575 */ 7576 if (cp->c_frontvp == NULL) { 7577 error = cachefs_getfrontfile(cp); 7578 if (error) { 7579 cachefs_nocache(cp); 7580 error = EAGAIN; 7581 goto out; 7582 } 7583 } 7584 /* 7585 * Check if the front file needs population. 7586 * If population is necessary, make sure we have a 7587 * backvp as well. We will get the page from the backvp. 7588 * bug 4152459- 7589 * But if the file system is in disconnected mode 7590 * and the file is a local file then do not check the 7591 * allocmap. 7592 */ 7593 if (((fscp->fs_cdconnected == CFS_CD_CONNECTED) || 7594 ((cp->c_metadata.md_flags & MD_LOCALFILENO) == 0)) && 7595 (cachefs_check_allocmap(cp, off) == 0)) { 7596 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 7597 error = ETIMEDOUT; 7598 goto out; 7599 } 7600 if (cp->c_backvp == NULL) { 7601 error = cachefs_getbackvp(fscp, cp); 7602 if (error) 7603 goto out; 7604 } 7605 if (cp->c_filegrp->fg_flags & CFS_FG_WRITE) { 7606 cachefs_cluster_allocmap(off, &popoff, 7607 &popsize, 7608 fscp->fs_info.fi_popsize, cp); 7609 if (popsize != 0) { 7610 error = cachefs_populate(cp, 7611 popoff, popsize, 7612 cp->c_frontvp, cp->c_backvp, 7613 cp->c_size, cr); 7614 if (error) { 7615 cachefs_nocache(cp); 7616 error = EAGAIN; 7617 goto out; 7618 } else { 7619 cp->c_flags |= 7620 CN_UPDATED | 7621 CN_NEED_FRONT_SYNC | 7622 CN_POPULATION_PENDING; 7623 } 7624 popsize = popsize - (off - popoff); 7625 } else { 7626 popsize = PAGESIZE; 7627 } 7628 } 7629 /* else XXX assert CN_NOCACHE? */ 7630 error = VOP_GETPAGE(cp->c_backvp, (offset_t)off, 7631 PAGESIZE, protp, ourpl, popsize, 7632 seg, addr, S_READ, cr, NULL); 7633 if (error) 7634 goto out; 7635 fscp->fs_stats.st_misses++; 7636 } else { 7637 if (cp->c_flags & CN_POPULATION_PENDING) { 7638 error = VOP_FSYNC(cp->c_frontvp, FSYNC, cr, 7639 NULL); 7640 cp->c_flags &= ~CN_POPULATION_PENDING; 7641 if (error) { 7642 cachefs_nocache(cp); 7643 error = EAGAIN; 7644 goto out; 7645 } 7646 } 7647 /* 7648 * File was populated so we get the page from the 7649 * frontvp 7650 */ 7651 error = VOP_GETPAGE(cp->c_frontvp, (offset_t)off, 7652 PAGESIZE, protp, ourpl, PAGESIZE, seg, addr, 7653 rw, cr, NULL); 7654 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_GPFRONT)) 7655 cachefs_log_gpfront(cachep, error, 7656 fscp->fs_cfsvfsp, 7657 &cp->c_metadata.md_cookie, cp->c_fileno, 7658 crgetuid(cr), off, PAGESIZE); 7659 if (error) { 7660 cachefs_nocache(cp); 7661 error = EAGAIN; 7662 goto out; 7663 } 7664 fscp->fs_stats.st_hits++; 7665 } 7666 getpages: 7667 ASSERT(have_statelock); 7668 if (have_statelock) { 7669 mutex_exit(&cp->c_statelock); 7670 have_statelock = 0; 7671 } 7672 downgrade = 0; 7673 for (ppp = ourpl; *ppp; ppp++) { 7674 if ((*ppp)->p_offset < off) { 7675 index++; 7676 page_unlock(*ppp); 7677 continue; 7678 } 7679 if (PAGE_SHARED(*ppp)) { 7680 if (page_tryupgrade(*ppp) == 0) { 7681 for (ppp = &ourpl[index]; *ppp; ppp++) 7682 page_unlock(*ppp); 7683 error = EAGAIN; 7684 goto out; 7685 } 7686 downgrade = 1; 7687 } 7688 ASSERT(PAGE_EXCL(*ppp)); 7689 (void) hat_pageunload((*ppp), HAT_FORCE_PGUNLOAD); 7690 page_rename(*ppp, vp, (*ppp)->p_offset); 7691 } 7692 pl[0] = ourpl[index]; 7693 pl[1] = NULL; 7694 if (downgrade) { 7695 page_downgrade(ourpl[index]); 7696 } 7697 /* Unlock the rest of the pages from the cluster */ 7698 for (ppp = &ourpl[index+1]; *ppp; ppp++) 7699 page_unlock(*ppp); 7700 } else { 7701 ASSERT(! have_statelock); 7702 if (have_statelock) { 7703 mutex_exit(&cp->c_statelock); 7704 have_statelock = 0; 7705 } 7706 /* XXX SE_SHARED probably isn't what we *always* want */ 7707 if ((pp = page_lookup(vp, off, SE_SHARED)) == NULL) { 7708 cachefs_lostpage++; 7709 goto again; 7710 } 7711 pl[0] = pp; 7712 pl[1] = NULL; 7713 /* XXX increment st_hits? i don't think so, but... */ 7714 } 7715 7716 out: 7717 if (have_statelock) { 7718 mutex_exit(&cp->c_statelock); 7719 have_statelock = 0; 7720 } 7721 if (fscp->fs_info.fi_popsize > DEF_POP_SIZE) 7722 cachefs_kmem_free(ourpl, sizeof (struct page *) * 7723 ((fscp->fs_info.fi_popsize / PAGESIZE) + 1)); 7724 return (error); 7725 } 7726 7727 /* gets a page but only from the back fs */ 7728 /*ARGSUSED*/ 7729 static int 7730 cachefs_getapage_back(struct vnode *vp, u_offset_t off, size_t len, 7731 uint_t *protp, struct page *pl[], size_t plsz, struct seg *seg, 7732 caddr_t addr, enum seg_rw rw, cred_t *cr) 7733 { 7734 cnode_t *cp = VTOC(vp); 7735 page_t **ppp, *pp = NULL; 7736 fscache_t *fscp = C_TO_FSCACHE(cp); 7737 int error = 0; 7738 struct page *ourpl[17]; 7739 int index = 0; 7740 int have_statelock = 0; 7741 int downgrade; 7742 7743 /* 7744 * Grab the cnode statelock so the cnode state won't change 7745 * while we're in here. 7746 */ 7747 ourpl[0] = NULL; 7748 off = off & (offset_t)PAGEMASK; 7749 again: 7750 if (page_exists(vp, off) == 0) { 7751 if (! have_statelock) { 7752 mutex_enter(&cp->c_statelock); 7753 have_statelock = 1; 7754 } 7755 7756 if (cp->c_backvp == NULL) { 7757 error = cachefs_getbackvp(fscp, cp); 7758 if (error) 7759 goto out; 7760 } 7761 error = VOP_GETPAGE(cp->c_backvp, (offset_t)off, 7762 PAGESIZE, protp, ourpl, PAGESIZE, seg, 7763 addr, S_READ, cr, NULL); 7764 if (error) 7765 goto out; 7766 7767 if (have_statelock) { 7768 mutex_exit(&cp->c_statelock); 7769 have_statelock = 0; 7770 } 7771 downgrade = 0; 7772 for (ppp = ourpl; *ppp; ppp++) { 7773 if ((*ppp)->p_offset < off) { 7774 index++; 7775 page_unlock(*ppp); 7776 continue; 7777 } 7778 if (PAGE_SHARED(*ppp)) { 7779 if (page_tryupgrade(*ppp) == 0) { 7780 for (ppp = &ourpl[index]; *ppp; ppp++) 7781 page_unlock(*ppp); 7782 error = EAGAIN; 7783 goto out; 7784 } 7785 downgrade = 1; 7786 } 7787 ASSERT(PAGE_EXCL(*ppp)); 7788 (void) hat_pageunload((*ppp), HAT_FORCE_PGUNLOAD); 7789 page_rename(*ppp, vp, (*ppp)->p_offset); 7790 } 7791 pl[0] = ourpl[index]; 7792 pl[1] = NULL; 7793 if (downgrade) { 7794 page_downgrade(ourpl[index]); 7795 } 7796 /* Unlock the rest of the pages from the cluster */ 7797 for (ppp = &ourpl[index+1]; *ppp; ppp++) 7798 page_unlock(*ppp); 7799 } else { 7800 ASSERT(! have_statelock); 7801 if (have_statelock) { 7802 mutex_exit(&cp->c_statelock); 7803 have_statelock = 0; 7804 } 7805 if ((pp = page_lookup(vp, off, SE_SHARED)) == NULL) { 7806 cachefs_lostpage++; 7807 goto again; 7808 } 7809 pl[0] = pp; 7810 pl[1] = NULL; 7811 } 7812 7813 out: 7814 if (have_statelock) { 7815 mutex_exit(&cp->c_statelock); 7816 have_statelock = 0; 7817 } 7818 return (error); 7819 } 7820 7821 /*ARGSUSED*/ 7822 static int 7823 cachefs_putpage(vnode_t *vp, offset_t off, size_t len, int flags, cred_t *cr, 7824 caller_context_t *ct) 7825 { 7826 cnode_t *cp = VTOC(vp); 7827 int error = 0; 7828 fscache_t *fscp = C_TO_FSCACHE(cp); 7829 int held = 0; 7830 int connected = 0; 7831 7832 if (getzoneid() != GLOBAL_ZONEID) 7833 return (EPERM); 7834 7835 /* Call backfilesytem if NFSv4 */ 7836 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { 7837 error = cachefs_putpage_backfs_nfsv4(vp, off, len, flags, cr); 7838 goto out; 7839 } 7840 7841 for (;;) { 7842 /* get (or renew) access to the file system */ 7843 if (held) { 7844 cachefs_cd_release(fscp); 7845 held = 0; 7846 } 7847 error = cachefs_cd_access(fscp, connected, 1); 7848 if (error) 7849 break; 7850 held = 1; 7851 7852 error = cachefs_putpage_common(vp, off, len, flags, cr); 7853 if (error == 0) 7854 break; 7855 7856 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 7857 if (CFS_TIMEOUT(fscp, error)) { 7858 cachefs_cd_release(fscp); 7859 held = 0; 7860 cachefs_cd_timedout(fscp); 7861 connected = 0; 7862 continue; 7863 } 7864 } else { 7865 if (NOMEMWAIT()) { 7866 error = 0; 7867 goto out; 7868 } 7869 if (CFS_TIMEOUT(fscp, error)) { 7870 connected = 1; 7871 continue; 7872 } 7873 } 7874 break; 7875 } 7876 7877 out: 7878 7879 if (held) { 7880 cachefs_cd_release(fscp); 7881 } 7882 7883 #ifdef CFS_CD_DEBUG 7884 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 7885 #endif 7886 return (error); 7887 } 7888 7889 /* 7890 * cachefs_putpage_backfs_nfsv4 7891 * 7892 * Call NFSv4 back filesystem to handle the putpage (cachefs 7893 * pass-through support for NFSv4). 7894 */ 7895 static int 7896 cachefs_putpage_backfs_nfsv4(vnode_t *vp, offset_t off, size_t len, int flags, 7897 cred_t *cr) 7898 { 7899 cnode_t *cp = VTOC(vp); 7900 fscache_t *fscp = C_TO_FSCACHE(cp); 7901 vnode_t *backvp; 7902 int error; 7903 7904 /* 7905 * For NFSv4 pass-through to work, only connected operation is 7906 * supported, the cnode backvp must exist, and cachefs optional 7907 * (eg., disconnectable) flags are turned off. Assert these 7908 * conditions for the putpage operation. 7909 */ 7910 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 7911 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 7912 7913 /* Call backfs vnode op after extracting backvp */ 7914 mutex_enter(&cp->c_statelock); 7915 backvp = cp->c_backvp; 7916 mutex_exit(&cp->c_statelock); 7917 7918 CFS_DPRINT_BACKFS_NFSV4(fscp, 7919 ("cachefs_putpage_backfs_nfsv4: cnode %p, backvp %p\n", 7920 cp, backvp)); 7921 error = VOP_PUTPAGE(backvp, off, len, flags, cr, NULL); 7922 7923 return (error); 7924 } 7925 7926 /* 7927 * Flags are composed of {B_INVAL, B_FREE, B_DONTNEED, B_FORCE} 7928 * If len == 0, do from off to EOF. 7929 * 7930 * The normal cases should be len == 0 & off == 0 (entire vp list), 7931 * len == MAXBSIZE (from segmap_release actions), and len == PAGESIZE 7932 * (from pageout). 7933 */ 7934 7935 /*ARGSUSED*/ 7936 int 7937 cachefs_putpage_common(struct vnode *vp, offset_t off, size_t len, 7938 int flags, cred_t *cr) 7939 { 7940 struct cnode *cp = VTOC(vp); 7941 struct page *pp; 7942 size_t io_len; 7943 u_offset_t eoff, io_off; 7944 int error = 0; 7945 fscache_t *fscp = C_TO_FSCACHE(cp); 7946 cachefscache_t *cachep = fscp->fs_cache; 7947 7948 if (len == 0 && (flags & B_INVAL) == 0 && vn_is_readonly(vp)) { 7949 return (0); 7950 } 7951 if (!vn_has_cached_data(vp) || (off >= cp->c_size && 7952 (flags & B_INVAL) == 0)) 7953 return (0); 7954 7955 /* 7956 * Should never have cached data for the cachefs vnode 7957 * if NFSv4 is in use. 7958 */ 7959 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 7960 7961 /* 7962 * If this is an async putpage let a thread handle it. 7963 */ 7964 if (flags & B_ASYNC) { 7965 struct cachefs_req *rp; 7966 int tflags = (flags & ~(B_ASYNC|B_DONTNEED)); 7967 7968 if (ttoproc(curthread) == proc_pageout) { 7969 /* 7970 * If this is the page daemon we 7971 * do the push synchronously (Dangerous!) and hope 7972 * we can free enough to keep running... 7973 */ 7974 flags &= ~B_ASYNC; 7975 goto again; 7976 } 7977 7978 if (! cachefs_async_okay()) { 7979 7980 /* 7981 * this is somewhat like NFS's behavior. keep 7982 * the system from thrashing. we've seen 7983 * cases where async queues get out of 7984 * control, especially if 7985 * madvise(MADV_SEQUENTIAL) is done on a large 7986 * mmap()ed file that is read sequentially. 7987 */ 7988 7989 flags &= ~B_ASYNC; 7990 goto again; 7991 } 7992 7993 /* 7994 * if no flags other than B_ASYNC were set, 7995 * we coalesce putpage requests into a single one for the 7996 * whole file (len = off = 0). If such a request is 7997 * already queued, we're done. 7998 * 7999 * If there are other flags set (e.g., B_INVAL), we don't 8000 * attempt to coalesce and we use the specified length and 8001 * offset. 8002 */ 8003 rp = kmem_cache_alloc(cachefs_req_cache, KM_SLEEP); 8004 mutex_enter(&cp->c_iomutex); 8005 if ((cp->c_ioflags & CIO_PUTPAGES) == 0 || tflags != 0) { 8006 rp->cfs_cmd = CFS_PUTPAGE; 8007 rp->cfs_req_u.cu_putpage.cp_vp = vp; 8008 if (tflags == 0) { 8009 off = len = 0; 8010 cp->c_ioflags |= CIO_PUTPAGES; 8011 } 8012 rp->cfs_req_u.cu_putpage.cp_off = off; 8013 rp->cfs_req_u.cu_putpage.cp_len = (uint_t)len; 8014 rp->cfs_req_u.cu_putpage.cp_flags = flags & ~B_ASYNC; 8015 rp->cfs_cr = cr; 8016 crhold(rp->cfs_cr); 8017 VN_HOLD(vp); 8018 cp->c_nio++; 8019 cachefs_addqueue(rp, &(C_TO_FSCACHE(cp)->fs_workq)); 8020 } else { 8021 kmem_cache_free(cachefs_req_cache, rp); 8022 } 8023 8024 mutex_exit(&cp->c_iomutex); 8025 return (0); 8026 } 8027 8028 8029 again: 8030 if (len == 0) { 8031 /* 8032 * Search the entire vp list for pages >= off 8033 */ 8034 error = pvn_vplist_dirty(vp, off, cachefs_push, flags, cr); 8035 } else { 8036 /* 8037 * Do a range from [off...off + len] looking for pages 8038 * to deal with. 8039 */ 8040 eoff = (u_offset_t)off + len; 8041 for (io_off = off; io_off < eoff && io_off < cp->c_size; 8042 io_off += io_len) { 8043 /* 8044 * If we are not invalidating, synchronously 8045 * freeing or writing pages use the routine 8046 * page_lookup_nowait() to prevent reclaiming 8047 * them from the free list. 8048 */ 8049 if ((flags & B_INVAL) || ((flags & B_ASYNC) == 0)) { 8050 pp = page_lookup(vp, io_off, 8051 (flags & (B_INVAL | B_FREE)) ? 8052 SE_EXCL : SE_SHARED); 8053 } else { 8054 /* XXX this looks like dead code */ 8055 pp = page_lookup_nowait(vp, io_off, 8056 (flags & B_FREE) ? SE_EXCL : SE_SHARED); 8057 } 8058 8059 if (pp == NULL || pvn_getdirty(pp, flags) == 0) 8060 io_len = PAGESIZE; 8061 else { 8062 error = cachefs_push(vp, pp, &io_off, 8063 &io_len, flags, cr); 8064 if (error != 0) 8065 break; 8066 /* 8067 * "io_off" and "io_len" are returned as 8068 * the range of pages we actually wrote. 8069 * This allows us to skip ahead more quickly 8070 * since several pages may've been dealt 8071 * with by this iteration of the loop. 8072 */ 8073 } 8074 } 8075 } 8076 8077 if (error == 0 && off == 0 && (len == 0 || len >= cp->c_size)) { 8078 cp->c_flags &= ~CDIRTY; 8079 } 8080 8081 if (CACHEFS_LOG_LOGGING(cachep, CACHEFS_LOG_PUTPAGE)) 8082 cachefs_log_putpage(cachep, error, fscp->fs_cfsvfsp, 8083 &cp->c_metadata.md_cookie, cp->c_id.cid_fileno, 8084 crgetuid(cr), off, len); 8085 8086 return (error); 8087 8088 } 8089 8090 /*ARGSUSED*/ 8091 static int 8092 cachefs_map(struct vnode *vp, offset_t off, struct as *as, caddr_t *addrp, 8093 size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cr, 8094 caller_context_t *ct) 8095 { 8096 cnode_t *cp = VTOC(vp); 8097 fscache_t *fscp = C_TO_FSCACHE(cp); 8098 struct segvn_crargs vn_a; 8099 int error; 8100 int held = 0; 8101 int writing; 8102 int connected = 0; 8103 8104 #ifdef CFSDEBUG 8105 u_offset_t offx = (u_offset_t)off; 8106 8107 CFS_DEBUG(CFSDEBUG_VOPS) 8108 printf("cachefs_map: ENTER vp %p off %lld len %lu flags %d\n", 8109 (void *)vp, offx, len, flags); 8110 #endif 8111 if (getzoneid() != GLOBAL_ZONEID) { 8112 error = EPERM; 8113 goto out; 8114 } 8115 8116 if (vp->v_flag & VNOMAP) { 8117 error = ENOSYS; 8118 goto out; 8119 } 8120 if (off < 0 || (offset_t)(off + len) < 0) { 8121 error = ENXIO; 8122 goto out; 8123 } 8124 if (vp->v_type != VREG) { 8125 error = ENODEV; 8126 goto out; 8127 } 8128 8129 /* 8130 * Check to see if the vnode is currently marked as not cachable. 8131 * If so, we have to refuse the map request as this violates the 8132 * don't cache attribute. 8133 */ 8134 if (vp->v_flag & VNOCACHE) 8135 return (EAGAIN); 8136 8137 #ifdef OBSOLETE 8138 /* 8139 * If file is being locked, disallow mapping. 8140 */ 8141 if (vn_has_flocks(vp)) { 8142 error = EAGAIN; 8143 goto out; 8144 } 8145 #endif 8146 8147 /* call backfilesystem if NFSv4 */ 8148 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { 8149 error = cachefs_map_backfs_nfsv4(vp, off, as, addrp, len, prot, 8150 maxprot, flags, cr); 8151 goto out; 8152 } 8153 8154 writing = (prot & PROT_WRITE && ((flags & MAP_PRIVATE) == 0)); 8155 8156 for (;;) { 8157 /* get (or renew) access to the file system */ 8158 if (held) { 8159 cachefs_cd_release(fscp); 8160 held = 0; 8161 } 8162 error = cachefs_cd_access(fscp, connected, writing); 8163 if (error) 8164 break; 8165 held = 1; 8166 8167 if (writing) { 8168 mutex_enter(&cp->c_statelock); 8169 if (CFS_ISFS_WRITE_AROUND(fscp)) { 8170 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 8171 connected = 1; 8172 continue; 8173 } else { 8174 cachefs_nocache(cp); 8175 } 8176 } 8177 8178 /* 8179 * CN_MAPWRITE is for an optimization in cachefs_delmap. 8180 * If CN_MAPWRITE is not set then cachefs_delmap does 8181 * not need to try to push out any pages. 8182 * This bit gets cleared when the cnode goes inactive. 8183 */ 8184 cp->c_flags |= CN_MAPWRITE; 8185 8186 mutex_exit(&cp->c_statelock); 8187 } 8188 break; 8189 } 8190 8191 if (held) { 8192 cachefs_cd_release(fscp); 8193 } 8194 8195 as_rangelock(as); 8196 error = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags); 8197 if (error != 0) { 8198 as_rangeunlock(as); 8199 goto out; 8200 } 8201 8202 /* 8203 * package up all the data passed in into a segvn_args struct and 8204 * call as_map with segvn_create function to create a new segment 8205 * in the address space. 8206 */ 8207 vn_a.vp = vp; 8208 vn_a.offset = off; 8209 vn_a.type = flags & MAP_TYPE; 8210 vn_a.prot = (uchar_t)prot; 8211 vn_a.maxprot = (uchar_t)maxprot; 8212 vn_a.cred = cr; 8213 vn_a.amp = NULL; 8214 vn_a.flags = flags & ~MAP_TYPE; 8215 vn_a.szc = 0; 8216 vn_a.lgrp_mem_policy_flags = 0; 8217 error = as_map(as, *addrp, len, segvn_create, &vn_a); 8218 as_rangeunlock(as); 8219 out: 8220 8221 #ifdef CFS_CD_DEBUG 8222 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 8223 #endif 8224 #ifdef CFSDEBUG 8225 CFS_DEBUG(CFSDEBUG_VOPS) 8226 printf("cachefs_map: EXIT vp %p error %d\n", (void *)vp, error); 8227 #endif 8228 return (error); 8229 } 8230 8231 /* 8232 * cachefs_map_backfs_nfsv4 8233 * 8234 * Call NFSv4 back filesystem to handle the map (cachefs 8235 * pass-through support for NFSv4). 8236 */ 8237 static int 8238 cachefs_map_backfs_nfsv4(struct vnode *vp, offset_t off, struct as *as, 8239 caddr_t *addrp, size_t len, uchar_t prot, 8240 uchar_t maxprot, uint_t flags, cred_t *cr) 8241 { 8242 cnode_t *cp = VTOC(vp); 8243 fscache_t *fscp = C_TO_FSCACHE(cp); 8244 vnode_t *backvp; 8245 int error; 8246 8247 /* 8248 * For NFSv4 pass-through to work, only connected operation is 8249 * supported, the cnode backvp must exist, and cachefs optional 8250 * (eg., disconnectable) flags are turned off. Assert these 8251 * conditions for the map operation. 8252 */ 8253 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 8254 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 8255 8256 /* Call backfs vnode op after extracting backvp */ 8257 mutex_enter(&cp->c_statelock); 8258 backvp = cp->c_backvp; 8259 mutex_exit(&cp->c_statelock); 8260 8261 CFS_DPRINT_BACKFS_NFSV4(fscp, 8262 ("cachefs_map_backfs_nfsv4: cnode %p, backvp %p\n", 8263 cp, backvp)); 8264 error = VOP_MAP(backvp, off, as, addrp, len, prot, maxprot, flags, cr, 8265 NULL); 8266 8267 return (error); 8268 } 8269 8270 /*ARGSUSED*/ 8271 static int 8272 cachefs_addmap(struct vnode *vp, offset_t off, struct as *as, 8273 caddr_t addr, size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, 8274 cred_t *cr, caller_context_t *ct) 8275 { 8276 cnode_t *cp = VTOC(vp); 8277 fscache_t *fscp = C_TO_FSCACHE(cp); 8278 8279 if (getzoneid() != GLOBAL_ZONEID) 8280 return (EPERM); 8281 8282 if (vp->v_flag & VNOMAP) 8283 return (ENOSYS); 8284 8285 /* 8286 * Check this is not an NFSv4 filesystem, as the mapping 8287 * is not done on the cachefs filesystem if NFSv4 is in 8288 * use. 8289 */ 8290 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 8291 8292 mutex_enter(&cp->c_statelock); 8293 cp->c_mapcnt += btopr(len); 8294 mutex_exit(&cp->c_statelock); 8295 return (0); 8296 } 8297 8298 /*ARGSUSED*/ 8299 static int 8300 cachefs_delmap(struct vnode *vp, offset_t off, struct as *as, 8301 caddr_t addr, size_t len, uint_t prot, uint_t maxprot, uint_t flags, 8302 cred_t *cr, caller_context_t *ct) 8303 { 8304 cnode_t *cp = VTOC(vp); 8305 fscache_t *fscp = C_TO_FSCACHE(cp); 8306 int error; 8307 int connected = 0; 8308 int held = 0; 8309 8310 /* 8311 * The file may be passed in to (or inherited into) the zone, so we 8312 * need to let this operation go through since it happens as part of 8313 * exiting. 8314 */ 8315 if (vp->v_flag & VNOMAP) 8316 return (ENOSYS); 8317 8318 /* 8319 * Check this is not an NFSv4 filesystem, as the mapping 8320 * is not done on the cachefs filesystem if NFSv4 is in 8321 * use. 8322 */ 8323 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 8324 8325 mutex_enter(&cp->c_statelock); 8326 cp->c_mapcnt -= btopr(len); 8327 ASSERT(cp->c_mapcnt >= 0); 8328 mutex_exit(&cp->c_statelock); 8329 8330 if (cp->c_mapcnt || !vn_has_cached_data(vp) || 8331 ((cp->c_flags & CN_MAPWRITE) == 0)) 8332 return (0); 8333 8334 for (;;) { 8335 /* get (or renew) access to the file system */ 8336 if (held) { 8337 cachefs_cd_release(fscp); 8338 held = 0; 8339 } 8340 error = cachefs_cd_access(fscp, connected, 1); 8341 if (error) 8342 break; 8343 held = 1; 8344 connected = 0; 8345 8346 error = cachefs_putpage_common(vp, (offset_t)0, 8347 (uint_t)0, 0, cr); 8348 if (CFS_TIMEOUT(fscp, error)) { 8349 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 8350 cachefs_cd_release(fscp); 8351 held = 0; 8352 cachefs_cd_timedout(fscp); 8353 continue; 8354 } else { 8355 connected = 1; 8356 continue; 8357 } 8358 } 8359 8360 /* if no space left in cache, wait until connected */ 8361 if ((error == ENOSPC) && 8362 (fscp->fs_cdconnected != CFS_CD_CONNECTED)) { 8363 connected = 1; 8364 continue; 8365 } 8366 8367 mutex_enter(&cp->c_statelock); 8368 if (!error) 8369 error = cp->c_error; 8370 cp->c_error = 0; 8371 mutex_exit(&cp->c_statelock); 8372 break; 8373 } 8374 8375 if (held) 8376 cachefs_cd_release(fscp); 8377 8378 #ifdef CFS_CD_DEBUG 8379 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 8380 #endif 8381 return (error); 8382 } 8383 8384 /* ARGSUSED */ 8385 static int 8386 cachefs_frlock(struct vnode *vp, int cmd, struct flock64 *bfp, int flag, 8387 offset_t offset, struct flk_callback *flk_cbp, cred_t *cr, 8388 caller_context_t *ct) 8389 { 8390 struct cnode *cp = VTOC(vp); 8391 int error; 8392 struct fscache *fscp = C_TO_FSCACHE(cp); 8393 vnode_t *backvp; 8394 int held = 0; 8395 int connected = 0; 8396 8397 if (getzoneid() != GLOBAL_ZONEID) 8398 return (EPERM); 8399 8400 if ((cmd != F_GETLK) && (cmd != F_SETLK) && (cmd != F_SETLKW)) 8401 return (EINVAL); 8402 8403 /* Disallow locking of files that are currently mapped */ 8404 if (((cmd == F_SETLK) || (cmd == F_SETLKW)) && (cp->c_mapcnt > 0)) { 8405 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 8406 return (EAGAIN); 8407 } 8408 8409 /* 8410 * Cachefs only provides pass-through support for NFSv4, 8411 * and all vnode operations are passed through to the 8412 * back file system. For NFSv4 pass-through to work, only 8413 * connected operation is supported, the cnode backvp must 8414 * exist, and cachefs optional (eg., disconnectable) flags 8415 * are turned off. Assert these conditions to ensure that 8416 * the backfilesystem is called for the frlock operation. 8417 */ 8418 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 8419 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 8420 8421 /* XXX bob: nfs does a bunch more checks than we do */ 8422 if (CFS_ISFS_LLOCK(fscp)) { 8423 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 8424 return (fs_frlock(vp, cmd, bfp, flag, offset, flk_cbp, cr, ct)); 8425 } 8426 8427 for (;;) { 8428 /* get (or renew) access to the file system */ 8429 if (held) { 8430 /* Won't loop with NFSv4 connected behavior */ 8431 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 8432 cachefs_cd_release(fscp); 8433 held = 0; 8434 } 8435 error = cachefs_cd_access(fscp, connected, 0); 8436 if (error) 8437 break; 8438 held = 1; 8439 8440 /* if not connected, quit or wait */ 8441 if (fscp->fs_cdconnected != CFS_CD_CONNECTED) { 8442 connected = 1; 8443 continue; 8444 } 8445 8446 /* nocache the file */ 8447 if ((cp->c_flags & CN_NOCACHE) == 0 && 8448 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 8449 mutex_enter(&cp->c_statelock); 8450 cachefs_nocache(cp); 8451 mutex_exit(&cp->c_statelock); 8452 } 8453 8454 /* 8455 * XXX bob: probably should do a consistency check 8456 * Pass arguments unchanged if NFSv4 is the backfs. 8457 */ 8458 if (bfp->l_whence == 2 && CFS_ISFS_BACKFS_NFSV4(fscp) == 0) { 8459 bfp->l_start += cp->c_size; 8460 bfp->l_whence = 0; 8461 } 8462 8463 /* get the back vp */ 8464 mutex_enter(&cp->c_statelock); 8465 if (cp->c_backvp == NULL) { 8466 error = cachefs_getbackvp(fscp, cp); 8467 if (error) { 8468 mutex_exit(&cp->c_statelock); 8469 break; 8470 } 8471 } 8472 backvp = cp->c_backvp; 8473 VN_HOLD(backvp); 8474 mutex_exit(&cp->c_statelock); 8475 8476 /* 8477 * make sure we can flush currently dirty pages before 8478 * allowing the lock 8479 */ 8480 if (bfp->l_type != F_UNLCK && cmd != F_GETLK && 8481 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 8482 error = cachefs_putpage( 8483 vp, (offset_t)0, 0, B_INVAL, cr, ct); 8484 if (error) { 8485 error = ENOLCK; 8486 VN_RELE(backvp); 8487 break; 8488 } 8489 } 8490 8491 /* do lock on the back file */ 8492 CFS_DPRINT_BACKFS_NFSV4(fscp, 8493 ("cachefs_frlock (nfsv4): cp %p, backvp %p\n", 8494 cp, backvp)); 8495 error = VOP_FRLOCK(backvp, cmd, bfp, flag, offset, NULL, cr, 8496 ct); 8497 VN_RELE(backvp); 8498 if (CFS_TIMEOUT(fscp, error)) { 8499 connected = 1; 8500 continue; 8501 } 8502 break; 8503 } 8504 8505 if (held) { 8506 cachefs_cd_release(fscp); 8507 } 8508 8509 /* 8510 * If we are setting a lock mark the vnode VNOCACHE so the page 8511 * cache does not give inconsistent results on locked files shared 8512 * between clients. The VNOCACHE flag is never turned off as long 8513 * as the vnode is active because it is hard to figure out when the 8514 * last lock is gone. 8515 * XXX - what if some already has the vnode mapped in? 8516 * XXX bob: see nfs3_frlock, do not allow locking if vnode mapped in. 8517 */ 8518 if ((error == 0) && (bfp->l_type != F_UNLCK) && (cmd != F_GETLK) && 8519 !CFS_ISFS_BACKFS_NFSV4(fscp)) 8520 vp->v_flag |= VNOCACHE; 8521 8522 #ifdef CFS_CD_DEBUG 8523 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 8524 #endif 8525 return (error); 8526 } 8527 8528 /* 8529 * Free storage space associated with the specified vnode. The portion 8530 * to be freed is specified by bfp->l_start and bfp->l_len (already 8531 * normalized to a "whence" of 0). 8532 * 8533 * This is an experimental facility whose continued existence is not 8534 * guaranteed. Currently, we only support the special case 8535 * of l_len == 0, meaning free to end of file. 8536 */ 8537 /* ARGSUSED */ 8538 static int 8539 cachefs_space(struct vnode *vp, int cmd, struct flock64 *bfp, int flag, 8540 offset_t offset, cred_t *cr, caller_context_t *ct) 8541 { 8542 cnode_t *cp = VTOC(vp); 8543 fscache_t *fscp = C_TO_FSCACHE(cp); 8544 int error; 8545 8546 ASSERT(vp->v_type == VREG); 8547 if (getzoneid() != GLOBAL_ZONEID) 8548 return (EPERM); 8549 if (cmd != F_FREESP) 8550 return (EINVAL); 8551 8552 /* call backfilesystem if NFSv4 */ 8553 if (CFS_ISFS_BACKFS_NFSV4(fscp)) { 8554 error = cachefs_space_backfs_nfsv4(vp, cmd, bfp, flag, 8555 offset, cr, ct); 8556 goto out; 8557 } 8558 8559 if ((error = convoff(vp, bfp, 0, offset)) == 0) { 8560 ASSERT(bfp->l_start >= 0); 8561 if (bfp->l_len == 0) { 8562 struct vattr va; 8563 8564 va.va_size = bfp->l_start; 8565 va.va_mask = AT_SIZE; 8566 error = cachefs_setattr(vp, &va, 0, cr, ct); 8567 } else 8568 error = EINVAL; 8569 } 8570 8571 out: 8572 return (error); 8573 } 8574 8575 /* 8576 * cachefs_space_backfs_nfsv4 8577 * 8578 * Call NFSv4 back filesystem to handle the space (cachefs 8579 * pass-through support for NFSv4). 8580 */ 8581 static int 8582 cachefs_space_backfs_nfsv4(struct vnode *vp, int cmd, struct flock64 *bfp, 8583 int flag, offset_t offset, cred_t *cr, caller_context_t *ct) 8584 { 8585 cnode_t *cp = VTOC(vp); 8586 fscache_t *fscp = C_TO_FSCACHE(cp); 8587 vnode_t *backvp; 8588 int error; 8589 8590 /* 8591 * For NFSv4 pass-through to work, only connected operation is 8592 * supported, the cnode backvp must exist, and cachefs optional 8593 * (eg., disconnectable) flags are turned off. Assert these 8594 * conditions for the space operation. 8595 */ 8596 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 8597 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 8598 8599 /* Call backfs vnode op after extracting backvp */ 8600 mutex_enter(&cp->c_statelock); 8601 backvp = cp->c_backvp; 8602 mutex_exit(&cp->c_statelock); 8603 8604 CFS_DPRINT_BACKFS_NFSV4(fscp, 8605 ("cachefs_space_backfs_nfsv4: cnode %p, backvp %p\n", 8606 cp, backvp)); 8607 error = VOP_SPACE(backvp, cmd, bfp, flag, offset, cr, ct); 8608 8609 return (error); 8610 } 8611 8612 /*ARGSUSED*/ 8613 static int 8614 cachefs_realvp(struct vnode *vp, struct vnode **vpp, caller_context_t *ct) 8615 { 8616 return (EINVAL); 8617 } 8618 8619 /*ARGSUSED*/ 8620 static int 8621 cachefs_pageio(struct vnode *vp, page_t *pp, u_offset_t io_off, size_t io_len, 8622 int flags, cred_t *cr, caller_context_t *ct) 8623 { 8624 return (ENOSYS); 8625 } 8626 8627 static int 8628 cachefs_setsecattr_connected(cnode_t *cp, 8629 vsecattr_t *vsec, int flag, cred_t *cr) 8630 { 8631 fscache_t *fscp = C_TO_FSCACHE(cp); 8632 int error = 0; 8633 8634 ASSERT(RW_WRITE_HELD(&cp->c_rwlock)); 8635 ASSERT((fscp->fs_info.fi_mntflags & CFS_NOACL) == 0); 8636 8637 mutex_enter(&cp->c_statelock); 8638 8639 if (cp->c_backvp == NULL) { 8640 error = cachefs_getbackvp(fscp, cp); 8641 if (error) { 8642 cachefs_nocache(cp); 8643 goto out; 8644 } 8645 } 8646 8647 error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr); 8648 if (error) 8649 goto out; 8650 8651 /* only owner can set acl */ 8652 if (cp->c_metadata.md_vattr.va_uid != crgetuid(cr)) { 8653 error = EINVAL; 8654 goto out; 8655 } 8656 8657 8658 CFS_DPRINT_BACKFS_NFSV4(fscp, 8659 ("cachefs_setsecattr (nfsv4): cp %p, backvp %p", 8660 cp, cp->c_backvp)); 8661 error = VOP_SETSECATTR(cp->c_backvp, vsec, flag, cr, NULL); 8662 if (error) { 8663 goto out; 8664 } 8665 8666 if ((cp->c_filegrp->fg_flags & CFS_FG_WRITE) == 0 && 8667 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 8668 cachefs_nocache(cp); 8669 goto out; 8670 } 8671 8672 CFSOP_MODIFY_COBJECT(fscp, cp, cr); 8673 8674 /* acl may have changed permissions -- handle this. */ 8675 if (!CFS_ISFS_BACKFS_NFSV4(fscp)) 8676 cachefs_acl2perm(cp, vsec); 8677 8678 if ((cp->c_flags & CN_NOCACHE) == 0 && 8679 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 8680 error = cachefs_cacheacl(cp, vsec); 8681 if (error != 0) { 8682 #ifdef CFSDEBUG 8683 CFS_DEBUG(CFSDEBUG_VOPS) 8684 printf("cachefs_setacl: cacheacl: error %d\n", 8685 error); 8686 #endif /* CFSDEBUG */ 8687 error = 0; 8688 cachefs_nocache(cp); 8689 } 8690 } 8691 8692 out: 8693 mutex_exit(&cp->c_statelock); 8694 8695 return (error); 8696 } 8697 8698 static int 8699 cachefs_setsecattr_disconnected(cnode_t *cp, 8700 vsecattr_t *vsec, int flag, cred_t *cr) 8701 { 8702 fscache_t *fscp = C_TO_FSCACHE(cp); 8703 mode_t failmode = cp->c_metadata.md_vattr.va_mode; 8704 off_t commit = 0; 8705 int error = 0; 8706 8707 ASSERT((fscp->fs_info.fi_mntflags & CFS_NOACL) == 0); 8708 8709 if (CFS_ISFS_WRITE_AROUND(fscp)) 8710 return (ETIMEDOUT); 8711 8712 mutex_enter(&cp->c_statelock); 8713 8714 /* only owner can set acl */ 8715 if (cp->c_metadata.md_vattr.va_uid != crgetuid(cr)) { 8716 error = EINVAL; 8717 goto out; 8718 } 8719 8720 if (cp->c_metadata.md_flags & MD_NEEDATTRS) { 8721 error = ETIMEDOUT; 8722 goto out; 8723 } 8724 8725 /* XXX do i need this? is this right? */ 8726 if (cp->c_flags & CN_ALLOC_PENDING) { 8727 if (cp->c_filegrp->fg_flags & CFS_FG_ALLOC_ATTR) { 8728 (void) filegrp_allocattr(cp->c_filegrp); 8729 } 8730 error = filegrp_create_metadata(cp->c_filegrp, 8731 &cp->c_metadata, &cp->c_id); 8732 if (error) { 8733 goto out; 8734 } 8735 cp->c_flags &= ~CN_ALLOC_PENDING; 8736 } 8737 8738 /* XXX is this right? */ 8739 if ((cp->c_metadata.md_flags & MD_MAPPING) == 0) { 8740 error = cachefs_dlog_cidmap(fscp); 8741 if (error) { 8742 error = ENOSPC; 8743 goto out; 8744 } 8745 cp->c_metadata.md_flags |= MD_MAPPING; 8746 cp->c_flags |= CN_UPDATED; 8747 } 8748 8749 commit = cachefs_dlog_setsecattr(fscp, vsec, flag, cp, cr); 8750 if (commit == 0) 8751 goto out; 8752 8753 /* fix modes in metadata */ 8754 cachefs_acl2perm(cp, vsec); 8755 8756 if ((cp->c_flags & CN_NOCACHE) == 0) { 8757 error = cachefs_cacheacl(cp, vsec); 8758 if (error != 0) { 8759 goto out; 8760 } 8761 } 8762 8763 /* XXX is this right? */ 8764 if (cachefs_modified_alloc(cp)) { 8765 error = ENOSPC; 8766 goto out; 8767 } 8768 8769 out: 8770 if (error != 0) 8771 cp->c_metadata.md_vattr.va_mode = failmode; 8772 8773 mutex_exit(&cp->c_statelock); 8774 8775 if (commit) { 8776 if (cachefs_dlog_commit(fscp, commit, error)) { 8777 /*EMPTY*/ 8778 /* XXX fix on panic? */ 8779 } 8780 } 8781 8782 return (error); 8783 } 8784 8785 /*ARGSUSED*/ 8786 static int 8787 cachefs_setsecattr(vnode_t *vp, vsecattr_t *vsec, int flag, cred_t *cr, 8788 caller_context_t *ct) 8789 { 8790 cnode_t *cp = VTOC(vp); 8791 fscache_t *fscp = C_TO_FSCACHE(cp); 8792 int connected = 0; 8793 int held = 0; 8794 int error = 0; 8795 8796 #ifdef CFSDEBUG 8797 CFS_DEBUG(CFSDEBUG_VOPS) 8798 printf("cachefs_setsecattr: ENTER vp %p\n", (void *)vp); 8799 #endif 8800 if (getzoneid() != GLOBAL_ZONEID) { 8801 error = EPERM; 8802 goto out; 8803 } 8804 8805 if (fscp->fs_info.fi_mntflags & CFS_NOACL) { 8806 error = ENOSYS; 8807 goto out; 8808 } 8809 8810 if (! cachefs_vtype_aclok(vp)) { 8811 error = EINVAL; 8812 goto out; 8813 } 8814 8815 /* 8816 * Cachefs only provides pass-through support for NFSv4, 8817 * and all vnode operations are passed through to the 8818 * back file system. For NFSv4 pass-through to work, only 8819 * connected operation is supported, the cnode backvp must 8820 * exist, and cachefs optional (eg., disconnectable) flags 8821 * are turned off. Assert these conditions to ensure that 8822 * the backfilesystem is called for the setsecattr operation. 8823 */ 8824 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 8825 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 8826 8827 for (;;) { 8828 /* drop hold on file system */ 8829 if (held) { 8830 /* Won't loop with NFSv4 connected operation */ 8831 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 8832 cachefs_cd_release(fscp); 8833 held = 0; 8834 } 8835 8836 /* acquire access to the file system */ 8837 error = cachefs_cd_access(fscp, connected, 1); 8838 if (error) 8839 break; 8840 held = 1; 8841 8842 /* perform the setattr */ 8843 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) 8844 error = cachefs_setsecattr_connected(cp, 8845 vsec, flag, cr); 8846 else 8847 error = cachefs_setsecattr_disconnected(cp, 8848 vsec, flag, cr); 8849 if (error) { 8850 /* if connected */ 8851 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 8852 if (CFS_TIMEOUT(fscp, error)) { 8853 cachefs_cd_release(fscp); 8854 held = 0; 8855 cachefs_cd_timedout(fscp); 8856 connected = 0; 8857 continue; 8858 } 8859 } 8860 8861 /* else must be disconnected */ 8862 else { 8863 if (CFS_TIMEOUT(fscp, error)) { 8864 connected = 1; 8865 continue; 8866 } 8867 } 8868 } 8869 break; 8870 } 8871 8872 if (held) { 8873 cachefs_cd_release(fscp); 8874 } 8875 return (error); 8876 8877 out: 8878 #ifdef CFS_CD_DEBUG 8879 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 8880 #endif 8881 8882 #ifdef CFSDEBUG 8883 CFS_DEBUG(CFSDEBUG_VOPS) 8884 printf("cachefs_setsecattr: EXIT error = %d\n", error); 8885 #endif 8886 return (error); 8887 } 8888 8889 /* 8890 * call this BEFORE calling cachefs_cacheacl(), as the latter will 8891 * sanitize the acl. 8892 */ 8893 8894 static void 8895 cachefs_acl2perm(cnode_t *cp, vsecattr_t *vsec) 8896 { 8897 aclent_t *aclp; 8898 int i; 8899 8900 for (i = 0; i < vsec->vsa_aclcnt; i++) { 8901 aclp = ((aclent_t *)vsec->vsa_aclentp) + i; 8902 switch (aclp->a_type) { 8903 case USER_OBJ: 8904 cp->c_metadata.md_vattr.va_mode &= (~0700); 8905 cp->c_metadata.md_vattr.va_mode |= (aclp->a_perm << 6); 8906 break; 8907 8908 case GROUP_OBJ: 8909 cp->c_metadata.md_vattr.va_mode &= (~070); 8910 cp->c_metadata.md_vattr.va_mode |= (aclp->a_perm << 3); 8911 break; 8912 8913 case OTHER_OBJ: 8914 cp->c_metadata.md_vattr.va_mode &= (~07); 8915 cp->c_metadata.md_vattr.va_mode |= (aclp->a_perm); 8916 break; 8917 8918 case CLASS_OBJ: 8919 cp->c_metadata.md_aclclass = aclp->a_perm; 8920 break; 8921 } 8922 } 8923 8924 cp->c_flags |= CN_UPDATED; 8925 } 8926 8927 static int 8928 cachefs_getsecattr(vnode_t *vp, vsecattr_t *vsec, int flag, cred_t *cr, 8929 caller_context_t *ct) 8930 { 8931 cnode_t *cp = VTOC(vp); 8932 fscache_t *fscp = C_TO_FSCACHE(cp); 8933 int held = 0, connected = 0; 8934 int error = 0; 8935 8936 #ifdef CFSDEBUG 8937 CFS_DEBUG(CFSDEBUG_VOPS) 8938 printf("cachefs_getsecattr: ENTER vp %p\n", (void *)vp); 8939 #endif 8940 8941 if (getzoneid() != GLOBAL_ZONEID) { 8942 error = EPERM; 8943 goto out; 8944 } 8945 8946 /* 8947 * Cachefs only provides pass-through support for NFSv4, 8948 * and all vnode operations are passed through to the 8949 * back file system. For NFSv4 pass-through to work, only 8950 * connected operation is supported, the cnode backvp must 8951 * exist, and cachefs optional (eg., disconnectable) flags 8952 * are turned off. Assert these conditions to ensure that 8953 * the backfilesystem is called for the getsecattr operation. 8954 */ 8955 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 8956 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 8957 8958 if (fscp->fs_info.fi_mntflags & CFS_NOACL) { 8959 error = fs_fab_acl(vp, vsec, flag, cr, ct); 8960 goto out; 8961 } 8962 8963 for (;;) { 8964 if (held) { 8965 /* Won't loop with NFSv4 connected behavior */ 8966 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 8967 cachefs_cd_release(fscp); 8968 held = 0; 8969 } 8970 error = cachefs_cd_access(fscp, connected, 0); 8971 if (error) 8972 break; 8973 held = 1; 8974 8975 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) { 8976 error = cachefs_getsecattr_connected(vp, vsec, flag, 8977 cr); 8978 if (CFS_TIMEOUT(fscp, error)) { 8979 cachefs_cd_release(fscp); 8980 held = 0; 8981 cachefs_cd_timedout(fscp); 8982 connected = 0; 8983 continue; 8984 } 8985 } else { 8986 error = cachefs_getsecattr_disconnected(vp, vsec, flag, 8987 cr); 8988 if (CFS_TIMEOUT(fscp, error)) { 8989 if (cachefs_cd_access_miss(fscp)) { 8990 error = cachefs_getsecattr_connected(vp, 8991 vsec, flag, cr); 8992 if (!CFS_TIMEOUT(fscp, error)) 8993 break; 8994 delay(5*hz); 8995 connected = 0; 8996 continue; 8997 } 8998 connected = 1; 8999 continue; 9000 } 9001 } 9002 break; 9003 } 9004 9005 out: 9006 if (held) 9007 cachefs_cd_release(fscp); 9008 9009 #ifdef CFS_CD_DEBUG 9010 ASSERT((curthread->t_flag & T_CD_HELD) == 0); 9011 #endif 9012 #ifdef CFSDEBUG 9013 CFS_DEBUG(CFSDEBUG_VOPS) 9014 printf("cachefs_getsecattr: EXIT error = %d\n", error); 9015 #endif 9016 return (error); 9017 } 9018 9019 static int 9020 cachefs_shrlock(vnode_t *vp, int cmd, struct shrlock *shr, int flag, cred_t *cr, 9021 caller_context_t *ct) 9022 { 9023 cnode_t *cp = VTOC(vp); 9024 fscache_t *fscp = C_TO_FSCACHE(cp); 9025 int error = 0; 9026 vnode_t *backvp; 9027 9028 #ifdef CFSDEBUG 9029 CFS_DEBUG(CFSDEBUG_VOPS) 9030 printf("cachefs_shrlock: ENTER vp %p\n", (void *)vp); 9031 #endif 9032 9033 if (getzoneid() != GLOBAL_ZONEID) { 9034 error = EPERM; 9035 goto out; 9036 } 9037 9038 /* 9039 * Cachefs only provides pass-through support for NFSv4, 9040 * and all vnode operations are passed through to the 9041 * back file system. For NFSv4 pass-through to work, only 9042 * connected operation is supported, the cnode backvp must 9043 * exist, and cachefs optional (eg., disconnectable) flags 9044 * are turned off. Assert these conditions to ensure that 9045 * the backfilesystem is called for the shrlock operation. 9046 */ 9047 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 9048 CFS_BACKFS_NFSV4_ASSERT_CNODE(cp); 9049 9050 mutex_enter(&cp->c_statelock); 9051 if (cp->c_backvp == NULL) 9052 error = cachefs_getbackvp(fscp, cp); 9053 backvp = cp->c_backvp; 9054 mutex_exit(&cp->c_statelock); 9055 ASSERT((error != 0) || (backvp != NULL)); 9056 9057 if (error == 0) { 9058 CFS_DPRINT_BACKFS_NFSV4(fscp, 9059 ("cachefs_shrlock (nfsv4): cp %p, backvp %p", 9060 cp, backvp)); 9061 error = VOP_SHRLOCK(backvp, cmd, shr, flag, cr, ct); 9062 } 9063 9064 out: 9065 #ifdef CFSDEBUG 9066 CFS_DEBUG(CFSDEBUG_VOPS) 9067 printf("cachefs_shrlock: EXIT error = %d\n", error); 9068 #endif 9069 return (error); 9070 } 9071 9072 static int 9073 cachefs_getsecattr_connected(vnode_t *vp, vsecattr_t *vsec, int flag, 9074 cred_t *cr) 9075 { 9076 cnode_t *cp = VTOC(vp); 9077 fscache_t *fscp = C_TO_FSCACHE(cp); 9078 int hit = 0; 9079 int error = 0; 9080 9081 9082 mutex_enter(&cp->c_statelock); 9083 error = CFSOP_CHECK_COBJECT(fscp, cp, 0, cr); 9084 if (error) 9085 goto out; 9086 9087 /* read from the cache if we can */ 9088 if ((cp->c_metadata.md_flags & MD_ACL) && 9089 ((cp->c_flags & CN_NOCACHE) == 0) && 9090 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 9091 ASSERT((cp->c_flags & CN_NOCACHE) == 0); 9092 error = cachefs_getaclfromcache(cp, vsec); 9093 if (error) { 9094 cachefs_nocache(cp); 9095 ASSERT((cp->c_metadata.md_flags & MD_ACL) == 0); 9096 error = 0; 9097 } else { 9098 hit = 1; 9099 goto out; 9100 } 9101 } 9102 9103 ASSERT(error == 0); 9104 if (cp->c_backvp == NULL) 9105 error = cachefs_getbackvp(fscp, cp); 9106 if (error) 9107 goto out; 9108 9109 CFS_DPRINT_BACKFS_NFSV4(fscp, 9110 ("cachefs_getsecattr (nfsv4): cp %p, backvp %p", 9111 cp, cp->c_backvp)); 9112 error = VOP_GETSECATTR(cp->c_backvp, vsec, flag, cr, NULL); 9113 if (error) 9114 goto out; 9115 9116 if (((fscp->fs_info.fi_mntflags & CFS_NOACL) == 0) && 9117 (cachefs_vtype_aclok(vp)) && 9118 ((cp->c_flags & CN_NOCACHE) == 0) && 9119 !CFS_ISFS_BACKFS_NFSV4(fscp)) { 9120 error = cachefs_cacheacl(cp, vsec); 9121 if (error) { 9122 error = 0; 9123 cachefs_nocache(cp); 9124 } 9125 } 9126 9127 out: 9128 if (error == 0) { 9129 if (hit) 9130 fscp->fs_stats.st_hits++; 9131 else 9132 fscp->fs_stats.st_misses++; 9133 } 9134 mutex_exit(&cp->c_statelock); 9135 9136 return (error); 9137 } 9138 9139 static int 9140 /*ARGSUSED*/ 9141 cachefs_getsecattr_disconnected(vnode_t *vp, vsecattr_t *vsec, int flag, 9142 cred_t *cr) 9143 { 9144 cnode_t *cp = VTOC(vp); 9145 fscache_t *fscp = C_TO_FSCACHE(cp); 9146 int hit = 0; 9147 int error = 0; 9148 9149 9150 mutex_enter(&cp->c_statelock); 9151 9152 /* read from the cache if we can */ 9153 if (((cp->c_flags & CN_NOCACHE) == 0) && 9154 (cp->c_metadata.md_flags & MD_ACL)) { 9155 error = cachefs_getaclfromcache(cp, vsec); 9156 if (error) { 9157 cachefs_nocache(cp); 9158 ASSERT((cp->c_metadata.md_flags & MD_ACL) == 0); 9159 error = 0; 9160 } else { 9161 hit = 1; 9162 goto out; 9163 } 9164 } 9165 error = ETIMEDOUT; 9166 9167 out: 9168 if (error == 0) { 9169 if (hit) 9170 fscp->fs_stats.st_hits++; 9171 else 9172 fscp->fs_stats.st_misses++; 9173 } 9174 mutex_exit(&cp->c_statelock); 9175 9176 return (error); 9177 } 9178 9179 /* 9180 * cachefs_cacheacl() -- cache an ACL, which we do by applying it to 9181 * the frontfile if possible; otherwise, the adjunct directory. 9182 * 9183 * inputs: 9184 * cp - the cnode, with its statelock already held 9185 * vsecp - a pointer to a vsecattr_t you'd like us to cache as-is, 9186 * or NULL if you want us to do the VOP_GETSECATTR(backvp). 9187 * 9188 * returns: 9189 * 0 - all is well 9190 * nonzero - errno 9191 */ 9192 9193 int 9194 cachefs_cacheacl(cnode_t *cp, vsecattr_t *vsecp) 9195 { 9196 fscache_t *fscp = C_TO_FSCACHE(cp); 9197 vsecattr_t vsec; 9198 aclent_t *aclp; 9199 int gotvsec = 0; 9200 int error = 0; 9201 vnode_t *vp = NULL; 9202 void *aclkeep = NULL; 9203 int i; 9204 9205 ASSERT(MUTEX_HELD(&cp->c_statelock)); 9206 ASSERT((cp->c_flags & CN_NOCACHE) == 0); 9207 ASSERT(CFS_ISFS_BACKFS_NFSV4(fscp) == 0); 9208 ASSERT((fscp->fs_info.fi_mntflags & CFS_NOACL) == 0); 9209 ASSERT(cachefs_vtype_aclok(CTOV(cp))); 9210 9211 if (fscp->fs_info.fi_mntflags & CFS_NOACL) { 9212 error = ENOSYS; 9213 goto out; 9214 } 9215 9216 if (vsecp == NULL) { 9217 if (cp->c_backvp == NULL) 9218 error = cachefs_getbackvp(fscp, cp); 9219 if (error != 0) 9220 goto out; 9221 vsecp = &vsec; 9222 bzero(&vsec, sizeof (vsec)); 9223 vsecp->vsa_mask = 9224 VSA_ACL | VSA_ACLCNT | VSA_DFACL | VSA_DFACLCNT; 9225 error = VOP_GETSECATTR(cp->c_backvp, vsecp, 0, kcred, NULL); 9226 if (error != 0) { 9227 goto out; 9228 } 9229 gotvsec = 1; 9230 } else if (vsecp->vsa_mask & VSA_ACL) { 9231 aclkeep = vsecp->vsa_aclentp; 9232 vsecp->vsa_aclentp = cachefs_kmem_alloc(vsecp->vsa_aclcnt * 9233 sizeof (aclent_t), KM_SLEEP); 9234 bcopy(aclkeep, vsecp->vsa_aclentp, vsecp->vsa_aclcnt * 9235 sizeof (aclent_t)); 9236 } else if ((vsecp->vsa_mask & (VSA_ACL | VSA_DFACL)) == 0) { 9237 /* unless there's real data, we can cache nothing. */ 9238 return (0); 9239 } 9240 9241 /* 9242 * prevent the ACL from chmoding our frontfile, and 9243 * snarf the class info 9244 */ 9245 9246 if ((vsecp->vsa_mask & (VSA_ACL | VSA_ACLCNT)) == 9247 (VSA_ACL | VSA_ACLCNT)) { 9248 for (i = 0; i < vsecp->vsa_aclcnt; i++) { 9249 aclp = ((aclent_t *)vsecp->vsa_aclentp) + i; 9250 switch (aclp->a_type) { 9251 case CLASS_OBJ: 9252 cp->c_metadata.md_aclclass = 9253 aclp->a_perm; 9254 /*FALLTHROUGH*/ 9255 case USER_OBJ: 9256 case GROUP_OBJ: 9257 case OTHER_OBJ: 9258 aclp->a_perm = 06; 9259 } 9260 } 9261 } 9262 9263 /* 9264 * if the frontfile exists, then we always do the work. but, 9265 * if there's no frontfile, and the ACL isn't a `real' ACL, 9266 * then we don't want to do the work. otherwise, an `ls -l' 9267 * will create tons of emtpy frontfiles. 9268 */ 9269 9270 if (((cp->c_metadata.md_flags & MD_FILE) == 0) && 9271 ((vsecp->vsa_aclcnt + vsecp->vsa_dfaclcnt) 9272 <= MIN_ACL_ENTRIES)) { 9273 cp->c_metadata.md_flags |= MD_ACL; 9274 cp->c_flags |= CN_UPDATED; 9275 goto out; 9276 } 9277 9278 /* 9279 * if we have a default ACL, then we need a 9280 * real live directory in the frontfs that we 9281 * can apply the ACL to. if not, then we just 9282 * use the frontfile. we get the frontfile 9283 * regardless -- that way, we know the 9284 * directory for the frontfile exists. 9285 */ 9286 9287 if (vsecp->vsa_dfaclcnt > 0) { 9288 if (cp->c_acldirvp == NULL) 9289 error = cachefs_getacldirvp(cp); 9290 if (error != 0) 9291 goto out; 9292 vp = cp->c_acldirvp; 9293 } else { 9294 if (cp->c_frontvp == NULL) 9295 error = cachefs_getfrontfile(cp); 9296 if (error != 0) 9297 goto out; 9298 vp = cp->c_frontvp; 9299 } 9300 ASSERT(vp != NULL); 9301 9302 (void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, NULL); 9303 error = VOP_SETSECATTR(vp, vsecp, 0, kcred, NULL); 9304 VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, NULL); 9305 if (error != 0) { 9306 #ifdef CFSDEBUG 9307 CFS_DEBUG(CFSDEBUG_VOPS) 9308 printf("cachefs_cacheacl: setsecattr: error %d\n", 9309 error); 9310 #endif /* CFSDEBUG */ 9311 /* 9312 * If there was an error, we don't want to call 9313 * cachefs_nocache(); so, set error to 0. 9314 * We will call cachefs_purgeacl(), in order to 9315 * clean such things as adjunct ACL directories. 9316 */ 9317 cachefs_purgeacl(cp); 9318 error = 0; 9319 goto out; 9320 } 9321 if (vp == cp->c_frontvp) 9322 cp->c_flags |= CN_NEED_FRONT_SYNC; 9323 9324 cp->c_metadata.md_flags |= MD_ACL; 9325 cp->c_flags |= CN_UPDATED; 9326 9327 out: 9328 if ((error) && (fscp->fs_cdconnected == CFS_CD_CONNECTED)) 9329 cachefs_nocache(cp); 9330 9331 if (gotvsec) { 9332 if (vsec.vsa_aclcnt) 9333 kmem_free(vsec.vsa_aclentp, 9334 vsec.vsa_aclcnt * sizeof (aclent_t)); 9335 if (vsec.vsa_dfaclcnt) 9336 kmem_free(vsec.vsa_dfaclentp, 9337 vsec.vsa_dfaclcnt * sizeof (aclent_t)); 9338 } else if (aclkeep != NULL) { 9339 cachefs_kmem_free(vsecp->vsa_aclentp, 9340 vsecp->vsa_aclcnt * sizeof (aclent_t)); 9341 vsecp->vsa_aclentp = aclkeep; 9342 } 9343 9344 return (error); 9345 } 9346 9347 void 9348 cachefs_purgeacl(cnode_t *cp) 9349 { 9350 ASSERT(MUTEX_HELD(&cp->c_statelock)); 9351 9352 ASSERT(!CFS_ISFS_BACKFS_NFSV4(C_TO_FSCACHE(cp))); 9353 9354 if (cp->c_acldirvp != NULL) { 9355 VN_RELE(cp->c_acldirvp); 9356 cp->c_acldirvp = NULL; 9357 } 9358 9359 if (cp->c_metadata.md_flags & MD_ACLDIR) { 9360 char name[CFS_FRONTFILE_NAME_SIZE + 2]; 9361 9362 ASSERT(cp->c_filegrp->fg_dirvp != NULL); 9363 make_ascii_name(&cp->c_id, name); 9364 (void) strcat(name, ".d"); 9365 9366 (void) VOP_RMDIR(cp->c_filegrp->fg_dirvp, name, 9367 cp->c_filegrp->fg_dirvp, kcred, NULL, 0); 9368 } 9369 9370 cp->c_metadata.md_flags &= ~(MD_ACL | MD_ACLDIR); 9371 cp->c_flags |= CN_UPDATED; 9372 } 9373 9374 static int 9375 cachefs_getacldirvp(cnode_t *cp) 9376 { 9377 char name[CFS_FRONTFILE_NAME_SIZE + 2]; 9378 int error = 0; 9379 9380 ASSERT(MUTEX_HELD(&cp->c_statelock)); 9381 ASSERT(cp->c_acldirvp == NULL); 9382 9383 if (cp->c_frontvp == NULL) 9384 error = cachefs_getfrontfile(cp); 9385 if (error != 0) 9386 goto out; 9387 9388 ASSERT(cp->c_filegrp->fg_dirvp != NULL); 9389 make_ascii_name(&cp->c_id, name); 9390 (void) strcat(name, ".d"); 9391 error = VOP_LOOKUP(cp->c_filegrp->fg_dirvp, 9392 name, &cp->c_acldirvp, NULL, 0, NULL, kcred, NULL, NULL, NULL); 9393 if ((error != 0) && (error != ENOENT)) 9394 goto out; 9395 9396 if (error != 0) { 9397 vattr_t va; 9398 9399 va.va_mode = S_IFDIR | 0777; 9400 va.va_uid = 0; 9401 va.va_gid = 0; 9402 va.va_type = VDIR; 9403 va.va_mask = AT_TYPE | AT_MODE | 9404 AT_UID | AT_GID; 9405 error = 9406 VOP_MKDIR(cp->c_filegrp->fg_dirvp, 9407 name, &va, &cp->c_acldirvp, kcred, NULL, 0, NULL); 9408 if (error != 0) 9409 goto out; 9410 } 9411 9412 ASSERT(cp->c_acldirvp != NULL); 9413 cp->c_metadata.md_flags |= MD_ACLDIR; 9414 cp->c_flags |= CN_UPDATED; 9415 9416 out: 9417 if (error != 0) 9418 cp->c_acldirvp = NULL; 9419 return (error); 9420 } 9421 9422 static int 9423 cachefs_getaclfromcache(cnode_t *cp, vsecattr_t *vsec) 9424 { 9425 aclent_t *aclp; 9426 int error = 0; 9427 vnode_t *vp = NULL; 9428 int i; 9429 9430 ASSERT(cp->c_metadata.md_flags & MD_ACL); 9431 ASSERT(MUTEX_HELD(&cp->c_statelock)); 9432 ASSERT(vsec->vsa_aclentp == NULL); 9433 9434 if (cp->c_metadata.md_flags & MD_ACLDIR) { 9435 if (cp->c_acldirvp == NULL) 9436 error = cachefs_getacldirvp(cp); 9437 if (error != 0) 9438 goto out; 9439 vp = cp->c_acldirvp; 9440 } else if (cp->c_metadata.md_flags & MD_FILE) { 9441 if (cp->c_frontvp == NULL) 9442 error = cachefs_getfrontfile(cp); 9443 if (error != 0) 9444 goto out; 9445 vp = cp->c_frontvp; 9446 } else { 9447 9448 /* 9449 * if we get here, then we know that MD_ACL is on, 9450 * meaning an ACL was successfully cached. we also 9451 * know that neither MD_ACLDIR nor MD_FILE are on, so 9452 * this has to be an entry without a `real' ACL. 9453 * thus, we forge whatever is necessary. 9454 */ 9455 9456 if (vsec->vsa_mask & VSA_ACLCNT) 9457 vsec->vsa_aclcnt = MIN_ACL_ENTRIES; 9458 9459 if (vsec->vsa_mask & VSA_ACL) { 9460 vsec->vsa_aclentp = 9461 kmem_zalloc(MIN_ACL_ENTRIES * 9462 sizeof (aclent_t), KM_SLEEP); 9463 aclp = (aclent_t *)vsec->vsa_aclentp; 9464 aclp->a_type = USER_OBJ; 9465 ++aclp; 9466 aclp->a_type = GROUP_OBJ; 9467 ++aclp; 9468 aclp->a_type = OTHER_OBJ; 9469 ++aclp; 9470 aclp->a_type = CLASS_OBJ; 9471 ksort((caddr_t)vsec->vsa_aclentp, MIN_ACL_ENTRIES, 9472 sizeof (aclent_t), cmp2acls); 9473 } 9474 9475 ASSERT(vp == NULL); 9476 } 9477 9478 if (vp != NULL) { 9479 if ((error = VOP_GETSECATTR(vp, vsec, 0, kcred, NULL)) != 0) { 9480 #ifdef CFSDEBUG 9481 CFS_DEBUG(CFSDEBUG_VOPS) 9482 printf("cachefs_getaclfromcache: error %d\n", 9483 error); 9484 #endif /* CFSDEBUG */ 9485 goto out; 9486 } 9487 } 9488 9489 if (vsec->vsa_aclentp != NULL) { 9490 for (i = 0; i < vsec->vsa_aclcnt; i++) { 9491 aclp = ((aclent_t *)vsec->vsa_aclentp) + i; 9492 switch (aclp->a_type) { 9493 case USER_OBJ: 9494 aclp->a_id = cp->c_metadata.md_vattr.va_uid; 9495 aclp->a_perm = 9496 cp->c_metadata.md_vattr.va_mode & 0700; 9497 aclp->a_perm >>= 6; 9498 break; 9499 9500 case GROUP_OBJ: 9501 aclp->a_id = cp->c_metadata.md_vattr.va_gid; 9502 aclp->a_perm = 9503 cp->c_metadata.md_vattr.va_mode & 070; 9504 aclp->a_perm >>= 3; 9505 break; 9506 9507 case OTHER_OBJ: 9508 aclp->a_perm = 9509 cp->c_metadata.md_vattr.va_mode & 07; 9510 break; 9511 9512 case CLASS_OBJ: 9513 aclp->a_perm = 9514 cp->c_metadata.md_aclclass; 9515 break; 9516 } 9517 } 9518 } 9519 9520 out: 9521 9522 if (error != 0) 9523 cachefs_nocache(cp); 9524 9525 return (error); 9526 } 9527 9528 /* 9529 * Fills in targp with attribute information from srcp, cp 9530 * and if necessary the system. 9531 */ 9532 static void 9533 cachefs_attr_setup(vattr_t *srcp, vattr_t *targp, cnode_t *cp, cred_t *cr) 9534 { 9535 time_t now; 9536 9537 ASSERT((srcp->va_mask & (AT_TYPE | AT_MODE)) == (AT_TYPE | AT_MODE)); 9538 9539 /* 9540 * Add code to fill in the va struct. We use the fields from 9541 * the srcp struct if they are populated, otherwise we guess 9542 */ 9543 9544 targp->va_mask = 0; /* initialize all fields */ 9545 targp->va_mode = srcp->va_mode; 9546 targp->va_type = srcp->va_type; 9547 targp->va_nlink = 1; 9548 targp->va_nodeid = 0; 9549 9550 if (srcp->va_mask & AT_UID) 9551 targp->va_uid = srcp->va_uid; 9552 else 9553 targp->va_uid = crgetuid(cr); 9554 9555 if (srcp->va_mask & AT_GID) 9556 targp->va_gid = srcp->va_gid; 9557 else 9558 targp->va_gid = crgetgid(cr); 9559 9560 if (srcp->va_mask & AT_FSID) 9561 targp->va_fsid = srcp->va_fsid; 9562 else 9563 targp->va_fsid = 0; /* initialize all fields */ 9564 9565 now = gethrestime_sec(); 9566 if (srcp->va_mask & AT_ATIME) 9567 targp->va_atime = srcp->va_atime; 9568 else 9569 targp->va_atime.tv_sec = now; 9570 9571 if (srcp->va_mask & AT_MTIME) 9572 targp->va_mtime = srcp->va_mtime; 9573 else 9574 targp->va_mtime.tv_sec = now; 9575 9576 if (srcp->va_mask & AT_CTIME) 9577 targp->va_ctime = srcp->va_ctime; 9578 else 9579 targp->va_ctime.tv_sec = now; 9580 9581 9582 if (srcp->va_mask & AT_SIZE) 9583 targp->va_size = srcp->va_size; 9584 else 9585 targp->va_size = 0; 9586 9587 /* 9588 * the remaing fields are set by the fs and not changable. 9589 * we populate these entries useing the parent directory 9590 * values. It's a small hack, but should work. 9591 */ 9592 targp->va_blksize = cp->c_metadata.md_vattr.va_blksize; 9593 targp->va_rdev = cp->c_metadata.md_vattr.va_rdev; 9594 targp->va_nblocks = cp->c_metadata.md_vattr.va_nblocks; 9595 targp->va_seq = 0; /* Never keep the sequence number */ 9596 } 9597 9598 /* 9599 * set the gid for a newly created file. The algorithm is as follows: 9600 * 9601 * 1) If the gid is set in the attribute list, then use it if 9602 * the caller is privileged, belongs to the target group, or 9603 * the group is the same as the parent directory. 9604 * 9605 * 2) If the parent directory's set-gid bit is clear, then use 9606 * the process gid 9607 * 9608 * 3) Otherwise, use the gid of the parent directory. 9609 * 9610 * Note: newcp->c_attr.va_{mode,type} must already be set before calling 9611 * this routine. 9612 */ 9613 static void 9614 cachefs_creategid(cnode_t *dcp, cnode_t *newcp, vattr_t *vap, cred_t *cr) 9615 { 9616 if ((vap->va_mask & AT_GID) && 9617 ((vap->va_gid == dcp->c_attr.va_gid) || 9618 groupmember(vap->va_gid, cr) || 9619 secpolicy_vnode_create_gid(cr) != 0)) { 9620 newcp->c_attr.va_gid = vap->va_gid; 9621 } else { 9622 if (dcp->c_attr.va_mode & S_ISGID) 9623 newcp->c_attr.va_gid = dcp->c_attr.va_gid; 9624 else 9625 newcp->c_attr.va_gid = crgetgid(cr); 9626 } 9627 9628 /* 9629 * if we're creating a directory, and the parent directory has the 9630 * set-GID bit set, set it on the new directory. 9631 * Otherwise, if the user is neither privileged nor a member of the 9632 * file's new group, clear the file's set-GID bit. 9633 */ 9634 if (dcp->c_attr.va_mode & S_ISGID && newcp->c_attr.va_type == VDIR) { 9635 newcp->c_attr.va_mode |= S_ISGID; 9636 } else if ((newcp->c_attr.va_mode & S_ISGID) && 9637 secpolicy_vnode_setids_setgids(cr, newcp->c_attr.va_gid) != 0) 9638 newcp->c_attr.va_mode &= ~S_ISGID; 9639 } 9640 9641 /* 9642 * create an acl for the newly created file. should be called right 9643 * after cachefs_creategid. 9644 */ 9645 9646 static void 9647 cachefs_createacl(cnode_t *dcp, cnode_t *newcp) 9648 { 9649 fscache_t *fscp = C_TO_FSCACHE(dcp); 9650 vsecattr_t vsec; 9651 int gotvsec = 0; 9652 int error = 0; /* placeholder */ 9653 aclent_t *aclp; 9654 o_mode_t *classp = NULL; 9655 o_mode_t gunion = 0; 9656 int i; 9657 9658 if ((fscp->fs_info.fi_mntflags & CFS_NOACL) || 9659 (! cachefs_vtype_aclok(CTOV(newcp)))) 9660 return; 9661 9662 ASSERT(dcp->c_metadata.md_flags & MD_ACL); 9663 ASSERT(MUTEX_HELD(&dcp->c_statelock)); 9664 ASSERT(MUTEX_HELD(&newcp->c_statelock)); 9665 9666 /* 9667 * XXX should probably not do VSA_ACL and VSA_ACLCNT, but that 9668 * would hit code paths that isn't hit anywhere else. 9669 */ 9670 9671 bzero(&vsec, sizeof (vsec)); 9672 vsec.vsa_mask = VSA_ACL | VSA_ACLCNT | VSA_DFACL | VSA_DFACLCNT; 9673 error = cachefs_getaclfromcache(dcp, &vsec); 9674 if (error != 0) 9675 goto out; 9676 gotvsec = 1; 9677 9678 if ((vsec.vsa_dfaclcnt > 0) && (vsec.vsa_dfaclentp != NULL)) { 9679 if ((vsec.vsa_aclcnt > 0) && (vsec.vsa_aclentp != NULL)) 9680 kmem_free(vsec.vsa_aclentp, 9681 vsec.vsa_aclcnt * sizeof (aclent_t)); 9682 9683 vsec.vsa_aclcnt = vsec.vsa_dfaclcnt; 9684 vsec.vsa_aclentp = vsec.vsa_dfaclentp; 9685 vsec.vsa_dfaclcnt = 0; 9686 vsec.vsa_dfaclentp = NULL; 9687 9688 if (newcp->c_attr.va_type == VDIR) { 9689 vsec.vsa_dfaclentp = kmem_alloc(vsec.vsa_aclcnt * 9690 sizeof (aclent_t), KM_SLEEP); 9691 vsec.vsa_dfaclcnt = vsec.vsa_aclcnt; 9692 bcopy(vsec.vsa_aclentp, vsec.vsa_dfaclentp, 9693 vsec.vsa_aclcnt * sizeof (aclent_t)); 9694 } 9695 9696 /* 9697 * this function should be called pretty much after 9698 * the rest of the file creation stuff is done. so, 9699 * uid, gid, etc. should be `right'. we'll go with 9700 * that, rather than trying to determine whether to 9701 * get stuff from cr or va. 9702 */ 9703 9704 for (i = 0; i < vsec.vsa_aclcnt; i++) { 9705 aclp = ((aclent_t *)vsec.vsa_aclentp) + i; 9706 switch (aclp->a_type) { 9707 case DEF_USER_OBJ: 9708 aclp->a_type = USER_OBJ; 9709 aclp->a_id = newcp->c_metadata.md_vattr.va_uid; 9710 aclp->a_perm = 9711 newcp->c_metadata.md_vattr.va_mode; 9712 aclp->a_perm &= 0700; 9713 aclp->a_perm >>= 6; 9714 break; 9715 9716 case DEF_GROUP_OBJ: 9717 aclp->a_type = GROUP_OBJ; 9718 aclp->a_id = newcp->c_metadata.md_vattr.va_gid; 9719 aclp->a_perm = 9720 newcp->c_metadata.md_vattr.va_mode; 9721 aclp->a_perm &= 070; 9722 aclp->a_perm >>= 3; 9723 gunion |= aclp->a_perm; 9724 break; 9725 9726 case DEF_OTHER_OBJ: 9727 aclp->a_type = OTHER_OBJ; 9728 aclp->a_perm = 9729 newcp->c_metadata.md_vattr.va_mode & 07; 9730 break; 9731 9732 case DEF_CLASS_OBJ: 9733 aclp->a_type = CLASS_OBJ; 9734 classp = &(aclp->a_perm); 9735 break; 9736 9737 case DEF_USER: 9738 aclp->a_type = USER; 9739 gunion |= aclp->a_perm; 9740 break; 9741 9742 case DEF_GROUP: 9743 aclp->a_type = GROUP; 9744 gunion |= aclp->a_perm; 9745 break; 9746 } 9747 } 9748 9749 /* XXX is this the POSIX thing to do? */ 9750 if (classp != NULL) 9751 *classp &= gunion; 9752 9753 /* 9754 * we don't need to log this; rather, we clear the 9755 * MD_ACL bit when we reconnect. 9756 */ 9757 9758 error = cachefs_cacheacl(newcp, &vsec); 9759 if (error != 0) 9760 goto out; 9761 } 9762 9763 newcp->c_metadata.md_aclclass = 07; /* XXX check posix */ 9764 newcp->c_metadata.md_flags |= MD_ACL; 9765 newcp->c_flags |= CN_UPDATED; 9766 9767 out: 9768 9769 if (gotvsec) { 9770 if ((vsec.vsa_aclcnt > 0) && (vsec.vsa_aclentp != NULL)) 9771 kmem_free(vsec.vsa_aclentp, 9772 vsec.vsa_aclcnt * sizeof (aclent_t)); 9773 if ((vsec.vsa_dfaclcnt > 0) && (vsec.vsa_dfaclentp != NULL)) 9774 kmem_free(vsec.vsa_dfaclentp, 9775 vsec.vsa_dfaclcnt * sizeof (aclent_t)); 9776 } 9777 } 9778 9779 /* 9780 * this is translated from the UFS code for access checking. 9781 */ 9782 9783 static int 9784 cachefs_access_local(void *vcp, int mode, cred_t *cr) 9785 { 9786 cnode_t *cp = vcp; 9787 fscache_t *fscp = C_TO_FSCACHE(cp); 9788 int shift = 0; 9789 9790 ASSERT(MUTEX_HELD(&cp->c_statelock)); 9791 9792 if (mode & VWRITE) { 9793 /* 9794 * Disallow write attempts on read-only 9795 * file systems, unless the file is special. 9796 */ 9797 struct vnode *vp = CTOV(cp); 9798 if (vn_is_readonly(vp)) { 9799 if (!IS_DEVVP(vp)) { 9800 return (EROFS); 9801 } 9802 } 9803 } 9804 9805 /* 9806 * if we need to do ACLs, do it. this works whether anyone 9807 * has explicitly made an ACL or not. 9808 */ 9809 9810 if (((fscp->fs_info.fi_mntflags & CFS_NOACL) == 0) && 9811 (cachefs_vtype_aclok(CTOV(cp)))) 9812 return (cachefs_acl_access(cp, mode, cr)); 9813 9814 if (crgetuid(cr) != cp->c_attr.va_uid) { 9815 shift += 3; 9816 if (!groupmember(cp->c_attr.va_gid, cr)) 9817 shift += 3; 9818 } 9819 9820 return (secpolicy_vnode_access2(cr, CTOV(cp), cp->c_attr.va_uid, 9821 cp->c_attr.va_mode << shift, mode)); 9822 } 9823 9824 /* 9825 * This is transcribed from ufs_acl_access(). If that changes, then 9826 * this should, too. 9827 * 9828 * Check the cnode's ACL's to see if this mode of access is 9829 * allowed; return 0 if allowed, EACCES if not. 9830 * 9831 * We follow the procedure defined in Sec. 3.3.5, ACL Access 9832 * Check Algorithm, of the POSIX 1003.6 Draft Standard. 9833 */ 9834 9835 #define ACL_MODE_CHECK(M, PERM, C, I) \ 9836 secpolicy_vnode_access2(C, CTOV(I), owner, (PERM), (M)) 9837 9838 static int 9839 cachefs_acl_access(struct cnode *cp, int mode, cred_t *cr) 9840 { 9841 int error = 0; 9842 9843 fscache_t *fscp = C_TO_FSCACHE(cp); 9844 9845 int mask = ~0; 9846 int ismask = 0; 9847 9848 int gperm = 0; 9849 int ngroup = 0; 9850 9851 vsecattr_t vsec; 9852 int gotvsec = 0; 9853 aclent_t *aclp; 9854 9855 uid_t owner = cp->c_attr.va_uid; 9856 9857 int i; 9858 9859 ASSERT(MUTEX_HELD(&cp->c_statelock)); 9860 ASSERT((fscp->fs_info.fi_mntflags & CFS_NOACL) == 0); 9861 9862 /* 9863 * strictly speaking, we shouldn't set VSA_DFACL and DFACLCNT, 9864 * but then i believe we'd be the only thing exercising those 9865 * code paths -- probably a bad thing. 9866 */ 9867 9868 bzero(&vsec, sizeof (vsec)); 9869 vsec.vsa_mask = VSA_ACL | VSA_ACLCNT | VSA_DFACL | VSA_DFACLCNT; 9870 9871 /* XXX KLUDGE! correct insidious 0-class problem */ 9872 if (cp->c_metadata.md_aclclass == 0 && 9873 fscp->fs_cdconnected == CFS_CD_CONNECTED) 9874 cachefs_purgeacl(cp); 9875 again: 9876 if (cp->c_metadata.md_flags & MD_ACL) { 9877 error = cachefs_getaclfromcache(cp, &vsec); 9878 if (error != 0) { 9879 #ifdef CFSDEBUG 9880 if (error != ETIMEDOUT) 9881 CFS_DEBUG(CFSDEBUG_VOPS) 9882 printf("cachefs_acl_access():" 9883 "error %d from getaclfromcache()\n", 9884 error); 9885 #endif /* CFSDEBUG */ 9886 if ((cp->c_metadata.md_flags & MD_ACL) == 0) { 9887 goto again; 9888 } else { 9889 goto out; 9890 } 9891 } 9892 } else { 9893 if (cp->c_backvp == NULL) { 9894 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) 9895 error = cachefs_getbackvp(fscp, cp); 9896 else 9897 error = ETIMEDOUT; 9898 } 9899 if (error == 0) 9900 error = VOP_GETSECATTR(cp->c_backvp, &vsec, 0, cr, 9901 NULL); 9902 if (error != 0) { 9903 #ifdef CFSDEBUG 9904 CFS_DEBUG(CFSDEBUG_VOPS) 9905 printf("cachefs_acl_access():" 9906 "error %d from getsecattr(backvp)\n", 9907 error); 9908 #endif /* CFSDEBUG */ 9909 goto out; 9910 } 9911 if ((cp->c_flags & CN_NOCACHE) == 0 && 9912 !CFS_ISFS_BACKFS_NFSV4(fscp)) 9913 (void) cachefs_cacheacl(cp, &vsec); 9914 } 9915 gotvsec = 1; 9916 9917 ASSERT(error == 0); 9918 for (i = 0; i < vsec.vsa_aclcnt; i++) { 9919 aclp = ((aclent_t *)vsec.vsa_aclentp) + i; 9920 switch (aclp->a_type) { 9921 case USER_OBJ: 9922 /* 9923 * this might look cleaner in the 2nd loop 9924 * below, but we do it here as an 9925 * optimization. 9926 */ 9927 9928 owner = aclp->a_id; 9929 if (crgetuid(cr) == owner) { 9930 error = ACL_MODE_CHECK(mode, aclp->a_perm << 6, 9931 cr, cp); 9932 goto out; 9933 } 9934 break; 9935 9936 case CLASS_OBJ: 9937 mask = aclp->a_perm; 9938 ismask = 1; 9939 break; 9940 } 9941 } 9942 9943 ASSERT(error == 0); 9944 for (i = 0; i < vsec.vsa_aclcnt; i++) { 9945 aclp = ((aclent_t *)vsec.vsa_aclentp) + i; 9946 switch (aclp->a_type) { 9947 case USER: 9948 if (crgetuid(cr) == aclp->a_id) { 9949 error = ACL_MODE_CHECK(mode, 9950 (aclp->a_perm & mask) << 6, cr, cp); 9951 goto out; 9952 } 9953 break; 9954 9955 case GROUP_OBJ: 9956 if (groupmember(aclp->a_id, cr)) { 9957 ++ngroup; 9958 gperm |= aclp->a_perm; 9959 if (! ismask) { 9960 error = ACL_MODE_CHECK(mode, 9961 aclp->a_perm << 6, 9962 cr, cp); 9963 goto out; 9964 } 9965 } 9966 break; 9967 9968 case GROUP: 9969 if (groupmember(aclp->a_id, cr)) { 9970 ++ngroup; 9971 gperm |= aclp->a_perm; 9972 } 9973 break; 9974 9975 case OTHER_OBJ: 9976 if (ngroup == 0) { 9977 error = ACL_MODE_CHECK(mode, aclp->a_perm << 6, 9978 cr, cp); 9979 goto out; 9980 } 9981 break; 9982 9983 default: 9984 break; 9985 } 9986 } 9987 9988 ASSERT(ngroup > 0); 9989 error = ACL_MODE_CHECK(mode, (gperm & mask) << 6, cr, cp); 9990 9991 out: 9992 if (gotvsec) { 9993 if (vsec.vsa_aclcnt && vsec.vsa_aclentp) 9994 kmem_free(vsec.vsa_aclentp, 9995 vsec.vsa_aclcnt * sizeof (aclent_t)); 9996 if (vsec.vsa_dfaclcnt && vsec.vsa_dfaclentp) 9997 kmem_free(vsec.vsa_dfaclentp, 9998 vsec.vsa_dfaclcnt * sizeof (aclent_t)); 9999 } 10000 10001 return (error); 10002 } 10003 10004 /* 10005 * see if permissions allow for removal of the given file from 10006 * the given directory. 10007 */ 10008 static int 10009 cachefs_stickyrmchk(struct cnode *dcp, struct cnode *cp, cred_t *cr) 10010 { 10011 uid_t uid; 10012 /* 10013 * If the containing directory is sticky, the user must: 10014 * - own the directory, or 10015 * - own the file, or 10016 * - be able to write the file (if it's a plain file), or 10017 * - be sufficiently privileged. 10018 */ 10019 if ((dcp->c_attr.va_mode & S_ISVTX) && 10020 ((uid = crgetuid(cr)) != dcp->c_attr.va_uid) && 10021 (uid != cp->c_attr.va_uid) && 10022 (cp->c_attr.va_type != VREG || 10023 cachefs_access_local(cp, VWRITE, cr) != 0)) 10024 return (secpolicy_vnode_remove(cr)); 10025 10026 return (0); 10027 } 10028 10029 /* 10030 * Returns a new name, may even be unique. 10031 * Stolen from nfs code. 10032 * Since now we will use renaming to .cfs* in place of .nfs* 10033 * for CacheFS. Both NFS and CacheFS will rename opened files. 10034 */ 10035 static char cachefs_prefix[] = ".cfs"; 10036 kmutex_t cachefs_newnum_lock; 10037 10038 static char * 10039 cachefs_newname(void) 10040 { 10041 static uint_t newnum = 0; 10042 char *news; 10043 char *s, *p; 10044 uint_t id; 10045 10046 mutex_enter(&cachefs_newnum_lock); 10047 if (newnum == 0) { 10048 newnum = gethrestime_sec() & 0xfffff; 10049 newnum |= 0x10000; 10050 } 10051 id = newnum++; 10052 mutex_exit(&cachefs_newnum_lock); 10053 10054 news = cachefs_kmem_alloc(MAXNAMELEN, KM_SLEEP); 10055 s = news; 10056 p = cachefs_prefix; 10057 while (*p != '\0') 10058 *s++ = *p++; 10059 while (id != 0) { 10060 *s++ = "0123456789ABCDEF"[id & 0x0f]; 10061 id >>= 4; 10062 } 10063 *s = '\0'; 10064 return (news); 10065 } 10066 10067 /* 10068 * Called to rename the specified file to a temporary file so 10069 * operations to the file after remove work. 10070 * Must call this routine with the dir c_rwlock held as a writer. 10071 */ 10072 static int 10073 /*ARGSUSED*/ 10074 cachefs_remove_dolink(vnode_t *dvp, vnode_t *vp, char *nm, cred_t *cr) 10075 { 10076 cnode_t *cp = VTOC(vp); 10077 char *tmpname; 10078 fscache_t *fscp = C_TO_FSCACHE(cp); 10079 int error; 10080 10081 ASSERT(RW_WRITE_HELD(&(VTOC(dvp)->c_rwlock))); 10082 10083 /* get the new name for the file */ 10084 tmpname = cachefs_newname(); 10085 10086 /* do the link */ 10087 if (fscp->fs_cdconnected == CFS_CD_CONNECTED) 10088 error = cachefs_link_connected(dvp, vp, tmpname, cr); 10089 else 10090 error = cachefs_link_disconnected(dvp, vp, tmpname, cr); 10091 if (error) { 10092 cachefs_kmem_free(tmpname, MAXNAMELEN); 10093 return (error); 10094 } 10095 10096 mutex_enter(&cp->c_statelock); 10097 if (cp->c_unldvp) { 10098 VN_RELE(cp->c_unldvp); 10099 cachefs_kmem_free(cp->c_unlname, MAXNAMELEN); 10100 crfree(cp->c_unlcred); 10101 } 10102 10103 VN_HOLD(dvp); 10104 cp->c_unldvp = dvp; 10105 crhold(cr); 10106 cp->c_unlcred = cr; 10107 cp->c_unlname = tmpname; 10108 10109 /* drop the backvp so NFS does not also do a rename */ 10110 mutex_exit(&cp->c_statelock); 10111 10112 return (0); 10113 } 10114 10115 /* 10116 * Marks the cnode as modified. 10117 */ 10118 static void 10119 cachefs_modified(cnode_t *cp) 10120 { 10121 fscache_t *fscp = C_TO_FSCACHE(cp); 10122 struct vattr va; 10123 int error; 10124 10125 ASSERT(MUTEX_HELD(&cp->c_statelock)); 10126 ASSERT(cp->c_metadata.md_rlno); 10127 10128 /* if not on the modify list */ 10129 if (cp->c_metadata.md_rltype != CACHEFS_RL_MODIFIED) { 10130 /* put on modified list, also marks the file as modified */ 10131 cachefs_rlent_moveto(fscp->fs_cache, CACHEFS_RL_MODIFIED, 10132 cp->c_metadata.md_rlno, cp->c_metadata.md_frontblks); 10133 cp->c_metadata.md_rltype = CACHEFS_RL_MODIFIED; 10134 cp->c_flags |= CN_UPDATED; 10135 10136 /* if a modified regular file that is not local */ 10137 if (((cp->c_id.cid_flags & CFS_CID_LOCAL) == 0) && 10138 (cp->c_metadata.md_flags & MD_FILE) && 10139 (cp->c_attr.va_type == VREG)) { 10140 10141 if (cp->c_frontvp == NULL) 10142 (void) cachefs_getfrontfile(cp); 10143 if (cp->c_frontvp) { 10144 /* identify file so fsck knows it is modified */ 10145 va.va_mode = 0766; 10146 va.va_mask = AT_MODE; 10147 error = VOP_SETATTR(cp->c_frontvp, 10148 &va, 0, kcred, NULL); 10149 if (error) { 10150 cmn_err(CE_WARN, 10151 "Cannot change ff mode.\n"); 10152 } 10153 } 10154 } 10155 } 10156 } 10157 10158 /* 10159 * Marks the cnode as modified. 10160 * Allocates a rl slot for the cnode if necessary. 10161 * Returns 0 for success, !0 if cannot get an rl slot. 10162 */ 10163 static int 10164 cachefs_modified_alloc(cnode_t *cp) 10165 { 10166 fscache_t *fscp = C_TO_FSCACHE(cp); 10167 filegrp_t *fgp = cp->c_filegrp; 10168 int error; 10169 rl_entry_t rl_ent; 10170 10171 ASSERT(MUTEX_HELD(&cp->c_statelock)); 10172 10173 /* get the rl slot if needed */ 10174 if (cp->c_metadata.md_rlno == 0) { 10175 /* get a metadata slot if we do not have one yet */ 10176 if (cp->c_flags & CN_ALLOC_PENDING) { 10177 if (cp->c_filegrp->fg_flags & CFS_FG_ALLOC_ATTR) { 10178 (void) filegrp_allocattr(cp->c_filegrp); 10179 } 10180 error = filegrp_create_metadata(cp->c_filegrp, 10181 &cp->c_metadata, &cp->c_id); 10182 if (error) 10183 return (error); 10184 cp->c_flags &= ~CN_ALLOC_PENDING; 10185 } 10186 10187 /* get a free rl entry */ 10188 rl_ent.rl_fileno = cp->c_id.cid_fileno; 10189 rl_ent.rl_local = (cp->c_id.cid_flags & CFS_CID_LOCAL) ? 1 : 0; 10190 rl_ent.rl_fsid = fscp->fs_cfsid; 10191 rl_ent.rl_attrc = 0; 10192 error = cachefs_rl_alloc(fscp->fs_cache, &rl_ent, 10193 &cp->c_metadata.md_rlno); 10194 if (error) 10195 return (error); 10196 cp->c_metadata.md_rltype = CACHEFS_RL_NONE; 10197 10198 /* hold the filegrp so the attrcache file is not gc */ 10199 error = filegrp_ffhold(fgp); 10200 if (error) { 10201 cachefs_rlent_moveto(fscp->fs_cache, 10202 CACHEFS_RL_FREE, cp->c_metadata.md_rlno, 0); 10203 cp->c_metadata.md_rlno = 0; 10204 return (error); 10205 } 10206 } 10207 cachefs_modified(cp); 10208 return (0); 10209 } 10210 10211 int 10212 cachefs_vtype_aclok(vnode_t *vp) 10213 { 10214 vtype_t *vtp, oktypes[] = {VREG, VDIR, VFIFO, VNON}; 10215 10216 if (vp->v_type == VNON) 10217 return (0); 10218 10219 for (vtp = oktypes; *vtp != VNON; vtp++) 10220 if (vp->v_type == *vtp) 10221 break; 10222 10223 return (*vtp != VNON); 10224 } 10225 10226 static int 10227 cachefs_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr, 10228 caller_context_t *ct) 10229 { 10230 int error = 0; 10231 fscache_t *fscp = C_TO_FSCACHE(VTOC(vp)); 10232 10233 /* Assert cachefs compatibility if NFSv4 is in use */ 10234 CFS_BACKFS_NFSV4_ASSERT_FSCACHE(fscp); 10235 CFS_BACKFS_NFSV4_ASSERT_CNODE(VTOC(vp)); 10236 10237 if (cmd == _PC_FILESIZEBITS) { 10238 u_offset_t maxsize = fscp->fs_offmax; 10239 (*valp) = 0; 10240 while (maxsize != 0) { 10241 maxsize >>= 1; 10242 (*valp)++; 10243 } 10244 (*valp)++; 10245 } else 10246 error = fs_pathconf(vp, cmd, valp, cr, ct); 10247 10248 return (error); 10249 } 10250