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