78
79/*
80 * Defines for malloc
81 * (Here for FreeBSD, since they allocate storage.)
82 */
83MALLOC_DEFINE(M_NEWNFSRVCACHE, "NFSD srvcache", "NFSD Server Request Cache");
84MALLOC_DEFINE(M_NEWNFSDCLIENT, "NFSD V4client", "NFSD V4 Client Id");
85MALLOC_DEFINE(M_NEWNFSDSTATE, "NFSD V4state",
86 "NFSD V4 State (Openowner, Open, Lockowner, Delegation");
87MALLOC_DEFINE(M_NEWNFSDLOCK, "NFSD V4lock", "NFSD V4 byte range lock");
88MALLOC_DEFINE(M_NEWNFSDLOCKFILE, "NFSD lckfile", "NFSD Open/Lock file");
89MALLOC_DEFINE(M_NEWNFSSTRING, "NFSD string", "NFSD V4 long string");
90MALLOC_DEFINE(M_NEWNFSUSERGROUP, "NFSD usrgroup", "NFSD V4 User/group map");
91MALLOC_DEFINE(M_NEWNFSDREQ, "NFS req", "NFS request header");
92MALLOC_DEFINE(M_NEWNFSFH, "NFS fh", "NFS file handle");
93MALLOC_DEFINE(M_NEWNFSCLOWNER, "NFSCL owner", "NFSCL Open Owner");
94MALLOC_DEFINE(M_NEWNFSCLOPEN, "NFSCL open", "NFSCL Open");
95MALLOC_DEFINE(M_NEWNFSCLDELEG, "NFSCL deleg", "NFSCL Delegation");
96MALLOC_DEFINE(M_NEWNFSCLCLIENT, "NFSCL client", "NFSCL Client");
97MALLOC_DEFINE(M_NEWNFSCLLOCKOWNER, "NFSCL lckown", "NFSCL Lock Owner");
98MALLOC_DEFINE(M_NEWNFSCLLOCK, "NFSCL lck", "NFSCL Lock");
99MALLOC_DEFINE(M_NEWNFSV4NODE, "NEWNFSnode", "New nfs vnode");
100MALLOC_DEFINE(M_NEWNFSDIRECTIO, "NEWdirectio", "New nfs Direct IO buffer");
101MALLOC_DEFINE(M_NEWNFSDIROFF, "NFSCL diroffdiroff",
102 "New NFS directory offset data");
103MALLOC_DEFINE(M_NEWNFSDROLLBACK, "NFSD rollback",
104 "New NFS local lock rollback");
105
106/*
107 * Definition of mutex locks.
108 * newnfsd_mtx is used in nfsrvd_nfsd() to protect the nfs socket list
109 * and assorted other nfsd structures.
110 * Giant is used to protect the nfsd list and count, which is just
111 * updated when nfsd's start/stop and is grabbed for nfsrvd_dorpc()
112 * for the VFS ops.
113 */
114struct mtx newnfsd_mtx;
115struct mtx nfs_sockl_mutex;
116struct mtx nfs_state_mutex;
117struct mtx nfs_nameid_mutex;
118struct mtx nfs_req_mutex;
119struct mtx nfs_slock_mutex;
120
121/* local functions */
122static int nfssvc_call(struct thread *, struct nfssvc_args *, struct ucred *);
123
124#ifdef __NO_STRICT_ALIGNMENT
125/*
126 * These architectures don't need re-alignment, so just return.
127 */
128void
129newnfs_realign(struct mbuf **pm)
130{
131
132 return;
133}
134#else /* !__NO_STRICT_ALIGNMENT */
135/*
136 * newnfs_realign:
137 *
138 * Check for badly aligned mbuf data and realign by copying the unaligned
139 * portion of the data into a new mbuf chain and freeing the portions
140 * of the old chain that were replaced.
141 *
142 * We cannot simply realign the data within the existing mbuf chain
143 * because the underlying buffers may contain other rpc commands and
144 * we cannot afford to overwrite them.
145 *
146 * We would prefer to avoid this situation entirely. The situation does
147 * not occur with NFS/UDP and is supposed to only occassionally occur
148 * with TCP. Use vfs.nfs.realign_count and realign_test to check this.
149 *
150 */
151void
152newnfs_realign(struct mbuf **pm)
153{
154 struct mbuf *m, *n;
155 int off, space;
156
157 ++nfs_realign_test;
158 while ((m = *pm) != NULL) {
159 if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
160 /*
161 * NB: we can't depend on m_pkthdr.len to help us
162 * decide what to do here. May not be worth doing
163 * the m_length calculation as m_copyback will
164 * expand the mbuf chain below as needed.
165 */
166 space = m_length(m, NULL);
167 if (space >= MINCLSIZE) {
168 /* NB: m_copyback handles space > MCLBYTES */
169 n = m_getcl(M_WAITOK, MT_DATA, 0);
170 } else
171 n = m_get(M_WAITOK, MT_DATA);
172 if (n == NULL)
173 return;
174 /*
175 * Align the remainder of the mbuf chain.
176 */
177 n->m_len = 0;
178 off = 0;
179 while (m != NULL) {
180 m_copyback(n, off, m->m_len, mtod(m, caddr_t));
181 off += m->m_len;
182 m = m->m_next;
183 }
184 m_freem(*pm);
185 *pm = n;
186 ++nfs_realign_count;
187 break;
188 }
189 pm = &m->m_next;
190 }
191}
192#endif /* __NO_STRICT_ALIGNMENT */
193
194#ifdef notdef
195static void
196nfsrv_object_create(struct vnode *vp, struct thread *td)
197{
198
199 if (vp == NULL || vp->v_type != VREG)
200 return;
201 (void) vfs_object_create(vp, td, td->td_ucred);
202}
203#endif
204
205/*
206 * Look up a file name. Basically just initialize stuff and call namei().
207 */
208int
209nfsrv_lookupfilename(struct nameidata *ndp, char *fname, NFSPROC_T *p)
210{
211 int error;
212
213 NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF | MPSAFE, UIO_USERSPACE, fname,
214 p);
215 error = namei(ndp);
216 if (!error) {
217 NDFREE(ndp, NDF_ONLY_PNBUF);
218 }
219 return (error);
220}
221
222/*
223 * Copy NFS uid, gids to the cred structure.
224 */
225void
226newnfs_copycred(struct nfscred *nfscr, struct ucred *cr)
227{
228
229 KASSERT(nfscr->nfsc_ngroups >= 0,
230 ("newnfs_copycred: negative nfsc_ngroups"));
231 cr->cr_uid = nfscr->nfsc_uid;
232 crsetgroups(cr, nfscr->nfsc_ngroups, nfscr->nfsc_groups);
233}
234
235/*
236 * Map args from nfsmsleep() to msleep().
237 */
238int
239nfsmsleep(void *chan, void *mutex, int prio, const char *wmesg,
240 struct timespec *ts)
241{
242 u_int64_t nsecval;
243 int error, timeo;
244
245 if (ts) {
246 timeo = hz * ts->tv_sec;
247 nsecval = (u_int64_t)ts->tv_nsec;
248 nsecval = ((nsecval * ((u_int64_t)hz)) + 500000000) /
249 1000000000;
250 timeo += (int)nsecval;
251 } else {
252 timeo = 0;
253 }
254 error = msleep(chan, (struct mtx *)mutex, prio, wmesg, timeo);
255 return (error);
256}
257
258/*
259 * Get the file system info for the server. For now, just assume FFS.
260 */
261void
262nfsvno_getfs(struct nfsfsinfo *sip, int isdgram)
263{
264 int pref;
265
266 /*
267 * XXX
268 * There should be file system VFS OP(s) to get this information.
269 * For now, assume ufs.
270 */
271 if (isdgram)
272 pref = NFS_MAXDGRAMDATA;
273 else
274 pref = NFS_MAXDATA;
275 sip->fs_rtmax = NFS_MAXDATA;
276 sip->fs_rtpref = pref;
277 sip->fs_rtmult = NFS_FABLKSIZE;
278 sip->fs_wtmax = NFS_MAXDATA;
279 sip->fs_wtpref = pref;
280 sip->fs_wtmult = NFS_FABLKSIZE;
281 sip->fs_dtpref = pref;
282 sip->fs_maxfilesize = 0xffffffffffffffffull;
283 sip->fs_timedelta.tv_sec = 0;
284 sip->fs_timedelta.tv_nsec = 1;
285 sip->fs_properties = (NFSV3FSINFO_LINK |
286 NFSV3FSINFO_SYMLINK | NFSV3FSINFO_HOMOGENEOUS |
287 NFSV3FSINFO_CANSETTIME);
288}
289
290/* Fake nfsrv_atroot. Just return 0 */
291int
292nfsrv_atroot(struct vnode *vp, long *retp)
293{
294
295 return (0);
296}
297
298/*
299 * Set the credentials to refer to root.
300 * If only the various BSDen could agree on whether cr_gid is a separate
301 * field or cr_groups[0]...
302 */
303void
304newnfs_setroot(struct ucred *cred)
305{
306
307 cred->cr_uid = 0;
308 cred->cr_groups[0] = 0;
309 cred->cr_ngroups = 1;
310}
311
312/*
313 * Get the client credential. Used for Renew and recovery.
314 */
315struct ucred *
316newnfs_getcred(void)
317{
318 struct ucred *cred;
319 struct thread *td = curthread;
320
321 cred = crdup(td->td_ucred);
322 newnfs_setroot(cred);
323 return (cred);
324}
325
326/*
327 * Nfs timer routine
328 * Call the nfsd's timer function once/sec.
329 */
330void
331newnfs_timer(void *arg)
332{
333 static time_t lasttime = 0;
334 /*
335 * Call the server timer, if set up.
336 * The argument indicates if it is the next second and therefore
337 * leases should be checked.
338 */
339 if (lasttime != NFSD_MONOSEC) {
340 lasttime = NFSD_MONOSEC;
341 if (nfsd_call_servertimer != NULL)
342 (*nfsd_call_servertimer)();
343 }
344 callout_reset(&newnfsd_callout, nfscl_ticks, newnfs_timer, NULL);
345}
346
347
348/*
349 * Sleep for a short period of time unless errval == NFSERR_GRACE, where
350 * the sleep should be for 5 seconds.
351 * Since lbolt doesn't exist in FreeBSD-CURRENT, just use a timeout on
352 * an event that never gets a wakeup. Only return EINTR or 0.
353 */
354int
355nfs_catnap(int prio, int errval, const char *wmesg)
356{
357 static int non_event;
358 int ret;
359
360 if (errval == NFSERR_GRACE)
361 ret = tsleep(&non_event, prio, wmesg, 5 * hz);
362 else
363 ret = tsleep(&non_event, prio, wmesg, 1);
364 if (ret != EINTR)
365 ret = 0;
366 return (ret);
367}
368
369/*
370 * Get referral. For now, just fail.
371 */
372struct nfsreferral *
373nfsv4root_getreferral(struct vnode *vp, struct vnode *dvp, u_int32_t fileno)
374{
375
376 return (NULL);
377}
378
379static int
380nfssvc_nfscommon(struct thread *td, struct nfssvc_args *uap)
381{
382 int error;
383
384 error = nfssvc_call(td, uap, td->td_ucred);
385 return (error);
386}
387
388static int
389nfssvc_call(struct thread *p, struct nfssvc_args *uap, struct ucred *cred)
390{
391 int error = EINVAL;
392 struct nfsd_idargs nid;
393
394 if (uap->flag & NFSSVC_IDNAME) {
395 error = copyin(uap->argp, (caddr_t)&nid, sizeof (nid));
396 if (error)
397 return (error);
398 error = nfssvc_idname(&nid);
399 return (error);
400 } else if (uap->flag & NFSSVC_GETSTATS) {
401 error = copyout(&newnfsstats,
402 CAST_USER_ADDR_T(uap->argp), sizeof (newnfsstats));
403 return (error);
404 } else if (uap->flag & NFSSVC_NFSUSERDPORT) {
405 u_short sockport;
406
407 error = copyin(uap->argp, (caddr_t)&sockport,
408 sizeof (u_short));
409 if (!error)
410 error = nfsrv_nfsuserdport(sockport, p);
411 } else if (uap->flag & NFSSVC_NFSUSERDDELPORT) {
412 nfsrv_nfsuserddelport();
413 error = 0;
414 }
415 return (error);
416}
417
418/*
419 * called by all three modevent routines, so that it gets things
420 * initialized soon enough.
421 */
422void
423newnfs_portinit(void)
424{
425 static int inited = 0;
426
427 if (inited)
428 return;
429 inited = 1;
430 /* Initialize SMP locks used by both client and server. */
431 mtx_init(&newnfsd_mtx, "newnfsd_mtx", NULL, MTX_DEF);
432 mtx_init(&nfs_state_mutex, "nfs_state_mutex", NULL, MTX_DEF);
433}
434
435/*
436 * Determine if the file system supports NFSv4 ACLs.
437 * Return 1 if it does, 0 otherwise.
438 */
439int
440nfs_supportsnfsv4acls(struct vnode *vp)
441{
442 int error;
443 register_t retval;
444
445 ASSERT_VOP_LOCKED(vp, "nfs supports nfsv4acls");
446
447 if (nfsrv_useacl == 0)
448 return (0);
449 error = VOP_PATHCONF(vp, _PC_ACL_NFS4, &retval);
450 if (error == 0 && retval != 0)
451 return (1);
452 return (0);
453}
454
455extern int (*nfsd_call_nfscommon)(struct thread *, struct nfssvc_args *);
456
457/*
458 * Called once to initialize data structures...
459 */
460static int
461nfscommon_modevent(module_t mod, int type, void *data)
462{
463 int error = 0;
464 static int loaded = 0;
465
466 switch (type) {
467 case MOD_LOAD:
468 if (loaded)
469 return (0);
470 newnfs_portinit();
471 mtx_init(&nfs_nameid_mutex, "nfs_nameid_mutex", NULL, MTX_DEF);
472 mtx_init(&nfs_sockl_mutex, "nfs_sockl_mutex", NULL, MTX_DEF);
473 mtx_init(&nfs_slock_mutex, "nfs_slock_mutex", NULL, MTX_DEF);
474 mtx_init(&nfs_req_mutex, "nfs_req_mutex", NULL, MTX_DEF);
475 mtx_init(&nfsrv_nfsuserdsock.nr_mtx, "nfsuserd", NULL,
476 MTX_DEF);
477 callout_init(&newnfsd_callout, CALLOUT_MPSAFE);
478 newnfs_init();
479 nfsd_call_nfscommon = nfssvc_nfscommon;
480 loaded = 1;
481 break;
482
483 case MOD_UNLOAD:
484 if (newnfs_numnfsd != 0 || nfsrv_nfsuserd != 0 ||
485 nfs_numnfscbd != 0) {
486 error = EBUSY;
487 break;
488 }
489
490 nfsd_call_nfscommon = NULL;
491 callout_drain(&newnfsd_callout);
492 /* and get rid of the mutexes */
493 mtx_destroy(&nfs_nameid_mutex);
494 mtx_destroy(&newnfsd_mtx);
495 mtx_destroy(&nfs_state_mutex);
496 mtx_destroy(&nfs_sockl_mutex);
497 mtx_destroy(&nfs_slock_mutex);
498 mtx_destroy(&nfs_req_mutex);
499 mtx_destroy(&nfsrv_nfsuserdsock.nr_mtx);
500 loaded = 0;
501 break;
502 default:
503 error = EOPNOTSUPP;
504 break;
505 }
506 return error;
507}
508static moduledata_t nfscommon_mod = {
509 "nfscommon",
510 nfscommon_modevent,
511 NULL,
512};
513DECLARE_MODULE(nfscommon, nfscommon_mod, SI_SUB_VFS, SI_ORDER_ANY);
514
515/* So that loader and kldload(2) can find us, wherever we are.. */
516MODULE_VERSION(nfscommon, 1);
517MODULE_DEPEND(nfscommon, nfssvc, 1, 1, 1);
518MODULE_DEPEND(nfscommon, krpc, 1, 1, 1);
519
| 82
83/*
84 * Defines for malloc
85 * (Here for FreeBSD, since they allocate storage.)
86 */
87MALLOC_DEFINE(M_NEWNFSRVCACHE, "NFSD srvcache", "NFSD Server Request Cache");
88MALLOC_DEFINE(M_NEWNFSDCLIENT, "NFSD V4client", "NFSD V4 Client Id");
89MALLOC_DEFINE(M_NEWNFSDSTATE, "NFSD V4state",
90 "NFSD V4 State (Openowner, Open, Lockowner, Delegation");
91MALLOC_DEFINE(M_NEWNFSDLOCK, "NFSD V4lock", "NFSD V4 byte range lock");
92MALLOC_DEFINE(M_NEWNFSDLOCKFILE, "NFSD lckfile", "NFSD Open/Lock file");
93MALLOC_DEFINE(M_NEWNFSSTRING, "NFSD string", "NFSD V4 long string");
94MALLOC_DEFINE(M_NEWNFSUSERGROUP, "NFSD usrgroup", "NFSD V4 User/group map");
95MALLOC_DEFINE(M_NEWNFSDREQ, "NFS req", "NFS request header");
96MALLOC_DEFINE(M_NEWNFSFH, "NFS fh", "NFS file handle");
97MALLOC_DEFINE(M_NEWNFSCLOWNER, "NFSCL owner", "NFSCL Open Owner");
98MALLOC_DEFINE(M_NEWNFSCLOPEN, "NFSCL open", "NFSCL Open");
99MALLOC_DEFINE(M_NEWNFSCLDELEG, "NFSCL deleg", "NFSCL Delegation");
100MALLOC_DEFINE(M_NEWNFSCLCLIENT, "NFSCL client", "NFSCL Client");
101MALLOC_DEFINE(M_NEWNFSCLLOCKOWNER, "NFSCL lckown", "NFSCL Lock Owner");
102MALLOC_DEFINE(M_NEWNFSCLLOCK, "NFSCL lck", "NFSCL Lock");
103MALLOC_DEFINE(M_NEWNFSV4NODE, "NEWNFSnode", "New nfs vnode");
104MALLOC_DEFINE(M_NEWNFSDIRECTIO, "NEWdirectio", "New nfs Direct IO buffer");
105MALLOC_DEFINE(M_NEWNFSDIROFF, "NFSCL diroffdiroff",
106 "New NFS directory offset data");
107MALLOC_DEFINE(M_NEWNFSDROLLBACK, "NFSD rollback",
108 "New NFS local lock rollback");
109
110/*
111 * Definition of mutex locks.
112 * newnfsd_mtx is used in nfsrvd_nfsd() to protect the nfs socket list
113 * and assorted other nfsd structures.
114 * Giant is used to protect the nfsd list and count, which is just
115 * updated when nfsd's start/stop and is grabbed for nfsrvd_dorpc()
116 * for the VFS ops.
117 */
118struct mtx newnfsd_mtx;
119struct mtx nfs_sockl_mutex;
120struct mtx nfs_state_mutex;
121struct mtx nfs_nameid_mutex;
122struct mtx nfs_req_mutex;
123struct mtx nfs_slock_mutex;
124
125/* local functions */
126static int nfssvc_call(struct thread *, struct nfssvc_args *, struct ucred *);
127
128#ifdef __NO_STRICT_ALIGNMENT
129/*
130 * These architectures don't need re-alignment, so just return.
131 */
132void
133newnfs_realign(struct mbuf **pm)
134{
135
136 return;
137}
138#else /* !__NO_STRICT_ALIGNMENT */
139/*
140 * newnfs_realign:
141 *
142 * Check for badly aligned mbuf data and realign by copying the unaligned
143 * portion of the data into a new mbuf chain and freeing the portions
144 * of the old chain that were replaced.
145 *
146 * We cannot simply realign the data within the existing mbuf chain
147 * because the underlying buffers may contain other rpc commands and
148 * we cannot afford to overwrite them.
149 *
150 * We would prefer to avoid this situation entirely. The situation does
151 * not occur with NFS/UDP and is supposed to only occassionally occur
152 * with TCP. Use vfs.nfs.realign_count and realign_test to check this.
153 *
154 */
155void
156newnfs_realign(struct mbuf **pm)
157{
158 struct mbuf *m, *n;
159 int off, space;
160
161 ++nfs_realign_test;
162 while ((m = *pm) != NULL) {
163 if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
164 /*
165 * NB: we can't depend on m_pkthdr.len to help us
166 * decide what to do here. May not be worth doing
167 * the m_length calculation as m_copyback will
168 * expand the mbuf chain below as needed.
169 */
170 space = m_length(m, NULL);
171 if (space >= MINCLSIZE) {
172 /* NB: m_copyback handles space > MCLBYTES */
173 n = m_getcl(M_WAITOK, MT_DATA, 0);
174 } else
175 n = m_get(M_WAITOK, MT_DATA);
176 if (n == NULL)
177 return;
178 /*
179 * Align the remainder of the mbuf chain.
180 */
181 n->m_len = 0;
182 off = 0;
183 while (m != NULL) {
184 m_copyback(n, off, m->m_len, mtod(m, caddr_t));
185 off += m->m_len;
186 m = m->m_next;
187 }
188 m_freem(*pm);
189 *pm = n;
190 ++nfs_realign_count;
191 break;
192 }
193 pm = &m->m_next;
194 }
195}
196#endif /* __NO_STRICT_ALIGNMENT */
197
198#ifdef notdef
199static void
200nfsrv_object_create(struct vnode *vp, struct thread *td)
201{
202
203 if (vp == NULL || vp->v_type != VREG)
204 return;
205 (void) vfs_object_create(vp, td, td->td_ucred);
206}
207#endif
208
209/*
210 * Look up a file name. Basically just initialize stuff and call namei().
211 */
212int
213nfsrv_lookupfilename(struct nameidata *ndp, char *fname, NFSPROC_T *p)
214{
215 int error;
216
217 NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF | MPSAFE, UIO_USERSPACE, fname,
218 p);
219 error = namei(ndp);
220 if (!error) {
221 NDFREE(ndp, NDF_ONLY_PNBUF);
222 }
223 return (error);
224}
225
226/*
227 * Copy NFS uid, gids to the cred structure.
228 */
229void
230newnfs_copycred(struct nfscred *nfscr, struct ucred *cr)
231{
232
233 KASSERT(nfscr->nfsc_ngroups >= 0,
234 ("newnfs_copycred: negative nfsc_ngroups"));
235 cr->cr_uid = nfscr->nfsc_uid;
236 crsetgroups(cr, nfscr->nfsc_ngroups, nfscr->nfsc_groups);
237}
238
239/*
240 * Map args from nfsmsleep() to msleep().
241 */
242int
243nfsmsleep(void *chan, void *mutex, int prio, const char *wmesg,
244 struct timespec *ts)
245{
246 u_int64_t nsecval;
247 int error, timeo;
248
249 if (ts) {
250 timeo = hz * ts->tv_sec;
251 nsecval = (u_int64_t)ts->tv_nsec;
252 nsecval = ((nsecval * ((u_int64_t)hz)) + 500000000) /
253 1000000000;
254 timeo += (int)nsecval;
255 } else {
256 timeo = 0;
257 }
258 error = msleep(chan, (struct mtx *)mutex, prio, wmesg, timeo);
259 return (error);
260}
261
262/*
263 * Get the file system info for the server. For now, just assume FFS.
264 */
265void
266nfsvno_getfs(struct nfsfsinfo *sip, int isdgram)
267{
268 int pref;
269
270 /*
271 * XXX
272 * There should be file system VFS OP(s) to get this information.
273 * For now, assume ufs.
274 */
275 if (isdgram)
276 pref = NFS_MAXDGRAMDATA;
277 else
278 pref = NFS_MAXDATA;
279 sip->fs_rtmax = NFS_MAXDATA;
280 sip->fs_rtpref = pref;
281 sip->fs_rtmult = NFS_FABLKSIZE;
282 sip->fs_wtmax = NFS_MAXDATA;
283 sip->fs_wtpref = pref;
284 sip->fs_wtmult = NFS_FABLKSIZE;
285 sip->fs_dtpref = pref;
286 sip->fs_maxfilesize = 0xffffffffffffffffull;
287 sip->fs_timedelta.tv_sec = 0;
288 sip->fs_timedelta.tv_nsec = 1;
289 sip->fs_properties = (NFSV3FSINFO_LINK |
290 NFSV3FSINFO_SYMLINK | NFSV3FSINFO_HOMOGENEOUS |
291 NFSV3FSINFO_CANSETTIME);
292}
293
294/* Fake nfsrv_atroot. Just return 0 */
295int
296nfsrv_atroot(struct vnode *vp, long *retp)
297{
298
299 return (0);
300}
301
302/*
303 * Set the credentials to refer to root.
304 * If only the various BSDen could agree on whether cr_gid is a separate
305 * field or cr_groups[0]...
306 */
307void
308newnfs_setroot(struct ucred *cred)
309{
310
311 cred->cr_uid = 0;
312 cred->cr_groups[0] = 0;
313 cred->cr_ngroups = 1;
314}
315
316/*
317 * Get the client credential. Used for Renew and recovery.
318 */
319struct ucred *
320newnfs_getcred(void)
321{
322 struct ucred *cred;
323 struct thread *td = curthread;
324
325 cred = crdup(td->td_ucred);
326 newnfs_setroot(cred);
327 return (cred);
328}
329
330/*
331 * Nfs timer routine
332 * Call the nfsd's timer function once/sec.
333 */
334void
335newnfs_timer(void *arg)
336{
337 static time_t lasttime = 0;
338 /*
339 * Call the server timer, if set up.
340 * The argument indicates if it is the next second and therefore
341 * leases should be checked.
342 */
343 if (lasttime != NFSD_MONOSEC) {
344 lasttime = NFSD_MONOSEC;
345 if (nfsd_call_servertimer != NULL)
346 (*nfsd_call_servertimer)();
347 }
348 callout_reset(&newnfsd_callout, nfscl_ticks, newnfs_timer, NULL);
349}
350
351
352/*
353 * Sleep for a short period of time unless errval == NFSERR_GRACE, where
354 * the sleep should be for 5 seconds.
355 * Since lbolt doesn't exist in FreeBSD-CURRENT, just use a timeout on
356 * an event that never gets a wakeup. Only return EINTR or 0.
357 */
358int
359nfs_catnap(int prio, int errval, const char *wmesg)
360{
361 static int non_event;
362 int ret;
363
364 if (errval == NFSERR_GRACE)
365 ret = tsleep(&non_event, prio, wmesg, 5 * hz);
366 else
367 ret = tsleep(&non_event, prio, wmesg, 1);
368 if (ret != EINTR)
369 ret = 0;
370 return (ret);
371}
372
373/*
374 * Get referral. For now, just fail.
375 */
376struct nfsreferral *
377nfsv4root_getreferral(struct vnode *vp, struct vnode *dvp, u_int32_t fileno)
378{
379
380 return (NULL);
381}
382
383static int
384nfssvc_nfscommon(struct thread *td, struct nfssvc_args *uap)
385{
386 int error;
387
388 error = nfssvc_call(td, uap, td->td_ucred);
389 return (error);
390}
391
392static int
393nfssvc_call(struct thread *p, struct nfssvc_args *uap, struct ucred *cred)
394{
395 int error = EINVAL;
396 struct nfsd_idargs nid;
397
398 if (uap->flag & NFSSVC_IDNAME) {
399 error = copyin(uap->argp, (caddr_t)&nid, sizeof (nid));
400 if (error)
401 return (error);
402 error = nfssvc_idname(&nid);
403 return (error);
404 } else if (uap->flag & NFSSVC_GETSTATS) {
405 error = copyout(&newnfsstats,
406 CAST_USER_ADDR_T(uap->argp), sizeof (newnfsstats));
407 return (error);
408 } else if (uap->flag & NFSSVC_NFSUSERDPORT) {
409 u_short sockport;
410
411 error = copyin(uap->argp, (caddr_t)&sockport,
412 sizeof (u_short));
413 if (!error)
414 error = nfsrv_nfsuserdport(sockport, p);
415 } else if (uap->flag & NFSSVC_NFSUSERDDELPORT) {
416 nfsrv_nfsuserddelport();
417 error = 0;
418 }
419 return (error);
420}
421
422/*
423 * called by all three modevent routines, so that it gets things
424 * initialized soon enough.
425 */
426void
427newnfs_portinit(void)
428{
429 static int inited = 0;
430
431 if (inited)
432 return;
433 inited = 1;
434 /* Initialize SMP locks used by both client and server. */
435 mtx_init(&newnfsd_mtx, "newnfsd_mtx", NULL, MTX_DEF);
436 mtx_init(&nfs_state_mutex, "nfs_state_mutex", NULL, MTX_DEF);
437}
438
439/*
440 * Determine if the file system supports NFSv4 ACLs.
441 * Return 1 if it does, 0 otherwise.
442 */
443int
444nfs_supportsnfsv4acls(struct vnode *vp)
445{
446 int error;
447 register_t retval;
448
449 ASSERT_VOP_LOCKED(vp, "nfs supports nfsv4acls");
450
451 if (nfsrv_useacl == 0)
452 return (0);
453 error = VOP_PATHCONF(vp, _PC_ACL_NFS4, &retval);
454 if (error == 0 && retval != 0)
455 return (1);
456 return (0);
457}
458
459extern int (*nfsd_call_nfscommon)(struct thread *, struct nfssvc_args *);
460
461/*
462 * Called once to initialize data structures...
463 */
464static int
465nfscommon_modevent(module_t mod, int type, void *data)
466{
467 int error = 0;
468 static int loaded = 0;
469
470 switch (type) {
471 case MOD_LOAD:
472 if (loaded)
473 return (0);
474 newnfs_portinit();
475 mtx_init(&nfs_nameid_mutex, "nfs_nameid_mutex", NULL, MTX_DEF);
476 mtx_init(&nfs_sockl_mutex, "nfs_sockl_mutex", NULL, MTX_DEF);
477 mtx_init(&nfs_slock_mutex, "nfs_slock_mutex", NULL, MTX_DEF);
478 mtx_init(&nfs_req_mutex, "nfs_req_mutex", NULL, MTX_DEF);
479 mtx_init(&nfsrv_nfsuserdsock.nr_mtx, "nfsuserd", NULL,
480 MTX_DEF);
481 callout_init(&newnfsd_callout, CALLOUT_MPSAFE);
482 newnfs_init();
483 nfsd_call_nfscommon = nfssvc_nfscommon;
484 loaded = 1;
485 break;
486
487 case MOD_UNLOAD:
488 if (newnfs_numnfsd != 0 || nfsrv_nfsuserd != 0 ||
489 nfs_numnfscbd != 0) {
490 error = EBUSY;
491 break;
492 }
493
494 nfsd_call_nfscommon = NULL;
495 callout_drain(&newnfsd_callout);
496 /* and get rid of the mutexes */
497 mtx_destroy(&nfs_nameid_mutex);
498 mtx_destroy(&newnfsd_mtx);
499 mtx_destroy(&nfs_state_mutex);
500 mtx_destroy(&nfs_sockl_mutex);
501 mtx_destroy(&nfs_slock_mutex);
502 mtx_destroy(&nfs_req_mutex);
503 mtx_destroy(&nfsrv_nfsuserdsock.nr_mtx);
504 loaded = 0;
505 break;
506 default:
507 error = EOPNOTSUPP;
508 break;
509 }
510 return error;
511}
512static moduledata_t nfscommon_mod = {
513 "nfscommon",
514 nfscommon_modevent,
515 NULL,
516};
517DECLARE_MODULE(nfscommon, nfscommon_mod, SI_SUB_VFS, SI_ORDER_ANY);
518
519/* So that loader and kldload(2) can find us, wherever we are.. */
520MODULE_VERSION(nfscommon, 1);
521MODULE_DEPEND(nfscommon, nfssvc, 1, 1, 1);
522MODULE_DEPEND(nfscommon, krpc, 1, 1, 1);
523
|