// SPDX-License-Identifier: GPL-2.0/* * 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/slab.h>#include <linux/errno.h>#include <linux/kernel.h>#include <linux/sched.h>#include <linux/sunrpc/clnt.h>#include <linux/sunrpc/svc_xprt.h> #include "lockd.h" #define NLMDBG_FACILITY		NLMDBG_SVCLOCK static 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 lockd_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);static DEFINE_SPINLOCK(nlm_blocked_lock); /* * Insert a blocked lock into the global list */static voidnlmsvc_insert_block_locked(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;} static void nlmsvc_insert_block(struct nlm_block *block, unsigned long when){	spin_lock(&nlm_blocked_lock);	nlmsvc_insert_block_locked(block, when);	spin_unlock(&nlm_blocked_lock);} /* * Remove a block from the global list */static inline voidnlmsvc_remove_block(struct nlm_block *block){	spin_lock(&nlm_blocked_lock);	if (!list_empty(&block->b_list)) {		list_del_init(&block->b_list);		spin_unlock(&nlm_blocked_lock);		nlmsvc_release_block(block);		return;	}	spin_unlock(&nlm_blocked_lock);} /* * Find a block for a given lock */static struct nlm_block *nlmsvc_lookup_block(struct nlm_file *file, struct lockd_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.c.flc_pid,				(long long)lock->fl.fl_start,				(long long)lock->fl.fl_end,				lock->fl.c.flc_type);	spin_lock(&nlm_blocked_lock);	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=%*phN\n",				block->b_file, fl->c.flc_pid,				(long long)fl->fl_start,				(long long)fl->fl_end, fl->c.flc_type,				block->b_call->a_args.cookie.len,				block->b_call->a_args.cookie.data);		if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) {			kref_get(&block->b_count);			spin_unlock(&nlm_blocked_lock);			return block;		}	}	spin_unlock(&nlm_blocked_lock); 	return NULL;} static int lockd_cookie_match(struct lockd_cookie *a, struct lockd_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 lockd_cookie *cookie){	struct nlm_block *block; 	spin_lock(&nlm_blocked_lock);	list_for_each_entry(block, &nlm_blocked, b_list) {		if (lockd_cookie_match(&block->b_call->a_args.cookie, cookie))			goto found;	}	spin_unlock(&nlm_blocked_lock); 	return NULL; found:	dprintk("nlmsvc_find_block(%*phN): block=%p\n",		cookie->len, cookie->data, block);	kref_get(&block->b_count);	spin_unlock(&nlm_blocked_lock);	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 lockd_lock *lock,		    struct lockd_cookie *cookie){	struct nlm_block	*block;	struct nlm_rqst		*call = NULL; 	call = nlm_alloc_call(host);	if (call == NULL)		return NULL; 	/* Allocate memory for block, and initialize arguments */	block = kzalloc_obj(*block);	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.c.flc_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;	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:	nlmsvc_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 = locks_delete_block(&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 */	list_del_init(&block->b_flist);	mutex_unlock(&file->f_mutex); 	nlmsvc_freegrantargs(block->b_call);	nlmsvc_release_call(block->b_call);	nlm_release_file(block->b_file);	kfree(block);} static void nlmsvc_release_block(struct nlm_block *block){	if (block != NULL)		kref_put_mutex(&block->b_count, nlmsvc_free_block, &block->b_file->f_mutex);} /* * 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);	spin_lock(&nlm_blocked_lock);	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);		spin_unlock(&nlm_blocked_lock);		mutex_unlock(&file->f_mutex);		nlmsvc_unlink_block(block);		nlmsvc_release_block(block);		goto restart;	}	spin_unlock(&nlm_blocked_lock);	mutex_unlock(&file->f_mutex);} static struct nlm_lockowner *nlmsvc_get_lockowner(struct nlm_lockowner *lockowner){	refcount_inc(&lockowner->count);	return lockowner;} void nlmsvc_put_lockowner(struct nlm_lockowner *lockowner){	if (!refcount_dec_and_lock(&lockowner->count, &lockowner->host->h_lock))		return;	list_del(&lockowner->list);	spin_unlock(&lockowner->host->h_lock);	nlmsvc_release_host(lockowner->host);	kfree(lockowner);} static struct nlm_lockowner *__nlmsvc_find_lockowner(struct nlm_host *host, pid_t pid){	struct nlm_lockowner *lockowner;	list_for_each_entry(lockowner, &host->h_lockowners, list) {		if (lockowner->pid != pid)			continue;		return nlmsvc_get_lockowner(lockowner);	}	return NULL;} static struct nlm_lockowner *nlmsvc_find_lockowner(struct nlm_host *host, pid_t pid){	struct nlm_lockowner *res, *new = NULL; 	spin_lock(&host->h_lock);	res = __nlmsvc_find_lockowner(host, pid); 	if (res == NULL) {		spin_unlock(&host->h_lock);		new = kmalloc_obj(*res);		spin_lock(&host->h_lock);		res = __nlmsvc_find_lockowner(host, pid);		if (res == NULL && new != NULL) {			res = new;			/* fs/locks.c will manage the refcount through lock_ops */			refcount_set(&new->count, 1);			new->pid = pid;			new->host = nlm_get_host(host);			list_add(&new->list, &host->h_lockowners);			new = NULL;		}	} 	spin_unlock(&host->h_lock);	kfree(new);	return res;} voidnlmsvc_release_lockowner(struct lockd_lock *lock){	if (lock->fl.c.flc_owner)		nlmsvc_put_lockowner(lock->fl.c.flc_owner);} void nlmsvc_locks_init_private(struct file_lock *fl, struct nlm_host *host,						pid_t pid){	fl->c.flc_owner = nlmsvc_find_lockowner(host, pid);} /* * Initialize arguments for GRANTED call. The nlm_rqst structure * has been cleared already. */static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct lockd_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 = ((struct nlm_lockowner *) lock->fl.c.flc_owner)->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); 	locks_release_private(&call->a_args.lock.fl);} /* * 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__int__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 lockd_lock *lock, int wait,	    struct lockd_cookie *cookie, int reclaim){	struct inode		*inode __maybe_unused = nlmsvc_file_inode(file);	struct nlm_block	*block = NULL;	int			error;	int			mode;	int			async_block = 0;	__be32			ret; 	dprintk("lockd: nlmsvc_lock(%s/%llu, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",				inode->i_sb->s_id, inode->i_ino,				lock->fl.c.flc_type,				lock->fl.c.flc_pid,				(long long)lock->fl.fl_start,				(long long)lock->fl.fl_end,				wait); 	if (nlmsvc_file_cannot_lock(file))		return nlm_lck_denied_nolocks; 	if (!locks_can_async_lock(nlmsvc_file_file(file)->f_op)) {		async_block = wait;		wait = 0;	} 	/* 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.c.flc_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;		}

Lines 1–500 of 1042. Load more