1// SPDX-License-Identifier: GPL-2.0 2#include <linux/ceph/ceph_debug.h> 3 4#include <linux/spinlock.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 30const struct dentry_operations ceph_dentry_ops; 31 32static bool __dentry_lease_is_valid(struct ceph_dentry_info *di); 33static int __dir_lease_try_check(const struct dentry *dentry); 34 35/* 36 * Initialize ceph dentry state. 37 */ 38static int ceph_d_init(struct dentry *dentry) 39{ 40 struct ceph_dentry_info *di; 41 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(dentry->d_sb); 42 43 di = kmem_cache_zalloc(ceph_dentry_cachep, GFP_KERNEL); 44 if (!di) 45 return -ENOMEM; /* oh well */ 46 47 di->dentry = dentry; 48 di->lease_session = NULL; 49 di->time = jiffies; 50 dentry->d_fsdata = di; 51 INIT_LIST_HEAD(&di->lease_list); 52 53 atomic64_inc(&mdsc->metric.total_dentries); 54 55 return 0; 56} 57 58/* 59 * for f_pos for readdir: 60 * - hash order: 61 * (0xff << 52) | ((24 bits hash) << 28) | 62 * (the nth entry has hash collision); 63 * - frag+name order; 64 * ((frag value) << 28) | (the nth entry in frag); 65 */ 66#define OFFSET_BITS 28 67#define OFFSET_MASK ((1 << OFFSET_BITS) - 1) 68#define HASH_ORDER (0xffull << (OFFSET_BITS + 24)) 69loff_t ceph_make_fpos(unsigned high, unsigned off, bool hash_order) 70{ 71 loff_t fpos = ((loff_t)high << 28) | (loff_t)off; 72 if (hash_order) 73 fpos |= HASH_ORDER; 74 return fpos; 75} 76 77static bool is_hash_order(loff_t p) 78{ 79 return (p & HASH_ORDER) == HASH_ORDER; 80} 81 82static unsigned fpos_frag(loff_t p) 83{ 84 return p >> OFFSET_BITS; 85} 86 87static unsigned fpos_hash(loff_t p) 88{ 89 return ceph_frag_value(fpos_frag(p)); 90} 91 92static unsigned fpos_off(loff_t p) 93{ 94 return p & OFFSET_MASK; 95} 96 97static int fpos_cmp(loff_t l, loff_t r) 98{ 99 int v = ceph_frag_compare(fpos_frag(l), fpos_frag(r)); 100 if (v) 101 return v; 102 return (int)(fpos_off(l) - fpos_off(r)); 103} 104 105/* 106 * make note of the last dentry we read, so we can 107 * continue at the same lexicographical point, 108 * regardless of what dir changes take place on the 109 * server. 110 */ 111static int note_last_dentry(struct ceph_dir_file_info *dfi, const char *name, 112 int len, unsigned next_offset) 113{ 114 char *buf = kmalloc(len+1, GFP_KERNEL); 115 if (!buf) 116 return -ENOMEM; 117 kfree(dfi->last_name); 118 dfi->last_name = buf; 119 memcpy(dfi->last_name, name, len); 120 dfi->last_name[len] = 0; 121 dfi->next_offset = next_offset; 122 dout("note_last_dentry '%s'\n", dfi->last_name); 123 return 0; 124} 125 126 127static struct dentry * 128__dcache_find_get_entry(struct dentry *parent, u64 idx, 129 struct ceph_readdir_cache_control *cache_ctl) 130{ 131 struct inode *dir = d_inode(parent); 132 struct dentry *dentry; 133 unsigned idx_mask = (PAGE_SIZE / sizeof(struct dentry *)) - 1; 134 loff_t ptr_pos = idx * sizeof(struct dentry *); 135 pgoff_t ptr_pgoff = ptr_pos >> PAGE_SHIFT; 136 137 if (ptr_pos >= i_size_read(dir)) 138 return NULL; 139 140 if (!cache_ctl->page || ptr_pgoff != page_index(cache_ctl->page)) { 141 ceph_readdir_cache_release(cache_ctl); 142 cache_ctl->page = find_lock_page(&dir->i_data, ptr_pgoff); 143 if (!cache_ctl->page) { 144 dout(" page %lu not found\n", ptr_pgoff); 145 return ERR_PTR(-EAGAIN); 146 } 147 /* reading/filling the cache are serialized by 148 i_mutex, no need to use page lock */ 149 unlock_page(cache_ctl->page); 150 cache_ctl->dentries = kmap(cache_ctl->page); 151 } 152 153 cache_ctl->index = idx & idx_mask; 154 155 rcu_read_lock(); 156 spin_lock(&parent->d_lock); 157 /* check i_size again here, because empty directory can be 158 * marked as complete while not holding the i_mutex. */ 159 if (ceph_dir_is_complete_ordered(dir) && ptr_pos < i_size_read(dir)) 160 dentry = cache_ctl->dentries[cache_ctl->index]; 161 else 162 dentry = NULL; 163 spin_unlock(&parent->d_lock); 164 if (dentry && !lockref_get_not_dead(&dentry->d_lockref)) 165 dentry = NULL; 166 rcu_read_unlock(); 167 return dentry ? : ERR_PTR(-EAGAIN); 168} 169 170/* 171 * When possible, we try to satisfy a readdir by peeking at the 172 * dcache. We make this work by carefully ordering dentries on 173 * d_child when we initially get results back from the MDS, and 174 * falling back to a "normal" sync readdir if any dentries in the dir 175 * are dropped. 176 * 177 * Complete dir indicates that we have all dentries in the dir. It is 178 * defined IFF we hold CEPH_CAP_FILE_SHARED (which will be revoked by 179 * the MDS if/when the directory is modified). 180 */ 181static int __dcache_readdir(struct file *file, struct dir_context *ctx, 182 int shared_gen) 183{ 184 struct ceph_dir_file_info *dfi = file->private_data; 185 struct dentry *parent = file->f_path.dentry; 186 struct inode *dir = d_inode(parent); 187 struct dentry *dentry, *last = NULL; 188 struct ceph_dentry_info *di; 189 struct ceph_readdir_cache_control cache_ctl = {}; 190 u64 idx = 0; 191 int err = 0; 192 193 dout("__dcache_readdir %p v%u at %llx\n", dir, (unsigned)shared_gen, ctx->pos); 194 195 /* search start position */ 196 if (ctx->pos > 2) { 197 u64 count = div_u64(i_size_read(dir), sizeof(struct dentry *)); 198 while (count > 0) { 199 u64 step = count >> 1; 200 dentry = __dcache_find_get_entry(parent, idx + step, 201 &cache_ctl); 202 if (!dentry) { 203 /* use linar search */ 204 idx = 0; 205 break; 206 } 207 if (IS_ERR(dentry)) { 208 err = PTR_ERR(dentry); 209 goto out; 210 } 211 di = ceph_dentry(dentry); 212 spin_lock(&dentry->d_lock); 213 if (fpos_cmp(di->offset, ctx->pos) < 0) { 214 idx += step + 1; 215 count -= step + 1; 216 } else { 217 count = step; 218 } 219 spin_unlock(&dentry->d_lock); 220 dput(dentry); 221 } 222 223 dout("__dcache_readdir %p cache idx %llu\n", dir, idx); 224 } 225 226 227 for (;;) { 228 bool emit_dentry = false; 229 dentry = __dcache_find_get_entry(parent, idx++, &cache_ctl); 230 if (!dentry) { 231 dfi->file_info.flags |= CEPH_F_ATEND; 232 err = 0; 233 break; 234 } 235 if (IS_ERR(dentry)) { 236 err = PTR_ERR(dentry); 237 goto out; 238 } 239 240 spin_lock(&dentry->d_lock); 241 di = ceph_dentry(dentry); 242 if (d_unhashed(dentry) || 243 d_really_is_negative(dentry) || 244 di->lease_shared_gen != shared_gen) { 245 spin_unlock(&dentry->d_lock); 246 dput(dentry); 247 err = -EAGAIN; 248 goto out; 249 } 250 if (fpos_cmp(ctx->pos, di->offset) <= 0) { 251 __ceph_dentry_dir_lease_touch(di); 252 emit_dentry = true; 253 } 254 spin_unlock(&dentry->d_lock); 255 256 if (emit_dentry) { 257 dout(" %llx dentry %p %pd %p\n", di->offset, 258 dentry, dentry, d_inode(dentry)); 259 ctx->pos = di->offset; 260 if (!dir_emit(ctx, dentry->d_name.name, 261 dentry->d_name.len, ceph_present_inode(d_inode(dentry)), 262 d_inode(dentry)->i_mode >> 12)) { 263 dput(dentry); 264 err = 0; 265 break; 266 } 267 ctx->pos++; 268 269 if (last) 270 dput(last); 271 last = dentry; 272 } else { 273 dput(dentry); 274 } 275 } 276out: 277 ceph_readdir_cache_release(&cache_ctl); 278 if (last) { 279 int ret; 280 di = ceph_dentry(last); 281 ret = note_last_dentry(dfi, last->d_name.name, last->d_name.len, 282 fpos_off(di->offset) + 1); 283 if (ret < 0) 284 err = ret; 285 dput(last); 286 /* last_name no longer match cache index */ 287 if (dfi->readdir_cache_idx >= 0) { 288 dfi->readdir_cache_idx = -1; 289 dfi->dir_release_count = 0; 290 } 291 } 292 return err; 293} 294 295static bool need_send_readdir(struct ceph_dir_file_info *dfi, loff_t pos) 296{ 297 if (!dfi->last_readdir) 298 return true; 299 if (is_hash_order(pos)) 300 return !ceph_frag_contains_value(dfi->frag, fpos_hash(pos)); 301 else 302 return dfi->frag != fpos_frag(pos); 303} 304 305static int ceph_readdir(struct file *file, struct dir_context *ctx) 306{ 307 struct ceph_dir_file_info *dfi = file->private_data; 308 struct inode *inode = file_inode(file); 309 struct ceph_inode_info *ci = ceph_inode(inode); 310 struct ceph_fs_client *fsc = ceph_inode_to_client(inode); 311 struct ceph_mds_client *mdsc = fsc->mdsc; 312 int i; 313 int err; 314 unsigned frag = -1; 315 struct ceph_mds_reply_info_parsed *rinfo; 316 317 dout("readdir %p file %p pos %llx\n", inode, file, ctx->pos); 318 if (dfi->file_info.flags & CEPH_F_ATEND) 319 return 0; 320 321 /* always start with . and .. */ 322 if (ctx->pos == 0) { 323 dout("readdir off 0 -> '.'\n"); 324 if (!dir_emit(ctx, ".", 1, ceph_present_inode(inode), 325 inode->i_mode >> 12)) 326 return 0; 327 ctx->pos = 1; 328 } 329 if (ctx->pos == 1) { 330 u64 ino; 331 struct dentry *dentry = file->f_path.dentry; 332 333 spin_lock(&dentry->d_lock); 334 ino = ceph_present_inode(dentry->d_parent->d_inode); 335 spin_unlock(&dentry->d_lock); 336 337 dout("readdir off 1 -> '..'\n"); 338 if (!dir_emit(ctx, "..", 2, ino, inode->i_mode >> 12)) 339 return 0; 340 ctx->pos = 2; 341 } 342 343 spin_lock(&ci->i_ceph_lock); 344 /* request Fx cap. if have Fx, we don't need to release Fs cap 345 * for later create/unlink. */ 346 __ceph_touch_fmode(ci, mdsc, CEPH_FILE_MODE_WR); 347 /* can we use the dcache? */ 348 if (ceph_test_mount_opt(fsc, DCACHE) && 349 !ceph_test_mount_opt(fsc, NOASYNCREADDIR) && 350 ceph_snap(inode) != CEPH_SNAPDIR && 351 __ceph_dir_is_complete_ordered(ci) && 352 __ceph_caps_issued_mask_metric(ci, CEPH_CAP_FILE_SHARED, 1)) { 353 int shared_gen = atomic_read(&ci->i_shared_gen); 354 355 spin_unlock(&ci->i_ceph_lock); 356 err = __dcache_readdir(file, ctx, shared_gen); 357 if (err != -EAGAIN) 358 return err; 359 } else { 360 spin_unlock(&ci->i_ceph_lock); 361 } 362 363 /* proceed with a normal readdir */ 364more: 365 /* do we have the correct frag content buffered? */ 366 if (need_send_readdir(dfi, ctx->pos)) { 367 struct ceph_mds_request *req; 368 int op = ceph_snap(inode) == CEPH_SNAPDIR ? 369 CEPH_MDS_OP_LSSNAP : CEPH_MDS_OP_READDIR; 370 371 /* discard old result, if any */ 372 if (dfi->last_readdir) { 373 ceph_mdsc_put_request(dfi->last_readdir); 374 dfi->last_readdir = NULL; 375 } 376 377 if (is_hash_order(ctx->pos)) { 378 /* fragtree isn't always accurate. choose frag 379 * based on previous reply when possible. */ 380 if (frag == (unsigned)-1) 381 frag = ceph_choose_frag(ci, fpos_hash(ctx->pos), 382 NULL, NULL); 383 } else { 384 frag = fpos_frag(ctx->pos); 385 } 386 387 dout("readdir fetching %llx.%llx frag %x offset '%s'\n", 388 ceph_vinop(inode), frag, dfi->last_name); 389 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS); 390 if (IS_ERR(req)) 391 return PTR_ERR(req); 392 err = ceph_alloc_readdir_reply_buffer(req, inode); 393 if (err) { 394 ceph_mdsc_put_request(req); 395 return err; 396 } 397 /* hints to request -> mds selection code */ 398 req->r_direct_mode = USE_AUTH_MDS; 399 if (op == CEPH_MDS_OP_READDIR) { 400 req->r_direct_hash = ceph_frag_value(frag); 401 __set_bit(CEPH_MDS_R_DIRECT_IS_HASH, &req->r_req_flags); 402 req->r_inode_drop = CEPH_CAP_FILE_EXCL; 403 } 404 if (dfi->last_name) { 405 req->r_path2 = kstrdup(dfi->last_name, GFP_KERNEL); 406 if (!req->r_path2) { 407 ceph_mdsc_put_request(req); 408 return -ENOMEM; 409 } 410 } else if (is_hash_order(ctx->pos)) { 411 req->r_args.readdir.offset_hash = 412 cpu_to_le32(fpos_hash(ctx->pos)); 413 } 414 415 req->r_dir_release_cnt = dfi->dir_release_count; 416 req->r_dir_ordered_cnt = dfi->dir_ordered_count; 417 req->r_readdir_cache_idx = dfi->readdir_cache_idx; 418 req->r_readdir_offset = dfi->next_offset; 419 req->r_args.readdir.frag = cpu_to_le32(frag); 420 req->r_args.readdir.flags = 421 cpu_to_le16(CEPH_READDIR_REPLY_BITFLAGS); 422 423 req->r_inode = inode; 424 ihold(inode); 425 req->r_dentry = dget(file->f_path.dentry); 426 err = ceph_mdsc_do_request(mdsc, NULL, req); 427 if (err < 0) { 428 ceph_mdsc_put_request(req); 429 return err; 430 } 431 dout("readdir got and parsed readdir result=%d on " 432 "frag %x, end=%d, complete=%d, hash_order=%d\n", 433 err, frag, 434 (int)req->r_reply_info.dir_end, 435 (int)req->r_reply_info.dir_complete, 436 (int)req->r_reply_info.hash_order); 437 438 rinfo = &req->r_reply_info; 439 if (le32_to_cpu(rinfo->dir_dir->frag) != frag) { 440 frag = le32_to_cpu(rinfo->dir_dir->frag); 441 if (!rinfo->hash_order) { 442 dfi->next_offset = req->r_readdir_offset; 443 /* adjust ctx->pos to beginning of frag */ 444 ctx->pos = ceph_make_fpos(frag, 445 dfi->next_offset, 446 false); 447 } 448 } 449 450 dfi->frag = frag; 451 dfi->last_readdir = req; 452 453 if (test_bit(CEPH_MDS_R_DID_PREPOPULATE, &req->r_req_flags)) { 454 dfi->readdir_cache_idx = req->r_readdir_cache_idx; 455 if (dfi->readdir_cache_idx < 0) { 456 /* preclude from marking dir ordered */ 457 dfi->dir_ordered_count = 0; 458 } else if (ceph_frag_is_leftmost(frag) && 459 dfi->next_offset == 2) { 460 /* note dir version at start of readdir so 461 * we can tell if any dentries get dropped */ 462 dfi->dir_release_count = req->r_dir_release_cnt; 463 dfi->dir_ordered_count = req->r_dir_ordered_cnt; 464 } 465 } else { 466 dout("readdir !did_prepopulate\n"); 467 /* disable readdir cache */ 468 dfi->readdir_cache_idx = -1; 469 /* preclude from marking dir complete */ 470 dfi->dir_release_count = 0; 471 } 472 473 /* note next offset and last dentry name */ 474 if (rinfo->dir_nr > 0) { 475 struct ceph_mds_reply_dir_entry *rde = 476 rinfo->dir_entries + (rinfo->dir_nr-1); 477 unsigned next_offset = req->r_reply_info.dir_end ? 478 2 : (fpos_off(rde->offset) + 1); 479 err = note_last_dentry(dfi, rde->name, rde->name_len, 480 next_offset); 481 if (err) { 482 ceph_mdsc_put_request(dfi->last_readdir); 483 dfi->last_readdir = NULL; 484 return err; 485 } 486 } else if (req->r_reply_info.dir_end) { 487 dfi->next_offset = 2; 488 /* keep last name */ 489 } 490 } 491 492 rinfo = &dfi->last_readdir->r_reply_info; 493 dout("readdir frag %x num %d pos %llx chunk first %llx\n", 494 dfi->frag, rinfo->dir_nr, ctx->pos, 495 rinfo->dir_nr ? rinfo->dir_entries[0].offset : 0LL); 496 497 i = 0; 498 /* search start position */ 499 if (rinfo->dir_nr > 0) { 500 int step, nr = rinfo->dir_nr; 501 while (nr > 0) { 502 step = nr >> 1; 503 if (rinfo->dir_entries[i + step].offset < ctx->pos) { 504 i += step + 1; 505 nr -= step + 1; 506 } else { 507 nr = step; 508 } 509 } 510 } 511 for (; i < rinfo->dir_nr; i++) { 512 struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i; 513 514 BUG_ON(rde->offset < ctx->pos); 515 516 ctx->pos = rde->offset; 517 dout("readdir (%d/%d) -> %llx '%.*s' %p\n", 518 i, rinfo->dir_nr, ctx->pos, 519 rde->name_len, rde->name, &rde->inode.in); 520 521 BUG_ON(!rde->inode.in); 522 523 if (!dir_emit(ctx, rde->name, rde->name_len, 524 ceph_present_ino(inode->i_sb, le64_to_cpu(rde->inode.in->ino)), 525 le32_to_cpu(rde->inode.in->mode) >> 12)) { 526 /* 527 * NOTE: Here no need to put the 'dfi->last_readdir', 528 * because when dir_emit stops us it's most likely 529 * doesn't have enough memory, etc. So for next readdir 530 * it will continue. 531 */ 532 dout("filldir stopping us...\n"); 533 return 0; 534 } 535 ctx->pos++; 536 } 537 538 ceph_mdsc_put_request(dfi->last_readdir); 539 dfi->last_readdir = NULL; 540 541 if (dfi->next_offset > 2) { 542 frag = dfi->frag; 543 goto more; 544 } 545 546 /* more frags? */ 547 if (!ceph_frag_is_rightmost(dfi->frag)) { 548 frag = ceph_frag_next(dfi->frag); 549 if (is_hash_order(ctx->pos)) { 550 loff_t new_pos = ceph_make_fpos(ceph_frag_value(frag), 551 dfi->next_offset, true); 552 if (new_pos > ctx->pos) 553 ctx->pos = new_pos; 554 /* keep last_name */ 555 } else { 556 ctx->pos = ceph_make_fpos(frag, dfi->next_offset, 557 false); 558 kfree(dfi->last_name); 559 dfi->last_name = NULL; 560 } 561 dout("readdir next frag is %x\n", frag); 562 goto more; 563 } 564 dfi->file_info.flags |= CEPH_F_ATEND; 565 566 /* 567 * if dir_release_count still matches the dir, no dentries 568 * were released during the whole readdir, and we should have 569 * the complete dir contents in our cache. 570 */ 571 if (atomic64_read(&ci->i_release_count) == 572 dfi->dir_release_count) { 573 spin_lock(&ci->i_ceph_lock); 574 if (dfi->dir_ordered_count == 575 atomic64_read(&ci->i_ordered_count)) { 576 dout(" marking %p complete and ordered\n", inode); 577 /* use i_size to track number of entries in 578 * readdir cache */ 579 BUG_ON(dfi->readdir_cache_idx < 0); 580 i_size_write(inode, dfi->readdir_cache_idx * 581 sizeof(struct dentry*)); 582 } else { 583 dout(" marking %p complete\n", inode); 584 } 585 __ceph_dir_set_complete(ci, dfi->dir_release_count, 586 dfi->dir_ordered_count); 587 spin_unlock(&ci->i_ceph_lock); 588 } 589 590 dout("readdir %p file %p done.\n", inode, file); 591 return 0; 592} 593 594static void reset_readdir(struct ceph_dir_file_info *dfi) 595{ 596 if (dfi->last_readdir) { 597 ceph_mdsc_put_request(dfi->last_readdir); 598 dfi->last_readdir = NULL; 599 } 600 kfree(dfi->last_name); 601 dfi->last_name = NULL; 602 dfi->dir_release_count = 0; 603 dfi->readdir_cache_idx = -1; 604 dfi->next_offset = 2; /* compensate for . and .. */ 605 dfi->file_info.flags &= ~CEPH_F_ATEND; 606} 607 608/* 609 * discard buffered readdir content on seekdir(0), or seek to new frag, 610 * or seek prior to current chunk 611 */ 612static bool need_reset_readdir(struct ceph_dir_file_info *dfi, loff_t new_pos) 613{ 614 struct ceph_mds_reply_info_parsed *rinfo; 615 loff_t chunk_offset; 616 if (new_pos == 0) 617 return true; 618 if (is_hash_order(new_pos)) { 619 /* no need to reset last_name for a forward seek when 620 * dentries are sotred in hash order */ 621 } else if (dfi->frag != fpos_frag(new_pos)) { 622 return true; 623 } 624 rinfo = dfi->last_readdir ? &dfi->last_readdir->r_reply_info : NULL; 625 if (!rinfo || !rinfo->dir_nr) 626 return true; 627 chunk_offset = rinfo->dir_entries[0].offset; 628 return new_pos < chunk_offset || 629 is_hash_order(new_pos) != is_hash_order(chunk_offset); 630} 631 632static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int whence) 633{ 634 struct ceph_dir_file_info *dfi = file->private_data; 635 struct inode *inode = file->f_mapping->host; 636 loff_t retval; 637 638 inode_lock(inode); 639 retval = -EINVAL; 640 switch (whence) { 641 case SEEK_CUR: 642 offset += file->f_pos; 643 case SEEK_SET: 644 break; 645 case SEEK_END: 646 retval = -EOPNOTSUPP; 647 default: 648 goto out; 649 } 650 651 if (offset >= 0) { 652 if (need_reset_readdir(dfi, offset)) { 653 dout("dir_llseek dropping %p content\n", file); 654 reset_readdir(dfi); 655 } else if (is_hash_order(offset) && offset > file->f_pos) { 656 /* for hash offset, we don't know if a forward seek 657 * is within same frag */ 658 dfi->dir_release_count = 0; 659 dfi->readdir_cache_idx = -1; 660 } 661 662 if (offset != file->f_pos) { 663 file->f_pos = offset; 664 file->f_version = 0; 665 dfi->file_info.flags &= ~CEPH_F_ATEND; 666 } 667 retval = offset; 668 } 669out: 670 inode_unlock(inode); 671 return retval; 672} 673 674/* 675 * Handle lookups for the hidden .snap directory. 676 */ 677int ceph_handle_snapdir(struct ceph_mds_request *req, 678 struct dentry *dentry, int err) 679{ 680 struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 681 struct inode *parent = d_inode(dentry->d_parent); /* we hold i_mutex */ 682 683 /* .snap dir? */ 684 if (err == -ENOENT && 685 ceph_snap(parent) == CEPH_NOSNAP && 686 strcmp(dentry->d_name.name, 687 fsc->mount_options->snapdir_name) == 0) { 688 struct inode *inode = ceph_get_snapdir(parent); 689 dout("ENOENT on snapdir %p '%pd', linking to snapdir %p\n", 690 dentry, dentry, inode); 691 BUG_ON(!d_unhashed(dentry)); 692 d_add(dentry, inode); 693 err = 0; 694 } 695 return err; 696} 697 698/* 699 * Figure out final result of a lookup/open request. 700 * 701 * Mainly, make sure we return the final req->r_dentry (if it already 702 * existed) in place of the original VFS-provided dentry when they 703 * differ. 704 * 705 * Gracefully handle the case where the MDS replies with -ENOENT and 706 * no trace (which it may do, at its discretion, e.g., if it doesn't 707 * care to issue a lease on the negative dentry). 708 */ 709struct dentry *ceph_finish_lookup(struct ceph_mds_request *req, 710 struct dentry *dentry, int err) 711{ 712 if (err == -ENOENT) { 713 /* no trace? */ 714 err = 0; 715 if (!req->r_reply_info.head->is_dentry) { 716 dout("ENOENT and no trace, dentry %p inode %p\n", 717 dentry, d_inode(dentry)); 718 if (d_really_is_positive(dentry)) { 719 d_drop(dentry); 720 err = -ENOENT; 721 } else { 722 d_add(dentry, NULL); 723 } 724 } 725 } 726 if (err) 727 dentry = ERR_PTR(err); 728 else if (dentry != req->r_dentry) 729 dentry = dget(req->r_dentry); /* we got spliced */ 730 else 731 dentry = NULL; 732 return dentry; 733} 734 735static bool is_root_ceph_dentry(struct inode *inode, struct dentry *dentry) 736{ 737 return ceph_ino(inode) == CEPH_INO_ROOT && 738 strncmp(dentry->d_name.name, ".ceph", 5) == 0; 739} 740 741/* 742 * Look up a single dir entry. If there is a lookup intent, inform 743 * the MDS so that it gets our 'caps wanted' value in a single op. 744 */ 745static struct dentry *ceph_lookup(struct inode *dir, struct dentry *dentry, 746 unsigned int flags) 747{ 748 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb); 749 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(dir->i_sb); 750 struct ceph_mds_request *req; 751 int op; 752 int mask; 753 int err; 754 755 dout("lookup %p dentry %p '%pd'\n", 756 dir, dentry, dentry); 757 758 if (dentry->d_name.len > NAME_MAX) 759 return ERR_PTR(-ENAMETOOLONG); 760 761 /* can we conclude ENOENT locally? */ 762 if (d_really_is_negative(dentry)) { 763 struct ceph_inode_info *ci = ceph_inode(dir); 764 struct ceph_dentry_info *di = ceph_dentry(dentry); 765 766 spin_lock(&ci->i_ceph_lock); 767 dout(" dir %p flags are 0x%lx\n", dir, ci->i_ceph_flags); 768 if (strncmp(dentry->d_name.name, 769 fsc->mount_options->snapdir_name, 770 dentry->d_name.len) && 771 !is_root_ceph_dentry(dir, dentry) && 772 ceph_test_mount_opt(fsc, DCACHE) && 773 __ceph_dir_is_complete(ci) && 774 __ceph_caps_issued_mask_metric(ci, CEPH_CAP_FILE_SHARED, 1)) { 775 __ceph_touch_fmode(ci, mdsc, CEPH_FILE_MODE_RD); 776 spin_unlock(&ci->i_ceph_lock); 777 dout(" dir %p complete, -ENOENT\n", dir); 778 d_add(dentry, NULL); 779 di->lease_shared_gen = atomic_read(&ci->i_shared_gen); 780 return NULL; 781 } 782 spin_unlock(&ci->i_ceph_lock); 783 } 784 785 op = ceph_snap(dir) == CEPH_SNAPDIR ? 786 CEPH_MDS_OP_LOOKUPSNAP : CEPH_MDS_OP_LOOKUP; 787 req = ceph_mdsc_create_request(mdsc, op, USE_ANY_MDS); 788 if (IS_ERR(req)) 789 return ERR_CAST(req); 790 req->r_dentry = dget(dentry); 791 req->r_num_caps = 2; 792 793 mask = CEPH_STAT_CAP_INODE | CEPH_CAP_AUTH_SHARED; 794 if (ceph_security_xattr_wanted(dir)) 795 mask |= CEPH_CAP_XATTR_SHARED; 796 req->r_args.getattr.mask = cpu_to_le32(mask); 797 798 req->r_parent = dir; 799 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 800 err = ceph_mdsc_do_request(mdsc, NULL, req); 801 err = ceph_handle_snapdir(req, dentry, err); 802 dentry = ceph_finish_lookup(req, dentry, err); 803 ceph_mdsc_put_request(req); /* will dput(dentry) */ 804 dout("lookup result=%p\n", dentry); 805 return dentry; 806} 807 808/* 809 * If we do a create but get no trace back from the MDS, follow up with 810 * a lookup (the VFS expects us to link up the provided dentry). 811 */ 812int ceph_handle_notrace_create(struct inode *dir, struct dentry *dentry) 813{ 814 struct dentry *result = ceph_lookup(dir, dentry, 0); 815 816 if (result && !IS_ERR(result)) { 817 /* 818 * We created the item, then did a lookup, and found 819 * it was already linked to another inode we already 820 * had in our cache (and thus got spliced). To not 821 * confuse VFS (especially when inode is a directory), 822 * we don't link our dentry to that inode, return an 823 * error instead. 824 * 825 * This event should be rare and it happens only when 826 * we talk to old MDS. Recent MDS does not send traceless 827 * reply for request that creates new inode. 828 */ 829 d_drop(result); 830 return -ESTALE; 831 } 832 return PTR_ERR(result); 833} 834 835static int ceph_mknod(struct inode *dir, struct dentry *dentry, 836 umode_t mode, dev_t rdev) 837{ 838 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(dir->i_sb); 839 struct ceph_mds_request *req; 840 struct ceph_acl_sec_ctx as_ctx = {}; 841 int err; 842 843 if (ceph_snap(dir) != CEPH_NOSNAP) 844 return -EROFS; 845 846 if (ceph_quota_is_max_files_exceeded(dir)) { 847 err = -EDQUOT; 848 goto out; 849 } 850 851 err = ceph_pre_init_acls(dir, &mode, &as_ctx); 852 if (err < 0) 853 goto out; 854 err = ceph_security_init_secctx(dentry, mode, &as_ctx); 855 if (err < 0) 856 goto out; 857 858 dout("mknod in dir %p dentry %p mode 0%ho rdev %d\n", 859 dir, dentry, mode, rdev); 860 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_MKNOD, USE_AUTH_MDS); 861 if (IS_ERR(req)) { 862 err = PTR_ERR(req); 863 goto out; 864 } 865 req->r_dentry = dget(dentry); 866 req->r_num_caps = 2; 867 req->r_parent = dir; 868 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 869 req->r_args.mknod.mode = cpu_to_le32(mode); 870 req->r_args.mknod.rdev = cpu_to_le32(rdev); 871 req->r_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_AUTH_EXCL; 872 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 873 if (as_ctx.pagelist) { 874 req->r_pagelist = as_ctx.pagelist; 875 as_ctx.pagelist = NULL; 876 } 877 err = ceph_mdsc_do_request(mdsc, dir, req); 878 if (!err && !req->r_reply_info.head->is_dentry) 879 err = ceph_handle_notrace_create(dir, dentry); 880 ceph_mdsc_put_request(req); 881out: 882 if (!err) 883 ceph_init_inode_acls(d_inode(dentry), &as_ctx); 884 else 885 d_drop(dentry); 886 ceph_release_acl_sec_ctx(&as_ctx); 887 return err; 888} 889 890static int ceph_create(struct inode *dir, struct dentry *dentry, umode_t mode, 891 bool excl) 892{ 893 return ceph_mknod(dir, dentry, mode, 0); 894} 895 896static int ceph_symlink(struct inode *dir, struct dentry *dentry, 897 const char *dest) 898{ 899 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(dir->i_sb); 900 struct ceph_mds_request *req; 901 struct ceph_acl_sec_ctx as_ctx = {}; 902 int err; 903 904 if (ceph_snap(dir) != CEPH_NOSNAP) 905 return -EROFS; 906 907 if (ceph_quota_is_max_files_exceeded(dir)) { 908 err = -EDQUOT; 909 goto out; 910 } 911 912 err = ceph_security_init_secctx(dentry, S_IFLNK | 0777, &as_ctx); 913 if (err < 0) 914 goto out; 915 916 dout("symlink in dir %p dentry %p to '%s'\n", dir, dentry, dest); 917 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SYMLINK, USE_AUTH_MDS); 918 if (IS_ERR(req)) { 919 err = PTR_ERR(req); 920 goto out; 921 } 922 req->r_path2 = kstrdup(dest, GFP_KERNEL); 923 if (!req->r_path2) { 924 err = -ENOMEM; 925 ceph_mdsc_put_request(req); 926 goto out; 927 } 928 req->r_parent = dir; 929 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 930 req->r_dentry = dget(dentry); 931 req->r_num_caps = 2; 932 req->r_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_AUTH_EXCL; 933 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 934 if (as_ctx.pagelist) { 935 req->r_pagelist = as_ctx.pagelist; 936 as_ctx.pagelist = NULL; 937 } 938 err = ceph_mdsc_do_request(mdsc, dir, req); 939 if (!err && !req->r_reply_info.head->is_dentry) 940 err = ceph_handle_notrace_create(dir, dentry); 941 ceph_mdsc_put_request(req); 942out: 943 if (err) 944 d_drop(dentry); 945 ceph_release_acl_sec_ctx(&as_ctx); 946 return err; 947} 948 949static int ceph_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 950{ 951 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(dir->i_sb); 952 struct ceph_mds_request *req; 953 struct ceph_acl_sec_ctx as_ctx = {}; 954 int err = -EROFS; 955 int op; 956 957 if (ceph_snap(dir) == CEPH_SNAPDIR) { 958 /* mkdir .snap/foo is a MKSNAP */ 959 op = CEPH_MDS_OP_MKSNAP; 960 dout("mksnap dir %p snap '%pd' dn %p\n", dir, 961 dentry, dentry); 962 } else if (ceph_snap(dir) == CEPH_NOSNAP) { 963 dout("mkdir dir %p dn %p mode 0%ho\n", dir, dentry, mode); 964 op = CEPH_MDS_OP_MKDIR; 965 } else { 966 goto out; 967 } 968 969 if (op == CEPH_MDS_OP_MKDIR && 970 ceph_quota_is_max_files_exceeded(dir)) { 971 err = -EDQUOT; 972 goto out; 973 } 974 975 mode |= S_IFDIR; 976 err = ceph_pre_init_acls(dir, &mode, &as_ctx); 977 if (err < 0) 978 goto out; 979 err = ceph_security_init_secctx(dentry, mode, &as_ctx); 980 if (err < 0) 981 goto out; 982 983 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS); 984 if (IS_ERR(req)) { 985 err = PTR_ERR(req); 986 goto out; 987 } 988 989 req->r_dentry = dget(dentry); 990 req->r_num_caps = 2; 991 req->r_parent = dir; 992 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 993 req->r_args.mkdir.mode = cpu_to_le32(mode); 994 req->r_dentry_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_AUTH_EXCL; 995 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 996 if (as_ctx.pagelist) { 997 req->r_pagelist = as_ctx.pagelist; 998 as_ctx.pagelist = NULL; 999 } 1000 err = ceph_mdsc_do_request(mdsc, dir, req); 1001 if (!err && 1002 !req->r_reply_info.head->is_target && 1003 !req->r_reply_info.head->is_dentry) 1004 err = ceph_handle_notrace_create(dir, dentry); 1005 ceph_mdsc_put_request(req); 1006out: 1007 if (!err) 1008 ceph_init_inode_acls(d_inode(dentry), &as_ctx); 1009 else 1010 d_drop(dentry); 1011 ceph_release_acl_sec_ctx(&as_ctx); 1012 return err; 1013} 1014 1015static int ceph_link(struct dentry *old_dentry, struct inode *dir, 1016 struct dentry *dentry) 1017{ 1018 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(dir->i_sb); 1019 struct ceph_mds_request *req; 1020 int err; 1021 1022 if (ceph_snap(dir) != CEPH_NOSNAP) 1023 return -EROFS; 1024 1025 dout("link in dir %p old_dentry %p dentry %p\n", dir, 1026 old_dentry, dentry); 1027 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LINK, USE_AUTH_MDS); 1028 if (IS_ERR(req)) { 1029 d_drop(dentry); 1030 return PTR_ERR(req); 1031 } 1032 req->r_dentry = dget(dentry); 1033 req->r_num_caps = 2; 1034 req->r_old_dentry = dget(old_dentry); 1035 req->r_parent = dir; 1036 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 1037 req->r_dentry_drop = CEPH_CAP_FILE_SHARED; 1038 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 1039 /* release LINK_SHARED on source inode (mds will lock it) */ 1040 req->r_old_inode_drop = CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL; 1041 err = ceph_mdsc_do_request(mdsc, dir, req); 1042 if (err) { 1043 d_drop(dentry); 1044 } else if (!req->r_reply_info.head->is_dentry) { 1045 ihold(d_inode(old_dentry)); 1046 d_instantiate(dentry, d_inode(old_dentry)); 1047 } 1048 ceph_mdsc_put_request(req); 1049 return err; 1050} 1051 1052static void ceph_async_unlink_cb(struct ceph_mds_client *mdsc, 1053 struct ceph_mds_request *req) 1054{ 1055 int result = req->r_err ? req->r_err : 1056 le32_to_cpu(req->r_reply_info.head->result); 1057 1058 if (result == -EJUKEBOX) 1059 goto out; 1060 1061 /* If op failed, mark everyone involved for errors */ 1062 if (result) { 1063 int pathlen = 0; 1064 u64 base = 0; 1065 char *path = ceph_mdsc_build_path(req->r_dentry, &pathlen, 1066 &base, 0); 1067 1068 /* mark error on parent + clear complete */ 1069 mapping_set_error(req->r_parent->i_mapping, result); 1070 ceph_dir_clear_complete(req->r_parent); 1071 1072 /* drop the dentry -- we don't know its status */ 1073 if (!d_unhashed(req->r_dentry)) 1074 d_drop(req->r_dentry); 1075 1076 /* mark inode itself for an error (since metadata is bogus) */ 1077 mapping_set_error(req->r_old_inode->i_mapping, result); 1078 1079 pr_warn("ceph: async unlink failure path=(%llx)%s result=%d!\n", 1080 base, IS_ERR(path) ? "<<bad>>" : path, result); 1081 ceph_mdsc_free_path(path, pathlen); 1082 } 1083out: 1084 iput(req->r_old_inode); 1085 ceph_mdsc_release_dir_caps(req); 1086} 1087 1088static int get_caps_for_async_unlink(struct inode *dir, struct dentry *dentry) 1089{ 1090 struct ceph_inode_info *ci = ceph_inode(dir); 1091 struct ceph_dentry_info *di; 1092 int got = 0, want = CEPH_CAP_FILE_EXCL | CEPH_CAP_DIR_UNLINK; 1093 1094 spin_lock(&ci->i_ceph_lock); 1095 if ((__ceph_caps_issued(ci, NULL) & want) == want) { 1096 ceph_take_cap_refs(ci, want, false); 1097 got = want; 1098 } 1099 spin_unlock(&ci->i_ceph_lock); 1100 1101 /* If we didn't get anything, return 0 */ 1102 if (!got) 1103 return 0; 1104 1105 spin_lock(&dentry->d_lock); 1106 di = ceph_dentry(dentry); 1107 /* 1108 * - We are holding Fx, which implies Fs caps. 1109 * - Only support async unlink for primary linkage 1110 */ 1111 if (atomic_read(&ci->i_shared_gen) != di->lease_shared_gen || 1112 !(di->flags & CEPH_DENTRY_PRIMARY_LINK)) 1113 want = 0; 1114 spin_unlock(&dentry->d_lock); 1115 1116 /* Do we still want what we've got? */ 1117 if (want == got) 1118 return got; 1119 1120 ceph_put_cap_refs(ci, got); 1121 return 0; 1122} 1123 1124/* 1125 * rmdir and unlink are differ only by the metadata op code 1126 */ 1127static int ceph_unlink(struct inode *dir, struct dentry *dentry) 1128{ 1129 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb); 1130 struct ceph_mds_client *mdsc = fsc->mdsc; 1131 struct inode *inode = d_inode(dentry); 1132 struct ceph_mds_request *req; 1133 bool try_async = ceph_test_mount_opt(fsc, ASYNC_DIROPS); 1134 int err = -EROFS; 1135 int op; 1136 1137 if (ceph_snap(dir) == CEPH_SNAPDIR) { 1138 /* rmdir .snap/foo is RMSNAP */ 1139 dout("rmsnap dir %p '%pd' dn %p\n", dir, dentry, dentry); 1140 op = CEPH_MDS_OP_RMSNAP; 1141 } else if (ceph_snap(dir) == CEPH_NOSNAP) { 1142 dout("unlink/rmdir dir %p dn %p inode %p\n", 1143 dir, dentry, inode); 1144 op = d_is_dir(dentry) ? 1145 CEPH_MDS_OP_RMDIR : CEPH_MDS_OP_UNLINK; 1146 } else 1147 goto out; 1148retry: 1149 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS); 1150 if (IS_ERR(req)) { 1151 err = PTR_ERR(req); 1152 goto out; 1153 } 1154 req->r_dentry = dget(dentry); 1155 req->r_num_caps = 2; 1156 req->r_parent = dir; 1157 req->r_dentry_drop = CEPH_CAP_FILE_SHARED; 1158 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 1159 req->r_inode_drop = ceph_drop_caps_for_unlink(inode); 1160 1161 if (try_async && op == CEPH_MDS_OP_UNLINK && 1162 (req->r_dir_caps = get_caps_for_async_unlink(dir, dentry))) { 1163 dout("async unlink on %llu/%.*s caps=%s", ceph_ino(dir), 1164 dentry->d_name.len, dentry->d_name.name, 1165 ceph_cap_string(req->r_dir_caps)); 1166 set_bit(CEPH_MDS_R_ASYNC, &req->r_req_flags); 1167 req->r_callback = ceph_async_unlink_cb; 1168 req->r_old_inode = d_inode(dentry); 1169 ihold(req->r_old_inode); 1170 err = ceph_mdsc_submit_request(mdsc, dir, req); 1171 if (!err) { 1172 /* 1173 * We have enough caps, so we assume that the unlink 1174 * will succeed. Fix up the target inode and dcache. 1175 */ 1176 drop_nlink(inode); 1177 d_delete(dentry); 1178 } else if (err == -EJUKEBOX) { 1179 try_async = false; 1180 ceph_mdsc_put_request(req); 1181 goto retry; 1182 } 1183 } else { 1184 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 1185 err = ceph_mdsc_do_request(mdsc, dir, req); 1186 if (!err && !req->r_reply_info.head->is_dentry) 1187 d_delete(dentry); 1188 } 1189 1190 ceph_mdsc_put_request(req); 1191out: 1192 return err; 1193} 1194 1195static int ceph_rename(struct inode *old_dir, struct dentry *old_dentry, 1196 struct inode *new_dir, struct dentry *new_dentry, 1197 unsigned int flags) 1198{ 1199 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(old_dir->i_sb); 1200 struct ceph_mds_request *req; 1201 int op = CEPH_MDS_OP_RENAME; 1202 int err; 1203 1204 if (flags) 1205 return -EINVAL; 1206 1207 if (ceph_snap(old_dir) != ceph_snap(new_dir)) 1208 return -EXDEV; 1209 if (ceph_snap(old_dir) != CEPH_NOSNAP) { 1210 if (old_dir == new_dir && ceph_snap(old_dir) == CEPH_SNAPDIR) 1211 op = CEPH_MDS_OP_RENAMESNAP; 1212 else 1213 return -EROFS; 1214 } else if (old_dir != new_dir) { 1215 err = ceph_quota_check_rename(mdsc, d_inode(old_dentry), 1216 new_dir); 1217 if (err) 1218 return err; 1219 } 1220 1221 dout("rename dir %p dentry %p to dir %p dentry %p\n", 1222 old_dir, old_dentry, new_dir, new_dentry); 1223 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS); 1224 if (IS_ERR(req)) 1225 return PTR_ERR(req); 1226 ihold(old_dir); 1227 req->r_dentry = dget(new_dentry); 1228 req->r_num_caps = 2; 1229 req->r_old_dentry = dget(old_dentry); 1230 req->r_old_dentry_dir = old_dir; 1231 req->r_parent = new_dir; 1232 set_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags); 1233 req->r_old_dentry_drop = CEPH_CAP_FILE_SHARED; 1234 req->r_old_dentry_unless = CEPH_CAP_FILE_EXCL; 1235 req->r_dentry_drop = CEPH_CAP_FILE_SHARED; 1236 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 1237 /* release LINK_RDCACHE on source inode (mds will lock it) */ 1238 req->r_old_inode_drop = CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL; 1239 if (d_really_is_positive(new_dentry)) { 1240 req->r_inode_drop = 1241 ceph_drop_caps_for_unlink(d_inode(new_dentry)); 1242 } 1243 err = ceph_mdsc_do_request(mdsc, old_dir, req); 1244 if (!err && !req->r_reply_info.head->is_dentry) { 1245 /* 1246 * Normally d_move() is done by fill_trace (called by 1247 * do_request, above). If there is no trace, we need 1248 * to do it here. 1249 */ 1250 d_move(old_dentry, new_dentry); 1251 } 1252 ceph_mdsc_put_request(req); 1253 return err; 1254} 1255 1256/* 1257 * Move dentry to tail of mdsc->dentry_leases list when lease is updated. 1258 * Leases at front of the list will expire first. (Assume all leases have 1259 * similar duration) 1260 * 1261 * Called under dentry->d_lock. 1262 */ 1263void __ceph_dentry_lease_touch(struct ceph_dentry_info *di) 1264{ 1265 struct dentry *dn = di->dentry; 1266 struct ceph_mds_client *mdsc; 1267 1268 dout("dentry_lease_touch %p %p '%pd'\n", di, dn, dn); 1269 1270 di->flags |= CEPH_DENTRY_LEASE_LIST; 1271 if (di->flags & CEPH_DENTRY_SHRINK_LIST) { 1272 di->flags |= CEPH_DENTRY_REFERENCED; 1273 return; 1274 } 1275 1276 mdsc = ceph_sb_to_client(dn->d_sb)->mdsc; 1277 spin_lock(&mdsc->dentry_list_lock); 1278 list_move_tail(&di->lease_list, &mdsc->dentry_leases); 1279 spin_unlock(&mdsc->dentry_list_lock); 1280} 1281 1282static void __dentry_dir_lease_touch(struct ceph_mds_client* mdsc, 1283 struct ceph_dentry_info *di) 1284{ 1285 di->flags &= ~(CEPH_DENTRY_LEASE_LIST | CEPH_DENTRY_REFERENCED); 1286 di->lease_gen = 0; 1287 di->time = jiffies; 1288 list_move_tail(&di->lease_list, &mdsc->dentry_dir_leases); 1289} 1290 1291/* 1292 * When dir lease is used, add dentry to tail of mdsc->dentry_dir_leases 1293 * list if it's not in the list, otherwise set 'referenced' flag. 1294 * 1295 * Called under dentry->d_lock. 1296 */ 1297void __ceph_dentry_dir_lease_touch(struct ceph_dentry_info *di) 1298{ 1299 struct dentry *dn = di->dentry; 1300 struct ceph_mds_client *mdsc; 1301 1302 dout("dentry_dir_lease_touch %p %p '%pd' (offset 0x%llx)\n", 1303 di, dn, dn, di->offset); 1304 1305 if (!list_empty(&di->lease_list)) { 1306 if (di->flags & CEPH_DENTRY_LEASE_LIST) { 1307 /* don't remove dentry from dentry lease list 1308 * if its lease is valid */ 1309 if (__dentry_lease_is_valid(di)) 1310 return; 1311 } else { 1312 di->flags |= CEPH_DENTRY_REFERENCED; 1313 return; 1314 } 1315 } 1316 1317 if (di->flags & CEPH_DENTRY_SHRINK_LIST) { 1318 di->flags |= CEPH_DENTRY_REFERENCED; 1319 di->flags &= ~CEPH_DENTRY_LEASE_LIST; 1320 return; 1321 } 1322 1323 mdsc = ceph_sb_to_client(dn->d_sb)->mdsc; 1324 spin_lock(&mdsc->dentry_list_lock); 1325 __dentry_dir_lease_touch(mdsc, di), 1326 spin_unlock(&mdsc->dentry_list_lock); 1327} 1328 1329static void __dentry_lease_unlist(struct ceph_dentry_info *di) 1330{ 1331 struct ceph_mds_client *mdsc; 1332 if (di->flags & CEPH_DENTRY_SHRINK_LIST) 1333 return; 1334 if (list_empty(&di->lease_list)) 1335 return; 1336 1337 mdsc = ceph_sb_to_client(di->dentry->d_sb)->mdsc; 1338 spin_lock(&mdsc->dentry_list_lock); 1339 list_del_init(&di->lease_list); 1340 spin_unlock(&mdsc->dentry_list_lock); 1341} 1342 1343enum { 1344 KEEP = 0, 1345 DELETE = 1, 1346 TOUCH = 2, 1347 STOP = 4, 1348}; 1349 1350struct ceph_lease_walk_control { 1351 bool dir_lease; 1352 bool expire_dir_lease; 1353 unsigned long nr_to_scan; 1354 unsigned long dir_lease_ttl; 1355}; 1356 1357static unsigned long 1358__dentry_leases_walk(struct ceph_mds_client *mdsc, 1359 struct ceph_lease_walk_control *lwc, 1360 int (*check)(struct dentry*, void*)) 1361{ 1362 struct ceph_dentry_info *di, *tmp; 1363 struct dentry *dentry, *last = NULL; 1364 struct list_head* list; 1365 LIST_HEAD(dispose); 1366 unsigned long freed = 0; 1367 int ret = 0; 1368 1369 list = lwc->dir_lease ? &mdsc->dentry_dir_leases : &mdsc->dentry_leases; 1370 spin_lock(&mdsc->dentry_list_lock); 1371 list_for_each_entry_safe(di, tmp, list, lease_list) { 1372 if (!lwc->nr_to_scan) 1373 break; 1374 --lwc->nr_to_scan; 1375 1376 dentry = di->dentry; 1377 if (last == dentry) 1378 break; 1379 1380 if (!spin_trylock(&dentry->d_lock)) 1381 continue; 1382 1383 if (__lockref_is_dead(&dentry->d_lockref)) { 1384 list_del_init(&di->lease_list); 1385 goto next; 1386 } 1387 1388 ret = check(dentry, lwc); 1389 if (ret & TOUCH) { 1390 /* move it into tail of dir lease list */ 1391 __dentry_dir_lease_touch(mdsc, di); 1392 if (!last) 1393 last = dentry; 1394 } 1395 if (ret & DELETE) { 1396 /* stale lease */ 1397 di->flags &= ~CEPH_DENTRY_REFERENCED; 1398 if (dentry->d_lockref.count > 0) { 1399 /* update_dentry_lease() will re-add 1400 * it to lease list, or 1401 * ceph_d_delete() will return 1 when 1402 * last reference is dropped */ 1403 list_del_init(&di->lease_list); 1404 } else { 1405 di->flags |= CEPH_DENTRY_SHRINK_LIST; 1406 list_move_tail(&di->lease_list, &dispose); 1407 dget_dlock(dentry); 1408 } 1409 } 1410next: 1411 spin_unlock(&dentry->d_lock); 1412 if (ret & STOP) 1413 break; 1414 } 1415 spin_unlock(&mdsc->dentry_list_lock); 1416 1417 while (!list_empty(&dispose)) { 1418 di = list_first_entry(&dispose, struct ceph_dentry_info, 1419 lease_list); 1420 dentry = di->dentry; 1421 spin_lock(&dentry->d_lock); 1422 1423 list_del_init(&di->lease_list); 1424 di->flags &= ~CEPH_DENTRY_SHRINK_LIST; 1425 if (di->flags & CEPH_DENTRY_REFERENCED) { 1426 spin_lock(&mdsc->dentry_list_lock); 1427 if (di->flags & CEPH_DENTRY_LEASE_LIST) { 1428 list_add_tail(&di->lease_list, 1429 &mdsc->dentry_leases); 1430 } else { 1431 __dentry_dir_lease_touch(mdsc, di); 1432 } 1433 spin_unlock(&mdsc->dentry_list_lock); 1434 } else { 1435 freed++; 1436 } 1437 1438 spin_unlock(&dentry->d_lock); 1439 /* ceph_d_delete() does the trick */ 1440 dput(dentry); 1441 } 1442 return freed; 1443} 1444 1445static int __dentry_lease_check(struct dentry *dentry, void *arg) 1446{ 1447 struct ceph_dentry_info *di = ceph_dentry(dentry); 1448 int ret; 1449 1450 if (__dentry_lease_is_valid(di)) 1451 return STOP; 1452 ret = __dir_lease_try_check(dentry); 1453 if (ret == -EBUSY) 1454 return KEEP; 1455 if (ret > 0) 1456 return TOUCH; 1457 return DELETE; 1458} 1459 1460static int __dir_lease_check(struct dentry *dentry, void *arg) 1461{ 1462 struct ceph_lease_walk_control *lwc = arg; 1463 struct ceph_dentry_info *di = ceph_dentry(dentry); 1464 1465 int ret = __dir_lease_try_check(dentry); 1466 if (ret == -EBUSY) 1467 return KEEP; 1468 if (ret > 0) { 1469 if (time_before(jiffies, di->time + lwc->dir_lease_ttl)) 1470 return STOP; 1471 /* Move dentry to tail of dir lease list if we don't want 1472 * to delete it. So dentries in the list are checked in a 1473 * round robin manner */ 1474 if (!lwc->expire_dir_lease) 1475 return TOUCH; 1476 if (dentry->d_lockref.count > 0 || 1477 (di->flags & CEPH_DENTRY_REFERENCED)) 1478 return TOUCH; 1479 /* invalidate dir lease */ 1480 di->lease_shared_gen = 0; 1481 } 1482 return DELETE; 1483} 1484 1485int ceph_trim_dentries(struct ceph_mds_client *mdsc) 1486{ 1487 struct ceph_lease_walk_control lwc; 1488 unsigned long count; 1489 unsigned long freed; 1490 1491 spin_lock(&mdsc->caps_list_lock); 1492 if (mdsc->caps_use_max > 0 && 1493 mdsc->caps_use_count > mdsc->caps_use_max) 1494 count = mdsc->caps_use_count - mdsc->caps_use_max; 1495 else 1496 count = 0; 1497 spin_unlock(&mdsc->caps_list_lock); 1498 1499 lwc.dir_lease = false; 1500 lwc.nr_to_scan = CEPH_CAPS_PER_RELEASE * 2; 1501 freed = __dentry_leases_walk(mdsc, &lwc, __dentry_lease_check); 1502 if (!lwc.nr_to_scan) /* more invalid leases */ 1503 return -EAGAIN; 1504 1505 if (lwc.nr_to_scan < CEPH_CAPS_PER_RELEASE) 1506 lwc.nr_to_scan = CEPH_CAPS_PER_RELEASE; 1507 1508 lwc.dir_lease = true; 1509 lwc.expire_dir_lease = freed < count; 1510 lwc.dir_lease_ttl = mdsc->fsc->mount_options->caps_wanted_delay_max * HZ; 1511 freed +=__dentry_leases_walk(mdsc, &lwc, __dir_lease_check); 1512 if (!lwc.nr_to_scan) /* more to check */ 1513 return -EAGAIN; 1514 1515 return freed > 0 ? 1 : 0; 1516} 1517 1518/* 1519 * Ensure a dentry lease will no longer revalidate. 1520 */ 1521void ceph_invalidate_dentry_lease(struct dentry *dentry) 1522{ 1523 struct ceph_dentry_info *di = ceph_dentry(dentry); 1524 spin_lock(&dentry->d_lock); 1525 di->time = jiffies; 1526 di->lease_shared_gen = 0; 1527 di->flags &= ~CEPH_DENTRY_PRIMARY_LINK; 1528 __dentry_lease_unlist(di); 1529 spin_unlock(&dentry->d_lock); 1530} 1531 1532/* 1533 * Check if dentry lease is valid. If not, delete the lease. Try to 1534 * renew if the least is more than half up. 1535 */ 1536static bool __dentry_lease_is_valid(struct ceph_dentry_info *di) 1537{ 1538 struct ceph_mds_session *session; 1539 1540 if (!di->lease_gen) 1541 return false; 1542 1543 session = di->lease_session; 1544 if (session) { 1545 u32 gen; 1546 unsigned long ttl; 1547 1548 spin_lock(&session->s_gen_ttl_lock); 1549 gen = session->s_cap_gen; 1550 ttl = session->s_cap_ttl; 1551 spin_unlock(&session->s_gen_ttl_lock); 1552 1553 if (di->lease_gen == gen && 1554 time_before(jiffies, ttl) && 1555 time_before(jiffies, di->time)) 1556 return true; 1557 } 1558 di->lease_gen = 0; 1559 return false; 1560} 1561 1562static int dentry_lease_is_valid(struct dentry *dentry, unsigned int flags) 1563{ 1564 struct ceph_dentry_info *di; 1565 struct ceph_mds_session *session = NULL; 1566 u32 seq = 0; 1567 int valid = 0; 1568 1569 spin_lock(&dentry->d_lock); 1570 di = ceph_dentry(dentry); 1571 if (di && __dentry_lease_is_valid(di)) { 1572 valid = 1; 1573 1574 if (di->lease_renew_after && 1575 time_after(jiffies, di->lease_renew_after)) { 1576 /* 1577 * We should renew. If we're in RCU walk mode 1578 * though, we can't do that so just return 1579 * -ECHILD. 1580 */ 1581 if (flags & LOOKUP_RCU) { 1582 valid = -ECHILD; 1583 } else { 1584 session = ceph_get_mds_session(di->lease_session); 1585 seq = di->lease_seq; 1586 di->lease_renew_after = 0; 1587 di->lease_renew_from = jiffies; 1588 } 1589 } 1590 } 1591 spin_unlock(&dentry->d_lock); 1592 1593 if (session) { 1594 ceph_mdsc_lease_send_msg(session, dentry, 1595 CEPH_MDS_LEASE_RENEW, seq); 1596 ceph_put_mds_session(session); 1597 } 1598 dout("dentry_lease_is_valid - dentry %p = %d\n", dentry, valid); 1599 return valid; 1600} 1601 1602/* 1603 * Called under dentry->d_lock. 1604 */ 1605static int __dir_lease_try_check(const struct dentry *dentry) 1606{ 1607 struct ceph_dentry_info *di = ceph_dentry(dentry); 1608 struct inode *dir; 1609 struct ceph_inode_info *ci; 1610 int valid = 0; 1611 1612 if (!di->lease_shared_gen) 1613 return 0; 1614 if (IS_ROOT(dentry)) 1615 return 0; 1616 1617 dir = d_inode(dentry->d_parent); 1618 ci = ceph_inode(dir); 1619 1620 if (spin_trylock(&ci->i_ceph_lock)) { 1621 if (atomic_read(&ci->i_shared_gen) == di->lease_shared_gen && 1622 __ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 0)) 1623 valid = 1; 1624 spin_unlock(&ci->i_ceph_lock); 1625 } else { 1626 valid = -EBUSY; 1627 } 1628 1629 if (!valid) 1630 di->lease_shared_gen = 0; 1631 return valid; 1632} 1633 1634/* 1635 * Check if directory-wide content lease/cap is valid. 1636 */ 1637static int dir_lease_is_valid(struct inode *dir, struct dentry *dentry, 1638 struct ceph_mds_client *mdsc) 1639{ 1640 struct ceph_inode_info *ci = ceph_inode(dir); 1641 int valid; 1642 int shared_gen; 1643 1644 spin_lock(&ci->i_ceph_lock); 1645 valid = __ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1); 1646 if (valid) { 1647 __ceph_touch_fmode(ci, mdsc, CEPH_FILE_MODE_RD); 1648 shared_gen = atomic_read(&ci->i_shared_gen); 1649 } 1650 spin_unlock(&ci->i_ceph_lock); 1651 if (valid) { 1652 struct ceph_dentry_info *di; 1653 spin_lock(&dentry->d_lock); 1654 di = ceph_dentry(dentry); 1655 if (dir == d_inode(dentry->d_parent) && 1656 di && di->lease_shared_gen == shared_gen) 1657 __ceph_dentry_dir_lease_touch(di); 1658 else 1659 valid = 0; 1660 spin_unlock(&dentry->d_lock); 1661 } 1662 dout("dir_lease_is_valid dir %p v%u dentry %p = %d\n", 1663 dir, (unsigned)atomic_read(&ci->i_shared_gen), dentry, valid); 1664 return valid; 1665} 1666 1667/* 1668 * Check if cached dentry can be trusted. 1669 */ 1670static int ceph_d_revalidate(struct dentry *dentry, unsigned int flags) 1671{ 1672 int valid = 0; 1673 struct dentry *parent; 1674 struct inode *dir, *inode; 1675 struct ceph_mds_client *mdsc; 1676 1677 if (flags & LOOKUP_RCU) { 1678 parent = READ_ONCE(dentry->d_parent); 1679 dir = d_inode_rcu(parent); 1680 if (!dir) 1681 return -ECHILD; 1682 inode = d_inode_rcu(dentry); 1683 } else { 1684 parent = dget_parent(dentry); 1685 dir = d_inode(parent); 1686 inode = d_inode(dentry); 1687 } 1688 1689 dout("d_revalidate %p '%pd' inode %p offset 0x%llx\n", dentry, 1690 dentry, inode, ceph_dentry(dentry)->offset); 1691 1692 mdsc = ceph_sb_to_client(dir->i_sb)->mdsc; 1693 1694 /* always trust cached snapped dentries, snapdir dentry */ 1695 if (ceph_snap(dir) != CEPH_NOSNAP) { 1696 dout("d_revalidate %p '%pd' inode %p is SNAPPED\n", dentry, 1697 dentry, inode); 1698 valid = 1; 1699 } else if (inode && ceph_snap(inode) == CEPH_SNAPDIR) { 1700 valid = 1; 1701 } else { 1702 valid = dentry_lease_is_valid(dentry, flags); 1703 if (valid == -ECHILD) 1704 return valid; 1705 if (valid || dir_lease_is_valid(dir, dentry, mdsc)) { 1706 if (inode) 1707 valid = ceph_is_any_caps(inode); 1708 else 1709 valid = 1; 1710 } 1711 } 1712 1713 if (!valid) { 1714 struct ceph_mds_request *req; 1715 int op, err; 1716 u32 mask; 1717 1718 if (flags & LOOKUP_RCU) 1719 return -ECHILD; 1720 1721 percpu_counter_inc(&mdsc->metric.d_lease_mis); 1722 1723 op = ceph_snap(dir) == CEPH_SNAPDIR ? 1724 CEPH_MDS_OP_LOOKUPSNAP : CEPH_MDS_OP_LOOKUP; 1725 req = ceph_mdsc_create_request(mdsc, op, USE_ANY_MDS); 1726 if (!IS_ERR(req)) { 1727 req->r_dentry = dget(dentry); 1728 req->r_num_caps = 2; 1729 req->r_parent = dir; 1730 1731 mask = CEPH_STAT_CAP_INODE | CEPH_CAP_AUTH_SHARED; 1732 if (ceph_security_xattr_wanted(dir)) 1733 mask |= CEPH_CAP_XATTR_SHARED; 1734 req->r_args.getattr.mask = cpu_to_le32(mask); 1735 1736 err = ceph_mdsc_do_request(mdsc, NULL, req); 1737 switch (err) { 1738 case 0: 1739 if (d_really_is_positive(dentry) && 1740 d_inode(dentry) == req->r_target_inode) 1741 valid = 1; 1742 break; 1743 case -ENOENT: 1744 if (d_really_is_negative(dentry)) 1745 valid = 1; 1746 fallthrough; 1747 default: 1748 break; 1749 } 1750 ceph_mdsc_put_request(req); 1751 dout("d_revalidate %p lookup result=%d\n", 1752 dentry, err); 1753 } 1754 } else { 1755 percpu_counter_inc(&mdsc->metric.d_lease_hit); 1756 } 1757 1758 dout("d_revalidate %p %s\n", dentry, valid ? "valid" : "invalid"); 1759 if (!valid) 1760 ceph_dir_clear_complete(dir); 1761 1762 if (!(flags & LOOKUP_RCU)) 1763 dput(parent); 1764 return valid; 1765} 1766 1767/* 1768 * Delete unused dentry that doesn't have valid lease 1769 * 1770 * Called under dentry->d_lock. 1771 */ 1772static int ceph_d_delete(const struct dentry *dentry) 1773{ 1774 struct ceph_dentry_info *di; 1775 1776 /* won't release caps */ 1777 if (d_really_is_negative(dentry)) 1778 return 0; 1779 if (ceph_snap(d_inode(dentry)) != CEPH_NOSNAP) 1780 return 0; 1781 /* vaild lease? */ 1782 di = ceph_dentry(dentry); 1783 if (di) { 1784 if (__dentry_lease_is_valid(di)) 1785 return 0; 1786 if (__dir_lease_try_check(dentry)) 1787 return 0; 1788 } 1789 return 1; 1790} 1791 1792/* 1793 * Release our ceph_dentry_info. 1794 */ 1795static void ceph_d_release(struct dentry *dentry) 1796{ 1797 struct ceph_dentry_info *di = ceph_dentry(dentry); 1798 struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 1799 1800 dout("d_release %p\n", dentry); 1801 1802 atomic64_dec(&fsc->mdsc->metric.total_dentries); 1803 1804 spin_lock(&dentry->d_lock); 1805 __dentry_lease_unlist(di); 1806 dentry->d_fsdata = NULL; 1807 spin_unlock(&dentry->d_lock); 1808 1809 ceph_put_mds_session(di->lease_session); 1810 kmem_cache_free(ceph_dentry_cachep, di); 1811} 1812 1813/* 1814 * When the VFS prunes a dentry from the cache, we need to clear the 1815 * complete flag on the parent directory. 1816 * 1817 * Called under dentry->d_lock. 1818 */ 1819static void ceph_d_prune(struct dentry *dentry) 1820{ 1821 struct ceph_inode_info *dir_ci; 1822 struct ceph_dentry_info *di; 1823 1824 dout("ceph_d_prune %pd %p\n", dentry, dentry); 1825 1826 /* do we have a valid parent? */ 1827 if (IS_ROOT(dentry)) 1828 return; 1829 1830 /* we hold d_lock, so d_parent is stable */ 1831 dir_ci = ceph_inode(d_inode(dentry->d_parent)); 1832 if (dir_ci->i_vino.snap == CEPH_SNAPDIR) 1833 return; 1834 1835 /* who calls d_delete() should also disable dcache readdir */ 1836 if (d_really_is_negative(dentry)) 1837 return; 1838 1839 /* d_fsdata does not get cleared until d_release */ 1840 if (!d_unhashed(dentry)) { 1841 __ceph_dir_clear_complete(dir_ci); 1842 return; 1843 } 1844 1845 /* Disable dcache readdir just in case that someone called d_drop() 1846 * or d_invalidate(), but MDS didn't revoke CEPH_CAP_FILE_SHARED 1847 * properly (dcache readdir is still enabled) */ 1848 di = ceph_dentry(dentry); 1849 if (di->offset > 0 && 1850 di->lease_shared_gen == atomic_read(&dir_ci->i_shared_gen)) 1851 __ceph_dir_clear_ordered(dir_ci); 1852} 1853 1854/* 1855 * read() on a dir. This weird interface hack only works if mounted 1856 * with '-o dirstat'. 1857 */ 1858static ssize_t ceph_read_dir(struct file *file, char __user *buf, size_t size, 1859 loff_t *ppos) 1860{ 1861 struct ceph_dir_file_info *dfi = file->private_data; 1862 struct inode *inode = file_inode(file); 1863 struct ceph_inode_info *ci = ceph_inode(inode); 1864 int left; 1865 const int bufsize = 1024; 1866 1867 if (!ceph_test_mount_opt(ceph_sb_to_client(inode->i_sb), DIRSTAT)) 1868 return -EISDIR; 1869 1870 if (!dfi->dir_info) { 1871 dfi->dir_info = kmalloc(bufsize, GFP_KERNEL); 1872 if (!dfi->dir_info) 1873 return -ENOMEM; 1874 dfi->dir_info_len = 1875 snprintf(dfi->dir_info, bufsize, 1876 "entries: %20lld\n" 1877 " files: %20lld\n" 1878 " subdirs: %20lld\n" 1879 "rentries: %20lld\n" 1880 " rfiles: %20lld\n" 1881 " rsubdirs: %20lld\n" 1882 "rbytes: %20lld\n" 1883 "rctime: %10lld.%09ld\n", 1884 ci->i_files + ci->i_subdirs, 1885 ci->i_files, 1886 ci->i_subdirs, 1887 ci->i_rfiles + ci->i_rsubdirs, 1888 ci->i_rfiles, 1889 ci->i_rsubdirs, 1890 ci->i_rbytes, 1891 ci->i_rctime.tv_sec, 1892 ci->i_rctime.tv_nsec); 1893 } 1894 1895 if (*ppos >= dfi->dir_info_len) 1896 return 0; 1897 size = min_t(unsigned, size, dfi->dir_info_len-*ppos); 1898 left = copy_to_user(buf, dfi->dir_info + *ppos, size); 1899 if (left == size) 1900 return -EFAULT; 1901 *ppos += (size - left); 1902 return size - left; 1903} 1904 1905 1906 1907/* 1908 * Return name hash for a given dentry. This is dependent on 1909 * the parent directory's hash function. 1910 */ 1911unsigned ceph_dentry_hash(struct inode *dir, struct dentry *dn) 1912{ 1913 struct ceph_inode_info *dci = ceph_inode(dir); 1914 unsigned hash; 1915 1916 switch (dci->i_dir_layout.dl_dir_hash) { 1917 case 0: /* for backward compat */ 1918 case CEPH_STR_HASH_LINUX: 1919 return dn->d_name.hash; 1920 1921 default: 1922 spin_lock(&dn->d_lock); 1923 hash = ceph_str_hash(dci->i_dir_layout.dl_dir_hash, 1924 dn->d_name.name, dn->d_name.len); 1925 spin_unlock(&dn->d_lock); 1926 return hash; 1927 } 1928} 1929 1930const struct file_operations ceph_dir_fops = { 1931 .read = ceph_read_dir, 1932 .iterate = ceph_readdir, 1933 .llseek = ceph_dir_llseek, 1934 .open = ceph_open, 1935 .release = ceph_release, 1936 .unlocked_ioctl = ceph_ioctl, 1937 .compat_ioctl = compat_ptr_ioctl, 1938 .fsync = ceph_fsync, 1939 .lock = ceph_lock, 1940 .flock = ceph_flock, 1941}; 1942 1943const struct file_operations ceph_snapdir_fops = { 1944 .iterate = ceph_readdir, 1945 .llseek = ceph_dir_llseek, 1946 .open = ceph_open, 1947 .release = ceph_release, 1948}; 1949 1950const struct inode_operations ceph_dir_iops = { 1951 .lookup = ceph_lookup, 1952 .permission = ceph_permission, 1953 .getattr = ceph_getattr, 1954 .setattr = ceph_setattr, 1955 .listxattr = ceph_listxattr, 1956 .get_acl = ceph_get_acl, 1957 .set_acl = ceph_set_acl, 1958 .mknod = ceph_mknod, 1959 .symlink = ceph_symlink, 1960 .mkdir = ceph_mkdir, 1961 .link = ceph_link, 1962 .unlink = ceph_unlink, 1963 .rmdir = ceph_unlink, 1964 .rename = ceph_rename, 1965 .create = ceph_create, 1966 .atomic_open = ceph_atomic_open, 1967}; 1968 1969const struct inode_operations ceph_snapdir_iops = { 1970 .lookup = ceph_lookup, 1971 .permission = ceph_permission, 1972 .getattr = ceph_getattr, 1973 .mkdir = ceph_mkdir, 1974 .rmdir = ceph_unlink, 1975 .rename = ceph_rename, 1976}; 1977 1978const struct dentry_operations ceph_dentry_ops = { 1979 .d_revalidate = ceph_d_revalidate, 1980 .d_delete = ceph_d_delete, 1981 .d_release = ceph_d_release, 1982 .d_prune = ceph_d_prune, 1983 .d_init = ceph_d_init, 1984}; 1985