/*      $NetBSD: v7fs_populate.c,v 1.4 2022/02/11 10:55:15 hannken Exp $        */

/*-
* Copyright (c) 2011 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by UCHIYAMA Yasushi.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#if HAVE_NBTOOL_CONFIG_H
#include "nbtool_config.h"
#endif

#include <sys/cdefs.h>
#if defined(__RCSID) && !defined(__lint)
__RCSID("$NetBSD: v7fs_populate.c,v 1.4 2022/02/11 10:55:15 hannken Exp $");
#endif  /* !__lint */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <err.h>

#if !HAVE_NBTOOL_CONFIG_H
#include <sys/mount.h>
#endif

#include "makefs.h"
#include "v7fs.h"
#include "v7fs_impl.h"
#include "v7fs_inode.h"
#include "v7fs_superblock.h"
#include "v7fs_datablock.h"
#include "v7fs_endian.h"
#include "v7fs_file.h"
#include "v7fs_makefs.h"
#include "newfs_v7fs.h"

#define VPRINTF(fmt, args...)   { if (v7fs_newfs_verbose) printf(fmt, ##args); }

static void
attr_setup(fsnode *node, struct v7fs_fileattr *attr)
{
       struct stat *st = &node->inode->st;

       attr->mode = node->type | st->st_mode;
       attr->uid = st->st_uid;
       attr->gid = st->st_gid;
       attr->device = 0;
       attr->ctime = st->st_ctime;
       attr->atime = st->st_atime;
       attr->mtime = st->st_mtime;
}

static int
allocate(struct v7fs_self *fs, struct v7fs_inode *parent_inode, fsnode *node,
   dev_t dev, struct v7fs_inode *inode)
{
       int error;
       v7fs_ino_t ino;
       struct v7fs_fileattr attr;

       memset(inode, 0, sizeof(*inode));

       attr_setup(node, &attr);
       attr.device = dev;
       if ((error = v7fs_file_allocate(fs, parent_inode, node->name,
           strlen(node->name), &attr, &ino))) {
               errno = error;
               warn("%s", node->name);
               return error;
       }
       node->inode->ino = ino;
       node->inode->flags |= FI_ALLOCATED;
       if ((error = v7fs_inode_load(fs, inode, ino))) {
               errno = error;
               warn("%s", node->name);
               return error;
       }

       return 0;
}

struct copy_arg {
       int fd;
       uint8_t buf[V7FS_BSIZE];
};

static int
copy_subr(struct v7fs_self *fs, void *ctx, v7fs_daddr_t blk, size_t sz)
{
       struct copy_arg *p = ctx;

       if (read(p->fd, p->buf, sz) != (ssize_t)sz) {
               return V7FS_ITERATOR_ERROR;
       }

       if (!fs->io.write(fs->io.cookie, p->buf, blk)) {
               errno = EIO;
               return V7FS_ITERATOR_ERROR;
       }
       progress(0);

       return 0;
}

static int
file_copy(struct v7fs_self *fs, struct v7fs_inode *parent_inode, fsnode *node,
       const char *filepath)
{
       struct v7fs_inode inode;
       const char *errmsg;
       fsinode *fnode = node->inode;
       int error = 0;
       int fd;

       /* Check hard-link */
       if ((fnode->nlink > 1) && (fnode->flags & FI_ALLOCATED)) {
               if ((error = v7fs_inode_load(fs, &inode, fnode->ino))) {
                       errmsg = "inode load";
                       goto err_exit;
               }
               if ((error = v7fs_file_link(fs, parent_inode, &inode,
                           node->name, strlen(node->name)))) {
                       errmsg = "hard link";
                       goto err_exit;
               }
               return 0;
       }

       /* Allocate file */
       if ((error = allocate(fs, parent_inode, node, 0, &inode))) {
               errmsg = "file allocate";
               goto err_exit;
       }
       if ((error = v7fs_datablock_expand(fs, &inode, fnode->st.st_size))) {
               errmsg = "datablock expand";
               goto err_exit;
       }

       /* Data copy */
       if ((fd = open(filepath, O_RDONLY)) == -1) {
               error = errno;
               errmsg = "source file";
               goto err_exit;
       }

       error = v7fs_datablock_foreach(fs, &inode, copy_subr,
           &(struct copy_arg){ .fd = fd });
       if (error != V7FS_ITERATOR_END) {
               errmsg = "data copy";
               close(fd);
               goto err_exit;
       } else {
               error = 0;
       }
       close(fd);

       return error;

err_exit:
       errno = error;
       warn("%s %s", node->name, errmsg);

       return error;
}

static int
populate_walk(struct v7fs_self *fs, struct v7fs_inode *parent_inode,
   fsnode *root, char *dir)
{
       fsnode *cur;
       char *mydir = dir + strlen(dir);
       char srcpath[MAXPATHLEN + 1];
       struct v7fs_inode inode;
       int error = 0;
       bool failed = false;

       for (cur = root; cur != NULL; cur = cur->next) {
               switch (cur->type & S_IFMT) {
               default:
                       VPRINTF("%x\n", cur->flags & S_IFMT);
                       break;
               case S_IFCHR:
                       /*FALLTHROUGH*/
               case S_IFBLK:
                       if ((error = allocate(fs, parent_inode, cur,
                           cur->inode->st.st_rdev, &inode))) {
                               errno = error;
                               warn("%s", cur->name);
                       }
                       break;
               case S_IFDIR:
                       if (!cur->child)        /*'.'*/
                               break;
                       /* Allocate this directory. */
                       if ((error = allocate(fs, parent_inode, cur, 0,
                           &inode))) {
                               errno = error;
                               warn("%s", cur->name);
                       } else {
                               /* Populate children. */
                               mydir[0] = '/';
                               strcpy(&mydir[1], cur->name);
                               error = populate_walk(fs, &inode, cur->child,
                                   dir);
                               mydir[0] = '\0';
                       }
                       break;
               case S_IFREG:
                       snprintf(srcpath, sizeof(srcpath), "%s/%s", dir,
                           cur->name);
                       error = file_copy(fs, parent_inode, cur, srcpath);
                       break;
               case S_IFLNK:
                       if ((error = allocate(fs, parent_inode, cur, 0,
                           &inode))) {
                               errno = error;
                               warn("%s", cur->name);
                       } else {
                               v7fs_file_symlink(fs, &inode, cur->symlink);
                       }
                       break;
               }
               if (error)
                       failed = true;
       }

       return failed ? 2 : 0;
}

int
v7fs_populate(const char *dir, fsnode *root, fsinfo_t *fsopts,
   const struct v7fs_mount_device *device)
{
       v7fs_opt_t *v7fs_opts = fsopts->fs_specific;
       static char path[MAXPATHLEN + 1];
       struct v7fs_inode root_inode;
       struct v7fs_self *fs;
       int error;

       if ((error = v7fs_io_init(&fs, device, V7FS_BSIZE))) {
               errno = error;
               warn("I/O setup failed.");
               return error;
       }
       fs->endian = device->endian;
       v7fs_endian_init(fs);

       if ((error = v7fs_superblock_load(fs))) {
               errno = error;
               warn("Can't load superblock.");
               return error;
       }
       fsopts->superblock = &fs->superblock;   /* not used. */

       if ((error = v7fs_inode_load(fs, &root_inode, V7FS_ROOT_INODE))) {
               errno = error;
               warn("Can't load root inode.");
               return error;
       }

       progress(&(struct progress_arg){ .label = "populate", .tick =
           v7fs_opts->npuredatablk / PROGRESS_BAR_GRANULE });

       strncpy(path, dir, sizeof(path));
       error = populate_walk(fs, &root_inode, root, path);

       v7fs_inode_writeback(fs, &root_inode);
       v7fs_superblock_writeback(fs);

       return error;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.