fs/9p: This patch implements TLCREATE for 9p2000.L protocol.
authorVenkateswararao Jujjuri (JV) <jvrao@linux.vnet.ibm.com>
Fri, 18 Jun 2010 01:27:46 +0000 (18:27 -0700)
committerEric Van Hensbergen <ericvh@gmail.com>
Mon, 2 Aug 2010 19:28:32 +0000 (14:28 -0500)
SYNOPSIS

    size[4] Tlcreate tag[2] fid[4] name[s] flags[4] mode[4] gid[4]

    size[4] Rlcreate tag[2] qid[13] iounit[4]

DESCRIPTION

The Tlreate request asks the file server to create a new regular file with the
name supplied, in the directory (dir) represented by fid.
The mode argument specifies the permissions to use. New file is created with
the uid if the fid and with supplied gid.

The flags argument represent Linux access mode flags with which the caller
is requesting to open the file with. Protocol allows all the Linux access
modes but it is upto the server to allow/disallow any of these acess modes.
If the server doesn't support any of the access mode, it is expected to
return error.

Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
fs/9p/vfs_inode.c
include/net/9p/9p.h
include/net/9p/client.h
net/9p/client.c

index 39dc795673229bc7870754261ed239fc4b0be617..2ac245902a4ffd2b4650985a47a40a3f01fdb01e 100644 (file)
@@ -641,6 +641,118 @@ error:
        return ERR_PTR(err);
 }
 
+/**
+ * v9fs_vfs_create_dotl - VFS hook to create files for 9P2000.L protocol.
+ * @dir: directory inode that is being created
+ * @dentry:  dentry that is being deleted
+ * @mode: create permissions
+ * @nd: path information
+ *
+ */
+
+static int
+v9fs_vfs_create_dotl(struct inode *dir, struct dentry *dentry, int mode,
+               struct nameidata *nd)
+{
+       int err = 0;
+       char *name = NULL;
+       gid_t gid;
+       int flags;
+       struct v9fs_session_info *v9ses;
+       struct p9_fid *fid = NULL;
+       struct p9_fid *dfid, *ofid;
+       struct file *filp;
+       struct p9_qid qid;
+       struct inode *inode;
+
+       v9ses = v9fs_inode2v9ses(dir);
+       if (nd && nd->flags & LOOKUP_OPEN)
+               flags = nd->intent.open.flags - 1;
+       else
+               flags = O_RDWR;
+
+       name = (char *) dentry->d_name.name;
+       P9_DPRINTK(P9_DEBUG_VFS, "v9fs_vfs_create_dotl: name:%s flags:0x%x "
+                       "mode:0x%x\n", name, flags, mode);
+
+       dfid = v9fs_fid_lookup(dentry->d_parent);
+       if (IS_ERR(dfid)) {
+               err = PTR_ERR(dfid);
+               P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
+               return err;
+       }
+
+       /* clone a fid to use for creation */
+       ofid = p9_client_walk(dfid, 0, NULL, 1);
+       if (IS_ERR(ofid)) {
+               err = PTR_ERR(ofid);
+               P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
+               return err;
+       }
+
+       gid = v9fs_get_fsgid_for_create(dir);
+       err = p9_client_create_dotl(ofid, name, flags, mode, gid, &qid);
+       if (err < 0) {
+               P9_DPRINTK(P9_DEBUG_VFS,
+                               "p9_client_open_dotl failed in creat %d\n",
+                               err);
+               goto error;
+       }
+
+       /* No need to populate the inode if we are not opening the file AND
+        * not in cached mode.
+        */
+       if (!v9ses->cache && !(nd && nd->flags & LOOKUP_OPEN)) {
+               /* Not in cached mode. No need to populate inode with stat */
+               dentry->d_op = &v9fs_dentry_operations;
+               p9_client_clunk(ofid);
+               d_instantiate(dentry, NULL);
+               return 0;
+       }
+
+       /* Now walk from the parent so we can get an unopened fid. */
+       fid = p9_client_walk(dfid, 1, &name, 1);
+       if (IS_ERR(fid)) {
+               err = PTR_ERR(fid);
+               P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
+               fid = NULL;
+               goto error;
+       }
+
+       /* instantiate inode and assign the unopened fid to dentry */
+       inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
+       if (IS_ERR(inode)) {
+               err = PTR_ERR(inode);
+               P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
+               goto error;
+       }
+       dentry->d_op = &v9fs_cached_dentry_operations;
+       d_instantiate(dentry, inode);
+       err = v9fs_fid_add(dentry, fid);
+       if (err < 0)
+               goto error;
+
+       /* if we are opening a file, assign the open fid to the file */
+       if (nd && nd->flags & LOOKUP_OPEN) {
+               filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
+               if (IS_ERR(filp)) {
+                       p9_client_clunk(ofid);
+                       return PTR_ERR(filp);
+               }
+               filp->private_data = ofid;
+       } else
+               p9_client_clunk(ofid);
+
+       return 0;
+
+error:
+       if (ofid)
+               p9_client_clunk(ofid);
+       if (fid)
+               p9_client_clunk(fid);
+       return err;
+}
+
 /**
  * v9fs_vfs_create - VFS hook to create files
  * @dir: directory inode that is being created
@@ -1808,7 +1920,7 @@ static const struct inode_operations v9fs_dir_inode_operations_dotu = {
 };
 
 static const struct inode_operations v9fs_dir_inode_operations_dotl = {
-       .create = v9fs_vfs_create,
+       .create = v9fs_vfs_create_dotl,
        .lookup = v9fs_vfs_lookup,
        .link = v9fs_vfs_link_dotl,
        .symlink = v9fs_vfs_symlink_dotl,
index 091b471d8f05daa9f062e7be66aa76cf66e19584..06d111d61038c9f6a2b64b1b6eb212d00498a1d3 100644 (file)
@@ -92,6 +92,8 @@ do { \
  * @P9_RSYMLINK: make symlink response
  * @P9_TMKNOD: create a special file object request
  * @P9_RMKNOD: create a special file object response
+ * @P9_TLCREATE: prepare a handle for I/O on an new file for 9P2000.L
+ * @P9_RLCREATE: response with file access information for 9P2000.L
  * @P9_TRENAME: rename request
  * @P9_RRENAME: rename response
  * @P9_TMKDIR: create a directory request
@@ -137,6 +139,8 @@ do { \
 enum p9_msg_t {
        P9_TSTATFS = 8,
        P9_RSTATFS,
+       P9_TLCREATE = 14,
+       P9_RLCREATE,
        P9_TSYMLINK = 16,
        P9_RSYMLINK,
        P9_TMKNOD = 18,
index 55d913a9b7970daa4fe33bbf292050b7a89f7f10..d755c0ed67502fcf9c0cccc8e07f127417ef3a9d 100644 (file)
@@ -229,6 +229,8 @@ int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
 int p9_client_link(struct p9_fid *fid, struct p9_fid *oldfid, char *newname);
 int p9_client_symlink(struct p9_fid *fid, char *name, char *symname, gid_t gid,
                                                        struct p9_qid *qid);
+int p9_client_create_dotl(struct p9_fid *ofid, char *name, u32 flags, u32 mode,
+               gid_t gid, struct p9_qid *qid);
 int p9_client_clunk(struct p9_fid *fid);
 int p9_client_remove(struct p9_fid *fid);
 int p9_client_read(struct p9_fid *fid, char *data, char __user *udata,
index a3bdd341f2ac13b536682a8aa6d423654158eb5a..e580409b1052677b9f39a4e6275cea7248305e64 100644 (file)
@@ -1050,6 +1050,50 @@ error:
 }
 EXPORT_SYMBOL(p9_client_open);
 
+int p9_client_create_dotl(struct p9_fid *ofid, char *name, u32 flags, u32 mode,
+               gid_t gid, struct p9_qid *qid)
+{
+       int err = 0;
+       struct p9_client *clnt;
+       struct p9_req_t *req;
+       int iounit;
+
+       P9_DPRINTK(P9_DEBUG_9P,
+                       ">>> TLCREATE fid %d name %s flags %d mode %d gid %d\n",
+                       ofid->fid, name, flags, mode, gid);
+       clnt = ofid->clnt;
+
+       if (ofid->mode != -1)
+               return -EINVAL;
+
+       req = p9_client_rpc(clnt, P9_TLCREATE, "dsddd", ofid->fid, name, flags,
+                       mode, gid);
+       if (IS_ERR(req)) {
+               err = PTR_ERR(req);
+               goto error;
+       }
+
+       err = p9pdu_readf(req->rc, clnt->proto_version, "Qd", qid, &iounit);
+       if (err) {
+               p9pdu_dump(1, req->rc);
+               goto free_and_error;
+       }
+
+       P9_DPRINTK(P9_DEBUG_9P, "<<< RLCREATE qid %x.%llx.%x iounit %x\n",
+                       qid->type,
+                       (unsigned long long)qid->path,
+                       qid->version, iounit);
+
+       ofid->mode = mode;
+       ofid->iounit = iounit;
+
+free_and_error:
+       p9_free_req(clnt, req);
+error:
+       return err;
+}
+EXPORT_SYMBOL(p9_client_create_dotl);
+
 int p9_client_fcreate(struct p9_fid *fid, char *name, u32 perm, int mode,
                     char *extension)
 {