afs: Get YFS ACLs and information through xattrs

The YFS/AuriStor variant of AFS provides more capable ACLs and provides
per-volume ACLs and per-file ACLs as well as per-directory ACLs.  It also
provides some extra information that can be retrieved through four ACLs:

 (1) afs.yfs.acl

     The YFS file ACL (not the same format as afs.acl).

 (2) afs.yfs.vol_acl

     The YFS volume ACL.

 (3) afs.yfs.acl_inherited

     "1" if a file's ACL is inherited from its parent directory, "0"
     otherwise.

 (4) afs.yfs.acl_num_cleaned

     The number of of ACEs removed from the ACL by the server because the
     PT entries were removed from the PTS database (ie. the subject is no
     longer known).

Signed-off-by: David Howells <dhowells@redhat.com>

4 files changed, 304 insertions, 4 deletions

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 5269824244c6..b800b4e286d3 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -1371,6 +1371,19 @@ extern int yfs_fs_inline_bulk_status(struct afs_fs_cursor *, struct afs_net *,
                                      struct afs_callback *, unsigned int,
                                      struct afs_volsync *);
 
+struct yfs_acl {
+        struct afs_acl  *acl;           /* Dir/file/symlink ACL */
+        struct afs_acl  *vol_acl;       /* Whole volume ACL */
+        u32             inherit_flag;   /* True if ACL is inherited from parent dir */
+        u32             num_cleaned;    /* Number of ACEs removed due to subject removal */
+        unsigned int    flags;
+#define YFS_ACL_WANT_ACL        0x01    /* Set if caller wants ->acl */
+#define YFS_ACL_WANT_VOL_ACL    0x02    /* Set if caller wants ->vol_acl */
+};
+
+extern void yfs_free_opaque_acl(struct yfs_acl *);
+extern struct yfs_acl *yfs_fs_fetch_opaque_acl(struct afs_fs_cursor *, unsigned int);
+
 /*
  * Miscellaneous inline functions.
  */
diff --git a/fs/afs/protocol_yfs.h b/fs/afs/protocol_yfs.h
index d443e2bfa094..915b9d10cdf3 100644
--- a/fs/afs/protocol_yfs.h
+++ b/fs/afs/protocol_yfs.h
@@ -31,9 +31,9 @@ enum YFS_CM_Operations {
 };
 
 enum YFS_FS_Operations {
-        YFSFETCHACL             = 64131, /* YFS Fetch file ACL */
+        YFSFETCHACL             = 64131, /* YFS Fetch file AFS3 ACL */
         YFSFETCHSTATUS          = 64132, /* YFS Fetch file status */
-        YFSSTOREACL             = 64134, /* YFS Store file ACL */
+        YFSSTOREACL             = 64134, /* YFS Store file AFS3 ACL */
         YFSSTORESTATUS          = 64135, /* YFS Store file status */
         YFSREMOVEFILE           = 64136, /* YFS Remove a file */
         YFSCREATEFILE           = 64137, /* YFS Create a file */
@@ -49,7 +49,7 @@ enum YFS_FS_Operations {
         YFSRELEASELOCK          = 64158, /* YFS Release a file lock */
         YFSLOOKUP               = 64161, /* YFS lookup file in directory */
         YFSFLUSHCPS             = 64165,
-        YFSFETCHOPAQUEACL       = 64168,
+        YFSFETCHOPAQUEACL       = 64168, /* YFS Fetch file YFS ACL */
         YFSWHOAMI               = 64170,
         YFSREMOVEACL            = 64171,
         YFSREMOVEFILE2          = 64173,
diff --git a/fs/afs/xattr.c b/fs/afs/xattr.c
index 31db360947a6..a5c82b0ad539 100644
--- a/fs/afs/xattr.c
+++ b/fs/afs/xattr.c
@@ -19,7 +19,11 @@ static const char afs_xattr_list[] =
         "afs.acl\0"
         "afs.cell\0"
         "afs.fid\0"
-        "afs.volume";
+        "afs.volume\0"
+        "afs.yfs.acl\0"
+        "afs.yfs.acl_inherited\0"
+        "afs.yfs.acl_num_cleaned\0"
+        "afs.yfs.vol_acl";
 
 /*
  * Retrieve a list of the supported xattrs.
@@ -134,6 +138,100 @@ static const struct xattr_handler afs_xattr_afs_acl_handler = {
 };
 
 /*
+ * Get a file's YFS ACL.
+ */
+static int afs_xattr_get_yfs(const struct xattr_handler *handler,
+                             struct dentry *dentry,
+                             struct inode *inode, const char *name,
+                             void *buffer, size_t size)
+{
+        struct afs_fs_cursor fc;
+        struct afs_vnode *vnode = AFS_FS_I(inode);
+        struct yfs_acl *yacl = NULL;
+        struct key *key;
+        unsigned int flags = 0;
+        char buf[16], *data;
+        int which = 0, dsize, ret;
+
+        if (strcmp(name, "acl") == 0)
+                which = 0;
+        else if (strcmp(name, "acl_inherited") == 0)
+                which = 1;
+        else if (strcmp(name, "acl_num_cleaned") == 0)
+                which = 2;
+        else if (strcmp(name, "vol_acl") == 0)
+                which = 3;
+        else
+                return -EOPNOTSUPP;
+
+        if (which == 0)
+                flags |= YFS_ACL_WANT_ACL;
+        else if (which == 3)
+                flags |= YFS_ACL_WANT_VOL_ACL;
+
+        key = afs_request_key(vnode->volume->cell);
+        if (IS_ERR(key))
+                return PTR_ERR(key);
+
+        ret = -ERESTARTSYS;
+        if (afs_begin_vnode_operation(&fc, vnode, key)) {
+                while (afs_select_fileserver(&fc)) {
+                        fc.cb_break = afs_calc_vnode_cb_break(vnode);
+                        yacl = yfs_fs_fetch_opaque_acl(&fc, flags);
+                }
+
+                afs_check_for_remote_deletion(&fc, fc.vnode);
+                afs_vnode_commit_status(&fc, vnode, fc.cb_break);
+                ret = afs_end_vnode_operation(&fc);
+        }
+
+        if (ret == 0) {
+                switch (which) {
+                case 0:
+                        data = yacl->acl->data;
+                        dsize = yacl->acl->size;
+                        break;
+                case 1:
+                        data = buf;
+                        dsize = snprintf(buf, sizeof(buf), "%u",
+                                         yacl->inherit_flag);
+                        break;
+                case 2:
+                        data = buf;
+                        dsize = snprintf(buf, sizeof(buf), "%u",
+                                         yacl->num_cleaned);
+                        break;
+                case 3:
+                        data = yacl->vol_acl->data;
+                        dsize = yacl->vol_acl->size;
+                        break;
+                default:
+                        ret = -EOPNOTSUPP;
+                        goto out;
+                }
+
+                ret = dsize;
+                if (size > 0) {
+                        if (dsize > size) {
+                                ret = -ERANGE;
+                                goto out;
+                        }
+                        memcpy(buffer, data, dsize);
+                }
+        }
+
+out:
+        yfs_free_opaque_acl(yacl);
+        key_put(key);
+        return ret;
+}
+
+static const struct xattr_handler afs_xattr_yfs_handler = {
+        .prefix = "afs.yfs.",
+        .get    = afs_xattr_get_yfs,
+};
+
+/*
  * Get the name of the cell on which a file resides.
  */
 static int afs_xattr_get_cell(const struct xattr_handler *handler,
@@ -227,5 +325,6 @@ const struct xattr_handler *afs_xattr_handlers[] = {
         &afs_xattr_afs_cell_handler,
         &afs_xattr_afs_fid_handler,
         &afs_xattr_afs_volume_handler,
+        &afs_xattr_yfs_handler,         /* afs.yfs. prefix */
         NULL
 };
diff --git a/fs/afs/yfsclient.c b/fs/afs/yfsclient.c
index 055840aa07f6..13eafa764d71 100644
--- a/fs/afs/yfsclient.c
+++ b/fs/afs/yfsclient.c
@@ -2204,3 +2204,191 @@ int yfs_fs_inline_bulk_status(struct afs_fs_cursor *fc,
         afs_make_call(&fc->ac, call, GFP_NOFS);
         return afs_wait_for_call_to_complete(call, &fc->ac);
 }
+
+/*
+ * Deliver reply data to an YFS.FetchOpaqueACL.
+ */
+static int yfs_deliver_fs_fetch_opaque_acl(struct afs_call *call)
+{
+        struct afs_volsync *volsync = call->reply[2];
+        struct afs_vnode *vnode = call->reply[1];
+        struct yfs_acl *yacl =  call->reply[0];
+        struct afs_acl *acl;
+        const __be32 *bp;
+        unsigned int size;
+        int ret;
+
+        _enter("{%u}", call->unmarshall);
+
+        switch (call->unmarshall) {
+        case 0:
+                afs_extract_to_tmp(call);
+                call->unmarshall++;
+
+                /* Extract the file ACL length */
+        case 1:
+                ret = afs_extract_data(call, true);
+                if (ret < 0)
+                        return ret;
+
+                size = call->count2 = ntohl(call->tmp);
+                size = round_up(size, 4);
+
+                if (yacl->flags & YFS_ACL_WANT_ACL) {
+                        acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL);
+                        if (!acl)
+                                return -ENOMEM;
+                        yacl->acl = acl;
+                        acl->size = call->count2;
+                        afs_extract_begin(call, acl->data, size);
+                } else {
+                        iov_iter_discard(&call->iter, READ, size);
+                }
+                call->unmarshall++;
+
+                /* Extract the file ACL */
+        case 2:
+                ret = afs_extract_data(call, true);
+                if (ret < 0)
+                        return ret;
+
+                afs_extract_to_tmp(call);
+                call->unmarshall++;
+
+                /* Extract the volume ACL length */
+        case 3:
+                ret = afs_extract_data(call, true);
+                if (ret < 0)
+                        return ret;
+
+                size = call->count2 = ntohl(call->tmp);
+                size = round_up(size, 4);
+
+                if (yacl->flags & YFS_ACL_WANT_VOL_ACL) {
+                        acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL);
+                        if (!acl)
+                                return -ENOMEM;
+                        yacl->vol_acl = acl;
+                        acl->size = call->count2;
+                        afs_extract_begin(call, acl->data, size);
+                } else {
+                        iov_iter_discard(&call->iter, READ, size);
+                }
+                call->unmarshall++;
+
+                /* Extract the volume ACL */
+        case 4:
+                ret = afs_extract_data(call, true);
+                if (ret < 0)
+                        return ret;
+
+                afs_extract_to_buf(call,
+                                   sizeof(__be32) * 2 +
+                                   sizeof(struct yfs_xdr_YFSFetchStatus) +
+                                   sizeof(struct yfs_xdr_YFSVolSync));
+                call->unmarshall++;
+
+                /* extract the metadata */
+        case 5:
+                ret = afs_extract_data(call, false);
+                if (ret < 0)
+                        return ret;
+
+                bp = call->buffer;
+                yacl->inherit_flag = ntohl(*bp++);
+                yacl->num_cleaned = ntohl(*bp++);
+                ret = yfs_decode_status(call, &bp, &vnode->status, vnode,
+                                        &call->expected_version, NULL);
+                if (ret < 0)
+                        return ret;
+                xdr_decode_YFSVolSync(&bp, volsync);
+
+                call->unmarshall++;
+
+        case 6:
+                break;
+        }
+
+        _leave(" = 0 [done]");
+        return 0;
+}
+
+void yfs_free_opaque_acl(struct yfs_acl *yacl)
+{
+        if (yacl) {
+                kfree(yacl->acl);
+                kfree(yacl->vol_acl);
+                kfree(yacl);
+        }
+}
+
+static void yfs_destroy_fs_fetch_opaque_acl(struct afs_call *call)
+{
+        yfs_free_opaque_acl(call->reply[0]);
+        afs_flat_call_destructor(call);
+}
+
+/*
+ * YFS.FetchOpaqueACL operation type
+ */
+static const struct afs_call_type yfs_RXYFSFetchOpaqueACL = {
+        .name           = "YFS.FetchOpaqueACL",
+        .op             = yfs_FS_FetchOpaqueACL,
+        .deliver        = yfs_deliver_fs_fetch_opaque_acl,
+        .destructor     = yfs_destroy_fs_fetch_opaque_acl,
+};
+
+/*
+ * Fetch the YFS advanced ACLs for a file.
+ */
+struct yfs_acl *yfs_fs_fetch_opaque_acl(struct afs_fs_cursor *fc,
+                                        unsigned int flags)
+{
+        struct afs_vnode *vnode = fc->vnode;
+        struct afs_call *call;
+        struct yfs_acl *yacl;
+        struct afs_net *net = afs_v2net(vnode);
+        __be32 *bp;
+
+        _enter(",%x,{%llx:%llu},,",
+               key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
+
+        call = afs_alloc_flat_call(net, &yfs_RXYFSFetchOpaqueACL,
+                                   sizeof(__be32) * 2 +
+                                   sizeof(struct yfs_xdr_YFSFid),
+                                   sizeof(__be32) * 2 +
+                                   sizeof(struct yfs_xdr_YFSFetchStatus) +
+                                   sizeof(struct yfs_xdr_YFSVolSync));
+        if (!call)
+                goto nomem;
+
+        yacl = kzalloc(sizeof(struct yfs_acl), GFP_KERNEL);
+        if (!yacl)
+                goto nomem_call;
+
+        yacl->flags = flags;
+        call->key = fc->key;
+        call->reply[0] = yacl;
+        call->reply[1] = vnode;
+        call->reply[2] = NULL; /* volsync */
+        call->ret_reply0 = true;
+
+        /* marshall the parameters */
+        bp = call->request;
+        bp = xdr_encode_u32(bp, YFSFETCHOPAQUEACL);
+        bp = xdr_encode_u32(bp, 0); /* RPC flags */
+        bp = xdr_encode_YFSFid(bp, &vnode->fid);
+        yfs_check_req(call, bp);
+
+        call->cb_break = fc->cb_break;
+        afs_use_fs_server(call, fc->cbi);
+        trace_afs_make_fs_call(call, &vnode->fid);
+        afs_make_call(&fc->ac, call, GFP_KERNEL);
+        return (struct yfs_acl *)afs_wait_for_call_to_complete(call, &fc->ac);
+
+nomem_call:
+        afs_put_call(call);
+nomem:
+        fc->ac.error = -ENOMEM;
+        return ERR_PTR(-ENOMEM);
+}