Nano_Allwinner
/
ubuntu-buildroot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ubuntu-buildroot/output/build/host-e2fsprogs-1.46.5/misc/mk_hugefiles.c

608 lines
15 KiB
C
Raw Blame History

/*
* mk_hugefiles.c -- create huge files
*/
#define _XOPEN_SOURCE 600 /* for inclusion of PATH_MAX in Solaris */
#define _BSD_SOURCE /* for makedev() and major() */
#define _DEFAULT_SOURCE /* since glibc 2.20 _BSD_SOURCE is deprecated */
#include "config.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <ctype.h>
#include <time.h>
#ifdef __linux__
#include <sys/utsname.h>
#endif
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#else
extern char *optarg;
extern int optind;
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_SYS_SYSMACROS_H
#include <sys/sysmacros.h>
#endif
#include <libgen.h>
#include <limits.h>
#include <blkid/blkid.h>
#include "ext2fs/ext2_fs.h"
#include "ext2fs/ext2fsP.h"
#include "et/com_err.h"
#include "uuid/uuid.h"
#include "e2p/e2p.h"
#include "ext2fs/ext2fs.h"
#include "util.h"
#include "support/profile.h"
#include "support/prof_err.h"
#include "support/nls-enable.h"
#include "mke2fs.h"
static int uid;
static int gid;
static blk64_t num_blocks;
static blk64_t num_slack;
static unsigned long num_files;
static blk64_t goal;
static char *fn_prefix;
static int idx_digits;
static char *fn_buf;
static char *fn_numbuf;
int zero_hugefile = 1;
#define SYSFS_PATH_LEN 300
typedef char sysfs_path_t[SYSFS_PATH_LEN];
#ifndef HAVE_SNPRINTF
/*
* We are very careful to avoid needing to worry about buffer
* overflows, so we don't really need to use snprintf() except as an
* additional safety check. So if snprintf() is not present, it's
* safe to fall back to vsprintf(). This provides portability since
* vsprintf() is guaranteed by C89, while snprintf() is only
* guaranteed by C99 --- which for example, Microsoft Visual Studio
* has *still* not bothered to implement. :-/ (Not that I expect
* mke2fs to be ported to MS Visual Studio any time soon, but
* libext2fs *does* get built on Microsoft platforms, and we might
* want to move this into libext2fs some day.)
*/
static int my_snprintf(char *str, size_t size, const char *format, ...)
{
va_list ap;
int ret;
va_start(ap, format);
ret = vsprintf(str, format, ap);
va_end(ap);
return ret;
}
#define snprintf my_snprintf
#endif
/*
* Fall back to Linux's definitions of makedev and major are needed.
* The search_sysfs_block() function is highly unlikely to work on
* non-Linux systems anyway.
*/
#ifndef makedev
#define makedev(maj, min) (((maj) << 8) + (min))
#endif
static char *search_sysfs_block(dev_t devno, sysfs_path_t ret_path)
{
struct dirent *de, *p_de;
DIR *dir = NULL, *p_dir = NULL;
FILE *f;
sysfs_path_t path, p_path;
unsigned int major, minor;
char *ret = ret_path;
ret_path[0] = 0;
if ((dir = opendir("/sys/block")) == NULL)
return NULL;
while ((de = readdir(dir)) != NULL) {
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..") ||
strlen(de->d_name) > sizeof(path)-32)
continue;
snprintf(path, SYSFS_PATH_LEN,
"/sys/block/%s/dev", de->d_name);
f = fopen(path, "r");
if (f &&
(fscanf(f, "%u:%u", &major, &minor) == 2)) {
fclose(f); f = NULL;
if (makedev(major, minor) == devno) {
snprintf(ret_path, SYSFS_PATH_LEN,
"/sys/block/%s", de->d_name);
goto success;
}
#ifdef major
if (major(devno) != major)
continue;
#endif
}
if (f)
fclose(f);
snprintf(path, SYSFS_PATH_LEN, "/sys/block/%s", de->d_name);
if (p_dir)
closedir(p_dir);
if ((p_dir = opendir(path)) == NULL)
continue;
while ((p_de = readdir(p_dir)) != NULL) {
if (!strcmp(p_de->d_name, ".") ||
!strcmp(p_de->d_name, "..") ||
(strlen(p_de->d_name) >
SYSFS_PATH_LEN - strlen(path) - 32))
continue;
snprintf(p_path, SYSFS_PATH_LEN, "%s/%s/dev",
path, p_de->d_name);
f = fopen(p_path, "r");
if (f &&
(fscanf(f, "%u:%u", &major, &minor) == 2) &&
(((major << 8) + minor) == devno)) {
fclose(f);
snprintf(ret_path, SYSFS_PATH_LEN, "%s/%s",
path, p_de->d_name);
goto success;
}
if (f)
fclose(f);
}
}
ret = NULL;
success:
if (dir)
closedir(dir);
if (p_dir)
closedir(p_dir);
return ret;
}
static blk64_t get_partition_start(const char *device_name)
{
unsigned long long start;
sysfs_path_t path;
struct stat st;
FILE *f;
char *cp;
int n;
if ((stat(device_name, &st) < 0) || !S_ISBLK(st.st_mode))
return 0;
cp = search_sysfs_block(st.st_rdev, path);
if (!cp)
return 0;
if (strlen(path) > SYSFS_PATH_LEN - sizeof("/start"))
return 0;
strcat(path, "/start");
f = fopen(path, "r");
if (!f)
return 0;
n = fscanf(f, "%llu", &start);
fclose(f);
return (n == 1) ? start : 0;
}
static errcode_t create_directory(ext2_filsys fs, char *dir,
ext2_ino_t *ret_ino)
{
struct ext2_inode inode;
ext2_ino_t ino = EXT2_ROOT_INO;
ext2_ino_t newdir;
errcode_t retval = 0;
char *fn, *cp, *next;
fn = malloc(strlen(dir) + 1);
if (fn == NULL)
return ENOMEM;
strcpy(fn, dir);
cp = fn;
while(1) {
next = strchr(cp, '/');
if (next)
*next++ = 0;
if (*cp) {
retval = ext2fs_new_inode(fs, ino, LINUX_S_IFDIR,
NULL, &newdir);
if (retval)
goto errout;
retval = ext2fs_mkdir(fs, ino, newdir, cp);
if (retval)
goto errout;
ino = newdir;
retval = ext2fs_read_inode(fs, ino, &inode);
if (retval)
goto errout;
inode.i_uid = uid & 0xFFFF;
ext2fs_set_i_uid_high(inode, (uid >> 16) & 0xffff);
inode.i_gid = gid & 0xFFFF;
ext2fs_set_i_gid_high(inode, (gid >> 16) & 0xffff);
retval = ext2fs_write_inode(fs, ino, &inode);
if (retval)
goto errout;
}
if (next == NULL || *next == '\0')
break;
cp = next;
}
errout:
free(fn);
if (retval == 0)
*ret_ino = ino;
return retval;
}
static errcode_t mk_hugefile(ext2_filsys fs, blk64_t num,
ext2_ino_t dir, unsigned long idx, ext2_ino_t *ino)
{
errcode_t retval;
blk64_t lblk, bend = 0;
__u64 size;
blk64_t left;
blk64_t count = 0;
struct ext2_inode inode;
ext2_extent_handle_t handle;
retval = ext2fs_new_inode(fs, 0, LINUX_S_IFREG, NULL, ino);
if (retval)
return retval;
memset(&inode, 0, sizeof(struct ext2_inode));
inode.i_mode = LINUX_S_IFREG | (0666 & ~fs->umask);
inode.i_links_count = 1;
inode.i_uid = uid & 0xFFFF;
ext2fs_set_i_uid_high(inode, (uid >> 16) & 0xffff);
inode.i_gid = gid & 0xFFFF;
ext2fs_set_i_gid_high(inode, (gid >> 16) & 0xffff);
retval = ext2fs_write_new_inode(fs, *ino, &inode);
if (retval)
return retval;
ext2fs_inode_alloc_stats2(fs, *ino, +1, 0);
retval = ext2fs_extent_open2(fs, *ino, &inode, &handle);
if (retval)
return retval;
/*
* We don't use ext2fs_fallocate() here because hugefiles are
* designed to be physically contiguous (if the block group
* descriptors are configured to be in a single block at the
* beginning of the file system, by using the
* packed_meta_blocks layout), with the extent tree blocks
* allocated near the beginning of the file system.
*/
lblk = 0;
left = num ? num : 1;
while (left) {
blk64_t pblk, end;
blk64_t n = left;
retval = ext2fs_find_first_zero_block_bitmap2(fs->block_map,
goal, ext2fs_blocks_count(fs->super) - 1, &end);
if (retval)
goto errout;
goal = end;
retval = ext2fs_find_first_set_block_bitmap2(fs->block_map, goal,
ext2fs_blocks_count(fs->super) - 1, &bend);
if (retval == ENOENT) {
bend = ext2fs_blocks_count(fs->super);
if (num == 0)
left = 0;
}
if (!num || bend - goal < left)
n = bend - goal;
pblk = goal;
if (num)
left -= n;
goal += n;
count += n;
ext2fs_block_alloc_stats_range(fs, pblk, n, +1);
if (zero_hugefile) {
blk64_t ret_blk;
retval = ext2fs_zero_blocks2(fs, pblk, n,
&ret_blk, NULL);
if (retval)
com_err(program_name, retval,
_("while zeroing block %llu "
"for hugefile"),
(unsigned long long) ret_blk);
}
while (n) {
blk64_t l = n;
struct ext2fs_extent newextent;
if (l > EXT_INIT_MAX_LEN)
l = EXT_INIT_MAX_LEN;
newextent.e_len = l;
newextent.e_pblk = pblk;
newextent.e_lblk = lblk;
newextent.e_flags = 0;
retval = ext2fs_extent_insert(handle,
EXT2_EXTENT_INSERT_AFTER, &newextent);
if (retval)
return retval;
pblk += l;
lblk += l;
n -= l;
}
}
retval = ext2fs_read_inode(fs, *ino, &inode);
if (retval)
goto errout;
retval = ext2fs_iblk_add_blocks(fs, &inode,
count / EXT2FS_CLUSTER_RATIO(fs));
if (retval)
goto errout;
size = (__u64) count * fs->blocksize;
retval = ext2fs_inode_size_set(fs, &inode, size);
if (retval)
goto errout;
retval = ext2fs_write_new_inode(fs, *ino, &inode);
if (retval)
goto errout;
if (idx_digits)
sprintf(fn_numbuf, "%0*lu", idx_digits, idx);
else if (num_files > 1)
sprintf(fn_numbuf, "%lu", idx);
retry:
retval = ext2fs_link(fs, dir, fn_buf, *ino, EXT2_FT_REG_FILE);
if (retval == EXT2_ET_DIR_NO_SPACE) {
retval = ext2fs_expand_dir(fs, dir);
if (retval)
goto errout;
goto retry;
}
if (retval)
goto errout;
errout:
if (handle)
ext2fs_extent_free(handle);
return retval;
}
static blk64_t calc_overhead(ext2_filsys fs, blk64_t num)
{
blk64_t e_blocks, e_blocks2, e_blocks3, e_blocks4;
int extents_per_block;
int extents = (num + EXT_INIT_MAX_LEN - 1) / EXT_INIT_MAX_LEN;
if (extents <= 4)
return 0;
/*
* This calculation is due to the fact that we are inefficient
* in how handle extent splits when appending to the end of
* the extent tree. Sigh. We should fix this so that we can
* actually store 340 extents per 4k block, instead of only 170.
*/
extents_per_block = ((fs->blocksize -
sizeof(struct ext3_extent_header)) /
sizeof(struct ext3_extent));
extents_per_block = (extents_per_block/ 2) - 1;
e_blocks = (extents + extents_per_block - 1) / extents_per_block;
e_blocks2 = (e_blocks + extents_per_block - 1) / extents_per_block;
e_blocks3 = (e_blocks2 + extents_per_block - 1) / extents_per_block;
e_blocks4 = (e_blocks3 + extents_per_block - 1) / extents_per_block;
return (e_blocks + e_blocks2 + e_blocks3 + e_blocks4) *
EXT2FS_CLUSTER_RATIO(fs);
}
/*
* Find the place where we should start allocating blocks for the huge
* files. Leave <slack> free blocks at the beginning of the file
* system for things like metadata blocks.
*/
static blk64_t get_start_block(ext2_filsys fs, blk64_t slack)
{
errcode_t retval;
blk64_t blk = fs->super->s_first_data_block, next;
blk64_t last_blk = ext2fs_blocks_count(fs->super) - 1;
while (slack) {
retval = ext2fs_find_first_zero_block_bitmap2(fs->block_map,
blk, last_blk, &blk);
if (retval)
break;
retval = ext2fs_find_first_set_block_bitmap2(fs->block_map,
blk, last_blk, &next);
if (retval)
next = last_blk;
if (next - blk > slack) {
blk += slack;
break;
}
slack -= (next - blk);
blk = next;
}
return blk;
}
static blk64_t round_up_align(blk64_t b, unsigned long align,
blk64_t part_offset)
{
unsigned long m;
if (align == 0)
return b;
part_offset = part_offset % align;
m = (b + part_offset) % align;
if (m)
b += align - m;
return b;
}
errcode_t mk_hugefiles(ext2_filsys fs, const char *device_name)
{
unsigned long i;
ext2_ino_t dir;
errcode_t retval;
blk64_t fs_blocks, part_offset = 0;
unsigned long align;
int d, dsize;
char *t;
if (!get_bool_from_profile(fs_types, "make_hugefiles", 0))
return 0;
if (!ext2fs_has_feature_extents(fs->super))
return EXT2_ET_EXTENT_NOT_SUPPORTED;
uid = get_int_from_profile(fs_types, "hugefiles_uid", 0);
gid = get_int_from_profile(fs_types, "hugefiles_gid", 0);
fs->umask = get_int_from_profile(fs_types, "hugefiles_umask", 077);
num_files = get_int_from_profile(fs_types, "num_hugefiles", 0);
t = get_string_from_profile(fs_types, "hugefiles_slack", "1M");
num_slack = parse_num_blocks2(t, fs->super->s_log_block_size);
free(t);
t = get_string_from_profile(fs_types, "hugefiles_size", "0");
num_blocks = parse_num_blocks2(t, fs->super->s_log_block_size);
free(t);
t = get_string_from_profile(fs_types, "hugefiles_align", "0");
align = parse_num_blocks2(t, fs->super->s_log_block_size);
free(t);
if (get_bool_from_profile(fs_types, "hugefiles_align_disk", 0)) {
part_offset = get_partition_start(device_name) /
(fs->blocksize / 512);
if (part_offset % EXT2FS_CLUSTER_RATIO(fs)) {
fprintf(stderr,
_("Partition offset of %llu (%uk) blocks "
"not compatible with cluster size %u.\n"),
(unsigned long long) part_offset, fs->blocksize,
EXT2_CLUSTER_SIZE(fs->super));
exit(1);
}
}
num_blocks = round_up_align(num_blocks, align, 0);
zero_hugefile = get_bool_from_profile(fs_types, "zero_hugefiles",
zero_hugefile);
t = get_string_from_profile(fs_types, "hugefiles_dir", "/");
retval = create_directory(fs, t, &dir);
free(t);
if (retval)
return retval;
fn_prefix = get_string_from_profile(fs_types, "hugefiles_name",
"hugefile");
idx_digits = get_int_from_profile(fs_types, "hugefiles_digits", 5);
d = int_log10(num_files) + 1;
if (idx_digits > d)
d = idx_digits;
dsize = strlen(fn_prefix) + d + 16;
fn_buf = malloc(dsize);
if (!fn_buf) {
free(fn_prefix);
return ENOMEM;
}
strcpy(fn_buf, fn_prefix);
fn_numbuf = fn_buf + strlen(fn_prefix);
free(fn_prefix);
fs_blocks = ext2fs_free_blocks_count(fs->super);
if (fs_blocks < num_slack + align)
return ENOSPC;
fs_blocks -= num_slack + align;
if (num_blocks && num_blocks > fs_blocks)
return ENOSPC;
if (num_blocks == 0 && num_files == 0)
num_files = 1;
if (num_files == 0 && num_blocks) {
num_files = fs_blocks / num_blocks;
fs_blocks -= (num_files / 16) + 1;
fs_blocks -= calc_overhead(fs, num_blocks) * num_files;
num_files = fs_blocks / num_blocks;
}
if (num_blocks == 0 && num_files > 1) {
num_blocks = fs_blocks / num_files;
fs_blocks -= (num_files / 16) + 1;
fs_blocks -= calc_overhead(fs, num_blocks) * num_files;
num_blocks = fs_blocks / num_files;
}
num_slack += (calc_overhead(fs, num_blocks ? num_blocks : fs_blocks) *
num_files);
num_slack += (num_files / 16) + 1; /* space for dir entries */
goal = get_start_block(fs, num_slack);
goal = round_up_align(goal, align, part_offset);
if ((num_blocks ? num_blocks : fs_blocks) >
(0x80000000UL / fs->blocksize))
ext2fs_set_feature_large_file(fs->super);
if (!quiet) {
if (zero_hugefile && verbose)
printf("%s", _("Huge files will be zero'ed\n"));
printf(_("Creating %lu huge file(s) "), num_files);
if (num_blocks)
printf(_("with %llu blocks each"),
(unsigned long long) num_blocks);
fputs(": ", stdout);
}
for (i=0; i < num_files; i++) {
ext2_ino_t ino;
retval = mk_hugefile(fs, num_blocks, dir, i, &ino);
if (retval) {
com_err(program_name, retval,
_("while creating huge file %lu"), i);
goto errout;
}
}
if (!quiet)
fputs(_("done\n"), stdout);
errout:
free(fn_buf);
return retval;
}
Reference in New Issue View Git Blame Copy Permalink