fs/afs/flock.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* AFS file locking support
   3  *
   4  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include "internal.h"
   9
  10 #define AFS_LOCK_GRANTED        0
  11 #define AFS_LOCK_PENDING        1
  12 #define AFS_LOCK_YOUR_TRY       2
  13
  14 struct workqueue_struct *afs_lock_manager;
  15
  16 static void afs_next_locker(struct afs_vnode *vnode, int error);
  17 static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl);
  18 static void afs_fl_release_private(struct file_lock *fl);
  19
  20 static const struct file_lock_operations afs_lock_ops = {
  21         .fl_copy_lock           = afs_fl_copy_lock,
  22         .fl_release_private     = afs_fl_release_private,
  23 };
  24
  25 static inline void afs_set_lock_state(struct afs_vnode *vnode, enum afs_lock_state state)
  26 {
  27         _debug("STATE %u -> %u", vnode->lock_state, state);
  28         vnode->lock_state = state;
  29 }
  30
  31 static atomic_t afs_file_lock_debug_id;
  32
  33 /*
  34  * if the callback is broken on this vnode, then the lock may now be available
  35  */
  36 void afs_lock_may_be_available(struct afs_vnode *vnode)
  37 {
  38         _enter("{%llx:%llu}", vnode->fid.vid, vnode->fid.vnode);
  39
  40         spin_lock(&vnode->lock);
  41         if (vnode->lock_state == AFS_VNODE_LOCK_WAITING_FOR_CB)
  42                 afs_next_locker(vnode, 0);
  43         trace_afs_flock_ev(vnode, NULL, afs_flock_callback_break, 0);
  44         spin_unlock(&vnode->lock);
  45 }
  46
  47 /*
  48  * the lock will time out in 5 minutes unless we extend it, so schedule
  49  * extension in a bit less than that time
  50  */
  51 static void afs_schedule_lock_extension(struct afs_vnode *vnode)
  52 {
  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->reply_time;
  80                 afs_schedule_lock_extension(vnode);
  81                 spin_unlock(&vnode->lock);
  82         }
  83 }
  84
  85 /*
  86  * grant one or more locks (readlocks are allowed to jump the queue if the
  87  * first lock in the queue is itself a readlock)
  88  * - the caller must hold the vnode lock
  89  */
  90 static void afs_grant_locks(struct afs_vnode *vnode)
  91 {
  92         struct file_lock *p, *_p;
  93         bool exclusive = (vnode->lock_type == AFS_LOCK_WRITE);
  94
  95         list_for_each_entry_safe(p, _p, &vnode->pending_locks, fl_u.afs.link) {
  96                 if (!exclusive && p->fl_type == F_WRLCK)
  97                         continue;
  98
  99                 list_move_tail(&p->fl_u.afs.link, &vnode->granted_locks);
 100                 p->fl_u.afs.state = AFS_LOCK_GRANTED;
 101                 trace_afs_flock_op(vnode, p, afs_flock_op_grant);
 102                 wake_up(&p->fl_wait);
 103         }
 104 }
 105
 106 /*
 107  * If an error is specified, reject every pending lock that matches the
 108  * authentication and type of the lock we failed to get.  If there are any
 109  * remaining lockers, try to wake up one of them to have a go.
 110  */
 111 static void afs_next_locker(struct afs_vnode *vnode, int error)
 112 {
 113         struct file_lock *p, *_p, *next = NULL;
 114         struct key *key = vnode->lock_key;
 115         unsigned int fl_type = F_RDLCK;
 116
 117         _enter("");
 118
 119         if (vnode->lock_type == AFS_LOCK_WRITE)
 120                 fl_type = F_WRLCK;
 121
 122         list_for_each_entry_safe(p, _p, &vnode->pending_locks, fl_u.afs.link) {
 123                 if (error &&
 124                     p->fl_type == fl_type &&
 125                     afs_file_key(p->fl_file) == key) {
 126                         list_del_init(&p->fl_u.afs.link);
 127                         p->fl_u.afs.state = error;
 128                         wake_up(&p->fl_wait);
 129                 }
 130
 131                 /* Select the next locker to hand off to. */
 132                 if (next &&
 133                     (next->fl_type == F_WRLCK || p->fl_type == F_RDLCK))
 134                         continue;
 135                 next = p;
 136         }
 137
 138         vnode->lock_key = NULL;
 139         key_put(key);
 140
 141         if (next) {
 142                 afs_set_lock_state(vnode, AFS_VNODE_LOCK_SETTING);
 143                 next->fl_u.afs.state = AFS_LOCK_YOUR_TRY;
 144                 trace_afs_flock_op(vnode, next, afs_flock_op_wake);
 145                 wake_up(&next->fl_wait);
 146         } else {
 147                 afs_set_lock_state(vnode, AFS_VNODE_LOCK_NONE);
 148                 trace_afs_flock_ev(vnode, NULL, afs_flock_no_lockers, 0);
 149         }
 150
 151         _leave("");
 152 }
 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 };
 188
 189 /*
 190  * Get a lock on a file
 191  */
 192 static int afs_set_lock(struct afs_vnode *vnode, struct key *key,
 193                         afs_lock_type_t type)
 194 {
 195         struct afs_operation *op;
 196
 197         _enter("%s{%llx:%llu.%u},%x,%u",
 198                vnode->volume->name,
 199                vnode->fid.vid,
 200                vnode->fid.vnode,
 201                vnode->fid.unique,
 202                key_serial(key), type);
 203
 204         op = afs_alloc_operation(key, vnode->volume);
 205         if (IS_ERR(op))
 206                 return PTR_ERR(op);
 207
 208         afs_op_set_vnode(op, 0, vnode);
 209
 210         op->lock.type   = type;
 211         op->ops         = &afs_set_lock_operation;
 212         return afs_do_sync_operation(op);
 213 }
 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 };
 220
 221 /*
 222  * Extend a lock on a file
 223  */
 224 static int afs_extend_lock(struct afs_vnode *vnode, struct key *key)
 225 {
 226         struct afs_operation *op;
 227
 228         _enter("%s{%llx:%llu.%u},%x",
 229                vnode->volume->name,
 230                vnode->fid.vid,
 231                vnode->fid.vnode,
 232                vnode->fid.unique,
 233                key_serial(key));
 234
 235         op = afs_alloc_operation(key, vnode->volume);
 236         if (IS_ERR(op))
 237                 return PTR_ERR(op);
 238
 239         afs_op_set_vnode(op, 0, vnode);
 240
 241         op->flags       |= AFS_OPERATION_UNINTR;
 242         op->ops         = &afs_extend_lock_operation;
 243         return afs_do_sync_operation(op);
 244 }
 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 };
 251
 252 /*
 253  * Release a lock on a file
 254  */
 255 static int afs_release_lock(struct afs_vnode *vnode, struct key *key)
 256 {
 257         struct afs_operation *op;
 258
 259         _enter("%s{%llx:%llu.%u},%x",
 260                vnode->volume->name,
 261                vnode->fid.vid,
 262                vnode->fid.vnode,
 263                vnode->fid.unique,
 264                key_serial(key));
 265
 266         op = afs_alloc_operation(key, vnode->volume);
 267         if (IS_ERR(op))
 268                 return PTR_ERR(op);
 269
 270         afs_op_set_vnode(op, 0, vnode);
 271
 272         op->flags       |= AFS_OPERATION_UNINTR;
 273         op->ops         = &afs_release_lock_operation;
 274         return afs_do_sync_operation(op);
 275 }
 276
 277 /*
 278  * do work for a lock, including:
 279  * - probing for a lock we're waiting on but didn't get immediately
 280  * - extending a lock that's close to timing out
 281  */
 282 void afs_lock_work(struct work_struct *work)
 283 {
 284         struct afs_vnode *vnode =
 285                 container_of(work, struct afs_vnode, lock_work.work);
 286         struct key *key;
 287         int ret;
 288
 289         _enter("{%llx:%llu}", vnode->fid.vid, vnode->fid.vnode);
 290
 291         spin_lock(&vnode->lock);
 292
 293 again:
 294         _debug("wstate %u for %p", vnode->lock_state, vnode);
 295         switch (vnode->lock_state) {
 296         case AFS_VNODE_LOCK_NEED_UNLOCK:
 297                 afs_set_lock_state(vnode, AFS_VNODE_LOCK_UNLOCKING);
 298                 trace_afs_flock_ev(vnode, NULL, afs_flock_work_unlocking, 0);
 299                 spin_unlock(&vnode->lock);
 300
 301                 /* attempt to release the server lock; if it fails, we just
 302                  * wait 5 minutes and it'll expire anyway */
 303                 ret = afs_release_lock(vnode, vnode->lock_key);
 304                 if (ret < 0 && vnode->lock_state != AFS_VNODE_LOCK_DELETED) {
 305                         trace_afs_flock_ev(vnode, NULL, afs_flock_release_fail,
 306                                            ret);
 307                         printk(KERN_WARNING "AFS:"
 308                                " Failed to release lock on {%llx:%llx} error %d\n",
 309                                vnode->fid.vid, vnode->fid.vnode, ret);
 310                 }
 311
 312                 spin_lock(&vnode->lock);
 313                 if (ret == -ENOENT)
 314                         afs_kill_lockers_enoent(vnode);
 315                 else
 316                         afs_next_locker(vnode, 0);
 317                 spin_unlock(&vnode->lock);
 318                 return;
 319
 320         /* If we've already got a lock, then it must be time to extend that
 321          * lock as AFS locks time out after 5 minutes.
 322          */
 323         case AFS_VNODE_LOCK_GRANTED:
 324                 _debug("extend");
 325
 326                 ASSERT(!list_empty(&vnode->granted_locks));
 327
 328                 key = key_get(vnode->lock_key);
 329                 afs_set_lock_state(vnode, AFS_VNODE_LOCK_EXTENDING);
 330                 trace_afs_flock_ev(vnode, NULL, afs_flock_work_extending, 0);
 331                 spin_unlock(&vnode->lock);
 332
 333                 ret = afs_extend_lock(vnode, key); /* RPC */
 334                 key_put(key);
 335
 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                 }
 342
 343                 spin_lock(&vnode->lock);
 344
 345                 if (ret == -ENOENT) {
 346                         afs_kill_lockers_enoent(vnode);
 347                         spin_unlock(&vnode->lock);
 348                         return;
 349                 }
 350
 351                 if (vnode->lock_state != AFS_VNODE_LOCK_EXTENDING)
 352                         goto again;
 353                 afs_set_lock_state(vnode, AFS_VNODE_LOCK_GRANTED);
 354
 355                 if (ret != 0)
 356                         queue_delayed_work(afs_lock_manager, &vnode->lock_work,
 357                                            HZ * 10);
 358                 spin_unlock(&vnode->lock);
 359                 _leave(" [ext]");
 360                 return;
 361
 362         /* If we're waiting for a callback to indicate lock release, we can't
 363          * actually rely on this, so need to recheck at regular intervals.  The
 364          * problem is that the server might not notify us if the lock just
 365          * expires (say because a client died) rather than being explicitly
 366          * released.
 367          */
 368         case AFS_VNODE_LOCK_WAITING_FOR_CB:
 369                 _debug("retry");
 370                 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);
 376                 spin_unlock(&vnode->lock);
 377                 return;
 378
 379         default:
 380                 /* Looks like a lock request was withdrawn. */
 381                 spin_unlock(&vnode->lock);
 382                 _leave(" [no]");
 383                 return;
 384         }
 385 }
 386
 387 /*
 388  * pass responsibility for the unlocking of a vnode on the server to the
 389  * manager thread, lest a pending signal in the calling thread interrupt
 390  * AF_RXRPC
 391  * - the caller must hold the vnode lock
 392  */
 393 static void afs_defer_unlock(struct afs_vnode *vnode)
 394 {
 395         _enter("%u", vnode->lock_state);
 396
 397         if (list_empty(&vnode->granted_locks) &&
 398             (vnode->lock_state == AFS_VNODE_LOCK_GRANTED ||
 399              vnode->lock_state == AFS_VNODE_LOCK_EXTENDING)) {
 400                 cancel_delayed_work(&vnode->lock_work);
 401
 402                 afs_set_lock_state(vnode, AFS_VNODE_LOCK_NEED_UNLOCK);
 403                 trace_afs_flock_ev(vnode, NULL, afs_flock_defer_unlock, 0);
 404                 queue_delayed_work(afs_lock_manager, &vnode->lock_work, 0);
 405         }
 406 }
 407
 408 /*
 409  * Check that our view of the file metadata is up to date and check to see
 410  * whether we think that we have a locking permit.
 411  */
 412 static int afs_do_setlk_check(struct afs_vnode *vnode, struct key *key,
 413                               enum afs_flock_mode mode, afs_lock_type_t type)
 414 {
 415         afs_access_t access;
 416         int ret;
 417
 418         /* Make sure we've got a callback on this file and that our view of the
 419          * data version is up to date.
 420          */
 421         ret = afs_validate(vnode, key);
 422         if (ret < 0)
 423                 return ret;
 424
 425         /* Check the permission set to see if we're actually going to be
 426          * allowed to get a lock on this file.
 427          */
 428         ret = afs_check_permit(vnode, key, &access);
 429         if (ret < 0)
 430                 return ret;
 431
 432         /* At a rough estimation, you need LOCK, WRITE or INSERT perm to
 433          * read-lock a file and WRITE or INSERT perm to write-lock a file.
 434          *
 435          * We can't rely on the server to do this for us since if we want to
 436          * share a read lock that we already have, we won't go the server.
 437          */
 438         if (type == AFS_LOCK_READ) {
 439                 if (!(access & (AFS_ACE_INSERT | AFS_ACE_WRITE | AFS_ACE_LOCK)))
 440                         return -EACCES;
 441         } else {
 442                 if (!(access & (AFS_ACE_INSERT | AFS_ACE_WRITE)))
 443                         return -EACCES;
 444         }
 445
 446         return 0;
 447 }
 448
 449 /*
 450  * request a lock on a file on the server
 451  */
 452 static int afs_do_setlk(struct file *file, struct file_lock *fl)
 453 {
 454         struct inode *inode = locks_inode(file);
 455         struct afs_vnode *vnode = AFS_FS_I(inode);
 456         enum afs_flock_mode mode = AFS_FS_S(inode->i_sb)->flock_mode;
 457         afs_lock_type_t type;
 458         struct key *key = afs_file_key(file);
 459         bool partial, no_server_lock = false;
 460         int ret;
 461
 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);
 468
 469         fl->fl_ops = &afs_lock_ops;
 470         INIT_LIST_HEAD(&fl->fl_u.afs.link);
 471         fl->fl_u.afs.state = AFS_LOCK_PENDING;
 472
 473         partial = (fl->fl_start != 0 || fl->fl_end != OFFSET_MAX);
 474         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;
 477
 478         ret = afs_do_setlk_check(vnode, key, mode, type);
 479         if (ret < 0)
 480                 return ret;
 481
 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
 498         spin_lock(&vnode->lock);
 499         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;
 504
 505         /* If we've already got a lock on the server then try to move to having
 506          * the VFS grant the requested lock.  Note that this means that other
 507          * clients may get starved out.
 508          */
 509         _debug("try %u", vnode->lock_state);
 510         if (vnode->lock_state == AFS_VNODE_LOCK_GRANTED) {
 511                 if (type == AFS_LOCK_READ) {
 512                         _debug("instant readlock");
 513                         list_move_tail(&fl->fl_u.afs.link, &vnode->granted_locks);
 514                         fl->fl_u.afs.state = AFS_LOCK_GRANTED;
 515                         goto vnode_is_locked_u;
 516                 }
 517
 518                 if (vnode->lock_type == AFS_LOCK_WRITE) {
 519                         _debug("instant writelock");
 520                         list_move_tail(&fl->fl_u.afs.link, &vnode->granted_locks);
 521                         fl->fl_u.afs.state = AFS_LOCK_GRANTED;
 522                         goto vnode_is_locked_u;
 523                 }
 524         }
 525
 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
 538         if (vnode->lock_state != AFS_VNODE_LOCK_NONE)
 539                 goto need_to_wait;
 540
 541 try_to_lock:
 542         /* We don't have a lock on this vnode and we aren't currently waiting
 543          * for one either, so ask the server for a lock.
 544          *
 545          * Note that we need to be careful if we get interrupted by a signal
 546          * after dispatching the request as we may still get the lock, even
 547          * though we don't wait for the reply (it's not too bad a problem - the
 548          * lock will expire in 5 mins anyway).
 549          */
 550         trace_afs_flock_ev(vnode, fl, afs_flock_try_to_lock, 0);
 551         vnode->lock_key = key_get(key);
 552         vnode->lock_type = type;
 553         afs_set_lock_state(vnode, AFS_VNODE_LOCK_SETTING);
 554         spin_unlock(&vnode->lock);
 555
 556         ret = afs_set_lock(vnode, key, type); /* RPC */
 557
 558         spin_lock(&vnode->lock);
 559         switch (ret) {
 560         case -EKEYREJECTED:
 561         case -EKEYEXPIRED:
 562         case -EKEYREVOKED:
 563         case -EPERM:
 564         case -EACCES:
 565                 fl->fl_u.afs.state = ret;
 566                 trace_afs_flock_ev(vnode, fl, afs_flock_fail_perm, ret);
 567                 list_del_init(&fl->fl_u.afs.link);
 568                 afs_next_locker(vnode, ret);
 569                 goto error_unlock;
 570
 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
 578         default:
 579                 fl->fl_u.afs.state = ret;
 580                 trace_afs_flock_ev(vnode, fl, afs_flock_fail_other, ret);
 581                 list_del_init(&fl->fl_u.afs.link);
 582                 afs_next_locker(vnode, 0);
 583                 goto error_unlock;
 584
 585         case -EWOULDBLOCK:
 586                 /* The server doesn't have a lock-waiting queue, so the client
 587                  * will have to retry.  The server will break the outstanding
 588                  * callbacks on a file when a lock is released.
 589                  */
 590                 ASSERT(list_empty(&vnode->granted_locks));
 591                 ASSERTCMP(vnode->pending_locks.next, ==, &fl->fl_u.afs.link);
 592                 goto lock_is_contended;
 593
 594         case 0:
 595                 afs_set_lock_state(vnode, AFS_VNODE_LOCK_GRANTED);
 596                 trace_afs_flock_ev(vnode, fl, afs_flock_acquired, type);
 597                 afs_grant_locks(vnode);
 598                 goto vnode_is_locked_u;
 599         }
 600
 601 vnode_is_locked_u:
 602         spin_unlock(&vnode->lock);
 603 vnode_is_locked:
 604         /* the lock has been granted by the server... */
 605         ASSERTCMP(fl->fl_u.afs.state, ==, AFS_LOCK_GRANTED);
 606
 607 skip_server_lock:
 608         /* ... but the VFS still needs to distribute access on this client. */
 609         trace_afs_flock_ev(vnode, fl, afs_flock_vfs_locking, 0);
 610         ret = locks_lock_file_wait(file, fl);
 611         trace_afs_flock_ev(vnode, fl, afs_flock_vfs_lock, ret);
 612         if (ret < 0)
 613                 goto vfs_rejected_lock;
 614
 615         /* Again, make sure we've got a callback on this file and, again, make
 616          * sure that our view of the data version is up to date (we ignore
 617          * errors incurred here and deal with the consequences elsewhere).
 618          */
 619         afs_validate(vnode, key);
 620         _leave(" = 0");
 621         return 0;
 622
 623 lock_is_contended:
 624         if (!(fl->fl_flags & FL_SLEEP)) {
 625                 list_del_init(&fl->fl_u.afs.link);
 626                 afs_next_locker(vnode, 0);
 627                 ret = -EAGAIN;
 628                 goto error_unlock;
 629         }
 630
 631         afs_set_lock_state(vnode, AFS_VNODE_LOCK_WAITING_FOR_CB);
 632         trace_afs_flock_ev(vnode, fl, afs_flock_would_block, ret);
 633         queue_delayed_work(afs_lock_manager, &vnode->lock_work, HZ * 5);
 634
 635 need_to_wait:
 636         /* We're going to have to wait.  Either this client doesn't have a lock
 637          * on the server yet and we need to wait for a callback to occur, or
 638          * the client does have a lock on the server, but it's shared and we
 639          * need an exclusive lock.
 640          */
 641         spin_unlock(&vnode->lock);
 642
 643         trace_afs_flock_ev(vnode, fl, afs_flock_waiting, 0);
 644         ret = wait_event_interruptible(fl->fl_wait,
 645                                        fl->fl_u.afs.state != AFS_LOCK_PENDING);
 646         trace_afs_flock_ev(vnode, fl, afs_flock_waited, ret);
 647
 648         if (fl->fl_u.afs.state >= 0 && fl->fl_u.afs.state != AFS_LOCK_GRANTED) {
 649                 spin_lock(&vnode->lock);
 650
 651                 switch (fl->fl_u.afs.state) {
 652                 case AFS_LOCK_YOUR_TRY:
 653                         fl->fl_u.afs.state = AFS_LOCK_PENDING;
 654                         goto try_to_lock;
 655                 case AFS_LOCK_PENDING:
 656                         if (ret > 0) {
 657                                 /* We need to retry the lock.  We may not be
 658                                  * notified by the server if it just expired
 659                                  * rather than being released.
 660                                  */
 661                                 ASSERTCMP(vnode->lock_state, ==, AFS_VNODE_LOCK_WAITING_FOR_CB);
 662                                 afs_set_lock_state(vnode, AFS_VNODE_LOCK_SETTING);
 663                                 fl->fl_u.afs.state = AFS_LOCK_PENDING;
 664                                 goto try_to_lock;
 665                         }
 666                         goto error_unlock;
 667                 case AFS_LOCK_GRANTED:
 668                 default:
 669                         break;
 670                 }
 671
 672                 spin_unlock(&vnode->lock);
 673         }
 674
 675         if (fl->fl_u.afs.state == AFS_LOCK_GRANTED)
 676                 goto vnode_is_locked;
 677         ret = fl->fl_u.afs.state;
 678         goto error;
 679
 680 vfs_rejected_lock:
 681         /* The VFS rejected the lock we just obtained, so we have to discard
 682          * what we just got.  We defer this to the lock manager work item to
 683          * deal with.
 684          */
 685         _debug("vfs refused %d", ret);
 686         if (no_server_lock)
 687                 goto error;
 688         spin_lock(&vnode->lock);
 689         list_del_init(&fl->fl_u.afs.link);
 690         afs_defer_unlock(vnode);
 691
 692 error_unlock:
 693         spin_unlock(&vnode->lock);
 694 error:
 695         _leave(" = %d", ret);
 696         return ret;
 697 }
 698
 699 /*
 700  * unlock on a file on the server
 701  */
 702 static int afs_do_unlk(struct file *file, struct file_lock *fl)
 703 {
 704         struct afs_vnode *vnode = AFS_FS_I(locks_inode(file));
 705         int ret;
 706
 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);
 710
 711         /* Flush all pending writes before doing anything with locks. */
 712         vfs_fsync(file, 0);
 713
 714         ret = locks_lock_file_wait(file, fl);
 715         _leave(" = %d [%u]", ret, vnode->lock_state);
 716         return ret;
 717 }
 718
 719 /*
 720  * return information about a lock we currently hold, if indeed we hold one
 721  */
 722 static int afs_do_getlk(struct file *file, struct file_lock *fl)
 723 {
 724         struct afs_vnode *vnode = AFS_FS_I(locks_inode(file));
 725         struct key *key = afs_file_key(file);
 726         int ret, lock_count;
 727
 728         _enter("");
 729
 730         if (vnode->lock_state == AFS_VNODE_LOCK_DELETED)
 731                 return -ENOENT;
 732
 733         fl->fl_type = F_UNLCK;
 734
 735         /* check local lock records first */
 736         posix_test_lock(file, fl);
 737         if (fl->fl_type == F_UNLCK) {
 738                 /* no local locks; consult the server */
 739                 ret = afs_fetch_status(vnode, key, false, NULL);
 740                 if (ret < 0)
 741                         goto error;
 742
 743                 lock_count = READ_ONCE(vnode->status.lock_count);
 744                 if (lock_count != 0) {
 745                         if (lock_count > 0)
 746                                 fl->fl_type = F_RDLCK;
 747                         else
 748                                 fl->fl_type = F_WRLCK;
 749                         fl->fl_start = 0;
 750                         fl->fl_end = OFFSET_MAX;
 751                         fl->fl_pid = 0;
 752                 }
 753         }
 754
 755         ret = 0;
 756 error:
 757         _leave(" = %d [%hd]", ret, fl->fl_type);
 758         return ret;
 759 }
 760
 761 /*
 762  * manage POSIX locks on a file
 763  */
 764 int afs_lock(struct file *file, int cmd, struct file_lock *fl)
 765 {
 766         struct afs_vnode *vnode = AFS_FS_I(locks_inode(file));
 767         enum afs_flock_operation op;
 768         int ret;
 769
 770         _enter("{%llx:%llu},%d,{t=%x,fl=%x,r=%Ld:%Ld}",
 771                vnode->fid.vid, vnode->fid.vnode, cmd,
 772                fl->fl_type, fl->fl_flags,
 773                (long long) fl->fl_start, (long long) fl->fl_end);
 774
 775         /* AFS doesn't support mandatory locks */
 776         if (__mandatory_lock(&vnode->vfs_inode) && fl->fl_type != F_UNLCK)
 777                 return -ENOLCK;
 778
 779         if (IS_GETLK(cmd))
 780                 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
 785         if (fl->fl_type == F_UNLCK)
 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;
 798 }
 799
 800 /*
 801  * manage FLOCK locks on a file
 802  */
 803 int afs_flock(struct file *file, int cmd, struct file_lock *fl)
 804 {
 805         struct afs_vnode *vnode = AFS_FS_I(locks_inode(file));
 806         enum afs_flock_operation op;
 807         int ret;
 808
 809         _enter("{%llx:%llu},%d,{t=%x,fl=%x}",
 810                vnode->fid.vid, vnode->fid.vnode, cmd,
 811                fl->fl_type, fl->fl_flags);
 812
 813         /*
 814          * No BSD flocks over NFS allowed.
 815          * Note: we could try to fake a POSIX lock request here by
 816          * using ((u32) filp | 0x80000000) or some such as the pid.
 817          * Not sure whether that would be unique, though, or whether
 818          * that would break in other places.
 819          */
 820         if (!(fl->fl_flags & FL_FLOCK))
 821                 return -ENOLCK;
 822
 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
 826         /* we're simulating flock() locks using posix locks on the server */
 827         if (fl->fl_type == F_UNLCK)
 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;
 840 }
 841
 842 /*
 843  * the POSIX lock management core VFS code copies the lock record and adds the
 844  * copy into its own list, so we need to add that copy to the vnode's lock
 845  * queue in the same place as the original (which will be deleted shortly
 846  * after)
 847  */
 848 static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl)
 849 {
 850         struct afs_vnode *vnode = AFS_FS_I(locks_inode(fl->fl_file));
 851
 852         _enter("");
 853
 854         new->fl_u.afs.debug_id = atomic_inc_return(&afs_file_lock_debug_id);
 855
 856         spin_lock(&vnode->lock);
 857         trace_afs_flock_op(vnode, new, afs_flock_op_copy_lock);
 858         list_add(&new->fl_u.afs.link, &fl->fl_u.afs.link);
 859         spin_unlock(&vnode->lock);
 860 }
 861
 862 /*
 863  * need to remove this lock from the vnode queue when it's removed from the
 864  * VFS's list
 865  */
 866 static void afs_fl_release_private(struct file_lock *fl)
 867 {
 868         struct afs_vnode *vnode = AFS_FS_I(locks_inode(fl->fl_file));
 869
 870         _enter("");
 871
 872         spin_lock(&vnode->lock);
 873
 874         trace_afs_flock_op(vnode, fl, afs_flock_op_release_lock);
 875         list_del_init(&fl->fl_u.afs.link);
 876         if (list_empty(&vnode->granted_locks))
 877                 afs_defer_unlock(vnode);
 878
 879         _debug("state %u for %p", vnode->lock_state, vnode);
 880         spin_unlock(&vnode->lock);
 881 }