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: M. Mohan Kumar <mohan@in.ibm.com>
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>

diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
index 09861295eef92f42b3e54c08cd58a830115b327b..d26db1932f7a44a8ce5cbb0185c72af6143112e0 100644 (file)
--- a/fs/9p/v9fs_vfs.h
+++ b/fs/9p/v9fs_vfs.h
@@ -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)

diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index fdf303207c7289e93006a91a7bea223c38849303..6f77abd23184240276dfc4284865ce7b7450c6b1 100644 (file)
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -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,
 };

diff --git a/include/net/9p/9p.h b/include/net/9p/9p.h
index 55e96057f47fd636b817ef53df332a16ba754b8f..1859a2560cc5f8de8750f6e42f9c1d8a3e3f8ff9 100644 (file)
--- a/include/net/9p/9p.h
+++ b/include/net/9p/9p.h
@@ -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;

diff --git a/include/net/9p/client.h b/include/net/9p/client.h
index 8744e3ad4a07462040725b86bf1af89929a8db9d..d7dcb142e3bb4b89a0ae304998c60415d434d12d 100644 (file)
--- a/include/net/9p/client.h
+++ b/include/net/9p/client.h
@@ -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);
 

diff --git a/net/9p/client.c b/net/9p/client.c
index 30c4a1b224fb55c5acda6e30b6cf2376b9dd965e..fbd2b195801c80a50edb922cc1f1dad374fecc1c 100644 (file)
--- a/net/9p/client.c
+++ b/net/9p/client.c
@@ -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);