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