misc/create_inode.c

   1 /*
   2  * create_inode.c --- create an inode
   3  *
   4  * Copyright (C) 2014 Robert Yang <liezhi.yang@windriver.com>
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU library
   8  * General Public License, version 2.
   9  * %End-Header%
  10  */
  11
  12 #define _FILE_OFFSET_BITS       64
  13 #define _LARGEFILE64_SOURCE     1
  14 #define _GNU_SOURCE             1
  15
  16 #include "config.h"
  17 #include <time.h>
  18 #include <sys/types.h>
  19 #include <unistd.h>
  20 #include <limits.h> /* for PATH_MAX */
  21 #ifdef HAVE_ATTR_XATTR_H
  22 #include <attr/xattr.h>
  23 #endif
  24 #include <sys/ioctl.h>
  25 #include <ext2fs/ext2fs.h>
  26 #include <ext2fs/ext2_types.h>
  27 #include <ext2fs/fiemap.h>
  28
  29 #include "create_inode.h"
  30 #include "support/nls-enable.h"
  31
  32 /* 64KiB is the minimium blksize to best minimize system call overhead. */
  33 #define COPY_FILE_BUFLEN        65536
  34
  35 static int ext2_file_type(unsigned int mode)
  36 {
  37         if (LINUX_S_ISREG(mode))
  38                 return EXT2_FT_REG_FILE;
  39
  40         if (LINUX_S_ISDIR(mode))
  41                 return EXT2_FT_DIR;
  42
  43         if (LINUX_S_ISCHR(mode))
  44                 return EXT2_FT_CHRDEV;
  45
  46         if (LINUX_S_ISBLK(mode))
  47                 return EXT2_FT_BLKDEV;
  48
  49         if (LINUX_S_ISLNK(mode))
  50                 return EXT2_FT_SYMLINK;
  51
  52         if (LINUX_S_ISFIFO(mode))
  53                 return EXT2_FT_FIFO;
  54
  55         if (LINUX_S_ISSOCK(mode))
  56                 return EXT2_FT_SOCK;
  57
  58         return 0;
  59 }
  60
  61 /* Link an inode number to a directory */
  62 static errcode_t add_link(ext2_filsys fs, ext2_ino_t parent_ino,
  63                           ext2_ino_t ino, const char *name)
  64 {
  65         struct ext2_inode       inode;
  66         errcode_t               retval;
  67
  68         retval = ext2fs_read_inode(fs, ino, &inode);
  69         if (retval) {
  70                 com_err(__func__, retval, _("while reading inode %u"), ino);
  71                 return retval;
  72         }
  73
  74         retval = ext2fs_link(fs, parent_ino, name, ino,
  75                              ext2_file_type(inode.i_mode));
  76         if (retval == EXT2_ET_DIR_NO_SPACE) {
  77                 retval = ext2fs_expand_dir(fs, parent_ino);
  78                 if (retval) {
  79                         com_err(__func__, retval,
  80                                 _("while expanding directory"));
  81                         return retval;
  82                 }
  83                 retval = ext2fs_link(fs, parent_ino, name, ino,
  84                                      ext2_file_type(inode.i_mode));
  85         }
  86         if (retval) {
  87                 com_err(__func__, retval, _("while linking \"%s\""), name);
  88                 return retval;
  89         }
  90
  91         inode.i_links_count++;
  92
  93         retval = ext2fs_write_inode(fs, ino, &inode);
  94         if (retval)
  95                 com_err(__func__, retval, _("while writing inode %u"), ino);
  96
  97         return retval;
  98 }
  99
 100 /* Set the uid, gid, mode and time for the inode */
 101 static errcode_t set_inode_extra(ext2_filsys fs, ext2_ino_t ino,
 102                                  struct stat *st)
 103 {
 104         errcode_t               retval;
 105         struct ext2_inode       inode;
 106
 107         retval = ext2fs_read_inode(fs, ino, &inode);
 108         if (retval) {
 109                 com_err(__func__, retval, _("while reading inode %u"), ino);
 110                 return retval;
 111         }
 112
 113         inode.i_uid = st->st_uid;
 114         inode.i_gid = st->st_gid;
 115         inode.i_mode |= st->st_mode;
 116         inode.i_atime = st->st_atime;
 117         inode.i_mtime = st->st_mtime;
 118         inode.i_ctime = st->st_ctime;
 119
 120         retval = ext2fs_write_inode(fs, ino, &inode);
 121         if (retval)
 122                 com_err(__func__, retval, _("while writing inode %u"), ino);
 123         return retval;
 124 }
 125
 126 #ifdef HAVE_LLISTXATTR
 127 static errcode_t set_inode_xattr(ext2_filsys fs, ext2_ino_t ino,
 128                                  const char *filename)
 129 {
 130         errcode_t                       retval, close_retval;
 131         struct ext2_xattr_handle        *handle;
 132         ssize_t                         size, value_size;
 133         char                            *list = NULL;
 134         int                             i;
 135
 136         size = llistxattr(filename, NULL, 0);
 137         if (size == -1) {
 138                 retval = errno;
 139                 com_err(__func__, retval, _("while listing attributes of \"%s\""),
 140                         filename);
 141                 return retval;
 142         } else if (size == 0) {
 143                 return 0;
 144         }
 145
 146         retval = ext2fs_xattrs_open(fs, ino, &handle);
 147         if (retval) {
 148                 if (retval == EXT2_ET_MISSING_EA_FEATURE)
 149                         return 0;
 150                 com_err(__func__, retval, _("while opening inode %u"), ino);
 151                 return retval;
 152         }
 153
 154         retval = ext2fs_get_mem(size, &list);
 155         if (retval) {
 156                 com_err(__func__, retval, _("while allocating memory"));
 157                 goto out;
 158         }
 159
 160         size = llistxattr(filename, list, size);
 161         if (size == -1) {
 162                 retval = errno;
 163                 com_err(__func__, retval, _("while listing attributes of \"%s\""),
 164                         filename);
 165                 goto out;
 166         }
 167
 168         for (i = 0; i < size; i += strlen(&list[i]) + 1) {
 169                 const char *name = &list[i];
 170                 char *value;
 171
 172                 value_size = lgetxattr(filename, name, NULL, 0);
 173                 if (value_size == -1) {
 174                         retval = errno;
 175                         com_err(__func__, retval,
 176                                 _("while reading attribute \"%s\" of \"%s\""),
 177                                 name, filename);
 178                         break;
 179                 }
 180
 181                 retval = ext2fs_get_mem(value_size, &value);
 182                 if (retval) {
 183                         com_err(__func__, retval, _("while allocating memory"));
 184                         break;
 185                 }
 186
 187                 value_size = lgetxattr(filename, name, value, value_size);
 188                 if (value_size == -1) {
 189                         ext2fs_free_mem(&value);
 190                         retval = errno;
 191                         com_err(__func__, retval,
 192                                 _("while reading attribute \"%s\" of \"%s\""),
 193                                 name, filename);
 194                         break;
 195                 }
 196
 197                 retval = ext2fs_xattr_set(handle, name, value, value_size);
 198                 ext2fs_free_mem(&value);
 199                 if (retval) {
 200                         com_err(__func__, retval,
 201                                 _("while writing attribute \"%s\" to inode %u"),
 202                                 name, ino);
 203                         break;
 204                 }
 205
 206         }
 207  out:
 208         ext2fs_free_mem(&list);
 209         close_retval = ext2fs_xattrs_close(&handle);
 210         if (close_retval) {
 211                 com_err(__func__, retval, _("while closing inode %u"), ino);
 212                 retval = retval ? retval : close_retval;
 213         }
 214         return retval;
 215         return 0;
 216 }
 217 #else /* HAVE_LLISTXATTR */
 218 static errcode_t set_inode_xattr(ext2_filsys fs EXT2FS_ATTR((unused)),
 219                                  ext2_ino_t ino EXT2FS_ATTR((unused)),
 220                                  const char *filename EXT2FS_ATTR((unused)))
 221 {
 222         return 0;
 223 }
 224 #endif  /* HAVE_LLISTXATTR */
 225
 226 /* Make a special files (block and character devices), fifo's, and sockets  */
 227 errcode_t do_mknod_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
 228                             struct stat *st)
 229 {
 230         ext2_ino_t              ino;
 231         errcode_t               retval;
 232         struct ext2_inode       inode;
 233         unsigned long           devmajor, devminor, mode;
 234         int                     filetype;
 235
 236         switch(st->st_mode & S_IFMT) {
 237         case S_IFCHR:
 238                 mode = LINUX_S_IFCHR;
 239                 filetype = EXT2_FT_CHRDEV;
 240                 break;
 241         case S_IFBLK:
 242                 mode = LINUX_S_IFBLK;
 243                 filetype =  EXT2_FT_BLKDEV;
 244                 break;
 245         case S_IFIFO:
 246                 mode = LINUX_S_IFIFO;
 247                 filetype = EXT2_FT_FIFO;
 248                 break;
 249         case S_IFSOCK:
 250                 mode = LINUX_S_IFSOCK;
 251                 filetype = EXT2_FT_SOCK;
 252                 break;
 253         default:
 254                 return EXT2_ET_INVALID_ARGUMENT;
 255         }
 256
 257         retval = ext2fs_new_inode(fs, cwd, 010755, 0, &ino);
 258         if (retval) {
 259                 com_err(__func__, retval, _("while allocating inode \"%s\""),
 260                         name);
 261                 return retval;
 262         }
 263
 264 #ifdef DEBUGFS
 265         printf("Allocated inode: %u\n", ino);
 266 #endif
 267         retval = ext2fs_link(fs, cwd, name, ino, filetype);
 268         if (retval == EXT2_ET_DIR_NO_SPACE) {
 269                 retval = ext2fs_expand_dir(fs, cwd);
 270                 if (retval) {
 271                         com_err(__func__, retval,
 272                                 _("while expanding directory"));
 273                         return retval;
 274                 }
 275                 retval = ext2fs_link(fs, cwd, name, ino, filetype);
 276         }
 277         if (retval) {
 278                 com_err(name, retval, _("while creating inode \"%s\""), name);
 279                 return retval;
 280         }
 281         if (ext2fs_test_inode_bitmap2(fs->inode_map, ino))
 282                 com_err(__func__, 0, "Warning: inode already set");
 283         ext2fs_inode_alloc_stats2(fs, ino, +1, 0);
 284         memset(&inode, 0, sizeof(inode));
 285         inode.i_mode = mode;
 286         inode.i_atime = inode.i_ctime = inode.i_mtime =
 287                 fs->now ? fs->now : time(0);
 288
 289         if (filetype != S_IFIFO) {
 290                 devmajor = major(st->st_rdev);
 291                 devminor = minor(st->st_rdev);
 292
 293                 if ((devmajor < 256) && (devminor < 256)) {
 294                         inode.i_block[0] = devmajor * 256 + devminor;
 295                         inode.i_block[1] = 0;
 296                 } else {
 297                         inode.i_block[0] = 0;
 298                         inode.i_block[1] = (devminor & 0xff) | (devmajor << 8) |
 299                                            ((devminor & ~0xff) << 12);
 300                 }
 301         }
 302         inode.i_links_count = 1;
 303
 304         retval = ext2fs_write_new_inode(fs, ino, &inode);
 305         if (retval)
 306                 com_err(__func__, retval, _("while writing inode %u"), ino);
 307
 308         return retval;
 309 }
 310
 311 /* Make a symlink name -> target */
 312 errcode_t do_symlink_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
 313                               char *target, ext2_ino_t root)
 314 {
 315         char                    *cp;
 316         ext2_ino_t              parent_ino;
 317         errcode_t               retval;
 318
 319         cp = strrchr(name, '/');
 320         if (cp) {
 321                 *cp = 0;
 322                 retval = ext2fs_namei(fs, root, cwd, name, &parent_ino);
 323                 if (retval) {
 324                         com_err(name, retval, 0);
 325                         return retval;
 326                 }
 327                 name = cp+1;
 328         } else
 329                 parent_ino = cwd;
 330
 331         retval = ext2fs_symlink(fs, parent_ino, 0, name, target);
 332         if (retval == EXT2_ET_DIR_NO_SPACE) {
 333                 retval = ext2fs_expand_dir(fs, parent_ino);
 334                 if (retval) {
 335                         com_err("do_symlink_internal", retval,
 336                                 _("while expanding directory"));
 337                         return retval;
 338                 }
 339                 retval = ext2fs_symlink(fs, parent_ino, 0, name, target);
 340         }
 341         if (retval)
 342                 com_err("ext2fs_symlink", retval,
 343                         _("while creating symlink \"%s\""), name);
 344         return retval;
 345 }
 346
 347 /* Make a directory in the fs */
 348 errcode_t do_mkdir_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
 349                             ext2_ino_t root)
 350 {
 351         char                    *cp;
 352         ext2_ino_t              parent_ino;
 353         errcode_t               retval;
 354
 355
 356         cp = strrchr(name, '/');
 357         if (cp) {
 358                 *cp = 0;
 359                 retval = ext2fs_namei(fs, root, cwd, name, &parent_ino);
 360                 if (retval) {
 361                         com_err(name, retval, _("while looking up \"%s\""),
 362                                 name);
 363                         return retval;
 364                 }
 365                 name = cp+1;
 366         } else
 367                 parent_ino = cwd;
 368
 369         retval = ext2fs_mkdir(fs, parent_ino, 0, name);
 370         if (retval == EXT2_ET_DIR_NO_SPACE) {
 371                 retval = ext2fs_expand_dir(fs, parent_ino);
 372                 if (retval) {
 373                         com_err(__func__, retval,
 374                                 _("while expanding directory"));
 375                         return retval;
 376                 }
 377                 retval = ext2fs_mkdir(fs, parent_ino, 0, name);
 378         }
 379         if (retval)
 380                 com_err("ext2fs_mkdir", retval,
 381                         _("while creating directory \"%s\""), name);
 382         return retval;
 383 }
 384
 385 #if !defined HAVE_PREAD64 && !defined HAVE_PREAD
 386 static ssize_t my_pread(int fd, void *buf, size_t count, off_t offset)
 387 {
 388         if (lseek(fd, offset, SEEK_SET) < 0)
 389                 return 0;
 390
 391         return read(fd, buf, count);
 392 }
 393 #endif /* !defined HAVE_PREAD64 && !defined HAVE_PREAD */
 394
 395 static errcode_t copy_file_range(ext2_filsys fs, int fd, ext2_file_t e2_file,
 396                                  off_t start, off_t end, char *buf,
 397                                  char *zerobuf)
 398 {
 399         off_t off, bpos;
 400         ssize_t got, blen;
 401         unsigned int written;
 402         char *ptr;
 403         errcode_t err = 0;
 404
 405         for (off = start; off < end; off += COPY_FILE_BUFLEN) {
 406 #ifdef HAVE_PREAD64
 407                 got = pread64(fd, buf, COPY_FILE_BUFLEN, off);
 408 #elif HAVE_PREAD
 409                 got = pread(fd, buf, COPY_FILE_BUFLEN, off);
 410 #else
 411                 got = my_pread(fd, buf, COPY_FILE_BUFLEN, off);
 412 #endif
 413                 if (got < 0) {
 414                         err = errno;
 415                         goto fail;
 416                 }
 417                 for (bpos = 0, ptr = buf; bpos < got; bpos += fs->blocksize) {
 418                         blen = fs->blocksize;
 419                         if (blen > got - bpos)
 420                                 blen = got - bpos;
 421                         if (memcmp(ptr, zerobuf, blen) == 0) {
 422                                 ptr += blen;
 423                                 continue;
 424                         }
 425                         err = ext2fs_file_lseek(e2_file, off + bpos,
 426                                                 EXT2_SEEK_SET, NULL);
 427                         if (err)
 428                                 goto fail;
 429                         while (blen > 0) {
 430                                 err = ext2fs_file_write(e2_file, ptr, blen,
 431                                                         &written);
 432                                 if (err)
 433                                         goto fail;
 434                                 if (written == 0) {
 435                                         err = EIO;
 436                                         goto fail;
 437                                 }
 438                                 blen -= written;
 439                                 ptr += written;
 440                         }
 441                 }
 442         }
 443 fail:
 444         return err;
 445 }
 446
 447 #if defined(SEEK_DATA) && defined(SEEK_HOLE)
 448 static errcode_t try_lseek_copy(ext2_filsys fs, int fd, struct stat *statbuf,
 449                                 ext2_file_t e2_file, char *buf, char *zerobuf)
 450 {
 451         off_t data = 0, hole;
 452         off_t data_blk, hole_blk;
 453         errcode_t err = 0;
 454
 455         /* Try to use SEEK_DATA and SEEK_HOLE */
 456         while (data < statbuf->st_size) {
 457                 data = lseek(fd, data, SEEK_DATA);
 458                 if (data < 0) {
 459                         if (errno == ENXIO)
 460                                 break;
 461                         return EXT2_ET_UNIMPLEMENTED;
 462                 }
 463                 hole = lseek(fd, data, SEEK_HOLE);
 464                 if (hole < 0)
 465                         return EXT2_ET_UNIMPLEMENTED;
 466
 467                 data_blk = data & ~(fs->blocksize - 1);
 468                 hole_blk = (hole + (fs->blocksize - 1)) & ~(fs->blocksize - 1);
 469                 err = copy_file_range(fs, fd, e2_file, data_blk, hole_blk, buf,
 470                                       zerobuf);
 471                 if (err)
 472                         return err;
 473
 474                 data = hole;
 475         }
 476
 477         return err;
 478 }
 479 #endif /* SEEK_DATA and SEEK_HOLE */
 480
 481 #if defined(FS_IOC_FIEMAP)
 482 static errcode_t try_fiemap_copy(ext2_filsys fs, int fd, ext2_file_t e2_file,
 483                                  char *buf, char *zerobuf)
 484 {
 485 #define EXTENT_MAX_COUNT 512
 486         struct fiemap *fiemap_buf;
 487         struct fiemap_extent *ext_buf, *ext;
 488         int ext_buf_size, fie_buf_size;
 489         off_t pos = 0;
 490         unsigned int i;
 491         errcode_t err;
 492
 493         ext_buf_size = EXTENT_MAX_COUNT * sizeof(struct fiemap_extent);
 494         fie_buf_size = sizeof(struct fiemap) + ext_buf_size;
 495
 496         err = ext2fs_get_memzero(fie_buf_size, &fiemap_buf);
 497         if (err)
 498                 return err;
 499
 500         ext_buf = fiemap_buf->fm_extents;
 501         memset(fiemap_buf, 0, fie_buf_size);
 502         fiemap_buf->fm_length = FIEMAP_MAX_OFFSET;
 503         fiemap_buf->fm_flags |= FIEMAP_FLAG_SYNC;
 504         fiemap_buf->fm_extent_count = EXTENT_MAX_COUNT;
 505
 506         do {
 507                 fiemap_buf->fm_start = pos;
 508                 memset(ext_buf, 0, ext_buf_size);
 509                 err = ioctl(fd, FS_IOC_FIEMAP, fiemap_buf);
 510                 if (err < 0 && (errno == EOPNOTSUPP || errno == ENOTTY)) {
 511                         err = EXT2_ET_UNIMPLEMENTED;
 512                         goto out;
 513                 } else if (err < 0) {
 514                         err = errno;
 515                         goto out;
 516                 } else if (fiemap_buf->fm_mapped_extents == 0)
 517                         goto out;
 518                 for (i = 0, ext = ext_buf; i < fiemap_buf->fm_mapped_extents;
 519                      i++, ext++) {
 520                         err = copy_file_range(fs, fd, e2_file, ext->fe_logical,
 521                                               ext->fe_logical + ext->fe_length,
 522                                               buf, zerobuf);
 523                         if (err)
 524                                 goto out;
 525                 }
 526
 527                 ext--;
 528                 /* Record file's logical offset this time */
 529                 pos = ext->fe_logical + ext->fe_length;
 530                 /*
 531                  * If fm_extents array has been filled and
 532                  * there are extents left, continue to cycle.
 533                  */
 534         } while (fiemap_buf->fm_mapped_extents == EXTENT_MAX_COUNT &&
 535                  !(ext->fe_flags & FIEMAP_EXTENT_LAST));
 536 out:
 537         ext2fs_free_mem(&fiemap_buf);
 538         return err;
 539 }
 540 #endif /* FS_IOC_FIEMAP */
 541
 542 static errcode_t copy_file(ext2_filsys fs, int fd, struct stat *statbuf,
 543                            ext2_ino_t ino)
 544 {
 545         ext2_file_t e2_file;
 546         char *buf = NULL, *zerobuf = NULL;
 547         errcode_t err, close_err;
 548
 549         err = ext2fs_file_open(fs, ino, EXT2_FILE_WRITE, &e2_file);
 550         if (err)
 551                 return err;
 552
 553         err = ext2fs_get_mem(COPY_FILE_BUFLEN, &buf);
 554         if (err)
 555                 goto out;
 556
 557         err = ext2fs_get_memzero(fs->blocksize, &zerobuf);
 558         if (err)
 559                 goto out;
 560
 561 #if defined(SEEK_DATA) && defined(SEEK_HOLE)
 562         err = try_lseek_copy(fs, fd, statbuf, e2_file, buf, zerobuf);
 563         if (err != EXT2_ET_UNIMPLEMENTED)
 564                 goto out;
 565 #endif
 566
 567 #if defined(FS_IOC_FIEMAP)
 568         err = try_fiemap_copy(fs, fd, e2_file, buf, zerobuf);
 569         if (err != EXT2_ET_UNIMPLEMENTED)
 570                 goto out;
 571 #endif
 572
 573         err = copy_file_range(fs, fd, e2_file, 0, statbuf->st_size, buf,
 574                               zerobuf);
 575 out:
 576         ext2fs_free_mem(&zerobuf);
 577         ext2fs_free_mem(&buf);
 578         close_err = ext2fs_file_close(e2_file);
 579         if (err == 0)
 580                 err = close_err;
 581         return err;
 582 }
 583
 584 static int is_hardlink(struct hdlinks_s *hdlinks, dev_t dev, ino_t ino)
 585 {
 586         int i;
 587
 588         for (i = 0; i < hdlinks->count; i++) {
 589                 if (hdlinks->hdl[i].src_dev == dev &&
 590                     hdlinks->hdl[i].src_ino == ino)
 591                         return i;
 592         }
 593         return -1;
 594 }
 595
 596 /* Copy the native file to the fs */
 597 errcode_t do_write_internal(ext2_filsys fs, ext2_ino_t cwd, const char *src,
 598                             const char *dest, ext2_ino_t root)
 599 {
 600         int             fd;
 601         struct stat     statbuf;
 602         ext2_ino_t      newfile;
 603         errcode_t       retval;
 604         struct ext2_inode inode;
 605
 606         fd = ext2fs_open_file(src, O_RDONLY, 0);
 607         if (fd < 0) {
 608                 retval = errno;
 609                 com_err(__func__, retval, _("while opening \"%s\" to copy"),
 610                         src);
 611                 return retval;
 612         }
 613         if (fstat(fd, &statbuf) < 0) {
 614                 retval = errno;
 615                 goto out;
 616         }
 617
 618         retval = ext2fs_namei(fs, root, cwd, dest, &newfile);
 619         if (retval == 0) {
 620                 retval = EXT2_ET_FILE_EXISTS;
 621                 goto out;
 622         }
 623
 624         retval = ext2fs_new_inode(fs, cwd, 010755, 0, &newfile);
 625         if (retval)
 626                 goto out;
 627 #ifdef DEBUGFS
 628         printf("Allocated inode: %u\n", newfile);
 629 #endif
 630         retval = ext2fs_link(fs, cwd, dest, newfile,
 631                                 EXT2_FT_REG_FILE);
 632         if (retval == EXT2_ET_DIR_NO_SPACE) {
 633                 retval = ext2fs_expand_dir(fs, cwd);
 634                 if (retval)
 635                         goto out;
 636                 retval = ext2fs_link(fs, cwd, dest, newfile,
 637                                         EXT2_FT_REG_FILE);
 638         }
 639         if (retval)
 640                 goto out;
 641         if (ext2fs_test_inode_bitmap2(fs->inode_map, newfile))
 642                 com_err(__func__, 0, "Warning: inode already set");
 643         ext2fs_inode_alloc_stats2(fs, newfile, +1, 0);
 644         memset(&inode, 0, sizeof(inode));
 645         inode.i_mode = (statbuf.st_mode & ~LINUX_S_IFMT) | LINUX_S_IFREG;
 646         inode.i_atime = inode.i_ctime = inode.i_mtime =
 647                 fs->now ? fs->now : time(0);
 648         inode.i_links_count = 1;
 649         retval = ext2fs_inode_size_set(fs, &inode, statbuf.st_size);
 650         if (retval)
 651                 goto out;
 652         if (ext2fs_has_feature_inline_data(fs->super)) {
 653                 inode.i_flags |= EXT4_INLINE_DATA_FL;
 654         } else if (ext2fs_has_feature_extents(fs->super)) {
 655                 ext2_extent_handle_t handle;
 656
 657                 inode.i_flags &= ~EXT4_EXTENTS_FL;
 658                 retval = ext2fs_extent_open2(fs, newfile, &inode, &handle);
 659                 if (retval)
 660                         goto out;
 661                 ext2fs_extent_free(handle);
 662         }
 663
 664         retval = ext2fs_write_new_inode(fs, newfile, &inode);
 665         if (retval)
 666                 goto out;
 667         if (inode.i_flags & EXT4_INLINE_DATA_FL) {
 668                 retval = ext2fs_inline_data_init(fs, newfile);
 669                 if (retval)
 670                         goto out;
 671         }
 672         if (LINUX_S_ISREG(inode.i_mode)) {
 673                 retval = copy_file(fs, fd, &statbuf, newfile);
 674                 if (retval)
 675                         goto out;
 676         }
 677 out:
 678         close(fd);
 679         return retval;
 680 }
 681
 682 /* Copy files from source_dir to fs */
 683 static errcode_t __populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
 684                                const char *source_dir, ext2_ino_t root,
 685                                struct hdlinks_s *hdlinks)
 686 {
 687         const char      *name;
 688         DIR             *dh;
 689         struct dirent   *dent;
 690         struct stat     st;
 691         char            *ln_target = NULL;
 692         unsigned int    save_inode;
 693         ext2_ino_t      ino;
 694         errcode_t       retval = 0;
 695         int             read_cnt;
 696         int             hdlink;
 697
 698         if (chdir(source_dir) < 0) {
 699                 retval = errno;
 700                 com_err(__func__, retval,
 701                         _("while changing working directory to \"%s\""),
 702                         source_dir);
 703                 return retval;
 704         }
 705
 706         if (!(dh = opendir("."))) {
 707                 retval = errno;
 708                 com_err(__func__, retval,
 709                         _("while opening directory \"%s\""), source_dir);
 710                 return retval;
 711         }
 712
 713         while ((dent = readdir(dh))) {
 714                 if ((!strcmp(dent->d_name, ".")) ||
 715                     (!strcmp(dent->d_name, "..")))
 716                         continue;
 717                 if (lstat(dent->d_name, &st)) {
 718                         retval = errno;
 719                         com_err(__func__, retval, _("while lstat \"%s\""),
 720                                 dent->d_name);
 721                         goto out;
 722                 }
 723                 name = dent->d_name;
 724
 725                 /* Check for hardlinks */
 726                 save_inode = 0;
 727                 if (!S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode) &&
 728                     st.st_nlink > 1) {
 729                         hdlink = is_hardlink(hdlinks, st.st_dev, st.st_ino);
 730                         if (hdlink >= 0) {
 731                                 retval = add_link(fs, parent_ino,
 732                                                   hdlinks->hdl[hdlink].dst_ino,
 733                                                   name);
 734                                 if (retval) {
 735                                         com_err(__func__, retval,
 736                                                 "while linking %s", name);
 737                                         goto out;
 738                                 }
 739                                 continue;
 740                         } else
 741                                 save_inode = 1;
 742                 }
 743
 744                 switch(st.st_mode & S_IFMT) {
 745                 case S_IFCHR:
 746                 case S_IFBLK:
 747                 case S_IFIFO:
 748                 case S_IFSOCK:
 749                         retval = do_mknod_internal(fs, parent_ino, name, &st);
 750                         if (retval) {
 751                                 com_err(__func__, retval,
 752                                         _("while creating special file "
 753                                           "\"%s\""), name);
 754                                 goto out;
 755                         }
 756                         break;
 757                 case S_IFLNK:
 758                         ln_target = malloc(st.st_size + 1);
 759                         if (ln_target == NULL) {
 760                                 com_err(__func__, retval,
 761                                         _("malloc failed"));
 762                                 goto out;
 763                         }
 764                         read_cnt = readlink(name, ln_target,
 765                                             st.st_size + 1);
 766                         if (read_cnt == -1) {
 767                                 retval = errno;
 768                                 com_err(__func__, retval,
 769                                         _("while trying to read link \"%s\""),
 770                                         name);
 771                                 free(ln_target);
 772                                 goto out;
 773                         }
 774                         if (read_cnt > st.st_size) {
 775                                 com_err(__func__, retval,
 776                                         _("symlink increased in size "
 777                                           "between lstat() and readlink()"));
 778                                 free(ln_target);
 779                                 goto out;
 780                         }
 781                         ln_target[read_cnt] = '\0';
 782                         retval = do_symlink_internal(fs, parent_ino, name,
 783                                                      ln_target, root);
 784                         free(ln_target);
 785                         if (retval) {
 786                                 com_err(__func__, retval,
 787                                         _("while writing symlink\"%s\""),
 788                                         name);
 789                                 goto out;
 790                         }
 791                         break;
 792                 case S_IFREG:
 793                         retval = do_write_internal(fs, parent_ino, name, name,
 794                                                    root);
 795                         if (retval) {
 796                                 com_err(__func__, retval,
 797                                         _("while writing file \"%s\""), name);
 798                                 goto out;
 799                         }
 800                         break;
 801                 case S_IFDIR:
 802                         /* Don't choke on /lost+found */
 803                         if (parent_ino == EXT2_ROOT_INO &&
 804                             strcmp(name, "lost+found") == 0)
 805                                 goto find_lnf;
 806                         retval = do_mkdir_internal(fs, parent_ino, name,
 807                                                    root);
 808                         if (retval) {
 809                                 com_err(__func__, retval,
 810                                         _("while making dir \"%s\""), name);
 811                                 goto out;
 812                         }
 813 find_lnf:
 814                         retval = ext2fs_namei(fs, root, parent_ino,
 815                                               name, &ino);
 816                         if (retval) {
 817                                 com_err(name, retval, 0);
 818                                         goto out;
 819                         }
 820                         /* Populate the dir recursively*/
 821                         retval = __populate_fs(fs, ino, name, root, hdlinks);
 822                         if (retval)
 823                                 goto out;
 824                         if (chdir("..")) {
 825                                 retval = errno;
 826                                 com_err(__func__, retval,
 827                                         _("while changing directory"));
 828                                 goto out;
 829                         }
 830                         break;
 831                 default:
 832                         com_err(__func__, 0,
 833                                 _("ignoring entry \"%s\""), name);
 834                 }
 835
 836                 retval =  ext2fs_namei(fs, root, parent_ino, name, &ino);
 837                 if (retval) {
 838                         com_err(name, retval, _("while looking up \"%s\""),
 839                                 name);
 840                         goto out;
 841                 }
 842
 843                 retval = set_inode_extra(fs, ino, &st);
 844                 if (retval) {
 845                         com_err(__func__, retval,
 846                                 _("while setting inode for \"%s\""), name);
 847                         goto out;
 848                 }
 849
 850                 retval = set_inode_xattr(fs, ino, name);
 851                 if (retval) {
 852                         com_err(__func__, retval,
 853                                 _("while setting xattrs for \"%s\""), name);
 854                         goto out;
 855                 }
 856
 857                 /* Save the hardlink ino */
 858                 if (save_inode) {
 859                         /*
 860                          * Check whether need more memory, and we don't need
 861                          * free() since the lifespan will be over after the fs
 862                          * populated.
 863                          */
 864                         if (hdlinks->count == hdlinks->size) {
 865                                 void *p = realloc(hdlinks->hdl,
 866                                                 (hdlinks->size + HDLINK_CNT) *
 867                                                 sizeof(struct hdlink_s));
 868                                 if (p == NULL) {
 869                                         retval = EXT2_ET_NO_MEMORY;
 870                                         com_err(name, retval,
 871                                                 _("while saving inode data"));
 872                                         goto out;
 873                                 }
 874                                 hdlinks->hdl = p;
 875                                 hdlinks->size += HDLINK_CNT;
 876                         }
 877                         hdlinks->hdl[hdlinks->count].src_dev = st.st_dev;
 878                         hdlinks->hdl[hdlinks->count].src_ino = st.st_ino;
 879                         hdlinks->hdl[hdlinks->count].dst_ino = ino;
 880                         hdlinks->count++;
 881                 }
 882         }
 883
 884 out:
 885         closedir(dh);
 886         return retval;
 887 }
 888
 889 errcode_t populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
 890                       const char *source_dir, ext2_ino_t root)
 891 {
 892         struct hdlinks_s hdlinks;
 893         errcode_t retval;
 894
 895         if (!(fs->flags & EXT2_FLAG_RW)) {
 896                 com_err(__func__, 0, "Filesystem opened readonly");
 897                 return EROFS;
 898         }
 899
 900         hdlinks.count = 0;
 901         hdlinks.size = HDLINK_CNT;
 902         hdlinks.hdl = realloc(NULL, hdlinks.size * sizeof(struct hdlink_s));
 903         if (hdlinks.hdl == NULL) {
 904                 retval = errno;
 905                 com_err(__func__, retval, _("while allocating memory"));
 906                 return retval;
 907         }
 908
 909         retval = __populate_fs(fs, parent_ino, source_dir, root, &hdlinks);
 910
 911         free(hdlinks.hdl);
 912         return retval;
 913 }