/*
* Copyright (c) 2008 Isilon Inc http://www.isilon.com/
* Authors: Doug Rabson <dfr@rabson.org>
* Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Copyright 2011 Nexenta Systems, Inc. All rights reserved.
* Copyright (c) 2012 by Delphix. All rights reserved.
* Copyright (c) 2014, Joyent, Inc. All rights reserved.
*/
/*
* Client-side support for (NFS) VOP_FRLOCK, VOP_SHRLOCK.
* (called via klmops.c: lm_frlock, lm4_frlock)
*
* Source code derived from FreeBSD nlm_advlock.c
*/
#include <sys/param.h>
#include <sys/fcntl.h>
#include <sys/lock.h>
#include <sys/flock.h>
#include <sys/mount.h>
#include <sys/mutex.h>
#include <sys/proc.h>
#include <sys/share.h>
#include <sys/syslog.h>
#include <sys/systm.h>
#include <sys/unistd.h>
#include <sys/vnode.h>
#include <sys/queue.h>
#include <sys/sdt.h>
#include <netinet/in.h>
#include <fs/fs_subr.h>
#include <rpcsvc/nlm_prot.h>
#include <nfs/nfs.h>
#include <nfs/nfs_clnt.h>
#include <nfs/export.h>
#include <nfs/rnode.h>
#include <nfs/lm.h>
#include "nlm_impl.h"
/* Extra flags for nlm_call_lock() - xflags */
#define NLM_X_RECLAIM 1
#define NLM_X_BLOCKING 2
/*
* Max. number of retries nlm_call_cancel() does
* when NLM server is in grace period or doesn't
* respond correctly.
*/
#define NLM_CANCEL_NRETRS 5
/*
* Determines wether given lock "flp" is safe.
* The lock is considered to be safe when it
* acquires the whole file (i.e. its start
* and len are zeroes).
*/
#define NLM_FLOCK_IS_SAFE(flp) \
((flp)->l_start == 0 && (flp)->l_len == 0)
static volatile uint32_t nlm_xid = 1;
static int nlm_init_fh_by_vp(vnode_t *, struct netobj *, rpcvers_t *);
static int nlm_map_status(nlm4_stats);
static int nlm_map_clnt_stat(enum clnt_stat);
static void nlm_send_siglost(pid_t);
static int nlm_frlock_getlk(struct nlm_host *, vnode_t *,
struct flock64 *, int, u_offset_t, struct netobj *, int);
static int nlm_frlock_setlk(struct nlm_host *, vnode_t *,
struct flock64 *, int, u_offset_t, struct netobj *,
struct flk_callback *, int, bool_t);
static int nlm_reclaim_lock(struct nlm_host *, vnode_t *,
struct flock64 *, int32_t);
static void nlm_init_lock(struct nlm4_lock *,
const struct flock64 *, struct netobj *,
struct nlm_owner_handle *);
static int nlm_call_lock(vnode_t *, struct flock64 *,
struct nlm_host *, struct netobj *,
struct flk_callback *, int, int);
static int nlm_call_unlock(struct flock64 *, struct nlm_host *,
struct netobj *, int);
static int nlm_call_test(struct flock64 *, struct nlm_host *,
struct netobj *, int);
static int nlm_call_cancel(struct nlm4_lockargs *,
struct nlm_host *, int);
static int nlm_local_getlk(vnode_t *, struct flock64 *, int);
static int nlm_local_setlk(vnode_t *, struct flock64 *, int);
static void nlm_local_cancelk(vnode_t *, struct flock64 *);
static void nlm_init_share(struct nlm4_share *,
const struct shrlock *, struct netobj *);
static int nlm_call_share(struct shrlock *, struct nlm_host *,
struct netobj *, int, int);
static int nlm_call_unshare(struct shrlock *, struct nlm_host *,
struct netobj *, int);
static int nlm_reclaim_share(struct nlm_host *, vnode_t *,
struct shrlock *, uint32_t);
static int nlm_local_shrlock(vnode_t *, struct shrlock *, int, int);
static void nlm_local_shrcancel(vnode_t *, struct shrlock *);
/*
* Reclaim locks/shares acquired by the client side
* on the given server represented by hostp.
* The function is called from a dedicated thread
* when server reports us that it's entered grace
* period.
*/
void
nlm_reclaim_client(struct nlm_globals *g, struct nlm_host *hostp)
{
int32_t state;
int error, sysid;
struct locklist *llp_head, *llp;
struct nlm_shres *nsp_head, *nsp;
bool_t restart;
sysid = hostp->nh_sysid | LM_SYSID_CLIENT;
do {
error = 0;
restart = FALSE;
state = nlm_host_get_state(hostp);
DTRACE_PROBE3(reclaim__iter, struct nlm_globals *, g,
struct nlm_host *, hostp, int, state);
/*
* We cancel all sleeping locks that were
* done by the host, because we don't allow
* reclamation of sleeping locks. The reason
* we do this is that allowing of sleeping locks
* reclamation can potentially break locks recovery
* order.
*
* Imagine that we have two client machines A and B
* and an NLM server machine. A adds a non sleeping
* lock to the file F and aquires this file. Machine
* B in its turn adds sleeping lock to the file
* F and blocks because F is already aquired by
* the machine A. Then server crashes and after the
* reboot it notifies its clients about the crash.
* If we would allow sleeping locks reclamation,
* there would be possible that machine B recovers
* its lock faster than machine A (by some reason).
* So that B aquires the file F after server crash and
* machine A (that by some reason recovers slower) fails
* to recover its non sleeping lock. Thus the original
* locks order becames broken.
*/
nlm_host_cancel_slocks(g, hostp);
/*
* Try to reclaim all active locks we have
*/
llp_head = llp = flk_get_active_locks(sysid, NOPID);
while (llp != NULL) {
error = nlm_reclaim_lock(hostp, llp->ll_vp,
&llp->ll_flock, state);
if (error == 0) {
llp = llp->ll_next;
continue;
} else if (error == ERESTART) {
restart = TRUE;
break;
} else {
/*
* Critical error occurred, the lock
* can not be recovered, just take it away.
*/
nlm_local_cancelk(llp->ll_vp, &llp->ll_flock);
}
llp = llp->ll_next;
}
flk_free_locklist(llp_head);
if (restart) {
/*
* Lock reclamation fucntion reported us that
* the server state was changed (again), so
* try to repeat the whole reclamation process.
*/
continue;
}
nsp_head = nsp = nlm_get_active_shres(hostp);
while (nsp != NULL) {
error = nlm_reclaim_share(hostp, nsp->ns_vp,
nsp->ns_shr, state);
if (error == 0) {
nsp = nsp->ns_next;
continue;
} else if (error == ERESTART) {
break;
} else {
/* Failed to reclaim share */
nlm_shres_untrack(hostp, nsp->ns_vp,
nsp->ns_shr);
nlm_local_shrcancel(nsp->ns_vp,
nsp->ns_shr);
}
nsp = nsp->ns_next;
}
nlm_free_shrlist(nsp_head);
} while (state != nlm_host_get_state(hostp));
}
/*
* nlm_frlock --
* NFS advisory byte-range locks.
* Called in klmops.c
*
* Note that the local locking code (os/flock.c) is used to
* keep track of remote locks granted by some server, so we
* can reclaim those locks after a server restarts. We can
* also sometimes use this as a cache of lock information.
*
* Was: nlm_advlock()
*/
/* ARGSUSED */
int
nlm_frlock(struct vnode *vp, int cmd, struct flock64 *flkp,
int flags, u_offset_t offset, struct cred *crp,
struct netobj *fhp, struct flk_callback *flcb, int vers)
{
mntinfo_t *mi;
servinfo_t *sv;
const char *netid;
struct nlm_host *hostp;
int error;
struct nlm_globals *g;
mi = VTOMI(vp);
sv = mi->mi_curr_serv;
netid = nlm_knc_to_netid(sv->sv_knconf);
if (netid == NULL) {
NLM_ERR("nlm_frlock: unknown NFS netid");
return (ENOSYS);
}
g = zone_getspecific(nlm_zone_key, curzone);
hostp = nlm_host_findcreate(g, sv->sv_hostname, netid, &sv->sv_addr);
if (hostp == NULL)
return (ENOSYS);
/*
* Purge cached attributes in order to make sure that
* future calls of convoff()/VOP_GETATTR() will get the
* latest data.
*/
if (flkp->l_whence == SEEK_END)
PURGE_ATTRCACHE(vp);
/* Now flk0 is the zero-based lock request. */
switch (cmd) {
case F_GETLK:
error = nlm_frlock_getlk(hostp, vp, flkp, flags,
offset, fhp, vers);
break;
case F_SETLK:
case F_SETLKW:
error = nlm_frlock_setlk(hostp, vp, flkp, flags,
offset, fhp, flcb, vers, (cmd == F_SETLKW));
if (error == 0)
nlm_host_monitor(g, hostp, 0);
break;
default:
error = EINVAL;
break;
}
nlm_host_release(g, hostp);
return (error);
}
static int
nlm_frlock_getlk(struct nlm_host *hostp, vnode_t *vp,
struct flock64 *flkp, int flags, u_offset_t offset,
struct netobj *fhp, int vers)
{
struct flock64 flk0;
int error;
/*
* Check local (cached) locks first.
* If we find one, no need for RPC.
*/
flk0 = *flkp;
flk0.l_pid = curproc->p_pid;
error = nlm_local_getlk(vp, &flk0, flags);
if (error != 0)
return (error);
if (flk0.l_type != F_UNLCK) {
*flkp = flk0;
return (0);
}
/* Not found locally. Try remote. */
flk0 = *flkp;
flk0.l_pid = curproc->p_pid;
error = convoff(vp, &flk0, 0, (offset_t)offset);
if (error != 0)
return (error);
error = nlm_call_test(&flk0, hostp, fhp, vers);
if (error != 0)
return (error);
if (flk0.l_type == F_UNLCK) {
/*
* Update the caller's *flkp with information
* on the conflicting lock (or lack thereof).
*/
flkp->l_type = F_UNLCK;
} else {
/*
* Found a conflicting lock. Set the
* caller's *flkp with the info, first
* converting to the caller's whence.
*/
(void) convoff(vp, &flk0, flkp->l_whence, (offset_t)offset);
*flkp = flk0;
}
return (0);
}
static int
nlm_frlock_setlk(struct nlm_host *hostp, vnode_t *vp,
struct flock64 *flkp, int flags, u_offset_t offset,
struct netobj *fhp, struct flk_callback *flcb,
int vers, bool_t do_block)
{
int error, xflags;
error = convoff(vp, flkp, 0, (offset_t)offset);
if (error != 0)
return (error);
/*
* NFS v2 clients should not request locks where any part
* of the lock range is beyond 0xffffffff. The NFS code
* checks that (see nfs_frlock, flk_check_lock_data), but
* as that's outside this module, let's check here too.
* This check ensures that we will be able to convert this
* lock request into 32-bit form without change, and that
* (more importantly) when the granted call back arrives,
* it's unchanged when converted back into 64-bit form.
* If this lock range were to change in any way during
* either of those conversions, the "granted" call back
* from the NLM server would not find our sleeping lock.
*/
if (vers < NLM4_VERS) {
if (flkp->l_start > MAX_UOFF32 ||
flkp->l_start + flkp->l_len > MAX_UOFF32 + 1)
return (EINVAL);
}
/*
* Fill in l_sysid for the local locking calls.
* Also, let's not trust the caller's l_pid.
*/
flkp->l_sysid = hostp->nh_sysid | LM_SYSID_CLIENT;
flkp->l_pid = curproc->p_pid;
if (flkp->l_type == F_UNLCK) {
/*
* Purge local (cached) lock information first,
* then clear the remote lock.
*/
(void) nlm_local_setlk(vp, flkp, flags);
error = nlm_call_unlock(flkp, hostp, fhp, vers);
return (error);
}
if (!do_block) {
/*
* This is a non-blocking "set" request,
* so we can check locally first, and
* sometimes avoid an RPC call.
*/
struct flock64 flk0;
flk0 = *flkp;
error = nlm_local_getlk(vp, &flk0, flags);
if (error != 0 && flk0.l_type != F_UNLCK) {
/* Found a conflicting lock. */
return (EAGAIN);
}
xflags = 0;
} else {
xflags = NLM_X_BLOCKING;
}
nfs_add_locking_id(vp, curproc->p_pid, RLMPL_PID,
(char *)&curproc->p_pid, sizeof (pid_t));
error = nlm_call_lock(vp, flkp, hostp, fhp, flcb, vers, xflags);
if (error != 0)
return (error);
/*
* Save the lock locally. This should not fail,
* because the server is authoritative about locks
* and it just told us we have the lock!
*/
error = nlm_local_setlk(vp, flkp, flags);
if (error != 0) {
/*
* That's unexpected situation. Just ignore the error.
*/
NLM_WARN("nlm_frlock_setlk: Failed to set local lock. "
"[err=%d]\n", error);
error = 0;
}
return (error);
}
/*
* Cancel all client side remote locks/shares on the
* given host. Report to the processes that own
* cancelled locks that they are removed by force
* by sending SIGLOST.
*/
void
nlm_client_cancel_all(struct nlm_globals *g, struct nlm_host *hostp)
{
struct locklist *llp_head, *llp;
struct nlm_shres *nsp_head, *nsp;
struct netobj lm_fh;
rpcvers_t vers;
int error, sysid;
sysid = hostp->nh_sysid | LM_SYSID_CLIENT;
nlm_host_cancel_slocks(g, hostp);
/*
* Destroy all active locks
*/
llp_head = llp = flk_get_active_locks(sysid, NOPID);
while (llp != NULL) {
llp->ll_flock.l_type = F_UNLCK;
error = nlm_init_fh_by_vp(llp->ll_vp, &lm_fh, &vers);
if (error == 0)
(void) nlm_call_unlock(&llp->ll_flock, hostp,
&lm_fh, vers);
nlm_local_cancelk(llp->ll_vp, &llp->ll_flock);
llp = llp->ll_next;
}
flk_free_locklist(llp_head);
/*
* Destroy all active share reservations
*/
nsp_head = nsp = nlm_get_active_shres(hostp);
while (nsp != NULL) {
error = nlm_init_fh_by_vp(nsp->ns_vp, &lm_fh, &vers);
if (error == 0)
(void) nlm_call_unshare(nsp->ns_shr, hostp,
&lm_fh, vers);
nlm_local_shrcancel(nsp->ns_vp, nsp->ns_shr);
nlm_shres_untrack(hostp, nsp->ns_vp, nsp->ns_shr);
nsp = nsp->ns_next;
}
nlm_free_shrlist(nsp_head);
}
/*
* The function determines whether the lock "fl" can
* be safely applied to the file vnode "vp" corresponds to.
* The lock can be "safely" applied if all the conditions
* above are held:
* - It's not a mandatory lock
* - The vnode wasn't mapped by anyone
* - The vnode was mapped, but it hasn't any locks on it.
* - The vnode was mapped and all locks it has occupies
* the whole file.
*/
int
nlm_safelock(vnode_t *vp, const struct flock64 *fl, cred_t *cr)
{
rnode_t *rp = VTOR(vp);
struct vattr va;
int err;
if ((rp->r_mapcnt > 0) && (fl->l_start != 0 || fl->l_len != 0))
return (0);
va.va_mask = AT_MODE;
err = VOP_GETATTR(vp, &va, 0, cr, NULL);
if (err != 0)
return (0);
/* NLM4 doesn't allow mandatory file locking */
if (MANDLOCK(vp, va.va_mode))
return (0);
return (1);
}
/*
* The function determines whether it's safe to map
* a file correspoding to vnode vp.
* The mapping is considered to be "safe" if file
* either has no any locks on it or all locks it
* has occupy the whole file.
*/
int
nlm_safemap(const vnode_t *vp)
{
struct locklist *llp, *llp_next;
struct nlm_slock *nslp;
struct nlm_globals *g;
int safe = 1;
/* Check active locks at first */
llp = flk_active_locks_for_vp(vp);
while (llp != NULL) {
if ((llp->ll_vp == vp) &&
!NLM_FLOCK_IS_SAFE(&llp->ll_flock))
safe = 0;
llp_next = llp->ll_next;
VN_RELE(llp->ll_vp);
kmem_free(llp, sizeof (*llp));
llp = llp_next;
}
if (!safe)
return (safe);
/* Then check sleeping locks if any */
g = zone_getspecific(nlm_zone_key, curzone);
mutex_enter(&g->lock);
TAILQ_FOREACH(nslp, &g->nlm_slocks, nsl_link) {
if (nslp->nsl_state == NLM_SL_BLOCKED &&
nslp->nsl_vp == vp &&
(nslp->nsl_lock.l_offset != 0 ||
nslp->nsl_lock.l_len != 0)) {
safe = 0;
break;
}
}
mutex_exit(&g->lock);
return (safe);
}
int
nlm_has_sleep(const vnode_t *vp)
{
struct nlm_globals *g;
struct nlm_slock *nslp;
int has_slocks = FALSE;
g = zone_getspecific(nlm_zone_key, curzone);
mutex_enter(&g->lock);
TAILQ_FOREACH(nslp, &g->nlm_slocks, nsl_link) {
if (nslp->nsl_state == NLM_SL_BLOCKED &&
nslp->nsl_vp == vp) {
has_slocks = TRUE;
break;
}
}
mutex_exit(&g->lock);
return (has_slocks);
}
void
nlm_register_lock_locally(struct vnode *vp, struct nlm_host *hostp,
struct flock64 *flk, int flags, u_offset_t offset)
{
int sysid = 0;
if (hostp == NULL) {
mntinfo_t *mi;
servinfo_t *sv;
const char *netid;
struct nlm_globals *g;
mi = VTOMI(vp);
sv = mi->mi_curr_serv;
netid = nlm_knc_to_netid(sv->sv_knconf);
if (netid != NULL) {
g = zone_getspecific(nlm_zone_key, curzone);
hostp = nlm_host_findcreate(g, sv->sv_hostname,
netid, &sv->sv_addr);
}
}
if (hostp != NULL) {
sysid = hostp->nh_sysid | LM_SYSID_CLIENT;
}
flk->l_sysid = sysid;
(void) convoff(vp, flk, 0, (offset_t)offset);
(void) nlm_local_setlk(vp, flk, flags);
}
/*
* The BSD code had functions here to "reclaim" (destroy)
* remote locks when a vnode is being forcibly destroyed.
* We just keep vnodes around until statd tells us the
* client has gone away.
*/
static int
nlm_reclaim_lock(struct nlm_host *hostp, vnode_t *vp,
struct flock64 *flp, int32_t orig_state)
{
struct netobj lm_fh;
int error, state;
rpcvers_t vers;
/*
* If the remote NSM state changes during recovery, the host
* must have rebooted a second time. In that case, we must
* restart the recovery.
*/
state = nlm_host_get_state(hostp);
if (state != orig_state)
return (ERESTART);
error = nlm_init_fh_by_vp(vp, &lm_fh, &vers);
if (error != 0)
return (error);
return (nlm_call_lock(vp, flp, hostp, &lm_fh,
NULL, vers, NLM_X_RECLAIM));
}
/*
* Get local lock information for some NFS server.
*
* This gets (checks for) a local conflicting lock.
* Note: Modifies passed flock, if a conflict is found,
* but the caller expects that.
*/
static int
nlm_local_getlk(vnode_t *vp, struct flock64 *fl, int flags)
{
VERIFY(fl->l_whence == SEEK_SET);
return (reclock(vp, fl, 0, flags, 0, NULL));
}
/*
* Set local lock information for some NFS server.
*
* Called after a lock request (set or clear) succeeded. We record the
* details in the local lock manager. Note that since the remote
* server has granted the lock, we can be sure that it doesn't
* conflict with any other locks we have in the local lock manager.
*
* Since it is possible that host may also make NLM client requests to
* our NLM server, we use a different sysid value to record our own
* client locks.
*
* Note that since it is possible for us to receive replies from the
* server in a different order than the locks were granted (e.g. if
* many local threads are contending for the same lock), we must use a
* blocking operation when registering with the local lock manager.
* We expect that any actual wait will be rare and short hence we
* ignore signals for this.
*/
static int
nlm_local_setlk(vnode_t *vp, struct flock64 *fl, int flags)
{
VERIFY(fl->l_whence == SEEK_SET);
return (reclock(vp, fl, SETFLCK, flags, 0, NULL));
}
/*
* Cancel local lock and send send SIGLOST signal
* to the lock owner.
*
* NOTE: modifies flp
*/
static void
nlm_local_cancelk(vnode_t *vp, struct flock64 *flp)
{
flp->l_type = F_UNLCK;
(void) nlm_local_setlk(vp, flp, FREAD | FWRITE);
nlm_send_siglost(flp->l_pid);
}
/*
* Do NLM_LOCK call.
* Was: nlm_setlock()
*
* NOTE: nlm_call_lock() function should care about locking/unlocking
* of rnode->r_lkserlock which should be released before nlm_call_lock()
* sleeps on waiting lock and acquired when it wakes up.
*/
static int
nlm_call_lock(vnode_t *vp, struct flock64 *flp,
struct nlm_host *hostp, struct netobj *fhp,
struct flk_callback *flcb, int vers, int xflags)
{
struct nlm4_lockargs args;
struct nlm_owner_handle oh;
struct nlm_globals *g;
rnode_t *rnp = VTOR(vp);
struct nlm_slock *nslp = NULL;
uint32_t xid;
int error = 0;
bzero(&args, sizeof (args));
g = zone_getspecific(nlm_zone_key, curzone);
nlm_init_lock(&args.alock, flp, fhp, &oh);
args.exclusive = (flp->l_type == F_WRLCK);
args.reclaim = xflags & NLM_X_RECLAIM;
args.state = g->nsm_state;
args.cookie.n_len = sizeof (xid);
args.cookie.n_bytes = (char *)&xid;
oh.oh_sysid = hostp->nh_sysid;
xid = atomic_inc_32_nv(&nlm_xid);
if (xflags & NLM_X_BLOCKING) {
args.block = TRUE;
nslp = nlm_slock_register(g, hostp, &args.alock, vp);
}
for (;;) {
nlm_rpc_t *rpcp;
enum clnt_stat stat;
struct nlm4_res res;
enum nlm4_stats nlm_err;
error = nlm_host_get_rpc(hostp, vers, &rpcp);
if (error != 0) {
error = ENOLCK;
goto out;
}
bzero(&res, sizeof (res));
stat = nlm_lock_rpc(&args, &res, rpcp->nr_handle, vers);
nlm_host_rele_rpc(hostp, rpcp);
error = nlm_map_clnt_stat(stat);
if (error != 0) {
if (error == EAGAIN)
continue;
goto out;
}
DTRACE_PROBE1(lock__res, enum nlm4_stats, res.stat.stat);
nlm_err = res.stat.stat;
xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res);
if (nlm_err == nlm4_denied_grace_period) {
if (args.reclaim) {
error = ENOLCK;
goto out;
}
error = nlm_host_wait_grace(hostp);
if (error != 0)
goto out;
continue;
}
switch (nlm_err) {
case nlm4_granted:
case nlm4_blocked:
error = 0;
break;
case nlm4_denied:
if (nslp != NULL) {
NLM_WARN("nlm_call_lock: got nlm4_denied for "
"blocking lock\n");
}
error = EAGAIN;
break;
default:
error = nlm_map_status(nlm_err);
}
/*
* If we deal with either non-blocking lock or
* with a blocking locks that wasn't blocked on
* the server side (by some reason), our work
* is finished.
*/
if (nslp == NULL ||
nlm_err != nlm4_blocked ||
error != 0)
goto out;
/*
* Before releasing the r_lkserlock of rnode, we should
* check whether the new lock is "safe". If it's not
* safe, disable caching for the given vnode. That is done
* for sleeping locks only that are waiting for a GRANT reply
* from the NLM server.
*
* NOTE: the vnode cache can be enabled back later if an
* unsafe lock will be merged with existent locks so that
* it will become safe. This condition is checked in the
* NFSv3 code (see nfs_lockcompletion).
*/
if (!NLM_FLOCK_IS_SAFE(flp)) {
mutex_enter(&vp->v_lock);
vp->v_flag &= ~VNOCACHE;
mutex_exit(&vp->v_lock);
}
/*
* The server should call us back with a
* granted message when the lock succeeds.
* In order to deal with broken servers,
* lost granted messages, or server reboots,
* we will also re-try every few seconds.
*
* Note: We're supposed to call these
* flk_invoke_callbacks when blocking.
* Take care on rnode->r_lkserlock, we should
* release it before going to sleep.
*/
(void) flk_invoke_callbacks(flcb, FLK_BEFORE_SLEEP);
nfs_rw_exit(&rnp->r_lkserlock);
error = nlm_slock_wait(g, nslp, g->retrans_tmo);
/*
* NFS expects that we return with rnode->r_lkserlock
* locked on write, lock it back.
*
* NOTE: nfs_rw_enter_sig() can be either interruptible
* or not. It depends on options of NFS mount. Here
* we're _always_ uninterruptible (independently of mount
* options), because nfs_frlock/nfs3_frlock expects that
* we return with rnode->r_lkserlock acquired. So we don't
* want our lock attempt to be interrupted by a signal.
*/
(void) nfs_rw_enter_sig(&rnp->r_lkserlock, RW_WRITER, 0);
(void) flk_invoke_callbacks(flcb, FLK_AFTER_SLEEP);
if (error == 0) {
break;
} else if (error == EINTR) {
/*
* We need to call the server to cancel our
* lock request.
*/
DTRACE_PROBE1(cancel__lock, int, error);
(void) nlm_call_cancel(&args, hostp, vers);
break;
} else {
/*
* Timeout happened, resend the lock request to
* the server. Well, we're a bit paranoid here,
* but keep in mind previous request could lost
* (especially with conectionless transport).
*/
ASSERT(error == ETIMEDOUT);
continue;
}
}
/*
* We could disable the vnode cache for the given _sleeping_
* (codition: nslp != NULL) lock if it was unsafe. Normally,
* nfs_lockcompletion() function can enable the vnode cache
* back if the lock becomes safe after activativation. But it
* will not happen if any error occurs on the locking path.
*
* Here we enable the vnode cache back if the error occurred
* and if there aren't any unsafe locks on the given vnode.
* Note that if error happened, sleeping lock was derigistered.
*/
if (error != 0 && nslp != NULL && nlm_safemap(vp)) {
mutex_enter(&vp->v_lock);
vp->v_flag |= VNOCACHE;
mutex_exit(&vp->v_lock);
}
out:
if (nslp != NULL)
nlm_slock_unregister(g, nslp);
return (error);
}
/*
* Do NLM_CANCEL call.
* Helper for nlm_call_lock() error recovery.
*/
static int
nlm_call_cancel(struct nlm4_lockargs *largs,
struct nlm_host *hostp, int vers)
{
nlm4_cancargs cargs;
uint32_t xid;
int error, retries;
bzero(&cargs, sizeof (cargs));
xid = atomic_inc_32_nv(&nlm_xid);
cargs.cookie.n_len = sizeof (xid);
cargs.cookie.n_bytes = (char *)&xid;
cargs.block = largs->block;
cargs.exclusive = largs->exclusive;
cargs.alock = largs->alock;
/*
* Unlike all other nlm_call_* functions, nlm_call_cancel
* doesn't spin forever until it gets reasonable response
* from NLM server. It makes limited number of retries and
* if server doesn't send a reasonable reply, it returns an
* error. It behaves like that because it's called from nlm_call_lock
* with blocked signals and thus it can not be interrupted from
* user space.
*/
for (retries = 0; retries < NLM_CANCEL_NRETRS; retries++) {
nlm_rpc_t *rpcp;
enum clnt_stat stat;
struct nlm4_res res;
error = nlm_host_get_rpc(hostp, vers, &rpcp);
if (error != 0)
return (ENOLCK);
bzero(&res, sizeof (res));
stat = nlm_cancel_rpc(&cargs, &res, rpcp->nr_handle, vers);
nlm_host_rele_rpc(hostp, rpcp);
DTRACE_PROBE1(cancel__rloop_end, enum clnt_stat, stat);
error = nlm_map_clnt_stat(stat);
if (error != 0) {
if (error == EAGAIN)
continue;
return (error);
}
DTRACE_PROBE1(cancel__res, enum nlm4_stats, res.stat.stat);
switch (res.stat.stat) {
/*
* There was nothing to cancel. We are going to go ahead
* and assume we got the lock.
*/
case nlm_denied:
/*
* The server has recently rebooted. Treat this as a
* successful cancellation.
*/
case nlm4_denied_grace_period:
/*
* We managed to cancel.
*/
case nlm4_granted:
error = 0;
break;
default:
/*
* Broken server implementation. Can't really do
* anything here.
*/
error = EIO;
break;
}
xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res);
break;
}
return (error);
}
/*
* Do NLM_UNLOCK call.
* Was: nlm_clearlock
*/
static int
nlm_call_unlock(struct flock64 *flp, struct nlm_host *hostp,
struct netobj *fhp, int vers)
{
struct nlm4_unlockargs args;
struct nlm_owner_handle oh;
enum nlm4_stats nlm_err;
uint32_t xid;
int error;
bzero(&args, sizeof (args));
nlm_init_lock(&args.alock, flp, fhp, &oh);
oh.oh_sysid = hostp->nh_sysid;
xid = atomic_inc_32_nv(&nlm_xid);
args.cookie.n_len = sizeof (xid);
args.cookie.n_bytes = (char *)&xid;
for (;;) {
nlm_rpc_t *rpcp;
struct nlm4_res res;
enum clnt_stat stat;
error = nlm_host_get_rpc(hostp, vers, &rpcp);
if (error != 0)
return (ENOLCK);
bzero(&res, sizeof (res));
stat = nlm_unlock_rpc(&args, &res, rpcp->nr_handle, vers);
nlm_host_rele_rpc(hostp, rpcp);
error = nlm_map_clnt_stat(stat);
if (error != 0) {
if (error == EAGAIN)
continue;
return (error);
}
DTRACE_PROBE1(unlock__res, enum nlm4_stats, res.stat.stat);
nlm_err = res.stat.stat;
xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res);
if (nlm_err == nlm4_denied_grace_period) {
error = nlm_host_wait_grace(hostp);
if (error != 0)
return (error);
continue;
}
break;
}
/* special cases */
switch (nlm_err) {
case nlm4_denied:
error = EINVAL;
break;
default:
error = nlm_map_status(nlm_err);
break;
}
return (error);
}
/*
* Do NLM_TEST call.
* Was: nlm_getlock()
*/
static int
nlm_call_test(struct flock64 *flp, struct nlm_host *hostp,
struct netobj *fhp, int vers)
{
struct nlm4_testargs args;
struct nlm4_holder h;
struct nlm_owner_handle oh;
enum nlm4_stats nlm_err;
uint32_t xid;
int error;
bzero(&args, sizeof (args));
nlm_init_lock(&args.alock, flp, fhp, &oh);
args.exclusive = (flp->l_type == F_WRLCK);
oh.oh_sysid = hostp->nh_sysid;
xid = atomic_inc_32_nv(&nlm_xid);
args.cookie.n_len = sizeof (xid);
args.cookie.n_bytes = (char *)&xid;
for (;;) {
nlm_rpc_t *rpcp;
struct nlm4_testres res;
enum clnt_stat stat;
error = nlm_host_get_rpc(hostp, vers, &rpcp);
if (error != 0)
return (ENOLCK);
bzero(&res, sizeof (res));
stat = nlm_test_rpc(&args, &res, rpcp->nr_handle, vers);
nlm_host_rele_rpc(hostp, rpcp);
error = nlm_map_clnt_stat(stat);
if (error != 0) {
if (error == EAGAIN)
continue;
return (error);
}
DTRACE_PROBE1(test__res, enum nlm4_stats, res.stat.stat);
nlm_err = res.stat.stat;
bcopy(&res.stat.nlm4_testrply_u.holder, &h, sizeof (h));
xdr_free((xdrproc_t)xdr_nlm4_testres, (void *)&res);
if (nlm_err == nlm4_denied_grace_period) {
error = nlm_host_wait_grace(hostp);
if (error != 0)
return (error);
continue;
}
break;
}
switch (nlm_err) {
case nlm4_granted:
flp->l_type = F_UNLCK;
error = 0;
break;
case nlm4_denied:
flp->l_start = h.l_offset;
flp->l_len = h.l_len;
flp->l_pid = h.svid;
flp->l_type = (h.exclusive) ? F_WRLCK : F_RDLCK;
flp->l_whence = SEEK_SET;
flp->l_sysid = 0;
error = 0;
break;
default:
error = nlm_map_status(nlm_err);
break;
}
return (error);
}
static void
nlm_init_lock(struct nlm4_lock *lock,
const struct flock64 *fl, struct netobj *fh,
struct nlm_owner_handle *oh)
{
/* Caller converts to zero-base. */
VERIFY(fl->l_whence == SEEK_SET);
bzero(lock, sizeof (*lock));
bzero(oh, sizeof (*oh));
lock->caller_name = uts_nodename();
lock->fh.n_len = fh->n_len;
lock->fh.n_bytes = fh->n_bytes;
lock->oh.n_len = sizeof (*oh);
lock->oh.n_bytes = (void *)oh;
lock->svid = fl->l_pid;
lock->l_offset = fl->l_start;
lock->l_len = fl->l_len;
}
/* ************************************************************** */
int
nlm_shrlock(struct vnode *vp, int cmd, struct shrlock *shr,
int flags, struct netobj *fh, int vers)
{
struct shrlock shlk;
mntinfo_t *mi;
servinfo_t *sv;
const char *netid;
struct nlm_host *host = NULL;
int error;
struct nlm_globals *g;
mi = VTOMI(vp);
sv = mi->mi_curr_serv;
netid = nlm_knc_to_netid(sv->sv_knconf);
if (netid == NULL) {
NLM_ERR("nlm_shrlock: unknown NFS netid\n");
return (ENOSYS);
}
g = zone_getspecific(nlm_zone_key, curzone);
host = nlm_host_findcreate(g, sv->sv_hostname, netid, &sv->sv_addr);
if (host == NULL)
return (ENOSYS);
/*
* Fill in s_sysid for the local locking calls.
* Also, let's not trust the caller's l_pid.
*/
shlk = *shr;
shlk.s_sysid = host->nh_sysid | LM_SYSID_CLIENT;
shlk.s_pid = curproc->p_pid;
if (cmd == F_UNSHARE) {
/*
* Purge local (cached) share information first,
* then clear the remote share.
*/
(void) nlm_local_shrlock(vp, &shlk, cmd, flags);
nlm_shres_untrack(host, vp, &shlk);
error = nlm_call_unshare(&shlk, host, fh, vers);
goto out;
}
nfs_add_locking_id(vp, curproc->p_pid, RLMPL_OWNER,
shr->s_owner, shr->s_own_len);
error = nlm_call_share(&shlk, host, fh, vers, FALSE);
if (error != 0)
goto out;
/*
* Save the share locally. This should not fail,
* because the server is authoritative about shares
* and it just told us we have the share reservation!
*/
error = nlm_local_shrlock(vp, shr, cmd, flags);
if (error != 0) {
/*
* Oh oh, we really don't expect an error here.
*/
NLM_WARN("nlm_shrlock: set locally, err %d\n", error);
error = 0;
}
nlm_shres_track(host, vp, &shlk);
nlm_host_monitor(g, host, 0);
out:
nlm_host_release(g, host);
return (error);
}
static int
nlm_reclaim_share(struct nlm_host *hostp, vnode_t *vp,
struct shrlock *shr, uint32_t orig_state)
{
struct netobj lm_fh;
int error, state;
rpcvers_t vers;
state = nlm_host_get_state(hostp);
if (state != orig_state) {
/*
* It seems that NLM server rebooted while
* we were busy with recovery.
*/
return (ERESTART);
}
error = nlm_init_fh_by_vp(vp, &lm_fh, &vers);
if (error != 0)
return (error);
return (nlm_call_share(shr, hostp, &lm_fh, vers, 1));
}
/*
* Set local share information for some NFS server.
*
* Called after a share request (set or clear) succeeded. We record
* the details in the local lock manager. Note that since the remote
* server has granted the share, we can be sure that it doesn't
* conflict with any other shares we have in the local lock manager.
*
* Since it is possible that host may also make NLM client requests to
* our NLM server, we use a different sysid value to record our own
* client shares.
*/
int
nlm_local_shrlock(vnode_t *vp, struct shrlock *shr, int cmd, int flags)
{
return (fs_shrlock(vp, cmd, shr, flags, CRED(), NULL));
}
static void
nlm_local_shrcancel(vnode_t *vp, struct shrlock *shr)
{
(void) nlm_local_shrlock(vp, shr, F_UNSHARE, FREAD | FWRITE);
nlm_send_siglost(shr->s_pid);
}
/*
* Do NLM_SHARE call.
* Was: nlm_setshare()
*/
static int
nlm_call_share(struct shrlock *shr, struct nlm_host *host,
struct netobj *fh, int vers, int reclaim)
{
struct nlm4_shareargs args;
enum nlm4_stats nlm_err;
uint32_t xid;
int error;
bzero(&args, sizeof (args));
nlm_init_share(&args.share, shr, fh);
args.reclaim = reclaim;
xid = atomic_inc_32_nv(&nlm_xid);
args.cookie.n_len = sizeof (xid);
args.cookie.n_bytes = (char *)&xid;
for (;;) {
nlm_rpc_t *rpcp;
struct nlm4_shareres res;
enum clnt_stat stat;
error = nlm_host_get_rpc(host, vers, &rpcp);
if (error != 0)
return (ENOLCK);
bzero(&res, sizeof (res));
stat = nlm_share_rpc(&args, &res, rpcp->nr_handle, vers);
nlm_host_rele_rpc(host, rpcp);
error = nlm_map_clnt_stat(stat);
if (error != 0) {
if (error == EAGAIN)
continue;
return (error);
}
DTRACE_PROBE1(share__res, enum nlm4_stats, res.stat);
nlm_err = res.stat;
xdr_free((xdrproc_t)xdr_nlm4_shareres, (void *)&res);
if (nlm_err == nlm4_denied_grace_period) {
if (args.reclaim)
return (ENOLCK);
error = nlm_host_wait_grace(host);
if (error != 0)
return (error);
continue;
}
break;
}
switch (nlm_err) {
case nlm4_granted:
error = 0;
break;
case nlm4_blocked:
case nlm4_denied:
error = EAGAIN;
break;
case nlm4_denied_nolocks:
case nlm4_deadlck:
error = ENOLCK;
break;
default:
error = EINVAL;
break;
}
return (error);
}
/*
* Do NLM_UNSHARE call.
*/
static int
nlm_call_unshare(struct shrlock *shr, struct nlm_host *host,
struct netobj *fh, int vers)
{
struct nlm4_shareargs args;
enum nlm4_stats nlm_err;
uint32_t xid;
int error;
bzero(&args, sizeof (args));
nlm_init_share(&args.share, shr, fh);
xid = atomic_inc_32_nv(&nlm_xid);
args.cookie.n_len = sizeof (xid);
args.cookie.n_bytes = (char *)&xid;
for (;;) {
nlm_rpc_t *rpcp;
struct nlm4_shareres res;
enum clnt_stat stat;
error = nlm_host_get_rpc(host, vers, &rpcp);
if (error != 0)
return (ENOLCK);
bzero(&res, sizeof (res));
stat = nlm_unshare_rpc(&args, &res, rpcp->nr_handle, vers);
nlm_host_rele_rpc(host, rpcp);
error = nlm_map_clnt_stat(stat);
if (error != 0) {
if (error == EAGAIN)
continue;
return (error);
}
DTRACE_PROBE1(unshare__res, enum nlm4_stats, res.stat);
nlm_err = res.stat;
xdr_free((xdrproc_t)xdr_nlm4_res, (void *)&res);
if (nlm_err == nlm4_denied_grace_period) {
error = nlm_host_wait_grace(host);
if (error != 0)
return (error);
continue;
}
break;
}
switch (nlm_err) {
case nlm4_granted:
error = 0;
break;
case nlm4_denied:
error = EAGAIN;
break;
case nlm4_denied_nolocks:
error = ENOLCK;
break;
default:
error = EINVAL;
break;
}
return (error);
}
static void
nlm_init_share(struct nlm4_share *args,
const struct shrlock *shr, struct netobj *fh)
{
bzero(args, sizeof (*args));
args->caller_name = uts_nodename();
args->fh.n_len = fh->n_len;
args->fh.n_bytes = fh->n_bytes;
args->oh.n_len = shr->s_own_len;
args->oh.n_bytes = (void *)shr->s_owner;
switch (shr->s_deny) {
default:
case F_NODNY:
args->mode = fsm_DN;
break;
case F_RDDNY:
args->mode = fsm_DR;
break;
case F_WRDNY:
args->mode = fsm_DW;
break;
case F_RWDNY:
args->mode = fsm_DRW;
break;
}
switch (shr->s_access) {
default:
case 0: /* seen with F_UNSHARE */
args->access = fsa_NONE;
break;
case F_RDACC:
args->access = fsa_R;
break;
case F_WRACC:
args->access = fsa_W;
break;
case F_RWACC:
args->access = fsa_RW;
break;
}
}
/*
* Initialize filehandle according to the version
* of NFS vnode was created on. The version of
* NLM that can be used with given NFS version
* is saved to lm_vers.
*/
static int
nlm_init_fh_by_vp(vnode_t *vp, struct netobj *fh, rpcvers_t *lm_vers)
{
mntinfo_t *mi = VTOMI(vp);
/*
* Too bad the NFS code doesn't just carry the FH
* in a netobj or a netbuf.
*/
switch (mi->mi_vers) {
case NFS_V3:
/* See nfs3_frlock() */
*lm_vers = NLM4_VERS;
fh->n_len = VTOFH3(vp)->fh3_length;
fh->n_bytes = (char *)&(VTOFH3(vp)->fh3_u.data);
break;
case NFS_VERSION:
/* See nfs_frlock() */
*lm_vers = NLM_VERS;
fh->n_len = sizeof (fhandle_t);
/* LINTED E_BAD_PTR_CAST_ALIGN */
fh->n_bytes = (char *)VTOFH(vp);
break;
default:
return (ENOSYS);
}
return (0);
}
/*
* Send SIGLOST to the process identified by pid.
* NOTE: called when NLM decides to remove lock
* or share reservation ownder by the process
* by force.
*/
static void
nlm_send_siglost(pid_t pid)
{
proc_t *p;
mutex_enter(&pidlock);
p = prfind(pid);
if (p != NULL)
psignal(p, SIGLOST);
mutex_exit(&pidlock);
}
static int
nlm_map_clnt_stat(enum clnt_stat stat)
{
switch (stat) {
case RPC_SUCCESS:
return (0);
case RPC_TIMEDOUT:
case RPC_PROGUNAVAIL:
return (EAGAIN);
case RPC_INTR:
return (EINTR);
default:
return (EINVAL);
}
}
static int
nlm_map_status(enum nlm4_stats stat)
{
switch (stat) {
case nlm4_granted:
return (0);
case nlm4_denied:
return (EAGAIN);
case nlm4_denied_nolocks:
return (ENOLCK);
case nlm4_blocked:
return (EAGAIN);
case nlm4_denied_grace_period:
return (EAGAIN);
case nlm4_deadlck:
return (EDEADLK);
case nlm4_rofs:
return (EROFS);
case nlm4_stale_fh:
return (ESTALE);
case nlm4_fbig:
return (EFBIG);
case nlm4_failed:
return (EACCES);
default:
return (EINVAL);
}
}