third_party_f2fs-tools/fsck/sload.c

/**
 * sload.c
 *
 * Copyright (C) 2015 Huawei Ltd.
 * Witten by:
 *   Hou Pengyang <houpengyang@huawei.com>
 *   Liu Shuoran <liushuoran@huawei.com>
 *   Jaegeuk Kim <jaegeuk@kernel.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#define _GNU_SOURCE
#include "fsck.h"
#include <libgen.h>
#include <dirent.h>
#include <mntent.h>

#ifdef HAVE_LIBSELINUX
#include <selinux/selinux.h>
#include <selinux/label.h>
#endif

#ifdef WITH_ANDROID
#include <selinux/label.h>
#include <private/android_filesystem_config.h>

static void handle_selabel(struct dentry *de, int dir, char *target_out)
{
	uint64_t capabilities;
	unsigned int mode = 0;
	unsigned int uid = 0;
	unsigned int gid = 0;

	fs_config(de->path, dir, target_out, &uid,
			&gid, &mode, &capabilities);
	de->mode = mode;
	de->uid = uid;
	de->gid = gid;
	de->capabilities = capabilities;
}
#else
#define handle_selabel(...)
#endif

static int filter_dot(const struct dirent *d)
{
	return (strcmp(d->d_name, "..") && strcmp(d->d_name, "."));
}

static void f2fs_make_directory(struct f2fs_sb_info *sbi,
				int entries, struct dentry *de)
{
	int i = 0;

	for (i = 0; i < entries; i++) {
		if (de[i].file_type == F2FS_FT_DIR)
			f2fs_mkdir(sbi, de + i);
		else if (de[i].file_type == F2FS_FT_REG_FILE)
			f2fs_create(sbi, de + i);
		else if (de[i].file_type == F2FS_FT_SYMLINK)
			f2fs_symlink(sbi, de + i);
	}
}

static int build_directory(struct f2fs_sb_info *sbi, const char *full_path,
			const char *dir_path, const char *target_out_dir,
			nid_t dir_ino, struct selabel_handle *sehnd)
{
	int entries = 0;
	struct dentry *dentries;
	struct dirent **namelist = NULL;
	struct stat stat;
	int i, ret = 0;

	entries = scandir(full_path, &namelist, filter_dot, (void *)alphasort);
	if (entries < 0) {
		ERR_MSG("No entries in %s\n", full_path);
		return -ENOENT;
	}

	dentries = calloc(entries, sizeof(struct dentry));
	if (dentries == NULL)
		return -ENOMEM;

	for (i = 0; i < entries; i++) {
		dentries[i].name = (unsigned char *)strdup(namelist[i]->d_name);
		if (dentries[i].name == NULL) {
			ERR_MSG("Skip: ENOMEM\n");
			continue;
		}
		dentries[i].len = strlen((char *)dentries[i].name);

		ret = asprintf(&dentries[i].path, "%s/%s",
					dir_path, namelist[i]->d_name);
		ASSERT(ret > 0);
		ret = asprintf(&dentries[i].full_path, "%s/%s",
					full_path, namelist[i]->d_name);
		ASSERT(ret > 0);
		free(namelist[i]);

		ret = lstat(dentries[i].full_path, &stat);
		if (ret < 0) {
			ERR_MSG("Skip: lstat failure\n");
			continue;
		}
		dentries[i].size = stat.st_size;
		dentries[i].mode = stat.st_mode &
			(S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO);
		dentries[i].mtime = stat.st_mtime;

		handle_selabel(dentries + i, S_ISDIR(stat.st_mode),
							target_out_dir);

#ifdef HAVE_LIBSELINUX
		if (sehnd && selabel_lookup(sehnd, &dentries[i].secon,
					dentries[i].path, stat.st_mode) < 0)
			ERR_MSG("Cannot lookup security context for %s\n",
						dentries[i].path);
#endif

		dentries[i].pino = dir_ino;

		if (S_ISREG(stat.st_mode)) {
			dentries[i].file_type = F2FS_FT_REG_FILE;
		} else if (S_ISDIR(stat.st_mode)) {
			dentries[i].file_type = F2FS_FT_DIR;
		} else if (S_ISCHR(stat.st_mode)) {
			dentries[i].file_type = F2FS_FT_CHRDEV;
		} else if (S_ISBLK(stat.st_mode)) {
			dentries[i].file_type = F2FS_FT_BLKDEV;
		} else if (S_ISFIFO(stat.st_mode)) {
			dentries[i].file_type = F2FS_FT_FIFO;
		} else if (S_ISSOCK(stat.st_mode)) {
			dentries[i].file_type = F2FS_FT_SOCK;
		} else if (S_ISLNK(stat.st_mode)) {
			dentries[i].file_type = F2FS_FT_SYMLINK;
			dentries[i].link = calloc(F2FS_BLKSIZE, 1);
			ASSERT(dentries[i].link);
			ret = readlink(dentries[i].full_path,
					dentries[i].link, F2FS_BLKSIZE - 1);
			ASSERT(ret >= 0);
		} else {
			MSG(1, "unknown file type on %s", dentries[i].path);
			i--;
			entries--;
		}
	}

	free(namelist);

	f2fs_make_directory(sbi, entries, dentries);

	for (i = 0; i < entries; i++) {
		if (dentries[i].file_type == F2FS_FT_REG_FILE) {
			f2fs_build_file(sbi, dentries + i);
		} else if (dentries[i].file_type == F2FS_FT_DIR) {
			char *subdir_full_path = NULL;
			char *subdir_dir_path;

			ret = asprintf(&subdir_full_path, "%s/",
							dentries[i].full_path);
			ASSERT(ret > 0);
			ret = asprintf(&subdir_dir_path, "%s/",
							dentries[i].path);
			ASSERT(ret > 0);

			build_directory(sbi, subdir_full_path, subdir_dir_path,
					target_out_dir, dentries[i].ino, sehnd);
			free(subdir_full_path);
			free(subdir_dir_path);
		} else if (dentries[i].file_type == F2FS_FT_SYMLINK) {
			/*
			 * It is already done in f2fs_make_directory
			 * f2fs_make_symlink(sbi, dir_ino, &dentries[i]);
			 */
		} else {
			MSG(1, "Error unknown file type\n");
		}

#ifdef HAVE_LIBSELINUX
		if (dentries[i].secon) {
			inode_set_selinux(sbi, dentries[i].ino, dentries[i].secon);
			MSG(1, "File = %s \n----->SELinux context = %s\n",
					dentries[i].path, dentries[i].secon);
			MSG(1, "----->mode = 0x%x, uid = 0x%x, gid = 0x%x, "
					"capabilities = 0x%lx \n",
					dentries[i].mode, dentries[i].uid,
					dentries[i].gid, dentries[i].capabilities);
		}

		free(dentries[i].secon);
#endif

		free(dentries[i].path);
		free(dentries[i].full_path);
		free((void *)dentries[i].name);
	}

	free(dentries);
	return 0;
}

int f2fs_sload(struct f2fs_sb_info *sbi, const char *from_dir,
				const char *mount_point,
				const char *target_out_dir,
				struct selabel_handle *sehnd)
{
	int ret = 0;
	nid_t mnt_ino = F2FS_ROOT_INO(sbi);

	/* flush NAT/SIT journal entries */
	flush_journal_entries(sbi);

	ret = f2fs_find_path(sbi, (char *)mount_point, &mnt_ino);
	if (ret) {
		ERR_MSG("Failed to get mount point %s\n", mount_point);
		return ret;
	}

	ret = build_directory(sbi, from_dir, mount_point, target_out_dir,
						mnt_ino, sehnd);
	if (ret) {
		ERR_MSG("Failed to build due to %d\n", ret);
		return ret;
	}

#ifdef HAVE_LIBSELINUX
	if (sehnd) {
		char *secontext = NULL;

		/* set root inode selinux context */
		if (selabel_lookup(sehnd, &secontext, mount_point, S_IFDIR) < 0)
			ERR_MSG("cannot lookup security context for %s\n",
								mount_point);
		if (secontext) {
			MSG(1, "Labeling %s as %s, root_ino = %d\n",
					mount_point, secontext, F2FS_ROOT_INO(sbi));
			/* xattr_add for root inode */
			inode_set_selinux(sbi, F2FS_ROOT_INO(sbi), secontext);
		}
		free(secontext);
	}
#endif

	/* update curseg info; can update sit->types */
	move_curseg_info(sbi, SM_I(sbi)->main_blkaddr);
	zero_journal_entries(sbi);
	write_curseg_info(sbi);

	/* flush dirty sit entries */
	flush_sit_entries(sbi);

	write_checkpoint(sbi);
	return 0;
}