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
13static atomic_t afs_operation_debug_counter;
14
15/*
16 * Create an operation against a volume.
17 */
18struct 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(error: -ENOMEM);
27
28 if (!key) {
29 key = afs_request_key(volume->cell);
30 if (IS_ERR(ptr: key)) {
31 kfree(objp: op);
32 return ERR_CAST(ptr: 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(v: &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(v: &afs_operation_debug_counter);
45 op->nr_iterations = -1;
46 afs_op_set_error(op, error: -EDESTADDRREQ);
47
48 _leave(" = [op=%08x]", op->debug_id);
49 return op;
50}
51
52struct 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 */
61static void afs_unlock_for_io(struct afs_vnode *vnode)
62{
63 struct afs_io_locker *locker;
64
65 spin_lock(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(entry: &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(tsk: locker->task);
73 } else {
74 clear_bit(AFS_VNODE_IO_LOCK, addr: &vnode->flags);
75 }
76 spin_unlock(lock: &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 */
83static void afs_lock_for_io(struct afs_vnode *vnode)
84{
85 struct afs_io_locker myself = { .task = current, };
86
87 spin_lock(lock: &vnode->lock);
88
89 if (!test_and_set_bit(AFS_VNODE_IO_LOCK, addr: &vnode->flags)) {
90 spin_unlock(lock: &vnode->lock);
91 return;
92 }
93
94 list_add_tail(new: &myself.link, head: &vnode->io_lock_waiters);
95 spin_unlock(lock: &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 */
110static 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(lock: &vnode->lock);
116
117 if (!test_and_set_bit(AFS_VNODE_IO_LOCK, addr: &vnode->flags)) {
118 spin_unlock(lock: &vnode->lock);
119 return 0;
120 }
121
122 list_add_tail(new: &myself.link, head: &vnode->io_lock_waiters);
123 spin_unlock(lock: &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(lock: &vnode->lock);
139 if (myself.have_lock) {
140 spin_unlock(lock: &vnode->lock);
141 afs_unlock_for_io(vnode);
142 } else {
143 list_del(entry: &myself.link);
144 spin_unlock(lock: &vnode->lock);
145 }
146 ret = -ERESTARTSYS;
147 }
148 return ret;
149}
150
151/*
152 * Lock the vnode(s) being operated upon.
153 */
154static 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, error: -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(vnode: vnode2) < 0) {
184 afs_op_set_error(op, error: -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
198static 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(vnode: vnode2);
207 if (op->flags & AFS_OPERATION_LOCK_0)
208 afs_unlock_for_io(vnode);
209}
210
211static 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, addr: &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 */
237bool 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, vp: &op->file[0], index: 0);
250 afs_prepare_vnode(op, vp: &op->file[1], index: 1);
251 op->cb_v_break = atomic_read(v: &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 */
259void 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 */
278void 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(call: 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, addr: &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 */
329int 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, addr: &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, addr: &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(objp: 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(volume: op->volume, reason: afs_volume_trace_put_put_op);
367 key_put(key: op->key);
368 kfree(objp: op);
369 return ret;
370}
371
372int 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

source code of linux/fs/afs/fs_operation.c