fs/afs/fs_operation.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* Fileserver-directed operation handling.
   3  *
   4  * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/slab.h>
  10 #include <linux/fs.h>
  11 #include "internal.h"
  12
  13 static atomic_t afs_operation_debug_counter;
  14
  15 /*
  16  * Create an operation against a volume.
  17  */
  18 struct afs_operation *afs_alloc_operation(struct key *key, struct afs_volume *volume)
  19 {
  20         struct afs_operation *op;
  21
  22         _enter("");
  23
  24         op = kzalloc(sizeof(*op), GFP_KERNEL);
  25         if (!op)
  26                 return ERR_PTR(-ENOMEM);
  27
  28         if (!key) {
  29                 key = afs_request_key(volume->cell);
  30                 if (IS_ERR(key)) {
  31                         kfree(op);
  32                         return ERR_CAST(key);
  33                 }
  34         } else {
  35                 key_get(key);
  36         }
  37
  38         op->key         = key;
  39         op->volume      = afs_get_volume(volume, afs_volume_trace_get_new_op);
  40         op->net         = volume->cell->net;
  41         op->cb_v_break  = volume->cb_v_break;
  42         op->debug_id    = atomic_inc_return(&afs_operation_debug_counter);
  43         op->nr_iterations = -1;
  44         afs_op_set_error(op, -EDESTADDRREQ);
  45
  46         _leave(" = [op=%08x]", op->debug_id);
  47         return op;
  48 }
  49
  50 /*
  51  * Lock the vnode(s) being operated upon.
  52  */
  53 static bool afs_get_io_locks(struct afs_operation *op)
  54 {
  55         struct afs_vnode *vnode = op->file[0].vnode;
  56         struct afs_vnode *vnode2 = op->file[1].vnode;
  57
  58         _enter("");
  59
  60         if (op->flags & AFS_OPERATION_UNINTR) {
  61                 mutex_lock(&vnode->io_lock);
  62                 op->flags |= AFS_OPERATION_LOCK_0;
  63                 _leave(" = t [1]");
  64                 return true;
  65         }
  66
  67         if (!vnode2 || !op->file[1].need_io_lock || vnode == vnode2)
  68                 vnode2 = NULL;
  69
  70         if (vnode2 > vnode)
  71                 swap(vnode, vnode2);
  72
  73         if (mutex_lock_interruptible(&vnode->io_lock) < 0) {
  74                 afs_op_set_error(op, -ERESTARTSYS);
  75                 op->flags |= AFS_OPERATION_STOP;
  76                 _leave(" = f [I 0]");
  77                 return false;
  78         }
  79         op->flags |= AFS_OPERATION_LOCK_0;
  80
  81         if (vnode2) {
  82                 if (mutex_lock_interruptible_nested(&vnode2->io_lock, 1) < 0) {
  83                         afs_op_set_error(op, -ERESTARTSYS);
  84                         op->flags |= AFS_OPERATION_STOP;
  85                         mutex_unlock(&vnode->io_lock);
  86                         op->flags &= ~AFS_OPERATION_LOCK_0;
  87                         _leave(" = f [I 1]");
  88                         return false;
  89                 }
  90                 op->flags |= AFS_OPERATION_LOCK_1;
  91         }
  92
  93         _leave(" = t [2]");
  94         return true;
  95 }
  96
  97 static void afs_drop_io_locks(struct afs_operation *op)
  98 {
  99         struct afs_vnode *vnode = op->file[0].vnode;
 100         struct afs_vnode *vnode2 = op->file[1].vnode;
 101
 102         _enter("");
 103
 104         if (op->flags & AFS_OPERATION_LOCK_1)
 105                 mutex_unlock(&vnode2->io_lock);
 106         if (op->flags & AFS_OPERATION_LOCK_0)
 107                 mutex_unlock(&vnode->io_lock);
 108 }
 109
 110 static void afs_prepare_vnode(struct afs_operation *op, struct afs_vnode_param *vp,
 111                               unsigned int index)
 112 {
 113         struct afs_vnode *vnode = vp->vnode;
 114
 115         if (vnode) {
 116                 vp->fid                 = vnode->fid;
 117                 vp->dv_before           = vnode->status.data_version;
 118                 vp->cb_break_before     = afs_calc_vnode_cb_break(vnode);
 119                 if (vnode->lock_state != AFS_VNODE_LOCK_NONE)
 120                         op->flags       |= AFS_OPERATION_CUR_ONLY;
 121                 if (vp->modification)
 122                         set_bit(AFS_VNODE_MODIFYING, &vnode->flags);
 123         }
 124
 125         if (vp->fid.vnode)
 126                 _debug("PREP[%u] {%llx:%llu.%u}",
 127                        index, vp->fid.vid, vp->fid.vnode, vp->fid.unique);
 128 }
 129
 130 /*
 131  * Begin an operation on the fileserver.
 132  *
 133  * Fileserver operations are serialised on the server by vnode, so we serialise
 134  * them here also using the io_lock.
 135  */
 136 bool afs_begin_vnode_operation(struct afs_operation *op)
 137 {
 138         struct afs_vnode *vnode = op->file[0].vnode;
 139
 140         ASSERT(vnode);
 141
 142         _enter("");
 143
 144         if (op->file[0].need_io_lock)
 145                 if (!afs_get_io_locks(op))
 146                         return false;
 147
 148         afs_prepare_vnode(op, &op->file[0], 0);
 149         afs_prepare_vnode(op, &op->file[1], 1);
 150         op->cb_v_break = op->volume->cb_v_break;
 151         _leave(" = true");
 152         return true;
 153 }
 154
 155 /*
 156  * Tidy up a filesystem cursor and unlock the vnode.
 157  */
 158 static void afs_end_vnode_operation(struct afs_operation *op)
 159 {
 160         _enter("");
 161
 162         switch (afs_op_error(op)) {
 163         case -EDESTADDRREQ:
 164         case -EADDRNOTAVAIL:
 165         case -ENETUNREACH:
 166         case -EHOSTUNREACH:
 167                 afs_dump_edestaddrreq(op);
 168                 break;
 169         }
 170
 171         afs_drop_io_locks(op);
 172 }
 173
 174 /*
 175  * Wait for an in-progress operation to complete.
 176  */
 177 void afs_wait_for_operation(struct afs_operation *op)
 178 {
 179         _enter("");
 180
 181         while (afs_select_fileserver(op)) {
 182                 op->call_error = 0;
 183                 op->call_abort_code = 0;
 184                 op->cb_s_break = op->server->cb_s_break;
 185                 if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags) &&
 186                     op->ops->issue_yfs_rpc)
 187                         op->ops->issue_yfs_rpc(op);
 188                 else if (op->ops->issue_afs_rpc)
 189                         op->ops->issue_afs_rpc(op);
 190                 else
 191                         op->call_error = -ENOTSUPP;
 192
 193                 if (op->call) {
 194                         afs_wait_for_call_to_complete(op->call, &op->ac);
 195                         op->call_abort_code = op->call->abort_code;
 196                         op->call_error = op->call->error;
 197                         op->call_responded = op->call->responded;
 198                         op->ac.call_responded = true;
 199                         WRITE_ONCE(op->ac.alist->addrs[op->ac.index].last_error,
 200                                    op->call_error);
 201                         afs_put_call(op->call);
 202                 }
 203         }
 204
 205         if (!afs_op_error(op)) {
 206                 _debug("success");
 207                 op->ops->success(op);
 208         } else if (op->cumul_error.aborted) {
 209                 if (op->ops->aborted)
 210                         op->ops->aborted(op);
 211         } else {
 212                 if (op->ops->failed)
 213                         op->ops->failed(op);
 214         }
 215
 216         afs_end_vnode_operation(op);
 217
 218         if (!afs_op_error(op) && op->ops->edit_dir) {
 219                 _debug("edit_dir");
 220                 op->ops->edit_dir(op);
 221         }
 222         _leave("");
 223 }
 224
 225 /*
 226  * Dispose of an operation.
 227  */
 228 int afs_put_operation(struct afs_operation *op)
 229 {
 230         int i, ret = afs_op_error(op);
 231
 232         _enter("op=%08x,%d", op->debug_id, ret);
 233
 234         if (op->ops && op->ops->put)
 235                 op->ops->put(op);
 236         if (op->file[0].modification)
 237                 clear_bit(AFS_VNODE_MODIFYING, &op->file[0].vnode->flags);
 238         if (op->file[1].modification && op->file[1].vnode != op->file[0].vnode)
 239                 clear_bit(AFS_VNODE_MODIFYING, &op->file[1].vnode->flags);
 240         if (op->file[0].put_vnode)
 241                 iput(&op->file[0].vnode->netfs.inode);
 242         if (op->file[1].put_vnode)
 243                 iput(&op->file[1].vnode->netfs.inode);
 244
 245         if (op->more_files) {
 246                 for (i = 0; i < op->nr_files - 2; i++)
 247                         if (op->more_files[i].put_vnode)
 248                                 iput(&op->more_files[i].vnode->netfs.inode);
 249                 kfree(op->more_files);
 250         }
 251
 252         afs_end_cursor(&op->ac);
 253         afs_put_serverlist(op->net, op->server_list);
 254         afs_put_volume(op->net, op->volume, afs_volume_trace_put_put_op);
 255         key_put(op->key);
 256         kfree(op);
 257         return ret;
 258 }
 259
 260 int afs_do_sync_operation(struct afs_operation *op)
 261 {
 262         afs_begin_vnode_operation(op);
 263         afs_wait_for_operation(op);
 264         return afs_put_operation(op);
 265 }