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          = atomic_read(&volume->cb_v_break);
  42         op->pre_volsync.creation = volume->creation_time;
  43         op->pre_volsync.update  = volume->update_time;
  44         op->debug_id            = atomic_inc_return(&afs_operation_debug_counter);
  45         op->nr_iterations       = -1;
  46         afs_op_set_error(op, -EDESTADDRREQ);
  47
  48         _leave(" = [op=%08x]", op->debug_id);
  49         return op;
  50 }
  51
  52 /*
  53  * Lock the vnode(s) being operated upon.
  54  */
  55 static bool afs_get_io_locks(struct afs_operation *op)
  56 {
  57         struct afs_vnode *vnode = op->file[0].vnode;
  58         struct afs_vnode *vnode2 = op->file[1].vnode;
  59
  60         _enter("");
  61
  62         if (op->flags & AFS_OPERATION_UNINTR) {
  63                 mutex_lock(&vnode->io_lock);
  64                 op->flags |= AFS_OPERATION_LOCK_0;
  65                 _leave(" = t [1]");
  66                 return true;
  67         }
  68
  69         if (!vnode2 || !op->file[1].need_io_lock || vnode == vnode2)
  70                 vnode2 = NULL;
  71
  72         if (vnode2 > vnode)
  73                 swap(vnode, vnode2);
  74
  75         if (mutex_lock_interruptible(&vnode->io_lock) < 0) {
  76                 afs_op_set_error(op, -ERESTARTSYS);
  77                 op->flags |= AFS_OPERATION_STOP;
  78                 _leave(" = f [I 0]");
  79                 return false;
  80         }
  81         op->flags |= AFS_OPERATION_LOCK_0;
  82
  83         if (vnode2) {
  84                 if (mutex_lock_interruptible_nested(&vnode2->io_lock, 1) < 0) {
  85                         afs_op_set_error(op, -ERESTARTSYS);
  86                         op->flags |= AFS_OPERATION_STOP;
  87                         mutex_unlock(&vnode->io_lock);
  88                         op->flags &= ~AFS_OPERATION_LOCK_0;
  89                         _leave(" = f [I 1]");
  90                         return false;
  91                 }
  92                 op->flags |= AFS_OPERATION_LOCK_1;
  93         }
  94
  95         _leave(" = t [2]");
  96         return true;
  97 }
  98
  99 static void afs_drop_io_locks(struct afs_operation *op)
 100 {
 101         struct afs_vnode *vnode = op->file[0].vnode;
 102         struct afs_vnode *vnode2 = op->file[1].vnode;
 103
 104         _enter("");
 105
 106         if (op->flags & AFS_OPERATION_LOCK_1)
 107                 mutex_unlock(&vnode2->io_lock);
 108         if (op->flags & AFS_OPERATION_LOCK_0)
 109                 mutex_unlock(&vnode->io_lock);
 110 }
 111
 112 static void afs_prepare_vnode(struct afs_operation *op, struct afs_vnode_param *vp,
 113                               unsigned int index)
 114 {
 115         struct afs_vnode *vnode = vp->vnode;
 116
 117         if (vnode) {
 118                 vp->fid                 = vnode->fid;
 119                 vp->dv_before           = vnode->status.data_version;
 120                 vp->cb_break_before     = afs_calc_vnode_cb_break(vnode);
 121                 if (vnode->lock_state != AFS_VNODE_LOCK_NONE)
 122                         op->flags       |= AFS_OPERATION_CUR_ONLY;
 123                 if (vp->modification)
 124                         set_bit(AFS_VNODE_MODIFYING, &vnode->flags);
 125         }
 126
 127         if (vp->fid.vnode)
 128                 _debug("PREP[%u] {%llx:%llu.%u}",
 129                        index, vp->fid.vid, vp->fid.vnode, vp->fid.unique);
 130 }
 131
 132 /*
 133  * Begin an operation on the fileserver.
 134  *
 135  * Fileserver operations are serialised on the server by vnode, so we serialise
 136  * them here also using the io_lock.
 137  */
 138 bool afs_begin_vnode_operation(struct afs_operation *op)
 139 {
 140         struct afs_vnode *vnode = op->file[0].vnode;
 141
 142         ASSERT(vnode);
 143
 144         _enter("");
 145
 146         if (op->file[0].need_io_lock)
 147                 if (!afs_get_io_locks(op))
 148                         return false;
 149
 150         afs_prepare_vnode(op, &op->file[0], 0);
 151         afs_prepare_vnode(op, &op->file[1], 1);
 152         op->cb_v_break = atomic_read(&op->volume->cb_v_break);
 153         _leave(" = true");
 154         return true;
 155 }
 156
 157 /*
 158  * Tidy up a filesystem cursor and unlock the vnode.
 159  */
 160 static void afs_end_vnode_operation(struct afs_operation *op)
 161 {
 162         _enter("");
 163
 164         switch (afs_op_error(op)) {
 165         case -EDESTADDRREQ:
 166         case -EADDRNOTAVAIL:
 167         case -ENETUNREACH:
 168         case -EHOSTUNREACH:
 169                 afs_dump_edestaddrreq(op);
 170                 break;
 171         }
 172
 173         afs_drop_io_locks(op);
 174 }
 175
 176 /*
 177  * Wait for an in-progress operation to complete.
 178  */
 179 void afs_wait_for_operation(struct afs_operation *op)
 180 {
 181         _enter("");
 182
 183         while (afs_select_fileserver(op)) {
 184                 op->call_responded = false;
 185                 op->call_error = 0;
 186                 op->call_abort_code = 0;
 187                 if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags) &&
 188                     op->ops->issue_yfs_rpc)
 189                         op->ops->issue_yfs_rpc(op);
 190                 else if (op->ops->issue_afs_rpc)
 191                         op->ops->issue_afs_rpc(op);
 192                 else
 193                         op->call_error = -ENOTSUPP;
 194
 195                 if (op->call) {
 196                         afs_wait_for_call_to_complete(op->call);
 197                         op->call_abort_code = op->call->abort_code;
 198                         op->call_error = op->call->error;
 199                         op->call_responded = op->call->responded;
 200                         afs_put_call(op->call);
 201                 }
 202         }
 203
 204         if (op->call_responded && op->server)
 205                 set_bit(AFS_SERVER_FL_RESPONDING, &op->server->flags);
 206
 207         if (!afs_op_error(op)) {
 208                 _debug("success");
 209                 op->ops->success(op);
 210         } else if (op->cumul_error.aborted) {
 211                 if (op->ops->aborted)
 212                         op->ops->aborted(op);
 213         } else {
 214                 if (op->ops->failed)
 215                         op->ops->failed(op);
 216         }
 217
 218         afs_end_vnode_operation(op);
 219
 220         if (!afs_op_error(op) && op->ops->edit_dir) {
 221                 _debug("edit_dir");
 222                 op->ops->edit_dir(op);
 223         }
 224         _leave("");
 225 }
 226
 227 /*
 228  * Dispose of an operation.
 229  */
 230 int afs_put_operation(struct afs_operation *op)
 231 {
 232         struct afs_addr_list *alist;
 233         int i, ret = afs_op_error(op);
 234
 235         _enter("op=%08x,%d", op->debug_id, ret);
 236
 237         if (op->ops && op->ops->put)
 238                 op->ops->put(op);
 239         if (op->file[0].modification)
 240                 clear_bit(AFS_VNODE_MODIFYING, &op->file[0].vnode->flags);
 241         if (op->file[1].modification && op->file[1].vnode != op->file[0].vnode)
 242                 clear_bit(AFS_VNODE_MODIFYING, &op->file[1].vnode->flags);
 243         if (op->file[0].put_vnode)
 244                 iput(&op->file[0].vnode->netfs.inode);
 245         if (op->file[1].put_vnode)
 246                 iput(&op->file[1].vnode->netfs.inode);
 247
 248         if (op->more_files) {
 249                 for (i = 0; i < op->nr_files - 2; i++)
 250                         if (op->more_files[i].put_vnode)
 251                                 iput(&op->more_files[i].vnode->netfs.inode);
 252                 kfree(op->more_files);
 253         }
 254
 255         if (op->estate) {
 256                 alist = op->estate->addresses;
 257                 if (alist) {
 258                         if (op->call_responded &&
 259                             op->addr_index != alist->preferred &&
 260                             test_bit(alist->preferred, &op->addr_tried))
 261                                 WRITE_ONCE(alist->preferred, op->addr_index);
 262                 }
 263         }
 264
 265         afs_clear_server_states(op);
 266         afs_put_serverlist(op->net, op->server_list);
 267         afs_put_volume(op->volume, afs_volume_trace_put_put_op);
 268         key_put(op->key);
 269         kfree(op);
 270         return ret;
 271 }
 272
 273 int afs_do_sync_operation(struct afs_operation *op)
 274 {
 275         afs_begin_vnode_operation(op);
 276         afs_wait_for_operation(op);
 277         return afs_put_operation(op);
 278 }