Commit a099027c authored by M. Mohan Kumar's avatar M. Mohan Kumar Committed by Eric Van Hensbergen
Browse files

9p: Implement TLOCK 



Synopsis

    size[4] TLock tag[2] fid[4] flock[n]
    size[4] RLock tag[2] status[1]

Description

Tlock is used to acquire/release byte range posix locks on a file
identified by given fid. The reply contains status of the lock request

    flock structure:
        type[1] - Type of lock: F_RDLCK, F_WRLCK, F_UNLCK
        flags[4] - Flags could be either of
          P9_LOCK_FLAGS_BLOCK - Blocked lock request, if there is a
            conflicting lock exists, wait for that lock to be released.
          P9_LOCK_FLAGS_RECLAIM - Reclaim lock request, used when client is
            trying to reclaim a lock after a server restrart (due to crash)
        start[8] - Starting offset for lock
        length[8] - Number of bytes to lock
          If length is 0, lock all bytes starting at the location 'start'
          through to the end of file
        pid[4] - PID of the process that wants to take lock
        client_id[4] - Unique client id

        status[1] - Status of the lock request, can be
          P9_LOCK_SUCCESS(0), P9_LOCK_BLOCKED(1), P9_LOCK_ERROR(2) or
          P9_LOCK_GRACE(3)
          P9_LOCK_SUCCESS - Request was successful
          P9_LOCK_BLOCKED - A conflicting lock is held by another process
          P9_LOCK_ERROR - Error while processing the lock request
          P9_LOCK_GRACE - Server is in grace period, it can't accept new lock
            requests in this period (except locks with
            P9_LOCK_FLAGS_RECLAIM flag set)

Signed-off-by: default avatarM. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: default avatarAneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: default avatarVenkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: default avatarEric Van Hensbergen <ericvh@gmail.com>
parent 920e65dc

fs/9p/v9fs_vfs.h

+2 −0
Original line number Diff line number Diff line
@@ -65,3 +65,5 @@ int v9fs_uflags2omode(int uflags, int extended); 
ssize_t v9fs_file_readn(struct file *, char *, char __user *, u32, u64);

void v9fs_blank_wstat(struct p9_wstat *wstat);

int v9fs_vfs_setattr_dotl(struct dentry *, struct iattr *);



#define P9_LOCK_TIMEOUT (30*HZ)

fs/9p/vfs_file.c

+158 −2
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ 
#include <linux/inet.h>

#include <linux/list.h>

#include <linux/pagemap.h>

#include <linux/utsname.h>

#include <asm/uaccess.h>

#include <linux/idr.h>

#include <net/9p/9p.h>
@@ -133,6 +134,159 @@ static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl) 
	return res;

}



static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl)

{

	struct p9_flock flock;

	struct p9_fid *fid;

	uint8_t status;

	int res = 0;

	unsigned char fl_type;



	fid = filp->private_data;

	BUG_ON(fid == NULL);



	if ((fl->fl_flags & FL_POSIX) != FL_POSIX)

		BUG();



	res = posix_lock_file_wait(filp, fl);

	if (res < 0)

		goto out;



	/* convert posix lock to p9 tlock args */

	memset(&flock, 0, sizeof(flock));

	flock.type = fl->fl_type;

	flock.start = fl->fl_start;

	if (fl->fl_end == OFFSET_MAX)

		flock.length = 0;

	else

		flock.length = fl->fl_end - fl->fl_start + 1;

	flock.proc_id = fl->fl_pid;

	flock.client_id = utsname()->nodename;

	if (IS_SETLKW(cmd))

		flock.flags = P9_LOCK_FLAGS_BLOCK;



	/*

	 * if its a blocked request and we get P9_LOCK_BLOCKED as the status

	 * for lock request, keep on trying

	 */

	for (;;) {

		res = p9_client_lock_dotl(fid, &flock, &status);

		if (res < 0)

			break;



		if (status != P9_LOCK_BLOCKED)

			break;

		if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd))

			break;

		schedule_timeout_interruptible(P9_LOCK_TIMEOUT);

	}



	/* map 9p status to VFS status */

	switch (status) {

	case P9_LOCK_SUCCESS:

		res = 0;

		break;

	case P9_LOCK_BLOCKED:

		res = -EAGAIN;

		break;

	case P9_LOCK_ERROR:

	case P9_LOCK_GRACE:

		res = -ENOLCK;

		break;

	default:

		BUG();

	}



	/*

	 * incase server returned error for lock request, revert

	 * it locally

	 */

	if (res < 0 && fl->fl_type != F_UNLCK) {

		fl_type = fl->fl_type;

		fl->fl_type = F_UNLCK;

		res = posix_lock_file_wait(filp, fl);

		fl->fl_type = fl_type;

	}

out:

	return res;

}



/**

 * v9fs_file_lock_dotl - lock a file (or directory)

 * @filp: file to be locked

 * @cmd: lock command

 * @fl: file lock structure

 *

 */



static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl)

{

	struct inode *inode = filp->f_path.dentry->d_inode;

	int ret = -ENOLCK;



	P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,

				cmd, fl, filp->f_path.dentry->d_name.name);



	/* No mandatory locks */

	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)

		goto out_err;



	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {

		filemap_write_and_wait(inode->i_mapping);

		invalidate_mapping_pages(&inode->i_data, 0, -1);

	}



	if (IS_SETLK(cmd) || IS_SETLKW(cmd))

		ret = v9fs_file_do_lock(filp, cmd, fl);

	else

		ret = -EINVAL;

out_err:

	return ret;

}



/**

 * v9fs_file_flock_dotl - lock a file

 * @filp: file to be locked

 * @cmd: lock command

 * @fl: file lock structure

 *

 */



static int v9fs_file_flock_dotl(struct file *filp, int cmd,

	struct file_lock *fl)

{

	struct inode *inode = filp->f_path.dentry->d_inode;

	int ret = -ENOLCK;



	P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,

				cmd, fl, filp->f_path.dentry->d_name.name);



	/* No mandatory locks */

	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)

		goto out_err;



	if (!(fl->fl_flags & FL_FLOCK))

		goto out_err;



	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {

		filemap_write_and_wait(inode->i_mapping);

		invalidate_mapping_pages(&inode->i_data, 0, -1);

	}

	/* Convert flock to posix lock */

	fl->fl_owner = (fl_owner_t)filp;

	fl->fl_start = 0;

	fl->fl_end = OFFSET_MAX;

	fl->fl_flags |= FL_POSIX;

	fl->fl_flags ^= FL_FLOCK;



	if (IS_SETLK(cmd) | IS_SETLKW(cmd))

		ret = v9fs_file_do_lock(filp, cmd, fl);

	else

		ret = -EINVAL;

out_err:

	return ret;

}



/**

 * v9fs_file_readn - read from a file

 * @filp: file pointer to read
@@ -323,7 +477,8 @@ static const struct file_operations v9fs_cached_file_operations_dotl = { 
	.write = v9fs_file_write,

	.open = v9fs_file_open,

	.release = v9fs_dir_release,

	.lock = v9fs_file_lock,

	.lock = v9fs_file_lock_dotl,

	.flock = v9fs_file_flock_dotl,

	.mmap = generic_file_readonly_mmap,

	.fsync = v9fs_file_fsync_dotl,

};
@@ -345,7 +500,8 @@ const struct file_operations v9fs_file_operations_dotl = { 
	.write = v9fs_file_write,

	.open = v9fs_file_open,

	.release = v9fs_dir_release,

	.lock = v9fs_file_lock,

	.lock = v9fs_file_lock_dotl,

	.flock = v9fs_file_flock_dotl,

	.mmap = generic_file_readonly_mmap,

	.fsync = v9fs_file_fsync_dotl,

};

include/net/9p/9p.h

+28 −0
Original line number Diff line number Diff line
@@ -165,6 +165,8 @@ enum p9_msg_t { 
	P9_RREADDIR,

	P9_TFSYNC = 50,

	P9_RFSYNC,

	P9_TLOCK = 52,

	P9_RLOCK,

	P9_TLINK = 70,

	P9_RLINK,

	P9_TMKDIR = 72,
@@ -464,6 +466,32 @@ struct p9_iattr_dotl { 
	u64 mtime_nsec;

};



#define P9_LOCK_SUCCESS 0

#define P9_LOCK_BLOCKED 1

#define P9_LOCK_ERROR 2

#define P9_LOCK_GRACE 3



#define P9_LOCK_FLAGS_BLOCK 1

#define P9_LOCK_FLAGS_RECLAIM 2



/* struct p9_flock: POSIX lock structure

 * @type - type of lock

 * @flags - lock flags

 * @start - starting offset of the lock

 * @length - number of bytes

 * @proc_id - process id which wants to take lock

 * @client_id - client id

 */



struct p9_flock {

	u8 type;

	u32 flags;

	u64 start;

	u64 length;

	u32 proc_id;

	char *client_id;

};



/* Structures for Protocol Operations */

struct p9_tstatfs {

	u32 fid;

include/net/9p/client.h

+1 −0
Original line number Diff line number Diff line
@@ -249,6 +249,7 @@ int p9_client_mknod_dotl(struct p9_fid *oldfid, char *name, int mode, 
			dev_t rdev, gid_t gid, struct p9_qid *);

int p9_client_mkdir_dotl(struct p9_fid *fid, char *name, int mode,

				gid_t gid, struct p9_qid *);

int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status);

struct p9_req_t *p9_tag_lookup(struct p9_client *, u16);

void p9_client_cb(struct p9_client *c, struct p9_req_t *req);

net/9p/client.c

+33 −0
Original line number Diff line number Diff line
@@ -1803,3 +1803,36 @@ error: 


}

EXPORT_SYMBOL(p9_client_mkdir_dotl);



int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status)

{

	int err;

	struct p9_client *clnt;

	struct p9_req_t *req;



	err = 0;

	clnt = fid->clnt;

	P9_DPRINTK(P9_DEBUG_9P, ">>> TLOCK fid %d type %i flags %d "

			"start %lld length %lld proc_id %d client_id %s\n",

			fid->fid, flock->type, flock->flags, flock->start,

			flock->length, flock->proc_id, flock->client_id);



	req = p9_client_rpc(clnt, P9_TLOCK, "dbdqqds", fid->fid, flock->type,

				flock->flags, flock->start, flock->length,

					flock->proc_id, flock->client_id);



	if (IS_ERR(req))

		return PTR_ERR(req);



	err = p9pdu_readf(req->rc, clnt->proto_version, "b", status);

	if (err) {

		p9pdu_dump(1, req->rc);

		goto error;

	}

	P9_DPRINTK(P9_DEBUG_9P, "<<< RLOCK status %i\n", *status);

error:

	p9_free_req(clnt, req);

	return err;



}

EXPORT_SYMBOL(p9_client_lock_dotl);

CRA Git | Maintained and supported by SUSTech CRA and CCSE