1 #include <linux/ceph/ceph_debug.h> 2 3 #include <linux/spinlock.h> 4 #include <linux/fs_struct.h> 5 #include <linux/namei.h> 6 #include <linux/slab.h> 7 #include <linux/sched.h> 8 #include <linux/xattr.h> 9 10 #include "super.h" 11 #include "mds_client.h" 12 13 /* 14 * Directory operations: readdir, lookup, create, link, unlink, 15 * rename, etc. 16 */ 17 18 /* 19 * Ceph MDS operations are specified in terms of a base ino and 20 * relative path. Thus, the client can specify an operation on a 21 * specific inode (e.g., a getattr due to fstat(2)), or as a path 22 * relative to, say, the root directory. 23 * 24 * Normally, we limit ourselves to strict inode ops (no path component) 25 * or dentry operations (a single path component relative to an ino). The 26 * exception to this is open_root_dentry(), which will open the mount 27 * point by name. 28 */ 29 30 const struct dentry_operations ceph_dentry_ops; 31 32 /* 33 * Initialize ceph dentry state. 34 */ 35 static int ceph_d_init(struct dentry *dentry) 36 { 37 struct ceph_dentry_info *di; 38 39 di = kmem_cache_zalloc(ceph_dentry_cachep, GFP_KERNEL); 40 if (!di) 41 return -ENOMEM; /* oh well */ 42 43 di->dentry = dentry; 44 di->lease_session = NULL; 45 di->time = jiffies; 46 dentry->d_fsdata = di; 47 ceph_dentry_lru_add(dentry); 48 return 0; 49 } 50 51 /* 52 * for f_pos for readdir: 53 * - hash order: 54 * (0xff << 52) | ((24 bits hash) << 28) | 55 * (the nth entry has hash collision); 56 * - frag+name order; 57 * ((frag value) << 28) | (the nth entry in frag); 58 */ 59 #define OFFSET_BITS 28 60 #define OFFSET_MASK ((1 << OFFSET_BITS) - 1) 61 #define HASH_ORDER (0xffull << (OFFSET_BITS + 24)) 62 loff_t ceph_make_fpos(unsigned high, unsigned off, bool hash_order) 63 { 64 loff_t fpos = ((loff_t)high << 28) | (loff_t)off; 65 if (hash_order) 66 fpos |= HASH_ORDER; 67 return fpos; 68 } 69 70 static bool is_hash_order(loff_t p) 71 { 72 return (p & HASH_ORDER) == HASH_ORDER; 73 } 74 75 static unsigned fpos_frag(loff_t p) 76 { 77 return p >> OFFSET_BITS; 78 } 79 80 static unsigned fpos_hash(loff_t p) 81 { 82 return ceph_frag_value(fpos_frag(p)); 83 } 84 85 static unsigned fpos_off(loff_t p) 86 { 87 return p & OFFSET_MASK; 88 } 89 90 static int fpos_cmp(loff_t l, loff_t r) 91 { 92 int v = ceph_frag_compare(fpos_frag(l), fpos_frag(r)); 93 if (v) 94 return v; 95 return (int)(fpos_off(l) - fpos_off(r)); 96 } 97 98 /* 99 * make note of the last dentry we read, so we can 100 * continue at the same lexicographical point, 101 * regardless of what dir changes take place on the 102 * server. 103 */ 104 static int note_last_dentry(struct ceph_file_info *fi, const char *name, 105 int len, unsigned next_offset) 106 { 107 char *buf = kmalloc(len+1, GFP_KERNEL); 108 if (!buf) 109 return -ENOMEM; 110 kfree(fi->last_name); 111 fi->last_name = buf; 112 memcpy(fi->last_name, name, len); 113 fi->last_name[len] = 0; 114 fi->next_offset = next_offset; 115 dout("note_last_dentry '%s'\n", fi->last_name); 116 return 0; 117 } 118 119 120 static struct dentry * 121 __dcache_find_get_entry(struct dentry *parent, u64 idx, 122 struct ceph_readdir_cache_control *cache_ctl) 123 { 124 struct inode *dir = d_inode(parent); 125 struct dentry *dentry; 126 unsigned idx_mask = (PAGE_SIZE / sizeof(struct dentry *)) - 1; 127 loff_t ptr_pos = idx * sizeof(struct dentry *); 128 pgoff_t ptr_pgoff = ptr_pos >> PAGE_SHIFT; 129 130 if (ptr_pos >= i_size_read(dir)) 131 return NULL; 132 133 if (!cache_ctl->page || ptr_pgoff != page_index(cache_ctl->page)) { 134 ceph_readdir_cache_release(cache_ctl); 135 cache_ctl->page = find_lock_page(&dir->i_data, ptr_pgoff); 136 if (!cache_ctl->page) { 137 dout(" page %lu not found\n", ptr_pgoff); 138 return ERR_PTR(-EAGAIN); 139 } 140 /* reading/filling the cache are serialized by 141 i_mutex, no need to use page lock */ 142 unlock_page(cache_ctl->page); 143 cache_ctl->dentries = kmap(cache_ctl->page); 144 } 145 146 cache_ctl->index = idx & idx_mask; 147 148 rcu_read_lock(); 149 spin_lock(&parent->d_lock); 150 /* check i_size again here, because empty directory can be 151 * marked as complete while not holding the i_mutex. */ 152 if (ceph_dir_is_complete_ordered(dir) && ptr_pos < i_size_read(dir)) 153 dentry = cache_ctl->dentries[cache_ctl->index]; 154 else 155 dentry = NULL; 156 spin_unlock(&parent->d_lock); 157 if (dentry && !lockref_get_not_dead(&dentry->d_lockref)) 158 dentry = NULL; 159 rcu_read_unlock(); 160 return dentry ? : ERR_PTR(-EAGAIN); 161 } 162 163 /* 164 * When possible, we try to satisfy a readdir by peeking at the 165 * dcache. We make this work by carefully ordering dentries on 166 * d_child when we initially get results back from the MDS, and 167 * falling back to a "normal" sync readdir if any dentries in the dir 168 * are dropped. 169 * 170 * Complete dir indicates that we have all dentries in the dir. It is 171 * defined IFF we hold CEPH_CAP_FILE_SHARED (which will be revoked by 172 * the MDS if/when the directory is modified). 173 */ 174 static int __dcache_readdir(struct file *file, struct dir_context *ctx, 175 u32 shared_gen) 176 { 177 struct ceph_file_info *fi = file->private_data; 178 struct dentry *parent = file->f_path.dentry; 179 struct inode *dir = d_inode(parent); 180 struct dentry *dentry, *last = NULL; 181 struct ceph_dentry_info *di; 182 struct ceph_readdir_cache_control cache_ctl = {}; 183 u64 idx = 0; 184 int err = 0; 185 186 dout("__dcache_readdir %p v%u at %llx\n", dir, shared_gen, ctx->pos); 187 188 /* search start position */ 189 if (ctx->pos > 2) { 190 u64 count = div_u64(i_size_read(dir), sizeof(struct dentry *)); 191 while (count > 0) { 192 u64 step = count >> 1; 193 dentry = __dcache_find_get_entry(parent, idx + step, 194 &cache_ctl); 195 if (!dentry) { 196 /* use linar search */ 197 idx = 0; 198 break; 199 } 200 if (IS_ERR(dentry)) { 201 err = PTR_ERR(dentry); 202 goto out; 203 } 204 di = ceph_dentry(dentry); 205 spin_lock(&dentry->d_lock); 206 if (fpos_cmp(di->offset, ctx->pos) < 0) { 207 idx += step + 1; 208 count -= step + 1; 209 } else { 210 count = step; 211 } 212 spin_unlock(&dentry->d_lock); 213 dput(dentry); 214 } 215 216 dout("__dcache_readdir %p cache idx %llu\n", dir, idx); 217 } 218 219 220 for (;;) { 221 bool emit_dentry = false; 222 dentry = __dcache_find_get_entry(parent, idx++, &cache_ctl); 223 if (!dentry) { 224 fi->flags |= CEPH_F_ATEND; 225 err = 0; 226 break; 227 } 228 if (IS_ERR(dentry)) { 229 err = PTR_ERR(dentry); 230 goto out; 231 } 232 233 di = ceph_dentry(dentry); 234 spin_lock(&dentry->d_lock); 235 if (di->lease_shared_gen == shared_gen && 236 d_really_is_positive(dentry) && 237 fpos_cmp(ctx->pos, di->offset) <= 0) { 238 emit_dentry = true; 239 } 240 spin_unlock(&dentry->d_lock); 241 242 if (emit_dentry) { 243 dout(" %llx dentry %p %pd %p\n", di->offset, 244 dentry, dentry, d_inode(dentry)); 245 ctx->pos = di->offset; 246 if (!dir_emit(ctx, dentry->d_name.name, 247 dentry->d_name.len, 248 ceph_translate_ino(dentry->d_sb, 249 d_inode(dentry)->i_ino), 250 d_inode(dentry)->i_mode >> 12)) { 251 dput(dentry); 252 err = 0; 253 break; 254 } 255 ctx->pos++; 256 257 if (last) 258 dput(last); 259 last = dentry; 260 } else { 261 dput(dentry); 262 } 263 } 264 out: 265 ceph_readdir_cache_release(&cache_ctl); 266 if (last) { 267 int ret; 268 di = ceph_dentry(last); 269 ret = note_last_dentry(fi, last->d_name.name, last->d_name.len, 270 fpos_off(di->offset) + 1); 271 if (ret < 0) 272 err = ret; 273 dput(last); 274 } 275 return err; 276 } 277 278 static bool need_send_readdir(struct ceph_file_info *fi, loff_t pos) 279 { 280 if (!fi->last_readdir) 281 return true; 282 if (is_hash_order(pos)) 283 return !ceph_frag_contains_value(fi->frag, fpos_hash(pos)); 284 else 285 return fi->frag != fpos_frag(pos); 286 } 287 288 static int ceph_readdir(struct file *file, struct dir_context *ctx) 289 { 290 struct ceph_file_info *fi = file->private_data; 291 struct inode *inode = file_inode(file); 292 struct ceph_inode_info *ci = ceph_inode(inode); 293 struct ceph_fs_client *fsc = ceph_inode_to_client(inode); 294 struct ceph_mds_client *mdsc = fsc->mdsc; 295 int i; 296 int err; 297 u32 ftype; 298 struct ceph_mds_reply_info_parsed *rinfo; 299 300 dout("readdir %p file %p pos %llx\n", inode, file, ctx->pos); 301 if (fi->flags & CEPH_F_ATEND) 302 return 0; 303 304 /* always start with . and .. */ 305 if (ctx->pos == 0) { 306 dout("readdir off 0 -> '.'\n"); 307 if (!dir_emit(ctx, ".", 1, 308 ceph_translate_ino(inode->i_sb, inode->i_ino), 309 inode->i_mode >> 12)) 310 return 0; 311 ctx->pos = 1; 312 } 313 if (ctx->pos == 1) { 314 ino_t ino = parent_ino(file->f_path.dentry); 315 dout("readdir off 1 -> '..'\n"); 316 if (!dir_emit(ctx, "..", 2, 317 ceph_translate_ino(inode->i_sb, ino), 318 inode->i_mode >> 12)) 319 return 0; 320 ctx->pos = 2; 321 } 322 323 /* can we use the dcache? */ 324 spin_lock(&ci->i_ceph_lock); 325 if (ceph_test_mount_opt(fsc, DCACHE) && 326 !ceph_test_mount_opt(fsc, NOASYNCREADDIR) && 327 ceph_snap(inode) != CEPH_SNAPDIR && 328 __ceph_dir_is_complete_ordered(ci) && 329 __ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1)) { 330 u32 shared_gen = ci->i_shared_gen; 331 spin_unlock(&ci->i_ceph_lock); 332 err = __dcache_readdir(file, ctx, shared_gen); 333 if (err != -EAGAIN) 334 return err; 335 } else { 336 spin_unlock(&ci->i_ceph_lock); 337 } 338 339 /* proceed with a normal readdir */ 340 more: 341 /* do we have the correct frag content buffered? */ 342 if (need_send_readdir(fi, ctx->pos)) { 343 struct ceph_mds_request *req; 344 unsigned frag; 345 int op = ceph_snap(inode) == CEPH_SNAPDIR ? 346 CEPH_MDS_OP_LSSNAP : CEPH_MDS_OP_READDIR; 347 348 /* discard old result, if any */ 349 if (fi->last_readdir) { 350 ceph_mdsc_put_request(fi->last_readdir); 351 fi->last_readdir = NULL; 352 } 353 354 if (is_hash_order(ctx->pos)) { 355 frag = ceph_choose_frag(ci, fpos_hash(ctx->pos), 356 NULL, NULL); 357 } else { 358 frag = fpos_frag(ctx->pos); 359 } 360 361 dout("readdir fetching %llx.%llx frag %x offset '%s'\n", 362 ceph_vinop(inode), frag, fi->last_name); 363 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS); 364 if (IS_ERR(req)) 365 return PTR_ERR(req); 366 err = ceph_alloc_readdir_reply_buffer(req, inode); 367 if (err) { 368 ceph_mdsc_put_request(req); 369 return err; 370 } 371 /* hints to request -> mds selection code */ 372 req->r_direct_mode = USE_AUTH_MDS; 373 req->r_direct_hash = ceph_frag_value(frag); 374 __set_bit(CEPH_MDS_R_DIRECT_IS_HASH, &req->r_req_flags); 375 if (fi->last_name) { 376 req->r_path2 = kstrdup(fi->last_name, GFP_KERNEL); 377 if (!req->r_path2) { 378 ceph_mdsc_put_request(req); 379 return -ENOMEM; 380 } 381 } 382 req->r_dir_release_cnt = fi->dir_release_count; 383 req->r_dir_ordered_cnt = fi->dir_ordered_count; 384 req->r_readdir_cache_idx = fi->readdir_cache_idx; 385 req->r_readdir_offset = fi->next_offset; 386 req->r_args.readdir.frag = cpu_to_le32(frag); 387 req->r_args.readdir.flags = 388 cpu_to_le16(CEPH_READDIR_REPLY_BITFLAGS); 389 390 req->r_inode = inode; 391 ihold(inode); 392 req->r_dentry = dget(file->f_path.dentry); 393 err = ceph_mdsc_do_request(mdsc, NULL, req); 394 if (err < 0) { 395 ceph_mdsc_put_request(req); 396 return err; 397 } 398 dout("readdir got and parsed readdir result=%d on " 399 "frag %x, end=%d, complete=%d, hash_order=%d\n", 400 err, frag, 401 (int)req->r_reply_info.dir_end, 402 (int)req->r_reply_info.dir_complete, 403 (int)req->r_reply_info.hash_order); 404 405 rinfo = &req->r_reply_info; 406 if (le32_to_cpu(rinfo->dir_dir->frag) != frag) { 407 frag = le32_to_cpu(rinfo->dir_dir->frag); 408 if (!rinfo->hash_order) { 409 fi->next_offset = req->r_readdir_offset; 410 /* adjust ctx->pos to beginning of frag */ 411 ctx->pos = ceph_make_fpos(frag, 412 fi->next_offset, 413 false); 414 } 415 } 416 417 fi->frag = frag; 418 fi->last_readdir = req; 419 420 if (test_bit(CEPH_MDS_R_DID_PREPOPULATE, &req->r_req_flags)) { 421 fi->readdir_cache_idx = req->r_readdir_cache_idx; 422 if (fi->readdir_cache_idx < 0) { 423 /* preclude from marking dir ordered */ 424 fi->dir_ordered_count = 0; 425 } else if (ceph_frag_is_leftmost(frag) && 426 fi->next_offset == 2) { 427 /* note dir version at start of readdir so 428 * we can tell if any dentries get dropped */ 429 fi->dir_release_count = req->r_dir_release_cnt; 430 fi->dir_ordered_count = req->r_dir_ordered_cnt; 431 } 432 } else { 433 dout("readdir !did_prepopulate"); 434 /* disable readdir cache */ 435 fi->readdir_cache_idx = -1; 436 /* preclude from marking dir complete */ 437 fi->dir_release_count = 0; 438 } 439 440 /* note next offset and last dentry name */ 441 if (rinfo->dir_nr > 0) { 442 struct ceph_mds_reply_dir_entry *rde = 443 rinfo->dir_entries + (rinfo->dir_nr-1); 444 unsigned next_offset = req->r_reply_info.dir_end ? 445 2 : (fpos_off(rde->offset) + 1); 446 err = note_last_dentry(fi, rde->name, rde->name_len, 447 next_offset); 448 if (err) 449 return err; 450 } else if (req->r_reply_info.dir_end) { 451 fi->next_offset = 2; 452 /* keep last name */ 453 } 454 } 455 456 rinfo = &fi->last_readdir->r_reply_info; 457 dout("readdir frag %x num %d pos %llx chunk first %llx\n", 458 fi->frag, rinfo->dir_nr, ctx->pos, 459 rinfo->dir_nr ? rinfo->dir_entries[0].offset : 0LL); 460 461 i = 0; 462 /* search start position */ 463 if (rinfo->dir_nr > 0) { 464 int step, nr = rinfo->dir_nr; 465 while (nr > 0) { 466 step = nr >> 1; 467 if (rinfo->dir_entries[i + step].offset < ctx->pos) { 468 i += step + 1; 469 nr -= step + 1; 470 } else { 471 nr = step; 472 } 473 } 474 } 475 for (; i < rinfo->dir_nr; i++) { 476 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i; 477 struct ceph_vino vino; 478 ino_t ino; 479 480 BUG_ON(rde->offset < ctx->pos); 481 482 ctx->pos = rde->offset; 483 dout("readdir (%d/%d) -> %llx '%.*s' %p\n", 484 i, rinfo->dir_nr, ctx->pos, 485 rde->name_len, rde->name, &rde->inode.in); 486 487 BUG_ON(!rde->inode.in); 488 ftype = le32_to_cpu(rde->inode.in->mode) >> 12; 489 vino.ino = le64_to_cpu(rde->inode.in->ino); 490 vino.snap = le64_to_cpu(rde->inode.in->snapid); 491 ino = ceph_vino_to_ino(vino); 492 493 if (!dir_emit(ctx, rde->name, rde->name_len, 494 ceph_translate_ino(inode->i_sb, ino), ftype)) { 495 dout("filldir stopping us...\n"); 496 return 0; 497 } 498 ctx->pos++; 499 } 500 501 if (fi->next_offset > 2) { 502 ceph_mdsc_put_request(fi->last_readdir); 503 fi->last_readdir = NULL; 504 goto more; 505 } 506 507 /* more frags? */ 508 if (!ceph_frag_is_rightmost(fi->frag)) { 509 unsigned frag = ceph_frag_next(fi->frag); 510 if (is_hash_order(ctx->pos)) { 511 loff_t new_pos = ceph_make_fpos(ceph_frag_value(frag), 512 fi->next_offset, true); 513 if (new_pos > ctx->pos) 514 ctx->pos = new_pos; 515 /* keep last_name */ 516 } else { 517 ctx->pos = ceph_make_fpos(frag, fi->next_offset, false); 518 kfree(fi->last_name); 519 fi->last_name = NULL; 520 } 521 dout("readdir next frag is %x\n", frag); 522 goto more; 523 } 524 fi->flags |= CEPH_F_ATEND; 525 526 /* 527 * if dir_release_count still matches the dir, no dentries 528 * were released during the whole readdir, and we should have 529 * the complete dir contents in our cache. 530 */ 531 if (atomic64_read(&ci->i_release_count) == fi->dir_release_count) { 532 spin_lock(&ci->i_ceph_lock); 533 if (fi->dir_ordered_count == atomic64_read(&ci->i_ordered_count)) { 534 dout(" marking %p complete and ordered\n", inode); 535 /* use i_size to track number of entries in 536 * readdir cache */ 537 BUG_ON(fi->readdir_cache_idx < 0); 538 i_size_write(inode, fi->readdir_cache_idx * 539 sizeof(struct dentry*)); 540 } else { 541 dout(" marking %p complete\n", inode); 542 } 543 __ceph_dir_set_complete(ci, fi->dir_release_count, 544 fi->dir_ordered_count); 545 spin_unlock(&ci->i_ceph_lock); 546 } 547 548 dout("readdir %p file %p done.\n", inode, file); 549 return 0; 550 } 551 552 static void reset_readdir(struct ceph_file_info *fi) 553 { 554 if (fi->last_readdir) { 555 ceph_mdsc_put_request(fi->last_readdir); 556 fi->last_readdir = NULL; 557 } 558 kfree(fi->last_name); 559 fi->last_name = NULL; 560 fi->dir_release_count = 0; 561 fi->readdir_cache_idx = -1; 562 fi->next_offset = 2; /* compensate for . and .. */ 563 fi->flags &= ~CEPH_F_ATEND; 564 } 565 566 /* 567 * discard buffered readdir content on seekdir(0), or seek to new frag, 568 * or seek prior to current chunk 569 */ 570 static bool need_reset_readdir(struct ceph_file_info *fi, loff_t new_pos) 571 { 572 struct ceph_mds_reply_info_parsed *rinfo; 573 loff_t chunk_offset; 574 if (new_pos == 0) 575 return true; 576 if (is_hash_order(new_pos)) { 577 /* no need to reset last_name for a forward seek when 578 * dentries are sotred in hash order */ 579 } else if (fi->frag != fpos_frag(new_pos)) { 580 return true; 581 } 582 rinfo = fi->last_readdir ? &fi->last_readdir->r_reply_info : NULL; 583 if (!rinfo || !rinfo->dir_nr) 584 return true; 585 chunk_offset = rinfo->dir_entries[0].offset; 586 return new_pos < chunk_offset || 587 is_hash_order(new_pos) != is_hash_order(chunk_offset); 588 } 589 590 static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int whence) 591 { 592 struct ceph_file_info *fi = file->private_data; 593 struct inode *inode = file->f_mapping->host; 594 loff_t retval; 595 596 inode_lock(inode); 597 retval = -EINVAL; 598 switch (whence) { 599 case SEEK_CUR: 600 offset += file->f_pos; 601 case SEEK_SET: 602 break; 603 case SEEK_END: 604 retval = -EOPNOTSUPP; 605 default: 606 goto out; 607 } 608 609 if (offset >= 0) { 610 if (need_reset_readdir(fi, offset)) { 611 dout("dir_llseek dropping %p content\n", file); 612 reset_readdir(fi); 613 } else if (is_hash_order(offset) && offset > file->f_pos) { 614 /* for hash offset, we don't know if a forward seek 615 * is within same frag */ 616 fi->dir_release_count = 0; 617 fi->readdir_cache_idx = -1; 618 } 619 620 if (offset != file->f_pos) { 621 file->f_pos = offset; 622 file->f_version = 0; 623 fi->flags &= ~CEPH_F_ATEND; 624 } 625 retval = offset; 626 } 627 out: 628 inode_unlock(inode); 629 return retval; 630 } 631 632 /* 633 * Handle lookups for the hidden .snap directory. 634 */ 635 int ceph_handle_snapdir(struct ceph_mds_request *req, 636 struct dentry *dentry, int err) 637 { 638 struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 639 struct inode *parent = d_inode(dentry->d_parent); /* we hold i_mutex */ 640 641 /* .snap dir? */ 642 if (err == -ENOENT && 643 ceph_snap(parent) == CEPH_NOSNAP && 644 strcmp(dentry->d_name.name, 645 fsc->mount_options->snapdir_name) == 0) { 646 struct inode *inode = ceph_get_snapdir(parent); 647 dout("ENOENT on snapdir %p '%pd', linking to snapdir %p\n", 648 dentry, dentry, inode); 649 BUG_ON(!d_unhashed(dentry)); 650 d_add(dentry, inode); 651 err = 0; 652 } 653 return err; 654 } 655 656 /* 657 * Figure out final result of a lookup/open request. 658 * 659 * Mainly, make sure we return the final req->r_dentry (if it already 660 * existed) in place of the original VFS-provided dentry when they 661 * differ. 662 * 663 * Gracefully handle the case where the MDS replies with -ENOENT and 664 * no trace (which it may do, at its discretion, e.g., if it doesn't 665 * care to issue a lease on the negative dentry). 666 */ 667 struct dentry *ceph_finish_lookup(struct ceph_mds_request *req, 668 struct dentry *dentry, int err) 669 { 670 if (err == -ENOENT) { 671 /* no trace? */ 672 err = 0; 673 if (!req->r_reply_info.head->is_dentry) { 674 dout("ENOENT and no trace, dentry %p inode %p\n", 675 dentry, d_inode(dentry)); 676 if (d_really_is_positive(dentry)) { 677 d_drop(dentry); 678 err = -ENOENT; 679 } else { 680 d_add(dentry, NULL); 681 } 682 } 683 } 684 if (err) 685 dentry = ERR_PTR(err); 686 else if (dentry != req->r_dentry) 687 dentry = dget(req->r_dentry); /* we got spliced */ 688 else 689 dentry = NULL; 690 return dentry; 691 } 692 693 static bool is_root_ceph_dentry(struct inode *inode, struct dentry *dentry) 694 { 695 return ceph_ino(inode) == CEPH_INO_ROOT && 696 strncmp(dentry->d_name.name, ".ceph", 5) == 0; 697 } 698 699 /* 700 * Look up a single dir entry. If there is a lookup intent, inform 701 * the MDS so that it gets our 'caps wanted' value in a single op. 702 */ 703 static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry, 704 unsigned int flags) 705 { 706 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb); 707 struct ceph_mds_client *mdsc = fsc->mdsc; 708 struct ceph_mds_request *req; 709 int op; 710 int mask; 711 int err; 712 713 dout("lookup %p dentry %p '%pd'\n", 714 dir, dentry, dentry); 715 716 if (dentry->d_name.len > NAME_MAX) 717 return ERR_PTR(-ENAMETOOLONG); 718 719 /* can we conclude ENOENT locally? */ 720 if (d_really_is_negative(dentry)) { 721 struct ceph_inode_info *ci = ceph_inode(dir); 722 struct ceph_dentry_info *di = ceph_dentry(dentry); 723 724 spin_lock(&ci->i_ceph_lock); 725 dout(" dir %p flags are %d\n", dir, ci->i_ceph_flags); 726 if (strncmp(dentry->d_name.name, 727 fsc->mount_options->snapdir_name, 728 dentry->d_name.len) && 729 !is_root_ceph_dentry(dir, dentry) && 730 ceph_test_mount_opt(fsc, DCACHE) && 731 __ceph_dir_is_complete(ci) && 732 (__ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1))) { 733 spin_unlock(&ci->i_ceph_lock); 734 dout(" dir %p complete, -ENOENT\n", dir); 735 d_add(dentry, NULL); 736 di->lease_shared_gen = ci->i_shared_gen; 737 return NULL; 738 } 739 spin_unlock(&ci->i_ceph_lock); 740 } 741 742 op = ceph_snap(dir) == CEPH_SNAPDIR ? 743 CEPH_MDS_OP_LOOKUPSNAP : CEPH_MDS_OP_LOOKUP; 744 req = ceph_mdsc_create_request(mdsc, op, USE_ANY_MDS); 745 if (IS_ERR(req)) 746 return ERR_CAST(req); 747 req->r_dentry = dget(dentry); 748 req->r_num_caps = 2; 749 750 mask = CEPH_STAT_CAP_INODE | CEPH_CAP_AUTH_SHARED; 751 if (ceph_security_xattr_wanted(dir)) 752 mask |= CEPH_CAP_XATTR_SHARED; 753 req->r_args.getattr.mask = cpu_to_le32(mask); 754 755 req->r_parent = dir; 756 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 757 err = ceph_mdsc_do_request(mdsc, NULL, req); 758 err = ceph_handle_snapdir(req, dentry, err); 759 dentry = ceph_finish_lookup(req, dentry, err); 760 ceph_mdsc_put_request(req); /* will dput(dentry) */ 761 dout("lookup result=%p\n", dentry); 762 return dentry; 763 } 764 765 /* 766 * If we do a create but get no trace back from the MDS, follow up with 767 * a lookup (the VFS expects us to link up the provided dentry). 768 */ 769 int ceph_handle_notrace_create(struct inode *dir, struct dentry *dentry) 770 { 771 struct dentry *result = ceph_lookup(dir, dentry, 0); 772 773 if (result && !IS_ERR(result)) { 774 /* 775 * We created the item, then did a lookup, and found 776 * it was already linked to another inode we already 777 * had in our cache (and thus got spliced). To not 778 * confuse VFS (especially when inode is a directory), 779 * we don't link our dentry to that inode, return an 780 * error instead. 781 * 782 * This event should be rare and it happens only when 783 * we talk to old MDS. Recent MDS does not send traceless 784 * reply for request that creates new inode. 785 */ 786 d_drop(result); 787 return -ESTALE; 788 } 789 return PTR_ERR(result); 790 } 791 792 static int ceph_mknod(struct inode *dir, struct dentry *dentry, 793 umode_t mode, dev_t rdev) 794 { 795 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb); 796 struct ceph_mds_client *mdsc = fsc->mdsc; 797 struct ceph_mds_request *req; 798 struct ceph_acls_info acls = {}; 799 int err; 800 801 if (ceph_snap(dir) != CEPH_NOSNAP) 802 return -EROFS; 803 804 err = ceph_pre_init_acls(dir, &mode, &acls); 805 if (err < 0) 806 return err; 807 808 dout("mknod in dir %p dentry %p mode 0%ho rdev %d\n", 809 dir, dentry, mode, rdev); 810 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_MKNOD, USE_AUTH_MDS); 811 if (IS_ERR(req)) { 812 err = PTR_ERR(req); 813 goto out; 814 } 815 req->r_dentry = dget(dentry); 816 req->r_num_caps = 2; 817 req->r_parent = dir; 818 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 819 req->r_args.mknod.mode = cpu_to_le32(mode); 820 req->r_args.mknod.rdev = cpu_to_le32(rdev); 821 req->r_dentry_drop = CEPH_CAP_FILE_SHARED; 822 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 823 if (acls.pagelist) { 824 req->r_pagelist = acls.pagelist; 825 acls.pagelist = NULL; 826 } 827 err = ceph_mdsc_do_request(mdsc, dir, req); 828 if (!err && !req->r_reply_info.head->is_dentry) 829 err = ceph_handle_notrace_create(dir, dentry); 830 ceph_mdsc_put_request(req); 831 out: 832 if (!err) 833 ceph_init_inode_acls(d_inode(dentry), &acls); 834 else 835 d_drop(dentry); 836 ceph_release_acls_info(&acls); 837 return err; 838 } 839 840 static int ceph_create(struct inode *dir, struct dentry *dentry, umode_t mode, 841 bool excl) 842 { 843 return ceph_mknod(dir, dentry, mode, 0); 844 } 845 846 static int ceph_symlink(struct inode *dir, struct dentry *dentry, 847 const char *dest) 848 { 849 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb); 850 struct ceph_mds_client *mdsc = fsc->mdsc; 851 struct ceph_mds_request *req; 852 int err; 853 854 if (ceph_snap(dir) != CEPH_NOSNAP) 855 return -EROFS; 856 857 dout("symlink in dir %p dentry %p to '%s'\n", dir, dentry, dest); 858 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SYMLINK, USE_AUTH_MDS); 859 if (IS_ERR(req)) { 860 err = PTR_ERR(req); 861 goto out; 862 } 863 req->r_path2 = kstrdup(dest, GFP_KERNEL); 864 if (!req->r_path2) { 865 err = -ENOMEM; 866 ceph_mdsc_put_request(req); 867 goto out; 868 } 869 req->r_parent = dir; 870 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 871 req->r_dentry = dget(dentry); 872 req->r_num_caps = 2; 873 req->r_dentry_drop = CEPH_CAP_FILE_SHARED; 874 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 875 err = ceph_mdsc_do_request(mdsc, dir, req); 876 if (!err && !req->r_reply_info.head->is_dentry) 877 err = ceph_handle_notrace_create(dir, dentry); 878 ceph_mdsc_put_request(req); 879 out: 880 if (err) 881 d_drop(dentry); 882 return err; 883 } 884 885 static int ceph_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 886 { 887 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb); 888 struct ceph_mds_client *mdsc = fsc->mdsc; 889 struct ceph_mds_request *req; 890 struct ceph_acls_info acls = {}; 891 int err = -EROFS; 892 int op; 893 894 if (ceph_snap(dir) == CEPH_SNAPDIR) { 895 /* mkdir .snap/foo is a MKSNAP */ 896 op = CEPH_MDS_OP_MKSNAP; 897 dout("mksnap dir %p snap '%pd' dn %p\n", dir, 898 dentry, dentry); 899 } else if (ceph_snap(dir) == CEPH_NOSNAP) { 900 dout("mkdir dir %p dn %p mode 0%ho\n", dir, dentry, mode); 901 op = CEPH_MDS_OP_MKDIR; 902 } else { 903 goto out; 904 } 905 906 mode |= S_IFDIR; 907 err = ceph_pre_init_acls(dir, &mode, &acls); 908 if (err < 0) 909 goto out; 910 911 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS); 912 if (IS_ERR(req)) { 913 err = PTR_ERR(req); 914 goto out; 915 } 916 917 req->r_dentry = dget(dentry); 918 req->r_num_caps = 2; 919 req->r_parent = dir; 920 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 921 req->r_args.mkdir.mode = cpu_to_le32(mode); 922 req->r_dentry_drop = CEPH_CAP_FILE_SHARED; 923 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 924 if (acls.pagelist) { 925 req->r_pagelist = acls.pagelist; 926 acls.pagelist = NULL; 927 } 928 err = ceph_mdsc_do_request(mdsc, dir, req); 929 if (!err && 930 !req->r_reply_info.head->is_target && 931 !req->r_reply_info.head->is_dentry) 932 err = ceph_handle_notrace_create(dir, dentry); 933 ceph_mdsc_put_request(req); 934 out: 935 if (!err) 936 ceph_init_inode_acls(d_inode(dentry), &acls); 937 else 938 d_drop(dentry); 939 ceph_release_acls_info(&acls); 940 return err; 941 } 942 943 static int ceph_link(struct dentry *old_dentry, struct inode *dir, 944 struct dentry *dentry) 945 { 946 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb); 947 struct ceph_mds_client *mdsc = fsc->mdsc; 948 struct ceph_mds_request *req; 949 int err; 950 951 if (ceph_snap(dir) != CEPH_NOSNAP) 952 return -EROFS; 953 954 dout("link in dir %p old_dentry %p dentry %p\n", dir, 955 old_dentry, dentry); 956 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LINK, USE_AUTH_MDS); 957 if (IS_ERR(req)) { 958 d_drop(dentry); 959 return PTR_ERR(req); 960 } 961 req->r_dentry = dget(dentry); 962 req->r_num_caps = 2; 963 req->r_old_dentry = dget(old_dentry); 964 req->r_parent = dir; 965 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 966 req->r_dentry_drop = CEPH_CAP_FILE_SHARED; 967 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 968 /* release LINK_SHARED on source inode (mds will lock it) */ 969 req->r_old_inode_drop = CEPH_CAP_LINK_SHARED; 970 err = ceph_mdsc_do_request(mdsc, dir, req); 971 if (err) { 972 d_drop(dentry); 973 } else if (!req->r_reply_info.head->is_dentry) { 974 ihold(d_inode(old_dentry)); 975 d_instantiate(dentry, d_inode(old_dentry)); 976 } 977 ceph_mdsc_put_request(req); 978 return err; 979 } 980 981 /* 982 * For a soon-to-be unlinked file, drop the AUTH_RDCACHE caps. If it 983 * looks like the link count will hit 0, drop any other caps (other 984 * than PIN) we don't specifically want (due to the file still being 985 * open). 986 */ 987 static int drop_caps_for_unlink(struct inode *inode) 988 { 989 struct ceph_inode_info *ci = ceph_inode(inode); 990 int drop = CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL; 991 992 spin_lock(&ci->i_ceph_lock); 993 if (inode->i_nlink == 1) { 994 drop |= ~(__ceph_caps_wanted(ci) | CEPH_CAP_PIN); 995 ci->i_ceph_flags |= CEPH_I_NODELAY; 996 } 997 spin_unlock(&ci->i_ceph_lock); 998 return drop; 999 } 1000 1001 /* 1002 * rmdir and unlink are differ only by the metadata op code 1003 */ 1004 static int ceph_unlink(struct inode *dir, struct dentry *dentry) 1005 { 1006 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb); 1007 struct ceph_mds_client *mdsc = fsc->mdsc; 1008 struct inode *inode = d_inode(dentry); 1009 struct ceph_mds_request *req; 1010 int err = -EROFS; 1011 int op; 1012 1013 if (ceph_snap(dir) == CEPH_SNAPDIR) { 1014 /* rmdir .snap/foo is RMSNAP */ 1015 dout("rmsnap dir %p '%pd' dn %p\n", dir, dentry, dentry); 1016 op = CEPH_MDS_OP_RMSNAP; 1017 } else if (ceph_snap(dir) == CEPH_NOSNAP) { 1018 dout("unlink/rmdir dir %p dn %p inode %p\n", 1019 dir, dentry, inode); 1020 op = d_is_dir(dentry) ? 1021 CEPH_MDS_OP_RMDIR : CEPH_MDS_OP_UNLINK; 1022 } else 1023 goto out; 1024 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS); 1025 if (IS_ERR(req)) { 1026 err = PTR_ERR(req); 1027 goto out; 1028 } 1029 req->r_dentry = dget(dentry); 1030 req->r_num_caps = 2; 1031 req->r_parent = dir; 1032 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 1033 req->r_dentry_drop = CEPH_CAP_FILE_SHARED; 1034 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 1035 req->r_inode_drop = drop_caps_for_unlink(inode); 1036 err = ceph_mdsc_do_request(mdsc, dir, req); 1037 if (!err && !req->r_reply_info.head->is_dentry) 1038 d_delete(dentry); 1039 ceph_mdsc_put_request(req); 1040 out: 1041 return err; 1042 } 1043 1044 static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry, 1045 struct inode *new_dir, struct dentry *new_dentry, 1046 unsigned int flags) 1047 { 1048 struct ceph_fs_client *fsc = ceph_sb_to_client(old_dir->i_sb); 1049 struct ceph_mds_client *mdsc = fsc->mdsc; 1050 struct ceph_mds_request *req; 1051 int op = CEPH_MDS_OP_RENAME; 1052 int err; 1053 1054 if (flags) 1055 return -EINVAL; 1056 1057 if (ceph_snap(old_dir) != ceph_snap(new_dir)) 1058 return -EXDEV; 1059 if (ceph_snap(old_dir) != CEPH_NOSNAP) { 1060 if (old_dir == new_dir && ceph_snap(old_dir) == CEPH_SNAPDIR) 1061 op = CEPH_MDS_OP_RENAMESNAP; 1062 else 1063 return -EROFS; 1064 } 1065 dout("rename dir %p dentry %p to dir %p dentry %p\n", 1066 old_dir, old_dentry, new_dir, new_dentry); 1067 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS); 1068 if (IS_ERR(req)) 1069 return PTR_ERR(req); 1070 ihold(old_dir); 1071 req->r_dentry = dget(new_dentry); 1072 req->r_num_caps = 2; 1073 req->r_old_dentry = dget(old_dentry); 1074 req->r_old_dentry_dir = old_dir; 1075 req->r_parent = new_dir; 1076 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 1077 req->r_old_dentry_drop = CEPH_CAP_FILE_SHARED; 1078 req->r_old_dentry_unless = CEPH_CAP_FILE_EXCL; 1079 req->r_dentry_drop = CEPH_CAP_FILE_SHARED; 1080 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 1081 /* release LINK_RDCACHE on source inode (mds will lock it) */ 1082 req->r_old_inode_drop = CEPH_CAP_LINK_SHARED; 1083 if (d_really_is_positive(new_dentry)) 1084 req->r_inode_drop = drop_caps_for_unlink(d_inode(new_dentry)); 1085 err = ceph_mdsc_do_request(mdsc, old_dir, req); 1086 if (!err && !req->r_reply_info.head->is_dentry) { 1087 /* 1088 * Normally d_move() is done by fill_trace (called by 1089 * do_request, above). If there is no trace, we need 1090 * to do it here. 1091 */ 1092 1093 /* d_move screws up sibling dentries' offsets */ 1094 ceph_dir_clear_complete(old_dir); 1095 ceph_dir_clear_complete(new_dir); 1096 1097 d_move(old_dentry, new_dentry); 1098 1099 /* ensure target dentry is invalidated, despite 1100 rehashing bug in vfs_rename_dir */ 1101 ceph_invalidate_dentry_lease(new_dentry); 1102 } 1103 ceph_mdsc_put_request(req); 1104 return err; 1105 } 1106 1107 /* 1108 * Ensure a dentry lease will no longer revalidate. 1109 */ 1110 void ceph_invalidate_dentry_lease(struct dentry *dentry) 1111 { 1112 spin_lock(&dentry->d_lock); 1113 ceph_dentry(dentry)->time = jiffies; 1114 ceph_dentry(dentry)->lease_shared_gen = 0; 1115 spin_unlock(&dentry->d_lock); 1116 } 1117 1118 /* 1119 * Check if dentry lease is valid. If not, delete the lease. Try to 1120 * renew if the least is more than half up. 1121 */ 1122 static int dentry_lease_is_valid(struct dentry *dentry, unsigned int flags, 1123 struct inode *dir) 1124 { 1125 struct ceph_dentry_info *di; 1126 struct ceph_mds_session *s; 1127 int valid = 0; 1128 u32 gen; 1129 unsigned long ttl; 1130 struct ceph_mds_session *session = NULL; 1131 u32 seq = 0; 1132 1133 spin_lock(&dentry->d_lock); 1134 di = ceph_dentry(dentry); 1135 if (di && di->lease_session) { 1136 s = di->lease_session; 1137 spin_lock(&s->s_gen_ttl_lock); 1138 gen = s->s_cap_gen; 1139 ttl = s->s_cap_ttl; 1140 spin_unlock(&s->s_gen_ttl_lock); 1141 1142 if (di->lease_gen == gen && 1143 time_before(jiffies, di->time) && 1144 time_before(jiffies, ttl)) { 1145 valid = 1; 1146 if (di->lease_renew_after && 1147 time_after(jiffies, di->lease_renew_after)) { 1148 /* 1149 * We should renew. If we're in RCU walk mode 1150 * though, we can't do that so just return 1151 * -ECHILD. 1152 */ 1153 if (flags & LOOKUP_RCU) { 1154 valid = -ECHILD; 1155 } else { 1156 session = ceph_get_mds_session(s); 1157 seq = di->lease_seq; 1158 di->lease_renew_after = 0; 1159 di->lease_renew_from = jiffies; 1160 } 1161 } 1162 } 1163 } 1164 spin_unlock(&dentry->d_lock); 1165 1166 if (session) { 1167 ceph_mdsc_lease_send_msg(session, dir, dentry, 1168 CEPH_MDS_LEASE_RENEW, seq); 1169 ceph_put_mds_session(session); 1170 } 1171 dout("dentry_lease_is_valid - dentry %p = %d\n", dentry, valid); 1172 return valid; 1173 } 1174 1175 /* 1176 * Check if directory-wide content lease/cap is valid. 1177 */ 1178 static int dir_lease_is_valid(struct inode *dir, struct dentry *dentry) 1179 { 1180 struct ceph_inode_info *ci = ceph_inode(dir); 1181 struct ceph_dentry_info *di = ceph_dentry(dentry); 1182 int valid = 0; 1183 1184 spin_lock(&ci->i_ceph_lock); 1185 if (ci->i_shared_gen == di->lease_shared_gen) 1186 valid = __ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1); 1187 spin_unlock(&ci->i_ceph_lock); 1188 dout("dir_lease_is_valid dir %p v%u dentry %p v%u = %d\n", 1189 dir, (unsigned)ci->i_shared_gen, dentry, 1190 (unsigned)di->lease_shared_gen, valid); 1191 return valid; 1192 } 1193 1194 /* 1195 * Check if cached dentry can be trusted. 1196 */ 1197 static int ceph_d_revalidate(struct dentry *dentry, unsigned int flags) 1198 { 1199 int valid = 0; 1200 struct dentry *parent; 1201 struct inode *dir; 1202 1203 if (flags & LOOKUP_RCU) { 1204 parent = READ_ONCE(dentry->d_parent); 1205 dir = d_inode_rcu(parent); 1206 if (!dir) 1207 return -ECHILD; 1208 } else { 1209 parent = dget_parent(dentry); 1210 dir = d_inode(parent); 1211 } 1212 1213 dout("d_revalidate %p '%pd' inode %p offset %lld\n", dentry, 1214 dentry, d_inode(dentry), ceph_dentry(dentry)->offset); 1215 1216 /* always trust cached snapped dentries, snapdir dentry */ 1217 if (ceph_snap(dir) != CEPH_NOSNAP) { 1218 dout("d_revalidate %p '%pd' inode %p is SNAPPED\n", dentry, 1219 dentry, d_inode(dentry)); 1220 valid = 1; 1221 } else if (d_really_is_positive(dentry) && 1222 ceph_snap(d_inode(dentry)) == CEPH_SNAPDIR) { 1223 valid = 1; 1224 } else { 1225 valid = dentry_lease_is_valid(dentry, flags, dir); 1226 if (valid == -ECHILD) 1227 return valid; 1228 if (valid || dir_lease_is_valid(dir, dentry)) { 1229 if (d_really_is_positive(dentry)) 1230 valid = ceph_is_any_caps(d_inode(dentry)); 1231 else 1232 valid = 1; 1233 } 1234 } 1235 1236 if (!valid) { 1237 struct ceph_mds_client *mdsc = 1238 ceph_sb_to_client(dir->i_sb)->mdsc; 1239 struct ceph_mds_request *req; 1240 int op, err; 1241 u32 mask; 1242 1243 if (flags & LOOKUP_RCU) 1244 return -ECHILD; 1245 1246 op = ceph_snap(dir) == CEPH_SNAPDIR ? 1247 CEPH_MDS_OP_LOOKUPSNAP : CEPH_MDS_OP_LOOKUP; 1248 req = ceph_mdsc_create_request(mdsc, op, USE_ANY_MDS); 1249 if (!IS_ERR(req)) { 1250 req->r_dentry = dget(dentry); 1251 req->r_num_caps = 2; 1252 req->r_parent = dir; 1253 1254 mask = CEPH_STAT_CAP_INODE | CEPH_CAP_AUTH_SHARED; 1255 if (ceph_security_xattr_wanted(dir)) 1256 mask |= CEPH_CAP_XATTR_SHARED; 1257 req->r_args.getattr.mask = cpu_to_le32(mask); 1258 1259 err = ceph_mdsc_do_request(mdsc, NULL, req); 1260 switch (err) { 1261 case 0: 1262 if (d_really_is_positive(dentry) && 1263 d_inode(dentry) == req->r_target_inode) 1264 valid = 1; 1265 break; 1266 case -ENOENT: 1267 if (d_really_is_negative(dentry)) 1268 valid = 1; 1269 /* Fallthrough */ 1270 default: 1271 break; 1272 } 1273 ceph_mdsc_put_request(req); 1274 dout("d_revalidate %p lookup result=%d\n", 1275 dentry, err); 1276 } 1277 } 1278 1279 dout("d_revalidate %p %s\n", dentry, valid ? "valid" : "invalid"); 1280 if (valid) { 1281 ceph_dentry_lru_touch(dentry); 1282 } else { 1283 ceph_dir_clear_complete(dir); 1284 } 1285 1286 if (!(flags & LOOKUP_RCU)) 1287 dput(parent); 1288 return valid; 1289 } 1290 1291 /* 1292 * Release our ceph_dentry_info. 1293 */ 1294 static void ceph_d_release(struct dentry *dentry) 1295 { 1296 struct ceph_dentry_info *di = ceph_dentry(dentry); 1297 1298 dout("d_release %p\n", dentry); 1299 ceph_dentry_lru_del(dentry); 1300 1301 spin_lock(&dentry->d_lock); 1302 dentry->d_fsdata = NULL; 1303 spin_unlock(&dentry->d_lock); 1304 1305 if (di->lease_session) 1306 ceph_put_mds_session(di->lease_session); 1307 kmem_cache_free(ceph_dentry_cachep, di); 1308 } 1309 1310 /* 1311 * When the VFS prunes a dentry from the cache, we need to clear the 1312 * complete flag on the parent directory. 1313 * 1314 * Called under dentry->d_lock. 1315 */ 1316 static void ceph_d_prune(struct dentry *dentry) 1317 { 1318 dout("ceph_d_prune %p\n", dentry); 1319 1320 /* do we have a valid parent? */ 1321 if (IS_ROOT(dentry)) 1322 return; 1323 1324 /* if we are not hashed, we don't affect dir's completeness */ 1325 if (d_unhashed(dentry)) 1326 return; 1327 1328 if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_SNAPDIR) 1329 return; 1330 1331 /* 1332 * we hold d_lock, so d_parent is stable, and d_fsdata is never 1333 * cleared until d_release 1334 */ 1335 ceph_dir_clear_complete(d_inode(dentry->d_parent)); 1336 } 1337 1338 /* 1339 * read() on a dir. This weird interface hack only works if mounted 1340 * with '-o dirstat'. 1341 */ 1342 static ssize_t ceph_read_dir(struct file *file, char __user *buf, size_t size, 1343 loff_t *ppos) 1344 { 1345 struct ceph_file_info *cf = file->private_data; 1346 struct inode *inode = file_inode(file); 1347 struct ceph_inode_info *ci = ceph_inode(inode); 1348 int left; 1349 const int bufsize = 1024; 1350 1351 if (!ceph_test_mount_opt(ceph_sb_to_client(inode->i_sb), DIRSTAT)) 1352 return -EISDIR; 1353 1354 if (!cf->dir_info) { 1355 cf->dir_info = kmalloc(bufsize, GFP_KERNEL); 1356 if (!cf->dir_info) 1357 return -ENOMEM; 1358 cf->dir_info_len = 1359 snprintf(cf->dir_info, bufsize, 1360 "entries: %20lld\n" 1361 " files: %20lld\n" 1362 " subdirs: %20lld\n" 1363 "rentries: %20lld\n" 1364 " rfiles: %20lld\n" 1365 " rsubdirs: %20lld\n" 1366 "rbytes: %20lld\n" 1367 "rctime: %10ld.%09ld\n", 1368 ci->i_files + ci->i_subdirs, 1369 ci->i_files, 1370 ci->i_subdirs, 1371 ci->i_rfiles + ci->i_rsubdirs, 1372 ci->i_rfiles, 1373 ci->i_rsubdirs, 1374 ci->i_rbytes, 1375 (long)ci->i_rctime.tv_sec, 1376 (long)ci->i_rctime.tv_nsec); 1377 } 1378 1379 if (*ppos >= cf->dir_info_len) 1380 return 0; 1381 size = min_t(unsigned, size, cf->dir_info_len-*ppos); 1382 left = copy_to_user(buf, cf->dir_info + *ppos, size); 1383 if (left == size) 1384 return -EFAULT; 1385 *ppos += (size - left); 1386 return size - left; 1387 } 1388 1389 /* 1390 * We maintain a private dentry LRU. 1391 * 1392 * FIXME: this needs to be changed to a per-mds lru to be useful. 1393 */ 1394 void ceph_dentry_lru_add(struct dentry *dn) 1395 { 1396 struct ceph_dentry_info *di = ceph_dentry(dn); 1397 struct ceph_mds_client *mdsc; 1398 1399 dout("dentry_lru_add %p %p '%pd'\n", di, dn, dn); 1400 mdsc = ceph_sb_to_client(dn->d_sb)->mdsc; 1401 spin_lock(&mdsc->dentry_lru_lock); 1402 list_add_tail(&di->lru, &mdsc->dentry_lru); 1403 mdsc->num_dentry++; 1404 spin_unlock(&mdsc->dentry_lru_lock); 1405 } 1406 1407 void ceph_dentry_lru_touch(struct dentry *dn) 1408 { 1409 struct ceph_dentry_info *di = ceph_dentry(dn); 1410 struct ceph_mds_client *mdsc; 1411 1412 dout("dentry_lru_touch %p %p '%pd' (offset %lld)\n", di, dn, dn, 1413 di->offset); 1414 mdsc = ceph_sb_to_client(dn->d_sb)->mdsc; 1415 spin_lock(&mdsc->dentry_lru_lock); 1416 list_move_tail(&di->lru, &mdsc->dentry_lru); 1417 spin_unlock(&mdsc->dentry_lru_lock); 1418 } 1419 1420 void ceph_dentry_lru_del(struct dentry *dn) 1421 { 1422 struct ceph_dentry_info *di = ceph_dentry(dn); 1423 struct ceph_mds_client *mdsc; 1424 1425 dout("dentry_lru_del %p %p '%pd'\n", di, dn, dn); 1426 mdsc = ceph_sb_to_client(dn->d_sb)->mdsc; 1427 spin_lock(&mdsc->dentry_lru_lock); 1428 list_del_init(&di->lru); 1429 mdsc->num_dentry--; 1430 spin_unlock(&mdsc->dentry_lru_lock); 1431 } 1432 1433 /* 1434 * Return name hash for a given dentry. This is dependent on 1435 * the parent directory's hash function. 1436 */ 1437 unsigned ceph_dentry_hash(struct inode *dir, struct dentry *dn) 1438 { 1439 struct ceph_inode_info *dci = ceph_inode(dir); 1440 1441 switch (dci->i_dir_layout.dl_dir_hash) { 1442 case 0: /* for backward compat */ 1443 case CEPH_STR_HASH_LINUX: 1444 return dn->d_name.hash; 1445 1446 default: 1447 return ceph_str_hash(dci->i_dir_layout.dl_dir_hash, 1448 dn->d_name.name, dn->d_name.len); 1449 } 1450 } 1451 1452 const struct file_operations ceph_dir_fops = { 1453 .read = ceph_read_dir, 1454 .iterate = ceph_readdir, 1455 .llseek = ceph_dir_llseek, 1456 .open = ceph_open, 1457 .release = ceph_release, 1458 .unlocked_ioctl = ceph_ioctl, 1459 .fsync = ceph_fsync, 1460 }; 1461 1462 const struct file_operations ceph_snapdir_fops = { 1463 .iterate = ceph_readdir, 1464 .llseek = ceph_dir_llseek, 1465 .open = ceph_open, 1466 .release = ceph_release, 1467 }; 1468 1469 const struct inode_operations ceph_dir_iops = { 1470 .lookup = ceph_lookup, 1471 .permission = ceph_permission, 1472 .getattr = ceph_getattr, 1473 .setattr = ceph_setattr, 1474 .listxattr = ceph_listxattr, 1475 .get_acl = ceph_get_acl, 1476 .set_acl = ceph_set_acl, 1477 .mknod = ceph_mknod, 1478 .symlink = ceph_symlink, 1479 .mkdir = ceph_mkdir, 1480 .link = ceph_link, 1481 .unlink = ceph_unlink, 1482 .rmdir = ceph_unlink, 1483 .rename = ceph_rename, 1484 .create = ceph_create, 1485 .atomic_open = ceph_atomic_open, 1486 }; 1487 1488 const struct inode_operations ceph_snapdir_iops = { 1489 .lookup = ceph_lookup, 1490 .permission = ceph_permission, 1491 .getattr = ceph_getattr, 1492 .mkdir = ceph_mkdir, 1493 .rmdir = ceph_unlink, 1494 .rename = ceph_rename, 1495 }; 1496 1497 const struct dentry_operations ceph_dentry_ops = { 1498 .d_revalidate = ceph_d_revalidate, 1499 .d_release = ceph_d_release, 1500 .d_prune = ceph_d_prune, 1501 .d_init = ceph_d_init, 1502 }; 1503