fs/ceph/locks.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/ceph/ceph_debug.h>
   3
   4 #include <linux/file.h>
   5 #include <linux/namei.h>
   6 #include <linux/random.h>
   7
   8 #include "super.h"
   9 #include "mds_client.h"
  10 #include <linux/ceph/pagelist.h>
  11
  12 static u64 lock_secret;
  13 static int ceph_lock_wait_for_completion(struct ceph_mds_client *mdsc,
  14                                          struct ceph_mds_request *req);
  15
  16 static inline u64 secure_addr(void *addr)
  17 {
  18         u64 v = lock_secret ^ (u64)(unsigned long)addr;
  19         /*
  20          * Set the most significant bit, so that MDS knows the 'owner'
  21          * is sufficient to identify the owner of lock. (old code uses
  22          * both 'owner' and 'pid')
  23          */
  24         v |= (1ULL << 63);
  25         return v;
  26 }
  27
  28 void __init ceph_flock_init(void)
  29 {
  30         get_random_bytes(&lock_secret, sizeof(lock_secret));
  31 }
  32
  33 static void ceph_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
  34 {
  35         struct inode *inode = file_inode(src->fl_file);
  36         atomic_inc(&ceph_inode(inode)->i_filelock_ref);
  37 }
  38
  39 static void ceph_fl_release_lock(struct file_lock *fl)
  40 {
  41         struct inode *inode = file_inode(fl->fl_file);
  42         atomic_dec(&ceph_inode(inode)->i_filelock_ref);
  43 }
  44
  45 static const struct file_lock_operations ceph_fl_lock_ops = {
  46         .fl_copy_lock = ceph_fl_copy_lock,
  47         .fl_release_private = ceph_fl_release_lock,
  48 };
  49
  50 /**
  51  * Implement fcntl and flock locking functions.
  52  */
  53 static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode,
  54                              int cmd, u8 wait, struct file_lock *fl)
  55 {
  56         struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
  57         struct ceph_mds_request *req;
  58         int err;
  59         u64 length = 0;
  60         u64 owner;
  61
  62         if (operation == CEPH_MDS_OP_SETFILELOCK) {
  63                 /*
  64                  * increasing i_filelock_ref closes race window between
  65                  * handling request reply and adding file_lock struct to
  66                  * inode. Otherwise, auth caps may get trimmed in the
  67                  * window. Caller function will decrease the counter.
  68                  */
  69                 fl->fl_ops = &ceph_fl_lock_ops;
  70                 atomic_inc(&ceph_inode(inode)->i_filelock_ref);
  71         }
  72
  73         if (operation != CEPH_MDS_OP_SETFILELOCK || cmd == CEPH_LOCK_UNLOCK)
  74                 wait = 0;
  75
  76         req = ceph_mdsc_create_request(mdsc, operation, USE_AUTH_MDS);
  77         if (IS_ERR(req))
  78                 return PTR_ERR(req);
  79         req->r_inode = inode;
  80         ihold(inode);
  81         req->r_num_caps = 1;
  82
  83         /* mds requires start and length rather than start and end */
  84         if (LLONG_MAX == fl->fl_end)
  85                 length = 0;
  86         else
  87                 length = fl->fl_end - fl->fl_start + 1;
  88
  89         owner = secure_addr(fl->fl_owner);
  90
  91         dout("ceph_lock_message: rule: %d, op: %d, owner: %llx, pid: %llu, "
  92              "start: %llu, length: %llu, wait: %d, type: %d", (int)lock_type,
  93              (int)operation, owner, (u64)fl->fl_pid, fl->fl_start, length,
  94              wait, fl->fl_type);
  95
  96         req->r_args.filelock_change.rule = lock_type;
  97         req->r_args.filelock_change.type = cmd;
  98         req->r_args.filelock_change.owner = cpu_to_le64(owner);
  99         req->r_args.filelock_change.pid = cpu_to_le64((u64)fl->fl_pid);
 100         req->r_args.filelock_change.start = cpu_to_le64(fl->fl_start);
 101         req->r_args.filelock_change.length = cpu_to_le64(length);
 102         req->r_args.filelock_change.wait = wait;
 103
 104         if (wait)
 105                 req->r_wait_for_completion = ceph_lock_wait_for_completion;
 106
 107         err = ceph_mdsc_do_request(mdsc, inode, req);
 108
 109         if (operation == CEPH_MDS_OP_GETFILELOCK) {
 110                 fl->fl_pid = -le64_to_cpu(req->r_reply_info.filelock_reply->pid);
 111                 if (CEPH_LOCK_SHARED == req->r_reply_info.filelock_reply->type)
 112                         fl->fl_type = F_RDLCK;
 113                 else if (CEPH_LOCK_EXCL == req->r_reply_info.filelock_reply->type)
 114                         fl->fl_type = F_WRLCK;
 115                 else
 116                         fl->fl_type = F_UNLCK;
 117
 118                 fl->fl_start = le64_to_cpu(req->r_reply_info.filelock_reply->start);
 119                 length = le64_to_cpu(req->r_reply_info.filelock_reply->start) +
 120                                                  le64_to_cpu(req->r_reply_info.filelock_reply->length);
 121                 if (length >= 1)
 122                         fl->fl_end = length -1;
 123                 else
 124                         fl->fl_end = 0;
 125
 126         }
 127         ceph_mdsc_put_request(req);
 128         dout("ceph_lock_message: rule: %d, op: %d, pid: %llu, start: %llu, "
 129              "length: %llu, wait: %d, type: %d, err code %d", (int)lock_type,
 130              (int)operation, (u64)fl->fl_pid, fl->fl_start,
 131              length, wait, fl->fl_type, err);
 132         return err;
 133 }
 134
 135 static int ceph_lock_wait_for_completion(struct ceph_mds_client *mdsc,
 136                                          struct ceph_mds_request *req)
 137 {
 138         struct ceph_mds_request *intr_req;
 139         struct inode *inode = req->r_inode;
 140         int err, lock_type;
 141
 142         BUG_ON(req->r_op != CEPH_MDS_OP_SETFILELOCK);
 143         if (req->r_args.filelock_change.rule == CEPH_LOCK_FCNTL)
 144                 lock_type = CEPH_LOCK_FCNTL_INTR;
 145         else if (req->r_args.filelock_change.rule == CEPH_LOCK_FLOCK)
 146                 lock_type = CEPH_LOCK_FLOCK_INTR;
 147         else
 148                 BUG_ON(1);
 149         BUG_ON(req->r_args.filelock_change.type == CEPH_LOCK_UNLOCK);
 150
 151         err = wait_for_completion_interruptible(&req->r_completion);
 152         if (!err)
 153                 return 0;
 154
 155         dout("ceph_lock_wait_for_completion: request %llu was interrupted\n",
 156              req->r_tid);
 157
 158         mutex_lock(&mdsc->mutex);
 159         if (test_bit(CEPH_MDS_R_GOT_RESULT, &req->r_req_flags)) {
 160                 err = 0;
 161         } else {
 162                 /*
 163                  * ensure we aren't running concurrently with
 164                  * ceph_fill_trace or ceph_readdir_prepopulate, which
 165                  * rely on locks (dir mutex) held by our caller.
 166                  */
 167                 mutex_lock(&req->r_fill_mutex);
 168                 req->r_err = err;
 169                 set_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags);
 170                 mutex_unlock(&req->r_fill_mutex);
 171
 172                 if (!req->r_session) {
 173                         // haven't sent the request
 174                         err = 0;
 175                 }
 176         }
 177         mutex_unlock(&mdsc->mutex);
 178         if (!err)
 179                 return 0;
 180
 181         intr_req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETFILELOCK,
 182                                             USE_AUTH_MDS);
 183         if (IS_ERR(intr_req))
 184                 return PTR_ERR(intr_req);
 185
 186         intr_req->r_inode = inode;
 187         ihold(inode);
 188         intr_req->r_num_caps = 1;
 189
 190         intr_req->r_args.filelock_change = req->r_args.filelock_change;
 191         intr_req->r_args.filelock_change.rule = lock_type;
 192         intr_req->r_args.filelock_change.type = CEPH_LOCK_UNLOCK;
 193
 194         err = ceph_mdsc_do_request(mdsc, inode, intr_req);
 195         ceph_mdsc_put_request(intr_req);
 196
 197         if (err && err != -ERESTARTSYS)
 198                 return err;
 199
 200         wait_for_completion_killable(&req->r_safe_completion);
 201         return 0;
 202 }
 203
 204 /**
 205  * Attempt to set an fcntl lock.
 206  * For now, this just goes away to the server. Later it may be more awesome.
 207  */
 208 int ceph_lock(struct file *file, int cmd, struct file_lock *fl)
 209 {
 210         struct inode *inode = file_inode(file);
 211         int err;
 212         u16 op = CEPH_MDS_OP_SETFILELOCK;
 213         u8 lock_cmd;
 214         u8 wait = 0;
 215
 216         if (!(fl->fl_flags & FL_POSIX))
 217                 return -ENOLCK;
 218         /* No mandatory locks */
 219         if (__mandatory_lock(file->f_mapping->host) && fl->fl_type != F_UNLCK)
 220                 return -ENOLCK;
 221
 222         dout("ceph_lock, fl_owner: %p", fl->fl_owner);
 223
 224         /* set wait bit as appropriate, then make command as Ceph expects it*/
 225         if (IS_GETLK(cmd))
 226                 op = CEPH_MDS_OP_GETFILELOCK;
 227         else if (IS_SETLKW(cmd))
 228                 wait = 1;
 229
 230         if (op == CEPH_MDS_OP_SETFILELOCK) {
 231                 /*
 232                  * increasing i_filelock_ref closes race window between
 233                  * handling request reply and adding file_lock struct to
 234                  * inode. Otherwise, i_auth_cap may get trimmed in the
 235                  * window. Caller function will decrease the counter.
 236                  */
 237                 fl->fl_ops = &ceph_fl_lock_ops;
 238                 atomic_inc(&ceph_inode(inode)->i_filelock_ref);
 239         }
 240
 241         if (F_RDLCK == fl->fl_type)
 242                 lock_cmd = CEPH_LOCK_SHARED;
 243         else if (F_WRLCK == fl->fl_type)
 244                 lock_cmd = CEPH_LOCK_EXCL;
 245         else
 246                 lock_cmd = CEPH_LOCK_UNLOCK;
 247
 248         err = ceph_lock_message(CEPH_LOCK_FCNTL, op, inode, lock_cmd, wait, fl);
 249         if (!err) {
 250                 if (op != CEPH_MDS_OP_GETFILELOCK) {
 251                         dout("mds locked, locking locally");
 252                         err = posix_lock_file(file, fl, NULL);
 253                         if (err && (CEPH_MDS_OP_SETFILELOCK == op)) {
 254                                 /* undo! This should only happen if
 255                                  * the kernel detects local
 256                                  * deadlock. */
 257                                 ceph_lock_message(CEPH_LOCK_FCNTL, op, inode,
 258                                                   CEPH_LOCK_UNLOCK, 0, fl);
 259                                 dout("got %d on posix_lock_file, undid lock",
 260                                      err);
 261                         }
 262                 }
 263         }
 264         return err;
 265 }
 266
 267 int ceph_flock(struct file *file, int cmd, struct file_lock *fl)
 268 {
 269         struct inode *inode = file_inode(file);
 270         int err;
 271         u8 lock_cmd;
 272         u8 wait = 0;
 273
 274         if (!(fl->fl_flags & FL_FLOCK))
 275                 return -ENOLCK;
 276         /* No mandatory locks */
 277         if (fl->fl_type & LOCK_MAND)
 278                 return -EOPNOTSUPP;
 279
 280         dout("ceph_flock, fl_file: %p", fl->fl_file);
 281
 282         /* see comment in ceph_lock */
 283         fl->fl_ops = &ceph_fl_lock_ops;
 284         atomic_inc(&ceph_inode(inode)->i_filelock_ref);
 285
 286         if (IS_SETLKW(cmd))
 287                 wait = 1;
 288
 289         if (F_RDLCK == fl->fl_type)
 290                 lock_cmd = CEPH_LOCK_SHARED;
 291         else if (F_WRLCK == fl->fl_type)
 292                 lock_cmd = CEPH_LOCK_EXCL;
 293         else
 294                 lock_cmd = CEPH_LOCK_UNLOCK;
 295
 296         err = ceph_lock_message(CEPH_LOCK_FLOCK, CEPH_MDS_OP_SETFILELOCK,
 297                                 inode, lock_cmd, wait, fl);
 298         if (!err) {
 299                 err = locks_lock_file_wait(file, fl);
 300                 if (err) {
 301                         ceph_lock_message(CEPH_LOCK_FLOCK,
 302                                           CEPH_MDS_OP_SETFILELOCK,
 303                                           inode, CEPH_LOCK_UNLOCK, 0, fl);
 304                         dout("got %d on locks_lock_file_wait, undid lock", err);
 305                 }
 306         }
 307         return err;
 308 }
 309
 310 /*
 311  * Fills in the passed counter variables, so you can prepare pagelist metadata
 312  * before calling ceph_encode_locks.
 313  */
 314 void ceph_count_locks(struct inode *inode, int *fcntl_count, int *flock_count)
 315 {
 316         struct file_lock *lock;
 317         struct file_lock_context *ctx;
 318
 319         *fcntl_count = 0;
 320         *flock_count = 0;
 321
 322         ctx = inode->i_flctx;
 323         if (ctx) {
 324                 spin_lock(&ctx->flc_lock);
 325                 list_for_each_entry(lock, &ctx->flc_posix, fl_list)
 326                         ++(*fcntl_count);
 327                 list_for_each_entry(lock, &ctx->flc_flock, fl_list)
 328                         ++(*flock_count);
 329                 spin_unlock(&ctx->flc_lock);
 330         }
 331         dout("counted %d flock locks and %d fcntl locks",
 332              *flock_count, *fcntl_count);
 333 }
 334
 335 /*
 336  * Given a pointer to a lock, convert it to a ceph filelock
 337  */
 338 static int lock_to_ceph_filelock(struct file_lock *lock,
 339                                  struct ceph_filelock *cephlock)
 340 {
 341         int err = 0;
 342         cephlock->start = cpu_to_le64(lock->fl_start);
 343         cephlock->length = cpu_to_le64(lock->fl_end - lock->fl_start + 1);
 344         cephlock->client = cpu_to_le64(0);
 345         cephlock->pid = cpu_to_le64((u64)lock->fl_pid);
 346         cephlock->owner = cpu_to_le64(secure_addr(lock->fl_owner));
 347
 348         switch (lock->fl_type) {
 349         case F_RDLCK:
 350                 cephlock->type = CEPH_LOCK_SHARED;
 351                 break;
 352         case F_WRLCK:
 353                 cephlock->type = CEPH_LOCK_EXCL;
 354                 break;
 355         case F_UNLCK:
 356                 cephlock->type = CEPH_LOCK_UNLOCK;
 357                 break;
 358         default:
 359                 dout("Have unknown lock type %d", lock->fl_type);
 360                 err = -EINVAL;
 361         }
 362
 363         return err;
 364 }
 365
 366 /**
 367  * Encode the flock and fcntl locks for the given inode into the ceph_filelock
 368  * array. Must be called with inode->i_lock already held.
 369  * If we encounter more of a specific lock type than expected, return -ENOSPC.
 370  */
 371 int ceph_encode_locks_to_buffer(struct inode *inode,
 372                                 struct ceph_filelock *flocks,
 373                                 int num_fcntl_locks, int num_flock_locks)
 374 {
 375         struct file_lock *lock;
 376         struct file_lock_context *ctx = inode->i_flctx;
 377         int err = 0;
 378         int seen_fcntl = 0;
 379         int seen_flock = 0;
 380         int l = 0;
 381
 382         dout("encoding %d flock and %d fcntl locks", num_flock_locks,
 383              num_fcntl_locks);
 384
 385         if (!ctx)
 386                 return 0;
 387
 388         spin_lock(&ctx->flc_lock);
 389         list_for_each_entry(lock, &ctx->flc_posix, fl_list) {
 390                 ++seen_fcntl;
 391                 if (seen_fcntl > num_fcntl_locks) {
 392                         err = -ENOSPC;
 393                         goto fail;
 394                 }
 395                 err = lock_to_ceph_filelock(lock, &flocks[l]);
 396                 if (err)
 397                         goto fail;
 398                 ++l;
 399         }
 400         list_for_each_entry(lock, &ctx->flc_flock, fl_list) {
 401                 ++seen_flock;
 402                 if (seen_flock > num_flock_locks) {
 403                         err = -ENOSPC;
 404                         goto fail;
 405                 }
 406                 err = lock_to_ceph_filelock(lock, &flocks[l]);
 407                 if (err)
 408                         goto fail;
 409                 ++l;
 410         }
 411 fail:
 412         spin_unlock(&ctx->flc_lock);
 413         return err;
 414 }
 415
 416 /**
 417  * Copy the encoded flock and fcntl locks into the pagelist.
 418  * Format is: #fcntl locks, sequential fcntl locks, #flock locks,
 419  * sequential flock locks.
 420  * Returns zero on success.
 421  */
 422 int ceph_locks_to_pagelist(struct ceph_filelock *flocks,
 423                            struct ceph_pagelist *pagelist,
 424                            int num_fcntl_locks, int num_flock_locks)
 425 {
 426         int err = 0;
 427         __le32 nlocks;
 428
 429         nlocks = cpu_to_le32(num_fcntl_locks);
 430         err = ceph_pagelist_append(pagelist, &nlocks, sizeof(nlocks));
 431         if (err)
 432                 goto out_fail;
 433
 434         if (num_fcntl_locks > 0) {
 435                 err = ceph_pagelist_append(pagelist, flocks,
 436                                            num_fcntl_locks * sizeof(*flocks));
 437                 if (err)
 438                         goto out_fail;
 439         }
 440
 441         nlocks = cpu_to_le32(num_flock_locks);
 442         err = ceph_pagelist_append(pagelist, &nlocks, sizeof(nlocks));
 443         if (err)
 444                 goto out_fail;
 445
 446         if (num_flock_locks > 0) {
 447                 err = ceph_pagelist_append(pagelist, &flocks[num_fcntl_locks],
 448                                            num_flock_locks * sizeof(*flocks));
 449         }
 450 out_fail:
 451         return err;
 452 }