2 * create_inode.c --- create an inode
4 * Copyright (C) 2014 Robert Yang <liezhi.yang@windriver.com>
7 * This file may be redistributed under the terms of the GNU library
8 * General Public License, version 2.
12 #define _FILE_OFFSET_BITS 64
13 #define _LARGEFILE64_SOURCE 1
18 #include <sys/types.h>
20 #include <limits.h> /* for PATH_MAX */
21 #if defined HAVE_SYS_XATTR_H
22 #include <sys/xattr.h>
23 #elif defined HAVE_ATTR_XATTR_H
24 #include <attr/xattr.h>
26 #include <sys/ioctl.h>
27 #ifdef HAVE_SYS_SYSMACROS_H
28 #include <sys/sysmacros.h>
31 #include <ext2fs/ext2fs.h>
32 #include <ext2fs/ext2_types.h>
33 #include <ext2fs/fiemap.h>
35 #include "create_inode.h"
36 #include "support/nls-enable.h"
38 /* 64KiB is the minimum blksize to best minimize system call overhead. */
39 #define COPY_FILE_BUFLEN 65536
41 static int ext2_file_type(unsigned int mode)
43 if (LINUX_S_ISREG(mode))
44 return EXT2_FT_REG_FILE;
46 if (LINUX_S_ISDIR(mode))
49 if (LINUX_S_ISCHR(mode))
50 return EXT2_FT_CHRDEV;
52 if (LINUX_S_ISBLK(mode))
53 return EXT2_FT_BLKDEV;
55 if (LINUX_S_ISLNK(mode))
56 return EXT2_FT_SYMLINK;
58 if (LINUX_S_ISFIFO(mode))
61 if (LINUX_S_ISSOCK(mode))
67 /* Link an inode number to a directory */
68 static errcode_t add_link(ext2_filsys fs, ext2_ino_t parent_ino,
69 ext2_ino_t ino, const char *name)
71 struct ext2_inode inode;
74 retval = ext2fs_read_inode(fs, ino, &inode);
76 com_err(__func__, retval, _("while reading inode %u"), ino);
80 retval = ext2fs_link(fs, parent_ino, name, ino,
81 ext2_file_type(inode.i_mode));
82 if (retval == EXT2_ET_DIR_NO_SPACE) {
83 retval = ext2fs_expand_dir(fs, parent_ino);
85 com_err(__func__, retval,
86 _("while expanding directory"));
89 retval = ext2fs_link(fs, parent_ino, name, ino,
90 ext2_file_type(inode.i_mode));
93 com_err(__func__, retval, _("while linking \"%s\""), name);
97 inode.i_links_count++;
99 retval = ext2fs_write_inode(fs, ino, &inode);
101 com_err(__func__, retval, _("while writing inode %u"), ino);
106 /* Set the uid, gid, mode and time for the inode */
107 static errcode_t set_inode_extra(ext2_filsys fs, ext2_ino_t ino,
111 struct ext2_inode inode;
113 retval = ext2fs_read_inode(fs, ino, &inode);
115 com_err(__func__, retval, _("while reading inode %u"), ino);
119 inode.i_uid = st->st_uid;
120 inode.i_gid = st->st_gid;
121 inode.i_mode |= st->st_mode;
122 inode.i_atime = st->st_atime;
123 inode.i_mtime = st->st_mtime;
124 inode.i_ctime = st->st_ctime;
126 retval = ext2fs_write_inode(fs, ino, &inode);
128 com_err(__func__, retval, _("while writing inode %u"), ino);
132 #ifdef HAVE_LLISTXATTR
133 static errcode_t set_inode_xattr(ext2_filsys fs, ext2_ino_t ino,
134 const char *filename)
136 errcode_t retval, close_retval;
137 struct ext2_xattr_handle *handle;
138 ssize_t size, value_size;
142 size = llistxattr(filename, NULL, 0);
145 com_err(__func__, retval, _("while listing attributes of \"%s\""),
148 } else if (size == 0) {
152 retval = ext2fs_xattrs_open(fs, ino, &handle);
154 if (retval == EXT2_ET_MISSING_EA_FEATURE)
156 com_err(__func__, retval, _("while opening inode %u"), ino);
160 retval = ext2fs_get_mem(size, &list);
162 com_err(__func__, retval, _("while allocating memory"));
166 size = llistxattr(filename, list, size);
169 com_err(__func__, retval, _("while listing attributes of \"%s\""),
174 for (i = 0; i < size; i += strlen(&list[i]) + 1) {
175 const char *name = &list[i];
178 value_size = lgetxattr(filename, name, NULL, 0);
179 if (value_size == -1) {
181 com_err(__func__, retval,
182 _("while reading attribute \"%s\" of \"%s\""),
187 retval = ext2fs_get_mem(value_size, &value);
189 com_err(__func__, retval, _("while allocating memory"));
193 value_size = lgetxattr(filename, name, value, value_size);
194 if (value_size == -1) {
195 ext2fs_free_mem(&value);
197 com_err(__func__, retval,
198 _("while reading attribute \"%s\" of \"%s\""),
203 retval = ext2fs_xattr_set(handle, name, value, value_size);
204 ext2fs_free_mem(&value);
206 com_err(__func__, retval,
207 _("while writing attribute \"%s\" to inode %u"),
214 ext2fs_free_mem(&list);
215 close_retval = ext2fs_xattrs_close(&handle);
217 com_err(__func__, retval, _("while closing inode %u"), ino);
218 retval = retval ? retval : close_retval;
223 #else /* HAVE_LLISTXATTR */
224 static errcode_t set_inode_xattr(ext2_filsys fs EXT2FS_ATTR((unused)),
225 ext2_ino_t ino EXT2FS_ATTR((unused)),
226 const char *filename EXT2FS_ATTR((unused)))
230 #endif /* HAVE_LLISTXATTR */
232 /* Make a special files (block and character devices), fifo's, and sockets */
233 errcode_t do_mknod_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
238 struct ext2_inode inode;
239 unsigned long devmajor, devminor, mode;
242 switch(st->st_mode & S_IFMT) {
244 mode = LINUX_S_IFCHR;
245 filetype = EXT2_FT_CHRDEV;
248 mode = LINUX_S_IFBLK;
249 filetype = EXT2_FT_BLKDEV;
252 mode = LINUX_S_IFIFO;
253 filetype = EXT2_FT_FIFO;
256 mode = LINUX_S_IFSOCK;
257 filetype = EXT2_FT_SOCK;
260 return EXT2_ET_INVALID_ARGUMENT;
263 retval = ext2fs_new_inode(fs, cwd, 010755, 0, &ino);
265 com_err(__func__, retval, _("while allocating inode \"%s\""),
271 printf("Allocated inode: %u\n", ino);
273 retval = ext2fs_link(fs, cwd, name, ino, filetype);
274 if (retval == EXT2_ET_DIR_NO_SPACE) {
275 retval = ext2fs_expand_dir(fs, cwd);
277 com_err(__func__, retval,
278 _("while expanding directory"));
281 retval = ext2fs_link(fs, cwd, name, ino, filetype);
284 com_err(name, retval, _("while creating inode \"%s\""), name);
287 if (ext2fs_test_inode_bitmap2(fs->inode_map, ino))
288 com_err(__func__, 0, "Warning: inode already set");
289 ext2fs_inode_alloc_stats2(fs, ino, +1, 0);
290 memset(&inode, 0, sizeof(inode));
292 inode.i_atime = inode.i_ctime = inode.i_mtime =
293 fs->now ? fs->now : time(0);
295 if (filetype != S_IFIFO) {
296 devmajor = major(st->st_rdev);
297 devminor = minor(st->st_rdev);
299 if ((devmajor < 256) && (devminor < 256)) {
300 inode.i_block[0] = devmajor * 256 + devminor;
301 inode.i_block[1] = 0;
303 inode.i_block[0] = 0;
304 inode.i_block[1] = (devminor & 0xff) | (devmajor << 8) |
305 ((devminor & ~0xff) << 12);
308 inode.i_links_count = 1;
310 retval = ext2fs_write_new_inode(fs, ino, &inode);
312 com_err(__func__, retval, _("while writing inode %u"), ino);
317 /* Make a symlink name -> target */
318 errcode_t do_symlink_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
319 char *target, ext2_ino_t root)
322 ext2_ino_t parent_ino;
325 cp = strrchr(name, '/');
328 retval = ext2fs_namei(fs, root, cwd, name, &parent_ino);
330 com_err(name, retval, 0);
337 retval = ext2fs_symlink(fs, parent_ino, 0, name, target);
338 if (retval == EXT2_ET_DIR_NO_SPACE) {
339 retval = ext2fs_expand_dir(fs, parent_ino);
341 com_err("do_symlink_internal", retval,
342 _("while expanding directory"));
345 retval = ext2fs_symlink(fs, parent_ino, 0, name, target);
348 com_err("ext2fs_symlink", retval,
349 _("while creating symlink \"%s\""), name);
353 /* Make a directory in the fs */
354 errcode_t do_mkdir_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
358 ext2_ino_t parent_ino;
362 cp = strrchr(name, '/');
365 retval = ext2fs_namei(fs, root, cwd, name, &parent_ino);
367 com_err(name, retval, _("while looking up \"%s\""),
375 retval = ext2fs_mkdir(fs, parent_ino, 0, name);
376 if (retval == EXT2_ET_DIR_NO_SPACE) {
377 retval = ext2fs_expand_dir(fs, parent_ino);
379 com_err(__func__, retval,
380 _("while expanding directory"));
383 retval = ext2fs_mkdir(fs, parent_ino, 0, name);
386 com_err("ext2fs_mkdir", retval,
387 _("while creating directory \"%s\""), name);
391 #if !defined HAVE_PREAD64 && !defined HAVE_PREAD
392 static ssize_t my_pread(int fd, void *buf, size_t count, off_t offset)
394 if (lseek(fd, offset, SEEK_SET) < 0)
397 return read(fd, buf, count);
399 #endif /* !defined HAVE_PREAD64 && !defined HAVE_PREAD */
401 static errcode_t copy_file_chunk(ext2_filsys fs, int fd, ext2_file_t e2_file,
402 off_t start, off_t end, char *buf,
407 unsigned int written;
411 for (off = start; off < end; off += COPY_FILE_BUFLEN) {
413 got = pread64(fd, buf, COPY_FILE_BUFLEN, off);
415 got = pread(fd, buf, COPY_FILE_BUFLEN, off);
417 got = my_pread(fd, buf, COPY_FILE_BUFLEN, off);
423 for (bpos = 0, ptr = buf; bpos < got; bpos += fs->blocksize) {
424 blen = fs->blocksize;
425 if (blen > got - bpos)
427 if (memcmp(ptr, zerobuf, blen) == 0) {
431 err = ext2fs_file_lseek(e2_file, off + bpos,
432 EXT2_SEEK_SET, NULL);
436 err = ext2fs_file_write(e2_file, ptr, blen,
453 #if defined(SEEK_DATA) && defined(SEEK_HOLE)
454 static errcode_t try_lseek_copy(ext2_filsys fs, int fd, struct stat *statbuf,
455 ext2_file_t e2_file, char *buf, char *zerobuf)
457 off_t data = 0, hole;
458 off_t data_blk, hole_blk;
461 /* Try to use SEEK_DATA and SEEK_HOLE */
462 while (data < statbuf->st_size) {
463 data = lseek(fd, data, SEEK_DATA);
467 return EXT2_ET_UNIMPLEMENTED;
469 hole = lseek(fd, data, SEEK_HOLE);
471 return EXT2_ET_UNIMPLEMENTED;
473 data_blk = data & ~(fs->blocksize - 1);
474 hole_blk = (hole + (fs->blocksize - 1)) & ~(fs->blocksize - 1);
475 err = copy_file_chunk(fs, fd, e2_file, data_blk, hole_blk, buf,
485 #endif /* SEEK_DATA and SEEK_HOLE */
487 #if defined(FS_IOC_FIEMAP)
488 static errcode_t try_fiemap_copy(ext2_filsys fs, int fd, ext2_file_t e2_file,
489 char *buf, char *zerobuf)
491 #define EXTENT_MAX_COUNT 512
492 struct fiemap *fiemap_buf;
493 struct fiemap_extent *ext_buf, *ext;
494 int ext_buf_size, fie_buf_size;
499 ext_buf_size = EXTENT_MAX_COUNT * sizeof(struct fiemap_extent);
500 fie_buf_size = sizeof(struct fiemap) + ext_buf_size;
502 err = ext2fs_get_memzero(fie_buf_size, &fiemap_buf);
506 ext_buf = fiemap_buf->fm_extents;
507 memset(fiemap_buf, 0, fie_buf_size);
508 fiemap_buf->fm_length = FIEMAP_MAX_OFFSET;
509 fiemap_buf->fm_flags |= FIEMAP_FLAG_SYNC;
510 fiemap_buf->fm_extent_count = EXTENT_MAX_COUNT;
513 fiemap_buf->fm_start = pos;
514 memset(ext_buf, 0, ext_buf_size);
515 err = ioctl(fd, FS_IOC_FIEMAP, fiemap_buf);
516 if (err < 0 && (errno == EOPNOTSUPP || errno == ENOTTY)) {
517 err = EXT2_ET_UNIMPLEMENTED;
519 } else if (err < 0) {
522 } else if (fiemap_buf->fm_mapped_extents == 0)
524 for (i = 0, ext = ext_buf; i < fiemap_buf->fm_mapped_extents;
526 err = copy_file_chunk(fs, fd, e2_file, ext->fe_logical,
527 ext->fe_logical + ext->fe_length,
534 /* Record file's logical offset this time */
535 pos = ext->fe_logical + ext->fe_length;
537 * If fm_extents array has been filled and
538 * there are extents left, continue to cycle.
540 } while (fiemap_buf->fm_mapped_extents == EXTENT_MAX_COUNT &&
541 !(ext->fe_flags & FIEMAP_EXTENT_LAST));
543 ext2fs_free_mem(&fiemap_buf);
546 #endif /* FS_IOC_FIEMAP */
548 static errcode_t copy_file(ext2_filsys fs, int fd, struct stat *statbuf,
552 char *buf = NULL, *zerobuf = NULL;
553 errcode_t err, close_err;
555 err = ext2fs_file_open(fs, ino, EXT2_FILE_WRITE, &e2_file);
559 err = ext2fs_get_mem(COPY_FILE_BUFLEN, &buf);
563 err = ext2fs_get_memzero(fs->blocksize, &zerobuf);
567 #if defined(SEEK_DATA) && defined(SEEK_HOLE)
568 err = try_lseek_copy(fs, fd, statbuf, e2_file, buf, zerobuf);
569 if (err != EXT2_ET_UNIMPLEMENTED)
573 #if defined(FS_IOC_FIEMAP)
574 err = try_fiemap_copy(fs, fd, e2_file, buf, zerobuf);
575 if (err != EXT2_ET_UNIMPLEMENTED)
579 err = copy_file_chunk(fs, fd, e2_file, 0, statbuf->st_size, buf,
582 ext2fs_free_mem(&zerobuf);
583 ext2fs_free_mem(&buf);
584 close_err = ext2fs_file_close(e2_file);
590 static int is_hardlink(struct hdlinks_s *hdlinks, dev_t dev, ino_t ino)
594 for (i = 0; i < hdlinks->count; i++) {
595 if (hdlinks->hdl[i].src_dev == dev &&
596 hdlinks->hdl[i].src_ino == ino)
602 /* Copy the native file to the fs */
603 errcode_t do_write_internal(ext2_filsys fs, ext2_ino_t cwd, const char *src,
604 const char *dest, ext2_ino_t root)
610 struct ext2_inode inode;
612 fd = ext2fs_open_file(src, O_RDONLY, 0);
615 com_err(__func__, retval, _("while opening \"%s\" to copy"),
619 if (fstat(fd, &statbuf) < 0) {
624 retval = ext2fs_namei(fs, root, cwd, dest, &newfile);
626 retval = EXT2_ET_FILE_EXISTS;
630 retval = ext2fs_new_inode(fs, cwd, 010755, 0, &newfile);
634 printf("Allocated inode: %u\n", newfile);
636 retval = ext2fs_link(fs, cwd, dest, newfile,
638 if (retval == EXT2_ET_DIR_NO_SPACE) {
639 retval = ext2fs_expand_dir(fs, cwd);
642 retval = ext2fs_link(fs, cwd, dest, newfile,
647 if (ext2fs_test_inode_bitmap2(fs->inode_map, newfile))
648 com_err(__func__, 0, "Warning: inode already set");
649 ext2fs_inode_alloc_stats2(fs, newfile, +1, 0);
650 memset(&inode, 0, sizeof(inode));
651 inode.i_mode = (statbuf.st_mode & ~LINUX_S_IFMT) | LINUX_S_IFREG;
652 inode.i_atime = inode.i_ctime = inode.i_mtime =
653 fs->now ? fs->now : time(0);
654 inode.i_links_count = 1;
655 retval = ext2fs_inode_size_set(fs, &inode, statbuf.st_size);
658 if (ext2fs_has_feature_inline_data(fs->super)) {
659 inode.i_flags |= EXT4_INLINE_DATA_FL;
660 } else if (ext2fs_has_feature_extents(fs->super)) {
661 ext2_extent_handle_t handle;
663 inode.i_flags &= ~EXT4_EXTENTS_FL;
664 retval = ext2fs_extent_open2(fs, newfile, &inode, &handle);
667 ext2fs_extent_free(handle);
670 retval = ext2fs_write_new_inode(fs, newfile, &inode);
673 if (inode.i_flags & EXT4_INLINE_DATA_FL) {
674 retval = ext2fs_inline_data_init(fs, newfile);
678 if (LINUX_S_ISREG(inode.i_mode)) {
679 retval = copy_file(fs, fd, &statbuf, newfile);
694 static errcode_t path_append(struct file_info *target, const char *file)
696 if (strlen(file) + target->path_len + 1 > target->path_max_len) {
697 target->path_max_len *= 2;
698 target->path = realloc(target->path, target->path_max_len);
700 return EXT2_ET_NO_MEMORY;
702 target->path_len += sprintf(target->path + target->path_len, "/%s",
707 /* Copy files from source_dir to fs */
708 static errcode_t __populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
709 const char *source_dir, ext2_ino_t root,
710 struct hdlinks_s *hdlinks,
711 struct file_info *target,
712 struct fs_ops_callbacks *fs_callbacks)
718 char *ln_target = NULL;
719 unsigned int save_inode;
721 errcode_t retval = 0;
724 size_t cur_dir_path_len;
726 if (chdir(source_dir) < 0) {
728 com_err(__func__, retval,
729 _("while changing working directory to \"%s\""),
734 if (!(dh = opendir("."))) {
736 com_err(__func__, retval,
737 _("while opening directory \"%s\""), source_dir);
741 while ((dent = readdir(dh))) {
742 if ((!strcmp(dent->d_name, ".")) ||
743 (!strcmp(dent->d_name, "..")))
745 if (lstat(dent->d_name, &st)) {
747 com_err(__func__, retval, _("while lstat \"%s\""),
753 /* Check for hardlinks */
755 if (!S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode) &&
757 hdlink = is_hardlink(hdlinks, st.st_dev, st.st_ino);
759 retval = add_link(fs, parent_ino,
760 hdlinks->hdl[hdlink].dst_ino,
763 com_err(__func__, retval,
764 "while linking %s", name);
772 cur_dir_path_len = target->path_len;
773 retval = path_append(target, name);
777 if (fs_callbacks && fs_callbacks->create_new_inode) {
778 retval = fs_callbacks->create_new_inode(fs,
779 target->path, name, parent_ino, root,
780 st.st_mode & S_IFMT);
785 switch(st.st_mode & S_IFMT) {
790 retval = do_mknod_internal(fs, parent_ino, name, &st);
792 com_err(__func__, retval,
793 _("while creating special file "
799 ln_target = malloc(st.st_size + 1);
800 if (ln_target == NULL) {
801 com_err(__func__, retval,
805 read_cnt = readlink(name, ln_target,
807 if (read_cnt == -1) {
809 com_err(__func__, retval,
810 _("while trying to read link \"%s\""),
815 if (read_cnt > st.st_size) {
816 com_err(__func__, retval,
817 _("symlink increased in size "
818 "between lstat() and readlink()"));
822 ln_target[read_cnt] = '\0';
823 retval = do_symlink_internal(fs, parent_ino, name,
827 com_err(__func__, retval,
828 _("while writing symlink\"%s\""),
834 retval = do_write_internal(fs, parent_ino, name, name,
837 com_err(__func__, retval,
838 _("while writing file \"%s\""), name);
843 /* Don't choke on /lost+found */
844 if (parent_ino == EXT2_ROOT_INO &&
845 strcmp(name, "lost+found") == 0)
847 retval = do_mkdir_internal(fs, parent_ino, name,
850 com_err(__func__, retval,
851 _("while making dir \"%s\""), name);
855 retval = ext2fs_namei(fs, root, parent_ino,
858 com_err(name, retval, 0);
861 /* Populate the dir recursively*/
862 retval = __populate_fs(fs, ino, name, root, hdlinks,
863 target, fs_callbacks);
868 com_err(__func__, retval,
869 _("while changing directory"));
875 _("ignoring entry \"%s\""), name);
878 retval = ext2fs_namei(fs, root, parent_ino, name, &ino);
880 com_err(name, retval, _("while looking up \"%s\""),
885 retval = set_inode_extra(fs, ino, &st);
887 com_err(__func__, retval,
888 _("while setting inode for \"%s\""), name);
892 retval = set_inode_xattr(fs, ino, name);
894 com_err(__func__, retval,
895 _("while setting xattrs for \"%s\""), name);
899 if (fs_callbacks && fs_callbacks->end_create_new_inode) {
900 retval = fs_callbacks->end_create_new_inode(fs,
901 target->path, name, parent_ino, root,
902 st.st_mode & S_IFMT);
907 /* Save the hardlink ino */
910 * Check whether need more memory, and we don't need
911 * free() since the lifespan will be over after the fs
914 if (hdlinks->count == hdlinks->size) {
915 void *p = realloc(hdlinks->hdl,
916 (hdlinks->size + HDLINK_CNT) *
917 sizeof(struct hdlink_s));
919 retval = EXT2_ET_NO_MEMORY;
920 com_err(name, retval,
921 _("while saving inode data"));
925 hdlinks->size += HDLINK_CNT;
927 hdlinks->hdl[hdlinks->count].src_dev = st.st_dev;
928 hdlinks->hdl[hdlinks->count].src_ino = st.st_ino;
929 hdlinks->hdl[hdlinks->count].dst_ino = ino;
932 target->path_len = cur_dir_path_len;
933 target->path[target->path_len] = 0;
941 errcode_t populate_fs2(ext2_filsys fs, ext2_ino_t parent_ino,
942 const char *source_dir, ext2_ino_t root,
943 struct fs_ops_callbacks *fs_callbacks)
945 struct file_info file_info;
946 struct hdlinks_s hdlinks;
949 if (!(fs->flags & EXT2_FLAG_RW)) {
950 com_err(__func__, 0, "Filesystem opened readonly");
955 hdlinks.size = HDLINK_CNT;
956 hdlinks.hdl = realloc(NULL, hdlinks.size * sizeof(struct hdlink_s));
957 if (hdlinks.hdl == NULL) {
959 com_err(__func__, retval, _("while allocating memory"));
963 file_info.path_len = 0;
964 file_info.path_max_len = 255;
965 file_info.path = calloc(file_info.path_max_len, 1);
967 retval = __populate_fs(fs, parent_ino, source_dir, root, &hdlinks,
968 &file_info, fs_callbacks);
970 free(file_info.path);
975 errcode_t populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
976 const char *source_dir, ext2_ino_t root)
978 return populate_fs2(fs, parent_ino, source_dir, root, NULL);