/* * linux/fs/lockd/svclock.c * * Handling of server-side locks, mostly of the blocked variety. * This is the ugliest part of lockd because we tread on very thin ice. * GRANT and CANCEL calls may get stuck, meet in mid-flight, etc. * IMNSHO introducing the grant callback into the NLM protocol was one * of the worst ideas Sun ever had. Except maybe for the idea of doing * NFS file locking at all. * * I'm trying hard to avoid race conditions by protecting most accesses * to a file's list of blocked locks through a semaphore. The global * list of blocked locks is not protected in this fashion however. * Therefore, some functions (such as the RPC callback for the async grant * call) move blocked locks towards the head of the list *while some other * process might be traversing it*. This should not be a problem in * practice, because this will only cause functions traversing the list * to visit some blocks twice. * * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> */#include <linux/types.h>#include <linux/errno.h>#include <linux/kernel.h>#include <linux/sched.h>#include <linux/smp_lock.h>#include <linux/sunrpc/clnt.h>#include <linux/sunrpc/svc.h>#include <linux/lockd/nlm.h>#include <linux/lockd/lockd.h>#include <linux/kthread.h>#define NLMDBG_FACILITY		NLMDBG_SVCLOCK#ifdef CONFIG_LOCKD_V4#define nlm_deadlock	nlm4_deadlock#else#define nlm_deadlock	nlm_lck_denied#endifstatic void nlmsvc_release_block(struct nlm_block *block);static void	nlmsvc_insert_block(struct nlm_block *block, unsigned long);static void	nlmsvc_remove_block(struct nlm_block *block);static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock);static void nlmsvc_freegrantargs(struct nlm_rqst *call);static const struct rpc_call_ops nlmsvc_grant_ops;/* * The list of blocked locks to retry */static LIST_HEAD(nlm_blocked);/* * Insert a blocked lock into the global list */static voidnlmsvc_insert_block(struct nlm_block *block, unsigned long when){	struct nlm_block *b;	struct list_head *pos;	dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block, when);	if (list_empty(&block->b_list)) {		kref_get(&block->b_count);	} else {		list_del_init(&block->b_list);	}	pos = &nlm_blocked;	if (when != NLM_NEVER) {		if ((when += jiffies) == NLM_NEVER)			when ++;		list_for_each(pos, &nlm_blocked) {			b = list_entry(pos, struct nlm_block, b_list);			if (time_after(b->b_when,when) || b->b_when == NLM_NEVER)				break;		}		/* On normal exit from the loop, pos == &nlm_blocked,		 * so we will be adding to the end of the list - good		 */	}	list_add_tail(&block->b_list, pos);	block->b_when = when;}/* * Remove a block from the global list */static inline voidnlmsvc_remove_block(struct nlm_block *block){	if (!list_empty(&block->b_list)) {		list_del_init(&block->b_list);		nlmsvc_release_block(block);	}}/* * Find a block for a given lock */static struct nlm_block *nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock){	struct nlm_block	*block;	struct file_lock	*fl;	dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",				file, lock->fl.fl_pid,				(long long)lock->fl.fl_start,				(long long)lock->fl.fl_end, lock->fl.fl_type);	list_for_each_entry(block, &nlm_blocked, b_list) {		fl = &block->b_call->a_args.lock.fl;		dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",				block->b_file, fl->fl_pid,				(long long)fl->fl_start,				(long long)fl->fl_end, fl->fl_type,				nlmdbg_cookie2a(&block->b_call->a_args.cookie));		if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) {			kref_get(&block->b_count);			return block;		}	}	return NULL;}static inline int nlm_cookie_match(struct nlm_cookie *a, struct nlm_cookie *b){	if (a->len != b->len)		return 0;	if (memcmp(a->data, b->data, a->len))		return 0;	return 1;}/* * Find a block with a given NLM cookie. */static inline struct nlm_block *nlmsvc_find_block(struct nlm_cookie *cookie){	struct nlm_block *block;	list_for_each_entry(block, &nlm_blocked, b_list) {		if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie))			goto found;	}	return NULL;found:	dprintk("nlmsvc_find_block(%s): block=%p\n", nlmdbg_cookie2a(cookie), block);	kref_get(&block->b_count);	return block;}/* * Create a block and initialize it. * * Note: we explicitly set the cookie of the grant reply to that of * the blocked lock request. The spec explicitly mentions that the client * should _not_ rely on the callback containing the same cookie as the * request, but (as I found out later) that's because some implementations * do just this. Never mind the standards comittees, they support our * logging industries. * * 10 years later: I hope we can safely ignore these old and broken * clients by now. Let's fix this so we can uniquely identify an incoming * GRANTED_RES message by cookie, without having to rely on the client's IP * address. --okir */static struct nlm_block *nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_host *host,		    struct nlm_file *file, struct nlm_lock *lock,		    struct nlm_cookie *cookie){	struct nlm_block	*block;	struct nlm_rqst		*call = NULL;	nlm_get_host(host);	call = nlm_alloc_call(host);	if (call == NULL)		return NULL;	/* Allocate memory for block, and initialize arguments */	block = kzalloc(sizeof(*block), GFP_KERNEL);	if (block == NULL)		goto failed;	kref_init(&block->b_count);	INIT_LIST_HEAD(&block->b_list);	INIT_LIST_HEAD(&block->b_flist);	if (!nlmsvc_setgrantargs(call, lock))		goto failed_free;	/* Set notifier function for VFS, and init args */	call->a_args.lock.fl.fl_flags |= FL_SLEEP;	call->a_args.lock.fl.fl_lmops = &nlmsvc_lock_operations;	nlmclnt_next_cookie(&call->a_args.cookie);	dprintk("lockd: created block %p...\n", block);	/* Create and initialize the block */	block->b_daemon = rqstp->rq_server;	block->b_host   = host;	block->b_file   = file;	block->b_fl = NULL;	file->f_count++;	/* Add to file's list of blocks */	list_add(&block->b_flist, &file->f_blocks);	/* Set up RPC arguments for callback */	block->b_call = call;	call->a_flags   = RPC_TASK_ASYNC;	call->a_block = block;	return block;failed_free:	kfree(block);failed:	nlm_release_call(call);	return NULL;}/* * Delete a block. * It is the caller's responsibility to check whether the file * can be closed hereafter. */static int nlmsvc_unlink_block(struct nlm_block *block){	int status;	dprintk("lockd: unlinking block %p...\n", block);	/* Remove block from list */	status = posix_unblock_lock(block->b_file->f_file, &block->b_call->a_args.lock.fl);	nlmsvc_remove_block(block);	return status;}static void nlmsvc_free_block(struct kref *kref){	struct nlm_block *block = container_of(kref, struct nlm_block, b_count);	struct nlm_file		*file = block->b_file;	dprintk("lockd: freeing block %p...\n", block);	/* Remove block from file's list of blocks */	mutex_lock(&file->f_mutex);	list_del_init(&block->b_flist);	mutex_unlock(&file->f_mutex);	nlmsvc_freegrantargs(block->b_call);	nlm_release_call(block->b_call);	nlm_release_file(block->b_file);	kfree(block->b_fl);	kfree(block);}static void nlmsvc_release_block(struct nlm_block *block){	if (block != NULL)		kref_put(&block->b_count, nlmsvc_free_block);}/* * Loop over all blocks and delete blocks held by * a matching host. */void nlmsvc_traverse_blocks(struct nlm_host *host,			struct nlm_file *file,			nlm_host_match_fn_t match){	struct nlm_block *block, *next;restart:	mutex_lock(&file->f_mutex);	list_for_each_entry_safe(block, next, &file->f_blocks, b_flist) {		if (!match(block->b_host, host))			continue;		/* Do not destroy blocks that are not on		 * the global retry list - why? */		if (list_empty(&block->b_list))			continue;		kref_get(&block->b_count);		mutex_unlock(&file->f_mutex);		nlmsvc_unlink_block(block);		nlmsvc_release_block(block);		goto restart;	}	mutex_unlock(&file->f_mutex);}/* * Initialize arguments for GRANTED call. The nlm_rqst structure * has been cleared already. */static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock){	locks_copy_lock(&call->a_args.lock.fl, &lock->fl);	memcpy(&call->a_args.lock.fh, &lock->fh, sizeof(call->a_args.lock.fh));	call->a_args.lock.caller = utsname()->nodename;	call->a_args.lock.oh.len = lock->oh.len;	/* set default data area */	call->a_args.lock.oh.data = call->a_owner;	call->a_args.lock.svid = lock->fl.fl_pid;	if (lock->oh.len > NLMCLNT_OHSIZE) {		void *data = kmalloc(lock->oh.len, GFP_KERNEL);		if (!data)			return 0;		call->a_args.lock.oh.data = (u8 *) data;	}	memcpy(call->a_args.lock.oh.data, lock->oh.data, lock->oh.len);	return 1;}static void nlmsvc_freegrantargs(struct nlm_rqst *call){	if (call->a_args.lock.oh.data != call->a_owner)		kfree(call->a_args.lock.oh.data);}/* * Deferred lock request handling for non-blocking lock */static __be32nlmsvc_defer_lock_rqst(struct svc_rqst *rqstp, struct nlm_block *block){	__be32 status = nlm_lck_denied_nolocks;	block->b_flags |= B_QUEUED;	nlmsvc_insert_block(block, NLM_TIMEOUT);	block->b_cache_req = &rqstp->rq_chandle;	if (rqstp->rq_chandle.defer) {		block->b_deferred_req =			rqstp->rq_chandle.defer(block->b_cache_req);		if (block->b_deferred_req != NULL)			status = nlm_drop_reply;	}	dprintk("lockd: nlmsvc_defer_lock_rqst block %p flags %d status %d\n",		block, block->b_flags, ntohl(status));	return status;}/* * Attempt to establish a lock, and if it can't be granted, block it * if required. */__be32nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,	    struct nlm_host *host, struct nlm_lock *lock, int wait,	    struct nlm_cookie *cookie, int reclaim){	struct nlm_block	*block = NULL;	int			error;	__be32			ret;	dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",				file->f_file->f_path.dentry->d_inode->i_sb->s_id,				file->f_file->f_path.dentry->d_inode->i_ino,				lock->fl.fl_type, lock->fl.fl_pid,				(long long)lock->fl.fl_start,				(long long)lock->fl.fl_end,				wait);	/* Lock file against concurrent access */	mutex_lock(&file->f_mutex);	/* Get existing block (in case client is busy-waiting)	 * or create new block	 */	block = nlmsvc_lookup_block(file, lock);	if (block == NULL) {		block = nlmsvc_create_block(rqstp, host, file, lock, cookie);		ret = nlm_lck_denied_nolocks;		if (block == NULL)			goto out;		lock = &block->b_call->a_args.lock;	} else		lock->fl.fl_flags &= ~FL_SLEEP;	if (block->b_flags & B_QUEUED) {		dprintk("lockd: nlmsvc_lock deferred block %p flags %d\n",							block, block->b_flags);		if (block->b_granted) {			nlmsvc_unlink_block(block);			ret = nlm_granted;			goto out;		}		if (block->b_flags & B_TIMED_OUT) {			nlmsvc_unlink_block(block);			ret = nlm_lck_denied;			goto out;		}		ret = nlm_drop_reply;		goto out;	}	if (locks_in_grace() && !reclaim) {		ret = nlm_lck_denied_grace_period;		goto out;	}	if (reclaim && !locks_in_grace()) {		ret = nlm_lck_denied_grace_period;		goto out;	}	if (!wait)		lock->fl.fl_flags &= ~FL_SLEEP;	error = vfs_lock_file(file->f_file, F_SETLK, &lock->fl, NULL);	lock->fl.fl_flags &= ~FL_SLEEP;	dprintk("lockd: vfs_lock_file returned %d\n", error);	switch (error) {		case 0:			ret = nlm_granted;			goto out;		case -EAGAIN:			ret = nlm_lck_denied;			break;		case FILE_LOCK_DEFERRED:			if (wait)				break;			/* Filesystem lock operation is in progress			   Add it to the queue waiting for callback */			ret = nlmsvc_defer_lock_rqst(rqstp, block);			goto out;		case -EDEADLK:			ret = nlm_deadlock;			goto out;		default:			/* includes ENOLCK */			ret = nlm_lck_denied_nolocks;			goto out;	}	ret = nlm_lck_denied;	if (!wait)		goto out;	ret = nlm_lck_blocked;	/* Append to list of blocked */	nlmsvc_insert_block(block, NLM_NEVER);out:	mutex_unlock(&file->f_mutex);	nlmsvc_release_block(block);	dprintk("lockd: nlmsvc_lock returned %u\n", ret);	return ret;}