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 struct afs_io_locker { 53 struct list_head link; 54 struct task_struct *task; 55 unsigned long have_lock; 56 }; 57 58 /* 59 * Unlock the I/O lock on a vnode. 60 */ 61 static void afs_unlock_for_io(struct afs_vnode *vnode) 62 { 63 struct afs_io_locker *locker; 64 65 spin_lock(&vnode->lock); 66 locker = list_first_entry_or_null(&vnode->io_lock_waiters, 67 struct afs_io_locker, link); 68 if (locker) { 69 list_del(&locker->link); 70 smp_store_release(&locker->have_lock, 1); /* The unlock barrier. */ 71 smp_mb__after_atomic(); /* Store have_lock before task state */ 72 wake_up_process(locker->task); 73 } else { 74 clear_bit(AFS_VNODE_IO_LOCK, &vnode->flags); 75 } 76 spin_unlock(&vnode->lock); 77 } 78 79 /* 80 * Lock the I/O lock on a vnode uninterruptibly. We can't use an ordinary 81 * mutex as lockdep will complain if we unlock it in the wrong thread. 82 */ 83 static void afs_lock_for_io(struct afs_vnode *vnode) 84 { 85 struct afs_io_locker myself = { .task = current, }; 86 87 spin_lock(&vnode->lock); 88 89 if (!test_and_set_bit(AFS_VNODE_IO_LOCK, &vnode->flags)) { 90 spin_unlock(&vnode->lock); 91 return; 92 } 93 94 list_add_tail(&myself.link, &vnode->io_lock_waiters); 95 spin_unlock(&vnode->lock); 96 97 for (;;) { 98 set_current_state(TASK_UNINTERRUPTIBLE); 99 if (smp_load_acquire(&myself.have_lock)) /* The lock barrier */ 100 break; 101 schedule(); 102 } 103 __set_current_state(TASK_RUNNING); 104 } 105 106 /* 107 * Lock the I/O lock on a vnode interruptibly. We can't use an ordinary mutex 108 * as lockdep will complain if we unlock it in the wrong thread. 109 */ 110 static int afs_lock_for_io_interruptible(struct afs_vnode *vnode) 111 { 112 struct afs_io_locker myself = { .task = current, }; 113 int ret = 0; 114 115 spin_lock(&vnode->lock); 116 117 if (!test_and_set_bit(AFS_VNODE_IO_LOCK, &vnode->flags)) { 118 spin_unlock(&vnode->lock); 119 return 0; 120 } 121 122 list_add_tail(&myself.link, &vnode->io_lock_waiters); 123 spin_unlock(&vnode->lock); 124 125 for (;;) { 126 set_current_state(TASK_INTERRUPTIBLE); 127 if (smp_load_acquire(&myself.have_lock) || /* The lock barrier */ 128 signal_pending(current)) 129 break; 130 schedule(); 131 } 132 __set_current_state(TASK_RUNNING); 133 134 /* If we got a signal, try to transfer the lock onto the next 135 * waiter. 136 */ 137 if (unlikely(signal_pending(current))) { 138 spin_lock(&vnode->lock); 139 if (myself.have_lock) { 140 spin_unlock(&vnode->lock); 141 afs_unlock_for_io(vnode); 142 } else { 143 list_del(&myself.link); 144 spin_unlock(&vnode->lock); 145 } 146 ret = -ERESTARTSYS; 147 } 148 return ret; 149 } 150 151 /* 152 * Lock the vnode(s) being operated upon. 153 */ 154 static bool afs_get_io_locks(struct afs_operation *op) 155 { 156 struct afs_vnode *vnode = op->file[0].vnode; 157 struct afs_vnode *vnode2 = op->file[1].vnode; 158 159 _enter(""); 160 161 if (op->flags & AFS_OPERATION_UNINTR) { 162 afs_lock_for_io(vnode); 163 op->flags |= AFS_OPERATION_LOCK_0; 164 _leave(" = t [1]"); 165 return true; 166 } 167 168 if (!vnode2 || !op->file[1].need_io_lock || vnode == vnode2) 169 vnode2 = NULL; 170 171 if (vnode2 > vnode) 172 swap(vnode, vnode2); 173 174 if (afs_lock_for_io_interruptible(vnode) < 0) { 175 afs_op_set_error(op, -ERESTARTSYS); 176 op->flags |= AFS_OPERATION_STOP; 177 _leave(" = f [I 0]"); 178 return false; 179 } 180 op->flags |= AFS_OPERATION_LOCK_0; 181 182 if (vnode2) { 183 if (afs_lock_for_io_interruptible(vnode2) < 0) { 184 afs_op_set_error(op, -ERESTARTSYS); 185 op->flags |= AFS_OPERATION_STOP; 186 afs_unlock_for_io(vnode); 187 op->flags &= ~AFS_OPERATION_LOCK_0; 188 _leave(" = f [I 1]"); 189 return false; 190 } 191 op->flags |= AFS_OPERATION_LOCK_1; 192 } 193 194 _leave(" = t [2]"); 195 return true; 196 } 197 198 static void afs_drop_io_locks(struct afs_operation *op) 199 { 200 struct afs_vnode *vnode = op->file[0].vnode; 201 struct afs_vnode *vnode2 = op->file[1].vnode; 202 203 _enter(""); 204 205 if (op->flags & AFS_OPERATION_LOCK_1) 206 afs_unlock_for_io(vnode2); 207 if (op->flags & AFS_OPERATION_LOCK_0) 208 afs_unlock_for_io(vnode); 209 } 210 211 static void afs_prepare_vnode(struct afs_operation *op, struct afs_vnode_param *vp, 212 unsigned int index) 213 { 214 struct afs_vnode *vnode = vp->vnode; 215 216 if (vnode) { 217 vp->fid = vnode->fid; 218 vp->dv_before = vnode->status.data_version; 219 vp->cb_break_before = afs_calc_vnode_cb_break(vnode); 220 if (vnode->lock_state != AFS_VNODE_LOCK_NONE) 221 op->flags |= AFS_OPERATION_CUR_ONLY; 222 if (vp->modification) 223 set_bit(AFS_VNODE_MODIFYING, &vnode->flags); 224 } 225 226 if (vp->fid.vnode) 227 _debug("PREP[%u] {%llx:%llu.%u}", 228 index, vp->fid.vid, vp->fid.vnode, vp->fid.unique); 229 } 230 231 /* 232 * Begin an operation on the fileserver. 233 * 234 * Fileserver operations are serialised on the server by vnode, so we serialise 235 * them here also using the io_lock. 236 */ 237 bool afs_begin_vnode_operation(struct afs_operation *op) 238 { 239 struct afs_vnode *vnode = op->file[0].vnode; 240 241 ASSERT(vnode); 242 243 _enter(""); 244 245 if (op->file[0].need_io_lock) 246 if (!afs_get_io_locks(op)) 247 return false; 248 249 afs_prepare_vnode(op, &op->file[0], 0); 250 afs_prepare_vnode(op, &op->file[1], 1); 251 op->cb_v_break = atomic_read(&op->volume->cb_v_break); 252 _leave(" = true"); 253 return true; 254 } 255 256 /* 257 * Tidy up a filesystem cursor and unlock the vnode. 258 */ 259 void afs_end_vnode_operation(struct afs_operation *op) 260 { 261 _enter(""); 262 263 switch (afs_op_error(op)) { 264 case -EDESTADDRREQ: 265 case -EADDRNOTAVAIL: 266 case -ENETUNREACH: 267 case -EHOSTUNREACH: 268 afs_dump_edestaddrreq(op); 269 break; 270 } 271 272 afs_drop_io_locks(op); 273 } 274 275 /* 276 * Wait for an in-progress operation to complete. 277 */ 278 void afs_wait_for_operation(struct afs_operation *op) 279 { 280 _enter(""); 281 282 while (afs_select_fileserver(op)) { 283 op->call_responded = false; 284 op->call_error = 0; 285 op->call_abort_code = 0; 286 if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags) && 287 op->ops->issue_yfs_rpc) 288 op->ops->issue_yfs_rpc(op); 289 else if (op->ops->issue_afs_rpc) 290 op->ops->issue_afs_rpc(op); 291 else 292 op->call_error = -ENOTSUPP; 293 294 if (op->call) { 295 afs_wait_for_call_to_complete(op->call); 296 op->call_abort_code = op->call->abort_code; 297 op->call_error = op->call->error; 298 op->call_responded = op->call->responded; 299 afs_put_call(op->call); 300 } 301 } 302 303 if (op->call_responded && op->server) 304 set_bit(AFS_SERVER_FL_RESPONDING, &op->server->flags); 305 306 if (!afs_op_error(op)) { 307 _debug("success"); 308 op->ops->success(op); 309 } else if (op->cumul_error.aborted) { 310 if (op->ops->aborted) 311 op->ops->aborted(op); 312 } else { 313 if (op->ops->failed) 314 op->ops->failed(op); 315 } 316 317 afs_end_vnode_operation(op); 318 319 if (!afs_op_error(op) && op->ops->edit_dir) { 320 _debug("edit_dir"); 321 op->ops->edit_dir(op); 322 } 323 _leave(""); 324 } 325 326 /* 327 * Dispose of an operation. 328 */ 329 int afs_put_operation(struct afs_operation *op) 330 { 331 struct afs_addr_list *alist; 332 int i, ret = afs_op_error(op); 333 334 _enter("op=%08x,%d", op->debug_id, ret); 335 336 if (op->ops && op->ops->put) 337 op->ops->put(op); 338 if (op->file[0].modification) 339 clear_bit(AFS_VNODE_MODIFYING, &op->file[0].vnode->flags); 340 if (op->file[1].modification && op->file[1].vnode != op->file[0].vnode) 341 clear_bit(AFS_VNODE_MODIFYING, &op->file[1].vnode->flags); 342 if (op->file[0].put_vnode) 343 iput(&op->file[0].vnode->netfs.inode); 344 if (op->file[1].put_vnode) 345 iput(&op->file[1].vnode->netfs.inode); 346 347 if (op->more_files) { 348 for (i = 0; i < op->nr_files - 2; i++) 349 if (op->more_files[i].put_vnode) 350 iput(&op->more_files[i].vnode->netfs.inode); 351 kfree(op->more_files); 352 } 353 354 if (op->estate) { 355 alist = op->estate->addresses; 356 if (alist) { 357 if (op->call_responded && 358 op->addr_index != alist->preferred && 359 test_bit(alist->preferred, &op->addr_tried)) 360 WRITE_ONCE(alist->preferred, op->addr_index); 361 } 362 } 363 364 afs_clear_server_states(op); 365 afs_put_serverlist(op->net, op->server_list); 366 afs_put_volume(op->volume, afs_volume_trace_put_put_op); 367 key_put(op->key); 368 kfree(op); 369 return ret; 370 } 371 372 int afs_do_sync_operation(struct afs_operation *op) 373 { 374 afs_begin_vnode_operation(op); 375 afs_wait_for_operation(op); 376 return afs_put_operation(op); 377 } 378