Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/fs/coda/coda_vfsops.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Coda: an Experimental Distributed File System 3 * Release 3.1 4 * 5 * Copyright (c) 1987-1998 Carnegie Mellon University 6 * All Rights Reserved 7 * 8 * Permission to use, copy, modify and distribute this software and its 9 * documentation is hereby granted, provided that both the copyright 10 * notice and this permission notice appear in all copies of the 11 * software, derivative works or modified versions, and any portions 12 * thereof, and that both notices appear in supporting documentation, and 13 * that credit is given to Carnegie Mellon University in all documents 14 * and publicity pertaining to direct or indirect use of this code or its 15 * derivatives. 16 * 17 * CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS KNOWN TO HAVE BUGS, 18 * SOME OF WHICH MAY HAVE SERIOUS CONSEQUENCES. CARNEGIE MELLON ALLOWS 19 * FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION. CARNEGIE MELLON 20 * DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER 21 * RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE OR OF 22 * ANY DERIVATIVE WORK. 23 * 24 * Carnegie Mellon encourages users of this software to return any 25 * improvements or extensions that they make, and to grant Carnegie 26 * Mellon the rights to redistribute these changes without encumbrance. 27 * 28 * @(#) src/sys/cfs/coda_vfsops.c,v 1.1.1.1 1998/08/29 21:14:52 rvb Exp $ 29 */ 30 31 /*- 32 * Mach Operating System 33 * Copyright (c) 1989 Carnegie-Mellon University 34 * All rights reserved. The CMU software License Agreement specifies 35 * the terms and conditions for use and redistribution. 36 */ 37 38 /* 39 * This code was written for the Coda filesystem at Carnegie Mellon 40 * University. Contributers include David Steere, James Kistler, and 41 * M. Satyanarayanan. 42 */ 43 44 #include <sys/cdefs.h> 45 __FBSDID("$FreeBSD: releng/9.1/sys/fs/coda/coda_vfsops.c 206210 2010-04-05 20:12:54Z rwatson $"); 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/conf.h> 50 #include <sys/fcntl.h> 51 #include <sys/kernel.h> 52 #include <sys/lock.h> 53 #include <sys/malloc.h> 54 #include <sys/mount.h> 55 #include <sys/namei.h> 56 #include <sys/proc.h> 57 58 #include <fs/coda/coda.h> 59 #include <fs/coda/cnode.h> 60 #include <fs/coda/coda_vfsops.h> 61 #include <fs/coda/coda_venus.h> 62 #include <fs/coda/coda_subr.h> 63 #include <fs/coda/coda_opstats.h> 64 65 MALLOC_DEFINE(M_CODA, "coda", "Various Coda Structures"); 66 67 int codadebug = 0; 68 int coda_vfsop_print_entry = 0; 69 #define ENTRY do { \ 70 if (coda_vfsop_print_entry) \ 71 myprintf(("Entered %s\n", __func__)); \ 72 } while (0) 73 74 struct vnode *coda_ctlvp; 75 76 /* 77 * Structure to keep statistics of internally generated/satisfied calls. 78 */ 79 static struct coda_op_stats coda_vfsopstats[CODA_VFSOPS_SIZE]; 80 81 #define MARK_ENTRY(op) (coda_vfsopstats[op].entries++) 82 #define MARK_INT_SAT(op) (coda_vfsopstats[op].sat_intrn++) 83 #define MARK_INT_FAIL(op) (coda_vfsopstats[op].unsat_intrn++) 84 #define MARK_INT_GEN(op) (coda_vfsopstats[op].gen_intrn++) 85 86 int 87 coda_vfsopstats_init(void) 88 { 89 int i; 90 91 for (i=0; i<CODA_VFSOPS_SIZE;i++) { 92 coda_vfsopstats[i].opcode = i; 93 coda_vfsopstats[i].entries = 0; 94 coda_vfsopstats[i].sat_intrn = 0; 95 coda_vfsopstats[i].unsat_intrn = 0; 96 coda_vfsopstats[i].gen_intrn = 0; 97 } 98 return (0); 99 } 100 101 static const char *coda_opts[] = { "from", NULL }; 102 /* 103 * cfs mount vfsop 104 * 105 * Set up mount info record and attach it to vfs struct. 106 */ 107 /*ARGSUSED*/ 108 int 109 coda_mount(struct mount *vfsp) 110 { 111 struct vnode *dvp; 112 struct cnode *cp; 113 struct cdev *dev; 114 struct coda_mntinfo *mi; 115 struct vnode *rootvp; 116 struct CodaFid rootfid = INVAL_FID; 117 struct CodaFid ctlfid = CTL_FID; 118 int error; 119 struct nameidata ndp; 120 ENTRY; 121 char *from; 122 123 if (vfs_filteropt(vfsp->mnt_optnew, coda_opts)) 124 return (EINVAL); 125 from = vfs_getopts(vfsp->mnt_optnew, "from", &error); 126 if (error) 127 return (error); 128 coda_vfsopstats_init(); 129 coda_vnodeopstats_init(); 130 MARK_ENTRY(CODA_MOUNT_STATS); 131 if (CODA_MOUNTED(vfsp)) { 132 MARK_INT_FAIL(CODA_MOUNT_STATS); 133 return (EBUSY); 134 } 135 136 /* 137 * Validate mount device. Similar to getmdev(). 138 */ 139 NDINIT(&ndp, LOOKUP, FOLLOW, UIO_SYSSPACE, from, curthread); 140 error = namei(&ndp); 141 dvp = ndp.ni_vp; 142 if (error) { 143 MARK_INT_FAIL(CODA_MOUNT_STATS); 144 return (error); 145 } 146 if (dvp->v_type != VCHR) { 147 MARK_INT_FAIL(CODA_MOUNT_STATS); 148 vrele(dvp); 149 NDFREE(&ndp, NDF_ONLY_PNBUF); 150 return (ENXIO); 151 } 152 dev = dvp->v_rdev; 153 vrele(dvp); 154 NDFREE(&ndp, NDF_ONLY_PNBUF); 155 156 /* 157 * Initialize the mount record and link it to the vfs struct. 158 */ 159 mi = dev2coda_mntinfo(dev); 160 if (!mi) { 161 MARK_INT_FAIL(CODA_MOUNT_STATS); 162 printf("Coda mount: %s is not a cfs device\n", from); 163 return (ENXIO); 164 } 165 if (!VC_OPEN(&mi->mi_vcomm)) { 166 MARK_INT_FAIL(CODA_MOUNT_STATS); 167 return (ENODEV); 168 } 169 170 /* 171 * No initialization (here) of mi_vcomm! 172 */ 173 vfsp->mnt_data = mi; 174 vfs_getnewfsid (vfsp); 175 mi->mi_vfsp = vfsp; 176 mi->mi_started = 0; /* XXX See coda_root() */ 177 178 /* 179 * Make a root vnode to placate the Vnode interface, but don't 180 * actually make the CODA_ROOT call to venus until the first call to 181 * coda_root in case a server is down while venus is starting. 182 */ 183 cp = make_coda_node(&rootfid, vfsp, VDIR); 184 rootvp = CTOV(cp); 185 rootvp->v_vflag |= VV_ROOT; 186 cp = make_coda_node(&ctlfid, vfsp, VREG); 187 coda_ctlvp = CTOV(cp); 188 189 /* 190 * Add vfs and rootvp to chain of vfs hanging off mntinfo. 191 */ 192 mi->mi_vfsp = vfsp; 193 mi->mi_rootvp = rootvp; 194 vfs_mountedfrom(vfsp, from); 195 196 /* 197 * Error is currently guaranteed to be zero, but in case some code 198 * changes... 199 */ 200 CODADEBUG(1, myprintf(("coda_mount returned %d\n", error));); 201 if (error) 202 MARK_INT_FAIL(CODA_MOUNT_STATS); 203 else 204 MARK_INT_SAT(CODA_MOUNT_STATS); 205 return (error); 206 } 207 208 int 209 coda_unmount(struct mount *vfsp, int mntflags) 210 { 211 struct coda_mntinfo *mi = vftomi(vfsp); 212 int active, error = 0; 213 214 ENTRY; 215 MARK_ENTRY(CODA_UMOUNT_STATS); 216 if (!CODA_MOUNTED(vfsp)) { 217 MARK_INT_FAIL(CODA_UMOUNT_STATS); 218 return (EINVAL); 219 } 220 if (mi->mi_vfsp == vfsp) { 221 /* 222 * We found the victim. 223 */ 224 if (!IS_UNMOUNTING(VTOC(mi->mi_rootvp))) 225 return (EBUSY); /* Venus is still running */ 226 #ifdef DEBUG 227 printf("coda_unmount: ROOT: vp %p, cp %p\n", mi->mi_rootvp, 228 VTOC(mi->mi_rootvp)); 229 #endif 230 vrele(mi->mi_rootvp); 231 mi->mi_rootvp = NULL; 232 vrele(coda_ctlvp); 233 coda_ctlvp = NULL; 234 active = coda_kill(vfsp, NOT_DOWNCALL); 235 error = vflush(mi->mi_vfsp, 0, FORCECLOSE, curthread); 236 #ifdef CODA_VERBOSE 237 printf("coda_unmount: active = %d, vflush active %d\n", 238 active, error); 239 #endif 240 error = 0; 241 /* 242 * I'm going to take this out to allow lookups to go through. 243 * I'm not sure it's important anyway. -- DCS 2/2/94 244 */ 245 /* vfsp->VFS_DATA = NULL; */ 246 247 /* 248 * No more vfsp's to hold onto. 249 */ 250 mi->mi_vfsp = NULL; 251 252 if (error) 253 MARK_INT_FAIL(CODA_UMOUNT_STATS); 254 else 255 MARK_INT_SAT(CODA_UMOUNT_STATS); 256 return (error); 257 } 258 return (EINVAL); 259 } 260 261 /* 262 * Find root of cfs. 263 */ 264 int 265 coda_root(struct mount *vfsp, int flags, struct vnode **vpp) 266 { 267 struct coda_mntinfo *mi = vftomi(vfsp); 268 int error; 269 struct proc *p; 270 struct thread *td; 271 struct CodaFid VFid; 272 static const struct CodaFid invalfid = INVAL_FID; 273 274 td = curthread; 275 p = td->td_proc; 276 ENTRY; 277 MARK_ENTRY(CODA_ROOT_STATS); 278 if (vfsp == mi->mi_vfsp) { 279 /* 280 * Cache the root across calls. We only need to pass the 281 * request on to Venus if the root vnode is the dummy we 282 * installed in coda_mount() with all c_fid members zeroed. 283 * 284 * XXX In addition, we assume that the first call to 285 * coda_root() is from vfs_mount() (before the call to 286 * checkdirs()) and return the dummy root node to avoid a 287 * deadlock. This bug is fixed in the Coda CVS repository 288 * but not in any released versions as of 6 Mar 2003. 289 */ 290 if (memcmp(&VTOC(mi->mi_rootvp)->c_fid, &invalfid, 291 sizeof(struct CodaFid)) != 0 || mi->mi_started == 0) { 292 /* 293 * Found valid root. 294 */ 295 *vpp = mi->mi_rootvp; 296 mi->mi_started = 1; 297 298 /* 299 * On Mach, this is vref. On FreeBSD, vref + 300 * vn_lock. 301 */ 302 vref(*vpp); 303 vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY); 304 MARK_INT_SAT(CODA_ROOT_STATS); 305 return (0); 306 } 307 } 308 309 error = venus_root(vftomi(vfsp), td->td_ucred, p, &VFid); 310 if (!error) { 311 /* 312 * Save the new rootfid in the cnode, and rehash the cnode 313 * into the cnode hash with the new fid key. 314 */ 315 coda_unsave(VTOC(mi->mi_rootvp)); 316 VTOC(mi->mi_rootvp)->c_fid = VFid; 317 coda_save(VTOC(mi->mi_rootvp)); 318 *vpp = mi->mi_rootvp; 319 vref(*vpp); 320 vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY); 321 MARK_INT_SAT(CODA_ROOT_STATS); 322 } else if (error == ENODEV || error == EINTR) { 323 /* 324 * Gross hack here! 325 * 326 * If Venus fails to respond to the CODA_ROOT call, coda_call 327 * returns ENODEV. Return the uninitialized root vnode to 328 * allow vfs operations such as unmount to continue. Without 329 * this hack, there is no way to do an unmount if Venus dies 330 * before a successful CODA_ROOT call is done. All vnode 331 * operations will fail. 332 */ 333 *vpp = mi->mi_rootvp; 334 vref(*vpp); 335 vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY); 336 MARK_INT_FAIL(CODA_ROOT_STATS); 337 error = 0; 338 } else { 339 CODADEBUG(CODA_ROOT, myprintf(("error %d in CODA_ROOT\n", 340 error));); 341 MARK_INT_FAIL(CODA_ROOT_STATS); 342 } 343 return (error); 344 } 345 346 /* 347 * Get filesystem statistics. 348 */ 349 int 350 coda_statfs(struct mount *vfsp, struct statfs *sbp) 351 { 352 353 ENTRY; 354 MARK_ENTRY(CODA_STATFS_STATS); 355 if (!CODA_MOUNTED(vfsp)) { 356 MARK_INT_FAIL(CODA_STATFS_STATS); 357 return (EINVAL); 358 } 359 360 /* 361 * XXX - what to do about f_flags, others? --bnoble 362 * 363 * We just make up free space counts that are sufficiently large. 364 */ 365 sbp->f_flags = 0; 366 sbp->f_bsize = 8192; /* XXX */ 367 sbp->f_iosize = 8192; /* XXX */ 368 #define CODA_SFS_SIZ 0x8AB75D 369 sbp->f_blocks = CODA_SFS_SIZ; 370 sbp->f_bfree = CODA_SFS_SIZ; 371 sbp->f_bavail = CODA_SFS_SIZ; 372 sbp->f_files = CODA_SFS_SIZ; 373 sbp->f_ffree = CODA_SFS_SIZ; 374 MARK_INT_SAT(CODA_STATFS_STATS); 375 return (0); 376 } 377 378 /* 379 * Flush any pending I/O. 380 */ 381 int 382 coda_sync(struct mount *vfsp, int waitfor) 383 { 384 385 ENTRY; 386 MARK_ENTRY(CODA_SYNC_STATS); 387 MARK_INT_SAT(CODA_SYNC_STATS); 388 return (0); 389 } 390 391 /* 392 * fhtovp is now what vget used to be in 4.3-derived systems. For some silly 393 * reason, vget is now keyed by a 32 bit ino_t, rather than a type-specific 394 * fid. 395 * 396 * XXX: coda_fhtovp is currently not hooked up, so no NFS export for Coda. 397 * We leave it here in the hopes that someone will find it someday and hook 398 * it up. Among other things, it will need some reworking to match the 399 * vfs_fhtovp_t prototype. 400 */ 401 int 402 coda_fhtovp(struct mount *vfsp, struct fid *fhp, struct mbuf *nam, 403 struct vnode **vpp, int *exflagsp, struct ucred **creadanonp) 404 { 405 struct cfid *cfid = (struct cfid *)fhp; 406 struct cnode *cp = NULL; 407 int error; 408 struct thread *td = curthread; /* XXX -mach */ 409 struct proc *p = td->td_proc; 410 struct CodaFid VFid; 411 int vtype; 412 413 ENTRY; 414 MARK_ENTRY(CODA_VGET_STATS); 415 416 /* 417 * Check for vget of control object. 418 */ 419 if (IS_CTL_FID(&cfid->cfid_fid)) { 420 *vpp = coda_ctlvp; 421 vref(coda_ctlvp); 422 MARK_INT_SAT(CODA_VGET_STATS); 423 return (0); 424 } 425 error = venus_fhtovp(vftomi(vfsp), &cfid->cfid_fid, td->td_ucred, p, 426 &VFid, &vtype); 427 if (error) { 428 CODADEBUG(CODA_VGET, myprintf(("vget error %d\n",error));); 429 *vpp = NULL; 430 } else { 431 CODADEBUG(CODA_VGET, myprintf(("vget: %s type %d result " 432 "%d\n", coda_f2s(&VFid), vtype, error));); 433 cp = make_coda_node(&VFid, vfsp, vtype); 434 *vpp = CTOV(cp); 435 } 436 return (error); 437 } 438 439 struct vfsops coda_vfsops = { 440 .vfs_mount = coda_mount, 441 .vfs_root = coda_root, 442 .vfs_statfs = coda_statfs, 443 .vfs_sync = coda_sync, 444 .vfs_unmount = coda_unmount, 445 }; 446 VFS_SET(coda_vfsops, coda, VFCF_NETWORK);
Cache object: 3c5ac682eec662c17494bd8a14d19fe0
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]