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