1 /**
2 * dir.c
3 *
4 * Many parts of codes are copied from Linux kernel/fs/f2fs.
5 *
6 * Copyright (C) 2015 Huawei Ltd.
7 * Witten by:
8 * Hou Pengyang <houpengyang@huawei.com>
9 * Liu Shuoran <liushuoran@huawei.com>
10 * Jaegeuk Kim <jaegeuk@kernel.org>
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
15 */
16 #include "fsck.h"
17 #include "node.h"
18 #include <search.h>
19
room_for_filename(const u8 * bitmap,int slots,int max_slots)20 static int room_for_filename(const u8 *bitmap, int slots, int max_slots)
21 {
22 int bit_start = 0;
23 int zero_start, zero_end;
24 next:
25 zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start);
26 if (zero_start >= max_slots)
27 return max_slots;
28
29 zero_end = find_next_bit_le(bitmap, max_slots, zero_start + 1);
30
31 if (zero_end - zero_start >= slots)
32 return zero_start;
33 bit_start = zero_end;
34 goto next;
35
36 }
37
make_dentry_ptr(struct f2fs_dentry_ptr * d,struct f2fs_node * node_blk,void * src,int type)38 void make_dentry_ptr(struct f2fs_dentry_ptr *d, struct f2fs_node *node_blk,
39 void *src, int type)
40 {
41 if (type == 1) {
42 struct f2fs_dentry_block *t = (struct f2fs_dentry_block *)src;
43 d->max = NR_DENTRY_IN_BLOCK;
44 d->nr_bitmap = SIZE_OF_DENTRY_BITMAP;
45 d->bitmap = t->dentry_bitmap;
46 d->dentry = F2FS_DENTRY_BLOCK_DENTRIES(t);
47 d->filename = F2FS_DENTRY_BLOCK_FILENAMES(t);
48 } else {
49 int entry_cnt = NR_INLINE_DENTRY(node_blk);
50 int bitmap_size = INLINE_DENTRY_BITMAP_SIZE(node_blk);
51 int reserved_size = INLINE_RESERVED_SIZE(node_blk);
52
53 d->max = entry_cnt;
54 d->nr_bitmap = bitmap_size;
55 d->bitmap = (u8 *)src;
56 d->dentry = (struct f2fs_dir_entry *)
57 ((char *)src + bitmap_size + reserved_size);
58 d->filename = (__u8 (*)[F2FS_SLOT_LEN])((char *)src +
59 bitmap_size + reserved_size +
60 SIZE_OF_DIR_ENTRY * entry_cnt);
61 }
62 }
63
find_target_dentry(const u8 * name,unsigned int len,f2fs_hash_t namehash,int * max_slots,struct f2fs_dentry_ptr * d)64 static struct f2fs_dir_entry *find_target_dentry(const u8 *name,
65 unsigned int len, f2fs_hash_t namehash, int *max_slots,
66 struct f2fs_dentry_ptr *d)
67 {
68 struct f2fs_dir_entry *de;
69 unsigned long bit_pos = 0;
70 int max_len = 0;
71
72 if (max_slots)
73 *max_slots = 0;
74 while (bit_pos < (unsigned long)d->max) {
75 if (!test_bit_le(bit_pos, d->bitmap)) {
76 bit_pos++;
77 max_len++;
78 continue;
79 }
80
81 de = &d->dentry[bit_pos];
82 if (le16_to_cpu(de->name_len) == len &&
83 de->hash_code == namehash &&
84 !memcmp(d->filename[bit_pos], name, len)) {
85 goto found;
86 }
87
88 if (max_slots && max_len > *max_slots)
89 *max_slots = max_len;
90 max_len = 0;
91 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
92 }
93 de = NULL;
94 found:
95 if (max_slots && max_len > *max_slots)
96 *max_slots = max_len;
97 return de;
98 }
99
find_in_block(void * block,const u8 * name,int len,f2fs_hash_t namehash,int * max_slots)100 static struct f2fs_dir_entry *find_in_block(void *block,
101 const u8 *name, int len, f2fs_hash_t namehash,
102 int *max_slots)
103 {
104 struct f2fs_dentry_ptr d;
105
106 make_dentry_ptr(&d, NULL, block, 1);
107 return find_target_dentry(name, len, namehash, max_slots, &d);
108 }
109
find_in_level(struct f2fs_sb_info * sbi,struct f2fs_node * dir,unsigned int level,struct dentry * de)110 static int find_in_level(struct f2fs_sb_info *sbi, struct f2fs_node *dir,
111 unsigned int level, struct dentry *de)
112 {
113 unsigned int nbucket, nblock;
114 unsigned int bidx, end_block;
115 struct f2fs_dir_entry *dentry = NULL;
116 struct dnode_of_data dn;
117 void *dentry_blk;
118 int max_slots = 214;
119 nid_t ino = le32_to_cpu(F2FS_NODE_FOOTER(dir)->ino);
120 f2fs_hash_t namehash;
121 unsigned int dir_level = dir->i.i_dir_level;
122 int ret = 0;
123
124 namehash = f2fs_dentry_hash(get_encoding(sbi), IS_CASEFOLDED(&dir->i),
125 de->name, de->len);
126
127 nbucket = dir_buckets(level, dir_level);
128 nblock = bucket_blocks(level);
129
130 bidx = dir_block_index(level, dir_level, le32_to_cpu(namehash) % nbucket);
131 end_block = bidx + nblock;
132
133 dentry_blk = calloc(F2FS_BLKSIZE, 1);
134 ASSERT(dentry_blk);
135
136 memset(&dn, 0, sizeof(dn));
137 for (; bidx < end_block; bidx++) {
138
139 /* Firstly, we should know direct node of target data blk */
140 if (dn.node_blk && dn.node_blk != dn.inode_blk)
141 free(dn.node_blk);
142
143 set_new_dnode(&dn, dir, NULL, ino);
144 get_dnode_of_data(sbi, &dn, bidx, LOOKUP_NODE);
145 if (dn.data_blkaddr == NULL_ADDR)
146 continue;
147
148 ret = dev_read_block(dentry_blk, dn.data_blkaddr);
149 ASSERT(ret >= 0);
150
151 dentry = find_in_block(dentry_blk, de->name, de->len,
152 namehash, &max_slots);
153 if (dentry) {
154 ret = 1;
155 de->ino = le32_to_cpu(dentry->ino);
156 break;
157 }
158 }
159
160 if (dn.node_blk && dn.node_blk != dn.inode_blk)
161 free(dn.node_blk);
162 free(dentry_blk);
163
164 return ret;
165 }
166
f2fs_find_entry(struct f2fs_sb_info * sbi,struct f2fs_node * dir,struct dentry * de)167 static int f2fs_find_entry(struct f2fs_sb_info *sbi,
168 struct f2fs_node *dir, struct dentry *de)
169 {
170 unsigned int max_depth;
171 unsigned int level;
172
173 max_depth = le32_to_cpu(dir->i.i_current_depth);
174 for (level = 0; level < max_depth; level ++) {
175 if (find_in_level(sbi, dir, level, de))
176 return 1;
177 }
178 return 0;
179 }
180
181 /* return ino if file exists, otherwise return 0 */
f2fs_lookup(struct f2fs_sb_info * sbi,struct f2fs_node * dir,u8 * name,int len)182 nid_t f2fs_lookup(struct f2fs_sb_info *sbi, struct f2fs_node *dir,
183 u8 *name, int len)
184 {
185 int err;
186 struct dentry de = {
187 .name = name,
188 .len = len,
189 };
190
191 err = f2fs_find_entry(sbi, dir, &de);
192 if (err == 1)
193 return de.ino;
194 else
195 return 0;
196 }
197
f2fs_update_dentry(nid_t ino,int file_type,struct f2fs_dentry_ptr * d,const unsigned char * name,int len,f2fs_hash_t name_hash,unsigned int bit_pos)198 static void f2fs_update_dentry(nid_t ino, int file_type,
199 struct f2fs_dentry_ptr *d,
200 const unsigned char *name, int len, f2fs_hash_t name_hash,
201 unsigned int bit_pos)
202 {
203 struct f2fs_dir_entry *de;
204 int slots = GET_DENTRY_SLOTS(len);
205 int i;
206
207 de = &d->dentry[bit_pos];
208 de->name_len = cpu_to_le16(len);
209 de->hash_code = name_hash;
210 memcpy(d->filename[bit_pos], name, len);
211 d->filename[bit_pos][len] = 0;
212 de->ino = cpu_to_le32(ino);
213 de->file_type = file_type;
214 for (i = 0; i < slots; i++)
215 test_and_set_bit_le(bit_pos + i, d->bitmap);
216 }
217
218 /*
219 * f2fs_add_link - Add a new file(dir) to parent dir.
220 */
f2fs_add_link(struct f2fs_sb_info * sbi,struct f2fs_node * parent,const unsigned char * name,int name_len,nid_t ino,int file_type,block_t * p_blkaddr,int inc_link)221 int f2fs_add_link(struct f2fs_sb_info *sbi, struct f2fs_node *parent,
222 const unsigned char *name, int name_len, nid_t ino,
223 int file_type, block_t *p_blkaddr, int inc_link)
224 {
225 int level = 0, current_depth, bit_pos;
226 int nbucket, nblock, bidx, block;
227 int slots = GET_DENTRY_SLOTS(name_len);
228 f2fs_hash_t dentry_hash;
229 struct f2fs_dentry_block *dentry_blk;
230 struct f2fs_dentry_ptr d;
231 struct dnode_of_data dn;
232 nid_t pino;
233 unsigned int dir_level;
234 int ret;
235 bool datablk_alloced = false;
236
237 if (parent == NULL)
238 return -EINVAL;
239
240 dentry_hash = f2fs_dentry_hash(get_encoding(sbi),
241 IS_CASEFOLDED(&parent->i),
242 name, name_len);
243 pino = le32_to_cpu(F2FS_NODE_FOOTER(parent)->ino);
244 dir_level = parent->i.i_dir_level;
245
246 if (!pino) {
247 ERR_MSG("Wrong parent ino:%d \n", pino);
248 return -EINVAL;
249 }
250
251 dentry_blk = calloc(F2FS_BLKSIZE, 1);
252 ASSERT(dentry_blk);
253
254 current_depth = le32_to_cpu(parent->i.i_current_depth);
255 start:
256 if (current_depth == MAX_DIR_HASH_DEPTH) {
257 free(dentry_blk);
258 ERR_MSG("\tError: MAX_DIR_HASH\n");
259 return -ENOSPC;
260 }
261
262 /* Need a new dentry block */
263 if (level == current_depth)
264 ++current_depth;
265
266 nbucket = dir_buckets(level, dir_level);
267 nblock = bucket_blocks(level);
268 bidx = dir_block_index(level, dir_level, le32_to_cpu(dentry_hash) % nbucket);
269
270 memset(&dn, 0, sizeof(dn));
271 for (block = bidx; block <= (bidx + nblock - 1); block++) {
272
273 /* Firstly, we should know the direct node of target data blk */
274 if (dn.node_blk && dn.node_blk != dn.inode_blk)
275 free(dn.node_blk);
276
277 set_new_dnode(&dn, parent, NULL, pino);
278 get_dnode_of_data(sbi, &dn, block, ALLOC_NODE);
279
280 if (dn.data_blkaddr == NULL_ADDR) {
281 new_data_block(sbi, dentry_blk, &dn, CURSEG_HOT_DATA);
282 datablk_alloced = true;
283 } else {
284 ret = dev_read_block(dentry_blk, dn.data_blkaddr);
285 ASSERT(ret >= 0);
286 }
287 bit_pos = room_for_filename(dentry_blk->dentry_bitmap,
288 slots, NR_DENTRY_IN_BLOCK);
289
290 if (bit_pos < NR_DENTRY_IN_BLOCK)
291 goto add_dentry;
292 }
293 level ++;
294 goto start;
295
296 add_dentry:
297 make_dentry_ptr(&d, NULL, (void *)dentry_blk, 1);
298 f2fs_update_dentry(ino, file_type, &d, name, name_len, dentry_hash, bit_pos);
299
300 if (c.zoned_model == F2FS_ZONED_HM) {
301 if (datablk_alloced) {
302 ret = dev_write_block(dentry_blk, dn.data_blkaddr);
303 } else {
304 ret = update_block(sbi, dentry_blk, &dn.data_blkaddr,
305 dn.node_blk);
306 if (dn.inode_blk == dn.node_blk)
307 dn.idirty = 1;
308 else
309 dn.ndirty = 1;
310 }
311 } else {
312 ret = dev_write_block(dentry_blk, dn.data_blkaddr);
313 }
314 ASSERT(ret >= 0);
315
316 /*
317 * Parent inode needs updating, because its inode info may be changed.
318 * such as i_current_depth and i_blocks.
319 */
320 if (parent->i.i_current_depth != cpu_to_le32(current_depth)) {
321 parent->i.i_current_depth = cpu_to_le32(current_depth);
322 dn.idirty = 1;
323 }
324
325 /* Update parent's i_links info*/
326 if (inc_link && (file_type == F2FS_FT_DIR)){
327 u32 links = le32_to_cpu(parent->i.i_links);
328 parent->i.i_links = cpu_to_le32(links + 1);
329 dn.idirty = 1;
330 }
331
332 if ((__u64)((block + 1) * F2FS_BLKSIZE) >
333 le64_to_cpu(parent->i.i_size)) {
334 parent->i.i_size = cpu_to_le64((block + 1) * F2FS_BLKSIZE);
335 dn.idirty = 1;
336 }
337
338 if (dn.ndirty) {
339 ret = dn.alloced ?
340 dev_write_block(dn.node_blk, dn.node_blkaddr) :
341 update_block(sbi, dn.node_blk, &dn.node_blkaddr, NULL);
342 ASSERT(ret >= 0);
343 }
344
345 if (dn.idirty) {
346 ASSERT(parent == dn.inode_blk);
347 ret = update_inode(sbi, dn.inode_blk, p_blkaddr);
348 ASSERT(ret >= 0);
349 }
350
351 if (dn.node_blk != dn.inode_blk)
352 free(dn.node_blk);
353 free(dentry_blk);
354 return 0;
355 }
356
make_empty_dir(struct f2fs_sb_info * sbi,struct f2fs_node * inode)357 static void make_empty_dir(struct f2fs_sb_info *sbi, struct f2fs_node *inode)
358 {
359 struct f2fs_dentry_block *dent_blk;
360 nid_t ino = le32_to_cpu(F2FS_NODE_FOOTER(inode)->ino);
361 nid_t pino = le32_to_cpu(inode->i.i_pino);
362 struct f2fs_summary sum;
363 struct node_info ni;
364 block_t blkaddr = NULL_ADDR;
365 int ret;
366
367 get_node_info(sbi, ino, &ni);
368
369 dent_blk = calloc(F2FS_BLKSIZE, 1);
370 ASSERT(dent_blk);
371
372 F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).hash_code = 0;
373 F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).ino = cpu_to_le32(ino);
374 F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).name_len = cpu_to_le16(1);
375 F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 0).file_type = F2FS_FT_DIR;
376 memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, 0), ".", 1);
377
378 F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).hash_code = 0;
379 F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).ino = cpu_to_le32(pino);
380 F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).name_len = cpu_to_le16(2);
381 F2FS_DENTRY_BLOCK_DENTRY(dent_blk, 1).file_type = F2FS_FT_DIR;
382 memcpy(F2FS_DENTRY_BLOCK_FILENAME(dent_blk, 1), "..", 2);
383
384 test_and_set_bit_le(0, dent_blk->dentry_bitmap);
385 test_and_set_bit_le(1, dent_blk->dentry_bitmap);
386
387 set_summary(&sum, ino, 0, ni.version);
388 ret = reserve_new_block(sbi, &blkaddr, &sum, CURSEG_HOT_DATA, 0);
389 ASSERT(!ret);
390
391 ret = dev_write_block(dent_blk, blkaddr);
392 ASSERT(ret >= 0);
393
394 inode->i.i_addr[get_extra_isize(inode)] = cpu_to_le32(blkaddr);
395 free(dent_blk);
396 }
397
page_symlink(struct f2fs_sb_info * sbi,struct f2fs_node * inode,const char * symname,int symlen)398 static void page_symlink(struct f2fs_sb_info *sbi, struct f2fs_node *inode,
399 const char *symname, int symlen)
400 {
401 nid_t ino = le32_to_cpu(F2FS_NODE_FOOTER(inode)->ino);
402 struct f2fs_summary sum;
403 struct node_info ni;
404 char *data_blk;
405 block_t blkaddr = NULL_ADDR;
406 int ret;
407
408 get_node_info(sbi, ino, &ni);
409
410 /* store into inline_data */
411 if ((unsigned long)(symlen + 1) <= MAX_INLINE_DATA(inode)) {
412 inode->i.i_inline |= F2FS_INLINE_DATA;
413 inode->i.i_inline |= F2FS_DATA_EXIST;
414 memcpy(inline_data_addr(inode), symname, symlen);
415 return;
416 }
417
418 data_blk = calloc(F2FS_BLKSIZE, 1);
419 ASSERT(data_blk);
420
421 memcpy(data_blk, symname, symlen);
422
423 set_summary(&sum, ino, 0, ni.version);
424 ret = reserve_new_block(sbi, &blkaddr, &sum, CURSEG_WARM_DATA, 0);
425 ASSERT(!ret);
426
427 ret = dev_write_block(data_blk, blkaddr);
428 ASSERT(ret >= 0);
429
430 inode->i.i_addr[get_extra_isize(inode)] = cpu_to_le32(blkaddr);
431 free(data_blk);
432 }
433
is_extension_exist(const char * s,const char * sub)434 static inline int is_extension_exist(const char *s,
435 const char *sub)
436 {
437 unsigned int slen = strlen(s);
438 unsigned int sublen = strlen(sub);
439 int i;
440
441 /*
442 * filename format of multimedia file should be defined as:
443 * "filename + '.' + extension + (optional: '.' + temp extension)".
444 */
445 if (slen < sublen + 2)
446 return 0;
447
448 for (i = 1; i < slen - sublen; i++) {
449 if (s[i] != '.')
450 continue;
451 if (!strncasecmp(s + i + 1, sub, sublen))
452 return 1;
453 }
454
455 return 0;
456 }
457
set_file_temperature(struct f2fs_sb_info * sbi,struct f2fs_node * node_blk,const unsigned char * name)458 static void set_file_temperature(struct f2fs_sb_info *sbi,
459 struct f2fs_node *node_blk,
460 const unsigned char *name)
461 {
462 __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
463 int i, cold_count, hot_count;
464
465 cold_count = le32_to_cpu(sbi->raw_super->extension_count);
466 hot_count = sbi->raw_super->hot_ext_count;
467
468 for (i = 0; i < cold_count + hot_count; i++) {
469 if (is_extension_exist((const char *)name,
470 (const char *)extlist[i]))
471 break;
472 }
473
474 if (i == cold_count + hot_count)
475 return;
476
477 if (i < cold_count)
478 node_blk->i.i_advise |= FADVISE_COLD_BIT;
479 else
480 node_blk->i.i_advise |= FADVISE_HOT_BIT;
481 }
482
init_inode_block(struct f2fs_sb_info * sbi,struct f2fs_node * node_blk,struct dentry * de)483 static void init_inode_block(struct f2fs_sb_info *sbi,
484 struct f2fs_node *node_blk, struct dentry *de)
485 {
486 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
487 mode_t mode = de->mode;
488 int links = 1;
489 unsigned int size;
490 int blocks = 1;
491
492 if (de->file_type == F2FS_FT_DIR) {
493 mode |= S_IFDIR;
494 size = F2FS_BLKSIZE;
495 links++;
496 blocks++;
497 } else if (de->file_type == F2FS_FT_REG_FILE) {
498 #ifdef S_IFREG
499 mode |= S_IFREG;
500 #else
501 ASSERT(0);
502 #endif
503 size = 0;
504 } else if (de->file_type == F2FS_FT_SYMLINK) {
505 ASSERT(de->link);
506 #ifdef S_IFLNK
507 mode |= S_IFLNK;
508 #else
509 ASSERT(0);
510 #endif
511 size = strlen(de->link);
512 if (size + 1 > MAX_INLINE_DATA(node_blk))
513 blocks++;
514 } else {
515 ASSERT(0);
516 }
517
518 node_blk->i.i_mode = cpu_to_le16(mode);
519 node_blk->i.i_advise = 0;
520 node_blk->i.i_uid = cpu_to_le32(de->uid);
521 node_blk->i.i_gid = cpu_to_le32(de->gid);
522 node_blk->i.i_links = cpu_to_le32(links);
523 node_blk->i.i_size = cpu_to_le32(size);
524 node_blk->i.i_blocks = cpu_to_le32(blocks);
525 node_blk->i.i_atime = cpu_to_le64(de->mtime);
526 node_blk->i.i_ctime = cpu_to_le64(de->mtime);
527 node_blk->i.i_mtime = cpu_to_le64(de->mtime);
528 node_blk->i.i_atime_nsec = 0;
529 node_blk->i.i_ctime_nsec = 0;
530 node_blk->i.i_mtime_nsec = 0;
531 node_blk->i.i_generation = 0;
532 if (de->file_type == F2FS_FT_DIR)
533 node_blk->i.i_current_depth = cpu_to_le32(1);
534 else
535 node_blk->i.i_current_depth = cpu_to_le32(0);
536 node_blk->i.i_xattr_nid = 0;
537 node_blk->i.i_flags = 0;
538 node_blk->i.i_inline = F2FS_INLINE_XATTR;
539 node_blk->i.i_pino = cpu_to_le32(de->pino);
540 node_blk->i.i_namelen = cpu_to_le32(de->len);
541 memcpy(node_blk->i.i_name, de->name, de->len);
542 node_blk->i.i_name[de->len] = 0;
543
544 if (c.feature & F2FS_FEATURE_EXTRA_ATTR) {
545 node_blk->i.i_inline |= F2FS_EXTRA_ATTR;
546 node_blk->i.i_extra_isize = cpu_to_le16(calc_extra_isize());
547 }
548
549 set_file_temperature(sbi, node_blk, de->name);
550
551 F2FS_NODE_FOOTER(node_blk)->ino = cpu_to_le32(de->ino);
552 F2FS_NODE_FOOTER(node_blk)->nid = cpu_to_le32(de->ino);
553 F2FS_NODE_FOOTER(node_blk)->flag = 0;
554 F2FS_NODE_FOOTER(node_blk)->cp_ver = ckpt->checkpoint_ver;
555 set_cold_node(node_blk, S_ISDIR(mode));
556
557 if (S_ISDIR(mode)) {
558 make_empty_dir(sbi, node_blk);
559 } else if (S_ISLNK(mode)) {
560 page_symlink(sbi, node_blk, de->link, size);
561
562 free(de->link);
563 de->link = NULL;
564 }
565
566 if (c.feature & F2FS_FEATURE_INODE_CHKSUM)
567 node_blk->i.i_inode_checksum =
568 cpu_to_le32(f2fs_inode_chksum(node_blk));
569 }
570
convert_inline_dentry(struct f2fs_sb_info * sbi,struct f2fs_node * node,block_t * p_blkaddr)571 int convert_inline_dentry(struct f2fs_sb_info *sbi, struct f2fs_node *node,
572 block_t *p_blkaddr)
573 {
574 struct f2fs_inode *inode = &(node->i);
575 unsigned int dir_level = node->i.i_dir_level;
576 nid_t ino = le32_to_cpu(F2FS_NODE_FOOTER(node)->ino);
577 char inline_data[MAX_INLINE_DATA(node)];
578 struct dnode_of_data dn;
579 struct f2fs_dentry_ptr d;
580 unsigned long bit_pos = 0;
581 int ret = 0;
582 bool datablk_alloced = false;
583
584 if (!(inode->i_inline & F2FS_INLINE_DENTRY))
585 return 0;
586
587 memcpy(inline_data, inline_data_addr(node), MAX_INLINE_DATA(node));
588 memset(inline_data_addr(node), 0, MAX_INLINE_DATA(node));
589 inode->i_inline &= ~F2FS_INLINE_DENTRY;
590
591 ret = update_block(sbi, node, p_blkaddr, NULL);
592 ASSERT(ret >= 0);
593
594 memset(&dn, 0, sizeof(dn));
595 if (!dir_level) {
596 struct f2fs_dentry_block *dentry_blk;
597 struct f2fs_dentry_ptr src, dst;
598
599 dentry_blk = calloc(F2FS_BLKSIZE, 1);
600 ASSERT(dentry_blk);
601
602 set_new_dnode(&dn, node, NULL, ino);
603 get_dnode_of_data(sbi, &dn, 0, ALLOC_NODE);
604 if (dn.data_blkaddr == NULL_ADDR) {
605 new_data_block(sbi, dentry_blk, &dn, CURSEG_HOT_DATA);
606 datablk_alloced = true;
607 }
608
609 make_dentry_ptr(&src, node, (void *)inline_data, 2);
610 make_dentry_ptr(&dst, NULL, (void *)dentry_blk, 1);
611
612 /* copy data from inline dentry block to new dentry block */
613 memcpy(dst.bitmap, src.bitmap, src.nr_bitmap);
614 memset(dst.bitmap + src.nr_bitmap, 0,
615 dst.nr_bitmap - src.nr_bitmap);
616
617 memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max);
618 memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN);
619
620 ret = datablk_alloced ?
621 dev_write_block(dentry_blk, dn.data_blkaddr) :
622 update_block(sbi, dentry_blk, &dn.data_blkaddr, NULL);
623 ASSERT(ret >= 0);
624
625 MSG(1, "%s: copy inline entry to block\n", __func__);
626
627 free(dentry_blk);
628 return ret;
629 }
630
631 make_empty_dir(sbi, node);
632 make_dentry_ptr(&d, node, (void *)inline_data, 2);
633
634 while (bit_pos < (unsigned long)d.max) {
635 struct f2fs_dir_entry *de;
636 const unsigned char *filename;
637 int namelen;
638
639 if (!test_bit_le(bit_pos, d.bitmap)) {
640 bit_pos++;
641 continue;
642 }
643
644 de = &d.dentry[bit_pos];
645 if (!de->name_len) {
646 bit_pos++;
647 continue;
648 }
649
650 filename = d.filename[bit_pos];
651 namelen = le32_to_cpu(de->name_len);
652
653 if (is_dot_dotdot(filename, namelen)) {
654 bit_pos += GET_DENTRY_SLOTS(namelen);
655 continue;
656 }
657
658 ret = f2fs_add_link(sbi, node, filename, namelen,
659 le32_to_cpu(de->ino),
660 de->file_type, p_blkaddr, 0);
661 if (ret)
662 MSG(0, "Convert file \"%s\" ERR=%d\n", filename, ret);
663 else
664 MSG(1, "%s: add inline entry to block\n", __func__);
665
666 bit_pos += GET_DENTRY_SLOTS(namelen);
667 }
668
669 return 0;
670 }
671
cmp_from_devino(const void * a,const void * b)672 static int cmp_from_devino(const void *a, const void *b) {
673 u64 devino_a = ((struct hardlink_cache_entry*) a)->from_devino;
674 u64 devino_b = ((struct hardlink_cache_entry*) b)->from_devino;
675
676 return (devino_a > devino_b) - (devino_a < devino_b);
677 }
678
f2fs_search_hardlink(struct f2fs_sb_info * sbi,struct dentry * de)679 struct hardlink_cache_entry *f2fs_search_hardlink(struct f2fs_sb_info *sbi,
680 struct dentry *de)
681 {
682 struct hardlink_cache_entry *find_hardlink = NULL;
683 struct hardlink_cache_entry *found_hardlink = NULL;
684 void *search_result;
685
686 /* This might be a hardlink, try to find it in the cache */
687 find_hardlink = calloc(1, sizeof(struct hardlink_cache_entry));
688 find_hardlink->from_devino = de->from_devino;
689
690 search_result = tsearch(find_hardlink, &(sbi->hardlink_cache),
691 cmp_from_devino);
692 ASSERT(search_result != 0);
693
694 found_hardlink = *(struct hardlink_cache_entry**) search_result;
695 ASSERT(find_hardlink->from_devino == found_hardlink->from_devino);
696
697 /* If it was already in the cache, free the entry we just created */
698 if (found_hardlink != find_hardlink)
699 free(find_hardlink);
700
701 return found_hardlink;
702 }
703
f2fs_create(struct f2fs_sb_info * sbi,struct dentry * de)704 int f2fs_create(struct f2fs_sb_info *sbi, struct dentry *de)
705 {
706 struct f2fs_node *parent, *child;
707 struct hardlink_cache_entry *found_hardlink = NULL;
708 struct node_info ni, hardlink_ni;
709 struct f2fs_summary sum;
710 block_t blkaddr = NULL_ADDR;
711 int ret;
712 bool nodeblk_alloced = false;
713
714 /* Find if there is a */
715 get_node_info(sbi, de->pino, &ni);
716 if (ni.blk_addr == NULL_ADDR) {
717 MSG(0, "No parent directory pino=%x\n", de->pino);
718 return -1;
719 }
720
721 if (de->from_devino)
722 found_hardlink = f2fs_search_hardlink(sbi, de);
723
724 parent = calloc(F2FS_BLKSIZE, 1);
725 ASSERT(parent);
726
727 ret = dev_read_block(parent, ni.blk_addr);
728 ASSERT(ret >= 0);
729
730 /* Must convert inline dentry before the following opertions */
731 ret = convert_inline_dentry(sbi, parent, &ni.blk_addr);
732 if (ret) {
733 MSG(0, "Convert inline dentry for pino=%x failed.\n", de->pino);
734 ret = -1;
735 goto free_parent_dir;
736 }
737
738 ret = f2fs_find_entry(sbi, parent, de);
739 if (ret) {
740 MSG(0, "Skip the existing \"%s\" pino=%x ERR=%d\n",
741 de->name, de->pino, ret);
742 if (de->file_type == F2FS_FT_REG_FILE)
743 de->ino = 0;
744 ret = 0;
745 goto free_parent_dir;
746 }
747
748 child = calloc(F2FS_BLKSIZE, 1);
749 ASSERT(child);
750
751 if (found_hardlink && found_hardlink->to_ino) {
752 /*
753 * If we found this devino in the cache, we're creating a
754 * hard link.
755 */
756 get_node_info(sbi, found_hardlink->to_ino, &hardlink_ni);
757 if (hardlink_ni.blk_addr == NULL_ADDR) {
758 MSG(1, "No original inode for hard link to_ino=%x\n",
759 found_hardlink->to_ino);
760 ret = -1;
761 goto free_child_dir;
762 }
763
764 /* Use previously-recorded inode */
765 de->ino = found_hardlink->to_ino;
766 blkaddr = hardlink_ni.blk_addr;
767 MSG(1, "Info: Creating \"%s\" as hard link to inode %d\n",
768 de->path, de->ino);
769 } else {
770 f2fs_alloc_nid(sbi, &de->ino);
771 }
772
773 init_inode_block(sbi, child, de);
774
775 ret = f2fs_add_link(sbi, parent, child->i.i_name,
776 le32_to_cpu(child->i.i_namelen),
777 le32_to_cpu(F2FS_NODE_FOOTER(child)->ino),
778 map_de_type(le16_to_cpu(child->i.i_mode)),
779 &ni.blk_addr, 1);
780 if (ret) {
781 MSG(0, "Skip the existing \"%s\" pino=%x ERR=%d\n",
782 de->name, de->pino, ret);
783 ret = 0;
784 goto free_child_dir;
785 }
786
787 if (found_hardlink) {
788 if (!found_hardlink->to_ino) {
789 MSG(2, "Adding inode %d from %s to hardlink cache\n",
790 de->ino, de->path);
791 found_hardlink->to_ino = de->ino;
792 } else {
793 /* Replace child with original block */
794 free(child);
795
796 child = calloc(F2FS_BLKSIZE, 1);
797 ASSERT(child);
798
799 ret = dev_read_block(child, blkaddr);
800 ASSERT(ret >= 0);
801
802 /* Increment links and skip to writing block */
803 child->i.i_links = cpu_to_le32(
804 le32_to_cpu(child->i.i_links) + 1);
805 MSG(2, "Number of links on inode %d is now %d\n",
806 de->ino, le32_to_cpu(child->i.i_links));
807 goto write_child_dir;
808 }
809 }
810
811 /* write child */
812 set_summary(&sum, de->ino, 0, ni.version);
813 ret = reserve_new_block(sbi, &blkaddr, &sum, CURSEG_HOT_NODE, 1);
814 nodeblk_alloced = true;
815 ASSERT(!ret);
816
817 /* update nat info */
818 update_nat_blkaddr(sbi, de->ino, de->ino, blkaddr);
819
820 write_child_dir:
821 ret = nodeblk_alloced ? dev_write_block(child, blkaddr) :
822 update_block(sbi, child, &blkaddr, NULL);
823 ASSERT(ret >= 0);
824
825 update_free_segments(sbi);
826 MSG(1, "Info: Create %s -> %s\n"
827 " -- ino=%x, type=%x, mode=%x, uid=%x, "
828 "gid=%x, cap=%"PRIx64", size=%lu, link=%u "
829 "blocks=%"PRIx64" pino=%x\n",
830 de->full_path, de->path,
831 de->ino, de->file_type, de->mode,
832 de->uid, de->gid, de->capabilities, de->size,
833 le32_to_cpu(child->i.i_links),
834 le64_to_cpu(child->i.i_blocks),
835 de->pino);
836 free_child_dir:
837 free(child);
838 free_parent_dir:
839 free(parent);
840 return ret;
841 }
842
f2fs_mkdir(struct f2fs_sb_info * sbi,struct dentry * de)843 int f2fs_mkdir(struct f2fs_sb_info *sbi, struct dentry *de)
844 {
845 return f2fs_create(sbi, de);
846 }
847
f2fs_symlink(struct f2fs_sb_info * sbi,struct dentry * de)848 int f2fs_symlink(struct f2fs_sb_info *sbi, struct dentry *de)
849 {
850 return f2fs_create(sbi, de);
851 }
852
f2fs_find_path(struct f2fs_sb_info * sbi,char * path,nid_t * ino)853 int f2fs_find_path(struct f2fs_sb_info *sbi, char *path, nid_t *ino)
854 {
855 struct f2fs_node *parent;
856 struct node_info ni;
857 struct dentry de;
858 int err = 0;
859 int ret;
860 char *p;
861
862 if (path[0] != '/')
863 return -ENOENT;
864
865 *ino = F2FS_ROOT_INO(sbi);
866 parent = calloc(F2FS_BLKSIZE, 1);
867 ASSERT(parent);
868
869 p = strtok(path, "/");
870 while (p) {
871 de.name = (const u8 *)p;
872 de.len = strlen(p);
873
874 get_node_info(sbi, *ino, &ni);
875 if (ni.blk_addr == NULL_ADDR) {
876 err = -ENOENT;
877 goto err;
878 }
879 ret = dev_read_block(parent, ni.blk_addr);
880 ASSERT(ret >= 0);
881
882 ret = f2fs_find_entry(sbi, parent, &de);
883 if (!ret) {
884 err = -ENOENT;
885 goto err;
886 }
887
888 *ino = de.ino;
889 p = strtok(NULL, "/");
890 }
891 err:
892 free(parent);
893 return err;
894 }
895