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