1// SPDX-License-Identifier: GPL-2.0 2/* 3 * fs/hmdfs/hmdfs_dentryfile.c 4 * 5 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. 6 */ 7 8#include "hmdfs_dentryfile.h" 9 10#include <linux/ctype.h> 11#include <linux/file.h> 12#include <linux/mount.h> 13#include <linux/pagemap.h> 14#include <linux/slab.h> 15#include <linux/xattr.h> 16#include <linux/err.h> 17 18#include "authority/authentication.h" 19#include "comm/transport.h" 20#include "hmdfs_client.h" 21#include "hmdfs_device_view.h" 22#include "hmdfs_merge_view.h" 23 24/* Hashing code copied from f2fs */ 25#define HMDFS_HASH_COL_BIT ((0x1ULL) << 63) 26#define DELTA 0x9E3779B9 27 28static bool is_dot_dotdot(const unsigned char *name, __u32 len) 29{ 30 if (len == 1 && name[0] == '.') 31 return true; 32 33 if (len == 2 && name[0] == '.' && name[1] == '.') 34 return true; 35 36 return false; 37} 38 39static void str2hashbuf(const unsigned char *msg, size_t len, unsigned int *buf, 40 int num, bool case_sense) 41{ 42 unsigned int pad, val; 43 int i; 44 unsigned char c; 45 46 pad = (__u32)len | ((__u32)len << 8); 47 pad |= pad << 16; 48 49 val = pad; 50 if (len > (size_t)num * 4) 51 len = (size_t)num * 4; 52 for (i = 0; i < len; i++) { 53 if ((i % 4) == 0) 54 val = pad; 55 c = msg[i]; 56 if (!case_sense) 57 c = tolower(c); 58 val = c + (val << 8); 59 if ((i % 4) == 3) { 60 *buf++ = val; 61 val = pad; 62 num--; 63 } 64 } 65 if (--num >= 0) 66 *buf++ = val; 67 while (--num >= 0) 68 *buf++ = pad; 69} 70 71static void tea_transform(unsigned int buf[4], unsigned int const in[]) 72{ 73 __u32 sum = 0; 74 __u32 b0 = buf[0], b1 = buf[1]; 75 __u32 a = in[0], b = in[1], c = in[2], d = in[3]; 76 int n = 16; 77 78 do { 79 sum += DELTA; 80 b0 += ((b1 << 4) + a) ^ (b1 + sum) ^ ((b1 >> 5) + b); 81 b1 += ((b0 << 4) + c) ^ (b0 + sum) ^ ((b0 >> 5) + d); 82 } while (--n); 83 84 buf[0] += b0; 85 buf[1] += b1; 86} 87 88__u32 hmdfs_dentry_hash(const struct qstr *qstr, bool case_sense) 89{ 90 __u32 hash; 91 __u32 hmdfs_hash; 92 const unsigned char *p = qstr->name; 93 __u32 len = qstr->len; 94 __u32 in[8], buf[4]; 95 96 if (is_dot_dotdot(p, len)) 97 return 0; 98 99 /* Initialize the default seed for the hash checksum functions */ 100 buf[0] = 0x67452301; 101 buf[1] = 0xefcdab89; 102 buf[2] = 0x98badcfe; 103 buf[3] = 0x10325476; 104 105 while (1) { 106 str2hashbuf(p, len, in, 4, case_sense); 107 tea_transform(buf, in); 108 p += 16; 109 if (len <= 16) 110 break; 111 len -= 16; 112 } 113 hash = buf[0]; 114 hmdfs_hash = hash & ~HMDFS_HASH_COL_BIT; 115 return hmdfs_hash; 116} 117 118static atomic_t curr_ino = ATOMIC_INIT(INUNUMBER_START); 119int get_inonumber(void) 120{ 121 return atomic_inc_return(&curr_ino); 122} 123 124static int hmdfs_get_root_dentry_type(struct dentry *dentry, int *is_root) 125{ 126 struct hmdfs_dentry_info *d_info = hmdfs_d(dentry); 127 128 *is_root = 1; 129 switch (d_info->dentry_type) { 130 case HMDFS_LAYER_OTHER_LOCAL: 131 *is_root = 0; 132 fallthrough; 133 case HMDFS_LAYER_SECOND_LOCAL: 134 return HMDFS_LAYER_SECOND_LOCAL; 135 case HMDFS_LAYER_OTHER_CLOUD: 136 *is_root = 0; 137 fallthrough; 138 case HMDFS_LAYER_SECOND_CLOUD: 139 return HMDFS_LAYER_SECOND_CLOUD; 140 case HMDFS_LAYER_OTHER_REMOTE: 141 *is_root = 0; 142 fallthrough; 143 case HMDFS_LAYER_SECOND_REMOTE: 144 return HMDFS_LAYER_SECOND_REMOTE; 145 default: 146 hmdfs_info("Unexpected dentry type %d", d_info->dentry_type); 147 return -EINVAL; 148 } 149} 150 151static int prepend(char **buffer, int *buflen, const char *str, int namelen) 152{ 153 *buflen -= namelen; 154 if (*buflen < 0) 155 return -ENAMETOOLONG; 156 *buffer -= namelen; 157 memcpy(*buffer, str, namelen); 158 return 0; 159} 160 161static int prepend_name(char **buffer, int *buflen, const struct qstr *name) 162{ 163 const char *dname = name->name; 164 u32 dlen = name->len; 165 char *p = NULL; 166 167 *buflen -= dlen + 1; 168 if (*buflen < 0) 169 return -ENAMETOOLONG; 170 p = *buffer -= dlen + 1; 171 *p++ = '/'; 172 while (dlen--) { 173 char c = *dname++; 174 175 if (!c) 176 break; 177 *p++ = c; 178 } 179 return 0; 180} 181 182static char *hmdfs_dentry_path_raw(struct dentry *d, char *buf, int buflen) 183{ 184 struct dentry *dentry = NULL; 185 char *end = NULL; 186 char *retval = NULL; 187 unsigned int len; 188 unsigned int seq = 0; 189 int root_flag = 0; 190 int error = 0; 191 struct hmdfs_dentry_info *di = hmdfs_d(d); 192 int hmdfs_root_dentry_type = 0; 193 194 di->time = jiffies; 195 hmdfs_root_dentry_type = hmdfs_get_root_dentry_type(d, &root_flag); 196 if (hmdfs_root_dentry_type < 0) 197 return NULL; 198 if (root_flag) { 199 strcpy(buf, "/"); 200 return buf; 201 } 202 rcu_read_lock(); 203restart: 204 dentry = d; 205 di = hmdfs_d(dentry); 206 di->time = jiffies; 207 end = buf + buflen; 208 len = buflen; 209 prepend(&end, &len, "\0", 1); 210 retval = end - 1; 211 *retval = '/'; 212 read_seqbegin_or_lock(&rename_lock, &seq); 213 while (di->dentry_type != hmdfs_root_dentry_type) { 214 struct dentry *parent = dentry->d_parent; 215 216 prefetch(parent); 217 error = prepend_name(&end, &len, &dentry->d_name); 218 if (error) 219 break; 220 retval = end; 221 dentry = parent; 222 di = hmdfs_d(dentry); 223 di->time = jiffies; 224 } 225 if (!(seq & 1)) 226 rcu_read_unlock(); 227 if (need_seqretry(&rename_lock, seq)) { 228 seq = 1; 229 goto restart; 230 } 231 done_seqretry(&rename_lock, seq); 232 if (error) 233 goto Elong; 234 return retval; 235Elong: 236 return ERR_PTR(-ENAMETOOLONG); 237} 238 239char *hmdfs_get_dentry_relative_path(struct dentry *dentry) 240{ 241 char *final_buf = NULL; 242 char *buf = NULL; 243 char *p = NULL; 244 245 buf = kzalloc(PATH_MAX, GFP_KERNEL); 246 if (!buf) 247 return NULL; 248 249 final_buf = kzalloc(PATH_MAX, GFP_KERNEL); 250 if (!final_buf) { 251 kfree(buf); 252 return NULL; 253 } 254 255 /* NULL dentry return root dir */ 256 if (!dentry) { 257 strcpy(final_buf, "/"); 258 kfree(buf); 259 return final_buf; 260 } 261 p = hmdfs_dentry_path_raw(dentry, buf, PATH_MAX); 262 if (IS_ERR_OR_NULL(p)) { 263 kfree(buf); 264 kfree(final_buf); 265 return NULL; 266 } 267 268 if (strlen(p) >= PATH_MAX) { 269 kfree(buf); 270 kfree(final_buf); 271 return NULL; 272 } 273 strcpy(final_buf, p); 274 kfree(buf); 275 return final_buf; 276} 277 278static char *hmdfs_merge_dentry_path_raw(struct dentry *d, char *buf, int buflen) 279{ 280 struct dentry *dentry = NULL; 281 char *end = NULL; 282 char *retval = NULL; 283 unsigned int len; 284 unsigned int seq = 0; 285 int error = 0; 286 struct hmdfs_dentry_info_merge *mdi = NULL; 287 288 rcu_read_lock(); 289restart: 290 mdi = hmdfs_dm(d); 291 dentry = d; 292 end = buf + buflen; 293 len = buflen; 294 prepend(&end, &len, "\0", 1); 295 retval = end - 1; 296 *retval = '/'; 297 read_seqbegin_or_lock(&rename_lock, &seq); 298 while (mdi->dentry_type != HMDFS_LAYER_FIRST_MERGE && 299 mdi->dentry_type != HMDFS_LAYER_FIRST_MERGE_CLOUD) { 300 struct dentry *parent = dentry->d_parent; 301 302 prefetch(parent); 303 error = prepend_name(&end, &len, &dentry->d_name); 304 if (error) 305 break; 306 retval = end; 307 dentry = parent; 308 mdi = hmdfs_dm(dentry); 309 } 310 if (!(seq & 1)) 311 rcu_read_unlock(); 312 if (need_seqretry(&rename_lock, seq)) { 313 seq = 1; 314 goto restart; 315 } 316 done_seqretry(&rename_lock, seq); 317 if (error) 318 goto Elong; 319 return retval; 320Elong: 321 return ERR_PTR(-ENAMETOOLONG); 322} 323 324char *hmdfs_merge_get_dentry_relative_path(struct dentry *dentry) 325{ 326 char *final_buf = NULL; 327 char *buf = NULL; 328 char *p = NULL; 329 330 buf = kzalloc(PATH_MAX, GFP_KERNEL); 331 if (!buf) 332 return NULL; 333 334 final_buf = kzalloc(PATH_MAX, GFP_KERNEL); 335 if (!final_buf) { 336 kfree(buf); 337 return NULL; 338 } 339 340 /* NULL dentry return root dir */ 341 if (!dentry) { 342 strcpy(final_buf, "/"); 343 kfree(buf); 344 return final_buf; 345 } 346 p = hmdfs_merge_dentry_path_raw(dentry, buf, PATH_MAX); 347 if (IS_ERR_OR_NULL(p)) { 348 kfree(buf); 349 kfree(final_buf); 350 return NULL; 351 } 352 353 if (strlen(p) >= PATH_MAX) { 354 kfree(buf); 355 kfree(final_buf); 356 return NULL; 357 } 358 strcpy(final_buf, p); 359 kfree(buf); 360 return final_buf; 361} 362 363char *hmdfs_get_dentry_absolute_path(const char *rootdir, 364 const char *relative_path) 365{ 366 char *buf = 0; 367 368 if (!rootdir || !relative_path) 369 return NULL; 370 if (strlen(rootdir) + strlen(relative_path) >= PATH_MAX) 371 return NULL; 372 373 buf = kzalloc(PATH_MAX, GFP_KERNEL); 374 if (!buf) 375 return NULL; 376 377 strcpy(buf, rootdir); 378 strcat(buf, relative_path); 379 return buf; 380} 381 382char *hmdfs_connect_path(const char *path, const char *name) 383{ 384 char *buf = 0; 385 size_t path_len, name_len; 386 387 if (!path || !name) 388 return NULL; 389 390 path_len = strnlen(path, PATH_MAX); 391 name_len = strnlen(name, PATH_MAX); 392 if (path_len + name_len + 1 >= PATH_MAX) 393 return NULL; 394 395 buf = kzalloc(PATH_MAX, GFP_KERNEL); 396 if (!buf) 397 return NULL; 398 399 strncpy(buf, path, path_len); 400 strcat(buf, "/"); 401 strncat(buf, name, name_len); 402 return buf; 403} 404 405int hmdfs_metainfo_read_nocred(struct file *filp, 406 void *buffer, int size, int bidx) 407{ 408 loff_t pos = get_dentry_group_pos(bidx); 409 410 return kernel_read(filp, buffer, (size_t)size, &pos); 411} 412 413int hmdfs_metainfo_read(struct hmdfs_sb_info *sbi, struct file *filp, 414 void *buffer, int size, int bidx) 415{ 416 loff_t pos = get_dentry_group_pos(bidx); 417 418 return cache_file_read(sbi, filp, buffer, (size_t)size, &pos); 419} 420 421int hmdfs_metainfo_write(struct hmdfs_sb_info *sbi, struct file *filp, 422 const void *buffer, int size, int bidx) 423{ 424 loff_t pos = get_dentry_group_pos(bidx); 425 426 return cache_file_write(sbi, filp, buffer, (size_t)size, &pos); 427} 428 429/* for each level */ 430/* bucketseq start offset by 0,for example 431 * level0 bucket0(0) 432 * level1 bucket0(1) bucket1(2) 433 * level2 bucket0(3) bucket1(4) bucket2(5) bucket3(6) 434 * return bucket number. 435 */ 436__u64 get_bucketaddr(unsigned int level, __u64 buckoffset) 437{ 438 __u64 all_level_bucketaddr = 0; 439 __u64 curlevelmaxbucks; 440 441 if (level >= MAX_BUCKET_LEVEL) { 442 hmdfs_err("level = %d overflow", level); 443 return all_level_bucketaddr; 444 } 445 curlevelmaxbucks = ((__u64)1 << level); 446 if (buckoffset >= curlevelmaxbucks) { 447 hmdfs_err("buckoffset %llu overflow, level %d has %llu buckets max", 448 buckoffset, level, curlevelmaxbucks); 449 return all_level_bucketaddr; 450 } 451 all_level_bucketaddr = curlevelmaxbucks + buckoffset - 1; 452 453 return all_level_bucketaddr; 454} 455 456__u64 get_bucket_by_level(unsigned int level) 457{ 458 __u64 buckets = 0; 459 460 if (level >= MAX_BUCKET_LEVEL) { 461 hmdfs_err("level = %d overflow", level); 462 return buckets; 463 } 464 465 buckets = ((__u64)1 << level); 466 return buckets; 467} 468 469static __u64 get_overall_bucket(unsigned int level) 470{ 471 __u64 buckets = 0; 472 473 if (level >= MAX_BUCKET_LEVEL) { 474 hmdfs_err("level = %d overflow", level); 475 return buckets; 476 } 477 buckets = ((__u64)1 << (level + 1)) - 1; 478 return buckets; 479} 480 481static inline loff_t get_dcache_file_size(unsigned int level) 482{ 483 loff_t buckets = get_overall_bucket(level); 484 485 return buckets * DENTRYGROUP_SIZE * BUCKET_BLOCKS + DENTRYGROUP_HEADER; 486} 487 488static char *get_relative_path(struct hmdfs_sb_info *sbi, char *from) 489{ 490 char *relative; 491 492 if (strncmp(from, sbi->local_src, strlen(sbi->local_src))) { 493 hmdfs_warning("orig path do not start with local_src"); 494 return NULL; 495 } 496 relative = from + strlen(sbi->local_src); 497 if (*relative == '/') 498 relative++; 499 return relative; 500} 501 502struct file *hmdfs_get_or_create_dents(struct hmdfs_sb_info *sbi, char *name) 503{ 504 struct path root_path, path; 505 struct file *filp = NULL; 506 char *relative; 507 int err; 508 509 err = kern_path(sbi->local_src, 0, &root_path); 510 if (err) { 511 hmdfs_err("kern_path failed err = %d", err); 512 return NULL; 513 } 514 relative = get_relative_path(sbi, name); 515 if (!relative) { 516 hmdfs_err("get relative path failed"); 517 goto err_root_path; 518 } 519 err = vfs_path_lookup(root_path.dentry, root_path.mnt, relative, 0, 520 &path); 521 if (err) { 522 hmdfs_err("lookup failed err = %d", err); 523 goto err_root_path; 524 } 525 526 filp = hmdfs_server_cache_revalidate(sbi, relative, &path); 527 if (IS_ERR_OR_NULL(filp)) { 528 filp = hmdfs_server_rebuild_dents(sbi, &path, NULL, relative); 529 if (IS_ERR_OR_NULL(filp)) 530 goto err_lookup_path; 531 } 532 533err_lookup_path: 534 path_put(&path); 535err_root_path: 536 path_put(&root_path); 537 return filp; 538} 539 540/* read all dentry in target path directory */ 541int read_dentry(struct hmdfs_sb_info *sbi, char *file_name, 542 struct dir_context *ctx) 543{ 544 unsigned long pos = (unsigned long)(ctx->pos); 545 unsigned long group_id = (pos << (1 + DEV_ID_BIT_NUM)) >> 546 (POS_BIT_NUM - GROUP_ID_BIT_NUM); 547 unsigned long offset = pos & OFFSET_BIT_MASK; 548 struct hmdfs_dentry_group *dentry_group = NULL; 549 struct file *handler = NULL; 550 int group_num = 0; 551 int iterate_result = 0; 552 int i, j; 553 const struct cred *saved_cred; 554 555 saved_cred = hmdfs_override_fsids(false); 556 if (!saved_cred) { 557 hmdfs_err("prepare cred failed!"); 558 return -ENOMEM; 559 } 560 561 562 if (!file_name) 563 return -EINVAL; 564 565 dentry_group = kzalloc(sizeof(*dentry_group), GFP_KERNEL); 566 if (!dentry_group) 567 return -ENOMEM; 568 569 handler = hmdfs_get_or_create_dents(sbi, file_name); 570 if (IS_ERR_OR_NULL(handler)) { 571 kfree(dentry_group); 572 return -ENOENT; 573 } 574 575 group_num = get_dentry_group_cnt(file_inode(handler)); 576 577 for (i = group_id; i < group_num; i++) { 578 hmdfs_metainfo_read(sbi, handler, dentry_group, 579 sizeof(struct hmdfs_dentry_group), i); 580 for (j = offset; j < DENTRY_PER_GROUP; j++) { 581 int len; 582 int file_type = 0; 583 bool is_continue; 584 585 len = le16_to_cpu(dentry_group->nsl[j].namelen); 586 if (!test_bit_le(j, dentry_group->bitmap) || len == 0) 587 continue; 588 589 if (S_ISDIR(le16_to_cpu(dentry_group->nsl[j].i_mode))) 590 file_type = DT_DIR; 591 else if (S_ISREG(le16_to_cpu( 592 dentry_group->nsl[j].i_mode))) 593 file_type = DT_REG; 594 else if (S_ISLNK(le16_to_cpu( 595 dentry_group->nsl[j].i_mode))) 596 file_type = DT_LNK; 597 else 598 continue; 599 600 pos = hmdfs_set_pos(0, i, j); 601 is_continue = dir_emit( 602 ctx, dentry_group->filename[j], len, 603 le64_to_cpu(dentry_group->nsl[j].i_ino), 604 file_type); 605 if (!is_continue) { 606 ctx->pos = pos; 607 iterate_result = 1; 608 goto done; 609 } 610 } 611 offset = 0; 612 } 613 614done: 615 hmdfs_revert_fsids(saved_cred); 616 kfree(dentry_group); 617 fput(handler); 618 return iterate_result; 619} 620 621unsigned int get_max_depth(struct file *filp) 622{ 623 size_t isize; 624 625 isize = get_dentry_group_cnt(file_inode(filp)) / BUCKET_BLOCKS; 626 627 return get_count_order(isize + 1); 628} 629 630struct hmdfs_dentry_group *find_dentry_page(struct hmdfs_sb_info *sbi, 631 pgoff_t index, struct file *filp) 632{ 633 int size; 634 struct hmdfs_dentry_group *dentry_blk = NULL; 635 loff_t pos = get_dentry_group_pos(index); 636 int err; 637 638 dentry_blk = kmalloc(sizeof(*dentry_blk), GFP_KERNEL); 639 if (!dentry_blk) 640 return NULL; 641 642 err = hmdfs_wlock_file(filp, pos, DENTRYGROUP_SIZE); 643 if (err) { 644 hmdfs_err("lock file pos %lld failed", pos); 645 kfree(dentry_blk); 646 return NULL; 647 } 648 649 size = cache_file_read(sbi, filp, dentry_blk, (size_t)DENTRYGROUP_SIZE, 650 &pos); 651 if (size != DENTRYGROUP_SIZE) { 652 hmdfs_unlock_file(filp, pos, DENTRYGROUP_SIZE); 653 kfree(dentry_blk); 654 dentry_blk = NULL; 655 } 656 657 return dentry_blk; 658} 659 660static ssize_t write_dentry_page(struct file *filp, const void *buffer, 661 int buffersize, loff_t position) 662{ 663 ssize_t size; 664 665 size = kernel_write(filp, buffer, (size_t)buffersize, &position); 666 if (size != buffersize) 667 hmdfs_err("write failed, ret = %zd", size); 668 669 return size; 670} 671 672static struct hmdfs_dentry *find_in_block(struct hmdfs_dentry_group *dentry_blk, 673 __u32 namehash, 674 const struct qstr *qstr, 675 struct hmdfs_dentry **insense_de, 676 bool case_sense) 677{ 678 struct hmdfs_dentry *de; 679 unsigned long bit_pos = 0; 680 int max_len = 0; 681 682 while (bit_pos < DENTRY_PER_GROUP) { 683 if (!test_bit_le(bit_pos, dentry_blk->bitmap)) { 684 bit_pos++; 685 max_len++; 686 continue; 687 } 688 de = &dentry_blk->nsl[bit_pos]; 689 if (unlikely(!de->namelen)) { 690 bit_pos++; 691 continue; 692 } 693 694 if (le32_to_cpu(de->hash) == namehash && 695 le16_to_cpu(de->namelen) == qstr->len && 696 !memcmp(qstr->name, dentry_blk->filename[bit_pos], 697 le16_to_cpu(de->namelen))) 698 goto found; 699 if (!(*insense_de) && !case_sense && 700 le32_to_cpu(de->hash) == namehash && 701 le16_to_cpu(de->namelen) == qstr->len && 702 str_n_case_eq(qstr->name, dentry_blk->filename[bit_pos], 703 le16_to_cpu(de->namelen))) 704 *insense_de = de; 705 max_len = 0; 706 bit_pos += get_dentry_slots(le16_to_cpu(de->namelen)); 707 } 708 de = NULL; 709found: 710 return de; 711} 712 713static struct hmdfs_dentry *hmdfs_in_level(struct dentry *child_dentry, 714 unsigned int level, 715 struct hmdfs_dcache_lookup_ctx *ctx) 716{ 717 unsigned long nbucket; 718 unsigned long bidx, end_block; 719 struct hmdfs_dentry *de = NULL; 720 struct hmdfs_dentry *tmp_insense_de = NULL; 721 struct hmdfs_dentry_group *dentry_blk; 722 723 nbucket = get_bucket_by_level(level); 724 if (!nbucket) 725 return de; 726 727 bidx = get_bucketaddr(level, ctx->hash % nbucket) * BUCKET_BLOCKS; 728 end_block = bidx + BUCKET_BLOCKS; 729 730 for (; bidx < end_block; bidx++) { 731 dentry_blk = find_dentry_page(ctx->sbi, bidx, ctx->filp); 732 if (!dentry_blk) 733 break; 734 735 de = find_in_block(dentry_blk, ctx->hash, ctx->name, 736 &tmp_insense_de, ctx->sbi->s_case_sensitive); 737 if (!de && !(ctx->insense_de) && tmp_insense_de) { 738 ctx->insense_de = tmp_insense_de; 739 ctx->insense_page = dentry_blk; 740 ctx->insense_bidx = bidx; 741 } else if (!de) { 742 hmdfs_unlock_file(ctx->filp, get_dentry_group_pos(bidx), 743 DENTRYGROUP_SIZE); 744 kfree(dentry_blk); 745 } else { 746 ctx->page = dentry_blk; 747 break; 748 } 749 } 750 ctx->bidx = bidx; 751 return de; 752} 753 754struct hmdfs_dentry *hmdfs_find_dentry(struct dentry *child_dentry, 755 struct hmdfs_dcache_lookup_ctx *ctx) 756{ 757 struct hmdfs_dentry *de = NULL; 758 unsigned int max_depth; 759 unsigned int level; 760 761 if (!ctx->filp) 762 return NULL; 763 764 ctx->hash = hmdfs_dentry_hash(ctx->name, ctx->sbi->s_case_sensitive); 765 766 max_depth = get_max_depth(ctx->filp); 767 for (level = 0; level < max_depth; level++) { 768 de = hmdfs_in_level(child_dentry, level, ctx); 769 if (de) { 770 if (ctx->insense_page) { 771 hmdfs_unlock_file(ctx->filp, 772 get_dentry_group_pos(ctx->insense_bidx), 773 DENTRYGROUP_SIZE); 774 kfree(ctx->insense_page); 775 ctx->insense_page = NULL; 776 } 777 return de; 778 } 779 } 780 if (ctx->insense_de) { 781 ctx->bidx = ctx->insense_bidx; 782 ctx->page = ctx->insense_page; 783 ctx->insense_bidx = 0; 784 ctx->insense_page = NULL; 785 } 786 return ctx->insense_de; 787} 788 789void update_dentry(struct hmdfs_dentry_group *d, struct dentry *child_dentry, 790 struct inode *inode, struct super_block *hmdfs_sb, 791 __u32 name_hash, unsigned int bit_pos) 792{ 793 struct hmdfs_dentry *de; 794 struct hmdfs_dentry_info *gdi; 795 const struct qstr name = child_dentry->d_name; 796 int slots = get_dentry_slots(name.len); 797 int i; 798 unsigned long ino; 799 __u32 igen; 800 801 gdi = hmdfs_sb == child_dentry->d_sb ? hmdfs_d(child_dentry) : NULL; 802 if (!gdi && S_ISLNK(d_inode(child_dentry)->i_mode)) { 803 ino = d_inode(child_dentry)->i_ino; 804 igen = d_inode(child_dentry)->i_generation; 805 } else { 806 ino = inode->i_ino; 807 igen = inode->i_generation; 808 } 809 810 de = &d->nsl[bit_pos]; 811 de->hash = cpu_to_le32(name_hash); 812 de->namelen = cpu_to_le16(name.len); 813 memcpy(d->filename[bit_pos], name.name, name.len); 814 de->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec); 815 de->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec); 816 de->i_size = cpu_to_le64(inode->i_size); 817 de->i_ino = cpu_to_le64(generate_u64_ino(ino, igen)); 818 de->i_flag = 0; 819 if (gdi && hm_islnk(gdi->file_type)) 820 de->i_mode = cpu_to_le16(S_IFLNK); 821 else if (!gdi && S_ISLNK(d_inode(child_dentry)->i_mode)) 822 de->i_mode = d_inode(child_dentry)->i_mode; 823 else 824 de->i_mode = cpu_to_le16(inode->i_mode); 825 826 for (i = 0; i < slots; i++) { 827 __set_bit_le(bit_pos + i, d->bitmap); 828 /* avoid wrong garbage data for readdir */ 829 if (i) 830 (de + i)->namelen = 0; 831 } 832} 833 834int room_for_filename(const void *bitmap, int slots, int max_slots) 835{ 836 int bit_start = 0; 837 int zero_start, zero_end; 838next: 839 zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start); 840 if (zero_start >= max_slots) 841 return max_slots; 842 843 zero_end = find_next_bit_le(bitmap, max_slots, zero_start); 844 if (zero_end - zero_start >= slots) 845 return zero_start; 846 847 bit_start = zero_end + 1; 848 849 if (zero_end + 1 >= max_slots) 850 return max_slots; 851 goto next; 852} 853 854void create_in_cache_file(uint64_t dev_id, struct dentry *dentry) 855{ 856 struct clearcache_item *item = NULL; 857 858 item = hmdfs_find_cache_item(dev_id, dentry->d_parent); 859 if (item) { 860 if (d_inode(dentry)) 861 create_dentry(dentry, d_inode(dentry), item->filp, 862 hmdfs_sb(dentry->d_sb)); 863 else 864 hmdfs_err("inode is null!"); 865 kref_put(&item->ref, release_cache_item); 866 } else { 867 hmdfs_info("find cache item failed, device_id:%llu", dev_id); 868 } 869} 870 871int create_dentry(struct dentry *child_dentry, struct inode *inode, 872 struct file *file, struct hmdfs_sb_info *sbi) 873{ 874 unsigned int bit_pos, level; 875 unsigned long bidx, end_block; 876 const struct qstr qstr = child_dentry->d_name; 877 __u32 namehash; 878 loff_t pos; 879 ssize_t size; 880 int ret = 0; 881 struct hmdfs_dentry_group *dentry_blk = NULL; 882 883 level = 0; 884 885 namehash = hmdfs_dentry_hash(&qstr, sbi->s_case_sensitive); 886 887 dentry_blk = kmalloc(sizeof(*dentry_blk), GFP_KERNEL); 888 if (!dentry_blk) { 889 ret = -ENOMEM; 890 goto out_err; 891 } 892find: 893 if (level == MAX_BUCKET_LEVEL) { 894 ret = -ENOSPC; 895 goto out; 896 } 897 bidx = BUCKET_BLOCKS * 898 get_bucketaddr(level, namehash % get_bucket_by_level(level)); 899 end_block = bidx + BUCKET_BLOCKS; 900 if (end_block > get_dentry_group_cnt(file_inode(file))) { 901 if (cache_file_truncate(sbi, &(file->f_path), 902 get_dcache_file_size(level))) { 903 ret = -ENOSPC; 904 goto out; 905 } 906 } 907 908 for (; bidx < end_block; bidx++) { 909 int size; 910 911 pos = get_dentry_group_pos(bidx); 912 ret = hmdfs_wlock_file(file, pos, DENTRYGROUP_SIZE); 913 if (ret) 914 goto out; 915 916 size = cache_file_read(sbi, file, dentry_blk, 917 (size_t)DENTRYGROUP_SIZE, &pos); 918 if (size != DENTRYGROUP_SIZE) { 919 ret = -ENOSPC; 920 hmdfs_unlock_file(file, pos, DENTRYGROUP_SIZE); 921 goto out; 922 } 923 924 bit_pos = room_for_filename(&dentry_blk->bitmap, 925 get_dentry_slots(qstr.len), 926 DENTRY_PER_GROUP); 927 if (bit_pos < DENTRY_PER_GROUP) 928 goto add; 929 hmdfs_unlock_file(file, pos, DENTRYGROUP_SIZE); 930 } 931 ++level; 932 goto find; 933add: 934 pos = get_dentry_group_pos(bidx); 935 update_dentry(dentry_blk, child_dentry, inode, sbi->sb, namehash, 936 bit_pos); 937 size = cache_file_write(sbi, file, dentry_blk, 938 sizeof(struct hmdfs_dentry_group), &pos); 939 if (size != sizeof(struct hmdfs_dentry_group)) 940 hmdfs_err("cache file write failed!, ret = %zd", size); 941 hmdfs_unlock_file(file, pos, DENTRYGROUP_SIZE); 942out: 943 kfree(dentry_blk); 944out_err: 945 return ret; 946} 947 948void hmdfs_init_dcache_lookup_ctx(struct hmdfs_dcache_lookup_ctx *ctx, 949 struct hmdfs_sb_info *sbi, 950 const struct qstr *qstr, struct file *filp) 951{ 952 ctx->sbi = sbi; 953 ctx->name = qstr; 954 ctx->filp = filp; 955 ctx->bidx = 0; 956 ctx->page = NULL; 957 ctx->insense_de = NULL; 958 ctx->insense_bidx = 0; 959 ctx->insense_page = NULL; 960} 961 962int update_inode_to_dentry(struct dentry *child_dentry, struct inode *inode) 963{ 964 struct hmdfs_sb_info *sbi = d_inode(child_dentry)->i_sb->s_fs_info; 965 struct hmdfs_dentry *de = NULL; 966 loff_t ipos; 967 struct dentry *parent_dentry; 968 struct cache_file_node *cfn = NULL; 969 char *relative_path = NULL; 970 struct hmdfs_dcache_lookup_ctx ctx; 971 972 parent_dentry = child_dentry->d_parent; 973 if (hmdfs_d(parent_dentry)->dentry_type == HMDFS_LAYER_FIRST_DEVICE) 974 return 0; 975 976 relative_path = hmdfs_get_dentry_relative_path(parent_dentry); 977 if (!relative_path) 978 return -ENOMEM; 979 980 cfn = find_cfn(sbi, HMDFS_SERVER_CID, relative_path, true); 981 if (!cfn) 982 goto out; 983 984 hmdfs_init_dcache_lookup_ctx(&ctx, sbi, &child_dentry->d_name, 985 cfn->filp); 986 de = hmdfs_find_dentry(child_dentry, &ctx); 987 if (!de) 988 goto out_cfn; 989 990 de->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec); 991 de->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec); 992 de->i_size = cpu_to_le64(inode->i_size); 993 de->i_ino = cpu_to_le64( 994 generate_u64_ino(inode->i_ino, inode->i_generation)); 995 de->i_flag = 0; 996 997 ipos = get_dentry_group_pos(ctx.bidx); 998 write_dentry_page(cfn->filp, ctx.page, 999 sizeof(struct hmdfs_dentry_group), ipos); 1000 hmdfs_unlock_file(cfn->filp, ipos, DENTRYGROUP_SIZE); 1001 kfree(ctx.page); 1002out_cfn: 1003 release_cfn(cfn); 1004out: 1005 kfree(relative_path); 1006 return 0; 1007} 1008 1009void hmdfs_delete_dentry(struct dentry *d, struct file *filp) 1010{ 1011 struct hmdfs_dentry *de = NULL; 1012 unsigned int bit_pos; 1013 int slots, i; 1014 loff_t ipos; 1015 ssize_t size; 1016 struct hmdfs_dcache_lookup_ctx ctx; 1017 1018 hmdfs_init_dcache_lookup_ctx(&ctx, hmdfs_sb(d->d_sb), &d->d_name, filp); 1019 1020 de = hmdfs_find_dentry(d, &ctx); 1021 if (IS_ERR_OR_NULL(de)) { 1022 hmdfs_info("find dentry failed!, err=%ld", PTR_ERR(de)); 1023 return; 1024 } 1025 slots = get_dentry_slots(le16_to_cpu(de->namelen)); 1026 1027 bit_pos = de - ctx.page->nsl; 1028 for (i = 0; i < slots; i++) 1029 __clear_bit_le(bit_pos + i, &ctx.page->bitmap); 1030 1031 ipos = get_dentry_group_pos(ctx.bidx); 1032 size = cache_file_write(hmdfs_sb(d->d_sb), filp, ctx.page, 1033 sizeof(struct hmdfs_dentry_group), &ipos); 1034 if (size != sizeof(struct hmdfs_dentry_group)) 1035 hmdfs_err("cache file write failed!, ret = %zd", size); 1036 hmdfs_unlock_file(filp, ipos, DENTRYGROUP_SIZE); 1037 kfree(ctx.page); 1038} 1039 1040static int hmdfs_get_cache_path(struct hmdfs_sb_info *sbi, struct path *dir) 1041{ 1042 struct hmdfs_dentry_info *di = hmdfs_d(sbi->sb->s_root); 1043 int err; 1044 1045 if (!sbi->s_dentry_cache) { 1046 *dir = di->lower_path; 1047 return 0; 1048 } 1049 1050 err = kern_path(sbi->cache_dir, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, dir); 1051 if (err) 1052 hmdfs_err("open failed, errno = %d", err); 1053 1054 return err; 1055} 1056 1057static void hmdfs_put_cache_path(struct hmdfs_sb_info *sbi, struct path *dir) 1058{ 1059 if (!sbi->s_dentry_cache) 1060 return; 1061 path_put(dir); 1062} 1063 1064struct file *create_local_dentry_file_cache(struct hmdfs_sb_info *sbi) 1065{ 1066 struct file *filp = NULL; 1067 const struct cred *old_cred = hmdfs_override_creds(sbi->system_cred); 1068 struct path cache_dir; 1069 int err; 1070 1071 err = hmdfs_get_cache_path(sbi, &cache_dir); 1072 if (err) { 1073 filp = ERR_PTR(err); 1074 goto out; 1075 } 1076 1077 filp = file_open_root(&cache_dir, ".", 1078 O_RDWR | O_LARGEFILE | O_TMPFILE, 1079 DENTRY_FILE_PERM); 1080 if (IS_ERR(filp)) 1081 hmdfs_err("dentryfile open failed and exit err=%ld", 1082 PTR_ERR(filp)); 1083 1084 hmdfs_put_cache_path(sbi, &cache_dir); 1085out: 1086 hmdfs_revert_creds(old_cred); 1087 return filp; 1088} 1089 1090static int hmdfs_linkat(struct path *old_path, const char *newname) 1091{ 1092 struct dentry *new_dentry = NULL; 1093 struct path new_path; 1094 int error; 1095 1096 new_dentry = kern_path_create(AT_FDCWD, newname, &new_path, 0); 1097 if (IS_ERR(new_dentry)) { 1098 hmdfs_err("create kernel path failed, error: %ld", 1099 PTR_ERR(new_dentry)); 1100 return PTR_ERR(new_dentry); 1101 } 1102 1103 error = -EXDEV; 1104 if (old_path->mnt != new_path.mnt) 1105 goto out_dput; 1106 1107 error = vfs_link(old_path->dentry, new_path.dentry->d_inode, new_dentry, 1108 NULL); 1109 1110out_dput: 1111 done_path_create(&new_path, new_dentry); 1112 return error; 1113} 1114 1115static int cache_file_mkdir(const char *name, umode_t mode) 1116{ 1117 struct dentry *dentry; 1118 struct path path; 1119 int err; 1120 1121 dentry = kern_path_create(AT_FDCWD, name, &path, LOOKUP_DIRECTORY); 1122 if (IS_ERR(dentry)) 1123 return PTR_ERR(dentry); 1124 1125 err = vfs_mkdir(d_inode(path.dentry), dentry, mode); 1126 if (err && err != -EEXIST) 1127 hmdfs_err("vfs_mkdir failed, err = %d", err); 1128 1129 done_path_create(&path, dentry); 1130 return err; 1131} 1132 1133static int cache_file_create_path(const char *fullpath) 1134{ 1135 char *path; 1136 char *s; 1137 int err = 0; 1138 1139 path = kstrdup(fullpath, GFP_KERNEL); 1140 if (!path) 1141 return -ENOMEM; 1142 1143 s = path + 1; 1144 while (true) { 1145 s = strchr(s, '/'); 1146 if (!s) 1147 break; 1148 s[0] = '\0'; 1149 err = cache_file_mkdir(path, 0755); 1150 if (err && err != -EEXIST) 1151 break; 1152 s[0] = '/'; 1153 s++; 1154 } 1155 kfree(path); 1156 return err; 1157} 1158 1159static void hmdfs_cache_path_create(char *s, const char *dir, bool server) 1160{ 1161 if (server) 1162 snprintf(s, PATH_MAX, "%s/dentry_cache/server/", dir); 1163 else 1164 snprintf(s, PATH_MAX, "%s/dentry_cache/client/", dir); 1165} 1166 1167static void concat_cachefile_name(char *s, uint64_t hash, const char *id, 1168 bool server) 1169{ 1170 int offset = strlen(s); 1171 1172 if (server) 1173 snprintf(s + offset, PATH_MAX - offset, "%016llx", hash); 1174 else 1175 snprintf(s + offset, PATH_MAX - offset, "%s_%016llx", id, hash); 1176} 1177 1178int cache_file_name_generate(char *fullname, struct hmdfs_peer *con, 1179 const char *relative_path, bool server) 1180{ 1181 struct hmdfs_sb_info *sbi = con->sbi; 1182 uint64_t hash; 1183 char cid[HMDFS_CFN_CID_SIZE]; 1184 int err; 1185 1186 hmdfs_cache_path_create(fullname, sbi->cache_dir, server); 1187 1188 err = cache_file_create_path(fullname); 1189 if (err && err != -EEXIST) { 1190 hmdfs_err("making dir failed %d", err); 1191 return err; 1192 } 1193 1194 strncpy(cid, con->cid, HMDFS_CFN_CID_SIZE - 1); 1195 cid[HMDFS_CFN_CID_SIZE - 1] = '\0'; 1196 1197 hash = path_hash(relative_path, strlen(relative_path), 1198 sbi->s_case_sensitive); 1199 concat_cachefile_name(fullname, hash, cid, server); 1200 1201 return 0; 1202} 1203 1204static void free_cfn(struct cache_file_node *cfn) 1205{ 1206 if (!IS_ERR_OR_NULL(cfn->filp)) 1207 filp_close(cfn->filp, NULL); 1208 1209 kfree(cfn->relative_path); 1210 kfree(cfn); 1211} 1212 1213static bool path_cmp(const char *path1, const char *path2, bool case_sensitive) 1214{ 1215 int ret; 1216 1217 if (case_sensitive) 1218 ret = strcmp(path1, path2); 1219 else 1220 ret = strcasecmp(path1, path2); 1221 1222 return !ret; 1223} 1224 1225static bool dentry_file_match(struct cache_file_node *cfn, const char *id, 1226 const char *path) 1227{ 1228 return (path_cmp(cfn->relative_path, path, cfn->sbi->s_case_sensitive) && 1229 !strncmp((cfn)->cid, id, HMDFS_CFN_CID_SIZE - 1)); 1230} 1231 1232struct cache_file_node *__find_cfn(struct hmdfs_sb_info *sbi, const char *cid, 1233 const char *path, bool server) 1234{ 1235 struct cache_file_node *cfn = NULL; 1236 struct list_head *head = NULL; 1237 1238 head = get_list_head(sbi, server); 1239 1240 list_for_each_entry(cfn, head, list) { 1241 if (dentry_file_match(cfn, cid, path)) { 1242 refcount_inc(&cfn->ref); 1243 return cfn; 1244 } 1245 } 1246 return NULL; 1247} 1248 1249struct cache_file_node *create_cfn(struct hmdfs_sb_info *sbi, const char *path, 1250 const char *cid, bool server) 1251{ 1252 struct cache_file_node *cfn = kzalloc(sizeof(*cfn), GFP_KERNEL); 1253 1254 if (!cfn) 1255 return NULL; 1256 1257 cfn->relative_path = kstrdup(path, GFP_KERNEL); 1258 if (!cfn->relative_path) 1259 goto out; 1260 1261 refcount_set(&cfn->ref, 1); 1262 strncpy(cfn->cid, cid, HMDFS_CFN_CID_SIZE - 1); 1263 cfn->cid[HMDFS_CFN_CID_SIZE - 1] = '\0'; 1264 cfn->sbi = sbi; 1265 cfn->server = server; 1266 return cfn; 1267out: 1268 free_cfn(cfn); 1269 return NULL; 1270} 1271 1272static struct file *insert_cfn(struct hmdfs_sb_info *sbi, const char *filename, 1273 const char *path, const char *cid, bool server) 1274{ 1275 const struct cred *old_cred = NULL; 1276 struct cache_file_node *cfn = NULL; 1277 struct cache_file_node *exist = NULL; 1278 struct list_head *head = NULL; 1279 struct file *filp = NULL; 1280 1281 cfn = create_cfn(sbi, path, cid, server); 1282 if (!cfn) 1283 return ERR_PTR(-ENOMEM); 1284 1285 old_cred = hmdfs_override_creds(sbi->system_cred); 1286 filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0); 1287 hmdfs_revert_creds(old_cred); 1288 if (IS_ERR(filp)) { 1289 hmdfs_err("open file failed, err=%ld", PTR_ERR(filp)); 1290 goto out; 1291 } 1292 1293 head = get_list_head(sbi, server); 1294 1295 mutex_lock(&sbi->cache_list_lock); 1296 exist = __find_cfn(sbi, cid, path, server); 1297 if (!exist) { 1298 cfn->filp = filp; 1299 list_add_tail(&cfn->list, head); 1300 } else { 1301 mutex_unlock(&sbi->cache_list_lock); 1302 release_cfn(exist); 1303 filp_close(filp, NULL); 1304 filp = ERR_PTR(-EEXIST); 1305 goto out; 1306 } 1307 mutex_unlock(&sbi->cache_list_lock); 1308 return filp; 1309out: 1310 free_cfn(cfn); 1311 return filp; 1312} 1313 1314int hmdfs_rename_dentry(struct dentry *old_dentry, struct dentry *new_dentry, 1315 struct file *old_filp, struct file *new_filp) 1316{ 1317 int ret; 1318 struct hmdfs_sb_info *sbi = hmdfs_sb(new_dentry->d_sb); 1319 1320 /* 1321 * Try to delete first, because stale dentry might exist after 1322 * coverwrite. 1323 */ 1324 hmdfs_delete_dentry(new_dentry, new_filp); 1325 1326 ret = create_dentry(new_dentry, d_inode(old_dentry), new_filp, sbi); 1327 if (ret) { 1328 hmdfs_err("create dentry failed!, err=%d", ret); 1329 return ret; 1330 } 1331 1332 hmdfs_delete_dentry(old_dentry, old_filp); 1333 return 0; 1334} 1335 1336/** 1337 * cache_file_persistent - link the tmpfile to the cache dir 1338 * @con: the connection peer 1339 * @filp: the file handler of the tmpfile 1340 * @relative_path: the relative path which the tmpfile belongs 1341 * @server: server or client 1342 * 1343 * Return value: the new file handler of the persistent file if the 1344 * persistent operation succeed. Otherwise will return the original handler 1345 * of the tmpfile passed in, so that the caller does not have to check 1346 * the returned handler. 1347 * 1348 */ 1349struct file *cache_file_persistent(struct hmdfs_peer *con, struct file *filp, 1350 const char *relative_path, bool server) 1351{ 1352 struct cache_file_node *cfn = NULL; 1353 char *fullname = NULL; 1354 char *cid = server ? HMDFS_SERVER_CID : (char *)con->cid; 1355 struct file *newf = NULL; 1356 int i = 0; 1357 int len; 1358 int err; 1359 1360 if (!con->sbi->s_dentry_cache) 1361 return filp; 1362 1363 cfn = find_cfn(con->sbi, cid, relative_path, server); 1364 if (cfn) { 1365 release_cfn(cfn); 1366 return filp; 1367 } 1368 fullname = kzalloc(PATH_MAX, GFP_KERNEL); 1369 if (!fullname) 1370 return filp; 1371 1372 err = cache_file_name_generate(fullname, con, relative_path, server); 1373 if (err) 1374 goto out; 1375 1376 err = __vfs_setxattr(file_dentry(filp), file_inode(filp), 1377 DENTRY_FILE_XATTR_NAME, relative_path, 1378 strlen(relative_path), 0); 1379 if (err) { 1380 hmdfs_err("setxattr for file failed, err=%d", err); 1381 goto out; 1382 } 1383 1384 len = strlen(fullname); 1385 1386 do { 1387 err = hmdfs_linkat(&filp->f_path, fullname); 1388 if (!err) 1389 break; 1390 1391 snprintf(fullname + len, PATH_MAX - len, "_%d", i); 1392 } while (i++ < DENTRY_FILE_NAME_RETRY); 1393 1394 if (err) { 1395 hmdfs_err("link for file failed, err=%d", err); 1396 goto out; 1397 } 1398 1399 newf = insert_cfn(con->sbi, fullname, relative_path, cid, server); 1400 if (!IS_ERR(newf)) 1401 filp = newf; 1402out: 1403 kfree(fullname); 1404 return filp; 1405} 1406 1407int get_cloud_cache_file(struct dentry *dentry, struct hmdfs_sb_info *sbi) 1408{ 1409 int ret; 1410 ssize_t res; 1411 struct hmdfs_dentry_info *d_info = hmdfs_d(dentry); 1412 struct clearcache_item *item; 1413 struct file *filp = NULL; 1414 uint64_t hash; 1415 char *relative_path = NULL; 1416 char *dirname = NULL; 1417 char *fullname = NULL; 1418 char *cache_file_name = NULL; 1419 char *kvalue = NULL; 1420 1421 item = hmdfs_find_cache_item(CLOUD_DEVICE, dentry); 1422 if (item) { 1423 kref_put(&item->ref, release_cache_item); 1424 return 0; 1425 } 1426 1427 relative_path = hmdfs_get_dentry_relative_path(dentry); 1428 if (unlikely(!relative_path)) { 1429 hmdfs_err("get relative path failed %d", -ENOMEM); 1430 ret = -ENOMEM; 1431 goto out; 1432 } 1433 1434 dirname = kzalloc(PATH_MAX, GFP_KERNEL); 1435 if (!dirname) { 1436 ret = -ENOMEM; 1437 goto out; 1438 } 1439 1440 cache_file_name = kzalloc(PATH_MAX, GFP_KERNEL); 1441 if (!cache_file_name) { 1442 ret = -ENOMEM; 1443 goto out; 1444 } 1445 1446 fullname = kzalloc(PATH_MAX, GFP_KERNEL); 1447 if (!fullname) { 1448 ret = -ENOMEM; 1449 goto out; 1450 } 1451 1452 kvalue = kzalloc(PATH_MAX, GFP_KERNEL); 1453 if (!kvalue) { 1454 ret = -ENOMEM; 1455 goto out; 1456 } 1457 1458 hash = path_hash(relative_path, strlen(relative_path), 1459 sbi->s_case_sensitive); 1460 concat_cachefile_name(cache_file_name, hash, CLOUD_CID, false); 1461 snprintf(dirname, PATH_MAX, "%s/dentry_cache/cloud/", 1462 sbi->cache_dir); 1463 snprintf(fullname, PATH_MAX, "%s%s", dirname, cache_file_name); 1464 1465 filp = filp_open(fullname, O_RDWR | O_LARGEFILE, 0); 1466 if (IS_ERR(filp)) { 1467 hmdfs_debug("open fail %ld", PTR_ERR(filp)); 1468 ret = PTR_ERR(filp); 1469 goto out; 1470 } 1471 1472 res = __vfs_getxattr(file_dentry(filp), file_inode(filp), 1473 DENTRY_FILE_XATTR_NAME, kvalue, PATH_MAX); 1474 if (res <= 0 || res >= PATH_MAX) { 1475 hmdfs_err("getxattr return: %zd", res); 1476 filp_close(filp, NULL); 1477 ret = -ENOENT; 1478 goto out; 1479 } 1480 kvalue[res] = '\0'; 1481 1482 if (!path_cmp(relative_path, kvalue, sbi->s_case_sensitive)) { 1483 hmdfs_err("relative path from xattr do not match"); 1484 filp_close(filp, NULL); 1485 ret = -ENOENT; 1486 goto out; 1487 } 1488 1489 mutex_lock(&d_info->cache_pull_lock); 1490 hmdfs_add_cache_list(CLOUD_DEVICE, dentry, filp); 1491 mutex_unlock(&d_info->cache_pull_lock); 1492 1493 ret = 0; 1494out: 1495 kfree(relative_path); 1496 kfree(dirname); 1497 kfree(fullname); 1498 kfree(cache_file_name); 1499 kfree(kvalue); 1500 1501 return ret; 1502} 1503 1504void __destroy_cfn(struct list_head *head) 1505{ 1506 struct cache_file_node *cfn = NULL; 1507 struct cache_file_node *n = NULL; 1508 1509 list_for_each_entry_safe(cfn, n, head, list) { 1510 list_del_init(&cfn->list); 1511 release_cfn(cfn); 1512 } 1513} 1514 1515void hmdfs_cfn_destroy(struct hmdfs_sb_info *sbi) 1516{ 1517 mutex_lock(&sbi->cache_list_lock); 1518 __destroy_cfn(&sbi->client_cache); 1519 __destroy_cfn(&sbi->server_cache); 1520 mutex_unlock(&sbi->cache_list_lock); 1521} 1522 1523struct cache_file_node *find_cfn(struct hmdfs_sb_info *sbi, const char *cid, 1524 const char *path, bool server) 1525{ 1526 struct cache_file_node *cfn = NULL; 1527 1528 mutex_lock(&sbi->cache_list_lock); 1529 cfn = __find_cfn(sbi, cid, path, server); 1530 mutex_unlock(&sbi->cache_list_lock); 1531 return cfn; 1532} 1533 1534void release_cfn(struct cache_file_node *cfn) 1535{ 1536 if (refcount_dec_and_test(&cfn->ref)) 1537 free_cfn(cfn); 1538} 1539 1540void remove_cfn(struct cache_file_node *cfn) 1541{ 1542 struct hmdfs_sb_info *sbi = cfn->sbi; 1543 bool deleted; 1544 1545 mutex_lock(&sbi->cache_list_lock); 1546 deleted = list_empty(&cfn->list); 1547 if (!deleted) 1548 list_del_init(&cfn->list); 1549 mutex_unlock(&sbi->cache_list_lock); 1550 if (!deleted) { 1551 delete_dentry_file(cfn->filp); 1552 release_cfn(cfn); 1553 } 1554} 1555 1556int hmdfs_do_lock_file(struct file *filp, unsigned char fl_type, loff_t start, 1557 loff_t len) 1558{ 1559 struct file_lock fl; 1560 int err; 1561 1562 locks_init_lock(&fl); 1563 1564 fl.fl_type = fl_type; 1565 fl.fl_flags = FL_POSIX | FL_CLOSE | FL_SLEEP; 1566 fl.fl_start = start; 1567 fl.fl_end = start + len - 1; 1568 fl.fl_owner = filp; 1569 fl.fl_pid = current->tgid; 1570 fl.fl_file = filp; 1571 fl.fl_ops = NULL; 1572 fl.fl_lmops = NULL; 1573 1574 err = locks_lock_file_wait(filp, &fl); 1575 if (err) 1576 hmdfs_err("lock file wait failed: %d", err); 1577 1578 return err; 1579} 1580 1581int hmdfs_wlock_file(struct file *filp, loff_t start, loff_t len) 1582{ 1583 return hmdfs_do_lock_file(filp, F_WRLCK, start, len); 1584} 1585 1586int hmdfs_rlock_file(struct file *filp, loff_t start, loff_t len) 1587{ 1588 return hmdfs_do_lock_file(filp, F_RDLCK, start, len); 1589} 1590 1591int hmdfs_unlock_file(struct file *filp, loff_t start, loff_t len) 1592{ 1593 return hmdfs_do_lock_file(filp, F_UNLCK, start, len); 1594} 1595 1596long cache_file_truncate(struct hmdfs_sb_info *sbi, const struct path *path, 1597 loff_t length) 1598{ 1599 const struct cred *old_cred = hmdfs_override_creds(sbi->system_cred); 1600 long ret = vfs_truncate(path, length); 1601 1602 hmdfs_revert_creds(old_cred); 1603 1604 return ret; 1605} 1606 1607ssize_t cache_file_read(struct hmdfs_sb_info *sbi, struct file *filp, void *buf, 1608 size_t count, loff_t *pos) 1609{ 1610 const struct cred *old_cred = hmdfs_override_creds(sbi->system_cred); 1611 ssize_t ret = kernel_read(filp, buf, count, pos); 1612 1613 hmdfs_revert_creds(old_cred); 1614 1615 return ret; 1616} 1617 1618ssize_t cache_file_write(struct hmdfs_sb_info *sbi, struct file *filp, 1619 const void *buf, size_t count, loff_t *pos) 1620{ 1621 const struct cred *old_cred = hmdfs_override_creds(sbi->system_cred); 1622 ssize_t ret = kernel_write(filp, buf, count, pos); 1623 1624 hmdfs_revert_creds(old_cred); 1625 1626 return ret; 1627} 1628 1629 1630int read_header(struct hmdfs_sb_info *sbi, struct file *filp, 1631 struct hmdfs_dcache_header *header) 1632{ 1633 ssize_t bytes; 1634 loff_t pos = 0; 1635 1636 bytes = cache_file_read(sbi, filp, header, sizeof(*header), &pos); 1637 if (bytes != sizeof(*header)) { 1638 hmdfs_err("read file failed, err:%zd", bytes); 1639 return -EIO; 1640 } 1641 1642 return 0; 1643} 1644 1645static unsigned long long cache_get_dentry_count(struct hmdfs_sb_info *sbi, 1646 struct file *filp) 1647{ 1648 struct hmdfs_dcache_header header; 1649 int overallpage; 1650 1651 overallpage = get_dentry_group_cnt(file_inode(filp)); 1652 if (overallpage == 0) 1653 return 0; 1654 1655 if (read_header(sbi, filp, &header)) 1656 return 0; 1657 1658 return le64_to_cpu(header.num); 1659} 1660 1661static int cache_check_case_sensitive(struct hmdfs_sb_info *sbi, 1662 struct file *filp) 1663{ 1664 struct hmdfs_dcache_header header; 1665 1666 if (read_header(sbi, filp, &header)) 1667 return 0; 1668 1669 if (sbi->s_case_sensitive != (bool)header.case_sensitive) { 1670 hmdfs_info("Case sensitive inconsistent, current fs is: %d, cache is %d, will drop cache", 1671 sbi->s_case_sensitive, header.case_sensitive); 1672 return 0; 1673 } 1674 return 1; 1675} 1676 1677int write_header(struct file *filp, struct hmdfs_dcache_header *header) 1678{ 1679 loff_t pos = 0; 1680 ssize_t size; 1681 1682 size = kernel_write(filp, header, sizeof(*header), &pos); 1683 if (size != sizeof(*header)) { 1684 hmdfs_err("update dcache header failed %zd", size); 1685 return -EIO; 1686 } 1687 1688 return 0; 1689} 1690 1691void add_to_delete_list(struct hmdfs_sb_info *sbi, struct cache_file_node *cfn) 1692{ 1693 mutex_lock(&sbi->cache_list_lock); 1694 list_add_tail(&cfn->list, &sbi->to_delete); 1695 mutex_unlock(&sbi->cache_list_lock); 1696} 1697 1698void load_cfn(struct hmdfs_sb_info *sbi, const char *fullname, const char *path, 1699 const char *cid, bool server) 1700{ 1701 struct cache_file_node *cfn = NULL; 1702 struct cache_file_node *cfn1 = NULL; 1703 struct list_head *head = NULL; 1704 1705 cfn = create_cfn(sbi, path, cid, server); 1706 if (!cfn) 1707 return; 1708 1709 cfn->filp = filp_open(fullname, O_RDWR | O_LARGEFILE, 0); 1710 if (IS_ERR(cfn->filp)) { 1711 hmdfs_err("open fail %ld", PTR_ERR(cfn->filp)); 1712 goto out; 1713 } 1714 1715 if (cache_get_dentry_count(sbi, cfn->filp) < sbi->dcache_threshold && strcmp(cid, CLOUD_CID)) { 1716 add_to_delete_list(sbi, cfn); 1717 return; 1718 } 1719 1720 if (!cache_check_case_sensitive(sbi, cfn->filp) && strcmp(cid, CLOUD_CID)) { 1721 add_to_delete_list(sbi, cfn); 1722 return; 1723 } 1724 1725 head = get_list_head(sbi, server); 1726 1727 mutex_lock(&sbi->cache_list_lock); 1728 cfn1 = __find_cfn(sbi, cid, path, server); 1729 if (!cfn1) { 1730 list_add_tail(&cfn->list, head); 1731 } else { 1732 release_cfn(cfn1); 1733 mutex_unlock(&sbi->cache_list_lock); 1734 add_to_delete_list(sbi, cfn); 1735 return; 1736 } 1737 mutex_unlock(&sbi->cache_list_lock); 1738 1739 return; 1740out: 1741 free_cfn(cfn); 1742} 1743 1744static int get_cid_and_hash(const char *name, uint64_t *hash, char *cid) 1745{ 1746 int len; 1747 char *p = strstr(name, "_"); 1748 1749 if (!p) 1750 return -EINVAL; 1751 1752 len = p - name; 1753 if (len >= HMDFS_CFN_CID_SIZE) 1754 return -EINVAL; 1755 1756 memcpy(cid, name, len); 1757 cid[len] = '\0'; 1758 1759 if (sscanf(++p, "%llx", hash) != 1) 1760 return -EINVAL; 1761 return 0; 1762} 1763 1764static void store_one(const char *name, struct cache_file_callback *cb) 1765{ 1766 struct file *file = NULL; 1767 char *fullname = NULL; 1768 char *kvalue = NULL; 1769 char cid[HMDFS_CFN_CID_SIZE]; 1770 uint64_t hash; 1771 ssize_t error; 1772 1773 if (strlen(name) + strlen(cb->dirname) >= PATH_MAX) 1774 return; 1775 1776 fullname = kzalloc(PATH_MAX, GFP_KERNEL); 1777 if (!fullname) 1778 return; 1779 1780 snprintf(fullname, PATH_MAX, "%s%s", cb->dirname, name); 1781 1782 file = filp_open(fullname, O_RDWR | O_LARGEFILE, 0); 1783 if (IS_ERR(file)) { 1784 hmdfs_err("open fail %ld", PTR_ERR(file)); 1785 goto out; 1786 } 1787 1788 kvalue = kzalloc(PATH_MAX, GFP_KERNEL); 1789 if (!kvalue) 1790 goto out_file; 1791 1792 error = __vfs_getxattr(file_dentry(file), file_inode(file), 1793 DENTRY_FILE_XATTR_NAME, kvalue, PATH_MAX); 1794 if (error <= 0 || error >= PATH_MAX) { 1795 hmdfs_err("getxattr return: %zd", error); 1796 goto out_kvalue; 1797 } 1798 1799 kvalue[error] = '\0'; 1800 cid[0] = '\0'; 1801 1802 if (!cb->server) { 1803 if (get_cid_and_hash(name, &hash, cid)) { 1804 hmdfs_err("get cid and hash fail"); 1805 goto out_kvalue; 1806 } 1807 } 1808 1809 load_cfn(cb->sbi, fullname, kvalue, cid, cb->server); 1810 1811out_kvalue: 1812 kfree(kvalue); 1813out_file: 1814 filp_close(file, NULL); 1815out: 1816 kfree(fullname); 1817} 1818 1819static int cache_file_iterate(struct dir_context *ctx, const char *name, 1820 int name_len, loff_t offset, u64 ino, 1821 unsigned int d_type) 1822{ 1823 struct cache_file_item *cfi = NULL; 1824 struct cache_file_callback *cb = 1825 container_of(ctx, struct cache_file_callback, ctx); 1826 1827 if (name_len > NAME_MAX) { 1828 hmdfs_err("name_len:%d NAME_MAX:%u", name_len, NAME_MAX); 1829 return 0; 1830 } 1831 1832 if (d_type != DT_REG) 1833 return 0; 1834 1835 cfi = kmalloc(sizeof(*cfi), GFP_KERNEL); 1836 if (!cfi) 1837 return -ENOMEM; 1838 1839 cfi->name = kstrndup(name, name_len, GFP_KERNEL); 1840 if (!cfi->name) { 1841 kfree(cfi); 1842 return -ENOMEM; 1843 } 1844 1845 list_add_tail(&cfi->list, &cb->list); 1846 1847 return 0; 1848} 1849 1850void hmdfs_do_load(struct hmdfs_sb_info *sbi, const char *fullname, bool server) 1851{ 1852 struct file *file = NULL; 1853 struct path dirpath; 1854 int err; 1855 struct cache_file_item *cfi = NULL; 1856 struct cache_file_item *n = NULL; 1857 struct cache_file_callback cb = { 1858 .ctx.actor = cache_file_iterate, 1859 .ctx.pos = 0, 1860 .dirname = fullname, 1861 .sbi = sbi, 1862 .server = server, 1863 }; 1864 INIT_LIST_HEAD(&cb.list); 1865 1866 1867 err = kern_path(fullname, LOOKUP_DIRECTORY, &dirpath); 1868 if (err) { 1869 hmdfs_info("No file path"); 1870 return; 1871 } 1872 1873 file = dentry_open(&dirpath, O_RDONLY, current_cred()); 1874 if (IS_ERR_OR_NULL(file)) { 1875 hmdfs_err("dentry_open failed, error: %ld", PTR_ERR(file)); 1876 path_put(&dirpath); 1877 return; 1878 } 1879 1880 err = iterate_dir(file, &cb.ctx); 1881 if (err) 1882 hmdfs_err("iterate_dir failed, err: %d", err); 1883 1884 list_for_each_entry_safe(cfi, n, &cb.list, list) { 1885 store_one(cfi->name, &cb); 1886 list_del_init(&cfi->list); 1887 kfree(cfi->name); 1888 kfree(cfi); 1889 } 1890 1891 fput(file); 1892 path_put(&dirpath); 1893} 1894 1895/** 1896 * This function just used for delete dentryfile.dat 1897 */ 1898int delete_dentry_file(struct file *filp) 1899{ 1900 int err = 0; 1901 struct dentry *dentry = file_dentry(filp); 1902 struct dentry *parent = lock_parent(dentry); 1903 1904 if (dentry->d_parent == parent) { 1905 dget(dentry); 1906 err = vfs_unlink(d_inode(parent), dentry, NULL); 1907 dput(dentry); 1908 } 1909 unlock_dir(parent); 1910 1911 return err; 1912} 1913 1914void hmdfs_delete_useless_cfn(struct hmdfs_sb_info *sbi) 1915{ 1916 struct cache_file_node *cfn = NULL; 1917 struct cache_file_node *n = NULL; 1918 1919 mutex_lock(&sbi->cache_list_lock); 1920 1921 list_for_each_entry_safe(cfn, n, &sbi->to_delete, list) { 1922 delete_dentry_file(cfn->filp); 1923 list_del_init(&cfn->list); 1924 release_cfn(cfn); 1925 } 1926 mutex_unlock(&sbi->cache_list_lock); 1927} 1928 1929void hmdfs_cfn_load(struct hmdfs_sb_info *sbi) 1930{ 1931 char *fullname = NULL; 1932 1933 if (!sbi->s_dentry_cache) 1934 return; 1935 1936 fullname = kzalloc(PATH_MAX, GFP_KERNEL); 1937 if (!fullname) 1938 return; 1939 1940 snprintf(fullname, PATH_MAX, "%s/dentry_cache/client/", 1941 sbi->cache_dir); 1942 hmdfs_do_load(sbi, fullname, false); 1943 1944 snprintf(fullname, PATH_MAX, "%s/dentry_cache/server/", 1945 sbi->cache_dir); 1946 hmdfs_do_load(sbi, fullname, true); 1947 1948 kfree(fullname); 1949 1950 hmdfs_delete_useless_cfn(sbi); 1951} 1952 1953static void __cache_file_destroy_by_path(struct list_head *head, 1954 const char *path) 1955{ 1956 struct cache_file_node *cfn = NULL; 1957 struct cache_file_node *n = NULL; 1958 1959 list_for_each_entry_safe(cfn, n, head, list) { 1960 if (strcmp(path, cfn->relative_path) != 0) 1961 continue; 1962 list_del_init(&cfn->list); 1963 delete_dentry_file(cfn->filp); 1964 release_cfn(cfn); 1965 } 1966} 1967 1968static void cache_file_destroy_by_path(struct hmdfs_sb_info *sbi, 1969 const char *path) 1970{ 1971 mutex_lock(&sbi->cache_list_lock); 1972 1973 __cache_file_destroy_by_path(&sbi->server_cache, path); 1974 __cache_file_destroy_by_path(&sbi->client_cache, path); 1975 1976 mutex_unlock(&sbi->cache_list_lock); 1977} 1978 1979static void cache_file_find_and_delete(struct hmdfs_peer *con, 1980 const char *relative_path) 1981{ 1982 struct cache_file_node *cfn; 1983 1984 cfn = find_cfn(con->sbi, con->cid, relative_path, false); 1985 if (!cfn) 1986 return; 1987 1988 remove_cfn(cfn); 1989 release_cfn(cfn); 1990} 1991 1992void cache_file_delete_by_dentry(struct hmdfs_peer *con, struct dentry *dentry) 1993{ 1994 char *relative_path = NULL; 1995 1996 relative_path = hmdfs_get_dentry_relative_path(dentry); 1997 if (unlikely(!relative_path)) { 1998 hmdfs_err("get relative path failed %d", -ENOMEM); 1999 return; 2000 } 2001 cache_file_find_and_delete(con, relative_path); 2002 kfree(relative_path); 2003} 2004 2005struct file *hmdfs_get_new_dentry_file(struct hmdfs_peer *con, 2006 const char *relative_path, 2007 struct hmdfs_dcache_header *header) 2008{ 2009 struct hmdfs_sb_info *sbi = con->sbi; 2010 int len = strlen(relative_path); 2011 struct file *filp = NULL; 2012 int err; 2013 2014 filp = create_local_dentry_file_cache(sbi); 2015 if (IS_ERR(filp)) 2016 return filp; 2017 2018 err = hmdfs_client_start_readdir(con, filp, relative_path, len, header); 2019 if (err) { 2020 if (err != -ENOENT) 2021 hmdfs_err("readdir failed dev: %llu err: %d", 2022 con->device_id, err); 2023 fput(filp); 2024 filp = ERR_PTR(err); 2025 } 2026 2027 return filp; 2028} 2029 2030void add_cfn_to_item(struct dentry *dentry, struct hmdfs_peer *con, 2031 struct cache_file_node *cfn) 2032{ 2033 struct file *file = cfn->filp; 2034 int err; 2035 2036 err = hmdfs_add_cache_list(con->device_id, dentry, file); 2037 if (unlikely(err)) { 2038 hmdfs_err("add cache list failed devid:%llu err:%d", 2039 con->device_id, err); 2040 return; 2041 } 2042} 2043 2044int hmdfs_add_file_to_cache(struct dentry *dentry, struct hmdfs_peer *con, 2045 struct file *file, const char *relative_path) 2046{ 2047 struct hmdfs_sb_info *sbi = con->sbi; 2048 struct file *newf = file; 2049 2050 if (cache_get_dentry_count(sbi, file) >= sbi->dcache_threshold) 2051 newf = cache_file_persistent(con, file, relative_path, false); 2052 else 2053 cache_file_find_and_delete(con, relative_path); 2054 2055 return hmdfs_add_cache_list(con->device_id, dentry, newf); 2056} 2057 2058static struct file *read_header_and_revalidate(struct hmdfs_peer *con, 2059 struct file *filp, 2060 const char *relative_path) 2061{ 2062 struct hmdfs_dcache_header header; 2063 struct hmdfs_dcache_header *p = NULL; 2064 2065 if (read_header(con->sbi, filp, &header) == 0) 2066 p = &header; 2067 2068 return hmdfs_get_new_dentry_file(con, relative_path, p); 2069} 2070 2071void remote_file_revalidate_cfn(struct dentry *dentry, struct hmdfs_peer *con, 2072 struct cache_file_node *cfn, 2073 const char *relative_path) 2074{ 2075 struct file *file = NULL; 2076 int err; 2077 2078 file = read_header_and_revalidate(con, cfn->filp, relative_path); 2079 if (IS_ERR(file)) 2080 return; 2081 2082 /* 2083 * If the request returned ok but file length is 0, we assume 2084 * that the server verified the client cache file is uptodate. 2085 */ 2086 if (i_size_read(file->f_inode) == 0) { 2087 hmdfs_info("The cfn cache for dev:%llu is uptodate", 2088 con->device_id); 2089 fput(file); 2090 add_cfn_to_item(dentry, con, cfn); 2091 return; 2092 } 2093 2094 /* OK, cfn is not uptodate, let's remove it and add the new file */ 2095 remove_cfn(cfn); 2096 2097 err = hmdfs_add_file_to_cache(dentry, con, file, relative_path); 2098 if (unlikely(err)) 2099 hmdfs_err("add cache list failed devid:%llu err:%d", 2100 con->device_id, err); 2101 fput(file); 2102} 2103 2104void remote_file_revalidate_item(struct dentry *dentry, struct hmdfs_peer *con, 2105 struct clearcache_item *item, 2106 const char *relative_path) 2107{ 2108 struct file *file = NULL; 2109 int err; 2110 2111 file = read_header_and_revalidate(con, item->filp, relative_path); 2112 if (IS_ERR(file)) 2113 return; 2114 2115 /* 2116 * If the request returned ok but file length is 0, we assume 2117 * that the server verified the client cache file is uptodate. 2118 */ 2119 if (i_size_read(file->f_inode) == 0) { 2120 hmdfs_info("The item cache for dev:%llu is uptodate", 2121 con->device_id); 2122 item->time = jiffies; 2123 fput(file); 2124 return; 2125 } 2126 2127 /* We need to replace the old item */ 2128 remove_cache_item(item); 2129 cache_file_find_and_delete(con, relative_path); 2130 2131 err = hmdfs_add_file_to_cache(dentry, con, file, relative_path); 2132 if (unlikely(err)) 2133 hmdfs_err("add cache list failed devid:%llu err:%d", 2134 con->device_id, err); 2135 fput(file); 2136} 2137 2138bool get_remote_dentry_file(struct dentry *dentry, struct hmdfs_peer *con) 2139{ 2140 struct hmdfs_dentry_info *d_info = hmdfs_d(dentry); 2141 struct cache_file_node *cfn = NULL; 2142 struct hmdfs_sb_info *sbi = con->sbi; 2143 char *relative_path = NULL; 2144 int err = 0; 2145 struct file *filp = NULL; 2146 struct clearcache_item *item; 2147 2148 if (hmdfs_cache_revalidate(READ_ONCE(con->conn_time), con->device_id, 2149 dentry)) 2150 return false; 2151 2152 relative_path = hmdfs_get_dentry_relative_path(dentry); 2153 if (unlikely(!relative_path)) { 2154 hmdfs_err("get relative path failed %d", -ENOMEM); 2155 return false; 2156 } 2157 mutex_lock(&d_info->cache_pull_lock); 2158 if (hmdfs_cache_revalidate(READ_ONCE(con->conn_time), con->device_id, 2159 dentry)) 2160 goto out_unlock; 2161 2162 item = hmdfs_find_cache_item(con->device_id, dentry); 2163 if (item) { 2164 remote_file_revalidate_item(dentry, con, item, relative_path); 2165 kref_put(&item->ref, release_cache_item); 2166 goto out_unlock; 2167 } 2168 2169 cfn = find_cfn(sbi, con->cid, relative_path, false); 2170 if (cfn) { 2171 remote_file_revalidate_cfn(dentry, con, cfn, relative_path); 2172 release_cfn(cfn); 2173 goto out_unlock; 2174 } 2175 2176 filp = hmdfs_get_new_dentry_file(con, relative_path, NULL); 2177 if (IS_ERR(filp)) { 2178 err = PTR_ERR(filp); 2179 goto out_unlock; 2180 } 2181 2182 err = hmdfs_add_file_to_cache(dentry, con, filp, relative_path); 2183 if (unlikely(err)) 2184 hmdfs_err("add cache list failed devid:%lu err:%d", 2185 (unsigned long)con->device_id, err); 2186 fput(filp); 2187 2188out_unlock: 2189 mutex_unlock(&d_info->cache_pull_lock); 2190 if (err && err != -ENOENT) 2191 hmdfs_err("readdir failed dev:%lu err:%d", 2192 (unsigned long)con->device_id, err); 2193 kfree(relative_path); 2194 return true; 2195} 2196 2197int hmdfs_file_type(const char *name) 2198{ 2199 if (!name) 2200 return -EINVAL; 2201 2202 if (!strcmp(name, CURRENT_DIR) || !strcmp(name, PARENT_DIR)) 2203 return HMDFS_TYPE_DOT; 2204 2205 return HMDFS_TYPE_COMMON; 2206} 2207 2208struct clearcache_item *hmdfs_find_cache_item(uint64_t dev_id, 2209 struct dentry *dentry) 2210{ 2211 struct clearcache_item *item = NULL; 2212 struct hmdfs_dentry_info *d_info = hmdfs_d(dentry); 2213 2214 if (!d_info) 2215 return NULL; 2216 2217 spin_lock(&d_info->cache_list_lock); 2218 list_for_each_entry(item, &(d_info->cache_list_head), list) { 2219 if (dev_id == item->dev_id) { 2220 kref_get(&item->ref); 2221 spin_unlock(&d_info->cache_list_lock); 2222 return item; 2223 } 2224 } 2225 spin_unlock(&d_info->cache_list_lock); 2226 return NULL; 2227} 2228 2229bool hmdfs_cache_revalidate(unsigned long conn_time, uint64_t dev_id, 2230 struct dentry *dentry) 2231{ 2232 bool ret = false; 2233 struct clearcache_item *item = NULL; 2234 struct hmdfs_dentry_info *d_info = hmdfs_d(dentry); 2235 unsigned int timeout; 2236 2237 if (!d_info) 2238 return ret; 2239 2240 timeout = hmdfs_sb(dentry->d_sb)->dcache_timeout; 2241 spin_lock(&d_info->cache_list_lock); 2242 list_for_each_entry(item, &(d_info->cache_list_head), list) { 2243 if (dev_id == item->dev_id) { 2244 ret = cache_item_revalidate(conn_time, item->time, 2245 timeout); 2246 break; 2247 } 2248 } 2249 spin_unlock(&d_info->cache_list_lock); 2250 return ret; 2251} 2252 2253void remove_cache_item(struct clearcache_item *item) 2254{ 2255 bool deleted; 2256 2257 spin_lock(&item->d_info->cache_list_lock); 2258 deleted = list_empty(&item->list); 2259 if (!deleted) 2260 list_del_init(&item->list); 2261 spin_unlock(&item->d_info->cache_list_lock); 2262 if (!deleted) 2263 kref_put(&item->ref, release_cache_item); 2264} 2265 2266void release_cache_item(struct kref *ref) 2267{ 2268 struct clearcache_item *item = 2269 container_of(ref, struct clearcache_item, ref); 2270 2271 if (item->filp) 2272 fput(item->filp); 2273 kfree(item); 2274} 2275 2276void hmdfs_remove_cache_filp(struct hmdfs_peer *con, struct dentry *dentry) 2277{ 2278 struct clearcache_item *item = NULL; 2279 struct clearcache_item *item_temp = NULL; 2280 struct hmdfs_dentry_info *d_info = hmdfs_d(dentry); 2281 // struct path *lower_path = NULL; 2282 2283 if (!d_info) 2284 return; 2285 2286 spin_lock(&d_info->cache_list_lock); 2287 list_for_each_entry_safe(item, item_temp, &(d_info->cache_list_head), 2288 list) { 2289 if (con->device_id == item->dev_id) { 2290 list_del_init(&item->list); 2291 spin_unlock(&d_info->cache_list_lock); 2292 cache_file_delete_by_dentry(con, dentry); 2293 kref_put(&item->ref, release_cache_item); 2294 return; 2295 } 2296 } 2297 spin_unlock(&d_info->cache_list_lock); 2298} 2299 2300int hmdfs_add_cache_list(uint64_t dev_id, struct dentry *dentry, 2301 struct file *filp) 2302{ 2303 struct clearcache_item *item = NULL; 2304 struct hmdfs_dentry_info *d_info = hmdfs_d(dentry); 2305 2306 if (!d_info) 2307 return -ENOMEM; 2308 2309 item = kzalloc(sizeof(*item), GFP_KERNEL); 2310 if (!item) 2311 return -ENOMEM; 2312 2313 item->dev_id = dev_id; 2314 item->filp = get_file(filp); 2315 item->time = jiffies; 2316 item->d_info = d_info; 2317 kref_init(&item->ref); 2318 spin_lock(&d_info->cache_list_lock); 2319 list_add_tail(&(item->list), &(d_info->cache_list_head)); 2320 spin_unlock(&d_info->cache_list_lock); 2321 return 0; 2322} 2323 2324void hmdfs_add_remote_cache_list(struct hmdfs_peer *con, const char *dir_path) 2325{ 2326 int err = 0; 2327 struct remotecache_item *item = NULL; 2328 struct remotecache_item *item_temp = NULL; 2329 struct path path, root_path; 2330 struct hmdfs_dentry_info *d_info = NULL; 2331 2332 err = kern_path(con->sbi->local_dst, 0, &root_path); 2333 if (err) { 2334 hmdfs_err("kern_path failed err = %d", err); 2335 return; 2336 } 2337 2338 err = vfs_path_lookup(root_path.dentry, root_path.mnt, dir_path, 0, 2339 &path); 2340 if (err) 2341 goto out_put_root; 2342 2343 d_info = hmdfs_d(path.dentry); 2344 if (!d_info) { 2345 err = -EINVAL; 2346 goto out; 2347 } 2348 2349 /* find duplicate con */ 2350 mutex_lock(&d_info->remote_cache_list_lock); 2351 list_for_each_entry_safe(item, item_temp, 2352 &(d_info->remote_cache_list_head), list) { 2353 if (item->con->device_id == con->device_id) { 2354 mutex_unlock(&d_info->remote_cache_list_lock); 2355 goto out; 2356 } 2357 } 2358 2359 item = kzalloc(sizeof(*item), GFP_KERNEL); 2360 if (!item) { 2361 err = -ENOMEM; 2362 mutex_unlock(&d_info->remote_cache_list_lock); 2363 goto out; 2364 } 2365 2366 item->con = con; 2367 item->drop_flag = 0; 2368 list_add(&(item->list), &(d_info->remote_cache_list_head)); 2369 mutex_unlock(&d_info->remote_cache_list_lock); 2370 2371out: 2372 path_put(&path); 2373out_put_root: 2374 path_put(&root_path); 2375} 2376 2377int hmdfs_drop_remote_cache_dents(struct dentry *dentry) 2378{ 2379 struct path lower_path; 2380 struct inode *lower_inode = NULL; 2381 struct remotecache_item *item = NULL; 2382 struct remotecache_item *item_temp = NULL; 2383 struct hmdfs_dentry_info *d_info = NULL; 2384 char *relative_path = NULL; 2385 2386 if (!dentry) { 2387 hmdfs_err("dentry null and return"); 2388 return 0; 2389 } 2390 2391 d_info = hmdfs_d(dentry); 2392 if (!d_info) { 2393 hmdfs_err("d_info null and return"); 2394 return 0; 2395 } 2396 hmdfs_get_lower_path(dentry, &lower_path); 2397 if (IS_ERR_OR_NULL(lower_path.dentry)) { 2398 hmdfs_put_lower_path(&lower_path); 2399 return 0; 2400 } 2401 lower_inode = d_inode(lower_path.dentry); 2402 hmdfs_put_lower_path(&lower_path); 2403 if (IS_ERR_OR_NULL(lower_inode)) 2404 return 0; 2405 /* only for directory */ 2406 if (!S_ISDIR(lower_inode->i_mode)) 2407 return 0; 2408 2409 relative_path = hmdfs_get_dentry_relative_path(dentry); 2410 if (!relative_path) { 2411 hmdfs_err("get dentry relative path failed"); 2412 return 0; 2413 } 2414 mutex_lock(&d_info->remote_cache_list_lock); 2415 list_for_each_entry_safe(item, item_temp, 2416 &(d_info->remote_cache_list_head), list) { 2417 if (item->drop_flag) { 2418 item->drop_flag = 0; 2419 continue; 2420 } 2421 mutex_unlock(&d_info->remote_cache_list_lock); 2422 hmdfs_send_drop_push(item->con, relative_path); 2423 mutex_lock(&d_info->remote_cache_list_lock); 2424 list_del(&item->list); 2425 kfree(item); 2426 } 2427 mutex_unlock(&d_info->remote_cache_list_lock); 2428 2429 kfree(relative_path); 2430 return 0; 2431} 2432 2433/* Clear the dentry cache files of target directory */ 2434int hmdfs_clear_cache_dents(struct dentry *dentry, bool remove_cache) 2435{ 2436 struct clearcache_item *item = NULL; 2437 struct clearcache_item *item_temp = NULL; 2438 struct hmdfs_dentry_info *d_info = hmdfs_d(dentry); 2439 char *path = NULL; 2440 2441 if (!d_info) 2442 return 0; 2443 2444 spin_lock(&d_info->cache_list_lock); 2445 list_for_each_entry_safe(item, item_temp, &(d_info->cache_list_head), 2446 list) { 2447 list_del_init(&item->list); 2448 kref_put(&item->ref, release_cache_item); 2449 } 2450 spin_unlock(&d_info->cache_list_lock); 2451 2452 if (!remove_cache) 2453 return 0; 2454 2455 /* it also need confirm that there are no dentryfile_dev* 2456 * under this dentry 2457 */ 2458 path = hmdfs_get_dentry_relative_path(dentry); 2459 2460 if (unlikely(!path)) { 2461 hmdfs_err("get relative path failed"); 2462 return 0; 2463 } 2464 2465 cache_file_destroy_by_path(hmdfs_sb(dentry->d_sb), path); 2466 2467 kfree(path); 2468 return 0; 2469} 2470 2471void hmdfs_mark_drop_flag(uint64_t device_id, struct dentry *dentry) 2472{ 2473 struct remotecache_item *item = NULL; 2474 struct hmdfs_dentry_info *d_info = NULL; 2475 2476 d_info = hmdfs_d(dentry); 2477 if (!d_info) { 2478 hmdfs_err("d_info null and return"); 2479 return; 2480 } 2481 2482 mutex_lock(&d_info->remote_cache_list_lock); 2483 list_for_each_entry(item, &(d_info->remote_cache_list_head), list) { 2484 if (item->con->device_id == device_id) { 2485 item->drop_flag = 1; 2486 break; 2487 } 2488 } 2489 mutex_unlock(&d_info->remote_cache_list_lock); 2490} 2491 2492void hmdfs_clear_drop_flag(struct dentry *dentry) 2493{ 2494 struct remotecache_item *item = NULL; 2495 struct hmdfs_dentry_info *d_info = NULL; 2496 2497 if (!dentry) { 2498 hmdfs_err("dentry null and return"); 2499 return; 2500 } 2501 2502 d_info = hmdfs_d(dentry); 2503 if (!d_info) { 2504 hmdfs_err("d_info null and return"); 2505 return; 2506 } 2507 2508 mutex_lock(&d_info->remote_cache_list_lock); 2509 list_for_each_entry(item, &(d_info->remote_cache_list_head), list) { 2510 if (item->drop_flag) 2511 item->drop_flag = 0; 2512 } 2513 mutex_unlock(&d_info->remote_cache_list_lock); 2514} 2515 2516#define DUSTBIN_SUFFIX ".hwbk" 2517static void hmdfs_rename_bak(struct dentry *dentry) 2518{ 2519 struct path lower_path; 2520 struct dentry *lower_parent = NULL; 2521 struct dentry *lower_dentry = NULL; 2522 struct dentry *new_dentry = NULL; 2523 char *name = NULL; 2524 int len = 0; 2525 int err = 0; 2526 2527 hmdfs_get_lower_path(dentry, &lower_path); 2528 lower_dentry = lower_path.dentry; 2529 len = strlen(lower_dentry->d_name.name) + strlen(DUSTBIN_SUFFIX) + 2; 2530 if (len >= NAME_MAX) { 2531 err = -ENAMETOOLONG; 2532 goto put_lower_path; 2533 } 2534 2535 name = kmalloc(len, GFP_KERNEL); 2536 if (!name) { 2537 err = -ENOMEM; 2538 goto put_lower_path; 2539 } 2540 2541 snprintf(name, len, ".%s%s", lower_dentry->d_name.name, DUSTBIN_SUFFIX); 2542 err = mnt_want_write(lower_path.mnt); 2543 if (err) { 2544 hmdfs_info("get write access failed, err %d", err); 2545 goto free_name; 2546 } 2547 2548 lower_parent = lock_parent(lower_dentry); 2549 new_dentry = lookup_one_len(name, lower_parent, strlen(name)); 2550 if (IS_ERR(new_dentry)) { 2551 err = PTR_ERR(new_dentry); 2552 hmdfs_info("lookup new dentry failed, err %d", err); 2553 goto unlock_parent; 2554 } 2555 2556 err = vfs_rename(d_inode(lower_parent), lower_dentry, 2557 d_inode(lower_parent), new_dentry, NULL, 0); 2558 2559 dput(new_dentry); 2560unlock_parent: 2561 unlock_dir(lower_parent); 2562 mnt_drop_write(lower_path.mnt); 2563free_name: 2564 kfree(name); 2565put_lower_path: 2566 hmdfs_put_lower_path(&lower_path); 2567 2568 if (err) 2569 hmdfs_err("failed to rename file, err %d", err); 2570} 2571 2572int hmdfs_root_unlink(uint64_t device_id, struct path *root_path, 2573 const char *unlink_dir, const char *unlink_name) 2574{ 2575 int err = 0; 2576 struct path path; 2577 struct dentry *child_dentry = NULL; 2578 struct inode *dir = NULL; 2579 struct inode *child_inode = NULL; 2580 kuid_t tmp_uid; 2581 2582 err = vfs_path_lookup(root_path->dentry, root_path->mnt, 2583 unlink_dir, LOOKUP_DIRECTORY, &path); 2584 if (err) { 2585 hmdfs_err("found path failed err = %d", err); 2586 return err; 2587 } 2588 dir = d_inode(path.dentry); 2589 inode_lock_nested(dir, I_MUTEX_PARENT); 2590 2591 child_dentry = lookup_one_len(unlink_name, path.dentry, 2592 strlen(unlink_name)); 2593 if (IS_ERR(child_dentry)) { 2594 err = PTR_ERR(child_dentry); 2595 hmdfs_err("lookup_one_len failed, err = %d", err); 2596 goto unlock_out; 2597 } 2598 if (d_is_negative(child_dentry)) { 2599 err = -ENOENT; 2600 dput(child_dentry); 2601 goto unlock_out; 2602 } 2603 child_inode = d_inode(child_dentry); 2604 if (!child_inode) 2605 goto unlock_out; 2606 2607 tmp_uid = hmdfs_override_inode_uid(dir); 2608 2609 hmdfs_mark_drop_flag(device_id, path.dentry); 2610 ihold(child_inode); 2611 err = vfs_unlink(dir, child_dentry, NULL); 2612 /* 2613 * -EOWNERDEAD means we want to put the file in a specail dir instead of 2614 * deleting it, specifically dustbin in phone, so that user can 2615 * recover the deleted images and videos. 2616 */ 2617 if (err == -EOWNERDEAD) { 2618 hmdfs_rename_bak(child_dentry); 2619 err = 0; 2620 } 2621 if (err) 2622 hmdfs_err("unlink path failed err = %d", err); 2623 hmdfs_revert_inode_uid(dir, tmp_uid); 2624 dput(child_dentry); 2625 2626unlock_out: 2627 inode_unlock(dir); 2628 if (child_inode) 2629 iput(child_inode); 2630 path_put(&path); 2631 return err; 2632} 2633 2634struct dentry *hmdfs_root_mkdir(uint64_t device_id, const char *local_dst_path, 2635 const char *mkdir_dir, const char *mkdir_name, 2636 umode_t mode) 2637{ 2638 int err; 2639 struct path path; 2640 struct dentry *child_dentry = NULL; 2641 struct dentry *ret = NULL; 2642 char *mkdir_path = NULL; 2643 char *mkdir_abs_path = NULL; 2644 2645 mkdir_path = hmdfs_connect_path(mkdir_dir, mkdir_name); 2646 if (!mkdir_path) 2647 return ERR_PTR(-EACCES); 2648 2649 mkdir_abs_path = 2650 hmdfs_get_dentry_absolute_path(local_dst_path, mkdir_path); 2651 if (!mkdir_abs_path) { 2652 ret = ERR_PTR(-ENOMEM); 2653 goto out; 2654 } 2655 2656 child_dentry = kern_path_create(AT_FDCWD, mkdir_abs_path, 2657 &path, LOOKUP_DIRECTORY); 2658 if (IS_ERR(child_dentry)) { 2659 ret = child_dentry; 2660 goto out; 2661 } 2662 2663 hmdfs_mark_drop_flag(device_id, child_dentry->d_parent); 2664 err = vfs_mkdir(d_inode(path.dentry), child_dentry, mode); 2665 if (err) { 2666 hmdfs_err("mkdir failed! err=%d", err); 2667 ret = ERR_PTR(err); 2668 goto out_put; 2669 } 2670 ret = dget(child_dentry); 2671out_put: 2672 done_path_create(&path, child_dentry); 2673out: 2674 kfree(mkdir_path); 2675 kfree(mkdir_abs_path); 2676 return ret; 2677} 2678 2679struct dentry *hmdfs_root_create(uint64_t device_id, const char *local_dst_path, 2680 const char *create_dir, 2681 const char *create_name, 2682 umode_t mode, bool want_excl) 2683{ 2684 int err; 2685 struct path path; 2686 struct dentry *child_dentry = NULL; 2687 struct dentry *ret = NULL; 2688 char *create_path = NULL; 2689 char *create_abs_path = NULL; 2690 2691 create_path = hmdfs_connect_path(create_dir, create_name); 2692 if (!create_path) 2693 return ERR_PTR(-EACCES); 2694 2695 create_abs_path = 2696 hmdfs_get_dentry_absolute_path(local_dst_path, create_path); 2697 if (!create_abs_path) { 2698 ret = ERR_PTR(-ENOMEM); 2699 goto out; 2700 } 2701 2702 child_dentry = kern_path_create(AT_FDCWD, create_abs_path, &path, 0); 2703 2704 if (IS_ERR(child_dentry)) { 2705 ret = child_dentry; 2706 goto out; 2707 } 2708 hmdfs_mark_drop_flag(device_id, child_dentry->d_parent); 2709 err = vfs_create(d_inode(path.dentry), child_dentry, mode, want_excl); 2710 if (err) { 2711 hmdfs_err("path create failed! err=%d", err); 2712 ret = ERR_PTR(err); 2713 goto out_put; 2714 } 2715 ret = dget(child_dentry); 2716out_put: 2717 done_path_create(&path, child_dentry); 2718out: 2719 kfree(create_path); 2720 kfree(create_abs_path); 2721 return ret; 2722} 2723 2724int hmdfs_root_rmdir(uint64_t device_id, struct path *root_path, 2725 const char *rmdir_dir, const char *rmdir_name) 2726{ 2727 int err = 0; 2728 struct path path; 2729 struct dentry *child_dentry = NULL; 2730 struct inode *dir = NULL; 2731 2732 err = vfs_path_lookup(root_path->dentry, root_path->mnt, 2733 rmdir_dir, LOOKUP_DIRECTORY, &path); 2734 if (err) { 2735 hmdfs_err("found path failed err = %d", err); 2736 return err; 2737 } 2738 dir = d_inode(path.dentry); 2739 inode_lock_nested(dir, I_MUTEX_PARENT); 2740 2741 child_dentry = lookup_one_len(rmdir_name, path.dentry, 2742 strlen(rmdir_name)); 2743 if (IS_ERR(child_dentry)) { 2744 err = PTR_ERR(child_dentry); 2745 hmdfs_err("lookup_one_len failed, err = %d", err); 2746 goto unlock_out; 2747 } 2748 if (d_is_negative(child_dentry)) { 2749 err = -ENOENT; 2750 dput(child_dentry); 2751 goto unlock_out; 2752 } 2753 2754 hmdfs_mark_drop_flag(device_id, path.dentry); 2755 err = vfs_rmdir(dir, child_dentry); 2756 if (err) 2757 hmdfs_err("rmdir failed err = %d", err); 2758 dput(child_dentry); 2759 2760unlock_out: 2761 inode_unlock(dir); 2762 path_put(&path); 2763 return err; 2764} 2765 2766int hmdfs_root_rename(struct hmdfs_sb_info *sbi, uint64_t device_id, 2767 const char *oldpath, const char *oldname, 2768 const char *newpath, const char *newname, 2769 unsigned int flags) 2770{ 2771 int err = 0; 2772 struct path path_dst; 2773 struct path path_old; 2774 struct path path_new; 2775 struct dentry *trap = NULL; 2776 struct dentry *old_dentry = NULL; 2777 struct dentry *new_dentry = NULL; 2778 2779 err = kern_path(sbi->local_dst, 0, &path_dst); 2780 if (err) { 2781 hmdfs_err("kern_path for local dst failed %d", err); 2782 return err; 2783 } 2784 2785 err = vfs_path_lookup(path_dst.dentry, path_dst.mnt, oldpath, 0, 2786 &path_old); 2787 if (err) { 2788 hmdfs_info("lookup oldpath from local_dst failed, err %d", err); 2789 goto put_path_dst; 2790 } 2791 2792 err = vfs_path_lookup(path_dst.dentry, path_dst.mnt, newpath, 0, 2793 &path_new); 2794 if (err) { 2795 hmdfs_info("lookup newpath from local_dst failed, err %d", err); 2796 goto put_path_old; 2797 } 2798 2799 err = mnt_want_write(path_dst.mnt); 2800 if (err) { 2801 hmdfs_info("get write access failed for local_dst, err %d", 2802 err); 2803 goto put_path_new; 2804 } 2805 2806 trap = lock_rename(path_new.dentry, path_old.dentry); 2807 2808 old_dentry = lookup_one_len(oldname, path_old.dentry, strlen(oldname)); 2809 if (IS_ERR(old_dentry)) { 2810 err = PTR_ERR(old_dentry); 2811 hmdfs_info("lookup old dentry failed, err %d", err); 2812 goto unlock; 2813 } 2814 2815 /* source should not be ancestor of target */ 2816 if (old_dentry == trap) { 2817 err = -EINVAL; 2818 goto put_old_dentry; 2819 } 2820 2821 new_dentry = lookup_one_len(newname, path_new.dentry, strlen(newname)); 2822 if (IS_ERR(new_dentry)) { 2823 err = PTR_ERR(new_dentry); 2824 hmdfs_info("lookup new dentry failed, err %d", err); 2825 goto put_old_dentry; 2826 } 2827 2828 /* 2829 * Exchange rename is not supported, thus target should not be an 2830 * ancestor of source. 2831 */ 2832 if (trap == new_dentry) { 2833 err = -ENOTEMPTY; 2834 goto put_new_dentry; 2835 } 2836 2837 if (d_is_positive(new_dentry) && (flags & RENAME_NOREPLACE)) { 2838 err = -EEXIST; 2839 goto put_new_dentry; 2840 } 2841 2842 hmdfs_mark_drop_flag(device_id, path_old.dentry); 2843 if (path_old.dentry != path_new.dentry) 2844 hmdfs_mark_drop_flag(device_id, path_new.dentry); 2845 2846 err = vfs_rename(d_inode(path_old.dentry), old_dentry, 2847 d_inode(path_new.dentry), new_dentry, NULL, 0); 2848 2849put_new_dentry: 2850 dput(new_dentry); 2851put_old_dentry: 2852 dput(old_dentry); 2853unlock: 2854 unlock_rename(path_new.dentry, path_old.dentry); 2855 mnt_drop_write(path_dst.mnt); 2856put_path_new: 2857 path_put(&path_new); 2858put_path_old: 2859 path_put(&path_old); 2860put_path_dst: 2861 path_put(&path_dst); 2862 2863 return err; 2864} 2865 2866int hmdfs_get_path_in_sb(struct super_block *sb, const char *name, 2867 unsigned int flags, struct path *path) 2868{ 2869 int err; 2870 2871 err = kern_path(name, flags, path); 2872 if (err) { 2873 hmdfs_err("can't get %s %d\n", name, err); 2874 return err; 2875 } 2876 2877 /* should ensure the path is belong sb */ 2878 if (path->dentry->d_sb != sb) { 2879 err = -EINVAL; 2880 hmdfs_err("Wrong sb: %s on %s", name, 2881 path->dentry->d_sb->s_type->name); 2882 path_put(path); 2883 } 2884 2885 return err; 2886} 2887