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/coda/coda_vnops.c,v 1.1.1.1 1998/08/29 21:14:52 rvb Exp $
29 */
30 /*
31 * Mach Operating System
32 * Copyright (c) 1990 Carnegie-Mellon University
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/8.4/sys/fs/coda/coda_vnops.c 215860 2010-11-26 11:37:35Z kib $");
46
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/acct.h>
50 #include <sys/errno.h>
51 #include <sys/fcntl.h>
52 #include <sys/kernel.h>
53 #include <sys/lock.h>
54 #include <sys/malloc.h>
55 #include <sys/file.h> /* Must come after sys/malloc.h */
56 #include <sys/mount.h>
57 #include <sys/mutex.h>
58 #include <sys/namei.h>
59 #include <sys/proc.h>
60 #include <sys/uio.h>
61 #include <sys/unistd.h>
62
63 #include <vm/vm.h>
64 #include <vm/vm_object.h>
65 #include <vm/vm_extern.h>
66
67 #include <fs/coda/coda.h>
68 #include <fs/coda/cnode.h>
69 #include <fs/coda/coda_vnops.h>
70 #include <fs/coda/coda_venus.h>
71 #include <fs/coda/coda_opstats.h>
72 #include <fs/coda/coda_subr.h>
73 #include <fs/coda/coda_pioctl.h>
74
75 /*
76 * These flags select various performance enhancements.
77 */
78 static int coda_attr_cache = 1; /* Set to cache attributes. */
79 static int coda_symlink_cache = 1; /* Set to cache symbolic links. */
80 static int coda_access_cache = 1; /* Set to cache some access checks. */
81
82 /*
83 * Structure to keep track of vfs calls.
84 */
85 static struct coda_op_stats coda_vnodeopstats[CODA_VNODEOPS_SIZE];
86
87 #define MARK_ENTRY(op) (coda_vnodeopstats[op].entries++)
88 #define MARK_INT_SAT(op) (coda_vnodeopstats[op].sat_intrn++)
89 #define MARK_INT_FAIL(op) (coda_vnodeopstats[op].unsat_intrn++)
90 #define MARK_INT_GEN(op) (coda_vnodeopstats[op].gen_intrn++)
91
92 /*
93 * What we are delaying for in printf.
94 */
95 int coda_printf_delay = 0; /* In microseconds */
96 int coda_vnop_print_entry = 0;
97 static int coda_lockdebug = 0;
98
99 /*
100 * Some FreeBSD details:
101 *
102 * codadev_modevent is called at boot time or module load time.
103 */
104 #define ENTRY do { \
105 if (coda_vnop_print_entry) \
106 myprintf(("Entered %s\n", __func__)); \
107 } while (0)
108
109 /*
110 * Definition of the vnode operation vector.
111 */
112 struct vop_vector coda_vnodeops = {
113 .vop_default = &default_vnodeops,
114 .vop_cachedlookup = coda_lookup, /* uncached lookup */
115 .vop_lookup = vfs_cache_lookup, /* namecache lookup */
116 .vop_create = coda_create, /* create */
117 .vop_open = coda_open, /* open */
118 .vop_close = coda_close, /* close */
119 .vop_access = coda_access, /* access */
120 .vop_getattr = coda_getattr, /* getattr */
121 .vop_setattr = coda_setattr, /* setattr */
122 .vop_read = coda_read, /* read */
123 .vop_write = coda_write, /* write */
124 .vop_ioctl = coda_ioctl, /* ioctl */
125 .vop_fsync = coda_fsync, /* fsync */
126 .vop_remove = coda_remove, /* remove */
127 .vop_link = coda_link, /* link */
128 .vop_rename = coda_rename, /* rename */
129 .vop_mkdir = coda_mkdir, /* mkdir */
130 .vop_rmdir = coda_rmdir, /* rmdir */
131 .vop_symlink = coda_symlink, /* symlink */
132 .vop_readdir = coda_readdir, /* readdir */
133 .vop_readlink = coda_readlink, /* readlink */
134 .vop_inactive = coda_inactive, /* inactive */
135 .vop_reclaim = coda_reclaim, /* reclaim */
136 .vop_lock1 = coda_lock, /* lock */
137 .vop_unlock = coda_unlock, /* unlock */
138 .vop_bmap = VOP_EOPNOTSUPP, /* bmap */
139 .vop_print = VOP_NULL, /* print */
140 .vop_islocked = coda_islocked, /* islocked */
141 .vop_pathconf = coda_pathconf, /* pathconf */
142 .vop_poll = vop_stdpoll,
143 .vop_getpages = vop_stdgetpages, /* pager intf.*/
144 .vop_putpages = vop_stdputpages, /* pager intf.*/
145 .vop_getwritemount = vop_stdgetwritemount,
146 #if 0
147 /* missing */
148 .vop_cachedlookup = ufs_lookup,
149 .vop_whiteout = ufs_whiteout,
150 #endif
151
152 };
153
154 static void coda_print_vattr(struct vattr *attr);
155
156 int
157 coda_vnodeopstats_init(void)
158 {
159 int i;
160
161 for(i=0; i<CODA_VNODEOPS_SIZE; i++) {
162 coda_vnodeopstats[i].opcode = i;
163 coda_vnodeopstats[i].entries = 0;
164 coda_vnodeopstats[i].sat_intrn = 0;
165 coda_vnodeopstats[i].unsat_intrn = 0;
166 coda_vnodeopstats[i].gen_intrn = 0;
167 }
168 return (0);
169 }
170
171 /*
172 * coda_open calls Venus which returns an open file descriptor the cache file
173 * holding the data. We get the vnode while we are still in the context of
174 * the venus process in coda_psdev.c. This vnode is then passed back to the
175 * caller and opened.
176 */
177 int
178 coda_open(struct vop_open_args *ap)
179 {
180
181 /*
182 * FreeBSD can pass the O_EXCL flag in mode, even though the check
183 * has already happened. Venus defensively assumes that if open is
184 * passed the EXCL, it must be a bug. We strip the flag here.
185 */
186 /* true args */
187 struct vnode **vpp = &(ap->a_vp);
188 struct cnode *cp = VTOC(*vpp);
189 int flag = ap->a_mode & (~O_EXCL);
190 struct ucred *cred = ap->a_cred;
191 struct thread *td = ap->a_td;
192 /* locals */
193 int error;
194 struct vnode *vp;
195
196 MARK_ENTRY(CODA_OPEN_STATS);
197
198 /*
199 * Check for open of control file.
200 */
201 if (IS_CTL_VP(*vpp)) {
202 /* XXX */
203 /* if (WRITEABLE(flag)) */
204 if (flag & (FWRITE | O_TRUNC | O_CREAT | O_EXCL)) {
205 MARK_INT_FAIL(CODA_OPEN_STATS);
206 return (EACCES);
207 }
208 MARK_INT_SAT(CODA_OPEN_STATS);
209 return (0);
210 }
211 error = venus_open(vtomi((*vpp)), &cp->c_fid, flag, cred,
212 td->td_proc, &vp);
213 if (error)
214 return (error);
215 CODADEBUG(CODA_OPEN, myprintf(("open: vp %p result %d\n", vp,
216 error)););
217
218 /*
219 * Save the vnode pointer for the cache file.
220 */
221 if (cp->c_ovp == NULL) {
222 cp->c_ovp = vp;
223 } else {
224 if (cp->c_ovp != vp)
225 panic("coda_open: cp->c_ovp != ITOV(ip)");
226 }
227 cp->c_ocount++;
228
229 /*
230 * Flush the attribute cached if writing the file.
231 */
232 if (flag & FWRITE) {
233 cp->c_owrite++;
234 cp->c_flags &= ~C_VATTR;
235 }
236
237 /*
238 * Open the cache file.
239 */
240 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
241 error = VOP_OPEN(vp, flag, cred, td, NULL);
242 if (error) {
243 VOP_UNLOCK(vp, 0);
244 printf("coda_open: VOP_OPEN on container failed %d\n", error);
245 return (error);
246 }
247 (*vpp)->v_object = vp->v_object;
248 VOP_UNLOCK(vp, 0);
249 return (0);
250 }
251
252 /*
253 * Close the cache file used for I/O and notify Venus.
254 */
255 int
256 coda_close(struct vop_close_args *ap)
257 {
258 /* true args */
259 struct vnode *vp = ap->a_vp;
260 struct cnode *cp = VTOC(vp);
261 int flag = ap->a_fflag;
262 struct ucred *cred = ap->a_cred;
263 struct thread *td = ap->a_td;
264 /* locals */
265 int error;
266
267 MARK_ENTRY(CODA_CLOSE_STATS);
268
269 /*
270 * Check for close of control file.
271 */
272 if (IS_CTL_VP(vp)) {
273 MARK_INT_SAT(CODA_CLOSE_STATS);
274 return (0);
275 }
276 if (cp->c_ovp) {
277 vn_lock(cp->c_ovp, LK_EXCLUSIVE | LK_RETRY);
278 /* Do errors matter here? */
279 VOP_CLOSE(cp->c_ovp, flag, cred, td);
280 vput(cp->c_ovp);
281 }
282 #ifdef CODA_VERBOSE
283 else
284 printf("coda_close: NO container vp %p/cp %p\n", vp, cp);
285 #endif
286 if (--cp->c_ocount == 0)
287 cp->c_ovp = NULL;
288
289 /*
290 * File was opened for write.
291 */
292 if (flag & FWRITE)
293 --cp->c_owrite;
294 if (!IS_UNMOUNTING(cp))
295 error = venus_close(vtomi(vp), &cp->c_fid, flag, cred,
296 td->td_proc);
297 else
298 error = ENODEV;
299 CODADEBUG(CODA_CLOSE, myprintf(("close: result %d\n",error)););
300 return (error);
301 }
302
303 int
304 coda_read(struct vop_read_args *ap)
305 {
306
307 ENTRY;
308 return (coda_rdwr(ap->a_vp, ap->a_uio, UIO_READ, ap->a_ioflag,
309 ap->a_cred, ap->a_uio->uio_td));
310 }
311
312 int
313 coda_write(struct vop_write_args *ap)
314 {
315
316 ENTRY;
317 return (coda_rdwr(ap->a_vp, ap->a_uio, UIO_WRITE, ap->a_ioflag,
318 ap->a_cred, ap->a_uio->uio_td));
319 }
320
321 int
322 coda_rdwr(struct vnode *vp, struct uio *uiop, enum uio_rw rw, int ioflag,
323 struct ucred *cred, struct thread *td)
324 {
325 /* upcall decl */
326 /* NOTE: container file operation!!! */
327 /* locals */
328 struct cnode *cp = VTOC(vp);
329 struct vnode *cfvp = cp->c_ovp;
330 int opened_internally = 0;
331 int error = 0;
332
333 MARK_ENTRY(CODA_RDWR_STATS);
334 CODADEBUG(CODA_RDWR, myprintf(("coda_rdwr(%d, %p, %zd, %lld, %d)\n",
335 rw, (void *)uiop->uio_iov->iov_base, uiop->uio_resid,
336 (long long)uiop->uio_offset, uiop->uio_segflg)););
337
338 /*
339 * Check for rdwr of control object.
340 */
341 if (IS_CTL_VP(vp)) {
342 MARK_INT_FAIL(CODA_RDWR_STATS);
343 return (EINVAL);
344 }
345
346 /*
347 * If file is not already open this must be a page {read,write}
348 * request and we should open it internally.
349 */
350 if (cfvp == NULL) {
351 opened_internally = 1;
352 MARK_INT_GEN(CODA_OPEN_STATS);
353 error = VOP_OPEN(vp, (rw == UIO_READ ? FREAD : FWRITE), cred,
354 td, NULL);
355 #ifdef CODA_VERBOSE
356 printf("coda_rdwr: Internally Opening %p\n", vp);
357 #endif
358 if (error) {
359 printf("coda_rdwr: VOP_OPEN on container failed "
360 "%d\n", error);
361 return (error);
362 }
363 cfvp = cp->c_ovp;
364 }
365
366 /*
367 * Have UFS handle the call.
368 */
369 CODADEBUG(CODA_RDWR, myprintf(("indirect rdwr: fid = %s, refcnt = "
370 "%d\n", coda_f2s(&cp->c_fid), CTOV(cp)->v_usecount)););
371 vn_lock(cfvp, LK_EXCLUSIVE | LK_RETRY);
372 if (rw == UIO_READ) {
373 error = VOP_READ(cfvp, uiop, ioflag, cred);
374 } else {
375 error = VOP_WRITE(cfvp, uiop, ioflag, cred);
376 /*
377 * ufs_write updates the vnode_pager_setsize for the
378 * vnode/object.
379 *
380 * XXX: Since we now share vm objects between layers, this is
381 * probably unnecessary.
382 */
383 {
384 struct vattr attr;
385 if (VOP_GETATTR(cfvp, &attr, cred) == 0)
386 vnode_pager_setsize(vp, attr.va_size);
387 }
388 }
389 VOP_UNLOCK(cfvp, 0);
390 if (error)
391 MARK_INT_FAIL(CODA_RDWR_STATS);
392 else
393 MARK_INT_SAT(CODA_RDWR_STATS);
394
395 /*
396 * Do an internal close if necessary.
397 */
398 if (opened_internally) {
399 MARK_INT_GEN(CODA_CLOSE_STATS);
400 (void)VOP_CLOSE(vp, (rw == UIO_READ ? FREAD : FWRITE), cred,
401 td);
402 }
403
404 /*
405 * Invalidate cached attributes if writing.
406 */
407 if (rw == UIO_WRITE)
408 cp->c_flags &= ~C_VATTR;
409 return (error);
410 }
411
412 int
413 coda_ioctl(struct vop_ioctl_args *ap)
414 {
415 /* true args */
416 struct vnode *vp = ap->a_vp;
417 int com = ap->a_command;
418 caddr_t data = ap->a_data;
419 int flag = ap->a_fflag;
420 struct ucred *cred = ap->a_cred;
421 struct thread *td = ap->a_td;
422 /* locals */
423 int error;
424 struct vnode *tvp;
425 struct nameidata ndp;
426 struct PioctlData *iap = (struct PioctlData *)data;
427
428 MARK_ENTRY(CODA_IOCTL_STATS);
429 CODADEBUG(CODA_IOCTL, myprintf(("in coda_ioctl on %s\n", iap->path)););
430
431 /*
432 * Don't check for operation on a dying object, for ctlvp it
433 * shouldn't matter.
434 *
435 * Must be control object to succeed.
436 */
437 if (!IS_CTL_VP(vp)) {
438 MARK_INT_FAIL(CODA_IOCTL_STATS);
439 CODADEBUG(CODA_IOCTL, myprintf(("coda_ioctl error: vp != "
440 "ctlvp")););
441 return (EOPNOTSUPP);
442 }
443
444 /*
445 * Look up the pathname.
446 *
447 * Should we use the name cache here? It would get it from lookupname
448 * sooner or later anyway, right?
449 */
450 NDINIT(&ndp, LOOKUP, (iap->follow ? FOLLOW : NOFOLLOW),
451 UIO_USERSPACE, iap->path, td);
452 error = namei(&ndp);
453 tvp = ndp.ni_vp;
454 if (error) {
455 MARK_INT_FAIL(CODA_IOCTL_STATS);
456 CODADEBUG(CODA_IOCTL, myprintf(("coda_ioctl error: lookup "
457 "returns %d\n", error)););
458 return (error);
459 }
460
461 /*
462 * Make sure this is a coda style cnode, but it may be a different
463 * vfsp.
464 */
465 if (tvp->v_op != &coda_vnodeops) {
466 vrele(tvp);
467 NDFREE(&ndp, NDF_ONLY_PNBUF);
468 MARK_INT_FAIL(CODA_IOCTL_STATS);
469 CODADEBUG(CODA_IOCTL,
470 myprintf(("coda_ioctl error: %s not a coda object\n",
471 iap->path)););
472 return (EINVAL);
473 }
474 if (iap->vi.in_size > VC_MAXDATASIZE) {
475 NDFREE(&ndp, 0);
476 return (EINVAL);
477 }
478 error = venus_ioctl(vtomi(tvp), &((VTOC(tvp))->c_fid), com, flag,
479 data, cred, td->td_proc);
480 if (error)
481 MARK_INT_FAIL(CODA_IOCTL_STATS);
482 else
483 CODADEBUG(CODA_IOCTL, myprintf(("Ioctl returns %d \n",
484 error)););
485 vrele(tvp);
486 NDFREE(&ndp, NDF_ONLY_PNBUF);
487 return (error);
488 }
489
490 /*
491 * To reduce the cost of a user-level venus;we cache attributes in the
492 * kernel. Each cnode has storage allocated for an attribute. If c_vattr is
493 * valid, return a reference to it. Otherwise, get the attributes from venus
494 * and store them in the cnode. There is some question if this method is a
495 * security leak. But I think that in order to make this call, the user must
496 * have done a lookup and opened the file, and therefore should already have
497 * access.
498 */
499 int
500 coda_getattr(struct vop_getattr_args *ap)
501 {
502 /* true args */
503 struct vnode *vp = ap->a_vp;
504 struct cnode *cp = VTOC(vp);
505 struct vattr *vap = ap->a_vap;
506 struct ucred *cred = ap->a_cred;
507 /* locals */
508 struct vnode *convp;
509 int error, size;
510
511 MARK_ENTRY(CODA_GETATTR_STATS);
512 if (IS_UNMOUNTING(cp))
513 return (ENODEV);
514
515 /*
516 * Check for getattr of control object.
517 */
518 if (IS_CTL_VP(vp)) {
519 MARK_INT_FAIL(CODA_GETATTR_STATS);
520 return (ENOENT);
521 }
522
523 /*
524 * Check to see if the attributes have already been cached.
525 */
526 if (VALID_VATTR(cp)) {
527 CODADEBUG(CODA_GETATTR, myprintf(("attr cache hit: %s\n",
528 coda_f2s(&cp->c_fid))););
529 CODADEBUG(CODA_GETATTR, if (!(codadebug & ~CODA_GETATTR))
530 coda_print_vattr(&cp->c_vattr););
531 *vap = cp->c_vattr;
532 MARK_INT_SAT(CODA_GETATTR_STATS);
533 return (0);
534 }
535 error = venus_getattr(vtomi(vp), &cp->c_fid, cred, vap);
536 if (!error) {
537 CODADEBUG(CODA_GETATTR, myprintf(("getattr miss %s: result "
538 "%d\n", coda_f2s(&cp->c_fid), error)););
539 CODADEBUG(CODA_GETATTR, if (!(codadebug & ~CODA_GETATTR))
540 coda_print_vattr(vap););
541
542 /*
543 * XXX: Since we now share vm objects between layers, this is
544 * probably unnecessary.
545 */
546 size = vap->va_size;
547 convp = cp->c_ovp;
548 if (convp != NULL)
549 vnode_pager_setsize(convp, size);
550
551 /*
552 * If not open for write, store attributes in cnode.
553 */
554 if ((cp->c_owrite == 0) && (coda_attr_cache)) {
555 cp->c_vattr = *vap;
556 cp->c_flags |= C_VATTR;
557 }
558 }
559 return (error);
560 }
561
562 int
563 coda_setattr(struct vop_setattr_args *ap)
564 {
565 /* true args */
566 struct vnode *vp = ap->a_vp;
567 struct cnode *cp = VTOC(vp);
568 struct vattr *vap = ap->a_vap;
569 struct ucred *cred = ap->a_cred;
570 /* locals */
571 struct vnode *convp;
572 int error, size;
573
574 MARK_ENTRY(CODA_SETATTR_STATS);
575
576 /*
577 * Check for setattr of control object.
578 */
579 if (IS_CTL_VP(vp)) {
580 MARK_INT_FAIL(CODA_SETATTR_STATS);
581 return (ENOENT);
582 }
583 if (codadebug & CODADBGMSK(CODA_SETATTR))
584 coda_print_vattr(vap);
585 error = venus_setattr(vtomi(vp), &cp->c_fid, vap, cred);
586 if (!error)
587 cp->c_flags &= ~(C_VATTR | C_ACCCACHE);
588
589 /*
590 * XXX: Since we now share vm objects between layers, this is
591 * probably unnecessary.
592 *
593 * XXX: Shouldn't we only be doing this "set" if C_VATTR remains
594 * valid after venus_setattr()?
595 */
596 size = vap->va_size;
597 convp = cp->c_ovp;
598 if (size != VNOVAL && convp != NULL)
599 vnode_pager_setsize(convp, size);
600 CODADEBUG(CODA_SETATTR, myprintf(("setattr %d\n", error)););
601 return (error);
602 }
603
604 int
605 coda_access(struct vop_access_args *ap)
606 {
607 /* true args */
608 struct vnode *vp = ap->a_vp;
609 struct cnode *cp = VTOC(vp);
610 accmode_t accmode = ap->a_accmode;
611 struct ucred *cred = ap->a_cred;
612 struct thread *td = ap->a_td;
613 /* locals */
614 int error;
615
616 MARK_ENTRY(CODA_ACCESS_STATS);
617
618 /*
619 * Check for access of control object. Only read access is allowed
620 * on it.
621 */
622 if (IS_CTL_VP(vp)) {
623 /*
624 * Bogus hack - all will be marked as successes.
625 */
626 MARK_INT_SAT(CODA_ACCESS_STATS);
627 return (((accmode & VREAD) && !(accmode & (VWRITE | VEXEC)))
628 ? 0 : EACCES);
629 }
630
631 /*
632 * We maintain a one-entry LRU positive access cache with each cnode.
633 * In principle we could also track negative results, and for more
634 * than one uid, but we don't yet. Venus is responsible for
635 * invalidating this cache as required.
636 */
637 if (coda_access_cache && VALID_ACCCACHE(cp) &&
638 (cred->cr_uid == cp->c_cached_uid) &&
639 (accmode & cp->c_cached_mode) == accmode) {
640 MARK_INT_SAT(CODA_ACCESS_STATS);
641 return (0);
642 }
643 error = venus_access(vtomi(vp), &cp->c_fid, accmode, cred, td->td_proc);
644 if (error == 0 && coda_access_cache) {
645 /*-
646 * When we have a new successful request, we consider three
647 * cases:
648 *
649 * - No initialized access cache, in which case cache the
650 * result.
651 * - Cached result for a different user, in which case we
652 * replace the entry.
653 * - Cached result for the same user, in which case we add
654 * any newly granted rights to the cached mode.
655 *
656 * XXXRW: If we ever move to something more interesting than
657 * uid-based token lookup, we'll need to change this.
658 */
659 cp->c_flags |= C_ACCCACHE;
660 if (cp->c_cached_uid != cred->cr_uid) {
661 cp->c_cached_mode = accmode;
662 cp->c_cached_uid = cred->cr_uid;
663 } else
664 cp->c_cached_mode |= accmode;
665 }
666 return (error);
667 }
668
669 int
670 coda_readlink(struct vop_readlink_args *ap)
671 {
672 /* true args */
673 struct vnode *vp = ap->a_vp;
674 struct cnode *cp = VTOC(vp);
675 struct uio *uiop = ap->a_uio;
676 struct ucred *cred = ap->a_cred;
677 struct thread *td = ap->a_uio->uio_td;
678 /* locals */
679 int error;
680 char *str;
681 int len;
682
683 MARK_ENTRY(CODA_READLINK_STATS);
684
685 /*
686 * Check for readlink of control object.
687 */
688 if (IS_CTL_VP(vp)) {
689 MARK_INT_FAIL(CODA_READLINK_STATS);
690 return (ENOENT);
691 }
692 if ((coda_symlink_cache) && (VALID_SYMLINK(cp))) {
693 /*
694 * Symlink was cached.
695 */
696 uiop->uio_rw = UIO_READ;
697 error = uiomove(cp->c_symlink, (int)cp->c_symlen, uiop);
698 if (error)
699 MARK_INT_FAIL(CODA_READLINK_STATS);
700 else
701 MARK_INT_SAT(CODA_READLINK_STATS);
702 return (error);
703 }
704 error = venus_readlink(vtomi(vp), &cp->c_fid, cred, td != NULL ?
705 td->td_proc : NULL, &str, &len);
706 if (!error) {
707 uiop->uio_rw = UIO_READ;
708 error = uiomove(str, len, uiop);
709 if (coda_symlink_cache) {
710 cp->c_symlink = str;
711 cp->c_symlen = len;
712 cp->c_flags |= C_SYMLINK;
713 } else
714 CODA_FREE(str, len);
715 }
716 CODADEBUG(CODA_READLINK, myprintf(("in readlink result %d\n",
717 error)););
718 return (error);
719 }
720
721 int
722 coda_fsync(struct vop_fsync_args *ap)
723 {
724 /* true args */
725 struct vnode *vp = ap->a_vp;
726 struct cnode *cp = VTOC(vp);
727 struct thread *td = ap->a_td;
728 /* locals */
729 struct vnode *convp = cp->c_ovp;
730 int error;
731
732 MARK_ENTRY(CODA_FSYNC_STATS);
733
734 /*
735 * Check for fsync on an unmounting object.
736 *
737 * XXX: Is this comment true on FreeBSD? It seems likely, since
738 * unmounting is fairly non-atomic.
739 *
740 * The NetBSD kernel, in it's infinite wisdom, can try to fsync after
741 * an unmount has been initiated. This is a Bad Thing, which we have
742 * to avoid. Not a legitimate failure for stats.
743 */
744 if (IS_UNMOUNTING(cp))
745 return (ENODEV);
746
747 /*
748 * Check for fsync of control object.
749 */
750 if (IS_CTL_VP(vp)) {
751 MARK_INT_SAT(CODA_FSYNC_STATS);
752 return (0);
753 }
754 if (convp != NULL) {
755 vn_lock(convp, LK_EXCLUSIVE | LK_RETRY);
756 VOP_FSYNC(convp, MNT_WAIT, td);
757 VOP_UNLOCK(convp, 0);
758 }
759
760 /*
761 * We see fsyncs with usecount == 1 then usecount == 0. For now we
762 * ignore them.
763 */
764 #if 0
765 VI_LOCK(vp);
766 if (!vp->v_usecount) {
767 printf("coda_fsync on vnode %p with %d usecount. "
768 "c_flags = %x (%x)\n", vp, vp->v_usecount, cp->c_flags,
769 cp->c_flags&C_PURGING);
770 }
771 VI_UNLOCK(vp);
772 #endif
773
774 /*
775 * We can expect fsync on any vnode at all if venus is purging it.
776 * Venus can't very well answer the fsync request, now can it?
777 * Hopefully, it won't have to, because hopefully, venus preserves
778 * the (possibly untrue) invariant that it never purges an open
779 * vnode. Hopefully.
780 */
781 if (cp->c_flags & C_PURGING)
782 return (0);
783
784 /* XXX: needs research */
785 return (0);
786 error = venus_fsync(vtomi(vp), &cp->c_fid, td->td_proc);
787 CODADEBUG(CODA_FSYNC, myprintf(("in fsync result %d\n", error)););
788 return (error);
789 }
790
791 int
792 coda_inactive(struct vop_inactive_args *ap)
793 {
794 /*
795 * XXX - at the moment, inactive doesn't look at cred, and doesn't
796 * have a proc pointer. Oops.
797 */
798 /* true args */
799 struct vnode *vp = ap->a_vp;
800 struct cnode *cp = VTOC(vp);
801 struct ucred *cred __attribute__((unused)) = NULL;
802 struct thread *td __attribute__((unused)) = curthread;
803 /* upcall decl */
804 /* locals */
805
806 /*
807 * We don't need to send inactive to venus - DCS.
808 */
809 MARK_ENTRY(CODA_INACTIVE_STATS);
810 CODADEBUG(CODA_INACTIVE, myprintf(("in inactive, %s, vfsp %p\n",
811 coda_f2s(&cp->c_fid), vp->v_mount)););
812 vp->v_object = NULL;
813
814 /*
815 * If an array has been allocated to hold the symlink, deallocate it.
816 */
817 if ((coda_symlink_cache) && (VALID_SYMLINK(cp))) {
818 if (cp->c_symlink == NULL)
819 panic("coda_inactive: null symlink pointer in cnode");
820 CODA_FREE(cp->c_symlink, cp->c_symlen);
821 cp->c_flags &= ~C_SYMLINK;
822 cp->c_symlen = 0;
823 }
824
825 /*
826 * Remove it from the table so it can't be found.
827 */
828 coda_unsave(cp);
829 if ((struct coda_mntinfo *)(vp->v_mount->mnt_data) == NULL) {
830 myprintf(("Help! vfsp->vfs_data was NULL, but vnode %p "
831 "wasn't dying\n", vp));
832 panic("badness in coda_inactive\n");
833 }
834 if (IS_UNMOUNTING(cp)) {
835 #ifdef DEBUG
836 printf("coda_inactive: IS_UNMOUNTING use %d: vp %p, cp %p\n",
837 vrefcnt(vp), vp, cp);
838 if (cp->c_ovp != NULL)
839 printf("coda_inactive: cp->ovp != NULL use %d: vp "
840 "%p, cp %p\n", vrefcnt(vp), vp, cp);
841 #endif
842 } else
843 vgone(vp);
844 MARK_INT_SAT(CODA_INACTIVE_STATS);
845 return (0);
846 }
847
848 /*
849 * Remote filesystem operations having to do with directory manipulation.
850 */
851
852 /*
853 * In FreeBSD, lookup returns the vnode locked.
854 */
855 int
856 coda_lookup(struct vop_cachedlookup_args *ap)
857 {
858 /* true args */
859 struct vnode *dvp = ap->a_dvp;
860 struct cnode *dcp = VTOC(dvp);
861 struct vnode **vpp = ap->a_vpp;
862 /*
863 * It looks as though ap->a_cnp->ni_cnd->cn_nameptr holds the rest of
864 * the string to xlate, and that we must try to get at least
865 * ap->a_cnp->ni_cnd->cn_namelen of those characters to macth. I
866 * could be wrong.
867 */
868 struct componentname *cnp = ap->a_cnp;
869 struct ucred *cred = cnp->cn_cred;
870 struct thread *td = cnp->cn_thread;
871 /* locals */
872 struct cnode *cp;
873 const char *nm = cnp->cn_nameptr;
874 int len = cnp->cn_namelen;
875 struct CodaFid VFid;
876 int vtype;
877 int error = 0;
878
879 MARK_ENTRY(CODA_LOOKUP_STATS);
880 CODADEBUG(CODA_LOOKUP, myprintf(("lookup: %s in %s\n", nm,
881 coda_f2s(&dcp->c_fid))););
882
883 /*
884 * Check for lookup of control object.
885 */
886 if (IS_CTL_NAME(dvp, nm, len)) {
887 *vpp = coda_ctlvp;
888 vref(*vpp);
889 MARK_INT_SAT(CODA_LOOKUP_STATS);
890 goto exit;
891 }
892 if (len+1 > CODA_MAXNAMLEN) {
893 MARK_INT_FAIL(CODA_LOOKUP_STATS);
894 CODADEBUG(CODA_LOOKUP, myprintf(("name too long: lookup, "
895 "%s (%s)\n", coda_f2s(&dcp->c_fid), nm)););
896 *vpp = NULL;
897 error = EINVAL;
898 goto exit;
899 }
900
901 error = venus_lookup(vtomi(dvp), &dcp->c_fid, nm, len, cred,
902 td->td_proc, &VFid, &vtype);
903 if (error) {
904 MARK_INT_FAIL(CODA_LOOKUP_STATS);
905 CODADEBUG(CODA_LOOKUP, myprintf(("lookup error on %s "
906 "(%s)%d\n", coda_f2s(&dcp->c_fid), nm, error)););
907 *vpp = NULL;
908 } else {
909 MARK_INT_SAT(CODA_LOOKUP_STATS);
910 CODADEBUG(CODA_LOOKUP, myprintf(("lookup: %s type %o "
911 "result %d\n", coda_f2s(&VFid), vtype, error)););
912 cp = make_coda_node(&VFid, dvp->v_mount, vtype);
913 *vpp = CTOV(cp);
914
915 /*
916 * Enter the new vnode in the namecache only if the top bit
917 * isn't set.
918 *
919 * And don't enter a new vnode for an invalid one!
920 */
921 if (!(vtype & CODA_NOCACHE) && (cnp->cn_flags & MAKEENTRY))
922 cache_enter(dvp, *vpp, cnp);
923 }
924 exit:
925 /*
926 * If we are creating, and this was the last name to be looked up,
927 * and the error was ENOENT, then there really shouldn't be an error
928 * and we can make the leaf NULL and return success. Since this is
929 * supposed to work under Mach as well as FreeBSD, we're leaving this
930 * fn wrapped. We also must tell lookup/namei that we need to save
931 * the last component of the name. (Create will have to free the
932 * name buffer later...lucky us...).
933 */
934 if (((cnp->cn_nameiop == CREATE) || (cnp->cn_nameiop == RENAME))
935 && (cnp->cn_flags & ISLASTCN) && (error == ENOENT)) {
936 error = EJUSTRETURN;
937 cnp->cn_flags |= SAVENAME;
938 *ap->a_vpp = NULL;
939 }
940
941 /*
942 * If we are removing, and we are at the last element, and we found
943 * it, then we need to keep the name around so that the removal will
944 * go ahead as planned. Unfortunately, this will probably also lock
945 * the to-be-removed vnode, which may or may not be a good idea.
946 * I'll have to look at the bits of coda_remove to make sure. We'll
947 * only save the name if we did in fact find the name, otherwise
948 * coda_remove won't have a chance to free the pathname.
949 */
950 if ((cnp->cn_nameiop == DELETE) && (cnp->cn_flags & ISLASTCN)
951 && !error)
952 cnp->cn_flags |= SAVENAME;
953
954 /*
955 * If the lookup went well, we need to (potentially?) unlock the
956 * parent, and lock the child. We are only responsible for checking
957 * to see if the parent is supposed to be unlocked before we return.
958 * We must always lock the child (provided there is one, and (the
959 * parent isn't locked or it isn't the same as the parent.) Simple,
960 * huh? We can never leave the parent locked unless we are ISLASTCN.
961 */
962 if (!error || (error == EJUSTRETURN)) {
963 if (cnp->cn_flags & ISDOTDOT) {
964 VOP_UNLOCK(dvp, 0);
965 /*
966 * The parent is unlocked. As long as there is a
967 * child, lock it without bothering to check anything
968 * else.
969 */
970 if (*ap->a_vpp)
971 vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY);
972 vn_lock(dvp, LK_RETRY|LK_EXCLUSIVE);
973 } else {
974 /*
975 * The parent is locked, and may be the same as the
976 * child. If different, go ahead and lock it.
977 */
978 if (*ap->a_vpp && (*ap->a_vpp != dvp))
979 vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY);
980 }
981 } else {
982 /*
983 * If the lookup failed, we need to ensure that the leaf is
984 * NULL.
985 *
986 * Don't change any locking?
987 */
988 *ap->a_vpp = NULL;
989 }
990 return (error);
991 }
992
993 /*ARGSUSED*/
994 int
995 coda_create(struct vop_create_args *ap)
996 {
997 /* true args */
998 struct vnode *dvp = ap->a_dvp;
999 struct cnode *dcp = VTOC(dvp);
1000 struct vattr *va = ap->a_vap;
1001 int exclusive = 1;
1002 int mode = ap->a_vap->va_mode;
1003 struct vnode **vpp = ap->a_vpp;
1004 struct componentname *cnp = ap->a_cnp;
1005 struct ucred *cred = cnp->cn_cred;
1006 struct thread *td = cnp->cn_thread;
1007 /* locals */
1008 int error;
1009 struct cnode *cp;
1010 const char *nm = cnp->cn_nameptr;
1011 int len = cnp->cn_namelen;
1012 struct CodaFid VFid;
1013 struct vattr attr;
1014
1015 MARK_ENTRY(CODA_CREATE_STATS);
1016
1017 /*
1018 * All creates are exclusive XXX.
1019 *
1020 * I'm assuming the 'mode' argument is the file mode bits XXX.
1021 *
1022 * Check for create of control object.
1023 */
1024 if (IS_CTL_NAME(dvp, nm, len)) {
1025 *vpp = (struct vnode *)0;
1026 MARK_INT_FAIL(CODA_CREATE_STATS);
1027 return (EACCES);
1028 }
1029 error = venus_create(vtomi(dvp), &dcp->c_fid, nm, len, exclusive,
1030 mode, va, cred, td->td_proc, &VFid, &attr);
1031 if (!error) {
1032 /*
1033 * If this is an exclusive create, panic if the file already
1034 * exists.
1035 *
1036 * Venus should have detected the file and reported EEXIST.
1037 */
1038 if ((exclusive == 1) && (coda_find(&VFid) != NULL))
1039 panic("cnode existed for newly created file!");
1040 cp = make_coda_node(&VFid, dvp->v_mount, attr.va_type);
1041 *vpp = CTOV(cp);
1042
1043 /*
1044 * Update va to reflect the new attributes.
1045 */
1046 (*va) = attr;
1047
1048 /*
1049 * Update the attribute cache and mark it as valid.
1050 */
1051 if (coda_attr_cache) {
1052 VTOC(*vpp)->c_vattr = attr;
1053 VTOC(*vpp)->c_flags |= C_VATTR;
1054 }
1055
1056 /*
1057 * Invalidate the parent's attr cache, the modification time
1058 * has changed.
1059 */
1060 VTOC(dvp)->c_flags &= ~C_VATTR;
1061 cache_enter(dvp, *vpp, cnp);
1062 CODADEBUG(CODA_CREATE, myprintf(("create: %s, result %d\n",
1063 coda_f2s(&VFid), error)););
1064 } else {
1065 *vpp = (struct vnode *)0;
1066 CODADEBUG(CODA_CREATE, myprintf(("create error %d\n",
1067 error)););
1068 }
1069 if (!error) {
1070 if (cnp->cn_flags & MAKEENTRY)
1071 cache_enter(dvp, *vpp, cnp);
1072 if (cnp->cn_flags & LOCKLEAF)
1073 vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY);
1074 } else if (error == ENOENT) {
1075 /*
1076 * XXXRW: We only enter a negative entry if ENOENT is
1077 * returned, not other errors. But will Venus invalidate dvp
1078 * properly in all cases when new files appear via the
1079 * network rather than a local operation?
1080 */
1081 if (cnp->cn_flags & MAKEENTRY)
1082 cache_enter(dvp, NULL, cnp);
1083 }
1084 return (error);
1085 }
1086
1087 int
1088 coda_remove(struct vop_remove_args *ap)
1089 {
1090 /* true args */
1091 struct vnode *vp = ap->a_vp;
1092 struct vnode *dvp = ap->a_dvp;
1093 struct cnode *cp = VTOC(dvp);
1094 struct componentname *cnp = ap->a_cnp;
1095 struct ucred *cred = cnp->cn_cred;
1096 struct thread *td = cnp->cn_thread;
1097 /* locals */
1098 int error;
1099 const char *nm = cnp->cn_nameptr;
1100 int len = cnp->cn_namelen;
1101 #if 0
1102 struct cnode *tp;
1103 #endif
1104
1105 MARK_ENTRY(CODA_REMOVE_STATS);
1106 CODADEBUG(CODA_REMOVE, myprintf(("remove: %s in %s\n", nm,
1107 coda_f2s(&cp->c_fid))););
1108
1109 /*
1110 * Check for remove of control object.
1111 */
1112 if (IS_CTL_NAME(dvp, nm, len)) {
1113 MARK_INT_FAIL(CODA_REMOVE_STATS);
1114 return (ENOENT);
1115 }
1116
1117 /*
1118 * Invalidate the parent's attr cache, the modification time has
1119 * changed. We don't yet know if the last reference to the file is
1120 * being removed, but we do know the reference count on the child has
1121 * changed, so invalidate its attr cache also.
1122 */
1123 VTOC(dvp)->c_flags &= ~C_VATTR;
1124 VTOC(vp)->c_flags &= ~(C_VATTR | C_ACCCACHE);
1125 error = venus_remove(vtomi(dvp), &cp->c_fid, nm, len, cred,
1126 td->td_proc);
1127 cache_purge(vp);
1128 CODADEBUG(CODA_REMOVE, myprintf(("in remove result %d\n",error)););
1129 return (error);
1130 }
1131
1132 int
1133 coda_link(struct vop_link_args *ap)
1134 {
1135 /* true args */
1136 struct vnode *vp = ap->a_vp;
1137 struct cnode *cp = VTOC(vp);
1138 struct vnode *tdvp = ap->a_tdvp;
1139 struct cnode *tdcp = VTOC(tdvp);
1140 struct componentname *cnp = ap->a_cnp;
1141 struct ucred *cred = cnp->cn_cred;
1142 struct thread *td = cnp->cn_thread;
1143 /* locals */
1144 int error;
1145 const char *nm = cnp->cn_nameptr;
1146 int len = cnp->cn_namelen;
1147
1148 MARK_ENTRY(CODA_LINK_STATS);
1149
1150 if (codadebug & CODADBGMSK(CODA_LINK)) {
1151 myprintf(("nb_link: vp fid: %s\n", coda_f2s(&cp->c_fid)));
1152 myprintf(("nb_link: tdvp fid: %s)\n",
1153 coda_f2s(&tdcp->c_fid)));
1154 }
1155 if (codadebug & CODADBGMSK(CODA_LINK)) {
1156 myprintf(("link: vp fid: %s\n", coda_f2s(&cp->c_fid)));
1157 myprintf(("link: tdvp fid: %s\n", coda_f2s(&tdcp->c_fid)));
1158 }
1159
1160 /*
1161 * Check for link to/from control object.
1162 */
1163 if (IS_CTL_NAME(tdvp, nm, len) || IS_CTL_VP(vp)) {
1164 MARK_INT_FAIL(CODA_LINK_STATS);
1165 return (EACCES);
1166 }
1167 error = venus_link(vtomi(vp), &cp->c_fid, &tdcp->c_fid, nm, len,
1168 cred, td->td_proc);
1169
1170 /*
1171 * Invalidate the parent's attr cache, the modification time has
1172 * changed.
1173 */
1174 VTOC(tdvp)->c_flags &= ~C_VATTR;
1175 VTOC(vp)->c_flags &= ~C_VATTR;
1176 CODADEBUG(CODA_LINK, myprintf(("in link result %d\n",error)););
1177 return (error);
1178 }
1179
1180 int
1181 coda_rename(struct vop_rename_args *ap)
1182 {
1183 /* true args */
1184 struct vnode *fvp = ap->a_fvp;
1185 struct vnode *tvp = ap->a_tvp;
1186 struct vnode *odvp = ap->a_fdvp;
1187 struct cnode *odcp = VTOC(odvp);
1188 struct componentname *fcnp = ap->a_fcnp;
1189 struct vnode *ndvp = ap->a_tdvp;
1190 struct cnode *ndcp = VTOC(ndvp);
1191 struct componentname *tcnp = ap->a_tcnp;
1192 struct ucred *cred = fcnp->cn_cred;
1193 struct thread *td = fcnp->cn_thread;
1194 /* true args */
1195 int error;
1196 const char *fnm = fcnp->cn_nameptr;
1197 int flen = fcnp->cn_namelen;
1198 const char *tnm = tcnp->cn_nameptr;
1199 int tlen = tcnp->cn_namelen;
1200
1201 MARK_ENTRY(CODA_RENAME_STATS);
1202
1203 /*
1204 * Check for rename involving control object.
1205 */
1206 if (IS_CTL_NAME(odvp, fnm, flen) || IS_CTL_NAME(ndvp, tnm, tlen)) {
1207 MARK_INT_FAIL(CODA_RENAME_STATS);
1208 return (EACCES);
1209 }
1210
1211 /*
1212 * Remove the entries for both source and target directories, which
1213 * should catch references to the children. Perhaps we could purge
1214 * less?
1215 */
1216 cache_purge(odvp);
1217 cache_purge(ndvp);
1218
1219 /*
1220 * Invalidate parent directories as modification times have changed.
1221 * Invalidate access cache on renamed file as rights may have
1222 * changed.
1223 */
1224 VTOC(odvp)->c_flags &= ~C_VATTR;
1225 VTOC(ndvp)->c_flags &= ~C_VATTR;
1226 VTOC(fvp)->c_flags &= ~C_ACCCACHE;
1227 if (flen+1 > CODA_MAXNAMLEN) {
1228 MARK_INT_FAIL(CODA_RENAME_STATS);
1229 error = EINVAL;
1230 goto exit;
1231 }
1232 if (tlen+1 > CODA_MAXNAMLEN) {
1233 MARK_INT_FAIL(CODA_RENAME_STATS);
1234 error = EINVAL;
1235 goto exit;
1236 }
1237 error = venus_rename(vtomi(odvp), &odcp->c_fid, &ndcp->c_fid, fnm,
1238 flen, tnm, tlen, cred, td->td_proc);
1239 exit:
1240 CODADEBUG(CODA_RENAME, myprintf(("in rename result %d\n",error)););
1241
1242 /*
1243 * Update namecache to reflect that the names of various objects may
1244 * have changed (or gone away entirely).
1245 */
1246 cache_purge(fvp);
1247 cache_purge(tvp);
1248
1249 /*
1250 * Release parents first, then children.
1251 */
1252 vrele(odvp);
1253 if (tvp) {
1254 if (tvp == ndvp)
1255 vrele(ndvp);
1256 else
1257 vput(ndvp);
1258 vput(tvp);
1259 } else
1260 vput(ndvp);
1261 vrele(fvp);
1262 return (error);
1263 }
1264
1265 int
1266 coda_mkdir(struct vop_mkdir_args *ap)
1267 {
1268 /* true args */
1269 struct vnode *dvp = ap->a_dvp;
1270 struct cnode *dcp = VTOC(dvp);
1271 struct componentname *cnp = ap->a_cnp;
1272 struct vattr *va = ap->a_vap;
1273 struct vnode **vpp = ap->a_vpp;
1274 struct ucred *cred = cnp->cn_cred;
1275 struct thread *td = cnp->cn_thread;
1276 /* locals */
1277 int error;
1278 const char *nm = cnp->cn_nameptr;
1279 int len = cnp->cn_namelen;
1280 struct cnode *cp;
1281 struct CodaFid VFid;
1282 struct vattr ova;
1283
1284 MARK_ENTRY(CODA_MKDIR_STATS);
1285
1286 /*
1287 * Check for mkdir of target object.
1288 */
1289 if (IS_CTL_NAME(dvp, nm, len)) {
1290 *vpp = (struct vnode *)0;
1291 MARK_INT_FAIL(CODA_MKDIR_STATS);
1292 return (EACCES);
1293 }
1294 if (len+1 > CODA_MAXNAMLEN) {
1295 *vpp = (struct vnode *)0;
1296 MARK_INT_FAIL(CODA_MKDIR_STATS);
1297 return (EACCES);
1298 }
1299 error = venus_mkdir(vtomi(dvp), &dcp->c_fid, nm, len, va, cred,
1300 td->td_proc, &VFid, &ova);
1301 if (!error) {
1302 if (coda_find(&VFid) != NULL)
1303 panic("cnode existed for newly created directory!");
1304 cp = make_coda_node(&VFid, dvp->v_mount, va->va_type);
1305 *vpp = CTOV(cp);
1306
1307 /*
1308 * Enter the new vnode in the Name Cache.
1309 */
1310 if (cnp->cn_flags & MAKEENTRY)
1311 cache_enter(dvp, *vpp, cnp);
1312
1313 /*
1314 * Update the attr cache and mark as valid.
1315 */
1316 if (coda_attr_cache) {
1317 VTOC(*vpp)->c_vattr = ova;
1318 VTOC(*vpp)->c_flags |= C_VATTR;
1319 }
1320
1321 /*
1322 * Invalidate the parent's attr cache, the modification time
1323 * has changed.
1324 */
1325 VTOC(dvp)->c_flags &= ~C_VATTR;
1326 vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY);
1327 CODADEBUG( CODA_MKDIR, myprintf(("mkdir: %s result %d\n",
1328 coda_f2s(&VFid), error)););
1329 } else {
1330 *vpp = NULL;
1331 CODADEBUG(CODA_MKDIR, myprintf(("mkdir error %d\n",error)););
1332 }
1333 return (error);
1334 }
1335
1336 int
1337 coda_rmdir(struct vop_rmdir_args *ap)
1338 {
1339 /* true args */
1340 struct vnode *vp = ap->a_vp;
1341 struct vnode *dvp = ap->a_dvp;
1342 struct cnode *dcp = VTOC(dvp);
1343 struct componentname *cnp = ap->a_cnp;
1344 struct ucred *cred = cnp->cn_cred;
1345 struct thread *td = cnp->cn_thread;
1346 /* true args */
1347 int error;
1348 const char *nm = cnp->cn_nameptr;
1349 int len = cnp->cn_namelen;
1350 #if 0
1351 struct cnode *cp;
1352 #endif
1353
1354 MARK_ENTRY(CODA_RMDIR_STATS);
1355
1356 /*
1357 * Check for rmdir of control object.
1358 */
1359 if (IS_CTL_NAME(dvp, nm, len)) {
1360 MARK_INT_FAIL(CODA_RMDIR_STATS);
1361 return (ENOENT);
1362 }
1363
1364 /*
1365 * Possibly somewhat conservative purging, perhaps we just need to
1366 * purge vp?
1367 */
1368 cache_purge(dvp);
1369 cache_purge(vp);
1370
1371 /*
1372 * Invalidate the parent's attr cache, the modification time has
1373 * changed.
1374 */
1375 dcp->c_flags &= ~C_VATTR;
1376 error = venus_rmdir(vtomi(dvp), &dcp->c_fid, nm, len, cred,
1377 td->td_proc);
1378 CODADEBUG(CODA_RMDIR, myprintf(("in rmdir result %d\n", error)););
1379 return (error);
1380 }
1381
1382 int
1383 coda_symlink(struct vop_symlink_args *ap)
1384 {
1385 /* true args */
1386 struct vnode *tdvp = ap->a_dvp;
1387 struct cnode *tdcp = VTOC(tdvp);
1388 struct componentname *cnp = ap->a_cnp;
1389 struct vattr *tva = ap->a_vap;
1390 char *path = ap->a_target;
1391 struct ucred *cred = cnp->cn_cred;
1392 struct thread *td = cnp->cn_thread;
1393 struct vnode **vpp = ap->a_vpp;
1394 /* locals */
1395 int error;
1396
1397 /*-
1398 * XXX I'm assuming the following things about coda_symlink's
1399 * arguments:
1400 * t(foo) is the new name/parent/etc being created.
1401 * lname is the contents of the new symlink.
1402 */
1403 char *nm = cnp->cn_nameptr;
1404 int len = cnp->cn_namelen;
1405 int plen = strlen(path);
1406
1407 /*
1408 * Here's the strategy for the moment: perform the symlink, then do a
1409 * lookup to grab the resulting vnode. I know this requires two
1410 * communications with Venus for a new sybolic link, but that's the
1411 * way the ball bounces. I don't yet want to change the way the Mach
1412 * symlink works. When Mach support is deprecated, we should change
1413 * symlink so that the common case returns the resultant vnode in a
1414 * vpp argument.
1415 */
1416 MARK_ENTRY(CODA_SYMLINK_STATS);
1417
1418 /*
1419 * Check for symlink of control object.
1420 */
1421 if (IS_CTL_NAME(tdvp, nm, len)) {
1422 MARK_INT_FAIL(CODA_SYMLINK_STATS);
1423 return (EACCES);
1424 }
1425 if (plen+1 > CODA_MAXPATHLEN) {
1426 MARK_INT_FAIL(CODA_SYMLINK_STATS);
1427 return (EINVAL);
1428 }
1429 if (len+1 > CODA_MAXNAMLEN) {
1430 MARK_INT_FAIL(CODA_SYMLINK_STATS);
1431 error = EINVAL;
1432 goto exit;
1433 }
1434 error = venus_symlink(vtomi(tdvp), &tdcp->c_fid, path, plen, nm, len,
1435 tva, cred, td->td_proc);
1436
1437 /*
1438 * Invalidate the parent's attr cache, the modification time has
1439 * changed.
1440 */
1441 tdcp->c_flags &= ~C_VATTR;
1442 if (error == 0)
1443 error = VOP_LOOKUP(tdvp, vpp, cnp);
1444 exit:
1445 CODADEBUG(CODA_SYMLINK, myprintf(("in symlink result %d\n",error)););
1446 return (error);
1447 }
1448
1449 /*
1450 * Read directory entries.
1451 *
1452 * XXX: This forwards the operator straight to the cache vnode using
1453 * VOP_READDIR(), rather than calling venus_readdir(). Why?
1454 */
1455 int
1456 coda_readdir(struct vop_readdir_args *ap)
1457 {
1458 /* true args */
1459 struct vnode *vp = ap->a_vp;
1460 struct cnode *cp = VTOC(vp);
1461 struct uio *uiop = ap->a_uio;
1462 struct ucred *cred = ap->a_cred;
1463 int *eofflag = ap->a_eofflag;
1464 u_long **cookies = ap->a_cookies;
1465 int *ncookies = ap->a_ncookies;
1466 struct thread *td = ap->a_uio->uio_td;
1467 /* upcall decl */
1468 /* locals */
1469 int error = 0;
1470 int opened_internally = 0;
1471
1472 MARK_ENTRY(CODA_READDIR_STATS);
1473 CODADEBUG(CODA_READDIR, myprintf(("coda_readdir(%p, %zd, %lld, %d)\n",
1474 (void *)uiop->uio_iov->iov_base, uiop->uio_resid,
1475 (long long)uiop->uio_offset, uiop->uio_segflg)););
1476
1477 /*
1478 * Check for readdir of control object.
1479 */
1480 if (IS_CTL_VP(vp)) {
1481 MARK_INT_FAIL(CODA_READDIR_STATS);
1482 return (ENOENT);
1483 }
1484
1485 /*
1486 * If directory is not already open do an "internal open" on it.
1487 *
1488 * XXX: Why would this happen? For files, there's memory mapping,
1489 * execution, and other kernel access paths such as ktrace. For
1490 * directories, it is less clear.
1491 */
1492 if (cp->c_ovp == NULL) {
1493 opened_internally = 1;
1494 MARK_INT_GEN(CODA_OPEN_STATS);
1495 error = VOP_OPEN(vp, FREAD, cred, td, NULL);
1496 printf("coda_readdir: Internally Opening %p\n", vp);
1497 if (error) {
1498 printf("coda_readdir: VOP_OPEN on container failed "
1499 "%d\n", error);
1500 return (error);
1501 }
1502 }
1503
1504 /*
1505 * Have UFS handle the call.
1506 */
1507 CODADEBUG(CODA_READDIR, myprintf(("indirect readdir: fid = %s, "
1508 "refcnt = %d\n", coda_f2s(&cp->c_fid), vp->v_usecount)););
1509 vn_lock(cp->c_ovp, LK_SHARED | LK_RETRY);
1510 error = VOP_READDIR(cp->c_ovp, uiop, cred, eofflag, ncookies,
1511 cookies);
1512 VOP_UNLOCK(cp->c_ovp, 0);
1513 if (error)
1514 MARK_INT_FAIL(CODA_READDIR_STATS);
1515 else
1516 MARK_INT_SAT(CODA_READDIR_STATS);
1517
1518 /*
1519 * Do an "internal close" if necessary.
1520 */
1521 if (opened_internally) {
1522 MARK_INT_GEN(CODA_CLOSE_STATS);
1523 (void)VOP_CLOSE(vp, FREAD, cred, td);
1524 }
1525 return (error);
1526 }
1527
1528 int
1529 coda_reclaim(struct vop_reclaim_args *ap)
1530 {
1531 /* true args */
1532 struct vnode *vp = ap->a_vp;
1533 struct cnode *cp = VTOC(vp);
1534 /* upcall decl */
1535 /* locals */
1536
1537 /*
1538 * Forced unmount/flush will let vnodes with non-zero use be
1539 * destroyed!
1540 */
1541 ENTRY;
1542
1543 if (IS_UNMOUNTING(cp)) {
1544 #ifdef DEBUG
1545 if (VTOC(vp)->c_ovp) {
1546 if (IS_UNMOUNTING(cp))
1547 printf("coda_reclaim: c_ovp not void: vp "
1548 "%p, cp %p\n", vp, cp);
1549 }
1550 #endif
1551 }
1552 cache_purge(vp);
1553 coda_free(VTOC(vp));
1554 vp->v_data = NULL;
1555 vp->v_object = NULL;
1556 return (0);
1557 }
1558
1559 int
1560 coda_lock(struct vop_lock1_args *ap)
1561 {
1562 /* true args */
1563 struct vnode *vp = ap->a_vp;
1564 struct cnode *cp = VTOC(vp);
1565 /* upcall decl */
1566 /* locals */
1567
1568 ENTRY;
1569 if ((ap->a_flags & LK_INTERLOCK) == 0) {
1570 VI_LOCK(vp);
1571 ap->a_flags |= LK_INTERLOCK;
1572 }
1573 if (coda_lockdebug)
1574 myprintf(("Attempting lock on %s\n", coda_f2s(&cp->c_fid)));
1575 return (vop_stdlock(ap));
1576 }
1577
1578 int
1579 coda_unlock(struct vop_unlock_args *ap)
1580 {
1581 /* true args */
1582 struct vnode *vp = ap->a_vp;
1583 struct cnode *cp = VTOC(vp);
1584 /* upcall decl */
1585 /* locals */
1586
1587 ENTRY;
1588 if (coda_lockdebug)
1589 myprintf(("Attempting unlock on %s\n",
1590 coda_f2s(&cp->c_fid)));
1591 return (vop_stdunlock(ap));
1592 }
1593
1594 int
1595 coda_islocked(struct vop_islocked_args *ap)
1596 {
1597 /* true args */
1598
1599 ENTRY;
1600 return (vop_stdislocked(ap));
1601 }
1602
1603 static void
1604 coda_print_vattr(struct vattr *attr)
1605 {
1606 char *typestr;
1607
1608 switch (attr->va_type) {
1609 case VNON:
1610 typestr = "VNON";
1611 break;
1612
1613 case VREG:
1614 typestr = "VREG";
1615 break;
1616
1617 case VDIR:
1618 typestr = "VDIR";
1619 break;
1620
1621 case VBLK:
1622 typestr = "VBLK";
1623 break;
1624
1625 case VCHR:
1626 typestr = "VCHR";
1627 break;
1628
1629 case VLNK:
1630 typestr = "VLNK";
1631 break;
1632
1633 case VSOCK:
1634 typestr = "VSCK";
1635 break;
1636
1637 case VFIFO:
1638 typestr = "VFFO";
1639 break;
1640
1641 case VBAD:
1642 typestr = "VBAD";
1643 break;
1644
1645 default:
1646 typestr = "????";
1647 break;
1648 }
1649 myprintf(("attr: type %s mode %d uid %d gid %d fsid %d rdev %d\n",
1650 typestr, (int)attr->va_mode, (int)attr->va_uid,
1651 (int)attr->va_gid, (int)attr->va_fsid, (int)attr->va_rdev));
1652 myprintf((" fileid %d nlink %d size %d blocksize %d bytes %d\n",
1653 (int)attr->va_fileid, (int)attr->va_nlink, (int)attr->va_size,
1654 (int)attr->va_blocksize,(int)attr->va_bytes));
1655 myprintf((" gen %ld flags %ld vaflags %d\n", attr->va_gen,
1656 attr->va_flags, attr->va_vaflags));
1657 myprintf((" atime sec %d nsec %d\n", (int)attr->va_atime.tv_sec,
1658 (int)attr->va_atime.tv_nsec));
1659 myprintf((" mtime sec %d nsec %d\n", (int)attr->va_mtime.tv_sec,
1660 (int)attr->va_mtime.tv_nsec));
1661 myprintf((" ctime sec %d nsec %d\n", (int)attr->va_ctime.tv_sec,
1662 (int)attr->va_ctime.tv_nsec));
1663 }
1664
1665 /*
1666 * How to print a ucred.
1667 */
1668 void
1669 coda_print_cred(struct ucred *cred)
1670 {
1671 int i;
1672
1673 myprintf(("ref %d\tuid %d\n",cred->cr_ref,cred->cr_uid));
1674 for (i=0; i < cred->cr_ngroups; i++)
1675 myprintf(("\tgroup %d: (%d)\n",i,cred->cr_groups[i]));
1676 myprintf(("\n"));
1677 }
1678
1679 /*
1680 * Return a vnode for the given fid. If no cnode exists for this fid create
1681 * one and put it in a table hashed by coda_f2i(). If the cnode for this fid
1682 * is already in the table return it (ref count is incremented by coda_find.
1683 * The cnode will be flushed from the table when coda_inactive calls
1684 * coda_unsave.
1685 */
1686 struct cnode *
1687 make_coda_node(struct CodaFid *fid, struct mount *vfsp, short type)
1688 {
1689 struct cnode *cp;
1690 struct vnode *vp;
1691 int err;
1692
1693 /*
1694 * XXXRW: This really needs a moderate amount of reworking. We need
1695 * to properly tolerate failures of getnewvnode() and insmntque(),
1696 * and callers need to be able to accept an error back from
1697 * make_coda_node. There may also be more general issues in how we
1698 * handle forced unmount. Finally, if/when Coda loses its dependency
1699 * on Giant, the ordering of this needs rethinking.
1700 */
1701 cp = coda_find(fid);
1702 if (cp != NULL) {
1703 vref(CTOV(cp));
1704 return (cp);
1705 }
1706 cp = coda_alloc();
1707 cp->c_fid = *fid;
1708 err = getnewvnode("coda", vfsp, &coda_vnodeops, &vp);
1709 if (err)
1710 panic("coda: getnewvnode returned error %d\n", err);
1711 vp->v_data = cp;
1712 vp->v_type = type;
1713 cp->c_vnode = vp;
1714 coda_save(cp);
1715 err = insmntque(vp, vfsp);
1716 if (err != 0)
1717 printf("coda: insmntque failed: error %d", err);
1718 return (cp);
1719 }
1720
1721 int
1722 coda_pathconf(struct vop_pathconf_args *ap)
1723 {
1724
1725 switch (ap->a_name) {
1726 case _PC_NAME_MAX:
1727 *ap->a_retval = CODA_MAXNAMLEN;
1728 return (0);
1729
1730 case _PC_PATH_MAX:
1731 *ap->a_retval = CODA_MAXPATHLEN;
1732 return (0);
1733
1734 default:
1735 return (vop_stdpathconf(ap));
1736 }
1737 }
Cache object: 941dfdf07486e2723e677e51ad842d08
|