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