blob: 01b30c5f1b15ca9ada9b87410aed1c88f62856ca [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
* All Rights Reserved.
*/
#include "libxfs.h"
#include <sys/stat.h>
#include "libfrog/convert.h"
/*
* Prototypes for internal functions.
*/
static char *getstr(char **pp);
static void fail(char *msg, int i);
static struct xfs_trans * getres(struct xfs_mount *mp, uint blocks);
static void rsvfile(xfs_mount_t *mp, xfs_inode_t *ip, long long len);
static int newfile(xfs_trans_t *tp, xfs_inode_t *ip, int symlink, int logit,
char *buf, int len);
static char *newregfile(char **pp, int *len);
static void rtinit(xfs_mount_t *mp);
static long filesize(int fd);
/*
* Use this for block reservations needed for mkfs's conditions
* (basically no fragmentation).
*/
#define MKFS_BLOCKRES_INODE \
((uint)(M_IGEO(mp)->ialloc_blks + (M_IGEO(mp)->inobt_maxlevels - 1)))
#define MKFS_BLOCKRES(rb) \
((uint)(MKFS_BLOCKRES_INODE + XFS_DA_NODE_MAXDEPTH + \
(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 1) + (rb)))
static long long
getnum(
const char *str,
unsigned int blksize,
unsigned int sectsize,
bool convert)
{
long long i;
char *sp;
if (convert)
return cvtnum(blksize, sectsize, str);
i = strtoll(str, &sp, 0);
if (i == 0 && sp == str)
return -1LL;
if (*sp != '\0')
return -1LL; /* trailing garbage */
return i;
}
char *
setup_proto(
char *fname)
{
char *buf = NULL;
static char dflt[] = "d--755 0 0 $";
int fd;
long size;
if (!fname)
return dflt;
if ((fd = open(fname, O_RDONLY)) < 0 || (size = filesize(fd)) < 0) {
fprintf(stderr, _("%s: failed to open %s: %s\n"),
progname, fname, strerror(errno));
goto out_fail;
}
buf = malloc(size + 1);
if (read(fd, buf, size) < size) {
fprintf(stderr, _("%s: read failed on %s: %s\n"),
progname, fname, strerror(errno));
goto out_fail;
}
if (buf[size - 1] != '\n') {
fprintf(stderr, _("%s: proto file %s premature EOF\n"),
progname, fname);
goto out_fail;
}
buf[size] = '\0';
/*
* Skip past the stuff there for compatibility, a string and 2 numbers.
*/
(void)getstr(&buf); /* boot image name */
(void)getnum(getstr(&buf), 0, 0, false); /* block count */
(void)getnum(getstr(&buf), 0, 0, false); /* inode count */
close(fd);
return buf;
out_fail:
if (fd >= 0)
close(fd);
free(buf);
exit(1);
}
static void
fail(
char *msg,
int i)
{
fprintf(stderr, "%s: %s [%d - %s]\n", progname, msg, i, strerror(i));
exit(1);
}
void
res_failed(
int i)
{
fail(_("cannot reserve space"), i);
}
static struct xfs_trans *
getres(
struct xfs_mount *mp,
uint blocks)
{
struct xfs_trans *tp;
int i;
uint r;
for (i = 0, r = MKFS_BLOCKRES(blocks); r >= blocks; r--) {
i = -libxfs_trans_alloc_rollable(mp, r, &tp);
if (i == 0)
return tp;
}
res_failed(i);
/* NOTREACHED */
return NULL;
}
static char *
getstr(
char **pp)
{
char c;
char *p;
char *rval;
p = *pp;
while ((c = *p)) {
switch (c) {
case ' ':
case '\t':
case '\n':
p++;
continue;
case ':':
p++;
while (*p++ != '\n')
;
continue;
default:
rval = p;
while (c != ' ' && c != '\t' && c != '\n' && c != '\0')
c = *++p;
*p++ = '\0';
*pp = p;
return rval;
}
}
if (c != '\0') {
fprintf(stderr, _("%s: premature EOF in prototype file\n"),
progname);
exit(1);
}
return NULL;
}
static void
rsvfile(
xfs_mount_t *mp,
xfs_inode_t *ip,
long long llen)
{
int error;
xfs_trans_t *tp;
error = -libxfs_alloc_file_space(ip, 0, llen, 1, 0);
if (error) {
fail(_("error reserving space for a file"), error);
exit(1);
}
/*
* update the inode timestamp, mode, and prealloc flag bits
*/
error = -libxfs_trans_alloc_rollable(mp, 0, &tp);
if (error)
fail(_("allocating transaction for a file"), error);
libxfs_trans_ijoin(tp, ip, 0);
VFS_I(ip)->i_mode &= ~S_ISUID;
/*
* Note that we don't have to worry about mandatory
* file locking being disabled here because we only
* clear the S_ISGID bit if the Group execute bit is
* on, but if it was on then mandatory locking wouldn't
* have been enabled.
*/
if (VFS_I(ip)->i_mode & S_IXGRP)
VFS_I(ip)->i_mode &= ~S_ISGID;
libxfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
libxfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
error = -libxfs_trans_commit(tp);
if (error)
fail(_("committing space for a file failed"), error);
}
static int
newfile(
xfs_trans_t *tp,
xfs_inode_t *ip,
int symlink,
int logit,
char *buf,
int len)
{
xfs_buf_t *bp;
xfs_daddr_t d;
int error;
int flags;
xfs_bmbt_irec_t map;
xfs_mount_t *mp;
xfs_extlen_t nb;
int nmap;
flags = 0;
mp = ip->i_mount;
if (symlink && len <= XFS_IFORK_DSIZE(ip)) {
libxfs_init_local_fork(ip, XFS_DATA_FORK, buf, len);
ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
flags = XFS_ILOG_DDATA;
} else if (len > 0) {
nb = XFS_B_TO_FSB(mp, len);
nmap = 1;
error = -libxfs_bmapi_write(tp, ip, 0, nb, 0, nb, &map, &nmap);
if (error) {
fail(_("error allocating space for a file"), error);
}
if (nmap != 1) {
fprintf(stderr,
_("%s: cannot allocate space for file\n"),
progname);
exit(1);
}
d = XFS_FSB_TO_DADDR(mp, map.br_startblock);
error = -libxfs_trans_get_buf(logit ? tp : NULL, mp->m_dev, d,
nb << mp->m_blkbb_log, 0, &bp);
if (error) {
fprintf(stderr,
_("%s: cannot allocate buffer for file\n"),
progname);
exit(1);
}
memmove(bp->b_addr, buf, len);
if (len < bp->b_bcount)
memset((char *)bp->b_addr + len, 0, bp->b_bcount - len);
if (logit)
libxfs_trans_log_buf(tp, bp, 0, bp->b_bcount - 1);
else {
libxfs_buf_mark_dirty(bp);
libxfs_buf_relse(bp);
}
}
ip->i_d.di_size = len;
return flags;
}
static char *
newregfile(
char **pp,
int *len)
{
char *buf;
int fd;
char *fname;
long size;
fname = getstr(pp);
if ((fd = open(fname, O_RDONLY)) < 0 || (size = filesize(fd)) < 0) {
fprintf(stderr, _("%s: cannot open %s: %s\n"),
progname, fname, strerror(errno));
exit(1);
}
if ((*len = (int)size)) {
buf = malloc(size);
if (read(fd, buf, size) < size) {
fprintf(stderr, _("%s: read failed on %s: %s\n"),
progname, fname, strerror(errno));
exit(1);
}
} else
buf = NULL;
close(fd);
return buf;
}
static void
newdirent(
xfs_mount_t *mp,
xfs_trans_t *tp,
xfs_inode_t *pip,
struct xfs_name *name,
xfs_ino_t inum)
{
int error;
int rsv;
rsv = XFS_DIRENTER_SPACE_RES(mp, name->len);
error = -libxfs_dir_createname(tp, pip, name, inum, rsv);
if (error)
fail(_("directory createname error"), error);
}
static void
newdirectory(
xfs_mount_t *mp,
xfs_trans_t *tp,
xfs_inode_t *dp,
xfs_inode_t *pdp)
{
int error;
error = -libxfs_dir_init(tp, dp, pdp);
if (error)
fail(_("directory create error"), error);
}
static void
parseproto(
xfs_mount_t *mp,
xfs_inode_t *pip,
struct fsxattr *fsxp,
char **pp,
char *name)
{
#define IF_REGULAR 0
#define IF_RESERVED 1
#define IF_BLOCK 2
#define IF_CHAR 3
#define IF_DIRECTORY 4
#define IF_SYMLINK 5
#define IF_FIFO 6
char *buf;
int error;
int flags;
int fmt;
int i;
xfs_inode_t *ip;
int len;
long long llen;
int majdev;
int mindev;
int mode;
char *mstr;
xfs_trans_t *tp;
int val;
int isroot = 0;
cred_t creds;
char *value;
struct xfs_name xname;
memset(&creds, 0, sizeof(creds));
mstr = getstr(pp);
switch (mstr[0]) {
case '-':
fmt = IF_REGULAR;
break;
case 'r':
fmt = IF_RESERVED;
break;
case 'b':
fmt = IF_BLOCK;
break;
case 'c':
fmt = IF_CHAR;
break;
case 'd':
fmt = IF_DIRECTORY;
break;
case 'l':
fmt = IF_SYMLINK;
break;
case 'p':
fmt = IF_FIFO;
break;
default:
fprintf(stderr, _("%s: bad format string %s\n"),
progname, mstr);
exit(1);
}
mode = 0;
switch (mstr[1]) {
case '-':
break;
case 'u':
mode |= S_ISUID;
break;
default:
fprintf(stderr, _("%s: bad format string %s\n"),
progname, mstr);
exit(1);
}
switch (mstr[2]) {
case '-':
break;
case 'g':
mode |= S_ISGID;
break;
default:
fprintf(stderr, _("%s: bad format string %s\n"),
progname, mstr);
exit(1);
}
val = 0;
for (i = 3; i < 6; i++) {
if (mstr[i] < '0' || mstr[i] > '7') {
fprintf(stderr, _("%s: bad format string %s\n"),
progname, mstr);
exit(1);
}
val = val * 8 + mstr[i] - '0';
}
mode |= val;
creds.cr_uid = (int)getnum(getstr(pp), 0, 0, false);
creds.cr_gid = (int)getnum(getstr(pp), 0, 0, false);
xname.name = (unsigned char *)name;
xname.len = name ? strlen(name) : 0;
xname.type = 0;
flags = XFS_ILOG_CORE;
switch (fmt) {
case IF_REGULAR:
buf = newregfile(pp, &len);
tp = getres(mp, XFS_B_TO_FSB(mp, len));
error = -libxfs_inode_alloc(&tp, pip, mode|S_IFREG, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
flags |= newfile(tp, ip, 0, 0, buf, len);
if (buf)
free(buf);
libxfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_REG_FILE;
newdirent(mp, tp, pip, &xname, ip->i_ino);
break;
case IF_RESERVED: /* pre-allocated space only */
value = getstr(pp);
llen = getnum(value, mp->m_sb.sb_blocksize,
mp->m_sb.sb_sectsize, true);
if (llen < 0) {
fprintf(stderr,
_("%s: Bad value %s for proto file %s\n"),
progname, value, name);
exit(1);
}
tp = getres(mp, XFS_B_TO_FSB(mp, llen));
error = -libxfs_inode_alloc(&tp, pip, mode|S_IFREG, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode pre-allocation failed"), error);
libxfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_REG_FILE;
newdirent(mp, tp, pip, &xname, ip->i_ino);
libxfs_trans_log_inode(tp, ip, flags);
error = -libxfs_trans_commit(tp);
if (error)
fail(_("Space preallocation failed."), error);
rsvfile(mp, ip, llen);
libxfs_irele(ip);
return;
case IF_BLOCK:
tp = getres(mp, 0);
majdev = getnum(getstr(pp), 0, 0, false);
mindev = getnum(getstr(pp), 0, 0, false);
error = -libxfs_inode_alloc(&tp, pip, mode|S_IFBLK, 1,
IRIX_MKDEV(majdev, mindev), &creds, fsxp, &ip);
if (error) {
fail(_("Inode allocation failed"), error);
}
libxfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_BLKDEV;
newdirent(mp, tp, pip, &xname, ip->i_ino);
flags |= XFS_ILOG_DEV;
break;
case IF_CHAR:
tp = getres(mp, 0);
majdev = getnum(getstr(pp), 0, 0, false);
mindev = getnum(getstr(pp), 0, 0, false);
error = -libxfs_inode_alloc(&tp, pip, mode|S_IFCHR, 1,
IRIX_MKDEV(majdev, mindev), &creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
libxfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_CHRDEV;
newdirent(mp, tp, pip, &xname, ip->i_ino);
flags |= XFS_ILOG_DEV;
break;
case IF_FIFO:
tp = getres(mp, 0);
error = -libxfs_inode_alloc(&tp, pip, mode|S_IFIFO, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
libxfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_FIFO;
newdirent(mp, tp, pip, &xname, ip->i_ino);
break;
case IF_SYMLINK:
buf = getstr(pp);
len = (int)strlen(buf);
tp = getres(mp, XFS_B_TO_FSB(mp, len));
error = -libxfs_inode_alloc(&tp, pip, mode|S_IFLNK, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
flags |= newfile(tp, ip, 1, 1, buf, len);
libxfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_SYMLINK;
newdirent(mp, tp, pip, &xname, ip->i_ino);
break;
case IF_DIRECTORY:
tp = getres(mp, 0);
error = -libxfs_inode_alloc(&tp, pip, mode|S_IFDIR, 1, 0,
&creds, fsxp, &ip);
if (error)
fail(_("Inode allocation failed"), error);
inc_nlink(VFS_I(ip)); /* account for . */
if (!pip) {
pip = ip;
mp->m_sb.sb_rootino = ip->i_ino;
libxfs_log_sb(tp);
isroot = 1;
} else {
libxfs_trans_ijoin(tp, pip, 0);
xname.type = XFS_DIR3_FT_DIR;
newdirent(mp, tp, pip, &xname, ip->i_ino);
inc_nlink(VFS_I(pip));
libxfs_trans_log_inode(tp, pip, XFS_ILOG_CORE);
}
newdirectory(mp, tp, ip, pip);
libxfs_trans_log_inode(tp, ip, flags);
error = -libxfs_trans_commit(tp);
if (error)
fail(_("Directory inode allocation failed."), error);
/*
* RT initialization. Do this here to ensure that
* the RT inodes get placed after the root inode.
*/
if (isroot)
rtinit(mp);
tp = NULL;
for (;;) {
name = getstr(pp);
if (!name)
break;
if (strcmp(name, "$") == 0)
break;
parseproto(mp, ip, fsxp, pp, name);
}
libxfs_irele(ip);
return;
default:
ASSERT(0);
fail(_("Unknown format"), EINVAL);
}
libxfs_trans_log_inode(tp, ip, flags);
error = -libxfs_trans_commit(tp);
if (error) {
fail(_("Error encountered creating file from prototype file"),
error);
}
libxfs_irele(ip);
}
void
parse_proto(
xfs_mount_t *mp,
struct fsxattr *fsx,
char **pp)
{
parseproto(mp, NULL, fsx, pp, NULL);
}
/*
* Allocate the realtime bitmap and summary inodes, and fill in data if any.
*/
static void
rtinit(
xfs_mount_t *mp)
{
xfs_fileoff_t bno;
xfs_fileoff_t ebno;
xfs_bmbt_irec_t *ep;
int error;
int i;
xfs_bmbt_irec_t map[XFS_BMAP_MAX_NMAP];
xfs_extlen_t nsumblocks;
uint blocks;
int nmap;
xfs_inode_t *rbmip;
xfs_inode_t *rsumip;
xfs_trans_t *tp;
struct cred creds;
struct fsxattr fsxattrs;
/*
* First, allocate the inodes.
*/
i = -libxfs_trans_alloc_rollable(mp, MKFS_BLOCKRES_INODE, &tp);
if (i)
res_failed(i);
memset(&creds, 0, sizeof(creds));
memset(&fsxattrs, 0, sizeof(fsxattrs));
error = -libxfs_inode_alloc(&tp, NULL, S_IFREG, 1, 0,
&creds, &fsxattrs, &rbmip);
if (error) {
fail(_("Realtime bitmap inode allocation failed"), error);
}
/*
* Do our thing with rbmip before allocating rsumip,
* because the next call to ialloc() may
* commit the transaction in which rbmip was allocated.
*/
mp->m_sb.sb_rbmino = rbmip->i_ino;
rbmip->i_d.di_size = mp->m_sb.sb_rbmblocks * mp->m_sb.sb_blocksize;
rbmip->i_d.di_flags = XFS_DIFLAG_NEWRTBM;
*(uint64_t *)&VFS_I(rbmip)->i_atime = 0;
libxfs_trans_log_inode(tp, rbmip, XFS_ILOG_CORE);
libxfs_log_sb(tp);
mp->m_rbmip = rbmip;
error = -libxfs_inode_alloc(&tp, NULL, S_IFREG, 1, 0,
&creds, &fsxattrs, &rsumip);
if (error) {
fail(_("Realtime summary inode allocation failed"), error);
}
mp->m_sb.sb_rsumino = rsumip->i_ino;
rsumip->i_d.di_size = mp->m_rsumsize;
libxfs_trans_log_inode(tp, rsumip, XFS_ILOG_CORE);
libxfs_log_sb(tp);
error = -libxfs_trans_commit(tp);
if (error)
fail(_("Completion of the realtime summary inode failed"),
error);
mp->m_rsumip = rsumip;
/*
* Next, give the bitmap file some zero-filled blocks.
*/
blocks = mp->m_sb.sb_rbmblocks +
XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 1;
i = -libxfs_trans_alloc_rollable(mp, blocks, &tp);
if (i)
res_failed(i);
libxfs_trans_ijoin(tp, rbmip, 0);
bno = 0;
while (bno < mp->m_sb.sb_rbmblocks) {
nmap = XFS_BMAP_MAX_NMAP;
error = -libxfs_bmapi_write(tp, rbmip, bno,
(xfs_extlen_t)(mp->m_sb.sb_rbmblocks - bno),
0, mp->m_sb.sb_rbmblocks, map, &nmap);
if (error) {
fail(_("Allocation of the realtime bitmap failed"),
error);
}
for (i = 0, ep = map; i < nmap; i++, ep++) {
libxfs_device_zero(mp->m_ddev_targp,
XFS_FSB_TO_DADDR(mp, ep->br_startblock),
XFS_FSB_TO_BB(mp, ep->br_blockcount));
bno += ep->br_blockcount;
}
}
error = -libxfs_trans_commit(tp);
if (error)
fail(_("Block allocation of the realtime bitmap inode failed"),
error);
/*
* Give the summary file some zero-filled blocks.
*/
nsumblocks = mp->m_rsumsize >> mp->m_sb.sb_blocklog;
blocks = nsumblocks + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 1;
i = -libxfs_trans_alloc_rollable(mp, blocks, &tp);
if (i)
res_failed(i);
libxfs_trans_ijoin(tp, rsumip, 0);
bno = 0;
while (bno < nsumblocks) {
nmap = XFS_BMAP_MAX_NMAP;
error = -libxfs_bmapi_write(tp, rsumip, bno,
(xfs_extlen_t)(nsumblocks - bno),
0, nsumblocks, map, &nmap);
if (error) {
fail(_("Allocation of the realtime summary failed"),
error);
}
for (i = 0, ep = map; i < nmap; i++, ep++) {
libxfs_device_zero(mp->m_ddev_targp,
XFS_FSB_TO_DADDR(mp, ep->br_startblock),
XFS_FSB_TO_BB(mp, ep->br_blockcount));
bno += ep->br_blockcount;
}
}
error = -libxfs_trans_commit(tp);
if (error)
fail(_("Block allocation of the realtime summary inode failed"),
error);
/*
* Free the whole area using transactions.
* Do one transaction per bitmap block.
*/
for (bno = 0; bno < mp->m_sb.sb_rextents; bno = ebno) {
i = -libxfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate,
0, 0, 0, &tp);
if (i)
res_failed(i);
libxfs_trans_ijoin(tp, rbmip, 0);
ebno = XFS_RTMIN(mp->m_sb.sb_rextents,
bno + NBBY * mp->m_sb.sb_blocksize);
error = -libxfs_rtfree_extent(tp, bno, (xfs_extlen_t)(ebno-bno));
if (error) {
fail(_("Error initializing the realtime space"),
error);
}
error = -libxfs_trans_commit(tp);
if (error)
fail(_("Initialization of the realtime space failed"),
error);
}
}
static long
filesize(
int fd)
{
struct stat stb;
if (fstat(fd, &stb) < 0)
return -1;
return (long)stb.st_size;
}