int
nfs4_setopts(vnode_t *vp, model_t model, struct nfs_args *buf)
{
mntinfo4_t *mi; /* mount info, pointed at by vfs */
STRUCT_HANDLE(nfs_args, args);
int flags;
#ifdef lint
model = model;
#endif
STRUCT_SET_HANDLE(args, model, buf);
flags = STRUCT_FGET(args, flags);
/*
* Set option fields in mount info record
*/
mi = VTOMI4(vp);
if (flags & NFSMNT_NOAC) {
mutex_enter(&mi->mi_lock);
mi->mi_flags |= MI4_NOAC;
mutex_exit(&mi->mi_lock);
PURGE_ATTRCACHE4(vp);
}
mutex_enter(&mi->mi_lock);
if (flags & NFSMNT_NOCTO)
mi->mi_flags |= MI4_NOCTO;
if (flags & NFSMNT_LLOCK)
mi->mi_flags |= MI4_LLOCK;
if (flags & NFSMNT_GRPID)
mi->mi_flags |= MI4_GRPID;
mutex_exit(&mi->mi_lock);
if (flags & NFSMNT_RETRANS) {
if (STRUCT_FGET(args, retrans) < 0)
return (EINVAL);
mi->mi_retrans = STRUCT_FGET(args, retrans);
}
if (flags & NFSMNT_TIMEO) {
if (STRUCT_FGET(args, timeo) <= 0)
return (EINVAL);
mi->mi_timeo = STRUCT_FGET(args, timeo);
}
if (flags & NFSMNT_RSIZE) {
if (STRUCT_FGET(args, rsize) <= 0)
return (EINVAL);
mi->mi_tsize = MIN(mi->mi_tsize, STRUCT_FGET(args, rsize));
mi->mi_curread = MIN(mi->mi_curread, mi->mi_tsize);
}
if (flags & NFSMNT_WSIZE) {
if (STRUCT_FGET(args, wsize) <= 0)
return (EINVAL);
mi->mi_stsize = MIN(mi->mi_stsize, STRUCT_FGET(args, wsize));
mi->mi_curwrite = MIN(mi->mi_curwrite, mi->mi_stsize);
}
if (flags & NFSMNT_ACREGMIN) {
if (STRUCT_FGET(args, acregmin) < 0)
mi->mi_acregmin = SEC2HR(ACMINMAX);
else
mi->mi_acregmin = SEC2HR(MIN(STRUCT_FGET(args,
acregmin), ACMINMAX));
}
if (flags & NFSMNT_ACREGMAX) {
if (STRUCT_FGET(args, acregmax) < 0)
mi->mi_acregmax = SEC2HR(ACMAXMAX);
else
mi->mi_acregmax = SEC2HR(MIN(STRUCT_FGET(args,
acregmax), ACMAXMAX));
}
if (flags & NFSMNT_ACDIRMIN) {
if (STRUCT_FGET(args, acdirmin) < 0)
mi->mi_acdirmin = SEC2HR(ACMINMAX);
else
mi->mi_acdirmin = SEC2HR(MIN(STRUCT_FGET(args,
acdirmin), ACMINMAX));
}
if (flags & NFSMNT_ACDIRMAX) {
if (STRUCT_FGET(args, acdirmax) < 0)
mi->mi_acdirmax = SEC2HR(ACMAXMAX);
else
mi->mi_acdirmax = SEC2HR(MIN(STRUCT_FGET(args,
acdirmax), ACMAXMAX));
}
return (0);
}
void
r4_do_attrcache(vnode_t *vp, nfs4_ga_res_t *garp, int newnode,
hrtime_t t, cred_t *cr, int index)
{
int is_stub;
vattr_t *attr;
/*
* Don't add to attrcache if time overflow, but
* no need to check because either attr is null or the time
* values in it were processed by nfs4_time_ntov(), which checks
* for time overflows.
*/
attr = garp ? &garp->n4g_va : NULL;
if (attr) {
if (!newnode) {
rw_exit(&rtable4[index].r_lock);
#ifdef DEBUG
if (vp->v_type != attr->va_type &&
vp->v_type != VNON && attr->va_type != VNON) {
zcmn_err(VTOMI4(vp)->mi_zone->zone_id, CE_WARN,
"makenfs4node: type (%d) doesn't "
"match type of found node at %p (%d)",
attr->va_type, (void *)vp, vp->v_type);
}
#endif
nfs4_attr_cache(vp, garp, t, cr, TRUE, NULL);
} else {
rnode4_t *rp = VTOR4(vp);
vp->v_type = attr->va_type;
vp->v_rdev = attr->va_rdev;
/*
* Turn this object into a "stub" object if we
* crossed an underlying server fs boundary.
* To make this check, during mount we save the
* fsid of the server object being mounted.
* Here we compare this object's server fsid
* with the fsid we saved at mount. If they
* are different, we crossed server fs boundary.
*
* The stub type is set (or not) at rnode
* creation time and it never changes for life
* of the rnode.
*
* The stub type is also set during RO failover,
* nfs4_remap_file().
*
* This stub will be for a mirror-mount.
*
* We don't bother with taking r_state_lock to
* set the stub type because this is a new rnode
* and we're holding the hash bucket r_lock RW_WRITER.
* No other thread could have obtained access
* to this rnode.
*/
is_stub = 0;
if (garp->n4g_fsid_valid) {
fattr4_fsid ga_fsid = garp->n4g_fsid;
servinfo4_t *svp = rp->r_server;
rp->r_srv_fsid = ga_fsid;
(void) nfs_rw_enter_sig(&svp->sv_lock,
RW_READER, 0);
if (!FATTR4_FSID_EQ(&ga_fsid, &svp->sv_fsid))
is_stub = 1;
nfs_rw_exit(&svp->sv_lock);
}
if (is_stub)
r4_stub_mirrormount(rp);
else
r4_stub_none(rp);
/* Can not cache partial attr */
if (attr->va_mask == AT_ALL)
nfs4_attrcache_noinval(vp, garp, t);
else
PURGE_ATTRCACHE4(vp);
rw_exit(&rtable4[index].r_lock);
}
} else {
if (newnode) {
PURGE_ATTRCACHE4(vp);
}
rw_exit(&rtable4[index].r_lock);
}
}
