coda_vnops.c revision 1.68.12.4 1 1.68.12.4 yamt /* $NetBSD: coda_vnops.c,v 1.68.12.4 2010/08/11 22:53:01 yamt Exp $ */
2 1.1 rvb
3 1.2 rvb /*
4 1.40 perry *
5 1.2 rvb * Coda: an Experimental Distributed File System
6 1.2 rvb * Release 3.1
7 1.40 perry *
8 1.2 rvb * Copyright (c) 1987-1998 Carnegie Mellon University
9 1.2 rvb * All Rights Reserved
10 1.40 perry *
11 1.2 rvb * Permission to use, copy, modify and distribute this software and its
12 1.2 rvb * documentation is hereby granted, provided that both the copyright
13 1.2 rvb * notice and this permission notice appear in all copies of the
14 1.2 rvb * software, derivative works or modified versions, and any portions
15 1.2 rvb * thereof, and that both notices appear in supporting documentation, and
16 1.2 rvb * that credit is given to Carnegie Mellon University in all documents
17 1.2 rvb * and publicity pertaining to direct or indirect use of this code or its
18 1.2 rvb * derivatives.
19 1.40 perry *
20 1.2 rvb * CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS KNOWN TO HAVE BUGS,
21 1.2 rvb * SOME OF WHICH MAY HAVE SERIOUS CONSEQUENCES. CARNEGIE MELLON ALLOWS
22 1.2 rvb * FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION. CARNEGIE MELLON
23 1.2 rvb * DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER
24 1.2 rvb * RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE OR OF
25 1.2 rvb * ANY DERIVATIVE WORK.
26 1.40 perry *
27 1.2 rvb * Carnegie Mellon encourages users of this software to return any
28 1.2 rvb * improvements or extensions that they make, and to grant Carnegie
29 1.2 rvb * Mellon the rights to redistribute these changes without encumbrance.
30 1.40 perry *
31 1.40 perry * @(#) coda/coda_vnops.c,v 1.1.1.1 1998/08/29 21:26:46 rvb Exp $
32 1.2 rvb */
33 1.1 rvb
34 1.40 perry /*
35 1.1 rvb * Mach Operating System
36 1.1 rvb * Copyright (c) 1990 Carnegie-Mellon University
37 1.1 rvb * Copyright (c) 1989 Carnegie-Mellon University
38 1.1 rvb * All rights reserved. The CMU software License Agreement specifies
39 1.1 rvb * the terms and conditions for use and redistribution.
40 1.1 rvb */
41 1.1 rvb
42 1.1 rvb /*
43 1.1 rvb * This code was written for the Coda file system at Carnegie Mellon
44 1.1 rvb * University. Contributers include David Steere, James Kistler, and
45 1.40 perry * M. Satyanarayanan.
46 1.1 rvb */
47 1.27 lukem
48 1.27 lukem #include <sys/cdefs.h>
49 1.68.12.4 yamt __KERNEL_RCSID(0, "$NetBSD: coda_vnops.c,v 1.68.12.4 2010/08/11 22:53:01 yamt Exp $");
50 1.1 rvb
51 1.1 rvb #include <sys/param.h>
52 1.1 rvb #include <sys/systm.h>
53 1.1 rvb #include <sys/malloc.h>
54 1.1 rvb #include <sys/errno.h>
55 1.1 rvb #include <sys/acct.h>
56 1.1 rvb #include <sys/file.h>
57 1.1 rvb #include <sys/uio.h>
58 1.1 rvb #include <sys/namei.h>
59 1.1 rvb #include <sys/ioctl.h>
60 1.1 rvb #include <sys/mount.h>
61 1.1 rvb #include <sys/proc.h>
62 1.1 rvb #include <sys/select.h>
63 1.61 dogcow #include <sys/vnode.h>
64 1.49 elad #include <sys/kauth.h>
65 1.49 elad
66 1.1 rvb #include <miscfs/genfs/genfs.h>
67 1.1 rvb
68 1.4 rvb #include <coda/coda.h>
69 1.4 rvb #include <coda/cnode.h>
70 1.4 rvb #include <coda/coda_vnops.h>
71 1.4 rvb #include <coda/coda_venus.h>
72 1.4 rvb #include <coda/coda_opstats.h>
73 1.4 rvb #include <coda/coda_subr.h>
74 1.4 rvb #include <coda/coda_namecache.h>
75 1.4 rvb #include <coda/coda_pioctl.h>
76 1.1 rvb
77 1.40 perry /*
78 1.1 rvb * These flags select various performance enhancements.
79 1.1 rvb */
80 1.3 rvb int coda_attr_cache = 1; /* Set to cache attributes in the kernel */
81 1.3 rvb int coda_symlink_cache = 1; /* Set to cache symbolic link information */
82 1.3 rvb int coda_access_cache = 1; /* Set to handle some access checks directly */
83 1.1 rvb
84 1.1 rvb /* structure to keep track of vfs calls */
85 1.1 rvb
86 1.3 rvb struct coda_op_stats coda_vnodeopstats[CODA_VNODEOPS_SIZE];
87 1.1 rvb
88 1.3 rvb #define MARK_ENTRY(op) (coda_vnodeopstats[op].entries++)
89 1.3 rvb #define MARK_INT_SAT(op) (coda_vnodeopstats[op].sat_intrn++)
90 1.3 rvb #define MARK_INT_FAIL(op) (coda_vnodeopstats[op].unsat_intrn++)
91 1.3 rvb #define MARK_INT_GEN(op) (coda_vnodeopstats[op].gen_intrn++)
92 1.1 rvb
93 1.1 rvb /* What we are delaying for in printf */
94 1.3 rvb int coda_printf_delay = 0; /* in microseconds */
95 1.3 rvb int coda_vnop_print_entry = 0;
96 1.3 rvb static int coda_lockdebug = 0;
97 1.1 rvb
98 1.28 perry #define ENTRY if(coda_vnop_print_entry) myprintf(("Entered %s\n",__func__))
99 1.1 rvb
100 1.1 rvb /* Definition of the vnode operation vector */
101 1.1 rvb
102 1.23 jdolecek const struct vnodeopv_entry_desc coda_vnodeop_entries[] = {
103 1.3 rvb { &vop_default_desc, coda_vop_error },
104 1.3 rvb { &vop_lookup_desc, coda_lookup }, /* lookup */
105 1.3 rvb { &vop_create_desc, coda_create }, /* create */
106 1.5 rvb { &vop_mknod_desc, coda_vop_error }, /* mknod */
107 1.3 rvb { &vop_open_desc, coda_open }, /* open */
108 1.3 rvb { &vop_close_desc, coda_close }, /* close */
109 1.3 rvb { &vop_access_desc, coda_access }, /* access */
110 1.5 rvb { &vop_getattr_desc, coda_getattr }, /* getattr */
111 1.5 rvb { &vop_setattr_desc, coda_setattr }, /* setattr */
112 1.3 rvb { &vop_read_desc, coda_read }, /* read */
113 1.3 rvb { &vop_write_desc, coda_write }, /* write */
114 1.11 wrstuden { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */
115 1.3 rvb { &vop_ioctl_desc, coda_ioctl }, /* ioctl */
116 1.24 chs { &vop_mmap_desc, genfs_mmap }, /* mmap */
117 1.3 rvb { &vop_fsync_desc, coda_fsync }, /* fsync */
118 1.3 rvb { &vop_remove_desc, coda_remove }, /* remove */
119 1.3 rvb { &vop_link_desc, coda_link }, /* link */
120 1.3 rvb { &vop_rename_desc, coda_rename }, /* rename */
121 1.3 rvb { &vop_mkdir_desc, coda_mkdir }, /* mkdir */
122 1.3 rvb { &vop_rmdir_desc, coda_rmdir }, /* rmdir */
123 1.5 rvb { &vop_symlink_desc, coda_symlink }, /* symlink */
124 1.5 rvb { &vop_readdir_desc, coda_readdir }, /* readdir */
125 1.3 rvb { &vop_readlink_desc, coda_readlink }, /* readlink */
126 1.5 rvb { &vop_abortop_desc, coda_abortop }, /* abortop */
127 1.3 rvb { &vop_inactive_desc, coda_inactive }, /* inactive */
128 1.5 rvb { &vop_reclaim_desc, coda_reclaim }, /* reclaim */
129 1.3 rvb { &vop_lock_desc, coda_lock }, /* lock */
130 1.3 rvb { &vop_unlock_desc, coda_unlock }, /* unlock */
131 1.3 rvb { &vop_bmap_desc, coda_bmap }, /* bmap */
132 1.3 rvb { &vop_strategy_desc, coda_strategy }, /* strategy */
133 1.5 rvb { &vop_print_desc, coda_vop_error }, /* print */
134 1.3 rvb { &vop_islocked_desc, coda_islocked }, /* islocked */
135 1.3 rvb { &vop_pathconf_desc, coda_vop_error }, /* pathconf */
136 1.5 rvb { &vop_advlock_desc, coda_vop_nop }, /* advlock */
137 1.3 rvb { &vop_bwrite_desc, coda_vop_error }, /* bwrite */
138 1.1 rvb { &vop_seek_desc, genfs_seek }, /* seek */
139 1.5 rvb { &vop_poll_desc, genfs_poll }, /* poll */
140 1.25 chs { &vop_getpages_desc, coda_getpages }, /* getpages */
141 1.25 chs { &vop_putpages_desc, coda_putpages }, /* putpages */
142 1.24 chs { NULL, NULL }
143 1.1 rvb };
144 1.1 rvb
145 1.40 perry const struct vnodeopv_desc coda_vnodeop_opv_desc =
146 1.3 rvb { &coda_vnodeop_p, coda_vnodeop_entries };
147 1.1 rvb
148 1.1 rvb /* Definitions of NetBSD vnodeop interfaces */
149 1.1 rvb
150 1.54 gdt /*
151 1.54 gdt * A generic error routine. Return EIO without looking at arguments.
152 1.54 gdt */
153 1.1 rvb int
154 1.3 rvb coda_vop_error(void *anon) {
155 1.1 rvb struct vnodeop_desc **desc = (struct vnodeop_desc **)anon;
156 1.1 rvb
157 1.54 gdt if (codadebug) {
158 1.54 gdt myprintf(("coda_vop_error: Vnode operation %s called (error).\n",
159 1.54 gdt (*desc)->vdesc_name));
160 1.54 gdt }
161 1.54 gdt
162 1.9 rvb return EIO;
163 1.1 rvb }
164 1.1 rvb
165 1.67 ad /* A generic do-nothing. */
166 1.1 rvb int
167 1.3 rvb coda_vop_nop(void *anon) {
168 1.1 rvb struct vnodeop_desc **desc = (struct vnodeop_desc **)anon;
169 1.1 rvb
170 1.3 rvb if (codadebug) {
171 1.1 rvb myprintf(("Vnode operation %s called, but unsupported\n",
172 1.1 rvb (*desc)->vdesc_name));
173 1.40 perry }
174 1.1 rvb return (0);
175 1.1 rvb }
176 1.1 rvb
177 1.1 rvb int
178 1.3 rvb coda_vnodeopstats_init(void)
179 1.1 rvb {
180 1.17 augustss int i;
181 1.40 perry
182 1.3 rvb for(i=0;i<CODA_VNODEOPS_SIZE;i++) {
183 1.3 rvb coda_vnodeopstats[i].opcode = i;
184 1.3 rvb coda_vnodeopstats[i].entries = 0;
185 1.3 rvb coda_vnodeopstats[i].sat_intrn = 0;
186 1.3 rvb coda_vnodeopstats[i].unsat_intrn = 0;
187 1.3 rvb coda_vnodeopstats[i].gen_intrn = 0;
188 1.1 rvb }
189 1.40 perry
190 1.1 rvb return 0;
191 1.1 rvb }
192 1.40 perry
193 1.40 perry /*
194 1.58 gdt * XXX The entire relationship between VOP_OPEN and having a container
195 1.58 gdt * file (via venus_open) needs to be reexamined. In particular, it's
196 1.58 gdt * valid to open/mmap/close and then reference. Instead of doing
197 1.58 gdt * VOP_OPEN when getpages needs a container, we should do the
198 1.58 gdt * venus_open part, and record that the vnode has opened the container
199 1.58 gdt * for getpages, and do the matching logical close on coda_inactive.
200 1.58 gdt * Further, coda_rdwr needs a container file, and sometimes needs to
201 1.58 gdt * do the equivalent of open (core dumps).
202 1.58 gdt */
203 1.58 gdt /*
204 1.55 gdt * coda_open calls Venus to return the device and inode of the
205 1.55 gdt * container file, and then obtains a vnode for that file. The
206 1.55 gdt * container vnode is stored in the coda vnode, and a reference is
207 1.55 gdt * added for each open file.
208 1.1 rvb */
209 1.1 rvb int
210 1.43 xtraeme coda_open(void *v)
211 1.1 rvb {
212 1.40 perry /*
213 1.1 rvb * NetBSD can pass the O_EXCL flag in mode, even though the check
214 1.1 rvb * has already happened. Venus defensively assumes that if open
215 1.1 rvb * is passed the EXCL, it must be a bug. We strip the flag here.
216 1.1 rvb */
217 1.1 rvb /* true args */
218 1.1 rvb struct vop_open_args *ap = v;
219 1.55 gdt struct vnode *vp = ap->a_vp;
220 1.55 gdt struct cnode *cp = VTOC(vp);
221 1.1 rvb int flag = ap->a_mode & (~O_EXCL);
222 1.49 elad kauth_cred_t cred = ap->a_cred;
223 1.1 rvb /* locals */
224 1.1 rvb int error;
225 1.55 gdt dev_t dev; /* container file device, inode, vnode */
226 1.1 rvb ino_t inode;
227 1.55 gdt struct vnode *container_vp;
228 1.1 rvb
229 1.3 rvb MARK_ENTRY(CODA_OPEN_STATS);
230 1.1 rvb
231 1.1 rvb /* Check for open of control file. */
232 1.55 gdt if (IS_CTL_VP(vp)) {
233 1.40 perry /* if (WRITABLE(flag)) */
234 1.1 rvb if (flag & (FWRITE | O_TRUNC | O_CREAT | O_EXCL)) {
235 1.3 rvb MARK_INT_FAIL(CODA_OPEN_STATS);
236 1.1 rvb return(EACCES);
237 1.1 rvb }
238 1.3 rvb MARK_INT_SAT(CODA_OPEN_STATS);
239 1.1 rvb return(0);
240 1.1 rvb }
241 1.1 rvb
242 1.63 pooka error = venus_open(vtomi(vp), &cp->c_fid, flag, cred, curlwp, &dev, &inode);
243 1.1 rvb if (error)
244 1.1 rvb return (error);
245 1.1 rvb if (!error) {
246 1.68.12.1 yamt CODADEBUG(CODA_OPEN,
247 1.68.12.1 yamt myprintf(("open: dev 0x%llx inode %llu result %d\n",
248 1.68.12.1 yamt (unsigned long long)dev, (unsigned long long)inode, error));)
249 1.1 rvb }
250 1.1 rvb
251 1.55 gdt /*
252 1.55 gdt * Obtain locked and referenced container vnode from container
253 1.58 gdt * device/inode.
254 1.55 gdt */
255 1.55 gdt error = coda_grab_vnode(dev, inode, &container_vp);
256 1.1 rvb if (error)
257 1.1 rvb return (error);
258 1.1 rvb
259 1.55 gdt /* Save the vnode pointer for the container file. */
260 1.1 rvb if (cp->c_ovp == NULL) {
261 1.55 gdt cp->c_ovp = container_vp;
262 1.1 rvb } else {
263 1.55 gdt if (cp->c_ovp != container_vp)
264 1.55 gdt /*
265 1.55 gdt * Perhaps venus returned a different container, or
266 1.55 gdt * something else went wrong.
267 1.55 gdt */
268 1.55 gdt panic("coda_open: cp->c_ovp != container_vp");
269 1.1 rvb }
270 1.1 rvb cp->c_ocount++;
271 1.1 rvb
272 1.55 gdt /* Flush the attribute cache if writing the file. */
273 1.1 rvb if (flag & FWRITE) {
274 1.1 rvb cp->c_owrite++;
275 1.1 rvb cp->c_flags &= ~C_VATTR;
276 1.1 rvb }
277 1.1 rvb
278 1.60 gdt /*
279 1.60 gdt * Save the <device, inode> pair for the container file to speed
280 1.60 gdt * up subsequent reads while closed (mmap, program execution).
281 1.60 gdt * This is perhaps safe because venus will invalidate the node
282 1.60 gdt * before changing the container file mapping.
283 1.60 gdt */
284 1.1 rvb cp->c_device = dev;
285 1.1 rvb cp->c_inode = inode;
286 1.1 rvb
287 1.60 gdt /* Open the container file. */
288 1.63 pooka error = VOP_OPEN(container_vp, flag, cred);
289 1.55 gdt /*
290 1.55 gdt * Drop the lock on the container, after we have done VOP_OPEN
291 1.55 gdt * (which requires a locked vnode).
292 1.55 gdt */
293 1.68.12.4 yamt VOP_UNLOCK(container_vp);
294 1.1 rvb return(error);
295 1.1 rvb }
296 1.1 rvb
297 1.1 rvb /*
298 1.1 rvb * Close the cache file used for I/O and notify Venus.
299 1.1 rvb */
300 1.1 rvb int
301 1.43 xtraeme coda_close(void *v)
302 1.1 rvb {
303 1.1 rvb /* true args */
304 1.1 rvb struct vop_close_args *ap = v;
305 1.1 rvb struct vnode *vp = ap->a_vp;
306 1.1 rvb struct cnode *cp = VTOC(vp);
307 1.1 rvb int flag = ap->a_fflag;
308 1.49 elad kauth_cred_t cred = ap->a_cred;
309 1.1 rvb /* locals */
310 1.1 rvb int error;
311 1.1 rvb
312 1.3 rvb MARK_ENTRY(CODA_CLOSE_STATS);
313 1.1 rvb
314 1.1 rvb /* Check for close of control file. */
315 1.1 rvb if (IS_CTL_VP(vp)) {
316 1.3 rvb MARK_INT_SAT(CODA_CLOSE_STATS);
317 1.1 rvb return(0);
318 1.1 rvb }
319 1.1 rvb
320 1.55 gdt /*
321 1.58 gdt * XXX The IS_UNMOUNTING part of this is very suspect.
322 1.55 gdt */
323 1.1 rvb if (IS_UNMOUNTING(cp)) {
324 1.1 rvb if (cp->c_ovp) {
325 1.7 rvb #ifdef CODA_VERBOSE
326 1.3 rvb printf("coda_close: destroying container ref %d, ufs vp %p of vp %p/cp %p\n",
327 1.1 rvb vp->v_usecount, cp->c_ovp, vp, cp);
328 1.5 rvb #endif
329 1.8 rvb #ifdef hmm
330 1.1 rvb vgone(cp->c_ovp);
331 1.8 rvb #else
332 1.14 wrstuden vn_lock(cp->c_ovp, LK_EXCLUSIVE | LK_RETRY);
333 1.63 pooka VOP_CLOSE(cp->c_ovp, flag, cred); /* Do errors matter here? */
334 1.14 wrstuden vput(cp->c_ovp);
335 1.8 rvb #endif
336 1.1 rvb } else {
337 1.7 rvb #ifdef CODA_VERBOSE
338 1.3 rvb printf("coda_close: NO container vp %p/cp %p\n", vp, cp);
339 1.5 rvb #endif
340 1.1 rvb }
341 1.1 rvb return ENODEV;
342 1.1 rvb }
343 1.1 rvb
344 1.58 gdt /* Lock the container node, and VOP_CLOSE it. */
345 1.55 gdt vn_lock(cp->c_ovp, LK_EXCLUSIVE | LK_RETRY);
346 1.63 pooka VOP_CLOSE(cp->c_ovp, flag, cred); /* Do errors matter here? */
347 1.55 gdt /*
348 1.55 gdt * Drop the lock we just obtained, and vrele the container vnode.
349 1.55 gdt * Decrement reference counts, and clear container vnode pointer on
350 1.55 gdt * last close.
351 1.55 gdt */
352 1.55 gdt vput(cp->c_ovp);
353 1.55 gdt if (flag & FWRITE)
354 1.55 gdt --cp->c_owrite;
355 1.1 rvb if (--cp->c_ocount == 0)
356 1.1 rvb cp->c_ovp = NULL;
357 1.1 rvb
358 1.63 pooka error = venus_close(vtomi(vp), &cp->c_fid, flag, cred, curlwp);
359 1.54 gdt
360 1.3 rvb CODADEBUG(CODA_CLOSE, myprintf(("close: result %d\n",error)); )
361 1.1 rvb return(error);
362 1.1 rvb }
363 1.1 rvb
364 1.1 rvb int
365 1.43 xtraeme coda_read(void *v)
366 1.1 rvb {
367 1.1 rvb struct vop_read_args *ap = v;
368 1.1 rvb
369 1.1 rvb ENTRY;
370 1.3 rvb return(coda_rdwr(ap->a_vp, ap->a_uio, UIO_READ,
371 1.47 yamt ap->a_ioflag, ap->a_cred, curlwp));
372 1.1 rvb }
373 1.1 rvb
374 1.1 rvb int
375 1.43 xtraeme coda_write(void *v)
376 1.1 rvb {
377 1.1 rvb struct vop_write_args *ap = v;
378 1.1 rvb
379 1.1 rvb ENTRY;
380 1.3 rvb return(coda_rdwr(ap->a_vp, ap->a_uio, UIO_WRITE,
381 1.47 yamt ap->a_ioflag, ap->a_cred, curlwp));
382 1.1 rvb }
383 1.1 rvb
384 1.1 rvb int
385 1.43 xtraeme coda_rdwr(struct vnode *vp, struct uio *uiop, enum uio_rw rw, int ioflag,
386 1.49 elad kauth_cred_t cred, struct lwp *l)
387 1.40 perry {
388 1.1 rvb /* upcall decl */
389 1.1 rvb /* NOTE: container file operation!!! */
390 1.1 rvb /* locals */
391 1.1 rvb struct cnode *cp = VTOC(vp);
392 1.1 rvb struct vnode *cfvp = cp->c_ovp;
393 1.45 christos struct proc *p = l->l_proc;
394 1.1 rvb int opened_internally = 0;
395 1.1 rvb int error = 0;
396 1.1 rvb
397 1.3 rvb MARK_ENTRY(CODA_RDWR_STATS);
398 1.1 rvb
399 1.47 yamt CODADEBUG(CODA_RDWR, myprintf(("coda_rdwr(%d, %p, %lu, %lld)\n", rw,
400 1.12 matt uiop->uio_iov->iov_base,
401 1.40 perry (unsigned long) uiop->uio_resid,
402 1.47 yamt (long long) uiop->uio_offset)); )
403 1.40 perry
404 1.1 rvb /* Check for rdwr of control object. */
405 1.1 rvb if (IS_CTL_VP(vp)) {
406 1.3 rvb MARK_INT_FAIL(CODA_RDWR_STATS);
407 1.1 rvb return(EINVAL);
408 1.1 rvb }
409 1.1 rvb
410 1.1 rvb /* Redirect the request to UFS. */
411 1.1 rvb
412 1.40 perry /*
413 1.1 rvb * If file is not already open this must be a page
414 1.1 rvb * {read,write} request. Iget the cache file's inode
415 1.1 rvb * pointer if we still have its <device, inode> pair.
416 1.1 rvb * Otherwise, we must do an internal open to derive the
417 1.40 perry * pair.
418 1.58 gdt * XXX Integrate this into a coherent strategy for container
419 1.58 gdt * file acquisition.
420 1.1 rvb */
421 1.1 rvb if (cfvp == NULL) {
422 1.40 perry /*
423 1.1 rvb * If we're dumping core, do the internal open. Otherwise
424 1.1 rvb * venus won't have the correct size of the core when
425 1.1 rvb * it's completely written.
426 1.1 rvb */
427 1.40 perry if (cp->c_inode != 0 && !(p && (p->p_acflag & ACORE))) {
428 1.58 gdt printf("coda_rdwr: grabbing container vnode, losing reference\n");
429 1.58 gdt /* Get locked and refed vnode. */
430 1.35 thorpej error = coda_grab_vnode(cp->c_device, cp->c_inode, &cfvp);
431 1.1 rvb if (error) {
432 1.3 rvb MARK_INT_FAIL(CODA_RDWR_STATS);
433 1.1 rvb return(error);
434 1.1 rvb }
435 1.58 gdt /*
436 1.58 gdt * Drop lock.
437 1.58 gdt * XXX Where is reference released.
438 1.1 rvb */
439 1.68.12.4 yamt VOP_UNLOCK(cfvp);
440 1.1 rvb }
441 1.1 rvb else {
442 1.58 gdt printf("coda_rdwr: internal VOP_OPEN\n");
443 1.1 rvb opened_internally = 1;
444 1.3 rvb MARK_INT_GEN(CODA_OPEN_STATS);
445 1.63 pooka error = VOP_OPEN(vp, (rw == UIO_READ ? FREAD : FWRITE), cred);
446 1.18 phil #ifdef CODA_VERBOSE
447 1.3 rvb printf("coda_rdwr: Internally Opening %p\n", vp);
448 1.18 phil #endif
449 1.1 rvb if (error) {
450 1.3 rvb MARK_INT_FAIL(CODA_RDWR_STATS);
451 1.1 rvb return(error);
452 1.1 rvb }
453 1.1 rvb cfvp = cp->c_ovp;
454 1.1 rvb }
455 1.1 rvb }
456 1.1 rvb
457 1.1 rvb /* Have UFS handle the call. */
458 1.37 drochner CODADEBUG(CODA_RDWR, myprintf(("indirect rdwr: fid = %s, refcnt = %d\n",
459 1.37 drochner coda_f2s(&cp->c_fid), CTOV(cp)->v_usecount)); )
460 1.1 rvb
461 1.1 rvb if (rw == UIO_READ) {
462 1.1 rvb error = VOP_READ(cfvp, uiop, ioflag, cred);
463 1.1 rvb } else {
464 1.1 rvb error = VOP_WRITE(cfvp, uiop, ioflag, cred);
465 1.1 rvb }
466 1.1 rvb
467 1.1 rvb if (error)
468 1.3 rvb MARK_INT_FAIL(CODA_RDWR_STATS);
469 1.1 rvb else
470 1.3 rvb MARK_INT_SAT(CODA_RDWR_STATS);
471 1.1 rvb
472 1.1 rvb /* Do an internal close if necessary. */
473 1.1 rvb if (opened_internally) {
474 1.3 rvb MARK_INT_GEN(CODA_CLOSE_STATS);
475 1.63 pooka (void)VOP_CLOSE(vp, (rw == UIO_READ ? FREAD : FWRITE), cred);
476 1.1 rvb }
477 1.1 rvb
478 1.1 rvb /* Invalidate cached attributes if writing. */
479 1.1 rvb if (rw == UIO_WRITE)
480 1.1 rvb cp->c_flags &= ~C_VATTR;
481 1.1 rvb return(error);
482 1.1 rvb }
483 1.1 rvb
484 1.1 rvb int
485 1.43 xtraeme coda_ioctl(void *v)
486 1.1 rvb {
487 1.1 rvb /* true args */
488 1.1 rvb struct vop_ioctl_args *ap = v;
489 1.1 rvb struct vnode *vp = ap->a_vp;
490 1.1 rvb int com = ap->a_command;
491 1.52 christos void *data = ap->a_data;
492 1.1 rvb int flag = ap->a_fflag;
493 1.49 elad kauth_cred_t cred = ap->a_cred;
494 1.1 rvb /* locals */
495 1.1 rvb int error;
496 1.1 rvb struct vnode *tvp;
497 1.1 rvb struct PioctlData *iap = (struct PioctlData *)data;
498 1.68.12.2 yamt namei_simple_flags_t sflags;
499 1.1 rvb
500 1.3 rvb MARK_ENTRY(CODA_IOCTL_STATS);
501 1.1 rvb
502 1.3 rvb CODADEBUG(CODA_IOCTL, myprintf(("in coda_ioctl on %s\n", iap->path));)
503 1.40 perry
504 1.1 rvb /* Don't check for operation on a dying object, for ctlvp it
505 1.1 rvb shouldn't matter */
506 1.40 perry
507 1.1 rvb /* Must be control object to succeed. */
508 1.1 rvb if (!IS_CTL_VP(vp)) {
509 1.3 rvb MARK_INT_FAIL(CODA_IOCTL_STATS);
510 1.3 rvb CODADEBUG(CODA_IOCTL, myprintf(("coda_ioctl error: vp != ctlvp"));)
511 1.1 rvb return (EOPNOTSUPP);
512 1.1 rvb }
513 1.1 rvb /* Look up the pathname. */
514 1.1 rvb
515 1.1 rvb /* Should we use the name cache here? It would get it from
516 1.1 rvb lookupname sooner or later anyway, right? */
517 1.1 rvb
518 1.68.12.2 yamt sflags = iap->follow ? NSM_FOLLOW_NOEMULROOT : NSM_NOFOLLOW_NOEMULROOT;
519 1.68.12.2 yamt error = namei_simple_user(iap->path, sflags, &tvp);
520 1.1 rvb
521 1.1 rvb if (error) {
522 1.3 rvb MARK_INT_FAIL(CODA_IOCTL_STATS);
523 1.3 rvb CODADEBUG(CODA_IOCTL, myprintf(("coda_ioctl error: lookup returns %d\n",
524 1.1 rvb error));)
525 1.1 rvb return(error);
526 1.1 rvb }
527 1.1 rvb
528 1.40 perry /*
529 1.1 rvb * Make sure this is a coda style cnode, but it may be a
530 1.40 perry * different vfsp
531 1.1 rvb */
532 1.1 rvb /* XXX: this totally violates the comment about vtagtype in vnode.h */
533 1.3 rvb if (tvp->v_tag != VT_CODA) {
534 1.1 rvb vrele(tvp);
535 1.3 rvb MARK_INT_FAIL(CODA_IOCTL_STATS);
536 1.40 perry CODADEBUG(CODA_IOCTL,
537 1.40 perry myprintf(("coda_ioctl error: %s not a coda object\n",
538 1.1 rvb iap->path));)
539 1.1 rvb return(EINVAL);
540 1.1 rvb }
541 1.1 rvb
542 1.68.12.4 yamt if (iap->vi.in_size > VC_MAXDATASIZE || iap->vi.out_size > VC_MAXDATASIZE) {
543 1.1 rvb vrele(tvp);
544 1.1 rvb return(EINVAL);
545 1.1 rvb }
546 1.63 pooka error = venus_ioctl(vtomi(tvp), &((VTOC(tvp))->c_fid), com, flag, data,
547 1.63 pooka cred, curlwp);
548 1.1 rvb
549 1.1 rvb if (error)
550 1.3 rvb MARK_INT_FAIL(CODA_IOCTL_STATS);
551 1.1 rvb else
552 1.3 rvb CODADEBUG(CODA_IOCTL, myprintf(("Ioctl returns %d \n", error)); )
553 1.1 rvb
554 1.1 rvb vrele(tvp);
555 1.1 rvb return(error);
556 1.1 rvb }
557 1.1 rvb
558 1.1 rvb /*
559 1.1 rvb * To reduce the cost of a user-level venus;we cache attributes in
560 1.1 rvb * the kernel. Each cnode has storage allocated for an attribute. If
561 1.1 rvb * c_vattr is valid, return a reference to it. Otherwise, get the
562 1.1 rvb * attributes from venus and store them in the cnode. There is some
563 1.1 rvb * question if this method is a security leak. But I think that in
564 1.1 rvb * order to make this call, the user must have done a lookup and
565 1.40 perry * opened the file, and therefore should already have access.
566 1.1 rvb */
567 1.1 rvb int
568 1.43 xtraeme coda_getattr(void *v)
569 1.1 rvb {
570 1.1 rvb /* true args */
571 1.1 rvb struct vop_getattr_args *ap = v;
572 1.1 rvb struct vnode *vp = ap->a_vp;
573 1.1 rvb struct cnode *cp = VTOC(vp);
574 1.1 rvb struct vattr *vap = ap->a_vap;
575 1.49 elad kauth_cred_t cred = ap->a_cred;
576 1.1 rvb /* locals */
577 1.1 rvb int error;
578 1.1 rvb
579 1.3 rvb MARK_ENTRY(CODA_GETATTR_STATS);
580 1.1 rvb
581 1.1 rvb /* Check for getattr of control object. */
582 1.1 rvb if (IS_CTL_VP(vp)) {
583 1.3 rvb MARK_INT_FAIL(CODA_GETATTR_STATS);
584 1.1 rvb return(ENOENT);
585 1.1 rvb }
586 1.1 rvb
587 1.1 rvb /* Check to see if the attributes have already been cached */
588 1.40 perry if (VALID_VATTR(cp)) {
589 1.37 drochner CODADEBUG(CODA_GETATTR, { myprintf(("attr cache hit: %s\n",
590 1.37 drochner coda_f2s(&cp->c_fid)));});
591 1.3 rvb CODADEBUG(CODA_GETATTR, if (!(codadebug & ~CODA_GETATTR))
592 1.1 rvb print_vattr(&cp->c_vattr); );
593 1.40 perry
594 1.1 rvb *vap = cp->c_vattr;
595 1.3 rvb MARK_INT_SAT(CODA_GETATTR_STATS);
596 1.1 rvb return(0);
597 1.1 rvb }
598 1.1 rvb
599 1.63 pooka error = venus_getattr(vtomi(vp), &cp->c_fid, cred, curlwp, vap);
600 1.1 rvb
601 1.1 rvb if (!error) {
602 1.37 drochner CODADEBUG(CODA_GETATTR, myprintf(("getattr miss %s: result %d\n",
603 1.37 drochner coda_f2s(&cp->c_fid), error)); )
604 1.40 perry
605 1.3 rvb CODADEBUG(CODA_GETATTR, if (!(codadebug & ~CODA_GETATTR))
606 1.1 rvb print_vattr(vap); );
607 1.40 perry
608 1.40 perry /* If not open for write, store attributes in cnode */
609 1.40 perry if ((cp->c_owrite == 0) && (coda_attr_cache)) {
610 1.1 rvb cp->c_vattr = *vap;
611 1.40 perry cp->c_flags |= C_VATTR;
612 1.1 rvb }
613 1.40 perry
614 1.1 rvb }
615 1.1 rvb return(error);
616 1.1 rvb }
617 1.1 rvb
618 1.1 rvb int
619 1.43 xtraeme coda_setattr(void *v)
620 1.1 rvb {
621 1.1 rvb /* true args */
622 1.1 rvb struct vop_setattr_args *ap = v;
623 1.17 augustss struct vnode *vp = ap->a_vp;
624 1.1 rvb struct cnode *cp = VTOC(vp);
625 1.17 augustss struct vattr *vap = ap->a_vap;
626 1.49 elad kauth_cred_t cred = ap->a_cred;
627 1.1 rvb /* locals */
628 1.1 rvb int error;
629 1.1 rvb
630 1.3 rvb MARK_ENTRY(CODA_SETATTR_STATS);
631 1.1 rvb
632 1.1 rvb /* Check for setattr of control object. */
633 1.1 rvb if (IS_CTL_VP(vp)) {
634 1.3 rvb MARK_INT_FAIL(CODA_SETATTR_STATS);
635 1.1 rvb return(ENOENT);
636 1.1 rvb }
637 1.1 rvb
638 1.3 rvb if (codadebug & CODADBGMSK(CODA_SETATTR)) {
639 1.1 rvb print_vattr(vap);
640 1.1 rvb }
641 1.63 pooka error = venus_setattr(vtomi(vp), &cp->c_fid, vap, cred, curlwp);
642 1.1 rvb
643 1.1 rvb if (!error)
644 1.1 rvb cp->c_flags &= ~C_VATTR;
645 1.1 rvb
646 1.3 rvb CODADEBUG(CODA_SETATTR, myprintf(("setattr %d\n", error)); )
647 1.1 rvb return(error);
648 1.1 rvb }
649 1.1 rvb
650 1.1 rvb int
651 1.43 xtraeme coda_access(void *v)
652 1.1 rvb {
653 1.1 rvb /* true args */
654 1.1 rvb struct vop_access_args *ap = v;
655 1.1 rvb struct vnode *vp = ap->a_vp;
656 1.1 rvb struct cnode *cp = VTOC(vp);
657 1.1 rvb int mode = ap->a_mode;
658 1.49 elad kauth_cred_t cred = ap->a_cred;
659 1.1 rvb /* locals */
660 1.1 rvb int error;
661 1.1 rvb
662 1.3 rvb MARK_ENTRY(CODA_ACCESS_STATS);
663 1.1 rvb
664 1.1 rvb /* Check for access of control object. Only read access is
665 1.1 rvb allowed on it. */
666 1.1 rvb if (IS_CTL_VP(vp)) {
667 1.1 rvb /* bogus hack - all will be marked as successes */
668 1.3 rvb MARK_INT_SAT(CODA_ACCESS_STATS);
669 1.40 perry return(((mode & VREAD) && !(mode & (VWRITE | VEXEC)))
670 1.1 rvb ? 0 : EACCES);
671 1.1 rvb }
672 1.1 rvb
673 1.1 rvb /*
674 1.40 perry * if the file is a directory, and we are checking exec (eg lookup)
675 1.40 perry * access, and the file is in the namecache, then the user must have
676 1.1 rvb * lookup access to it.
677 1.1 rvb */
678 1.3 rvb if (coda_access_cache) {
679 1.1 rvb if ((vp->v_type == VDIR) && (mode & VEXEC)) {
680 1.3 rvb if (coda_nc_lookup(cp, ".", 1, cred)) {
681 1.3 rvb MARK_INT_SAT(CODA_ACCESS_STATS);
682 1.1 rvb return(0); /* it was in the cache */
683 1.1 rvb }
684 1.1 rvb }
685 1.1 rvb }
686 1.1 rvb
687 1.63 pooka error = venus_access(vtomi(vp), &cp->c_fid, mode, cred, curlwp);
688 1.1 rvb
689 1.1 rvb return(error);
690 1.1 rvb }
691 1.1 rvb
692 1.1 rvb /*
693 1.3 rvb * CODA abort op, called after namei() when a CREATE/DELETE isn't actually
694 1.3 rvb * done. If a buffer has been saved in anticipation of a coda_create or
695 1.3 rvb * a coda_remove, delete it.
696 1.1 rvb */
697 1.1 rvb /* ARGSUSED */
698 1.1 rvb int
699 1.43 xtraeme coda_abortop(void *v)
700 1.1 rvb {
701 1.1 rvb /* true args */
702 1.1 rvb struct vop_abortop_args /* {
703 1.1 rvb struct vnode *a_dvp;
704 1.1 rvb struct componentname *a_cnp;
705 1.1 rvb } */ *ap = v;
706 1.1 rvb /* upcall decl */
707 1.1 rvb /* locals */
708 1.1 rvb
709 1.1 rvb if ((ap->a_cnp->cn_flags & (HASBUF | SAVESTART)) == HASBUF)
710 1.20 thorpej PNBUF_PUT(ap->a_cnp->cn_pnbuf);
711 1.1 rvb return (0);
712 1.1 rvb }
713 1.1 rvb
714 1.1 rvb int
715 1.43 xtraeme coda_readlink(void *v)
716 1.1 rvb {
717 1.1 rvb /* true args */
718 1.1 rvb struct vop_readlink_args *ap = v;
719 1.1 rvb struct vnode *vp = ap->a_vp;
720 1.1 rvb struct cnode *cp = VTOC(vp);
721 1.1 rvb struct uio *uiop = ap->a_uio;
722 1.49 elad kauth_cred_t cred = ap->a_cred;
723 1.1 rvb /* locals */
724 1.47 yamt struct lwp *l = curlwp;
725 1.1 rvb int error;
726 1.1 rvb char *str;
727 1.1 rvb int len;
728 1.1 rvb
729 1.3 rvb MARK_ENTRY(CODA_READLINK_STATS);
730 1.1 rvb
731 1.1 rvb /* Check for readlink of control object. */
732 1.1 rvb if (IS_CTL_VP(vp)) {
733 1.3 rvb MARK_INT_FAIL(CODA_READLINK_STATS);
734 1.1 rvb return(ENOENT);
735 1.1 rvb }
736 1.1 rvb
737 1.3 rvb if ((coda_symlink_cache) && (VALID_SYMLINK(cp))) { /* symlink was cached */
738 1.1 rvb uiop->uio_rw = UIO_READ;
739 1.1 rvb error = uiomove(cp->c_symlink, (int)cp->c_symlen, uiop);
740 1.1 rvb if (error)
741 1.3 rvb MARK_INT_FAIL(CODA_READLINK_STATS);
742 1.1 rvb else
743 1.3 rvb MARK_INT_SAT(CODA_READLINK_STATS);
744 1.1 rvb return(error);
745 1.1 rvb }
746 1.1 rvb
747 1.45 christos error = venus_readlink(vtomi(vp), &cp->c_fid, cred, l, &str, &len);
748 1.1 rvb
749 1.1 rvb if (!error) {
750 1.1 rvb uiop->uio_rw = UIO_READ;
751 1.1 rvb error = uiomove(str, len, uiop);
752 1.1 rvb
753 1.3 rvb if (coda_symlink_cache) {
754 1.1 rvb cp->c_symlink = str;
755 1.1 rvb cp->c_symlen = len;
756 1.1 rvb cp->c_flags |= C_SYMLINK;
757 1.1 rvb } else
758 1.3 rvb CODA_FREE(str, len);
759 1.1 rvb }
760 1.1 rvb
761 1.3 rvb CODADEBUG(CODA_READLINK, myprintf(("in readlink result %d\n",error));)
762 1.1 rvb return(error);
763 1.1 rvb }
764 1.1 rvb
765 1.1 rvb int
766 1.43 xtraeme coda_fsync(void *v)
767 1.1 rvb {
768 1.1 rvb /* true args */
769 1.1 rvb struct vop_fsync_args *ap = v;
770 1.1 rvb struct vnode *vp = ap->a_vp;
771 1.1 rvb struct cnode *cp = VTOC(vp);
772 1.49 elad kauth_cred_t cred = ap->a_cred;
773 1.1 rvb /* locals */
774 1.1 rvb struct vnode *convp = cp->c_ovp;
775 1.1 rvb int error;
776 1.40 perry
777 1.3 rvb MARK_ENTRY(CODA_FSYNC_STATS);
778 1.1 rvb
779 1.1 rvb /* Check for fsync on an unmounting object */
780 1.1 rvb /* The NetBSD kernel, in it's infinite wisdom, can try to fsync
781 1.1 rvb * after an unmount has been initiated. This is a Bad Thing,
782 1.1 rvb * which we have to avoid. Not a legitimate failure for stats.
783 1.1 rvb */
784 1.1 rvb if (IS_UNMOUNTING(cp)) {
785 1.1 rvb return(ENODEV);
786 1.1 rvb }
787 1.1 rvb
788 1.1 rvb /* Check for fsync of control object. */
789 1.1 rvb if (IS_CTL_VP(vp)) {
790 1.3 rvb MARK_INT_SAT(CODA_FSYNC_STATS);
791 1.1 rvb return(0);
792 1.1 rvb }
793 1.1 rvb
794 1.1 rvb if (convp)
795 1.63 pooka VOP_FSYNC(convp, cred, MNT_WAIT, 0, 0);
796 1.1 rvb
797 1.1 rvb /*
798 1.1 rvb * We can expect fsync on any vnode at all if venus is pruging it.
799 1.1 rvb * Venus can't very well answer the fsync request, now can it?
800 1.1 rvb * Hopefully, it won't have to, because hopefully, venus preserves
801 1.1 rvb * the (possibly untrue) invariant that it never purges an open
802 1.1 rvb * vnode. Hopefully.
803 1.1 rvb */
804 1.1 rvb if (cp->c_flags & C_PURGING) {
805 1.1 rvb return(0);
806 1.1 rvb }
807 1.1 rvb
808 1.63 pooka error = venus_fsync(vtomi(vp), &cp->c_fid, cred, curlwp);
809 1.1 rvb
810 1.3 rvb CODADEBUG(CODA_FSYNC, myprintf(("in fsync result %d\n",error)); );
811 1.1 rvb return(error);
812 1.1 rvb }
813 1.1 rvb
814 1.60 gdt /*
815 1.60 gdt * vp is locked on entry, and we must unlock it.
816 1.60 gdt * XXX This routine is suspect and probably needs rewriting.
817 1.60 gdt */
818 1.1 rvb int
819 1.43 xtraeme coda_inactive(void *v)
820 1.1 rvb {
821 1.1 rvb /* true args */
822 1.1 rvb struct vop_inactive_args *ap = v;
823 1.1 rvb struct vnode *vp = ap->a_vp;
824 1.1 rvb struct cnode *cp = VTOC(vp);
825 1.65 perry kauth_cred_t cred __unused = NULL;
826 1.1 rvb
827 1.1 rvb /* We don't need to send inactive to venus - DCS */
828 1.3 rvb MARK_ENTRY(CODA_INACTIVE_STATS);
829 1.1 rvb
830 1.1 rvb if (IS_CTL_VP(vp)) {
831 1.3 rvb MARK_INT_SAT(CODA_INACTIVE_STATS);
832 1.1 rvb return 0;
833 1.1 rvb }
834 1.1 rvb
835 1.37 drochner CODADEBUG(CODA_INACTIVE, myprintf(("in inactive, %s, vfsp %p\n",
836 1.37 drochner coda_f2s(&cp->c_fid), vp->v_mount));)
837 1.1 rvb
838 1.1 rvb /* If an array has been allocated to hold the symlink, deallocate it */
839 1.3 rvb if ((coda_symlink_cache) && (VALID_SYMLINK(cp))) {
840 1.1 rvb if (cp->c_symlink == NULL)
841 1.3 rvb panic("coda_inactive: null symlink pointer in cnode");
842 1.40 perry
843 1.3 rvb CODA_FREE(cp->c_symlink, cp->c_symlen);
844 1.1 rvb cp->c_flags &= ~C_SYMLINK;
845 1.1 rvb cp->c_symlen = 0;
846 1.1 rvb }
847 1.1 rvb
848 1.1 rvb /* Remove it from the table so it can't be found. */
849 1.3 rvb coda_unsave(cp);
850 1.31 soren if (vp->v_mount->mnt_data == NULL) {
851 1.1 rvb myprintf(("Help! vfsp->vfs_data was NULL, but vnode %p wasn't dying\n", vp));
852 1.32 provos panic("badness in coda_inactive");
853 1.1 rvb }
854 1.1 rvb
855 1.1 rvb if (IS_UNMOUNTING(cp)) {
856 1.60 gdt /* XXX Do we need to VOP_CLOSE container vnodes? */
857 1.60 gdt if (vp->v_usecount > 0)
858 1.60 gdt printf("coda_inactive: IS_UNMOUNTING %p usecount %d\n",
859 1.60 gdt vp, vp->v_usecount);
860 1.1 rvb if (cp->c_ovp != NULL)
861 1.60 gdt printf("coda_inactive: %p ovp != NULL\n", vp);
862 1.68.12.4 yamt VOP_UNLOCK(vp);
863 1.1 rvb } else {
864 1.60 gdt /* Sanity checks that perhaps should be panic. */
865 1.60 gdt if (vp->v_usecount) {
866 1.60 gdt printf("coda_inactive: %p usecount %d\n", vp, vp->v_usecount);
867 1.1 rvb }
868 1.1 rvb if (cp->c_ovp != NULL) {
869 1.60 gdt printf("coda_inactive: %p ovp != NULL\n", vp);
870 1.1 rvb }
871 1.68.12.4 yamt VOP_UNLOCK(vp);
872 1.66 ad *ap->a_recycle = true;
873 1.1 rvb }
874 1.1 rvb
875 1.3 rvb MARK_INT_SAT(CODA_INACTIVE_STATS);
876 1.1 rvb return(0);
877 1.1 rvb }
878 1.1 rvb
879 1.1 rvb /*
880 1.60 gdt * Coda does not use the normal namecache, but a private version.
881 1.60 gdt * Consider how to use the standard facility instead.
882 1.1 rvb */
883 1.1 rvb int
884 1.43 xtraeme coda_lookup(void *v)
885 1.1 rvb {
886 1.1 rvb /* true args */
887 1.1 rvb struct vop_lookup_args *ap = v;
888 1.53 gdt /* (locked) vnode of dir in which to do lookup */
889 1.1 rvb struct vnode *dvp = ap->a_dvp;
890 1.1 rvb struct cnode *dcp = VTOC(dvp);
891 1.53 gdt /* output variable for result */
892 1.1 rvb struct vnode **vpp = ap->a_vpp;
893 1.53 gdt /* name to lookup */
894 1.53 gdt struct componentname *cnp = ap->a_cnp;
895 1.49 elad kauth_cred_t cred = cnp->cn_cred;
896 1.64 pooka struct lwp *l = curlwp;
897 1.1 rvb /* locals */
898 1.1 rvb struct cnode *cp;
899 1.1 rvb const char *nm = cnp->cn_nameptr;
900 1.1 rvb int len = cnp->cn_namelen;
901 1.53 gdt int flags = cnp->cn_flags;
902 1.54 gdt int isdot;
903 1.37 drochner CodaFid VFid;
904 1.1 rvb int vtype;
905 1.1 rvb int error = 0;
906 1.1 rvb
907 1.3 rvb MARK_ENTRY(CODA_LOOKUP_STATS);
908 1.1 rvb
909 1.37 drochner CODADEBUG(CODA_LOOKUP, myprintf(("lookup: %s in %s\n",
910 1.37 drochner nm, coda_f2s(&dcp->c_fid))););
911 1.1 rvb
912 1.53 gdt /*
913 1.53 gdt * XXX componentname flags in MODMASK are not handled at all
914 1.53 gdt */
915 1.53 gdt
916 1.53 gdt /*
917 1.53 gdt * The overall strategy is to switch on the lookup type and get a
918 1.53 gdt * result vnode that is vref'd but not locked. Then, the code at
919 1.53 gdt * exit: switches on ., .., and regular lookups and does the right
920 1.53 gdt * locking.
921 1.53 gdt */
922 1.53 gdt
923 1.1 rvb /* Check for lookup of control object. */
924 1.1 rvb if (IS_CTL_NAME(dvp, nm, len)) {
925 1.3 rvb *vpp = coda_ctlvp;
926 1.1 rvb vref(*vpp);
927 1.3 rvb MARK_INT_SAT(CODA_LOOKUP_STATS);
928 1.1 rvb goto exit;
929 1.1 rvb }
930 1.1 rvb
931 1.53 gdt /* Avoid trying to hand venus an unreasonably long name. */
932 1.3 rvb if (len+1 > CODA_MAXNAMLEN) {
933 1.3 rvb MARK_INT_FAIL(CODA_LOOKUP_STATS);
934 1.37 drochner CODADEBUG(CODA_LOOKUP, myprintf(("name too long: lookup, %s (%s)\n",
935 1.37 drochner coda_f2s(&dcp->c_fid), nm)););
936 1.1 rvb *vpp = (struct vnode *)0;
937 1.1 rvb error = EINVAL;
938 1.1 rvb goto exit;
939 1.1 rvb }
940 1.53 gdt
941 1.53 gdt /*
942 1.60 gdt * XXX Check for DOT lookups, and short circuit all the caches,
943 1.54 gdt * just doing an extra vref. (venus guarantees that lookup of
944 1.54 gdt * . returns self.)
945 1.54 gdt */
946 1.54 gdt isdot = (len == 1 && nm[0] == '.');
947 1.54 gdt
948 1.54 gdt /*
949 1.53 gdt * Try to resolve the lookup in the minicache. If that fails, ask
950 1.53 gdt * venus to do the lookup. XXX The interaction between vnode
951 1.53 gdt * locking and any locking that coda does is not clear.
952 1.53 gdt */
953 1.3 rvb cp = coda_nc_lookup(dcp, nm, len, cred);
954 1.1 rvb if (cp) {
955 1.1 rvb *vpp = CTOV(cp);
956 1.1 rvb vref(*vpp);
957 1.40 perry CODADEBUG(CODA_LOOKUP,
958 1.1 rvb myprintf(("lookup result %d vpp %p\n",error,*vpp));)
959 1.1 rvb } else {
960 1.53 gdt /* The name wasn't cached, so ask Venus. */
961 1.45 christos error = venus_lookup(vtomi(dvp), &dcp->c_fid, nm, len, cred, l, &VFid, &vtype);
962 1.40 perry
963 1.1 rvb if (error) {
964 1.3 rvb MARK_INT_FAIL(CODA_LOOKUP_STATS);
965 1.37 drochner CODADEBUG(CODA_LOOKUP, myprintf(("lookup error on %s (%s)%d\n",
966 1.37 drochner coda_f2s(&dcp->c_fid), nm, error));)
967 1.1 rvb *vpp = (struct vnode *)0;
968 1.1 rvb } else {
969 1.3 rvb MARK_INT_SAT(CODA_LOOKUP_STATS);
970 1.40 perry CODADEBUG(CODA_LOOKUP,
971 1.37 drochner myprintf(("lookup: %s type %o result %d\n",
972 1.37 drochner coda_f2s(&VFid), vtype, error)); )
973 1.40 perry
974 1.3 rvb cp = make_coda_node(&VFid, dvp->v_mount, vtype);
975 1.1 rvb *vpp = CTOV(cp);
976 1.53 gdt /* vpp is now vrefed. */
977 1.40 perry
978 1.53 gdt /*
979 1.53 gdt * Unless this vnode is marked CODA_NOCACHE, enter it into
980 1.53 gdt * the coda name cache to avoid a future venus round-trip.
981 1.53 gdt * XXX Interaction with componentname NOCACHE is unclear.
982 1.53 gdt */
983 1.3 rvb if (!(vtype & CODA_NOCACHE))
984 1.3 rvb coda_nc_enter(VTOC(dvp), nm, len, cred, VTOC(*vpp));
985 1.1 rvb }
986 1.1 rvb }
987 1.1 rvb
988 1.1 rvb exit:
989 1.40 perry /*
990 1.1 rvb * If we are creating, and this was the last name to be looked up,
991 1.53 gdt * and the error was ENOENT, then make the leaf NULL and return
992 1.53 gdt * success.
993 1.53 gdt * XXX Check against new lookup rules.
994 1.1 rvb */
995 1.1 rvb if (((cnp->cn_nameiop == CREATE) || (cnp->cn_nameiop == RENAME))
996 1.1 rvb && (cnp->cn_flags & ISLASTCN)
997 1.1 rvb && (error == ENOENT))
998 1.1 rvb {
999 1.1 rvb error = EJUSTRETURN;
1000 1.1 rvb cnp->cn_flags |= SAVENAME;
1001 1.1 rvb *ap->a_vpp = NULL;
1002 1.1 rvb }
1003 1.1 rvb
1004 1.40 perry /*
1005 1.1 rvb * If we are removing, and we are at the last element, and we
1006 1.1 rvb * found it, then we need to keep the name around so that the
1007 1.53 gdt * removal will go ahead as planned.
1008 1.53 gdt * XXX Check against new lookup rules.
1009 1.1 rvb */
1010 1.1 rvb if ((cnp->cn_nameiop == DELETE)
1011 1.1 rvb && (cnp->cn_flags & ISLASTCN)
1012 1.1 rvb && !error)
1013 1.1 rvb {
1014 1.1 rvb cnp->cn_flags |= SAVENAME;
1015 1.1 rvb }
1016 1.1 rvb
1017 1.40 perry /*
1018 1.53 gdt * If the lookup succeeded, we must generally lock the returned
1019 1.53 gdt * vnode. This could be a ., .., or normal lookup. See
1020 1.53 gdt * vnodeops(9) for the details.
1021 1.53 gdt */
1022 1.53 gdt /*
1023 1.53 gdt * XXX LK_RETRY is likely incorrect. Handle vn_lock failure
1024 1.53 gdt * somehow, and remove LK_RETRY.
1025 1.1 rvb */
1026 1.1 rvb if (!error || (error == EJUSTRETURN)) {
1027 1.53 gdt /* Lookup has a value and it isn't "."? */
1028 1.51 chs if (*ap->a_vpp && (*ap->a_vpp != dvp)) {
1029 1.53 gdt if (flags & ISDOTDOT)
1030 1.53 gdt /* ..: unlock parent */
1031 1.68.12.4 yamt VOP_UNLOCK(dvp);
1032 1.53 gdt /* all but .: lock child */
1033 1.53 gdt vn_lock(*ap->a_vpp, LK_EXCLUSIVE | LK_RETRY);
1034 1.53 gdt if (flags & ISDOTDOT)
1035 1.53 gdt /* ..: relock parent */
1036 1.53 gdt vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
1037 1.1 rvb }
1038 1.53 gdt /* else .: leave dvp locked */
1039 1.1 rvb } else {
1040 1.53 gdt /* The lookup failed, so return NULL. Leave dvp locked. */
1041 1.1 rvb *ap->a_vpp = NULL;
1042 1.1 rvb }
1043 1.1 rvb return(error);
1044 1.1 rvb }
1045 1.1 rvb
1046 1.1 rvb /*ARGSUSED*/
1047 1.1 rvb int
1048 1.43 xtraeme coda_create(void *v)
1049 1.1 rvb {
1050 1.1 rvb /* true args */
1051 1.1 rvb struct vop_create_args *ap = v;
1052 1.1 rvb struct vnode *dvp = ap->a_dvp;
1053 1.1 rvb struct cnode *dcp = VTOC(dvp);
1054 1.1 rvb struct vattr *va = ap->a_vap;
1055 1.1 rvb int exclusive = 1;
1056 1.1 rvb int mode = ap->a_vap->va_mode;
1057 1.1 rvb struct vnode **vpp = ap->a_vpp;
1058 1.1 rvb struct componentname *cnp = ap->a_cnp;
1059 1.49 elad kauth_cred_t cred = cnp->cn_cred;
1060 1.64 pooka struct lwp *l = curlwp;
1061 1.1 rvb /* locals */
1062 1.1 rvb int error;
1063 1.1 rvb struct cnode *cp;
1064 1.1 rvb const char *nm = cnp->cn_nameptr;
1065 1.1 rvb int len = cnp->cn_namelen;
1066 1.37 drochner CodaFid VFid;
1067 1.1 rvb struct vattr attr;
1068 1.1 rvb
1069 1.3 rvb MARK_ENTRY(CODA_CREATE_STATS);
1070 1.1 rvb
1071 1.1 rvb /* All creates are exclusive XXX */
1072 1.1 rvb /* I'm assuming the 'mode' argument is the file mode bits XXX */
1073 1.1 rvb
1074 1.1 rvb /* Check for create of control object. */
1075 1.1 rvb if (IS_CTL_NAME(dvp, nm, len)) {
1076 1.1 rvb *vpp = (struct vnode *)0;
1077 1.3 rvb MARK_INT_FAIL(CODA_CREATE_STATS);
1078 1.1 rvb return(EACCES);
1079 1.1 rvb }
1080 1.1 rvb
1081 1.45 christos error = venus_create(vtomi(dvp), &dcp->c_fid, nm, len, exclusive, mode, va, cred, l, &VFid, &attr);
1082 1.1 rvb
1083 1.1 rvb if (!error) {
1084 1.40 perry
1085 1.54 gdt /*
1086 1.54 gdt * XXX Violation of venus/kernel invariants is a difficult case,
1087 1.54 gdt * but venus should not be able to cause a panic.
1088 1.54 gdt */
1089 1.1 rvb /* If this is an exclusive create, panic if the file already exists. */
1090 1.1 rvb /* Venus should have detected the file and reported EEXIST. */
1091 1.1 rvb
1092 1.1 rvb if ((exclusive == 1) &&
1093 1.3 rvb (coda_find(&VFid) != NULL))
1094 1.1 rvb panic("cnode existed for newly created file!");
1095 1.40 perry
1096 1.3 rvb cp = make_coda_node(&VFid, dvp->v_mount, attr.va_type);
1097 1.1 rvb *vpp = CTOV(cp);
1098 1.40 perry
1099 1.54 gdt /* XXX vnodeops doesn't say this argument can be changed. */
1100 1.1 rvb /* Update va to reflect the new attributes. */
1101 1.1 rvb (*va) = attr;
1102 1.40 perry
1103 1.1 rvb /* Update the attribute cache and mark it as valid */
1104 1.3 rvb if (coda_attr_cache) {
1105 1.1 rvb VTOC(*vpp)->c_vattr = attr;
1106 1.40 perry VTOC(*vpp)->c_flags |= C_VATTR;
1107 1.1 rvb }
1108 1.1 rvb
1109 1.54 gdt /* Invalidate parent's attr cache (modification time has changed). */
1110 1.1 rvb VTOC(dvp)->c_flags &= ~C_VATTR;
1111 1.40 perry
1112 1.1 rvb /* enter the new vnode in the Name Cache */
1113 1.3 rvb coda_nc_enter(VTOC(dvp), nm, len, cred, VTOC(*vpp));
1114 1.40 perry
1115 1.40 perry CODADEBUG(CODA_CREATE,
1116 1.37 drochner myprintf(("create: %s, result %d\n",
1117 1.37 drochner coda_f2s(&VFid), error)); )
1118 1.1 rvb } else {
1119 1.1 rvb *vpp = (struct vnode *)0;
1120 1.3 rvb CODADEBUG(CODA_CREATE, myprintf(("create error %d\n", error));)
1121 1.1 rvb }
1122 1.1 rvb
1123 1.1 rvb /*
1124 1.54 gdt * vnodeops(9) says that we must unlock the parent and lock the child.
1125 1.54 gdt * XXX Should we lock the child first?
1126 1.1 rvb */
1127 1.1 rvb vput(dvp);
1128 1.1 rvb if (!error) {
1129 1.54 gdt if ((cnp->cn_flags & LOCKLEAF) == 0) {
1130 1.54 gdt /* This should not happen; flags are for lookup only. */
1131 1.54 gdt printf("coda_create: LOCKLEAF not set!\n");
1132 1.1 rvb }
1133 1.54 gdt
1134 1.54 gdt if ((error = vn_lock(*ap->a_vpp, LK_EXCLUSIVE))) {
1135 1.54 gdt /* XXX Perhaps avoid this panic. */
1136 1.54 gdt panic("coda_create: couldn't lock child");
1137 1.1 rvb }
1138 1.1 rvb }
1139 1.54 gdt
1140 1.54 gdt /* Per vnodeops(9), free name except on success and SAVESTART. */
1141 1.54 gdt if (error || (cnp->cn_flags & SAVESTART) == 0) {
1142 1.20 thorpej PNBUF_PUT(cnp->cn_pnbuf);
1143 1.1 rvb }
1144 1.1 rvb return(error);
1145 1.1 rvb }
1146 1.1 rvb
1147 1.1 rvb int
1148 1.43 xtraeme coda_remove(void *v)
1149 1.1 rvb {
1150 1.1 rvb /* true args */
1151 1.1 rvb struct vop_remove_args *ap = v;
1152 1.1 rvb struct vnode *dvp = ap->a_dvp;
1153 1.1 rvb struct cnode *cp = VTOC(dvp);
1154 1.54 gdt struct vnode *vp = ap->a_vp;
1155 1.1 rvb struct componentname *cnp = ap->a_cnp;
1156 1.49 elad kauth_cred_t cred = cnp->cn_cred;
1157 1.64 pooka struct lwp *l = curlwp;
1158 1.1 rvb /* locals */
1159 1.1 rvb int error;
1160 1.1 rvb const char *nm = cnp->cn_nameptr;
1161 1.1 rvb int len = cnp->cn_namelen;
1162 1.1 rvb struct cnode *tp;
1163 1.1 rvb
1164 1.3 rvb MARK_ENTRY(CODA_REMOVE_STATS);
1165 1.1 rvb
1166 1.37 drochner CODADEBUG(CODA_REMOVE, myprintf(("remove: %s in %s\n",
1167 1.37 drochner nm, coda_f2s(&cp->c_fid))););
1168 1.1 rvb
1169 1.3 rvb /* Remove the file's entry from the CODA Name Cache */
1170 1.1 rvb /* We're being conservative here, it might be that this person
1171 1.1 rvb * doesn't really have sufficient access to delete the file
1172 1.1 rvb * but we feel zapping the entry won't really hurt anyone -- dcs
1173 1.1 rvb */
1174 1.1 rvb /* I'm gonna go out on a limb here. If a file and a hardlink to it
1175 1.1 rvb * exist, and one is removed, the link count on the other will be
1176 1.1 rvb * off by 1. We could either invalidate the attrs if cached, or
1177 1.1 rvb * fix them. I'll try to fix them. DCS 11/8/94
1178 1.1 rvb */
1179 1.3 rvb tp = coda_nc_lookup(VTOC(dvp), nm, len, cred);
1180 1.1 rvb if (tp) {
1181 1.1 rvb if (VALID_VATTR(tp)) { /* If attrs are cached */
1182 1.1 rvb if (tp->c_vattr.va_nlink > 1) { /* If it's a hard link */
1183 1.1 rvb tp->c_vattr.va_nlink--;
1184 1.1 rvb }
1185 1.1 rvb }
1186 1.40 perry
1187 1.40 perry coda_nc_zapfile(VTOC(dvp), nm, len);
1188 1.1 rvb /* No need to flush it if it doesn't exist! */
1189 1.1 rvb }
1190 1.1 rvb /* Invalidate the parent's attr cache, the modification time has changed */
1191 1.1 rvb VTOC(dvp)->c_flags &= ~C_VATTR;
1192 1.1 rvb
1193 1.1 rvb /* Check for remove of control object. */
1194 1.1 rvb if (IS_CTL_NAME(dvp, nm, len)) {
1195 1.3 rvb MARK_INT_FAIL(CODA_REMOVE_STATS);
1196 1.1 rvb return(ENOENT);
1197 1.1 rvb }
1198 1.1 rvb
1199 1.45 christos error = venus_remove(vtomi(dvp), &cp->c_fid, nm, len, cred, l);
1200 1.1 rvb
1201 1.3 rvb CODADEBUG(CODA_REMOVE, myprintf(("in remove result %d\n",error)); )
1202 1.1 rvb
1203 1.40 perry /*
1204 1.55 gdt * Unlock parent and child (avoiding double if ".").
1205 1.1 rvb */
1206 1.54 gdt if (dvp == vp) {
1207 1.54 gdt vrele(vp);
1208 1.1 rvb } else {
1209 1.54 gdt vput(vp);
1210 1.1 rvb }
1211 1.1 rvb vput(dvp);
1212 1.1 rvb
1213 1.1 rvb return(error);
1214 1.1 rvb }
1215 1.1 rvb
1216 1.55 gdt /*
1217 1.55 gdt * dvp is the directory where the link is to go, and is locked.
1218 1.55 gdt * vp is the object to be linked to, and is unlocked.
1219 1.55 gdt * At exit, we must unlock dvp, and vput dvp.
1220 1.55 gdt */
1221 1.1 rvb int
1222 1.43 xtraeme coda_link(void *v)
1223 1.1 rvb {
1224 1.1 rvb /* true args */
1225 1.1 rvb struct vop_link_args *ap = v;
1226 1.1 rvb struct vnode *vp = ap->a_vp;
1227 1.1 rvb struct cnode *cp = VTOC(vp);
1228 1.55 gdt struct vnode *dvp = ap->a_dvp;
1229 1.55 gdt struct cnode *dcp = VTOC(dvp);
1230 1.1 rvb struct componentname *cnp = ap->a_cnp;
1231 1.49 elad kauth_cred_t cred = cnp->cn_cred;
1232 1.64 pooka struct lwp *l = curlwp;
1233 1.1 rvb /* locals */
1234 1.1 rvb int error;
1235 1.1 rvb const char *nm = cnp->cn_nameptr;
1236 1.1 rvb int len = cnp->cn_namelen;
1237 1.1 rvb
1238 1.3 rvb MARK_ENTRY(CODA_LINK_STATS);
1239 1.1 rvb
1240 1.3 rvb if (codadebug & CODADBGMSK(CODA_LINK)) {
1241 1.1 rvb
1242 1.37 drochner myprintf(("nb_link: vp fid: %s\n",
1243 1.37 drochner coda_f2s(&cp->c_fid)));
1244 1.55 gdt myprintf(("nb_link: dvp fid: %s)\n",
1245 1.55 gdt coda_f2s(&dcp->c_fid)));
1246 1.40 perry
1247 1.1 rvb }
1248 1.3 rvb if (codadebug & CODADBGMSK(CODA_LINK)) {
1249 1.37 drochner myprintf(("link: vp fid: %s\n",
1250 1.37 drochner coda_f2s(&cp->c_fid)));
1251 1.55 gdt myprintf(("link: dvp fid: %s\n",
1252 1.55 gdt coda_f2s(&dcp->c_fid)));
1253 1.1 rvb
1254 1.1 rvb }
1255 1.1 rvb
1256 1.1 rvb /* Check for link to/from control object. */
1257 1.55 gdt if (IS_CTL_NAME(dvp, nm, len) || IS_CTL_VP(vp)) {
1258 1.3 rvb MARK_INT_FAIL(CODA_LINK_STATS);
1259 1.1 rvb return(EACCES);
1260 1.1 rvb }
1261 1.1 rvb
1262 1.55 gdt /* If linking . to a name, error out earlier. */
1263 1.55 gdt if (vp == dvp) {
1264 1.55 gdt printf("coda_link vp==dvp\n");
1265 1.55 gdt error = EISDIR;
1266 1.55 gdt goto exit;
1267 1.55 gdt }
1268 1.1 rvb
1269 1.55 gdt /* XXX Why does venus_link need the vnode to be locked?*/
1270 1.55 gdt if ((error = vn_lock(vp, LK_EXCLUSIVE)) != 0) {
1271 1.55 gdt printf("coda_link: couldn't lock vnode %p\n", vp);
1272 1.55 gdt error = EFAULT; /* XXX better value */
1273 1.1 rvb goto exit;
1274 1.1 rvb }
1275 1.55 gdt error = venus_link(vtomi(vp), &cp->c_fid, &dcp->c_fid, nm, len, cred, l);
1276 1.68.12.4 yamt VOP_UNLOCK(vp);
1277 1.40 perry
1278 1.55 gdt /* Invalidate parent's attr cache (the modification time has changed). */
1279 1.55 gdt VTOC(dvp)->c_flags &= ~C_VATTR;
1280 1.55 gdt /* Invalidate child's attr cache (XXX why). */
1281 1.1 rvb VTOC(vp)->c_flags &= ~C_VATTR;
1282 1.1 rvb
1283 1.3 rvb CODADEBUG(CODA_LINK, myprintf(("in link result %d\n",error)); )
1284 1.1 rvb
1285 1.1 rvb exit:
1286 1.55 gdt vput(dvp);
1287 1.1 rvb return(error);
1288 1.1 rvb }
1289 1.1 rvb
1290 1.1 rvb int
1291 1.43 xtraeme coda_rename(void *v)
1292 1.1 rvb {
1293 1.1 rvb /* true args */
1294 1.1 rvb struct vop_rename_args *ap = v;
1295 1.1 rvb struct vnode *odvp = ap->a_fdvp;
1296 1.1 rvb struct cnode *odcp = VTOC(odvp);
1297 1.1 rvb struct componentname *fcnp = ap->a_fcnp;
1298 1.1 rvb struct vnode *ndvp = ap->a_tdvp;
1299 1.1 rvb struct cnode *ndcp = VTOC(ndvp);
1300 1.1 rvb struct componentname *tcnp = ap->a_tcnp;
1301 1.49 elad kauth_cred_t cred = fcnp->cn_cred;
1302 1.64 pooka struct lwp *l = curlwp;
1303 1.1 rvb /* true args */
1304 1.1 rvb int error;
1305 1.1 rvb const char *fnm = fcnp->cn_nameptr;
1306 1.1 rvb int flen = fcnp->cn_namelen;
1307 1.1 rvb const char *tnm = tcnp->cn_nameptr;
1308 1.1 rvb int tlen = tcnp->cn_namelen;
1309 1.1 rvb
1310 1.3 rvb MARK_ENTRY(CODA_RENAME_STATS);
1311 1.1 rvb
1312 1.1 rvb /* Hmmm. The vnodes are already looked up. Perhaps they are locked?
1313 1.1 rvb This could be Bad. XXX */
1314 1.5 rvb #ifdef OLD_DIAGNOSTIC
1315 1.1 rvb if ((fcnp->cn_cred != tcnp->cn_cred)
1316 1.45 christos || (fcnp->cn_lwp != tcnp->cn_lwp))
1317 1.1 rvb {
1318 1.3 rvb panic("coda_rename: component names don't agree");
1319 1.1 rvb }
1320 1.5 rvb #endif
1321 1.1 rvb
1322 1.40 perry /* Check for rename involving control object. */
1323 1.1 rvb if (IS_CTL_NAME(odvp, fnm, flen) || IS_CTL_NAME(ndvp, tnm, tlen)) {
1324 1.3 rvb MARK_INT_FAIL(CODA_RENAME_STATS);
1325 1.1 rvb return(EACCES);
1326 1.1 rvb }
1327 1.1 rvb
1328 1.1 rvb /* Problem with moving directories -- need to flush entry for .. */
1329 1.1 rvb if (odvp != ndvp) {
1330 1.3 rvb struct cnode *ovcp = coda_nc_lookup(VTOC(odvp), fnm, flen, cred);
1331 1.1 rvb if (ovcp) {
1332 1.1 rvb struct vnode *ovp = CTOV(ovcp);
1333 1.1 rvb if ((ovp) &&
1334 1.1 rvb (ovp->v_type == VDIR)) /* If it's a directory */
1335 1.3 rvb coda_nc_zapfile(VTOC(ovp),"..", 2);
1336 1.1 rvb }
1337 1.1 rvb }
1338 1.1 rvb
1339 1.1 rvb /* Remove the entries for both source and target files */
1340 1.3 rvb coda_nc_zapfile(VTOC(odvp), fnm, flen);
1341 1.3 rvb coda_nc_zapfile(VTOC(ndvp), tnm, tlen);
1342 1.1 rvb
1343 1.1 rvb /* Invalidate the parent's attr cache, the modification time has changed */
1344 1.1 rvb VTOC(odvp)->c_flags &= ~C_VATTR;
1345 1.1 rvb VTOC(ndvp)->c_flags &= ~C_VATTR;
1346 1.1 rvb
1347 1.3 rvb if (flen+1 > CODA_MAXNAMLEN) {
1348 1.3 rvb MARK_INT_FAIL(CODA_RENAME_STATS);
1349 1.1 rvb error = EINVAL;
1350 1.1 rvb goto exit;
1351 1.1 rvb }
1352 1.1 rvb
1353 1.3 rvb if (tlen+1 > CODA_MAXNAMLEN) {
1354 1.3 rvb MARK_INT_FAIL(CODA_RENAME_STATS);
1355 1.1 rvb error = EINVAL;
1356 1.1 rvb goto exit;
1357 1.1 rvb }
1358 1.1 rvb
1359 1.45 christos error = venus_rename(vtomi(odvp), &odcp->c_fid, &ndcp->c_fid, fnm, flen, tnm, tlen, cred, l);
1360 1.1 rvb
1361 1.1 rvb exit:
1362 1.3 rvb CODADEBUG(CODA_RENAME, myprintf(("in rename result %d\n",error));)
1363 1.1 rvb /* XXX - do we need to call cache pureg on the moved vnode? */
1364 1.1 rvb cache_purge(ap->a_fvp);
1365 1.1 rvb
1366 1.1 rvb /* It seems to be incumbent on us to drop locks on all four vnodes */
1367 1.1 rvb /* From-vnodes are not locked, only ref'd. To-vnodes are locked. */
1368 1.1 rvb
1369 1.1 rvb vrele(ap->a_fvp);
1370 1.1 rvb vrele(odvp);
1371 1.1 rvb
1372 1.1 rvb if (ap->a_tvp) {
1373 1.1 rvb if (ap->a_tvp == ndvp) {
1374 1.1 rvb vrele(ap->a_tvp);
1375 1.1 rvb } else {
1376 1.1 rvb vput(ap->a_tvp);
1377 1.1 rvb }
1378 1.1 rvb }
1379 1.1 rvb
1380 1.1 rvb vput(ndvp);
1381 1.1 rvb return(error);
1382 1.1 rvb }
1383 1.1 rvb
1384 1.1 rvb int
1385 1.43 xtraeme coda_mkdir(void *v)
1386 1.1 rvb {
1387 1.1 rvb /* true args */
1388 1.1 rvb struct vop_mkdir_args *ap = v;
1389 1.1 rvb struct vnode *dvp = ap->a_dvp;
1390 1.40 perry struct cnode *dcp = VTOC(dvp);
1391 1.1 rvb struct componentname *cnp = ap->a_cnp;
1392 1.17 augustss struct vattr *va = ap->a_vap;
1393 1.1 rvb struct vnode **vpp = ap->a_vpp;
1394 1.49 elad kauth_cred_t cred = cnp->cn_cred;
1395 1.64 pooka struct lwp *l = curlwp;
1396 1.1 rvb /* locals */
1397 1.1 rvb int error;
1398 1.1 rvb const char *nm = cnp->cn_nameptr;
1399 1.1 rvb int len = cnp->cn_namelen;
1400 1.1 rvb struct cnode *cp;
1401 1.37 drochner CodaFid VFid;
1402 1.1 rvb struct vattr ova;
1403 1.1 rvb
1404 1.3 rvb MARK_ENTRY(CODA_MKDIR_STATS);
1405 1.1 rvb
1406 1.1 rvb /* Check for mkdir of target object. */
1407 1.1 rvb if (IS_CTL_NAME(dvp, nm, len)) {
1408 1.1 rvb *vpp = (struct vnode *)0;
1409 1.3 rvb MARK_INT_FAIL(CODA_MKDIR_STATS);
1410 1.1 rvb return(EACCES);
1411 1.1 rvb }
1412 1.1 rvb
1413 1.3 rvb if (len+1 > CODA_MAXNAMLEN) {
1414 1.1 rvb *vpp = (struct vnode *)0;
1415 1.3 rvb MARK_INT_FAIL(CODA_MKDIR_STATS);
1416 1.1 rvb return(EACCES);
1417 1.1 rvb }
1418 1.1 rvb
1419 1.45 christos error = venus_mkdir(vtomi(dvp), &dcp->c_fid, nm, len, va, cred, l, &VFid, &ova);
1420 1.1 rvb
1421 1.1 rvb if (!error) {
1422 1.3 rvb if (coda_find(&VFid) != NULL)
1423 1.1 rvb panic("cnode existed for newly created directory!");
1424 1.40 perry
1425 1.40 perry
1426 1.3 rvb cp = make_coda_node(&VFid, dvp->v_mount, va->va_type);
1427 1.1 rvb *vpp = CTOV(cp);
1428 1.40 perry
1429 1.1 rvb /* enter the new vnode in the Name Cache */
1430 1.3 rvb coda_nc_enter(VTOC(dvp), nm, len, cred, VTOC(*vpp));
1431 1.1 rvb
1432 1.1 rvb /* as a side effect, enter "." and ".." for the directory */
1433 1.3 rvb coda_nc_enter(VTOC(*vpp), ".", 1, cred, VTOC(*vpp));
1434 1.3 rvb coda_nc_enter(VTOC(*vpp), "..", 2, cred, VTOC(dvp));
1435 1.1 rvb
1436 1.3 rvb if (coda_attr_cache) {
1437 1.1 rvb VTOC(*vpp)->c_vattr = ova; /* update the attr cache */
1438 1.1 rvb VTOC(*vpp)->c_flags |= C_VATTR; /* Valid attributes in cnode */
1439 1.1 rvb }
1440 1.1 rvb
1441 1.1 rvb /* Invalidate the parent's attr cache, the modification time has changed */
1442 1.1 rvb VTOC(dvp)->c_flags &= ~C_VATTR;
1443 1.40 perry
1444 1.37 drochner CODADEBUG( CODA_MKDIR, myprintf(("mkdir: %s result %d\n",
1445 1.37 drochner coda_f2s(&VFid), error)); )
1446 1.1 rvb } else {
1447 1.1 rvb *vpp = (struct vnode *)0;
1448 1.3 rvb CODADEBUG(CODA_MKDIR, myprintf(("mkdir error %d\n",error));)
1449 1.1 rvb }
1450 1.1 rvb
1451 1.1 rvb /*
1452 1.1 rvb * Currently, all mkdirs explicitly vput their dvp's.
1453 1.1 rvb * It also appears that we *must* lock the vpp, since
1454 1.1 rvb * lockleaf isn't set, but someone down the road is going
1455 1.1 rvb * to try to unlock the new directory.
1456 1.1 rvb */
1457 1.1 rvb vput(dvp);
1458 1.1 rvb if (!error) {
1459 1.2 rvb if ((error = vn_lock(*ap->a_vpp, LK_EXCLUSIVE))) {
1460 1.3 rvb panic("coda_mkdir: couldn't lock child");
1461 1.1 rvb }
1462 1.1 rvb }
1463 1.1 rvb
1464 1.54 gdt /* Per vnodeops(9), free name except on success and SAVESTART. */
1465 1.54 gdt if (error || (cnp->cn_flags & SAVESTART) == 0) {
1466 1.54 gdt PNBUF_PUT(cnp->cn_pnbuf);
1467 1.54 gdt }
1468 1.1 rvb return(error);
1469 1.1 rvb }
1470 1.1 rvb
1471 1.1 rvb int
1472 1.43 xtraeme coda_rmdir(void *v)
1473 1.1 rvb {
1474 1.1 rvb /* true args */
1475 1.1 rvb struct vop_rmdir_args *ap = v;
1476 1.1 rvb struct vnode *dvp = ap->a_dvp;
1477 1.1 rvb struct cnode *dcp = VTOC(dvp);
1478 1.55 gdt struct vnode *vp = ap->a_vp;
1479 1.1 rvb struct componentname *cnp = ap->a_cnp;
1480 1.49 elad kauth_cred_t cred = cnp->cn_cred;
1481 1.64 pooka struct lwp *l = curlwp;
1482 1.1 rvb /* true args */
1483 1.1 rvb int error;
1484 1.1 rvb const char *nm = cnp->cn_nameptr;
1485 1.1 rvb int len = cnp->cn_namelen;
1486 1.1 rvb struct cnode *cp;
1487 1.40 perry
1488 1.3 rvb MARK_ENTRY(CODA_RMDIR_STATS);
1489 1.1 rvb
1490 1.1 rvb /* Check for rmdir of control object. */
1491 1.1 rvb if (IS_CTL_NAME(dvp, nm, len)) {
1492 1.3 rvb MARK_INT_FAIL(CODA_RMDIR_STATS);
1493 1.1 rvb return(ENOENT);
1494 1.1 rvb }
1495 1.1 rvb
1496 1.55 gdt /* Can't remove . in self. */
1497 1.55 gdt if (dvp == vp) {
1498 1.55 gdt printf("coda_rmdir: dvp == vp\n");
1499 1.55 gdt error = EINVAL;
1500 1.55 gdt goto exit;
1501 1.55 gdt }
1502 1.55 gdt
1503 1.1 rvb /*
1504 1.55 gdt * The caller may not have adequate permissions, and the venus
1505 1.55 gdt * operation may fail, but it doesn't hurt from a correctness
1506 1.55 gdt * viewpoint to invalidate cache entries.
1507 1.55 gdt * XXX Why isn't this done after the venus_rmdir call?
1508 1.1 rvb */
1509 1.55 gdt /* Look up child in name cache (by name, from parent). */
1510 1.3 rvb cp = coda_nc_lookup(dcp, nm, len, cred);
1511 1.55 gdt /* If found, remove all children of the child (., ..). */
1512 1.3 rvb if (cp) coda_nc_zapParentfid(&(cp->c_fid), NOT_DOWNCALL);
1513 1.1 rvb
1514 1.55 gdt /* Remove child's own entry. */
1515 1.3 rvb coda_nc_zapfile(dcp, nm, len);
1516 1.1 rvb
1517 1.55 gdt /* Invalidate parent's attr cache (the modification time has changed). */
1518 1.1 rvb dcp->c_flags &= ~C_VATTR;
1519 1.1 rvb
1520 1.45 christos error = venus_rmdir(vtomi(dvp), &dcp->c_fid, nm, len, cred, l);
1521 1.1 rvb
1522 1.3 rvb CODADEBUG(CODA_RMDIR, myprintf(("in rmdir result %d\n", error)); )
1523 1.1 rvb
1524 1.55 gdt exit:
1525 1.55 gdt /* vput both vnodes */
1526 1.55 gdt vput(dvp);
1527 1.55 gdt if (dvp == vp) {
1528 1.55 gdt vrele(vp);
1529 1.1 rvb } else {
1530 1.55 gdt vput(vp);
1531 1.1 rvb }
1532 1.1 rvb
1533 1.1 rvb return(error);
1534 1.1 rvb }
1535 1.1 rvb
1536 1.1 rvb int
1537 1.43 xtraeme coda_symlink(void *v)
1538 1.1 rvb {
1539 1.1 rvb /* true args */
1540 1.1 rvb struct vop_symlink_args *ap = v;
1541 1.54 gdt struct vnode *dvp = ap->a_dvp;
1542 1.54 gdt struct cnode *dcp = VTOC(dvp);
1543 1.54 gdt /* a_vpp is used in place below */
1544 1.1 rvb struct componentname *cnp = ap->a_cnp;
1545 1.1 rvb struct vattr *tva = ap->a_vap;
1546 1.1 rvb char *path = ap->a_target;
1547 1.49 elad kauth_cred_t cred = cnp->cn_cred;
1548 1.64 pooka struct lwp *l = curlwp;
1549 1.1 rvb /* locals */
1550 1.1 rvb int error;
1551 1.39 petrov u_long saved_cn_flags;
1552 1.2 rvb const char *nm = cnp->cn_nameptr;
1553 1.1 rvb int len = cnp->cn_namelen;
1554 1.1 rvb int plen = strlen(path);
1555 1.1 rvb
1556 1.40 perry /*
1557 1.1 rvb * Here's the strategy for the moment: perform the symlink, then
1558 1.1 rvb * do a lookup to grab the resulting vnode. I know this requires
1559 1.1 rvb * two communications with Venus for a new sybolic link, but
1560 1.1 rvb * that's the way the ball bounces. I don't yet want to change
1561 1.1 rvb * the way the Mach symlink works. When Mach support is
1562 1.1 rvb * deprecated, we should change symlink so that the common case
1563 1.1 rvb * returns the resultant vnode in a vpp argument.
1564 1.1 rvb */
1565 1.1 rvb
1566 1.3 rvb MARK_ENTRY(CODA_SYMLINK_STATS);
1567 1.1 rvb
1568 1.1 rvb /* Check for symlink of control object. */
1569 1.54 gdt if (IS_CTL_NAME(dvp, nm, len)) {
1570 1.3 rvb MARK_INT_FAIL(CODA_SYMLINK_STATS);
1571 1.54 gdt error = EACCES;
1572 1.54 gdt goto exit;
1573 1.1 rvb }
1574 1.1 rvb
1575 1.3 rvb if (plen+1 > CODA_MAXPATHLEN) {
1576 1.3 rvb MARK_INT_FAIL(CODA_SYMLINK_STATS);
1577 1.54 gdt error = EINVAL;
1578 1.54 gdt goto exit;
1579 1.1 rvb }
1580 1.1 rvb
1581 1.3 rvb if (len+1 > CODA_MAXNAMLEN) {
1582 1.3 rvb MARK_INT_FAIL(CODA_SYMLINK_STATS);
1583 1.1 rvb error = EINVAL;
1584 1.1 rvb goto exit;
1585 1.1 rvb }
1586 1.1 rvb
1587 1.54 gdt error = venus_symlink(vtomi(dvp), &dcp->c_fid, path, plen, nm, len, tva, cred, l);
1588 1.1 rvb
1589 1.54 gdt /* Invalidate the parent's attr cache (modification time has changed). */
1590 1.54 gdt dcp->c_flags &= ~C_VATTR;
1591 1.1 rvb
1592 1.39 petrov if (!error) {
1593 1.39 petrov /*
1594 1.39 petrov * VOP_SYMLINK is not defined to pay attention to cnp->cn_flags;
1595 1.39 petrov * these are defined only for VOP_LOOKUP. We desire to reuse
1596 1.39 petrov * cnp for a VOP_LOOKUP operation, and must be sure to not pass
1597 1.39 petrov * stray flags passed to us. Such stray flags can occur because
1598 1.39 petrov * sys_symlink makes a namei call and then reuses the
1599 1.39 petrov * componentname structure.
1600 1.39 petrov */
1601 1.39 petrov /*
1602 1.39 petrov * XXX Arguably we should create our own componentname structure
1603 1.39 petrov * and not reuse the one that was passed in.
1604 1.39 petrov */
1605 1.39 petrov saved_cn_flags = cnp->cn_flags;
1606 1.39 petrov cnp->cn_flags &= ~(MODMASK | OPMASK);
1607 1.39 petrov cnp->cn_flags |= LOOKUP;
1608 1.54 gdt error = VOP_LOOKUP(dvp, ap->a_vpp, cnp);
1609 1.39 petrov cnp->cn_flags = saved_cn_flags;
1610 1.39 petrov /* Either an error occurs, or ap->a_vpp is locked. */
1611 1.1 rvb }
1612 1.54 gdt
1613 1.54 gdt exit:
1614 1.51 chs /* unlock and deference parent */
1615 1.54 gdt vput(dvp);
1616 1.54 gdt
1617 1.54 gdt /* Per vnodeops(9), free name except on success and SAVESTART. */
1618 1.54 gdt if (error || (cnp->cn_flags & SAVESTART) == 0) {
1619 1.54 gdt PNBUF_PUT(cnp->cn_pnbuf);
1620 1.54 gdt }
1621 1.1 rvb
1622 1.3 rvb CODADEBUG(CODA_SYMLINK, myprintf(("in symlink result %d\n",error)); )
1623 1.1 rvb return(error);
1624 1.1 rvb }
1625 1.1 rvb
1626 1.1 rvb /*
1627 1.1 rvb * Read directory entries.
1628 1.1 rvb */
1629 1.1 rvb int
1630 1.43 xtraeme coda_readdir(void *v)
1631 1.1 rvb {
1632 1.1 rvb /* true args */
1633 1.1 rvb struct vop_readdir_args *ap = v;
1634 1.1 rvb struct vnode *vp = ap->a_vp;
1635 1.1 rvb struct cnode *cp = VTOC(vp);
1636 1.17 augustss struct uio *uiop = ap->a_uio;
1637 1.49 elad kauth_cred_t cred = ap->a_cred;
1638 1.1 rvb int *eofflag = ap->a_eofflag;
1639 1.1 rvb off_t **cookies = ap->a_cookies;
1640 1.1 rvb int *ncookies = ap->a_ncookies;
1641 1.1 rvb /* upcall decl */
1642 1.1 rvb /* locals */
1643 1.1 rvb int error = 0;
1644 1.1 rvb
1645 1.3 rvb MARK_ENTRY(CODA_READDIR_STATS);
1646 1.1 rvb
1647 1.47 yamt CODADEBUG(CODA_READDIR, myprintf(("coda_readdir(%p, %lu, %lld)\n", uiop->uio_iov->iov_base, (unsigned long) uiop->uio_resid, (long long) uiop->uio_offset)); )
1648 1.40 perry
1649 1.1 rvb /* Check for readdir of control object. */
1650 1.1 rvb if (IS_CTL_VP(vp)) {
1651 1.3 rvb MARK_INT_FAIL(CODA_READDIR_STATS);
1652 1.1 rvb return(ENOENT);
1653 1.1 rvb }
1654 1.1 rvb
1655 1.2 rvb {
1656 1.1 rvb /* Redirect the request to UFS. */
1657 1.40 perry
1658 1.1 rvb /* If directory is not already open do an "internal open" on it. */
1659 1.1 rvb int opened_internally = 0;
1660 1.1 rvb if (cp->c_ovp == NULL) {
1661 1.1 rvb opened_internally = 1;
1662 1.3 rvb MARK_INT_GEN(CODA_OPEN_STATS);
1663 1.63 pooka error = VOP_OPEN(vp, FREAD, cred);
1664 1.18 phil #ifdef CODA_VERBOSE
1665 1.3 rvb printf("coda_readdir: Internally Opening %p\n", vp);
1666 1.18 phil #endif
1667 1.1 rvb if (error) return(error);
1668 1.48 christos } else
1669 1.48 christos vp = cp->c_ovp;
1670 1.40 perry
1671 1.1 rvb /* Have UFS handle the call. */
1672 1.37 drochner CODADEBUG(CODA_READDIR, myprintf((
1673 1.37 drochner "indirect readdir: fid = %s, refcnt = %d\n",
1674 1.37 drochner coda_f2s(&cp->c_fid), vp->v_usecount)); )
1675 1.48 christos error = VOP_READDIR(vp, uiop, cred, eofflag, cookies, ncookies);
1676 1.1 rvb if (error)
1677 1.3 rvb MARK_INT_FAIL(CODA_READDIR_STATS);
1678 1.1 rvb else
1679 1.3 rvb MARK_INT_SAT(CODA_READDIR_STATS);
1680 1.40 perry
1681 1.40 perry /* Do an "internal close" if necessary. */
1682 1.1 rvb if (opened_internally) {
1683 1.3 rvb MARK_INT_GEN(CODA_CLOSE_STATS);
1684 1.63 pooka (void)VOP_CLOSE(vp, FREAD, cred);
1685 1.1 rvb }
1686 1.1 rvb }
1687 1.1 rvb
1688 1.1 rvb return(error);
1689 1.1 rvb }
1690 1.1 rvb
1691 1.1 rvb /*
1692 1.1 rvb * Convert from file system blocks to device blocks
1693 1.1 rvb */
1694 1.1 rvb int
1695 1.43 xtraeme coda_bmap(void *v)
1696 1.1 rvb {
1697 1.1 rvb /* XXX on the global proc */
1698 1.1 rvb /* true args */
1699 1.1 rvb struct vop_bmap_args *ap = v;
1700 1.65 perry struct vnode *vp __unused = ap->a_vp; /* file's vnode */
1701 1.65 perry daddr_t bn __unused = ap->a_bn; /* fs block number */
1702 1.1 rvb struct vnode **vpp = ap->a_vpp; /* RETURN vp of device */
1703 1.65 perry daddr_t *bnp __unused = ap->a_bnp; /* RETURN device block number */
1704 1.65 perry struct lwp *l __unused = curlwp;
1705 1.1 rvb /* upcall decl */
1706 1.1 rvb /* locals */
1707 1.1 rvb
1708 1.1 rvb *vpp = (struct vnode *)0;
1709 1.3 rvb myprintf(("coda_bmap called!\n"));
1710 1.1 rvb return(EINVAL);
1711 1.1 rvb }
1712 1.1 rvb
1713 1.1 rvb /*
1714 1.1 rvb * I don't think the following two things are used anywhere, so I've
1715 1.40 perry * commented them out
1716 1.40 perry *
1717 1.40 perry * struct buf *async_bufhead;
1718 1.1 rvb * int async_daemon_count;
1719 1.1 rvb */
1720 1.1 rvb int
1721 1.43 xtraeme coda_strategy(void *v)
1722 1.1 rvb {
1723 1.1 rvb /* true args */
1724 1.1 rvb struct vop_strategy_args *ap = v;
1725 1.65 perry struct buf *bp __unused = ap->a_bp;
1726 1.65 perry struct lwp *l __unused = curlwp;
1727 1.1 rvb /* upcall decl */
1728 1.1 rvb /* locals */
1729 1.1 rvb
1730 1.3 rvb myprintf(("coda_strategy called! "));
1731 1.1 rvb return(EINVAL);
1732 1.1 rvb }
1733 1.1 rvb
1734 1.1 rvb int
1735 1.43 xtraeme coda_reclaim(void *v)
1736 1.1 rvb {
1737 1.1 rvb /* true args */
1738 1.1 rvb struct vop_reclaim_args *ap = v;
1739 1.1 rvb struct vnode *vp = ap->a_vp;
1740 1.1 rvb struct cnode *cp = VTOC(vp);
1741 1.1 rvb /* upcall decl */
1742 1.1 rvb /* locals */
1743 1.1 rvb
1744 1.1 rvb /*
1745 1.1 rvb * Forced unmount/flush will let vnodes with non zero use be destroyed!
1746 1.1 rvb */
1747 1.1 rvb ENTRY;
1748 1.1 rvb
1749 1.1 rvb if (IS_UNMOUNTING(cp)) {
1750 1.1 rvb #ifdef DEBUG
1751 1.1 rvb if (VTOC(vp)->c_ovp) {
1752 1.1 rvb if (IS_UNMOUNTING(cp))
1753 1.3 rvb printf("coda_reclaim: c_ovp not void: vp %p, cp %p\n", vp, cp);
1754 1.1 rvb }
1755 1.1 rvb #endif
1756 1.1 rvb } else {
1757 1.5 rvb #ifdef OLD_DIAGNOSTIC
1758 1.40 perry if (vp->v_usecount != 0)
1759 1.5 rvb print("coda_reclaim: pushing active %p\n", vp);
1760 1.1 rvb if (VTOC(vp)->c_ovp) {
1761 1.3 rvb panic("coda_reclaim: c_ovp not void");
1762 1.2 rvb }
1763 1.5 rvb #endif
1764 1.1 rvb }
1765 1.1 rvb cache_purge(vp);
1766 1.3 rvb coda_free(VTOC(vp));
1767 1.29 perry SET_VTOC(vp) = NULL;
1768 1.1 rvb return (0);
1769 1.1 rvb }
1770 1.1 rvb
1771 1.1 rvb int
1772 1.43 xtraeme coda_lock(void *v)
1773 1.1 rvb {
1774 1.1 rvb /* true args */
1775 1.1 rvb struct vop_lock_args *ap = v;
1776 1.1 rvb struct vnode *vp = ap->a_vp;
1777 1.1 rvb struct cnode *cp = VTOC(vp);
1778 1.1 rvb /* upcall decl */
1779 1.1 rvb /* locals */
1780 1.1 rvb
1781 1.1 rvb ENTRY;
1782 1.1 rvb
1783 1.3 rvb if (coda_lockdebug) {
1784 1.37 drochner myprintf(("Attempting lock on %s\n",
1785 1.37 drochner coda_f2s(&cp->c_fid)));
1786 1.1 rvb }
1787 1.1 rvb
1788 1.68.12.4 yamt return genfs_lock(v);
1789 1.1 rvb }
1790 1.1 rvb
1791 1.1 rvb int
1792 1.43 xtraeme coda_unlock(void *v)
1793 1.1 rvb {
1794 1.1 rvb /* true args */
1795 1.1 rvb struct vop_unlock_args *ap = v;
1796 1.1 rvb struct vnode *vp = ap->a_vp;
1797 1.1 rvb struct cnode *cp = VTOC(vp);
1798 1.1 rvb /* upcall decl */
1799 1.1 rvb /* locals */
1800 1.1 rvb
1801 1.1 rvb ENTRY;
1802 1.3 rvb if (coda_lockdebug) {
1803 1.37 drochner myprintf(("Attempting unlock on %s\n",
1804 1.37 drochner coda_f2s(&cp->c_fid)));
1805 1.1 rvb }
1806 1.1 rvb
1807 1.68.12.4 yamt return genfs_unlock(v);
1808 1.1 rvb }
1809 1.1 rvb
1810 1.1 rvb int
1811 1.43 xtraeme coda_islocked(void *v)
1812 1.1 rvb {
1813 1.1 rvb /* true args */
1814 1.1 rvb ENTRY;
1815 1.1 rvb
1816 1.68.12.4 yamt return genfs_islocked(v);
1817 1.1 rvb }
1818 1.1 rvb
1819 1.55 gdt /*
1820 1.55 gdt * Given a device and inode, obtain a locked vnode. One reference is
1821 1.55 gdt * obtained and passed back to the caller.
1822 1.55 gdt */
1823 1.1 rvb int
1824 1.35 thorpej coda_grab_vnode(dev_t dev, ino_t ino, struct vnode **vpp)
1825 1.1 rvb {
1826 1.1 rvb int error;
1827 1.1 rvb struct mount *mp;
1828 1.1 rvb
1829 1.55 gdt /* Obtain mount point structure from device. */
1830 1.1 rvb if (!(mp = devtomp(dev))) {
1831 1.68.12.1 yamt myprintf(("coda_grab_vnode: devtomp(0x%llx) returns NULL\n",
1832 1.68.12.1 yamt (unsigned long long)dev));
1833 1.1 rvb return(ENXIO);
1834 1.1 rvb }
1835 1.1 rvb
1836 1.55 gdt /*
1837 1.55 gdt * Obtain vnode from mount point and inode.
1838 1.55 gdt * XXX VFS_VGET does not clearly define locked/referenced state of
1839 1.55 gdt * returned vnode.
1840 1.55 gdt */
1841 1.45 christos error = VFS_VGET(mp, ino, vpp);
1842 1.1 rvb if (error) {
1843 1.68.12.1 yamt myprintf(("coda_grab_vnode: iget/vget(0x%llx, %llu) returns %p, err %d\n",
1844 1.68.12.1 yamt (unsigned long long)dev, (unsigned long long)ino, *vpp, error));
1845 1.1 rvb return(ENOENT);
1846 1.1 rvb }
1847 1.1 rvb return(0);
1848 1.1 rvb }
1849 1.1 rvb
1850 1.1 rvb void
1851 1.43 xtraeme print_vattr(struct vattr *attr)
1852 1.1 rvb {
1853 1.41 christos const char *typestr;
1854 1.1 rvb
1855 1.1 rvb switch (attr->va_type) {
1856 1.1 rvb case VNON:
1857 1.1 rvb typestr = "VNON";
1858 1.1 rvb break;
1859 1.1 rvb case VREG:
1860 1.1 rvb typestr = "VREG";
1861 1.1 rvb break;
1862 1.1 rvb case VDIR:
1863 1.1 rvb typestr = "VDIR";
1864 1.1 rvb break;
1865 1.1 rvb case VBLK:
1866 1.1 rvb typestr = "VBLK";
1867 1.1 rvb break;
1868 1.1 rvb case VCHR:
1869 1.1 rvb typestr = "VCHR";
1870 1.1 rvb break;
1871 1.1 rvb case VLNK:
1872 1.1 rvb typestr = "VLNK";
1873 1.1 rvb break;
1874 1.1 rvb case VSOCK:
1875 1.1 rvb typestr = "VSCK";
1876 1.1 rvb break;
1877 1.1 rvb case VFIFO:
1878 1.1 rvb typestr = "VFFO";
1879 1.1 rvb break;
1880 1.1 rvb case VBAD:
1881 1.1 rvb typestr = "VBAD";
1882 1.1 rvb break;
1883 1.1 rvb default:
1884 1.1 rvb typestr = "????";
1885 1.1 rvb break;
1886 1.1 rvb }
1887 1.1 rvb
1888 1.1 rvb
1889 1.1 rvb myprintf(("attr: type %s mode %d uid %d gid %d fsid %d rdev %d\n",
1890 1.1 rvb typestr, (int)attr->va_mode, (int)attr->va_uid,
1891 1.1 rvb (int)attr->va_gid, (int)attr->va_fsid, (int)attr->va_rdev));
1892 1.1 rvb
1893 1.1 rvb myprintf((" fileid %d nlink %d size %d blocksize %d bytes %d\n",
1894 1.40 perry (int)attr->va_fileid, (int)attr->va_nlink,
1895 1.1 rvb (int)attr->va_size,
1896 1.1 rvb (int)attr->va_blocksize,(int)attr->va_bytes));
1897 1.1 rvb myprintf((" gen %ld flags %ld vaflags %d\n",
1898 1.1 rvb attr->va_gen, attr->va_flags, attr->va_vaflags));
1899 1.1 rvb myprintf((" atime sec %d nsec %d\n",
1900 1.1 rvb (int)attr->va_atime.tv_sec, (int)attr->va_atime.tv_nsec));
1901 1.1 rvb myprintf((" mtime sec %d nsec %d\n",
1902 1.1 rvb (int)attr->va_mtime.tv_sec, (int)attr->va_mtime.tv_nsec));
1903 1.1 rvb myprintf((" ctime sec %d nsec %d\n",
1904 1.1 rvb (int)attr->va_ctime.tv_sec, (int)attr->va_ctime.tv_nsec));
1905 1.1 rvb }
1906 1.1 rvb
1907 1.1 rvb /* How to print a ucred */
1908 1.1 rvb void
1909 1.49 elad print_cred(kauth_cred_t cred)
1910 1.1 rvb {
1911 1.1 rvb
1912 1.49 elad uint16_t ngroups;
1913 1.1 rvb int i;
1914 1.1 rvb
1915 1.49 elad myprintf(("ref %d\tuid %d\n", kauth_cred_getrefcnt(cred),
1916 1.49 elad kauth_cred_geteuid(cred)));
1917 1.1 rvb
1918 1.49 elad ngroups = kauth_cred_ngroups(cred);
1919 1.49 elad for (i=0; i < ngroups; i++)
1920 1.49 elad myprintf(("\tgroup %d: (%d)\n", i, kauth_cred_group(cred, i)));
1921 1.1 rvb myprintf(("\n"));
1922 1.1 rvb
1923 1.1 rvb }
1924 1.1 rvb
1925 1.1 rvb /*
1926 1.1 rvb * Return a vnode for the given fid.
1927 1.1 rvb * If no cnode exists for this fid create one and put it
1928 1.37 drochner * in a table hashed by coda_f2i(). If the cnode for
1929 1.1 rvb * this fid is already in the table return it (ref count is
1930 1.3 rvb * incremented by coda_find. The cnode will be flushed from the
1931 1.3 rvb * table when coda_inactive calls coda_unsave.
1932 1.1 rvb */
1933 1.1 rvb struct cnode *
1934 1.43 xtraeme make_coda_node(CodaFid *fid, struct mount *vfsp, short type)
1935 1.1 rvb {
1936 1.1 rvb struct cnode *cp;
1937 1.1 rvb int err;
1938 1.1 rvb
1939 1.3 rvb if ((cp = coda_find(fid)) == NULL) {
1940 1.1 rvb struct vnode *vp;
1941 1.40 perry
1942 1.3 rvb cp = coda_alloc();
1943 1.1 rvb cp->c_fid = *fid;
1944 1.40 perry
1945 1.40 perry err = getnewvnode(VT_CODA, vfsp, coda_vnodeop_p, &vp);
1946 1.40 perry if (err) {
1947 1.40 perry panic("coda: getnewvnode returned error %d", err);
1948 1.40 perry }
1949 1.40 perry vp->v_data = cp;
1950 1.40 perry vp->v_type = type;
1951 1.40 perry cp->c_vnode = vp;
1952 1.62 pooka uvm_vnp_setsize(vp, 0);
1953 1.3 rvb coda_save(cp);
1954 1.40 perry
1955 1.1 rvb } else {
1956 1.1 rvb vref(CTOV(cp));
1957 1.1 rvb }
1958 1.1 rvb
1959 1.1 rvb return cp;
1960 1.25 chs }
1961 1.25 chs
1962 1.57 gdt /*
1963 1.57 gdt * coda_getpages may be called on a vnode which has not been opened,
1964 1.57 gdt * e.g. to fault in pages to execute a program. In that case, we must
1965 1.57 gdt * open the file to get the container. The vnode may or may not be
1966 1.57 gdt * locked, and we must leave it in the same state.
1967 1.59 gdt * XXX The protocol requires v_uobj.vmobjlock to be
1968 1.59 gdt * held by caller, but this isn't documented in vnodeops(9) or vnode_if.src.
1969 1.57 gdt */
1970 1.25 chs int
1971 1.43 xtraeme coda_getpages(void *v)
1972 1.25 chs {
1973 1.25 chs struct vop_getpages_args /* {
1974 1.25 chs struct vnode *a_vp;
1975 1.25 chs voff_t a_offset;
1976 1.25 chs struct vm_page **a_m;
1977 1.25 chs int *a_count;
1978 1.25 chs int a_centeridx;
1979 1.25 chs vm_prot_t a_access_type;
1980 1.25 chs int a_advice;
1981 1.25 chs int a_flags;
1982 1.25 chs } */ *ap = v;
1983 1.25 chs struct vnode *vp = ap->a_vp;
1984 1.25 chs struct cnode *cp = VTOC(vp);
1985 1.45 christos struct lwp *l = curlwp;
1986 1.50 ad kauth_cred_t cred = l->l_cred;
1987 1.57 gdt int error, cerror;
1988 1.57 gdt int waslocked; /* 1 if vnode lock was held on entry */
1989 1.57 gdt int didopen = 0; /* 1 if we opened container file */
1990 1.57 gdt
1991 1.58 gdt /*
1992 1.58 gdt * Handle a case that uvm_fault doesn't quite use yet.
1993 1.58 gdt * See layer_vnops.c. for inspiration.
1994 1.58 gdt */
1995 1.57 gdt if (ap->a_flags & PGO_LOCKED) {
1996 1.57 gdt return EBUSY;
1997 1.57 gdt }
1998 1.25 chs
1999 1.25 chs /* Check for control object. */
2000 1.25 chs if (IS_CTL_VP(vp)) {
2001 1.57 gdt printf("coda_getpages: control object %p\n", vp);
2002 1.66 ad mutex_exit(&vp->v_uobj.vmobjlock);
2003 1.25 chs return(EINVAL);
2004 1.25 chs }
2005 1.25 chs
2006 1.58 gdt /*
2007 1.58 gdt * XXX It's really not ok to be releasing the lock we get,
2008 1.58 gdt * because we could be overlapping with another call to
2009 1.58 gdt * getpages and drop a lock they are relying on. We need to
2010 1.58 gdt * figure out whether getpages ever is called holding the
2011 1.58 gdt * lock, and if we should serialize getpages calls by some
2012 1.58 gdt * mechanism.
2013 1.58 gdt */
2014 1.68.12.4 yamt /* XXX VOP_ISLOCKED() may not be used for lock decisions. */
2015 1.57 gdt waslocked = VOP_ISLOCKED(vp);
2016 1.57 gdt
2017 1.59 gdt /* Drop the vmobject lock. */
2018 1.66 ad mutex_exit(&vp->v_uobj.vmobjlock);
2019 1.58 gdt
2020 1.58 gdt /* Get container file if not already present. */
2021 1.57 gdt if (cp->c_ovp == NULL) {
2022 1.57 gdt /*
2023 1.57 gdt * VOP_OPEN requires a locked vnode. We must avoid
2024 1.57 gdt * locking the vnode if it is already locked, and
2025 1.57 gdt * leave it in the same state on exit.
2026 1.57 gdt */
2027 1.57 gdt if (waslocked == 0) {
2028 1.57 gdt cerror = vn_lock(vp, LK_EXCLUSIVE);
2029 1.57 gdt if (cerror) {
2030 1.57 gdt printf("coda_getpages: can't lock vnode %p\n",
2031 1.57 gdt vp);
2032 1.57 gdt return cerror;
2033 1.57 gdt }
2034 1.57 gdt #if 0
2035 1.57 gdt printf("coda_getpages: locked vnode %p\n", vp);
2036 1.57 gdt #endif
2037 1.57 gdt }
2038 1.57 gdt
2039 1.57 gdt /*
2040 1.57 gdt * Open file (causes upcall to venus).
2041 1.57 gdt * XXX Perhaps we should not fully open the file, but
2042 1.57 gdt * simply obtain a container file.
2043 1.57 gdt */
2044 1.57 gdt /* XXX Is it ok to do this while holding the simplelock? */
2045 1.63 pooka cerror = VOP_OPEN(vp, FREAD, cred);
2046 1.57 gdt
2047 1.57 gdt if (cerror) {
2048 1.57 gdt printf("coda_getpages: cannot open vnode %p => %d\n",
2049 1.57 gdt vp, cerror);
2050 1.57 gdt if (waslocked == 0)
2051 1.68.12.4 yamt VOP_UNLOCK(vp);
2052 1.57 gdt return cerror;
2053 1.57 gdt }
2054 1.57 gdt
2055 1.57 gdt #if 0
2056 1.57 gdt printf("coda_getpages: opened vnode %p\n", vp);
2057 1.57 gdt #endif
2058 1.57 gdt didopen = 1;
2059 1.25 chs }
2060 1.57 gdt KASSERT(cp->c_ovp != NULL);
2061 1.57 gdt
2062 1.59 gdt /* Munge the arg structure to refer to the container vnode. */
2063 1.25 chs ap->a_vp = cp->c_ovp;
2064 1.57 gdt
2065 1.58 gdt /* Get the lock on the container vnode, and call getpages on it. */
2066 1.66 ad mutex_enter(&ap->a_vp->v_uobj.vmobjlock);
2067 1.57 gdt error = VCALL(ap->a_vp, VOFFSET(vop_getpages), ap);
2068 1.57 gdt
2069 1.57 gdt /* If we opened the vnode, we must close it. */
2070 1.57 gdt if (didopen) {
2071 1.57 gdt /*
2072 1.57 gdt * VOP_CLOSE requires a locked vnode, but we are still
2073 1.58 gdt * holding the lock (or riding a caller's lock).
2074 1.57 gdt */
2075 1.63 pooka cerror = VOP_CLOSE(vp, FREAD, cred);
2076 1.57 gdt if (cerror != 0)
2077 1.57 gdt /* XXX How should we handle this? */
2078 1.57 gdt printf("coda_getpages: closed vnode %p -> %d\n",
2079 1.57 gdt vp, cerror);
2080 1.57 gdt
2081 1.58 gdt /* If we obtained a lock, drop it. */
2082 1.57 gdt if (waslocked == 0)
2083 1.68.12.4 yamt VOP_UNLOCK(vp);
2084 1.57 gdt }
2085 1.57 gdt
2086 1.25 chs return error;
2087 1.25 chs }
2088 1.25 chs
2089 1.57 gdt /*
2090 1.57 gdt * The protocol requires v_uobj.vmobjlock to be held by the caller, as
2091 1.59 gdt * documented in vnodeops(9). XXX vnode_if.src doesn't say this.
2092 1.57 gdt */
2093 1.25 chs int
2094 1.43 xtraeme coda_putpages(void *v)
2095 1.25 chs {
2096 1.25 chs struct vop_putpages_args /* {
2097 1.25 chs struct vnode *a_vp;
2098 1.25 chs voff_t a_offlo;
2099 1.25 chs voff_t a_offhi;
2100 1.25 chs int a_flags;
2101 1.25 chs } */ *ap = v;
2102 1.25 chs struct vnode *vp = ap->a_vp;
2103 1.57 gdt struct cnode *cp = VTOC(vp);
2104 1.57 gdt int error;
2105 1.25 chs
2106 1.59 gdt /* Drop the vmobject lock. */
2107 1.66 ad mutex_exit(&vp->v_uobj.vmobjlock);
2108 1.59 gdt
2109 1.25 chs /* Check for control object. */
2110 1.25 chs if (IS_CTL_VP(vp)) {
2111 1.57 gdt printf("coda_putpages: control object %p\n", vp);
2112 1.25 chs return(EINVAL);
2113 1.25 chs }
2114 1.25 chs
2115 1.25 chs /*
2116 1.57 gdt * If container object is not present, then there are no pages
2117 1.57 gdt * to put; just return without error. This happens all the
2118 1.57 gdt * time, apparently during discard of a closed vnode (which
2119 1.57 gdt * trivially can't have dirty pages).
2120 1.25 chs */
2121 1.58 gdt if (cp->c_ovp == NULL)
2122 1.57 gdt return 0;
2123 1.25 chs
2124 1.59 gdt /* Munge the arg structure to refer to the container vnode. */
2125 1.57 gdt ap->a_vp = cp->c_ovp;
2126 1.57 gdt
2127 1.58 gdt /* Get the lock on the container vnode, and call putpages on it. */
2128 1.66 ad mutex_enter(&ap->a_vp->v_uobj.vmobjlock);
2129 1.57 gdt error = VCALL(ap->a_vp, VOFFSET(vop_putpages), ap);
2130 1.57 gdt
2131 1.57 gdt return error;
2132 1.1 rvb }
2133