1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
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 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T.
26 * All rights reserved.
27 */
28
29 #include <sys/types.h>
30 #include <rpc/types.h>
31 #include <sys/systm.h>
32 #include <sys/vfs.h>
33 #include <sys/errno.h>
34 #include <sys/cred.h>
35 #include <sys/policy.h>
36 #include <sys/siginfo.h>
37 #include <sys/proc.h> /* for exit() declaration */
38 #include <sys/kmem.h>
39 #include <nfs/nfs4.h>
40 #include <nfs/nfssys.h>
41 #include <sys/thread.h>
42 #include <rpc/auth.h>
43 #include <rpc/rpcsys.h>
44 #include <rpc/svc.h>
45
46 /*
47 * This is filled in with an appropriate address for the
48 * function that will traverse the rfs4_client_t table
49 * and mark any matching IP Address as "forced_expire".
50 *
51 * It is the server init() function that plops the
52 * function pointer.
53 */
54 void (*rfs4_client_clrst)(struct nfs4clrst_args *) = NULL;
55
56 /* This filled in by nfssrv:_init() */
57 void (*nfs_srv_quiesce_func)(void) = NULL;
58
59 extern void nfscmd_args(uint_t);
60
61 /*
62 * These will be reset by klmmod:lm_svc(), when lockd starts NLM service,
63 * based on values read by lockd from /etc/default/nfs. Since nfssrv depends on
64 * klmmod, the declarations need to be here (in nfs, on which both depend) so
65 * that nfssrv can see the klmmod changes.
66 * When the dependency of NFSv4 on NLM/lockd is removed, this will need to
67 * be adjusted.
68 */
69 #define RFS4_LEASETIME 90 /* seconds */
70 time_t rfs4_lease_time = RFS4_LEASETIME;
71 time_t rfs4_grace_period = RFS4_LEASETIME;
72
73 /* DSS: distributed stable storage */
74 size_t nfs4_dss_buflen = 0;
75 /* This filled in by nfssrv:_init() */
76 int (*nfs_srv_dss_func)(char *, size_t) = NULL;
77
78 int
nfs_export(void * arg)79 nfs_export(void *arg)
80 {
81 STRUCT_DECL(exportfs_args, ea);
82
83 if (!INGLOBALZONE(curproc))
84 return (set_errno(EPERM));
85 STRUCT_INIT(ea, get_udatamodel());
86 if (copyin(arg, STRUCT_BUF(ea), STRUCT_SIZE(ea)))
87 return (set_errno(EFAULT));
88
89 return (exportfs(STRUCT_BUF(ea), get_udatamodel(), CRED()));
90 }
91
92 int
nfssys(enum nfssys_op opcode,void * arg)93 nfssys(enum nfssys_op opcode, void *arg)
94 {
95 int error = 0;
96
97 if (!(opcode == NFS_REVAUTH || opcode == NFS4_SVC) &&
98 secpolicy_nfs(CRED()) != 0)
99 return (set_errno(EPERM));
100
101 switch (opcode) {
102 case NFS4_CLR_STATE: { /* Clear NFS4 client state */
103 struct nfs4clrst_args clr;
104 STRUCT_DECL(nfs4clrst_args, u_clr);
105
106 /*
107 * If the server is not loaded then no point in
108 * clearing nothing :-)
109 */
110 if (rfs4_client_clrst == NULL) {
111 break;
112 }
113
114 if (!INGLOBALZONE(curproc))
115 return (set_errno(EPERM));
116
117 STRUCT_INIT(u_clr, get_udatamodel());
118
119 if (copyin(arg, STRUCT_BUF(u_clr), STRUCT_SIZE(u_clr)))
120 return (set_errno(EFAULT));
121
122 clr.vers = STRUCT_FGET(u_clr, vers);
123
124 if (clr.vers != NFS4_CLRST_VERSION)
125 return (set_errno(EINVAL));
126
127 clr.addr_type = STRUCT_FGET(u_clr, addr_type);
128 clr.ap = STRUCT_FGETP(u_clr, ap);
129 rfs4_client_clrst(&clr);
130 break;
131 }
132
133 case SVCPOOL_CREATE: { /* setup an RPC server thread pool */
134 struct svcpool_args p;
135
136 if (copyin(arg, &p, sizeof (p)))
137 return (set_errno(EFAULT));
138
139 error = svc_pool_create(&p);
140 break;
141 }
142
143 case SVCPOOL_WAIT: { /* wait in kernel for threads to be needed */
144 int id;
145
146 if (copyin(arg, &id, sizeof (id)))
147 return (set_errno(EFAULT));
148
149 error = svc_wait(id);
150 break;
151 }
152
153 case SVCPOOL_RUN: { /* give work to a runnable thread */
154 int id;
155
156 if (copyin(arg, &id, sizeof (id)))
157 return (set_errno(EFAULT));
158
159 error = svc_do_run(id);
160 break;
161 }
162
163 case RDMA_SVC_INIT: {
164 struct rdma_svc_args rsa;
165 char netstore[20] = "tcp";
166
167 if (!INGLOBALZONE(curproc))
168 return (set_errno(EPERM));
169 if (get_udatamodel() != DATAMODEL_NATIVE) {
170 STRUCT_DECL(rdma_svc_args, ursa);
171
172 STRUCT_INIT(ursa, get_udatamodel());
173 if (copyin(arg, STRUCT_BUF(ursa), STRUCT_SIZE(ursa)))
174 return (set_errno(EFAULT));
175
176 rsa.poolid = STRUCT_FGET(ursa, poolid);
177 rsa.nfs_versmin = STRUCT_FGET(ursa, nfs_versmin);
178 rsa.nfs_versmax = STRUCT_FGET(ursa, nfs_versmax);
179 rsa.delegation = STRUCT_FGET(ursa, delegation);
180 } else {
181 if (copyin(arg, &rsa, sizeof (rsa)))
182 return (set_errno(EFAULT));
183 }
184 rsa.netid = netstore;
185
186 error = rdma_start(&rsa);
187 break;
188 }
189
190 case NFS_SVC: { /* NFS server daemon */
191 STRUCT_DECL(nfs_svc_args, nsa);
192
193 if (!INGLOBALZONE(curproc))
194 return (set_errno(EPERM));
195 STRUCT_INIT(nsa, get_udatamodel());
196
197 if (copyin(arg, STRUCT_BUF(nsa), STRUCT_SIZE(nsa)))
198 return (set_errno(EFAULT));
199
200 error = nfs_svc(STRUCT_BUF(nsa), get_udatamodel());
201 break;
202 }
203
204 case EXPORTFS: { /* export a file system */
205 error = nfs_export(arg);
206 break;
207 }
208
209 case NFS_GETFH: { /* get a file handle */
210 STRUCT_DECL(nfs_getfh_args, nga);
211
212 if (!INGLOBALZONE(curproc))
213 return (set_errno(EPERM));
214 STRUCT_INIT(nga, get_udatamodel());
215 if (copyin(arg, STRUCT_BUF(nga), STRUCT_SIZE(nga)))
216 return (set_errno(EFAULT));
217
218 error = nfs_getfh(STRUCT_BUF(nga), get_udatamodel(), CRED());
219 break;
220 }
221
222 case NFS_REVAUTH: { /* revoke the cached credentials for the uid */
223 STRUCT_DECL(nfs_revauth_args, nra);
224
225 STRUCT_INIT(nra, get_udatamodel());
226 if (copyin(arg, STRUCT_BUF(nra), STRUCT_SIZE(nra)))
227 return (set_errno(EFAULT));
228
229 /* This call performs its own privilege checking */
230 error = sec_clnt_revoke(STRUCT_FGET(nra, authtype),
231 STRUCT_FGET(nra, uid), CRED(), NULL, get_udatamodel());
232 break;
233 }
234
235 case LM_SVC: { /* LM server daemon */
236 struct lm_svc_args lsa;
237
238 if (get_udatamodel() != DATAMODEL_NATIVE) {
239 STRUCT_DECL(lm_svc_args, ulsa);
240
241 STRUCT_INIT(ulsa, get_udatamodel());
242 if (copyin(arg, STRUCT_BUF(ulsa), STRUCT_SIZE(ulsa)))
243 return (set_errno(EFAULT));
244
245 lsa.version = STRUCT_FGET(ulsa, version);
246 lsa.fd = STRUCT_FGET(ulsa, fd);
247 lsa.n_fmly = STRUCT_FGET(ulsa, n_fmly);
248 lsa.n_proto = STRUCT_FGET(ulsa, n_proto);
249 lsa.n_rdev = expldev(STRUCT_FGET(ulsa, n_rdev));
250 lsa.debug = STRUCT_FGET(ulsa, debug);
251 lsa.timout = STRUCT_FGET(ulsa, timout);
252 lsa.grace = STRUCT_FGET(ulsa, grace);
253 lsa.retransmittimeout = STRUCT_FGET(ulsa,
254 retransmittimeout);
255 } else {
256 if (copyin(arg, &lsa, sizeof (lsa)))
257 return (set_errno(EFAULT));
258 }
259
260 error = lm_svc(&lsa);
261 break;
262 }
263
264 case KILL_LOCKMGR: {
265 error = lm_shutdown();
266 break;
267 }
268
269 case LOG_FLUSH: { /* Flush log buffer and possibly rename */
270 STRUCT_DECL(nfsl_flush_args, nfa);
271
272 STRUCT_INIT(nfa, get_udatamodel());
273 if (copyin(arg, STRUCT_BUF(nfa), STRUCT_SIZE(nfa)))
274 return (set_errno(EFAULT));
275
276 error = nfsl_flush(STRUCT_BUF(nfa), get_udatamodel());
277 break;
278 }
279
280 case NFS4_SVC: { /* NFS client callback daemon */
281
282 STRUCT_DECL(nfs4_svc_args, nsa);
283
284 STRUCT_INIT(nsa, get_udatamodel());
285
286 if (copyin(arg, STRUCT_BUF(nsa), STRUCT_SIZE(nsa)))
287 return (set_errno(EFAULT));
288
289 error = nfs4_svc(STRUCT_BUF(nsa), get_udatamodel());
290 break;
291 }
292
293 /* Request that NFSv4 server quiesce on next shutdown */
294 case NFS4_SVC_REQUEST_QUIESCE: {
295 int id;
296
297 /* check that nfssrv module is loaded */
298 if (nfs_srv_quiesce_func == NULL)
299 return (set_errno(ENOTSUP));
300
301 if (copyin(arg, &id, sizeof (id)))
302 return (set_errno(EFAULT));
303
304 error = svc_pool_control(id, SVCPSET_SHUTDOWN_PROC,
305 (void *)nfs_srv_quiesce_func);
306 break;
307 }
308
309 case NFS_IDMAP: {
310 struct nfsidmap_args idm;
311
312 if (copyin(arg, &idm, sizeof (idm)))
313 return (set_errno(EFAULT));
314
315 nfs_idmap_args(&idm);
316 error = 0;
317 break;
318 }
319
320 case NFS4_DSS_SETPATHS_SIZE: {
321 /* crosses ILP32/LP64 boundary */
322 uint32_t nfs4_dss_bufsize = 0;
323
324 if (copyin(arg, &nfs4_dss_bufsize, sizeof (nfs4_dss_bufsize)))
325 return (set_errno(EFAULT));
326 nfs4_dss_buflen = (long)nfs4_dss_bufsize;
327 error = 0;
328 break;
329 }
330
331 case NFS4_DSS_SETPATHS: {
332 char *nfs4_dss_bufp;
333
334 /* check that nfssrv module is loaded */
335 if (nfs_srv_dss_func == NULL)
336 return (set_errno(ENOTSUP));
337
338 /*
339 * NFS4_DSS_SETPATHS_SIZE must be called before
340 * NFS4_DSS_SETPATHS, to tell us how big a buffer we need
341 * to allocate.
342 */
343 if (nfs4_dss_buflen == 0)
344 return (set_errno(EINVAL));
345 nfs4_dss_bufp = kmem_alloc(nfs4_dss_buflen, KM_SLEEP);
346 if (nfs4_dss_bufp == NULL)
347 return (set_errno(ENOMEM));
348
349 if (copyin(arg, nfs4_dss_bufp, nfs4_dss_buflen)) {
350 kmem_free(nfs4_dss_bufp, nfs4_dss_buflen);
351 return (set_errno(EFAULT));
352 }
353
354 /* unpack the buffer and extract the pathnames */
355 error = nfs_srv_dss_func(nfs4_dss_bufp, nfs4_dss_buflen);
356 kmem_free(nfs4_dss_bufp, nfs4_dss_buflen);
357
358 break;
359 }
360
361 case NFS4_EPHEMERAL_MOUNT_TO: {
362 uint_t mount_to;
363
364 /*
365 * Not a very complicated call.
366 */
367 if (copyin(arg, &mount_to, sizeof (mount_to)))
368 return (set_errno(EFAULT));
369 nfs4_ephemeral_set_mount_to(mount_to);
370 error = 0;
371 break;
372 }
373
374 case MOUNTD_ARGS: {
375 uint_t did;
376
377 /*
378 * For now, only passing down the door fd; if we
379 * ever need to pass down more info, we can use
380 * a (properly aligned) struct.
381 */
382 if (copyin(arg, &did, sizeof (did)))
383 return (set_errno(EFAULT));
384 mountd_args(did);
385 error = 0;
386 break;
387 }
388
389 case NFSCMD_ARGS: {
390 uint_t did;
391
392 /*
393 * For now, only passing down the door fd; if we
394 * ever need to pass down more info, we can use
395 * a (properly aligned) struct.
396 */
397 if (copyin(arg, &did, sizeof (did)))
398 return (set_errno(EFAULT));
399 nfscmd_args(did);
400 error = 0;
401 break;
402 }
403
404 default:
405 error = EINVAL;
406 break;
407 }
408
409 return ((error != 0) ? set_errno(error) : 0);
410 }
411