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