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 ceph_dir_clear_ordered(dir); 1190 d_delete(dn); 1191 dput(dn); 1192 goto retry_lookup; 1193 } 1194 1195 req->r_dentry = dn; 1196 dput(parent); 1197 } 1198 } 1199 1200 if (rinfo->head->is_target) { 1201 tvino.ino = le64_to_cpu(rinfo->targeti.in->ino); 1202 tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid); 1203 1204 in = ceph_get_inode(sb, tvino); 1205 if (IS_ERR(in)) { 1206 err = PTR_ERR(in); 1207 goto done; 1208 } 1209 req->r_target_inode = in; 1210 1211 err = fill_inode(in, req->r_locked_page, &rinfo->targeti, NULL, 1212 session, req->r_request_started, 1213 (!test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) && 1214 rinfo->head->result == 0) ? req->r_fmode : -1, 1215 &req->r_caps_reservation); 1216 if (err < 0) { 1217 pr_err("fill_inode badness %p %llx.%llx\n", 1218 in, ceph_vinop(in)); 1219 goto done; 1220 } 1221 } 1222 1223 /* 1224 * ignore null lease/binding on snapdir ENOENT, or else we 1225 * will have trouble splicing in the virtual snapdir later 1226 */ 1227 if (rinfo->head->is_dentry && 1228 !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) && 1229 test_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags) && 1230 (rinfo->head->is_target || strncmp(req->r_dentry->d_name.name, 1231 fsc->mount_options->snapdir_name, 1232 req->r_dentry->d_name.len))) { 1233 /* 1234 * lookup link rename : null -> possibly existing inode 1235 * mknod symlink mkdir : null -> new inode 1236 * unlink : linked -> null 1237 */ 1238 struct inode *dir = req->r_parent; 1239 struct dentry *dn = req->r_dentry; 1240 bool have_dir_cap, have_lease; 1241 1242 BUG_ON(!dn); 1243 BUG_ON(!dir); 1244 BUG_ON(d_inode(dn->d_parent) != dir); 1245 1246 dvino.ino = le64_to_cpu(rinfo->diri.in->ino); 1247 dvino.snap = le64_to_cpu(rinfo->diri.in->snapid); 1248 1249 BUG_ON(ceph_ino(dir) != dvino.ino); 1250 BUG_ON(ceph_snap(dir) != dvino.snap); 1251 1252 /* do we have a lease on the whole dir? */ 1253 have_dir_cap = 1254 (le32_to_cpu(rinfo->diri.in->cap.caps) & 1255 CEPH_CAP_FILE_SHARED); 1256 1257 /* do we have a dn lease? */ 1258 have_lease = have_dir_cap || 1259 le32_to_cpu(rinfo->dlease->duration_ms); 1260 if (!have_lease) 1261 dout("fill_trace no dentry lease or dir cap\n"); 1262 1263 /* rename? */ 1264 if (req->r_old_dentry && req->r_op == CEPH_MDS_OP_RENAME) { 1265 struct inode *olddir = req->r_old_dentry_dir; 1266 BUG_ON(!olddir); 1267 1268 dout(" src %p '%pd' dst %p '%pd'\n", 1269 req->r_old_dentry, 1270 req->r_old_dentry, 1271 dn, dn); 1272 dout("fill_trace doing d_move %p -> %p\n", 1273 req->r_old_dentry, dn); 1274 1275 /* d_move screws up sibling dentries' offsets */ 1276 ceph_dir_clear_ordered(dir); 1277 ceph_dir_clear_ordered(olddir); 1278 1279 d_move(req->r_old_dentry, dn); 1280 dout(" src %p '%pd' dst %p '%pd'\n", 1281 req->r_old_dentry, 1282 req->r_old_dentry, 1283 dn, dn); 1284 1285 /* ensure target dentry is invalidated, despite 1286 rehashing bug in vfs_rename_dir */ 1287 ceph_invalidate_dentry_lease(dn); 1288 1289 dout("dn %p gets new offset %lld\n", req->r_old_dentry, 1290 ceph_dentry(req->r_old_dentry)->offset); 1291 1292 dn = req->r_old_dentry; /* use old_dentry */ 1293 } 1294 1295 /* null dentry? */ 1296 if (!rinfo->head->is_target) { 1297 dout("fill_trace null dentry\n"); 1298 if (d_really_is_positive(dn)) { 1299 ceph_dir_clear_ordered(dir); 1300 dout("d_delete %p\n", dn); 1301 d_delete(dn); 1302 } else if (have_lease) { 1303 if (d_unhashed(dn)) 1304 d_add(dn, NULL); 1305 update_dentry_lease(dn, rinfo->dlease, 1306 session, 1307 req->r_request_started, 1308 NULL, &dvino); 1309 } 1310 goto done; 1311 } 1312 1313 /* attach proper inode */ 1314 if (d_really_is_negative(dn)) { 1315 ceph_dir_clear_ordered(dir); 1316 ihold(in); 1317 dn = splice_dentry(dn, in); 1318 if (IS_ERR(dn)) { 1319 err = PTR_ERR(dn); 1320 goto done; 1321 } 1322 req->r_dentry = dn; /* may have spliced */ 1323 } else if (d_really_is_positive(dn) && d_inode(dn) != in) { 1324 dout(" %p links to %p %llx.%llx, not %llx.%llx\n", 1325 dn, d_inode(dn), ceph_vinop(d_inode(dn)), 1326 ceph_vinop(in)); 1327 ceph_dir_clear_ordered(dir); 1328 d_invalidate(dn); 1329 have_lease = false; 1330 } 1331 1332 if (have_lease) { 1333 tvino.ino = le64_to_cpu(rinfo->targeti.in->ino); 1334 tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid); 1335 update_dentry_lease(dn, rinfo->dlease, session, 1336 req->r_request_started, 1337 &tvino, &dvino); 1338 } 1339 dout(" final dn %p\n", dn); 1340 } else if ((req->r_op == CEPH_MDS_OP_LOOKUPSNAP || 1341 req->r_op == CEPH_MDS_OP_MKSNAP) && 1342 !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) { 1343 struct dentry *dn = req->r_dentry; 1344 struct inode *dir = req->r_parent; 1345 1346 /* fill out a snapdir LOOKUPSNAP dentry */ 1347 BUG_ON(!dn); 1348 BUG_ON(!dir); 1349 BUG_ON(ceph_snap(dir) != CEPH_SNAPDIR); 1350 dout(" linking snapped dir %p to dn %p\n", in, dn); 1351 ceph_dir_clear_ordered(dir); 1352 ihold(in); 1353 dn = splice_dentry(dn, in); 1354 if (IS_ERR(dn)) { 1355 err = PTR_ERR(dn); 1356 goto done; 1357 } 1358 req->r_dentry = dn; /* may have spliced */ 1359 } else if (rinfo->head->is_dentry) { 1360 struct ceph_vino *ptvino = NULL; 1361 1362 if ((le32_to_cpu(rinfo->diri.in->cap.caps) & CEPH_CAP_FILE_SHARED) || 1363 le32_to_cpu(rinfo->dlease->duration_ms)) { 1364 dvino.ino = le64_to_cpu(rinfo->diri.in->ino); 1365 dvino.snap = le64_to_cpu(rinfo->diri.in->snapid); 1366 1367 if (rinfo->head->is_target) { 1368 tvino.ino = le64_to_cpu(rinfo->targeti.in->ino); 1369 tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid); 1370 ptvino = &tvino; 1371 } 1372 1373 update_dentry_lease(req->r_dentry, rinfo->dlease, 1374 session, req->r_request_started, ptvino, 1375 &dvino); 1376 } else { 1377 dout("%s: no dentry lease or dir cap\n", __func__); 1378 } 1379 } 1380 done: 1381 dout("fill_trace done err=%d\n", err); 1382 return err; 1383 } 1384 1385 /* 1386 * Prepopulate our cache with readdir results, leases, etc. 1387 */ 1388 static int readdir_prepopulate_inodes_only(struct ceph_mds_request *req, 1389 struct ceph_mds_session *session) 1390 { 1391 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info; 1392 int i, err = 0; 1393 1394 for (i = 0; i < rinfo->dir_nr; i++) { 1395 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i; 1396 struct ceph_vino vino; 1397 struct inode *in; 1398 int rc; 1399 1400 vino.ino = le64_to_cpu(rde->inode.in->ino); 1401 vino.snap = le64_to_cpu(rde->inode.in->snapid); 1402 1403 in = ceph_get_inode(req->r_dentry->d_sb, vino); 1404 if (IS_ERR(in)) { 1405 err = PTR_ERR(in); 1406 dout("new_inode badness got %d\n", err); 1407 continue; 1408 } 1409 rc = fill_inode(in, NULL, &rde->inode, NULL, session, 1410 req->r_request_started, -1, 1411 &req->r_caps_reservation); 1412 if (rc < 0) { 1413 pr_err("fill_inode badness on %p got %d\n", in, rc); 1414 err = rc; 1415 } 1416 iput(in); 1417 } 1418 1419 return err; 1420 } 1421 1422 void ceph_readdir_cache_release(struct ceph_readdir_cache_control *ctl) 1423 { 1424 if (ctl->page) { 1425 kunmap(ctl->page); 1426 put_page(ctl->page); 1427 ctl->page = NULL; 1428 } 1429 } 1430 1431 static int fill_readdir_cache(struct inode *dir, struct dentry *dn, 1432 struct ceph_readdir_cache_control *ctl, 1433 struct ceph_mds_request *req) 1434 { 1435 struct ceph_inode_info *ci = ceph_inode(dir); 1436 unsigned nsize = PAGE_SIZE / sizeof(struct dentry*); 1437 unsigned idx = ctl->index % nsize; 1438 pgoff_t pgoff = ctl->index / nsize; 1439 1440 if (!ctl->page || pgoff != page_index(ctl->page)) { 1441 ceph_readdir_cache_release(ctl); 1442 if (idx == 0) 1443 ctl->page = grab_cache_page(&dir->i_data, pgoff); 1444 else 1445 ctl->page = find_lock_page(&dir->i_data, pgoff); 1446 if (!ctl->page) { 1447 ctl->index = -1; 1448 return idx == 0 ? -ENOMEM : 0; 1449 } 1450 /* reading/filling the cache are serialized by 1451 * i_mutex, no need to use page lock */ 1452 unlock_page(ctl->page); 1453 ctl->dentries = kmap(ctl->page); 1454 if (idx == 0) 1455 memset(ctl->dentries, 0, PAGE_SIZE); 1456 } 1457 1458 if (req->r_dir_release_cnt == atomic64_read(&ci->i_release_count) && 1459 req->r_dir_ordered_cnt == atomic64_read(&ci->i_ordered_count)) { 1460 dout("readdir cache dn %p idx %d\n", dn, ctl->index); 1461 ctl->dentries[idx] = dn; 1462 ctl->index++; 1463 } else { 1464 dout("disable readdir cache\n"); 1465 ctl->index = -1; 1466 } 1467 return 0; 1468 } 1469 1470 int ceph_readdir_prepopulate(struct ceph_mds_request *req, 1471 struct ceph_mds_session *session) 1472 { 1473 struct dentry *parent = req->r_dentry; 1474 struct ceph_inode_info *ci = ceph_inode(d_inode(parent)); 1475 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info; 1476 struct qstr dname; 1477 struct dentry *dn; 1478 struct inode *in; 1479 int err = 0, skipped = 0, ret, i; 1480 struct ceph_mds_request_head *rhead = req->r_request->front.iov_base; 1481 u32 frag = le32_to_cpu(rhead->args.readdir.frag); 1482 u32 last_hash = 0; 1483 u32 fpos_offset; 1484 struct ceph_readdir_cache_control cache_ctl = {}; 1485 1486 if (test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) 1487 return readdir_prepopulate_inodes_only(req, session); 1488 1489 if (rinfo->hash_order) { 1490 if (req->r_path2) { 1491 last_hash = ceph_str_hash(ci->i_dir_layout.dl_dir_hash, 1492 req->r_path2, 1493 strlen(req->r_path2)); 1494 last_hash = ceph_frag_value(last_hash); 1495 } else if (rinfo->offset_hash) { 1496 /* mds understands offset_hash */ 1497 WARN_ON_ONCE(req->r_readdir_offset != 2); 1498 last_hash = le32_to_cpu(rhead->args.readdir.offset_hash); 1499 } 1500 } 1501 1502 if (rinfo->dir_dir && 1503 le32_to_cpu(rinfo->dir_dir->frag) != frag) { 1504 dout("readdir_prepopulate got new frag %x -> %x\n", 1505 frag, le32_to_cpu(rinfo->dir_dir->frag)); 1506 frag = le32_to_cpu(rinfo->dir_dir->frag); 1507 if (!rinfo->hash_order) 1508 req->r_readdir_offset = 2; 1509 } 1510 1511 if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) { 1512 dout("readdir_prepopulate %d items under SNAPDIR dn %p\n", 1513 rinfo->dir_nr, parent); 1514 } else { 1515 dout("readdir_prepopulate %d items under dn %p\n", 1516 rinfo->dir_nr, parent); 1517 if (rinfo->dir_dir) 1518 ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir); 1519 1520 if (ceph_frag_is_leftmost(frag) && 1521 req->r_readdir_offset == 2 && 1522 !(rinfo->hash_order && last_hash)) { 1523 /* note dir version at start of readdir so we can 1524 * tell if any dentries get dropped */ 1525 req->r_dir_release_cnt = 1526 atomic64_read(&ci->i_release_count); 1527 req->r_dir_ordered_cnt = 1528 atomic64_read(&ci->i_ordered_count); 1529 req->r_readdir_cache_idx = 0; 1530 } 1531 } 1532 1533 cache_ctl.index = req->r_readdir_cache_idx; 1534 fpos_offset = req->r_readdir_offset; 1535 1536 /* FIXME: release caps/leases if error occurs */ 1537 for (i = 0; i < rinfo->dir_nr; i++) { 1538 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i; 1539 struct ceph_vino tvino, dvino; 1540 1541 dname.name = rde->name; 1542 dname.len = rde->name_len; 1543 dname.hash = full_name_hash(parent, dname.name, dname.len); 1544 1545 tvino.ino = le64_to_cpu(rde->inode.in->ino); 1546 tvino.snap = le64_to_cpu(rde->inode.in->snapid); 1547 1548 if (rinfo->hash_order) { 1549 u32 hash = ceph_str_hash(ci->i_dir_layout.dl_dir_hash, 1550 rde->name, rde->name_len); 1551 hash = ceph_frag_value(hash); 1552 if (hash != last_hash) 1553 fpos_offset = 2; 1554 last_hash = hash; 1555 rde->offset = ceph_make_fpos(hash, fpos_offset++, true); 1556 } else { 1557 rde->offset = ceph_make_fpos(frag, fpos_offset++, false); 1558 } 1559 1560 retry_lookup: 1561 dn = d_lookup(parent, &dname); 1562 dout("d_lookup on parent=%p name=%.*s got %p\n", 1563 parent, dname.len, dname.name, dn); 1564 1565 if (!dn) { 1566 dn = d_alloc(parent, &dname); 1567 dout("d_alloc %p '%.*s' = %p\n", parent, 1568 dname.len, dname.name, dn); 1569 if (!dn) { 1570 dout("d_alloc badness\n"); 1571 err = -ENOMEM; 1572 goto out; 1573 } 1574 } else if (d_really_is_positive(dn) && 1575 (ceph_ino(d_inode(dn)) != tvino.ino || 1576 ceph_snap(d_inode(dn)) != tvino.snap)) { 1577 dout(" dn %p points to wrong inode %p\n", 1578 dn, d_inode(dn)); 1579 __ceph_dir_clear_ordered(ci); 1580 d_delete(dn); 1581 dput(dn); 1582 goto retry_lookup; 1583 } 1584 1585 /* inode */ 1586 if (d_really_is_positive(dn)) { 1587 in = d_inode(dn); 1588 } else { 1589 in = ceph_get_inode(parent->d_sb, tvino); 1590 if (IS_ERR(in)) { 1591 dout("new_inode badness\n"); 1592 d_drop(dn); 1593 dput(dn); 1594 err = PTR_ERR(in); 1595 goto out; 1596 } 1597 } 1598 1599 ret = fill_inode(in, NULL, &rde->inode, NULL, session, 1600 req->r_request_started, -1, 1601 &req->r_caps_reservation); 1602 if (ret < 0) { 1603 pr_err("fill_inode badness on %p\n", in); 1604 if (d_really_is_positive(dn)) 1605 __ceph_dir_clear_ordered(ci); 1606 else 1607 iput(in); 1608 d_drop(dn); 1609 err = ret; 1610 goto next_item; 1611 } 1612 1613 if (d_really_is_negative(dn)) { 1614 struct dentry *realdn; 1615 1616 if (ceph_security_xattr_deadlock(in)) { 1617 dout(" skip splicing dn %p to inode %p" 1618 " (security xattr deadlock)\n", dn, in); 1619 iput(in); 1620 skipped++; 1621 goto next_item; 1622 } 1623 1624 realdn = splice_dentry(dn, in); 1625 if (IS_ERR(realdn)) { 1626 err = PTR_ERR(realdn); 1627 d_drop(dn); 1628 dn = NULL; 1629 goto next_item; 1630 } 1631 dn = realdn; 1632 } 1633 1634 ceph_dentry(dn)->offset = rde->offset; 1635 1636 dvino = ceph_vino(d_inode(parent)); 1637 update_dentry_lease(dn, rde->lease, req->r_session, 1638 req->r_request_started, &tvino, &dvino); 1639 1640 if (err == 0 && skipped == 0 && cache_ctl.index >= 0) { 1641 ret = fill_readdir_cache(d_inode(parent), dn, 1642 &cache_ctl, req); 1643 if (ret < 0) 1644 err = ret; 1645 } 1646 next_item: 1647 if (dn) 1648 dput(dn); 1649 } 1650 out: 1651 if (err == 0 && skipped == 0) { 1652 set_bit(CEPH_MDS_R_DID_PREPOPULATE, &req->r_req_flags); 1653 req->r_readdir_cache_idx = cache_ctl.index; 1654 } 1655 ceph_readdir_cache_release(&cache_ctl); 1656 dout("readdir_prepopulate done\n"); 1657 return err; 1658 } 1659 1660 bool ceph_inode_set_size(struct inode *inode, loff_t size) 1661 { 1662 struct ceph_inode_info *ci = ceph_inode(inode); 1663 bool ret; 1664 1665 spin_lock(&ci->i_ceph_lock); 1666 dout("set_size %p %llu -> %llu\n", inode, inode->i_size, size); 1667 i_size_write(inode, size); 1668 inode->i_blocks = calc_inode_blocks(size); 1669 1670 ret = __ceph_should_report_size(ci); 1671 1672 spin_unlock(&ci->i_ceph_lock); 1673 return ret; 1674 } 1675 1676 /* 1677 * Write back inode data in a worker thread. (This can't be done 1678 * in the message handler context.) 1679 */ 1680 void ceph_queue_writeback(struct inode *inode) 1681 { 1682 ihold(inode); 1683 if (queue_work(ceph_inode_to_client(inode)->wb_wq, 1684 &ceph_inode(inode)->i_wb_work)) { 1685 dout("ceph_queue_writeback %p\n", inode); 1686 } else { 1687 dout("ceph_queue_writeback %p failed\n", inode); 1688 iput(inode); 1689 } 1690 } 1691 1692 static void ceph_writeback_work(struct work_struct *work) 1693 { 1694 struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, 1695 i_wb_work); 1696 struct inode *inode = &ci->vfs_inode; 1697 1698 dout("writeback %p\n", inode); 1699 filemap_fdatawrite(&inode->i_data); 1700 iput(inode); 1701 } 1702 1703 /* 1704 * queue an async invalidation 1705 */ 1706 void ceph_queue_invalidate(struct inode *inode) 1707 { 1708 ihold(inode); 1709 if (queue_work(ceph_inode_to_client(inode)->pg_inv_wq, 1710 &ceph_inode(inode)->i_pg_inv_work)) { 1711 dout("ceph_queue_invalidate %p\n", inode); 1712 } else { 1713 dout("ceph_queue_invalidate %p failed\n", inode); 1714 iput(inode); 1715 } 1716 } 1717 1718 /* 1719 * Invalidate inode pages in a worker thread. (This can't be done 1720 * in the message handler context.) 1721 */ 1722 static void ceph_invalidate_work(struct work_struct *work) 1723 { 1724 struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, 1725 i_pg_inv_work); 1726 struct inode *inode = &ci->vfs_inode; 1727 struct ceph_fs_client *fsc = ceph_inode_to_client(inode); 1728 u32 orig_gen; 1729 int check = 0; 1730 1731 mutex_lock(&ci->i_truncate_mutex); 1732 1733 if (READ_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) { 1734 pr_warn_ratelimited("invalidate_pages %p %lld forced umount\n", 1735 inode, ceph_ino(inode)); 1736 mapping_set_error(inode->i_mapping, -EIO); 1737 truncate_pagecache(inode, 0); 1738 mutex_unlock(&ci->i_truncate_mutex); 1739 goto out; 1740 } 1741 1742 spin_lock(&ci->i_ceph_lock); 1743 dout("invalidate_pages %p gen %d revoking %d\n", inode, 1744 ci->i_rdcache_gen, ci->i_rdcache_revoking); 1745 if (ci->i_rdcache_revoking != ci->i_rdcache_gen) { 1746 if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE)) 1747 check = 1; 1748 spin_unlock(&ci->i_ceph_lock); 1749 mutex_unlock(&ci->i_truncate_mutex); 1750 goto out; 1751 } 1752 orig_gen = ci->i_rdcache_gen; 1753 spin_unlock(&ci->i_ceph_lock); 1754 1755 if (invalidate_inode_pages2(inode->i_mapping) < 0) { 1756 pr_err("invalidate_pages %p fails\n", inode); 1757 } 1758 1759 spin_lock(&ci->i_ceph_lock); 1760 if (orig_gen == ci->i_rdcache_gen && 1761 orig_gen == ci->i_rdcache_revoking) { 1762 dout("invalidate_pages %p gen %d successful\n", inode, 1763 ci->i_rdcache_gen); 1764 ci->i_rdcache_revoking--; 1765 check = 1; 1766 } else { 1767 dout("invalidate_pages %p gen %d raced, now %d revoking %d\n", 1768 inode, orig_gen, ci->i_rdcache_gen, 1769 ci->i_rdcache_revoking); 1770 if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE)) 1771 check = 1; 1772 } 1773 spin_unlock(&ci->i_ceph_lock); 1774 mutex_unlock(&ci->i_truncate_mutex); 1775 out: 1776 if (check) 1777 ceph_check_caps(ci, 0, NULL); 1778 iput(inode); 1779 } 1780 1781 1782 /* 1783 * called by trunc_wq; 1784 * 1785 * We also truncate in a separate thread as well. 1786 */ 1787 static void ceph_vmtruncate_work(struct work_struct *work) 1788 { 1789 struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info, 1790 i_vmtruncate_work); 1791 struct inode *inode = &ci->vfs_inode; 1792 1793 dout("vmtruncate_work %p\n", inode); 1794 __ceph_do_pending_vmtruncate(inode); 1795 iput(inode); 1796 } 1797 1798 /* 1799 * Queue an async vmtruncate. If we fail to queue work, we will handle 1800 * the truncation the next time we call __ceph_do_pending_vmtruncate. 1801 */ 1802 void ceph_queue_vmtruncate(struct inode *inode) 1803 { 1804 struct ceph_inode_info *ci = ceph_inode(inode); 1805 1806 ihold(inode); 1807 1808 if (queue_work(ceph_sb_to_client(inode->i_sb)->trunc_wq, 1809 &ci->i_vmtruncate_work)) { 1810 dout("ceph_queue_vmtruncate %p\n", inode); 1811 } else { 1812 dout("ceph_queue_vmtruncate %p failed, pending=%d\n", 1813 inode, ci->i_truncate_pending); 1814 iput(inode); 1815 } 1816 } 1817 1818 /* 1819 * Make sure any pending truncation is applied before doing anything 1820 * that may depend on it. 1821 */ 1822 void __ceph_do_pending_vmtruncate(struct inode *inode) 1823 { 1824 struct ceph_inode_info *ci = ceph_inode(inode); 1825 u64 to; 1826 int wrbuffer_refs, finish = 0; 1827 1828 mutex_lock(&ci->i_truncate_mutex); 1829 retry: 1830 spin_lock(&ci->i_ceph_lock); 1831 if (ci->i_truncate_pending == 0) { 1832 dout("__do_pending_vmtruncate %p none pending\n", inode); 1833 spin_unlock(&ci->i_ceph_lock); 1834 mutex_unlock(&ci->i_truncate_mutex); 1835 return; 1836 } 1837 1838 /* 1839 * make sure any dirty snapped pages are flushed before we 1840 * possibly truncate them.. so write AND block! 1841 */ 1842 if (ci->i_wrbuffer_ref_head < ci->i_wrbuffer_ref) { 1843 struct ceph_cap_snap *capsnap; 1844 to = ci->i_truncate_size; 1845 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) { 1846 // MDS should have revoked Frw caps 1847 WARN_ON_ONCE(capsnap->writing); 1848 if (capsnap->dirty_pages && capsnap->size > to) 1849 to = capsnap->size; 1850 } 1851 spin_unlock(&ci->i_ceph_lock); 1852 dout("__do_pending_vmtruncate %p flushing snaps first\n", 1853 inode); 1854 1855 truncate_pagecache(inode, to); 1856 1857 filemap_write_and_wait_range(&inode->i_data, 0, 1858 inode->i_sb->s_maxbytes); 1859 goto retry; 1860 } 1861 1862 /* there should be no reader or writer */ 1863 WARN_ON_ONCE(ci->i_rd_ref || ci->i_wr_ref); 1864 1865 to = ci->i_truncate_size; 1866 wrbuffer_refs = ci->i_wrbuffer_ref; 1867 dout("__do_pending_vmtruncate %p (%d) to %lld\n", inode, 1868 ci->i_truncate_pending, to); 1869 spin_unlock(&ci->i_ceph_lock); 1870 1871 truncate_pagecache(inode, to); 1872 1873 spin_lock(&ci->i_ceph_lock); 1874 if (to == ci->i_truncate_size) { 1875 ci->i_truncate_pending = 0; 1876 finish = 1; 1877 } 1878 spin_unlock(&ci->i_ceph_lock); 1879 if (!finish) 1880 goto retry; 1881 1882 mutex_unlock(&ci->i_truncate_mutex); 1883 1884 if (wrbuffer_refs == 0) 1885 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL); 1886 1887 wake_up_all(&ci->i_cap_wq); 1888 } 1889 1890 /* 1891 * symlinks 1892 */ 1893 static const struct inode_operations ceph_symlink_iops = { 1894 .get_link = simple_get_link, 1895 .setattr = ceph_setattr, 1896 .getattr = ceph_getattr, 1897 .listxattr = ceph_listxattr, 1898 }; 1899 1900 int __ceph_setattr(struct inode *inode, struct iattr *attr) 1901 { 1902 struct ceph_inode_info *ci = ceph_inode(inode); 1903 const unsigned int ia_valid = attr->ia_valid; 1904 struct ceph_mds_request *req; 1905 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc; 1906 struct ceph_cap_flush *prealloc_cf; 1907 int issued; 1908 int release = 0, dirtied = 0; 1909 int mask = 0; 1910 int err = 0; 1911 int inode_dirty_flags = 0; 1912 bool lock_snap_rwsem = false; 1913 1914 prealloc_cf = ceph_alloc_cap_flush(); 1915 if (!prealloc_cf) 1916 return -ENOMEM; 1917 1918 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETATTR, 1919 USE_AUTH_MDS); 1920 if (IS_ERR(req)) { 1921 ceph_free_cap_flush(prealloc_cf); 1922 return PTR_ERR(req); 1923 } 1924 1925 spin_lock(&ci->i_ceph_lock); 1926 issued = __ceph_caps_issued(ci, NULL); 1927 1928 if (!ci->i_head_snapc && 1929 (issued & (CEPH_CAP_ANY_EXCL | CEPH_CAP_FILE_WR))) { 1930 lock_snap_rwsem = true; 1931 if (!down_read_trylock(&mdsc->snap_rwsem)) { 1932 spin_unlock(&ci->i_ceph_lock); 1933 down_read(&mdsc->snap_rwsem); 1934 spin_lock(&ci->i_ceph_lock); 1935 issued = __ceph_caps_issued(ci, NULL); 1936 } 1937 } 1938 1939 dout("setattr %p issued %s\n", inode, ceph_cap_string(issued)); 1940 1941 if (ia_valid & ATTR_UID) { 1942 dout("setattr %p uid %d -> %d\n", inode, 1943 from_kuid(&init_user_ns, inode->i_uid), 1944 from_kuid(&init_user_ns, attr->ia_uid)); 1945 if (issued & CEPH_CAP_AUTH_EXCL) { 1946 inode->i_uid = attr->ia_uid; 1947 dirtied |= CEPH_CAP_AUTH_EXCL; 1948 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 || 1949 !uid_eq(attr->ia_uid, inode->i_uid)) { 1950 req->r_args.setattr.uid = cpu_to_le32( 1951 from_kuid(&init_user_ns, attr->ia_uid)); 1952 mask |= CEPH_SETATTR_UID; 1953 release |= CEPH_CAP_AUTH_SHARED; 1954 } 1955 } 1956 if (ia_valid & ATTR_GID) { 1957 dout("setattr %p gid %d -> %d\n", inode, 1958 from_kgid(&init_user_ns, inode->i_gid), 1959 from_kgid(&init_user_ns, attr->ia_gid)); 1960 if (issued & CEPH_CAP_AUTH_EXCL) { 1961 inode->i_gid = attr->ia_gid; 1962 dirtied |= CEPH_CAP_AUTH_EXCL; 1963 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 || 1964 !gid_eq(attr->ia_gid, inode->i_gid)) { 1965 req->r_args.setattr.gid = cpu_to_le32( 1966 from_kgid(&init_user_ns, attr->ia_gid)); 1967 mask |= CEPH_SETATTR_GID; 1968 release |= CEPH_CAP_AUTH_SHARED; 1969 } 1970 } 1971 if (ia_valid & ATTR_MODE) { 1972 dout("setattr %p mode 0%o -> 0%o\n", inode, inode->i_mode, 1973 attr->ia_mode); 1974 if (issued & CEPH_CAP_AUTH_EXCL) { 1975 inode->i_mode = attr->ia_mode; 1976 dirtied |= CEPH_CAP_AUTH_EXCL; 1977 } else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 || 1978 attr->ia_mode != inode->i_mode) { 1979 inode->i_mode = attr->ia_mode; 1980 req->r_args.setattr.mode = cpu_to_le32(attr->ia_mode); 1981 mask |= CEPH_SETATTR_MODE; 1982 release |= CEPH_CAP_AUTH_SHARED; 1983 } 1984 } 1985 1986 if (ia_valid & ATTR_ATIME) { 1987 dout("setattr %p atime %ld.%ld -> %ld.%ld\n", inode, 1988 inode->i_atime.tv_sec, inode->i_atime.tv_nsec, 1989 attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec); 1990 if (issued & CEPH_CAP_FILE_EXCL) { 1991 ci->i_time_warp_seq++; 1992 inode->i_atime = attr->ia_atime; 1993 dirtied |= CEPH_CAP_FILE_EXCL; 1994 } else if ((issued & CEPH_CAP_FILE_WR) && 1995 timespec_compare(&inode->i_atime, 1996 &attr->ia_atime) < 0) { 1997 inode->i_atime = attr->ia_atime; 1998 dirtied |= CEPH_CAP_FILE_WR; 1999 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 || 2000 !timespec_equal(&inode->i_atime, &attr->ia_atime)) { 2001 ceph_encode_timespec(&req->r_args.setattr.atime, 2002 &attr->ia_atime); 2003 mask |= CEPH_SETATTR_ATIME; 2004 release |= CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_RD | 2005 CEPH_CAP_FILE_WR; 2006 } 2007 } 2008 if (ia_valid & ATTR_MTIME) { 2009 dout("setattr %p mtime %ld.%ld -> %ld.%ld\n", inode, 2010 inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec, 2011 attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec); 2012 if (issued & CEPH_CAP_FILE_EXCL) { 2013 ci->i_time_warp_seq++; 2014 inode->i_mtime = attr->ia_mtime; 2015 dirtied |= CEPH_CAP_FILE_EXCL; 2016 } else if ((issued & CEPH_CAP_FILE_WR) && 2017 timespec_compare(&inode->i_mtime, 2018 &attr->ia_mtime) < 0) { 2019 inode->i_mtime = attr->ia_mtime; 2020 dirtied |= CEPH_CAP_FILE_WR; 2021 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 || 2022 !timespec_equal(&inode->i_mtime, &attr->ia_mtime)) { 2023 ceph_encode_timespec(&req->r_args.setattr.mtime, 2024 &attr->ia_mtime); 2025 mask |= CEPH_SETATTR_MTIME; 2026 release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_RD | 2027 CEPH_CAP_FILE_WR; 2028 } 2029 } 2030 if (ia_valid & ATTR_SIZE) { 2031 dout("setattr %p size %lld -> %lld\n", inode, 2032 inode->i_size, attr->ia_size); 2033 if ((issued & CEPH_CAP_FILE_EXCL) && 2034 attr->ia_size > inode->i_size) { 2035 i_size_write(inode, attr->ia_size); 2036 inode->i_blocks = calc_inode_blocks(attr->ia_size); 2037 ci->i_reported_size = attr->ia_size; 2038 dirtied |= CEPH_CAP_FILE_EXCL; 2039 } else if ((issued & CEPH_CAP_FILE_SHARED) == 0 || 2040 attr->ia_size != inode->i_size) { 2041 req->r_args.setattr.size = cpu_to_le64(attr->ia_size); 2042 req->r_args.setattr.old_size = 2043 cpu_to_le64(inode->i_size); 2044 mask |= CEPH_SETATTR_SIZE; 2045 release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_RD | 2046 CEPH_CAP_FILE_WR; 2047 } 2048 } 2049 2050 /* these do nothing */ 2051 if (ia_valid & ATTR_CTIME) { 2052 bool only = (ia_valid & (ATTR_SIZE|ATTR_MTIME|ATTR_ATIME| 2053 ATTR_MODE|ATTR_UID|ATTR_GID)) == 0; 2054 dout("setattr %p ctime %ld.%ld -> %ld.%ld (%s)\n", inode, 2055 inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec, 2056 attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec, 2057 only ? "ctime only" : "ignored"); 2058 if (only) { 2059 /* 2060 * if kernel wants to dirty ctime but nothing else, 2061 * we need to choose a cap to dirty under, or do 2062 * a almost-no-op setattr 2063 */ 2064 if (issued & CEPH_CAP_AUTH_EXCL) 2065 dirtied |= CEPH_CAP_AUTH_EXCL; 2066 else if (issued & CEPH_CAP_FILE_EXCL) 2067 dirtied |= CEPH_CAP_FILE_EXCL; 2068 else if (issued & CEPH_CAP_XATTR_EXCL) 2069 dirtied |= CEPH_CAP_XATTR_EXCL; 2070 else 2071 mask |= CEPH_SETATTR_CTIME; 2072 } 2073 } 2074 if (ia_valid & ATTR_FILE) 2075 dout("setattr %p ATTR_FILE ... hrm!\n", inode); 2076 2077 if (dirtied) { 2078 inode_dirty_flags = __ceph_mark_dirty_caps(ci, dirtied, 2079 &prealloc_cf); 2080 inode->i_ctime = attr->ia_ctime; 2081 } 2082 2083 release &= issued; 2084 spin_unlock(&ci->i_ceph_lock); 2085 if (lock_snap_rwsem) 2086 up_read(&mdsc->snap_rwsem); 2087 2088 if (inode_dirty_flags) 2089 __mark_inode_dirty(inode, inode_dirty_flags); 2090 2091 2092 if (mask) { 2093 req->r_inode = inode; 2094 ihold(inode); 2095 req->r_inode_drop = release; 2096 req->r_args.setattr.mask = cpu_to_le32(mask); 2097 req->r_num_caps = 1; 2098 req->r_stamp = attr->ia_ctime; 2099 err = ceph_mdsc_do_request(mdsc, NULL, req); 2100 } 2101 dout("setattr %p result=%d (%s locally, %d remote)\n", inode, err, 2102 ceph_cap_string(dirtied), mask); 2103 2104 ceph_mdsc_put_request(req); 2105 ceph_free_cap_flush(prealloc_cf); 2106 2107 if (err >= 0 && (mask & CEPH_SETATTR_SIZE)) 2108 __ceph_do_pending_vmtruncate(inode); 2109 2110 return err; 2111 } 2112 2113 /* 2114 * setattr 2115 */ 2116 int ceph_setattr(struct dentry *dentry, struct iattr *attr) 2117 { 2118 struct inode *inode = d_inode(dentry); 2119 int err; 2120 2121 if (ceph_snap(inode) != CEPH_NOSNAP) 2122 return -EROFS; 2123 2124 err = setattr_prepare(dentry, attr); 2125 if (err != 0) 2126 return err; 2127 2128 err = __ceph_setattr(inode, attr); 2129 2130 if (err >= 0 && (attr->ia_valid & ATTR_MODE)) 2131 err = posix_acl_chmod(inode, attr->ia_mode); 2132 2133 return err; 2134 } 2135 2136 /* 2137 * Verify that we have a lease on the given mask. If not, 2138 * do a getattr against an mds. 2139 */ 2140 int __ceph_do_getattr(struct inode *inode, struct page *locked_page, 2141 int mask, bool force) 2142 { 2143 struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb); 2144 struct ceph_mds_client *mdsc = fsc->mdsc; 2145 struct ceph_mds_request *req; 2146 int err; 2147 2148 if (ceph_snap(inode) == CEPH_SNAPDIR) { 2149 dout("do_getattr inode %p SNAPDIR\n", inode); 2150 return 0; 2151 } 2152 2153 dout("do_getattr inode %p mask %s mode 0%o\n", 2154 inode, ceph_cap_string(mask), inode->i_mode); 2155 if (!force && ceph_caps_issued_mask(ceph_inode(inode), mask, 1)) 2156 return 0; 2157 2158 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, USE_ANY_MDS); 2159 if (IS_ERR(req)) 2160 return PTR_ERR(req); 2161 req->r_inode = inode; 2162 ihold(inode); 2163 req->r_num_caps = 1; 2164 req->r_args.getattr.mask = cpu_to_le32(mask); 2165 req->r_locked_page = locked_page; 2166 err = ceph_mdsc_do_request(mdsc, NULL, req); 2167 if (locked_page && err == 0) { 2168 u64 inline_version = req->r_reply_info.targeti.inline_version; 2169 if (inline_version == 0) { 2170 /* the reply is supposed to contain inline data */ 2171 err = -EINVAL; 2172 } else if (inline_version == CEPH_INLINE_NONE) { 2173 err = -ENODATA; 2174 } else { 2175 err = req->r_reply_info.targeti.inline_len; 2176 } 2177 } 2178 ceph_mdsc_put_request(req); 2179 dout("do_getattr result=%d\n", err); 2180 return err; 2181 } 2182 2183 2184 /* 2185 * Check inode permissions. We verify we have a valid value for 2186 * the AUTH cap, then call the generic handler. 2187 */ 2188 int ceph_permission(struct inode *inode, int mask) 2189 { 2190 int err; 2191 2192 if (mask & MAY_NOT_BLOCK) 2193 return -ECHILD; 2194 2195 err = ceph_do_getattr(inode, CEPH_CAP_AUTH_SHARED, false); 2196 2197 if (!err) 2198 err = generic_permission(inode, mask); 2199 return err; 2200 } 2201 2202 /* 2203 * Get all attributes. Hopefully somedata we'll have a statlite() 2204 * and can limit the fields we require to be accurate. 2205 */ 2206 int ceph_getattr(const struct path *path, struct kstat *stat, 2207 u32 request_mask, unsigned int flags) 2208 { 2209 struct inode *inode = d_inode(path->dentry); 2210 struct ceph_inode_info *ci = ceph_inode(inode); 2211 int err; 2212 2213 err = ceph_do_getattr(inode, CEPH_STAT_CAP_INODE_ALL, false); 2214 if (!err) { 2215 generic_fillattr(inode, stat); 2216 stat->ino = ceph_translate_ino(inode->i_sb, inode->i_ino); 2217 if (ceph_snap(inode) != CEPH_NOSNAP) 2218 stat->dev = ceph_snap(inode); 2219 else 2220 stat->dev = 0; 2221 if (S_ISDIR(inode->i_mode)) { 2222 if (ceph_test_mount_opt(ceph_sb_to_client(inode->i_sb), 2223 RBYTES)) 2224 stat->size = ci->i_rbytes; 2225 else 2226 stat->size = ci->i_files + ci->i_subdirs; 2227 stat->blocks = 0; 2228 stat->blksize = 65536; 2229 } 2230 } 2231 return err; 2232 } 2233