forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/fs/afs/flock.c
....@@ -1,12 +1,8 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /* AFS file locking support
23  *
34  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
45  * Written by David Howells (dhowells@redhat.com)
5
- *
6
- * This program is free software; you can redistribute it and/or
7
- * modify it under the terms of the GNU General Public License
8
- * as published by the Free Software Foundation; either version
9
- * 2 of the License, or (at your option) any later version.
106  */
117 
128 #include "internal.h"
....@@ -32,16 +28,19 @@
3228 	vnode->lock_state = state;
3329 }
3430 
31
+static atomic_t afs_file_lock_debug_id;
32
+
3533 /*
3634  * if the callback is broken on this vnode, then the lock may now be available
3735  */
3836 void afs_lock_may_be_available(struct afs_vnode *vnode)
3937 {
40
-	_enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
38
+	_enter("{%llx:%llu}", vnode->fid.vid, vnode->fid.vnode);
4139 
4240 	spin_lock(&vnode->lock);
4341 	if (vnode->lock_state == AFS_VNODE_LOCK_WAITING_FOR_CB)
4442 		afs_next_locker(vnode, 0);
43
+	trace_afs_flock_ev(vnode, NULL, afs_flock_callback_break, 0);
4544 	spin_unlock(&vnode->lock);
4645 }
4746 
....@@ -49,10 +48,38 @@
4948  * the lock will time out in 5 minutes unless we extend it, so schedule
5049  * extension in a bit less than that time
5150  */
52
-static void __maybe_unused afs_schedule_lock_extension(struct afs_vnode *vnode)
51
+static void afs_schedule_lock_extension(struct afs_vnode *vnode)
5352 {
54
-	queue_delayed_work(afs_lock_manager, &vnode->lock_work,
55
-			   AFS_LOCKWAIT * HZ / 2);
53
+	ktime_t expires_at, now, duration;
54
+	u64 duration_j;
55
+
56
+	expires_at = ktime_add_ms(vnode->locked_at, AFS_LOCKWAIT * 1000 / 2);
57
+	now = ktime_get_real();
58
+	duration = ktime_sub(expires_at, now);
59
+	if (duration <= 0)
60
+		duration_j = 0;
61
+	else
62
+		duration_j = nsecs_to_jiffies(ktime_to_ns(duration));
63
+
64
+	queue_delayed_work(afs_lock_manager, &vnode->lock_work, duration_j);
65
+}
66
+
67
+/*
68
+ * In the case of successful completion of a lock operation, record the time
69
+ * the reply appeared and start the lock extension timer.
70
+ */
71
+void afs_lock_op_done(struct afs_call *call)
72
+{
73
+	struct afs_operation *op = call->op;
74
+	struct afs_vnode *vnode = op->file[0].vnode;
75
+
76
+	if (call->error == 0) {
77
+		spin_lock(&vnode->lock);
78
+		trace_afs_flock_ev(vnode, NULL, afs_flock_timestamp, 0);
79
+		vnode->locked_at = call->issue_time;
80
+		afs_schedule_lock_extension(vnode);
81
+		spin_unlock(&vnode->lock);
82
+	}
5683 }
5784 
5885 /*
....@@ -71,6 +98,7 @@
7198 
7299 		list_move_tail(&p->fl_u.afs.link, &vnode->granted_locks);
73100 		p->fl_u.afs.state = AFS_LOCK_GRANTED;
101
+		trace_afs_flock_op(vnode, p, afs_flock_op_grant);
74102 		wake_up(&p->fl_wait);
75103 	}
76104 }
....@@ -113,13 +141,50 @@
113141 	if (next) {
114142 		afs_set_lock_state(vnode, AFS_VNODE_LOCK_SETTING);
115143 		next->fl_u.afs.state = AFS_LOCK_YOUR_TRY;
144
+		trace_afs_flock_op(vnode, next, afs_flock_op_wake);
116145 		wake_up(&next->fl_wait);
117146 	} else {
118147 		afs_set_lock_state(vnode, AFS_VNODE_LOCK_NONE);
148
+		trace_afs_flock_ev(vnode, NULL, afs_flock_no_lockers, 0);
119149 	}
120150 
121151 	_leave("");
122152 }
153
+
154
+/*
155
+ * Kill off all waiters in the the pending lock queue due to the vnode being
156
+ * deleted.
157
+ */
158
+static void afs_kill_lockers_enoent(struct afs_vnode *vnode)
159
+{
160
+	struct file_lock *p;
161
+
162
+	afs_set_lock_state(vnode, AFS_VNODE_LOCK_DELETED);
163
+
164
+	while (!list_empty(&vnode->pending_locks)) {
165
+		p = list_entry(vnode->pending_locks.next,
166
+			       struct file_lock, fl_u.afs.link);
167
+		list_del_init(&p->fl_u.afs.link);
168
+		p->fl_u.afs.state = -ENOENT;
169
+		wake_up(&p->fl_wait);
170
+	}
171
+
172
+	key_put(vnode->lock_key);
173
+	vnode->lock_key = NULL;
174
+}
175
+
176
+static void afs_lock_success(struct afs_operation *op)
177
+{
178
+	_enter("op=%08x", op->debug_id);
179
+	afs_vnode_commit_status(op, &op->file[0]);
180
+}
181
+
182
+static const struct afs_operation_ops afs_set_lock_operation = {
183
+	.issue_afs_rpc	= afs_fs_set_lock,
184
+	.issue_yfs_rpc	= yfs_fs_set_lock,
185
+	.success	= afs_lock_success,
186
+	.aborted	= afs_check_for_remote_deletion,
187
+};
123188 
124189 /*
125190  * Get a lock on a file
....@@ -127,92 +192,86 @@
127192 static int afs_set_lock(struct afs_vnode *vnode, struct key *key,
128193 			afs_lock_type_t type)
129194 {
130
-	struct afs_fs_cursor fc;
131
-	int ret;
195
+	struct afs_operation *op;
132196 
133
-	_enter("%s{%x:%u.%u},%x,%u",
197
+	_enter("%s{%llx:%llu.%u},%x,%u",
134198 	       vnode->volume->name,
135199 	       vnode->fid.vid,
136200 	       vnode->fid.vnode,
137201 	       vnode->fid.unique,
138202 	       key_serial(key), type);
139203 
140
-	ret = -ERESTARTSYS;
141
-	if (afs_begin_vnode_operation(&fc, vnode, key)) {
142
-		while (afs_select_fileserver(&fc)) {
143
-			fc.cb_break = afs_calc_vnode_cb_break(vnode);
144
-			afs_fs_set_lock(&fc, type);
145
-		}
204
+	op = afs_alloc_operation(key, vnode->volume);
205
+	if (IS_ERR(op))
206
+		return PTR_ERR(op);
146207 
147
-		afs_check_for_remote_deletion(&fc, fc.vnode);
148
-		afs_vnode_commit_status(&fc, vnode, fc.cb_break);
149
-		ret = afs_end_vnode_operation(&fc);
150
-	}
208
+	afs_op_set_vnode(op, 0, vnode);
151209 
152
-	_leave(" = %d", ret);
153
-	return ret;
210
+	op->lock.type	= type;
211
+	op->ops		= &afs_set_lock_operation;
212
+	return afs_do_sync_operation(op);
154213 }
214
+
215
+static const struct afs_operation_ops afs_extend_lock_operation = {
216
+	.issue_afs_rpc	= afs_fs_extend_lock,
217
+	.issue_yfs_rpc	= yfs_fs_extend_lock,
218
+	.success	= afs_lock_success,
219
+};
155220 
156221 /*
157222  * Extend a lock on a file
158223  */
159224 static int afs_extend_lock(struct afs_vnode *vnode, struct key *key)
160225 {
161
-	struct afs_fs_cursor fc;
162
-	int ret;
226
+	struct afs_operation *op;
163227 
164
-	_enter("%s{%x:%u.%u},%x",
228
+	_enter("%s{%llx:%llu.%u},%x",
165229 	       vnode->volume->name,
166230 	       vnode->fid.vid,
167231 	       vnode->fid.vnode,
168232 	       vnode->fid.unique,
169233 	       key_serial(key));
170234 
171
-	ret = -ERESTARTSYS;
172
-	if (afs_begin_vnode_operation(&fc, vnode, key)) {
173
-		while (afs_select_current_fileserver(&fc)) {
174
-			fc.cb_break = afs_calc_vnode_cb_break(vnode);
175
-			afs_fs_extend_lock(&fc);
176
-		}
235
+	op = afs_alloc_operation(key, vnode->volume);
236
+	if (IS_ERR(op))
237
+		return PTR_ERR(op);
177238 
178
-		afs_check_for_remote_deletion(&fc, fc.vnode);
179
-		afs_vnode_commit_status(&fc, vnode, fc.cb_break);
180
-		ret = afs_end_vnode_operation(&fc);
181
-	}
239
+	afs_op_set_vnode(op, 0, vnode);
182240 
183
-	_leave(" = %d", ret);
184
-	return ret;
241
+	op->flags	|= AFS_OPERATION_UNINTR;
242
+	op->ops		= &afs_extend_lock_operation;
243
+	return afs_do_sync_operation(op);
185244 }
245
+
246
+static const struct afs_operation_ops afs_release_lock_operation = {
247
+	.issue_afs_rpc	= afs_fs_release_lock,
248
+	.issue_yfs_rpc	= yfs_fs_release_lock,
249
+	.success	= afs_lock_success,
250
+};
186251 
187252 /*
188253  * Release a lock on a file
189254  */
190255 static int afs_release_lock(struct afs_vnode *vnode, struct key *key)
191256 {
192
-	struct afs_fs_cursor fc;
193
-	int ret;
257
+	struct afs_operation *op;
194258 
195
-	_enter("%s{%x:%u.%u},%x",
259
+	_enter("%s{%llx:%llu.%u},%x",
196260 	       vnode->volume->name,
197261 	       vnode->fid.vid,
198262 	       vnode->fid.vnode,
199263 	       vnode->fid.unique,
200264 	       key_serial(key));
201265 
202
-	ret = -ERESTARTSYS;
203
-	if (afs_begin_vnode_operation(&fc, vnode, key)) {
204
-		while (afs_select_current_fileserver(&fc)) {
205
-			fc.cb_break = afs_calc_vnode_cb_break(vnode);
206
-			afs_fs_release_lock(&fc);
207
-		}
266
+	op = afs_alloc_operation(key, vnode->volume);
267
+	if (IS_ERR(op))
268
+		return PTR_ERR(op);
208269 
209
-		afs_check_for_remote_deletion(&fc, fc.vnode);
210
-		afs_vnode_commit_status(&fc, vnode, fc.cb_break);
211
-		ret = afs_end_vnode_operation(&fc);
212
-	}
270
+	afs_op_set_vnode(op, 0, vnode);
213271 
214
-	_leave(" = %d", ret);
215
-	return ret;
272
+	op->flags	|= AFS_OPERATION_UNINTR;
273
+	op->ops		= &afs_release_lock_operation;
274
+	return afs_do_sync_operation(op);
216275 }
217276 
218277 /*
....@@ -227,7 +286,7 @@
227286 	struct key *key;
228287 	int ret;
229288 
230
-	_enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
289
+	_enter("{%llx:%llu}", vnode->fid.vid, vnode->fid.vnode);
231290 
232291 	spin_lock(&vnode->lock);
233292 
....@@ -235,20 +294,26 @@
235294 	_debug("wstate %u for %p", vnode->lock_state, vnode);
236295 	switch (vnode->lock_state) {
237296 	case AFS_VNODE_LOCK_NEED_UNLOCK:
238
-		_debug("unlock");
239297 		afs_set_lock_state(vnode, AFS_VNODE_LOCK_UNLOCKING);
298
+		trace_afs_flock_ev(vnode, NULL, afs_flock_work_unlocking, 0);
240299 		spin_unlock(&vnode->lock);
241300 
242301 		/* attempt to release the server lock; if it fails, we just
243302 		 * wait 5 minutes and it'll expire anyway */
244303 		ret = afs_release_lock(vnode, vnode->lock_key);
245
-		if (ret < 0)
304
+		if (ret < 0 && vnode->lock_state != AFS_VNODE_LOCK_DELETED) {
305
+			trace_afs_flock_ev(vnode, NULL, afs_flock_release_fail,
306
+					   ret);
246307 			printk(KERN_WARNING "AFS:"
247
-			       " Failed to release lock on {%x:%x} error %d\n",
308
+			       " Failed to release lock on {%llx:%llx} error %d\n",
248309 			       vnode->fid.vid, vnode->fid.vnode, ret);
310
+		}
249311 
250312 		spin_lock(&vnode->lock);
251
-		afs_next_locker(vnode, 0);
313
+		if (ret == -ENOENT)
314
+			afs_kill_lockers_enoent(vnode);
315
+		else
316
+			afs_next_locker(vnode, 0);
252317 		spin_unlock(&vnode->lock);
253318 		return;
254319 
....@@ -262,16 +327,26 @@
262327 
263328 		key = key_get(vnode->lock_key);
264329 		afs_set_lock_state(vnode, AFS_VNODE_LOCK_EXTENDING);
330
+		trace_afs_flock_ev(vnode, NULL, afs_flock_work_extending, 0);
265331 		spin_unlock(&vnode->lock);
266332 
267333 		ret = afs_extend_lock(vnode, key); /* RPC */
268334 		key_put(key);
269335 
270
-		if (ret < 0)
271
-			pr_warning("AFS: Failed to extend lock on {%x:%x} error %d\n",
272
-				   vnode->fid.vid, vnode->fid.vnode, ret);
336
+		if (ret < 0) {
337
+			trace_afs_flock_ev(vnode, NULL, afs_flock_extend_fail,
338
+					   ret);
339
+			pr_warn("AFS: Failed to extend lock on {%llx:%llx} error %d\n",
340
+				vnode->fid.vid, vnode->fid.vnode, ret);
341
+		}
273342 
274343 		spin_lock(&vnode->lock);
344
+
345
+		if (ret == -ENOENT) {
346
+			afs_kill_lockers_enoent(vnode);
347
+			spin_unlock(&vnode->lock);
348
+			return;
349
+		}
275350 
276351 		if (vnode->lock_state != AFS_VNODE_LOCK_EXTENDING)
277352 			goto again;
....@@ -293,6 +368,11 @@
293368 	case AFS_VNODE_LOCK_WAITING_FOR_CB:
294369 		_debug("retry");
295370 		afs_next_locker(vnode, 0);
371
+		spin_unlock(&vnode->lock);
372
+		return;
373
+
374
+	case AFS_VNODE_LOCK_DELETED:
375
+		afs_kill_lockers_enoent(vnode);
296376 		spin_unlock(&vnode->lock);
297377 		return;
298378 
....@@ -320,6 +400,7 @@
320400 		cancel_delayed_work(&vnode->lock_work);
321401 
322402 		afs_set_lock_state(vnode, AFS_VNODE_LOCK_NEED_UNLOCK);
403
+		trace_afs_flock_ev(vnode, NULL, afs_flock_defer_unlock, 0);
323404 		queue_delayed_work(afs_lock_manager, &vnode->lock_work, 0);
324405 	}
325406 }
....@@ -329,7 +410,7 @@
329410  * whether we think that we have a locking permit.
330411  */
331412 static int afs_do_setlk_check(struct afs_vnode *vnode, struct key *key,
332
-			      afs_lock_type_t type, bool can_sleep)
413
+			      enum afs_flock_mode mode, afs_lock_type_t type)
333414 {
334415 	afs_access_t access;
335416 	int ret;
....@@ -357,13 +438,9 @@
357438 	if (type == AFS_LOCK_READ) {
358439 		if (!(access & (AFS_ACE_INSERT | AFS_ACE_WRITE | AFS_ACE_LOCK)))
359440 			return -EACCES;
360
-		if (vnode->status.lock_count == -1 && !can_sleep)
361
-			return -EAGAIN; /* Write locked */
362441 	} else {
363442 		if (!(access & (AFS_ACE_INSERT | AFS_ACE_WRITE)))
364443 			return -EACCES;
365
-		if (vnode->status.lock_count != 0 && !can_sleep)
366
-			return -EAGAIN; /* Locked */
367444 	}
368445 
369446 	return 0;
....@@ -376,24 +453,54 @@
376453 {
377454 	struct inode *inode = locks_inode(file);
378455 	struct afs_vnode *vnode = AFS_FS_I(inode);
456
+	enum afs_flock_mode mode = AFS_FS_S(inode->i_sb)->flock_mode;
379457 	afs_lock_type_t type;
380458 	struct key *key = afs_file_key(file);
459
+	bool partial, no_server_lock = false;
381460 	int ret;
382461 
383
-	_enter("{%x:%u},%u", vnode->fid.vid, vnode->fid.vnode, fl->fl_type);
462
+	if (mode == afs_flock_mode_unset)
463
+		mode = afs_flock_mode_openafs;
464
+
465
+	_enter("{%llx:%llu},%llu-%llu,%u,%u",
466
+	       vnode->fid.vid, vnode->fid.vnode,
467
+	       fl->fl_start, fl->fl_end, fl->fl_type, mode);
384468 
385469 	fl->fl_ops = &afs_lock_ops;
386470 	INIT_LIST_HEAD(&fl->fl_u.afs.link);
387471 	fl->fl_u.afs.state = AFS_LOCK_PENDING;
388472 
473
+	partial = (fl->fl_start != 0 || fl->fl_end != OFFSET_MAX);
389474 	type = (fl->fl_type == F_RDLCK) ? AFS_LOCK_READ : AFS_LOCK_WRITE;
475
+	if (mode == afs_flock_mode_write && partial)
476
+		type = AFS_LOCK_WRITE;
390477 
391
-	ret = afs_do_setlk_check(vnode, key, type, fl->fl_flags & FL_SLEEP);
478
+	ret = afs_do_setlk_check(vnode, key, mode, type);
392479 	if (ret < 0)
393480 		return ret;
394481 
482
+	trace_afs_flock_op(vnode, fl, afs_flock_op_set_lock);
483
+
484
+	/* AFS3 protocol only supports full-file locks and doesn't provide any
485
+	 * method of upgrade/downgrade, so we need to emulate for partial-file
486
+	 * locks.
487
+	 *
488
+	 * The OpenAFS client only gets a server lock for a full-file lock and
489
+	 * keeps partial-file locks local.  Allow this behaviour to be emulated
490
+	 * (as the default).
491
+	 */
492
+	if (mode == afs_flock_mode_local ||
493
+	    (partial && mode == afs_flock_mode_openafs)) {
494
+		no_server_lock = true;
495
+		goto skip_server_lock;
496
+	}
497
+
395498 	spin_lock(&vnode->lock);
396499 	list_add_tail(&fl->fl_u.afs.link, &vnode->pending_locks);
500
+
501
+	ret = -ENOENT;
502
+	if (vnode->lock_state == AFS_VNODE_LOCK_DELETED)
503
+		goto error_unlock;
397504 
398505 	/* If we've already got a lock on the server then try to move to having
399506 	 * the VFS grant the requested lock.  Note that this means that other
....@@ -416,6 +523,18 @@
416523 		}
417524 	}
418525 
526
+	if (vnode->lock_state == AFS_VNODE_LOCK_NONE &&
527
+	    !(fl->fl_flags & FL_SLEEP)) {
528
+		ret = -EAGAIN;
529
+		if (type == AFS_LOCK_READ) {
530
+			if (vnode->status.lock_count == -1)
531
+				goto lock_is_contended; /* Write locked */
532
+		} else {
533
+			if (vnode->status.lock_count != 0)
534
+				goto lock_is_contended; /* Locked */
535
+		}
536
+	}
537
+
419538 	if (vnode->lock_state != AFS_VNODE_LOCK_NONE)
420539 		goto need_to_wait;
421540 
....@@ -428,7 +547,7 @@
428547 	 * though we don't wait for the reply (it's not too bad a problem - the
429548 	 * lock will expire in 5 mins anyway).
430549 	 */
431
-	_debug("not locked");
550
+	trace_afs_flock_ev(vnode, fl, afs_flock_try_to_lock, 0);
432551 	vnode->lock_key = key_get(key);
433552 	vnode->lock_type = type;
434553 	afs_set_lock_state(vnode, AFS_VNODE_LOCK_SETTING);
....@@ -444,12 +563,21 @@
444563 	case -EPERM:
445564 	case -EACCES:
446565 		fl->fl_u.afs.state = ret;
566
+		trace_afs_flock_ev(vnode, fl, afs_flock_fail_perm, ret);
447567 		list_del_init(&fl->fl_u.afs.link);
448568 		afs_next_locker(vnode, ret);
449569 		goto error_unlock;
450570 
571
+	case -ENOENT:
572
+		fl->fl_u.afs.state = ret;
573
+		trace_afs_flock_ev(vnode, fl, afs_flock_fail_other, ret);
574
+		list_del_init(&fl->fl_u.afs.link);
575
+		afs_kill_lockers_enoent(vnode);
576
+		goto error_unlock;
577
+
451578 	default:
452579 		fl->fl_u.afs.state = ret;
580
+		trace_afs_flock_ev(vnode, fl, afs_flock_fail_other, ret);
453581 		list_del_init(&fl->fl_u.afs.link);
454582 		afs_next_locker(vnode, 0);
455583 		goto error_unlock;
....@@ -459,14 +587,13 @@
459587 		 * will have to retry.  The server will break the outstanding
460588 		 * callbacks on a file when a lock is released.
461589 		 */
462
-		_debug("would block");
463590 		ASSERT(list_empty(&vnode->granted_locks));
464591 		ASSERTCMP(vnode->pending_locks.next, ==, &fl->fl_u.afs.link);
465592 		goto lock_is_contended;
466593 
467594 	case 0:
468
-		_debug("acquired");
469595 		afs_set_lock_state(vnode, AFS_VNODE_LOCK_GRANTED);
596
+		trace_afs_flock_ev(vnode, fl, afs_flock_acquired, type);
470597 		afs_grant_locks(vnode);
471598 		goto vnode_is_locked_u;
472599 	}
....@@ -477,8 +604,11 @@
477604 	/* the lock has been granted by the server... */
478605 	ASSERTCMP(fl->fl_u.afs.state, ==, AFS_LOCK_GRANTED);
479606 
607
+skip_server_lock:
480608 	/* ... but the VFS still needs to distribute access on this client. */
609
+	trace_afs_flock_ev(vnode, fl, afs_flock_vfs_locking, 0);
481610 	ret = locks_lock_file_wait(file, fl);
611
+	trace_afs_flock_ev(vnode, fl, afs_flock_vfs_lock, ret);
482612 	if (ret < 0)
483613 		goto vfs_rejected_lock;
484614 
....@@ -499,6 +629,7 @@
499629 	}
500630 
501631 	afs_set_lock_state(vnode, AFS_VNODE_LOCK_WAITING_FOR_CB);
632
+	trace_afs_flock_ev(vnode, fl, afs_flock_would_block, ret);
502633 	queue_delayed_work(afs_lock_manager, &vnode->lock_work, HZ * 5);
503634 
504635 need_to_wait:
....@@ -509,10 +640,10 @@
509640 	 */
510641 	spin_unlock(&vnode->lock);
511642 
512
-	_debug("sleep");
643
+	trace_afs_flock_ev(vnode, fl, afs_flock_waiting, 0);
513644 	ret = wait_event_interruptible(fl->fl_wait,
514645 				       fl->fl_u.afs.state != AFS_LOCK_PENDING);
515
-	_debug("wait = %d", ret);
646
+	trace_afs_flock_ev(vnode, fl, afs_flock_waited, ret);
516647 
517648 	if (fl->fl_u.afs.state >= 0 && fl->fl_u.afs.state != AFS_LOCK_GRANTED) {
518649 		spin_lock(&vnode->lock);
....@@ -552,6 +683,8 @@
552683 	 * deal with.
553684 	 */
554685 	_debug("vfs refused %d", ret);
686
+	if (no_server_lock)
687
+		goto error;
555688 	spin_lock(&vnode->lock);
556689 	list_del_init(&fl->fl_u.afs.link);
557690 	afs_defer_unlock(vnode);
....@@ -571,7 +704,9 @@
571704 	struct afs_vnode *vnode = AFS_FS_I(locks_inode(file));
572705 	int ret;
573706 
574
-	_enter("{%x:%u},%u", vnode->fid.vid, vnode->fid.vnode, fl->fl_type);
707
+	_enter("{%llx:%llu},%u", vnode->fid.vid, vnode->fid.vnode, fl->fl_type);
708
+
709
+	trace_afs_flock_op(vnode, fl, afs_flock_op_unlock);
575710 
576711 	/* Flush all pending writes before doing anything with locks. */
577712 	vfs_fsync(file, 0);
....@@ -592,13 +727,16 @@
592727 
593728 	_enter("");
594729 
730
+	if (vnode->lock_state == AFS_VNODE_LOCK_DELETED)
731
+		return -ENOENT;
732
+
595733 	fl->fl_type = F_UNLCK;
596734 
597735 	/* check local lock records first */
598736 	posix_test_lock(file, fl);
599737 	if (fl->fl_type == F_UNLCK) {
600738 		/* no local locks; consult the server */
601
-		ret = afs_fetch_status(vnode, key, false);
739
+		ret = afs_fetch_status(vnode, key, false, NULL);
602740 		if (ret < 0)
603741 			goto error;
604742 
....@@ -626,8 +764,10 @@
626764 int afs_lock(struct file *file, int cmd, struct file_lock *fl)
627765 {
628766 	struct afs_vnode *vnode = AFS_FS_I(locks_inode(file));
767
+	enum afs_flock_operation op;
768
+	int ret;
629769 
630
-	_enter("{%x:%u},%d,{t=%x,fl=%x,r=%Ld:%Ld}",
770
+	_enter("{%llx:%llu},%d,{t=%x,fl=%x,r=%Ld:%Ld}",
631771 	       vnode->fid.vid, vnode->fid.vnode, cmd,
632772 	       fl->fl_type, fl->fl_flags,
633773 	       (long long) fl->fl_start, (long long) fl->fl_end);
....@@ -638,9 +778,23 @@
638778 
639779 	if (IS_GETLK(cmd))
640780 		return afs_do_getlk(file, fl);
781
+
782
+	fl->fl_u.afs.debug_id = atomic_inc_return(&afs_file_lock_debug_id);
783
+	trace_afs_flock_op(vnode, fl, afs_flock_op_lock);
784
+
641785 	if (fl->fl_type == F_UNLCK)
642
-		return afs_do_unlk(file, fl);
643
-	return afs_do_setlk(file, fl);
786
+		ret = afs_do_unlk(file, fl);
787
+	else
788
+		ret = afs_do_setlk(file, fl);
789
+
790
+	switch (ret) {
791
+	case 0:		op = afs_flock_op_return_ok; break;
792
+	case -EAGAIN:	op = afs_flock_op_return_eagain; break;
793
+	case -EDEADLK:	op = afs_flock_op_return_edeadlk; break;
794
+	default:	op = afs_flock_op_return_error; break;
795
+	}
796
+	trace_afs_flock_op(vnode, fl, op);
797
+	return ret;
644798 }
645799 
646800 /*
....@@ -649,8 +803,10 @@
649803 int afs_flock(struct file *file, int cmd, struct file_lock *fl)
650804 {
651805 	struct afs_vnode *vnode = AFS_FS_I(locks_inode(file));
806
+	enum afs_flock_operation op;
807
+	int ret;
652808 
653
-	_enter("{%x:%u},%d,{t=%x,fl=%x}",
809
+	_enter("{%llx:%llu},%d,{t=%x,fl=%x}",
654810 	       vnode->fid.vid, vnode->fid.vnode, cmd,
655811 	       fl->fl_type, fl->fl_flags);
656812 
....@@ -664,10 +820,23 @@
664820 	if (!(fl->fl_flags & FL_FLOCK))
665821 		return -ENOLCK;
666822 
823
+	fl->fl_u.afs.debug_id = atomic_inc_return(&afs_file_lock_debug_id);
824
+	trace_afs_flock_op(vnode, fl, afs_flock_op_flock);
825
+
667826 	/* we're simulating flock() locks using posix locks on the server */
668827 	if (fl->fl_type == F_UNLCK)
669
-		return afs_do_unlk(file, fl);
670
-	return afs_do_setlk(file, fl);
828
+		ret = afs_do_unlk(file, fl);
829
+	else
830
+		ret = afs_do_setlk(file, fl);
831
+
832
+	switch (ret) {
833
+	case 0:		op = afs_flock_op_return_ok; break;
834
+	case -EAGAIN:	op = afs_flock_op_return_eagain; break;
835
+	case -EDEADLK:	op = afs_flock_op_return_edeadlk; break;
836
+	default:	op = afs_flock_op_return_error; break;
837
+	}
838
+	trace_afs_flock_op(vnode, fl, op);
839
+	return ret;
671840 }
672841 
673842 /*
....@@ -682,7 +851,10 @@
682851 
683852 	_enter("");
684853 
854
+	new->fl_u.afs.debug_id = atomic_inc_return(&afs_file_lock_debug_id);
855
+
685856 	spin_lock(&vnode->lock);
857
+	trace_afs_flock_op(vnode, new, afs_flock_op_copy_lock);
686858 	list_add(&new->fl_u.afs.link, &fl->fl_u.afs.link);
687859 	spin_unlock(&vnode->lock);
688860 }
....@@ -699,6 +871,7 @@
699871 
700872 	spin_lock(&vnode->lock);
701873 
874
+	trace_afs_flock_op(vnode, fl, afs_flock_op_release_lock);
702875 	list_del_init(&fl->fl_u.afs.link);
703876 	if (list_empty(&vnode->granted_locks))
704877 		afs_defer_unlock(vnode);