317 lines
8.4 KiB
C
317 lines
8.4 KiB
C
/* $NetBSD: main.c,v 1.10 2011/08/10 11:31:49 uch 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>
|
|
#ifndef lint
|
|
__RCSID("$NetBSD: main.c,v 1.10 2011/08/10 11:31:49 uch Exp $");
|
|
#endif /* not lint */
|
|
|
|
#include <sys/param.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <time.h>
|
|
#include <err.h>
|
|
|
|
#include "v7fs.h"
|
|
#include "v7fs_impl.h"
|
|
#include "v7fs_endian.h"
|
|
#include "v7fs_superblock.h"
|
|
#include "v7fs_inode.h"
|
|
#include "v7fs_datablock.h" /*v7fs_datablock_expand/last */
|
|
#include "newfs_v7fs.h"
|
|
#include "progress.h" /*../sbin/fsck */
|
|
|
|
#define VPRINTF(lv, fmt, args...) { if (v7fs_newfs_verbose >= lv) \
|
|
printf(fmt, ##args); }
|
|
|
|
static v7fs_daddr_t
|
|
determine_ilist_size(v7fs_daddr_t volume_size, int32_t files)
|
|
{
|
|
v7fs_daddr_t ilist_size;
|
|
|
|
if (files)
|
|
ilist_size = howmany(files, V7FS_INODE_PER_BLOCK);
|
|
else
|
|
ilist_size = volume_size / 25; /* 4% */
|
|
if (ilist_size > (v7fs_daddr_t)V7FS_ILISTBLK_MAX)
|
|
ilist_size = V7FS_ILISTBLK_MAX;
|
|
|
|
return ilist_size;
|
|
}
|
|
|
|
static int
|
|
partition_check(struct v7fs_self *fs)
|
|
{
|
|
struct v7fs_superblock *sb = &fs->superblock;
|
|
int error;
|
|
|
|
if ((error = v7fs_superblock_load(fs))) {
|
|
if (error != EINVAL) {
|
|
/* Invalid superblock information is OK. */
|
|
warnx("Can't read superblock sector.");
|
|
}
|
|
}
|
|
sb->modified = 1;
|
|
if ((error = v7fs_superblock_writeback(fs))) {
|
|
if (errno == EROFS) {
|
|
warnx("Overwriting disk label? ");
|
|
}
|
|
warnx("Can't write superblock sector.");
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
static int
|
|
make_root(struct v7fs_self *fs)
|
|
{
|
|
struct v7fs_inode inode;
|
|
struct v7fs_dirent *dir;
|
|
int error;
|
|
|
|
/* INO 1 badblk (don't used) */
|
|
memset(&inode, 0, sizeof(inode));
|
|
inode.inode_number = 1;
|
|
inode.mode = V7FS_IFREG; /* V7 manner */
|
|
v7fs_inode_writeback(fs, &inode);
|
|
|
|
/* INO 2 root */
|
|
v7fs_ino_t ino;
|
|
if ((error = v7fs_inode_allocate(fs, &ino))) {
|
|
errno = error;
|
|
warn("Can't allocate / inode");
|
|
return error;
|
|
}
|
|
|
|
memset(&inode, 0, sizeof(inode));
|
|
inode.inode_number = ino;
|
|
inode.mode = 0777 | V7FS_IFDIR;
|
|
inode.uid = 0;
|
|
inode.gid = 0;
|
|
inode.nlink = 2; /* . + .. */
|
|
inode.atime = inode.mtime = inode.ctime = time(0);
|
|
|
|
/* root dirent. */
|
|
v7fs_datablock_expand(fs, &inode, sizeof(*dir) * 2);
|
|
v7fs_daddr_t blk = inode.addr[0];
|
|
void *buf;
|
|
if (!(buf = scratch_read(fs, blk))) {
|
|
v7fs_inode_deallocate(fs, ino);
|
|
errno = error = EIO;
|
|
warn("Can't read / dirent.");
|
|
return error;
|
|
}
|
|
dir = (struct v7fs_dirent *)buf; /*disk endian */
|
|
|
|
strcpy(dir[0].name, ".");
|
|
dir[0].inode_number = V7FS_VAL16(fs, ino);
|
|
strcpy(dir[1].name, "..");
|
|
dir[1].inode_number = V7FS_VAL16(fs, ino);
|
|
if (!fs->io.write(fs->io.cookie, buf, blk)) {/*writeback */
|
|
scratch_free(fs, buf);
|
|
errno = error = EIO;
|
|
warn("Can't write / dirent.");
|
|
return error;
|
|
}
|
|
scratch_free(fs, buf);
|
|
v7fs_inode_writeback(fs, &inode);
|
|
if ((error = v7fs_superblock_writeback(fs))) {
|
|
errno = error;
|
|
warnx("Can't write superblock.");
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
static v7fs_daddr_t
|
|
make_freeblocklist(struct v7fs_self *fs, v7fs_daddr_t listblk, uint8_t *buf)
|
|
{
|
|
uint32_t (*val32)(uint32_t) = fs->val.conv32;
|
|
uint16_t (*val16)(uint16_t) = fs->val.conv16;
|
|
struct v7fs_freeblock *fb = (struct v7fs_freeblock *)buf;
|
|
int i, j, k;
|
|
|
|
memset(buf, 0, V7FS_BSIZE);
|
|
|
|
for (i = V7FS_MAX_FREEBLOCK - 1, j = listblk + 1, k = 0; i >= 0;
|
|
i--, j++, k++) {
|
|
progress(0);
|
|
if (j == (int32_t)fs->superblock.volume_size)
|
|
{
|
|
VPRINTF(4, "\nlast freeblock #%d\n",
|
|
(*val32)(fb->freeblock[i + 1]));
|
|
|
|
memmove(fb->freeblock + 1, fb->freeblock + i + 1, k *
|
|
sizeof(v7fs_daddr_t));
|
|
fb->freeblock[0] = 0; /* Terminate link; */
|
|
fb->nfreeblock = (*val16)(k + 1);
|
|
VPRINTF(4, "last freeblock contains #%d\n",
|
|
(*val16)(fb->nfreeblock));
|
|
fs->io.write(fs->io.cookie, buf, listblk);
|
|
return 0;
|
|
}
|
|
fb->freeblock[i] = (*val32)(j);
|
|
}
|
|
fb->nfreeblock = (*val16)(k);
|
|
|
|
if (!fs->io.write(fs->io.cookie, buf, listblk)) {
|
|
errno = EIO;
|
|
warn("blk=%ld", (long)listblk);
|
|
return 0;
|
|
}
|
|
|
|
/* Return next link block */
|
|
return (*val32)(fb->freeblock[0]);
|
|
}
|
|
|
|
static int
|
|
make_filesystem(struct v7fs_self *fs, v7fs_daddr_t volume_size,
|
|
v7fs_daddr_t ilist_size)
|
|
{
|
|
struct v7fs_superblock *sb;
|
|
v7fs_daddr_t blk;
|
|
uint8_t buf[V7FS_BSIZE];
|
|
int error = 0;
|
|
int32_t i, j;
|
|
|
|
/* Setup ilist. (ilist must be zero filled. becuase of they are free) */
|
|
VPRINTF(4, "Zero clear ilist.\n");
|
|
progress(&(struct progress_arg){ .label = "zero ilist", .tick =
|
|
ilist_size / PROGRESS_BAR_GRANULE });
|
|
memset(buf, 0, sizeof buf);
|
|
for (i = V7FS_ILIST_SECTOR; i < (int32_t)ilist_size; i++) {
|
|
fs->io.write(fs->io.cookie, buf, i);
|
|
progress(0);
|
|
}
|
|
#ifndef HAVE_NBTOOL_CONFIG_H
|
|
progress_done();
|
|
#endif
|
|
VPRINTF(4, "\n");
|
|
|
|
/* Construct superblock */
|
|
sb = &fs->superblock;
|
|
sb->volume_size = volume_size;
|
|
sb->datablock_start_sector = ilist_size + V7FS_ILIST_SECTOR;
|
|
sb->update_time = time(NULL);
|
|
|
|
/* fill free inode cache. */
|
|
VPRINTF(4, "Setup inode cache.\n");
|
|
sb->nfreeinode = V7FS_MAX_FREEINODE;
|
|
for (i = V7FS_MAX_FREEINODE - 1, j = V7FS_ROOT_INODE; i >= 0; i--, j++)
|
|
sb->freeinode[i] = j;
|
|
sb->total_freeinode = ilist_size * V7FS_INODE_PER_BLOCK - 1;
|
|
|
|
/* fill free block cache. */
|
|
VPRINTF(4, "Setup free block cache.\n");
|
|
sb->nfreeblock = V7FS_MAX_FREEBLOCK;
|
|
for (i = V7FS_MAX_FREEBLOCK - 1, j = sb->datablock_start_sector; i >= 0;
|
|
i--, j++)
|
|
sb->freeblock[i] = j;
|
|
|
|
sb->total_freeblock = volume_size - sb->datablock_start_sector;
|
|
|
|
/* Write superblock. */
|
|
sb->modified = 1;
|
|
if ((error = v7fs_superblock_writeback(fs))) {
|
|
errno = error;
|
|
warn("Can't write back superblock.");
|
|
return error;
|
|
}
|
|
|
|
/* Construct freeblock list */
|
|
VPRINTF(4, "Setup whole freeblock list.\n");
|
|
progress(&(struct progress_arg){ .label = "freeblock list", .tick =
|
|
(volume_size - sb->datablock_start_sector) / PROGRESS_BAR_GRANULE});
|
|
blk = sb->freeblock[0];
|
|
while ((blk = make_freeblocklist(fs, blk, buf)))
|
|
continue;
|
|
#ifndef HAVE_NBTOOL_CONFIG_H
|
|
progress_done();
|
|
#endif
|
|
|
|
VPRINTF(4, "done.\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
v7fs_newfs(const struct v7fs_mount_device *mount, int32_t maxfile)
|
|
{
|
|
struct v7fs_self *fs;
|
|
v7fs_daddr_t ilist_size;
|
|
int error;
|
|
v7fs_daddr_t volume_size = mount->sectors;
|
|
|
|
/* Check and determine ilistblock, datablock size. */
|
|
if (volume_size > V7FS_DADDR_MAX + 1) {
|
|
warnx("volume size %d over v7fs limit %d. truncated.",
|
|
volume_size, V7FS_DADDR_MAX + 1);
|
|
volume_size = V7FS_DADDR_MAX + 1;
|
|
}
|
|
|
|
ilist_size = determine_ilist_size(volume_size, maxfile);
|
|
|
|
VPRINTF(1, "volume size=%d, ilist size=%d, endian=%d, NAME_MAX=%d\n",
|
|
volume_size, ilist_size, mount->endian, V7FS_NAME_MAX);
|
|
|
|
/* Setup I/O ops. */
|
|
if ((error = v7fs_io_init(&fs, mount, V7FS_BSIZE))) {
|
|
errno = error;
|
|
warn("I/O setup failed.");
|
|
return error;
|
|
}
|
|
fs->endian = mount->endian;
|
|
v7fs_endian_init(fs);
|
|
|
|
if ((error = partition_check(fs))) {
|
|
return error;
|
|
}
|
|
|
|
/* Construct filesystem. */
|
|
if ((error = make_filesystem(fs, volume_size, ilist_size))) {
|
|
return error;
|
|
}
|
|
|
|
/* Setup root. */
|
|
if ((error = make_root(fs))) {
|
|
return error;
|
|
}
|
|
|
|
v7fs_io_fini(fs);
|
|
|
|
return 0;
|
|
}
|