51369649b0
Mainly focus on files that use BSD 3-Clause license. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts. Special thanks to Wind River for providing access to "The Duke of Highlander" tool: an older (2014) run over FreeBSD tree was useful as a starting point.
2561 lines
65 KiB
C
2561 lines
65 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*
|
|
* 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 (c) 1982, 1986, 1989, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* Scooter Morris at Genentech Inc.
|
|
*
|
|
* 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.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
|
*
|
|
* @(#)ufs_lockf.c 8.3 (Berkeley) 1/6/94
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include "opt_debug_lockf.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/hash.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/limits.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/mutex.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/sx.h>
|
|
#include <sys/unistd.h>
|
|
#include <sys/vnode.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/fcntl.h>
|
|
#include <sys/lockf.h>
|
|
#include <sys/taskqueue.h>
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <ufs/ufs/extattr.h>
|
|
#include <ufs/ufs/quota.h>
|
|
#include <ufs/ufs/ufsmount.h>
|
|
#include <ufs/ufs/inode.h>
|
|
|
|
static int lockf_debug = 0; /* control debug output */
|
|
SYSCTL_INT(_debug, OID_AUTO, lockf_debug, CTLFLAG_RW, &lockf_debug, 0, "");
|
|
#endif
|
|
|
|
static MALLOC_DEFINE(M_LOCKF, "lockf", "Byte-range locking structures");
|
|
|
|
struct owner_edge;
|
|
struct owner_vertex;
|
|
struct owner_vertex_list;
|
|
struct owner_graph;
|
|
|
|
#define NOLOCKF (struct lockf_entry *)0
|
|
#define SELF 0x1
|
|
#define OTHERS 0x2
|
|
static void lf_init(void *);
|
|
static int lf_hash_owner(caddr_t, struct flock *, int);
|
|
static int lf_owner_matches(struct lock_owner *, caddr_t, struct flock *,
|
|
int);
|
|
static struct lockf_entry *
|
|
lf_alloc_lock(struct lock_owner *);
|
|
static int lf_free_lock(struct lockf_entry *);
|
|
static int lf_clearlock(struct lockf *, struct lockf_entry *);
|
|
static int lf_overlaps(struct lockf_entry *, struct lockf_entry *);
|
|
static int lf_blocks(struct lockf_entry *, struct lockf_entry *);
|
|
static void lf_free_edge(struct lockf_edge *);
|
|
static struct lockf_edge *
|
|
lf_alloc_edge(void);
|
|
static void lf_alloc_vertex(struct lockf_entry *);
|
|
static int lf_add_edge(struct lockf_entry *, struct lockf_entry *);
|
|
static void lf_remove_edge(struct lockf_edge *);
|
|
static void lf_remove_outgoing(struct lockf_entry *);
|
|
static void lf_remove_incoming(struct lockf_entry *);
|
|
static int lf_add_outgoing(struct lockf *, struct lockf_entry *);
|
|
static int lf_add_incoming(struct lockf *, struct lockf_entry *);
|
|
static int lf_findoverlap(struct lockf_entry **, struct lockf_entry *,
|
|
int);
|
|
static struct lockf_entry *
|
|
lf_getblock(struct lockf *, struct lockf_entry *);
|
|
static int lf_getlock(struct lockf *, struct lockf_entry *, struct flock *);
|
|
static void lf_insert_lock(struct lockf *, struct lockf_entry *);
|
|
static void lf_wakeup_lock(struct lockf *, struct lockf_entry *);
|
|
static void lf_update_dependancies(struct lockf *, struct lockf_entry *,
|
|
int all, struct lockf_entry_list *);
|
|
static void lf_set_start(struct lockf *, struct lockf_entry *, off_t,
|
|
struct lockf_entry_list*);
|
|
static void lf_set_end(struct lockf *, struct lockf_entry *, off_t,
|
|
struct lockf_entry_list*);
|
|
static int lf_setlock(struct lockf *, struct lockf_entry *,
|
|
struct vnode *, void **cookiep);
|
|
static int lf_cancel(struct lockf *, struct lockf_entry *, void *);
|
|
static void lf_split(struct lockf *, struct lockf_entry *,
|
|
struct lockf_entry *, struct lockf_entry_list *);
|
|
#ifdef LOCKF_DEBUG
|
|
static int graph_reaches(struct owner_vertex *x, struct owner_vertex *y,
|
|
struct owner_vertex_list *path);
|
|
static void graph_check(struct owner_graph *g, int checkorder);
|
|
static void graph_print_vertices(struct owner_vertex_list *set);
|
|
#endif
|
|
static int graph_delta_forward(struct owner_graph *g,
|
|
struct owner_vertex *x, struct owner_vertex *y,
|
|
struct owner_vertex_list *delta);
|
|
static int graph_delta_backward(struct owner_graph *g,
|
|
struct owner_vertex *x, struct owner_vertex *y,
|
|
struct owner_vertex_list *delta);
|
|
static int graph_add_indices(int *indices, int n,
|
|
struct owner_vertex_list *set);
|
|
static int graph_assign_indices(struct owner_graph *g, int *indices,
|
|
int nextunused, struct owner_vertex_list *set);
|
|
static int graph_add_edge(struct owner_graph *g,
|
|
struct owner_vertex *x, struct owner_vertex *y);
|
|
static void graph_remove_edge(struct owner_graph *g,
|
|
struct owner_vertex *x, struct owner_vertex *y);
|
|
static struct owner_vertex *graph_alloc_vertex(struct owner_graph *g,
|
|
struct lock_owner *lo);
|
|
static void graph_free_vertex(struct owner_graph *g,
|
|
struct owner_vertex *v);
|
|
static struct owner_graph * graph_init(struct owner_graph *g);
|
|
#ifdef LOCKF_DEBUG
|
|
static void lf_print(char *, struct lockf_entry *);
|
|
static void lf_printlist(char *, struct lockf_entry *);
|
|
static void lf_print_owner(struct lock_owner *);
|
|
#endif
|
|
|
|
/*
|
|
* This structure is used to keep track of both local and remote lock
|
|
* owners. The lf_owner field of the struct lockf_entry points back at
|
|
* the lock owner structure. Each possible lock owner (local proc for
|
|
* POSIX fcntl locks, local file for BSD flock locks or <pid,sysid>
|
|
* pair for remote locks) is represented by a unique instance of
|
|
* struct lock_owner.
|
|
*
|
|
* If a lock owner has a lock that blocks some other lock or a lock
|
|
* that is waiting for some other lock, it also has a vertex in the
|
|
* owner_graph below.
|
|
*
|
|
* Locks:
|
|
* (s) locked by state->ls_lock
|
|
* (S) locked by lf_lock_states_lock
|
|
* (l) locked by lf_lock_owners_lock
|
|
* (g) locked by lf_owner_graph_lock
|
|
* (c) const until freeing
|
|
*/
|
|
#define LOCK_OWNER_HASH_SIZE 256
|
|
|
|
struct lock_owner {
|
|
LIST_ENTRY(lock_owner) lo_link; /* (l) hash chain */
|
|
int lo_refs; /* (l) Number of locks referring to this */
|
|
int lo_flags; /* (c) Flags passwd to lf_advlock */
|
|
caddr_t lo_id; /* (c) Id value passed to lf_advlock */
|
|
pid_t lo_pid; /* (c) Process Id of the lock owner */
|
|
int lo_sysid; /* (c) System Id of the lock owner */
|
|
struct owner_vertex *lo_vertex; /* (g) entry in deadlock graph */
|
|
};
|
|
|
|
LIST_HEAD(lock_owner_list, lock_owner);
|
|
|
|
static struct sx lf_lock_states_lock;
|
|
static struct lockf_list lf_lock_states; /* (S) */
|
|
static struct sx lf_lock_owners_lock;
|
|
static struct lock_owner_list lf_lock_owners[LOCK_OWNER_HASH_SIZE]; /* (l) */
|
|
|
|
/*
|
|
* Structures for deadlock detection.
|
|
*
|
|
* We have two types of directed graph, the first is the set of locks,
|
|
* both active and pending on a vnode. Within this graph, active locks
|
|
* are terminal nodes in the graph (i.e. have no out-going
|
|
* edges). Pending locks have out-going edges to each blocking active
|
|
* lock that prevents the lock from being granted and also to each
|
|
* older pending lock that would block them if it was active. The
|
|
* graph for each vnode is naturally acyclic; new edges are only ever
|
|
* added to or from new nodes (either new pending locks which only add
|
|
* out-going edges or new active locks which only add in-coming edges)
|
|
* therefore they cannot create loops in the lock graph.
|
|
*
|
|
* The second graph is a global graph of lock owners. Each lock owner
|
|
* is a vertex in that graph and an edge is added to the graph
|
|
* whenever an edge is added to a vnode graph, with end points
|
|
* corresponding to owner of the new pending lock and the owner of the
|
|
* lock upon which it waits. In order to prevent deadlock, we only add
|
|
* an edge to this graph if the new edge would not create a cycle.
|
|
*
|
|
* The lock owner graph is topologically sorted, i.e. if a node has
|
|
* any outgoing edges, then it has an order strictly less than any
|
|
* node to which it has an outgoing edge. We preserve this ordering
|
|
* (and detect cycles) on edge insertion using Algorithm PK from the
|
|
* paper "A Dynamic Topological Sort Algorithm for Directed Acyclic
|
|
* Graphs" (ACM Journal of Experimental Algorithms, Vol 11, Article
|
|
* No. 1.7)
|
|
*/
|
|
struct owner_vertex;
|
|
|
|
struct owner_edge {
|
|
LIST_ENTRY(owner_edge) e_outlink; /* (g) link from's out-edge list */
|
|
LIST_ENTRY(owner_edge) e_inlink; /* (g) link to's in-edge list */
|
|
int e_refs; /* (g) number of times added */
|
|
struct owner_vertex *e_from; /* (c) out-going from here */
|
|
struct owner_vertex *e_to; /* (c) in-coming to here */
|
|
};
|
|
LIST_HEAD(owner_edge_list, owner_edge);
|
|
|
|
struct owner_vertex {
|
|
TAILQ_ENTRY(owner_vertex) v_link; /* (g) workspace for edge insertion */
|
|
uint32_t v_gen; /* (g) workspace for edge insertion */
|
|
int v_order; /* (g) order of vertex in graph */
|
|
struct owner_edge_list v_outedges;/* (g) list of out-edges */
|
|
struct owner_edge_list v_inedges; /* (g) list of in-edges */
|
|
struct lock_owner *v_owner; /* (c) corresponding lock owner */
|
|
};
|
|
TAILQ_HEAD(owner_vertex_list, owner_vertex);
|
|
|
|
struct owner_graph {
|
|
struct owner_vertex** g_vertices; /* (g) pointers to vertices */
|
|
int g_size; /* (g) number of vertices */
|
|
int g_space; /* (g) space allocated for vertices */
|
|
int *g_indexbuf; /* (g) workspace for loop detection */
|
|
uint32_t g_gen; /* (g) increment when re-ordering */
|
|
};
|
|
|
|
static struct sx lf_owner_graph_lock;
|
|
static struct owner_graph lf_owner_graph;
|
|
|
|
/*
|
|
* Initialise various structures and locks.
|
|
*/
|
|
static void
|
|
lf_init(void *dummy)
|
|
{
|
|
int i;
|
|
|
|
sx_init(&lf_lock_states_lock, "lock states lock");
|
|
LIST_INIT(&lf_lock_states);
|
|
|
|
sx_init(&lf_lock_owners_lock, "lock owners lock");
|
|
for (i = 0; i < LOCK_OWNER_HASH_SIZE; i++)
|
|
LIST_INIT(&lf_lock_owners[i]);
|
|
|
|
sx_init(&lf_owner_graph_lock, "owner graph lock");
|
|
graph_init(&lf_owner_graph);
|
|
}
|
|
SYSINIT(lf_init, SI_SUB_LOCK, SI_ORDER_FIRST, lf_init, NULL);
|
|
|
|
/*
|
|
* Generate a hash value for a lock owner.
|
|
*/
|
|
static int
|
|
lf_hash_owner(caddr_t id, struct flock *fl, int flags)
|
|
{
|
|
uint32_t h;
|
|
|
|
if (flags & F_REMOTE) {
|
|
h = HASHSTEP(0, fl->l_pid);
|
|
h = HASHSTEP(h, fl->l_sysid);
|
|
} else if (flags & F_FLOCK) {
|
|
h = ((uintptr_t) id) >> 7;
|
|
} else {
|
|
struct proc *p = (struct proc *) id;
|
|
h = HASHSTEP(0, p->p_pid);
|
|
h = HASHSTEP(h, 0);
|
|
}
|
|
|
|
return (h % LOCK_OWNER_HASH_SIZE);
|
|
}
|
|
|
|
/*
|
|
* Return true if a lock owner matches the details passed to
|
|
* lf_advlock.
|
|
*/
|
|
static int
|
|
lf_owner_matches(struct lock_owner *lo, caddr_t id, struct flock *fl,
|
|
int flags)
|
|
{
|
|
if (flags & F_REMOTE) {
|
|
return lo->lo_pid == fl->l_pid
|
|
&& lo->lo_sysid == fl->l_sysid;
|
|
} else {
|
|
return lo->lo_id == id;
|
|
}
|
|
}
|
|
|
|
static struct lockf_entry *
|
|
lf_alloc_lock(struct lock_owner *lo)
|
|
{
|
|
struct lockf_entry *lf;
|
|
|
|
lf = malloc(sizeof(struct lockf_entry), M_LOCKF, M_WAITOK|M_ZERO);
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 4)
|
|
printf("Allocated lock %p\n", lf);
|
|
#endif
|
|
if (lo) {
|
|
sx_xlock(&lf_lock_owners_lock);
|
|
lo->lo_refs++;
|
|
sx_xunlock(&lf_lock_owners_lock);
|
|
lf->lf_owner = lo;
|
|
}
|
|
|
|
return (lf);
|
|
}
|
|
|
|
static int
|
|
lf_free_lock(struct lockf_entry *lock)
|
|
{
|
|
|
|
KASSERT(lock->lf_refs > 0, ("lockf_entry negative ref count %p", lock));
|
|
if (--lock->lf_refs > 0)
|
|
return (0);
|
|
/*
|
|
* Adjust the lock_owner reference count and
|
|
* reclaim the entry if this is the last lock
|
|
* for that owner.
|
|
*/
|
|
struct lock_owner *lo = lock->lf_owner;
|
|
if (lo) {
|
|
KASSERT(LIST_EMPTY(&lock->lf_outedges),
|
|
("freeing lock with dependencies"));
|
|
KASSERT(LIST_EMPTY(&lock->lf_inedges),
|
|
("freeing lock with dependants"));
|
|
sx_xlock(&lf_lock_owners_lock);
|
|
KASSERT(lo->lo_refs > 0, ("lock owner refcount"));
|
|
lo->lo_refs--;
|
|
if (lo->lo_refs == 0) {
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1)
|
|
printf("lf_free_lock: freeing lock owner %p\n",
|
|
lo);
|
|
#endif
|
|
if (lo->lo_vertex) {
|
|
sx_xlock(&lf_owner_graph_lock);
|
|
graph_free_vertex(&lf_owner_graph,
|
|
lo->lo_vertex);
|
|
sx_xunlock(&lf_owner_graph_lock);
|
|
}
|
|
LIST_REMOVE(lo, lo_link);
|
|
free(lo, M_LOCKF);
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 4)
|
|
printf("Freed lock owner %p\n", lo);
|
|
#endif
|
|
}
|
|
sx_unlock(&lf_lock_owners_lock);
|
|
}
|
|
if ((lock->lf_flags & F_REMOTE) && lock->lf_vnode) {
|
|
vrele(lock->lf_vnode);
|
|
lock->lf_vnode = NULL;
|
|
}
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 4)
|
|
printf("Freed lock %p\n", lock);
|
|
#endif
|
|
free(lock, M_LOCKF);
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Advisory record locking support
|
|
*/
|
|
int
|
|
lf_advlockasync(struct vop_advlockasync_args *ap, struct lockf **statep,
|
|
u_quad_t size)
|
|
{
|
|
struct lockf *state, *freestate = NULL;
|
|
struct flock *fl = ap->a_fl;
|
|
struct lockf_entry *lock;
|
|
struct vnode *vp = ap->a_vp;
|
|
caddr_t id = ap->a_id;
|
|
int flags = ap->a_flags;
|
|
int hash;
|
|
struct lock_owner *lo;
|
|
off_t start, end, oadd;
|
|
int error;
|
|
|
|
/*
|
|
* Handle the F_UNLKSYS case first - no need to mess about
|
|
* creating a lock owner for this one.
|
|
*/
|
|
if (ap->a_op == F_UNLCKSYS) {
|
|
lf_clearremotesys(fl->l_sysid);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Convert the flock structure into a start and end.
|
|
*/
|
|
switch (fl->l_whence) {
|
|
|
|
case SEEK_SET:
|
|
case SEEK_CUR:
|
|
/*
|
|
* Caller is responsible for adding any necessary offset
|
|
* when SEEK_CUR is used.
|
|
*/
|
|
start = fl->l_start;
|
|
break;
|
|
|
|
case SEEK_END:
|
|
if (size > OFF_MAX ||
|
|
(fl->l_start > 0 && size > OFF_MAX - fl->l_start))
|
|
return (EOVERFLOW);
|
|
start = size + fl->l_start;
|
|
break;
|
|
|
|
default:
|
|
return (EINVAL);
|
|
}
|
|
if (start < 0)
|
|
return (EINVAL);
|
|
if (fl->l_len < 0) {
|
|
if (start == 0)
|
|
return (EINVAL);
|
|
end = start - 1;
|
|
start += fl->l_len;
|
|
if (start < 0)
|
|
return (EINVAL);
|
|
} else if (fl->l_len == 0) {
|
|
end = OFF_MAX;
|
|
} else {
|
|
oadd = fl->l_len - 1;
|
|
if (oadd > OFF_MAX - start)
|
|
return (EOVERFLOW);
|
|
end = start + oadd;
|
|
}
|
|
|
|
retry_setlock:
|
|
|
|
/*
|
|
* Avoid the common case of unlocking when inode has no locks.
|
|
*/
|
|
VI_LOCK(vp);
|
|
if ((*statep) == NULL) {
|
|
if (ap->a_op != F_SETLK) {
|
|
fl->l_type = F_UNLCK;
|
|
VI_UNLOCK(vp);
|
|
return (0);
|
|
}
|
|
}
|
|
VI_UNLOCK(vp);
|
|
|
|
/*
|
|
* Map our arguments to an existing lock owner or create one
|
|
* if this is the first time we have seen this owner.
|
|
*/
|
|
hash = lf_hash_owner(id, fl, flags);
|
|
sx_xlock(&lf_lock_owners_lock);
|
|
LIST_FOREACH(lo, &lf_lock_owners[hash], lo_link)
|
|
if (lf_owner_matches(lo, id, fl, flags))
|
|
break;
|
|
if (!lo) {
|
|
/*
|
|
* We initialise the lock with a reference
|
|
* count which matches the new lockf_entry
|
|
* structure created below.
|
|
*/
|
|
lo = malloc(sizeof(struct lock_owner), M_LOCKF,
|
|
M_WAITOK|M_ZERO);
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 4)
|
|
printf("Allocated lock owner %p\n", lo);
|
|
#endif
|
|
|
|
lo->lo_refs = 1;
|
|
lo->lo_flags = flags;
|
|
lo->lo_id = id;
|
|
if (flags & F_REMOTE) {
|
|
lo->lo_pid = fl->l_pid;
|
|
lo->lo_sysid = fl->l_sysid;
|
|
} else if (flags & F_FLOCK) {
|
|
lo->lo_pid = -1;
|
|
lo->lo_sysid = 0;
|
|
} else {
|
|
struct proc *p = (struct proc *) id;
|
|
lo->lo_pid = p->p_pid;
|
|
lo->lo_sysid = 0;
|
|
}
|
|
lo->lo_vertex = NULL;
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1) {
|
|
printf("lf_advlockasync: new lock owner %p ", lo);
|
|
lf_print_owner(lo);
|
|
printf("\n");
|
|
}
|
|
#endif
|
|
|
|
LIST_INSERT_HEAD(&lf_lock_owners[hash], lo, lo_link);
|
|
} else {
|
|
/*
|
|
* We have seen this lock owner before, increase its
|
|
* reference count to account for the new lockf_entry
|
|
* structure we create below.
|
|
*/
|
|
lo->lo_refs++;
|
|
}
|
|
sx_xunlock(&lf_lock_owners_lock);
|
|
|
|
/*
|
|
* Create the lockf structure. We initialise the lf_owner
|
|
* field here instead of in lf_alloc_lock() to avoid paying
|
|
* the lf_lock_owners_lock tax twice.
|
|
*/
|
|
lock = lf_alloc_lock(NULL);
|
|
lock->lf_refs = 1;
|
|
lock->lf_start = start;
|
|
lock->lf_end = end;
|
|
lock->lf_owner = lo;
|
|
lock->lf_vnode = vp;
|
|
if (flags & F_REMOTE) {
|
|
/*
|
|
* For remote locks, the caller may release its ref to
|
|
* the vnode at any time - we have to ref it here to
|
|
* prevent it from being recycled unexpectedly.
|
|
*/
|
|
vref(vp);
|
|
}
|
|
|
|
/*
|
|
* XXX The problem is that VTOI is ufs specific, so it will
|
|
* break LOCKF_DEBUG for all other FS's other than UFS because
|
|
* it casts the vnode->data ptr to struct inode *.
|
|
*/
|
|
/* lock->lf_inode = VTOI(ap->a_vp); */
|
|
lock->lf_inode = (struct inode *)0;
|
|
lock->lf_type = fl->l_type;
|
|
LIST_INIT(&lock->lf_outedges);
|
|
LIST_INIT(&lock->lf_inedges);
|
|
lock->lf_async_task = ap->a_task;
|
|
lock->lf_flags = ap->a_flags;
|
|
|
|
/*
|
|
* Do the requested operation. First find our state structure
|
|
* and create a new one if necessary - the caller's *statep
|
|
* variable and the state's ls_threads count is protected by
|
|
* the vnode interlock.
|
|
*/
|
|
VI_LOCK(vp);
|
|
if (vp->v_iflag & VI_DOOMED) {
|
|
VI_UNLOCK(vp);
|
|
lf_free_lock(lock);
|
|
return (ENOENT);
|
|
}
|
|
|
|
/*
|
|
* Allocate a state structure if necessary.
|
|
*/
|
|
state = *statep;
|
|
if (state == NULL) {
|
|
struct lockf *ls;
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
ls = malloc(sizeof(struct lockf), M_LOCKF, M_WAITOK|M_ZERO);
|
|
sx_init(&ls->ls_lock, "ls_lock");
|
|
LIST_INIT(&ls->ls_active);
|
|
LIST_INIT(&ls->ls_pending);
|
|
ls->ls_threads = 1;
|
|
|
|
sx_xlock(&lf_lock_states_lock);
|
|
LIST_INSERT_HEAD(&lf_lock_states, ls, ls_link);
|
|
sx_xunlock(&lf_lock_states_lock);
|
|
|
|
/*
|
|
* Cope if we lost a race with some other thread while
|
|
* trying to allocate memory.
|
|
*/
|
|
VI_LOCK(vp);
|
|
if (vp->v_iflag & VI_DOOMED) {
|
|
VI_UNLOCK(vp);
|
|
sx_xlock(&lf_lock_states_lock);
|
|
LIST_REMOVE(ls, ls_link);
|
|
sx_xunlock(&lf_lock_states_lock);
|
|
sx_destroy(&ls->ls_lock);
|
|
free(ls, M_LOCKF);
|
|
lf_free_lock(lock);
|
|
return (ENOENT);
|
|
}
|
|
if ((*statep) == NULL) {
|
|
state = *statep = ls;
|
|
VI_UNLOCK(vp);
|
|
} else {
|
|
state = *statep;
|
|
state->ls_threads++;
|
|
VI_UNLOCK(vp);
|
|
|
|
sx_xlock(&lf_lock_states_lock);
|
|
LIST_REMOVE(ls, ls_link);
|
|
sx_xunlock(&lf_lock_states_lock);
|
|
sx_destroy(&ls->ls_lock);
|
|
free(ls, M_LOCKF);
|
|
}
|
|
} else {
|
|
state->ls_threads++;
|
|
VI_UNLOCK(vp);
|
|
}
|
|
|
|
sx_xlock(&state->ls_lock);
|
|
/*
|
|
* Recheck the doomed vnode after state->ls_lock is
|
|
* locked. lf_purgelocks() requires that no new threads add
|
|
* pending locks when vnode is marked by VI_DOOMED flag.
|
|
*/
|
|
VI_LOCK(vp);
|
|
if (vp->v_iflag & VI_DOOMED) {
|
|
state->ls_threads--;
|
|
wakeup(state);
|
|
VI_UNLOCK(vp);
|
|
sx_xunlock(&state->ls_lock);
|
|
lf_free_lock(lock);
|
|
return (ENOENT);
|
|
}
|
|
VI_UNLOCK(vp);
|
|
|
|
switch (ap->a_op) {
|
|
case F_SETLK:
|
|
error = lf_setlock(state, lock, vp, ap->a_cookiep);
|
|
break;
|
|
|
|
case F_UNLCK:
|
|
error = lf_clearlock(state, lock);
|
|
lf_free_lock(lock);
|
|
break;
|
|
|
|
case F_GETLK:
|
|
error = lf_getlock(state, lock, fl);
|
|
lf_free_lock(lock);
|
|
break;
|
|
|
|
case F_CANCEL:
|
|
if (ap->a_cookiep)
|
|
error = lf_cancel(state, lock, *ap->a_cookiep);
|
|
else
|
|
error = EINVAL;
|
|
lf_free_lock(lock);
|
|
break;
|
|
|
|
default:
|
|
lf_free_lock(lock);
|
|
error = EINVAL;
|
|
break;
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
/*
|
|
* Check for some can't happen stuff. In this case, the active
|
|
* lock list becoming disordered or containing mutually
|
|
* blocking locks. We also check the pending list for locks
|
|
* which should be active (i.e. have no out-going edges).
|
|
*/
|
|
LIST_FOREACH(lock, &state->ls_active, lf_link) {
|
|
struct lockf_entry *lf;
|
|
if (LIST_NEXT(lock, lf_link))
|
|
KASSERT((lock->lf_start
|
|
<= LIST_NEXT(lock, lf_link)->lf_start),
|
|
("locks disordered"));
|
|
LIST_FOREACH(lf, &state->ls_active, lf_link) {
|
|
if (lock == lf)
|
|
break;
|
|
KASSERT(!lf_blocks(lock, lf),
|
|
("two conflicting active locks"));
|
|
if (lock->lf_owner == lf->lf_owner)
|
|
KASSERT(!lf_overlaps(lock, lf),
|
|
("two overlapping locks from same owner"));
|
|
}
|
|
}
|
|
LIST_FOREACH(lock, &state->ls_pending, lf_link) {
|
|
KASSERT(!LIST_EMPTY(&lock->lf_outedges),
|
|
("pending lock which should be active"));
|
|
}
|
|
#endif
|
|
sx_xunlock(&state->ls_lock);
|
|
|
|
/*
|
|
* If we have removed the last active lock on the vnode and
|
|
* this is the last thread that was in-progress, we can free
|
|
* the state structure. We update the caller's pointer inside
|
|
* the vnode interlock but call free outside.
|
|
*
|
|
* XXX alternatively, keep the state structure around until
|
|
* the filesystem recycles - requires a callback from the
|
|
* filesystem.
|
|
*/
|
|
VI_LOCK(vp);
|
|
|
|
state->ls_threads--;
|
|
wakeup(state);
|
|
if (LIST_EMPTY(&state->ls_active) && state->ls_threads == 0) {
|
|
KASSERT(LIST_EMPTY(&state->ls_pending),
|
|
("freeing state with pending locks"));
|
|
freestate = state;
|
|
*statep = NULL;
|
|
}
|
|
|
|
VI_UNLOCK(vp);
|
|
|
|
if (freestate != NULL) {
|
|
sx_xlock(&lf_lock_states_lock);
|
|
LIST_REMOVE(freestate, ls_link);
|
|
sx_xunlock(&lf_lock_states_lock);
|
|
sx_destroy(&freestate->ls_lock);
|
|
free(freestate, M_LOCKF);
|
|
freestate = NULL;
|
|
}
|
|
|
|
if (error == EDOOFUS) {
|
|
KASSERT(ap->a_op == F_SETLK, ("EDOOFUS"));
|
|
goto retry_setlock;
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
int
|
|
lf_advlock(struct vop_advlock_args *ap, struct lockf **statep, u_quad_t size)
|
|
{
|
|
struct vop_advlockasync_args a;
|
|
|
|
a.a_vp = ap->a_vp;
|
|
a.a_id = ap->a_id;
|
|
a.a_op = ap->a_op;
|
|
a.a_fl = ap->a_fl;
|
|
a.a_flags = ap->a_flags;
|
|
a.a_task = NULL;
|
|
a.a_cookiep = NULL;
|
|
|
|
return (lf_advlockasync(&a, statep, size));
|
|
}
|
|
|
|
void
|
|
lf_purgelocks(struct vnode *vp, struct lockf **statep)
|
|
{
|
|
struct lockf *state;
|
|
struct lockf_entry *lock, *nlock;
|
|
|
|
/*
|
|
* For this to work correctly, the caller must ensure that no
|
|
* other threads enter the locking system for this vnode,
|
|
* e.g. by checking VI_DOOMED. We wake up any threads that are
|
|
* sleeping waiting for locks on this vnode and then free all
|
|
* the remaining locks.
|
|
*/
|
|
VI_LOCK(vp);
|
|
KASSERT(vp->v_iflag & VI_DOOMED,
|
|
("lf_purgelocks: vp %p has not vgone yet", vp));
|
|
state = *statep;
|
|
if (state) {
|
|
*statep = NULL;
|
|
state->ls_threads++;
|
|
VI_UNLOCK(vp);
|
|
|
|
sx_xlock(&state->ls_lock);
|
|
sx_xlock(&lf_owner_graph_lock);
|
|
LIST_FOREACH_SAFE(lock, &state->ls_pending, lf_link, nlock) {
|
|
LIST_REMOVE(lock, lf_link);
|
|
lf_remove_outgoing(lock);
|
|
lf_remove_incoming(lock);
|
|
|
|
/*
|
|
* If its an async lock, we can just free it
|
|
* here, otherwise we let the sleeping thread
|
|
* free it.
|
|
*/
|
|
if (lock->lf_async_task) {
|
|
lf_free_lock(lock);
|
|
} else {
|
|
lock->lf_flags |= F_INTR;
|
|
wakeup(lock);
|
|
}
|
|
}
|
|
sx_xunlock(&lf_owner_graph_lock);
|
|
sx_xunlock(&state->ls_lock);
|
|
|
|
/*
|
|
* Wait for all other threads, sleeping and otherwise
|
|
* to leave.
|
|
*/
|
|
VI_LOCK(vp);
|
|
while (state->ls_threads > 1)
|
|
msleep(state, VI_MTX(vp), 0, "purgelocks", 0);
|
|
VI_UNLOCK(vp);
|
|
|
|
/*
|
|
* We can just free all the active locks since they
|
|
* will have no dependencies (we removed them all
|
|
* above). We don't need to bother locking since we
|
|
* are the last thread using this state structure.
|
|
*/
|
|
KASSERT(LIST_EMPTY(&state->ls_pending),
|
|
("lock pending for %p", state));
|
|
LIST_FOREACH_SAFE(lock, &state->ls_active, lf_link, nlock) {
|
|
LIST_REMOVE(lock, lf_link);
|
|
lf_free_lock(lock);
|
|
}
|
|
sx_xlock(&lf_lock_states_lock);
|
|
LIST_REMOVE(state, ls_link);
|
|
sx_xunlock(&lf_lock_states_lock);
|
|
sx_destroy(&state->ls_lock);
|
|
free(state, M_LOCKF);
|
|
} else {
|
|
VI_UNLOCK(vp);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Return non-zero if locks 'x' and 'y' overlap.
|
|
*/
|
|
static int
|
|
lf_overlaps(struct lockf_entry *x, struct lockf_entry *y)
|
|
{
|
|
|
|
return (x->lf_start <= y->lf_end && x->lf_end >= y->lf_start);
|
|
}
|
|
|
|
/*
|
|
* Return non-zero if lock 'x' is blocked by lock 'y' (or vice versa).
|
|
*/
|
|
static int
|
|
lf_blocks(struct lockf_entry *x, struct lockf_entry *y)
|
|
{
|
|
|
|
return x->lf_owner != y->lf_owner
|
|
&& (x->lf_type == F_WRLCK || y->lf_type == F_WRLCK)
|
|
&& lf_overlaps(x, y);
|
|
}
|
|
|
|
/*
|
|
* Allocate a lock edge from the free list
|
|
*/
|
|
static struct lockf_edge *
|
|
lf_alloc_edge(void)
|
|
{
|
|
|
|
return (malloc(sizeof(struct lockf_edge), M_LOCKF, M_WAITOK|M_ZERO));
|
|
}
|
|
|
|
/*
|
|
* Free a lock edge.
|
|
*/
|
|
static void
|
|
lf_free_edge(struct lockf_edge *e)
|
|
{
|
|
|
|
free(e, M_LOCKF);
|
|
}
|
|
|
|
|
|
/*
|
|
* Ensure that the lock's owner has a corresponding vertex in the
|
|
* owner graph.
|
|
*/
|
|
static void
|
|
lf_alloc_vertex(struct lockf_entry *lock)
|
|
{
|
|
struct owner_graph *g = &lf_owner_graph;
|
|
|
|
if (!lock->lf_owner->lo_vertex)
|
|
lock->lf_owner->lo_vertex =
|
|
graph_alloc_vertex(g, lock->lf_owner);
|
|
}
|
|
|
|
/*
|
|
* Attempt to record an edge from lock x to lock y. Return EDEADLK if
|
|
* the new edge would cause a cycle in the owner graph.
|
|
*/
|
|
static int
|
|
lf_add_edge(struct lockf_entry *x, struct lockf_entry *y)
|
|
{
|
|
struct owner_graph *g = &lf_owner_graph;
|
|
struct lockf_edge *e;
|
|
int error;
|
|
|
|
#ifdef DIAGNOSTIC
|
|
LIST_FOREACH(e, &x->lf_outedges, le_outlink)
|
|
KASSERT(e->le_to != y, ("adding lock edge twice"));
|
|
#endif
|
|
|
|
/*
|
|
* Make sure the two owners have entries in the owner graph.
|
|
*/
|
|
lf_alloc_vertex(x);
|
|
lf_alloc_vertex(y);
|
|
|
|
error = graph_add_edge(g, x->lf_owner->lo_vertex,
|
|
y->lf_owner->lo_vertex);
|
|
if (error)
|
|
return (error);
|
|
|
|
e = lf_alloc_edge();
|
|
LIST_INSERT_HEAD(&x->lf_outedges, e, le_outlink);
|
|
LIST_INSERT_HEAD(&y->lf_inedges, e, le_inlink);
|
|
e->le_from = x;
|
|
e->le_to = y;
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Remove an edge from the lock graph.
|
|
*/
|
|
static void
|
|
lf_remove_edge(struct lockf_edge *e)
|
|
{
|
|
struct owner_graph *g = &lf_owner_graph;
|
|
struct lockf_entry *x = e->le_from;
|
|
struct lockf_entry *y = e->le_to;
|
|
|
|
graph_remove_edge(g, x->lf_owner->lo_vertex, y->lf_owner->lo_vertex);
|
|
LIST_REMOVE(e, le_outlink);
|
|
LIST_REMOVE(e, le_inlink);
|
|
e->le_from = NULL;
|
|
e->le_to = NULL;
|
|
lf_free_edge(e);
|
|
}
|
|
|
|
/*
|
|
* Remove all out-going edges from lock x.
|
|
*/
|
|
static void
|
|
lf_remove_outgoing(struct lockf_entry *x)
|
|
{
|
|
struct lockf_edge *e;
|
|
|
|
while ((e = LIST_FIRST(&x->lf_outedges)) != NULL) {
|
|
lf_remove_edge(e);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Remove all in-coming edges from lock x.
|
|
*/
|
|
static void
|
|
lf_remove_incoming(struct lockf_entry *x)
|
|
{
|
|
struct lockf_edge *e;
|
|
|
|
while ((e = LIST_FIRST(&x->lf_inedges)) != NULL) {
|
|
lf_remove_edge(e);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Walk the list of locks for the file and create an out-going edge
|
|
* from lock to each blocking lock.
|
|
*/
|
|
static int
|
|
lf_add_outgoing(struct lockf *state, struct lockf_entry *lock)
|
|
{
|
|
struct lockf_entry *overlap;
|
|
int error;
|
|
|
|
LIST_FOREACH(overlap, &state->ls_active, lf_link) {
|
|
/*
|
|
* We may assume that the active list is sorted by
|
|
* lf_start.
|
|
*/
|
|
if (overlap->lf_start > lock->lf_end)
|
|
break;
|
|
if (!lf_blocks(lock, overlap))
|
|
continue;
|
|
|
|
/*
|
|
* We've found a blocking lock. Add the corresponding
|
|
* edge to the graphs and see if it would cause a
|
|
* deadlock.
|
|
*/
|
|
error = lf_add_edge(lock, overlap);
|
|
|
|
/*
|
|
* The only error that lf_add_edge returns is EDEADLK.
|
|
* Remove any edges we added and return the error.
|
|
*/
|
|
if (error) {
|
|
lf_remove_outgoing(lock);
|
|
return (error);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We also need to add edges to sleeping locks that block
|
|
* us. This ensures that lf_wakeup_lock cannot grant two
|
|
* mutually blocking locks simultaneously and also enforces a
|
|
* 'first come, first served' fairness model. Note that this
|
|
* only happens if we are blocked by at least one active lock
|
|
* due to the call to lf_getblock in lf_setlock below.
|
|
*/
|
|
LIST_FOREACH(overlap, &state->ls_pending, lf_link) {
|
|
if (!lf_blocks(lock, overlap))
|
|
continue;
|
|
/*
|
|
* We've found a blocking lock. Add the corresponding
|
|
* edge to the graphs and see if it would cause a
|
|
* deadlock.
|
|
*/
|
|
error = lf_add_edge(lock, overlap);
|
|
|
|
/*
|
|
* The only error that lf_add_edge returns is EDEADLK.
|
|
* Remove any edges we added and return the error.
|
|
*/
|
|
if (error) {
|
|
lf_remove_outgoing(lock);
|
|
return (error);
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Walk the list of pending locks for the file and create an in-coming
|
|
* edge from lock to each blocking lock.
|
|
*/
|
|
static int
|
|
lf_add_incoming(struct lockf *state, struct lockf_entry *lock)
|
|
{
|
|
struct lockf_entry *overlap;
|
|
int error;
|
|
|
|
LIST_FOREACH(overlap, &state->ls_pending, lf_link) {
|
|
if (!lf_blocks(lock, overlap))
|
|
continue;
|
|
|
|
/*
|
|
* We've found a blocking lock. Add the corresponding
|
|
* edge to the graphs and see if it would cause a
|
|
* deadlock.
|
|
*/
|
|
error = lf_add_edge(overlap, lock);
|
|
|
|
/*
|
|
* The only error that lf_add_edge returns is EDEADLK.
|
|
* Remove any edges we added and return the error.
|
|
*/
|
|
if (error) {
|
|
lf_remove_incoming(lock);
|
|
return (error);
|
|
}
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Insert lock into the active list, keeping list entries ordered by
|
|
* increasing values of lf_start.
|
|
*/
|
|
static void
|
|
lf_insert_lock(struct lockf *state, struct lockf_entry *lock)
|
|
{
|
|
struct lockf_entry *lf, *lfprev;
|
|
|
|
if (LIST_EMPTY(&state->ls_active)) {
|
|
LIST_INSERT_HEAD(&state->ls_active, lock, lf_link);
|
|
return;
|
|
}
|
|
|
|
lfprev = NULL;
|
|
LIST_FOREACH(lf, &state->ls_active, lf_link) {
|
|
if (lf->lf_start > lock->lf_start) {
|
|
LIST_INSERT_BEFORE(lf, lock, lf_link);
|
|
return;
|
|
}
|
|
lfprev = lf;
|
|
}
|
|
LIST_INSERT_AFTER(lfprev, lock, lf_link);
|
|
}
|
|
|
|
/*
|
|
* Wake up a sleeping lock and remove it from the pending list now
|
|
* that all its dependencies have been resolved. The caller should
|
|
* arrange for the lock to be added to the active list, adjusting any
|
|
* existing locks for the same owner as needed.
|
|
*/
|
|
static void
|
|
lf_wakeup_lock(struct lockf *state, struct lockf_entry *wakelock)
|
|
{
|
|
|
|
/*
|
|
* Remove from ls_pending list and wake up the caller
|
|
* or start the async notification, as appropriate.
|
|
*/
|
|
LIST_REMOVE(wakelock, lf_link);
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1)
|
|
lf_print("lf_wakeup_lock: awakening", wakelock);
|
|
#endif /* LOCKF_DEBUG */
|
|
if (wakelock->lf_async_task) {
|
|
taskqueue_enqueue(taskqueue_thread, wakelock->lf_async_task);
|
|
} else {
|
|
wakeup(wakelock);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Re-check all dependent locks and remove edges to locks that we no
|
|
* longer block. If 'all' is non-zero, the lock has been removed and
|
|
* we must remove all the dependencies, otherwise it has simply been
|
|
* reduced but remains active. Any pending locks which have been been
|
|
* unblocked are added to 'granted'
|
|
*/
|
|
static void
|
|
lf_update_dependancies(struct lockf *state, struct lockf_entry *lock, int all,
|
|
struct lockf_entry_list *granted)
|
|
{
|
|
struct lockf_edge *e, *ne;
|
|
struct lockf_entry *deplock;
|
|
|
|
LIST_FOREACH_SAFE(e, &lock->lf_inedges, le_inlink, ne) {
|
|
deplock = e->le_from;
|
|
if (all || !lf_blocks(lock, deplock)) {
|
|
sx_xlock(&lf_owner_graph_lock);
|
|
lf_remove_edge(e);
|
|
sx_xunlock(&lf_owner_graph_lock);
|
|
if (LIST_EMPTY(&deplock->lf_outedges)) {
|
|
lf_wakeup_lock(state, deplock);
|
|
LIST_INSERT_HEAD(granted, deplock, lf_link);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set the start of an existing active lock, updating dependencies and
|
|
* adding any newly woken locks to 'granted'.
|
|
*/
|
|
static void
|
|
lf_set_start(struct lockf *state, struct lockf_entry *lock, off_t new_start,
|
|
struct lockf_entry_list *granted)
|
|
{
|
|
|
|
KASSERT(new_start >= lock->lf_start, ("can't increase lock"));
|
|
lock->lf_start = new_start;
|
|
LIST_REMOVE(lock, lf_link);
|
|
lf_insert_lock(state, lock);
|
|
lf_update_dependancies(state, lock, FALSE, granted);
|
|
}
|
|
|
|
/*
|
|
* Set the end of an existing active lock, updating dependencies and
|
|
* adding any newly woken locks to 'granted'.
|
|
*/
|
|
static void
|
|
lf_set_end(struct lockf *state, struct lockf_entry *lock, off_t new_end,
|
|
struct lockf_entry_list *granted)
|
|
{
|
|
|
|
KASSERT(new_end <= lock->lf_end, ("can't increase lock"));
|
|
lock->lf_end = new_end;
|
|
lf_update_dependancies(state, lock, FALSE, granted);
|
|
}
|
|
|
|
/*
|
|
* Add a lock to the active list, updating or removing any current
|
|
* locks owned by the same owner and processing any pending locks that
|
|
* become unblocked as a result. This code is also used for unlock
|
|
* since the logic for updating existing locks is identical.
|
|
*
|
|
* As a result of processing the new lock, we may unblock existing
|
|
* pending locks as a result of downgrading/unlocking. We simply
|
|
* activate the newly granted locks by looping.
|
|
*
|
|
* Since the new lock already has its dependencies set up, we always
|
|
* add it to the list (unless its an unlock request). This may
|
|
* fragment the lock list in some pathological cases but its probably
|
|
* not a real problem.
|
|
*/
|
|
static void
|
|
lf_activate_lock(struct lockf *state, struct lockf_entry *lock)
|
|
{
|
|
struct lockf_entry *overlap, *lf;
|
|
struct lockf_entry_list granted;
|
|
int ovcase;
|
|
|
|
LIST_INIT(&granted);
|
|
LIST_INSERT_HEAD(&granted, lock, lf_link);
|
|
|
|
while (!LIST_EMPTY(&granted)) {
|
|
lock = LIST_FIRST(&granted);
|
|
LIST_REMOVE(lock, lf_link);
|
|
|
|
/*
|
|
* Skip over locks owned by other processes. Handle
|
|
* any locks that overlap and are owned by ourselves.
|
|
*/
|
|
overlap = LIST_FIRST(&state->ls_active);
|
|
for (;;) {
|
|
ovcase = lf_findoverlap(&overlap, lock, SELF);
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (ovcase && (lockf_debug & 2)) {
|
|
printf("lf_setlock: overlap %d", ovcase);
|
|
lf_print("", overlap);
|
|
}
|
|
#endif
|
|
/*
|
|
* Six cases:
|
|
* 0) no overlap
|
|
* 1) overlap == lock
|
|
* 2) overlap contains lock
|
|
* 3) lock contains overlap
|
|
* 4) overlap starts before lock
|
|
* 5) overlap ends after lock
|
|
*/
|
|
switch (ovcase) {
|
|
case 0: /* no overlap */
|
|
break;
|
|
|
|
case 1: /* overlap == lock */
|
|
/*
|
|
* We have already setup the
|
|
* dependants for the new lock, taking
|
|
* into account a possible downgrade
|
|
* or unlock. Remove the old lock.
|
|
*/
|
|
LIST_REMOVE(overlap, lf_link);
|
|
lf_update_dependancies(state, overlap, TRUE,
|
|
&granted);
|
|
lf_free_lock(overlap);
|
|
break;
|
|
|
|
case 2: /* overlap contains lock */
|
|
/*
|
|
* Just split the existing lock.
|
|
*/
|
|
lf_split(state, overlap, lock, &granted);
|
|
break;
|
|
|
|
case 3: /* lock contains overlap */
|
|
/*
|
|
* Delete the overlap and advance to
|
|
* the next entry in the list.
|
|
*/
|
|
lf = LIST_NEXT(overlap, lf_link);
|
|
LIST_REMOVE(overlap, lf_link);
|
|
lf_update_dependancies(state, overlap, TRUE,
|
|
&granted);
|
|
lf_free_lock(overlap);
|
|
overlap = lf;
|
|
continue;
|
|
|
|
case 4: /* overlap starts before lock */
|
|
/*
|
|
* Just update the overlap end and
|
|
* move on.
|
|
*/
|
|
lf_set_end(state, overlap, lock->lf_start - 1,
|
|
&granted);
|
|
overlap = LIST_NEXT(overlap, lf_link);
|
|
continue;
|
|
|
|
case 5: /* overlap ends after lock */
|
|
/*
|
|
* Change the start of overlap and
|
|
* re-insert.
|
|
*/
|
|
lf_set_start(state, overlap, lock->lf_end + 1,
|
|
&granted);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1) {
|
|
if (lock->lf_type != F_UNLCK)
|
|
lf_print("lf_activate_lock: activated", lock);
|
|
else
|
|
lf_print("lf_activate_lock: unlocked", lock);
|
|
lf_printlist("lf_activate_lock", lock);
|
|
}
|
|
#endif /* LOCKF_DEBUG */
|
|
if (lock->lf_type != F_UNLCK)
|
|
lf_insert_lock(state, lock);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Cancel a pending lock request, either as a result of a signal or a
|
|
* cancel request for an async lock.
|
|
*/
|
|
static void
|
|
lf_cancel_lock(struct lockf *state, struct lockf_entry *lock)
|
|
{
|
|
struct lockf_entry_list granted;
|
|
|
|
/*
|
|
* Note it is theoretically possible that cancelling this lock
|
|
* may allow some other pending lock to become
|
|
* active. Consider this case:
|
|
*
|
|
* Owner Action Result Dependencies
|
|
*
|
|
* A: lock [0..0] succeeds
|
|
* B: lock [2..2] succeeds
|
|
* C: lock [1..2] blocked C->B
|
|
* D: lock [0..1] blocked C->B,D->A,D->C
|
|
* A: unlock [0..0] C->B,D->C
|
|
* C: cancel [1..2]
|
|
*/
|
|
|
|
LIST_REMOVE(lock, lf_link);
|
|
|
|
/*
|
|
* Removing out-going edges is simple.
|
|
*/
|
|
sx_xlock(&lf_owner_graph_lock);
|
|
lf_remove_outgoing(lock);
|
|
sx_xunlock(&lf_owner_graph_lock);
|
|
|
|
/*
|
|
* Removing in-coming edges may allow some other lock to
|
|
* become active - we use lf_update_dependancies to figure
|
|
* this out.
|
|
*/
|
|
LIST_INIT(&granted);
|
|
lf_update_dependancies(state, lock, TRUE, &granted);
|
|
lf_free_lock(lock);
|
|
|
|
/*
|
|
* Feed any newly active locks to lf_activate_lock.
|
|
*/
|
|
while (!LIST_EMPTY(&granted)) {
|
|
lock = LIST_FIRST(&granted);
|
|
LIST_REMOVE(lock, lf_link);
|
|
lf_activate_lock(state, lock);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set a byte-range lock.
|
|
*/
|
|
static int
|
|
lf_setlock(struct lockf *state, struct lockf_entry *lock, struct vnode *vp,
|
|
void **cookiep)
|
|
{
|
|
static char lockstr[] = "lockf";
|
|
int error, priority, stops_deferred;
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1)
|
|
lf_print("lf_setlock", lock);
|
|
#endif /* LOCKF_DEBUG */
|
|
|
|
/*
|
|
* Set the priority
|
|
*/
|
|
priority = PLOCK;
|
|
if (lock->lf_type == F_WRLCK)
|
|
priority += 4;
|
|
if (!(lock->lf_flags & F_NOINTR))
|
|
priority |= PCATCH;
|
|
/*
|
|
* Scan lock list for this file looking for locks that would block us.
|
|
*/
|
|
if (lf_getblock(state, lock)) {
|
|
/*
|
|
* Free the structure and return if nonblocking.
|
|
*/
|
|
if ((lock->lf_flags & F_WAIT) == 0
|
|
&& lock->lf_async_task == NULL) {
|
|
lf_free_lock(lock);
|
|
error = EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* For flock type locks, we must first remove
|
|
* any shared locks that we hold before we sleep
|
|
* waiting for an exclusive lock.
|
|
*/
|
|
if ((lock->lf_flags & F_FLOCK) &&
|
|
lock->lf_type == F_WRLCK) {
|
|
lock->lf_type = F_UNLCK;
|
|
lf_activate_lock(state, lock);
|
|
lock->lf_type = F_WRLCK;
|
|
}
|
|
|
|
/*
|
|
* We are blocked. Create edges to each blocking lock,
|
|
* checking for deadlock using the owner graph. For
|
|
* simplicity, we run deadlock detection for all
|
|
* locks, posix and otherwise.
|
|
*/
|
|
sx_xlock(&lf_owner_graph_lock);
|
|
error = lf_add_outgoing(state, lock);
|
|
sx_xunlock(&lf_owner_graph_lock);
|
|
|
|
if (error) {
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1)
|
|
lf_print("lf_setlock: deadlock", lock);
|
|
#endif
|
|
lf_free_lock(lock);
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* We have added edges to everything that blocks
|
|
* us. Sleep until they all go away.
|
|
*/
|
|
LIST_INSERT_HEAD(&state->ls_pending, lock, lf_link);
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1) {
|
|
struct lockf_edge *e;
|
|
LIST_FOREACH(e, &lock->lf_outedges, le_outlink) {
|
|
lf_print("lf_setlock: blocking on", e->le_to);
|
|
lf_printlist("lf_setlock", e->le_to);
|
|
}
|
|
}
|
|
#endif /* LOCKF_DEBUG */
|
|
|
|
if ((lock->lf_flags & F_WAIT) == 0) {
|
|
/*
|
|
* The caller requested async notification -
|
|
* this callback happens when the blocking
|
|
* lock is released, allowing the caller to
|
|
* make another attempt to take the lock.
|
|
*/
|
|
*cookiep = (void *) lock;
|
|
error = EINPROGRESS;
|
|
goto out;
|
|
}
|
|
|
|
lock->lf_refs++;
|
|
stops_deferred = sigdeferstop(SIGDEFERSTOP_ERESTART);
|
|
error = sx_sleep(lock, &state->ls_lock, priority, lockstr, 0);
|
|
sigallowstop(stops_deferred);
|
|
if (lf_free_lock(lock)) {
|
|
error = EDOOFUS;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* We may have been awakened by a signal and/or by a
|
|
* debugger continuing us (in which cases we must
|
|
* remove our lock graph edges) and/or by another
|
|
* process releasing a lock (in which case our edges
|
|
* have already been removed and we have been moved to
|
|
* the active list). We may also have been woken by
|
|
* lf_purgelocks which we report to the caller as
|
|
* EINTR. In that case, lf_purgelocks will have
|
|
* removed our lock graph edges.
|
|
*
|
|
* Note that it is possible to receive a signal after
|
|
* we were successfully woken (and moved to the active
|
|
* list) but before we resumed execution. In this
|
|
* case, our lf_outedges list will be clear. We
|
|
* pretend there was no error.
|
|
*
|
|
* Note also, if we have been sleeping long enough, we
|
|
* may now have incoming edges from some newer lock
|
|
* which is waiting behind us in the queue.
|
|
*/
|
|
if (lock->lf_flags & F_INTR) {
|
|
error = EINTR;
|
|
lf_free_lock(lock);
|
|
goto out;
|
|
}
|
|
if (LIST_EMPTY(&lock->lf_outedges)) {
|
|
error = 0;
|
|
} else {
|
|
lf_cancel_lock(state, lock);
|
|
goto out;
|
|
}
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1) {
|
|
lf_print("lf_setlock: granted", lock);
|
|
}
|
|
#endif
|
|
goto out;
|
|
}
|
|
/*
|
|
* It looks like we are going to grant the lock. First add
|
|
* edges from any currently pending lock that the new lock
|
|
* would block.
|
|
*/
|
|
sx_xlock(&lf_owner_graph_lock);
|
|
error = lf_add_incoming(state, lock);
|
|
sx_xunlock(&lf_owner_graph_lock);
|
|
if (error) {
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1)
|
|
lf_print("lf_setlock: deadlock", lock);
|
|
#endif
|
|
lf_free_lock(lock);
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* No blocks!! Add the lock. Note that we will
|
|
* downgrade or upgrade any overlapping locks this
|
|
* process already owns.
|
|
*/
|
|
lf_activate_lock(state, lock);
|
|
error = 0;
|
|
out:
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Remove a byte-range lock on an inode.
|
|
*
|
|
* Generally, find the lock (or an overlap to that lock)
|
|
* and remove it (or shrink it), then wakeup anyone we can.
|
|
*/
|
|
static int
|
|
lf_clearlock(struct lockf *state, struct lockf_entry *unlock)
|
|
{
|
|
struct lockf_entry *overlap;
|
|
|
|
overlap = LIST_FIRST(&state->ls_active);
|
|
|
|
if (overlap == NOLOCKF)
|
|
return (0);
|
|
#ifdef LOCKF_DEBUG
|
|
if (unlock->lf_type != F_UNLCK)
|
|
panic("lf_clearlock: bad type");
|
|
if (lockf_debug & 1)
|
|
lf_print("lf_clearlock", unlock);
|
|
#endif /* LOCKF_DEBUG */
|
|
|
|
lf_activate_lock(state, unlock);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Check whether there is a blocking lock, and if so return its
|
|
* details in '*fl'.
|
|
*/
|
|
static int
|
|
lf_getlock(struct lockf *state, struct lockf_entry *lock, struct flock *fl)
|
|
{
|
|
struct lockf_entry *block;
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 1)
|
|
lf_print("lf_getlock", lock);
|
|
#endif /* LOCKF_DEBUG */
|
|
|
|
if ((block = lf_getblock(state, lock))) {
|
|
fl->l_type = block->lf_type;
|
|
fl->l_whence = SEEK_SET;
|
|
fl->l_start = block->lf_start;
|
|
if (block->lf_end == OFF_MAX)
|
|
fl->l_len = 0;
|
|
else
|
|
fl->l_len = block->lf_end - block->lf_start + 1;
|
|
fl->l_pid = block->lf_owner->lo_pid;
|
|
fl->l_sysid = block->lf_owner->lo_sysid;
|
|
} else {
|
|
fl->l_type = F_UNLCK;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Cancel an async lock request.
|
|
*/
|
|
static int
|
|
lf_cancel(struct lockf *state, struct lockf_entry *lock, void *cookie)
|
|
{
|
|
struct lockf_entry *reallock;
|
|
|
|
/*
|
|
* We need to match this request with an existing lock
|
|
* request.
|
|
*/
|
|
LIST_FOREACH(reallock, &state->ls_pending, lf_link) {
|
|
if ((void *) reallock == cookie) {
|
|
/*
|
|
* Double-check that this lock looks right
|
|
* (maybe use a rolling ID for the cancel
|
|
* cookie instead?)
|
|
*/
|
|
if (!(reallock->lf_vnode == lock->lf_vnode
|
|
&& reallock->lf_start == lock->lf_start
|
|
&& reallock->lf_end == lock->lf_end)) {
|
|
return (ENOENT);
|
|
}
|
|
|
|
/*
|
|
* Make sure this lock was async and then just
|
|
* remove it from its wait lists.
|
|
*/
|
|
if (!reallock->lf_async_task) {
|
|
return (ENOENT);
|
|
}
|
|
|
|
/*
|
|
* Note that since any other thread must take
|
|
* state->ls_lock before it can possibly
|
|
* trigger the async callback, we are safe
|
|
* from a race with lf_wakeup_lock, i.e. we
|
|
* can free the lock (actually our caller does
|
|
* this).
|
|
*/
|
|
lf_cancel_lock(state, reallock);
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We didn't find a matching lock - not much we can do here.
|
|
*/
|
|
return (ENOENT);
|
|
}
|
|
|
|
/*
|
|
* Walk the list of locks for an inode and
|
|
* return the first blocking lock.
|
|
*/
|
|
static struct lockf_entry *
|
|
lf_getblock(struct lockf *state, struct lockf_entry *lock)
|
|
{
|
|
struct lockf_entry *overlap;
|
|
|
|
LIST_FOREACH(overlap, &state->ls_active, lf_link) {
|
|
/*
|
|
* We may assume that the active list is sorted by
|
|
* lf_start.
|
|
*/
|
|
if (overlap->lf_start > lock->lf_end)
|
|
break;
|
|
if (!lf_blocks(lock, overlap))
|
|
continue;
|
|
return (overlap);
|
|
}
|
|
return (NOLOCKF);
|
|
}
|
|
|
|
/*
|
|
* Walk the list of locks for an inode to find an overlapping lock (if
|
|
* any) and return a classification of that overlap.
|
|
*
|
|
* Arguments:
|
|
* *overlap The place in the lock list to start looking
|
|
* lock The lock which is being tested
|
|
* type Pass 'SELF' to test only locks with the same
|
|
* owner as lock, or 'OTHER' to test only locks
|
|
* with a different owner
|
|
*
|
|
* Returns one of six values:
|
|
* 0) no overlap
|
|
* 1) overlap == lock
|
|
* 2) overlap contains lock
|
|
* 3) lock contains overlap
|
|
* 4) overlap starts before lock
|
|
* 5) overlap ends after lock
|
|
*
|
|
* If there is an overlapping lock, '*overlap' is set to point at the
|
|
* overlapping lock.
|
|
*
|
|
* NOTE: this returns only the FIRST overlapping lock. There
|
|
* may be more than one.
|
|
*/
|
|
static int
|
|
lf_findoverlap(struct lockf_entry **overlap, struct lockf_entry *lock, int type)
|
|
{
|
|
struct lockf_entry *lf;
|
|
off_t start, end;
|
|
int res;
|
|
|
|
if ((*overlap) == NOLOCKF) {
|
|
return (0);
|
|
}
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 2)
|
|
lf_print("lf_findoverlap: looking for overlap in", lock);
|
|
#endif /* LOCKF_DEBUG */
|
|
start = lock->lf_start;
|
|
end = lock->lf_end;
|
|
res = 0;
|
|
while (*overlap) {
|
|
lf = *overlap;
|
|
if (lf->lf_start > end)
|
|
break;
|
|
if (((type & SELF) && lf->lf_owner != lock->lf_owner) ||
|
|
((type & OTHERS) && lf->lf_owner == lock->lf_owner)) {
|
|
*overlap = LIST_NEXT(lf, lf_link);
|
|
continue;
|
|
}
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 2)
|
|
lf_print("\tchecking", lf);
|
|
#endif /* LOCKF_DEBUG */
|
|
/*
|
|
* OK, check for overlap
|
|
*
|
|
* Six cases:
|
|
* 0) no overlap
|
|
* 1) overlap == lock
|
|
* 2) overlap contains lock
|
|
* 3) lock contains overlap
|
|
* 4) overlap starts before lock
|
|
* 5) overlap ends after lock
|
|
*/
|
|
if (start > lf->lf_end) {
|
|
/* Case 0 */
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 2)
|
|
printf("no overlap\n");
|
|
#endif /* LOCKF_DEBUG */
|
|
*overlap = LIST_NEXT(lf, lf_link);
|
|
continue;
|
|
}
|
|
if (lf->lf_start == start && lf->lf_end == end) {
|
|
/* Case 1 */
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 2)
|
|
printf("overlap == lock\n");
|
|
#endif /* LOCKF_DEBUG */
|
|
res = 1;
|
|
break;
|
|
}
|
|
if (lf->lf_start <= start && lf->lf_end >= end) {
|
|
/* Case 2 */
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 2)
|
|
printf("overlap contains lock\n");
|
|
#endif /* LOCKF_DEBUG */
|
|
res = 2;
|
|
break;
|
|
}
|
|
if (start <= lf->lf_start && end >= lf->lf_end) {
|
|
/* Case 3 */
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 2)
|
|
printf("lock contains overlap\n");
|
|
#endif /* LOCKF_DEBUG */
|
|
res = 3;
|
|
break;
|
|
}
|
|
if (lf->lf_start < start && lf->lf_end >= start) {
|
|
/* Case 4 */
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 2)
|
|
printf("overlap starts before lock\n");
|
|
#endif /* LOCKF_DEBUG */
|
|
res = 4;
|
|
break;
|
|
}
|
|
if (lf->lf_start > start && lf->lf_end > end) {
|
|
/* Case 5 */
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 2)
|
|
printf("overlap ends after lock\n");
|
|
#endif /* LOCKF_DEBUG */
|
|
res = 5;
|
|
break;
|
|
}
|
|
panic("lf_findoverlap: default");
|
|
}
|
|
return (res);
|
|
}
|
|
|
|
/*
|
|
* Split an the existing 'lock1', based on the extent of the lock
|
|
* described by 'lock2'. The existing lock should cover 'lock2'
|
|
* entirely.
|
|
*
|
|
* Any pending locks which have been been unblocked are added to
|
|
* 'granted'
|
|
*/
|
|
static void
|
|
lf_split(struct lockf *state, struct lockf_entry *lock1,
|
|
struct lockf_entry *lock2, struct lockf_entry_list *granted)
|
|
{
|
|
struct lockf_entry *splitlock;
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 2) {
|
|
lf_print("lf_split", lock1);
|
|
lf_print("splitting from", lock2);
|
|
}
|
|
#endif /* LOCKF_DEBUG */
|
|
/*
|
|
* Check to see if we don't need to split at all.
|
|
*/
|
|
if (lock1->lf_start == lock2->lf_start) {
|
|
lf_set_start(state, lock1, lock2->lf_end + 1, granted);
|
|
return;
|
|
}
|
|
if (lock1->lf_end == lock2->lf_end) {
|
|
lf_set_end(state, lock1, lock2->lf_start - 1, granted);
|
|
return;
|
|
}
|
|
/*
|
|
* Make a new lock consisting of the last part of
|
|
* the encompassing lock.
|
|
*/
|
|
splitlock = lf_alloc_lock(lock1->lf_owner);
|
|
memcpy(splitlock, lock1, sizeof *splitlock);
|
|
splitlock->lf_refs = 1;
|
|
if (splitlock->lf_flags & F_REMOTE)
|
|
vref(splitlock->lf_vnode);
|
|
|
|
/*
|
|
* This cannot cause a deadlock since any edges we would add
|
|
* to splitlock already exist in lock1. We must be sure to add
|
|
* necessary dependencies to splitlock before we reduce lock1
|
|
* otherwise we may accidentally grant a pending lock that
|
|
* was blocked by the tail end of lock1.
|
|
*/
|
|
splitlock->lf_start = lock2->lf_end + 1;
|
|
LIST_INIT(&splitlock->lf_outedges);
|
|
LIST_INIT(&splitlock->lf_inedges);
|
|
sx_xlock(&lf_owner_graph_lock);
|
|
lf_add_incoming(state, splitlock);
|
|
sx_xunlock(&lf_owner_graph_lock);
|
|
|
|
lf_set_end(state, lock1, lock2->lf_start - 1, granted);
|
|
|
|
/*
|
|
* OK, now link it in
|
|
*/
|
|
lf_insert_lock(state, splitlock);
|
|
}
|
|
|
|
struct lockdesc {
|
|
STAILQ_ENTRY(lockdesc) link;
|
|
struct vnode *vp;
|
|
struct flock fl;
|
|
};
|
|
STAILQ_HEAD(lockdesclist, lockdesc);
|
|
|
|
int
|
|
lf_iteratelocks_sysid(int sysid, lf_iterator *fn, void *arg)
|
|
{
|
|
struct lockf *ls;
|
|
struct lockf_entry *lf;
|
|
struct lockdesc *ldesc;
|
|
struct lockdesclist locks;
|
|
int error;
|
|
|
|
/*
|
|
* In order to keep the locking simple, we iterate over the
|
|
* active lock lists to build a list of locks that need
|
|
* releasing. We then call the iterator for each one in turn.
|
|
*
|
|
* We take an extra reference to the vnode for the duration to
|
|
* make sure it doesn't go away before we are finished.
|
|
*/
|
|
STAILQ_INIT(&locks);
|
|
sx_xlock(&lf_lock_states_lock);
|
|
LIST_FOREACH(ls, &lf_lock_states, ls_link) {
|
|
sx_xlock(&ls->ls_lock);
|
|
LIST_FOREACH(lf, &ls->ls_active, lf_link) {
|
|
if (lf->lf_owner->lo_sysid != sysid)
|
|
continue;
|
|
|
|
ldesc = malloc(sizeof(struct lockdesc), M_LOCKF,
|
|
M_WAITOK);
|
|
ldesc->vp = lf->lf_vnode;
|
|
vref(ldesc->vp);
|
|
ldesc->fl.l_start = lf->lf_start;
|
|
if (lf->lf_end == OFF_MAX)
|
|
ldesc->fl.l_len = 0;
|
|
else
|
|
ldesc->fl.l_len =
|
|
lf->lf_end - lf->lf_start + 1;
|
|
ldesc->fl.l_whence = SEEK_SET;
|
|
ldesc->fl.l_type = F_UNLCK;
|
|
ldesc->fl.l_pid = lf->lf_owner->lo_pid;
|
|
ldesc->fl.l_sysid = sysid;
|
|
STAILQ_INSERT_TAIL(&locks, ldesc, link);
|
|
}
|
|
sx_xunlock(&ls->ls_lock);
|
|
}
|
|
sx_xunlock(&lf_lock_states_lock);
|
|
|
|
/*
|
|
* Call the iterator function for each lock in turn. If the
|
|
* iterator returns an error code, just free the rest of the
|
|
* lockdesc structures.
|
|
*/
|
|
error = 0;
|
|
while ((ldesc = STAILQ_FIRST(&locks)) != NULL) {
|
|
STAILQ_REMOVE_HEAD(&locks, link);
|
|
if (!error)
|
|
error = fn(ldesc->vp, &ldesc->fl, arg);
|
|
vrele(ldesc->vp);
|
|
free(ldesc, M_LOCKF);
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
|
|
int
|
|
lf_iteratelocks_vnode(struct vnode *vp, lf_iterator *fn, void *arg)
|
|
{
|
|
struct lockf *ls;
|
|
struct lockf_entry *lf;
|
|
struct lockdesc *ldesc;
|
|
struct lockdesclist locks;
|
|
int error;
|
|
|
|
/*
|
|
* In order to keep the locking simple, we iterate over the
|
|
* active lock lists to build a list of locks that need
|
|
* releasing. We then call the iterator for each one in turn.
|
|
*
|
|
* We take an extra reference to the vnode for the duration to
|
|
* make sure it doesn't go away before we are finished.
|
|
*/
|
|
STAILQ_INIT(&locks);
|
|
VI_LOCK(vp);
|
|
ls = vp->v_lockf;
|
|
if (!ls) {
|
|
VI_UNLOCK(vp);
|
|
return (0);
|
|
}
|
|
ls->ls_threads++;
|
|
VI_UNLOCK(vp);
|
|
|
|
sx_xlock(&ls->ls_lock);
|
|
LIST_FOREACH(lf, &ls->ls_active, lf_link) {
|
|
ldesc = malloc(sizeof(struct lockdesc), M_LOCKF,
|
|
M_WAITOK);
|
|
ldesc->vp = lf->lf_vnode;
|
|
vref(ldesc->vp);
|
|
ldesc->fl.l_start = lf->lf_start;
|
|
if (lf->lf_end == OFF_MAX)
|
|
ldesc->fl.l_len = 0;
|
|
else
|
|
ldesc->fl.l_len =
|
|
lf->lf_end - lf->lf_start + 1;
|
|
ldesc->fl.l_whence = SEEK_SET;
|
|
ldesc->fl.l_type = F_UNLCK;
|
|
ldesc->fl.l_pid = lf->lf_owner->lo_pid;
|
|
ldesc->fl.l_sysid = lf->lf_owner->lo_sysid;
|
|
STAILQ_INSERT_TAIL(&locks, ldesc, link);
|
|
}
|
|
sx_xunlock(&ls->ls_lock);
|
|
VI_LOCK(vp);
|
|
ls->ls_threads--;
|
|
wakeup(ls);
|
|
VI_UNLOCK(vp);
|
|
|
|
/*
|
|
* Call the iterator function for each lock in turn. If the
|
|
* iterator returns an error code, just free the rest of the
|
|
* lockdesc structures.
|
|
*/
|
|
error = 0;
|
|
while ((ldesc = STAILQ_FIRST(&locks)) != NULL) {
|
|
STAILQ_REMOVE_HEAD(&locks, link);
|
|
if (!error)
|
|
error = fn(ldesc->vp, &ldesc->fl, arg);
|
|
vrele(ldesc->vp);
|
|
free(ldesc, M_LOCKF);
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
|
|
static int
|
|
lf_clearremotesys_iterator(struct vnode *vp, struct flock *fl, void *arg)
|
|
{
|
|
|
|
VOP_ADVLOCK(vp, 0, F_UNLCK, fl, F_REMOTE);
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
lf_clearremotesys(int sysid)
|
|
{
|
|
|
|
KASSERT(sysid != 0, ("Can't clear local locks with F_UNLCKSYS"));
|
|
lf_iteratelocks_sysid(sysid, lf_clearremotesys_iterator, NULL);
|
|
}
|
|
|
|
int
|
|
lf_countlocks(int sysid)
|
|
{
|
|
int i;
|
|
struct lock_owner *lo;
|
|
int count;
|
|
|
|
count = 0;
|
|
sx_xlock(&lf_lock_owners_lock);
|
|
for (i = 0; i < LOCK_OWNER_HASH_SIZE; i++)
|
|
LIST_FOREACH(lo, &lf_lock_owners[i], lo_link)
|
|
if (lo->lo_sysid == sysid)
|
|
count += lo->lo_refs;
|
|
sx_xunlock(&lf_lock_owners_lock);
|
|
|
|
return (count);
|
|
}
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
|
|
/*
|
|
* Return non-zero if y is reachable from x using a brute force
|
|
* search. If reachable and path is non-null, return the route taken
|
|
* in path.
|
|
*/
|
|
static int
|
|
graph_reaches(struct owner_vertex *x, struct owner_vertex *y,
|
|
struct owner_vertex_list *path)
|
|
{
|
|
struct owner_edge *e;
|
|
|
|
if (x == y) {
|
|
if (path)
|
|
TAILQ_INSERT_HEAD(path, x, v_link);
|
|
return 1;
|
|
}
|
|
|
|
LIST_FOREACH(e, &x->v_outedges, e_outlink) {
|
|
if (graph_reaches(e->e_to, y, path)) {
|
|
if (path)
|
|
TAILQ_INSERT_HEAD(path, x, v_link);
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Perform consistency checks on the graph. Make sure the values of
|
|
* v_order are correct. If checkorder is non-zero, check no vertex can
|
|
* reach any other vertex with a smaller order.
|
|
*/
|
|
static void
|
|
graph_check(struct owner_graph *g, int checkorder)
|
|
{
|
|
int i, j;
|
|
|
|
for (i = 0; i < g->g_size; i++) {
|
|
if (!g->g_vertices[i]->v_owner)
|
|
continue;
|
|
KASSERT(g->g_vertices[i]->v_order == i,
|
|
("lock graph vertices disordered"));
|
|
if (checkorder) {
|
|
for (j = 0; j < i; j++) {
|
|
if (!g->g_vertices[j]->v_owner)
|
|
continue;
|
|
KASSERT(!graph_reaches(g->g_vertices[i],
|
|
g->g_vertices[j], NULL),
|
|
("lock graph vertices disordered"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
graph_print_vertices(struct owner_vertex_list *set)
|
|
{
|
|
struct owner_vertex *v;
|
|
|
|
printf("{ ");
|
|
TAILQ_FOREACH(v, set, v_link) {
|
|
printf("%d:", v->v_order);
|
|
lf_print_owner(v->v_owner);
|
|
if (TAILQ_NEXT(v, v_link))
|
|
printf(", ");
|
|
}
|
|
printf(" }\n");
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
* Calculate the sub-set of vertices v from the affected region [y..x]
|
|
* where v is reachable from y. Return -1 if a loop was detected
|
|
* (i.e. x is reachable from y, otherwise the number of vertices in
|
|
* this subset.
|
|
*/
|
|
static int
|
|
graph_delta_forward(struct owner_graph *g, struct owner_vertex *x,
|
|
struct owner_vertex *y, struct owner_vertex_list *delta)
|
|
{
|
|
uint32_t gen;
|
|
struct owner_vertex *v;
|
|
struct owner_edge *e;
|
|
int n;
|
|
|
|
/*
|
|
* We start with a set containing just y. Then for each vertex
|
|
* v in the set so far unprocessed, we add each vertex that v
|
|
* has an out-edge to and that is within the affected region
|
|
* [y..x]. If we see the vertex x on our travels, stop
|
|
* immediately.
|
|
*/
|
|
TAILQ_INIT(delta);
|
|
TAILQ_INSERT_TAIL(delta, y, v_link);
|
|
v = y;
|
|
n = 1;
|
|
gen = g->g_gen;
|
|
while (v) {
|
|
LIST_FOREACH(e, &v->v_outedges, e_outlink) {
|
|
if (e->e_to == x)
|
|
return -1;
|
|
if (e->e_to->v_order < x->v_order
|
|
&& e->e_to->v_gen != gen) {
|
|
e->e_to->v_gen = gen;
|
|
TAILQ_INSERT_TAIL(delta, e->e_to, v_link);
|
|
n++;
|
|
}
|
|
}
|
|
v = TAILQ_NEXT(v, v_link);
|
|
}
|
|
|
|
return (n);
|
|
}
|
|
|
|
/*
|
|
* Calculate the sub-set of vertices v from the affected region [y..x]
|
|
* where v reaches x. Return the number of vertices in this subset.
|
|
*/
|
|
static int
|
|
graph_delta_backward(struct owner_graph *g, struct owner_vertex *x,
|
|
struct owner_vertex *y, struct owner_vertex_list *delta)
|
|
{
|
|
uint32_t gen;
|
|
struct owner_vertex *v;
|
|
struct owner_edge *e;
|
|
int n;
|
|
|
|
/*
|
|
* We start with a set containing just x. Then for each vertex
|
|
* v in the set so far unprocessed, we add each vertex that v
|
|
* has an in-edge from and that is within the affected region
|
|
* [y..x].
|
|
*/
|
|
TAILQ_INIT(delta);
|
|
TAILQ_INSERT_TAIL(delta, x, v_link);
|
|
v = x;
|
|
n = 1;
|
|
gen = g->g_gen;
|
|
while (v) {
|
|
LIST_FOREACH(e, &v->v_inedges, e_inlink) {
|
|
if (e->e_from->v_order > y->v_order
|
|
&& e->e_from->v_gen != gen) {
|
|
e->e_from->v_gen = gen;
|
|
TAILQ_INSERT_HEAD(delta, e->e_from, v_link);
|
|
n++;
|
|
}
|
|
}
|
|
v = TAILQ_PREV(v, owner_vertex_list, v_link);
|
|
}
|
|
|
|
return (n);
|
|
}
|
|
|
|
static int
|
|
graph_add_indices(int *indices, int n, struct owner_vertex_list *set)
|
|
{
|
|
struct owner_vertex *v;
|
|
int i, j;
|
|
|
|
TAILQ_FOREACH(v, set, v_link) {
|
|
for (i = n;
|
|
i > 0 && indices[i - 1] > v->v_order; i--)
|
|
;
|
|
for (j = n - 1; j >= i; j--)
|
|
indices[j + 1] = indices[j];
|
|
indices[i] = v->v_order;
|
|
n++;
|
|
}
|
|
|
|
return (n);
|
|
}
|
|
|
|
static int
|
|
graph_assign_indices(struct owner_graph *g, int *indices, int nextunused,
|
|
struct owner_vertex_list *set)
|
|
{
|
|
struct owner_vertex *v, *vlowest;
|
|
|
|
while (!TAILQ_EMPTY(set)) {
|
|
vlowest = NULL;
|
|
TAILQ_FOREACH(v, set, v_link) {
|
|
if (!vlowest || v->v_order < vlowest->v_order)
|
|
vlowest = v;
|
|
}
|
|
TAILQ_REMOVE(set, vlowest, v_link);
|
|
vlowest->v_order = indices[nextunused];
|
|
g->g_vertices[vlowest->v_order] = vlowest;
|
|
nextunused++;
|
|
}
|
|
|
|
return (nextunused);
|
|
}
|
|
|
|
static int
|
|
graph_add_edge(struct owner_graph *g, struct owner_vertex *x,
|
|
struct owner_vertex *y)
|
|
{
|
|
struct owner_edge *e;
|
|
struct owner_vertex_list deltaF, deltaB;
|
|
int nF, nB, n, vi, i;
|
|
int *indices;
|
|
|
|
sx_assert(&lf_owner_graph_lock, SX_XLOCKED);
|
|
|
|
LIST_FOREACH(e, &x->v_outedges, e_outlink) {
|
|
if (e->e_to == y) {
|
|
e->e_refs++;
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 8) {
|
|
printf("adding edge %d:", x->v_order);
|
|
lf_print_owner(x->v_owner);
|
|
printf(" -> %d:", y->v_order);
|
|
lf_print_owner(y->v_owner);
|
|
printf("\n");
|
|
}
|
|
#endif
|
|
if (y->v_order < x->v_order) {
|
|
/*
|
|
* The new edge violates the order. First find the set
|
|
* of affected vertices reachable from y (deltaF) and
|
|
* the set of affect vertices affected that reach x
|
|
* (deltaB), using the graph generation number to
|
|
* detect whether we have visited a given vertex
|
|
* already. We re-order the graph so that each vertex
|
|
* in deltaB appears before each vertex in deltaF.
|
|
*
|
|
* If x is a member of deltaF, then the new edge would
|
|
* create a cycle. Otherwise, we may assume that
|
|
* deltaF and deltaB are disjoint.
|
|
*/
|
|
g->g_gen++;
|
|
if (g->g_gen == 0) {
|
|
/*
|
|
* Generation wrap.
|
|
*/
|
|
for (vi = 0; vi < g->g_size; vi++) {
|
|
g->g_vertices[vi]->v_gen = 0;
|
|
}
|
|
g->g_gen++;
|
|
}
|
|
nF = graph_delta_forward(g, x, y, &deltaF);
|
|
if (nF < 0) {
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 8) {
|
|
struct owner_vertex_list path;
|
|
printf("deadlock: ");
|
|
TAILQ_INIT(&path);
|
|
graph_reaches(y, x, &path);
|
|
graph_print_vertices(&path);
|
|
}
|
|
#endif
|
|
return (EDEADLK);
|
|
}
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 8) {
|
|
printf("re-ordering graph vertices\n");
|
|
printf("deltaF = ");
|
|
graph_print_vertices(&deltaF);
|
|
}
|
|
#endif
|
|
|
|
nB = graph_delta_backward(g, x, y, &deltaB);
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 8) {
|
|
printf("deltaB = ");
|
|
graph_print_vertices(&deltaB);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* We first build a set of vertex indices (vertex
|
|
* order values) that we may use, then we re-assign
|
|
* orders first to those vertices in deltaB, then to
|
|
* deltaF. Note that the contents of deltaF and deltaB
|
|
* may be partially disordered - we perform an
|
|
* insertion sort while building our index set.
|
|
*/
|
|
indices = g->g_indexbuf;
|
|
n = graph_add_indices(indices, 0, &deltaF);
|
|
graph_add_indices(indices, n, &deltaB);
|
|
|
|
/*
|
|
* We must also be sure to maintain the relative
|
|
* ordering of deltaF and deltaB when re-assigning
|
|
* vertices. We do this by iteratively removing the
|
|
* lowest ordered element from the set and assigning
|
|
* it the next value from our new ordering.
|
|
*/
|
|
i = graph_assign_indices(g, indices, 0, &deltaB);
|
|
graph_assign_indices(g, indices, i, &deltaF);
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 8) {
|
|
struct owner_vertex_list set;
|
|
TAILQ_INIT(&set);
|
|
for (i = 0; i < nB + nF; i++)
|
|
TAILQ_INSERT_TAIL(&set,
|
|
g->g_vertices[indices[i]], v_link);
|
|
printf("new ordering = ");
|
|
graph_print_vertices(&set);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
KASSERT(x->v_order < y->v_order, ("Failed to re-order graph"));
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 8) {
|
|
graph_check(g, TRUE);
|
|
}
|
|
#endif
|
|
|
|
e = malloc(sizeof(struct owner_edge), M_LOCKF, M_WAITOK);
|
|
|
|
LIST_INSERT_HEAD(&x->v_outedges, e, e_outlink);
|
|
LIST_INSERT_HEAD(&y->v_inedges, e, e_inlink);
|
|
e->e_refs = 1;
|
|
e->e_from = x;
|
|
e->e_to = y;
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Remove an edge x->y from the graph.
|
|
*/
|
|
static void
|
|
graph_remove_edge(struct owner_graph *g, struct owner_vertex *x,
|
|
struct owner_vertex *y)
|
|
{
|
|
struct owner_edge *e;
|
|
|
|
sx_assert(&lf_owner_graph_lock, SX_XLOCKED);
|
|
|
|
LIST_FOREACH(e, &x->v_outedges, e_outlink) {
|
|
if (e->e_to == y)
|
|
break;
|
|
}
|
|
KASSERT(e, ("Removing non-existent edge from deadlock graph"));
|
|
|
|
e->e_refs--;
|
|
if (e->e_refs == 0) {
|
|
#ifdef LOCKF_DEBUG
|
|
if (lockf_debug & 8) {
|
|
printf("removing edge %d:", x->v_order);
|
|
lf_print_owner(x->v_owner);
|
|
printf(" -> %d:", y->v_order);
|
|
lf_print_owner(y->v_owner);
|
|
printf("\n");
|
|
}
|
|
#endif
|
|
LIST_REMOVE(e, e_outlink);
|
|
LIST_REMOVE(e, e_inlink);
|
|
free(e, M_LOCKF);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Allocate a vertex from the free list. Return ENOMEM if there are
|
|
* none.
|
|
*/
|
|
static struct owner_vertex *
|
|
graph_alloc_vertex(struct owner_graph *g, struct lock_owner *lo)
|
|
{
|
|
struct owner_vertex *v;
|
|
|
|
sx_assert(&lf_owner_graph_lock, SX_XLOCKED);
|
|
|
|
v = malloc(sizeof(struct owner_vertex), M_LOCKF, M_WAITOK);
|
|
if (g->g_size == g->g_space) {
|
|
g->g_vertices = realloc(g->g_vertices,
|
|
2 * g->g_space * sizeof(struct owner_vertex *),
|
|
M_LOCKF, M_WAITOK);
|
|
free(g->g_indexbuf, M_LOCKF);
|
|
g->g_indexbuf = malloc(2 * g->g_space * sizeof(int),
|
|
M_LOCKF, M_WAITOK);
|
|
g->g_space = 2 * g->g_space;
|
|
}
|
|
v->v_order = g->g_size;
|
|
v->v_gen = g->g_gen;
|
|
g->g_vertices[g->g_size] = v;
|
|
g->g_size++;
|
|
|
|
LIST_INIT(&v->v_outedges);
|
|
LIST_INIT(&v->v_inedges);
|
|
v->v_owner = lo;
|
|
|
|
return (v);
|
|
}
|
|
|
|
static void
|
|
graph_free_vertex(struct owner_graph *g, struct owner_vertex *v)
|
|
{
|
|
struct owner_vertex *w;
|
|
int i;
|
|
|
|
sx_assert(&lf_owner_graph_lock, SX_XLOCKED);
|
|
|
|
KASSERT(LIST_EMPTY(&v->v_outedges), ("Freeing vertex with edges"));
|
|
KASSERT(LIST_EMPTY(&v->v_inedges), ("Freeing vertex with edges"));
|
|
|
|
/*
|
|
* Remove from the graph's array and close up the gap,
|
|
* renumbering the other vertices.
|
|
*/
|
|
for (i = v->v_order + 1; i < g->g_size; i++) {
|
|
w = g->g_vertices[i];
|
|
w->v_order--;
|
|
g->g_vertices[i - 1] = w;
|
|
}
|
|
g->g_size--;
|
|
|
|
free(v, M_LOCKF);
|
|
}
|
|
|
|
static struct owner_graph *
|
|
graph_init(struct owner_graph *g)
|
|
{
|
|
|
|
g->g_vertices = malloc(10 * sizeof(struct owner_vertex *),
|
|
M_LOCKF, M_WAITOK);
|
|
g->g_size = 0;
|
|
g->g_space = 10;
|
|
g->g_indexbuf = malloc(g->g_space * sizeof(int), M_LOCKF, M_WAITOK);
|
|
g->g_gen = 0;
|
|
|
|
return (g);
|
|
}
|
|
|
|
#ifdef LOCKF_DEBUG
|
|
/*
|
|
* Print description of a lock owner
|
|
*/
|
|
static void
|
|
lf_print_owner(struct lock_owner *lo)
|
|
{
|
|
|
|
if (lo->lo_flags & F_REMOTE) {
|
|
printf("remote pid %d, system %d",
|
|
lo->lo_pid, lo->lo_sysid);
|
|
} else if (lo->lo_flags & F_FLOCK) {
|
|
printf("file %p", lo->lo_id);
|
|
} else {
|
|
printf("local pid %d", lo->lo_pid);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Print out a lock.
|
|
*/
|
|
static void
|
|
lf_print(char *tag, struct lockf_entry *lock)
|
|
{
|
|
|
|
printf("%s: lock %p for ", tag, (void *)lock);
|
|
lf_print_owner(lock->lf_owner);
|
|
if (lock->lf_inode != (struct inode *)0)
|
|
printf(" in ino %ju on dev <%s>,",
|
|
(uintmax_t)lock->lf_inode->i_number,
|
|
devtoname(ITODEV(lock->lf_inode)));
|
|
printf(" %s, start %jd, end ",
|
|
lock->lf_type == F_RDLCK ? "shared" :
|
|
lock->lf_type == F_WRLCK ? "exclusive" :
|
|
lock->lf_type == F_UNLCK ? "unlock" : "unknown",
|
|
(intmax_t)lock->lf_start);
|
|
if (lock->lf_end == OFF_MAX)
|
|
printf("EOF");
|
|
else
|
|
printf("%jd", (intmax_t)lock->lf_end);
|
|
if (!LIST_EMPTY(&lock->lf_outedges))
|
|
printf(" block %p\n",
|
|
(void *)LIST_FIRST(&lock->lf_outedges)->le_to);
|
|
else
|
|
printf("\n");
|
|
}
|
|
|
|
static void
|
|
lf_printlist(char *tag, struct lockf_entry *lock)
|
|
{
|
|
struct lockf_entry *lf, *blk;
|
|
struct lockf_edge *e;
|
|
|
|
if (lock->lf_inode == (struct inode *)0)
|
|
return;
|
|
|
|
printf("%s: Lock list for ino %ju on dev <%s>:\n",
|
|
tag, (uintmax_t)lock->lf_inode->i_number,
|
|
devtoname(ITODEV(lock->lf_inode)));
|
|
LIST_FOREACH(lf, &lock->lf_vnode->v_lockf->ls_active, lf_link) {
|
|
printf("\tlock %p for ",(void *)lf);
|
|
lf_print_owner(lock->lf_owner);
|
|
printf(", %s, start %jd, end %jd",
|
|
lf->lf_type == F_RDLCK ? "shared" :
|
|
lf->lf_type == F_WRLCK ? "exclusive" :
|
|
lf->lf_type == F_UNLCK ? "unlock" :
|
|
"unknown", (intmax_t)lf->lf_start, (intmax_t)lf->lf_end);
|
|
LIST_FOREACH(e, &lf->lf_outedges, le_outlink) {
|
|
blk = e->le_to;
|
|
printf("\n\t\tlock request %p for ", (void *)blk);
|
|
lf_print_owner(blk->lf_owner);
|
|
printf(", %s, start %jd, end %jd",
|
|
blk->lf_type == F_RDLCK ? "shared" :
|
|
blk->lf_type == F_WRLCK ? "exclusive" :
|
|
blk->lf_type == F_UNLCK ? "unlock" :
|
|
"unknown", (intmax_t)blk->lf_start,
|
|
(intmax_t)blk->lf_end);
|
|
if (!LIST_EMPTY(&blk->lf_inedges))
|
|
panic("lf_printlist: bad list");
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
#endif /* LOCKF_DEBUG */
|