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 17 #include "super.h" 18 #include "mds_client.h" 19 #include "cache.h" 20 #include <linux/ceph/decode.h> 21 22 /* 23 * Ceph inode operations 24 * 25 * Implement basic inode helpers (get, alloc) and inode ops (getattr, 26 * setattr, etc.), xattr helpers, and helpers for assimilating 27 * metadata returned by the MDS into our cache. 28 * 29 * Also define helpers for doing asynchronous writeback, invalidation, 30 * and truncation for the benefit of those who can't afford to block 31 * (typically because they are in the message handler path). 32 */ 33 34 static const struct inode_operations ceph_symlink_iops; 35 36 static void ceph_invalidate_work(struct work_struct *work); 37 static void ceph_writeback_work(struct work_struct *work); 38 static void ceph_vmtruncate_work(struct work_struct *work); 39 40 /* 41 * find or create an inode, given the ceph ino number 42 */ 43 static int ceph_set_ino_cb(struct inode *inode, void *data) 44 { 45 ceph_inode(inode)->i_vino = *(struct ceph_vino *)data; 46 inode->i_ino = ceph_vino_to_ino(*(struct ceph_vino *)data); 47 return 0; 48 } 49 50 struct inode *ceph_get_inode(struct super_block *sb, struct ceph_vino vino) 51 { 52 struct inode *inode; 53 ino_t t = ceph_vino_to_ino(vino); 54 55 inode = iget5_locked(sb, t, ceph_ino_compare, ceph_set_ino_cb, &vino); 56 if (!inode) 57 return ERR_PTR(-ENOMEM); 58 if (inode->i_state & I_NEW) { 59 dout("get_inode created new inode %p %llx.%llx ino %llx\n", 60 inode, ceph_vinop(inode), (u64)inode->i_ino); 61 unlock_new_inode(inode); 62 } 63 64 dout("get_inode on %lu=%llx.%llx got %p\n", inode->i_ino, vino.ino, 65 vino.snap, inode); 66 return inode; 67 } 68 69 /* 70 * get/constuct snapdir inode for a given directory 71 */ 72 struct inode *ceph_get_snapdir(struct inode *parent) 73 { 74 struct ceph_vino vino = { 75 .ino = ceph_ino(parent), 76 .snap = CEPH_SNAPDIR, 77 }; 78 struct inode *inode = ceph_get_inode(parent->i_sb, vino); 79 struct ceph_inode_info *ci = ceph_inode(inode); 80 81 BUG_ON(!S_ISDIR(parent->i_mode)); 82 if (IS_ERR(inode)) 83 return inode; 84 inode->i_mode = parent->i_mode; 85 inode->i_uid = parent->i_uid; 86 inode->i_gid = parent->i_gid; 87 inode->i_op = &ceph_snapdir_iops; 88 inode->i_fop = &ceph_snapdir_fops; 89 ci->i_snap_caps = CEPH_CAP_PIN; /* so we can open */ 90 ci->i_rbytes = 0; 91 return inode; 92 } 93 94 const struct inode_operations ceph_file_iops = { 95 .permission = ceph_permission, 96 .setattr = ceph_setattr, 97 .getattr = ceph_getattr, 98 .listxattr = ceph_listxattr, 99 .get_acl = ceph_get_acl, 100 .set_acl = ceph_set_acl, 101 }; 102 103 104 /* 105 * We use a 'frag tree' to keep track of the MDS's directory fragments 106 * for a given inode (usually there is just a single fragment). We 107 * need to know when a child frag is delegated to a new MDS, or when 108 * it is flagged as replicated, so we can direct our requests 109 * accordingly. 110 */ 111 112 /* 113 * find/create a frag in the tree 114 */ 115 static struct ceph_inode_frag *__get_or_create_frag(struct ceph_inode_info *ci, 116 u32 f) 117 { 118 struct rb_node **p; 119 struct rb_node *parent = NULL; 120 struct ceph_inode_frag *frag; 121 int c; 122 123 p = &ci->i_fragtree.rb_node; 124 while (*p) { 125 parent = *p; 126 frag = rb_entry(parent, struct ceph_inode_frag, node); 127 c = ceph_frag_compare(f, frag->frag); 128 if (c < 0) 129 p = &(*p)->rb_left; 130 else if (c > 0) 131 p = &(*p)->rb_right; 132 else 133 return frag; 134 } 135 136 frag = kmalloc(sizeof(*frag), GFP_NOFS); 137 if (!frag) 138 return ERR_PTR(-ENOMEM); 139 140 frag->frag = f; 141 frag->split_by = 0; 142 frag->mds = -1; 143 frag->ndist = 0; 144 145 rb_link_node(&frag->node, parent, p); 146 rb_insert_color(&frag->node, &ci->i_fragtree); 147 148 dout("get_or_create_frag added %llx.%llx frag %x\n", 149 ceph_vinop(&ci->vfs_inode), f); 150 return frag; 151 } 152 153 /* 154 * find a specific frag @f 155 */ 156 struct ceph_inode_frag *__ceph_find_frag(struct ceph_inode_info *ci, u32 f) 157 { 158 struct rb_node *n = ci->i_fragtree.rb_node; 159 160 while (n) { 161 struct ceph_inode_frag *frag = 162 rb_entry(n, struct ceph_inode_frag, node); 163 int c = ceph_frag_compare(f, frag->frag); 164 if (c < 0) 165 n = n->rb_left; 166 else if (c > 0) 167 n = n->rb_right; 168 else 169 return frag; 170 } 171 return NULL; 172 } 173 174 /* 175 * Choose frag containing the given value @v. If @pfrag is 176 * specified, copy the frag delegation info to the caller if 177 * it is present. 178 */ 179 static u32 __ceph_choose_frag(struct ceph_inode_info *ci, u32 v, 180 struct ceph_inode_frag *pfrag, int *found) 181 { 182 u32 t = ceph_frag_make(0, 0); 183 struct ceph_inode_frag *frag; 184 unsigned nway, i; 185 u32 n; 186 187 if (found) 188 *found = 0; 189 190 while (1) { 191 WARN_ON(!ceph_frag_contains_value(t, v)); 192 frag = __ceph_find_frag(ci, t); 193 if (!frag) 194 break; /* t is a leaf */ 195 if (frag->split_by == 0) { 196 if (pfrag) 197 memcpy(pfrag, frag, sizeof(*pfrag)); 198 if (found) 199 *found = 1; 200 break; 201 } 202 203 /* choose child */ 204 nway = 1 << frag->split_by; 205 dout("choose_frag(%x) %x splits by %d (%d ways)\n", v, t, 206 frag->split_by, nway); 207 for (i = 0; i < nway; i++) { 208 n = ceph_frag_make_child(t, frag->split_by, i); 209 if (ceph_frag_contains_value(n, v)) { 210 t = n; 211 break; 212 } 213 } 214 BUG_ON(i == nway); 215 } 216 dout("choose_frag(%x) = %x\n", v, t); 217 218 return t; 219 } 220 221 u32 ceph_choose_frag(struct ceph_inode_info *ci, u32 v, 222 struct ceph_inode_frag *pfrag, int *found) 223 { 224 u32 ret; 225 mutex_lock(&ci->i_fragtree_mutex); 226 ret = __ceph_choose_frag(ci, v, pfrag, found); 227 mutex_unlock(&ci->i_fragtree_mutex); 228 return ret; 229 } 230 231 /* 232 * Process dirfrag (delegation) info from the mds. Include leaf 233 * fragment in tree ONLY if ndist > 0. Otherwise, only 234 * branches/splits are included in i_fragtree) 235 */ 236 static int ceph_fill_dirfrag(struct inode *inode, 237 struct ceph_mds_reply_dirfrag *dirinfo) 238 { 239 struct ceph_inode_info *ci = ceph_inode(inode); 240 struct ceph_inode_frag *frag; 241 u32 id = le32_to_cpu(dirinfo->frag); 242 int mds = le32_to_cpu(dirinfo->auth); 243 int ndist = le32_to_cpu(dirinfo->ndist); 244 int diri_auth = -1; 245 int i; 246 int err = 0; 247 248 spin_lock(&ci->i_ceph_lock); 249 if (ci->i_auth_cap) 250 diri_auth = ci->i_auth_cap->mds; 251 spin_unlock(&ci->i_ceph_lock); 252 253 if (mds == -1) /* CDIR_AUTH_PARENT */ 254 mds = diri_auth; 255 256 mutex_lock(&ci->i_fragtree_mutex); 257 if (ndist == 0 && mds == diri_auth) { 258 /* no delegation info needed. */ 259 frag = __ceph_find_frag(ci, id); 260 if (!frag) 261 goto out; 262 if (frag->split_by == 0) { 263 /* tree leaf, remove */ 264 dout("fill_dirfrag removed %llx.%llx frag %x" 265 " (no ref)\n", ceph_vinop(inode), id); 266 rb_erase(&frag->node, &ci->i_fragtree); 267 kfree(frag); 268 } else { 269 /* tree branch, keep and clear */ 270 dout("fill_dirfrag cleared %llx.%llx frag %x" 271 " referral\n", ceph_vinop(inode), id); 272 frag->mds = -1; 273 frag->ndist = 0; 274 } 275 goto out; 276 } 277 278 279 /* find/add this frag to store mds delegation info */ 280 frag = __get_or_create_frag(ci, id); 281 if (IS_ERR(frag)) { 282 /* this is not the end of the world; we can continue 283 with bad/inaccurate delegation info */ 284 pr_err("fill_dirfrag ENOMEM on mds ref %llx.%llx fg %x\n", 285 ceph_vinop(inode), le32_to_cpu(dirinfo->frag)); 286 err = -ENOMEM; 287 goto out; 288 } 289 290 frag->mds = mds; 291 frag->ndist = min_t(u32, ndist, CEPH_MAX_DIRFRAG_REP); 292 for (i = 0; i < frag->ndist; i++) 293 frag->dist[i] = le32_to_cpu(dirinfo->dist[i]); 294 dout("fill_dirfrag %llx.%llx frag %x ndist=%d\n", 295 ceph_vinop(inode), frag->frag, frag->ndist); 296 297 out: 298 mutex_unlock(&ci->i_fragtree_mutex); 299 return err; 300 } 301 302 static int frag_tree_split_cmp(const void *l, const void *r) 303 { 304 struct ceph_frag_tree_split *ls = (struct ceph_frag_tree_split*)l; 305 struct ceph_frag_tree_split *rs = (struct ceph_frag_tree_split*)r; 306 return ceph_frag_compare(le32_to_cpu(ls->frag), 307 le32_to_cpu(rs->frag)); 308 } 309 310 static bool is_frag_child(u32 f, struct ceph_inode_frag *frag) 311 { 312 if (!frag) 313 return f == ceph_frag_make(0, 0); 314 if (ceph_frag_bits(f) != ceph_frag_bits(frag->frag) + frag->split_by) 315 return false; 316 return ceph_frag_contains_value(frag->frag, ceph_frag_value(f)); 317 } 318 319 static int ceph_fill_fragtree(struct inode *inode, 320 struct ceph_frag_tree_head *fragtree, 321 struct ceph_mds_reply_dirfrag *dirinfo) 322 { 323 struct ceph_inode_info *ci = ceph_inode(inode); 324 struct ceph_inode_frag *frag, *prev_frag = NULL; 325 struct rb_node *rb_node; 326 unsigned i, split_by, nsplits; 327 u32 id; 328 bool update = false; 329 330 mutex_lock(&ci->i_fragtree_mutex); 331 nsplits = le32_to_cpu(fragtree->nsplits); 332 if (nsplits != ci->i_fragtree_nsplits) { 333 update = true; 334 } else if (nsplits) { 335 i = prandom_u32() % nsplits; 336 id = le32_to_cpu(fragtree->splits[i].frag); 337 if (!__ceph_find_frag(ci, id)) 338 update = true; 339 } else if (!RB_EMPTY_ROOT(&ci->i_fragtree)) { 340 rb_node = rb_first(&ci->i_fragtree); 341 frag = rb_entry(rb_node, struct ceph_inode_frag, node); 342 if (frag->frag != ceph_frag_make(0, 0) || rb_next(rb_node)) 343 update = true; 344 } 345 if (!update && dirinfo) { 346 id = le32_to_cpu(dirinfo->frag); 347 if (id != __ceph_choose_frag(ci, id, NULL, NULL)) 348 update = true; 349 } 350 if (!update) 351 goto out_unlock; 352 353 if (nsplits > 1) { 354 sort(fragtree->splits, nsplits, sizeof(fragtree->splits[0]), 355 frag_tree_split_cmp, NULL); 356 } 357 358 dout("fill_fragtree %llx.%llx\n", ceph_vinop(inode)); 359 rb_node = rb_first(&ci->i_fragtree); 360 for (i = 0; i < nsplits; i++) { 361 id = le32_to_cpu(fragtree->splits[i].frag); 362 split_by = le32_to_cpu(fragtree->splits[i].by); 363 if (split_by == 0 || ceph_frag_bits(id) + split_by > 24) { 364 pr_err("fill_fragtree %llx.%llx invalid split %d/%u, " 365 "frag %x split by %d\n", ceph_vinop(inode), 366 i, nsplits, id, split_by); 367 continue; 368 } 369 frag = NULL; 370 while (rb_node) { 371 frag = rb_entry(rb_node, struct ceph_inode_frag, node); 372 if (ceph_frag_compare(frag->frag, id) >= 0) { 373 if (frag->frag != id) 374 frag = NULL; 375 else 376 rb_node = rb_next(rb_node); 377 break; 378 } 379 rb_node = rb_next(rb_node); 380 /* delete stale split/leaf node */ 381 if (frag->split_by > 0 || 382 !is_frag_child(frag->frag, prev_frag)) { 383 rb_erase(&frag->node, &ci->i_fragtree); 384 if (frag->split_by > 0) 385 ci->i_fragtree_nsplits--; 386 kfree(frag); 387 } 388 frag = NULL; 389 } 390 if (!frag) { 391 frag = __get_or_create_frag(ci, id); 392 if (IS_ERR(frag)) 393 continue; 394 } 395 if (frag->split_by == 0) 396 ci->i_fragtree_nsplits++; 397 frag->split_by = split_by; 398 dout(" frag %x split by %d\n", frag->frag, frag->split_by); 399 prev_frag = frag; 400 } 401 while (rb_node) { 402 frag = rb_entry(rb_node, struct ceph_inode_frag, node); 403 rb_node = rb_next(rb_node); 404 /* delete stale split/leaf node */ 405 if (frag->split_by > 0 || 406 !is_frag_child(frag->frag, prev_frag)) { 407 rb_erase(&frag->node, &ci->i_fragtree); 408 if (frag->split_by > 0) 409 ci->i_fragtree_nsplits--; 410 kfree(frag); 411 } 412 } 413 out_unlock: 414 mutex_unlock(&ci->i_fragtree_mutex); 415 return 0; 416 } 417 418 /* 419 * initialize a newly allocated inode. 420 */ 421 struct inode *ceph_alloc_inode(struct super_block *sb) 422 { 423 struct ceph_inode_info *ci; 424 int i; 425 426 ci = kmem_cache_alloc(ceph_inode_cachep, GFP_NOFS); 427 if (!ci) 428 return NULL; 429 430 dout("alloc_inode %p\n", &ci->vfs_inode); 431 432 spin_lock_init(&ci->i_ceph_lock); 433 434 ci->i_version = 0; 435 ci->i_inline_version = 0; 436 ci->i_time_warp_seq = 0; 437 ci->i_ceph_flags = 0; 438 atomic64_set(&ci->i_ordered_count, 1); 439 atomic64_set(&ci->i_release_count, 1); 440 atomic64_set(&ci->i_complete_seq[0], 0); 441 atomic64_set(&ci->i_complete_seq[1], 0); 442 ci->i_symlink = NULL; 443 444 memset(&ci->i_dir_layout, 0, sizeof(ci->i_dir_layout)); 445 RCU_INIT_POINTER(ci->i_layout.pool_ns, NULL); 446 447 ci->i_fragtree = RB_ROOT; 448 mutex_init(&ci->i_fragtree_mutex); 449 450 ci->i_xattrs.blob = NULL; 451 ci->i_xattrs.prealloc_blob = NULL; 452 ci->i_xattrs.dirty = false; 453 ci->i_xattrs.index = RB_ROOT; 454 ci->i_xattrs.count = 0; 455 ci->i_xattrs.names_size = 0; 456 ci->i_xattrs.vals_size = 0; 457 ci->i_xattrs.version = 0; 458 ci->i_xattrs.index_version = 0; 459 460 ci->i_caps = RB_ROOT; 461 ci->i_auth_cap = NULL; 462 ci->i_dirty_caps = 0; 463 ci->i_flushing_caps = 0; 464 INIT_LIST_HEAD(&ci->i_dirty_item); 465 INIT_LIST_HEAD(&ci->i_flushing_item); 466 ci->i_prealloc_cap_flush = NULL; 467 INIT_LIST_HEAD(&ci->i_cap_flush_list); 468 init_waitqueue_head(&ci->i_cap_wq); 469 ci->i_hold_caps_min = 0; 470 ci->i_hold_caps_max = 0; 471 INIT_LIST_HEAD(&ci->i_cap_delay_list); 472 INIT_LIST_HEAD(&ci->i_cap_snaps); 473 ci->i_head_snapc = NULL; 474 ci->i_snap_caps = 0; 475 476 for (i = 0; i < CEPH_FILE_MODE_BITS; i++) 477 ci->i_nr_by_mode[i] = 0; 478 479 mutex_init(&ci->i_truncate_mutex); 480 ci->i_truncate_seq = 0; 481 ci->i_truncate_size = 0; 482 ci->i_truncate_pending = 0; 483 484 ci->i_max_size = 0; 485 ci->i_reported_size = 0; 486 ci->i_wanted_max_size = 0; 487 ci->i_requested_max_size = 0; 488 489 ci->i_pin_ref = 0; 490 ci->i_rd_ref = 0; 491 ci->i_rdcache_ref = 0; 492 ci->i_wr_ref = 0; 493 ci->i_wb_ref = 0; 494 ci->i_wrbuffer_ref = 0; 495 ci->i_wrbuffer_ref_head = 0; 496 atomic_set(&ci->i_filelock_ref, 0); 497 ci->i_shared_gen = 0; 498 ci->i_rdcache_gen = 0; 499 ci->i_rdcache_revoking = 0; 500 501 INIT_LIST_HEAD(&ci->i_unsafe_dirops); 502 INIT_LIST_HEAD(&ci->i_unsafe_iops); 503 spin_lock_init(&ci->i_unsafe_lock); 504 505 ci->i_snap_realm = NULL; 506 INIT_LIST_HEAD(&ci->i_snap_realm_item); 507 INIT_LIST_HEAD(&ci->i_snap_flush_item); 508 509 INIT_WORK(&ci->i_wb_work, ceph_writeback_work); 510 INIT_WORK(&ci->i_pg_inv_work, ceph_invalidate_work); 511 512 INIT_WORK(&ci->i_vmtruncate_work, ceph_vmtruncate_work); 513 514 ceph_fscache_inode_init(ci); 515 516 return &ci->vfs_inode; 517 } 518 519 static void ceph_i_callback(struct rcu_head *head) 520 { 521 struct inode *inode = container_of(head, struct inode, i_rcu); 522 struct ceph_inode_info *ci = ceph_inode(inode); 523 524 kmem_cache_free(ceph_inode_cachep, ci); 525 } 526 527 void ceph_destroy_inode(struct inode *inode) 528 { 529 struct ceph_inode_info *ci = ceph_inode(inode); 530 struct ceph_inode_frag *frag; 531 struct rb_node *n; 532 533 dout("destroy_inode %p ino %llx.%llx\n", inode, ceph_vinop(inode)); 534 535 ceph_fscache_unregister_inode_cookie(ci); 536 537 ceph_queue_caps_release(inode); 538 539 /* 540 * we may still have a snap_realm reference if there are stray 541 * caps in i_snap_caps. 542 */ 543 if (ci->i_snap_realm) { 544 struct ceph_mds_client *mdsc = 545 ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc; 546 struct ceph_snap_realm *realm = ci->i_snap_realm; 547 548 dout(" dropping residual ref to snap realm %p\n", realm); 549 spin_lock(&realm->inodes_with_caps_lock); 550 list_del_init(&ci->i_snap_realm_item); 551 spin_unlock(&realm->inodes_with_caps_lock); 552 ceph_put_snap_realm(mdsc, realm); 553 } 554 555 kfree(ci->i_symlink); 556 while ((n = rb_first(&ci->i_fragtree)) != NULL) { 557 frag = rb_entry(n, struct ceph_inode_frag, node); 558 rb_erase(n, &ci->i_fragtree); 559 kfree(frag); 560 } 561 ci->i_fragtree_nsplits = 0; 562 563 __ceph_destroy_xattrs(ci); 564 if (ci->i_xattrs.blob) 565 ceph_buffer_put(ci->i_xattrs.blob); 566 if (ci->i_xattrs.prealloc_blob) 567 ceph_buffer_put(ci->i_xattrs.prealloc_blob); 568 569 ceph_put_string(rcu_dereference_raw(ci->i_layout.pool_ns)); 570 571 call_rcu(&inode->i_rcu, ceph_i_callback); 572 } 573 574 int ceph_drop_inode(struct inode *inode) 575 { 576 /* 577 * Positve dentry and corresponding inode are always accompanied 578 * in MDS reply. So no need to keep inode in the cache after 579 * dropping all its aliases. 580 */ 581 return 1; 582 } 583 584 static inline blkcnt_t calc_inode_blocks(u64 size) 585 { 586 return (size + (1<<9) - 1) >> 9; 587 } 588 589 /* 590 * Helpers to fill in size, ctime, mtime, and atime. We have to be 591 * careful because either the client or MDS may have more up to date 592 * info, depending on which capabilities are held, and whether 593 * time_warp_seq or truncate_seq have increased. (Ordinarily, mtime 594 * and size are monotonically increasing, except when utimes() or 595 * truncate() increments the corresponding _seq values.) 596 */ 597 int ceph_fill_file_size(struct inode *inode, int issued, 598 u32 truncate_seq, u64 truncate_size, u64 size) 599 { 600 struct ceph_inode_info *ci = ceph_inode(inode); 601 int queue_trunc = 0; 602 603 if (ceph_seq_cmp(truncate_seq, ci->i_truncate_seq) > 0 || 604 (truncate_seq == ci->i_truncate_seq && size > inode->i_size)) { 605 dout("size %lld -> %llu\n", inode->i_size, size); 606 if (size > 0 && S_ISDIR(inode->i_mode)) { 607 pr_err("fill_file_size non-zero size for directory\n"); 608 size = 0; 609 } 610 i_size_write(inode, size); 611 inode->i_blocks = calc_inode_blocks(size); 612 ci->i_reported_size = size; 613 if (truncate_seq != ci->i_truncate_seq) { 614 dout("truncate_seq %u -> %u\n", 615 ci->i_truncate_seq, truncate_seq); 616 ci->i_truncate_seq = truncate_seq; 617 618 /* the MDS should have revoked these caps */ 619 WARN_ON_ONCE(issued & (CEPH_CAP_FILE_EXCL | 620 CEPH_CAP_FILE_RD | 621 CEPH_CAP_FILE_WR | 622 CEPH_CAP_FILE_LAZYIO)); 623 /* 624 * If we hold relevant caps, or in the case where we're 625 * not the only client referencing this file and we 626 * don't hold those caps, then we need to check whether 627 * the file is either opened or mmaped 628 */ 629 if ((issued & (CEPH_CAP_FILE_CACHE| 630 CEPH_CAP_FILE_BUFFER)) || 631 mapping_mapped(inode->i_mapping) || 632 __ceph_caps_file_wanted(ci)) { 633 ci->i_truncate_pending++; 634 queue_trunc = 1; 635 } 636 } 637 } 638 if (ceph_seq_cmp(truncate_seq, ci->i_truncate_seq) >= 0 && 639 ci->i_truncate_size != truncate_size) { 640 dout("truncate_size %lld -> %llu\n", ci->i_truncate_size, 641 truncate_size); 642 ci->i_truncate_size = truncate_size; 643 } 644 645 if (queue_trunc) 646 ceph_fscache_invalidate(inode); 647 648 return queue_trunc; 649 } 650 651 void ceph_fill_file_time(struct inode *inode, int issued, 652 u64 time_warp_seq, struct timespec *ctime, 653 struct timespec *mtime, struct timespec *atime) 654 { 655 struct ceph_inode_info *ci = ceph_inode(inode); 656 int warn = 0; 657 658 if (issued & (CEPH_CAP_FILE_EXCL| 659 CEPH_CAP_FILE_WR| 660 CEPH_CAP_FILE_BUFFER| 661 CEPH_CAP_AUTH_EXCL| 662 CEPH_CAP_XATTR_EXCL)) { 663 if (timespec_compare(ctime, &inode->i_ctime) > 0) { 664 dout("ctime %ld.%09ld -> %ld.%09ld inc w/ cap\n", 665 inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec, 666 ctime->tv_sec, ctime->tv_nsec); 667 inode->i_ctime = *ctime; 668 } 669 if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) > 0) { 670 /* the MDS did a utimes() */ 671 dout("mtime %ld.%09ld -> %ld.%09ld " 672 "tw %d -> %d\n", 673 inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec, 674 mtime->tv_sec, mtime->tv_nsec, 675 ci->i_time_warp_seq, (int)time_warp_seq); 676 677 inode->i_mtime = *mtime; 678 inode->i_atime = *atime; 679 ci->i_time_warp_seq = time_warp_seq; 680 } else if (time_warp_seq == ci->i_time_warp_seq) { 681 /* nobody did utimes(); take the max */ 682 if (timespec_compare(mtime, &inode->i_mtime) > 0) { 683 dout("mtime %ld.%09ld -> %ld.%09ld inc\n", 684 inode->i_mtime.tv_sec, 685 inode->i_mtime.tv_nsec, 686 mtime->tv_sec, mtime->tv_nsec); 687 inode->i_mtime = *mtime; 688 } 689 if (timespec_compare(atime, &inode->i_atime) > 0) { 690 dout("atime %ld.%09ld -> %ld.%09ld inc\n", 691 inode->i_atime.tv_sec, 692 inode->i_atime.tv_nsec, 693 atime->tv_sec, atime->tv_nsec); 694 inode->i_atime = *atime; 695 } 696 } else if (issued & CEPH_CAP_FILE_EXCL) { 697 /* we did a utimes(); ignore mds values */ 698 } else { 699 warn = 1; 700 } 701 } else { 702 /* we have no write|excl caps; whatever the MDS says is true */ 703 if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) >= 0) { 704 inode->i_ctime = *ctime; 705 inode->i_mtime = *mtime; 706 inode->i_atime = *atime; 707 ci->i_time_warp_seq = time_warp_seq; 708 } else { 709 warn = 1; 710 } 711 } 712 if (warn) /* time_warp_seq shouldn't go backwards */ 713 dout("%p mds time_warp_seq %llu < %u\n", 714 inode, time_warp_seq, ci->i_time_warp_seq); 715 } 716 717 /* 718 * Populate an inode based on info from mds. May be called on new or 719 * existing inodes. 720 */ 721 static int fill_inode(struct inode *inode, struct page *locked_page, 722 struct ceph_mds_reply_info_in *iinfo, 723 struct ceph_mds_reply_dirfrag *dirinfo, 724 struct ceph_mds_session *session, 725 unsigned long ttl_from, int cap_fmode, 726 struct ceph_cap_reservation *caps_reservation) 727 { 728 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc; 729 struct ceph_mds_reply_inode *info = iinfo->in; 730 struct ceph_inode_info *ci = ceph_inode(inode); 731 int issued = 0, implemented, new_issued; 732 struct timespec mtime, atime, ctime; 733 struct ceph_buffer *xattr_blob = NULL; 734 struct ceph_string *pool_ns = NULL; 735 struct ceph_cap *new_cap = NULL; 736 int err = 0; 737 bool wake = false; 738 bool queue_trunc = false; 739 bool new_version = false; 740 bool fill_inline = false; 741 742 dout("fill_inode %p ino %llx.%llx v %llu had %llu\n", 743 inode, ceph_vinop(inode), le64_to_cpu(info->version), 744 ci->i_version); 745 746 /* prealloc new cap struct */ 747 if (info->cap.caps && ceph_snap(inode) == CEPH_NOSNAP) 748 new_cap = ceph_get_cap(mdsc, caps_reservation); 749 750 /* 751 * prealloc xattr data, if it looks like we'll need it. only 752 * if len > 4 (meaning there are actually xattrs; the first 4 753 * bytes are the xattr count). 754 */ 755 if (iinfo->xattr_len > 4) { 756 xattr_blob = ceph_buffer_new(iinfo->xattr_len, GFP_NOFS); 757 if (!xattr_blob) 758 pr_err("fill_inode ENOMEM xattr blob %d bytes\n", 759 iinfo->xattr_len); 760 } 761 762 if (iinfo->pool_ns_len > 0) 763 pool_ns = ceph_find_or_create_string(iinfo->pool_ns_data, 764 iinfo->pool_ns_len); 765 766 spin_lock(&ci->i_ceph_lock); 767 768 /* 769 * provided version will be odd if inode value is projected, 770 * even if stable. skip the update if we have newer stable 771 * info (ours>=theirs, e.g. due to racing mds replies), unless 772 * we are getting projected (unstable) info (in which case the 773 * version is odd, and we want ours>theirs). 774 * us them 775 * 2 2 skip 776 * 3 2 skip 777 * 3 3 update 778 */ 779 if (ci->i_version == 0 || 780 ((info->cap.flags & CEPH_CAP_FLAG_AUTH) && 781 le64_to_cpu(info->version) > (ci->i_version & ~1))) 782 new_version = true; 783 784 issued = __ceph_caps_issued(ci, &implemented); 785 issued |= implemented | __ceph_caps_dirty(ci); 786 new_issued = ~issued & le32_to_cpu(info->cap.caps); 787 788 /* update inode */ 789 ci->i_version = le64_to_cpu(info->version); 790 inode->i_version++; 791 inode->i_rdev = le32_to_cpu(info->rdev); 792 inode->i_blkbits = fls(le32_to_cpu(info->layout.fl_stripe_unit)) - 1; 793 794 if ((new_version || (new_issued & CEPH_CAP_AUTH_SHARED)) && 795 (issued & CEPH_CAP_AUTH_EXCL) == 0) { 796 inode->i_mode = le32_to_cpu(info->mode); 797 inode->i_uid = make_kuid(&init_user_ns, le32_to_cpu(info->uid)); 798 inode->i_gid = make_kgid(&init_user_ns, le32_to_cpu(info->gid)); 799 dout("%p mode 0%o uid.gid %d.%d\n", inode, inode->i_mode, 800 from_kuid(&init_user_ns, inode->i_uid), 801 from_kgid(&init_user_ns, inode->i_gid)); 802 } 803 804 if ((new_version || (new_issued & CEPH_CAP_LINK_SHARED)) && 805 (issued & CEPH_CAP_LINK_EXCL) == 0) 806 set_nlink(inode, le32_to_cpu(info->nlink)); 807 808 if (new_version || (new_issued & CEPH_CAP_ANY_RD)) { 809 /* be careful with mtime, atime, size */ 810 ceph_decode_timespec(&atime, &info->atime); 811 ceph_decode_timespec(&mtime, &info->mtime); 812 ceph_decode_timespec(&ctime, &info->ctime); 813 ceph_fill_file_time(inode, issued, 814 le32_to_cpu(info->time_warp_seq), 815 &ctime, &mtime, &atime); 816 } 817 818 if (new_version || 819 (new_issued & (CEPH_CAP_ANY_FILE_RD | CEPH_CAP_ANY_FILE_WR))) { 820 s64 old_pool = ci->i_layout.pool_id; 821 struct ceph_string *old_ns; 822 823 ceph_file_layout_from_legacy(&ci->i_layout, &info->layout); 824 old_ns = rcu_dereference_protected(ci->i_layout.pool_ns, 825 lockdep_is_held(&ci->i_ceph_lock)); 826 rcu_assign_pointer(ci->i_layout.pool_ns, pool_ns); 827 828 if (ci->i_layout.pool_id != old_pool || pool_ns != old_ns) 829 ci->i_ceph_flags &= ~CEPH_I_POOL_PERM; 830 831 pool_ns = old_ns; 832 833 queue_trunc = ceph_fill_file_size(inode, issued, 834 le32_to_cpu(info->truncate_seq), 835 le64_to_cpu(info->truncate_size), 836 le64_to_cpu(info->size)); 837 /* only update max_size on auth cap */ 838 if ((info->cap.flags & CEPH_CAP_FLAG_AUTH) && 839 ci->i_max_size != le64_to_cpu(info->max_size)) { 840 dout("max_size %lld -> %llu\n", ci->i_max_size, 841 le64_to_cpu(info->max_size)); 842 ci->i_max_size = le64_to_cpu(info->max_size); 843 } 844 } 845 846 /* xattrs */ 847 /* note that if i_xattrs.len <= 4, i_xattrs.data will still be NULL. */ 848 if ((ci->i_xattrs.version == 0 || !(issued & CEPH_CAP_XATTR_EXCL)) && 849 le64_to_cpu(info->xattr_version) > ci->i_xattrs.version) { 850 if (ci->i_xattrs.blob) 851 ceph_buffer_put(ci->i_xattrs.blob); 852 ci->i_xattrs.blob = xattr_blob; 853 if (xattr_blob) 854 memcpy(ci->i_xattrs.blob->vec.iov_base, 855 iinfo->xattr_data, iinfo->xattr_len); 856 ci->i_xattrs.version = le64_to_cpu(info->xattr_version); 857 ceph_forget_all_cached_acls(inode); 858 xattr_blob = NULL; 859 } 860 861 inode->i_mapping->a_ops = &ceph_aops; 862 863 switch (inode->i_mode & S_IFMT) { 864 case S_IFIFO: 865 case S_IFBLK: 866 case S_IFCHR: 867 case S_IFSOCK: 868 init_special_inode(inode, inode->i_mode, inode->i_rdev); 869 inode->i_op = &ceph_file_iops; 870 break; 871 case S_IFREG: 872 inode->i_op = &ceph_file_iops; 873 inode->i_fop = &ceph_file_fops; 874 break; 875 case S_IFLNK: 876 inode->i_op = &ceph_symlink_iops; 877 if (!ci->i_symlink) { 878 u32 symlen = iinfo->symlink_len; 879 char *sym; 880 881 spin_unlock(&ci->i_ceph_lock); 882 883 if (symlen != i_size_read(inode)) { 884 pr_err("fill_inode %llx.%llx BAD symlink " 885 "size %lld\n", ceph_vinop(inode), 886 i_size_read(inode)); 887 i_size_write(inode, symlen); 888 inode->i_blocks = calc_inode_blocks(symlen); 889 } 890 891 err = -ENOMEM; 892 sym = kstrndup(iinfo->symlink, symlen, GFP_NOFS); 893 if (!sym) 894 goto out; 895 896 spin_lock(&ci->i_ceph_lock); 897 if (!ci->i_symlink) 898 ci->i_symlink = sym; 899 else 900 kfree(sym); /* lost a race */ 901 } 902 inode->i_link = ci->i_symlink; 903 break; 904 case S_IFDIR: 905 inode->i_op = &ceph_dir_iops; 906 inode->i_fop = &ceph_dir_fops; 907 908 ci->i_dir_layout = iinfo->dir_layout; 909 910 ci->i_files = le64_to_cpu(info->files); 911 ci->i_subdirs = le64_to_cpu(info->subdirs); 912 ci->i_rbytes = le64_to_cpu(info->rbytes); 913 ci->i_rfiles = le64_to_cpu(info->rfiles); 914 ci->i_rsubdirs = le64_to_cpu(info->rsubdirs); 915 ceph_decode_timespec(&ci->i_rctime, &info->rctime); 916 break; 917 default: 918 pr_err("fill_inode %llx.%llx BAD mode 0%o\n", 919 ceph_vinop(inode), inode->i_mode); 920 } 921 922 /* were we issued a capability? */ 923 if (info->cap.caps) { 924 if (ceph_snap(inode) == CEPH_NOSNAP) { 925 unsigned caps = le32_to_cpu(info->cap.caps); 926 ceph_add_cap(inode, session, 927 le64_to_cpu(info->cap.cap_id), 928 cap_fmode, caps, 929 le32_to_cpu(info->cap.wanted), 930 le32_to_cpu(info->cap.seq), 931 le32_to_cpu(info->cap.mseq), 932 le64_to_cpu(info->cap.realm), 933 info->cap.flags, &new_cap); 934 935 /* set dir completion flag? */ 936 if (S_ISDIR(inode->i_mode) && 937 ci->i_files == 0 && ci->i_subdirs == 0 && 938 (caps & CEPH_CAP_FILE_SHARED) && 939 (issued & CEPH_CAP_FILE_EXCL) == 0 && 940 !__ceph_dir_is_complete(ci)) { 941 dout(" marking %p complete (empty)\n", inode); 942 i_size_write(inode, 0); 943 __ceph_dir_set_complete(ci, 944 atomic64_read(&ci->i_release_count), 945 atomic64_read(&ci->i_ordered_count)); 946 } 947 948 wake = true; 949 } else { 950 dout(" %p got snap_caps %s\n", inode, 951 ceph_cap_string(le32_to_cpu(info->cap.caps))); 952 ci->i_snap_caps |= le32_to_cpu(info->cap.caps); 953 if (cap_fmode >= 0) 954 __ceph_get_fmode(ci, cap_fmode); 955 } 956 } else if (cap_fmode >= 0) { 957 pr_warn("mds issued no caps on %llx.%llx\n", 958 ceph_vinop(inode)); 959 __ceph_get_fmode(ci, cap_fmode); 960 } 961 962 if (iinfo->inline_version > 0 && 963 iinfo->inline_version >= ci->i_inline_version) { 964 int cache_caps = CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_LAZYIO; 965 ci->i_inline_version = iinfo->inline_version; 966 if (ci->i_inline_version != CEPH_INLINE_NONE && 967 (locked_page || 968 (le32_to_cpu(info->cap.caps) & cache_caps))) 969 fill_inline = true; 970 } 971 972 spin_unlock(&ci->i_ceph_lock); 973 974 if (fill_inline) 975 ceph_fill_inline_data(inode, locked_page, 976 iinfo->inline_data, iinfo->inline_len); 977 978 if (wake) 979 wake_up_all(&ci->i_cap_wq); 980 981 /* queue truncate if we saw i_size decrease */ 982 if (queue_trunc) 983 ceph_queue_vmtruncate(inode); 984 985 /* populate frag tree */ 986 if (S_ISDIR(inode->i_mode)) 987 ceph_fill_fragtree(inode, &info->fragtree, dirinfo); 988 989 /* update delegation info? */ 990 if (dirinfo) 991 ceph_fill_dirfrag(inode, dirinfo); 992 993 err = 0; 994 out: 995 if (new_cap) 996 ceph_put_cap(mdsc, new_cap); 997 if (xattr_blob) 998 ceph_buffer_put(xattr_blob); 999 ceph_put_string(pool_ns); 1000 return err; 1001 } 1002 1003 /* 1004 * caller should hold session s_mutex. 1005 */ 1006 static void update_dentry_lease(struct dentry *dentry, 1007 struct ceph_mds_reply_lease *lease, 1008 struct ceph_mds_session *session, 1009 unsigned long from_time, 1010 struct ceph_vino *tgt_vino, 1011 struct ceph_vino *dir_vino) 1012 { 1013 struct ceph_dentry_info *di = ceph_dentry(dentry); 1014 long unsigned duration = le32_to_cpu(lease->duration_ms); 1015 long unsigned ttl = from_time + (duration * HZ) / 1000; 1016 long unsigned half_ttl = from_time + (duration * HZ / 2) / 1000; 1017 struct inode *dir; 1018 struct ceph_mds_session *old_lease_session = NULL; 1019 1020 /* 1021 * Make sure dentry's inode matches tgt_vino. NULL tgt_vino means that 1022 * we expect a negative dentry. 1023 */ 1024 if (!tgt_vino && d_really_is_positive(dentry)) 1025 return; 1026 1027 if (tgt_vino && (d_really_is_negative(dentry) || 1028 !ceph_ino_compare(d_inode(dentry), tgt_vino))) 1029 return; 1030 1031 spin_lock(&dentry->d_lock); 1032 dout("update_dentry_lease %p duration %lu ms ttl %lu\n", 1033 dentry, duration, ttl); 1034 1035 dir = d_inode(dentry->d_parent); 1036 1037 /* make sure parent matches dir_vino */ 1038 if (!ceph_ino_compare(dir, dir_vino)) 1039 goto out_unlock; 1040 1041 /* only track leases on regular dentries */ 1042 if (ceph_snap(dir) != CEPH_NOSNAP) 1043 goto out_unlock; 1044 1045 di->lease_shared_gen = ceph_inode(dir)->i_shared_gen; 1046 1047 if (duration == 0) 1048 goto out_unlock; 1049 1050 if (di->lease_gen == session->s_cap_gen && 1051 time_before(ttl, di->time)) 1052 goto out_unlock; /* we already have a newer lease. */ 1053 1054 if (di->lease_session && di->lease_session != session) { 1055 old_lease_session = di->lease_session; 1056 di->lease_session = NULL; 1057 } 1058 1059 ceph_dentry_lru_touch(dentry); 1060 1061 if (!di->lease_session) 1062 di->lease_session = ceph_get_mds_session(session); 1063 di->lease_gen = session->s_cap_gen; 1064 di->lease_seq = le32_to_cpu(lease->seq); 1065 di->lease_renew_after = half_ttl; 1066 di->lease_renew_from = 0; 1067 di->time = ttl; 1068 out_unlock: 1069 spin_unlock(&dentry->d_lock); 1070 if (old_lease_session) 1071 ceph_put_mds_session(old_lease_session); 1072 } 1073 1074 /* 1075 * splice a dentry to an inode. 1076 * caller must hold directory i_mutex for this to be safe. 1077 */ 1078 static struct dentry *splice_dentry(struct dentry *dn, struct inode *in) 1079 { 1080 struct dentry *realdn; 1081 1082 BUG_ON(d_inode(dn)); 1083 1084 /* dn must be unhashed */ 1085 if (!d_unhashed(dn)) 1086 d_drop(dn); 1087 realdn = d_splice_alias(in, dn); 1088 if (IS_ERR(realdn)) { 1089 pr_err("splice_dentry error %ld %p inode %p ino %llx.%llx\n", 1090 PTR_ERR(realdn), dn, in, ceph_vinop(in)); 1091 dn = realdn; /* note realdn contains the error */ 1092 goto out; 1093 } else if (realdn) { 1094 dout("dn %p (%d) spliced with %p (%d) " 1095 "inode %p ino %llx.%llx\n", 1096 dn, d_count(dn), 1097 realdn, d_count(realdn), 1098 d_inode(realdn), ceph_vinop(d_inode(realdn))); 1099 dput(dn); 1100 dn = realdn; 1101 } else { 1102 BUG_ON(!ceph_dentry(dn)); 1103 dout("dn %p attached to %p ino %llx.%llx\n", 1104 dn, d_inode(dn), ceph_vinop(d_inode(dn))); 1105 } 1106 out: 1107 return dn; 1108 } 1109 1110 /* 1111 * Incorporate results into the local cache. This is either just 1112 * one inode, or a directory, dentry, and possibly linked-to inode (e.g., 1113 * after a lookup). 1114 * 1115 * A reply may contain 1116 * a directory inode along with a dentry. 1117 * and/or a target inode 1118 * 1119 * Called with snap_rwsem (read). 1120 */ 1121 int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req) 1122 { 1123 struct ceph_mds_session *session = req->r_session; 1124 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info; 1125 struct inode *in = NULL; 1126 struct ceph_vino tvino, dvino; 1127 struct ceph_fs_client *fsc = ceph_sb_to_client(sb); 1128 int err = 0; 1129 1130 dout("fill_trace %p is_dentry %d is_target %d\n", req, 1131 rinfo->head->is_dentry, rinfo->head->is_target); 1132 1133 if (!rinfo->head->is_target && !rinfo->head->is_dentry) { 1134 dout("fill_trace reply is empty!\n"); 1135 if (rinfo->head->result == 0 && req->r_parent) 1136 ceph_invalidate_dir_request(req); 1137 return 0; 1138 } 1139 1140 if (rinfo->head->is_dentry) { 1141 struct inode *dir = req->r_parent; 1142 1143 if (dir) { 1144 err = fill_inode(dir, NULL, 1145 &rinfo->diri, rinfo->dirfrag, 1146 session, req->r_request_started, -1, 1147 &req->r_caps_reservation); 1148 if (err < 0) 1149 goto done; 1150 } else { 1151 WARN_ON_ONCE(1); 1152 } 1153 1154 if (dir && req->r_op == CEPH_MDS_OP_LOOKUPNAME) { 1155 struct qstr dname; 1156 struct dentry *dn, *parent; 1157 1158 BUG_ON(!rinfo->head->is_target); 1159 BUG_ON(req->r_dentry); 1160 1161 parent = d_find_any_alias(dir); 1162 BUG_ON(!parent); 1163 1164 dname.name = rinfo->dname; 1165 dname.len = rinfo->dname_len; 1166 dname.hash = full_name_hash(parent, dname.name, dname.len); 1167 tvino.ino = le64_to_cpu(rinfo->targeti.in->ino); 1168 tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid); 1169 retry_lookup: 1170 dn = d_lookup(parent, &dname); 1171 dout("d_lookup on parent=%p name=%.*s got %p\n", 1172 parent, dname.len, dname.name, dn); 1173 1174 if (!dn) { 1175 dn = d_alloc(parent, &dname); 1176 dout("d_alloc %p '%.*s' = %p\n", parent, 1177 dname.len, dname.name, dn); 1178 if (!dn) { 1179 dput(parent); 1180 err = -ENOMEM; 1181 goto done; 1182 } 1183 err = 0; 1184 } else if (d_really_is_positive(dn) && 1185 (ceph_ino(d_inode(dn)) != tvino.ino || 1186 ceph_snap(d_inode(dn)) != tvino.snap)) { 1187 dout(" dn %p points to wrong inode %p\n", 1188 dn, d_inode(dn)); 1189 d_delete(dn); 1190 dput(dn); 1191 goto retry_lookup; 1192 } 1193 1194 req->r_dentry = dn; 1195 dput(parent); 1196 } 1197 } 1198 1199 if (rinfo->head->is_target) { 1200 tvino.ino = le64_to_cpu(rinfo->targeti.in->ino); 1201 tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid); 1202 1203 in = ceph_get_inode(sb, tvino); 1204 if (IS_ERR(in)) { 1205 err = PTR_ERR(in); 1206 goto done; 1207 } 1208 req->r_target_inode = in; 1209 1210 err = fill_inode(in, req->r_locked_page, &rinfo->targeti, NULL, 1211 session, req->r_request_started, 1212 (!test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) && 1213 rinfo->head->result == 0) ? req->r_fmode : -1, 1214 &req->r_caps_reservation); 1215 if (err < 0) { 1216 pr_err("fill_inode badness %p %llx.%llx\n", 1217 in, ceph_vinop(in)); 1218 goto done; 1219 } 1220 } 1221 1222 /* 1223 * ignore null lease/binding on snapdir ENOENT, or else we 1224 * will have trouble splicing in the virtual snapdir later 1225 */ 1226 if (rinfo->head->is_dentry && 1227 !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) && 1228 test_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags) && 1229 (rinfo->head->is_target || strncmp(req->r_dentry->d_name.name, 1230 fsc->mount_options->snapdir_name, 1231 req->r_dentry->d_name.len))) { 1232 /* 1233 * lookup link rename : null -> possibly existing inode 1234 * mknod symlink mkdir : null -> new inode 1235 * unlink : linked -> null 1236 */ 1237 struct inode *dir = req->r_parent; 1238 struct dentry *dn = req->r_dentry; 1239 bool have_dir_cap, have_lease; 1240 1241 BUG_ON(!dn); 1242 BUG_ON(!dir); 1243 BUG_ON(d_inode(dn->d_parent) != dir); 1244 1245 dvino.ino = le64_to_cpu(rinfo->diri.in->ino); 1246 dvino.snap = le64_to_cpu(rinfo->diri.in->snapid); 1247 1248 BUG_ON(ceph_ino(dir) != dvino.ino); 1249 BUG_ON(ceph_snap(dir) != dvino.snap); 1250 1251 /* do we have a lease on the whole dir? */ 1252 have_dir_cap = 1253 (le32_to_cpu(rinfo->diri.in->cap.caps) & 1254 CEPH_CAP_FILE_SHARED); 1255 1256 /* do we have a dn lease? */ 1257 have_lease = have_dir_cap || 1258 le32_to_cpu(rinfo->dlease->duration_ms); 1259 if (!have_lease) 1260 dout("fill_trace no dentry lease or dir cap\n"); 1261 1262 /* rename? */ 1263 if (req->r_old_dentry && req->r_op == CEPH_MDS_OP_RENAME) { 1264 struct inode *olddir = req->r_old_dentry_dir; 1265 BUG_ON(!olddir); 1266 1267 dout(" src %p '%pd' dst %p '%pd'\n", 1268 req->r_old_dentry, 1269 req->r_old_dentry, 1270 dn, dn); 1271 dout("fill_trace doing d_move %p -> %p\n", 1272 req->r_old_dentry, dn); 1273 1274 /* d_move screws up sibling dentries' offsets */ 1275 ceph_dir_clear_ordered(dir); 1276 ceph_dir_clear_ordered(olddir); 1277 1278 d_move(req->r_old_dentry, dn); 1279 dout(" src %p '%pd' dst %p '%pd'\n", 1280 req->r_old_dentry, 1281 req->r_old_dentry, 1282 dn, dn); 1283 1284 /* ensure target dentry is invalidated, despite 1285 rehashing bug in vfs_rename_dir */ 1286 ceph_invalidate_dentry_lease(dn); 1287 1288 dout("dn %p gets new offset %lld\n", req->r_old_dentry, 1289 ceph_dentry(req->r_old_dentry)->offset); 1290 1291 dn = req->r_old_dentry; /* use old_dentry */ 1292 } 1293 1294 /* null dentry? */ 1295 if (!rinfo->head->is_target) { 1296 dout("fill_trace null dentry\n"); 1297 if (d_really_is_positive(dn)) { 1298 ceph_dir_clear_ordered(dir); 1299 dout("d_delete %p\n", dn); 1300 d_delete(dn); 1301 } else if (have_lease) { 1302 if (d_unhashed(dn)) 1303 d_add(dn, NULL); 1304 update_dentry_lease(dn, rinfo->dlease, 1305 session, 1306 req->r_request_started, 1307 NULL, &dvino); 1308 } 1309 goto done; 1310 } 1311 1312 /* attach proper inode */ 1313 if (d_really_is_negative(dn)) { 1314 ceph_dir_clear_ordered(dir); 1315 ihold(in); 1316 dn = splice_dentry(dn, in); 1317 if (IS_ERR(dn)) { 1318 err = PTR_ERR(dn); 1319 goto done; 1320 } 1321 req->r_dentry = dn; /* may have spliced */ 1322 } else if (d_really_is_positive(dn) && d_inode(dn) != in) { 1323 dout(" %p links to %p %llx.%llx, not %llx.%llx\n", 1324 dn, d_inode(dn), ceph_vinop(d_inode(dn)), 1325 ceph_vinop(in)); 1326 d_invalidate(dn); 1327 have_lease = false; 1328 } 1329 1330 if (have_lease) { 1331 tvino.ino = le64_to_cpu(rinfo->targeti.in->ino); 1332 tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid); 1333 update_dentry_lease(dn, rinfo->dlease, session, 1334 req->r_request_started, 1335 &tvino, &dvino); 1336 } 1337 dout(" final dn %p\n", dn); 1338 } else if ((req->r_op == CEPH_MDS_OP_LOOKUPSNAP || 1339 req->r_op == CEPH_MDS_OP_MKSNAP) && 1340 !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) { 1341 struct dentry *dn = req->r_dentry; 1342 struct inode *dir = req->r_parent; 1343 1344 /* fill out a snapdir LOOKUPSNAP dentry */ 1345 BUG_ON(!dn); 1346 BUG_ON(!dir); 1347 BUG_ON(ceph_snap(dir) != CEPH_SNAPDIR); 1348 dout(" linking snapped dir %p to dn %p\n", in, dn); 1349 ceph_dir_clear_ordered(dir); 1350 ihold(in); 1351 dn = splice_dentry(dn, in); 1352 if (IS_ERR(dn)) { 1353 err = PTR_ERR(dn); 1354 goto done; 1355 } 1356 req->r_dentry = dn; /* may have spliced */ 1357 } else if (rinfo->head->is_dentry) { 1358 struct ceph_vino *ptvino = NULL; 1359 1360 if ((le32_to_cpu(rinfo->diri.in->cap.caps) & CEPH_CAP_FILE_SHARED) || 1361 le32_to_cpu(rinfo->dlease->duration_ms)) { 1362 dvino.ino = le64_to_cpu(rinfo->diri.in->ino); 1363 dvino.snap = le64_to_cpu(rinfo->diri.in->snapid); 1364 1365 if (rinfo->head->is_target) { 1366 tvino.ino = le64_to_cpu(rinfo->targeti.in->ino); 1367 tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid); 1368 ptvino = &tvino; 1369 } 1370 1371 update_dentry_lease(req->r_dentry, rinfo->dlease, 1372 session, req->r_request_started, ptvino, 1373 &dvino); 1374 } else { 1375 dout("%s: no dentry lease or dir cap\n", __func__); 1376 } 1377 } 1378 done: 1379 dout("fill_trace done err=%d\n", err); 1380 return err; 1381 } 1382 1383 /* 1384 * Prepopulate our cache with readdir results, leases, etc. 1385 */ 1386 static int readdir_prepopulate_inodes_only(struct ceph_mds_request *req, 1387 struct ceph_mds_session *session) 1388 { 1389 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info; 1390 int i, err = 0; 1391 1392 for (i = 0; i < rinfo->dir_nr; i++) { 1393 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i; 1394 struct ceph_vino vino; 1395 struct inode *in; 1396 int rc; 1397 1398 vino.ino = le64_to_cpu(rde->inode.in->ino); 1399 vino.snap = le64_to_cpu(rde->inode.in->snapid); 1400 1401 in = ceph_get_inode(req->r_dentry->d_sb, vino); 1402 if (IS_ERR(in)) { 1403 err = PTR_ERR(in); 1404 dout("new_inode badness got %d\n", err); 1405 continue; 1406 } 1407 rc = fill_inode(in, NULL, &rde->inode, NULL, session, 1408 req->r_request_started, -1, 1409 &req->r_caps_reservation); 1410 if (rc < 0) { 1411 pr_err("fill_inode badness on %p got %d\n", in, rc); 1412 err = rc; 1413 } 1414 iput(in); 1415 } 1416 1417 return err; 1418 } 1419 1420 void ceph_readdir_cache_release(struct ceph_readdir_cache_control *ctl) 1421 { 1422 if (ctl->page) { 1423 kunmap(ctl->page); 1424 put_page(ctl->page); 1425 ctl->page = NULL; 1426 } 1427 } 1428 1429 static int fill_readdir_cache(struct inode *dir, struct dentry *dn, 1430 struct ceph_readdir_cache_control *ctl, 1431 struct ceph_mds_request *req) 1432 { 1433 struct ceph_inode_info *ci = ceph_inode(dir); 1434 unsigned nsize = PAGE_SIZE / sizeof(struct dentry*); 1435 unsigned idx = ctl->index % nsize; 1436 pgoff_t pgoff = ctl->index / nsize; 1437 1438 if (!ctl->page || pgoff != page_index(ctl->page)) { 1439 ceph_readdir_cache_release(ctl); 1440 if (idx == 0) 1441 ctl->page = grab_cache_page(&dir->i_data, pgoff); 1442 else 1443 ctl->page = find_lock_page(&dir->i_data, pgoff); 1444 if (!ctl->page) { 1445 ctl->index = -1; 1446 return idx == 0 ? -ENOMEM : 0; 1447 } 1448 /* reading/filling the cache are serialized by 1449 * i_mutex, no need to use page lock */ 1450 unlock_page(ctl->page); 1451 ctl->dentries = kmap(ctl->page); 1452 if (idx == 0) 1453 memset(ctl->dentries, 0, PAGE_SIZE); 1454 } 1455 1456 if (req->r_dir_release_cnt == atomic64_read(&ci->i_release_count) && 1457 req->r_dir_ordered_cnt == atomic64_read(&ci->i_ordered_count)) { 1458 dout("readdir cache dn %p idx %d\n", dn, ctl->index); 1459 ctl->dentries[idx] = dn; 1460 ctl->index++; 1461 } else { 1462 dout("disable readdir cache\n"); 1463 ctl->index = -1; 1464 } 1465 return 0; 1466 } 1467 1468 int ceph_readdir_prepopulate(struct ceph_mds_request *req, 1469 struct ceph_mds_session *session) 1470 { 1471 struct dentry *parent = req->r_dentry; 1472 struct ceph_inode_info *ci = ceph_inode(d_inode(parent)); 1473 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info; 1474 struct qstr dname; 1475 struct dentry *dn; 1476 struct inode *in; 1477 int err = 0, skipped = 0, ret, i; 1478 struct ceph_mds_request_head *rhead = req->r_request->front.iov_base; 1479 u32 frag = le32_to_cpu(rhead->args.readdir.frag); 1480 u32 last_hash = 0; 1481 u32 fpos_offset; 1482 struct ceph_readdir_cache_control cache_ctl = {}; 1483 1484 if (test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) 1485 return readdir_prepopulate_inodes_only(req, session); 1486 1487 if (rinfo->hash_order) { 1488 if (req->r_path2) { 1489 last_hash = ceph_str_hash(ci->i_dir_layout.dl_dir_hash, 1490 req->r_path2, 1491 strlen(req->r_path2)); 1492 last_hash = ceph_frag_value(last_hash); 1493 } else if (rinfo->offset_hash) { 1494 /* mds understands offset_hash */ 1495 WARN_ON_ONCE(req->r_readdir_offset != 2); 1496 last_hash = le32_to_cpu(rhead->args.readdir.offset_hash); 1497 } 1498 } 1499 1500 if (rinfo->dir_dir && 1501 le32_to_cpu(rinfo->dir_dir->frag) != frag) { 1502 dout("readdir_prepopulate got new frag %x -> %x\n", 1503 frag, le32_to_cpu(rinfo->dir_dir->frag)); 1504 frag = le32_to_cpu(rinfo->dir_dir->frag); 1505 if (!rinfo->hash_order) 1506 req->r_readdir_offset = 2; 1507 } 1508 1509 if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) { 1510 dout("readdir_prepopulate %d items under SNAPDIR dn %p\n", 1511 rinfo->dir_nr, parent); 1512 } else { 1513 dout("readdir_prepopulate %d items under dn %p\n", 1514 rinfo->dir_nr, parent); 1515 if (rinfo->dir_dir) 1516 ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir); 1517 1518 if (ceph_frag_is_leftmost(frag) && 1519 req->r_readdir_offset == 2 && 1520 !(rinfo->hash_order && last_hash)) { 1521 /* note dir version at start of readdir so we can 1522 * tell if any dentries get dropped */ 1523 req->r_dir_release_cnt = 1524 atomic64_read(&ci->i_release_count); 1525 req->r_dir_ordered_cnt = 1526 atomic64_read(&ci->i_ordered_count); 1527 req->r_readdir_cache_idx = 0; 1528 } 1529 } 1530 1531 cache_ctl.index = req->r_readdir_cache_idx; 1532 fpos_offset = req->r_readdir_offset; 1533 1534 /* FIXME: release caps/leases if error occurs */ 1535 for (i = 0; i < rinfo->dir_nr; i++) { 1536 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i; 1537 struct ceph_vino tvino, dvino; 1538 1539 dname.name = rde->name; 1540 dname.len = rde->name_len; 1541 dname.hash = full_name_hash(parent, dname.name, dname.len); 1542 1543 tvino.ino = le64_to_cpu(rde->inode.in->ino); 1544 tvino.snap = le64_to_cpu(rde->inode.in->snapid); 1545 1546 if (rinfo->hash_order) { 1547 u32 hash = ceph_str_hash(ci->i_dir_layout.dl_dir_hash, 1548 rde->name, rde->name_len); 1549 hash = ceph_frag_value(hash); 1550 if (hash != last_hash) 1551 fpos_offset = 2; 1552 last_hash = hash; 1553 rde->offset = ceph_make_fpos(hash, fpos_offset++, true); 1554 } else { 1555 rde->offset = ceph_make_fpos(frag, fpos_offset++, false); 1556 } 1557 1558 retry_lookup: 1559 dn = d_lookup(parent, &dname); 1560 dout("d_lookup on parent=%p name=%.*s got %p\n", 1561 parent, dname.len, dname.name, dn); 1562 1563 if (!dn) { 1564 dn = d_alloc(parent, &dname); 1565 dout("d_alloc %p '%.*s' = %p\n", parent, 1566 dname.len, dname.name, dn); 1567 if (!dn) { 1568 dout("d_alloc badness\n"); 1569 err = -ENOMEM; 1570 goto out; 1571 } 1572 } else if (d_really_is_positive(dn) && 1573 (ceph_ino(d_inode(dn)) != tvino.ino || 1574 ceph_snap(d_inode(dn)) != tvino.snap)) { 1575 dout(" dn %p points to wrong inode %p\n", 1576 dn, d_inode(dn)); 1577 d_delete(dn); 1578 dput(dn); 1579 goto retry_lookup; 1580 } 1581 1582 /* inode */ 1583 if (d_really_is_positive(dn)) { 1584 in = d_inode(dn); 1585 } else { 1586 in = ceph_get_inode(parent->d_sb, tvino); 1587 if (IS_ERR(in)) { 1588 dout("new_inode badness\n"); 1589 d_drop(dn); 1590 dput(dn); 1591 err = PTR_ERR(in); 1592 goto out; 1593 } 1594 } 1595 1596 ret = fill_inode(in, NULL, &rde->inode, NULL, session, 1597 req->r_request_started, -1, 1598 &req->r_caps_reservation); 1599 if (ret < 0) { 1600 pr_err("fill_inode badness on %p\n", in); 1601 if (d_really_is_negative(dn)) 1602 iput(in); 1603 d_drop(dn); 1604 err = ret; 1605 goto next_item; 1606 } 1607 1608 if (d_really_is_negative(dn)) { 1609 struct dentry *realdn; 1610 1611 if (ceph_security_xattr_deadlock(in)) { 1612 dout(" skip splicing dn %p to inode %p" 1613 " (security xattr deadlock)\n", dn, in); 1614 iput(in); 1615 skipped++; 1616 goto next_item; 1617 } 1618 1619 realdn = splice_dentry(dn, in); 1620 if (IS_ERR(realdn)) { 1621 err = PTR_ERR(realdn); 1622 d_drop(dn); 1623 dn = NULL; 1624 goto next_item; 1625 } 1626 dn = realdn; 1627 } 1628 1629 ceph_dentry(dn)->offset = rde->offset; 1630 1631 dvino = ceph_vino(d_inode(parent)); 1632 update_dentry_lease(dn, rde->lease, req->r_session, 1633 req->r_request_started, &tvino, &dvino); 1634 1635 if (err == 0 && skipped == 0 && cache_ctl.index >= 0) { 1636 ret = fill_readdir_cache(d_inode(parent), dn, 1637 &cache_ctl, req); 1638 if (ret < 0) 1639 err = ret; 1640 } 1641 next_item: 1642 if (dn) 1643 dput(dn); 1644 } 1645 out: 1646 if (err == 0 && skipped == 0) { 1647 set_bit(CEPH_MDS_R_DID_PREPOPULATE, &req->r_req_flags); 1648 req->r_readdir_cache_idx = cache_ctl.index; 1649 } 1650 ceph_readdir_cache_release(&cache_ctl); 1651 dout("readdir_prepopulate done\n"); 1652 return err; 1653 } 1654 1655 bool ceph_inode_set_size(struct inode *inode, loff_t size) 1656 { 1657 struct ceph_inode_info *ci = ceph_inode(inode); 1658 bool ret; 1659 1660 spin_lock(&ci->i_ceph_lock); 1661 dout("set_size %p %llu -> %llu\n", inode, inode->i_size, size); 1662 i_size_write(inode, size); 1663 inode->i_blocks = calc_inode_blocks(size); 1664 1665 ret = __ceph_should_report_size(ci); 1666 1667 spin_unlock(&ci->i_ceph_lock); 1668 return ret; 1669 } 1670 1671 /* 1672 * Write back inode data in a worker thread. (This can't be done 1673 * in the message handler context.) 1674 */ 1675 void ceph_queue_writeback(struct inode *inode) 1676 { 1677 ihold(inode); 1678 if (queue_work(ceph_inode_to_client(inode)->wb_wq, 1679 &ceph_inode(inode)->i_wb_work)) { 1680 dout("ceph_queue_writeback %p\n", inode); 1681 } else { 1682 dout("ceph_queue_writeback %p failed\n", inode); 1683 iput(inode); 1684 } 1685 } 1686 1687 static void ceph_writeback_work(struct work_struct *work) 1688 { 1689 struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, 1690 i_wb_work); 1691 struct inode *inode = &ci->vfs_inode; 1692 1693 dout("writeback %p\n", inode); 1694 filemap_fdatawrite(&inode->i_data); 1695 iput(inode); 1696 } 1697 1698 /* 1699 * queue an async invalidation 1700 */ 1701 void ceph_queue_invalidate(struct inode *inode) 1702 { 1703 ihold(inode); 1704 if (queue_work(ceph_inode_to_client(inode)->pg_inv_wq, 1705 &ceph_inode(inode)->i_pg_inv_work)) { 1706 dout("ceph_queue_invalidate %p\n", inode); 1707 } else { 1708 dout("ceph_queue_invalidate %p failed\n", inode); 1709 iput(inode); 1710 } 1711 } 1712 1713 /* 1714 * Invalidate inode pages in a worker thread. (This can't be done 1715 * in the message handler context.) 1716 */ 1717 static void ceph_invalidate_work(struct work_struct *work) 1718 { 1719 struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, 1720 i_pg_inv_work); 1721 struct inode *inode = &ci->vfs_inode; 1722 struct ceph_fs_client *fsc = ceph_inode_to_client(inode); 1723 u32 orig_gen; 1724 int check = 0; 1725 1726 mutex_lock(&ci->i_truncate_mutex); 1727 1728 if (READ_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) { 1729 pr_warn_ratelimited("invalidate_pages %p %lld forced umount\n", 1730 inode, ceph_ino(inode)); 1731 mapping_set_error(inode->i_mapping, -EIO); 1732 truncate_pagecache(inode, 0); 1733 mutex_unlock(&ci->i_truncate_mutex); 1734 goto out; 1735 } 1736 1737 spin_lock(&ci->i_ceph_lock); 1738 dout("invalidate_pages %p gen %d revoking %d\n", inode, 1739 ci->i_rdcache_gen, ci->i_rdcache_revoking); 1740 if (ci->i_rdcache_revoking != ci->i_rdcache_gen) { 1741 if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE)) 1742 check = 1; 1743 spin_unlock(&ci->i_ceph_lock); 1744 mutex_unlock(&ci->i_truncate_mutex); 1745 goto out; 1746 } 1747 orig_gen = ci->i_rdcache_gen; 1748 spin_unlock(&ci->i_ceph_lock); 1749 1750 if (invalidate_inode_pages2(inode->i_mapping) < 0) { 1751 pr_err("invalidate_pages %p fails\n", inode); 1752 } 1753 1754 spin_lock(&ci->i_ceph_lock); 1755 if (orig_gen == ci->i_rdcache_gen && 1756 orig_gen == ci->i_rdcache_revoking) { 1757 dout("invalidate_pages %p gen %d successful\n", inode, 1758 ci->i_rdcache_gen); 1759 ci->i_rdcache_revoking--; 1760 check = 1; 1761 } else { 1762 dout("invalidate_pages %p gen %d raced, now %d revoking %d\n", 1763 inode, orig_gen, ci->i_rdcache_gen, 1764 ci->i_rdcache_revoking); 1765 if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE)) 1766 check = 1; 1767 } 1768 spin_unlock(&ci->i_ceph_lock); 1769 mutex_unlock(&ci->i_truncate_mutex); 1770 out: 1771 if (check) 1772 ceph_check_caps(ci, 0, NULL); 1773 iput(inode); 1774 } 1775 1776 1777 /* 1778 * called by trunc_wq; 1779 * 1780 * We also truncate in a separate thread as well. 1781 */ 1782 static void ceph_vmtruncate_work(struct work_struct *work) 1783 { 1784 struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, 1785 i_vmtruncate_work); 1786 struct inode *inode = &ci->vfs_inode; 1787 1788 dout("vmtruncate_work %p\n", inode); 1789 __ceph_do_pending_vmtruncate(inode); 1790 iput(inode); 1791 } 1792 1793 /* 1794 * Queue an async vmtruncate. If we fail to queue work, we will handle 1795 * the truncation the next time we call __ceph_do_pending_vmtruncate. 1796 */ 1797 void ceph_queue_vmtruncate(struct inode *inode) 1798 { 1799 struct ceph_inode_info *ci = ceph_inode(inode); 1800 1801 ihold(inode); 1802 1803 if (queue_work(ceph_sb_to_client(inode->i_sb)->trunc_wq, 1804 &ci->i_vmtruncate_work)) { 1805 dout("ceph_queue_vmtruncate %p\n", inode); 1806 } else { 1807 dout("ceph_queue_vmtruncate %p failed, pending=%d\n", 1808 inode, ci->i_truncate_pending); 1809 iput(inode); 1810 } 1811 } 1812 1813 /* 1814 * Make sure any pending truncation is applied before doing anything 1815 * that may depend on it. 1816 */ 1817 void __ceph_do_pending_vmtruncate(struct inode *inode) 1818 { 1819 struct ceph_inode_info *ci = ceph_inode(inode); 1820 u64 to; 1821 int wrbuffer_refs, finish = 0; 1822 1823 mutex_lock(&ci->i_truncate_mutex); 1824 retry: 1825 spin_lock(&ci->i_ceph_lock); 1826 if (ci->i_truncate_pending == 0) { 1827 dout("__do_pending_vmtruncate %p none pending\n", inode); 1828 spin_unlock(&ci->i_ceph_lock); 1829 mutex_unlock(&ci->i_truncate_mutex); 1830 return; 1831 } 1832 1833 /* 1834 * make sure any dirty snapped pages are flushed before we 1835 * possibly truncate them.. so write AND block! 1836 */ 1837 if (ci->i_wrbuffer_ref_head < ci->i_wrbuffer_ref) { 1838 struct ceph_cap_snap *capsnap; 1839 to = ci->i_truncate_size; 1840 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) { 1841 // MDS should have revoked Frw caps 1842 WARN_ON_ONCE(capsnap->writing); 1843 if (capsnap->dirty_pages && capsnap->size > to) 1844 to = capsnap->size; 1845 } 1846 spin_unlock(&ci->i_ceph_lock); 1847 dout("__do_pending_vmtruncate %p flushing snaps first\n", 1848 inode); 1849 1850 truncate_pagecache(inode, to); 1851 1852 filemap_write_and_wait_range(&inode->i_data, 0, 1853 inode->i_sb->s_maxbytes); 1854 goto retry; 1855 } 1856 1857 /* there should be no reader or writer */ 1858 WARN_ON_ONCE(ci->i_rd_ref || ci->i_wr_ref); 1859 1860 to = ci->i_truncate_size; 1861 wrbuffer_refs = ci->i_wrbuffer_ref; 1862 dout("__do_pending_vmtruncate %p (%d) to %lld\n", inode, 1863 ci->i_truncate_pending, to); 1864 spin_unlock(&ci->i_ceph_lock); 1865 1866 truncate_pagecache(inode, to); 1867 1868 spin_lock(&ci->i_ceph_lock); 1869 if (to == ci->i_truncate_size) { 1870 ci->i_truncate_pending = 0; 1871 finish = 1; 1872 } 1873 spin_unlock(&ci->i_ceph_lock); 1874 if (!finish) 1875 goto retry; 1876 1877 mutex_unlock(&ci->i_truncate_mutex); 1878 1879 if (wrbuffer_refs == 0) 1880 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL); 1881 1882 wake_up_all(&ci->i_cap_wq); 1883 } 1884 1885 /* 1886 * symlinks 1887 */ 1888 static const struct inode_operations ceph_symlink_iops = { 1889 .get_link = simple_get_link, 1890 .setattr = ceph_setattr, 1891 .getattr = ceph_getattr, 1892 .listxattr = ceph_listxattr, 1893 }; 1894 1895 int __ceph_setattr(struct inode *inode, struct iattr *attr) 1896 { 1897 struct ceph_inode_info *ci = ceph_inode(inode); 1898 const unsigned int ia_valid = attr->ia_valid; 1899 struct ceph_mds_request *req; 1900 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc; 1901 struct ceph_cap_flush *prealloc_cf; 1902 int issued; 1903 int release = 0, dirtied = 0; 1904 int mask = 0; 1905 int err = 0; 1906 int inode_dirty_flags = 0; 1907 bool lock_snap_rwsem = false; 1908 1909 prealloc_cf = ceph_alloc_cap_flush(); 1910 if (!prealloc_cf) 1911 return -ENOMEM; 1912 1913 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETATTR, 1914 USE_AUTH_MDS); 1915 if (IS_ERR(req)) { 1916 ceph_free_cap_flush(prealloc_cf); 1917 return PTR_ERR(req); 1918 } 1919 1920 spin_lock(&ci->i_ceph_lock); 1921 issued = __ceph_caps_issued(ci, NULL); 1922 1923 if (!ci->i_head_snapc && 1924 (issued & (CEPH_CAP_ANY_EXCL | CEPH_CAP_FILE_WR))) { 1925 lock_snap_rwsem = true; 1926 if (!down_read_trylock(&mdsc->snap_rwsem)) { 1927 spin_unlock(&ci->i_ceph_lock); 1928 down_read(&mdsc->snap_rwsem); 1929 spin_lock(&ci->i_ceph_lock); 1930 issued = __ceph_caps_issued(ci, NULL); 1931 } 1932 } 1933 1934 dout("setattr %p issued %s\n", inode, ceph_cap_string(issued)); 1935 1936 if (ia_valid & ATTR_UID) { 1937 dout("setattr %p uid %d -> %d\n", inode, 1938 from_kuid(&init_user_ns, inode->i_uid), 1939 from_kuid(&init_user_ns, attr->ia_uid)); 1940 if (issued & CEPH_CAP_AUTH_EXCL) { 1941 inode->i_uid = attr->ia_uid; 1942 dirtied |= CEPH_CAP_AUTH_EXCL; 1943 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 || 1944 !uid_eq(attr->ia_uid, inode->i_uid)) { 1945 req->r_args.setattr.uid = cpu_to_le32( 1946 from_kuid(&init_user_ns, attr->ia_uid)); 1947 mask |= CEPH_SETATTR_UID; 1948 release |= CEPH_CAP_AUTH_SHARED; 1949 } 1950 } 1951 if (ia_valid & ATTR_GID) { 1952 dout("setattr %p gid %d -> %d\n", inode, 1953 from_kgid(&init_user_ns, inode->i_gid), 1954 from_kgid(&init_user_ns, attr->ia_gid)); 1955 if (issued & CEPH_CAP_AUTH_EXCL) { 1956 inode->i_gid = attr->ia_gid; 1957 dirtied |= CEPH_CAP_AUTH_EXCL; 1958 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 || 1959 !gid_eq(attr->ia_gid, inode->i_gid)) { 1960 req->r_args.setattr.gid = cpu_to_le32( 1961 from_kgid(&init_user_ns, attr->ia_gid)); 1962 mask |= CEPH_SETATTR_GID; 1963 release |= CEPH_CAP_AUTH_SHARED; 1964 } 1965 } 1966 if (ia_valid & ATTR_MODE) { 1967 dout("setattr %p mode 0%o -> 0%o\n", inode, inode->i_mode, 1968 attr->ia_mode); 1969 if (issued & CEPH_CAP_AUTH_EXCL) { 1970 inode->i_mode = attr->ia_mode; 1971 dirtied |= CEPH_CAP_AUTH_EXCL; 1972 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 || 1973 attr->ia_mode != inode->i_mode) { 1974 inode->i_mode = attr->ia_mode; 1975 req->r_args.setattr.mode = cpu_to_le32(attr->ia_mode); 1976 mask |= CEPH_SETATTR_MODE; 1977 release |= CEPH_CAP_AUTH_SHARED; 1978 } 1979 } 1980 1981 if (ia_valid & ATTR_ATIME) { 1982 dout("setattr %p atime %ld.%ld -> %ld.%ld\n", inode, 1983 inode->i_atime.tv_sec, inode->i_atime.tv_nsec, 1984 attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec); 1985 if (issued & CEPH_CAP_FILE_EXCL) { 1986 ci->i_time_warp_seq++; 1987 inode->i_atime = attr->ia_atime; 1988 dirtied |= CEPH_CAP_FILE_EXCL; 1989 } else if ((issued & CEPH_CAP_FILE_WR) && 1990 timespec_compare(&inode->i_atime, 1991 &attr->ia_atime) < 0) { 1992 inode->i_atime = attr->ia_atime; 1993 dirtied |= CEPH_CAP_FILE_WR; 1994 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 || 1995 !timespec_equal(&inode->i_atime, &attr->ia_atime)) { 1996 ceph_encode_timespec(&req->r_args.setattr.atime, 1997 &attr->ia_atime); 1998 mask |= CEPH_SETATTR_ATIME; 1999 release |= CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_RD | 2000 CEPH_CAP_FILE_WR; 2001 } 2002 } 2003 if (ia_valid & ATTR_MTIME) { 2004 dout("setattr %p mtime %ld.%ld -> %ld.%ld\n", inode, 2005 inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec, 2006 attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec); 2007 if (issued & CEPH_CAP_FILE_EXCL) { 2008 ci->i_time_warp_seq++; 2009 inode->i_mtime = attr->ia_mtime; 2010 dirtied |= CEPH_CAP_FILE_EXCL; 2011 } else if ((issued & CEPH_CAP_FILE_WR) && 2012 timespec_compare(&inode->i_mtime, 2013 &attr->ia_mtime) < 0) { 2014 inode->i_mtime = attr->ia_mtime; 2015 dirtied |= CEPH_CAP_FILE_WR; 2016 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 || 2017 !timespec_equal(&inode->i_mtime, &attr->ia_mtime)) { 2018 ceph_encode_timespec(&req->r_args.setattr.mtime, 2019 &attr->ia_mtime); 2020 mask |= CEPH_SETATTR_MTIME; 2021 release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_RD | 2022 CEPH_CAP_FILE_WR; 2023 } 2024 } 2025 if (ia_valid & ATTR_SIZE) { 2026 dout("setattr %p size %lld -> %lld\n", inode, 2027 inode->i_size, attr->ia_size); 2028 if ((issued & CEPH_CAP_FILE_EXCL) && 2029 attr->ia_size > inode->i_size) { 2030 i_size_write(inode, attr->ia_size); 2031 inode->i_blocks = calc_inode_blocks(attr->ia_size); 2032 ci->i_reported_size = attr->ia_size; 2033 dirtied |= CEPH_CAP_FILE_EXCL; 2034 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 || 2035 attr->ia_size != inode->i_size) { 2036 req->r_args.setattr.size = cpu_to_le64(attr->ia_size); 2037 req->r_args.setattr.old_size = 2038 cpu_to_le64(inode->i_size); 2039 mask |= CEPH_SETATTR_SIZE; 2040 release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_RD | 2041 CEPH_CAP_FILE_WR; 2042 } 2043 } 2044 2045 /* these do nothing */ 2046 if (ia_valid & ATTR_CTIME) { 2047 bool only = (ia_valid & (ATTR_SIZE|ATTR_MTIME|ATTR_ATIME| 2048 ATTR_MODE|ATTR_UID|ATTR_GID)) == 0; 2049 dout("setattr %p ctime %ld.%ld -> %ld.%ld (%s)\n", inode, 2050 inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec, 2051 attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec, 2052 only ? "ctime only" : "ignored"); 2053 if (only) { 2054 /* 2055 * if kernel wants to dirty ctime but nothing else, 2056 * we need to choose a cap to dirty under, or do 2057 * a almost-no-op setattr 2058 */ 2059 if (issued & CEPH_CAP_AUTH_EXCL) 2060 dirtied |= CEPH_CAP_AUTH_EXCL; 2061 else if (issued & CEPH_CAP_FILE_EXCL) 2062 dirtied |= CEPH_CAP_FILE_EXCL; 2063 else if (issued & CEPH_CAP_XATTR_EXCL) 2064 dirtied |= CEPH_CAP_XATTR_EXCL; 2065 else 2066 mask |= CEPH_SETATTR_CTIME; 2067 } 2068 } 2069 if (ia_valid & ATTR_FILE) 2070 dout("setattr %p ATTR_FILE ... hrm!\n", inode); 2071 2072 if (dirtied) { 2073 inode_dirty_flags = __ceph_mark_dirty_caps(ci, dirtied, 2074 &prealloc_cf); 2075 inode->i_ctime = attr->ia_ctime; 2076 } 2077 2078 release &= issued; 2079 spin_unlock(&ci->i_ceph_lock); 2080 if (lock_snap_rwsem) 2081 up_read(&mdsc->snap_rwsem); 2082 2083 if (inode_dirty_flags) 2084 __mark_inode_dirty(inode, inode_dirty_flags); 2085 2086 2087 if (mask) { 2088 req->r_inode = inode; 2089 ihold(inode); 2090 req->r_inode_drop = release; 2091 req->r_args.setattr.mask = cpu_to_le32(mask); 2092 req->r_num_caps = 1; 2093 req->r_stamp = attr->ia_ctime; 2094 err = ceph_mdsc_do_request(mdsc, NULL, req); 2095 } 2096 dout("setattr %p result=%d (%s locally, %d remote)\n", inode, err, 2097 ceph_cap_string(dirtied), mask); 2098 2099 ceph_mdsc_put_request(req); 2100 ceph_free_cap_flush(prealloc_cf); 2101 2102 if (err >= 0 && (mask & CEPH_SETATTR_SIZE)) 2103 __ceph_do_pending_vmtruncate(inode); 2104 2105 return err; 2106 } 2107 2108 /* 2109 * setattr 2110 */ 2111 int ceph_setattr(struct dentry *dentry, struct iattr *attr) 2112 { 2113 struct inode *inode = d_inode(dentry); 2114 int err; 2115 2116 if (ceph_snap(inode) != CEPH_NOSNAP) 2117 return -EROFS; 2118 2119 err = setattr_prepare(dentry, attr); 2120 if (err != 0) 2121 return err; 2122 2123 err = __ceph_setattr(inode, attr); 2124 2125 if (err >= 0 && (attr->ia_valid & ATTR_MODE)) 2126 err = posix_acl_chmod(inode, attr->ia_mode); 2127 2128 return err; 2129 } 2130 2131 /* 2132 * Verify that we have a lease on the given mask. If not, 2133 * do a getattr against an mds. 2134 */ 2135 int __ceph_do_getattr(struct inode *inode, struct page *locked_page, 2136 int mask, bool force) 2137 { 2138 struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb); 2139 struct ceph_mds_client *mdsc = fsc->mdsc; 2140 struct ceph_mds_request *req; 2141 int err; 2142 2143 if (ceph_snap(inode) == CEPH_SNAPDIR) { 2144 dout("do_getattr inode %p SNAPDIR\n", inode); 2145 return 0; 2146 } 2147 2148 dout("do_getattr inode %p mask %s mode 0%o\n", 2149 inode, ceph_cap_string(mask), inode->i_mode); 2150 if (!force && ceph_caps_issued_mask(ceph_inode(inode), mask, 1)) 2151 return 0; 2152 2153 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, USE_ANY_MDS); 2154 if (IS_ERR(req)) 2155 return PTR_ERR(req); 2156 req->r_inode = inode; 2157 ihold(inode); 2158 req->r_num_caps = 1; 2159 req->r_args.getattr.mask = cpu_to_le32(mask); 2160 req->r_locked_page = locked_page; 2161 err = ceph_mdsc_do_request(mdsc, NULL, req); 2162 if (locked_page && err == 0) { 2163 u64 inline_version = req->r_reply_info.targeti.inline_version; 2164 if (inline_version == 0) { 2165 /* the reply is supposed to contain inline data */ 2166 err = -EINVAL; 2167 } else if (inline_version == CEPH_INLINE_NONE) { 2168 err = -ENODATA; 2169 } else { 2170 err = req->r_reply_info.targeti.inline_len; 2171 } 2172 } 2173 ceph_mdsc_put_request(req); 2174 dout("do_getattr result=%d\n", err); 2175 return err; 2176 } 2177 2178 2179 /* 2180 * Check inode permissions. We verify we have a valid value for 2181 * the AUTH cap, then call the generic handler. 2182 */ 2183 int ceph_permission(struct inode *inode, int mask) 2184 { 2185 int err; 2186 2187 if (mask & MAY_NOT_BLOCK) 2188 return -ECHILD; 2189 2190 err = ceph_do_getattr(inode, CEPH_CAP_AUTH_SHARED, false); 2191 2192 if (!err) 2193 err = generic_permission(inode, mask); 2194 return err; 2195 } 2196 2197 /* 2198 * Get all attributes. Hopefully somedata we'll have a statlite() 2199 * and can limit the fields we require to be accurate. 2200 */ 2201 int ceph_getattr(const struct path *path, struct kstat *stat, 2202 u32 request_mask, unsigned int flags) 2203 { 2204 struct inode *inode = d_inode(path->dentry); 2205 struct ceph_inode_info *ci = ceph_inode(inode); 2206 int err; 2207 2208 err = ceph_do_getattr(inode, CEPH_STAT_CAP_INODE_ALL, false); 2209 if (!err) { 2210 generic_fillattr(inode, stat); 2211 stat->ino = ceph_translate_ino(inode->i_sb, inode->i_ino); 2212 if (ceph_snap(inode) != CEPH_NOSNAP) 2213 stat->dev = ceph_snap(inode); 2214 else 2215 stat->dev = 0; 2216 if (S_ISDIR(inode->i_mode)) { 2217 if (ceph_test_mount_opt(ceph_sb_to_client(inode->i_sb), 2218 RBYTES)) 2219 stat->size = ci->i_rbytes; 2220 else 2221 stat->size = ci->i_files + ci->i_subdirs; 2222 stat->blocks = 0; 2223 stat->blksize = 65536; 2224 } 2225 } 2226 return err; 2227 } 2228