afs: Move key to afs_read struct

Stash the key used to authenticate read operations in the afs_read struct.
This will be necessary to reissue the operation against the server if a
read from the cache fails in upcoming cache changes.

Signed-off-by: David Howells <dhowells@redhat.com>
Tested-By: Marc Dionne <marc.dionne@auristor.com>
cc: linux-afs@lists.infradead.org
cc: linux-cachefs@redhat.com
cc: linux-fsdevel@vger.kernel.org
Link: https://lore.kernel.org/r/158861248336.340223.1851189950710196001.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/159465823899.1377938.11925978022348532049.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/160588529557.3465195.7303323479305254243.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161118147693.1232039.13780672951838643842.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161161043340.2537118.511899217704140722.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161340406678.1303470.12676824086429446370.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161539550819.286939.1268332875889175195.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161653806683.2770958.11300984379283401542.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/161789089556.6155.14603302893431820997.stgit@warthog.procyon.org.uk/

diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 17548c1faf02999c7c631dd559fcaf2c430af607..d8825ce63eba3880094556332ff02ac2ad795248 100644 (file)
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -241,6 +241,7 @@ retry:
                return ERR_PTR(-ENOMEM);
 
        refcount_set(&req->usage, 1);
+       req->key = key_get(key);
        req->nr_pages = nr_pages;
        req->actual_len = i_size; /* May change */
        req->len = nr_pages * PAGE_SIZE; /* We can ask for more than there is */
@@ -305,7 +306,7 @@ retry:
 
        if (!test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) {
                trace_afs_reload_dir(dvnode);
-               ret = afs_fetch_data(dvnode, key, req);
+               ret = afs_fetch_data(dvnode, req);
                if (ret < 0)
                        goto error_unlock;
 

diff --git a/fs/afs/file.c b/fs/afs/file.c
index f1bae0b0a9c0c3574263dadd1d5dbe3e59e115e0..af6471defec3e0a7ad639c0b71e52f2a6e2374e1 100644 (file)
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -198,6 +198,7 @@ void afs_put_read(struct afs_read *req)
                        if (req->pages != req->array)
                                kfree(req->pages);
                }
+               key_put(req->key);
                kfree(req);
        }
 }
@@ -228,7 +229,7 @@ static const struct afs_operation_ops afs_fetch_data_operation = {
 /*
  * Fetch file data from the volume.
  */
-int afs_fetch_data(struct afs_vnode *vnode, struct key *key, struct afs_read *req)
+int afs_fetch_data(struct afs_vnode *vnode, struct afs_read *req)
 {
        struct afs_operation *op;
 
@@ -237,9 +238,9 @@ int afs_fetch_data(struct afs_vnode *vnode, struct key *key, struct afs_read *re
               vnode->fid.vid,
               vnode->fid.vnode,
               vnode->fid.unique,
-              key_serial(key));
+              key_serial(req->key));
 
-       op = afs_alloc_operation(key, vnode->volume);
+       op = afs_alloc_operation(req->key, vnode->volume);
        if (IS_ERR(op))
                return PTR_ERR(op);
 
@@ -278,6 +279,7 @@ int afs_page_filler(void *data, struct page *page)
         * unmarshalling code will clear the unfilled space.
         */
        refcount_set(&req->usage, 1);
+       req->key = key_get(key);
        req->pos = (loff_t)page->index << PAGE_SHIFT;
        req->len = PAGE_SIZE;
        req->nr_pages = 1;
@@ -287,7 +289,7 @@ int afs_page_filler(void *data, struct page *page)
 
        /* read the contents of the file from the server into the
         * page */
-       ret = afs_fetch_data(vnode, key, req);
+       ret = afs_fetch_data(vnode, req);
        afs_put_read(req);
 
        if (ret < 0) {
@@ -372,7 +374,6 @@ static int afs_readpages_one(struct file *file, struct address_space *mapping,
        struct afs_read *req;
        struct list_head *p;
        struct page *first, *page;
-       struct key *key = afs_file_key(file);
        pgoff_t index;
        int ret, n, i;
 
@@ -396,6 +397,7 @@ static int afs_readpages_one(struct file *file, struct address_space *mapping,
 
        refcount_set(&req->usage, 1);
        req->vnode = vnode;
+       req->key = key_get(afs_file_key(file));
        req->page_done = afs_readpages_page_done;
        req->pos = first->index;
        req->pos <<= PAGE_SHIFT;
@@ -425,11 +427,11 @@ static int afs_readpages_one(struct file *file, struct address_space *mapping,
        } while (req->nr_pages < n);
 
        if (req->nr_pages == 0) {
-               kfree(req);
+               afs_put_read(req);
                return 0;
        }
 
-       ret = afs_fetch_data(vnode, key, req);
+       ret = afs_fetch_data(vnode, req);
        if (ret < 0)
                goto error;
 

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index fd437d4722b56e3eac6882801868aaa6c1ecddb5..995fef267be71aa9ef0bd2d5a00375f2b722f99f 100644 (file)
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -204,6 +204,7 @@ struct afs_read {
        loff_t                  actual_len;     /* How much we're actually getting */
        loff_t                  remain;         /* Amount remaining */
        loff_t                  file_size;      /* File size returned by server */
+       struct key              *key;           /* The key to use to reissue the read */
        afs_dataversion_t       data_version;   /* Version number returned by server */
        refcount_t              usage;
        unsigned int            index;          /* Which page we're reading into */
@@ -1045,7 +1046,7 @@ extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *);
 extern void afs_put_wb_key(struct afs_wb_key *);
 extern int afs_open(struct inode *, struct file *);
 extern int afs_release(struct inode *, struct file *);
-extern int afs_fetch_data(struct afs_vnode *, struct key *, struct afs_read *);
+extern int afs_fetch_data(struct afs_vnode *, struct afs_read *);
 extern int afs_page_filler(void *, struct page *);
 extern void afs_put_read(struct afs_read *);
 

diff --git a/fs/afs/write.c b/fs/afs/write.c
index babc84dd97197d11e8100b617a9af5deb4080a36..a91da2e680da7ab355e2c89d3c18c99ff1794125 100644 (file)
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -25,9 +25,10 @@ int afs_set_page_dirty(struct page *page)
 /*
  * partly or wholly fill a page that's under preparation for writing
  */
-static int afs_fill_page(struct afs_vnode *vnode, struct key *key,
+static int afs_fill_page(struct file *file,
                         loff_t pos, unsigned int len, struct page *page)
 {
+       struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
        struct afs_read *req;
        size_t p;
        void *data;
@@ -49,6 +50,7 @@ static int afs_fill_page(struct afs_vnode *vnode, struct key *key,
                return -ENOMEM;
 
        refcount_set(&req->usage, 1);
+       req->key = key_get(afs_file_key(file));
        req->pos = pos;
        req->len = len;
        req->nr_pages = 1;
@@ -56,7 +58,7 @@ static int afs_fill_page(struct afs_vnode *vnode, struct key *key,
        req->pages[0] = page;
        get_page(page);
 
-       ret = afs_fetch_data(vnode, key, req);
+       ret = afs_fetch_data(vnode, req);
        afs_put_read(req);
        if (ret < 0) {
                if (ret == -ENOENT) {
@@ -80,7 +82,6 @@ int afs_write_begin(struct file *file, struct address_space *mapping,
 {
        struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
        struct page *page;
-       struct key *key = afs_file_key(file);
        unsigned long priv;
        unsigned f, from = pos & (PAGE_SIZE - 1);
        unsigned t, to = from + len;
@@ -95,7 +96,7 @@ int afs_write_begin(struct file *file, struct address_space *mapping,
                return -ENOMEM;
 
        if (!PageUptodate(page) && len != PAGE_SIZE) {
-               ret = afs_fill_page(vnode, key, pos & PAGE_MASK, PAGE_SIZE, page);
+               ret = afs_fill_page(file, pos & PAGE_MASK, PAGE_SIZE, page);
                if (ret < 0) {
                        unlock_page(page);
                        put_page(page);
@@ -163,7 +164,6 @@ int afs_write_end(struct file *file, struct address_space *mapping,
                  struct page *page, void *fsdata)
 {
        struct afs_vnode *vnode = AFS_FS_I(file_inode(file));
-       struct key *key = afs_file_key(file);
        unsigned long priv;
        unsigned int f, from = pos & (PAGE_SIZE - 1);
        unsigned int t, to = from + copied;
@@ -193,7 +193,7 @@ int afs_write_end(struct file *file, struct address_space *mapping,
                         * unmarshalling routine will take care of clearing any
                         * bits that are beyond the EOF.
                         */
-                       ret = afs_fill_page(vnode, key, pos + copied,
+                       ret = afs_fill_page(file, pos + copied,
                                            len - copied, page);
                        if (ret < 0)
                                goto out;