fsck/dir.c

   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
  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
  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 = t->dentry;
  47                 d->filename = t->filename;
  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
  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
 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
 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(dir->footer.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(BLOCK_SZ, 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
 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 */
 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
 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  */
 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 = f2fs_dentry_hash(get_encoding(sbi),
 229                                                 IS_CASEFOLDED(&parent->i),
 230                                                 name, name_len);
 231         struct f2fs_dentry_block *dentry_blk;
 232         struct f2fs_dentry_ptr d;
 233         struct dnode_of_data dn;
 234         nid_t pino = le32_to_cpu(parent->footer.ino);
 235         unsigned int dir_level = parent->i.i_dir_level;
 236         int ret;
 237
 238         if (parent == NULL)
 239                 return -EINVAL;
 240
 241         if (!pino) {
 242                 ERR_MSG("Wrong parent ino:%d \n", pino);
 243                 return -EINVAL;
 244         }
 245
 246         dentry_blk = calloc(BLOCK_SZ, 1);
 247         ASSERT(dentry_blk);
 248
 249         current_depth = le32_to_cpu(parent->i.i_current_depth);
 250 start:
 251         if (current_depth == MAX_DIR_HASH_DEPTH) {
 252                 free(dentry_blk);
 253                 ERR_MSG("\tError: MAX_DIR_HASH\n");
 254                 return -ENOSPC;
 255         }
 256
 257         /* Need a new dentry block */
 258         if (level == current_depth)
 259                 ++current_depth;
 260
 261         nbucket = dir_buckets(level, dir_level);
 262         nblock = bucket_blocks(level);
 263         bidx = dir_block_index(level, dir_level, le32_to_cpu(dentry_hash) % nbucket);
 264
 265         memset(&dn, 0, sizeof(dn));
 266         for (block = bidx; block <= (bidx + nblock - 1); block++) {
 267
 268                 /* Firstly, we should know the direct node of target data blk */
 269                 if (dn.node_blk && dn.node_blk != dn.inode_blk)
 270                         free(dn.node_blk);
 271
 272                 set_new_dnode(&dn, parent, NULL, pino);
 273                 get_dnode_of_data(sbi, &dn, block, ALLOC_NODE);
 274
 275                 if (dn.data_blkaddr == NULL_ADDR) {
 276                         new_data_block(sbi, dentry_blk, &dn, CURSEG_HOT_DATA);
 277                 } else {
 278                         ret = dev_read_block(dentry_blk, dn.data_blkaddr);
 279                         ASSERT(ret >= 0);
 280                 }
 281                 bit_pos = room_for_filename(dentry_blk->dentry_bitmap,
 282                                 slots, NR_DENTRY_IN_BLOCK);
 283
 284                 if (bit_pos < NR_DENTRY_IN_BLOCK)
 285                         goto add_dentry;
 286         }
 287         level ++;
 288         goto start;
 289
 290 add_dentry:
 291         make_dentry_ptr(&d, NULL, (void *)dentry_blk, 1);
 292         f2fs_update_dentry(ino, file_type, &d, name, name_len, dentry_hash, bit_pos);
 293
 294         ret = dev_write_block(dentry_blk, dn.data_blkaddr);
 295         ASSERT(ret >= 0);
 296
 297         /*
 298          * Parent inode needs updating, because its inode info may be changed.
 299          * such as i_current_depth and i_blocks.
 300          */
 301         if (parent->i.i_current_depth != cpu_to_le32(current_depth)) {
 302                 parent->i.i_current_depth = cpu_to_le32(current_depth);
 303                 dn.idirty = 1;
 304         }
 305
 306         /* Update parent's i_links info*/
 307         if (inc_link && (file_type == F2FS_FT_DIR)){
 308                 u32 links = le32_to_cpu(parent->i.i_links);
 309                 parent->i.i_links = cpu_to_le32(links + 1);
 310                 dn.idirty = 1;
 311         }
 312
 313         if ((__u64)((block + 1) * F2FS_BLKSIZE) >
 314                                         le64_to_cpu(parent->i.i_size)) {
 315                 parent->i.i_size = cpu_to_le64((block + 1) * F2FS_BLKSIZE);
 316                 dn.idirty = 1;
 317         }
 318
 319         if (dn.ndirty) {
 320                 ret = dev_write_block(dn.node_blk, dn.node_blkaddr);
 321                 ASSERT(ret >= 0);
 322         }
 323
 324         if (dn.idirty) {
 325                 ASSERT(parent == dn.inode_blk);
 326                 ret = write_inode(dn.inode_blk, p_blkaddr);
 327                 ASSERT(ret >= 0);
 328         }
 329
 330         if (dn.node_blk != dn.inode_blk)
 331                 free(dn.node_blk);
 332         free(dentry_blk);
 333         return 0;
 334 }
 335
 336 static void make_empty_dir(struct f2fs_sb_info *sbi, struct f2fs_node *inode)
 337 {
 338         struct f2fs_dentry_block *dent_blk;
 339         nid_t ino = le32_to_cpu(inode->footer.ino);
 340         nid_t pino = le32_to_cpu(inode->i.i_pino);
 341         struct f2fs_summary sum;
 342         struct node_info ni;
 343         block_t blkaddr = NULL_ADDR;
 344         int ret;
 345
 346         get_node_info(sbi, ino, &ni);
 347
 348         dent_blk = calloc(BLOCK_SZ, 1);
 349         ASSERT(dent_blk);
 350
 351         dent_blk->dentry[0].hash_code = 0;
 352         dent_blk->dentry[0].ino = cpu_to_le32(ino);
 353         dent_blk->dentry[0].name_len = cpu_to_le16(1);
 354         dent_blk->dentry[0].file_type = F2FS_FT_DIR;
 355         memcpy(dent_blk->filename[0], ".", 1);
 356
 357         dent_blk->dentry[1].hash_code = 0;
 358         dent_blk->dentry[1].ino = cpu_to_le32(pino);
 359         dent_blk->dentry[1].name_len = cpu_to_le16(2);
 360         dent_blk->dentry[1].file_type = F2FS_FT_DIR;
 361         memcpy(dent_blk->filename[1], "..", 2);
 362
 363         test_and_set_bit_le(0, dent_blk->dentry_bitmap);
 364         test_and_set_bit_le(1, dent_blk->dentry_bitmap);
 365
 366         set_summary(&sum, ino, 0, ni.version);
 367         ret = reserve_new_block(sbi, &blkaddr, &sum, CURSEG_HOT_DATA, 0);
 368         ASSERT(!ret);
 369
 370         ret = dev_write_block(dent_blk, blkaddr);
 371         ASSERT(ret >= 0);
 372
 373         inode->i.i_addr[get_extra_isize(inode)] = cpu_to_le32(blkaddr);
 374         free(dent_blk);
 375 }
 376
 377 static void page_symlink(struct f2fs_sb_info *sbi, struct f2fs_node *inode,
 378                                         const char *symname, int symlen)
 379 {
 380         nid_t ino = le32_to_cpu(inode->footer.ino);
 381         struct f2fs_summary sum;
 382         struct node_info ni;
 383         char *data_blk;
 384         block_t blkaddr = NULL_ADDR;
 385         int ret;
 386
 387         get_node_info(sbi, ino, &ni);
 388
 389         /* store into inline_data */
 390         if ((unsigned long)(symlen + 1) <= MAX_INLINE_DATA(inode)) {
 391                 inode->i.i_inline |= F2FS_INLINE_DATA;
 392                 inode->i.i_inline |= F2FS_DATA_EXIST;
 393                 memcpy(inline_data_addr(inode), symname, symlen);
 394                 return;
 395         }
 396
 397         data_blk = calloc(BLOCK_SZ, 1);
 398         ASSERT(data_blk);
 399
 400         memcpy(data_blk, symname, symlen);
 401
 402         set_summary(&sum, ino, 0, ni.version);
 403         ret = reserve_new_block(sbi, &blkaddr, &sum, CURSEG_WARM_DATA, 0);
 404         ASSERT(!ret);
 405
 406         ret = dev_write_block(data_blk, blkaddr);
 407         ASSERT(ret >= 0);
 408
 409         inode->i.i_addr[get_extra_isize(inode)] = cpu_to_le32(blkaddr);
 410         free(data_blk);
 411 }
 412
 413 static inline int is_extension_exist(const char *s,
 414                                         const char *sub)
 415 {
 416         unsigned int slen = strlen(s);
 417         unsigned int  sublen = strlen(sub);
 418         int i;
 419
 420         /*
 421          * filename format of multimedia file should be defined as:
 422          * "filename + '.' + extension + (optional: '.' + temp extension)".
 423          */
 424         if (slen < sublen + 2)
 425                 return 0;
 426
 427         for (i = 1; i < slen - sublen; i++) {
 428                 if (s[i] != '.')
 429                         continue;
 430                 if (!strncasecmp(s + i + 1, sub, sublen))
 431                         return 1;
 432         }
 433
 434         return 0;
 435 }
 436
 437 static void set_file_temperature(struct f2fs_sb_info *sbi,
 438                                 struct f2fs_node *node_blk,
 439                                 const unsigned char *name)
 440 {
 441         __u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
 442         int i, cold_count, hot_count;
 443
 444         cold_count = le32_to_cpu(sbi->raw_super->extension_count);
 445         hot_count = sbi->raw_super->hot_ext_count;
 446
 447         for (i = 0; i < cold_count + hot_count; i++) {
 448                 if (is_extension_exist((const char *)name,
 449                                         (const char *)extlist[i]))
 450                         break;
 451         }
 452
 453         if (i == cold_count + hot_count)
 454                 return;
 455
 456         if (i < cold_count)
 457                 node_blk->i.i_advise |= FADVISE_COLD_BIT;
 458         else
 459                 node_blk->i.i_advise |= FADVISE_HOT_BIT;
 460 }
 461
 462 static void init_inode_block(struct f2fs_sb_info *sbi,
 463                 struct f2fs_node *node_blk, struct dentry *de)
 464 {
 465         struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
 466         mode_t mode = de->mode;
 467         int links = 1;
 468         unsigned int size;
 469         int blocks = 1;
 470
 471         if (de->file_type == F2FS_FT_DIR) {
 472                 mode |= S_IFDIR;
 473                 size = 4096;
 474                 links++;
 475                 blocks++;
 476         } else if (de->file_type == F2FS_FT_REG_FILE) {
 477 #ifdef S_IFREG
 478                 mode |= S_IFREG;
 479 #else
 480                 ASSERT(0);
 481 #endif
 482                 size = 0;
 483         } else if (de->file_type == F2FS_FT_SYMLINK) {
 484                 ASSERT(de->link);
 485 #ifdef S_IFLNK
 486                 mode |= S_IFLNK;
 487 #else
 488                 ASSERT(0);
 489 #endif
 490                 size = strlen(de->link);
 491                 if (size + 1 > MAX_INLINE_DATA(node_blk))
 492                         blocks++;
 493         } else {
 494                 ASSERT(0);
 495         }
 496
 497         node_blk->i.i_mode = cpu_to_le16(mode);
 498         node_blk->i.i_advise = 0;
 499         node_blk->i.i_uid = cpu_to_le32(de->uid);
 500         node_blk->i.i_gid = cpu_to_le32(de->gid);
 501         node_blk->i.i_links = cpu_to_le32(links);
 502         node_blk->i.i_size = cpu_to_le32(size);
 503         node_blk->i.i_blocks = cpu_to_le32(blocks);
 504         node_blk->i.i_atime = cpu_to_le64(de->mtime);
 505         node_blk->i.i_ctime = cpu_to_le64(de->mtime);
 506         node_blk->i.i_mtime = cpu_to_le64(de->mtime);
 507         node_blk->i.i_atime_nsec = 0;
 508         node_blk->i.i_ctime_nsec = 0;
 509         node_blk->i.i_mtime_nsec = 0;
 510         node_blk->i.i_generation = 0;
 511         if (de->file_type == F2FS_FT_DIR)
 512                 node_blk->i.i_current_depth = cpu_to_le32(1);
 513         else
 514                 node_blk->i.i_current_depth = cpu_to_le32(0);
 515         node_blk->i.i_xattr_nid = 0;
 516         node_blk->i.i_flags = 0;
 517         node_blk->i.i_inline = F2FS_INLINE_XATTR;
 518         node_blk->i.i_pino = cpu_to_le32(de->pino);
 519         node_blk->i.i_namelen = cpu_to_le32(de->len);
 520         memcpy(node_blk->i.i_name, de->name, de->len);
 521         node_blk->i.i_name[de->len] = 0;
 522
 523         if (c.feature & cpu_to_le32(F2FS_FEATURE_EXTRA_ATTR)) {
 524                 node_blk->i.i_inline |= F2FS_EXTRA_ATTR;
 525                 node_blk->i.i_extra_isize = cpu_to_le16(calc_extra_isize());
 526         }
 527
 528         set_file_temperature(sbi, node_blk, de->name);
 529
 530         node_blk->footer.ino = cpu_to_le32(de->ino);
 531         node_blk->footer.nid = cpu_to_le32(de->ino);
 532         node_blk->footer.flag = 0;
 533         node_blk->footer.cp_ver = ckpt->checkpoint_ver;
 534         set_cold_node(node_blk, S_ISDIR(mode));
 535
 536         if (S_ISDIR(mode)) {
 537                 make_empty_dir(sbi, node_blk);
 538         } else if (S_ISLNK(mode)) {
 539                 page_symlink(sbi, node_blk, de->link, size);
 540
 541                 free(de->link);
 542                 de->link = NULL;
 543         }
 544
 545         if (c.feature & cpu_to_le32(F2FS_FEATURE_INODE_CHKSUM))
 546                 node_blk->i.i_inode_checksum =
 547                         cpu_to_le32(f2fs_inode_chksum(node_blk));
 548 }
 549
 550 int convert_inline_dentry(struct f2fs_sb_info *sbi, struct f2fs_node *node,
 551                                                         block_t p_blkaddr)
 552 {
 553         struct f2fs_inode *inode = &(node->i);
 554         unsigned int dir_level = node->i.i_dir_level;
 555         nid_t ino = le32_to_cpu(node->footer.ino);
 556         char inline_data[MAX_INLINE_DATA(node)];
 557         struct dnode_of_data dn;
 558         struct f2fs_dentry_ptr d;
 559         unsigned long bit_pos = 0;
 560         int ret = 0;
 561
 562         if (!(inode->i_inline & F2FS_INLINE_DENTRY))
 563                 return 0;
 564
 565         memcpy(inline_data, inline_data_addr(node), MAX_INLINE_DATA(node));
 566         memset(inline_data_addr(node), 0, MAX_INLINE_DATA(node));
 567         inode->i_inline &= ~F2FS_INLINE_DENTRY;
 568
 569         ret = dev_write_block(node, p_blkaddr);
 570         ASSERT(ret >= 0);
 571
 572         memset(&dn, 0, sizeof(dn));
 573         if (!dir_level) {
 574                 struct f2fs_dentry_block *dentry_blk;
 575                 struct f2fs_dentry_ptr src, dst;
 576
 577                 dentry_blk = calloc(BLOCK_SZ, 1);
 578                 ASSERT(dentry_blk);
 579
 580                 set_new_dnode(&dn, node, NULL, ino);
 581                 get_dnode_of_data(sbi, &dn, 0, ALLOC_NODE);
 582                 if (dn.data_blkaddr == NULL_ADDR)
 583                         new_data_block(sbi, dentry_blk, &dn, CURSEG_HOT_DATA);
 584
 585                 make_dentry_ptr(&src, node, (void *)inline_data, 2);
 586                 make_dentry_ptr(&dst, NULL, (void *)dentry_blk, 1);
 587
 588                  /* copy data from inline dentry block to new dentry block */
 589                 memcpy(dst.bitmap, src.bitmap, src.nr_bitmap);
 590                 memset(dst.bitmap + src.nr_bitmap, 0,
 591                                         dst.nr_bitmap - src.nr_bitmap);
 592
 593                 memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max);
 594                 memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN);
 595
 596                 ret = dev_write_block(dentry_blk, dn.data_blkaddr);
 597                 ASSERT(ret >= 0);
 598
 599                 MSG(1, "%s: copy inline entry to block\n", __func__);
 600
 601                 free(dentry_blk);
 602                 return ret;
 603         }
 604
 605         make_empty_dir(sbi, node);
 606         make_dentry_ptr(&d, node, (void *)inline_data, 2);
 607
 608         while (bit_pos < (unsigned long)d.max) {
 609                 struct f2fs_dir_entry *de;
 610                 const unsigned char *filename;
 611                 int namelen;
 612
 613                 if (!test_bit_le(bit_pos, d.bitmap)) {
 614                         bit_pos++;
 615                         continue;
 616                 }
 617
 618                 de = &d.dentry[bit_pos];
 619                 if (!de->name_len) {
 620                         bit_pos++;
 621                         continue;
 622                 }
 623
 624                 filename = d.filename[bit_pos];
 625                 namelen = le32_to_cpu(de->name_len);
 626
 627                 if (is_dot_dotdot(filename, namelen)) {
 628                         bit_pos += GET_DENTRY_SLOTS(namelen);
 629                         continue;
 630                 }
 631
 632                 ret = f2fs_add_link(sbi, node, filename, namelen,
 633                                 le32_to_cpu(de->ino),
 634                                 de->file_type, p_blkaddr, 0);
 635                 if (ret)
 636                         MSG(0, "Convert file \"%s\" ERR=%d\n", filename, ret);
 637                 else
 638                         MSG(1, "%s: add inline entry to block\n", __func__);
 639
 640                 bit_pos += GET_DENTRY_SLOTS(namelen);
 641         }
 642
 643         return 0;
 644 }
 645
 646 static int cmp_from_devino(const void *a, const void *b) {
 647         u64 devino_a = ((struct hardlink_cache_entry*) a)->from_devino;
 648         u64 devino_b = ((struct hardlink_cache_entry*) b)->from_devino;
 649
 650         return (devino_a > devino_b) - (devino_a < devino_b);
 651 }
 652
 653 struct hardlink_cache_entry *f2fs_search_hardlink(struct f2fs_sb_info *sbi,
 654                                                 struct dentry *de)
 655 {
 656         struct hardlink_cache_entry *find_hardlink = NULL;
 657         struct hardlink_cache_entry *found_hardlink = NULL;
 658         void *search_result;
 659
 660         /* This might be a hardlink, try to find it in the cache */
 661         find_hardlink = calloc(1, sizeof(struct hardlink_cache_entry));
 662         find_hardlink->from_devino = de->from_devino;
 663
 664         search_result = tsearch(find_hardlink, &(sbi->hardlink_cache),
 665                                 cmp_from_devino);
 666         ASSERT(search_result != 0);
 667
 668         found_hardlink = *(struct hardlink_cache_entry**) search_result;
 669         ASSERT(find_hardlink->from_devino == found_hardlink->from_devino);
 670
 671         /* If it was already in the cache, free the entry we just created */
 672         if (found_hardlink != find_hardlink)
 673                 free(find_hardlink);
 674
 675         return found_hardlink;
 676 }
 677
 678 int f2fs_create(struct f2fs_sb_info *sbi, struct dentry *de)
 679 {
 680         struct f2fs_node *parent, *child;
 681         struct hardlink_cache_entry *found_hardlink = NULL;
 682         struct node_info ni, hardlink_ni;
 683         struct f2fs_summary sum;
 684         block_t blkaddr = NULL_ADDR;
 685         int ret;
 686
 687         /* Find if there is a */
 688         get_node_info(sbi, de->pino, &ni);
 689         if (ni.blk_addr == NULL_ADDR) {
 690                 MSG(0, "No parent directory pino=%x\n", de->pino);
 691                 return -1;
 692         }
 693
 694         if (de->from_devino)
 695                 found_hardlink = f2fs_search_hardlink(sbi, de);
 696
 697         parent = calloc(BLOCK_SZ, 1);
 698         ASSERT(parent);
 699
 700         ret = dev_read_block(parent, ni.blk_addr);
 701         ASSERT(ret >= 0);
 702
 703         /* Must convert inline dentry before the following opertions */
 704         ret = convert_inline_dentry(sbi, parent, ni.blk_addr);
 705         if (ret) {
 706                 MSG(0, "Convert inline dentry for pino=%x failed.\n", de->pino);
 707                 return -1;
 708         }
 709
 710         ret = f2fs_find_entry(sbi, parent, de);
 711         if (ret) {
 712                 MSG(0, "Skip the existing \"%s\" pino=%x ERR=%d\n",
 713                                         de->name, de->pino, ret);
 714                 if (de->file_type == F2FS_FT_REG_FILE)
 715                         de->ino = 0;
 716                 goto free_parent_dir;
 717         }
 718
 719         child = calloc(BLOCK_SZ, 1);
 720         ASSERT(child);
 721
 722         if (found_hardlink && found_hardlink->to_ino) {
 723                 /*
 724                  * If we found this devino in the cache, we're creating a
 725                  * hard link.
 726                  */
 727                 get_node_info(sbi, found_hardlink->to_ino, &hardlink_ni);
 728                 if (hardlink_ni.blk_addr == NULL_ADDR) {
 729                         MSG(1, "No original inode for hard link to_ino=%x\n",
 730                                 found_hardlink->to_ino);
 731                         return -1;
 732                 }
 733
 734                 /* Use previously-recorded inode */
 735                 de->ino = found_hardlink->to_ino;
 736                 blkaddr = hardlink_ni.blk_addr;
 737                 MSG(1, "Info: Creating \"%s\" as hard link to inode %d\n",
 738                                 de->path, de->ino);
 739         } else {
 740                 f2fs_alloc_nid(sbi, &de->ino);
 741         }
 742
 743         init_inode_block(sbi, child, de);
 744
 745         ret = f2fs_add_link(sbi, parent, child->i.i_name,
 746                                 le32_to_cpu(child->i.i_namelen),
 747                                 le32_to_cpu(child->footer.ino),
 748                                 map_de_type(le16_to_cpu(child->i.i_mode)),
 749                                 ni.blk_addr, 1);
 750         if (ret) {
 751                 MSG(0, "Skip the existing \"%s\" pino=%x ERR=%d\n",
 752                                         de->name, de->pino, ret);
 753                 goto free_child_dir;
 754         }
 755
 756         if (found_hardlink) {
 757                 if (!found_hardlink->to_ino) {
 758                         MSG(2, "Adding inode %d from %s to hardlink cache\n",
 759                                 de->ino, de->path);
 760                         found_hardlink->to_ino = de->ino;
 761                 } else {
 762                         /* Replace child with original block */
 763                         free(child);
 764
 765                         child = calloc(BLOCK_SZ, 1);
 766                         ASSERT(child);
 767
 768                         ret = dev_read_block(child, blkaddr);
 769                         ASSERT(ret >= 0);
 770
 771                         /* Increment links and skip to writing block */
 772                         child->i.i_links = cpu_to_le32(
 773                                         le32_to_cpu(child->i.i_links) + 1);
 774                         MSG(2, "Number of links on inode %d is now %d\n",
 775                                 de->ino, le32_to_cpu(child->i.i_links));
 776                         goto write_child_dir;
 777                 }
 778         }
 779
 780         /* write child */
 781         set_summary(&sum, de->ino, 0, ni.version);
 782         ret = reserve_new_block(sbi, &blkaddr, &sum, CURSEG_HOT_NODE, 1);
 783         ASSERT(!ret);
 784
 785         /* update nat info */
 786         update_nat_blkaddr(sbi, de->ino, de->ino, blkaddr);
 787
 788 write_child_dir:
 789         ret = dev_write_block(child, blkaddr);
 790         ASSERT(ret >= 0);
 791
 792         update_free_segments(sbi);
 793         MSG(1, "Info: Create %s -> %s\n"
 794                 "  -- ino=%x, type=%x, mode=%x, uid=%x, "
 795                 "gid=%x, cap=%"PRIx64", size=%lu, link=%u "
 796                 "blocks=%"PRIx64" pino=%x\n",
 797                 de->full_path, de->path,
 798                 de->ino, de->file_type, de->mode,
 799                 de->uid, de->gid, de->capabilities, de->size,
 800                 le32_to_cpu(child->i.i_links),
 801                 le64_to_cpu(child->i.i_blocks),
 802                 de->pino);
 803 free_child_dir:
 804         free(child);
 805 free_parent_dir:
 806         free(parent);
 807         return 0;
 808 }
 809
 810 int f2fs_mkdir(struct f2fs_sb_info *sbi, struct dentry *de)
 811 {
 812         return f2fs_create(sbi, de);
 813 }
 814
 815 int f2fs_symlink(struct f2fs_sb_info *sbi, struct dentry *de)
 816 {
 817         return f2fs_create(sbi, de);
 818 }
 819
 820 int f2fs_find_path(struct f2fs_sb_info *sbi, char *path, nid_t *ino)
 821 {
 822         struct f2fs_node *parent;
 823         struct node_info ni;
 824         struct dentry de;
 825         int err = 0;
 826         int ret;
 827         char *p;
 828
 829         if (path[0] != '/')
 830                 return -ENOENT;
 831
 832         *ino = F2FS_ROOT_INO(sbi);
 833         parent = calloc(BLOCK_SZ, 1);
 834         ASSERT(parent);
 835
 836         p = strtok(path, "/");
 837         while (p) {
 838                 de.name = (const u8 *)p;
 839                 de.len = strlen(p);
 840
 841                 get_node_info(sbi, *ino, &ni);
 842                 if (ni.blk_addr == NULL_ADDR) {
 843                         err = -ENOENT;
 844                         goto err;
 845                 }
 846                 ret = dev_read_block(parent, ni.blk_addr);
 847                 ASSERT(ret >= 0);
 848
 849                 ret = f2fs_find_entry(sbi, parent, &de);
 850                 if (!ret) {
 851                         err = -ENOENT;
 852                         goto err;
 853                 }
 854
 855                 *ino = de.ino;
 856                 p = strtok(NULL, "/");
 857         }
 858 err:
 859         free(parent);
 860         return err;
 861 }