Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

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

9p: Implement TGETLOCK 



Synopsis

    size[4] TGetlock tag[2] fid[4] getlock[n]
    size[4] RGetlock tag[2] getlock[n]

Description

TGetlock is used to test for the existence of byte range posix locks on a file
identified by given fid. The reply contains getlock structure. If the lock could
be placed it returns F_UNLCK in type field of getlock structure.  Otherwise it
returns the details of the conflicting locks in the getlock structure

    getlock structure:
      type[1] - Type of lock: F_RDLCK, F_WRLCK
      start[8] - Starting offset for lock
      length[8] - Number of bytes to check for the lock
             If length is 0, check for lock in all bytes starting at the location
            'start' through to the end of file
      pid[4] - PID of the process that wants to take lock/owns the task
               in case of reply
      client[4] - Client id of the system that owns the process which
                  has the conflicting lock

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 a099027c

fs/9p/vfs_file.c

+47 −0
Original line number Diff line number Diff line
@@ -211,6 +211,51 @@ static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl) 
	return res;

}



static int v9fs_file_getlock(struct file *filp, struct file_lock *fl)

{

	struct p9_getlock glock;

	struct p9_fid *fid;

	int res = 0;



	fid = filp->private_data;

	BUG_ON(fid == NULL);



	posix_test_lock(filp, fl);

	/*

	 * if we have a conflicting lock locally, no need to validate

	 * with server

	 */

	if (fl->fl_type != F_UNLCK)

		return res;



	/* convert posix lock to p9 tgetlock args */

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

	glock.type = fl->fl_type;

	glock.start = fl->fl_start;

	if (fl->fl_end == OFFSET_MAX)

		glock.length = 0;

	else

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

	glock.proc_id = fl->fl_pid;

	glock.client_id = utsname()->nodename;



	res = p9_client_getlock_dotl(fid, &glock);

	if (res < 0)

		return res;

	if (glock.type != F_UNLCK) {

		fl->fl_type = glock.type;

		fl->fl_start = glock.start;

		if (glock.length == 0)

			fl->fl_end = OFFSET_MAX;

		else

			fl->fl_end = glock.start + glock.length - 1;

		fl->fl_pid = glock.proc_id;

	} else

		fl->fl_type = F_UNLCK;



	return res;

}



/**

 * v9fs_file_lock_dotl - lock a file (or directory)

 * @filp: file to be locked
@@ -238,6 +283,8 @@ static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl) 


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

		ret = v9fs_file_do_lock(filp, cmd, fl);

	else if (IS_GETLK(cmd))

		ret = v9fs_file_getlock(filp, fl);

	else

		ret = -EINVAL;

out_err:

include/net/9p/9p.h

+18 −0
Original line number Diff line number Diff line
@@ -167,6 +167,8 @@ enum p9_msg_t { 
	P9_RFSYNC,

	P9_TLOCK = 52,

	P9_RLOCK,

	P9_TGETLOCK = 54,

	P9_RGETLOCK,

	P9_TLINK = 70,

	P9_RLINK,

	P9_TMKDIR = 72,
@@ -492,6 +494,22 @@ struct p9_flock { 
	char *client_id;

};



/* struct p9_getlock: getlock structure

 * @type - type of lock

 * @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_getlock {

	u8 type;

	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
@@ -250,6 +250,7 @@ int p9_client_mknod_dotl(struct p9_fid *oldfid, char *name, int mode, 
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);

int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *fl);

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

+34 −0
Original line number Diff line number Diff line
@@ -1836,3 +1836,37 @@ int p9_client_lock_dotl(struct p9_fid *fid, struct p9_flock *flock, u8 *status) 


}

EXPORT_SYMBOL(p9_client_lock_dotl);



int p9_client_getlock_dotl(struct p9_fid *fid, struct p9_getlock *glock)

{

	int err;

	struct p9_client *clnt;

	struct p9_req_t *req;



	err = 0;

	clnt = fid->clnt;

	P9_DPRINTK(P9_DEBUG_9P, ">>> TGETLOCK fid %d, type %i start %lld "

		"length %lld proc_id %d client_id %s\n", fid->fid, glock->type,

		glock->start, glock->length, glock->proc_id, glock->client_id);



	req = p9_client_rpc(clnt, P9_TGETLOCK, "dbqqds", fid->fid,  glock->type,

		glock->start, glock->length, glock->proc_id, glock->client_id);



	if (IS_ERR(req))

		return PTR_ERR(req);



	err = p9pdu_readf(req->rc, clnt->proto_version, "bqqds", &glock->type,

			&glock->start, &glock->length, &glock->proc_id,

			&glock->client_id);

	if (err) {

		p9pdu_dump(1, req->rc);

		goto error;

	}

	P9_DPRINTK(P9_DEBUG_9P, "<<< RGETLOCK type %i start %lld length %lld "

		"proc_id %d client_id %s\n", glock->type, glock->start,

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

error:

	p9_free_req(clnt, req);

	return err;

}

EXPORT_SYMBOL(p9_client_getlock_dotl);