nfs_vnops.c revision 1.266.10.1 1 1.266.10.1 yamt /* $NetBSD: nfs_vnops.c,v 1.266.10.1 2008/04/27 12:52:50 yamt Exp $ */
2 1.34 cgd
3 1.1 cgd /*
4 1.32 mycroft * Copyright (c) 1989, 1993
5 1.32 mycroft * The Regents of the University of California. All rights reserved.
6 1.1 cgd *
7 1.1 cgd * This code is derived from software contributed to Berkeley by
8 1.1 cgd * Rick Macklem at The University of Guelph.
9 1.1 cgd *
10 1.1 cgd * Redistribution and use in source and binary forms, with or without
11 1.1 cgd * modification, are permitted provided that the following conditions
12 1.1 cgd * are met:
13 1.1 cgd * 1. Redistributions of source code must retain the above copyright
14 1.1 cgd * notice, this list of conditions and the following disclaimer.
15 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
16 1.1 cgd * notice, this list of conditions and the following disclaimer in the
17 1.1 cgd * documentation and/or other materials provided with the distribution.
18 1.177 agc * 3. Neither the name of the University nor the names of its contributors
19 1.1 cgd * may be used to endorse or promote products derived from this software
20 1.1 cgd * without specific prior written permission.
21 1.1 cgd *
22 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 1.1 cgd * SUCH DAMAGE.
33 1.1 cgd *
34 1.89 fvdl * @(#)nfs_vnops.c 8.19 (Berkeley) 7/31/95
35 1.1 cgd */
36 1.1 cgd
37 1.1 cgd /*
38 1.59 fvdl * vnode op calls for Sun NFS version 2 and 3
39 1.1 cgd */
40 1.143 lukem
41 1.143 lukem #include <sys/cdefs.h>
42 1.266.10.1 yamt __KERNEL_RCSID(0, "$NetBSD: nfs_vnops.c,v 1.266.10.1 2008/04/27 12:52:50 yamt Exp $");
43 1.1 cgd
44 1.205 yamt #include "opt_inet.h"
45 1.119 bjh21 #include "opt_nfs.h"
46 1.124 chs #include "opt_uvmhist.h"
47 1.119 bjh21
48 1.16 mycroft #include <sys/param.h>
49 1.16 mycroft #include <sys/proc.h>
50 1.16 mycroft #include <sys/kernel.h>
51 1.16 mycroft #include <sys/systm.h>
52 1.59 fvdl #include <sys/resourcevar.h>
53 1.16 mycroft #include <sys/mount.h>
54 1.16 mycroft #include <sys/buf.h>
55 1.253 yamt #include <sys/condvar.h>
56 1.232 blymn #include <sys/disk.h>
57 1.16 mycroft #include <sys/malloc.h>
58 1.264 yamt #include <sys/kmem.h>
59 1.16 mycroft #include <sys/mbuf.h>
60 1.253 yamt #include <sys/mutex.h>
61 1.16 mycroft #include <sys/namei.h>
62 1.16 mycroft #include <sys/vnode.h>
63 1.32 mycroft #include <sys/dirent.h>
64 1.59 fvdl #include <sys/fcntl.h>
65 1.147 lukem #include <sys/hash.h>
66 1.32 mycroft #include <sys/lockf.h>
67 1.75 mycroft #include <sys/stat.h>
68 1.95 kleink #include <sys/unistd.h>
69 1.236 elad #include <sys/kauth.h>
70 1.31 cgd
71 1.87 mrg #include <uvm/uvm_extern.h>
72 1.124 chs #include <uvm/uvm.h>
73 1.87 mrg
74 1.64 mycroft #include <miscfs/fifofs/fifo.h>
75 1.64 mycroft #include <miscfs/genfs/genfs.h>
76 1.244 yamt #include <miscfs/genfs/genfs_node.h>
77 1.32 mycroft #include <miscfs/specfs/specdev.h>
78 1.32 mycroft
79 1.32 mycroft #include <nfs/rpcv2.h>
80 1.59 fvdl #include <nfs/nfsproto.h>
81 1.16 mycroft #include <nfs/nfs.h>
82 1.16 mycroft #include <nfs/nfsnode.h>
83 1.16 mycroft #include <nfs/nfsmount.h>
84 1.16 mycroft #include <nfs/xdr_subs.h>
85 1.16 mycroft #include <nfs/nfsm_subs.h>
86 1.58 christos #include <nfs/nfs_var.h>
87 1.27 pk
88 1.59 fvdl #include <net/if.h>
89 1.59 fvdl #include <netinet/in.h>
90 1.59 fvdl #include <netinet/in_var.h>
91 1.1 cgd
92 1.1 cgd /*
93 1.1 cgd * Global vfs data structures for nfs
94 1.1 cgd */
95 1.58 christos int (**nfsv2_vnodeop_p) __P((void *));
96 1.127 jdolecek const struct vnodeopv_entry_desc nfsv2_vnodeop_entries[] = {
97 1.32 mycroft { &vop_default_desc, vn_default_error },
98 1.64 mycroft { &vop_lookup_desc, nfs_lookup }, /* lookup */
99 1.64 mycroft { &vop_create_desc, nfs_create }, /* create */
100 1.64 mycroft { &vop_mknod_desc, nfs_mknod }, /* mknod */
101 1.64 mycroft { &vop_open_desc, nfs_open }, /* open */
102 1.64 mycroft { &vop_close_desc, nfs_close }, /* close */
103 1.64 mycroft { &vop_access_desc, nfs_access }, /* access */
104 1.64 mycroft { &vop_getattr_desc, nfs_getattr }, /* getattr */
105 1.64 mycroft { &vop_setattr_desc, nfs_setattr }, /* setattr */
106 1.64 mycroft { &vop_read_desc, nfs_read }, /* read */
107 1.64 mycroft { &vop_write_desc, nfs_write }, /* write */
108 1.105 wrstuden { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */
109 1.64 mycroft { &vop_ioctl_desc, nfs_ioctl }, /* ioctl */
110 1.65 mycroft { &vop_poll_desc, nfs_poll }, /* poll */
111 1.156 jdolecek { &vop_kqfilter_desc, nfs_kqfilter }, /* kqfilter */
112 1.64 mycroft { &vop_revoke_desc, nfs_revoke }, /* revoke */
113 1.64 mycroft { &vop_mmap_desc, nfs_mmap }, /* mmap */
114 1.64 mycroft { &vop_fsync_desc, nfs_fsync }, /* fsync */
115 1.64 mycroft { &vop_seek_desc, nfs_seek }, /* seek */
116 1.64 mycroft { &vop_remove_desc, nfs_remove }, /* remove */
117 1.64 mycroft { &vop_link_desc, nfs_link }, /* link */
118 1.64 mycroft { &vop_rename_desc, nfs_rename }, /* rename */
119 1.64 mycroft { &vop_mkdir_desc, nfs_mkdir }, /* mkdir */
120 1.64 mycroft { &vop_rmdir_desc, nfs_rmdir }, /* rmdir */
121 1.64 mycroft { &vop_symlink_desc, nfs_symlink }, /* symlink */
122 1.64 mycroft { &vop_readdir_desc, nfs_readdir }, /* readdir */
123 1.64 mycroft { &vop_readlink_desc, nfs_readlink }, /* readlink */
124 1.64 mycroft { &vop_abortop_desc, nfs_abortop }, /* abortop */
125 1.64 mycroft { &vop_inactive_desc, nfs_inactive }, /* inactive */
126 1.64 mycroft { &vop_reclaim_desc, nfs_reclaim }, /* reclaim */
127 1.64 mycroft { &vop_lock_desc, nfs_lock }, /* lock */
128 1.64 mycroft { &vop_unlock_desc, nfs_unlock }, /* unlock */
129 1.64 mycroft { &vop_bmap_desc, nfs_bmap }, /* bmap */
130 1.64 mycroft { &vop_strategy_desc, nfs_strategy }, /* strategy */
131 1.64 mycroft { &vop_print_desc, nfs_print }, /* print */
132 1.64 mycroft { &vop_islocked_desc, nfs_islocked }, /* islocked */
133 1.64 mycroft { &vop_pathconf_desc, nfs_pathconf }, /* pathconf */
134 1.64 mycroft { &vop_advlock_desc, nfs_advlock }, /* advlock */
135 1.213 yamt { &vop_bwrite_desc, genfs_badop }, /* bwrite */
136 1.124 chs { &vop_getpages_desc, nfs_getpages }, /* getpages */
137 1.138 chs { &vop_putpages_desc, genfs_putpages }, /* putpages */
138 1.124 chs { NULL, NULL }
139 1.1 cgd };
140 1.127 jdolecek const struct vnodeopv_desc nfsv2_vnodeop_opv_desc =
141 1.32 mycroft { &nfsv2_vnodeop_p, nfsv2_vnodeop_entries };
142 1.1 cgd
143 1.1 cgd /*
144 1.1 cgd * Special device vnode ops
145 1.1 cgd */
146 1.58 christos int (**spec_nfsv2nodeop_p) __P((void *));
147 1.127 jdolecek const struct vnodeopv_entry_desc spec_nfsv2nodeop_entries[] = {
148 1.32 mycroft { &vop_default_desc, vn_default_error },
149 1.64 mycroft { &vop_lookup_desc, spec_lookup }, /* lookup */
150 1.64 mycroft { &vop_create_desc, spec_create }, /* create */
151 1.64 mycroft { &vop_mknod_desc, spec_mknod }, /* mknod */
152 1.64 mycroft { &vop_open_desc, spec_open }, /* open */
153 1.64 mycroft { &vop_close_desc, nfsspec_close }, /* close */
154 1.64 mycroft { &vop_access_desc, nfsspec_access }, /* access */
155 1.64 mycroft { &vop_getattr_desc, nfs_getattr }, /* getattr */
156 1.64 mycroft { &vop_setattr_desc, nfs_setattr }, /* setattr */
157 1.64 mycroft { &vop_read_desc, nfsspec_read }, /* read */
158 1.64 mycroft { &vop_write_desc, nfsspec_write }, /* write */
159 1.105 wrstuden { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */
160 1.64 mycroft { &vop_ioctl_desc, spec_ioctl }, /* ioctl */
161 1.65 mycroft { &vop_poll_desc, spec_poll }, /* poll */
162 1.156 jdolecek { &vop_kqfilter_desc, spec_kqfilter }, /* kqfilter */
163 1.64 mycroft { &vop_revoke_desc, spec_revoke }, /* revoke */
164 1.64 mycroft { &vop_mmap_desc, spec_mmap }, /* mmap */
165 1.124 chs { &vop_fsync_desc, spec_fsync }, /* fsync */
166 1.64 mycroft { &vop_seek_desc, spec_seek }, /* seek */
167 1.64 mycroft { &vop_remove_desc, spec_remove }, /* remove */
168 1.64 mycroft { &vop_link_desc, spec_link }, /* link */
169 1.64 mycroft { &vop_rename_desc, spec_rename }, /* rename */
170 1.64 mycroft { &vop_mkdir_desc, spec_mkdir }, /* mkdir */
171 1.64 mycroft { &vop_rmdir_desc, spec_rmdir }, /* rmdir */
172 1.64 mycroft { &vop_symlink_desc, spec_symlink }, /* symlink */
173 1.64 mycroft { &vop_readdir_desc, spec_readdir }, /* readdir */
174 1.64 mycroft { &vop_readlink_desc, spec_readlink }, /* readlink */
175 1.64 mycroft { &vop_abortop_desc, spec_abortop }, /* abortop */
176 1.64 mycroft { &vop_inactive_desc, nfs_inactive }, /* inactive */
177 1.64 mycroft { &vop_reclaim_desc, nfs_reclaim }, /* reclaim */
178 1.64 mycroft { &vop_lock_desc, nfs_lock }, /* lock */
179 1.64 mycroft { &vop_unlock_desc, nfs_unlock }, /* unlock */
180 1.64 mycroft { &vop_bmap_desc, spec_bmap }, /* bmap */
181 1.64 mycroft { &vop_strategy_desc, spec_strategy }, /* strategy */
182 1.64 mycroft { &vop_print_desc, nfs_print }, /* print */
183 1.64 mycroft { &vop_islocked_desc, nfs_islocked }, /* islocked */
184 1.64 mycroft { &vop_pathconf_desc, spec_pathconf }, /* pathconf */
185 1.64 mycroft { &vop_advlock_desc, spec_advlock }, /* advlock */
186 1.214 yamt { &vop_bwrite_desc, spec_bwrite }, /* bwrite */
187 1.137 chs { &vop_getpages_desc, spec_getpages }, /* getpages */
188 1.137 chs { &vop_putpages_desc, spec_putpages }, /* putpages */
189 1.124 chs { NULL, NULL }
190 1.1 cgd };
191 1.127 jdolecek const struct vnodeopv_desc spec_nfsv2nodeop_opv_desc =
192 1.32 mycroft { &spec_nfsv2nodeop_p, spec_nfsv2nodeop_entries };
193 1.1 cgd
194 1.58 christos int (**fifo_nfsv2nodeop_p) __P((void *));
195 1.127 jdolecek const struct vnodeopv_entry_desc fifo_nfsv2nodeop_entries[] = {
196 1.32 mycroft { &vop_default_desc, vn_default_error },
197 1.64 mycroft { &vop_lookup_desc, fifo_lookup }, /* lookup */
198 1.64 mycroft { &vop_create_desc, fifo_create }, /* create */
199 1.64 mycroft { &vop_mknod_desc, fifo_mknod }, /* mknod */
200 1.64 mycroft { &vop_open_desc, fifo_open }, /* open */
201 1.64 mycroft { &vop_close_desc, nfsfifo_close }, /* close */
202 1.64 mycroft { &vop_access_desc, nfsspec_access }, /* access */
203 1.64 mycroft { &vop_getattr_desc, nfs_getattr }, /* getattr */
204 1.64 mycroft { &vop_setattr_desc, nfs_setattr }, /* setattr */
205 1.64 mycroft { &vop_read_desc, nfsfifo_read }, /* read */
206 1.64 mycroft { &vop_write_desc, nfsfifo_write }, /* write */
207 1.105 wrstuden { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */
208 1.64 mycroft { &vop_ioctl_desc, fifo_ioctl }, /* ioctl */
209 1.65 mycroft { &vop_poll_desc, fifo_poll }, /* poll */
210 1.156 jdolecek { &vop_kqfilter_desc, fifo_kqfilter }, /* kqfilter */
211 1.64 mycroft { &vop_revoke_desc, fifo_revoke }, /* revoke */
212 1.64 mycroft { &vop_mmap_desc, fifo_mmap }, /* mmap */
213 1.64 mycroft { &vop_fsync_desc, nfs_fsync }, /* fsync */
214 1.64 mycroft { &vop_seek_desc, fifo_seek }, /* seek */
215 1.64 mycroft { &vop_remove_desc, fifo_remove }, /* remove */
216 1.64 mycroft { &vop_link_desc, fifo_link }, /* link */
217 1.64 mycroft { &vop_rename_desc, fifo_rename }, /* rename */
218 1.64 mycroft { &vop_mkdir_desc, fifo_mkdir }, /* mkdir */
219 1.64 mycroft { &vop_rmdir_desc, fifo_rmdir }, /* rmdir */
220 1.64 mycroft { &vop_symlink_desc, fifo_symlink }, /* symlink */
221 1.64 mycroft { &vop_readdir_desc, fifo_readdir }, /* readdir */
222 1.64 mycroft { &vop_readlink_desc, fifo_readlink }, /* readlink */
223 1.64 mycroft { &vop_abortop_desc, fifo_abortop }, /* abortop */
224 1.64 mycroft { &vop_inactive_desc, nfs_inactive }, /* inactive */
225 1.64 mycroft { &vop_reclaim_desc, nfs_reclaim }, /* reclaim */
226 1.64 mycroft { &vop_lock_desc, nfs_lock }, /* lock */
227 1.64 mycroft { &vop_unlock_desc, nfs_unlock }, /* unlock */
228 1.64 mycroft { &vop_bmap_desc, fifo_bmap }, /* bmap */
229 1.64 mycroft { &vop_strategy_desc, genfs_badop }, /* strategy */
230 1.64 mycroft { &vop_print_desc, nfs_print }, /* print */
231 1.64 mycroft { &vop_islocked_desc, nfs_islocked }, /* islocked */
232 1.64 mycroft { &vop_pathconf_desc, fifo_pathconf }, /* pathconf */
233 1.64 mycroft { &vop_advlock_desc, fifo_advlock }, /* advlock */
234 1.213 yamt { &vop_bwrite_desc, genfs_badop }, /* bwrite */
235 1.140 sommerfe { &vop_putpages_desc, fifo_putpages }, /* putpages */
236 1.124 chs { NULL, NULL }
237 1.1 cgd };
238 1.127 jdolecek const struct vnodeopv_desc fifo_nfsv2nodeop_opv_desc =
239 1.32 mycroft { &fifo_nfsv2nodeop_p, fifo_nfsv2nodeop_entries };
240 1.1 cgd
241 1.239 yamt static int nfs_linkrpc(struct vnode *, struct vnode *, const char *,
242 1.239 yamt size_t, kauth_cred_t, struct lwp *);
243 1.252 christos static void nfs_writerpc_extfree(struct mbuf *, void *, size_t, void *);
244 1.167 yamt
245 1.1 cgd /*
246 1.32 mycroft * Global variables
247 1.1 cgd */
248 1.59 fvdl extern u_int32_t nfs_true, nfs_false;
249 1.55 mycroft extern u_int32_t nfs_xdrneg1;
250 1.157 matt extern const nfstype nfsv3_type[9];
251 1.150 matt
252 1.1 cgd int nfs_numasync = 0;
253 1.225 christos #define DIRHDSIZ _DIRENT_NAMEOFF(dp)
254 1.225 christos #define UIO_ADVANCE(uio, siz) \
255 1.225 christos (void)((uio)->uio_resid -= (siz), \
256 1.225 christos (uio)->uio_iov->iov_base = (char *)(uio)->uio_iov->iov_base + (siz), \
257 1.225 christos (uio)->uio_iov->iov_len -= (siz))
258 1.1 cgd
259 1.188 yamt static void nfs_cache_enter(struct vnode *, struct vnode *,
260 1.188 yamt struct componentname *);
261 1.188 yamt
262 1.188 yamt static void
263 1.188 yamt nfs_cache_enter(struct vnode *dvp, struct vnode *vp,
264 1.188 yamt struct componentname *cnp)
265 1.188 yamt {
266 1.215 yamt struct nfsnode *dnp = VTONFS(dvp);
267 1.188 yamt
268 1.188 yamt if (vp != NULL) {
269 1.188 yamt struct nfsnode *np = VTONFS(vp);
270 1.188 yamt
271 1.188 yamt np->n_ctime = np->n_vattr->va_ctime.tv_sec;
272 1.215 yamt }
273 1.188 yamt
274 1.215 yamt if (!timespecisset(&dnp->n_nctime))
275 1.215 yamt dnp->n_nctime = dnp->n_vattr->va_mtime;
276 1.188 yamt
277 1.188 yamt cache_enter(dvp, vp, cnp);
278 1.188 yamt }
279 1.188 yamt
280 1.1 cgd /*
281 1.1 cgd * nfs null call from vfs.
282 1.1 cgd */
283 1.32 mycroft int
284 1.230 christos nfs_null(vp, cred, l)
285 1.1 cgd struct vnode *vp;
286 1.236 elad kauth_cred_t cred;
287 1.230 christos struct lwp *l;
288 1.1 cgd {
289 1.252 christos char *bpos, *dpos;
290 1.1 cgd int error = 0;
291 1.1 cgd struct mbuf *mreq, *mrep, *md, *mb;
292 1.165 drochner struct nfsnode *np = VTONFS(vp);
293 1.220 perry
294 1.165 drochner nfsm_reqhead(np, NFSPROC_NULL, 0);
295 1.230 christos nfsm_request(np, NFSPROC_NULL, l, cred);
296 1.1 cgd nfsm_reqdone;
297 1.1 cgd return (error);
298 1.1 cgd }
299 1.1 cgd
300 1.1 cgd /*
301 1.1 cgd * nfs access vnode op.
302 1.59 fvdl * For nfs version 2, just return ok. File accesses may fail later.
303 1.59 fvdl * For nfs version 3, use the access rpc to check accessibility. If file modes
304 1.59 fvdl * are changed on the server, accesses might still fail later.
305 1.1 cgd */
306 1.32 mycroft int
307 1.58 christos nfs_access(v)
308 1.58 christos void *v;
309 1.58 christos {
310 1.32 mycroft struct vop_access_args /* {
311 1.32 mycroft struct vnode *a_vp;
312 1.32 mycroft int a_mode;
313 1.236 elad kauth_cred_t a_cred;
314 1.58 christos } */ *ap = v;
315 1.110 augustss struct vnode *vp = ap->a_vp;
316 1.200 christos #ifndef NFS_V2_ONLY
317 1.110 augustss u_int32_t *tl;
318 1.252 christos char *cp;
319 1.110 augustss int32_t t1, t2;
320 1.252 christos char *bpos, *dpos, *cp2;
321 1.200 christos int error = 0, attrflag;
322 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
323 1.59 fvdl u_int32_t mode, rmode;
324 1.119 bjh21 const int v3 = NFS_ISV3(vp);
325 1.200 christos #endif
326 1.200 christos int cachevalid;
327 1.108 fvdl struct nfsnode *np = VTONFS(vp);
328 1.227 christos struct nfsmount *nmp = VFSTONFS(vp->v_mount);
329 1.266.10.1 yamt uid_t uid = kauth_cred_geteuid(ap->a_cred);
330 1.266.10.1 yamt int result;
331 1.108 fvdl
332 1.266.10.1 yamt mutex_enter(&np->n_attrlock);
333 1.266.10.1 yamt cachevalid = np->n_accstamp != -1 &&
334 1.257 yamt (time_uptime - np->n_accstamp) < nfs_attrtimeo(nmp, np) &&
335 1.266.10.1 yamt np->n_accuid == uid;
336 1.108 fvdl
337 1.108 fvdl /*
338 1.108 fvdl * Check access cache first. If this request has been made for this
339 1.108 fvdl * uid shortly before, use the cached result.
340 1.108 fvdl */
341 1.118 fvdl if (cachevalid) {
342 1.118 fvdl if (!np->n_accerror) {
343 1.266.10.1 yamt if ((np->n_accmode & ap->a_mode) == ap->a_mode) {
344 1.266.10.1 yamt result = np->n_accerror;
345 1.266.10.1 yamt mutex_exit(&np->n_attrlock);
346 1.266.10.1 yamt return result;
347 1.266.10.1 yamt }
348 1.266.10.1 yamt } else if ((np->n_accmode & ap->a_mode) == np->n_accmode) {
349 1.266.10.1 yamt result = np->n_accerror;
350 1.266.10.1 yamt mutex_exit(&np->n_attrlock);
351 1.266.10.1 yamt return result;
352 1.266.10.1 yamt }
353 1.118 fvdl }
354 1.266.10.1 yamt mutex_exit(&np->n_attrlock);
355 1.1 cgd
356 1.200 christos #ifndef NFS_V2_ONLY
357 1.1 cgd /*
358 1.59 fvdl * For nfs v3, do an access rpc, otherwise you are stuck emulating
359 1.32 mycroft * ufs_access() locally using the vattr. This may not be correct,
360 1.32 mycroft * since the server may apply other access criteria such as
361 1.32 mycroft * client uid-->server uid mapping that we do not know about, but
362 1.32 mycroft * this is better than just returning anything that is lying about
363 1.32 mycroft * in the cache.
364 1.32 mycroft */
365 1.59 fvdl if (v3) {
366 1.59 fvdl nfsstats.rpccnt[NFSPROC_ACCESS]++;
367 1.165 drochner nfsm_reqhead(np, NFSPROC_ACCESS, NFSX_FH(v3) + NFSX_UNSIGNED);
368 1.165 drochner nfsm_fhtom(np, v3);
369 1.59 fvdl nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
370 1.32 mycroft if (ap->a_mode & VREAD)
371 1.59 fvdl mode = NFSV3ACCESS_READ;
372 1.32 mycroft else
373 1.59 fvdl mode = 0;
374 1.74 mycroft if (vp->v_type != VDIR) {
375 1.74 mycroft if (ap->a_mode & VWRITE)
376 1.74 mycroft mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
377 1.74 mycroft if (ap->a_mode & VEXEC)
378 1.74 mycroft mode |= NFSV3ACCESS_EXECUTE;
379 1.74 mycroft } else {
380 1.59 fvdl if (ap->a_mode & VWRITE)
381 1.59 fvdl mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
382 1.59 fvdl NFSV3ACCESS_DELETE);
383 1.74 mycroft if (ap->a_mode & VEXEC)
384 1.59 fvdl mode |= NFSV3ACCESS_LOOKUP;
385 1.59 fvdl }
386 1.59 fvdl *tl = txdr_unsigned(mode);
387 1.260 pooka nfsm_request(np, NFSPROC_ACCESS, curlwp, ap->a_cred);
388 1.153 yamt nfsm_postop_attr(vp, attrflag, 0);
389 1.59 fvdl if (!error) {
390 1.59 fvdl nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
391 1.59 fvdl rmode = fxdr_unsigned(u_int32_t, *tl);
392 1.59 fvdl /*
393 1.59 fvdl * The NFS V3 spec does not clarify whether or not
394 1.59 fvdl * the returned access bits can be a superset of
395 1.59 fvdl * the ones requested, so...
396 1.59 fvdl */
397 1.59 fvdl if ((rmode & mode) != mode)
398 1.59 fvdl error = EACCES;
399 1.59 fvdl }
400 1.32 mycroft nfsm_reqdone;
401 1.32 mycroft } else
402 1.200 christos #endif
403 1.32 mycroft return (nfsspec_access(ap));
404 1.200 christos #ifndef NFS_V2_ONLY
405 1.71 fvdl /*
406 1.71 fvdl * Disallow write attempts on filesystems mounted read-only;
407 1.71 fvdl * unless the file is a socket, fifo, or a block or character
408 1.71 fvdl * device resident on the filesystem.
409 1.71 fvdl */
410 1.108 fvdl if (!error && (ap->a_mode & VWRITE) &&
411 1.108 fvdl (vp->v_mount->mnt_flag & MNT_RDONLY)) {
412 1.71 fvdl switch (vp->v_type) {
413 1.71 fvdl case VREG:
414 1.71 fvdl case VDIR:
415 1.71 fvdl case VLNK:
416 1.108 fvdl error = EROFS;
417 1.71 fvdl default:
418 1.71 fvdl break;
419 1.71 fvdl }
420 1.71 fvdl }
421 1.108 fvdl
422 1.108 fvdl if (!error || error == EACCES) {
423 1.266.10.1 yamt mutex_enter(&np->n_attrlock);
424 1.108 fvdl /*
425 1.108 fvdl * If we got the same result as for a previous,
426 1.108 fvdl * different request, OR it in. Don't update
427 1.108 fvdl * the timestamp in that case.
428 1.108 fvdl */
429 1.149 fvdl if (cachevalid && np->n_accstamp != -1 &&
430 1.149 fvdl error == np->n_accerror) {
431 1.118 fvdl if (!error)
432 1.118 fvdl np->n_accmode |= ap->a_mode;
433 1.118 fvdl else if ((np->n_accmode & ap->a_mode) == ap->a_mode)
434 1.118 fvdl np->n_accmode = ap->a_mode;
435 1.118 fvdl } else {
436 1.237 kardel np->n_accstamp = time_uptime;
437 1.236 elad np->n_accuid = kauth_cred_geteuid(ap->a_cred);
438 1.108 fvdl np->n_accmode = ap->a_mode;
439 1.108 fvdl np->n_accerror = error;
440 1.108 fvdl }
441 1.266.10.1 yamt mutex_exit(&np->n_attrlock);
442 1.108 fvdl }
443 1.108 fvdl
444 1.108 fvdl return (error);
445 1.200 christos #endif
446 1.1 cgd }
447 1.1 cgd
448 1.1 cgd /*
449 1.1 cgd * nfs open vnode op
450 1.32 mycroft * Check to see if the type is ok
451 1.32 mycroft * and that deletion is not in progress.
452 1.32 mycroft * For paged in text files, you will need to flush the page cache
453 1.32 mycroft * if consistency is lost.
454 1.1 cgd */
455 1.1 cgd /* ARGSUSED */
456 1.32 mycroft int
457 1.58 christos nfs_open(v)
458 1.58 christos void *v;
459 1.58 christos {
460 1.32 mycroft struct vop_open_args /* {
461 1.32 mycroft struct vnode *a_vp;
462 1.32 mycroft int a_mode;
463 1.236 elad kauth_cred_t a_cred;
464 1.58 christos } */ *ap = v;
465 1.110 augustss struct vnode *vp = ap->a_vp;
466 1.32 mycroft struct nfsnode *np = VTONFS(vp);
467 1.32 mycroft int error;
468 1.1 cgd
469 1.59 fvdl if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK) {
470 1.1 cgd return (EACCES);
471 1.59 fvdl }
472 1.124 chs
473 1.126 chs if (ap->a_mode & FREAD) {
474 1.184 fvdl if (np->n_rcred != NULL)
475 1.236 elad kauth_cred_free(np->n_rcred);
476 1.126 chs np->n_rcred = ap->a_cred;
477 1.236 elad kauth_cred_hold(np->n_rcred);
478 1.126 chs }
479 1.125 chs if (ap->a_mode & FWRITE) {
480 1.184 fvdl if (np->n_wcred != NULL)
481 1.236 elad kauth_cred_free(np->n_wcred);
482 1.125 chs np->n_wcred = ap->a_cred;
483 1.236 elad kauth_cred_hold(np->n_wcred);
484 1.125 chs }
485 1.125 chs
486 1.260 pooka error = nfs_flushstalebuf(vp, ap->a_cred, curlwp, 0);
487 1.247 yamt if (error)
488 1.247 yamt return error;
489 1.247 yamt
490 1.247 yamt NFS_INVALIDATE_ATTRCACHE(np); /* For Open/Close consistency */
491 1.247 yamt
492 1.32 mycroft return (0);
493 1.1 cgd }
494 1.1 cgd
495 1.1 cgd /*
496 1.1 cgd * nfs close vnode op
497 1.59 fvdl * What an NFS client should do upon close after writing is a debatable issue.
498 1.59 fvdl * Most NFS clients push delayed writes to the server upon close, basically for
499 1.59 fvdl * two reasons:
500 1.59 fvdl * 1 - So that any write errors may be reported back to the client process
501 1.59 fvdl * doing the close system call. By far the two most likely errors are
502 1.59 fvdl * NFSERR_NOSPC and NFSERR_DQUOT to indicate space allocation failure.
503 1.59 fvdl * 2 - To put a worst case upper bound on cache inconsistency between
504 1.59 fvdl * multiple clients for the file.
505 1.59 fvdl * There is also a consistency problem for Version 2 of the protocol w.r.t.
506 1.59 fvdl * not being able to tell if other clients are writing a file concurrently,
507 1.59 fvdl * since there is no way of knowing if the changed modify time in the reply
508 1.59 fvdl * is only due to the write for this client.
509 1.59 fvdl * (NFS Version 3 provides weak cache consistency data in the reply that
510 1.59 fvdl * should be sufficient to detect and handle this case.)
511 1.59 fvdl *
512 1.59 fvdl * The current code does the following:
513 1.59 fvdl * for NFS Version 2 - play it safe and flush/invalidate all dirty buffers
514 1.59 fvdl * for NFS Version 3 - flush dirty buffers to the server but don't invalidate
515 1.59 fvdl * or commit them (this satisfies 1 and 2 except for the
516 1.59 fvdl * case where the server crashes after this close but
517 1.59 fvdl * before the commit RPC, which is felt to be "good
518 1.59 fvdl * enough". Changing the last argument to nfs_flush() to
519 1.59 fvdl * a 1 would force a commit operation, if it is felt a
520 1.59 fvdl * commit is necessary now.
521 1.1 cgd */
522 1.1 cgd /* ARGSUSED */
523 1.32 mycroft int
524 1.58 christos nfs_close(v)
525 1.58 christos void *v;
526 1.58 christos {
527 1.32 mycroft struct vop_close_args /* {
528 1.32 mycroft struct vnodeop_desc *a_desc;
529 1.32 mycroft struct vnode *a_vp;
530 1.32 mycroft int a_fflag;
531 1.236 elad kauth_cred_t a_cred;
532 1.58 christos } */ *ap = v;
533 1.110 augustss struct vnode *vp = ap->a_vp;
534 1.110 augustss struct nfsnode *np = VTONFS(vp);
535 1.1 cgd int error = 0;
536 1.124 chs UVMHIST_FUNC("nfs_close"); UVMHIST_CALLED(ubchist);
537 1.1 cgd
538 1.32 mycroft if (vp->v_type == VREG) {
539 1.248 yamt if (np->n_flag & NMODIFIED) {
540 1.200 christos #ifndef NFS_V2_ONLY
541 1.59 fvdl if (NFS_ISV3(vp)) {
542 1.260 pooka error = nfs_flush(vp, ap->a_cred, MNT_WAIT, curlwp, 0);
543 1.59 fvdl np->n_flag &= ~NMODIFIED;
544 1.59 fvdl } else
545 1.200 christos #endif
546 1.260 pooka error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, curlwp, 1);
547 1.185 yamt NFS_INVALIDATE_ATTRCACHE(np);
548 1.32 mycroft }
549 1.32 mycroft if (np->n_flag & NWRITEERR) {
550 1.32 mycroft np->n_flag &= ~NWRITEERR;
551 1.32 mycroft error = np->n_error;
552 1.32 mycroft }
553 1.1 cgd }
554 1.124 chs UVMHIST_LOG(ubchist, "returning %d", error,0,0,0);
555 1.1 cgd return (error);
556 1.1 cgd }
557 1.1 cgd
558 1.1 cgd /*
559 1.1 cgd * nfs getattr call from vfs.
560 1.1 cgd */
561 1.32 mycroft int
562 1.58 christos nfs_getattr(v)
563 1.58 christos void *v;
564 1.58 christos {
565 1.32 mycroft struct vop_getattr_args /* {
566 1.32 mycroft struct vnode *a_vp;
567 1.32 mycroft struct vattr *a_vap;
568 1.236 elad kauth_cred_t a_cred;
569 1.58 christos } */ *ap = v;
570 1.110 augustss struct vnode *vp = ap->a_vp;
571 1.110 augustss struct nfsnode *np = VTONFS(vp);
572 1.252 christos char *cp;
573 1.110 augustss u_int32_t *tl;
574 1.110 augustss int32_t t1, t2;
575 1.252 christos char *bpos, *dpos;
576 1.1 cgd int error = 0;
577 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
578 1.119 bjh21 const int v3 = NFS_ISV3(vp);
579 1.220 perry
580 1.32 mycroft /*
581 1.32 mycroft * Update local times for special files.
582 1.32 mycroft */
583 1.32 mycroft if (np->n_flag & (NACC | NUPD))
584 1.32 mycroft np->n_flag |= NCHG;
585 1.181 yamt
586 1.181 yamt /*
587 1.181 yamt * if we have delayed truncation, do it now.
588 1.181 yamt */
589 1.181 yamt nfs_delayedtruncate(vp);
590 1.181 yamt
591 1.32 mycroft /*
592 1.32 mycroft * First look in the cache.
593 1.32 mycroft */
594 1.32 mycroft if (nfs_getattrcache(vp, ap->a_vap) == 0)
595 1.1 cgd return (0);
596 1.1 cgd nfsstats.rpccnt[NFSPROC_GETATTR]++;
597 1.165 drochner nfsm_reqhead(np, NFSPROC_GETATTR, NFSX_FH(v3));
598 1.165 drochner nfsm_fhtom(np, v3);
599 1.260 pooka nfsm_request(np, NFSPROC_GETATTR, curlwp, ap->a_cred);
600 1.81 fvdl if (!error) {
601 1.153 yamt nfsm_loadattr(vp, ap->a_vap, 0);
602 1.81 fvdl if (vp->v_type == VDIR &&
603 1.81 fvdl ap->a_vap->va_blocksize < NFS_DIRFRAGSIZ)
604 1.81 fvdl ap->a_vap->va_blocksize = NFS_DIRFRAGSIZ;
605 1.81 fvdl }
606 1.1 cgd nfsm_reqdone;
607 1.1 cgd return (error);
608 1.1 cgd }
609 1.1 cgd
610 1.1 cgd /*
611 1.1 cgd * nfs setattr call.
612 1.1 cgd */
613 1.32 mycroft int
614 1.58 christos nfs_setattr(v)
615 1.58 christos void *v;
616 1.58 christos {
617 1.32 mycroft struct vop_setattr_args /* {
618 1.32 mycroft struct vnodeop_desc *a_desc;
619 1.32 mycroft struct vnode *a_vp;
620 1.32 mycroft struct vattr *a_vap;
621 1.236 elad kauth_cred_t a_cred;
622 1.58 christos } */ *ap = v;
623 1.110 augustss struct vnode *vp = ap->a_vp;
624 1.110 augustss struct nfsnode *np = VTONFS(vp);
625 1.110 augustss struct vattr *vap = ap->a_vap;
626 1.59 fvdl int error = 0;
627 1.59 fvdl u_quad_t tsize = 0;
628 1.1 cgd
629 1.59 fvdl /*
630 1.71 fvdl * Setting of flags is not supported.
631 1.71 fvdl */
632 1.71 fvdl if (vap->va_flags != VNOVAL)
633 1.71 fvdl return (EOPNOTSUPP);
634 1.71 fvdl
635 1.71 fvdl /*
636 1.59 fvdl * Disallow write attempts if the filesystem is mounted read-only.
637 1.59 fvdl */
638 1.71 fvdl if ((vap->va_uid != (uid_t)VNOVAL ||
639 1.59 fvdl vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
640 1.59 fvdl vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) &&
641 1.59 fvdl (vp->v_mount->mnt_flag & MNT_RDONLY))
642 1.59 fvdl return (EROFS);
643 1.35 mycroft if (vap->va_size != VNOVAL) {
644 1.266 yamt if (vap->va_size > VFSTONFS(vp->v_mount)->nm_maxfilesize) {
645 1.266 yamt return EFBIG;
646 1.266 yamt }
647 1.59 fvdl switch (vp->v_type) {
648 1.59 fvdl case VDIR:
649 1.59 fvdl return (EISDIR);
650 1.59 fvdl case VCHR:
651 1.59 fvdl case VBLK:
652 1.59 fvdl case VSOCK:
653 1.59 fvdl case VFIFO:
654 1.56 jtc if (vap->va_mtime.tv_sec == VNOVAL &&
655 1.56 jtc vap->va_atime.tv_sec == VNOVAL &&
656 1.84 christos vap->va_mode == (mode_t)VNOVAL &&
657 1.59 fvdl vap->va_uid == (uid_t)VNOVAL &&
658 1.59 fvdl vap->va_gid == (gid_t)VNOVAL)
659 1.35 mycroft return (0);
660 1.59 fvdl vap->va_size = VNOVAL;
661 1.59 fvdl break;
662 1.59 fvdl default:
663 1.59 fvdl /*
664 1.59 fvdl * Disallow write attempts if the filesystem is
665 1.59 fvdl * mounted read-only.
666 1.59 fvdl */
667 1.59 fvdl if (vp->v_mount->mnt_flag & MNT_RDONLY)
668 1.59 fvdl return (EROFS);
669 1.244 yamt genfs_node_wrlock(vp);
670 1.87 mrg uvm_vnp_setsize(vp, vap->va_size);
671 1.148 fvdl tsize = np->n_size;
672 1.148 fvdl np->n_size = vap->va_size;
673 1.59 fvdl if (vap->va_size == 0)
674 1.59 fvdl error = nfs_vinvalbuf(vp, 0,
675 1.260 pooka ap->a_cred, curlwp, 1);
676 1.59 fvdl else
677 1.59 fvdl error = nfs_vinvalbuf(vp, V_SAVE,
678 1.260 pooka ap->a_cred, curlwp, 1);
679 1.71 fvdl if (error) {
680 1.148 fvdl uvm_vnp_setsize(vp, tsize);
681 1.244 yamt genfs_node_unlock(vp);
682 1.59 fvdl return (error);
683 1.71 fvdl }
684 1.148 fvdl np->n_vattr->va_size = vap->va_size;
685 1.71 fvdl }
686 1.242 drochner } else {
687 1.242 drochner /*
688 1.242 drochner * flush files before setattr because a later write of
689 1.242 drochner * cached data might change timestamps or reset sugid bits
690 1.242 drochner */
691 1.242 drochner if ((vap->va_mtime.tv_sec != VNOVAL ||
692 1.242 drochner vap->va_atime.tv_sec != VNOVAL ||
693 1.242 drochner vap->va_mode != VNOVAL) &&
694 1.242 drochner vp->v_type == VREG &&
695 1.242 drochner (error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
696 1.260 pooka curlwp, 1)) == EINTR)
697 1.242 drochner return (error);
698 1.242 drochner }
699 1.260 pooka error = nfs_setattrrpc(vp, vap, ap->a_cred, curlwp);
700 1.244 yamt if (vap->va_size != VNOVAL) {
701 1.244 yamt if (error) {
702 1.244 yamt np->n_size = np->n_vattr->va_size = tsize;
703 1.244 yamt uvm_vnp_setsize(vp, np->n_size);
704 1.244 yamt }
705 1.244 yamt genfs_node_unlock(vp);
706 1.32 mycroft }
707 1.156 jdolecek VN_KNOTE(vp, NOTE_ATTRIB);
708 1.59 fvdl return (error);
709 1.59 fvdl }
710 1.59 fvdl
711 1.59 fvdl /*
712 1.59 fvdl * Do an nfs setattr rpc.
713 1.59 fvdl */
714 1.59 fvdl int
715 1.230 christos nfs_setattrrpc(vp, vap, cred, l)
716 1.110 augustss struct vnode *vp;
717 1.110 augustss struct vattr *vap;
718 1.236 elad kauth_cred_t cred;
719 1.230 christos struct lwp *l;
720 1.59 fvdl {
721 1.110 augustss struct nfsv2_sattr *sp;
722 1.252 christos char *cp;
723 1.110 augustss int32_t t1, t2;
724 1.252 christos char *bpos, *dpos;
725 1.59 fvdl u_int32_t *tl;
726 1.200 christos int error = 0;
727 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
728 1.119 bjh21 const int v3 = NFS_ISV3(vp);
729 1.165 drochner struct nfsnode *np = VTONFS(vp);
730 1.200 christos #ifndef NFS_V2_ONLY
731 1.200 christos int wccflag = NFSV3_WCCRATTR;
732 1.252 christos char *cp2;
733 1.200 christos #endif
734 1.59 fvdl
735 1.1 cgd nfsstats.rpccnt[NFSPROC_SETATTR]++;
736 1.165 drochner nfsm_reqhead(np, NFSPROC_SETATTR, NFSX_FH(v3) + NFSX_SATTR(v3));
737 1.165 drochner nfsm_fhtom(np, v3);
738 1.200 christos #ifndef NFS_V2_ONLY
739 1.59 fvdl if (v3) {
740 1.251 thorpej nfsm_v3attrbuild(vap, true);
741 1.59 fvdl nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
742 1.59 fvdl *tl = nfs_false;
743 1.24 mycroft } else {
744 1.200 christos #endif
745 1.59 fvdl nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
746 1.84 christos if (vap->va_mode == (mode_t)VNOVAL)
747 1.59 fvdl sp->sa_mode = nfs_xdrneg1;
748 1.59 fvdl else
749 1.59 fvdl sp->sa_mode = vtonfsv2_mode(vp->v_type, vap->va_mode);
750 1.59 fvdl if (vap->va_uid == (uid_t)VNOVAL)
751 1.59 fvdl sp->sa_uid = nfs_xdrneg1;
752 1.59 fvdl else
753 1.59 fvdl sp->sa_uid = txdr_unsigned(vap->va_uid);
754 1.59 fvdl if (vap->va_gid == (gid_t)VNOVAL)
755 1.59 fvdl sp->sa_gid = nfs_xdrneg1;
756 1.59 fvdl else
757 1.59 fvdl sp->sa_gid = txdr_unsigned(vap->va_gid);
758 1.59 fvdl sp->sa_size = txdr_unsigned(vap->va_size);
759 1.59 fvdl txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
760 1.59 fvdl txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
761 1.200 christos #ifndef NFS_V2_ONLY
762 1.59 fvdl }
763 1.200 christos #endif
764 1.230 christos nfsm_request(np, NFSPROC_SETATTR, l, cred);
765 1.200 christos #ifndef NFS_V2_ONLY
766 1.59 fvdl if (v3) {
767 1.251 thorpej nfsm_wcc_data(vp, wccflag, NAC_NOTRUNC, false);
768 1.59 fvdl } else
769 1.200 christos #endif
770 1.244 yamt nfsm_loadattr(vp, (struct vattr *)0, NAC_NOTRUNC);
771 1.32 mycroft nfsm_reqdone;
772 1.1 cgd return (error);
773 1.1 cgd }
774 1.1 cgd
775 1.1 cgd /*
776 1.1 cgd * nfs lookup call, one step at a time...
777 1.1 cgd * First look in cache
778 1.1 cgd * If not found, unlock the directory nfsnode and do the rpc
779 1.128 fvdl *
780 1.128 fvdl * This code is full of lock/unlock statements and checks, because
781 1.128 fvdl * we continue after cache_lookup has finished (we need to check
782 1.128 fvdl * with the attr cache and do an rpc if it has timed out). This means
783 1.128 fvdl * that the locking effects of cache_lookup have to be taken into
784 1.128 fvdl * account.
785 1.1 cgd */
786 1.32 mycroft int
787 1.58 christos nfs_lookup(v)
788 1.58 christos void *v;
789 1.58 christos {
790 1.32 mycroft struct vop_lookup_args /* {
791 1.32 mycroft struct vnodeop_desc *a_desc;
792 1.32 mycroft struct vnode *a_dvp;
793 1.32 mycroft struct vnode **a_vpp;
794 1.32 mycroft struct componentname *a_cnp;
795 1.58 christos } */ *ap = v;
796 1.89 fvdl struct componentname *cnp = ap->a_cnp;
797 1.89 fvdl struct vnode *dvp = ap->a_dvp;
798 1.89 fvdl struct vnode **vpp = ap->a_vpp;
799 1.102 wrstuden int flags;
800 1.89 fvdl struct vnode *newvp;
801 1.89 fvdl u_int32_t *tl;
802 1.252 christos char *cp;
803 1.89 fvdl int32_t t1, t2;
804 1.252 christos char *bpos, *dpos, *cp2;
805 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
806 1.1 cgd long len;
807 1.59 fvdl nfsfh_t *fhp;
808 1.1 cgd struct nfsnode *np;
809 1.246 chs int error = 0, attrflag, fhsize;
810 1.119 bjh21 const int v3 = NFS_ISV3(dvp);
811 1.128 fvdl
812 1.102 wrstuden flags = cnp->cn_flags;
813 1.1 cgd
814 1.60 jtk *vpp = NULLVP;
815 1.128 fvdl newvp = NULLVP;
816 1.59 fvdl if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
817 1.59 fvdl (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
818 1.59 fvdl return (EROFS);
819 1.32 mycroft if (dvp->v_type != VDIR)
820 1.1 cgd return (ENOTDIR);
821 1.108 fvdl
822 1.198 yamt /*
823 1.198 yamt * RFC1813(nfsv3) 3.2 says clients should handle "." by themselves.
824 1.198 yamt */
825 1.198 yamt if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
826 1.260 pooka error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
827 1.198 yamt if (error)
828 1.198 yamt return error;
829 1.198 yamt if (cnp->cn_nameiop == RENAME && (flags & ISLASTCN))
830 1.198 yamt return EISDIR;
831 1.198 yamt VREF(dvp);
832 1.198 yamt *vpp = dvp;
833 1.198 yamt if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
834 1.259 yamt cnp->cn_flags |= SAVENAME;
835 1.198 yamt return 0;
836 1.198 yamt }
837 1.198 yamt
838 1.32 mycroft np = VTONFS(dvp);
839 1.106 jdolecek
840 1.106 jdolecek /*
841 1.106 jdolecek * Before tediously performing a linear scan of the directory,
842 1.106 jdolecek * check the name cache to see if the directory/name pair
843 1.106 jdolecek * we are looking for is known already.
844 1.106 jdolecek * If the directory/name pair is found in the name cache,
845 1.106 jdolecek * we have to ensure the directory has not changed from
846 1.106 jdolecek * the time the cache entry has been created. If it has,
847 1.220 perry * the cache entry has to be ignored.
848 1.106 jdolecek */
849 1.203 yamt error = cache_lookup_raw(dvp, vpp, cnp);
850 1.203 yamt KASSERT(dvp != *vpp);
851 1.203 yamt if (error >= 0) {
852 1.1 cgd struct vattr vattr;
853 1.108 fvdl int err2;
854 1.108 fvdl
855 1.108 fvdl if (error && error != ENOENT) {
856 1.108 fvdl *vpp = NULLVP;
857 1.128 fvdl return error;
858 1.128 fvdl }
859 1.128 fvdl
860 1.260 pooka err2 = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
861 1.131 fvdl if (err2 != 0) {
862 1.203 yamt if (error == 0)
863 1.203 yamt vrele(*vpp);
864 1.108 fvdl *vpp = NULLVP;
865 1.128 fvdl return err2;
866 1.108 fvdl }
867 1.1 cgd
868 1.260 pooka if (VOP_GETATTR(dvp, &vattr, cnp->cn_cred)
869 1.260 pooka || timespeccmp(&vattr.va_mtime,
870 1.215 yamt &VTONFS(dvp)->n_nctime, !=)) {
871 1.215 yamt if (error == 0) {
872 1.215 yamt vrele(*vpp);
873 1.215 yamt *vpp = NULLVP;
874 1.203 yamt }
875 1.187 yamt cache_purge1(dvp, NULL, PURGE_CHILDREN);
876 1.178 yamt timespecclear(&np->n_nctime);
877 1.82 fvdl goto dorpc;
878 1.82 fvdl }
879 1.82 fvdl
880 1.215 yamt if (error == ENOENT) {
881 1.215 yamt goto noentry;
882 1.215 yamt }
883 1.215 yamt
884 1.59 fvdl newvp = *vpp;
885 1.260 pooka if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred)
886 1.203 yamt && vattr.va_ctime.tv_sec == VTONFS(newvp)->n_ctime) {
887 1.106 jdolecek nfsstats.lookupcache_hits++;
888 1.246 chs if ((flags & ISDOTDOT) != 0) {
889 1.128 fvdl VOP_UNLOCK(dvp, 0);
890 1.202 yamt }
891 1.203 yamt error = vn_lock(newvp, LK_EXCLUSIVE);
892 1.246 chs if ((flags & ISDOTDOT) != 0) {
893 1.246 chs vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
894 1.246 chs }
895 1.203 yamt if (error) {
896 1.203 yamt /* newvp has been revoked. */
897 1.203 yamt vrele(newvp);
898 1.203 yamt *vpp = NULL;
899 1.203 yamt return error;
900 1.203 yamt }
901 1.203 yamt if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
902 1.203 yamt cnp->cn_flags |= SAVENAME;
903 1.190 yamt KASSERT(newvp->v_type != VNON);
904 1.106 jdolecek return (0);
905 1.1 cgd }
906 1.187 yamt cache_purge1(newvp, NULL, PURGE_PARENTS);
907 1.203 yamt vrele(newvp);
908 1.32 mycroft *vpp = NULLVP;
909 1.32 mycroft }
910 1.82 fvdl dorpc:
911 1.199 yamt #if 0
912 1.192 yamt /*
913 1.192 yamt * because nfsv3 has the same CREATE semantics as ours,
914 1.192 yamt * we don't have to perform LOOKUPs beforehand.
915 1.192 yamt *
916 1.192 yamt * XXX ideally we can do the same for nfsv2 in the case of !O_EXCL.
917 1.192 yamt * XXX although we have no way to know if O_EXCL is requested or not.
918 1.192 yamt */
919 1.192 yamt
920 1.196 yamt if (v3 && cnp->cn_nameiop == CREATE &&
921 1.196 yamt (flags & (ISLASTCN|ISDOTDOT)) == ISLASTCN &&
922 1.193 yamt (dvp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
923 1.192 yamt cnp->cn_flags |= SAVENAME;
924 1.192 yamt return (EJUSTRETURN);
925 1.192 yamt }
926 1.199 yamt #endif /* 0 */
927 1.192 yamt
928 1.1 cgd error = 0;
929 1.59 fvdl newvp = NULLVP;
930 1.1 cgd nfsstats.lookupcache_misses++;
931 1.1 cgd nfsstats.rpccnt[NFSPROC_LOOKUP]++;
932 1.32 mycroft len = cnp->cn_namelen;
933 1.165 drochner nfsm_reqhead(np, NFSPROC_LOOKUP,
934 1.59 fvdl NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
935 1.165 drochner nfsm_fhtom(np, v3);
936 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
937 1.261 pooka nfsm_request(np, NFSPROC_LOOKUP, curlwp, cnp->cn_cred);
938 1.1 cgd if (error) {
939 1.153 yamt nfsm_postop_attr(dvp, attrflag, 0);
940 1.59 fvdl m_freem(mrep);
941 1.59 fvdl goto nfsmout;
942 1.32 mycroft }
943 1.59 fvdl nfsm_getfh(fhp, fhsize, v3);
944 1.1 cgd
945 1.1 cgd /*
946 1.32 mycroft * Handle RENAME case...
947 1.1 cgd */
948 1.246 chs if (cnp->cn_nameiop == RENAME && (flags & ISLASTCN)) {
949 1.59 fvdl if (NFS_CMPFH(np, fhp, fhsize)) {
950 1.1 cgd m_freem(mrep);
951 1.1 cgd return (EISDIR);
952 1.1 cgd }
953 1.175 fvdl error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
954 1.59 fvdl if (error) {
955 1.1 cgd m_freem(mrep);
956 1.128 fvdl return error;
957 1.1 cgd }
958 1.1 cgd newvp = NFSTOV(np);
959 1.200 christos #ifndef NFS_V2_ONLY
960 1.59 fvdl if (v3) {
961 1.153 yamt nfsm_postop_attr(newvp, attrflag, 0);
962 1.153 yamt nfsm_postop_attr(dvp, attrflag, 0);
963 1.59 fvdl } else
964 1.200 christos #endif
965 1.153 yamt nfsm_loadattr(newvp, (struct vattr *)0, 0);
966 1.32 mycroft *vpp = newvp;
967 1.1 cgd m_freem(mrep);
968 1.32 mycroft cnp->cn_flags |= SAVENAME;
969 1.190 yamt goto validate;
970 1.1 cgd }
971 1.1 cgd
972 1.128 fvdl /*
973 1.128 fvdl * The postop attr handling is duplicated for each if case,
974 1.128 fvdl * because it should be done while dvp is locked (unlocking
975 1.128 fvdl * dvp is different for each case).
976 1.128 fvdl */
977 1.128 fvdl
978 1.59 fvdl if (NFS_CMPFH(np, fhp, fhsize)) {
979 1.128 fvdl /*
980 1.128 fvdl * "." lookup
981 1.128 fvdl */
982 1.32 mycroft VREF(dvp);
983 1.32 mycroft newvp = dvp;
984 1.200 christos #ifndef NFS_V2_ONLY
985 1.128 fvdl if (v3) {
986 1.153 yamt nfsm_postop_attr(newvp, attrflag, 0);
987 1.153 yamt nfsm_postop_attr(dvp, attrflag, 0);
988 1.128 fvdl } else
989 1.200 christos #endif
990 1.153 yamt nfsm_loadattr(newvp, (struct vattr *)0, 0);
991 1.128 fvdl } else if (flags & ISDOTDOT) {
992 1.128 fvdl /*
993 1.128 fvdl * ".." lookup
994 1.128 fvdl */
995 1.128 fvdl VOP_UNLOCK(dvp, 0);
996 1.175 fvdl error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
997 1.246 chs vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
998 1.128 fvdl if (error) {
999 1.128 fvdl m_freem(mrep);
1000 1.128 fvdl return error;
1001 1.128 fvdl }
1002 1.128 fvdl newvp = NFSTOV(np);
1003 1.128 fvdl
1004 1.200 christos #ifndef NFS_V2_ONLY
1005 1.128 fvdl if (v3) {
1006 1.153 yamt nfsm_postop_attr(newvp, attrflag, 0);
1007 1.153 yamt nfsm_postop_attr(dvp, attrflag, 0);
1008 1.128 fvdl } else
1009 1.200 christos #endif
1010 1.153 yamt nfsm_loadattr(newvp, (struct vattr *)0, 0);
1011 1.1 cgd } else {
1012 1.128 fvdl /*
1013 1.128 fvdl * Other lookups.
1014 1.128 fvdl */
1015 1.175 fvdl error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
1016 1.59 fvdl if (error) {
1017 1.1 cgd m_freem(mrep);
1018 1.128 fvdl return error;
1019 1.1 cgd }
1020 1.1 cgd newvp = NFSTOV(np);
1021 1.200 christos #ifndef NFS_V2_ONLY
1022 1.128 fvdl if (v3) {
1023 1.153 yamt nfsm_postop_attr(newvp, attrflag, 0);
1024 1.153 yamt nfsm_postop_attr(dvp, attrflag, 0);
1025 1.128 fvdl } else
1026 1.200 christos #endif
1027 1.153 yamt nfsm_loadattr(newvp, (struct vattr *)0, 0);
1028 1.1 cgd }
1029 1.32 mycroft if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
1030 1.32 mycroft cnp->cn_flags |= SAVENAME;
1031 1.32 mycroft if ((cnp->cn_flags & MAKEENTRY) &&
1032 1.32 mycroft (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN))) {
1033 1.188 yamt nfs_cache_enter(dvp, newvp, cnp);
1034 1.1 cgd }
1035 1.59 fvdl *vpp = newvp;
1036 1.59 fvdl nfsm_reqdone;
1037 1.59 fvdl if (error) {
1038 1.128 fvdl /*
1039 1.128 fvdl * We get here only because of errors returned by
1040 1.128 fvdl * the RPC. Otherwise we'll have returned above
1041 1.128 fvdl * (the nfsm_* macros will jump to nfsm_reqdone
1042 1.128 fvdl * on error).
1043 1.128 fvdl */
1044 1.82 fvdl if (error == ENOENT && (cnp->cn_flags & MAKEENTRY) &&
1045 1.82 fvdl cnp->cn_nameiop != CREATE) {
1046 1.188 yamt nfs_cache_enter(dvp, NULL, cnp);
1047 1.82 fvdl }
1048 1.128 fvdl if (newvp != NULLVP) {
1049 1.246 chs if (newvp == dvp) {
1050 1.246 chs vrele(newvp);
1051 1.246 chs } else {
1052 1.246 chs vput(newvp);
1053 1.246 chs }
1054 1.128 fvdl }
1055 1.203 yamt noentry:
1056 1.59 fvdl if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
1057 1.59 fvdl (flags & ISLASTCN) && error == ENOENT) {
1058 1.203 yamt if (dvp->v_mount->mnt_flag & MNT_RDONLY) {
1059 1.59 fvdl error = EROFS;
1060 1.203 yamt } else {
1061 1.59 fvdl error = EJUSTRETURN;
1062 1.203 yamt cnp->cn_flags |= SAVENAME;
1063 1.203 yamt }
1064 1.59 fvdl }
1065 1.128 fvdl *vpp = NULL;
1066 1.190 yamt return error;
1067 1.190 yamt }
1068 1.190 yamt
1069 1.190 yamt validate:
1070 1.190 yamt /*
1071 1.190 yamt * make sure we have valid type and size.
1072 1.190 yamt */
1073 1.190 yamt
1074 1.190 yamt newvp = *vpp;
1075 1.190 yamt if (newvp->v_type == VNON) {
1076 1.190 yamt struct vattr vattr; /* dummy */
1077 1.190 yamt
1078 1.190 yamt KASSERT(VTONFS(newvp)->n_attrstamp == 0);
1079 1.260 pooka error = VOP_GETATTR(newvp, &vattr, cnp->cn_cred);
1080 1.190 yamt if (error) {
1081 1.190 yamt vput(newvp);
1082 1.190 yamt *vpp = NULL;
1083 1.190 yamt }
1084 1.59 fvdl }
1085 1.128 fvdl
1086 1.128 fvdl return error;
1087 1.1 cgd }
1088 1.1 cgd
1089 1.1 cgd /*
1090 1.1 cgd * nfs read call.
1091 1.1 cgd * Just call nfs_bioread() to do the work.
1092 1.1 cgd */
1093 1.32 mycroft int
1094 1.58 christos nfs_read(v)
1095 1.58 christos void *v;
1096 1.58 christos {
1097 1.32 mycroft struct vop_read_args /* {
1098 1.32 mycroft struct vnode *a_vp;
1099 1.32 mycroft struct uio *a_uio;
1100 1.32 mycroft int a_ioflag;
1101 1.236 elad kauth_cred_t a_cred;
1102 1.58 christos } */ *ap = v;
1103 1.110 augustss struct vnode *vp = ap->a_vp;
1104 1.32 mycroft
1105 1.1 cgd if (vp->v_type != VREG)
1106 1.229 yamt return EISDIR;
1107 1.81 fvdl return (nfs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred, 0));
1108 1.1 cgd }
1109 1.1 cgd
1110 1.1 cgd /*
1111 1.1 cgd * nfs readlink call
1112 1.1 cgd */
1113 1.32 mycroft int
1114 1.58 christos nfs_readlink(v)
1115 1.58 christos void *v;
1116 1.58 christos {
1117 1.32 mycroft struct vop_readlink_args /* {
1118 1.32 mycroft struct vnode *a_vp;
1119 1.32 mycroft struct uio *a_uio;
1120 1.236 elad kauth_cred_t a_cred;
1121 1.58 christos } */ *ap = v;
1122 1.110 augustss struct vnode *vp = ap->a_vp;
1123 1.224 yamt struct nfsnode *np = VTONFS(vp);
1124 1.32 mycroft
1125 1.1 cgd if (vp->v_type != VLNK)
1126 1.1 cgd return (EPERM);
1127 1.224 yamt
1128 1.224 yamt if (np->n_rcred != NULL) {
1129 1.236 elad kauth_cred_free(np->n_rcred);
1130 1.224 yamt }
1131 1.224 yamt np->n_rcred = ap->a_cred;
1132 1.236 elad kauth_cred_hold(np->n_rcred);
1133 1.224 yamt
1134 1.81 fvdl return (nfs_bioread(vp, ap->a_uio, 0, ap->a_cred, 0));
1135 1.1 cgd }
1136 1.1 cgd
1137 1.1 cgd /*
1138 1.1 cgd * Do a readlink rpc.
1139 1.1 cgd * Called by nfs_doio() from below the buffer cache.
1140 1.1 cgd */
1141 1.32 mycroft int
1142 1.1 cgd nfs_readlinkrpc(vp, uiop, cred)
1143 1.110 augustss struct vnode *vp;
1144 1.1 cgd struct uio *uiop;
1145 1.236 elad kauth_cred_t cred;
1146 1.1 cgd {
1147 1.110 augustss u_int32_t *tl;
1148 1.252 christos char *cp;
1149 1.110 augustss int32_t t1, t2;
1150 1.252 christos char *bpos, *dpos, *cp2;
1151 1.200 christos int error = 0;
1152 1.169 yamt uint32_t len;
1153 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
1154 1.119 bjh21 const int v3 = NFS_ISV3(vp);
1155 1.165 drochner struct nfsnode *np = VTONFS(vp);
1156 1.200 christos #ifndef NFS_V2_ONLY
1157 1.200 christos int attrflag;
1158 1.200 christos #endif
1159 1.1 cgd
1160 1.1 cgd nfsstats.rpccnt[NFSPROC_READLINK]++;
1161 1.165 drochner nfsm_reqhead(np, NFSPROC_READLINK, NFSX_FH(v3));
1162 1.165 drochner nfsm_fhtom(np, v3);
1163 1.231 yamt nfsm_request(np, NFSPROC_READLINK, curlwp, cred);
1164 1.200 christos #ifndef NFS_V2_ONLY
1165 1.59 fvdl if (v3)
1166 1.153 yamt nfsm_postop_attr(vp, attrflag, 0);
1167 1.200 christos #endif
1168 1.59 fvdl if (!error) {
1169 1.200 christos #ifndef NFS_V2_ONLY
1170 1.169 yamt if (v3) {
1171 1.169 yamt nfsm_dissect(tl, uint32_t *, NFSX_UNSIGNED);
1172 1.169 yamt len = fxdr_unsigned(uint32_t, *tl);
1173 1.169 yamt if (len > MAXPATHLEN) {
1174 1.169 yamt /*
1175 1.169 yamt * this pathname is too long for us.
1176 1.169 yamt */
1177 1.169 yamt m_freem(mrep);
1178 1.169 yamt /* Solaris returns EINVAL. should we follow? */
1179 1.169 yamt error = ENAMETOOLONG;
1180 1.169 yamt goto nfsmout;
1181 1.169 yamt }
1182 1.200 christos } else
1183 1.200 christos #endif
1184 1.200 christos {
1185 1.169 yamt nfsm_strsiz(len, NFS_MAXPATHLEN);
1186 1.169 yamt }
1187 1.59 fvdl nfsm_mtouio(uiop, len);
1188 1.59 fvdl }
1189 1.1 cgd nfsm_reqdone;
1190 1.1 cgd return (error);
1191 1.1 cgd }
1192 1.1 cgd
1193 1.1 cgd /*
1194 1.1 cgd * nfs read rpc call
1195 1.1 cgd * Ditto above
1196 1.1 cgd */
1197 1.32 mycroft int
1198 1.124 chs nfs_readrpc(vp, uiop)
1199 1.110 augustss struct vnode *vp;
1200 1.1 cgd struct uio *uiop;
1201 1.1 cgd {
1202 1.110 augustss u_int32_t *tl;
1203 1.252 christos char *cp;
1204 1.110 augustss int32_t t1, t2;
1205 1.252 christos char *bpos, *dpos, *cp2;
1206 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
1207 1.1 cgd struct nfsmount *nmp;
1208 1.232 blymn int error = 0, len, retlen, tsiz, eof, byte_count;
1209 1.119 bjh21 const int v3 = NFS_ISV3(vp);
1210 1.165 drochner struct nfsnode *np = VTONFS(vp);
1211 1.200 christos #ifndef NFS_V2_ONLY
1212 1.200 christos int attrflag;
1213 1.200 christos #endif
1214 1.1 cgd
1215 1.59 fvdl #ifndef nolint
1216 1.59 fvdl eof = 0;
1217 1.59 fvdl #endif
1218 1.1 cgd nmp = VFSTONFS(vp->v_mount);
1219 1.1 cgd tsiz = uiop->uio_resid;
1220 1.80 fvdl if (uiop->uio_offset + tsiz > nmp->nm_maxfilesize)
1221 1.32 mycroft return (EFBIG);
1222 1.266.10.1 yamt mutex_enter(&nmp->nm_lock);
1223 1.232 blymn iostat_busy(nmp->nm_stats);
1224 1.266.10.1 yamt mutex_exit(&nmp->nm_lock);
1225 1.232 blymn byte_count = 0; /* count bytes actually transferred */
1226 1.1 cgd while (tsiz > 0) {
1227 1.1 cgd nfsstats.rpccnt[NFSPROC_READ]++;
1228 1.1 cgd len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz;
1229 1.165 drochner nfsm_reqhead(np, NFSPROC_READ, NFSX_FH(v3) + NFSX_UNSIGNED * 3);
1230 1.165 drochner nfsm_fhtom(np, v3);
1231 1.59 fvdl nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED * 3);
1232 1.200 christos #ifndef NFS_V2_ONLY
1233 1.59 fvdl if (v3) {
1234 1.98 fair txdr_hyper(uiop->uio_offset, tl);
1235 1.32 mycroft *(tl + 2) = txdr_unsigned(len);
1236 1.200 christos } else
1237 1.200 christos #endif
1238 1.200 christos {
1239 1.32 mycroft *tl++ = txdr_unsigned(uiop->uio_offset);
1240 1.32 mycroft *tl++ = txdr_unsigned(len);
1241 1.32 mycroft *tl = 0;
1242 1.32 mycroft }
1243 1.231 yamt nfsm_request(np, NFSPROC_READ, curlwp, np->n_rcred);
1244 1.200 christos #ifndef NFS_V2_ONLY
1245 1.59 fvdl if (v3) {
1246 1.153 yamt nfsm_postop_attr(vp, attrflag, NAC_NOTRUNC);
1247 1.59 fvdl if (error) {
1248 1.59 fvdl m_freem(mrep);
1249 1.59 fvdl goto nfsmout;
1250 1.59 fvdl }
1251 1.59 fvdl nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1252 1.59 fvdl eof = fxdr_unsigned(int, *(tl + 1));
1253 1.59 fvdl } else
1254 1.200 christos #endif
1255 1.153 yamt nfsm_loadattr(vp, (struct vattr *)0, NAC_NOTRUNC);
1256 1.1 cgd nfsm_strsiz(retlen, nmp->nm_rsize);
1257 1.1 cgd nfsm_mtouio(uiop, retlen);
1258 1.1 cgd m_freem(mrep);
1259 1.59 fvdl tsiz -= retlen;
1260 1.232 blymn byte_count += retlen;
1261 1.200 christos #ifndef NFS_V2_ONLY
1262 1.59 fvdl if (v3) {
1263 1.59 fvdl if (eof || retlen == 0)
1264 1.59 fvdl tsiz = 0;
1265 1.200 christos } else
1266 1.200 christos #endif
1267 1.200 christos if (retlen < len)
1268 1.1 cgd tsiz = 0;
1269 1.1 cgd }
1270 1.1 cgd nfsmout:
1271 1.266.10.1 yamt mutex_enter(&nmp->nm_lock);
1272 1.232 blymn iostat_unbusy(nmp->nm_stats, byte_count, 1);
1273 1.266.10.1 yamt mutex_exit(&nmp->nm_lock);
1274 1.1 cgd return (error);
1275 1.1 cgd }
1276 1.1 cgd
1277 1.171 yamt struct nfs_writerpc_context {
1278 1.253 yamt kmutex_t nwc_lock;
1279 1.253 yamt kcondvar_t nwc_cv;
1280 1.253 yamt int nwc_mbufcount;
1281 1.171 yamt };
1282 1.171 yamt
1283 1.1 cgd /*
1284 1.170 yamt * free mbuf used to refer protected pages while write rpc call.
1285 1.171 yamt * called at splvm.
1286 1.167 yamt */
1287 1.167 yamt static void
1288 1.252 christos nfs_writerpc_extfree(struct mbuf *m, void *tbuf, size_t size, void *arg)
1289 1.167 yamt {
1290 1.171 yamt struct nfs_writerpc_context *ctx = arg;
1291 1.170 yamt
1292 1.170 yamt KASSERT(m != NULL);
1293 1.171 yamt KASSERT(ctx != NULL);
1294 1.258 ad pool_cache_put(mb_cache, m);
1295 1.253 yamt mutex_enter(&ctx->nwc_lock);
1296 1.171 yamt if (--ctx->nwc_mbufcount == 0) {
1297 1.253 yamt cv_signal(&ctx->nwc_cv);
1298 1.171 yamt }
1299 1.253 yamt mutex_exit(&ctx->nwc_lock);
1300 1.167 yamt }
1301 1.167 yamt
1302 1.167 yamt /*
1303 1.1 cgd * nfs write call
1304 1.1 cgd */
1305 1.32 mycroft int
1306 1.173 yamt nfs_writerpc(vp, uiop, iomode, pageprotected, stalewriteverfp)
1307 1.110 augustss struct vnode *vp;
1308 1.110 augustss struct uio *uiop;
1309 1.166 yamt int *iomode;
1310 1.250 thorpej bool pageprotected;
1311 1.250 thorpej bool *stalewriteverfp;
1312 1.1 cgd {
1313 1.110 augustss u_int32_t *tl;
1314 1.252 christos char *cp;
1315 1.173 yamt int32_t t1, t2;
1316 1.252 christos char *bpos, *dpos;
1317 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
1318 1.59 fvdl struct nfsmount *nmp = VFSTONFS(vp->v_mount);
1319 1.200 christos int error = 0, len, tsiz, wccflag = NFSV3_WCCRATTR;
1320 1.119 bjh21 const int v3 = NFS_ISV3(vp);
1321 1.119 bjh21 int committed = NFSV3WRITE_FILESYNC;
1322 1.165 drochner struct nfsnode *np = VTONFS(vp);
1323 1.171 yamt struct nfs_writerpc_context ctx;
1324 1.253 yamt int byte_count;
1325 1.182 christos struct lwp *l = NULL;
1326 1.173 yamt size_t origresid;
1327 1.200 christos #ifndef NFS_V2_ONLY
1328 1.252 christos char *cp2;
1329 1.200 christos int rlen, commit;
1330 1.200 christos #endif
1331 1.171 yamt
1332 1.253 yamt mutex_init(&ctx.nwc_lock, MUTEX_DRIVER, IPL_VM);
1333 1.253 yamt cv_init(&ctx.nwc_cv, "nfsmblk");
1334 1.171 yamt ctx.nwc_mbufcount = 1;
1335 1.125 chs
1336 1.125 chs if (vp->v_mount->mnt_flag & MNT_RDONLY) {
1337 1.125 chs panic("writerpc readonly vp %p", vp);
1338 1.125 chs }
1339 1.1 cgd
1340 1.142 bjh21 #ifdef DIAGNOSTIC
1341 1.59 fvdl if (uiop->uio_iovcnt != 1)
1342 1.59 fvdl panic("nfs: writerpc iovcnt > 1");
1343 1.59 fvdl #endif
1344 1.1 cgd tsiz = uiop->uio_resid;
1345 1.80 fvdl if (uiop->uio_offset + tsiz > nmp->nm_maxfilesize)
1346 1.32 mycroft return (EFBIG);
1347 1.171 yamt if (pageprotected) {
1348 1.171 yamt l = curlwp;
1349 1.256 ad uvm_lwp_hold(l);
1350 1.171 yamt }
1351 1.173 yamt retry:
1352 1.173 yamt origresid = uiop->uio_resid;
1353 1.173 yamt KASSERT(origresid == uiop->uio_iov->iov_len);
1354 1.266.10.1 yamt mutex_enter(&nmp->nm_lock);
1355 1.232 blymn iostat_busy(nmp->nm_stats);
1356 1.266.10.1 yamt mutex_exit(&nmp->nm_lock);
1357 1.232 blymn byte_count = 0; /* count of bytes actually written */
1358 1.1 cgd while (tsiz > 0) {
1359 1.173 yamt uint32_t datalen; /* data bytes need to be allocated in mbuf */
1360 1.173 yamt uint32_t backup;
1361 1.251 thorpej bool stalewriteverf = false;
1362 1.167 yamt
1363 1.1 cgd nfsstats.rpccnt[NFSPROC_WRITE]++;
1364 1.124 chs len = min(tsiz, nmp->nm_wsize);
1365 1.167 yamt datalen = pageprotected ? 0 : nfsm_rndup(len);
1366 1.165 drochner nfsm_reqhead(np, NFSPROC_WRITE,
1367 1.167 yamt NFSX_FH(v3) + 5 * NFSX_UNSIGNED + datalen);
1368 1.165 drochner nfsm_fhtom(np, v3);
1369 1.200 christos #ifndef NFS_V2_ONLY
1370 1.59 fvdl if (v3) {
1371 1.59 fvdl nfsm_build(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
1372 1.98 fair txdr_hyper(uiop->uio_offset, tl);
1373 1.32 mycroft tl += 2;
1374 1.59 fvdl *tl++ = txdr_unsigned(len);
1375 1.59 fvdl *tl++ = txdr_unsigned(*iomode);
1376 1.50 gwr *tl = txdr_unsigned(len);
1377 1.200 christos } else
1378 1.200 christos #endif
1379 1.200 christos {
1380 1.110 augustss u_int32_t x;
1381 1.59 fvdl
1382 1.59 fvdl nfsm_build(tl, u_int32_t *, 4 * NFSX_UNSIGNED);
1383 1.50 gwr /* Set both "begin" and "current" to non-garbage. */
1384 1.50 gwr x = txdr_unsigned((u_int32_t)uiop->uio_offset);
1385 1.59 fvdl *tl++ = x; /* "begin offset" */
1386 1.59 fvdl *tl++ = x; /* "current offset" */
1387 1.50 gwr x = txdr_unsigned(len);
1388 1.59 fvdl *tl++ = x; /* total to this offset */
1389 1.59 fvdl *tl = x; /* size of this write */
1390 1.59 fvdl
1391 1.32 mycroft }
1392 1.167 yamt if (pageprotected) {
1393 1.167 yamt /*
1394 1.167 yamt * since we know pages can't be modified during i/o,
1395 1.167 yamt * no need to copy them for us.
1396 1.167 yamt */
1397 1.167 yamt struct mbuf *m;
1398 1.167 yamt struct iovec *iovp = uiop->uio_iov;
1399 1.167 yamt
1400 1.167 yamt m = m_get(M_WAIT, MT_DATA);
1401 1.170 yamt MCLAIM(m, &nfs_mowner);
1402 1.170 yamt MEXTADD(m, iovp->iov_base, len, M_MBUF,
1403 1.171 yamt nfs_writerpc_extfree, &ctx);
1404 1.167 yamt m->m_flags |= M_EXT_ROMAP;
1405 1.167 yamt m->m_len = len;
1406 1.167 yamt mb->m_next = m;
1407 1.167 yamt /*
1408 1.167 yamt * no need to maintain mb and bpos here
1409 1.167 yamt * because no one care them later.
1410 1.167 yamt */
1411 1.167 yamt #if 0
1412 1.167 yamt mb = m;
1413 1.252 christos bpos = mtod(void *, mb) + mb->m_len;
1414 1.167 yamt #endif
1415 1.225 christos UIO_ADVANCE(uiop, len);
1416 1.167 yamt uiop->uio_offset += len;
1417 1.253 yamt mutex_enter(&ctx.nwc_lock);
1418 1.171 yamt ctx.nwc_mbufcount++;
1419 1.253 yamt mutex_exit(&ctx.nwc_lock);
1420 1.183 yamt nfs_zeropad(mb, 0, nfsm_padlen(len));
1421 1.167 yamt } else {
1422 1.167 yamt nfsm_uiotom(uiop, len);
1423 1.167 yamt }
1424 1.231 yamt nfsm_request(np, NFSPROC_WRITE, curlwp, np->n_wcred);
1425 1.200 christos #ifndef NFS_V2_ONLY
1426 1.59 fvdl if (v3) {
1427 1.59 fvdl wccflag = NFSV3_WCCCHK;
1428 1.216 yamt nfsm_wcc_data(vp, wccflag, NAC_NOTRUNC, !error);
1429 1.59 fvdl if (!error) {
1430 1.59 fvdl nfsm_dissect(tl, u_int32_t *, 2 * NFSX_UNSIGNED
1431 1.59 fvdl + NFSX_V3WRITEVERF);
1432 1.59 fvdl rlen = fxdr_unsigned(int, *tl++);
1433 1.59 fvdl if (rlen == 0) {
1434 1.59 fvdl error = NFSERR_IO;
1435 1.80 fvdl m_freem(mrep);
1436 1.59 fvdl break;
1437 1.59 fvdl } else if (rlen < len) {
1438 1.59 fvdl backup = len - rlen;
1439 1.225 christos UIO_ADVANCE(uiop, -backup);
1440 1.59 fvdl uiop->uio_offset -= backup;
1441 1.59 fvdl len = rlen;
1442 1.59 fvdl }
1443 1.59 fvdl commit = fxdr_unsigned(int, *tl++);
1444 1.59 fvdl
1445 1.59 fvdl /*
1446 1.59 fvdl * Return the lowest committment level
1447 1.59 fvdl * obtained by any of the RPCs.
1448 1.59 fvdl */
1449 1.59 fvdl if (committed == NFSV3WRITE_FILESYNC)
1450 1.59 fvdl committed = commit;
1451 1.59 fvdl else if (committed == NFSV3WRITE_DATASYNC &&
1452 1.59 fvdl commit == NFSV3WRITE_UNSTABLE)
1453 1.59 fvdl committed = commit;
1454 1.254 yamt mutex_enter(&nmp->nm_lock);
1455 1.81 fvdl if ((nmp->nm_iflag & NFSMNT_HASWRITEVERF) == 0){
1456 1.166 yamt memcpy(nmp->nm_writeverf, tl,
1457 1.166 yamt NFSX_V3WRITEVERF);
1458 1.166 yamt nmp->nm_iflag |= NFSMNT_HASWRITEVERF;
1459 1.166 yamt } else if ((nmp->nm_iflag &
1460 1.166 yamt NFSMNT_STALEWRITEVERF) ||
1461 1.166 yamt memcmp(tl, nmp->nm_writeverf,
1462 1.166 yamt NFSX_V3WRITEVERF)) {
1463 1.166 yamt memcpy(nmp->nm_writeverf, tl,
1464 1.166 yamt NFSX_V3WRITEVERF);
1465 1.173 yamt /*
1466 1.173 yamt * note NFSMNT_STALEWRITEVERF
1467 1.220 perry * if we're the first thread to
1468 1.173 yamt * notice it.
1469 1.173 yamt */
1470 1.173 yamt if ((nmp->nm_iflag &
1471 1.173 yamt NFSMNT_STALEWRITEVERF) == 0) {
1472 1.251 thorpej stalewriteverf = true;
1473 1.173 yamt nmp->nm_iflag |=
1474 1.173 yamt NFSMNT_STALEWRITEVERF;
1475 1.173 yamt }
1476 1.59 fvdl }
1477 1.254 yamt mutex_exit(&nmp->nm_lock);
1478 1.59 fvdl }
1479 1.59 fvdl } else
1480 1.200 christos #endif
1481 1.172 yamt nfsm_loadattr(vp, (struct vattr *)0, NAC_NOTRUNC);
1482 1.59 fvdl if (wccflag)
1483 1.180 yamt VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr->va_mtime;
1484 1.1 cgd m_freem(mrep);
1485 1.80 fvdl if (error)
1486 1.80 fvdl break;
1487 1.1 cgd tsiz -= len;
1488 1.232 blymn byte_count += len;
1489 1.173 yamt if (stalewriteverf) {
1490 1.251 thorpej *stalewriteverfp = true;
1491 1.251 thorpej stalewriteverf = false;
1492 1.173 yamt if (committed == NFSV3WRITE_UNSTABLE &&
1493 1.173 yamt len != origresid) {
1494 1.173 yamt /*
1495 1.173 yamt * if our write requests weren't atomic but
1496 1.173 yamt * unstable, datas in previous iterations
1497 1.173 yamt * might have already been lost now.
1498 1.173 yamt * then, we should resend them to nfsd.
1499 1.173 yamt */
1500 1.173 yamt backup = origresid - tsiz;
1501 1.225 christos UIO_ADVANCE(uiop, -backup);
1502 1.173 yamt uiop->uio_offset -= backup;
1503 1.173 yamt tsiz = origresid;
1504 1.173 yamt goto retry;
1505 1.173 yamt }
1506 1.173 yamt }
1507 1.171 yamt }
1508 1.210 yamt nfsmout:
1509 1.266.10.1 yamt mutex_enter(&nmp->nm_lock);
1510 1.232 blymn iostat_unbusy(nmp->nm_stats, byte_count, 0);
1511 1.266.10.1 yamt mutex_exit(&nmp->nm_lock);
1512 1.171 yamt if (pageprotected) {
1513 1.171 yamt /*
1514 1.171 yamt * wait until mbufs go away.
1515 1.171 yamt * retransmitted mbufs can survive longer than rpc requests
1516 1.171 yamt * themselves.
1517 1.171 yamt */
1518 1.253 yamt mutex_enter(&ctx.nwc_lock);
1519 1.171 yamt ctx.nwc_mbufcount--;
1520 1.171 yamt while (ctx.nwc_mbufcount > 0) {
1521 1.253 yamt cv_wait(&ctx.nwc_cv, &ctx.nwc_lock);
1522 1.171 yamt }
1523 1.253 yamt mutex_exit(&ctx.nwc_lock);
1524 1.256 ad uvm_lwp_rele(l);
1525 1.1 cgd }
1526 1.255 yamt mutex_destroy(&ctx.nwc_lock);
1527 1.255 yamt cv_destroy(&ctx.nwc_cv);
1528 1.59 fvdl *iomode = committed;
1529 1.32 mycroft if (error)
1530 1.32 mycroft uiop->uio_resid = tsiz;
1531 1.1 cgd return (error);
1532 1.1 cgd }
1533 1.1 cgd
1534 1.1 cgd /*
1535 1.59 fvdl * nfs mknod rpc
1536 1.59 fvdl * For NFS v2 this is a kludge. Use a create rpc but with the IFMT bits of the
1537 1.59 fvdl * mode set to specify the file type and the size field for rdev.
1538 1.1 cgd */
1539 1.32 mycroft int
1540 1.59 fvdl nfs_mknodrpc(dvp, vpp, cnp, vap)
1541 1.110 augustss struct vnode *dvp;
1542 1.110 augustss struct vnode **vpp;
1543 1.110 augustss struct componentname *cnp;
1544 1.110 augustss struct vattr *vap;
1545 1.58 christos {
1546 1.110 augustss struct nfsv2_sattr *sp;
1547 1.110 augustss u_int32_t *tl;
1548 1.252 christos char *cp;
1549 1.110 augustss int32_t t1, t2;
1550 1.59 fvdl struct vnode *newvp = (struct vnode *)0;
1551 1.165 drochner struct nfsnode *dnp, *np;
1552 1.32 mycroft char *cp2;
1553 1.252 christos char *bpos, *dpos;
1554 1.59 fvdl int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;
1555 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
1556 1.53 cgd u_int32_t rdev;
1557 1.119 bjh21 const int v3 = NFS_ISV3(dvp);
1558 1.1 cgd
1559 1.1 cgd if (vap->va_type == VCHR || vap->va_type == VBLK)
1560 1.1 cgd rdev = txdr_unsigned(vap->va_rdev);
1561 1.59 fvdl else if (vap->va_type == VFIFO || vap->va_type == VSOCK)
1562 1.59 fvdl rdev = nfs_xdrneg1;
1563 1.1 cgd else {
1564 1.32 mycroft VOP_ABORTOP(dvp, cnp);
1565 1.32 mycroft vput(dvp);
1566 1.1 cgd return (EOPNOTSUPP);
1567 1.1 cgd }
1568 1.59 fvdl nfsstats.rpccnt[NFSPROC_MKNOD]++;
1569 1.165 drochner dnp = VTONFS(dvp);
1570 1.165 drochner nfsm_reqhead(dnp, NFSPROC_MKNOD, NFSX_FH(v3) + 4 * NFSX_UNSIGNED +
1571 1.59 fvdl + nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
1572 1.165 drochner nfsm_fhtom(dnp, v3);
1573 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1574 1.200 christos #ifndef NFS_V2_ONLY
1575 1.59 fvdl if (v3) {
1576 1.101 fvdl nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
1577 1.59 fvdl *tl++ = vtonfsv3_type(vap->va_type);
1578 1.251 thorpej nfsm_v3attrbuild(vap, false);
1579 1.59 fvdl if (vap->va_type == VCHR || vap->va_type == VBLK) {
1580 1.59 fvdl nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
1581 1.59 fvdl *tl++ = txdr_unsigned(major(vap->va_rdev));
1582 1.59 fvdl *tl = txdr_unsigned(minor(vap->va_rdev));
1583 1.59 fvdl }
1584 1.200 christos } else
1585 1.200 christos #endif
1586 1.200 christos {
1587 1.59 fvdl nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1588 1.59 fvdl sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
1589 1.59 fvdl sp->sa_uid = nfs_xdrneg1;
1590 1.59 fvdl sp->sa_gid = nfs_xdrneg1;
1591 1.59 fvdl sp->sa_size = rdev;
1592 1.59 fvdl txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
1593 1.59 fvdl txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
1594 1.59 fvdl }
1595 1.261 pooka nfsm_request(dnp, NFSPROC_MKNOD, curlwp, cnp->cn_cred);
1596 1.59 fvdl if (!error) {
1597 1.175 fvdl nfsm_mtofh(dvp, newvp, v3, gotvp);
1598 1.59 fvdl if (!gotvp) {
1599 1.59 fvdl error = nfs_lookitup(dvp, cnp->cn_nameptr,
1600 1.261 pooka cnp->cn_namelen, cnp->cn_cred, curlwp, &np);
1601 1.59 fvdl if (!error)
1602 1.59 fvdl newvp = NFSTOV(np);
1603 1.59 fvdl }
1604 1.32 mycroft }
1605 1.200 christos #ifndef NFS_V2_ONLY
1606 1.59 fvdl if (v3)
1607 1.216 yamt nfsm_wcc_data(dvp, wccflag, 0, !error);
1608 1.200 christos #endif
1609 1.1 cgd nfsm_reqdone;
1610 1.59 fvdl if (error) {
1611 1.59 fvdl if (newvp)
1612 1.128 fvdl vput(newvp);
1613 1.59 fvdl } else {
1614 1.59 fvdl if (cnp->cn_flags & MAKEENTRY)
1615 1.188 yamt nfs_cache_enter(dvp, newvp, cnp);
1616 1.59 fvdl *vpp = newvp;
1617 1.59 fvdl }
1618 1.117 thorpej PNBUF_PUT(cnp->cn_pnbuf);
1619 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
1620 1.59 fvdl if (!wccflag)
1621 1.185 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
1622 1.128 fvdl vput(dvp);
1623 1.59 fvdl return (error);
1624 1.59 fvdl }
1625 1.59 fvdl
1626 1.59 fvdl /*
1627 1.59 fvdl * nfs mknod vop
1628 1.59 fvdl * just call nfs_mknodrpc() to do the work.
1629 1.59 fvdl */
1630 1.59 fvdl /* ARGSUSED */
1631 1.59 fvdl int
1632 1.59 fvdl nfs_mknod(v)
1633 1.59 fvdl void *v;
1634 1.59 fvdl {
1635 1.59 fvdl struct vop_mknod_args /* {
1636 1.59 fvdl struct vnode *a_dvp;
1637 1.59 fvdl struct vnode **a_vpp;
1638 1.59 fvdl struct componentname *a_cnp;
1639 1.59 fvdl struct vattr *a_vap;
1640 1.59 fvdl } */ *ap = v;
1641 1.203 yamt struct vnode *dvp = ap->a_dvp;
1642 1.203 yamt struct componentname *cnp = ap->a_cnp;
1643 1.59 fvdl int error;
1644 1.59 fvdl
1645 1.203 yamt error = nfs_mknodrpc(dvp, ap->a_vpp, cnp, ap->a_vap);
1646 1.203 yamt VN_KNOTE(dvp, NOTE_WRITE);
1647 1.203 yamt if (error == 0 || error == EEXIST)
1648 1.203 yamt cache_purge1(dvp, cnp, 0);
1649 1.1 cgd return (error);
1650 1.1 cgd }
1651 1.1 cgd
1652 1.200 christos #ifndef NFS_V2_ONLY
1653 1.59 fvdl static u_long create_verf;
1654 1.200 christos #endif
1655 1.1 cgd /*
1656 1.1 cgd * nfs file create call
1657 1.1 cgd */
1658 1.32 mycroft int
1659 1.58 christos nfs_create(v)
1660 1.58 christos void *v;
1661 1.58 christos {
1662 1.32 mycroft struct vop_create_args /* {
1663 1.32 mycroft struct vnode *a_dvp;
1664 1.32 mycroft struct vnode **a_vpp;
1665 1.32 mycroft struct componentname *a_cnp;
1666 1.32 mycroft struct vattr *a_vap;
1667 1.58 christos } */ *ap = v;
1668 1.110 augustss struct vnode *dvp = ap->a_dvp;
1669 1.110 augustss struct vattr *vap = ap->a_vap;
1670 1.110 augustss struct componentname *cnp = ap->a_cnp;
1671 1.110 augustss struct nfsv2_sattr *sp;
1672 1.110 augustss u_int32_t *tl;
1673 1.252 christos char *cp;
1674 1.110 augustss int32_t t1, t2;
1675 1.165 drochner struct nfsnode *dnp, *np = (struct nfsnode *)0;
1676 1.59 fvdl struct vnode *newvp = (struct vnode *)0;
1677 1.252 christos char *bpos, *dpos, *cp2;
1678 1.262 yamt int error, wccflag = NFSV3_WCCRATTR, gotvp = 0;
1679 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
1680 1.119 bjh21 const int v3 = NFS_ISV3(dvp);
1681 1.262 yamt u_int32_t excl_mode = NFSV3CREATE_UNCHECKED;
1682 1.59 fvdl
1683 1.59 fvdl /*
1684 1.59 fvdl * Oops, not for me..
1685 1.59 fvdl */
1686 1.59 fvdl if (vap->va_type == VSOCK)
1687 1.59 fvdl return (nfs_mknodrpc(dvp, ap->a_vpp, cnp, vap));
1688 1.1 cgd
1689 1.204 yamt KASSERT(vap->va_type == VREG);
1690 1.204 yamt
1691 1.59 fvdl #ifdef VA_EXCLUSIVE
1692 1.262 yamt if (vap->va_vaflags & VA_EXCLUSIVE) {
1693 1.262 yamt excl_mode = NFSV3CREATE_EXCLUSIVE;
1694 1.262 yamt }
1695 1.59 fvdl #endif
1696 1.59 fvdl again:
1697 1.103 thorpej error = 0;
1698 1.1 cgd nfsstats.rpccnt[NFSPROC_CREATE]++;
1699 1.165 drochner dnp = VTONFS(dvp);
1700 1.165 drochner nfsm_reqhead(dnp, NFSPROC_CREATE, NFSX_FH(v3) + 2 * NFSX_UNSIGNED +
1701 1.59 fvdl nfsm_rndup(cnp->cn_namelen) + NFSX_SATTR(v3));
1702 1.165 drochner nfsm_fhtom(dnp, v3);
1703 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
1704 1.200 christos #ifndef NFS_V2_ONLY
1705 1.59 fvdl if (v3) {
1706 1.59 fvdl nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
1707 1.262 yamt if (excl_mode == NFSV3CREATE_EXCLUSIVE) {
1708 1.101 fvdl *tl = txdr_unsigned(NFSV3CREATE_EXCLUSIVE);
1709 1.101 fvdl nfsm_build(tl, u_int32_t *, NFSX_V3CREATEVERF);
1710 1.122 itojun #ifdef INET
1711 1.205 yamt if (TAILQ_FIRST(&in_ifaddrhead))
1712 1.205 yamt *tl++ = TAILQ_FIRST(&in_ifaddrhead)->
1713 1.205 yamt ia_addr.sin_addr.s_addr;
1714 1.101 fvdl else
1715 1.101 fvdl *tl++ = create_verf;
1716 1.122 itojun #else
1717 1.122 itojun *tl++ = create_verf;
1718 1.122 itojun #endif
1719 1.101 fvdl *tl = ++create_verf;
1720 1.59 fvdl } else {
1721 1.262 yamt *tl = txdr_unsigned(excl_mode);
1722 1.251 thorpej nfsm_v3attrbuild(vap, false);
1723 1.59 fvdl }
1724 1.200 christos } else
1725 1.200 christos #endif
1726 1.200 christos {
1727 1.59 fvdl nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
1728 1.59 fvdl sp->sa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
1729 1.59 fvdl sp->sa_uid = nfs_xdrneg1;
1730 1.59 fvdl sp->sa_gid = nfs_xdrneg1;
1731 1.59 fvdl sp->sa_size = 0;
1732 1.59 fvdl txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
1733 1.59 fvdl txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
1734 1.32 mycroft }
1735 1.261 pooka nfsm_request(dnp, NFSPROC_CREATE, curlwp, cnp->cn_cred);
1736 1.59 fvdl if (!error) {
1737 1.175 fvdl nfsm_mtofh(dvp, newvp, v3, gotvp);
1738 1.59 fvdl if (!gotvp) {
1739 1.59 fvdl error = nfs_lookitup(dvp, cnp->cn_nameptr,
1740 1.261 pooka cnp->cn_namelen, cnp->cn_cred, curlwp, &np);
1741 1.59 fvdl if (!error)
1742 1.59 fvdl newvp = NFSTOV(np);
1743 1.59 fvdl }
1744 1.59 fvdl }
1745 1.200 christos #ifndef NFS_V2_ONLY
1746 1.59 fvdl if (v3)
1747 1.216 yamt nfsm_wcc_data(dvp, wccflag, 0, !error);
1748 1.200 christos #endif
1749 1.1 cgd nfsm_reqdone;
1750 1.59 fvdl if (error) {
1751 1.238 yamt /*
1752 1.238 yamt * nfs_request maps NFSERR_NOTSUPP to ENOTSUP.
1753 1.238 yamt */
1754 1.262 yamt if (v3 && error == ENOTSUP) {
1755 1.262 yamt if (excl_mode == NFSV3CREATE_EXCLUSIVE) {
1756 1.262 yamt excl_mode = NFSV3CREATE_GUARDED;
1757 1.262 yamt goto again;
1758 1.262 yamt } else if (excl_mode == NFSV3CREATE_GUARDED) {
1759 1.262 yamt excl_mode = NFSV3CREATE_UNCHECKED;
1760 1.262 yamt goto again;
1761 1.262 yamt }
1762 1.59 fvdl }
1763 1.262 yamt } else if (v3 && (excl_mode == NFSV3CREATE_EXCLUSIVE)) {
1764 1.237 kardel struct timespec ts;
1765 1.237 kardel
1766 1.237 kardel getnanotime(&ts);
1767 1.204 yamt
1768 1.204 yamt /*
1769 1.204 yamt * make sure that we'll update timestamps as
1770 1.204 yamt * most server implementations use them to store
1771 1.204 yamt * the create verifier.
1772 1.204 yamt *
1773 1.204 yamt * XXX it's better to use TOSERVER always.
1774 1.204 yamt */
1775 1.204 yamt
1776 1.237 kardel if (vap->va_atime.tv_sec == VNOVAL)
1777 1.237 kardel vap->va_atime = ts;
1778 1.237 kardel if (vap->va_mtime.tv_sec == VNOVAL)
1779 1.237 kardel vap->va_mtime = ts;
1780 1.204 yamt
1781 1.261 pooka error = nfs_setattrrpc(newvp, vap, cnp->cn_cred, curlwp);
1782 1.204 yamt }
1783 1.203 yamt if (error == 0) {
1784 1.59 fvdl if (cnp->cn_flags & MAKEENTRY)
1785 1.188 yamt nfs_cache_enter(dvp, newvp, cnp);
1786 1.203 yamt else
1787 1.203 yamt cache_purge1(dvp, cnp, 0);
1788 1.59 fvdl *ap->a_vpp = newvp;
1789 1.203 yamt } else {
1790 1.203 yamt if (newvp)
1791 1.203 yamt vput(newvp);
1792 1.203 yamt if (error == EEXIST)
1793 1.203 yamt cache_purge1(dvp, cnp, 0);
1794 1.59 fvdl }
1795 1.117 thorpej PNBUF_PUT(cnp->cn_pnbuf);
1796 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
1797 1.59 fvdl if (!wccflag)
1798 1.185 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
1799 1.156 jdolecek VN_KNOTE(ap->a_dvp, NOTE_WRITE);
1800 1.128 fvdl vput(dvp);
1801 1.1 cgd return (error);
1802 1.1 cgd }
1803 1.1 cgd
1804 1.1 cgd /*
1805 1.1 cgd * nfs file remove call
1806 1.1 cgd * To try and make nfs semantics closer to ufs semantics, a file that has
1807 1.1 cgd * other processes using the vnode is renamed instead of removed and then
1808 1.1 cgd * removed later on the last close.
1809 1.1 cgd * - If v_usecount > 1
1810 1.1 cgd * If a rename is not already in the works
1811 1.1 cgd * call nfs_sillyrename() to set it up
1812 1.1 cgd * else
1813 1.1 cgd * do the remove rpc
1814 1.1 cgd */
1815 1.32 mycroft int
1816 1.58 christos nfs_remove(v)
1817 1.58 christos void *v;
1818 1.58 christos {
1819 1.32 mycroft struct vop_remove_args /* {
1820 1.32 mycroft struct vnodeop_desc *a_desc;
1821 1.32 mycroft struct vnode * a_dvp;
1822 1.32 mycroft struct vnode * a_vp;
1823 1.32 mycroft struct componentname * a_cnp;
1824 1.58 christos } */ *ap = v;
1825 1.110 augustss struct vnode *vp = ap->a_vp;
1826 1.110 augustss struct vnode *dvp = ap->a_dvp;
1827 1.110 augustss struct componentname *cnp = ap->a_cnp;
1828 1.110 augustss struct nfsnode *np = VTONFS(vp);
1829 1.1 cgd int error = 0;
1830 1.38 pk struct vattr vattr;
1831 1.1 cgd
1832 1.59 fvdl #ifndef DIAGNOSTIC
1833 1.59 fvdl if ((cnp->cn_flags & HASBUF) == 0)
1834 1.59 fvdl panic("nfs_remove: no name");
1835 1.59 fvdl if (vp->v_usecount < 1)
1836 1.59 fvdl panic("nfs_remove: bad v_usecount");
1837 1.59 fvdl #endif
1838 1.77 fvdl if (vp->v_type == VDIR)
1839 1.77 fvdl error = EPERM;
1840 1.77 fvdl else if (vp->v_usecount == 1 || (np->n_sillyrename &&
1841 1.260 pooka VOP_GETATTR(vp, &vattr, cnp->cn_cred) == 0 &&
1842 1.59 fvdl vattr.va_nlink > 1)) {
1843 1.32 mycroft /*
1844 1.32 mycroft * Purge the name cache so that the chance of a lookup for
1845 1.32 mycroft * the name succeeding while the remove is in progress is
1846 1.32 mycroft * minimized. Without node locking it can still happen, such
1847 1.32 mycroft * that an I/O op returns ESTALE, but since you get this if
1848 1.32 mycroft * another host removes the file..
1849 1.32 mycroft */
1850 1.32 mycroft cache_purge(vp);
1851 1.32 mycroft /*
1852 1.59 fvdl * throw away biocache buffers, mainly to avoid
1853 1.59 fvdl * unnecessary delayed writes later.
1854 1.32 mycroft */
1855 1.261 pooka error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, curlwp, 1);
1856 1.32 mycroft /* Do the rpc */
1857 1.59 fvdl if (error != EINTR)
1858 1.59 fvdl error = nfs_removerpc(dvp, cnp->cn_nameptr,
1859 1.261 pooka cnp->cn_namelen, cnp->cn_cred, curlwp);
1860 1.59 fvdl } else if (!np->n_sillyrename)
1861 1.251 thorpej error = nfs_sillyrename(dvp, vp, cnp, false);
1862 1.117 thorpej PNBUF_PUT(cnp->cn_pnbuf);
1863 1.176 yamt if (!error && nfs_getattrcache(vp, &vattr) == 0 &&
1864 1.176 yamt vattr.va_nlink == 1) {
1865 1.176 yamt np->n_flag |= NREMOVED;
1866 1.176 yamt }
1867 1.185 yamt NFS_INVALIDATE_ATTRCACHE(np);
1868 1.156 jdolecek VN_KNOTE(vp, NOTE_DELETE);
1869 1.156 jdolecek VN_KNOTE(dvp, NOTE_WRITE);
1870 1.152 thorpej if (dvp == vp)
1871 1.152 thorpej vrele(vp);
1872 1.152 thorpej else
1873 1.152 thorpej vput(vp);
1874 1.128 fvdl vput(dvp);
1875 1.1 cgd return (error);
1876 1.1 cgd }
1877 1.1 cgd
1878 1.1 cgd /*
1879 1.1 cgd * nfs file remove rpc called from nfs_inactive
1880 1.1 cgd */
1881 1.32 mycroft int
1882 1.32 mycroft nfs_removeit(sp)
1883 1.110 augustss struct sillyrename *sp;
1884 1.1 cgd {
1885 1.59 fvdl
1886 1.59 fvdl return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
1887 1.230 christos (struct lwp *)0));
1888 1.59 fvdl }
1889 1.59 fvdl
1890 1.59 fvdl /*
1891 1.59 fvdl * Nfs remove rpc, called from nfs_remove() and nfs_removeit().
1892 1.59 fvdl */
1893 1.59 fvdl int
1894 1.230 christos nfs_removerpc(dvp, name, namelen, cred, l)
1895 1.110 augustss struct vnode *dvp;
1896 1.68 cgd const char *name;
1897 1.59 fvdl int namelen;
1898 1.236 elad kauth_cred_t cred;
1899 1.230 christos struct lwp *l;
1900 1.59 fvdl {
1901 1.110 augustss u_int32_t *tl;
1902 1.252 christos char *cp;
1903 1.200 christos #ifndef NFS_V2_ONLY
1904 1.200 christos int32_t t1;
1905 1.252 christos char *cp2;
1906 1.200 christos #endif
1907 1.200 christos int32_t t2;
1908 1.252 christos char *bpos, *dpos;
1909 1.59 fvdl int error = 0, wccflag = NFSV3_WCCRATTR;
1910 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
1911 1.119 bjh21 const int v3 = NFS_ISV3(dvp);
1912 1.234 christos int rexmit = 0;
1913 1.165 drochner struct nfsnode *dnp = VTONFS(dvp);
1914 1.1 cgd
1915 1.1 cgd nfsstats.rpccnt[NFSPROC_REMOVE]++;
1916 1.165 drochner nfsm_reqhead(dnp, NFSPROC_REMOVE,
1917 1.59 fvdl NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(namelen));
1918 1.165 drochner nfsm_fhtom(dnp, v3);
1919 1.59 fvdl nfsm_strtom(name, namelen, NFS_MAXNAMLEN);
1920 1.230 christos nfsm_request1(dnp, NFSPROC_REMOVE, l, cred, &rexmit);
1921 1.200 christos #ifndef NFS_V2_ONLY
1922 1.59 fvdl if (v3)
1923 1.216 yamt nfsm_wcc_data(dvp, wccflag, 0, !error);
1924 1.200 christos #endif
1925 1.1 cgd nfsm_reqdone;
1926 1.59 fvdl VTONFS(dvp)->n_flag |= NMODIFIED;
1927 1.59 fvdl if (!wccflag)
1928 1.185 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
1929 1.197 yamt /*
1930 1.197 yamt * Kludge City: If the first reply to the remove rpc is lost..
1931 1.197 yamt * the reply to the retransmitted request will be ENOENT
1932 1.197 yamt * since the file was in fact removed
1933 1.197 yamt * Therefore, we cheat and return success.
1934 1.197 yamt */
1935 1.197 yamt if (rexmit && error == ENOENT)
1936 1.197 yamt error = 0;
1937 1.1 cgd return (error);
1938 1.1 cgd }
1939 1.1 cgd
1940 1.1 cgd /*
1941 1.1 cgd * nfs file rename call
1942 1.1 cgd */
1943 1.32 mycroft int
1944 1.58 christos nfs_rename(v)
1945 1.58 christos void *v;
1946 1.58 christos {
1947 1.32 mycroft struct vop_rename_args /* {
1948 1.32 mycroft struct vnode *a_fdvp;
1949 1.32 mycroft struct vnode *a_fvp;
1950 1.32 mycroft struct componentname *a_fcnp;
1951 1.32 mycroft struct vnode *a_tdvp;
1952 1.32 mycroft struct vnode *a_tvp;
1953 1.32 mycroft struct componentname *a_tcnp;
1954 1.58 christos } */ *ap = v;
1955 1.111 augustss struct vnode *fvp = ap->a_fvp;
1956 1.111 augustss struct vnode *tvp = ap->a_tvp;
1957 1.111 augustss struct vnode *fdvp = ap->a_fdvp;
1958 1.111 augustss struct vnode *tdvp = ap->a_tdvp;
1959 1.111 augustss struct componentname *tcnp = ap->a_tcnp;
1960 1.111 augustss struct componentname *fcnp = ap->a_fcnp;
1961 1.59 fvdl int error;
1962 1.17 cgd
1963 1.59 fvdl #ifndef DIAGNOSTIC
1964 1.59 fvdl if ((tcnp->cn_flags & HASBUF) == 0 ||
1965 1.59 fvdl (fcnp->cn_flags & HASBUF) == 0)
1966 1.59 fvdl panic("nfs_rename: no name");
1967 1.59 fvdl #endif
1968 1.17 cgd /* Check for cross-device rename */
1969 1.17 cgd if ((fvp->v_mount != tdvp->v_mount) ||
1970 1.17 cgd (tvp && (fvp->v_mount != tvp->v_mount))) {
1971 1.17 cgd error = EXDEV;
1972 1.17 cgd goto out;
1973 1.17 cgd }
1974 1.1 cgd
1975 1.59 fvdl /*
1976 1.59 fvdl * If the tvp exists and is in use, sillyrename it before doing the
1977 1.59 fvdl * rename of the new file over it.
1978 1.240 yamt *
1979 1.240 yamt * Have sillyrename use link instead of rename if possible,
1980 1.240 yamt * so that we don't lose the file if the rename fails, and so
1981 1.240 yamt * that there's no window when the "to" file doesn't exist.
1982 1.59 fvdl */
1983 1.59 fvdl if (tvp && tvp->v_usecount > 1 && !VTONFS(tvp)->n_sillyrename &&
1984 1.251 thorpej tvp->v_type != VDIR && !nfs_sillyrename(tdvp, tvp, tcnp, true)) {
1985 1.156 jdolecek VN_KNOTE(tvp, NOTE_DELETE);
1986 1.130 enami vput(tvp);
1987 1.59 fvdl tvp = NULL;
1988 1.59 fvdl }
1989 1.59 fvdl
1990 1.59 fvdl error = nfs_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
1991 1.59 fvdl tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred,
1992 1.261 pooka curlwp);
1993 1.32 mycroft
1994 1.156 jdolecek VN_KNOTE(fdvp, NOTE_WRITE);
1995 1.156 jdolecek VN_KNOTE(tdvp, NOTE_WRITE);
1996 1.203 yamt if (error == 0 || error == EEXIST) {
1997 1.203 yamt if (fvp->v_type == VDIR)
1998 1.203 yamt cache_purge(fvp);
1999 1.203 yamt else
2000 1.203 yamt cache_purge1(fdvp, fcnp, 0);
2001 1.32 mycroft if (tvp != NULL && tvp->v_type == VDIR)
2002 1.203 yamt cache_purge(tvp);
2003 1.203 yamt else
2004 1.203 yamt cache_purge1(tdvp, tcnp, 0);
2005 1.1 cgd }
2006 1.17 cgd out:
2007 1.32 mycroft if (tdvp == tvp)
2008 1.32 mycroft vrele(tdvp);
2009 1.1 cgd else
2010 1.32 mycroft vput(tdvp);
2011 1.32 mycroft if (tvp)
2012 1.32 mycroft vput(tvp);
2013 1.32 mycroft vrele(fdvp);
2014 1.32 mycroft vrele(fvp);
2015 1.1 cgd return (error);
2016 1.1 cgd }
2017 1.1 cgd
2018 1.1 cgd /*
2019 1.1 cgd * nfs file rename rpc called from nfs_remove() above
2020 1.1 cgd */
2021 1.32 mycroft int
2022 1.32 mycroft nfs_renameit(sdvp, scnp, sp)
2023 1.32 mycroft struct vnode *sdvp;
2024 1.32 mycroft struct componentname *scnp;
2025 1.111 augustss struct sillyrename *sp;
2026 1.1 cgd {
2027 1.59 fvdl return (nfs_renamerpc(sdvp, scnp->cn_nameptr, scnp->cn_namelen,
2028 1.261 pooka sdvp, sp->s_name, sp->s_namlen, scnp->cn_cred, curlwp));
2029 1.59 fvdl }
2030 1.59 fvdl
2031 1.59 fvdl /*
2032 1.59 fvdl * Do an nfs rename rpc. Called from nfs_rename() and nfs_renameit().
2033 1.59 fvdl */
2034 1.59 fvdl int
2035 1.230 christos nfs_renamerpc(fdvp, fnameptr, fnamelen, tdvp, tnameptr, tnamelen, cred, l)
2036 1.111 augustss struct vnode *fdvp;
2037 1.68 cgd const char *fnameptr;
2038 1.59 fvdl int fnamelen;
2039 1.111 augustss struct vnode *tdvp;
2040 1.68 cgd const char *tnameptr;
2041 1.59 fvdl int tnamelen;
2042 1.236 elad kauth_cred_t cred;
2043 1.230 christos struct lwp *l;
2044 1.59 fvdl {
2045 1.111 augustss u_int32_t *tl;
2046 1.252 christos char *cp;
2047 1.200 christos #ifndef NFS_V2_ONLY
2048 1.200 christos int32_t t1;
2049 1.252 christos char *cp2;
2050 1.200 christos #endif
2051 1.200 christos int32_t t2;
2052 1.252 christos char *bpos, *dpos;
2053 1.59 fvdl int error = 0, fwccflag = NFSV3_WCCRATTR, twccflag = NFSV3_WCCRATTR;
2054 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
2055 1.119 bjh21 const int v3 = NFS_ISV3(fdvp);
2056 1.234 christos int rexmit = 0;
2057 1.165 drochner struct nfsnode *fdnp = VTONFS(fdvp);
2058 1.1 cgd
2059 1.1 cgd nfsstats.rpccnt[NFSPROC_RENAME]++;
2060 1.165 drochner nfsm_reqhead(fdnp, NFSPROC_RENAME,
2061 1.59 fvdl (NFSX_FH(v3) + NFSX_UNSIGNED)*2 + nfsm_rndup(fnamelen) +
2062 1.59 fvdl nfsm_rndup(tnamelen));
2063 1.165 drochner nfsm_fhtom(fdnp, v3);
2064 1.59 fvdl nfsm_strtom(fnameptr, fnamelen, NFS_MAXNAMLEN);
2065 1.165 drochner nfsm_fhtom(VTONFS(tdvp), v3);
2066 1.59 fvdl nfsm_strtom(tnameptr, tnamelen, NFS_MAXNAMLEN);
2067 1.230 christos nfsm_request1(fdnp, NFSPROC_RENAME, l, cred, &rexmit);
2068 1.200 christos #ifndef NFS_V2_ONLY
2069 1.59 fvdl if (v3) {
2070 1.216 yamt nfsm_wcc_data(fdvp, fwccflag, 0, !error);
2071 1.216 yamt nfsm_wcc_data(tdvp, twccflag, 0, !error);
2072 1.59 fvdl }
2073 1.200 christos #endif
2074 1.1 cgd nfsm_reqdone;
2075 1.59 fvdl VTONFS(fdvp)->n_flag |= NMODIFIED;
2076 1.59 fvdl VTONFS(tdvp)->n_flag |= NMODIFIED;
2077 1.59 fvdl if (!fwccflag)
2078 1.185 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(fdvp));
2079 1.59 fvdl if (!twccflag)
2080 1.185 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(tdvp));
2081 1.197 yamt /*
2082 1.197 yamt * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
2083 1.197 yamt */
2084 1.197 yamt if (rexmit && error == ENOENT)
2085 1.197 yamt error = 0;
2086 1.1 cgd return (error);
2087 1.1 cgd }
2088 1.1 cgd
2089 1.240 yamt /*
2090 1.240 yamt * NFS link RPC, called from nfs_link.
2091 1.240 yamt * Assumes dvp and vp locked, and leaves them that way.
2092 1.240 yamt */
2093 1.240 yamt
2094 1.239 yamt static int
2095 1.239 yamt nfs_linkrpc(struct vnode *dvp, struct vnode *vp, const char *name,
2096 1.239 yamt size_t namelen, kauth_cred_t cred, struct lwp *l)
2097 1.239 yamt {
2098 1.239 yamt u_int32_t *tl;
2099 1.252 christos char *cp;
2100 1.239 yamt #ifndef NFS_V2_ONLY
2101 1.239 yamt int32_t t1;
2102 1.252 christos char *cp2;
2103 1.239 yamt #endif
2104 1.239 yamt int32_t t2;
2105 1.252 christos char *bpos, *dpos;
2106 1.239 yamt int error = 0, wccflag = NFSV3_WCCRATTR, attrflag = 0;
2107 1.239 yamt struct mbuf *mreq, *mrep, *md, *mb;
2108 1.239 yamt const int v3 = NFS_ISV3(dvp);
2109 1.239 yamt int rexmit = 0;
2110 1.239 yamt struct nfsnode *np = VTONFS(vp);
2111 1.239 yamt
2112 1.239 yamt nfsstats.rpccnt[NFSPROC_LINK]++;
2113 1.239 yamt nfsm_reqhead(np, NFSPROC_LINK,
2114 1.239 yamt NFSX_FH(v3)*2 + NFSX_UNSIGNED + nfsm_rndup(namelen));
2115 1.239 yamt nfsm_fhtom(np, v3);
2116 1.239 yamt nfsm_fhtom(VTONFS(dvp), v3);
2117 1.239 yamt nfsm_strtom(name, namelen, NFS_MAXNAMLEN);
2118 1.239 yamt nfsm_request1(np, NFSPROC_LINK, l, cred, &rexmit);
2119 1.239 yamt #ifndef NFS_V2_ONLY
2120 1.239 yamt if (v3) {
2121 1.239 yamt nfsm_postop_attr(vp, attrflag, 0);
2122 1.239 yamt nfsm_wcc_data(dvp, wccflag, 0, !error);
2123 1.239 yamt }
2124 1.239 yamt #endif
2125 1.239 yamt nfsm_reqdone;
2126 1.239 yamt
2127 1.239 yamt VTONFS(dvp)->n_flag |= NMODIFIED;
2128 1.239 yamt if (!attrflag)
2129 1.239 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(vp));
2130 1.239 yamt if (!wccflag)
2131 1.239 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
2132 1.239 yamt
2133 1.239 yamt /*
2134 1.239 yamt * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
2135 1.239 yamt */
2136 1.239 yamt if (rexmit && error == EEXIST)
2137 1.239 yamt error = 0;
2138 1.239 yamt
2139 1.239 yamt return error;
2140 1.239 yamt }
2141 1.239 yamt
2142 1.1 cgd /*
2143 1.1 cgd * nfs hard link create call
2144 1.1 cgd */
2145 1.32 mycroft int
2146 1.58 christos nfs_link(v)
2147 1.58 christos void *v;
2148 1.58 christos {
2149 1.32 mycroft struct vop_link_args /* {
2150 1.57 mycroft struct vnode *a_dvp;
2151 1.32 mycroft struct vnode *a_vp;
2152 1.32 mycroft struct componentname *a_cnp;
2153 1.58 christos } */ *ap = v;
2154 1.111 augustss struct vnode *vp = ap->a_vp;
2155 1.111 augustss struct vnode *dvp = ap->a_dvp;
2156 1.111 augustss struct componentname *cnp = ap->a_cnp;
2157 1.239 yamt int error = 0;
2158 1.1 cgd
2159 1.57 mycroft if (dvp->v_mount != vp->v_mount) {
2160 1.144 christos VOP_ABORTOP(dvp, cnp);
2161 1.71 fvdl vput(dvp);
2162 1.17 cgd return (EXDEV);
2163 1.17 cgd }
2164 1.132 fvdl if (dvp != vp) {
2165 1.132 fvdl error = vn_lock(vp, LK_EXCLUSIVE);
2166 1.132 fvdl if (error != 0) {
2167 1.132 fvdl VOP_ABORTOP(dvp, cnp);
2168 1.132 fvdl vput(dvp);
2169 1.132 fvdl return error;
2170 1.132 fvdl }
2171 1.132 fvdl }
2172 1.32 mycroft
2173 1.36 mycroft /*
2174 1.36 mycroft * Push all writes to the server, so that the attribute cache
2175 1.36 mycroft * doesn't get "out of sync" with the server.
2176 1.36 mycroft * XXX There should be a better way!
2177 1.36 mycroft */
2178 1.260 pooka VOP_FSYNC(vp, cnp->cn_cred, FSYNC_WAIT, 0, 0);
2179 1.36 mycroft
2180 1.239 yamt error = nfs_linkrpc(dvp, vp, cnp->cn_nameptr, cnp->cn_namelen,
2181 1.261 pooka cnp->cn_cred, curlwp);
2182 1.239 yamt
2183 1.239 yamt if (error == 0)
2184 1.203 yamt cache_purge1(dvp, cnp, 0);
2185 1.117 thorpej PNBUF_PUT(cnp->cn_pnbuf);
2186 1.132 fvdl if (dvp != vp)
2187 1.132 fvdl VOP_UNLOCK(vp, 0);
2188 1.156 jdolecek VN_KNOTE(vp, NOTE_LINK);
2189 1.156 jdolecek VN_KNOTE(dvp, NOTE_WRITE);
2190 1.59 fvdl vput(dvp);
2191 1.1 cgd return (error);
2192 1.1 cgd }
2193 1.1 cgd
2194 1.1 cgd /*
2195 1.1 cgd * nfs symbolic link create call
2196 1.1 cgd */
2197 1.32 mycroft int
2198 1.58 christos nfs_symlink(v)
2199 1.58 christos void *v;
2200 1.58 christos {
2201 1.32 mycroft struct vop_symlink_args /* {
2202 1.32 mycroft struct vnode *a_dvp;
2203 1.32 mycroft struct vnode **a_vpp;
2204 1.32 mycroft struct componentname *a_cnp;
2205 1.32 mycroft struct vattr *a_vap;
2206 1.32 mycroft char *a_target;
2207 1.58 christos } */ *ap = v;
2208 1.111 augustss struct vnode *dvp = ap->a_dvp;
2209 1.111 augustss struct vattr *vap = ap->a_vap;
2210 1.111 augustss struct componentname *cnp = ap->a_cnp;
2211 1.111 augustss struct nfsv2_sattr *sp;
2212 1.111 augustss u_int32_t *tl;
2213 1.252 christos char *cp;
2214 1.111 augustss int32_t t1, t2;
2215 1.252 christos char *bpos, *dpos, *cp2;
2216 1.59 fvdl int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;
2217 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
2218 1.59 fvdl struct vnode *newvp = (struct vnode *)0;
2219 1.119 bjh21 const int v3 = NFS_ISV3(dvp);
2220 1.233 christos int rexmit = 0;
2221 1.165 drochner struct nfsnode *dnp = VTONFS(dvp);
2222 1.1 cgd
2223 1.135 assar *ap->a_vpp = NULL;
2224 1.1 cgd nfsstats.rpccnt[NFSPROC_SYMLINK]++;
2225 1.32 mycroft slen = strlen(ap->a_target);
2226 1.165 drochner nfsm_reqhead(dnp, NFSPROC_SYMLINK, NFSX_FH(v3) + 2*NFSX_UNSIGNED +
2227 1.59 fvdl nfsm_rndup(cnp->cn_namelen) + nfsm_rndup(slen) + NFSX_SATTR(v3));
2228 1.165 drochner nfsm_fhtom(dnp, v3);
2229 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
2230 1.200 christos #ifndef NFS_V2_ONlY
2231 1.101 fvdl if (v3)
2232 1.251 thorpej nfsm_v3attrbuild(vap, false);
2233 1.200 christos #endif
2234 1.32 mycroft nfsm_strtom(ap->a_target, slen, NFS_MAXPATHLEN);
2235 1.200 christos #ifndef NFS_V2_ONlY
2236 1.59 fvdl if (!v3) {
2237 1.59 fvdl nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
2238 1.59 fvdl sp->sa_mode = vtonfsv2_mode(VLNK, vap->va_mode);
2239 1.59 fvdl sp->sa_uid = nfs_xdrneg1;
2240 1.59 fvdl sp->sa_gid = nfs_xdrneg1;
2241 1.59 fvdl sp->sa_size = nfs_xdrneg1;
2242 1.59 fvdl txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
2243 1.59 fvdl txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
2244 1.32 mycroft }
2245 1.200 christos #endif
2246 1.261 pooka nfsm_request1(dnp, NFSPROC_SYMLINK, curlwp, cnp->cn_cred,
2247 1.197 yamt &rexmit);
2248 1.200 christos #ifndef NFS_V2_ONlY
2249 1.59 fvdl if (v3) {
2250 1.59 fvdl if (!error)
2251 1.175 fvdl nfsm_mtofh(dvp, newvp, v3, gotvp);
2252 1.216 yamt nfsm_wcc_data(dvp, wccflag, 0, !error);
2253 1.59 fvdl }
2254 1.200 christos #endif
2255 1.1 cgd nfsm_reqdone;
2256 1.135 assar /*
2257 1.135 assar * Kludge: Map EEXIST => 0 assuming that it is a reply to a retry.
2258 1.135 assar */
2259 1.197 yamt if (rexmit && error == EEXIST)
2260 1.135 assar error = 0;
2261 1.203 yamt if (error == 0 || error == EEXIST)
2262 1.203 yamt cache_purge1(dvp, cnp, 0);
2263 1.135 assar if (error == 0 && newvp == NULL) {
2264 1.135 assar struct nfsnode *np = NULL;
2265 1.135 assar
2266 1.135 assar error = nfs_lookitup(dvp, cnp->cn_nameptr, cnp->cn_namelen,
2267 1.261 pooka cnp->cn_cred, curlwp, &np);
2268 1.135 assar if (error == 0)
2269 1.135 assar newvp = NFSTOV(np);
2270 1.135 assar }
2271 1.135 assar if (error) {
2272 1.135 assar if (newvp != NULL)
2273 1.135 assar vput(newvp);
2274 1.135 assar } else {
2275 1.135 assar *ap->a_vpp = newvp;
2276 1.135 assar }
2277 1.117 thorpej PNBUF_PUT(cnp->cn_pnbuf);
2278 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
2279 1.59 fvdl if (!wccflag)
2280 1.185 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
2281 1.156 jdolecek VN_KNOTE(dvp, NOTE_WRITE);
2282 1.128 fvdl vput(dvp);
2283 1.1 cgd return (error);
2284 1.1 cgd }
2285 1.1 cgd
2286 1.1 cgd /*
2287 1.1 cgd * nfs make dir call
2288 1.1 cgd */
2289 1.32 mycroft int
2290 1.58 christos nfs_mkdir(v)
2291 1.58 christos void *v;
2292 1.58 christos {
2293 1.32 mycroft struct vop_mkdir_args /* {
2294 1.32 mycroft struct vnode *a_dvp;
2295 1.32 mycroft struct vnode **a_vpp;
2296 1.32 mycroft struct componentname *a_cnp;
2297 1.32 mycroft struct vattr *a_vap;
2298 1.58 christos } */ *ap = v;
2299 1.111 augustss struct vnode *dvp = ap->a_dvp;
2300 1.111 augustss struct vattr *vap = ap->a_vap;
2301 1.111 augustss struct componentname *cnp = ap->a_cnp;
2302 1.111 augustss struct nfsv2_sattr *sp;
2303 1.111 augustss u_int32_t *tl;
2304 1.252 christos char *cp;
2305 1.111 augustss int32_t t1, t2;
2306 1.111 augustss int len;
2307 1.165 drochner struct nfsnode *dnp = VTONFS(dvp), *np = (struct nfsnode *)0;
2308 1.59 fvdl struct vnode *newvp = (struct vnode *)0;
2309 1.252 christos char *bpos, *dpos, *cp2;
2310 1.59 fvdl int error = 0, wccflag = NFSV3_WCCRATTR;
2311 1.59 fvdl int gotvp = 0;
2312 1.234 christos int rexmit = 0;
2313 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
2314 1.119 bjh21 const int v3 = NFS_ISV3(dvp);
2315 1.1 cgd
2316 1.32 mycroft len = cnp->cn_namelen;
2317 1.1 cgd nfsstats.rpccnt[NFSPROC_MKDIR]++;
2318 1.165 drochner nfsm_reqhead(dnp, NFSPROC_MKDIR,
2319 1.59 fvdl NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len) + NFSX_SATTR(v3));
2320 1.165 drochner nfsm_fhtom(dnp, v3);
2321 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, len, NFS_MAXNAMLEN);
2322 1.200 christos #ifndef NFS_V2_ONLY
2323 1.59 fvdl if (v3) {
2324 1.251 thorpej nfsm_v3attrbuild(vap, false);
2325 1.200 christos } else
2326 1.200 christos #endif
2327 1.200 christos {
2328 1.59 fvdl nfsm_build(sp, struct nfsv2_sattr *, NFSX_V2SATTR);
2329 1.59 fvdl sp->sa_mode = vtonfsv2_mode(VDIR, vap->va_mode);
2330 1.59 fvdl sp->sa_uid = nfs_xdrneg1;
2331 1.59 fvdl sp->sa_gid = nfs_xdrneg1;
2332 1.59 fvdl sp->sa_size = nfs_xdrneg1;
2333 1.59 fvdl txdr_nfsv2time(&vap->va_atime, &sp->sa_atime);
2334 1.59 fvdl txdr_nfsv2time(&vap->va_mtime, &sp->sa_mtime);
2335 1.32 mycroft }
2336 1.261 pooka nfsm_request1(dnp, NFSPROC_MKDIR, curlwp, cnp->cn_cred, &rexmit);
2337 1.59 fvdl if (!error)
2338 1.175 fvdl nfsm_mtofh(dvp, newvp, v3, gotvp);
2339 1.59 fvdl if (v3)
2340 1.216 yamt nfsm_wcc_data(dvp, wccflag, 0, !error);
2341 1.1 cgd nfsm_reqdone;
2342 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
2343 1.59 fvdl if (!wccflag)
2344 1.185 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
2345 1.1 cgd /*
2346 1.1 cgd * Kludge: Map EEXIST => 0 assuming that you have a reply to a retry
2347 1.1 cgd * if we can succeed in looking up the directory.
2348 1.1 cgd */
2349 1.197 yamt if ((rexmit && error == EEXIST) || (!error && !gotvp)) {
2350 1.59 fvdl if (newvp) {
2351 1.128 fvdl vput(newvp);
2352 1.59 fvdl newvp = (struct vnode *)0;
2353 1.59 fvdl }
2354 1.59 fvdl error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,
2355 1.261 pooka curlwp, &np);
2356 1.59 fvdl if (!error) {
2357 1.59 fvdl newvp = NFSTOV(np);
2358 1.195 yamt if (newvp->v_type != VDIR || newvp == dvp)
2359 1.59 fvdl error = EEXIST;
2360 1.1 cgd }
2361 1.1 cgd }
2362 1.59 fvdl if (error) {
2363 1.195 yamt if (newvp) {
2364 1.195 yamt if (dvp != newvp)
2365 1.195 yamt vput(newvp);
2366 1.195 yamt else
2367 1.195 yamt vrele(newvp);
2368 1.195 yamt }
2369 1.82 fvdl } else {
2370 1.156 jdolecek VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
2371 1.82 fvdl if (cnp->cn_flags & MAKEENTRY)
2372 1.188 yamt nfs_cache_enter(dvp, newvp, cnp);
2373 1.59 fvdl *ap->a_vpp = newvp;
2374 1.82 fvdl }
2375 1.117 thorpej PNBUF_PUT(cnp->cn_pnbuf);
2376 1.128 fvdl vput(dvp);
2377 1.1 cgd return (error);
2378 1.1 cgd }
2379 1.1 cgd
2380 1.1 cgd /*
2381 1.1 cgd * nfs remove directory call
2382 1.1 cgd */
2383 1.32 mycroft int
2384 1.58 christos nfs_rmdir(v)
2385 1.58 christos void *v;
2386 1.58 christos {
2387 1.32 mycroft struct vop_rmdir_args /* {
2388 1.32 mycroft struct vnode *a_dvp;
2389 1.32 mycroft struct vnode *a_vp;
2390 1.32 mycroft struct componentname *a_cnp;
2391 1.58 christos } */ *ap = v;
2392 1.111 augustss struct vnode *vp = ap->a_vp;
2393 1.111 augustss struct vnode *dvp = ap->a_dvp;
2394 1.111 augustss struct componentname *cnp = ap->a_cnp;
2395 1.111 augustss u_int32_t *tl;
2396 1.252 christos char *cp;
2397 1.200 christos #ifndef NFS_V2_ONLY
2398 1.200 christos int32_t t1;
2399 1.252 christos char *cp2;
2400 1.200 christos #endif
2401 1.200 christos int32_t t2;
2402 1.252 christos char *bpos, *dpos;
2403 1.59 fvdl int error = 0, wccflag = NFSV3_WCCRATTR;
2404 1.234 christos int rexmit = 0;
2405 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
2406 1.119 bjh21 const int v3 = NFS_ISV3(dvp);
2407 1.165 drochner struct nfsnode *dnp;
2408 1.1 cgd
2409 1.32 mycroft if (dvp == vp) {
2410 1.32 mycroft vrele(dvp);
2411 1.129 fvdl vput(dvp);
2412 1.117 thorpej PNBUF_PUT(cnp->cn_pnbuf);
2413 1.1 cgd return (EINVAL);
2414 1.1 cgd }
2415 1.1 cgd nfsstats.rpccnt[NFSPROC_RMDIR]++;
2416 1.165 drochner dnp = VTONFS(dvp);
2417 1.165 drochner nfsm_reqhead(dnp, NFSPROC_RMDIR,
2418 1.59 fvdl NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(cnp->cn_namelen));
2419 1.165 drochner nfsm_fhtom(dnp, v3);
2420 1.32 mycroft nfsm_strtom(cnp->cn_nameptr, cnp->cn_namelen, NFS_MAXNAMLEN);
2421 1.261 pooka nfsm_request1(dnp, NFSPROC_RMDIR, curlwp, cnp->cn_cred, &rexmit);
2422 1.200 christos #ifndef NFS_V2_ONLY
2423 1.59 fvdl if (v3)
2424 1.216 yamt nfsm_wcc_data(dvp, wccflag, 0, !error);
2425 1.200 christos #endif
2426 1.1 cgd nfsm_reqdone;
2427 1.117 thorpej PNBUF_PUT(cnp->cn_pnbuf);
2428 1.32 mycroft VTONFS(dvp)->n_flag |= NMODIFIED;
2429 1.59 fvdl if (!wccflag)
2430 1.185 yamt NFS_INVALIDATE_ATTRCACHE(VTONFS(dvp));
2431 1.156 jdolecek VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
2432 1.156 jdolecek VN_KNOTE(vp, NOTE_DELETE);
2433 1.32 mycroft cache_purge(vp);
2434 1.129 fvdl vput(vp);
2435 1.129 fvdl vput(dvp);
2436 1.1 cgd /*
2437 1.1 cgd * Kludge: Map ENOENT => 0 assuming that you have a reply to a retry.
2438 1.1 cgd */
2439 1.197 yamt if (rexmit && error == ENOENT)
2440 1.1 cgd error = 0;
2441 1.1 cgd return (error);
2442 1.1 cgd }
2443 1.1 cgd
2444 1.1 cgd /*
2445 1.1 cgd * nfs readdir call
2446 1.1 cgd */
2447 1.32 mycroft int
2448 1.58 christos nfs_readdir(v)
2449 1.58 christos void *v;
2450 1.58 christos {
2451 1.32 mycroft struct vop_readdir_args /* {
2452 1.32 mycroft struct vnode *a_vp;
2453 1.32 mycroft struct uio *a_uio;
2454 1.236 elad kauth_cred_t a_cred;
2455 1.32 mycroft int *a_eofflag;
2456 1.89 fvdl off_t **a_cookies;
2457 1.89 fvdl int *a_ncookies;
2458 1.58 christos } */ *ap = v;
2459 1.111 augustss struct vnode *vp = ap->a_vp;
2460 1.111 augustss struct uio *uio = ap->a_uio;
2461 1.85 fvdl struct nfsmount *nmp = VFSTONFS(vp->v_mount);
2462 1.52 ghudson char *base = uio->uio_iov->iov_base;
2463 1.1 cgd int tresid, error;
2464 1.81 fvdl size_t count, lost;
2465 1.90 fvdl struct dirent *dp;
2466 1.90 fvdl off_t *cookies = NULL;
2467 1.90 fvdl int ncookies = 0, nc;
2468 1.32 mycroft
2469 1.1 cgd if (vp->v_type != VDIR)
2470 1.1 cgd return (EPERM);
2471 1.81 fvdl
2472 1.81 fvdl lost = uio->uio_resid & (NFS_DIRFRAGSIZ - 1);
2473 1.81 fvdl count = uio->uio_resid - lost;
2474 1.81 fvdl if (count <= 0)
2475 1.81 fvdl return (EINVAL);
2476 1.81 fvdl
2477 1.1 cgd /*
2478 1.1 cgd * Call nfs_bioread() to do the real work.
2479 1.1 cgd */
2480 1.81 fvdl tresid = uio->uio_resid = count;
2481 1.81 fvdl error = nfs_bioread(vp, uio, 0, ap->a_cred,
2482 1.81 fvdl ap->a_cookies ? NFSBIO_CACHECOOKIES : 0);
2483 1.1 cgd
2484 1.90 fvdl if (!error && ap->a_cookies) {
2485 1.90 fvdl ncookies = count / 16;
2486 1.116 thorpej cookies = malloc(sizeof (off_t) * ncookies, M_TEMP, M_WAITOK);
2487 1.90 fvdl *ap->a_cookies = cookies;
2488 1.90 fvdl }
2489 1.90 fvdl
2490 1.59 fvdl if (!error && uio->uio_resid == tresid) {
2491 1.81 fvdl uio->uio_resid += lost;
2492 1.1 cgd nfsstats.direofcache_misses++;
2493 1.90 fvdl if (ap->a_cookies)
2494 1.90 fvdl *ap->a_ncookies = 0;
2495 1.59 fvdl *ap->a_eofflag = 1;
2496 1.59 fvdl return (0);
2497 1.59 fvdl }
2498 1.52 ghudson
2499 1.52 ghudson if (!error && ap->a_cookies) {
2500 1.52 ghudson /*
2501 1.52 ghudson * Only the NFS server and emulations use cookies, and they
2502 1.52 ghudson * load the directory block into system space, so we can
2503 1.52 ghudson * just look at it directly.
2504 1.52 ghudson */
2505 1.231 yamt if (!VMSPACE_IS_KERNEL_P(uio->uio_vmspace) ||
2506 1.231 yamt uio->uio_iovcnt != 1)
2507 1.59 fvdl panic("nfs_readdir: lost in space");
2508 1.91 kleink for (nc = 0; ncookies-- &&
2509 1.91 kleink base < (char *)uio->uio_iov->iov_base; nc++){
2510 1.52 ghudson dp = (struct dirent *) base;
2511 1.52 ghudson if (dp->d_reclen == 0)
2512 1.52 ghudson break;
2513 1.85 fvdl if (nmp->nm_flag & NFSMNT_XLATECOOKIE)
2514 1.85 fvdl *(cookies++) = (off_t)NFS_GETCOOKIE32(dp);
2515 1.85 fvdl else
2516 1.85 fvdl *(cookies++) = NFS_GETCOOKIE(dp);
2517 1.52 ghudson base += dp->d_reclen;
2518 1.52 ghudson }
2519 1.91 kleink uio->uio_resid +=
2520 1.252 christos ((char *)uio->uio_iov->iov_base - base);
2521 1.91 kleink uio->uio_iov->iov_len +=
2522 1.252 christos ((char *)uio->uio_iov->iov_base - base);
2523 1.52 ghudson uio->uio_iov->iov_base = base;
2524 1.90 fvdl *ap->a_ncookies = nc;
2525 1.52 ghudson }
2526 1.52 ghudson
2527 1.81 fvdl uio->uio_resid += lost;
2528 1.59 fvdl *ap->a_eofflag = 0;
2529 1.1 cgd return (error);
2530 1.1 cgd }
2531 1.1 cgd
2532 1.1 cgd /*
2533 1.1 cgd * Readdir rpc call.
2534 1.1 cgd * Called from below the buffer cache by nfs_doio().
2535 1.1 cgd */
2536 1.32 mycroft int
2537 1.1 cgd nfs_readdirrpc(vp, uiop, cred)
2538 1.59 fvdl struct vnode *vp;
2539 1.111 augustss struct uio *uiop;
2540 1.236 elad kauth_cred_t cred;
2541 1.1 cgd {
2542 1.111 augustss int len, left;
2543 1.111 augustss struct dirent *dp = NULL;
2544 1.111 augustss u_int32_t *tl;
2545 1.252 christos char *cp;
2546 1.111 augustss int32_t t1, t2;
2547 1.252 christos char *bpos, *dpos, *cp2;
2548 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
2549 1.59 fvdl struct nfsmount *nmp = VFSTONFS(vp->v_mount);
2550 1.59 fvdl struct nfsnode *dnp = VTONFS(vp);
2551 1.59 fvdl u_quad_t fileno;
2552 1.225 christos int error = 0, more_dirs = 1, blksiz = 0, bigenough = 1;
2553 1.200 christos #ifndef NFS_V2_ONLY
2554 1.200 christos int attrflag;
2555 1.200 christos #endif
2556 1.200 christos int nrpcs = 0, reclen;
2557 1.119 bjh21 const int v3 = NFS_ISV3(vp);
2558 1.59 fvdl
2559 1.81 fvdl #ifdef DIAGNOSTIC
2560 1.81 fvdl /*
2561 1.81 fvdl * Should be called from buffer cache, so only amount of
2562 1.81 fvdl * NFS_DIRBLKSIZ will be requested.
2563 1.81 fvdl */
2564 1.219 yamt if (uiop->uio_iovcnt != 1 || uiop->uio_resid != NFS_DIRBLKSIZ)
2565 1.59 fvdl panic("nfs readdirrpc bad uio");
2566 1.59 fvdl #endif
2567 1.1 cgd
2568 1.1 cgd /*
2569 1.59 fvdl * Loop around doing readdir rpc's of size nm_readdirsize
2570 1.81 fvdl * truncated to a multiple of NFS_DIRFRAGSIZ.
2571 1.1 cgd * The stopping criteria is EOF or buffer full.
2572 1.1 cgd */
2573 1.59 fvdl while (more_dirs && bigenough) {
2574 1.85 fvdl /*
2575 1.85 fvdl * Heuristic: don't bother to do another RPC to further
2576 1.85 fvdl * fill up this block if there is not much room left. (< 50%
2577 1.85 fvdl * of the readdir RPC size). This wastes some buffer space
2578 1.85 fvdl * but can save up to 50% in RPC calls.
2579 1.85 fvdl */
2580 1.85 fvdl if (nrpcs > 0 && uiop->uio_resid < (nmp->nm_readdirsize / 2)) {
2581 1.85 fvdl bigenough = 0;
2582 1.85 fvdl break;
2583 1.85 fvdl }
2584 1.1 cgd nfsstats.rpccnt[NFSPROC_READDIR]++;
2585 1.165 drochner nfsm_reqhead(dnp, NFSPROC_READDIR, NFSX_FH(v3) +
2586 1.59 fvdl NFSX_READDIR(v3));
2587 1.165 drochner nfsm_fhtom(dnp, v3);
2588 1.200 christos #ifndef NFS_V2_ONLY
2589 1.59 fvdl if (v3) {
2590 1.59 fvdl nfsm_build(tl, u_int32_t *, 5 * NFSX_UNSIGNED);
2591 1.81 fvdl if (nmp->nm_iflag & NFSMNT_SWAPCOOKIE) {
2592 1.81 fvdl txdr_swapcookie3(uiop->uio_offset, tl);
2593 1.81 fvdl } else {
2594 1.81 fvdl txdr_cookie3(uiop->uio_offset, tl);
2595 1.81 fvdl }
2596 1.81 fvdl tl += 2;
2597 1.59 fvdl *tl++ = dnp->n_cookieverf.nfsuquad[0];
2598 1.59 fvdl *tl++ = dnp->n_cookieverf.nfsuquad[1];
2599 1.200 christos } else
2600 1.200 christos #endif
2601 1.200 christos {
2602 1.59 fvdl nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
2603 1.81 fvdl *tl++ = txdr_unsigned(uiop->uio_offset);
2604 1.59 fvdl }
2605 1.59 fvdl *tl = txdr_unsigned(nmp->nm_readdirsize);
2606 1.231 yamt nfsm_request(dnp, NFSPROC_READDIR, curlwp, cred);
2607 1.85 fvdl nrpcs++;
2608 1.200 christos #ifndef NFS_V2_ONLY
2609 1.59 fvdl if (v3) {
2610 1.153 yamt nfsm_postop_attr(vp, attrflag, 0);
2611 1.59 fvdl if (!error) {
2612 1.59 fvdl nfsm_dissect(tl, u_int32_t *,
2613 1.59 fvdl 2 * NFSX_UNSIGNED);
2614 1.59 fvdl dnp->n_cookieverf.nfsuquad[0] = *tl++;
2615 1.59 fvdl dnp->n_cookieverf.nfsuquad[1] = *tl;
2616 1.59 fvdl } else {
2617 1.59 fvdl m_freem(mrep);
2618 1.59 fvdl goto nfsmout;
2619 1.59 fvdl }
2620 1.59 fvdl }
2621 1.200 christos #endif
2622 1.53 cgd nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
2623 1.1 cgd more_dirs = fxdr_unsigned(int, *tl);
2624 1.220 perry
2625 1.1 cgd /* loop thru the dir entries, doctoring them to 4bsd form */
2626 1.59 fvdl while (more_dirs && bigenough) {
2627 1.200 christos #ifndef NFS_V2_ONLY
2628 1.59 fvdl if (v3) {
2629 1.59 fvdl nfsm_dissect(tl, u_int32_t *,
2630 1.59 fvdl 3 * NFSX_UNSIGNED);
2631 1.98 fair fileno = fxdr_hyper(tl);
2632 1.59 fvdl len = fxdr_unsigned(int, *(tl + 2));
2633 1.200 christos } else
2634 1.200 christos #endif
2635 1.200 christos {
2636 1.59 fvdl nfsm_dissect(tl, u_int32_t *,
2637 1.59 fvdl 2 * NFSX_UNSIGNED);
2638 1.59 fvdl fileno = fxdr_unsigned(u_quad_t, *tl++);
2639 1.59 fvdl len = fxdr_unsigned(int, *tl);
2640 1.59 fvdl }
2641 1.1 cgd if (len <= 0 || len > NFS_MAXNAMLEN) {
2642 1.1 cgd error = EBADRPC;
2643 1.1 cgd m_freem(mrep);
2644 1.1 cgd goto nfsmout;
2645 1.1 cgd }
2646 1.225 christos /* for cookie stashing */
2647 1.225 christos reclen = _DIRENT_RECLEN(dp, len) + 2 * sizeof(off_t);
2648 1.81 fvdl left = NFS_DIRFRAGSIZ - blksiz;
2649 1.86 thorpej if (reclen > left) {
2650 1.211 yamt memset(uiop->uio_iov->iov_base, 0, left);
2651 1.59 fvdl dp->d_reclen += left;
2652 1.225 christos UIO_ADVANCE(uiop, left);
2653 1.59 fvdl blksiz = 0;
2654 1.81 fvdl NFS_STASHCOOKIE(dp, uiop->uio_offset);
2655 1.59 fvdl }
2656 1.86 thorpej if (reclen > uiop->uio_resid)
2657 1.59 fvdl bigenough = 0;
2658 1.59 fvdl if (bigenough) {
2659 1.225 christos int tlen;
2660 1.225 christos
2661 1.59 fvdl dp = (struct dirent *)uiop->uio_iov->iov_base;
2662 1.225 christos dp->d_fileno = fileno;
2663 1.59 fvdl dp->d_namlen = len;
2664 1.86 thorpej dp->d_reclen = reclen;
2665 1.59 fvdl dp->d_type = DT_UNKNOWN;
2666 1.225 christos blksiz += reclen;
2667 1.81 fvdl if (blksiz == NFS_DIRFRAGSIZ)
2668 1.59 fvdl blksiz = 0;
2669 1.225 christos UIO_ADVANCE(uiop, DIRHDSIZ);
2670 1.59 fvdl nfsm_mtouio(uiop, len);
2671 1.225 christos tlen = reclen - (DIRHDSIZ + len);
2672 1.225 christos (void)memset(uiop->uio_iov->iov_base, 0, tlen);
2673 1.225 christos UIO_ADVANCE(uiop, tlen);
2674 1.59 fvdl } else
2675 1.59 fvdl nfsm_adv(nfsm_rndup(len));
2676 1.200 christos #ifndef NFS_V2_ONLY
2677 1.59 fvdl if (v3) {
2678 1.59 fvdl nfsm_dissect(tl, u_int32_t *,
2679 1.59 fvdl 3 * NFSX_UNSIGNED);
2680 1.220 perry } else
2681 1.200 christos #endif
2682 1.200 christos {
2683 1.59 fvdl nfsm_dissect(tl, u_int32_t *,
2684 1.59 fvdl 2 * NFSX_UNSIGNED);
2685 1.1 cgd }
2686 1.59 fvdl if (bigenough) {
2687 1.200 christos #ifndef NFS_V2_ONLY
2688 1.81 fvdl if (v3) {
2689 1.81 fvdl if (nmp->nm_iflag & NFSMNT_SWAPCOOKIE)
2690 1.81 fvdl uiop->uio_offset =
2691 1.81 fvdl fxdr_swapcookie3(tl);
2692 1.81 fvdl else
2693 1.220 perry uiop->uio_offset =
2694 1.81 fvdl fxdr_cookie3(tl);
2695 1.81 fvdl }
2696 1.200 christos else
2697 1.200 christos #endif
2698 1.200 christos {
2699 1.81 fvdl uiop->uio_offset =
2700 1.81 fvdl fxdr_unsigned(off_t, *tl);
2701 1.81 fvdl }
2702 1.81 fvdl NFS_STASHCOOKIE(dp, uiop->uio_offset);
2703 1.81 fvdl }
2704 1.81 fvdl if (v3)
2705 1.59 fvdl tl += 2;
2706 1.59 fvdl else
2707 1.59 fvdl tl++;
2708 1.1 cgd more_dirs = fxdr_unsigned(int, *tl);
2709 1.1 cgd }
2710 1.1 cgd /*
2711 1.1 cgd * If at end of rpc data, get the eof boolean
2712 1.1 cgd */
2713 1.1 cgd if (!more_dirs) {
2714 1.53 cgd nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
2715 1.1 cgd more_dirs = (fxdr_unsigned(int, *tl) == 0);
2716 1.219 yamt
2717 1.219 yamt /*
2718 1.219 yamt * kludge: if we got no entries, treat it as EOF.
2719 1.219 yamt * some server sometimes send a reply without any
2720 1.219 yamt * entries or EOF.
2721 1.219 yamt * although it might mean the server has very long name,
2722 1.219 yamt * we can't handle such entries anyway.
2723 1.219 yamt */
2724 1.219 yamt
2725 1.219 yamt if (uiop->uio_resid >= NFS_DIRBLKSIZ)
2726 1.219 yamt more_dirs = 0;
2727 1.1 cgd }
2728 1.1 cgd m_freem(mrep);
2729 1.1 cgd }
2730 1.1 cgd /*
2731 1.81 fvdl * Fill last record, iff any, out to a multiple of NFS_DIRFRAGSIZ
2732 1.1 cgd * by increasing d_reclen for the last record.
2733 1.1 cgd */
2734 1.59 fvdl if (blksiz > 0) {
2735 1.81 fvdl left = NFS_DIRFRAGSIZ - blksiz;
2736 1.211 yamt memset(uiop->uio_iov->iov_base, 0, left);
2737 1.59 fvdl dp->d_reclen += left;
2738 1.81 fvdl NFS_STASHCOOKIE(dp, uiop->uio_offset);
2739 1.225 christos UIO_ADVANCE(uiop, left);
2740 1.59 fvdl }
2741 1.59 fvdl
2742 1.59 fvdl /*
2743 1.59 fvdl * We are now either at the end of the directory or have filled the
2744 1.59 fvdl * block.
2745 1.59 fvdl */
2746 1.218 yamt if (bigenough) {
2747 1.59 fvdl dnp->n_direofoffset = uiop->uio_offset;
2748 1.218 yamt dnp->n_flag |= NEOFVALID;
2749 1.218 yamt }
2750 1.1 cgd nfsmout:
2751 1.1 cgd return (error);
2752 1.1 cgd }
2753 1.1 cgd
2754 1.200 christos #ifndef NFS_V2_ONLY
2755 1.32 mycroft /*
2756 1.59 fvdl * NFS V3 readdir plus RPC. Used in place of nfs_readdirrpc().
2757 1.32 mycroft */
2758 1.32 mycroft int
2759 1.59 fvdl nfs_readdirplusrpc(vp, uiop, cred)
2760 1.32 mycroft struct vnode *vp;
2761 1.111 augustss struct uio *uiop;
2762 1.236 elad kauth_cred_t cred;
2763 1.32 mycroft {
2764 1.111 augustss int len, left;
2765 1.111 augustss struct dirent *dp = NULL;
2766 1.111 augustss u_int32_t *tl;
2767 1.252 christos char *cp;
2768 1.111 augustss int32_t t1, t2;
2769 1.79 fvdl struct vnode *newvp;
2770 1.252 christos char *bpos, *dpos, *cp2;
2771 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
2772 1.32 mycroft struct nameidata nami, *ndp = &nami;
2773 1.32 mycroft struct componentname *cnp = &ndp->ni_cnd;
2774 1.59 fvdl struct nfsmount *nmp = VFSTONFS(vp->v_mount);
2775 1.59 fvdl struct nfsnode *dnp = VTONFS(vp), *np;
2776 1.59 fvdl nfsfh_t *fhp;
2777 1.59 fvdl u_quad_t fileno;
2778 1.225 christos int error = 0, more_dirs = 1, blksiz = 0, doit, bigenough = 1, i;
2779 1.86 thorpej int attrflag, fhsize, nrpcs = 0, reclen;
2780 1.79 fvdl struct nfs_fattr fattr, *fp;
2781 1.59 fvdl
2782 1.81 fvdl #ifdef DIAGNOSTIC
2783 1.219 yamt if (uiop->uio_iovcnt != 1 || uiop->uio_resid != NFS_DIRBLKSIZ)
2784 1.59 fvdl panic("nfs readdirplusrpc bad uio");
2785 1.59 fvdl #endif
2786 1.32 mycroft ndp->ni_dvp = vp;
2787 1.32 mycroft newvp = NULLVP;
2788 1.59 fvdl
2789 1.59 fvdl /*
2790 1.59 fvdl * Loop around doing readdir rpc's of size nm_readdirsize
2791 1.81 fvdl * truncated to a multiple of NFS_DIRFRAGSIZ.
2792 1.32 mycroft * The stopping criteria is EOF or buffer full.
2793 1.32 mycroft */
2794 1.59 fvdl while (more_dirs && bigenough) {
2795 1.85 fvdl if (nrpcs > 0 && uiop->uio_resid < (nmp->nm_readdirsize / 2)) {
2796 1.85 fvdl bigenough = 0;
2797 1.85 fvdl break;
2798 1.85 fvdl }
2799 1.59 fvdl nfsstats.rpccnt[NFSPROC_READDIRPLUS]++;
2800 1.165 drochner nfsm_reqhead(dnp, NFSPROC_READDIRPLUS,
2801 1.59 fvdl NFSX_FH(1) + 6 * NFSX_UNSIGNED);
2802 1.165 drochner nfsm_fhtom(dnp, 1);
2803 1.59 fvdl nfsm_build(tl, u_int32_t *, 6 * NFSX_UNSIGNED);
2804 1.81 fvdl if (nmp->nm_iflag & NFSMNT_SWAPCOOKIE) {
2805 1.81 fvdl txdr_swapcookie3(uiop->uio_offset, tl);
2806 1.81 fvdl } else {
2807 1.81 fvdl txdr_cookie3(uiop->uio_offset, tl);
2808 1.81 fvdl }
2809 1.81 fvdl tl += 2;
2810 1.59 fvdl *tl++ = dnp->n_cookieverf.nfsuquad[0];
2811 1.59 fvdl *tl++ = dnp->n_cookieverf.nfsuquad[1];
2812 1.59 fvdl *tl++ = txdr_unsigned(nmp->nm_readdirsize);
2813 1.59 fvdl *tl = txdr_unsigned(nmp->nm_rsize);
2814 1.231 yamt nfsm_request(dnp, NFSPROC_READDIRPLUS, curlwp, cred);
2815 1.153 yamt nfsm_postop_attr(vp, attrflag, 0);
2816 1.59 fvdl if (error) {
2817 1.59 fvdl m_freem(mrep);
2818 1.59 fvdl goto nfsmout;
2819 1.59 fvdl }
2820 1.85 fvdl nrpcs++;
2821 1.59 fvdl nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
2822 1.59 fvdl dnp->n_cookieverf.nfsuquad[0] = *tl++;
2823 1.59 fvdl dnp->n_cookieverf.nfsuquad[1] = *tl++;
2824 1.32 mycroft more_dirs = fxdr_unsigned(int, *tl);
2825 1.220 perry
2826 1.32 mycroft /* loop thru the dir entries, doctoring them to 4bsd form */
2827 1.32 mycroft while (more_dirs && bigenough) {
2828 1.59 fvdl nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
2829 1.98 fair fileno = fxdr_hyper(tl);
2830 1.59 fvdl len = fxdr_unsigned(int, *(tl + 2));
2831 1.32 mycroft if (len <= 0 || len > NFS_MAXNAMLEN) {
2832 1.32 mycroft error = EBADRPC;
2833 1.32 mycroft m_freem(mrep);
2834 1.32 mycroft goto nfsmout;
2835 1.32 mycroft }
2836 1.225 christos /* for cookie stashing */
2837 1.226 yamt reclen = _DIRENT_RECLEN(dp, len) + 2 * sizeof(off_t);
2838 1.81 fvdl left = NFS_DIRFRAGSIZ - blksiz;
2839 1.86 thorpej if (reclen > left) {
2840 1.86 thorpej /*
2841 1.86 thorpej * DIRFRAGSIZ is aligned, no need to align
2842 1.86 thorpej * again here.
2843 1.86 thorpej */
2844 1.211 yamt memset(uiop->uio_iov->iov_base, 0, left);
2845 1.59 fvdl dp->d_reclen += left;
2846 1.225 christos UIO_ADVANCE(uiop, left);
2847 1.81 fvdl NFS_STASHCOOKIE(dp, uiop->uio_offset);
2848 1.59 fvdl blksiz = 0;
2849 1.59 fvdl }
2850 1.86 thorpej if (reclen > uiop->uio_resid)
2851 1.32 mycroft bigenough = 0;
2852 1.59 fvdl if (bigenough) {
2853 1.225 christos int tlen;
2854 1.225 christos
2855 1.32 mycroft dp = (struct dirent *)uiop->uio_iov->iov_base;
2856 1.225 christos dp->d_fileno = fileno;
2857 1.32 mycroft dp->d_namlen = len;
2858 1.86 thorpej dp->d_reclen = reclen;
2859 1.59 fvdl dp->d_type = DT_UNKNOWN;
2860 1.225 christos blksiz += reclen;
2861 1.81 fvdl if (blksiz == NFS_DIRFRAGSIZ)
2862 1.59 fvdl blksiz = 0;
2863 1.225 christos UIO_ADVANCE(uiop, DIRHDSIZ);
2864 1.32 mycroft nfsm_mtouio(uiop, len);
2865 1.225 christos tlen = reclen - (DIRHDSIZ + len);
2866 1.225 christos (void)memset(uiop->uio_iov->iov_base, 0, tlen);
2867 1.225 christos UIO_ADVANCE(uiop, tlen);
2868 1.225 christos cnp->cn_nameptr = dp->d_name;
2869 1.225 christos cnp->cn_namelen = dp->d_namlen;
2870 1.59 fvdl } else
2871 1.59 fvdl nfsm_adv(nfsm_rndup(len));
2872 1.59 fvdl nfsm_dissect(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
2873 1.59 fvdl if (bigenough) {
2874 1.81 fvdl if (nmp->nm_iflag & NFSMNT_SWAPCOOKIE)
2875 1.81 fvdl uiop->uio_offset =
2876 1.81 fvdl fxdr_swapcookie3(tl);
2877 1.81 fvdl else
2878 1.81 fvdl uiop->uio_offset =
2879 1.81 fvdl fxdr_cookie3(tl);
2880 1.81 fvdl NFS_STASHCOOKIE(dp, uiop->uio_offset);
2881 1.81 fvdl }
2882 1.81 fvdl tl += 2;
2883 1.59 fvdl
2884 1.59 fvdl /*
2885 1.59 fvdl * Since the attributes are before the file handle
2886 1.59 fvdl * (sigh), we must skip over the attributes and then
2887 1.59 fvdl * come back and get them.
2888 1.59 fvdl */
2889 1.59 fvdl attrflag = fxdr_unsigned(int, *tl);
2890 1.59 fvdl if (attrflag) {
2891 1.79 fvdl nfsm_dissect(fp, struct nfs_fattr *, NFSX_V3FATTR);
2892 1.97 perry memcpy(&fattr, fp, NFSX_V3FATTR);
2893 1.59 fvdl nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
2894 1.59 fvdl doit = fxdr_unsigned(int, *tl);
2895 1.59 fvdl if (doit) {
2896 1.59 fvdl nfsm_getfh(fhp, fhsize, 1);
2897 1.59 fvdl if (NFS_CMPFH(dnp, fhp, fhsize)) {
2898 1.59 fvdl VREF(vp);
2899 1.59 fvdl newvp = vp;
2900 1.59 fvdl np = dnp;
2901 1.59 fvdl } else {
2902 1.191 yamt error = nfs_nget1(vp->v_mount, fhp,
2903 1.191 yamt fhsize, &np, LK_NOWAIT);
2904 1.79 fvdl if (!error)
2905 1.59 fvdl newvp = NFSTOV(np);
2906 1.59 fvdl }
2907 1.79 fvdl if (!error) {
2908 1.222 christos const char *xcp;
2909 1.147 lukem
2910 1.153 yamt nfs_loadattrcache(&newvp, &fattr, 0, 0);
2911 1.208 yamt if (bigenough) {
2912 1.208 yamt dp->d_type =
2913 1.208 yamt IFTODT(VTTOIF(np->n_vattr->va_type));
2914 1.208 yamt if (cnp->cn_namelen <= NCHNAMLEN) {
2915 1.208 yamt ndp->ni_vp = newvp;
2916 1.222 christos xcp = cnp->cn_nameptr +
2917 1.208 yamt cnp->cn_namelen;
2918 1.208 yamt cnp->cn_hash =
2919 1.222 christos namei_hash(cnp->cn_nameptr, &xcp);
2920 1.208 yamt nfs_cache_enter(ndp->ni_dvp,
2921 1.208 yamt ndp->ni_vp, cnp);
2922 1.208 yamt }
2923 1.208 yamt }
2924 1.79 fvdl }
2925 1.209 yamt error = 0;
2926 1.79 fvdl }
2927 1.32 mycroft } else {
2928 1.59 fvdl /* Just skip over the file handle */
2929 1.59 fvdl nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
2930 1.59 fvdl i = fxdr_unsigned(int, *tl);
2931 1.59 fvdl nfsm_adv(nfsm_rndup(i));
2932 1.32 mycroft }
2933 1.32 mycroft if (newvp != NULLVP) {
2934 1.220 perry if (newvp == vp)
2935 1.220 perry vrele(newvp);
2936 1.220 perry else
2937 1.151 tls vput(newvp);
2938 1.59 fvdl newvp = NULLVP;
2939 1.32 mycroft }
2940 1.59 fvdl nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
2941 1.32 mycroft more_dirs = fxdr_unsigned(int, *tl);
2942 1.32 mycroft }
2943 1.32 mycroft /*
2944 1.32 mycroft * If at end of rpc data, get the eof boolean
2945 1.32 mycroft */
2946 1.32 mycroft if (!more_dirs) {
2947 1.53 cgd nfsm_dissect(tl, u_int32_t *, NFSX_UNSIGNED);
2948 1.32 mycroft more_dirs = (fxdr_unsigned(int, *tl) == 0);
2949 1.219 yamt
2950 1.219 yamt /*
2951 1.219 yamt * kludge: see a comment in nfs_readdirrpc.
2952 1.219 yamt */
2953 1.219 yamt
2954 1.219 yamt if (uiop->uio_resid >= NFS_DIRBLKSIZ)
2955 1.219 yamt more_dirs = 0;
2956 1.32 mycroft }
2957 1.32 mycroft m_freem(mrep);
2958 1.32 mycroft }
2959 1.32 mycroft /*
2960 1.81 fvdl * Fill last record, iff any, out to a multiple of NFS_DIRFRAGSIZ
2961 1.32 mycroft * by increasing d_reclen for the last record.
2962 1.32 mycroft */
2963 1.59 fvdl if (blksiz > 0) {
2964 1.81 fvdl left = NFS_DIRFRAGSIZ - blksiz;
2965 1.211 yamt memset(uiop->uio_iov->iov_base, 0, left);
2966 1.59 fvdl dp->d_reclen += left;
2967 1.81 fvdl NFS_STASHCOOKIE(dp, uiop->uio_offset);
2968 1.225 christos UIO_ADVANCE(uiop, left);
2969 1.59 fvdl }
2970 1.59 fvdl
2971 1.59 fvdl /*
2972 1.59 fvdl * We are now either at the end of the directory or have filled the
2973 1.59 fvdl * block.
2974 1.59 fvdl */
2975 1.218 yamt if (bigenough) {
2976 1.59 fvdl dnp->n_direofoffset = uiop->uio_offset;
2977 1.218 yamt dnp->n_flag |= NEOFVALID;
2978 1.218 yamt }
2979 1.32 mycroft nfsmout:
2980 1.128 fvdl if (newvp != NULLVP) {
2981 1.151 tls if(newvp == vp)
2982 1.151 tls vrele(newvp);
2983 1.151 tls else
2984 1.151 tls vput(newvp);
2985 1.128 fvdl }
2986 1.32 mycroft return (error);
2987 1.32 mycroft }
2988 1.200 christos #endif
2989 1.200 christos
2990 1.1 cgd /*
2991 1.1 cgd * Silly rename. To make the NFS filesystem that is stateless look a little
2992 1.1 cgd * more like the "ufs" a remove of an active vnode is translated to a rename
2993 1.1 cgd * to a funny looking filename that is removed by nfs_inactive on the
2994 1.1 cgd * nfsnode. There is the potential for another process on a different client
2995 1.1 cgd * to create the same funny name between the nfs_lookitup() fails and the
2996 1.1 cgd * nfs_rename() completes, but...
2997 1.1 cgd */
2998 1.32 mycroft int
2999 1.239 yamt nfs_sillyrename(dvp, vp, cnp, dolink)
3000 1.32 mycroft struct vnode *dvp, *vp;
3001 1.32 mycroft struct componentname *cnp;
3002 1.250 thorpej bool dolink;
3003 1.1 cgd {
3004 1.111 augustss struct sillyrename *sp;
3005 1.59 fvdl struct nfsnode *np;
3006 1.1 cgd int error;
3007 1.1 cgd short pid;
3008 1.1 cgd
3009 1.32 mycroft cache_purge(dvp);
3010 1.32 mycroft np = VTONFS(vp);
3011 1.59 fvdl #ifndef DIAGNOSTIC
3012 1.59 fvdl if (vp->v_type == VDIR)
3013 1.59 fvdl panic("nfs: sillyrename dir");
3014 1.59 fvdl #endif
3015 1.264 yamt sp = kmem_alloc(sizeof(*sp), KM_SLEEP);
3016 1.236 elad sp->s_cred = kauth_cred_dup(cnp->cn_cred);
3017 1.32 mycroft sp->s_dvp = dvp;
3018 1.32 mycroft VREF(dvp);
3019 1.1 cgd
3020 1.1 cgd /* Fudge together a funny name */
3021 1.261 pooka pid = curlwp->l_proc->p_pid;
3022 1.97 perry memcpy(sp->s_name, ".nfsAxxxx4.4", 13);
3023 1.1 cgd sp->s_namlen = 12;
3024 1.221 christos sp->s_name[8] = hexdigits[pid & 0xf];
3025 1.221 christos sp->s_name[7] = hexdigits[(pid >> 4) & 0xf];
3026 1.221 christos sp->s_name[6] = hexdigits[(pid >> 8) & 0xf];
3027 1.221 christos sp->s_name[5] = hexdigits[(pid >> 12) & 0xf];
3028 1.1 cgd
3029 1.1 cgd /* Try lookitups until we get one that isn't there */
3030 1.59 fvdl while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
3031 1.261 pooka curlwp, (struct nfsnode **)0) == 0) {
3032 1.1 cgd sp->s_name[4]++;
3033 1.1 cgd if (sp->s_name[4] > 'z') {
3034 1.1 cgd error = EINVAL;
3035 1.1 cgd goto bad;
3036 1.1 cgd }
3037 1.1 cgd }
3038 1.239 yamt if (dolink) {
3039 1.239 yamt error = nfs_linkrpc(dvp, vp, sp->s_name, sp->s_namlen,
3040 1.261 pooka sp->s_cred, curlwp);
3041 1.239 yamt /*
3042 1.239 yamt * nfs_request maps NFSERR_NOTSUPP to ENOTSUP.
3043 1.239 yamt */
3044 1.239 yamt if (error == ENOTSUP) {
3045 1.239 yamt error = nfs_renameit(dvp, cnp, sp);
3046 1.239 yamt }
3047 1.239 yamt } else {
3048 1.239 yamt error = nfs_renameit(dvp, cnp, sp);
3049 1.239 yamt }
3050 1.59 fvdl if (error)
3051 1.1 cgd goto bad;
3052 1.59 fvdl error = nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
3053 1.261 pooka curlwp, &np);
3054 1.1 cgd np->n_sillyrename = sp;
3055 1.1 cgd return (0);
3056 1.1 cgd bad:
3057 1.1 cgd vrele(sp->s_dvp);
3058 1.236 elad kauth_cred_free(sp->s_cred);
3059 1.264 yamt kmem_free(sp, sizeof(*sp));
3060 1.1 cgd return (error);
3061 1.1 cgd }
3062 1.1 cgd
3063 1.1 cgd /*
3064 1.59 fvdl * Look up a file name and optionally either update the file handle or
3065 1.59 fvdl * allocate an nfsnode, depending on the value of npp.
3066 1.59 fvdl * npp == NULL --> just do the lookup
3067 1.59 fvdl * *npp == NULL --> allocate a new nfsnode and make sure attributes are
3068 1.59 fvdl * handled too
3069 1.59 fvdl * *npp != NULL --> update the file handle in the vnode
3070 1.1 cgd */
3071 1.32 mycroft int
3072 1.230 christos nfs_lookitup(dvp, name, len, cred, l, npp)
3073 1.111 augustss struct vnode *dvp;
3074 1.68 cgd const char *name;
3075 1.59 fvdl int len;
3076 1.236 elad kauth_cred_t cred;
3077 1.230 christos struct lwp *l;
3078 1.59 fvdl struct nfsnode **npp;
3079 1.1 cgd {
3080 1.111 augustss u_int32_t *tl;
3081 1.252 christos char *cp;
3082 1.111 augustss int32_t t1, t2;
3083 1.59 fvdl struct vnode *newvp = (struct vnode *)0;
3084 1.59 fvdl struct nfsnode *np, *dnp = VTONFS(dvp);
3085 1.252 christos char *bpos, *dpos, *cp2;
3086 1.200 christos int error = 0, fhlen;
3087 1.200 christos #ifndef NFS_V2_ONLY
3088 1.200 christos int attrflag;
3089 1.200 christos #endif
3090 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
3091 1.59 fvdl nfsfh_t *nfhp;
3092 1.119 bjh21 const int v3 = NFS_ISV3(dvp);
3093 1.1 cgd
3094 1.1 cgd nfsstats.rpccnt[NFSPROC_LOOKUP]++;
3095 1.165 drochner nfsm_reqhead(dnp, NFSPROC_LOOKUP,
3096 1.59 fvdl NFSX_FH(v3) + NFSX_UNSIGNED + nfsm_rndup(len));
3097 1.165 drochner nfsm_fhtom(dnp, v3);
3098 1.59 fvdl nfsm_strtom(name, len, NFS_MAXNAMLEN);
3099 1.230 christos nfsm_request(dnp, NFSPROC_LOOKUP, l, cred);
3100 1.59 fvdl if (npp && !error) {
3101 1.59 fvdl nfsm_getfh(nfhp, fhlen, v3);
3102 1.59 fvdl if (*npp) {
3103 1.59 fvdl np = *npp;
3104 1.59 fvdl if (np->n_fhsize > NFS_SMALLFH && fhlen <= NFS_SMALLFH) {
3105 1.264 yamt kmem_free(np->n_fhp, np->n_fhsize);
3106 1.59 fvdl np->n_fhp = &np->n_fh;
3107 1.235 christos }
3108 1.235 christos #if NFS_SMALLFH < NFSX_V3FHMAX
3109 1.264 yamt else if (np->n_fhsize <= NFS_SMALLFH && fhlen > NFS_SMALLFH)
3110 1.264 yamt np->n_fhp = kmem_alloc(fhlen, KM_SLEEP);
3111 1.235 christos #endif
3112 1.264 yamt memcpy(np->n_fhp, nfhp, fhlen);
3113 1.59 fvdl np->n_fhsize = fhlen;
3114 1.59 fvdl newvp = NFSTOV(np);
3115 1.59 fvdl } else if (NFS_CMPFH(dnp, nfhp, fhlen)) {
3116 1.59 fvdl VREF(dvp);
3117 1.59 fvdl newvp = dvp;
3118 1.194 yamt np = dnp;
3119 1.59 fvdl } else {
3120 1.175 fvdl error = nfs_nget(dvp->v_mount, nfhp, fhlen, &np);
3121 1.59 fvdl if (error) {
3122 1.59 fvdl m_freem(mrep);
3123 1.59 fvdl return (error);
3124 1.59 fvdl }
3125 1.59 fvdl newvp = NFSTOV(np);
3126 1.59 fvdl }
3127 1.200 christos #ifndef NFS_V2_ONLY
3128 1.59 fvdl if (v3) {
3129 1.153 yamt nfsm_postop_attr(newvp, attrflag, 0);
3130 1.59 fvdl if (!attrflag && *npp == NULL) {
3131 1.59 fvdl m_freem(mrep);
3132 1.128 fvdl vput(newvp);
3133 1.59 fvdl return (ENOENT);
3134 1.59 fvdl }
3135 1.59 fvdl } else
3136 1.200 christos #endif
3137 1.153 yamt nfsm_loadattr(newvp, (struct vattr *)0, 0);
3138 1.59 fvdl }
3139 1.59 fvdl nfsm_reqdone;
3140 1.59 fvdl if (npp && *npp == NULL) {
3141 1.59 fvdl if (error) {
3142 1.59 fvdl if (newvp)
3143 1.128 fvdl vput(newvp);
3144 1.59 fvdl } else
3145 1.59 fvdl *npp = np;
3146 1.32 mycroft }
3147 1.59 fvdl return (error);
3148 1.59 fvdl }
3149 1.59 fvdl
3150 1.200 christos #ifndef NFS_V2_ONLY
3151 1.59 fvdl /*
3152 1.59 fvdl * Nfs Version 3 commit rpc
3153 1.59 fvdl */
3154 1.59 fvdl int
3155 1.230 christos nfs_commit(vp, offset, cnt, l)
3156 1.111 augustss struct vnode *vp;
3157 1.124 chs off_t offset;
3158 1.124 chs uint32_t cnt;
3159 1.230 christos struct lwp *l;
3160 1.59 fvdl {
3161 1.252 christos char *cp;
3162 1.111 augustss u_int32_t *tl;
3163 1.111 augustss int32_t t1, t2;
3164 1.111 augustss struct nfsmount *nmp = VFSTONFS(vp->v_mount);
3165 1.252 christos char *bpos, *dpos, *cp2;
3166 1.59 fvdl int error = 0, wccflag = NFSV3_WCCRATTR;
3167 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
3168 1.165 drochner struct nfsnode *np;
3169 1.120 fvdl
3170 1.166 yamt KASSERT(NFS_ISV3(vp));
3171 1.166 yamt
3172 1.160 yamt #ifdef NFS_DEBUG_COMMIT
3173 1.120 fvdl printf("commit %lu - %lu\n", (unsigned long)offset,
3174 1.120 fvdl (unsigned long)(offset + cnt));
3175 1.120 fvdl #endif
3176 1.220 perry
3177 1.254 yamt mutex_enter(&nmp->nm_lock);
3178 1.166 yamt if ((nmp->nm_iflag & NFSMNT_HASWRITEVERF) == 0) {
3179 1.254 yamt mutex_exit(&nmp->nm_lock);
3180 1.59 fvdl return (0);
3181 1.166 yamt }
3182 1.254 yamt mutex_exit(&nmp->nm_lock);
3183 1.59 fvdl nfsstats.rpccnt[NFSPROC_COMMIT]++;
3184 1.165 drochner np = VTONFS(vp);
3185 1.165 drochner nfsm_reqhead(np, NFSPROC_COMMIT, NFSX_FH(1));
3186 1.165 drochner nfsm_fhtom(np, 1);
3187 1.59 fvdl nfsm_build(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
3188 1.98 fair txdr_hyper(offset, tl);
3189 1.59 fvdl tl += 2;
3190 1.59 fvdl *tl = txdr_unsigned(cnt);
3191 1.230 christos nfsm_request(np, NFSPROC_COMMIT, l, np->n_wcred);
3192 1.251 thorpej nfsm_wcc_data(vp, wccflag, NAC_NOTRUNC, false);
3193 1.59 fvdl if (!error) {
3194 1.59 fvdl nfsm_dissect(tl, u_int32_t *, NFSX_V3WRITEVERF);
3195 1.254 yamt mutex_enter(&nmp->nm_lock);
3196 1.166 yamt if ((nmp->nm_iflag & NFSMNT_STALEWRITEVERF) ||
3197 1.166 yamt memcmp(nmp->nm_writeverf, tl, NFSX_V3WRITEVERF)) {
3198 1.166 yamt memcpy(nmp->nm_writeverf, tl, NFSX_V3WRITEVERF);
3199 1.59 fvdl error = NFSERR_STALEWRITEVERF;
3200 1.166 yamt nmp->nm_iflag |= NFSMNT_STALEWRITEVERF;
3201 1.59 fvdl }
3202 1.254 yamt mutex_exit(&nmp->nm_lock);
3203 1.1 cgd }
3204 1.1 cgd nfsm_reqdone;
3205 1.1 cgd return (error);
3206 1.1 cgd }
3207 1.200 christos #endif
3208 1.1 cgd
3209 1.1 cgd /*
3210 1.1 cgd * Kludge City..
3211 1.1 cgd * - make nfs_bmap() essentially a no-op that does no translation
3212 1.59 fvdl * - do nfs_strategy() by doing I/O with nfs_readrpc/nfs_writerpc
3213 1.1 cgd * (Maybe I could use the process's page mapping, but I was concerned that
3214 1.1 cgd * Kernel Write might not be enabled and also figured copyout() would do
3215 1.97 perry * a lot more work than memcpy() and also it currently happens in the
3216 1.1 cgd * context of the swapper process (2).
3217 1.1 cgd */
3218 1.32 mycroft int
3219 1.58 christos nfs_bmap(v)
3220 1.58 christos void *v;
3221 1.58 christos {
3222 1.32 mycroft struct vop_bmap_args /* {
3223 1.32 mycroft struct vnode *a_vp;
3224 1.32 mycroft daddr_t a_bn;
3225 1.32 mycroft struct vnode **a_vpp;
3226 1.32 mycroft daddr_t *a_bnp;
3227 1.32 mycroft int *a_runp;
3228 1.58 christos } */ *ap = v;
3229 1.111 augustss struct vnode *vp = ap->a_vp;
3230 1.139 chs int bshift = vp->v_mount->mnt_fs_bshift - vp->v_mount->mnt_dev_bshift;
3231 1.32 mycroft
3232 1.32 mycroft if (ap->a_vpp != NULL)
3233 1.32 mycroft *ap->a_vpp = vp;
3234 1.32 mycroft if (ap->a_bnp != NULL)
3235 1.139 chs *ap->a_bnp = ap->a_bn << bshift;
3236 1.138 chs if (ap->a_runp != NULL)
3237 1.138 chs *ap->a_runp = 1024 * 1024; /* XXX */
3238 1.1 cgd return (0);
3239 1.1 cgd }
3240 1.1 cgd
3241 1.1 cgd /*
3242 1.32 mycroft * Strategy routine.
3243 1.32 mycroft * For async requests when nfsiod(s) are running, queue the request by
3244 1.32 mycroft * calling nfs_asyncio(), otherwise just all nfs_doio() to do the
3245 1.32 mycroft * request.
3246 1.1 cgd */
3247 1.32 mycroft int
3248 1.58 christos nfs_strategy(v)
3249 1.58 christos void *v;
3250 1.1 cgd {
3251 1.58 christos struct vop_strategy_args *ap = v;
3252 1.111 augustss struct buf *bp = ap->a_bp;
3253 1.1 cgd int error = 0;
3254 1.1 cgd
3255 1.33 pk if ((bp->b_flags & (B_PHYS|B_ASYNC)) == (B_PHYS|B_ASYNC))
3256 1.33 pk panic("nfs physio/async");
3257 1.124 chs
3258 1.1 cgd /*
3259 1.1 cgd * If the op is asynchronous and an i/o daemon is waiting
3260 1.1 cgd * queue the request, wake it up and wait for completion
3261 1.1 cgd * otherwise just do it ourselves.
3262 1.1 cgd */
3263 1.223 christos if ((bp->b_flags & B_ASYNC) == 0 || nfs_asyncio(bp))
3264 1.223 christos error = nfs_doio(bp);
3265 1.1 cgd return (error);
3266 1.1 cgd }
3267 1.1 cgd
3268 1.1 cgd /*
3269 1.59 fvdl * fsync vnode op. Just call nfs_flush() with commit == 1.
3270 1.1 cgd */
3271 1.1 cgd /* ARGSUSED */
3272 1.32 mycroft int
3273 1.58 christos nfs_fsync(v)
3274 1.58 christos void *v;
3275 1.58 christos {
3276 1.32 mycroft struct vop_fsync_args /* {
3277 1.32 mycroft struct vnodeop_desc *a_desc;
3278 1.32 mycroft struct vnode * a_vp;
3279 1.236 elad kauth_cred_t a_cred;
3280 1.92 kleink int a_flags;
3281 1.120 fvdl off_t offlo;
3282 1.120 fvdl off_t offhi;
3283 1.230 christos struct lwp * a_l;
3284 1.58 christos } */ *ap = v;
3285 1.59 fvdl
3286 1.186 yamt struct vnode *vp = ap->a_vp;
3287 1.186 yamt
3288 1.186 yamt if (vp->v_type != VREG)
3289 1.186 yamt return 0;
3290 1.186 yamt
3291 1.186 yamt return (nfs_flush(vp, ap->a_cred,
3292 1.260 pooka (ap->a_flags & FSYNC_WAIT) != 0 ? MNT_WAIT : 0, curlwp, 1));
3293 1.59 fvdl }
3294 1.59 fvdl
3295 1.59 fvdl /*
3296 1.124 chs * Flush all the data associated with a vnode.
3297 1.59 fvdl */
3298 1.59 fvdl int
3299 1.245 yamt nfs_flush(struct vnode *vp, kauth_cred_t cred, int waitfor, struct lwp *l,
3300 1.245 yamt int commit)
3301 1.59 fvdl {
3302 1.111 augustss struct nfsnode *np = VTONFS(vp);
3303 1.124 chs int error;
3304 1.124 chs int flushflags = PGO_ALLPAGES|PGO_CLEANIT|PGO_SYNCIO;
3305 1.124 chs UVMHIST_FUNC("nfs_flush"); UVMHIST_CALLED(ubchist);
3306 1.1 cgd
3307 1.263 ad mutex_enter(&vp->v_interlock);
3308 1.145 chs error = VOP_PUTPAGES(vp, 0, 0, flushflags);
3309 1.32 mycroft if (np->n_flag & NWRITEERR) {
3310 1.1 cgd error = np->n_error;
3311 1.32 mycroft np->n_flag &= ~NWRITEERR;
3312 1.32 mycroft }
3313 1.124 chs UVMHIST_LOG(ubchist, "returning %d", error,0,0,0);
3314 1.1 cgd return (error);
3315 1.1 cgd }
3316 1.1 cgd
3317 1.1 cgd /*
3318 1.32 mycroft * Return POSIX pathconf information applicable to nfs.
3319 1.32 mycroft *
3320 1.95 kleink * N.B. The NFS V2 protocol doesn't support this RPC.
3321 1.32 mycroft */
3322 1.32 mycroft /* ARGSUSED */
3323 1.58 christos int
3324 1.58 christos nfs_pathconf(v)
3325 1.58 christos void *v;
3326 1.58 christos {
3327 1.32 mycroft struct vop_pathconf_args /* {
3328 1.32 mycroft struct vnode *a_vp;
3329 1.32 mycroft int a_name;
3330 1.41 cgd register_t *a_retval;
3331 1.58 christos } */ *ap = v;
3332 1.95 kleink struct nfsv3_pathconf *pcp;
3333 1.95 kleink struct vnode *vp = ap->a_vp;
3334 1.159 matt struct mbuf *mreq, *mrep, *md, *mb;
3335 1.95 kleink int32_t t1, t2;
3336 1.95 kleink u_int32_t *tl;
3337 1.252 christos char *bpos, *dpos, *cp, *cp2;
3338 1.95 kleink int error = 0, attrflag;
3339 1.146 christos #ifndef NFS_V2_ONLY
3340 1.146 christos struct nfsmount *nmp;
3341 1.99 kleink unsigned int l;
3342 1.99 kleink u_int64_t maxsize;
3343 1.146 christos #endif
3344 1.119 bjh21 const int v3 = NFS_ISV3(vp);
3345 1.165 drochner struct nfsnode *np = VTONFS(vp);
3346 1.95 kleink
3347 1.95 kleink switch (ap->a_name) {
3348 1.95 kleink /* Names that can be resolved locally. */
3349 1.95 kleink case _PC_PIPE_BUF:
3350 1.95 kleink *ap->a_retval = PIPE_BUF;
3351 1.95 kleink break;
3352 1.95 kleink case _PC_SYNC_IO:
3353 1.95 kleink *ap->a_retval = 1;
3354 1.95 kleink break;
3355 1.95 kleink /* Names that cannot be resolved locally; do an RPC, if possible. */
3356 1.95 kleink case _PC_LINK_MAX:
3357 1.95 kleink case _PC_NAME_MAX:
3358 1.95 kleink case _PC_CHOWN_RESTRICTED:
3359 1.95 kleink case _PC_NO_TRUNC:
3360 1.95 kleink if (!v3) {
3361 1.96 kleink error = EINVAL;
3362 1.95 kleink break;
3363 1.95 kleink }
3364 1.95 kleink nfsstats.rpccnt[NFSPROC_PATHCONF]++;
3365 1.165 drochner nfsm_reqhead(np, NFSPROC_PATHCONF, NFSX_FH(1));
3366 1.165 drochner nfsm_fhtom(np, 1);
3367 1.165 drochner nfsm_request(np, NFSPROC_PATHCONF,
3368 1.241 ad curlwp, curlwp->l_cred); /* XXX */
3369 1.153 yamt nfsm_postop_attr(vp, attrflag, 0);
3370 1.95 kleink if (!error) {
3371 1.95 kleink nfsm_dissect(pcp, struct nfsv3_pathconf *,
3372 1.95 kleink NFSX_V3PATHCONF);
3373 1.95 kleink switch (ap->a_name) {
3374 1.95 kleink case _PC_LINK_MAX:
3375 1.95 kleink *ap->a_retval =
3376 1.95 kleink fxdr_unsigned(register_t, pcp->pc_linkmax);
3377 1.95 kleink break;
3378 1.95 kleink case _PC_NAME_MAX:
3379 1.95 kleink *ap->a_retval =
3380 1.95 kleink fxdr_unsigned(register_t, pcp->pc_namemax);
3381 1.95 kleink break;
3382 1.95 kleink case _PC_CHOWN_RESTRICTED:
3383 1.95 kleink *ap->a_retval =
3384 1.95 kleink (pcp->pc_chownrestricted == nfs_true);
3385 1.95 kleink break;
3386 1.95 kleink case _PC_NO_TRUNC:
3387 1.95 kleink *ap->a_retval =
3388 1.95 kleink (pcp->pc_notrunc == nfs_true);
3389 1.95 kleink break;
3390 1.95 kleink }
3391 1.95 kleink }
3392 1.95 kleink nfsm_reqdone;
3393 1.99 kleink break;
3394 1.99 kleink case _PC_FILESIZEBITS:
3395 1.146 christos #ifndef NFS_V2_ONLY
3396 1.99 kleink if (v3) {
3397 1.99 kleink nmp = VFSTONFS(vp->v_mount);
3398 1.99 kleink if ((nmp->nm_iflag & NFSMNT_GOTFSINFO) == 0)
3399 1.99 kleink if ((error = nfs_fsinfo(nmp, vp,
3400 1.241 ad curlwp->l_cred, curlwp)) != 0) /* XXX */
3401 1.99 kleink break;
3402 1.99 kleink for (l = 0, maxsize = nmp->nm_maxfilesize;
3403 1.99 kleink (maxsize >> l) > 0; l++)
3404 1.99 kleink ;
3405 1.99 kleink *ap->a_retval = l + 1;
3406 1.146 christos } else
3407 1.146 christos #endif
3408 1.146 christos {
3409 1.99 kleink *ap->a_retval = 32; /* NFS V2 limitation */
3410 1.99 kleink }
3411 1.95 kleink break;
3412 1.95 kleink default:
3413 1.95 kleink error = EINVAL;
3414 1.95 kleink break;
3415 1.95 kleink }
3416 1.32 mycroft
3417 1.95 kleink return (error);
3418 1.32 mycroft }
3419 1.32 mycroft
3420 1.32 mycroft /*
3421 1.1 cgd * NFS advisory byte-level locks.
3422 1.1 cgd */
3423 1.32 mycroft int
3424 1.58 christos nfs_advlock(v)
3425 1.58 christos void *v;
3426 1.58 christos {
3427 1.32 mycroft struct vop_advlock_args /* {
3428 1.32 mycroft struct vnode *a_vp;
3429 1.252 christos void *a_id;
3430 1.32 mycroft int a_op;
3431 1.32 mycroft struct flock *a_fl;
3432 1.32 mycroft int a_flags;
3433 1.58 christos } */ *ap = v;
3434 1.111 augustss struct nfsnode *np = VTONFS(ap->a_vp);
3435 1.1 cgd
3436 1.115 jdolecek return lf_advlock(ap, &np->n_lockf, np->n_size);
3437 1.1 cgd }
3438 1.1 cgd
3439 1.1 cgd /*
3440 1.1 cgd * Print out the contents of an nfsnode.
3441 1.1 cgd */
3442 1.17 cgd int
3443 1.58 christos nfs_print(v)
3444 1.58 christos void *v;
3445 1.58 christos {
3446 1.32 mycroft struct vop_print_args /* {
3447 1.32 mycroft struct vnode *a_vp;
3448 1.58 christos } */ *ap = v;
3449 1.111 augustss struct vnode *vp = ap->a_vp;
3450 1.111 augustss struct nfsnode *np = VTONFS(vp);
3451 1.1 cgd
3452 1.225 christos printf("tag VT_NFS, fileid %lld fsid 0x%lx",
3453 1.225 christos (unsigned long long)np->n_vattr->va_fileid, np->n_vattr->va_fsid);
3454 1.1 cgd if (vp->v_type == VFIFO)
3455 1.1 cgd fifo_printinfo(vp);
3456 1.67 christos printf("\n");
3457 1.59 fvdl return (0);
3458 1.32 mycroft }
3459 1.32 mycroft
3460 1.32 mycroft /*
3461 1.153 yamt * nfs unlock wrapper.
3462 1.153 yamt */
3463 1.153 yamt int
3464 1.153 yamt nfs_unlock(void *v)
3465 1.153 yamt {
3466 1.153 yamt struct vop_unlock_args /* {
3467 1.153 yamt struct vnode *a_vp;
3468 1.153 yamt int a_flags;
3469 1.153 yamt } */ *ap = v;
3470 1.153 yamt struct vnode *vp = ap->a_vp;
3471 1.153 yamt
3472 1.155 yamt /*
3473 1.155 yamt * VOP_UNLOCK can be called by nfs_loadattrcache
3474 1.155 yamt * with v_data == 0.
3475 1.155 yamt */
3476 1.155 yamt if (VTONFS(vp)) {
3477 1.155 yamt nfs_delayedtruncate(vp);
3478 1.155 yamt }
3479 1.153 yamt
3480 1.153 yamt return genfs_unlock(v);
3481 1.59 fvdl }
3482 1.59 fvdl
3483 1.59 fvdl /*
3484 1.32 mycroft * nfs special file access vnode op.
3485 1.32 mycroft * Essentially just get vattr and then imitate iaccess() since the device is
3486 1.32 mycroft * local to the client.
3487 1.3 glass */
3488 1.32 mycroft int
3489 1.58 christos nfsspec_access(v)
3490 1.58 christos void *v;
3491 1.58 christos {
3492 1.32 mycroft struct vop_access_args /* {
3493 1.32 mycroft struct vnode *a_vp;
3494 1.32 mycroft int a_mode;
3495 1.236 elad kauth_cred_t a_cred;
3496 1.230 christos struct lwp *a_l;
3497 1.58 christos } */ *ap = v;
3498 1.46 mycroft struct vattr va;
3499 1.59 fvdl struct vnode *vp = ap->a_vp;
3500 1.32 mycroft int error;
3501 1.3 glass
3502 1.260 pooka error = VOP_GETATTR(vp, &va, ap->a_cred);
3503 1.71 fvdl if (error)
3504 1.71 fvdl return (error);
3505 1.71 fvdl
3506 1.59 fvdl /*
3507 1.59 fvdl * Disallow write attempts on filesystems mounted read-only;
3508 1.59 fvdl * unless the file is a socket, fifo, or a block or character
3509 1.59 fvdl * device resident on the filesystem.
3510 1.59 fvdl */
3511 1.59 fvdl if ((ap->a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
3512 1.59 fvdl switch (vp->v_type) {
3513 1.59 fvdl case VREG:
3514 1.59 fvdl case VDIR:
3515 1.59 fvdl case VLNK:
3516 1.59 fvdl return (EROFS);
3517 1.59 fvdl default:
3518 1.59 fvdl break;
3519 1.59 fvdl }
3520 1.59 fvdl }
3521 1.46 mycroft
3522 1.74 mycroft return (vaccess(va.va_type, va.va_mode,
3523 1.74 mycroft va.va_uid, va.va_gid, ap->a_mode, ap->a_cred));
3524 1.3 glass }
3525 1.22 pk
3526 1.22 pk /*
3527 1.22 pk * Read wrapper for special devices.
3528 1.22 pk */
3529 1.32 mycroft int
3530 1.58 christos nfsspec_read(v)
3531 1.58 christos void *v;
3532 1.58 christos {
3533 1.32 mycroft struct vop_read_args /* {
3534 1.32 mycroft struct vnode *a_vp;
3535 1.32 mycroft struct uio *a_uio;
3536 1.32 mycroft int a_ioflag;
3537 1.236 elad kauth_cred_t a_cred;
3538 1.58 christos } */ *ap = v;
3539 1.111 augustss struct nfsnode *np = VTONFS(ap->a_vp);
3540 1.32 mycroft
3541 1.32 mycroft /*
3542 1.32 mycroft * Set access flag.
3543 1.32 mycroft */
3544 1.32 mycroft np->n_flag |= NACC;
3545 1.237 kardel getnanotime(&np->n_atim);
3546 1.32 mycroft return (VOCALL(spec_vnodeop_p, VOFFSET(vop_read), ap));
3547 1.22 pk }
3548 1.22 pk
3549 1.22 pk /*
3550 1.22 pk * Write wrapper for special devices.
3551 1.22 pk */
3552 1.32 mycroft int
3553 1.58 christos nfsspec_write(v)
3554 1.58 christos void *v;
3555 1.58 christos {
3556 1.32 mycroft struct vop_write_args /* {
3557 1.32 mycroft struct vnode *a_vp;
3558 1.32 mycroft struct uio *a_uio;
3559 1.32 mycroft int a_ioflag;
3560 1.236 elad kauth_cred_t a_cred;
3561 1.58 christos } */ *ap = v;
3562 1.111 augustss struct nfsnode *np = VTONFS(ap->a_vp);
3563 1.32 mycroft
3564 1.32 mycroft /*
3565 1.32 mycroft * Set update flag.
3566 1.32 mycroft */
3567 1.32 mycroft np->n_flag |= NUPD;
3568 1.237 kardel getnanotime(&np->n_mtim);
3569 1.32 mycroft return (VOCALL(spec_vnodeop_p, VOFFSET(vop_write), ap));
3570 1.22 pk }
3571 1.22 pk
3572 1.22 pk /*
3573 1.22 pk * Close wrapper for special devices.
3574 1.22 pk *
3575 1.32 mycroft * Update the times on the nfsnode then do device close.
3576 1.22 pk */
3577 1.32 mycroft int
3578 1.58 christos nfsspec_close(v)
3579 1.58 christos void *v;
3580 1.58 christos {
3581 1.32 mycroft struct vop_close_args /* {
3582 1.32 mycroft struct vnode *a_vp;
3583 1.32 mycroft int a_fflag;
3584 1.236 elad kauth_cred_t a_cred;
3585 1.230 christos struct lwp *a_l;
3586 1.58 christos } */ *ap = v;
3587 1.111 augustss struct vnode *vp = ap->a_vp;
3588 1.111 augustss struct nfsnode *np = VTONFS(vp);
3589 1.32 mycroft struct vattr vattr;
3590 1.32 mycroft
3591 1.32 mycroft if (np->n_flag & (NACC | NUPD)) {
3592 1.32 mycroft np->n_flag |= NCHG;
3593 1.32 mycroft if (vp->v_usecount == 1 &&
3594 1.32 mycroft (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
3595 1.32 mycroft VATTR_NULL(&vattr);
3596 1.59 fvdl if (np->n_flag & NACC)
3597 1.59 fvdl vattr.va_atime = np->n_atim;
3598 1.59 fvdl if (np->n_flag & NUPD)
3599 1.59 fvdl vattr.va_mtime = np->n_mtim;
3600 1.260 pooka (void)VOP_SETATTR(vp, &vattr, ap->a_cred);
3601 1.32 mycroft }
3602 1.22 pk }
3603 1.32 mycroft return (VOCALL(spec_vnodeop_p, VOFFSET(vop_close), ap));
3604 1.22 pk }
3605 1.22 pk
3606 1.22 pk /*
3607 1.32 mycroft * Read wrapper for fifos.
3608 1.22 pk */
3609 1.32 mycroft int
3610 1.58 christos nfsfifo_read(v)
3611 1.58 christos void *v;
3612 1.58 christos {
3613 1.32 mycroft struct vop_read_args /* {
3614 1.32 mycroft struct vnode *a_vp;
3615 1.32 mycroft struct uio *a_uio;
3616 1.32 mycroft int a_ioflag;
3617 1.236 elad kauth_cred_t a_cred;
3618 1.58 christos } */ *ap = v;
3619 1.111 augustss struct nfsnode *np = VTONFS(ap->a_vp);
3620 1.32 mycroft
3621 1.22 pk /*
3622 1.32 mycroft * Set access flag.
3623 1.22 pk */
3624 1.32 mycroft np->n_flag |= NACC;
3625 1.237 kardel getnanotime(&np->n_atim);
3626 1.32 mycroft return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), ap));
3627 1.22 pk }
3628 1.22 pk
3629 1.22 pk /*
3630 1.32 mycroft * Write wrapper for fifos.
3631 1.22 pk */
3632 1.32 mycroft int
3633 1.58 christos nfsfifo_write(v)
3634 1.58 christos void *v;
3635 1.58 christos {
3636 1.32 mycroft struct vop_write_args /* {
3637 1.32 mycroft struct vnode *a_vp;
3638 1.32 mycroft struct uio *a_uio;
3639 1.32 mycroft int a_ioflag;
3640 1.236 elad kauth_cred_t a_cred;
3641 1.58 christos } */ *ap = v;
3642 1.111 augustss struct nfsnode *np = VTONFS(ap->a_vp);
3643 1.32 mycroft
3644 1.22 pk /*
3645 1.32 mycroft * Set update flag.
3646 1.22 pk */
3647 1.32 mycroft np->n_flag |= NUPD;
3648 1.237 kardel getnanotime(&np->n_mtim);
3649 1.32 mycroft return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), ap));
3650 1.22 pk }
3651 1.22 pk
3652 1.22 pk /*
3653 1.32 mycroft * Close wrapper for fifos.
3654 1.22 pk *
3655 1.32 mycroft * Update the times on the nfsnode then do fifo close.
3656 1.22 pk */
3657 1.32 mycroft int
3658 1.58 christos nfsfifo_close(v)
3659 1.58 christos void *v;
3660 1.58 christos {
3661 1.32 mycroft struct vop_close_args /* {
3662 1.32 mycroft struct vnode *a_vp;
3663 1.32 mycroft int a_fflag;
3664 1.236 elad kauth_cred_t a_cred;
3665 1.230 christos struct lwp *a_l;
3666 1.58 christos } */ *ap = v;
3667 1.111 augustss struct vnode *vp = ap->a_vp;
3668 1.111 augustss struct nfsnode *np = VTONFS(vp);
3669 1.32 mycroft struct vattr vattr;
3670 1.32 mycroft
3671 1.32 mycroft if (np->n_flag & (NACC | NUPD)) {
3672 1.237 kardel struct timespec ts;
3673 1.237 kardel
3674 1.237 kardel getnanotime(&ts);
3675 1.237 kardel if (np->n_flag & NACC)
3676 1.237 kardel np->n_atim = ts;
3677 1.237 kardel if (np->n_flag & NUPD)
3678 1.237 kardel np->n_mtim = ts;
3679 1.32 mycroft np->n_flag |= NCHG;
3680 1.32 mycroft if (vp->v_usecount == 1 &&
3681 1.32 mycroft (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
3682 1.32 mycroft VATTR_NULL(&vattr);
3683 1.59 fvdl if (np->n_flag & NACC)
3684 1.59 fvdl vattr.va_atime = np->n_atim;
3685 1.59 fvdl if (np->n_flag & NUPD)
3686 1.59 fvdl vattr.va_mtime = np->n_mtim;
3687 1.260 pooka (void)VOP_SETATTR(vp, &vattr, ap->a_cred);
3688 1.32 mycroft }
3689 1.22 pk }
3690 1.32 mycroft return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), ap));
3691 1.22 pk }
3692