fs/ceph/inode.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/ceph/ceph_debug.h>
   3
   4 #include <linux/module.h>
   5 #include <linux/fs.h>
   6 #include <linux/slab.h>
   7 #include <linux/string.h>
   8 #include <linux/uaccess.h>
   9 #include <linux/kernel.h>
  10 #include <linux/writeback.h>
  11 #include <linux/vmalloc.h>
  12 #include <linux/xattr.h>
  13 #include <linux/posix_acl.h>
  14 #include <linux/random.h>
  15 #include <linux/sort.h>
  16 #include <linux/iversion.h>
  17 #include <linux/fscrypt.h>
  18
  19 #include "super.h"
  20 #include "mds_client.h"
  21 #include "cache.h"
  22 #include "crypto.h"
  23 #include <linux/ceph/decode.h>
  24
  25 /*
  26  * Ceph inode operations
  27  *
  28  * Implement basic inode helpers (get, alloc) and inode ops (getattr,
  29  * setattr, etc.), xattr helpers, and helpers for assimilating
  30  * metadata returned by the MDS into our cache.
  31  *
  32  * Also define helpers for doing asynchronous writeback, invalidation,
  33  * and truncation for the benefit of those who can't afford to block
  34  * (typically because they are in the message handler path).
  35  */
  36
  37 static const struct inode_operations ceph_symlink_iops;
  38 static const struct inode_operations ceph_encrypted_symlink_iops;
  39
  40 static void ceph_inode_work(struct work_struct *work);
  41
  42 /*
  43  * find or create an inode, given the ceph ino number
  44  */
  45 static int ceph_set_ino_cb(struct inode *inode, void *data)
  46 {
  47         struct ceph_inode_info *ci = ceph_inode(inode);
  48         struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
  49
  50         ci->i_vino = *(struct ceph_vino *)data;
  51         inode->i_ino = ceph_vino_to_ino_t(ci->i_vino);
  52         inode_set_iversion_raw(inode, 0);
  53         percpu_counter_inc(&mdsc->metric.total_inodes);
  54
  55         return 0;
  56 }
  57
  58 /**
  59  * ceph_new_inode - allocate a new inode in advance of an expected create
  60  * @dir: parent directory for new inode
  61  * @dentry: dentry that may eventually point to new inode
  62  * @mode: mode of new inode
  63  * @as_ctx: pointer to inherited security context
  64  *
  65  * Allocate a new inode in advance of an operation to create a new inode.
  66  * This allocates the inode and sets up the acl_sec_ctx with appropriate
  67  * info for the new inode.
  68  *
  69  * Returns a pointer to the new inode or an ERR_PTR.
  70  */
  71 struct inode *ceph_new_inode(struct inode *dir, struct dentry *dentry,
  72                              umode_t *mode, struct ceph_acl_sec_ctx *as_ctx)
  73 {
  74         int err;
  75         struct inode *inode;
  76
  77         inode = new_inode(dir->i_sb);
  78         if (!inode)
  79                 return ERR_PTR(-ENOMEM);
  80
  81         if (!S_ISLNK(*mode)) {
  82                 err = ceph_pre_init_acls(dir, mode, as_ctx);
  83                 if (err < 0)
  84                         goto out_err;
  85         }
  86
  87         inode->i_state = 0;
  88         inode->i_mode = *mode;
  89
  90         err = ceph_security_init_secctx(dentry, *mode, as_ctx);
  91         if (err < 0)
  92                 goto out_err;
  93
  94         /*
  95          * We'll skip setting fscrypt context for snapshots, leaving that for
  96          * the handle_reply().
  97          */
  98         if (ceph_snap(dir) != CEPH_SNAPDIR) {
  99                 err = ceph_fscrypt_prepare_context(dir, inode, as_ctx);
 100                 if (err)
 101                         goto out_err;
 102         }
 103
 104         return inode;
 105 out_err:
 106         iput(inode);
 107         return ERR_PTR(err);
 108 }
 109
 110 void ceph_as_ctx_to_req(struct ceph_mds_request *req,
 111                         struct ceph_acl_sec_ctx *as_ctx)
 112 {
 113         if (as_ctx->pagelist) {
 114                 req->r_pagelist = as_ctx->pagelist;
 115                 as_ctx->pagelist = NULL;
 116         }
 117         ceph_fscrypt_as_ctx_to_req(req, as_ctx);
 118 }
 119
 120 /**
 121  * ceph_get_inode - find or create/hash a new inode
 122  * @sb: superblock to search and allocate in
 123  * @vino: vino to search for
 124  * @newino: optional new inode to insert if one isn't found (may be NULL)
 125  *
 126  * Search for or insert a new inode into the hash for the given vino, and
 127  * return a reference to it. If new is non-NULL, its reference is consumed.
 128  */
 129 struct inode *ceph_get_inode(struct super_block *sb, struct ceph_vino vino,
 130                              struct inode *newino)
 131 {
 132         struct inode *inode;
 133
 134         if (ceph_vino_is_reserved(vino))
 135                 return ERR_PTR(-EREMOTEIO);
 136
 137         if (newino) {
 138                 inode = inode_insert5(newino, (unsigned long)vino.ino,
 139                                       ceph_ino_compare, ceph_set_ino_cb, &vino);
 140                 if (inode != newino)
 141                         iput(newino);
 142         } else {
 143                 inode = iget5_locked(sb, (unsigned long)vino.ino,
 144                                      ceph_ino_compare, ceph_set_ino_cb, &vino);
 145         }
 146
 147         if (!inode) {
 148                 dout("No inode found for %llx.%llx\n", vino.ino, vino.snap);
 149                 return ERR_PTR(-ENOMEM);
 150         }
 151
 152         dout("get_inode on %llu=%llx.%llx got %p new %d\n", ceph_present_inode(inode),
 153              ceph_vinop(inode), inode, !!(inode->i_state & I_NEW));
 154         return inode;
 155 }
 156
 157 /*
 158  * get/constuct snapdir inode for a given directory
 159  */
 160 struct inode *ceph_get_snapdir(struct inode *parent)
 161 {
 162         struct ceph_vino vino = {
 163                 .ino = ceph_ino(parent),
 164                 .snap = CEPH_SNAPDIR,
 165         };
 166         struct inode *inode = ceph_get_inode(parent->i_sb, vino, NULL);
 167         struct ceph_inode_info *ci = ceph_inode(inode);
 168         int ret = -ENOTDIR;
 169
 170         if (IS_ERR(inode))
 171                 return inode;
 172
 173         if (!S_ISDIR(parent->i_mode)) {
 174                 pr_warn_once("bad snapdir parent type (mode=0%o)\n",
 175                              parent->i_mode);
 176                 goto err;
 177         }
 178
 179         if (!(inode->i_state & I_NEW) && !S_ISDIR(inode->i_mode)) {
 180                 pr_warn_once("bad snapdir inode type (mode=0%o)\n",
 181                              inode->i_mode);
 182                 goto err;
 183         }
 184
 185         inode->i_mode = parent->i_mode;
 186         inode->i_uid = parent->i_uid;
 187         inode->i_gid = parent->i_gid;
 188         inode->i_mtime = parent->i_mtime;
 189         inode->i_ctime = parent->i_ctime;
 190         inode->i_atime = parent->i_atime;
 191         ci->i_rbytes = 0;
 192         ci->i_btime = ceph_inode(parent)->i_btime;
 193
 194 #ifdef CONFIG_FS_ENCRYPTION
 195         /* if encrypted, just borrow fscrypt_auth from parent */
 196         if (IS_ENCRYPTED(parent)) {
 197                 struct ceph_inode_info *pci = ceph_inode(parent);
 198
 199                 ci->fscrypt_auth = kmemdup(pci->fscrypt_auth,
 200                                            pci->fscrypt_auth_len,
 201                                            GFP_KERNEL);
 202                 if (ci->fscrypt_auth) {
 203                         inode->i_flags |= S_ENCRYPTED;
 204                         ci->fscrypt_auth_len = pci->fscrypt_auth_len;
 205                 } else {
 206                         dout("Failed to alloc snapdir fscrypt_auth\n");
 207                         ret = -ENOMEM;
 208                         goto err;
 209                 }
 210         }
 211 #endif
 212         if (inode->i_state & I_NEW) {
 213                 inode->i_op = &ceph_snapdir_iops;
 214                 inode->i_fop = &ceph_snapdir_fops;
 215                 ci->i_snap_caps = CEPH_CAP_PIN; /* so we can open */
 216                 unlock_new_inode(inode);
 217         }
 218
 219         return inode;
 220 err:
 221         if ((inode->i_state & I_NEW))
 222                 discard_new_inode(inode);
 223         else
 224                 iput(inode);
 225         return ERR_PTR(ret);
 226 }
 227
 228 const struct inode_operations ceph_file_iops = {
 229         .permission = ceph_permission,
 230         .setattr = ceph_setattr,
 231         .getattr = ceph_getattr,
 232         .listxattr = ceph_listxattr,
 233         .get_inode_acl = ceph_get_acl,
 234         .set_acl = ceph_set_acl,
 235 };
 236
 237
 238 /*
 239  * We use a 'frag tree' to keep track of the MDS's directory fragments
 240  * for a given inode (usually there is just a single fragment).  We
 241  * need to know when a child frag is delegated to a new MDS, or when
 242  * it is flagged as replicated, so we can direct our requests
 243  * accordingly.
 244  */
 245
 246 /*
 247  * find/create a frag in the tree
 248  */
 249 static struct ceph_inode_frag *__get_or_create_frag(struct ceph_inode_info *ci,
 250                                                     u32 f)
 251 {
 252         struct rb_node **p;
 253         struct rb_node *parent = NULL;
 254         struct ceph_inode_frag *frag;
 255         int c;
 256
 257         p = &ci->i_fragtree.rb_node;
 258         while (*p) {
 259                 parent = *p;
 260                 frag = rb_entry(parent, struct ceph_inode_frag, node);
 261                 c = ceph_frag_compare(f, frag->frag);
 262                 if (c < 0)
 263                         p = &(*p)->rb_left;
 264                 else if (c > 0)
 265                         p = &(*p)->rb_right;
 266                 else
 267                         return frag;
 268         }
 269
 270         frag = kmalloc(sizeof(*frag), GFP_NOFS);
 271         if (!frag)
 272                 return ERR_PTR(-ENOMEM);
 273
 274         frag->frag = f;
 275         frag->split_by = 0;
 276         frag->mds = -1;
 277         frag->ndist = 0;
 278
 279         rb_link_node(&frag->node, parent, p);
 280         rb_insert_color(&frag->node, &ci->i_fragtree);
 281
 282         dout("get_or_create_frag added %llx.%llx frag %x\n",
 283              ceph_vinop(&ci->netfs.inode), f);
 284         return frag;
 285 }
 286
 287 /*
 288  * find a specific frag @f
 289  */
 290 struct ceph_inode_frag *__ceph_find_frag(struct ceph_inode_info *ci, u32 f)
 291 {
 292         struct rb_node *n = ci->i_fragtree.rb_node;
 293
 294         while (n) {
 295                 struct ceph_inode_frag *frag =
 296                         rb_entry(n, struct ceph_inode_frag, node);
 297                 int c = ceph_frag_compare(f, frag->frag);
 298                 if (c < 0)
 299                         n = n->rb_left;
 300                 else if (c > 0)
 301                         n = n->rb_right;
 302                 else
 303                         return frag;
 304         }
 305         return NULL;
 306 }
 307
 308 /*
 309  * Choose frag containing the given value @v.  If @pfrag is
 310  * specified, copy the frag delegation info to the caller if
 311  * it is present.
 312  */
 313 static u32 __ceph_choose_frag(struct ceph_inode_info *ci, u32 v,
 314                               struct ceph_inode_frag *pfrag, int *found)
 315 {
 316         u32 t = ceph_frag_make(0, 0);
 317         struct ceph_inode_frag *frag;
 318         unsigned nway, i;
 319         u32 n;
 320
 321         if (found)
 322                 *found = 0;
 323
 324         while (1) {
 325                 WARN_ON(!ceph_frag_contains_value(t, v));
 326                 frag = __ceph_find_frag(ci, t);
 327                 if (!frag)
 328                         break; /* t is a leaf */
 329                 if (frag->split_by == 0) {
 330                         if (pfrag)
 331                                 memcpy(pfrag, frag, sizeof(*pfrag));
 332                         if (found)
 333                                 *found = 1;
 334                         break;
 335                 }
 336
 337                 /* choose child */
 338                 nway = 1 << frag->split_by;
 339                 dout("choose_frag(%x) %x splits by %d (%d ways)\n", v, t,
 340                      frag->split_by, nway);
 341                 for (i = 0; i < nway; i++) {
 342                         n = ceph_frag_make_child(t, frag->split_by, i);
 343                         if (ceph_frag_contains_value(n, v)) {
 344                                 t = n;
 345                                 break;
 346                         }
 347                 }
 348                 BUG_ON(i == nway);
 349         }
 350         dout("choose_frag(%x) = %x\n", v, t);
 351
 352         return t;
 353 }
 354
 355 u32 ceph_choose_frag(struct ceph_inode_info *ci, u32 v,
 356                      struct ceph_inode_frag *pfrag, int *found)
 357 {
 358         u32 ret;
 359         mutex_lock(&ci->i_fragtree_mutex);
 360         ret = __ceph_choose_frag(ci, v, pfrag, found);
 361         mutex_unlock(&ci->i_fragtree_mutex);
 362         return ret;
 363 }
 364
 365 /*
 366  * Process dirfrag (delegation) info from the mds.  Include leaf
 367  * fragment in tree ONLY if ndist > 0.  Otherwise, only
 368  * branches/splits are included in i_fragtree)
 369  */
 370 static int ceph_fill_dirfrag(struct inode *inode,
 371                              struct ceph_mds_reply_dirfrag *dirinfo)
 372 {
 373         struct ceph_inode_info *ci = ceph_inode(inode);
 374         struct ceph_inode_frag *frag;
 375         u32 id = le32_to_cpu(dirinfo->frag);
 376         int mds = le32_to_cpu(dirinfo->auth);
 377         int ndist = le32_to_cpu(dirinfo->ndist);
 378         int diri_auth = -1;
 379         int i;
 380         int err = 0;
 381
 382         spin_lock(&ci->i_ceph_lock);
 383         if (ci->i_auth_cap)
 384                 diri_auth = ci->i_auth_cap->mds;
 385         spin_unlock(&ci->i_ceph_lock);
 386
 387         if (mds == -1) /* CDIR_AUTH_PARENT */
 388                 mds = diri_auth;
 389
 390         mutex_lock(&ci->i_fragtree_mutex);
 391         if (ndist == 0 && mds == diri_auth) {
 392                 /* no delegation info needed. */
 393                 frag = __ceph_find_frag(ci, id);
 394                 if (!frag)
 395                         goto out;
 396                 if (frag->split_by == 0) {
 397                         /* tree leaf, remove */
 398                         dout("fill_dirfrag removed %llx.%llx frag %x"
 399                              " (no ref)\n", ceph_vinop(inode), id);
 400                         rb_erase(&frag->node, &ci->i_fragtree);
 401                         kfree(frag);
 402                 } else {
 403                         /* tree branch, keep and clear */
 404                         dout("fill_dirfrag cleared %llx.%llx frag %x"
 405                              " referral\n", ceph_vinop(inode), id);
 406                         frag->mds = -1;
 407                         frag->ndist = 0;
 408                 }
 409                 goto out;
 410         }
 411
 412
 413         /* find/add this frag to store mds delegation info */
 414         frag = __get_or_create_frag(ci, id);
 415         if (IS_ERR(frag)) {
 416                 /* this is not the end of the world; we can continue
 417                    with bad/inaccurate delegation info */
 418                 pr_err("fill_dirfrag ENOMEM on mds ref %llx.%llx fg %x\n",
 419                        ceph_vinop(inode), le32_to_cpu(dirinfo->frag));
 420                 err = -ENOMEM;
 421                 goto out;
 422         }
 423
 424         frag->mds = mds;
 425         frag->ndist = min_t(u32, ndist, CEPH_MAX_DIRFRAG_REP);
 426         for (i = 0; i < frag->ndist; i++)
 427                 frag->dist[i] = le32_to_cpu(dirinfo->dist[i]);
 428         dout("fill_dirfrag %llx.%llx frag %x ndist=%d\n",
 429              ceph_vinop(inode), frag->frag, frag->ndist);
 430
 431 out:
 432         mutex_unlock(&ci->i_fragtree_mutex);
 433         return err;
 434 }
 435
 436 static int frag_tree_split_cmp(const void *l, const void *r)
 437 {
 438         struct ceph_frag_tree_split *ls = (struct ceph_frag_tree_split*)l;
 439         struct ceph_frag_tree_split *rs = (struct ceph_frag_tree_split*)r;
 440         return ceph_frag_compare(le32_to_cpu(ls->frag),
 441                                  le32_to_cpu(rs->frag));
 442 }
 443
 444 static bool is_frag_child(u32 f, struct ceph_inode_frag *frag)
 445 {
 446         if (!frag)
 447                 return f == ceph_frag_make(0, 0);
 448         if (ceph_frag_bits(f) != ceph_frag_bits(frag->frag) + frag->split_by)
 449                 return false;
 450         return ceph_frag_contains_value(frag->frag, ceph_frag_value(f));
 451 }
 452
 453 static int ceph_fill_fragtree(struct inode *inode,
 454                               struct ceph_frag_tree_head *fragtree,
 455                               struct ceph_mds_reply_dirfrag *dirinfo)
 456 {
 457         struct ceph_inode_info *ci = ceph_inode(inode);
 458         struct ceph_inode_frag *frag, *prev_frag = NULL;
 459         struct rb_node *rb_node;
 460         unsigned i, split_by, nsplits;
 461         u32 id;
 462         bool update = false;
 463
 464         mutex_lock(&ci->i_fragtree_mutex);
 465         nsplits = le32_to_cpu(fragtree->nsplits);
 466         if (nsplits != ci->i_fragtree_nsplits) {
 467                 update = true;
 468         } else if (nsplits) {
 469                 i = get_random_u32_below(nsplits);
 470                 id = le32_to_cpu(fragtree->splits[i].frag);
 471                 if (!__ceph_find_frag(ci, id))
 472                         update = true;
 473         } else if (!RB_EMPTY_ROOT(&ci->i_fragtree)) {
 474                 rb_node = rb_first(&ci->i_fragtree);
 475                 frag = rb_entry(rb_node, struct ceph_inode_frag, node);
 476                 if (frag->frag != ceph_frag_make(0, 0) || rb_next(rb_node))
 477                         update = true;
 478         }
 479         if (!update && dirinfo) {
 480                 id = le32_to_cpu(dirinfo->frag);
 481                 if (id != __ceph_choose_frag(ci, id, NULL, NULL))
 482                         update = true;
 483         }
 484         if (!update)
 485                 goto out_unlock;
 486
 487         if (nsplits > 1) {
 488                 sort(fragtree->splits, nsplits, sizeof(fragtree->splits[0]),
 489                      frag_tree_split_cmp, NULL);
 490         }
 491
 492         dout("fill_fragtree %llx.%llx\n", ceph_vinop(inode));
 493         rb_node = rb_first(&ci->i_fragtree);
 494         for (i = 0; i < nsplits; i++) {
 495                 id = le32_to_cpu(fragtree->splits[i].frag);
 496                 split_by = le32_to_cpu(fragtree->splits[i].by);
 497                 if (split_by == 0 || ceph_frag_bits(id) + split_by > 24) {
 498                         pr_err("fill_fragtree %llx.%llx invalid split %d/%u, "
 499                                "frag %x split by %d\n", ceph_vinop(inode),
 500                                i, nsplits, id, split_by);
 501                         continue;
 502                 }
 503                 frag = NULL;
 504                 while (rb_node) {
 505                         frag = rb_entry(rb_node, struct ceph_inode_frag, node);
 506                         if (ceph_frag_compare(frag->frag, id) >= 0) {
 507                                 if (frag->frag != id)
 508                                         frag = NULL;
 509                                 else
 510                                         rb_node = rb_next(rb_node);
 511                                 break;
 512                         }
 513                         rb_node = rb_next(rb_node);
 514                         /* delete stale split/leaf node */
 515                         if (frag->split_by > 0 ||
 516                             !is_frag_child(frag->frag, prev_frag)) {
 517                                 rb_erase(&frag->node, &ci->i_fragtree);
 518                                 if (frag->split_by > 0)
 519                                         ci->i_fragtree_nsplits--;
 520                                 kfree(frag);
 521                         }
 522                         frag = NULL;
 523                 }
 524                 if (!frag) {
 525                         frag = __get_or_create_frag(ci, id);
 526                         if (IS_ERR(frag))
 527                                 continue;
 528                 }
 529                 if (frag->split_by == 0)
 530                         ci->i_fragtree_nsplits++;
 531                 frag->split_by = split_by;
 532                 dout(" frag %x split by %d\n", frag->frag, frag->split_by);
 533                 prev_frag = frag;
 534         }
 535         while (rb_node) {
 536                 frag = rb_entry(rb_node, struct ceph_inode_frag, node);
 537                 rb_node = rb_next(rb_node);
 538                 /* delete stale split/leaf node */
 539                 if (frag->split_by > 0 ||
 540                     !is_frag_child(frag->frag, prev_frag)) {
 541                         rb_erase(&frag->node, &ci->i_fragtree);
 542                         if (frag->split_by > 0)
 543                                 ci->i_fragtree_nsplits--;
 544                         kfree(frag);
 545                 }
 546         }
 547 out_unlock:
 548         mutex_unlock(&ci->i_fragtree_mutex);
 549         return 0;
 550 }
 551
 552 /*
 553  * initialize a newly allocated inode.
 554  */
 555 struct inode *ceph_alloc_inode(struct super_block *sb)
 556 {
 557         struct ceph_inode_info *ci;
 558         int i;
 559
 560         ci = alloc_inode_sb(sb, ceph_inode_cachep, GFP_NOFS);
 561         if (!ci)
 562                 return NULL;
 563
 564         dout("alloc_inode %p\n", &ci->netfs.inode);
 565
 566         /* Set parameters for the netfs library */
 567         netfs_inode_init(&ci->netfs, &ceph_netfs_ops);
 568
 569         spin_lock_init(&ci->i_ceph_lock);
 570
 571         ci->i_version = 0;
 572         ci->i_inline_version = 0;
 573         ci->i_time_warp_seq = 0;
 574         ci->i_ceph_flags = 0;
 575         atomic64_set(&ci->i_ordered_count, 1);
 576         atomic64_set(&ci->i_release_count, 1);
 577         atomic64_set(&ci->i_complete_seq[0], 0);
 578         atomic64_set(&ci->i_complete_seq[1], 0);
 579         ci->i_symlink = NULL;
 580
 581         ci->i_max_bytes = 0;
 582         ci->i_max_files = 0;
 583
 584         memset(&ci->i_dir_layout, 0, sizeof(ci->i_dir_layout));
 585         memset(&ci->i_cached_layout, 0, sizeof(ci->i_cached_layout));
 586         RCU_INIT_POINTER(ci->i_layout.pool_ns, NULL);
 587
 588         ci->i_fragtree = RB_ROOT;
 589         mutex_init(&ci->i_fragtree_mutex);
 590
 591         ci->i_xattrs.blob = NULL;
 592         ci->i_xattrs.prealloc_blob = NULL;
 593         ci->i_xattrs.dirty = false;
 594         ci->i_xattrs.index = RB_ROOT;
 595         ci->i_xattrs.count = 0;
 596         ci->i_xattrs.names_size = 0;
 597         ci->i_xattrs.vals_size = 0;
 598         ci->i_xattrs.version = 0;
 599         ci->i_xattrs.index_version = 0;
 600
 601         ci->i_caps = RB_ROOT;
 602         ci->i_auth_cap = NULL;
 603         ci->i_dirty_caps = 0;
 604         ci->i_flushing_caps = 0;
 605         INIT_LIST_HEAD(&ci->i_dirty_item);
 606         INIT_LIST_HEAD(&ci->i_flushing_item);
 607         ci->i_prealloc_cap_flush = NULL;
 608         INIT_LIST_HEAD(&ci->i_cap_flush_list);
 609         init_waitqueue_head(&ci->i_cap_wq);
 610         ci->i_hold_caps_max = 0;
 611         INIT_LIST_HEAD(&ci->i_cap_delay_list);
 612         INIT_LIST_HEAD(&ci->i_cap_snaps);
 613         ci->i_head_snapc = NULL;
 614         ci->i_snap_caps = 0;
 615
 616         ci->i_last_rd = ci->i_last_wr = jiffies - 3600 * HZ;
 617         for (i = 0; i < CEPH_FILE_MODE_BITS; i++)
 618                 ci->i_nr_by_mode[i] = 0;
 619
 620         mutex_init(&ci->i_truncate_mutex);
 621         ci->i_truncate_seq = 0;
 622         ci->i_truncate_size = 0;
 623         ci->i_truncate_pending = 0;
 624         ci->i_truncate_pagecache_size = 0;
 625
 626         ci->i_max_size = 0;
 627         ci->i_reported_size = 0;
 628         ci->i_wanted_max_size = 0;
 629         ci->i_requested_max_size = 0;
 630
 631         ci->i_pin_ref = 0;
 632         ci->i_rd_ref = 0;
 633         ci->i_rdcache_ref = 0;
 634         ci->i_wr_ref = 0;
 635         ci->i_wb_ref = 0;
 636         ci->i_fx_ref = 0;
 637         ci->i_wrbuffer_ref = 0;
 638         ci->i_wrbuffer_ref_head = 0;
 639         atomic_set(&ci->i_filelock_ref, 0);
 640         atomic_set(&ci->i_shared_gen, 1);
 641         ci->i_rdcache_gen = 0;
 642         ci->i_rdcache_revoking = 0;
 643
 644         INIT_LIST_HEAD(&ci->i_unsafe_dirops);
 645         INIT_LIST_HEAD(&ci->i_unsafe_iops);
 646         spin_lock_init(&ci->i_unsafe_lock);
 647
 648         ci->i_snap_realm = NULL;
 649         INIT_LIST_HEAD(&ci->i_snap_realm_item);
 650         INIT_LIST_HEAD(&ci->i_snap_flush_item);
 651
 652         INIT_WORK(&ci->i_work, ceph_inode_work);
 653         ci->i_work_mask = 0;
 654         memset(&ci->i_btime, '\0', sizeof(ci->i_btime));
 655 #ifdef CONFIG_FS_ENCRYPTION
 656         ci->fscrypt_auth = NULL;
 657         ci->fscrypt_auth_len = 0;
 658 #endif
 659         return &ci->netfs.inode;
 660 }
 661
 662 void ceph_free_inode(struct inode *inode)
 663 {
 664         struct ceph_inode_info *ci = ceph_inode(inode);
 665
 666         kfree(ci->i_symlink);
 667 #ifdef CONFIG_FS_ENCRYPTION
 668         kfree(ci->fscrypt_auth);
 669 #endif
 670         fscrypt_free_inode(inode);
 671         kmem_cache_free(ceph_inode_cachep, ci);
 672 }
 673
 674 void ceph_evict_inode(struct inode *inode)
 675 {
 676         struct ceph_inode_info *ci = ceph_inode(inode);
 677         struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
 678         struct ceph_inode_frag *frag;
 679         struct rb_node *n;
 680
 681         dout("evict_inode %p ino %llx.%llx\n", inode, ceph_vinop(inode));
 682
 683         percpu_counter_dec(&mdsc->metric.total_inodes);
 684
 685         truncate_inode_pages_final(&inode->i_data);
 686         if (inode->i_state & I_PINNING_FSCACHE_WB)
 687                 ceph_fscache_unuse_cookie(inode, true);
 688         clear_inode(inode);
 689
 690         ceph_fscache_unregister_inode_cookie(ci);
 691         fscrypt_put_encryption_info(inode);
 692
 693         __ceph_remove_caps(ci);
 694
 695         if (__ceph_has_quota(ci, QUOTA_GET_ANY))
 696                 ceph_adjust_quota_realms_count(inode, false);
 697
 698         /*
 699          * we may still have a snap_realm reference if there are stray
 700          * caps in i_snap_caps.
 701          */
 702         if (ci->i_snap_realm) {
 703                 if (ceph_snap(inode) == CEPH_NOSNAP) {
 704                         dout(" dropping residual ref to snap realm %p\n",
 705                              ci->i_snap_realm);
 706                         ceph_change_snap_realm(inode, NULL);
 707                 } else {
 708                         ceph_put_snapid_map(mdsc, ci->i_snapid_map);
 709                         ci->i_snap_realm = NULL;
 710                 }
 711         }
 712
 713         while ((n = rb_first(&ci->i_fragtree)) != NULL) {
 714                 frag = rb_entry(n, struct ceph_inode_frag, node);
 715                 rb_erase(n, &ci->i_fragtree);
 716                 kfree(frag);
 717         }
 718         ci->i_fragtree_nsplits = 0;
 719
 720         __ceph_destroy_xattrs(ci);
 721         if (ci->i_xattrs.blob)
 722                 ceph_buffer_put(ci->i_xattrs.blob);
 723         if (ci->i_xattrs.prealloc_blob)
 724                 ceph_buffer_put(ci->i_xattrs.prealloc_blob);
 725
 726         ceph_put_string(rcu_dereference_raw(ci->i_layout.pool_ns));
 727         ceph_put_string(rcu_dereference_raw(ci->i_cached_layout.pool_ns));
 728 }
 729
 730 static inline blkcnt_t calc_inode_blocks(u64 size)
 731 {
 732         return (size + (1<<9) - 1) >> 9;
 733 }
 734
 735 /*
 736  * Helpers to fill in size, ctime, mtime, and atime.  We have to be
 737  * careful because either the client or MDS may have more up to date
 738  * info, depending on which capabilities are held, and whether
 739  * time_warp_seq or truncate_seq have increased.  (Ordinarily, mtime
 740  * and size are monotonically increasing, except when utimes() or
 741  * truncate() increments the corresponding _seq values.)
 742  */
 743 int ceph_fill_file_size(struct inode *inode, int issued,
 744                         u32 truncate_seq, u64 truncate_size, u64 size)
 745 {
 746         struct ceph_inode_info *ci = ceph_inode(inode);
 747         int queue_trunc = 0;
 748         loff_t isize = i_size_read(inode);
 749
 750         if (ceph_seq_cmp(truncate_seq, ci->i_truncate_seq) > 0 ||
 751             (truncate_seq == ci->i_truncate_seq && size > isize)) {
 752                 dout("size %lld -> %llu\n", isize, size);
 753                 if (size > 0 && S_ISDIR(inode->i_mode)) {
 754                         pr_err("fill_file_size non-zero size for directory\n");
 755                         size = 0;
 756                 }
 757                 i_size_write(inode, size);
 758                 inode->i_blocks = calc_inode_blocks(size);
 759                 /*
 760                  * If we're expanding, then we should be able to just update
 761                  * the existing cookie.
 762                  */
 763                 if (size > isize)
 764                         ceph_fscache_update(inode);
 765                 ci->i_reported_size = size;
 766                 if (truncate_seq != ci->i_truncate_seq) {
 767                         dout("%s truncate_seq %u -> %u\n", __func__,
 768                              ci->i_truncate_seq, truncate_seq);
 769                         ci->i_truncate_seq = truncate_seq;
 770
 771                         /* the MDS should have revoked these caps */
 772                         WARN_ON_ONCE(issued & (CEPH_CAP_FILE_EXCL |
 773                                                CEPH_CAP_FILE_RD |
 774                                                CEPH_CAP_FILE_WR |
 775                                                CEPH_CAP_FILE_LAZYIO));
 776                         /*
 777                          * If we hold relevant caps, or in the case where we're
 778                          * not the only client referencing this file and we
 779                          * don't hold those caps, then we need to check whether
 780                          * the file is either opened or mmaped
 781                          */
 782                         if ((issued & (CEPH_CAP_FILE_CACHE|
 783                                        CEPH_CAP_FILE_BUFFER)) ||
 784                             mapping_mapped(inode->i_mapping) ||
 785                             __ceph_is_file_opened(ci)) {
 786                                 ci->i_truncate_pending++;
 787                                 queue_trunc = 1;
 788                         }
 789                 }
 790         }
 791
 792         /*
 793          * It's possible that the new sizes of the two consecutive
 794          * size truncations will be in the same fscrypt last block,
 795          * and we need to truncate the corresponding page caches
 796          * anyway.
 797          */
 798         if (ceph_seq_cmp(truncate_seq, ci->i_truncate_seq) >= 0) {
 799                 dout("%s truncate_size %lld -> %llu, encrypted %d\n", __func__,
 800                      ci->i_truncate_size, truncate_size, !!IS_ENCRYPTED(inode));
 801
 802                 ci->i_truncate_size = truncate_size;
 803
 804                 if (IS_ENCRYPTED(inode)) {
 805                         dout("%s truncate_pagecache_size %lld -> %llu\n",
 806                              __func__, ci->i_truncate_pagecache_size, size);
 807                         ci->i_truncate_pagecache_size = size;
 808                 } else {
 809                         ci->i_truncate_pagecache_size = truncate_size;
 810                 }
 811         }
 812         return queue_trunc;
 813 }
 814
 815 void ceph_fill_file_time(struct inode *inode, int issued,
 816                          u64 time_warp_seq, struct timespec64 *ctime,
 817                          struct timespec64 *mtime, struct timespec64 *atime)
 818 {
 819         struct ceph_inode_info *ci = ceph_inode(inode);
 820         int warn = 0;
 821
 822         if (issued & (CEPH_CAP_FILE_EXCL|
 823                       CEPH_CAP_FILE_WR|
 824                       CEPH_CAP_FILE_BUFFER|
 825                       CEPH_CAP_AUTH_EXCL|
 826                       CEPH_CAP_XATTR_EXCL)) {
 827                 if (ci->i_version == 0 ||
 828                     timespec64_compare(ctime, &inode->i_ctime) > 0) {
 829                         dout("ctime %lld.%09ld -> %lld.%09ld inc w/ cap\n",
 830                              inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
 831                              ctime->tv_sec, ctime->tv_nsec);
 832                         inode->i_ctime = *ctime;
 833                 }
 834                 if (ci->i_version == 0 ||
 835                     ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) > 0) {
 836                         /* the MDS did a utimes() */
 837                         dout("mtime %lld.%09ld -> %lld.%09ld "
 838                              "tw %d -> %d\n",
 839                              inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
 840                              mtime->tv_sec, mtime->tv_nsec,
 841                              ci->i_time_warp_seq, (int)time_warp_seq);
 842
 843                         inode->i_mtime = *mtime;
 844                         inode->i_atime = *atime;
 845                         ci->i_time_warp_seq = time_warp_seq;
 846                 } else if (time_warp_seq == ci->i_time_warp_seq) {
 847                         /* nobody did utimes(); take the max */
 848                         if (timespec64_compare(mtime, &inode->i_mtime) > 0) {
 849                                 dout("mtime %lld.%09ld -> %lld.%09ld inc\n",
 850                                      inode->i_mtime.tv_sec,
 851                                      inode->i_mtime.tv_nsec,
 852                                      mtime->tv_sec, mtime->tv_nsec);
 853                                 inode->i_mtime = *mtime;
 854                         }
 855                         if (timespec64_compare(atime, &inode->i_atime) > 0) {
 856                                 dout("atime %lld.%09ld -> %lld.%09ld inc\n",
 857                                      inode->i_atime.tv_sec,
 858                                      inode->i_atime.tv_nsec,
 859                                      atime->tv_sec, atime->tv_nsec);
 860                                 inode->i_atime = *atime;
 861                         }
 862                 } else if (issued & CEPH_CAP_FILE_EXCL) {
 863                         /* we did a utimes(); ignore mds values */
 864                 } else {
 865                         warn = 1;
 866                 }
 867         } else {
 868                 /* we have no write|excl caps; whatever the MDS says is true */
 869                 if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) >= 0) {
 870                         inode->i_ctime = *ctime;
 871                         inode->i_mtime = *mtime;
 872                         inode->i_atime = *atime;
 873                         ci->i_time_warp_seq = time_warp_seq;
 874                 } else {
 875                         warn = 1;
 876                 }
 877         }
 878         if (warn) /* time_warp_seq shouldn't go backwards */
 879                 dout("%p mds time_warp_seq %llu < %u\n",
 880                      inode, time_warp_seq, ci->i_time_warp_seq);
 881 }
 882
 883 #if IS_ENABLED(CONFIG_FS_ENCRYPTION)
 884 static int decode_encrypted_symlink(const char *encsym, int enclen, u8 **decsym)
 885 {
 886         int declen;
 887         u8 *sym;
 888
 889         sym = kmalloc(enclen + 1, GFP_NOFS);
 890         if (!sym)
 891                 return -ENOMEM;
 892
 893         declen = ceph_base64_decode(encsym, enclen, sym);
 894         if (declen < 0) {
 895                 pr_err("%s: can't decode symlink (%d). Content: %.*s\n",
 896                        __func__, declen, enclen, encsym);
 897                 kfree(sym);
 898                 return -EIO;
 899         }
 900         sym[declen + 1] = '\0';
 901         *decsym = sym;
 902         return declen;
 903 }
 904 #else
 905 static int decode_encrypted_symlink(const char *encsym, int symlen, u8 **decsym)
 906 {
 907         return -EOPNOTSUPP;
 908 }
 909 #endif
 910
 911 /*
 912  * Populate an inode based on info from mds.  May be called on new or
 913  * existing inodes.
 914  */
 915 int ceph_fill_inode(struct inode *inode, struct page *locked_page,
 916                     struct ceph_mds_reply_info_in *iinfo,
 917                     struct ceph_mds_reply_dirfrag *dirinfo,
 918                     struct ceph_mds_session *session, int cap_fmode,
 919                     struct ceph_cap_reservation *caps_reservation)
 920 {
 921         struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
 922         struct ceph_mds_reply_inode *info = iinfo->in;
 923         struct ceph_inode_info *ci = ceph_inode(inode);
 924         int issued, new_issued, info_caps;
 925         struct timespec64 mtime, atime, ctime;
 926         struct ceph_buffer *xattr_blob = NULL;
 927         struct ceph_buffer *old_blob = NULL;
 928         struct ceph_string *pool_ns = NULL;
 929         struct ceph_cap *new_cap = NULL;
 930         int err = 0;
 931         bool wake = false;
 932         bool queue_trunc = false;
 933         bool new_version = false;
 934         bool fill_inline = false;
 935         umode_t mode = le32_to_cpu(info->mode);
 936         dev_t rdev = le32_to_cpu(info->rdev);
 937
 938         lockdep_assert_held(&mdsc->snap_rwsem);
 939
 940         dout("%s %p ino %llx.%llx v %llu had %llu\n", __func__,
 941              inode, ceph_vinop(inode), le64_to_cpu(info->version),
 942              ci->i_version);
 943
 944         /* Once I_NEW is cleared, we can't change type or dev numbers */
 945         if (inode->i_state & I_NEW) {
 946                 inode->i_mode = mode;
 947         } else {
 948                 if (inode_wrong_type(inode, mode)) {
 949                         pr_warn_once("inode type changed! (ino %llx.%llx is 0%o, mds says 0%o)\n",
 950                                      ceph_vinop(inode), inode->i_mode, mode);
 951                         return -ESTALE;
 952                 }
 953
 954                 if ((S_ISCHR(mode) || S_ISBLK(mode)) && inode->i_rdev != rdev) {
 955                         pr_warn_once("dev inode rdev changed! (ino %llx.%llx is %u:%u, mds says %u:%u)\n",
 956                                      ceph_vinop(inode), MAJOR(inode->i_rdev),
 957                                      MINOR(inode->i_rdev), MAJOR(rdev),
 958                                      MINOR(rdev));
 959                         return -ESTALE;
 960                 }
 961         }
 962
 963         info_caps = le32_to_cpu(info->cap.caps);
 964
 965         /* prealloc new cap struct */
 966         if (info_caps && ceph_snap(inode) == CEPH_NOSNAP) {
 967                 new_cap = ceph_get_cap(mdsc, caps_reservation);
 968                 if (!new_cap)
 969                         return -ENOMEM;
 970         }
 971
 972         /*
 973          * prealloc xattr data, if it looks like we'll need it.  only
 974          * if len > 4 (meaning there are actually xattrs; the first 4
 975          * bytes are the xattr count).
 976          */
 977         if (iinfo->xattr_len > 4) {
 978                 xattr_blob = ceph_buffer_new(iinfo->xattr_len, GFP_NOFS);
 979                 if (!xattr_blob)
 980                         pr_err("%s ENOMEM xattr blob %d bytes\n", __func__,
 981                                iinfo->xattr_len);
 982         }
 983
 984         if (iinfo->pool_ns_len > 0)
 985                 pool_ns = ceph_find_or_create_string(iinfo->pool_ns_data,
 986                                                      iinfo->pool_ns_len);
 987
 988         if (ceph_snap(inode) != CEPH_NOSNAP && !ci->i_snapid_map)
 989                 ci->i_snapid_map = ceph_get_snapid_map(mdsc, ceph_snap(inode));
 990
 991         spin_lock(&ci->i_ceph_lock);
 992
 993         /*
 994          * provided version will be odd if inode value is projected,
 995          * even if stable.  skip the update if we have newer stable
 996          * info (ours>=theirs, e.g. due to racing mds replies), unless
 997          * we are getting projected (unstable) info (in which case the
 998          * version is odd, and we want ours>theirs).
 999          *   us   them
1000          *   2    2     skip
1001          *   3    2     skip
1002          *   3    3     update
1003          */
1004         if (ci->i_version == 0 ||
1005             ((info->cap.flags & CEPH_CAP_FLAG_AUTH) &&
1006              le64_to_cpu(info->version) > (ci->i_version & ~1)))
1007                 new_version = true;
1008
1009         /* Update change_attribute */
1010         inode_set_max_iversion_raw(inode, iinfo->change_attr);
1011
1012         __ceph_caps_issued(ci, &issued);
1013         issued |= __ceph_caps_dirty(ci);
1014         new_issued = ~issued & info_caps;
1015
1016         __ceph_update_quota(ci, iinfo->max_bytes, iinfo->max_files);
1017
1018 #ifdef CONFIG_FS_ENCRYPTION
1019         if (iinfo->fscrypt_auth_len &&
1020             ((inode->i_state & I_NEW) || (ci->fscrypt_auth_len == 0))) {
1021                 kfree(ci->fscrypt_auth);
1022                 ci->fscrypt_auth_len = iinfo->fscrypt_auth_len;
1023                 ci->fscrypt_auth = iinfo->fscrypt_auth;
1024                 iinfo->fscrypt_auth = NULL;
1025                 iinfo->fscrypt_auth_len = 0;
1026                 inode_set_flags(inode, S_ENCRYPTED, S_ENCRYPTED);
1027         }
1028 #endif
1029
1030         if ((new_version || (new_issued & CEPH_CAP_AUTH_SHARED)) &&
1031             (issued & CEPH_CAP_AUTH_EXCL) == 0) {
1032                 inode->i_mode = mode;
1033                 inode->i_uid = make_kuid(&init_user_ns, le32_to_cpu(info->uid));
1034                 inode->i_gid = make_kgid(&init_user_ns, le32_to_cpu(info->gid));
1035                 dout("%p mode 0%o uid.gid %d.%d\n", inode, inode->i_mode,
1036                      from_kuid(&init_user_ns, inode->i_uid),
1037                      from_kgid(&init_user_ns, inode->i_gid));
1038                 ceph_decode_timespec64(&ci->i_btime, &iinfo->btime);
1039                 ceph_decode_timespec64(&ci->i_snap_btime, &iinfo->snap_btime);
1040         }
1041
1042         /* directories have fl_stripe_unit set to zero */
1043         if (IS_ENCRYPTED(inode))
1044                 inode->i_blkbits = CEPH_FSCRYPT_BLOCK_SHIFT;
1045         else if (le32_to_cpu(info->layout.fl_stripe_unit))
1046                 inode->i_blkbits =
1047                         fls(le32_to_cpu(info->layout.fl_stripe_unit)) - 1;
1048         else
1049                 inode->i_blkbits = CEPH_BLOCK_SHIFT;
1050
1051         if ((new_version || (new_issued & CEPH_CAP_LINK_SHARED)) &&
1052             (issued & CEPH_CAP_LINK_EXCL) == 0)
1053                 set_nlink(inode, le32_to_cpu(info->nlink));
1054
1055         if (new_version || (new_issued & CEPH_CAP_ANY_RD)) {
1056                 /* be careful with mtime, atime, size */
1057                 ceph_decode_timespec64(&atime, &info->atime);
1058                 ceph_decode_timespec64(&mtime, &info->mtime);
1059                 ceph_decode_timespec64(&ctime, &info->ctime);
1060                 ceph_fill_file_time(inode, issued,
1061                                 le32_to_cpu(info->time_warp_seq),
1062                                 &ctime, &mtime, &atime);
1063         }
1064
1065         if (new_version || (info_caps & CEPH_CAP_FILE_SHARED)) {
1066                 ci->i_files = le64_to_cpu(info->files);
1067                 ci->i_subdirs = le64_to_cpu(info->subdirs);
1068         }
1069
1070         if (new_version ||
1071             (new_issued & (CEPH_CAP_ANY_FILE_RD | CEPH_CAP_ANY_FILE_WR))) {
1072                 u64 size = le64_to_cpu(info->size);
1073                 s64 old_pool = ci->i_layout.pool_id;
1074                 struct ceph_string *old_ns;
1075
1076                 ceph_file_layout_from_legacy(&ci->i_layout, &info->layout);
1077                 old_ns = rcu_dereference_protected(ci->i_layout.pool_ns,
1078                                         lockdep_is_held(&ci->i_ceph_lock));
1079                 rcu_assign_pointer(ci->i_layout.pool_ns, pool_ns);
1080
1081                 if (ci->i_layout.pool_id != old_pool || pool_ns != old_ns)
1082                         ci->i_ceph_flags &= ~CEPH_I_POOL_PERM;
1083
1084                 pool_ns = old_ns;
1085
1086                 if (IS_ENCRYPTED(inode) && size &&
1087                     iinfo->fscrypt_file_len == sizeof(__le64)) {
1088                         u64 fsize = __le64_to_cpu(*(__le64 *)iinfo->fscrypt_file);
1089
1090                         if (size == round_up(fsize, CEPH_FSCRYPT_BLOCK_SIZE)) {
1091                                 size = fsize;
1092                         } else {
1093                                 pr_warn("fscrypt size mismatch: size=%llu fscrypt_file=%llu, discarding fscrypt_file size.\n",
1094                                         info->size, size);
1095                         }
1096                 }
1097
1098                 queue_trunc = ceph_fill_file_size(inode, issued,
1099                                         le32_to_cpu(info->truncate_seq),
1100                                         le64_to_cpu(info->truncate_size),
1101                                         size);
1102                 /* only update max_size on auth cap */
1103                 if ((info->cap.flags & CEPH_CAP_FLAG_AUTH) &&
1104                     ci->i_max_size != le64_to_cpu(info->max_size)) {
1105                         dout("max_size %lld -> %llu\n", ci->i_max_size,
1106                                         le64_to_cpu(info->max_size));
1107                         ci->i_max_size = le64_to_cpu(info->max_size);
1108                 }
1109         }
1110
1111         /* layout and rstat are not tracked by capability, update them if
1112          * the inode info is from auth mds */
1113         if (new_version || (info->cap.flags & CEPH_CAP_FLAG_AUTH)) {
1114                 if (S_ISDIR(inode->i_mode)) {
1115                         ci->i_dir_layout = iinfo->dir_layout;
1116                         ci->i_rbytes = le64_to_cpu(info->rbytes);
1117                         ci->i_rfiles = le64_to_cpu(info->rfiles);
1118                         ci->i_rsubdirs = le64_to_cpu(info->rsubdirs);
1119                         ci->i_dir_pin = iinfo->dir_pin;
1120                         ci->i_rsnaps = iinfo->rsnaps;
1121                         ceph_decode_timespec64(&ci->i_rctime, &info->rctime);
1122                 }
1123         }
1124
1125         /* xattrs */
1126         /* note that if i_xattrs.len <= 4, i_xattrs.data will still be NULL. */
1127         if ((ci->i_xattrs.version == 0 || !(issued & CEPH_CAP_XATTR_EXCL))  &&
1128             le64_to_cpu(info->xattr_version) > ci->i_xattrs.version) {
1129                 if (ci->i_xattrs.blob)
1130                         old_blob = ci->i_xattrs.blob;
1131                 ci->i_xattrs.blob = xattr_blob;
1132                 if (xattr_blob)
1133                         memcpy(ci->i_xattrs.blob->vec.iov_base,
1134                                iinfo->xattr_data, iinfo->xattr_len);
1135                 ci->i_xattrs.version = le64_to_cpu(info->xattr_version);
1136                 ceph_forget_all_cached_acls(inode);
1137                 ceph_security_invalidate_secctx(inode);
1138                 xattr_blob = NULL;
1139         }
1140
1141         /* finally update i_version */
1142         if (le64_to_cpu(info->version) > ci->i_version)
1143                 ci->i_version = le64_to_cpu(info->version);
1144
1145         inode->i_mapping->a_ops = &ceph_aops;
1146
1147         switch (inode->i_mode & S_IFMT) {
1148         case S_IFIFO:
1149         case S_IFBLK:
1150         case S_IFCHR:
1151         case S_IFSOCK:
1152                 inode->i_blkbits = PAGE_SHIFT;
1153                 init_special_inode(inode, inode->i_mode, rdev);
1154                 inode->i_op = &ceph_file_iops;
1155                 break;
1156         case S_IFREG:
1157                 inode->i_op = &ceph_file_iops;
1158                 inode->i_fop = &ceph_file_fops;
1159                 break;
1160         case S_IFLNK:
1161                 if (!ci->i_symlink) {
1162                         u32 symlen = iinfo->symlink_len;
1163                         char *sym;
1164
1165                         spin_unlock(&ci->i_ceph_lock);
1166
1167                         if (IS_ENCRYPTED(inode)) {
1168                                 if (symlen != i_size_read(inode))
1169                                         pr_err("%s %llx.%llx BAD symlink size %lld\n",
1170                                                 __func__, ceph_vinop(inode),
1171                                                 i_size_read(inode));
1172
1173                                 err = decode_encrypted_symlink(iinfo->symlink,
1174                                                                symlen, (u8 **)&sym);
1175                                 if (err < 0) {
1176                                         pr_err("%s decoding encrypted symlink failed: %d\n",
1177                                                 __func__, err);
1178                                         goto out;
1179                                 }
1180                                 symlen = err;
1181                                 i_size_write(inode, symlen);
1182                                 inode->i_blocks = calc_inode_blocks(symlen);
1183                         } else {
1184                                 if (symlen != i_size_read(inode)) {
1185                                         pr_err("%s %llx.%llx BAD symlink size %lld\n",
1186                                                 __func__, ceph_vinop(inode),
1187                                                 i_size_read(inode));
1188                                         i_size_write(inode, symlen);
1189                                         inode->i_blocks = calc_inode_blocks(symlen);
1190                                 }
1191
1192                                 err = -ENOMEM;
1193                                 sym = kstrndup(iinfo->symlink, symlen, GFP_NOFS);
1194                                 if (!sym)
1195                                         goto out;
1196                         }
1197
1198                         spin_lock(&ci->i_ceph_lock);
1199                         if (!ci->i_symlink)
1200                                 ci->i_symlink = sym;
1201                         else
1202                                 kfree(sym); /* lost a race */
1203                 }
1204
1205                 if (IS_ENCRYPTED(inode)) {
1206                         /*
1207                          * Encrypted symlinks need to be decrypted before we can
1208                          * cache their targets in i_link. Don't touch it here.
1209                          */
1210                         inode->i_op = &ceph_encrypted_symlink_iops;
1211                 } else {
1212                         inode->i_link = ci->i_symlink;
1213                         inode->i_op = &ceph_symlink_iops;
1214                 }
1215                 break;
1216         case S_IFDIR:
1217                 inode->i_op = &ceph_dir_iops;
1218                 inode->i_fop = &ceph_dir_fops;
1219                 break;
1220         default:
1221                 pr_err("%s %llx.%llx BAD mode 0%o\n", __func__,
1222                        ceph_vinop(inode), inode->i_mode);
1223         }
1224
1225         /* were we issued a capability? */
1226         if (info_caps) {
1227                 if (ceph_snap(inode) == CEPH_NOSNAP) {
1228                         ceph_add_cap(inode, session,
1229                                      le64_to_cpu(info->cap.cap_id),
1230                                      info_caps,
1231                                      le32_to_cpu(info->cap.wanted),
1232                                      le32_to_cpu(info->cap.seq),
1233                                      le32_to_cpu(info->cap.mseq),
1234                                      le64_to_cpu(info->cap.realm),
1235                                      info->cap.flags, &new_cap);
1236
1237                         /* set dir completion flag? */
1238                         if (S_ISDIR(inode->i_mode) &&
1239                             ci->i_files == 0 && ci->i_subdirs == 0 &&
1240                             (info_caps & CEPH_CAP_FILE_SHARED) &&
1241                             (issued & CEPH_CAP_FILE_EXCL) == 0 &&
1242                             !__ceph_dir_is_complete(ci)) {
1243                                 dout(" marking %p complete (empty)\n", inode);
1244                                 i_size_write(inode, 0);
1245                                 __ceph_dir_set_complete(ci,
1246                                         atomic64_read(&ci->i_release_count),
1247                                         atomic64_read(&ci->i_ordered_count));
1248                         }
1249
1250                         wake = true;
1251                 } else {
1252                         dout(" %p got snap_caps %s\n", inode,
1253                              ceph_cap_string(info_caps));
1254                         ci->i_snap_caps |= info_caps;
1255                 }
1256         }
1257
1258         if (iinfo->inline_version > 0 &&
1259             iinfo->inline_version >= ci->i_inline_version) {
1260                 int cache_caps = CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_LAZYIO;
1261                 ci->i_inline_version = iinfo->inline_version;
1262                 if (ceph_has_inline_data(ci) &&
1263                     (locked_page || (info_caps & cache_caps)))
1264                         fill_inline = true;
1265         }
1266
1267         if (cap_fmode >= 0) {
1268                 if (!info_caps)
1269                         pr_warn("mds issued no caps on %llx.%llx\n",
1270                                 ceph_vinop(inode));
1271                 __ceph_touch_fmode(ci, mdsc, cap_fmode);
1272         }
1273
1274         spin_unlock(&ci->i_ceph_lock);
1275
1276         ceph_fscache_register_inode_cookie(inode);
1277
1278         if (fill_inline)
1279                 ceph_fill_inline_data(inode, locked_page,
1280                                       iinfo->inline_data, iinfo->inline_len);
1281
1282         if (wake)
1283                 wake_up_all(&ci->i_cap_wq);
1284
1285         /* queue truncate if we saw i_size decrease */
1286         if (queue_trunc)
1287                 ceph_queue_vmtruncate(inode);
1288
1289         /* populate frag tree */
1290         if (S_ISDIR(inode->i_mode))
1291                 ceph_fill_fragtree(inode, &info->fragtree, dirinfo);
1292
1293         /* update delegation info? */
1294         if (dirinfo)
1295                 ceph_fill_dirfrag(inode, dirinfo);
1296
1297         err = 0;
1298 out:
1299         if (new_cap)
1300                 ceph_put_cap(mdsc, new_cap);
1301         ceph_buffer_put(old_blob);
1302         ceph_buffer_put(xattr_blob);
1303         ceph_put_string(pool_ns);
1304         return err;
1305 }
1306
1307 /*
1308  * caller should hold session s_mutex and dentry->d_lock.
1309  */
1310 static void __update_dentry_lease(struct inode *dir, struct dentry *dentry,
1311                                   struct ceph_mds_reply_lease *lease,
1312                                   struct ceph_mds_session *session,
1313                                   unsigned long from_time,
1314                                   struct ceph_mds_session **old_lease_session)
1315 {
1316         struct ceph_dentry_info *di = ceph_dentry(dentry);
1317         unsigned mask = le16_to_cpu(lease->mask);
1318         long unsigned duration = le32_to_cpu(lease->duration_ms);
1319         long unsigned ttl = from_time + (duration * HZ) / 1000;
1320         long unsigned half_ttl = from_time + (duration * HZ / 2) / 1000;
1321
1322         dout("update_dentry_lease %p duration %lu ms ttl %lu\n",
1323              dentry, duration, ttl);
1324
1325         /* only track leases on regular dentries */
1326         if (ceph_snap(dir) != CEPH_NOSNAP)
1327                 return;
1328
1329         if (mask & CEPH_LEASE_PRIMARY_LINK)
1330                 di->flags |= CEPH_DENTRY_PRIMARY_LINK;
1331         else
1332                 di->flags &= ~CEPH_DENTRY_PRIMARY_LINK;
1333
1334         di->lease_shared_gen = atomic_read(&ceph_inode(dir)->i_shared_gen);
1335         if (!(mask & CEPH_LEASE_VALID)) {
1336                 __ceph_dentry_dir_lease_touch(di);
1337                 return;
1338         }
1339
1340         if (di->lease_gen == atomic_read(&session->s_cap_gen) &&
1341             time_before(ttl, di->time))
1342                 return;  /* we already have a newer lease. */
1343
1344         if (di->lease_session && di->lease_session != session) {
1345                 *old_lease_session = di->lease_session;
1346                 di->lease_session = NULL;
1347         }
1348
1349         if (!di->lease_session)
1350                 di->lease_session = ceph_get_mds_session(session);
1351         di->lease_gen = atomic_read(&session->s_cap_gen);
1352         di->lease_seq = le32_to_cpu(lease->seq);
1353         di->lease_renew_after = half_ttl;
1354         di->lease_renew_from = 0;
1355         di->time = ttl;
1356
1357         __ceph_dentry_lease_touch(di);
1358 }
1359
1360 static inline void update_dentry_lease(struct inode *dir, struct dentry *dentry,
1361                                         struct ceph_mds_reply_lease *lease,
1362                                         struct ceph_mds_session *session,
1363                                         unsigned long from_time)
1364 {
1365         struct ceph_mds_session *old_lease_session = NULL;
1366         spin_lock(&dentry->d_lock);
1367         __update_dentry_lease(dir, dentry, lease, session, from_time,
1368                               &old_lease_session);
1369         spin_unlock(&dentry->d_lock);
1370         ceph_put_mds_session(old_lease_session);
1371 }
1372
1373 /*
1374  * update dentry lease without having parent inode locked
1375  */
1376 static void update_dentry_lease_careful(struct dentry *dentry,
1377                                         struct ceph_mds_reply_lease *lease,
1378                                         struct ceph_mds_session *session,
1379                                         unsigned long from_time,
1380                                         char *dname, u32 dname_len,
1381                                         struct ceph_vino *pdvino,
1382                                         struct ceph_vino *ptvino)
1383
1384 {
1385         struct inode *dir;
1386         struct ceph_mds_session *old_lease_session = NULL;
1387
1388         spin_lock(&dentry->d_lock);
1389         /* make sure dentry's name matches target */
1390         if (dentry->d_name.len != dname_len ||
1391             memcmp(dentry->d_name.name, dname, dname_len))
1392                 goto out_unlock;
1393
1394         dir = d_inode(dentry->d_parent);
1395         /* make sure parent matches dvino */
1396         if (!ceph_ino_compare(dir, pdvino))
1397                 goto out_unlock;
1398
1399         /* make sure dentry's inode matches target. NULL ptvino means that
1400          * we expect a negative dentry */
1401         if (ptvino) {
1402                 if (d_really_is_negative(dentry))
1403                         goto out_unlock;
1404                 if (!ceph_ino_compare(d_inode(dentry), ptvino))
1405                         goto out_unlock;
1406         } else {
1407                 if (d_really_is_positive(dentry))
1408                         goto out_unlock;
1409         }
1410
1411         __update_dentry_lease(dir, dentry, lease, session,
1412                               from_time, &old_lease_session);
1413 out_unlock:
1414         spin_unlock(&dentry->d_lock);
1415         ceph_put_mds_session(old_lease_session);
1416 }
1417
1418 /*
1419  * splice a dentry to an inode.
1420  * caller must hold directory i_rwsem for this to be safe.
1421  */
1422 static int splice_dentry(struct dentry **pdn, struct inode *in)
1423 {
1424         struct dentry *dn = *pdn;
1425         struct dentry *realdn;
1426
1427         BUG_ON(d_inode(dn));
1428
1429         if (S_ISDIR(in->i_mode)) {
1430                 /* If inode is directory, d_splice_alias() below will remove
1431                  * 'realdn' from its origin parent. We need to ensure that
1432                  * origin parent's readdir cache will not reference 'realdn'
1433                  */
1434                 realdn = d_find_any_alias(in);
1435                 if (realdn) {
1436                         struct ceph_dentry_info *di = ceph_dentry(realdn);
1437                         spin_lock(&realdn->d_lock);
1438
1439                         realdn->d_op->d_prune(realdn);
1440
1441                         di->time = jiffies;
1442                         di->lease_shared_gen = 0;
1443                         di->offset = 0;
1444
1445                         spin_unlock(&realdn->d_lock);
1446                         dput(realdn);
1447                 }
1448         }
1449
1450         /* dn must be unhashed */
1451         if (!d_unhashed(dn))
1452                 d_drop(dn);
1453         realdn = d_splice_alias(in, dn);
1454         if (IS_ERR(realdn)) {
1455                 pr_err("splice_dentry error %ld %p inode %p ino %llx.%llx\n",
1456                        PTR_ERR(realdn), dn, in, ceph_vinop(in));
1457                 return PTR_ERR(realdn);
1458         }
1459
1460         if (realdn) {
1461                 dout("dn %p (%d) spliced with %p (%d) "
1462                      "inode %p ino %llx.%llx\n",
1463                      dn, d_count(dn),
1464                      realdn, d_count(realdn),
1465                      d_inode(realdn), ceph_vinop(d_inode(realdn)));
1466                 dput(dn);
1467                 *pdn = realdn;
1468         } else {
1469                 BUG_ON(!ceph_dentry(dn));
1470                 dout("dn %p attached to %p ino %llx.%llx\n",
1471                      dn, d_inode(dn), ceph_vinop(d_inode(dn)));
1472         }
1473         return 0;
1474 }
1475
1476 /*
1477  * Incorporate results into the local cache.  This is either just
1478  * one inode, or a directory, dentry, and possibly linked-to inode (e.g.,
1479  * after a lookup).
1480  *
1481  * A reply may contain
1482  *         a directory inode along with a dentry.
1483  *  and/or a target inode
1484  *
1485  * Called with snap_rwsem (read).
1486  */
1487 int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req)
1488 {
1489         struct ceph_mds_session *session = req->r_session;
1490         struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
1491         struct inode *in = NULL;
1492         struct ceph_vino tvino, dvino;
1493         struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
1494         int err = 0;
1495
1496         dout("fill_trace %p is_dentry %d is_target %d\n", req,
1497              rinfo->head->is_dentry, rinfo->head->is_target);
1498
1499         if (!rinfo->head->is_target && !rinfo->head->is_dentry) {
1500                 dout("fill_trace reply is empty!\n");
1501                 if (rinfo->head->result == 0 && req->r_parent)
1502                         ceph_invalidate_dir_request(req);
1503                 return 0;
1504         }
1505
1506         if (rinfo->head->is_dentry) {
1507                 struct inode *dir = req->r_parent;
1508
1509                 if (dir) {
1510                         err = ceph_fill_inode(dir, NULL, &rinfo->diri,
1511                                               rinfo->dirfrag, session, -1,
1512                                               &req->r_caps_reservation);
1513                         if (err < 0)
1514                                 goto done;
1515                 } else {
1516                         WARN_ON_ONCE(1);
1517                 }
1518
1519                 if (dir && req->r_op == CEPH_MDS_OP_LOOKUPNAME &&
1520                     test_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags) &&
1521                     !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) {
1522                         bool is_nokey = false;
1523                         struct qstr dname;
1524                         struct dentry *dn, *parent;
1525                         struct fscrypt_str oname = FSTR_INIT(NULL, 0);
1526                         struct ceph_fname fname = { .dir        = dir,
1527                                                     .name       = rinfo->dname,
1528                                                     .ctext      = rinfo->altname,
1529                                                     .name_len   = rinfo->dname_len,
1530                                                     .ctext_len  = rinfo->altname_len };
1531
1532                         BUG_ON(!rinfo->head->is_target);
1533                         BUG_ON(req->r_dentry);
1534
1535                         parent = d_find_any_alias(dir);
1536                         BUG_ON(!parent);
1537
1538                         err = ceph_fname_alloc_buffer(dir, &oname);
1539                         if (err < 0) {
1540                                 dput(parent);
1541                                 goto done;
1542                         }
1543
1544                         err = ceph_fname_to_usr(&fname, NULL, &oname, &is_nokey);
1545                         if (err < 0) {
1546                                 dput(parent);
1547                                 ceph_fname_free_buffer(dir, &oname);
1548                                 goto done;
1549                         }
1550                         dname.name = oname.name;
1551                         dname.len = oname.len;
1552                         dname.hash = full_name_hash(parent, dname.name, dname.len);
1553                         tvino.ino = le64_to_cpu(rinfo->targeti.in->ino);
1554                         tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
1555 retry_lookup:
1556                         dn = d_lookup(parent, &dname);
1557                         dout("d_lookup on parent=%p name=%.*s got %p\n",
1558                              parent, dname.len, dname.name, dn);
1559
1560                         if (!dn) {
1561                                 dn = d_alloc(parent, &dname);
1562                                 dout("d_alloc %p '%.*s' = %p\n", parent,
1563                                      dname.len, dname.name, dn);
1564                                 if (!dn) {
1565                                         dput(parent);
1566                                         ceph_fname_free_buffer(dir, &oname);
1567                                         err = -ENOMEM;
1568                                         goto done;
1569                                 }
1570                                 if (is_nokey) {
1571                                         spin_lock(&dn->d_lock);
1572                                         dn->d_flags |= DCACHE_NOKEY_NAME;
1573                                         spin_unlock(&dn->d_lock);
1574                                 }
1575                                 err = 0;
1576                         } else if (d_really_is_positive(dn) &&
1577                                    (ceph_ino(d_inode(dn)) != tvino.ino ||
1578                                     ceph_snap(d_inode(dn)) != tvino.snap)) {
1579                                 dout(" dn %p points to wrong inode %p\n",
1580                                      dn, d_inode(dn));
1581                                 ceph_dir_clear_ordered(dir);
1582                                 d_delete(dn);
1583                                 dput(dn);
1584                                 goto retry_lookup;
1585                         }
1586                         ceph_fname_free_buffer(dir, &oname);
1587
1588                         req->r_dentry = dn;
1589                         dput(parent);
1590                 }
1591         }
1592
1593         if (rinfo->head->is_target) {
1594                 /* Should be filled in by handle_reply */
1595                 BUG_ON(!req->r_target_inode);
1596
1597                 in = req->r_target_inode;
1598                 err = ceph_fill_inode(in, req->r_locked_page, &rinfo->targeti,
1599                                 NULL, session,
1600                                 (!test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) &&
1601                                  !test_bit(CEPH_MDS_R_ASYNC, &req->r_req_flags) &&
1602                                  rinfo->head->result == 0) ?  req->r_fmode : -1,
1603                                 &req->r_caps_reservation);
1604                 if (err < 0) {
1605                         pr_err("ceph_fill_inode badness %p %llx.%llx\n",
1606                                 in, ceph_vinop(in));
1607                         req->r_target_inode = NULL;
1608                         if (in->i_state & I_NEW)
1609                                 discard_new_inode(in);
1610                         else
1611                                 iput(in);
1612                         goto done;
1613                 }
1614                 if (in->i_state & I_NEW)
1615                         unlock_new_inode(in);
1616         }
1617
1618         /*
1619          * ignore null lease/binding on snapdir ENOENT, or else we
1620          * will have trouble splicing in the virtual snapdir later
1621          */
1622         if (rinfo->head->is_dentry &&
1623             !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) &&
1624             test_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags) &&
1625             (rinfo->head->is_target || strncmp(req->r_dentry->d_name.name,
1626                                                fsc->mount_options->snapdir_name,
1627                                                req->r_dentry->d_name.len))) {
1628                 /*
1629                  * lookup link rename   : null -> possibly existing inode
1630                  * mknod symlink mkdir  : null -> new inode
1631                  * unlink               : linked -> null
1632                  */
1633                 struct inode *dir = req->r_parent;
1634                 struct dentry *dn = req->r_dentry;
1635                 bool have_dir_cap, have_lease;
1636
1637                 BUG_ON(!dn);
1638                 BUG_ON(!dir);
1639                 BUG_ON(d_inode(dn->d_parent) != dir);
1640
1641                 dvino.ino = le64_to_cpu(rinfo->diri.in->ino);
1642                 dvino.snap = le64_to_cpu(rinfo->diri.in->snapid);
1643
1644                 BUG_ON(ceph_ino(dir) != dvino.ino);
1645                 BUG_ON(ceph_snap(dir) != dvino.snap);
1646
1647                 /* do we have a lease on the whole dir? */
1648                 have_dir_cap =
1649                         (le32_to_cpu(rinfo->diri.in->cap.caps) &
1650                          CEPH_CAP_FILE_SHARED);
1651
1652                 /* do we have a dn lease? */
1653                 have_lease = have_dir_cap ||
1654                         le32_to_cpu(rinfo->dlease->duration_ms);
1655                 if (!have_lease)
1656                         dout("fill_trace  no dentry lease or dir cap\n");
1657
1658                 /* rename? */
1659                 if (req->r_old_dentry && req->r_op == CEPH_MDS_OP_RENAME) {
1660                         struct inode *olddir = req->r_old_dentry_dir;
1661                         BUG_ON(!olddir);
1662
1663                         dout(" src %p '%pd' dst %p '%pd'\n",
1664                              req->r_old_dentry,
1665                              req->r_old_dentry,
1666                              dn, dn);
1667                         dout("fill_trace doing d_move %p -> %p\n",
1668                              req->r_old_dentry, dn);
1669
1670                         /* d_move screws up sibling dentries' offsets */
1671                         ceph_dir_clear_ordered(dir);
1672                         ceph_dir_clear_ordered(olddir);
1673
1674                         d_move(req->r_old_dentry, dn);
1675                         dout(" src %p '%pd' dst %p '%pd'\n",
1676                              req->r_old_dentry,
1677                              req->r_old_dentry,
1678                              dn, dn);
1679
1680                         /* ensure target dentry is invalidated, despite
1681                            rehashing bug in vfs_rename_dir */
1682                         ceph_invalidate_dentry_lease(dn);
1683
1684                         dout("dn %p gets new offset %lld\n", req->r_old_dentry,
1685                              ceph_dentry(req->r_old_dentry)->offset);
1686
1687                         /* swap r_dentry and r_old_dentry in case that
1688                          * splice_dentry() gets called later. This is safe
1689                          * because no other place will use them */
1690                         req->r_dentry = req->r_old_dentry;
1691                         req->r_old_dentry = dn;
1692                         dn = req->r_dentry;
1693                 }
1694
1695                 /* null dentry? */
1696                 if (!rinfo->head->is_target) {
1697                         dout("fill_trace null dentry\n");
1698                         if (d_really_is_positive(dn)) {
1699                                 dout("d_delete %p\n", dn);
1700                                 ceph_dir_clear_ordered(dir);
1701                                 d_delete(dn);
1702                         } else if (have_lease) {
1703                                 if (d_unhashed(dn))
1704                                         d_add(dn, NULL);
1705                         }
1706
1707                         if (!d_unhashed(dn) && have_lease)
1708                                 update_dentry_lease(dir, dn,
1709                                                     rinfo->dlease, session,
1710                                                     req->r_request_started);
1711                         goto done;
1712                 }
1713
1714                 /* attach proper inode */
1715                 if (d_really_is_negative(dn)) {
1716                         ceph_dir_clear_ordered(dir);
1717                         ihold(in);
1718                         err = splice_dentry(&req->r_dentry, in);
1719                         if (err < 0)
1720                                 goto done;
1721                         dn = req->r_dentry;  /* may have spliced */
1722                 } else if (d_really_is_positive(dn) && d_inode(dn) != in) {
1723                         dout(" %p links to %p %llx.%llx, not %llx.%llx\n",
1724                              dn, d_inode(dn), ceph_vinop(d_inode(dn)),
1725                              ceph_vinop(in));
1726                         d_invalidate(dn);
1727                         have_lease = false;
1728                 }
1729
1730                 if (have_lease) {
1731                         update_dentry_lease(dir, dn,
1732                                             rinfo->dlease, session,
1733                                             req->r_request_started);
1734                 }
1735                 dout(" final dn %p\n", dn);
1736         } else if ((req->r_op == CEPH_MDS_OP_LOOKUPSNAP ||
1737                     req->r_op == CEPH_MDS_OP_MKSNAP) &&
1738                    test_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags) &&
1739                    !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) {
1740                 struct inode *dir = req->r_parent;
1741
1742                 /* fill out a snapdir LOOKUPSNAP dentry */
1743                 BUG_ON(!dir);
1744                 BUG_ON(ceph_snap(dir) != CEPH_SNAPDIR);
1745                 BUG_ON(!req->r_dentry);
1746                 dout(" linking snapped dir %p to dn %p\n", in, req->r_dentry);
1747                 ceph_dir_clear_ordered(dir);
1748                 ihold(in);
1749                 err = splice_dentry(&req->r_dentry, in);
1750                 if (err < 0)
1751                         goto done;
1752         } else if (rinfo->head->is_dentry && req->r_dentry) {
1753                 /* parent inode is not locked, be carefull */
1754                 struct ceph_vino *ptvino = NULL;
1755                 dvino.ino = le64_to_cpu(rinfo->diri.in->ino);
1756                 dvino.snap = le64_to_cpu(rinfo->diri.in->snapid);
1757                 if (rinfo->head->is_target) {
1758                         tvino.ino = le64_to_cpu(rinfo->targeti.in->ino);
1759                         tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
1760                         ptvino = &tvino;
1761                 }
1762                 update_dentry_lease_careful(req->r_dentry, rinfo->dlease,
1763                                             session, req->r_request_started,
1764                                             rinfo->dname, rinfo->dname_len,
1765                                             &dvino, ptvino);
1766         }
1767 done:
1768         dout("fill_trace done err=%d\n", err);
1769         return err;
1770 }
1771
1772 /*
1773  * Prepopulate our cache with readdir results, leases, etc.
1774  */
1775 static int readdir_prepopulate_inodes_only(struct ceph_mds_request *req,
1776                                            struct ceph_mds_session *session)
1777 {
1778         struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
1779         int i, err = 0;
1780
1781         for (i = 0; i < rinfo->dir_nr; i++) {
1782                 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i;
1783                 struct ceph_vino vino;
1784                 struct inode *in;
1785                 int rc;
1786
1787                 vino.ino = le64_to_cpu(rde->inode.in->ino);
1788                 vino.snap = le64_to_cpu(rde->inode.in->snapid);
1789
1790                 in = ceph_get_inode(req->r_dentry->d_sb, vino, NULL);
1791                 if (IS_ERR(in)) {
1792                         err = PTR_ERR(in);
1793                         dout("new_inode badness got %d\n", err);
1794                         continue;
1795                 }
1796                 rc = ceph_fill_inode(in, NULL, &rde->inode, NULL, session,
1797                                      -1, &req->r_caps_reservation);
1798                 if (rc < 0) {
1799                         pr_err("ceph_fill_inode badness on %p got %d\n",
1800                                in, rc);
1801                         err = rc;
1802                         if (in->i_state & I_NEW) {
1803                                 ihold(in);
1804                                 discard_new_inode(in);
1805                         }
1806                 } else if (in->i_state & I_NEW) {
1807                         unlock_new_inode(in);
1808                 }
1809
1810                 iput(in);
1811         }
1812
1813         return err;
1814 }
1815
1816 void ceph_readdir_cache_release(struct ceph_readdir_cache_control *ctl)
1817 {
1818         if (ctl->page) {
1819                 kunmap(ctl->page);
1820                 put_page(ctl->page);
1821                 ctl->page = NULL;
1822         }
1823 }
1824
1825 static int fill_readdir_cache(struct inode *dir, struct dentry *dn,
1826                               struct ceph_readdir_cache_control *ctl,
1827                               struct ceph_mds_request *req)
1828 {
1829         struct ceph_inode_info *ci = ceph_inode(dir);
1830         unsigned nsize = PAGE_SIZE / sizeof(struct dentry*);
1831         unsigned idx = ctl->index % nsize;
1832         pgoff_t pgoff = ctl->index / nsize;
1833
1834         if (!ctl->page || pgoff != page_index(ctl->page)) {
1835                 ceph_readdir_cache_release(ctl);
1836                 if (idx == 0)
1837                         ctl->page = grab_cache_page(&dir->i_data, pgoff);
1838                 else
1839                         ctl->page = find_lock_page(&dir->i_data, pgoff);
1840                 if (!ctl->page) {
1841                         ctl->index = -1;
1842                         return idx == 0 ? -ENOMEM : 0;
1843                 }
1844                 /* reading/filling the cache are serialized by
1845                  * i_rwsem, no need to use page lock */
1846                 unlock_page(ctl->page);
1847                 ctl->dentries = kmap(ctl->page);
1848                 if (idx == 0)
1849                         memset(ctl->dentries, 0, PAGE_SIZE);
1850         }
1851
1852         if (req->r_dir_release_cnt == atomic64_read(&ci->i_release_count) &&
1853             req->r_dir_ordered_cnt == atomic64_read(&ci->i_ordered_count)) {
1854                 dout("readdir cache dn %p idx %d\n", dn, ctl->index);
1855                 ctl->dentries[idx] = dn;
1856                 ctl->index++;
1857         } else {
1858                 dout("disable readdir cache\n");
1859                 ctl->index = -1;
1860         }
1861         return 0;
1862 }
1863
1864 int ceph_readdir_prepopulate(struct ceph_mds_request *req,
1865                              struct ceph_mds_session *session)
1866 {
1867         struct dentry *parent = req->r_dentry;
1868         struct inode *inode = d_inode(parent);
1869         struct ceph_inode_info *ci = ceph_inode(inode);
1870         struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
1871         struct qstr dname;
1872         struct dentry *dn;
1873         struct inode *in;
1874         int err = 0, skipped = 0, ret, i;
1875         u32 frag = le32_to_cpu(req->r_args.readdir.frag);
1876         u32 last_hash = 0;
1877         u32 fpos_offset;
1878         struct ceph_readdir_cache_control cache_ctl = {};
1879
1880         if (test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags))
1881                 return readdir_prepopulate_inodes_only(req, session);
1882
1883         if (rinfo->hash_order) {
1884                 if (req->r_path2) {
1885                         last_hash = ceph_str_hash(ci->i_dir_layout.dl_dir_hash,
1886                                                   req->r_path2,
1887                                                   strlen(req->r_path2));
1888                         last_hash = ceph_frag_value(last_hash);
1889                 } else if (rinfo->offset_hash) {
1890                         /* mds understands offset_hash */
1891                         WARN_ON_ONCE(req->r_readdir_offset != 2);
1892                         last_hash = le32_to_cpu(req->r_args.readdir.offset_hash);
1893                 }
1894         }
1895
1896         if (rinfo->dir_dir &&
1897             le32_to_cpu(rinfo->dir_dir->frag) != frag) {
1898                 dout("readdir_prepopulate got new frag %x -> %x\n",
1899                      frag, le32_to_cpu(rinfo->dir_dir->frag));
1900                 frag = le32_to_cpu(rinfo->dir_dir->frag);
1901                 if (!rinfo->hash_order)
1902                         req->r_readdir_offset = 2;
1903         }
1904
1905         if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) {
1906                 dout("readdir_prepopulate %d items under SNAPDIR dn %p\n",
1907                      rinfo->dir_nr, parent);
1908         } else {
1909                 dout("readdir_prepopulate %d items under dn %p\n",
1910                      rinfo->dir_nr, parent);
1911                 if (rinfo->dir_dir)
1912                         ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir);
1913
1914                 if (ceph_frag_is_leftmost(frag) &&
1915                     req->r_readdir_offset == 2 &&
1916                     !(rinfo->hash_order && last_hash)) {
1917                         /* note dir version at start of readdir so we can
1918                          * tell if any dentries get dropped */
1919                         req->r_dir_release_cnt =
1920                                 atomic64_read(&ci->i_release_count);
1921                         req->r_dir_ordered_cnt =
1922                                 atomic64_read(&ci->i_ordered_count);
1923                         req->r_readdir_cache_idx = 0;
1924                 }
1925         }
1926
1927         cache_ctl.index = req->r_readdir_cache_idx;
1928         fpos_offset = req->r_readdir_offset;
1929
1930         /* FIXME: release caps/leases if error occurs */
1931         for (i = 0; i < rinfo->dir_nr; i++) {
1932                 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i;
1933                 struct ceph_vino tvino;
1934
1935                 dname.name = rde->name;
1936                 dname.len = rde->name_len;
1937                 dname.hash = full_name_hash(parent, dname.name, dname.len);
1938
1939                 tvino.ino = le64_to_cpu(rde->inode.in->ino);
1940                 tvino.snap = le64_to_cpu(rde->inode.in->snapid);
1941
1942                 if (rinfo->hash_order) {
1943                         u32 hash = ceph_frag_value(rde->raw_hash);
1944                         if (hash != last_hash)
1945                                 fpos_offset = 2;
1946                         last_hash = hash;
1947                         rde->offset = ceph_make_fpos(hash, fpos_offset++, true);
1948                 } else {
1949                         rde->offset = ceph_make_fpos(frag, fpos_offset++, false);
1950                 }
1951
1952 retry_lookup:
1953                 dn = d_lookup(parent, &dname);
1954                 dout("d_lookup on parent=%p name=%.*s got %p\n",
1955                      parent, dname.len, dname.name, dn);
1956
1957                 if (!dn) {
1958                         dn = d_alloc(parent, &dname);
1959                         dout("d_alloc %p '%.*s' = %p\n", parent,
1960                              dname.len, dname.name, dn);
1961                         if (!dn) {
1962                                 dout("d_alloc badness\n");
1963                                 err = -ENOMEM;
1964                                 goto out;
1965                         }
1966                         if (rde->is_nokey) {
1967                                 spin_lock(&dn->d_lock);
1968                                 dn->d_flags |= DCACHE_NOKEY_NAME;
1969                                 spin_unlock(&dn->d_lock);
1970                         }
1971                 } else if (d_really_is_positive(dn) &&
1972                            (ceph_ino(d_inode(dn)) != tvino.ino ||
1973                             ceph_snap(d_inode(dn)) != tvino.snap)) {
1974                         struct ceph_dentry_info *di = ceph_dentry(dn);
1975                         dout(" dn %p points to wrong inode %p\n",
1976                              dn, d_inode(dn));
1977
1978                         spin_lock(&dn->d_lock);
1979                         if (di->offset > 0 &&
1980                             di->lease_shared_gen ==
1981                             atomic_read(&ci->i_shared_gen)) {
1982                                 __ceph_dir_clear_ordered(ci);
1983                                 di->offset = 0;
1984                         }
1985                         spin_unlock(&dn->d_lock);
1986
1987                         d_delete(dn);
1988                         dput(dn);
1989                         goto retry_lookup;
1990                 }
1991
1992                 /* inode */
1993                 if (d_really_is_positive(dn)) {
1994                         in = d_inode(dn);
1995                 } else {
1996                         in = ceph_get_inode(parent->d_sb, tvino, NULL);
1997                         if (IS_ERR(in)) {
1998                                 dout("new_inode badness\n");
1999                                 d_drop(dn);
2000                                 dput(dn);
2001                                 err = PTR_ERR(in);
2002                                 goto out;
2003                         }
2004                 }
2005
2006                 ret = ceph_fill_inode(in, NULL, &rde->inode, NULL, session,
2007                                       -1, &req->r_caps_reservation);
2008                 if (ret < 0) {
2009                         pr_err("ceph_fill_inode badness on %p\n", in);
2010                         if (d_really_is_negative(dn)) {
2011                                 if (in->i_state & I_NEW) {
2012                                         ihold(in);
2013                                         discard_new_inode(in);
2014                                 }
2015                                 iput(in);
2016                         }
2017                         d_drop(dn);
2018                         err = ret;
2019                         goto next_item;
2020                 }
2021                 if (in->i_state & I_NEW)
2022                         unlock_new_inode(in);
2023
2024                 if (d_really_is_negative(dn)) {
2025                         if (ceph_security_xattr_deadlock(in)) {
2026                                 dout(" skip splicing dn %p to inode %p"
2027                                      " (security xattr deadlock)\n", dn, in);
2028                                 iput(in);
2029                                 skipped++;
2030                                 goto next_item;
2031                         }
2032
2033                         err = splice_dentry(&dn, in);
2034                         if (err < 0)
2035                                 goto next_item;
2036                 }
2037
2038                 ceph_dentry(dn)->offset = rde->offset;
2039
2040                 update_dentry_lease(d_inode(parent), dn,
2041                                     rde->lease, req->r_session,
2042                                     req->r_request_started);
2043
2044                 if (err == 0 && skipped == 0 && cache_ctl.index >= 0) {
2045                         ret = fill_readdir_cache(d_inode(parent), dn,
2046                                                  &cache_ctl, req);
2047                         if (ret < 0)
2048                                 err = ret;
2049                 }
2050 next_item:
2051                 dput(dn);
2052         }
2053 out:
2054         if (err == 0 && skipped == 0) {
2055                 set_bit(CEPH_MDS_R_DID_PREPOPULATE, &req->r_req_flags);
2056                 req->r_readdir_cache_idx = cache_ctl.index;
2057         }
2058         ceph_readdir_cache_release(&cache_ctl);
2059         dout("readdir_prepopulate done\n");
2060         return err;
2061 }
2062
2063 bool ceph_inode_set_size(struct inode *inode, loff_t size)
2064 {
2065         struct ceph_inode_info *ci = ceph_inode(inode);
2066         bool ret;
2067
2068         spin_lock(&ci->i_ceph_lock);
2069         dout("set_size %p %llu -> %llu\n", inode, i_size_read(inode), size);
2070         i_size_write(inode, size);
2071         ceph_fscache_update(inode);
2072         inode->i_blocks = calc_inode_blocks(size);
2073
2074         ret = __ceph_should_report_size(ci);
2075
2076         spin_unlock(&ci->i_ceph_lock);
2077
2078         return ret;
2079 }
2080
2081 void ceph_queue_inode_work(struct inode *inode, int work_bit)
2082 {
2083         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
2084         struct ceph_inode_info *ci = ceph_inode(inode);
2085         set_bit(work_bit, &ci->i_work_mask);
2086
2087         ihold(inode);
2088         if (queue_work(fsc->inode_wq, &ci->i_work)) {
2089                 dout("queue_inode_work %p, mask=%lx\n", inode, ci->i_work_mask);
2090         } else {
2091                 dout("queue_inode_work %p already queued, mask=%lx\n",
2092                      inode, ci->i_work_mask);
2093                 iput(inode);
2094         }
2095 }
2096
2097 static void ceph_do_invalidate_pages(struct inode *inode)
2098 {
2099         struct ceph_inode_info *ci = ceph_inode(inode);
2100         u32 orig_gen;
2101         int check = 0;
2102
2103         ceph_fscache_invalidate(inode, false);
2104
2105         mutex_lock(&ci->i_truncate_mutex);
2106
2107         if (ceph_inode_is_shutdown(inode)) {
2108                 pr_warn_ratelimited("%s: inode %llx.%llx is shut down\n",
2109                                     __func__, ceph_vinop(inode));
2110                 mapping_set_error(inode->i_mapping, -EIO);
2111                 truncate_pagecache(inode, 0);
2112                 mutex_unlock(&ci->i_truncate_mutex);
2113                 goto out;
2114         }
2115
2116         spin_lock(&ci->i_ceph_lock);
2117         dout("invalidate_pages %p gen %d revoking %d\n", inode,
2118              ci->i_rdcache_gen, ci->i_rdcache_revoking);
2119         if (ci->i_rdcache_revoking != ci->i_rdcache_gen) {
2120                 if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE))
2121                         check = 1;
2122                 spin_unlock(&ci->i_ceph_lock);
2123                 mutex_unlock(&ci->i_truncate_mutex);
2124                 goto out;
2125         }
2126         orig_gen = ci->i_rdcache_gen;
2127         spin_unlock(&ci->i_ceph_lock);
2128
2129         if (invalidate_inode_pages2(inode->i_mapping) < 0) {
2130                 pr_err("invalidate_inode_pages2 %llx.%llx failed\n",
2131                        ceph_vinop(inode));
2132         }
2133
2134         spin_lock(&ci->i_ceph_lock);
2135         if (orig_gen == ci->i_rdcache_gen &&
2136             orig_gen == ci->i_rdcache_revoking) {
2137                 dout("invalidate_pages %p gen %d successful\n", inode,
2138                      ci->i_rdcache_gen);
2139                 ci->i_rdcache_revoking--;
2140                 check = 1;
2141         } else {
2142                 dout("invalidate_pages %p gen %d raced, now %d revoking %d\n",
2143                      inode, orig_gen, ci->i_rdcache_gen,
2144                      ci->i_rdcache_revoking);
2145                 if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE))
2146                         check = 1;
2147         }
2148         spin_unlock(&ci->i_ceph_lock);
2149         mutex_unlock(&ci->i_truncate_mutex);
2150 out:
2151         if (check)
2152                 ceph_check_caps(ci, 0);
2153 }
2154
2155 /*
2156  * Make sure any pending truncation is applied before doing anything
2157  * that may depend on it.
2158  */
2159 void __ceph_do_pending_vmtruncate(struct inode *inode)
2160 {
2161         struct ceph_inode_info *ci = ceph_inode(inode);
2162         u64 to;
2163         int wrbuffer_refs, finish = 0;
2164
2165         mutex_lock(&ci->i_truncate_mutex);
2166 retry:
2167         spin_lock(&ci->i_ceph_lock);
2168         if (ci->i_truncate_pending == 0) {
2169                 dout("%s %p none pending\n", __func__, inode);
2170                 spin_unlock(&ci->i_ceph_lock);
2171                 mutex_unlock(&ci->i_truncate_mutex);
2172                 return;
2173         }
2174
2175         /*
2176          * make sure any dirty snapped pages are flushed before we
2177          * possibly truncate them.. so write AND block!
2178          */
2179         if (ci->i_wrbuffer_ref_head < ci->i_wrbuffer_ref) {
2180                 spin_unlock(&ci->i_ceph_lock);
2181                 dout("%s %p flushing snaps first\n", __func__, inode);
2182                 filemap_write_and_wait_range(&inode->i_data, 0,
2183                                              inode->i_sb->s_maxbytes);
2184                 goto retry;
2185         }
2186
2187         /* there should be no reader or writer */
2188         WARN_ON_ONCE(ci->i_rd_ref || ci->i_wr_ref);
2189
2190         to = ci->i_truncate_pagecache_size;
2191         wrbuffer_refs = ci->i_wrbuffer_ref;
2192         dout("%s %p (%d) to %lld\n", __func__, inode,
2193              ci->i_truncate_pending, to);
2194         spin_unlock(&ci->i_ceph_lock);
2195
2196         ceph_fscache_resize(inode, to);
2197         truncate_pagecache(inode, to);
2198
2199         spin_lock(&ci->i_ceph_lock);
2200         if (to == ci->i_truncate_pagecache_size) {
2201                 ci->i_truncate_pending = 0;
2202                 finish = 1;
2203         }
2204         spin_unlock(&ci->i_ceph_lock);
2205         if (!finish)
2206                 goto retry;
2207
2208         mutex_unlock(&ci->i_truncate_mutex);
2209
2210         if (wrbuffer_refs == 0)
2211                 ceph_check_caps(ci, 0);
2212
2213         wake_up_all(&ci->i_cap_wq);
2214 }
2215
2216 static void ceph_inode_work(struct work_struct *work)
2217 {
2218         struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info,
2219                                                  i_work);
2220         struct inode *inode = &ci->netfs.inode;
2221
2222         if (test_and_clear_bit(CEPH_I_WORK_WRITEBACK, &ci->i_work_mask)) {
2223                 dout("writeback %p\n", inode);
2224                 filemap_fdatawrite(&inode->i_data);
2225         }
2226         if (test_and_clear_bit(CEPH_I_WORK_INVALIDATE_PAGES, &ci->i_work_mask))
2227                 ceph_do_invalidate_pages(inode);
2228
2229         if (test_and_clear_bit(CEPH_I_WORK_VMTRUNCATE, &ci->i_work_mask))
2230                 __ceph_do_pending_vmtruncate(inode);
2231
2232         if (test_and_clear_bit(CEPH_I_WORK_CHECK_CAPS, &ci->i_work_mask))
2233                 ceph_check_caps(ci, 0);
2234
2235         if (test_and_clear_bit(CEPH_I_WORK_FLUSH_SNAPS, &ci->i_work_mask))
2236                 ceph_flush_snaps(ci, NULL);
2237
2238         iput(inode);
2239 }
2240
2241 static const char *ceph_encrypted_get_link(struct dentry *dentry,
2242                                            struct inode *inode,
2243                                            struct delayed_call *done)
2244 {
2245         struct ceph_inode_info *ci = ceph_inode(inode);
2246
2247         if (!dentry)
2248                 return ERR_PTR(-ECHILD);
2249
2250         return fscrypt_get_symlink(inode, ci->i_symlink, i_size_read(inode),
2251                                    done);
2252 }
2253
2254 static int ceph_encrypted_symlink_getattr(struct mnt_idmap *idmap,
2255                                           const struct path *path,
2256                                           struct kstat *stat, u32 request_mask,
2257                                           unsigned int query_flags)
2258 {
2259         int ret;
2260
2261         ret = ceph_getattr(idmap, path, stat, request_mask, query_flags);
2262         if (ret)
2263                 return ret;
2264         return fscrypt_symlink_getattr(path, stat);
2265 }
2266
2267 /*
2268  * symlinks
2269  */
2270 static const struct inode_operations ceph_symlink_iops = {
2271         .get_link = simple_get_link,
2272         .setattr = ceph_setattr,
2273         .getattr = ceph_getattr,
2274         .listxattr = ceph_listxattr,
2275 };
2276
2277 static const struct inode_operations ceph_encrypted_symlink_iops = {
2278         .get_link = ceph_encrypted_get_link,
2279         .setattr = ceph_setattr,
2280         .getattr = ceph_encrypted_symlink_getattr,
2281         .listxattr = ceph_listxattr,
2282 };
2283
2284 /*
2285  * Transfer the encrypted last block to the MDS and the MDS
2286  * will help update it when truncating a smaller size.
2287  *
2288  * We don't support a PAGE_SIZE that is smaller than the
2289  * CEPH_FSCRYPT_BLOCK_SIZE.
2290  */
2291 static int fill_fscrypt_truncate(struct inode *inode,
2292                                  struct ceph_mds_request *req,
2293                                  struct iattr *attr)
2294 {
2295         struct ceph_inode_info *ci = ceph_inode(inode);
2296         int boff = attr->ia_size % CEPH_FSCRYPT_BLOCK_SIZE;
2297         loff_t pos, orig_pos = round_down(attr->ia_size,
2298                                           CEPH_FSCRYPT_BLOCK_SIZE);
2299         u64 block = orig_pos >> CEPH_FSCRYPT_BLOCK_SHIFT;
2300         struct ceph_pagelist *pagelist = NULL;
2301         struct kvec iov = {0};
2302         struct iov_iter iter;
2303         struct page *page = NULL;
2304         struct ceph_fscrypt_truncate_size_header header;
2305         int retry_op = 0;
2306         int len = CEPH_FSCRYPT_BLOCK_SIZE;
2307         loff_t i_size = i_size_read(inode);
2308         int got, ret, issued;
2309         u64 objver;
2310
2311         ret = __ceph_get_caps(inode, NULL, CEPH_CAP_FILE_RD, 0, -1, &got);
2312         if (ret < 0)
2313                 return ret;
2314
2315         issued = __ceph_caps_issued(ci, NULL);
2316
2317         dout("%s size %lld -> %lld got cap refs on %s, issued %s\n", __func__,
2318              i_size, attr->ia_size, ceph_cap_string(got),
2319              ceph_cap_string(issued));
2320
2321         /* Try to writeback the dirty pagecaches */
2322         if (issued & (CEPH_CAP_FILE_BUFFER)) {
2323                 loff_t lend = orig_pos + CEPH_FSCRYPT_BLOCK_SHIFT - 1;
2324
2325                 ret = filemap_write_and_wait_range(inode->i_mapping,
2326                                                    orig_pos, lend);
2327                 if (ret < 0)
2328                         goto out;
2329         }
2330
2331         page = __page_cache_alloc(GFP_KERNEL);
2332         if (page == NULL) {
2333                 ret = -ENOMEM;
2334                 goto out;
2335         }
2336
2337         pagelist = ceph_pagelist_alloc(GFP_KERNEL);
2338         if (!pagelist) {
2339                 ret = -ENOMEM;
2340                 goto out;
2341         }
2342
2343         iov.iov_base = kmap_local_page(page);
2344         iov.iov_len = len;
2345         iov_iter_kvec(&iter, READ, &iov, 1, len);
2346
2347         pos = orig_pos;
2348         ret = __ceph_sync_read(inode, &pos, &iter, &retry_op, &objver);
2349         if (ret < 0)
2350                 goto out;
2351
2352         /* Insert the header first */
2353         header.ver = 1;
2354         header.compat = 1;
2355         header.change_attr = cpu_to_le64(inode_peek_iversion_raw(inode));
2356
2357         /*
2358          * Always set the block_size to CEPH_FSCRYPT_BLOCK_SIZE,
2359          * because in MDS it may need this to do the truncate.
2360          */
2361         header.block_size = cpu_to_le32(CEPH_FSCRYPT_BLOCK_SIZE);
2362
2363         /*
2364          * If we hit a hole here, we should just skip filling
2365          * the fscrypt for the request, because once the fscrypt
2366          * is enabled, the file will be split into many blocks
2367          * with the size of CEPH_FSCRYPT_BLOCK_SIZE, if there
2368          * has a hole, the hole size should be multiple of block
2369          * size.
2370          *
2371          * If the Rados object doesn't exist, it will be set to 0.
2372          */
2373         if (!objver) {
2374                 dout("%s hit hole, ppos %lld < size %lld\n", __func__,
2375                      pos, i_size);
2376
2377                 header.data_len = cpu_to_le32(8 + 8 + 4);
2378                 header.file_offset = 0;
2379                 ret = 0;
2380         } else {
2381                 header.data_len = cpu_to_le32(8 + 8 + 4 + CEPH_FSCRYPT_BLOCK_SIZE);
2382                 header.file_offset = cpu_to_le64(orig_pos);
2383
2384                 dout("%s encrypt block boff/bsize %d/%lu\n", __func__,
2385                      boff, CEPH_FSCRYPT_BLOCK_SIZE);
2386
2387                 /* truncate and zero out the extra contents for the last block */
2388                 memset(iov.iov_base + boff, 0, PAGE_SIZE - boff);
2389
2390                 /* encrypt the last block */
2391                 ret = ceph_fscrypt_encrypt_block_inplace(inode, page,
2392                                                     CEPH_FSCRYPT_BLOCK_SIZE,
2393                                                     0, block,
2394                                                     GFP_KERNEL);
2395                 if (ret)
2396                         goto out;
2397         }
2398
2399         /* Insert the header */
2400         ret = ceph_pagelist_append(pagelist, &header, sizeof(header));
2401         if (ret)
2402                 goto out;
2403
2404         if (header.block_size) {
2405                 /* Append the last block contents to pagelist */
2406                 ret = ceph_pagelist_append(pagelist, iov.iov_base,
2407                                            CEPH_FSCRYPT_BLOCK_SIZE);
2408                 if (ret)
2409                         goto out;
2410         }
2411         req->r_pagelist = pagelist;
2412 out:
2413         dout("%s %p size dropping cap refs on %s\n", __func__,
2414              inode, ceph_cap_string(got));
2415         ceph_put_cap_refs(ci, got);
2416         if (iov.iov_base)
2417                 kunmap_local(iov.iov_base);
2418         if (page)
2419                 __free_pages(page, 0);
2420         if (ret && pagelist)
2421                 ceph_pagelist_release(pagelist);
2422         return ret;
2423 }
2424
2425 int __ceph_setattr(struct inode *inode, struct iattr *attr,
2426                    struct ceph_iattr *cia)
2427 {
2428         struct ceph_inode_info *ci = ceph_inode(inode);
2429         unsigned int ia_valid = attr->ia_valid;
2430         struct ceph_mds_request *req;
2431         struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2432         struct ceph_cap_flush *prealloc_cf;
2433         loff_t isize = i_size_read(inode);
2434         int issued;
2435         int release = 0, dirtied = 0;
2436         int mask = 0;
2437         int err = 0;
2438         int inode_dirty_flags = 0;
2439         bool lock_snap_rwsem = false;
2440         bool fill_fscrypt;
2441         int truncate_retry = 20; /* The RMW will take around 50ms */
2442
2443 retry:
2444         prealloc_cf = ceph_alloc_cap_flush();
2445         if (!prealloc_cf)
2446                 return -ENOMEM;
2447
2448         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETATTR,
2449                                        USE_AUTH_MDS);
2450         if (IS_ERR(req)) {
2451                 ceph_free_cap_flush(prealloc_cf);
2452                 return PTR_ERR(req);
2453         }
2454
2455         fill_fscrypt = false;
2456         spin_lock(&ci->i_ceph_lock);
2457         issued = __ceph_caps_issued(ci, NULL);
2458
2459         if (!ci->i_head_snapc &&
2460             (issued & (CEPH_CAP_ANY_EXCL | CEPH_CAP_FILE_WR))) {
2461                 lock_snap_rwsem = true;
2462                 if (!down_read_trylock(&mdsc->snap_rwsem)) {
2463                         spin_unlock(&ci->i_ceph_lock);
2464                         down_read(&mdsc->snap_rwsem);
2465                         spin_lock(&ci->i_ceph_lock);
2466                         issued = __ceph_caps_issued(ci, NULL);
2467                 }
2468         }
2469
2470         dout("setattr %p issued %s\n", inode, ceph_cap_string(issued));
2471 #if IS_ENABLED(CONFIG_FS_ENCRYPTION)
2472         if (cia && cia->fscrypt_auth) {
2473                 u32 len = ceph_fscrypt_auth_len(cia->fscrypt_auth);
2474
2475                 if (len > sizeof(*cia->fscrypt_auth)) {
2476                         err = -EINVAL;
2477                         spin_unlock(&ci->i_ceph_lock);
2478                         goto out;
2479                 }
2480
2481                 dout("setattr %llx:%llx fscrypt_auth len %u to %u)\n",
2482                         ceph_vinop(inode), ci->fscrypt_auth_len, len);
2483
2484                 /* It should never be re-set once set */
2485                 WARN_ON_ONCE(ci->fscrypt_auth);
2486
2487                 if (issued & CEPH_CAP_AUTH_EXCL) {
2488                         dirtied |= CEPH_CAP_AUTH_EXCL;
2489                         kfree(ci->fscrypt_auth);
2490                         ci->fscrypt_auth = (u8 *)cia->fscrypt_auth;
2491                         ci->fscrypt_auth_len = len;
2492                 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
2493                            ci->fscrypt_auth_len != len ||
2494                            memcmp(ci->fscrypt_auth, cia->fscrypt_auth, len)) {
2495                         req->r_fscrypt_auth = cia->fscrypt_auth;
2496                         mask |= CEPH_SETATTR_FSCRYPT_AUTH;
2497                         release |= CEPH_CAP_AUTH_SHARED;
2498                 }
2499                 cia->fscrypt_auth = NULL;
2500         }
2501 #else
2502         if (cia && cia->fscrypt_auth) {
2503                 err = -EINVAL;
2504                 spin_unlock(&ci->i_ceph_lock);
2505                 goto out;
2506         }
2507 #endif /* CONFIG_FS_ENCRYPTION */
2508
2509         if (ia_valid & ATTR_UID) {
2510                 dout("setattr %p uid %d -> %d\n", inode,
2511                      from_kuid(&init_user_ns, inode->i_uid),
2512                      from_kuid(&init_user_ns, attr->ia_uid));
2513                 if (issued & CEPH_CAP_AUTH_EXCL) {
2514                         inode->i_uid = attr->ia_uid;
2515                         dirtied |= CEPH_CAP_AUTH_EXCL;
2516                 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
2517                            !uid_eq(attr->ia_uid, inode->i_uid)) {
2518                         req->r_args.setattr.uid = cpu_to_le32(
2519                                 from_kuid(&init_user_ns, attr->ia_uid));
2520                         mask |= CEPH_SETATTR_UID;
2521                         release |= CEPH_CAP_AUTH_SHARED;
2522                 }
2523         }
2524         if (ia_valid & ATTR_GID) {
2525                 dout("setattr %p gid %d -> %d\n", inode,
2526                      from_kgid(&init_user_ns, inode->i_gid),
2527                      from_kgid(&init_user_ns, attr->ia_gid));
2528                 if (issued & CEPH_CAP_AUTH_EXCL) {
2529                         inode->i_gid = attr->ia_gid;
2530                         dirtied |= CEPH_CAP_AUTH_EXCL;
2531                 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
2532                            !gid_eq(attr->ia_gid, inode->i_gid)) {
2533                         req->r_args.setattr.gid = cpu_to_le32(
2534                                 from_kgid(&init_user_ns, attr->ia_gid));
2535                         mask |= CEPH_SETATTR_GID;
2536                         release |= CEPH_CAP_AUTH_SHARED;
2537                 }
2538         }
2539         if (ia_valid & ATTR_MODE) {
2540                 dout("setattr %p mode 0%o -> 0%o\n", inode, inode->i_mode,
2541                      attr->ia_mode);
2542                 if (issued & CEPH_CAP_AUTH_EXCL) {
2543                         inode->i_mode = attr->ia_mode;
2544                         dirtied |= CEPH_CAP_AUTH_EXCL;
2545                 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
2546                            attr->ia_mode != inode->i_mode) {
2547                         inode->i_mode = attr->ia_mode;
2548                         req->r_args.setattr.mode = cpu_to_le32(attr->ia_mode);
2549                         mask |= CEPH_SETATTR_MODE;
2550                         release |= CEPH_CAP_AUTH_SHARED;
2551                 }
2552         }
2553
2554         if (ia_valid & ATTR_ATIME) {
2555                 dout("setattr %p atime %lld.%ld -> %lld.%ld\n", inode,
2556                      inode->i_atime.tv_sec, inode->i_atime.tv_nsec,
2557                      attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec);
2558                 if (issued & CEPH_CAP_FILE_EXCL) {
2559                         ci->i_time_warp_seq++;
2560                         inode->i_atime = attr->ia_atime;
2561                         dirtied |= CEPH_CAP_FILE_EXCL;
2562                 } else if ((issued & CEPH_CAP_FILE_WR) &&
2563                            timespec64_compare(&inode->i_atime,
2564                                             &attr->ia_atime) < 0) {
2565                         inode->i_atime = attr->ia_atime;
2566                         dirtied |= CEPH_CAP_FILE_WR;
2567                 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
2568                            !timespec64_equal(&inode->i_atime, &attr->ia_atime)) {
2569                         ceph_encode_timespec64(&req->r_args.setattr.atime,
2570                                                &attr->ia_atime);
2571                         mask |= CEPH_SETATTR_ATIME;
2572                         release |= CEPH_CAP_FILE_SHARED |
2573                                    CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
2574                 }
2575         }
2576         if (ia_valid & ATTR_SIZE) {
2577                 dout("setattr %p size %lld -> %lld\n", inode, isize, attr->ia_size);
2578                 /*
2579                  * Only when the new size is smaller and not aligned to
2580                  * CEPH_FSCRYPT_BLOCK_SIZE will the RMW is needed.
2581                  */
2582                 if (IS_ENCRYPTED(inode) && attr->ia_size < isize &&
2583                     (attr->ia_size % CEPH_FSCRYPT_BLOCK_SIZE)) {
2584                         mask |= CEPH_SETATTR_SIZE;
2585                         release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL |
2586                                    CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
2587                         set_bit(CEPH_MDS_R_FSCRYPT_FILE, &req->r_req_flags);
2588                         mask |= CEPH_SETATTR_FSCRYPT_FILE;
2589                         req->r_args.setattr.size =
2590                                 cpu_to_le64(round_up(attr->ia_size,
2591                                                      CEPH_FSCRYPT_BLOCK_SIZE));
2592                         req->r_args.setattr.old_size =
2593                                 cpu_to_le64(round_up(isize,
2594                                                      CEPH_FSCRYPT_BLOCK_SIZE));
2595                         req->r_fscrypt_file = attr->ia_size;
2596                         fill_fscrypt = true;
2597                 } else if ((issued & CEPH_CAP_FILE_EXCL) && attr->ia_size >= isize) {
2598                         if (attr->ia_size > isize) {
2599                                 i_size_write(inode, attr->ia_size);
2600                                 inode->i_blocks = calc_inode_blocks(attr->ia_size);
2601                                 ci->i_reported_size = attr->ia_size;
2602                                 dirtied |= CEPH_CAP_FILE_EXCL;
2603                                 ia_valid |= ATTR_MTIME;
2604                         }
2605                 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
2606                            attr->ia_size != isize) {
2607                         mask |= CEPH_SETATTR_SIZE;
2608                         release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL |
2609                                    CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
2610                         if (IS_ENCRYPTED(inode) && attr->ia_size) {
2611                                 set_bit(CEPH_MDS_R_FSCRYPT_FILE, &req->r_req_flags);
2612                                 mask |= CEPH_SETATTR_FSCRYPT_FILE;
2613                                 req->r_args.setattr.size =
2614                                         cpu_to_le64(round_up(attr->ia_size,
2615                                                              CEPH_FSCRYPT_BLOCK_SIZE));
2616                                 req->r_args.setattr.old_size =
2617                                         cpu_to_le64(round_up(isize,
2618                                                              CEPH_FSCRYPT_BLOCK_SIZE));
2619                                 req->r_fscrypt_file = attr->ia_size;
2620                         } else {
2621                                 req->r_args.setattr.size = cpu_to_le64(attr->ia_size);
2622                                 req->r_args.setattr.old_size = cpu_to_le64(isize);
2623                                 req->r_fscrypt_file = 0;
2624                         }
2625                 }
2626         }
2627         if (ia_valid & ATTR_MTIME) {
2628                 dout("setattr %p mtime %lld.%ld -> %lld.%ld\n", inode,
2629                      inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
2630                      attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec);
2631                 if (issued & CEPH_CAP_FILE_EXCL) {
2632                         ci->i_time_warp_seq++;
2633                         inode->i_mtime = attr->ia_mtime;
2634                         dirtied |= CEPH_CAP_FILE_EXCL;
2635                 } else if ((issued & CEPH_CAP_FILE_WR) &&
2636                            timespec64_compare(&inode->i_mtime,
2637                                             &attr->ia_mtime) < 0) {
2638                         inode->i_mtime = attr->ia_mtime;
2639                         dirtied |= CEPH_CAP_FILE_WR;
2640                 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
2641                            !timespec64_equal(&inode->i_mtime, &attr->ia_mtime)) {
2642                         ceph_encode_timespec64(&req->r_args.setattr.mtime,
2643                                                &attr->ia_mtime);
2644                         mask |= CEPH_SETATTR_MTIME;
2645                         release |= CEPH_CAP_FILE_SHARED |
2646                                    CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
2647                 }
2648         }
2649
2650         /* these do nothing */
2651         if (ia_valid & ATTR_CTIME) {
2652                 bool only = (ia_valid & (ATTR_SIZE|ATTR_MTIME|ATTR_ATIME|
2653                                          ATTR_MODE|ATTR_UID|ATTR_GID)) == 0;
2654                 dout("setattr %p ctime %lld.%ld -> %lld.%ld (%s)\n", inode,
2655                      inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
2656                      attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec,
2657                      only ? "ctime only" : "ignored");
2658                 if (only) {
2659                         /*
2660                          * if kernel wants to dirty ctime but nothing else,
2661                          * we need to choose a cap to dirty under, or do
2662                          * a almost-no-op setattr
2663                          */
2664                         if (issued & CEPH_CAP_AUTH_EXCL)
2665                                 dirtied |= CEPH_CAP_AUTH_EXCL;
2666                         else if (issued & CEPH_CAP_FILE_EXCL)
2667                                 dirtied |= CEPH_CAP_FILE_EXCL;
2668                         else if (issued & CEPH_CAP_XATTR_EXCL)
2669                                 dirtied |= CEPH_CAP_XATTR_EXCL;
2670                         else
2671                                 mask |= CEPH_SETATTR_CTIME;
2672                 }
2673         }
2674         if (ia_valid & ATTR_FILE)
2675                 dout("setattr %p ATTR_FILE ... hrm!\n", inode);
2676
2677         if (dirtied) {
2678                 inode_dirty_flags = __ceph_mark_dirty_caps(ci, dirtied,
2679                                                            &prealloc_cf);
2680                 inode->i_ctime = attr->ia_ctime;
2681                 inode_inc_iversion_raw(inode);
2682         }
2683
2684         release &= issued;
2685         spin_unlock(&ci->i_ceph_lock);
2686         if (lock_snap_rwsem) {
2687                 up_read(&mdsc->snap_rwsem);
2688                 lock_snap_rwsem = false;
2689         }
2690
2691         if (inode_dirty_flags)
2692                 __mark_inode_dirty(inode, inode_dirty_flags);
2693
2694         if (mask) {
2695                 req->r_inode = inode;
2696                 ihold(inode);
2697                 req->r_inode_drop = release;
2698                 req->r_args.setattr.mask = cpu_to_le32(mask);
2699                 req->r_num_caps = 1;
2700                 req->r_stamp = attr->ia_ctime;
2701                 if (fill_fscrypt) {
2702                         err = fill_fscrypt_truncate(inode, req, attr);
2703                         if (err)
2704                                 goto out;
2705                 }
2706
2707                 /*
2708                  * The truncate request will return -EAGAIN when the
2709                  * last block has been updated just before the MDS
2710                  * successfully gets the xlock for the FILE lock. To
2711                  * avoid corrupting the file contents we need to retry
2712                  * it.
2713                  */
2714                 err = ceph_mdsc_do_request(mdsc, NULL, req);
2715                 if (err == -EAGAIN && truncate_retry--) {
2716                         dout("setattr %p result=%d (%s locally, %d remote), retry it!\n",
2717                              inode, err, ceph_cap_string(dirtied), mask);
2718                         ceph_mdsc_put_request(req);
2719                         ceph_free_cap_flush(prealloc_cf);
2720                         goto retry;
2721                 }
2722         }
2723 out:
2724         dout("setattr %p result=%d (%s locally, %d remote)\n", inode, err,
2725              ceph_cap_string(dirtied), mask);
2726
2727         ceph_mdsc_put_request(req);
2728         ceph_free_cap_flush(prealloc_cf);
2729
2730         if (err >= 0 && (mask & CEPH_SETATTR_SIZE))
2731                 __ceph_do_pending_vmtruncate(inode);
2732
2733         return err;
2734 }
2735
2736 /*
2737  * setattr
2738  */
2739 int ceph_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
2740                  struct iattr *attr)
2741 {
2742         struct inode *inode = d_inode(dentry);
2743         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
2744         int err;
2745
2746         if (ceph_snap(inode) != CEPH_NOSNAP)
2747                 return -EROFS;
2748
2749         if (ceph_inode_is_shutdown(inode))
2750                 return -ESTALE;
2751
2752         err = fscrypt_prepare_setattr(dentry, attr);
2753         if (err)
2754                 return err;
2755
2756         err = setattr_prepare(&nop_mnt_idmap, dentry, attr);
2757         if (err != 0)
2758                 return err;
2759
2760         if ((attr->ia_valid & ATTR_SIZE) &&
2761             attr->ia_size > max(i_size_read(inode), fsc->max_file_size))
2762                 return -EFBIG;
2763
2764         if ((attr->ia_valid & ATTR_SIZE) &&
2765             ceph_quota_is_max_bytes_exceeded(inode, attr->ia_size))
2766                 return -EDQUOT;
2767
2768         err = __ceph_setattr(inode, attr, NULL);
2769
2770         if (err >= 0 && (attr->ia_valid & ATTR_MODE))
2771                 err = posix_acl_chmod(&nop_mnt_idmap, dentry, attr->ia_mode);
2772
2773         return err;
2774 }
2775
2776 int ceph_try_to_choose_auth_mds(struct inode *inode, int mask)
2777 {
2778         int issued = ceph_caps_issued(ceph_inode(inode));
2779
2780         /*
2781          * If any 'x' caps is issued we can just choose the auth MDS
2782          * instead of the random replica MDSes. Because only when the
2783          * Locker is in LOCK_EXEC state will the loner client could
2784          * get the 'x' caps. And if we send the getattr requests to
2785          * any replica MDS it must auth pin and tries to rdlock from
2786          * the auth MDS, and then the auth MDS need to do the Locker
2787          * state transition to LOCK_SYNC. And after that the lock state
2788          * will change back.
2789          *
2790          * This cost much when doing the Locker state transition and
2791          * usually will need to revoke caps from clients.
2792          *
2793          * And for the 'Xs' caps for getxattr we will also choose the
2794          * auth MDS, because the MDS side code is buggy due to setxattr
2795          * won't notify the replica MDSes when the values changed and
2796          * the replica MDS will return the old values. Though we will
2797          * fix it in MDS code, but this still makes sense for old ceph.
2798          */
2799         if (((mask & CEPH_CAP_ANY_SHARED) && (issued & CEPH_CAP_ANY_EXCL))
2800             || (mask & (CEPH_STAT_RSTAT | CEPH_STAT_CAP_XATTR)))
2801                 return USE_AUTH_MDS;
2802         else
2803                 return USE_ANY_MDS;
2804 }
2805
2806 /*
2807  * Verify that we have a lease on the given mask.  If not,
2808  * do a getattr against an mds.
2809  */
2810 int __ceph_do_getattr(struct inode *inode, struct page *locked_page,
2811                       int mask, bool force)
2812 {
2813         struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb);
2814         struct ceph_mds_client *mdsc = fsc->mdsc;
2815         struct ceph_mds_request *req;
2816         int mode;
2817         int err;
2818
2819         if (ceph_snap(inode) == CEPH_SNAPDIR) {
2820                 dout("do_getattr inode %p SNAPDIR\n", inode);
2821                 return 0;
2822         }
2823
2824         dout("do_getattr inode %p mask %s mode 0%o\n",
2825              inode, ceph_cap_string(mask), inode->i_mode);
2826         if (!force && ceph_caps_issued_mask_metric(ceph_inode(inode), mask, 1))
2827                         return 0;
2828
2829         mode = ceph_try_to_choose_auth_mds(inode, mask);
2830         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, mode);
2831         if (IS_ERR(req))
2832                 return PTR_ERR(req);
2833         req->r_inode = inode;
2834         ihold(inode);
2835         req->r_num_caps = 1;
2836         req->r_args.getattr.mask = cpu_to_le32(mask);
2837         req->r_locked_page = locked_page;
2838         err = ceph_mdsc_do_request(mdsc, NULL, req);
2839         if (locked_page && err == 0) {
2840                 u64 inline_version = req->r_reply_info.targeti.inline_version;
2841                 if (inline_version == 0) {
2842                         /* the reply is supposed to contain inline data */
2843                         err = -EINVAL;
2844                 } else if (inline_version == CEPH_INLINE_NONE ||
2845                            inline_version == 1) {
2846                         err = -ENODATA;
2847                 } else {
2848                         err = req->r_reply_info.targeti.inline_len;
2849                 }
2850         }
2851         ceph_mdsc_put_request(req);
2852         dout("do_getattr result=%d\n", err);
2853         return err;
2854 }
2855
2856 int ceph_do_getvxattr(struct inode *inode, const char *name, void *value,
2857                       size_t size)
2858 {
2859         struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb);
2860         struct ceph_mds_client *mdsc = fsc->mdsc;
2861         struct ceph_mds_request *req;
2862         int mode = USE_AUTH_MDS;
2863         int err;
2864         char *xattr_value;
2865         size_t xattr_value_len;
2866
2867         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETVXATTR, mode);
2868         if (IS_ERR(req)) {
2869                 err = -ENOMEM;
2870                 goto out;
2871         }
2872
2873         req->r_feature_needed = CEPHFS_FEATURE_OP_GETVXATTR;
2874         req->r_path2 = kstrdup(name, GFP_NOFS);
2875         if (!req->r_path2) {
2876                 err = -ENOMEM;
2877                 goto put;
2878         }
2879
2880         ihold(inode);
2881         req->r_inode = inode;
2882         err = ceph_mdsc_do_request(mdsc, NULL, req);
2883         if (err < 0)
2884                 goto put;
2885
2886         xattr_value = req->r_reply_info.xattr_info.xattr_value;
2887         xattr_value_len = req->r_reply_info.xattr_info.xattr_value_len;
2888
2889         dout("do_getvxattr xattr_value_len:%zu, size:%zu\n", xattr_value_len, size);
2890
2891         err = (int)xattr_value_len;
2892         if (size == 0)
2893                 goto put;
2894
2895         if (xattr_value_len > size) {
2896                 err = -ERANGE;
2897                 goto put;
2898         }
2899
2900         memcpy(value, xattr_value, xattr_value_len);
2901 put:
2902         ceph_mdsc_put_request(req);
2903 out:
2904         dout("do_getvxattr result=%d\n", err);
2905         return err;
2906 }
2907
2908
2909 /*
2910  * Check inode permissions.  We verify we have a valid value for
2911  * the AUTH cap, then call the generic handler.
2912  */
2913 int ceph_permission(struct mnt_idmap *idmap, struct inode *inode,
2914                     int mask)
2915 {
2916         int err;
2917
2918         if (mask & MAY_NOT_BLOCK)
2919                 return -ECHILD;
2920
2921         err = ceph_do_getattr(inode, CEPH_CAP_AUTH_SHARED, false);
2922
2923         if (!err)
2924                 err = generic_permission(&nop_mnt_idmap, inode, mask);
2925         return err;
2926 }
2927
2928 /* Craft a mask of needed caps given a set of requested statx attrs. */
2929 static int statx_to_caps(u32 want, umode_t mode)
2930 {
2931         int mask = 0;
2932
2933         if (want & (STATX_MODE|STATX_UID|STATX_GID|STATX_CTIME|STATX_BTIME|STATX_CHANGE_COOKIE))
2934                 mask |= CEPH_CAP_AUTH_SHARED;
2935
2936         if (want & (STATX_NLINK|STATX_CTIME|STATX_CHANGE_COOKIE)) {
2937                 /*
2938                  * The link count for directories depends on inode->i_subdirs,
2939                  * and that is only updated when Fs caps are held.
2940                  */
2941                 if (S_ISDIR(mode))
2942                         mask |= CEPH_CAP_FILE_SHARED;
2943                 else
2944                         mask |= CEPH_CAP_LINK_SHARED;
2945         }
2946
2947         if (want & (STATX_ATIME|STATX_MTIME|STATX_CTIME|STATX_SIZE|STATX_BLOCKS|STATX_CHANGE_COOKIE))
2948                 mask |= CEPH_CAP_FILE_SHARED;
2949
2950         if (want & (STATX_CTIME|STATX_CHANGE_COOKIE))
2951                 mask |= CEPH_CAP_XATTR_SHARED;
2952
2953         return mask;
2954 }
2955
2956 /*
2957  * Get all the attributes. If we have sufficient caps for the requested attrs,
2958  * then we can avoid talking to the MDS at all.
2959  */
2960 int ceph_getattr(struct mnt_idmap *idmap, const struct path *path,
2961                  struct kstat *stat, u32 request_mask, unsigned int flags)
2962 {
2963         struct inode *inode = d_inode(path->dentry);
2964         struct super_block *sb = inode->i_sb;
2965         struct ceph_inode_info *ci = ceph_inode(inode);
2966         u32 valid_mask = STATX_BASIC_STATS;
2967         int err = 0;
2968
2969         if (ceph_inode_is_shutdown(inode))
2970                 return -ESTALE;
2971
2972         /* Skip the getattr altogether if we're asked not to sync */
2973         if ((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) {
2974                 err = ceph_do_getattr(inode,
2975                                 statx_to_caps(request_mask, inode->i_mode),
2976                                 flags & AT_STATX_FORCE_SYNC);
2977                 if (err)
2978                         return err;
2979         }
2980
2981         generic_fillattr(&nop_mnt_idmap, inode, stat);
2982         stat->ino = ceph_present_inode(inode);
2983
2984         /*
2985          * btime on newly-allocated inodes is 0, so if this is still set to
2986          * that, then assume that it's not valid.
2987          */
2988         if (ci->i_btime.tv_sec || ci->i_btime.tv_nsec) {
2989                 stat->btime = ci->i_btime;
2990                 valid_mask |= STATX_BTIME;
2991         }
2992
2993         if (request_mask & STATX_CHANGE_COOKIE) {
2994                 stat->change_cookie = inode_peek_iversion_raw(inode);
2995                 valid_mask |= STATX_CHANGE_COOKIE;
2996         }
2997
2998         if (ceph_snap(inode) == CEPH_NOSNAP)
2999                 stat->dev = sb->s_dev;
3000         else
3001                 stat->dev = ci->i_snapid_map ? ci->i_snapid_map->dev : 0;
3002
3003         if (S_ISDIR(inode->i_mode)) {
3004                 if (ceph_test_mount_opt(ceph_sb_to_client(sb), RBYTES)) {
3005                         stat->size = ci->i_rbytes;
3006                 } else if (ceph_snap(inode) == CEPH_SNAPDIR) {
3007                         struct ceph_inode_info *pci;
3008                         struct ceph_snap_realm *realm;
3009                         struct inode *parent;
3010
3011                         parent = ceph_lookup_inode(sb, ceph_ino(inode));
3012                         if (IS_ERR(parent))
3013                                 return PTR_ERR(parent);
3014
3015                         pci = ceph_inode(parent);
3016                         spin_lock(&pci->i_ceph_lock);
3017                         realm = pci->i_snap_realm;
3018                         if (realm)
3019                                 stat->size = realm->num_snaps;
3020                         else
3021                                 stat->size = 0;
3022                         spin_unlock(&pci->i_ceph_lock);
3023                         iput(parent);
3024                 } else {
3025                         stat->size = ci->i_files + ci->i_subdirs;
3026                 }
3027                 stat->blocks = 0;
3028                 stat->blksize = 65536;
3029                 /*
3030                  * Some applications rely on the number of st_nlink
3031                  * value on directories to be either 0 (if unlinked)
3032                  * or 2 + number of subdirectories.
3033                  */
3034                 if (stat->nlink == 1)
3035                         /* '.' + '..' + subdirs */
3036                         stat->nlink = 1 + 1 + ci->i_subdirs;
3037         }
3038
3039         stat->attributes |= STATX_ATTR_CHANGE_MONOTONIC;
3040         if (IS_ENCRYPTED(inode))
3041                 stat->attributes |= STATX_ATTR_ENCRYPTED;
3042         stat->attributes_mask |= (STATX_ATTR_CHANGE_MONOTONIC |
3043                                   STATX_ATTR_ENCRYPTED);
3044
3045         stat->result_mask = request_mask & valid_mask;
3046         return err;
3047 }
3048
3049 void ceph_inode_shutdown(struct inode *inode)
3050 {
3051         struct ceph_inode_info *ci = ceph_inode(inode);
3052         struct rb_node *p;
3053         int iputs = 0;
3054         bool invalidate = false;
3055
3056         spin_lock(&ci->i_ceph_lock);
3057         ci->i_ceph_flags |= CEPH_I_SHUTDOWN;
3058         p = rb_first(&ci->i_caps);
3059         while (p) {
3060                 struct ceph_cap *cap = rb_entry(p, struct ceph_cap, ci_node);
3061
3062                 p = rb_next(p);
3063                 iputs += ceph_purge_inode_cap(inode, cap, &invalidate);
3064         }
3065         spin_unlock(&ci->i_ceph_lock);
3066
3067         if (invalidate)
3068                 ceph_queue_invalidate(inode);
3069         while (iputs--)
3070                 iput(inode);
3071 }