Mercurial > illumos > illumos-gate
annotate usr/src/uts/common/fs/nfs/nfs_server.c @ 2140:043bd360aabc
6417056 nfssrv should use doors/xdr as its IPC mech to mountd(1m)
author | rmesta |
---|---|
date | Wed, 07 Jun 2006 09:06:06 -0700 |
parents | a29bc457bcb9 |
children | ffba0dc9ebeb |
rev | line source |
---|---|
0 | 1 /* |
2 * CDDL HEADER START | |
3 * | |
4 * The contents of this file are subject to the terms of the | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
5 * Common Development and Distribution License (the "License"). |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
6 * You may not use this file except in compliance with the License. |
0 | 7 * |
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE | |
9 * or http://www.opensolaris.org/os/licensing. | |
10 * See the License for the specific language governing permissions | |
11 * and limitations under the License. | |
12 * | |
13 * When distributing Covered Code, include this CDDL HEADER in each | |
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. | |
15 * If applicable, add the following below this CDDL HEADER, with the | |
16 * fields enclosed by brackets "[]" replaced with your own identifying | |
17 * information: Portions Copyright [yyyy] [name of copyright owner] | |
18 * | |
19 * CDDL HEADER END | |
20 */ | |
21 /* | |
1232 | 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. |
0 | 23 * Use is subject to license terms. |
24 */ | |
25 | |
26 /* | |
27 * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T. | |
28 * All rights reserved. | |
29 * Use is subject to license terms. | |
30 */ | |
31 | |
32 #pragma ident "%Z%%M% %I% %E% SMI" | |
33 | |
34 #include <sys/param.h> | |
35 #include <sys/types.h> | |
36 #include <sys/systm.h> | |
37 #include <sys/cred.h> | |
38 #include <sys/proc.h> | |
39 #include <sys/user.h> | |
40 #include <sys/buf.h> | |
41 #include <sys/vfs.h> | |
42 #include <sys/vnode.h> | |
43 #include <sys/pathname.h> | |
44 #include <sys/uio.h> | |
45 #include <sys/file.h> | |
46 #include <sys/stat.h> | |
47 #include <sys/errno.h> | |
48 #include <sys/socket.h> | |
49 #include <sys/sysmacros.h> | |
50 #include <sys/siginfo.h> | |
51 #include <sys/tiuser.h> | |
52 #include <sys/statvfs.h> | |
53 #include <sys/stream.h> | |
54 #include <sys/strsubr.h> | |
55 #include <sys/stropts.h> | |
56 #include <sys/timod.h> | |
57 #include <sys/t_kuser.h> | |
58 #include <sys/kmem.h> | |
59 #include <sys/kstat.h> | |
60 #include <sys/dirent.h> | |
61 #include <sys/cmn_err.h> | |
62 #include <sys/debug.h> | |
63 #include <sys/unistd.h> | |
64 #include <sys/vtrace.h> | |
65 #include <sys/mode.h> | |
66 #include <sys/acl.h> | |
67 #include <sys/sdt.h> | |
68 | |
69 #include <rpc/types.h> | |
70 #include <rpc/auth.h> | |
71 #include <rpc/auth_unix.h> | |
72 #include <rpc/auth_des.h> | |
73 #include <rpc/svc.h> | |
74 #include <rpc/xdr.h> | |
75 | |
76 #include <nfs/nfs.h> | |
77 #include <nfs/export.h> | |
78 #include <nfs/nfssys.h> | |
79 #include <nfs/nfs_clnt.h> | |
80 #include <nfs/nfs_acl.h> | |
81 #include <nfs/nfs_log.h> | |
82 #include <nfs/lm.h> | |
74 | 83 #include <nfs/nfs_dispatch.h> |
84 #include <nfs/nfs4_drc.h> | |
0 | 85 |
86 #include <sys/modctl.h> | |
87 #include <sys/cladm.h> | |
88 #include <sys/clconf.h> | |
89 | |
90 #define MAXHOST 32 | |
91 const char *kinet_ntop6(uchar_t *, char *, size_t); | |
92 | |
93 /* | |
94 * Module linkage information. | |
95 */ | |
96 | |
97 static struct modlmisc modlmisc = { | |
98 &mod_miscops, "NFS server module" | |
99 }; | |
100 | |
101 static struct modlinkage modlinkage = { | |
102 MODREV_1, (void *)&modlmisc, NULL | |
103 }; | |
104 | |
105 char _depends_on[] = "misc/klmmod"; | |
106 | |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
107 /* for testing RG failover code path on non-Cluster system */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
108 int hanfsv4_force = 0; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
109 |
0 | 110 int |
111 _init(void) | |
112 { | |
113 int status; | |
114 | |
115 if ((status = nfs_srvinit()) != 0) { | |
116 cmn_err(CE_WARN, "_init: nfs_srvinit failed"); | |
117 return (status); | |
118 } | |
119 | |
120 status = mod_install((struct modlinkage *)&modlinkage); | |
121 if (status != 0) { | |
122 /* | |
123 * Could not load module, cleanup previous | |
124 * initialization work. | |
125 */ | |
126 nfs_srvfini(); | |
127 } | |
128 | |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
129 /* |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
130 * Initialise some placeholders for nfssys() calls. These have |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
131 * to be declared by the nfs module, since that handles nfssys() |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
132 * calls - also used by NFS clients - but are provided by this |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
133 * nfssrv module. These also then serve as confirmation to the |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
134 * relevant code in nfs that nfssrv has been loaded, as they're |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
135 * initially NULL. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
136 */ |
0 | 137 nfs_srv_quiesce_func = nfs_srv_quiesce_all; |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
138 nfs_srv_dss_func = rfs4_dss_setpaths; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
139 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
140 /* setup DSS paths here; must be done before initial server startup */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
141 rfs4_dss_paths = rfs4_dss_oldpaths = NULL; |
0 | 142 |
143 return (status); | |
144 } | |
145 | |
146 int | |
147 _fini() | |
148 { | |
149 return (EBUSY); | |
150 } | |
151 | |
152 int | |
153 _info(struct modinfo *modinfop) | |
154 { | |
155 return (mod_info(&modlinkage, modinfop)); | |
156 } | |
157 | |
158 /* | |
159 * PUBLICFH_CHECK() checks if the dispatch routine supports | |
160 * RPC_PUBLICFH_OK, if the filesystem is exported public, and if the | |
161 * incoming request is using the public filehandle. The check duplicates | |
162 * the exportmatch() call done in checkexport(), and we should consider | |
163 * modifying those routines to avoid the duplication. For now, we optimize | |
164 * by calling exportmatch() only after checking that the dispatch routine | |
165 * supports RPC_PUBLICFH_OK, and if the filesystem is explicitly exported | |
166 * public (i.e., not the placeholder). | |
167 */ | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
168 #define PUBLICFH_CHECK(disp, exi, fsid, xfid) \ |
0 | 169 ((disp->dis_flags & RPC_PUBLICFH_OK) && \ |
170 ((exi->exi_export.ex_flags & EX_PUBLIC) || \ | |
171 (exi == exi_public && exportmatch(exi_root, \ | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
172 fsid, xfid)))) |
0 | 173 |
174 static void nfs_srv_shutdown_all(int); | |
175 static void rfs4_server_start(int); | |
176 static void nullfree(void); | |
177 static void rfs_dispatch(struct svc_req *, SVCXPRT *); | |
178 static void acl_dispatch(struct svc_req *, SVCXPRT *); | |
179 static void common_dispatch(struct svc_req *, SVCXPRT *, | |
180 rpcvers_t, rpcvers_t, char *, | |
181 struct rpc_disptable *); | |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
182 static void hanfsv4_failover(void); |
0 | 183 static int checkauth(struct exportinfo *, struct svc_req *, cred_t *, int, |
184 bool_t); | |
185 static char *client_name(struct svc_req *req); | |
186 static char *client_addr(struct svc_req *req, char *buf); | |
187 extern int sec_svc_getcred(struct svc_req *, cred_t *cr, char **, int *); | |
188 extern bool_t sec_svc_inrootlist(int, caddr_t, int, caddr_t *); | |
189 | |
190 #define NFSLOG_COPY_NETBUF(exi, xprt, nb) { \ | |
191 (nb)->maxlen = (xprt)->xp_rtaddr.maxlen; \ | |
192 (nb)->len = (xprt)->xp_rtaddr.len; \ | |
193 (nb)->buf = kmem_alloc((nb)->len, KM_SLEEP); \ | |
194 bcopy((xprt)->xp_rtaddr.buf, (nb)->buf, (nb)->len); \ | |
195 } | |
196 | |
197 /* | |
198 * Public Filehandle common nfs routines | |
199 */ | |
200 static int MCLpath(char **); | |
201 static void URLparse(char *); | |
202 | |
203 /* | |
204 * NFS callout table. | |
205 * This table is used by svc_getreq() to dispatch a request with | |
206 * a given prog/vers pair to an appropriate service provider | |
207 * dispatch routine. | |
208 * | |
209 * NOTE: ordering is relied upon below when resetting the version min/max | |
210 * for NFS_PROGRAM. Careful, if this is ever changed. | |
211 */ | |
212 static SVC_CALLOUT __nfs_sc_clts[] = { | |
213 { NFS_PROGRAM, NFS_VERSMIN, NFS_VERSMAX, rfs_dispatch }, | |
214 { NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, acl_dispatch } | |
215 }; | |
216 | |
217 static SVC_CALLOUT_TABLE nfs_sct_clts = { | |
218 sizeof (__nfs_sc_clts) / sizeof (__nfs_sc_clts[0]), FALSE, | |
219 __nfs_sc_clts | |
220 }; | |
221 | |
222 static SVC_CALLOUT __nfs_sc_cots[] = { | |
223 { NFS_PROGRAM, NFS_VERSMIN, NFS_VERSMAX, rfs_dispatch }, | |
224 { NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, acl_dispatch } | |
225 }; | |
226 | |
227 static SVC_CALLOUT_TABLE nfs_sct_cots = { | |
228 sizeof (__nfs_sc_cots) / sizeof (__nfs_sc_cots[0]), FALSE, __nfs_sc_cots | |
229 }; | |
230 | |
231 static SVC_CALLOUT __nfs_sc_rdma[] = { | |
232 { NFS_PROGRAM, NFS_VERSMIN, NFS_VERSMAX, rfs_dispatch }, | |
233 { NFS_ACL_PROGRAM, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, acl_dispatch } | |
234 }; | |
235 | |
236 static SVC_CALLOUT_TABLE nfs_sct_rdma = { | |
237 sizeof (__nfs_sc_rdma) / sizeof (__nfs_sc_rdma[0]), FALSE, __nfs_sc_rdma | |
238 }; | |
239 rpcvers_t nfs_versmin = NFS_VERSMIN_DEFAULT; | |
240 rpcvers_t nfs_versmax = NFS_VERSMAX_DEFAULT; | |
241 | |
242 /* | |
243 * Used to track the state of the server so that initialization | |
244 * can be done properly. | |
245 */ | |
246 typedef enum { | |
247 NFS_SERVER_STOPPED, /* server state destroyed */ | |
248 NFS_SERVER_STOPPING, /* server state being destroyed */ | |
249 NFS_SERVER_RUNNING, | |
250 NFS_SERVER_QUIESCED, /* server state preserved */ | |
251 NFS_SERVER_OFFLINE /* server pool offline */ | |
252 } nfs_server_running_t; | |
253 | |
254 static nfs_server_running_t nfs_server_upordown; | |
255 static kmutex_t nfs_server_upordown_lock; | |
256 static kcondvar_t nfs_server_upordown_cv; | |
257 | |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
258 /* |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
259 * DSS: distributed stable storage |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
260 * lists of all DSS paths: current, and before last warmstart |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
261 */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
262 nvlist_t *rfs4_dss_paths, *rfs4_dss_oldpaths; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
263 |
74 | 264 int rfs4_dispatch(struct rpcdisp *, struct svc_req *, SVCXPRT *, char *); |
265 | |
0 | 266 /* |
267 * RDMA wait variables. | |
268 */ | |
269 static kcondvar_t rdma_wait_cv; | |
270 static kmutex_t rdma_wait_mutex; | |
271 | |
272 /* | |
273 * Will be called at the point the server pool is being unregistered | |
274 * from the pool list. From that point onwards, the pool is waiting | |
275 * to be drained and as such the server state is stale and pertains | |
276 * to the old instantiation of the NFS server pool. | |
277 */ | |
278 void | |
279 nfs_srv_offline(void) | |
280 { | |
281 mutex_enter(&nfs_server_upordown_lock); | |
282 if (nfs_server_upordown == NFS_SERVER_RUNNING) { | |
283 nfs_server_upordown = NFS_SERVER_OFFLINE; | |
284 } | |
285 mutex_exit(&nfs_server_upordown_lock); | |
286 } | |
287 | |
288 /* | |
289 * Will be called at the point the server pool is being destroyed so | |
290 * all transports have been closed and no service threads are in | |
291 * existence. | |
292 * | |
293 * If we quiesce the server, we're shutting it down without destroying the | |
294 * server state. This allows it to warm start subsequently. | |
295 */ | |
296 void | |
297 nfs_srv_stop_all(void) | |
298 { | |
299 int quiesce = 0; | |
300 nfs_srv_shutdown_all(quiesce); | |
301 } | |
302 | |
303 /* | |
304 * This alternative shutdown routine can be requested via nfssys() | |
305 */ | |
306 void | |
307 nfs_srv_quiesce_all(void) | |
308 { | |
309 int quiesce = 1; | |
310 nfs_srv_shutdown_all(quiesce); | |
311 } | |
312 | |
313 static void | |
314 nfs_srv_shutdown_all(int quiesce) { | |
315 mutex_enter(&nfs_server_upordown_lock); | |
316 if (quiesce) { | |
317 if (nfs_server_upordown == NFS_SERVER_RUNNING || | |
318 nfs_server_upordown == NFS_SERVER_OFFLINE) { | |
319 nfs_server_upordown = NFS_SERVER_QUIESCED; | |
320 cv_signal(&nfs_server_upordown_cv); | |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
321 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
322 /* reset DSS state, for subsequent warm restart */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
323 rfs4_dss_numnewpaths = 0; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
324 rfs4_dss_newpaths = NULL; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
325 |
0 | 326 cmn_err(CE_NOTE, "nfs_server: server is now quiesced; " |
327 "NFSv4 state has been preserved"); | |
328 } | |
329 } else { | |
330 if (nfs_server_upordown == NFS_SERVER_OFFLINE) { | |
331 nfs_server_upordown = NFS_SERVER_STOPPING; | |
332 mutex_exit(&nfs_server_upordown_lock); | |
333 rfs4_state_fini(); | |
74 | 334 rfs4_fini_drc(nfs4_drc); |
0 | 335 mutex_enter(&nfs_server_upordown_lock); |
336 nfs_server_upordown = NFS_SERVER_STOPPED; | |
337 cv_signal(&nfs_server_upordown_cv); | |
338 } | |
339 } | |
340 mutex_exit(&nfs_server_upordown_lock); | |
341 } | |
342 | |
343 static int | |
344 nfs_srv_set_sc_versions(struct file *fp, SVC_CALLOUT_TABLE **sctpp, | |
345 rpcvers_t versmin, rpcvers_t versmax) | |
346 { | |
347 struct strioctl strioc; | |
348 struct T_info_ack tinfo; | |
349 int error, retval; | |
350 | |
351 /* | |
352 * Find out what type of transport this is. | |
353 */ | |
354 strioc.ic_cmd = TI_GETINFO; | |
355 strioc.ic_timout = -1; | |
356 strioc.ic_len = sizeof (tinfo); | |
357 strioc.ic_dp = (char *)&tinfo; | |
358 tinfo.PRIM_type = T_INFO_REQ; | |
359 | |
360 error = strioctl(fp->f_vnode, I_STR, (intptr_t)&strioc, 0, K_TO_K, | |
361 CRED(), &retval); | |
362 if (error || retval) | |
363 return (error); | |
364 | |
365 /* | |
366 * Based on our query of the transport type... | |
367 * | |
368 * Reset the min/max versions based on the caller's request | |
369 * NOTE: This assumes that NFS_PROGRAM is first in the array!! | |
370 * And the second entry is the NFS_ACL_PROGRAM. | |
371 */ | |
372 switch (tinfo.SERV_type) { | |
373 case T_CLTS: | |
374 if (versmax == NFS_V4) | |
375 return (EINVAL); | |
376 __nfs_sc_clts[0].sc_versmin = versmin; | |
377 __nfs_sc_clts[0].sc_versmax = versmax; | |
378 __nfs_sc_clts[1].sc_versmin = versmin; | |
379 __nfs_sc_clts[1].sc_versmax = versmax; | |
380 *sctpp = &nfs_sct_clts; | |
381 break; | |
382 case T_COTS: | |
383 case T_COTS_ORD: | |
384 __nfs_sc_cots[0].sc_versmin = versmin; | |
385 __nfs_sc_cots[0].sc_versmax = versmax; | |
386 /* For the NFS_ACL program, check the max version */ | |
387 if (versmax > NFS_ACL_VERSMAX) | |
388 versmax = NFS_ACL_VERSMAX; | |
389 __nfs_sc_cots[1].sc_versmin = versmin; | |
390 __nfs_sc_cots[1].sc_versmax = versmax; | |
391 *sctpp = &nfs_sct_cots; | |
392 break; | |
393 default: | |
394 error = EINVAL; | |
395 } | |
396 | |
397 return (error); | |
398 } | |
399 | |
400 /* | |
401 * NFS Server system call. | |
402 * Does all of the work of running a NFS server. | |
403 * uap->fd is the fd of an open transport provider | |
404 */ | |
405 int | |
406 nfs_svc(struct nfs_svc_args *arg, model_t model) | |
407 { | |
408 file_t *fp; | |
409 SVCMASTERXPRT *xprt; | |
410 int error; | |
411 int readsize; | |
412 char buf[KNC_STRSIZE]; | |
413 size_t len; | |
414 STRUCT_HANDLE(nfs_svc_args, uap); | |
415 struct netbuf addrmask; | |
416 SVC_CALLOUT_TABLE *sctp = NULL; | |
417 | |
418 #ifdef lint | |
419 model = model; /* STRUCT macros don't always refer to it */ | |
420 #endif | |
421 | |
422 STRUCT_SET_HANDLE(uap, model, arg); | |
423 | |
424 /* Check privileges in nfssys() */ | |
425 | |
426 if ((fp = getf(STRUCT_FGET(uap, fd))) == NULL) | |
427 return (EBADF); | |
428 | |
429 /* | |
430 * Set read buffer size to rsize | |
431 * and add room for RPC headers. | |
432 */ | |
433 readsize = nfs3tsize() + (RPC_MAXDATASIZE - NFS_MAXDATA); | |
434 if (readsize < RPC_MAXDATASIZE) | |
435 readsize = RPC_MAXDATASIZE; | |
436 | |
437 error = copyinstr((const char *)STRUCT_FGETP(uap, netid), buf, | |
438 KNC_STRSIZE, &len); | |
439 if (error) { | |
440 releasef(STRUCT_FGET(uap, fd)); | |
441 return (error); | |
442 } | |
443 | |
444 addrmask.len = STRUCT_FGET(uap, addrmask.len); | |
445 addrmask.maxlen = STRUCT_FGET(uap, addrmask.maxlen); | |
446 addrmask.buf = kmem_alloc(addrmask.maxlen, KM_SLEEP); | |
447 error = copyin(STRUCT_FGETP(uap, addrmask.buf), addrmask.buf, | |
448 addrmask.len); | |
449 if (error) { | |
450 releasef(STRUCT_FGET(uap, fd)); | |
451 kmem_free(addrmask.buf, addrmask.maxlen); | |
452 return (error); | |
453 } | |
454 | |
455 nfs_versmin = STRUCT_FGET(uap, versmin); | |
456 nfs_versmax = STRUCT_FGET(uap, versmax); | |
457 | |
458 /* Double check the vers min/max ranges */ | |
459 if ((nfs_versmin > nfs_versmax) || | |
460 (nfs_versmin < NFS_VERSMIN) || | |
461 (nfs_versmax > NFS_VERSMAX)) { | |
462 nfs_versmin = NFS_VERSMIN_DEFAULT; | |
463 nfs_versmax = NFS_VERSMAX_DEFAULT; | |
464 } | |
465 | |
466 if (error = | |
467 nfs_srv_set_sc_versions(fp, &sctp, nfs_versmin, nfs_versmax)) { | |
468 releasef(STRUCT_FGET(uap, fd)); | |
469 kmem_free(addrmask.buf, addrmask.maxlen); | |
470 return (error); | |
471 } | |
472 | |
473 /* Initialize nfsv4 server */ | |
474 if (nfs_versmax == (rpcvers_t)NFS_V4) | |
475 rfs4_server_start(STRUCT_FGET(uap, delegation)); | |
476 | |
477 /* Create a transport handle. */ | |
478 error = svc_tli_kcreate(fp, readsize, buf, &addrmask, &xprt, | |
479 sctp, NULL, NFS_SVCPOOL_ID, TRUE); | |
480 | |
481 if (error) | |
482 kmem_free(addrmask.buf, addrmask.maxlen); | |
483 | |
484 releasef(STRUCT_FGET(uap, fd)); | |
485 | |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
486 /* HA-NFSv4: save the cluster nodeid */ |
0 | 487 if (cluster_bootflags & CLUSTER_BOOTED) |
488 lm_global_nlmid = clconf_get_nodeid(); | |
489 | |
490 return (error); | |
491 } | |
492 | |
493 static void | |
494 rfs4_server_start(int nfs4_srv_delegation) | |
495 { | |
496 /* | |
497 * Determine if the server has previously been "started" and | |
498 * if not, do the per instance initialization | |
499 */ | |
500 mutex_enter(&nfs_server_upordown_lock); | |
501 | |
502 if (nfs_server_upordown != NFS_SERVER_RUNNING) { | |
503 /* Do we need to stop and wait on the previous server? */ | |
504 while (nfs_server_upordown == NFS_SERVER_STOPPING || | |
505 nfs_server_upordown == NFS_SERVER_OFFLINE) | |
506 cv_wait(&nfs_server_upordown_cv, | |
507 &nfs_server_upordown_lock); | |
508 | |
509 if (nfs_server_upordown != NFS_SERVER_RUNNING) { | |
510 (void) svc_pool_control(NFS_SVCPOOL_ID, | |
511 SVCPSET_UNREGISTER_PROC, (void *)&nfs_srv_offline); | |
512 (void) svc_pool_control(NFS_SVCPOOL_ID, | |
513 SVCPSET_SHUTDOWN_PROC, (void *)&nfs_srv_stop_all); | |
514 | |
515 /* is this an nfsd warm start? */ | |
516 if (nfs_server_upordown == NFS_SERVER_QUIESCED) { | |
517 cmn_err(CE_NOTE, "nfs_server: " | |
518 "server was previously quiesced; " | |
519 "existing NFSv4 state will be re-used"); | |
520 | |
521 /* | |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
522 * HA-NFSv4: this is also the signal |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
523 * that a Resource Group failover has |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
524 * occurred. |
0 | 525 */ |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
526 if (cluster_bootflags & CLUSTER_BOOTED || |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
527 hanfsv4_force) |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
528 hanfsv4_failover(); |
0 | 529 } else { |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
530 /* cold start */ |
0 | 531 rfs4_state_init(); |
74 | 532 nfs4_drc = rfs4_init_drc(nfs4_drc_max, |
533 nfs4_drc_hash, | |
534 nfs4_drc_lifetime); | |
0 | 535 } |
536 | |
537 /* | |
538 * Check to see if delegation is to be | |
539 * enabled at the server | |
540 */ | |
541 if (nfs4_srv_delegation != FALSE) | |
542 rfs4_set_deleg_policy(SRV_NORMAL_DELEGATE); | |
543 | |
544 nfs_server_upordown = NFS_SERVER_RUNNING; | |
545 } | |
546 cv_signal(&nfs_server_upordown_cv); | |
547 } | |
548 mutex_exit(&nfs_server_upordown_lock); | |
549 } | |
550 | |
551 /* | |
552 * If RDMA device available, | |
553 * start RDMA listener. | |
554 */ | |
555 int | |
556 rdma_start(struct rdma_svc_args *rsa) | |
557 { | |
558 int error; | |
559 rdma_xprt_group_t started_rdma_xprts; | |
560 | |
561 /* Double check the vers min/max ranges */ | |
562 if ((rsa->nfs_versmin > rsa->nfs_versmax) || | |
563 (rsa->nfs_versmin < NFS_VERSMIN) || | |
564 (rsa->nfs_versmax > NFS_VERSMAX)) { | |
565 rsa->nfs_versmin = NFS_VERSMIN_DEFAULT; | |
566 rsa->nfs_versmax = NFS_VERSMAX_DEFAULT; | |
567 } | |
568 nfs_versmin = rsa->nfs_versmin; | |
569 nfs_versmax = rsa->nfs_versmax; | |
570 | |
571 /* Set the versions in the callout table */ | |
572 __nfs_sc_rdma[0].sc_versmin = rsa->nfs_versmin; | |
573 __nfs_sc_rdma[0].sc_versmax = rsa->nfs_versmax; | |
574 /* For the NFS_ACL program, check the max version */ | |
575 __nfs_sc_rdma[1].sc_versmin = rsa->nfs_versmin; | |
576 if (rsa->nfs_versmax > NFS_ACL_VERSMAX) | |
577 __nfs_sc_rdma[1].sc_versmax = NFS_ACL_VERSMAX; | |
578 else | |
579 __nfs_sc_rdma[1].sc_versmax = rsa->nfs_versmax; | |
580 | |
581 /* Initialize nfsv4 server */ | |
582 if (rsa->nfs_versmax == (rpcvers_t)NFS_V4) | |
583 rfs4_server_start(rsa->delegation); | |
584 | |
585 started_rdma_xprts.rtg_count = 0; | |
586 started_rdma_xprts.rtg_listhead = NULL; | |
587 started_rdma_xprts.rtg_poolid = rsa->poolid; | |
588 error = svc_rdma_kcreate(rsa->netid, &nfs_sct_rdma, rsa->poolid, | |
589 &started_rdma_xprts); | |
590 | |
591 if (error == 0) { | |
592 mutex_enter(&rdma_wait_mutex); | |
593 if (!cv_wait_sig(&rdma_wait_cv, &rdma_wait_mutex)) { | |
594 rdma_stop(started_rdma_xprts); | |
595 } | |
596 mutex_exit(&rdma_wait_mutex); | |
597 } | |
598 | |
599 return (error); | |
600 } | |
601 | |
602 /* ARGSUSED */ | |
74 | 603 void |
0 | 604 rpc_null(caddr_t *argp, caddr_t *resp) |
605 { | |
606 } | |
607 | |
608 /* ARGSUSED */ | |
609 static void | |
610 rfs_error(caddr_t *argp, caddr_t *resp) | |
611 { | |
612 /* return (EOPNOTSUPP); */ | |
613 } | |
614 | |
615 static void | |
616 nullfree(void) | |
617 { | |
618 } | |
619 | |
620 static char *rfscallnames_v2[] = { | |
621 "RFS2_NULL", | |
622 "RFS2_GETATTR", | |
623 "RFS2_SETATTR", | |
624 "RFS2_ROOT", | |
625 "RFS2_LOOKUP", | |
626 "RFS2_READLINK", | |
627 "RFS2_READ", | |
628 "RFS2_WRITECACHE", | |
629 "RFS2_WRITE", | |
630 "RFS2_CREATE", | |
631 "RFS2_REMOVE", | |
632 "RFS2_RENAME", | |
633 "RFS2_LINK", | |
634 "RFS2_SYMLINK", | |
635 "RFS2_MKDIR", | |
636 "RFS2_RMDIR", | |
637 "RFS2_READDIR", | |
638 "RFS2_STATFS" | |
639 }; | |
640 | |
641 static struct rpcdisp rfsdisptab_v2[] = { | |
642 /* | |
643 * NFS VERSION 2 | |
644 */ | |
645 | |
646 /* RFS_NULL = 0 */ | |
647 {rpc_null, | |
648 xdr_void, NULL_xdrproc_t, 0, | |
649 xdr_void, NULL_xdrproc_t, 0, | |
650 nullfree, RPC_IDEMPOTENT, | |
74 | 651 0}, |
0 | 652 |
653 /* RFS_GETATTR = 1 */ | |
654 {rfs_getattr, | |
655 xdr_fhandle, xdr_fastfhandle, sizeof (fhandle_t), | |
656 xdr_attrstat, xdr_fastattrstat, sizeof (struct nfsattrstat), | |
657 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON|RPC_MAPRESP, | |
74 | 658 rfs_getattr_getfh}, |
0 | 659 |
660 /* RFS_SETATTR = 2 */ | |
661 {rfs_setattr, | |
662 xdr_saargs, NULL_xdrproc_t, sizeof (struct nfssaargs), | |
663 xdr_attrstat, xdr_fastattrstat, sizeof (struct nfsattrstat), | |
664 nullfree, RPC_MAPRESP, | |
74 | 665 rfs_setattr_getfh}, |
0 | 666 |
667 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */ | |
668 {rfs_error, | |
669 xdr_void, NULL_xdrproc_t, 0, | |
670 xdr_void, NULL_xdrproc_t, 0, | |
671 nullfree, RPC_IDEMPOTENT, | |
74 | 672 0}, |
0 | 673 |
674 /* RFS_LOOKUP = 4 */ | |
675 {rfs_lookup, | |
676 xdr_diropargs, NULL_xdrproc_t, sizeof (struct nfsdiropargs), | |
677 xdr_diropres, xdr_fastdiropres, sizeof (struct nfsdiropres), | |
678 nullfree, RPC_IDEMPOTENT|RPC_MAPRESP|RPC_PUBLICFH_OK, | |
74 | 679 rfs_lookup_getfh}, |
0 | 680 |
681 /* RFS_READLINK = 5 */ | |
682 {rfs_readlink, | |
683 xdr_fhandle, xdr_fastfhandle, sizeof (fhandle_t), | |
684 xdr_rdlnres, NULL_xdrproc_t, sizeof (struct nfsrdlnres), | |
685 rfs_rlfree, RPC_IDEMPOTENT, | |
74 | 686 rfs_readlink_getfh}, |
0 | 687 |
688 /* RFS_READ = 6 */ | |
689 {rfs_read, | |
690 xdr_readargs, NULL_xdrproc_t, sizeof (struct nfsreadargs), | |
691 xdr_rdresult, NULL_xdrproc_t, sizeof (struct nfsrdresult), | |
692 rfs_rdfree, RPC_IDEMPOTENT, | |
74 | 693 rfs_read_getfh}, |
0 | 694 |
695 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */ | |
696 {rfs_error, | |
697 xdr_void, NULL_xdrproc_t, 0, | |
698 xdr_void, NULL_xdrproc_t, 0, | |
699 nullfree, RPC_IDEMPOTENT, | |
74 | 700 0}, |
0 | 701 |
702 /* RFS_WRITE = 8 */ | |
703 {rfs_write, | |
704 xdr_writeargs, NULL_xdrproc_t, sizeof (struct nfswriteargs), | |
705 xdr_attrstat, xdr_fastattrstat, sizeof (struct nfsattrstat), | |
706 nullfree, RPC_MAPRESP, | |
74 | 707 rfs_write_getfh}, |
0 | 708 |
709 /* RFS_CREATE = 9 */ | |
710 {rfs_create, | |
711 xdr_creatargs, NULL_xdrproc_t, sizeof (struct nfscreatargs), | |
712 xdr_diropres, xdr_fastdiropres, sizeof (struct nfsdiropres), | |
713 nullfree, RPC_MAPRESP, | |
74 | 714 rfs_create_getfh}, |
0 | 715 |
716 /* RFS_REMOVE = 10 */ | |
717 {rfs_remove, | |
718 xdr_diropargs, NULL_xdrproc_t, sizeof (struct nfsdiropargs), | |
719 #ifdef _LITTLE_ENDIAN | |
720 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), | |
721 #else | |
722 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), | |
723 #endif | |
724 nullfree, RPC_MAPRESP, | |
74 | 725 rfs_remove_getfh}, |
0 | 726 |
727 /* RFS_RENAME = 11 */ | |
728 {rfs_rename, | |
729 xdr_rnmargs, NULL_xdrproc_t, sizeof (struct nfsrnmargs), | |
730 #ifdef _LITTLE_ENDIAN | |
731 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), | |
732 #else | |
733 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), | |
734 #endif | |
735 nullfree, RPC_MAPRESP, | |
74 | 736 rfs_rename_getfh}, |
0 | 737 |
738 /* RFS_LINK = 12 */ | |
739 {rfs_link, | |
740 xdr_linkargs, NULL_xdrproc_t, sizeof (struct nfslinkargs), | |
741 #ifdef _LITTLE_ENDIAN | |
742 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), | |
743 #else | |
744 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), | |
745 #endif | |
746 nullfree, RPC_MAPRESP, | |
74 | 747 rfs_link_getfh}, |
0 | 748 |
749 /* RFS_SYMLINK = 13 */ | |
750 {rfs_symlink, | |
751 xdr_slargs, NULL_xdrproc_t, sizeof (struct nfsslargs), | |
752 #ifdef _LITTLE_ENDIAN | |
753 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), | |
754 #else | |
755 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), | |
756 #endif | |
757 nullfree, RPC_MAPRESP, | |
74 | 758 rfs_symlink_getfh}, |
0 | 759 |
760 /* RFS_MKDIR = 14 */ | |
761 {rfs_mkdir, | |
762 xdr_creatargs, NULL_xdrproc_t, sizeof (struct nfscreatargs), | |
763 xdr_diropres, xdr_fastdiropres, sizeof (struct nfsdiropres), | |
764 nullfree, RPC_MAPRESP, | |
74 | 765 rfs_mkdir_getfh}, |
0 | 766 |
767 /* RFS_RMDIR = 15 */ | |
768 {rfs_rmdir, | |
769 xdr_diropargs, NULL_xdrproc_t, sizeof (struct nfsdiropargs), | |
770 #ifdef _LITTLE_ENDIAN | |
771 xdr_enum, xdr_fastenum, sizeof (enum nfsstat), | |
772 #else | |
773 xdr_enum, NULL_xdrproc_t, sizeof (enum nfsstat), | |
774 #endif | |
775 nullfree, RPC_MAPRESP, | |
74 | 776 rfs_rmdir_getfh}, |
0 | 777 |
778 /* RFS_READDIR = 16 */ | |
779 {rfs_readdir, | |
780 xdr_rddirargs, NULL_xdrproc_t, sizeof (struct nfsrddirargs), | |
781 xdr_putrddirres, NULL_xdrproc_t, sizeof (struct nfsrddirres), | |
782 rfs_rddirfree, RPC_IDEMPOTENT, | |
74 | 783 rfs_readdir_getfh}, |
0 | 784 |
785 /* RFS_STATFS = 17 */ | |
786 {rfs_statfs, | |
787 xdr_fhandle, xdr_fastfhandle, sizeof (fhandle_t), | |
788 xdr_statfs, xdr_faststatfs, sizeof (struct nfsstatfs), | |
789 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON|RPC_MAPRESP, | |
74 | 790 rfs_statfs_getfh}, |
0 | 791 }; |
792 | |
793 static char *rfscallnames_v3[] = { | |
794 "RFS3_NULL", | |
795 "RFS3_GETATTR", | |
796 "RFS3_SETATTR", | |
797 "RFS3_LOOKUP", | |
798 "RFS3_ACCESS", | |
799 "RFS3_READLINK", | |
800 "RFS3_READ", | |
801 "RFS3_WRITE", | |
802 "RFS3_CREATE", | |
803 "RFS3_MKDIR", | |
804 "RFS3_SYMLINK", | |
805 "RFS3_MKNOD", | |
806 "RFS3_REMOVE", | |
807 "RFS3_RMDIR", | |
808 "RFS3_RENAME", | |
809 "RFS3_LINK", | |
810 "RFS3_READDIR", | |
811 "RFS3_READDIRPLUS", | |
812 "RFS3_FSSTAT", | |
813 "RFS3_FSINFO", | |
814 "RFS3_PATHCONF", | |
815 "RFS3_COMMIT" | |
816 }; | |
817 | |
818 static struct rpcdisp rfsdisptab_v3[] = { | |
819 /* | |
820 * NFS VERSION 3 | |
821 */ | |
822 | |
823 /* RFS_NULL = 0 */ | |
824 {rpc_null, | |
825 xdr_void, NULL_xdrproc_t, 0, | |
826 xdr_void, NULL_xdrproc_t, 0, | |
827 nullfree, RPC_IDEMPOTENT, | |
74 | 828 0}, |
0 | 829 |
830 /* RFS3_GETATTR = 1 */ | |
831 {rfs3_getattr, | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
832 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (GETATTR3args), |
0 | 833 xdr_GETATTR3res, NULL_xdrproc_t, sizeof (GETATTR3res), |
834 nullfree, (RPC_IDEMPOTENT | RPC_ALLOWANON), | |
74 | 835 rfs3_getattr_getfh}, |
0 | 836 |
837 /* RFS3_SETATTR = 2 */ | |
838 {rfs3_setattr, | |
839 xdr_SETATTR3args, NULL_xdrproc_t, sizeof (SETATTR3args), | |
840 xdr_SETATTR3res, NULL_xdrproc_t, sizeof (SETATTR3res), | |
841 nullfree, 0, | |
74 | 842 rfs3_setattr_getfh}, |
0 | 843 |
844 /* RFS3_LOOKUP = 3 */ | |
845 {rfs3_lookup, | |
846 xdr_diropargs3, NULL_xdrproc_t, sizeof (LOOKUP3args), | |
847 xdr_LOOKUP3res, NULL_xdrproc_t, sizeof (LOOKUP3res), | |
848 nullfree, (RPC_IDEMPOTENT | RPC_PUBLICFH_OK), | |
74 | 849 rfs3_lookup_getfh}, |
0 | 850 |
851 /* RFS3_ACCESS = 4 */ | |
852 {rfs3_access, | |
853 xdr_ACCESS3args, NULL_xdrproc_t, sizeof (ACCESS3args), | |
854 xdr_ACCESS3res, NULL_xdrproc_t, sizeof (ACCESS3res), | |
855 nullfree, RPC_IDEMPOTENT, | |
74 | 856 rfs3_access_getfh}, |
0 | 857 |
858 /* RFS3_READLINK = 5 */ | |
859 {rfs3_readlink, | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
860 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (READLINK3args), |
0 | 861 xdr_READLINK3res, NULL_xdrproc_t, sizeof (READLINK3res), |
862 rfs3_readlink_free, RPC_IDEMPOTENT, | |
74 | 863 rfs3_readlink_getfh}, |
0 | 864 |
865 /* RFS3_READ = 6 */ | |
866 {rfs3_read, | |
867 xdr_READ3args, NULL_xdrproc_t, sizeof (READ3args), | |
868 xdr_READ3res, NULL_xdrproc_t, sizeof (READ3res), | |
869 rfs3_read_free, RPC_IDEMPOTENT, | |
74 | 870 rfs3_read_getfh}, |
0 | 871 |
872 /* RFS3_WRITE = 7 */ | |
873 {rfs3_write, | |
874 xdr_WRITE3args, NULL_xdrproc_t, sizeof (WRITE3args), | |
875 xdr_WRITE3res, NULL_xdrproc_t, sizeof (WRITE3res), | |
876 nullfree, 0, | |
74 | 877 rfs3_write_getfh}, |
0 | 878 |
879 /* RFS3_CREATE = 8 */ | |
880 {rfs3_create, | |
881 xdr_CREATE3args, NULL_xdrproc_t, sizeof (CREATE3args), | |
882 xdr_CREATE3res, NULL_xdrproc_t, sizeof (CREATE3res), | |
883 nullfree, 0, | |
74 | 884 rfs3_create_getfh}, |
0 | 885 |
886 /* RFS3_MKDIR = 9 */ | |
887 {rfs3_mkdir, | |
888 xdr_MKDIR3args, NULL_xdrproc_t, sizeof (MKDIR3args), | |
889 xdr_MKDIR3res, NULL_xdrproc_t, sizeof (MKDIR3res), | |
890 nullfree, 0, | |
74 | 891 rfs3_mkdir_getfh}, |
0 | 892 |
893 /* RFS3_SYMLINK = 10 */ | |
894 {rfs3_symlink, | |
895 xdr_SYMLINK3args, NULL_xdrproc_t, sizeof (SYMLINK3args), | |
896 xdr_SYMLINK3res, NULL_xdrproc_t, sizeof (SYMLINK3res), | |
897 nullfree, 0, | |
74 | 898 rfs3_symlink_getfh}, |
0 | 899 |
900 /* RFS3_MKNOD = 11 */ | |
901 {rfs3_mknod, | |
902 xdr_MKNOD3args, NULL_xdrproc_t, sizeof (MKNOD3args), | |
903 xdr_MKNOD3res, NULL_xdrproc_t, sizeof (MKNOD3res), | |
904 nullfree, 0, | |
74 | 905 rfs3_mknod_getfh}, |
0 | 906 |
907 /* RFS3_REMOVE = 12 */ | |
908 {rfs3_remove, | |
909 xdr_diropargs3, NULL_xdrproc_t, sizeof (REMOVE3args), | |
910 xdr_REMOVE3res, NULL_xdrproc_t, sizeof (REMOVE3res), | |
911 nullfree, 0, | |
74 | 912 rfs3_remove_getfh}, |
0 | 913 |
914 /* RFS3_RMDIR = 13 */ | |
915 {rfs3_rmdir, | |
916 xdr_diropargs3, NULL_xdrproc_t, sizeof (RMDIR3args), | |
917 xdr_RMDIR3res, NULL_xdrproc_t, sizeof (RMDIR3res), | |
918 nullfree, 0, | |
74 | 919 rfs3_rmdir_getfh}, |
0 | 920 |
921 /* RFS3_RENAME = 14 */ | |
922 {rfs3_rename, | |
923 xdr_RENAME3args, NULL_xdrproc_t, sizeof (RENAME3args), | |
924 xdr_RENAME3res, NULL_xdrproc_t, sizeof (RENAME3res), | |
925 nullfree, 0, | |
74 | 926 rfs3_rename_getfh}, |
0 | 927 |
928 /* RFS3_LINK = 15 */ | |
929 {rfs3_link, | |
930 xdr_LINK3args, NULL_xdrproc_t, sizeof (LINK3args), | |
931 xdr_LINK3res, NULL_xdrproc_t, sizeof (LINK3res), | |
932 nullfree, 0, | |
74 | 933 rfs3_link_getfh}, |
0 | 934 |
935 /* RFS3_READDIR = 16 */ | |
936 {rfs3_readdir, | |
937 xdr_READDIR3args, NULL_xdrproc_t, sizeof (READDIR3args), | |
938 xdr_READDIR3res, NULL_xdrproc_t, sizeof (READDIR3res), | |
939 rfs3_readdir_free, RPC_IDEMPOTENT, | |
74 | 940 rfs3_readdir_getfh}, |
0 | 941 |
942 /* RFS3_READDIRPLUS = 17 */ | |
943 {rfs3_readdirplus, | |
944 xdr_READDIRPLUS3args, NULL_xdrproc_t, sizeof (READDIRPLUS3args), | |
945 xdr_READDIRPLUS3res, NULL_xdrproc_t, sizeof (READDIRPLUS3res), | |
946 rfs3_readdirplus_free, RPC_AVOIDWORK, | |
74 | 947 rfs3_readdirplus_getfh}, |
0 | 948 |
949 /* RFS3_FSSTAT = 18 */ | |
950 {rfs3_fsstat, | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
951 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (FSSTAT3args), |
0 | 952 xdr_FSSTAT3res, NULL_xdrproc_t, sizeof (FSSTAT3res), |
953 nullfree, RPC_IDEMPOTENT, | |
74 | 954 rfs3_fsstat_getfh}, |
0 | 955 |
956 /* RFS3_FSINFO = 19 */ | |
957 {rfs3_fsinfo, | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
958 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (FSINFO3args), |
0 | 959 xdr_FSINFO3res, NULL_xdrproc_t, sizeof (FSINFO3res), |
960 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON, | |
74 | 961 rfs3_fsinfo_getfh}, |
0 | 962 |
963 /* RFS3_PATHCONF = 20 */ | |
964 {rfs3_pathconf, | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
965 xdr_nfs_fh3_server, NULL_xdrproc_t, sizeof (PATHCONF3args), |
0 | 966 xdr_PATHCONF3res, NULL_xdrproc_t, sizeof (PATHCONF3res), |
967 nullfree, RPC_IDEMPOTENT, | |
74 | 968 rfs3_pathconf_getfh}, |
0 | 969 |
970 /* RFS3_COMMIT = 21 */ | |
971 {rfs3_commit, | |
972 xdr_COMMIT3args, NULL_xdrproc_t, sizeof (COMMIT3args), | |
973 xdr_COMMIT3res, NULL_xdrproc_t, sizeof (COMMIT3res), | |
974 nullfree, RPC_IDEMPOTENT, | |
74 | 975 rfs3_commit_getfh}, |
0 | 976 }; |
977 | |
978 static char *rfscallnames_v4[] = { | |
979 "RFS4_NULL", | |
980 "RFS4_COMPOUND", | |
981 "RFS4_NULL", | |
982 "RFS4_NULL", | |
983 "RFS4_NULL", | |
984 "RFS4_NULL", | |
985 "RFS4_NULL", | |
986 "RFS4_NULL", | |
987 "RFS4_CREATE" | |
988 }; | |
989 | |
990 static struct rpcdisp rfsdisptab_v4[] = { | |
991 /* | |
992 * NFS VERSION 4 | |
993 */ | |
994 | |
995 /* RFS_NULL = 0 */ | |
996 {rpc_null, | |
997 xdr_void, NULL_xdrproc_t, 0, | |
998 xdr_void, NULL_xdrproc_t, 0, | |
74 | 999 nullfree, RPC_IDEMPOTENT, 0}, |
0 | 1000 |
1001 /* RFS4_compound = 1 */ | |
1002 {rfs4_compound, | |
806 | 1003 xdr_COMPOUND4args_srv, NULL_xdrproc_t, sizeof (COMPOUND4args), |
1004 xdr_COMPOUND4res_srv, NULL_xdrproc_t, sizeof (COMPOUND4res), | |
74 | 1005 rfs4_compound_free, 0, 0}, |
0 | 1006 }; |
1007 | |
1008 union rfs_args { | |
1009 /* | |
1010 * NFS VERSION 2 | |
1011 */ | |
1012 | |
1013 /* RFS_NULL = 0 */ | |
1014 | |
1015 /* RFS_GETATTR = 1 */ | |
1016 fhandle_t nfs2_getattr_args; | |
1017 | |
1018 /* RFS_SETATTR = 2 */ | |
1019 struct nfssaargs nfs2_setattr_args; | |
1020 | |
1021 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */ | |
1022 | |
1023 /* RFS_LOOKUP = 4 */ | |
1024 struct nfsdiropargs nfs2_lookup_args; | |
1025 | |
1026 /* RFS_READLINK = 5 */ | |
1027 fhandle_t nfs2_readlink_args; | |
1028 | |
1029 /* RFS_READ = 6 */ | |
1030 struct nfsreadargs nfs2_read_args; | |
1031 | |
1032 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */ | |
1033 | |
1034 /* RFS_WRITE = 8 */ | |
1035 struct nfswriteargs nfs2_write_args; | |
1036 | |
1037 /* RFS_CREATE = 9 */ | |
1038 struct nfscreatargs nfs2_create_args; | |
1039 | |
1040 /* RFS_REMOVE = 10 */ | |
1041 struct nfsdiropargs nfs2_remove_args; | |
1042 | |
1043 /* RFS_RENAME = 11 */ | |
1044 struct nfsrnmargs nfs2_rename_args; | |
1045 | |
1046 /* RFS_LINK = 12 */ | |
1047 struct nfslinkargs nfs2_link_args; | |
1048 | |
1049 /* RFS_SYMLINK = 13 */ | |
1050 struct nfsslargs nfs2_symlink_args; | |
1051 | |
1052 /* RFS_MKDIR = 14 */ | |
1053 struct nfscreatargs nfs2_mkdir_args; | |
1054 | |
1055 /* RFS_RMDIR = 15 */ | |
1056 struct nfsdiropargs nfs2_rmdir_args; | |
1057 | |
1058 /* RFS_READDIR = 16 */ | |
1059 struct nfsrddirargs nfs2_readdir_args; | |
1060 | |
1061 /* RFS_STATFS = 17 */ | |
1062 fhandle_t nfs2_statfs_args; | |
1063 | |
1064 /* | |
1065 * NFS VERSION 3 | |
1066 */ | |
1067 | |
1068 /* RFS_NULL = 0 */ | |
1069 | |
1070 /* RFS3_GETATTR = 1 */ | |
1071 GETATTR3args nfs3_getattr_args; | |
1072 | |
1073 /* RFS3_SETATTR = 2 */ | |
1074 SETATTR3args nfs3_setattr_args; | |
1075 | |
1076 /* RFS3_LOOKUP = 3 */ | |
1077 LOOKUP3args nfs3_lookup_args; | |
1078 | |
1079 /* RFS3_ACCESS = 4 */ | |
1080 ACCESS3args nfs3_access_args; | |
1081 | |
1082 /* RFS3_READLINK = 5 */ | |
1083 READLINK3args nfs3_readlink_args; | |
1084 | |
1085 /* RFS3_READ = 6 */ | |
1086 READ3args nfs3_read_args; | |
1087 | |
1088 /* RFS3_WRITE = 7 */ | |
1089 WRITE3args nfs3_write_args; | |
1090 | |
1091 /* RFS3_CREATE = 8 */ | |
1092 CREATE3args nfs3_create_args; | |
1093 | |
1094 /* RFS3_MKDIR = 9 */ | |
1095 MKDIR3args nfs3_mkdir_args; | |
1096 | |
1097 /* RFS3_SYMLINK = 10 */ | |
1098 SYMLINK3args nfs3_symlink_args; | |
1099 | |
1100 /* RFS3_MKNOD = 11 */ | |
1101 MKNOD3args nfs3_mknod_args; | |
1102 | |
1103 /* RFS3_REMOVE = 12 */ | |
1104 REMOVE3args nfs3_remove_args; | |
1105 | |
1106 /* RFS3_RMDIR = 13 */ | |
1107 RMDIR3args nfs3_rmdir_args; | |
1108 | |
1109 /* RFS3_RENAME = 14 */ | |
1110 RENAME3args nfs3_rename_args; | |
1111 | |
1112 /* RFS3_LINK = 15 */ | |
1113 LINK3args nfs3_link_args; | |
1114 | |
1115 /* RFS3_READDIR = 16 */ | |
1116 READDIR3args nfs3_readdir_args; | |
1117 | |
1118 /* RFS3_READDIRPLUS = 17 */ | |
1119 READDIRPLUS3args nfs3_readdirplus_args; | |
1120 | |
1121 /* RFS3_FSSTAT = 18 */ | |
1122 FSSTAT3args nfs3_fsstat_args; | |
1123 | |
1124 /* RFS3_FSINFO = 19 */ | |
1125 FSINFO3args nfs3_fsinfo_args; | |
1126 | |
1127 /* RFS3_PATHCONF = 20 */ | |
1128 PATHCONF3args nfs3_pathconf_args; | |
1129 | |
1130 /* RFS3_COMMIT = 21 */ | |
1131 COMMIT3args nfs3_commit_args; | |
1132 | |
1133 /* | |
1134 * NFS VERSION 4 | |
1135 */ | |
1136 | |
1137 /* RFS_NULL = 0 */ | |
1138 | |
1139 /* COMPUND = 1 */ | |
1140 COMPOUND4args nfs4_compound_args; | |
1141 }; | |
1142 | |
1143 union rfs_res { | |
1144 /* | |
1145 * NFS VERSION 2 | |
1146 */ | |
1147 | |
1148 /* RFS_NULL = 0 */ | |
1149 | |
1150 /* RFS_GETATTR = 1 */ | |
1151 struct nfsattrstat nfs2_getattr_res; | |
1152 | |
1153 /* RFS_SETATTR = 2 */ | |
1154 struct nfsattrstat nfs2_setattr_res; | |
1155 | |
1156 /* RFS_ROOT = 3 *** NO LONGER SUPPORTED *** */ | |
1157 | |
1158 /* RFS_LOOKUP = 4 */ | |
1159 struct nfsdiropres nfs2_lookup_res; | |
1160 | |
1161 /* RFS_READLINK = 5 */ | |
1162 struct nfsrdlnres nfs2_readlink_res; | |
1163 | |
1164 /* RFS_READ = 6 */ | |
1165 struct nfsrdresult nfs2_read_res; | |
1166 | |
1167 /* RFS_WRITECACHE = 7 *** NO LONGER SUPPORTED *** */ | |
1168 | |
1169 /* RFS_WRITE = 8 */ | |
1170 struct nfsattrstat nfs2_write_res; | |
1171 | |
1172 /* RFS_CREATE = 9 */ | |
1173 struct nfsdiropres nfs2_create_res; | |
1174 | |
1175 /* RFS_REMOVE = 10 */ | |
1176 enum nfsstat nfs2_remove_res; | |
1177 | |
1178 /* RFS_RENAME = 11 */ | |
1179 enum nfsstat nfs2_rename_res; | |
1180 | |
1181 /* RFS_LINK = 12 */ | |
1182 enum nfsstat nfs2_link_res; | |
1183 | |
1184 /* RFS_SYMLINK = 13 */ | |
1185 enum nfsstat nfs2_symlink_res; | |
1186 | |
1187 /* RFS_MKDIR = 14 */ | |
1188 struct nfsdiropres nfs2_mkdir_res; | |
1189 | |
1190 /* RFS_RMDIR = 15 */ | |
1191 enum nfsstat nfs2_rmdir_res; | |
1192 | |
1193 /* RFS_READDIR = 16 */ | |
1194 struct nfsrddirres nfs2_readdir_res; | |
1195 | |
1196 /* RFS_STATFS = 17 */ | |
1197 struct nfsstatfs nfs2_statfs_res; | |
1198 | |
1199 /* | |
1200 * NFS VERSION 3 | |
1201 */ | |
1202 | |
1203 /* RFS_NULL = 0 */ | |
1204 | |
1205 /* RFS3_GETATTR = 1 */ | |
1206 GETATTR3res nfs3_getattr_res; | |
1207 | |
1208 /* RFS3_SETATTR = 2 */ | |
1209 SETATTR3res nfs3_setattr_res; | |
1210 | |
1211 /* RFS3_LOOKUP = 3 */ | |
1212 LOOKUP3res nfs3_lookup_res; | |
1213 | |
1214 /* RFS3_ACCESS = 4 */ | |
1215 ACCESS3res nfs3_access_res; | |
1216 | |
1217 /* RFS3_READLINK = 5 */ | |
1218 READLINK3res nfs3_readlink_res; | |
1219 | |
1220 /* RFS3_READ = 6 */ | |
1221 READ3res nfs3_read_res; | |
1222 | |
1223 /* RFS3_WRITE = 7 */ | |
1224 WRITE3res nfs3_write_res; | |
1225 | |
1226 /* RFS3_CREATE = 8 */ | |
1227 CREATE3res nfs3_create_res; | |
1228 | |
1229 /* RFS3_MKDIR = 9 */ | |
1230 MKDIR3res nfs3_mkdir_res; | |
1231 | |
1232 /* RFS3_SYMLINK = 10 */ | |
1233 SYMLINK3res nfs3_symlink_res; | |
1234 | |
1235 /* RFS3_MKNOD = 11 */ | |
1236 MKNOD3res nfs3_mknod_res; | |
1237 | |
1238 /* RFS3_REMOVE = 12 */ | |
1239 REMOVE3res nfs3_remove_res; | |
1240 | |
1241 /* RFS3_RMDIR = 13 */ | |
1242 RMDIR3res nfs3_rmdir_res; | |
1243 | |
1244 /* RFS3_RENAME = 14 */ | |
1245 RENAME3res nfs3_rename_res; | |
1246 | |
1247 /* RFS3_LINK = 15 */ | |
1248 LINK3res nfs3_link_res; | |
1249 | |
1250 /* RFS3_READDIR = 16 */ | |
1251 READDIR3res nfs3_readdir_res; | |
1252 | |
1253 /* RFS3_READDIRPLUS = 17 */ | |
1254 READDIRPLUS3res nfs3_readdirplus_res; | |
1255 | |
1256 /* RFS3_FSSTAT = 18 */ | |
1257 FSSTAT3res nfs3_fsstat_res; | |
1258 | |
1259 /* RFS3_FSINFO = 19 */ | |
1260 FSINFO3res nfs3_fsinfo_res; | |
1261 | |
1262 /* RFS3_PATHCONF = 20 */ | |
1263 PATHCONF3res nfs3_pathconf_res; | |
1264 | |
1265 /* RFS3_COMMIT = 21 */ | |
1266 COMMIT3res nfs3_commit_res; | |
1267 | |
1268 /* | |
1269 * NFS VERSION 4 | |
1270 */ | |
1271 | |
1272 /* RFS_NULL = 0 */ | |
1273 | |
1274 /* RFS4_COMPOUND = 1 */ | |
1275 COMPOUND4res nfs4_compound_res; | |
1276 | |
1277 }; | |
1278 | |
1279 static struct rpc_disptable rfs_disptable[] = { | |
1280 {sizeof (rfsdisptab_v2) / sizeof (rfsdisptab_v2[0]), | |
1281 rfscallnames_v2, | |
1282 &rfsproccnt_v2_ptr, rfsdisptab_v2}, | |
1283 {sizeof (rfsdisptab_v3) / sizeof (rfsdisptab_v3[0]), | |
1284 rfscallnames_v3, | |
1285 &rfsproccnt_v3_ptr, rfsdisptab_v3}, | |
1286 {sizeof (rfsdisptab_v4) / sizeof (rfsdisptab_v4[0]), | |
1287 rfscallnames_v4, | |
1288 &rfsproccnt_v4_ptr, rfsdisptab_v4}, | |
1289 }; | |
1290 | |
1291 /* | |
1292 * If nfs_portmon is set, then clients are required to use privileged | |
1293 * ports (ports < IPPORT_RESERVED) in order to get NFS services. | |
1294 * | |
1295 * N.B.: this attempt to carry forward the already ill-conceived notion | |
1296 * of privileged ports for TCP/UDP is really quite ineffectual. Not only | |
1297 * is it transport-dependent, it's laughably easy to spoof. If you're | |
1298 * really interested in security, you must start with secure RPC instead. | |
1299 */ | |
1300 static int nfs_portmon = 0; | |
1301 | |
1302 #ifdef DEBUG | |
1303 static int cred_hits = 0; | |
1304 static int cred_misses = 0; | |
1305 #endif | |
1306 | |
1307 | |
1308 #ifdef DEBUG | |
1309 /* | |
1310 * Debug code to allow disabling of rfs_dispatch() use of | |
1311 * fastxdrargs() and fastxdrres() calls for testing purposes. | |
1312 */ | |
1313 static int rfs_no_fast_xdrargs = 0; | |
1314 static int rfs_no_fast_xdrres = 0; | |
1315 #endif | |
1316 | |
1317 union acl_args { | |
1318 /* | |
1319 * ACL VERSION 2 | |
1320 */ | |
1321 | |
1322 /* ACL2_NULL = 0 */ | |
1323 | |
1324 /* ACL2_GETACL = 1 */ | |
1325 GETACL2args acl2_getacl_args; | |
1326 | |
1327 /* ACL2_SETACL = 2 */ | |
1328 SETACL2args acl2_setacl_args; | |
1329 | |
1330 /* ACL2_GETATTR = 3 */ | |
1331 GETATTR2args acl2_getattr_args; | |
1332 | |
1333 /* ACL2_ACCESS = 4 */ | |
1334 ACCESS2args acl2_access_args; | |
1335 | |
1336 /* ACL2_GETXATTRDIR = 5 */ | |
1337 GETXATTRDIR2args acl2_getxattrdir_args; | |
1338 | |
1339 /* | |
1340 * ACL VERSION 3 | |
1341 */ | |
1342 | |
1343 /* ACL3_NULL = 0 */ | |
1344 | |
1345 /* ACL3_GETACL = 1 */ | |
1346 GETACL3args acl3_getacl_args; | |
1347 | |
1348 /* ACL3_SETACL = 2 */ | |
1349 SETACL3args acl3_setacl; | |
1350 | |
1351 /* ACL3_GETXATTRDIR = 3 */ | |
1352 GETXATTRDIR3args acl3_getxattrdir_args; | |
1353 | |
1354 }; | |
1355 | |
1356 union acl_res { | |
1357 /* | |
1358 * ACL VERSION 2 | |
1359 */ | |
1360 | |
1361 /* ACL2_NULL = 0 */ | |
1362 | |
1363 /* ACL2_GETACL = 1 */ | |
1364 GETACL2res acl2_getacl_res; | |
1365 | |
1366 /* ACL2_SETACL = 2 */ | |
1367 SETACL2res acl2_setacl_res; | |
1368 | |
1369 /* ACL2_GETATTR = 3 */ | |
1370 GETATTR2res acl2_getattr_res; | |
1371 | |
1372 /* ACL2_ACCESS = 4 */ | |
1373 ACCESS2res acl2_access_res; | |
1374 | |
1375 /* ACL2_GETXATTRDIR = 5 */ | |
1376 GETXATTRDIR2args acl2_getxattrdir_res; | |
1377 | |
1378 /* | |
1379 * ACL VERSION 3 | |
1380 */ | |
1381 | |
1382 /* ACL3_NULL = 0 */ | |
1383 | |
1384 /* ACL3_GETACL = 1 */ | |
1385 GETACL3res acl3_getacl_res; | |
1386 | |
1387 /* ACL3_SETACL = 2 */ | |
1388 SETACL3res acl3_setacl_res; | |
1389 | |
1390 /* ACL3_GETXATTRDIR = 3 */ | |
1391 GETXATTRDIR3res acl3_getxattrdir_res; | |
1392 | |
1393 }; | |
1394 | |
1395 static bool_t | |
1396 auth_tooweak(struct svc_req *req, char *res) | |
1397 { | |
1398 | |
1399 if (req->rq_vers == NFS_VERSION && req->rq_proc == RFS_LOOKUP) { | |
1400 struct nfsdiropres *dr = (struct nfsdiropres *)res; | |
1401 if (dr->dr_status == WNFSERR_CLNT_FLAVOR) | |
1402 return (TRUE); | |
1403 } else if (req->rq_vers == NFS_V3 && req->rq_proc == NFSPROC3_LOOKUP) { | |
1404 LOOKUP3res *resp = (LOOKUP3res *)res; | |
1405 if (resp->status == WNFSERR_CLNT_FLAVOR) | |
1406 return (TRUE); | |
1407 } | |
1408 return (FALSE); | |
1409 } | |
1410 | |
74 | 1411 |
0 | 1412 static void |
1413 common_dispatch(struct svc_req *req, SVCXPRT *xprt, rpcvers_t min_vers, | |
1414 rpcvers_t max_vers, char *pgmname, | |
1415 struct rpc_disptable *disptable) | |
1416 { | |
1417 int which; | |
1418 rpcvers_t vers; | |
1419 char *args; | |
1420 union { | |
1421 union rfs_args ra; | |
1422 union acl_args aa; | |
1423 } args_buf; | |
1424 char *res; | |
1425 union { | |
1426 union rfs_res rr; | |
1427 union acl_res ar; | |
1428 } res_buf; | |
1429 struct rpcdisp *disp = NULL; | |
1430 int dis_flags = 0; | |
1431 cred_t *cr; | |
1432 int error = 0; | |
1433 int anon_ok; | |
1434 struct exportinfo *exi = NULL; | |
1435 unsigned int nfslog_rec_id; | |
1436 int dupstat; | |
1437 struct dupreq *dr; | |
1438 int authres; | |
1439 bool_t publicfh_ok = FALSE; | |
1440 enum_t auth_flavor; | |
1441 bool_t dupcached = FALSE; | |
1442 struct netbuf nb; | |
1443 bool_t logging_enabled = FALSE; | |
1444 struct exportinfo *nfslog_exi = NULL; | |
1232 | 1445 char **procnames; |
1446 char cbuf[INET6_ADDRSTRLEN]; /* to hold both IPv4 and IPv6 addr */ | |
0 | 1447 |
1448 vers = req->rq_vers; | |
1449 | |
1450 if (vers < min_vers || vers > max_vers) { | |
1451 svcerr_progvers(req->rq_xprt, min_vers, max_vers); | |
1452 error++; | |
1453 cmn_err(CE_NOTE, "%s: bad version number %u", pgmname, vers); | |
1454 goto done; | |
1455 } | |
1456 vers -= min_vers; | |
1457 | |
1458 which = req->rq_proc; | |
1459 if (which < 0 || which >= disptable[(int)vers].dis_nprocs) { | |
1460 svcerr_noproc(req->rq_xprt); | |
1461 error++; | |
1462 goto done; | |
1463 } | |
1464 | |
1465 (*(disptable[(int)vers].dis_proccntp))[which].value.ui64++; | |
1466 | |
1467 disp = &disptable[(int)vers].dis_table[which]; | |
1232 | 1468 procnames = disptable[(int)vers].dis_procnames; |
0 | 1469 |
1470 auth_flavor = req->rq_cred.oa_flavor; | |
1232 | 1471 |
0 | 1472 /* |
1473 * Deserialize into the args struct. | |
1474 */ | |
1475 args = (char *)&args_buf; | |
74 | 1476 |
0 | 1477 #ifdef DEBUG |
1478 if (rfs_no_fast_xdrargs || (auth_flavor == RPCSEC_GSS) || | |
1479 disp->dis_fastxdrargs == NULL_xdrproc_t || | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1480 !SVC_GETARGS(xprt, disp->dis_fastxdrargs, (char *)&args)) |
0 | 1481 #else |
1482 if ((auth_flavor == RPCSEC_GSS) || | |
1483 disp->dis_fastxdrargs == NULL_xdrproc_t || | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1484 !SVC_GETARGS(xprt, disp->dis_fastxdrargs, (char *)&args)) |
0 | 1485 #endif |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1486 { |
0 | 1487 bzero(args, disp->dis_argsz); |
1488 if (!SVC_GETARGS(xprt, disp->dis_xdrargs, args)) { | |
1489 svcerr_decode(xprt); | |
1490 error++; | |
1232 | 1491 cmn_err(CE_NOTE, |
1492 "Failed to decode arguments for %s version %u " | |
1493 "procedure %s client %s%s", | |
1494 pgmname, vers + min_vers, procnames[which], | |
1495 client_name(req), client_addr(req, cbuf)); | |
0 | 1496 goto done; |
1497 } | |
1498 } | |
1499 | |
1500 /* | |
74 | 1501 * If Version 4 use that specific dispatch function. |
0 | 1502 */ |
74 | 1503 if (req->rq_vers == 4) { |
1504 error += rfs4_dispatch(disp, req, xprt, args); | |
1505 goto done; | |
1506 } | |
1507 | |
1508 dis_flags = disp->dis_flags; | |
0 | 1509 |
1510 /* | |
1511 * Find export information and check authentication, | |
1512 * setting the credential if everything is ok. | |
1513 */ | |
1514 if (disp->dis_getfh != NULL) { | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1515 void *fh; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1516 fsid_t *fsid; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1517 fid_t *fid, *xfid; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1518 fhandle_t *fh2; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1519 nfs_fh3 *fh3; |
0 | 1520 |
1521 fh = (*disp->dis_getfh)(args); | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1522 switch (req->rq_vers) { |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1523 case NFS_VERSION: |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1524 fh2 = (fhandle_t *)fh; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1525 fsid = &fh2->fh_fsid; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1526 fid = (fid_t *)&fh2->fh_len; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1527 xfid = (fid_t *)&fh2->fh_xlen; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1528 break; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1529 case NFS_V3: |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1530 fh3 = (nfs_fh3 *)fh; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1531 fsid = &fh3->fh3_fsid; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1532 fid = FH3TOFIDP(fh3); |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1533 xfid = FH3TOXFIDP(fh3); |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1534 break; |
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1535 } |
0 | 1536 |
1537 /* | |
1538 * Fix for bug 1038302 - corbin | |
1539 * There is a problem here if anonymous access is | |
1540 * disallowed. If the current request is part of the | |
1541 * client's mount process for the requested filesystem, | |
1542 * then it will carry root (uid 0) credentials on it, and | |
1543 * will be denied by checkauth if that client does not | |
1544 * have explicit root=0 permission. This will cause the | |
1545 * client's mount operation to fail. As a work-around, | |
1546 * we check here to see if the request is a getattr or | |
1547 * statfs operation on the exported vnode itself, and | |
1548 * pass a flag to checkauth with the result of this test. | |
1549 * | |
1550 * The filehandle refers to the mountpoint itself if | |
1551 * the fh_data and fh_xdata portions of the filehandle | |
1552 * are equal. | |
1553 * | |
1554 * Added anon_ok argument to checkauth(). | |
1555 */ | |
1556 | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1557 if ((dis_flags & RPC_ALLOWANON) && EQFID(fid, xfid)) |
0 | 1558 anon_ok = 1; |
1559 else | |
1560 anon_ok = 0; | |
1561 | |
1562 cr = xprt->xp_cred; | |
1563 ASSERT(cr != NULL); | |
1564 #ifdef DEBUG | |
1565 if (crgetref(cr) != 1) { | |
1566 crfree(cr); | |
1567 cr = crget(); | |
1568 xprt->xp_cred = cr; | |
1569 cred_misses++; | |
1570 } else | |
1571 cred_hits++; | |
1572 #else | |
1573 if (crgetref(cr) != 1) { | |
1574 crfree(cr); | |
1575 cr = crget(); | |
1576 xprt->xp_cred = cr; | |
1577 } | |
1578 #endif | |
1579 | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1580 exi = checkexport(fsid, xfid); |
74 | 1581 |
0 | 1582 if (exi != NULL) { |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1583 publicfh_ok = PUBLICFH_CHECK(disp, exi, fsid, xfid); |
0 | 1584 |
1585 /* | |
1586 * Don't allow non-V4 clients access | |
1587 * to pseudo exports | |
1588 */ | |
1589 if (PSEUDO(exi)) { | |
1590 svcerr_weakauth(xprt); | |
1591 error++; | |
1592 goto done; | |
1593 } | |
1594 | |
1595 authres = checkauth(exi, req, cr, anon_ok, publicfh_ok); | |
1596 /* | |
1597 * authres > 0: authentication OK - proceed | |
1598 * authres == 0: authentication weak - return error | |
1599 * authres < 0: authentication timeout - drop | |
1600 */ | |
1601 if (authres <= 0) { | |
1602 if (authres == 0) { | |
1603 svcerr_weakauth(xprt); | |
1604 error++; | |
1605 } | |
1606 goto done; | |
1607 } | |
1608 } | |
1609 } else | |
1610 cr = NULL; | |
1611 | |
1612 if ((dis_flags & RPC_MAPRESP) && (auth_flavor != RPCSEC_GSS)) { | |
1613 res = (char *)SVC_GETRES(xprt, disp->dis_ressz); | |
1614 if (res == NULL) | |
1615 res = (char *)&res_buf; | |
1616 } else | |
1617 res = (char *)&res_buf; | |
1618 | |
1619 if (!(dis_flags & RPC_IDEMPOTENT)) { | |
1620 dupstat = SVC_DUP_EXT(xprt, req, res, disp->dis_ressz, &dr, | |
1621 &dupcached); | |
1622 | |
1623 switch (dupstat) { | |
1624 case DUP_ERROR: | |
1625 svcerr_systemerr(xprt); | |
1626 error++; | |
1627 goto done; | |
1628 /* NOTREACHED */ | |
1629 case DUP_INPROGRESS: | |
1630 if (res != (char *)&res_buf) | |
1631 SVC_FREERES(xprt); | |
1632 error++; | |
1633 goto done; | |
1634 /* NOTREACHED */ | |
1635 case DUP_NEW: | |
1636 case DUP_DROP: | |
1637 curthread->t_flag |= T_DONTPEND; | |
74 | 1638 |
0 | 1639 (*disp->dis_proc)(args, res, exi, req, cr); |
74 | 1640 |
0 | 1641 curthread->t_flag &= ~T_DONTPEND; |
1642 if (curthread->t_flag & T_WOULDBLOCK) { | |
1643 curthread->t_flag &= ~T_WOULDBLOCK; | |
1644 SVC_DUPDONE_EXT(xprt, dr, res, NULL, | |
1645 disp->dis_ressz, DUP_DROP); | |
1646 if (res != (char *)&res_buf) | |
1647 SVC_FREERES(xprt); | |
1648 error++; | |
1649 goto done; | |
1650 } | |
1651 if (dis_flags & RPC_AVOIDWORK) { | |
1652 SVC_DUPDONE_EXT(xprt, dr, res, NULL, | |
1653 disp->dis_ressz, DUP_DROP); | |
1654 } else { | |
1655 SVC_DUPDONE_EXT(xprt, dr, res, | |
1656 disp->dis_resfree == nullfree ? NULL : | |
1657 disp->dis_resfree, | |
1658 disp->dis_ressz, DUP_DONE); | |
1659 dupcached = TRUE; | |
1660 } | |
1661 break; | |
1662 case DUP_DONE: | |
1663 break; | |
1664 } | |
1665 | |
1666 } else { | |
1667 curthread->t_flag |= T_DONTPEND; | |
74 | 1668 |
0 | 1669 (*disp->dis_proc)(args, res, exi, req, cr); |
74 | 1670 |
0 | 1671 curthread->t_flag &= ~T_DONTPEND; |
1672 if (curthread->t_flag & T_WOULDBLOCK) { | |
1673 curthread->t_flag &= ~T_WOULDBLOCK; | |
1674 if (res != (char *)&res_buf) | |
1675 SVC_FREERES(xprt); | |
1676 error++; | |
1677 goto done; | |
1678 } | |
1679 } | |
1680 | |
1681 if (auth_tooweak(req, res)) { | |
1682 svcerr_weakauth(xprt); | |
1683 error++; | |
1684 goto done; | |
1685 } | |
1686 | |
1687 /* | |
1688 * Check to see if logging has been enabled on the server. | |
1689 * If so, then obtain the export info struct to be used for | |
1690 * the later writing of the log record. This is done for | |
1691 * the case that a lookup is done across a non-logged public | |
1692 * file system. | |
1693 */ | |
1694 if (nfslog_buffer_list != NULL) { | |
1695 nfslog_exi = nfslog_get_exi(exi, req, res, &nfslog_rec_id); | |
1696 /* | |
1697 * Is logging enabled? | |
1698 */ | |
1699 logging_enabled = (nfslog_exi != NULL); | |
1700 | |
1701 /* | |
1702 * Copy the netbuf for logging purposes, before it is | |
1703 * freed by svc_sendreply(). | |
1704 */ | |
1705 if (logging_enabled) { | |
1706 NFSLOG_COPY_NETBUF(nfslog_exi, xprt, &nb); | |
1707 /* | |
1708 * If RPC_MAPRESP flag set (i.e. in V2 ops) the | |
1709 * res gets copied directly into the mbuf and | |
1710 * may be freed soon after the sendreply. So we | |
1711 * must copy it here to a safe place... | |
1712 */ | |
1713 if (res != (char *)&res_buf) { | |
1714 bcopy(res, (char *)&res_buf, disp->dis_ressz); | |
1715 } | |
1716 } | |
1717 } | |
1718 | |
1719 /* | |
1720 * Serialize and send results struct | |
1721 */ | |
1722 #ifdef DEBUG | |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1723 if (rfs_no_fast_xdrres == 0 && res != (char *)&res_buf) |
0 | 1724 #else |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1725 if (res != (char *)&res_buf) |
0 | 1726 #endif |
1610
3436e82414c8
6344186 NFSv3 needs to support .zfs (like NFSv4 already does)
thurlow
parents:
1232
diff
changeset
|
1727 { |
0 | 1728 if (!svc_sendreply(xprt, disp->dis_fastxdrres, res)) { |
1729 cmn_err(CE_NOTE, "%s: bad sendreply", pgmname); | |
1730 error++; | |
1731 } | |
1732 } else { | |
1733 if (!svc_sendreply(xprt, disp->dis_xdrres, res)) { | |
1734 cmn_err(CE_NOTE, "%s: bad sendreply", pgmname); | |
1735 error++; | |
1736 } | |
1737 } | |
1738 | |
1739 /* | |
1740 * Log if needed | |
1741 */ | |
1742 if (logging_enabled) { | |
1743 nfslog_write_record(nfslog_exi, req, args, (char *)&res_buf, | |
1744 cr, &nb, nfslog_rec_id, NFSLOG_ONE_BUFFER); | |
1745 exi_rele(nfslog_exi); | |
1746 kmem_free((&nb)->buf, (&nb)->len); | |
1747 } | |
1748 | |
1749 /* | |
1750 * Free results struct. With the addition of NFS V4 we can | |
1751 * have non-idempotent procedures with functions. | |
1752 */ | |
1753 if (disp->dis_resfree != nullfree && dupcached == FALSE) { | |
1754 (*disp->dis_resfree)(res); | |
1755 } | |
1756 | |
1757 done: | |
1758 /* | |
1759 * Free arguments struct | |
1760 */ | |
1761 if (disp) { | |
1762 if (!SVC_FREEARGS(xprt, disp->dis_xdrargs, args)) { | |
1763 cmn_err(CE_NOTE, "%s: bad freeargs", pgmname); | |
1764 error++; | |
1765 } | |
1766 } else { | |
1767 if (!SVC_FREEARGS(xprt, (xdrproc_t)0, (caddr_t)0)) { | |
1768 cmn_err(CE_NOTE, "%s: bad freeargs", pgmname); | |
1769 error++; | |
1770 } | |
1771 } | |
1772 | |
1773 if (exi != NULL) | |
1774 exi_rele(exi); | |
1775 | |
1776 global_svstat_ptr[req->rq_vers][NFS_BADCALLS].value.ui64 += error; | |
1777 | |
1778 global_svstat_ptr[req->rq_vers][NFS_CALLS].value.ui64++; | |
1779 } | |
1780 | |
1781 static void | |
1782 rfs_dispatch(struct svc_req *req, SVCXPRT *xprt) | |
1783 { | |
1784 common_dispatch(req, xprt, NFS_VERSMIN, NFS_VERSMAX, | |
1232 | 1785 "NFS", rfs_disptable); |
0 | 1786 } |
1787 | |
1788 static char *aclcallnames_v2[] = { | |
1789 "ACL2_NULL", | |
1790 "ACL2_GETACL", | |
1791 "ACL2_SETACL", | |
1792 "ACL2_GETATTR", | |
1793 "ACL2_ACCESS", | |
1794 "ACL2_GETXATTRDIR" | |
1795 }; | |
1796 | |
1797 static struct rpcdisp acldisptab_v2[] = { | |
1798 /* | |
1799 * ACL VERSION 2 | |
1800 */ | |
1801 | |
1802 /* ACL2_NULL = 0 */ | |
1803 {rpc_null, | |
1804 xdr_void, NULL_xdrproc_t, 0, | |
1805 xdr_void, NULL_xdrproc_t, 0, | |
1806 nullfree, RPC_IDEMPOTENT, | |
1807 0}, | |
1808 | |
1809 /* ACL2_GETACL = 1 */ | |
1810 {acl2_getacl, | |
1811 xdr_GETACL2args, xdr_fastGETACL2args, sizeof (GETACL2args), | |
1812 xdr_GETACL2res, NULL_xdrproc_t, sizeof (GETACL2res), | |
1813 acl2_getacl_free, RPC_IDEMPOTENT, | |
1814 acl2_getacl_getfh}, | |
1815 | |
1816 /* ACL2_SETACL = 2 */ | |
1817 {acl2_setacl, | |
1818 xdr_SETACL2args, NULL_xdrproc_t, sizeof (SETACL2args), | |
1819 #ifdef _LITTLE_ENDIAN | |
1820 xdr_SETACL2res, xdr_fastSETACL2res, sizeof (SETACL2res), | |
1821 #else | |
1822 xdr_SETACL2res, NULL_xdrproc_t, sizeof (SETACL2res), | |
1823 #endif | |
1824 nullfree, RPC_MAPRESP, | |
1825 acl2_setacl_getfh}, | |
1826 | |
1827 /* ACL2_GETATTR = 3 */ | |
1828 {acl2_getattr, | |
1829 xdr_GETATTR2args, xdr_fastGETATTR2args, sizeof (GETATTR2args), | |
1830 #ifdef _LITTLE_ENDIAN | |
1831 xdr_GETATTR2res, xdr_fastGETATTR2res, sizeof (GETATTR2res), | |
1832 #else | |
1833 xdr_GETATTR2res, NULL_xdrproc_t, sizeof (GETATTR2res), | |
1834 #endif | |
1835 nullfree, RPC_IDEMPOTENT|RPC_ALLOWANON|RPC_MAPRESP, | |
1836 acl2_getattr_getfh}, | |
1837 | |
1838 /* ACL2_ACCESS = 4 */ | |
1839 {acl2_access, | |
1840 xdr_ACCESS2args, xdr_fastACCESS2args, sizeof (ACCESS2args), | |
1841 #ifdef _LITTLE_ENDIAN | |
1842 xdr_ACCESS2res, xdr_fastACCESS2res, sizeof (ACCESS2res), | |
1843 #else | |
1844 xdr_ACCESS2res, NULL_xdrproc_t, sizeof (ACCESS2res), | |
1845 #endif | |
1846 nullfree, RPC_IDEMPOTENT|RPC_MAPRESP, | |
1847 acl2_access_getfh}, | |
1848 | |
1849 /* ACL2_GETXATTRDIR = 5 */ | |
1850 {acl2_getxattrdir, | |
1851 xdr_GETXATTRDIR2args, NULL_xdrproc_t, sizeof (GETXATTRDIR2args), | |
1852 xdr_GETXATTRDIR2res, NULL_xdrproc_t, sizeof (GETXATTRDIR2res), | |
1853 nullfree, RPC_IDEMPOTENT, | |
1854 acl2_getxattrdir_getfh}, | |
1855 }; | |
1856 | |
1857 static char *aclcallnames_v3[] = { | |
1858 "ACL3_NULL", | |
1859 "ACL3_GETACL", | |
1860 "ACL3_SETACL", | |
1861 "ACL3_GETXATTRDIR" | |
1862 }; | |
1863 | |
1864 static struct rpcdisp acldisptab_v3[] = { | |
1865 /* | |
1866 * ACL VERSION 3 | |
1867 */ | |
1868 | |
1869 /* ACL3_NULL = 0 */ | |
1870 {rpc_null, | |
1871 xdr_void, NULL_xdrproc_t, 0, | |
1872 xdr_void, NULL_xdrproc_t, 0, | |
1873 nullfree, RPC_IDEMPOTENT, | |
1874 0}, | |
1875 | |
1876 /* ACL3_GETACL = 1 */ | |
1877 {acl3_getacl, | |
1878 xdr_GETACL3args, NULL_xdrproc_t, sizeof (GETACL3args), | |
1879 xdr_GETACL3res, NULL_xdrproc_t, sizeof (GETACL3res), | |
1880 acl3_getacl_free, RPC_IDEMPOTENT, | |
1881 acl3_getacl_getfh}, | |
1882 | |
1883 /* ACL3_SETACL = 2 */ | |
1884 {acl3_setacl, | |
1885 xdr_SETACL3args, NULL_xdrproc_t, sizeof (SETACL3args), | |
1886 xdr_SETACL3res, NULL_xdrproc_t, sizeof (SETACL3res), | |
1887 nullfree, 0, | |
1888 acl3_setacl_getfh}, | |
1889 | |
1890 /* ACL3_GETXATTRDIR = 3 */ | |
1891 {acl3_getxattrdir, | |
1892 xdr_GETXATTRDIR3args, NULL_xdrproc_t, sizeof (GETXATTRDIR3args), | |
1893 xdr_GETXATTRDIR3res, NULL_xdrproc_t, sizeof (GETXATTRDIR3res), | |
1894 nullfree, RPC_IDEMPOTENT, | |
1895 acl3_getxattrdir_getfh}, | |
1896 }; | |
1897 | |
1898 static struct rpc_disptable acl_disptable[] = { | |
1899 {sizeof (acldisptab_v2) / sizeof (acldisptab_v2[0]), | |
1900 aclcallnames_v2, | |
1901 &aclproccnt_v2_ptr, acldisptab_v2}, | |
1902 {sizeof (acldisptab_v3) / sizeof (acldisptab_v3[0]), | |
1903 aclcallnames_v3, | |
1904 &aclproccnt_v3_ptr, acldisptab_v3}, | |
1905 }; | |
1906 | |
1907 static void | |
1908 acl_dispatch(struct svc_req *req, SVCXPRT *xprt) | |
1909 { | |
1910 common_dispatch(req, xprt, NFS_ACL_VERSMIN, NFS_ACL_VERSMAX, | |
1232 | 1911 "ACL", acl_disptable); |
0 | 1912 } |
1913 | |
1914 int | |
1915 checkwin(int flavor, int window, struct svc_req *req) | |
1916 { | |
1917 struct authdes_cred *adc; | |
1918 | |
1919 switch (flavor) { | |
1920 case AUTH_DES: | |
1921 adc = (struct authdes_cred *)req->rq_clntcred; | |
1922 if (adc->adc_fullname.window > window) | |
1923 return (0); | |
1924 break; | |
1925 | |
1926 default: | |
1927 break; | |
1928 } | |
1929 return (1); | |
1930 } | |
1931 | |
1932 | |
1933 /* | |
1934 * checkauth() will check the access permission against the export | |
1935 * information. Then map root uid/gid to appropriate uid/gid. | |
1936 * | |
1937 * This routine is used by NFS V3 and V2 code. | |
1938 */ | |
1939 static int | |
1940 checkauth(struct exportinfo *exi, struct svc_req *req, cred_t *cr, int anon_ok, | |
1941 bool_t publicfh_ok) | |
1942 { | |
1943 int i, nfsflavor, rpcflavor, stat, access; | |
1944 struct secinfo *secp; | |
1945 caddr_t principal; | |
1946 char buf[INET6_ADDRSTRLEN]; /* to hold both IPv4 and IPv6 addr */ | |
1947 int anon_res = 0; | |
1948 | |
1949 /* | |
1950 * Check for privileged port number | |
1951 * N.B.: this assumes that we know the format of a netbuf. | |
1952 */ | |
1953 if (nfs_portmon) { | |
1954 struct sockaddr *ca; | |
1955 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf; | |
1956 | |
1957 if (ca == NULL) | |
1958 return (0); | |
1959 | |
1960 if ((ca->sa_family == AF_INET && | |
1961 ntohs(((struct sockaddr_in *)ca)->sin_port) >= | |
1962 IPPORT_RESERVED) || | |
1963 (ca->sa_family == AF_INET6 && | |
1964 ntohs(((struct sockaddr_in6 *)ca)->sin6_port) >= | |
1965 IPPORT_RESERVED)) { | |
1966 cmn_err(CE_NOTE, | |
1967 "nfs_server: client %s%ssent NFS request from " | |
1968 "unprivileged port", | |
1969 client_name(req), client_addr(req, buf)); | |
1970 return (0); | |
1971 } | |
1972 } | |
1973 | |
1974 /* | |
1975 * return 1 on success or 0 on failure | |
1976 */ | |
1977 stat = sec_svc_getcred(req, cr, &principal, &nfsflavor); | |
1978 | |
1979 /* | |
1980 * A failed AUTH_UNIX svc_get_cred() implies we couldn't set | |
1981 * the credentials; below we map that to anonymous. | |
1982 */ | |
1983 if (!stat && nfsflavor != AUTH_UNIX) { | |
1984 cmn_err(CE_NOTE, | |
1985 "nfs_server: couldn't get unix cred for %s", | |
1986 client_name(req)); | |
1987 return (0); | |
1988 } | |
1989 | |
1990 /* | |
1991 * Short circuit checkauth() on operations that support the | |
1992 * public filehandle, and if the request for that operation | |
1993 * is using the public filehandle. Note that we must call | |
1994 * sec_svc_getcred() first so that xp_cookie is set to the | |
1995 * right value. Normally xp_cookie is just the RPC flavor | |
1996 * of the the request, but in the case of RPCSEC_GSS it | |
1997 * could be a pseudo flavor. | |
1998 */ | |
1999 if (publicfh_ok) | |
2000 return (1); | |
2001 | |
2002 rpcflavor = req->rq_cred.oa_flavor; | |
2003 /* | |
2004 * Check if the auth flavor is valid for this export | |
2005 */ | |
2006 access = nfsauth_access(exi, req); | |
2007 if (access & NFSAUTH_DROP) | |
2008 return (-1); /* drop the request */ | |
2009 | |
2010 if (access & NFSAUTH_DENIED) { | |
2011 /* | |
2012 * If anon_ok == 1 and we got NFSAUTH_DENIED, it was | |
2013 * probably due to the flavor not matching during the | |
2014 * the mount attempt. So map the flavor to AUTH_NONE | |
2015 * so that the credentials get mapped to the anonymous | |
2016 * user. | |
2017 */ | |
2018 if (anon_ok == 1) | |
2019 rpcflavor = AUTH_NONE; | |
2020 else | |
2021 return (0); /* deny access */ | |
2022 | |
2023 } else if (access & NFSAUTH_MAPNONE) { | |
2024 /* | |
2025 * Access was granted even though the flavor mismatched | |
2026 * because AUTH_NONE was one of the exported flavors. | |
2027 */ | |
2028 rpcflavor = AUTH_NONE; | |
2029 | |
2030 } else if (access & NFSAUTH_WRONGSEC) { | |
2031 /* | |
2032 * NFSAUTH_WRONGSEC is used for NFSv4. Since V2/V3 already | |
2033 * negotiates the security flavor thru MOUNT protocol, the | |
2034 * only way it can get NFSAUTH_WRONGSEC here is from | |
2035 * NFS_ACL for V4. This could be for a limited view, so | |
2036 * map it to RO access. V4 lookup/readdir will take care | |
2037 * of the limited view portion. | |
2038 */ | |
2039 access |= NFSAUTH_RO; | |
2040 access &= ~NFSAUTH_WRONGSEC; | |
2041 } | |
2042 | |
2043 switch (rpcflavor) { | |
2044 case AUTH_NONE: | |
2045 anon_res = crsetugid(cr, exi->exi_export.ex_anon, | |
2046 exi->exi_export.ex_anon); | |
2047 (void) crsetgroups(cr, 0, NULL); | |
2048 break; | |
2049 | |
2050 case AUTH_UNIX: | |
2051 if (!stat || crgetuid(cr) == 0 && !(access & NFSAUTH_ROOT)) { | |
2052 anon_res = crsetugid(cr, exi->exi_export.ex_anon, | |
2053 exi->exi_export.ex_anon); | |
2054 (void) crsetgroups(cr, 0, NULL); | |
2055 } | |
2056 break; | |
2057 | |
2058 case AUTH_DES: | |
2059 case RPCSEC_GSS: | |
2060 /* | |
2061 * Find the secinfo structure. We should be able | |
2062 * to find it by the time we reach here. | |
2063 * nfsauth_access() has done the checking. | |
2064 */ | |
2065 secp = NULL; | |
2066 for (i = 0; i < exi->exi_export.ex_seccnt; i++) { | |
2067 if (exi->exi_export.ex_secinfo[i].s_secinfo.sc_nfsnum == | |
2068 nfsflavor) { | |
2069 secp = &exi->exi_export.ex_secinfo[i]; | |
2070 break; | |
2071 } | |
2072 } | |
2073 | |
2074 if (!secp) { | |
2075 cmn_err(CE_NOTE, "nfs_server: client %s%shad " | |
2076 "no secinfo data for flavor %d", | |
2077 client_name(req), client_addr(req, buf), | |
2078 nfsflavor); | |
2079 return (0); | |
2080 } | |
2081 | |
2082 if (!checkwin(rpcflavor, secp->s_window, req)) { | |
2083 cmn_err(CE_NOTE, | |
2084 "nfs_server: client %s%sused invalid " | |
2085 "auth window value", | |
2086 client_name(req), client_addr(req, buf)); | |
2087 return (0); | |
2088 } | |
2089 | |
2090 /* | |
2091 * Map root principals listed in the share's root= list to root, | |
2092 * and map any others principals that were mapped to root by RPC | |
2093 * to anon. | |
2094 */ | |
2095 if (principal && sec_svc_inrootlist(rpcflavor, principal, | |
2096 secp->s_rootcnt, secp->s_rootnames)) { | |
2097 if (crgetuid(cr) == 0) | |
2098 return (1); | |
2099 | |
2100 (void) crsetugid(cr, 0, 0); | |
2101 | |
2102 /* | |
2103 * NOTE: If and when kernel-land privilege tracing is | |
2104 * added this may have to be replaced with code that | |
2105 * retrieves root's supplementary groups (e.g., using | |
2106 * kgss_get_group_info(). In the meantime principals | |
2107 * mapped to uid 0 get all privileges, so setting cr's | |
2108 * supplementary groups for them does nothing. | |
2109 */ | |
2110 (void) crsetgroups(cr, 0, NULL); | |
2111 | |
2112 return (1); | |
2113 } | |
2114 | |
2115 /* | |
2116 * Not a root princ, or not in root list, map UID 0/nobody to | |
2117 * the anon ID for the share. (RPC sets cr's UIDs and GIDs to | |
2118 * UID_NOBODY and GID_NOBODY, respectively.) | |
2119 */ | |
2120 if (crgetuid(cr) != 0 && | |
2121 (crgetuid(cr) != UID_NOBODY || crgetgid(cr) != GID_NOBODY)) | |
2122 return (1); | |
2123 | |
2124 anon_res = crsetugid(cr, exi->exi_export.ex_anon, | |
2125 exi->exi_export.ex_anon); | |
2126 (void) crsetgroups(cr, 0, NULL); | |
2127 break; | |
2128 default: | |
2129 return (0); | |
2130 } /* switch on rpcflavor */ | |
2131 | |
2132 /* | |
2133 * Even if anon access is disallowed via ex_anon == -1, we allow | |
2134 * this access if anon_ok is set. So set creds to the default | |
2135 * "nobody" id. | |
2136 */ | |
2137 if (anon_res != 0) { | |
2138 if (anon_ok == 0) { | |
2139 cmn_err(CE_NOTE, | |
2140 "nfs_server: client %s%ssent wrong " | |
2141 "authentication for %s", | |
2142 client_name(req), client_addr(req, buf), | |
2143 exi->exi_export.ex_path ? | |
2144 exi->exi_export.ex_path : "?"); | |
2145 return (0); | |
2146 } | |
2147 | |
2148 if (crsetugid(cr, UID_NOBODY, GID_NOBODY) != 0) | |
2149 return (0); | |
2150 } | |
2151 | |
2152 return (1); | |
2153 } | |
2154 | |
2155 /* | |
2156 * returns 0 on failure, -1 on a drop, -2 on wrong security flavor, | |
2157 * and 1 on success | |
2158 */ | |
2159 int | |
2160 checkauth4(struct compound_state *cs, struct svc_req *req) | |
2161 { | |
2162 int i, rpcflavor, access; | |
2163 struct secinfo *secp; | |
2164 char buf[MAXHOST + 1]; | |
2165 int anon_res = 0, nfsflavor; | |
2166 struct exportinfo *exi; | |
2167 cred_t *cr; | |
2168 caddr_t principal; | |
2169 | |
2170 exi = cs->exi; | |
2171 cr = cs->cr; | |
2172 principal = cs->principal; | |
2173 nfsflavor = cs->nfsflavor; | |
2174 | |
2175 ASSERT(cr != NULL); | |
2176 | |
2177 rpcflavor = req->rq_cred.oa_flavor; | |
2178 cs->access &= ~CS_ACCESS_LIMITED; | |
2179 | |
2180 /* | |
2181 * Check the access right per auth flavor on the vnode of | |
2182 * this export for the given request. | |
2183 */ | |
2184 access = nfsauth4_access(cs->exi, cs->vp, req); | |
2185 | |
2186 if (access & NFSAUTH_WRONGSEC) | |
2187 return (-2); /* no access for this security flavor */ | |
2188 | |
2189 if (access & NFSAUTH_DROP) | |
2190 return (-1); /* drop the request */ | |
2191 | |
2192 if (access & NFSAUTH_DENIED) { | |
2193 | |
2194 if (exi->exi_export.ex_seccnt > 0) | |
2195 return (0); /* deny access */ | |
2196 | |
2197 } else if (access & NFSAUTH_LIMITED) { | |
2198 | |
2199 cs->access |= CS_ACCESS_LIMITED; | |
2200 | |
2201 } else if (access & NFSAUTH_MAPNONE) { | |
2202 /* | |
2203 * Access was granted even though the flavor mismatched | |
2204 * because AUTH_NONE was one of the exported flavors. | |
2205 */ | |
2206 rpcflavor = AUTH_NONE; | |
2207 } | |
2208 | |
2209 /* | |
2210 * XXX probably need to redo some of it for nfsv4? | |
2211 * return 1 on success or 0 on failure | |
2212 */ | |
2213 | |
2214 switch (rpcflavor) { | |
2215 case AUTH_NONE: | |
2216 anon_res = crsetugid(cr, exi->exi_export.ex_anon, | |
2217 exi->exi_export.ex_anon); | |
2218 (void) crsetgroups(cr, 0, NULL); | |
2219 break; | |
2220 | |
2221 case AUTH_UNIX: | |
2222 if (crgetuid(cr) == 0 && !(access & NFSAUTH_ROOT)) { | |
2223 anon_res = crsetugid(cr, exi->exi_export.ex_anon, | |
2224 exi->exi_export.ex_anon); | |
2225 (void) crsetgroups(cr, 0, NULL); | |
2226 } | |
2227 break; | |
2228 | |
2229 default: | |
2230 /* | |
2231 * Find the secinfo structure. We should be able | |
2232 * to find it by the time we reach here. | |
2233 * nfsauth_access() has done the checking. | |
2234 */ | |
2235 secp = NULL; | |
2236 for (i = 0; i < exi->exi_export.ex_seccnt; i++) { | |
2237 if (exi->exi_export.ex_secinfo[i].s_secinfo.sc_nfsnum == | |
2238 nfsflavor) { | |
2239 secp = &exi->exi_export.ex_secinfo[i]; | |
2240 break; | |
2241 } | |
2242 } | |
2243 | |
2244 if (!secp) { | |
2245 cmn_err(CE_NOTE, "nfs_server: client %s%shad " | |
2246 "no secinfo data for flavor %d", | |
2247 client_name(req), client_addr(req, buf), | |
2248 nfsflavor); | |
2249 return (0); | |
2250 } | |
2251 | |
2252 if (!checkwin(rpcflavor, secp->s_window, req)) { | |
2253 cmn_err(CE_NOTE, | |
2254 "nfs_server: client %s%sused invalid " | |
2255 "auth window value", | |
2256 client_name(req), client_addr(req, buf)); | |
2257 return (0); | |
2258 } | |
2259 | |
2260 /* | |
2261 * Map root principals listed in the share's root= list to root, | |
2262 * and map any others principals that were mapped to root by RPC | |
2263 * to anon. | |
2264 */ | |
2265 if (principal && sec_svc_inrootlist(rpcflavor, principal, | |
2266 secp->s_rootcnt, secp->s_rootnames)) { | |
2267 if (crgetuid(cr) == 0) | |
2268 return (1); | |
2269 | |
2270 (void) crsetugid(cr, 0, 0); | |
2271 | |
2272 /* | |
2273 * NOTE: If and when kernel-land privilege tracing is | |
2274 * added this may have to be replaced with code that | |
2275 * retrieves root's supplementary groups (e.g., using | |
2276 * kgss_get_group_info(). In the meantime principals | |
2277 * mapped to uid 0 get all privileges, so setting cr's | |
2278 * supplementary groups for them does nothing. | |
2279 */ | |
2280 (void) crsetgroups(cr, 0, NULL); | |
2281 | |
2282 return (1); | |
2283 } | |
2284 | |
2285 /* | |
2286 * Not a root princ, or not in root list, map UID 0/nobody to | |
2287 * the anon ID for the share. (RPC sets cr's UIDs and GIDs to | |
2288 * UID_NOBODY and GID_NOBODY, respectively.) | |
2289 */ | |
2290 if (crgetuid(cr) != 0 && | |
2291 (crgetuid(cr) != UID_NOBODY || crgetgid(cr) != GID_NOBODY)) | |
2292 return (1); | |
2293 | |
2294 anon_res = crsetugid(cr, exi->exi_export.ex_anon, | |
2295 exi->exi_export.ex_anon); | |
2296 (void) crsetgroups(cr, 0, NULL); | |
2297 break; | |
2298 } /* switch on rpcflavor */ | |
2299 | |
2300 /* | |
2301 * Even if anon access is disallowed via ex_anon == -1, we allow | |
2302 * this access if anon_ok is set. So set creds to the default | |
2303 * "nobody" id. | |
2304 */ | |
2305 | |
2306 if (anon_res != 0) { | |
2307 cmn_err(CE_NOTE, | |
2308 "nfs_server: client %s%ssent wrong " | |
2309 "authentication for %s", | |
2310 client_name(req), client_addr(req, buf), | |
2311 exi->exi_export.ex_path ? | |
2312 exi->exi_export.ex_path : "?"); | |
2313 return (0); | |
2314 } | |
2315 | |
2316 return (1); | |
2317 } | |
2318 | |
2319 | |
2320 static char * | |
2321 client_name(struct svc_req *req) | |
2322 { | |
2323 char *hostname = NULL; | |
2324 | |
2325 /* | |
2326 * If it's a Unix cred then use the | |
2327 * hostname from the credential. | |
2328 */ | |
2329 if (req->rq_cred.oa_flavor == AUTH_UNIX) { | |
2330 hostname = ((struct authunix_parms *) | |
2331 req->rq_clntcred)->aup_machname; | |
2332 } | |
2333 if (hostname == NULL) | |
2334 hostname = ""; | |
2335 | |
2336 return (hostname); | |
2337 } | |
2338 | |
2339 static char * | |
2340 client_addr(struct svc_req *req, char *buf) | |
2341 { | |
2342 struct sockaddr *ca; | |
2343 uchar_t *b; | |
2344 char *frontspace = ""; | |
2345 | |
2346 /* | |
2347 * We assume we are called in tandem with client_name and the | |
2348 * format string looks like "...client %s%sblah blah..." | |
2349 * | |
2350 * If it's a Unix cred then client_name returned | |
2351 * a host name, so we need insert a space between host name | |
2352 * and IP address. | |
2353 */ | |
2354 if (req->rq_cred.oa_flavor == AUTH_UNIX) | |
2355 frontspace = " "; | |
2356 | |
2357 /* | |
2358 * Convert the caller's IP address to a dotted string | |
2359 */ | |
2360 ca = (struct sockaddr *)svc_getrpccaller(req->rq_xprt)->buf; | |
2361 | |
2362 if (ca->sa_family == AF_INET) { | |
2363 b = (uchar_t *)&((struct sockaddr_in *)ca)->sin_addr; | |
2364 (void) sprintf(buf, "%s(%d.%d.%d.%d) ", frontspace, | |
2365 b[0] & 0xFF, b[1] & 0xFF, b[2] & 0xFF, b[3] & 0xFF); | |
2366 } else if (ca->sa_family == AF_INET6) { | |
2367 struct sockaddr_in6 *sin6; | |
2368 sin6 = (struct sockaddr_in6 *)ca; | |
2369 (void) kinet_ntop6((uchar_t *)&sin6->sin6_addr, | |
2370 buf, INET6_ADDRSTRLEN); | |
2371 | |
2372 } else { | |
2373 | |
2374 /* | |
2375 * No IP address to print. If there was a host name | |
2376 * printed, then we print a space. | |
2377 */ | |
2378 (void) sprintf(buf, frontspace); | |
2379 } | |
2380 | |
2381 return (buf); | |
2382 } | |
2383 | |
2384 /* | |
2385 * NFS Server initialization routine. This routine should only be called | |
2386 * once. It performs the following tasks: | |
2387 * - Call sub-initialization routines (localize access to variables) | |
2388 * - Initialize all locks | |
2389 * - initialize the version 3 write verifier | |
2390 */ | |
2391 int | |
2392 nfs_srvinit(void) | |
2393 { | |
2394 int error; | |
2395 | |
2396 error = nfs_exportinit(); | |
2397 if (error != 0) | |
2398 return (error); | |
2399 error = rfs4_srvrinit(); | |
2400 if (error != 0) { | |
2401 nfs_exportfini(); | |
2402 return (error); | |
2403 } | |
2404 rfs_srvrinit(); | |
2405 rfs3_srvrinit(); | |
2406 nfsauth_init(); | |
2407 | |
2408 /* Init the stuff to control start/stop */ | |
2409 nfs_server_upordown = NFS_SERVER_STOPPED; | |
2410 mutex_init(&nfs_server_upordown_lock, NULL, MUTEX_DEFAULT, NULL); | |
2411 cv_init(&nfs_server_upordown_cv, NULL, CV_DEFAULT, NULL); | |
2412 mutex_init(&rdma_wait_mutex, NULL, MUTEX_DEFAULT, NULL); | |
2413 cv_init(&rdma_wait_cv, NULL, CV_DEFAULT, NULL); | |
2414 | |
2415 return (0); | |
2416 } | |
2417 | |
2418 /* | |
2419 * NFS Server finalization routine. This routine is called to cleanup the | |
2420 * initialization work previously performed if the NFS server module could | |
2421 * not be loaded correctly. | |
2422 */ | |
2423 void | |
2424 nfs_srvfini(void) | |
2425 { | |
2426 nfsauth_fini(); | |
2427 rfs3_srvrfini(); | |
2428 rfs_srvrfini(); | |
2429 nfs_exportfini(); | |
2430 | |
2431 mutex_destroy(&nfs_server_upordown_lock); | |
2432 cv_destroy(&nfs_server_upordown_cv); | |
2433 mutex_destroy(&rdma_wait_mutex); | |
2434 cv_destroy(&rdma_wait_cv); | |
2435 } | |
2436 | |
2437 /* | |
2438 * Set up an iovec array of up to cnt pointers. | |
2439 */ | |
2440 | |
2441 void | |
2442 mblk_to_iov(mblk_t *m, int cnt, struct iovec *iovp) | |
2443 { | |
2444 while (m != NULL && cnt-- > 0) { | |
2445 iovp->iov_base = (caddr_t)m->b_rptr; | |
2446 iovp->iov_len = (m->b_wptr - m->b_rptr); | |
2447 iovp++; | |
2448 m = m->b_cont; | |
2449 } | |
2450 } | |
2451 | |
2452 /* | |
2453 * Common code between NFS Version 2 and NFS Version 3 for the public | |
2454 * filehandle multicomponent lookups. | |
2455 */ | |
2456 | |
2457 /* | |
2458 * Public filehandle evaluation of a multi-component lookup, following | |
2459 * symbolic links, if necessary. This may result in a vnode in another | |
2460 * filesystem, which is OK as long as the other filesystem is exported. | |
2461 * | |
2462 * Note that the exi will be set either to NULL or a new reference to the | |
2463 * exportinfo struct that corresponds to the vnode of the multi-component path. | |
2464 * It is the callers responsibility to release this reference. | |
2465 */ | |
2466 int | |
2467 rfs_publicfh_mclookup(char *p, vnode_t *dvp, cred_t *cr, vnode_t **vpp, | |
2468 struct exportinfo **exi, struct sec_ol *sec) | |
2469 { | |
2470 int pathflag; | |
2471 vnode_t *mc_dvp = NULL; | |
2472 vnode_t *realvp; | |
2473 int error; | |
2474 | |
2475 *exi = NULL; | |
2476 | |
2477 /* | |
2478 * check if the given path is a url or native path. Since p is | |
2479 * modified by MCLpath(), it may be empty after returning from | |
2480 * there, and should be checked. | |
2481 */ | |
2482 if ((pathflag = MCLpath(&p)) == -1) | |
2483 return (EIO); | |
2484 | |
2485 /* | |
2486 * If pathflag is SECURITY_QUERY, turn the SEC_QUERY bit | |
2487 * on in sec->sec_flags. This bit will later serve as an | |
2488 * indication in makefh_ol() or makefh3_ol() to overload the | |
2489 * filehandle to contain the sec modes used by the server for | |
2490 * the path. | |
2491 */ | |
2492 if (pathflag == SECURITY_QUERY) { | |
2493 if ((sec->sec_index = (uint_t)(*p)) > 0) { | |
2494 sec->sec_flags |= SEC_QUERY; | |
2495 p++; | |
2496 if ((pathflag = MCLpath(&p)) == -1) | |
2497 return (EIO); | |
2498 } else { | |
2499 cmn_err(CE_NOTE, | |
2500 "nfs_server: invalid security index %d, " | |
2501 "violating WebNFS SNEGO protocol.", sec->sec_index); | |
2502 return (EIO); | |
2503 } | |
2504 } | |
2505 | |
2506 if (p[0] == '\0') { | |
2507 error = ENOENT; | |
2508 goto publicfh_done; | |
2509 } | |
2510 | |
2511 error = rfs_pathname(p, &mc_dvp, vpp, dvp, cr, pathflag); | |
2512 | |
2513 /* | |
2514 * If name resolves to "/" we get EINVAL since we asked for | |
2515 * the vnode of the directory that the file is in. Try again | |
2516 * with NULL directory vnode. | |
2517 */ | |
2518 if (error == EINVAL) { | |
2519 error = rfs_pathname(p, NULL, vpp, dvp, cr, pathflag); | |
2520 if (!error) { | |
2521 ASSERT(*vpp != NULL); | |
2522 if ((*vpp)->v_type == VDIR) { | |
2523 VN_HOLD(*vpp); | |
2524 mc_dvp = *vpp; | |
2525 } else { | |
2526 /* | |
2527 * This should not happen, the filesystem is | |
2528 * in an inconsistent state. Fail the lookup | |
2529 * at this point. | |
2530 */ | |
2531 VN_RELE(*vpp); | |
2532 error = EINVAL; | |
2533 } | |
2534 } | |
2535 } | |
2536 | |
2537 if (error) | |
2538 goto publicfh_done; | |
2539 | |
2540 if (*vpp == NULL) { | |
2541 error = ENOENT; | |
2542 goto publicfh_done; | |
2543 } | |
2544 | |
2545 ASSERT(mc_dvp != NULL); | |
2546 ASSERT(*vpp != NULL); | |
2547 | |
2548 if ((*vpp)->v_type == VDIR) { | |
2549 do { | |
2550 /* | |
2551 * *vpp may be an AutoFS node, so we perform | |
2552 * a VOP_ACCESS() to trigger the mount of the intended | |
2553 * filesystem, so we can perform the lookup in the | |
2554 * intended filesystem. | |
2555 */ | |
2556 (void) VOP_ACCESS(*vpp, 0, 0, cr); | |
2557 | |
2558 /* | |
2559 * If vnode is covered, get the | |
2560 * the topmost vnode. | |
2561 */ | |
2562 if (vn_mountedvfs(*vpp) != NULL) { | |
2563 error = traverse(vpp); | |
2564 if (error) { | |
2565 VN_RELE(*vpp); | |
2566 goto publicfh_done; | |
2567 } | |
2568 } | |
2569 | |
2570 if (VOP_REALVP(*vpp, &realvp) == 0 && realvp != *vpp) { | |
2571 /* | |
2572 * If realvp is different from *vpp | |
2573 * then release our reference on *vpp, so that | |
2574 * the export access check be performed on the | |
2575 * real filesystem instead. | |
2576 */ | |
2577 VN_HOLD(realvp); | |
2578 VN_RELE(*vpp); | |
2579 *vpp = realvp; | |
2580 } else | |
2581 break; | |
2582 /* LINTED */ | |
2583 } while (TRUE); | |
2584 | |
2585 /* | |
2586 * Let nfs_vptexi() figure what the real parent is. | |
2587 */ | |
2588 VN_RELE(mc_dvp); | |
2589 mc_dvp = NULL; | |
2590 | |
2591 } else { | |
2592 /* | |
2593 * If vnode is covered, get the | |
2594 * the topmost vnode. | |
2595 */ | |
2596 if (vn_mountedvfs(mc_dvp) != NULL) { | |
2597 error = traverse(&mc_dvp); | |
2598 if (error) { | |
2599 VN_RELE(*vpp); | |
2600 goto publicfh_done; | |
2601 } | |
2602 } | |
2603 | |
2604 if (VOP_REALVP(mc_dvp, &realvp) == 0 && realvp != mc_dvp) { | |
2605 /* | |
2606 * *vpp is a file, obtain realvp of the parent | |
2607 * directory vnode. | |
2608 */ | |
2609 VN_HOLD(realvp); | |
2610 VN_RELE(mc_dvp); | |
2611 mc_dvp = realvp; | |
2612 } | |
2613 } | |
2614 | |
2615 /* | |
2616 * The pathname may take us from the public filesystem to another. | |
2617 * If that's the case then just set the exportinfo to the new export | |
2618 * and build filehandle for it. Thanks to per-access checking there's | |
2619 * no security issues with doing this. If the client is not allowed | |
2620 * access to this new export then it will get an access error when it | |
2621 * tries to use the filehandle | |
2622 */ | |
2623 if (error = nfs_check_vpexi(mc_dvp, *vpp, kcred, exi)) { | |
2624 VN_RELE(*vpp); | |
2625 goto publicfh_done; | |
2626 } | |
2627 | |
2628 /* | |
2629 * Not allowed access to pseudo exports. | |
2630 */ | |
2631 if (PSEUDO(*exi)) { | |
2632 error = ENOENT; | |
2633 VN_RELE(*vpp); | |
2634 goto publicfh_done; | |
2635 } | |
2636 | |
2637 /* | |
2638 * Do a lookup for the index file. We know the index option doesn't | |
2639 * allow paths through handling in the share command, so mc_dvp will | |
2640 * be the parent for the index file vnode, if its present. Use | |
2641 * temporary pointers to preserve and reuse the vnode pointers of the | |
2642 * original directory in case there's no index file. Note that the | |
2643 * index file is a native path, and should not be interpreted by | |
2644 * the URL parser in rfs_pathname() | |
2645 */ | |
2646 if (((*exi)->exi_export.ex_flags & EX_INDEX) && | |
2647 ((*vpp)->v_type == VDIR) && (pathflag == URLPATH)) { | |
2648 vnode_t *tvp, *tmc_dvp; /* temporary vnode pointers */ | |
2649 | |
2650 tmc_dvp = mc_dvp; | |
2651 mc_dvp = tvp = *vpp; | |
2652 | |
2653 error = rfs_pathname((*exi)->exi_export.ex_index, NULL, vpp, | |
2654 mc_dvp, cr, NATIVEPATH); | |
2655 | |
2656 if (error == ENOENT) { | |
2657 *vpp = tvp; | |
2658 mc_dvp = tmc_dvp; | |
2659 error = 0; | |
2660 } else { /* ok or error other than ENOENT */ | |
2661 if (tmc_dvp) | |
2662 VN_RELE(tmc_dvp); | |
2663 if (error) | |
2664 goto publicfh_done; | |
2665 | |
2666 /* | |
2667 * Found a valid vp for index "filename". Sanity check | |
2668 * for odd case where a directory is provided as index | |
2669 * option argument and leads us to another filesystem | |
2670 */ | |
2671 | |
2672 /* Release the reference on the old exi value */ | |
2673 ASSERT(*exi != NULL); | |
2674 exi_rele(*exi); | |
2675 | |
2676 if (error = nfs_check_vpexi(mc_dvp, *vpp, kcred, exi)) { | |
2677 VN_RELE(*vpp); | |
2678 goto publicfh_done; | |
2679 } | |
2680 } | |
2681 } | |
2682 | |
2683 publicfh_done: | |
2684 if (mc_dvp) | |
2685 VN_RELE(mc_dvp); | |
2686 | |
2687 return (error); | |
2688 } | |
2689 | |
2690 /* | |
2691 * Evaluate a multi-component path | |
2692 */ | |
2693 int | |
2694 rfs_pathname( | |
2695 char *path, /* pathname to evaluate */ | |
2696 vnode_t **dirvpp, /* ret for ptr to parent dir vnode */ | |
2697 vnode_t **compvpp, /* ret for ptr to component vnode */ | |
2698 vnode_t *startdvp, /* starting vnode */ | |
2699 cred_t *cr, /* user's credential */ | |
2700 int pathflag) /* flag to identify path, e.g. URL */ | |
2701 { | |
2702 char namebuf[TYPICALMAXPATHLEN]; | |
2703 struct pathname pn; | |
2704 int error; | |
2705 | |
2706 /* | |
2707 * If pathname starts with '/', then set startdvp to root. | |
2708 */ | |
2709 if (*path == '/') { | |
2710 while (*path == '/') | |
2711 path++; | |
2712 | |
2713 startdvp = rootdir; | |
2714 } | |
2715 | |
2716 error = pn_get_buf(path, UIO_SYSSPACE, &pn, namebuf, sizeof (namebuf)); | |
2717 if (error == 0) { | |
2718 /* | |
2719 * Call the URL parser for URL paths to modify the original | |
2720 * string to handle any '%' encoded characters that exist. | |
2721 * Done here to avoid an extra bcopy in the lookup. | |
2722 * We need to be careful about pathlen's. We know that | |
2723 * rfs_pathname() is called with a non-empty path. However, | |
2724 * it could be emptied due to the path simply being all /'s, | |
2725 * which is valid to proceed with the lookup, or due to the | |
2726 * URL parser finding an encoded null character at the | |
2727 * beginning of path which should not proceed with the lookup. | |
2728 */ | |
2729 if (pn.pn_pathlen != 0 && pathflag == URLPATH) { | |
2730 URLparse(pn.pn_path); | |
2731 if ((pn.pn_pathlen = strlen(pn.pn_path)) == 0) | |
2732 return (ENOENT); | |
2733 } | |
2734 VN_HOLD(startdvp); | |
2735 error = lookuppnvp(&pn, NULL, NO_FOLLOW, dirvpp, compvpp, | |
2736 rootdir, startdvp, cr); | |
2737 } | |
2738 if (error == ENAMETOOLONG) { | |
2739 /* | |
2740 * This thread used a pathname > TYPICALMAXPATHLEN bytes long. | |
2741 */ | |
2742 if (error = pn_get(path, UIO_SYSSPACE, &pn)) | |
2743 return (error); | |
2744 if (pn.pn_pathlen != 0 && pathflag == URLPATH) { | |
2745 URLparse(pn.pn_path); | |
2746 if ((pn.pn_pathlen = strlen(pn.pn_path)) == 0) { | |
2747 pn_free(&pn); | |
2748 return (ENOENT); | |
2749 } | |
2750 } | |
2751 VN_HOLD(startdvp); | |
2752 error = lookuppnvp(&pn, NULL, NO_FOLLOW, dirvpp, compvpp, | |
2753 rootdir, startdvp, cr); | |
2754 pn_free(&pn); | |
2755 } | |
2756 | |
2757 return (error); | |
2758 } | |
2759 | |
2760 /* | |
2761 * Adapt the multicomponent lookup path depending on the pathtype | |
2762 */ | |
2763 static int | |
2764 MCLpath(char **path) | |
2765 { | |
2766 unsigned char c = (unsigned char)**path; | |
2767 | |
2768 /* | |
2769 * If the MCL path is between 0x20 and 0x7E (graphic printable | |
2770 * character of the US-ASCII coded character set), its a URL path, | |
2771 * per RFC 1738. | |
2772 */ | |
2773 if (c >= 0x20 && c <= 0x7E) | |
2774 return (URLPATH); | |
2775 | |
2776 /* | |
2777 * If the first octet of the MCL path is not an ASCII character | |
2778 * then it must be interpreted as a tag value that describes the | |
2779 * format of the remaining octets of the MCL path. | |
2780 * | |
2781 * If the first octet of the MCL path is 0x81 it is a query | |
2782 * for the security info. | |
2783 */ | |
2784 switch (c) { | |
2785 case 0x80: /* native path, i.e. MCL via mount protocol */ | |
2786 (*path)++; | |
2787 return (NATIVEPATH); | |
2788 case 0x81: /* security query */ | |
2789 (*path)++; | |
2790 return (SECURITY_QUERY); | |
2791 default: | |
2792 return (-1); | |
2793 } | |
2794 } | |
2795 | |
2796 #define fromhex(c) ((c >= '0' && c <= '9') ? (c - '0') : \ | |
2797 ((c >= 'A' && c <= 'F') ? (c - 'A' + 10) :\ | |
2798 ((c >= 'a' && c <= 'f') ? (c - 'a' + 10) : 0))) | |
2799 | |
2800 /* | |
2801 * The implementation of URLparse gaurantees that the final string will | |
2802 * fit in the original one. Replaces '%' occurrences followed by 2 characters | |
2803 * with its corresponding hexadecimal character. | |
2804 */ | |
2805 static void | |
2806 URLparse(char *str) | |
2807 { | |
2808 char *p, *q; | |
2809 | |
2810 p = q = str; | |
2811 while (*p) { | |
2812 *q = *p; | |
2813 if (*p++ == '%') { | |
2814 if (*p) { | |
2815 *q = fromhex(*p) * 16; | |
2816 p++; | |
2817 if (*p) { | |
2818 *q += fromhex(*p); | |
2819 p++; | |
2820 } | |
2821 } | |
2822 } | |
2823 q++; | |
2824 } | |
2825 *q = '\0'; | |
2826 } | |
2827 | |
2828 | |
2829 /* | |
2830 * Get the export information for the lookup vnode, and verify its | |
2831 * useable. | |
2832 */ | |
2833 int | |
2834 nfs_check_vpexi(vnode_t *mc_dvp, vnode_t *vp, cred_t *cr, | |
2835 struct exportinfo **exi) | |
2836 { | |
2837 int walk; | |
2838 int error = 0; | |
2839 | |
2840 *exi = nfs_vptoexi(mc_dvp, vp, cr, &walk, NULL, FALSE); | |
2841 if (*exi == NULL) | |
2842 error = EACCES; | |
2843 else { | |
2844 /* | |
2845 * If nosub is set for this export then | |
2846 * a lookup relative to the public fh | |
2847 * must not terminate below the | |
2848 * exported directory. | |
2849 */ | |
2850 if ((*exi)->exi_export.ex_flags & EX_NOSUB && walk > 0) | |
2851 error = EACCES; | |
2852 } | |
2853 | |
2854 return (error); | |
2855 } | |
2035
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2856 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2857 /* |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2858 * Do the main work of handling HA-NFSv4 Resource Group failover on |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2859 * Sun Cluster. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2860 * We need to detect whether any RG admin paths have been added or removed, |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2861 * and adjust resources accordingly. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2862 * Currently we're using a very inefficient algorithm, ~ 2 * O(n**2). In |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2863 * order to scale, the list and array of paths need to be held in more |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2864 * suitable data structures. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2865 */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2866 static void |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2867 hanfsv4_failover(void) |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2868 { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2869 int i, start_grace, numadded_paths = 0; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2870 char **added_paths = NULL; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2871 rfs4_dss_path_t *dss_path; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2872 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2873 /* |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2874 * First, look for removed paths: RGs that have been failed-over |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2875 * away from this node. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2876 * Walk the "currently-serving" rfs4_dss_pathlist and, for each |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2877 * path, check if it is on the "passed-in" rfs4_dss_newpaths array |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2878 * from nfsd. If not, that RG path has been removed. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2879 * |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2880 * Note that nfsd has sorted rfs4_dss_newpaths for us, and removed |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2881 * any duplicates. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2882 */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2883 dss_path = rfs4_dss_pathlist; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2884 do { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2885 int found = 0; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2886 char *path = dss_path->path; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2887 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2888 /* used only for non-HA so may not be removed */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2889 if (strcmp(path, NFS4_DSS_VAR_DIR) == 0) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2890 dss_path = dss_path->next; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2891 continue; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2892 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2893 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2894 for (i = 0; i < rfs4_dss_numnewpaths; i++) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2895 int cmpret; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2896 size_t ncmp; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2897 char *newpath = rfs4_dss_newpaths[i]; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2898 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2899 ncmp = MAX(strlen(path), strlen(newpath)); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2900 cmpret = strncmp(path, newpath, ncmp); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2901 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2902 /* |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2903 * Since nfsd has sorted rfs4_dss_newpaths for us, |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2904 * once the return from strncmp is negative we know |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2905 * we've passed the point where "path" should be, |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2906 * and can stop searching: "path" has been removed. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2907 */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2908 if (cmpret < 0) |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2909 break; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2910 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2911 if (cmpret == 0) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2912 found = 1; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2913 break; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2914 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2915 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2916 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2917 if (found == 0) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2918 unsigned index = dss_path->index; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2919 rfs4_servinst_t *sip = dss_path->sip; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2920 rfs4_dss_path_t *path_next = dss_path->next; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2921 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2922 /* |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2923 * This path has been removed. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2924 * We must clear out the servinst reference to |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2925 * it, since it's now owned by another |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2926 * node: we should not attempt to touch it. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2927 */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2928 ASSERT(dss_path == sip->dss_paths[index]); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2929 sip->dss_paths[index] = NULL; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2930 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2931 /* remove from "currently-serving" list, and destroy */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2932 remque(dss_path); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2933 kmem_free(dss_path, sizeof (rfs4_dss_path_t)); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2934 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2935 dss_path = path_next; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2936 } else { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2937 /* path was found; not removed */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2938 dss_path = dss_path->next; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2939 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2940 } while (dss_path != rfs4_dss_pathlist); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2941 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2942 /* |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2943 * Now, look for added paths: RGs that have been failed-over |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2944 * to this node. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2945 * Walk the "passed-in" rfs4_dss_newpaths array from nfsd and, |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2946 * for each path, check if it is on the "currently-serving" |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2947 * rfs4_dss_pathlist. If not, that RG path has been added. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2948 * |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2949 * Note: we don't do duplicate detection here; nfsd does that for us. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2950 * |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2951 * Note: numadded_paths <= rfs4_dss_numnewpaths, which gives us |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2952 * an upper bound for the size needed for added_paths[numadded_paths]. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2953 */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2954 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2955 /* probably more space than we need, but guaranteed to be enough */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2956 if (rfs4_dss_numnewpaths > 0) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2957 size_t sz = rfs4_dss_numnewpaths * sizeof (char *); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2958 added_paths = kmem_zalloc(sz, KM_SLEEP); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2959 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2960 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2961 /* walk the "passed-in" rfs4_dss_newpaths array from nfsd */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2962 for (i = 0; i < rfs4_dss_numnewpaths; i++) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2963 int found = 0; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2964 char *newpath = rfs4_dss_newpaths[i]; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2965 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2966 dss_path = rfs4_dss_pathlist; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2967 do { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2968 char *path = dss_path->path; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2969 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2970 /* used only for non-HA */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2971 if (strcmp(path, NFS4_DSS_VAR_DIR) == 0) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2972 dss_path = dss_path->next; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2973 continue; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2974 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2975 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2976 if (strncmp(path, newpath, strlen(path)) == 0) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2977 found = 1; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2978 break; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2979 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2980 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2981 dss_path = dss_path->next; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2982 } while (dss_path != rfs4_dss_pathlist); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2983 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2984 if (found == 0) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2985 added_paths[numadded_paths] = newpath; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2986 numadded_paths++; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2987 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2988 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2989 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2990 /* did we find any added paths? */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2991 if (numadded_paths > 0) { |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2992 /* create a new server instance, and start its grace period */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2993 start_grace = 1; |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2994 rfs4_servinst_create(start_grace, numadded_paths, added_paths); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2995 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2996 /* read in the stable storage state from these paths */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2997 rfs4_dss_readstate(numadded_paths, added_paths); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2998 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
2999 /* |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3000 * Multiple failovers during a grace period will cause |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3001 * clients of the same resource group to be partitioned |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3002 * into different server instances, with different |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3003 * grace periods. Since clients of the same resource |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3004 * group must be subject to the same grace period, |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3005 * we need to reset all currently active grace periods. |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3006 */ |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3007 rfs4_grace_reset_all(); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3008 } |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3009 |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3010 if (rfs4_dss_numnewpaths > 0) |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3011 kmem_free(added_paths, rfs4_dss_numnewpaths * sizeof (char *)); |
a29bc457bcb9
PSARC/2006/313 NFSv4: nfsd "-s" distributed stable storage
calum
parents:
1610
diff
changeset
|
3012 } |