Attachment #35289 for bug #57018

View | Details | Raw Unified | Return to bug 57018
Collapse All | Expand All

Lines 11-16 Link Here

(-)sbin/growfs/Makefile (+2 lines)
11	PROG= growfs	11	PROG= growfs
12	SRCS= growfs.c	12	SRCS= growfs.c
13	MAN= growfs.8	13	MAN= growfs.8
		14	DPADD= ${LIBUFS}
		15	LDADD= -lufs
14		16
15	WARNS?= 0	17	WARNS?= 0
16		18




#endif /* not lint */

/* ********************************************************** INCLUDES ***** */
#include <sys/types.h>
#include <sys/param.h>
#include <sys/disklabel.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/disk.h>


#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ufs/ufs/ufsmount.h>
#include <ufs/ufs/dinode.h>
#include <ufs/ffs/fs.h>
#include <libufs.h>

#include "debug.h"


int	_dbg_lvl_ = (DL_INFO);	/* DL_TRC */
#endif /* FS_DEBUG */

struct uufsd disk;

static union {
	struct fs	fs;
	char	pad[SBLOCKSIZE];
} fsun1;
#define fsun2	disk.d_sbunion
#define	sblock	disk.d_fs	/* the new superblock */
#define	osblock	fsun1.fs	/* the old superblock */
/*
 * Possible superblock locations ordered from most to least likely.
 */
static int sblock_try[] = SBLOCKSEARCH;
static ufs2_daddr_t sblockloc;

static union {
	struct cg	cg;

static char		inobuf[MAXBSIZE];	/* inode block */
static int		maxino;			/* last valid inode */
static int		unlabeled;     /* unlabeled partition, e.g. vinum volume etc. */
static int		Nflag;

/*
 * An array of elements of type struct gfs_bpp describes all blocks to

};

/* ******************************************************** PROTOTYPES ***** */
static void	growfs(void);
static void	rdfs(ufs2_daddr_t, size_t, void *);
static void	wtfs(ufs2_daddr_t, size_t, void *);
static ufs2_daddr_t alloc(void);
static int	charsperline(void);
static void	usage(void);
static int	isblock(struct fs *, unsigned char *, int);
static void	clrblock(struct fs *, unsigned char *, int);
static void	setblock(struct fs *, unsigned char *, int);
static void	initcg(int, time_t);
static void	updjcg(int, time_t);
static void	updcsloc(time_t);
static struct disklabel	*get_disklabel(int);
static void	return_disklabel(int, struct disklabel *);
static union dinode *ginode(ino_t, int);
static void	frag_adjust(ufs2_daddr_t, int);
static int	cond_bl_upd(ufs2_daddr_t *, struct gfs_bpp *);
		    unsigned int);
static void	updclst(int);
static void	updrefs(int, ino_t, struct gfs_bpp *);
static void	indirchk(ufs_lbn_t, ufs_lbn_t, ufs2_daddr_t, ufs_lbn_t,
		    struct gfs_bpp *);
static void	get_dev_size(int, int *);

/* ************************************************************ growfs ***** */

 * copies.
 */
static void
growfs(void)
{
	DBG_FUNC("growfs")
	int	i;

	for (i = 0; i < osblock.fs_cssize; i += osblock.fs_bsize) {
		rdfs(fsbtodb(&osblock, osblock.fs_csaddr +
		    numfrags(&osblock, i)), (size_t)MIN(osblock.fs_cssize - i,
		    osblock.fs_bsize), (void *)(((char *)fscs)+i));
	}

#ifdef FS_DEBUG

	/*
	 * Do all needed changes in the former last cylinder group.
	 */
	updjcg(osblock.fs_ncg-1, utime);

	/*
	 * Dump out summary information about file system.

	 * Iterate for only the new cylinder groups.
	 */
	for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {
		initcg(cylno, utime);
		j = sprintf(tmpbuf, " %d%s",
		    (int)fsbtodb(&sblock, cgsblock(&sblock, cylno)),
		    cylno < (sblock.fs_ncg-1) ? "," : "" );

	 * Do all needed changes in the first cylinder group.
	 * allocate blocks in new location
	 */
	updcsloc(utime);

	/*
	 * Now write the cylinder summary back to disk.

	for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
		wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
		    (size_t)MIN(sblock.fs_cssize - i, sblock.fs_bsize),
		    (void *)(((char *)fscs) + i));
	}
	DBG_PRINT0("fscs written\n");


	 * Now write the new superblock back to disk.
	 */
	sblock.fs_time = utime;
	if (Nflag == 0 && sbwrite(&disk, 0) == -1)
		err(1, "sbwrite: %s", disk.d_error);
	DBG_PRINT0("sblock written\n");
	DBG_DUMP_FS(&sblock,
	    "new initial sblock");

	 */
	for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
		wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
		    (size_t)SBLOCKSIZE, (void *)&sblock);
	}
	DBG_PRINT0("sblock copies written\n");
	DBG_DUMP_FS(&sblock,

 * provisions for that case are removed here.
 */
static void
initcg(int cylno, time_t utime)
{
	DBG_FUNC("initcg")
	static caddr_t iobuf;
	long i, d, dlower, dupper, blkno, start;
	ufs2_daddr_t cbase, dmax;
	struct ufs1_dinode *dp1;
	struct ufs2_dinode *dp2;

			}
#endif
		wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
		    sblock.fs_bsize, iobuf);
	}
	if (cylno > 0) {
		/*

	sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
	*cs = acg.cg_cs;
	wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
		sblock.fs_bsize, (char *)&acg);
	DBG_DUMP_CG(&sblock,
	    "new cg",
	    &acg);

 * out if a write back operation is needed.
 */
static int
cond_bl_upd(ufs2_daddr_t *block, struct gfs_bpp *field)
    unsigned int Nflag)
{
	DBG_FUNC("cond_bl_upd")
	struct gfs_bpp *f;

		if (!ibuf)
			errx(1, "malloc failed");
		src -= fragnum;
		rdfs(fsbtodb(&sblock, src), (size_t)sblock.fs_bsize, ibuf);
		wtfs(dst, (size_t)sblock.fs_bsize, ibuf);
		free(ibuf);
		/*
		 * The same block can't be found again in this loop.

 * tables and cluster summary during all those operations.
 */
static void
updjcg(int cylno, time_t utime)
{
	DBG_FUNC("updjcg")
	ufs2_daddr_t	cbase, dmax, dupper;

	 * a copy.
	 */
	rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)),
	    (size_t)osblock.fs_cgsize, (void *)&aocg);
	DBG_PRINT0("jcg read\n");
	DBG_DUMP_CG(&sblock,
	    "old joining cg",

			acg.cg_old_ncyl=sblock.fs_old_cpg;

		wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
		    (size_t)sblock.fs_cgsize, (void *)&acg);
		DBG_PRINT0("jcg written\n");
		DBG_DUMP_CG(&sblock,
		    "new joining cg",

	 * Write the updated "joining" cylinder group back to disk.
	 */
	wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,
	    (void *)&acg);
	DBG_PRINT0("jcg written\n");
	DBG_DUMP_CG(&sblock,
	    "new joining cg",

 * completely avoid implementing copy on write if we stick to method (2) only.
 */
static void
updcsloc(time_t utime)
{
	DBG_FUNC("updcsloc")
	struct csum	*cs;

	 *	block from disk.
	 */
	rdfs(fsbtodb(&osblock, cgtod(&osblock, ocscg)),
	    (size_t)osblock.fs_cgsize, (void *)&aocg);
	DBG_PRINT0("oscg read\n");
	DBG_DUMP_CG(&sblock,
	    "old summary cg",

		 * summary back to disk.
		 */
		wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)),
		    (size_t)sblock.fs_cgsize, (void *)&acg);
		DBG_PRINT0("oscg written\n");
		DBG_DUMP_CG(&sblock,
		    "old summary cg",

		 * summary from disk, and make a copy.
		 */
		rdfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
		    (size_t)sblock.fs_cgsize, (void *)&aocg);
		DBG_PRINT0("nscg read\n");
		DBG_DUMP_CG(&sblock,
		    "new summary cg",

		 * back to disk.
		 */
		wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
		    (size_t)sblock.fs_cgsize, (void *)&acg);
		DBG_PRINT0("nscg written\n");
		DBG_DUMP_CG(&sblock,
		    "new summary cg",

			 *	in the case we have any active snapshots.
			 */
			rdfs(fsbtodb(&sblock, bp[i].old*sblock.fs_frag),
			    (size_t)sblock.fs_bsize, (void *)&ablk);
			wtfs(fsbtodb(&sblock, bp[i].new*sblock.fs_frag),
			    (size_t)sblock.fs_bsize, (void *)&ablk);
			DBG_DUMP_HEX(&sblock,
			    "copied full block",
			    (unsigned char *)&ablk);

			DBG_PRINT1("scg doing cg (%d)\n",
			    cylno);
			for(inc=osblock.fs_ipg-1 ; inc>=0 ; inc--) {
				updrefs(cylno, (ino_t)inc, bp);
			}
		}


		 */
		for(i=0; i<ind; i++) {
			if(!bp[i].found || (bp[i].found>sblock.fs_frag)) {
				warnx("error: %d refs found for block %jd.",
				    bp[i].found, bp[i].old);
			}


	 * Write summary cylinder group back to disk.
	 */
	wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)), (size_t)sblock.fs_cgsize,
	    (void *)&acg);
	DBG_PRINT0("scg written\n");
	DBG_DUMP_CG(&sblock,
	    "new summary cg",

 * Here we read some block(s) from disk.
 */
static void
rdfs(ufs2_daddr_t bno, size_t size, void *bf)
{
	DBG_FUNC("rdfs")
	ssize_t	n;

	DBG_ENTER;

	if (bread(&disk, bno, bf, size) == -1)
		err(1, "rdfs: read error: %ld: %s", (long)bno, disk.d_error);
	}
	n = read(fsi, bf, size);
	if (n != (ssize_t)size) {
		err(34, "rdfs: read error: %ld", (long)bno);
	}

	DBG_LEAVE;
	return;

 * Here we write some block(s) to disk.
 */
static void
wtfs(ufs2_daddr_t bno, size_t size, void *bf)
{
	DBG_FUNC("wtfs")
	ssize_t	n;

	DBG_ENTER;


		DBG_LEAVE;
		return;
	}

	if (bwrite(&disk, bno, bf, size) == -1)
		err(35, "wtfs: write error: %ld: %s", (long)bno, disk.d_error);
	n = write(fso, bf, size);
	if (n != (ssize_t)size) {
		err(36, "wtfs: write error: %ld", (long)bno);
	}

	DBG_LEAVE;
	return;

 * inodes.
 */
static union dinode *
ginode(ino_t inumber, int cg)
{
	DBG_FUNC("ginode")
	static ino_t	startinum = 0;	/* first inode in cached block */

	if (startinum == 0 ||
	    inumber < startinum || inumber >= startinum + INOPB(&sblock)) {
		inoblk = fsbtodb(&sblock, ino_to_fsba(&sblock, inumber));
		rdfs(inoblk, (size_t)sblock.fs_bsize, inobuf);
		startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
	}
	DBG_LEAVE;

	char	ch;
	unsigned int	size=0;
	size_t	len;
	unsigned int	Nflag=0;
	int	ExpertFlag=0;
	struct stat	st;
	struct disklabel	*lp;
	struct partition	*pp;
	int	i,fsi,fso;
    u_int32_t p_size;
	char	reply[5];
#ifdef FSMAXSNAP

	}

	/*
	 * Try to access our device read/write.
	 */
	if (Nflag) {
		fso = -1;
	} else {
		fso = open(device, O_WRONLY);
		if (fso < 0) {
			err(1, "%s", device);
		}
	}

	/*
	 * ... and reading.
	 */
	if (ufs_disk_fillout(&disk, device) == -1)
		err(1, "ufs_disk_fillout: %s", disk.d_error);
	if (ufs_disk_write(&disk) == -1)
		err(1, "ufs_disk_write: %s", disk.d_error);

	/*
	 * Try to read a label and guess the slice if not specified. This

	 * with the task of specifying the option -v on vinum volumes.
	 */
	cp=device+strlen(device)-1;
	lp = get_disklabel(disk.d_fd);
    if (lp != NULL) {
        if (isdigit(*cp)) {
            pp = &lp->d_partitions[2];

        }
        p_size = pp->p_size;
    } else {
        get_dev_size(disk.d_fd, &p_size);
    }

	/*

	}

	/*
	 * Take a backup of the superblock.
	 */
	for (i = 0; sblock_try[i] != -1; i++) {
		sblockloc = sblock_try[i] / DEV_BSIZE;
		rdfs(sblockloc, (size_t)SBLOCKSIZE, (void *)&(osblock), fsi);
		if ((osblock.fs_magic == FS_UFS1_MAGIC ||
		     (osblock.fs_magic == FS_UFS2_MAGIC &&
		      osblock.fs_sblockloc == sblock_try[i])) &&
		    osblock.fs_bsize <= MAXBSIZE &&
		    osblock.fs_bsize >= sizeof(struct fs))
			break;
	}
	if (sblock_try[i] == -1) {
		errx(1, "superblock not recognized");
	}
	memcpy((void *)&fsun1, (void *)&fsun2, sizeof(fsun2));
	maxino = sblock.fs_ncg * sblock.fs_ipg;


	 * Are we really growing ?
	 */
	if(osblock.fs_size >= sblock.fs_size) {
		errx(1, "we are not growing (%jd->%jd)", osblock.fs_size,
		    sblock.fs_size);
	}


		}
	}

	printf("new file system size is: %jd frags\n", sblock.fs_size);

	/*
	 * Try to access our new last block in the file system. Even if we
	 * later on realize we have to abort our operation, on that block
	 * there should be no data, so we can't destroy something yet.
	 */
	wtfs((ufs2_daddr_t)p_size-1, (size_t)DEV_BSIZE, (void *)&sblock);
	    fso, Nflag);

	/*
	 * Now calculate new superblock values and check for reasonable

		sblock.fs_ncg--;
		if (sblock.fs_magic == FS_UFS1_MAGIC)
			sblock.fs_old_ncyl = sblock.fs_ncg * sblock.fs_old_cpg;
		printf("Warning: %jd sector(s) cannot be allocated.\n",
		    fsbtodb(&sblock, sblock.fs_size % sblock.fs_fpg));
		sblock.fs_size = sblock.fs_ncg * sblock.fs_fpg;
	}

	/*
	 * Ok, everything prepared, so now let's do the tricks.
	 */
	growfs();

	/*
	 * Update the disk label.

        pp->p_frag = sblock.fs_frag;
        pp->p_cpg = sblock.fs_fpg;

        return_disklabel(disk.d_fd, lp);
        DBG_PRINT0("label rewritten\n");
    }

	ufs_disk_close(&disk);
	if(fso>-1) close(fso);

	DBG_CLOSE;


 * Write the updated disklabel back to disk.
 */
static void
return_disklabel(int fd, struct disklabel *lp)
{
	DBG_FUNC("return_disklabel")
	u_short	sum;

 * cylinder group.
 */
static void
updrefs(int cg, ino_t in, struct gfs_bpp *bp)
    Nflag)
{
	DBG_FUNC("updrefs")
	ufs_lbn_t	len, lbn, numblks;
	ufs2_daddr_t	iptr, blksperindir;
	union dinode	*ino;
	int		i, mode, inodeupdated;

	DBG_ENTER;


	 * XXX We should skip unused inodes even from being read from disk
	 *     here by using the bitmap.
	 */
	ino = ginode(in, cg);
	mode = DIP(ino, di_mode) & IFMT;
	if (mode != IFDIR && mode != IFREG && mode != IFLNK) {
		DBG_LEAVE;

		iptr = DIP(ino, di_db[i]);
		if (iptr == 0)
			continue;
		if (cond_bl_upd(&iptr, bp)) {
			DIP(ino, di_db[i]) = iptr;
			inodeupdated++;
		}

		iptr = DIP(ino, di_ib[i]);
		if (iptr == 0)
			continue;
		if (cond_bl_upd(&iptr, bp)) {
			DIP(ino, di_ib[i]) = iptr;
			inodeupdated++;
		}
		indirchk(blksperindir, lbn, iptr, numblks, bp);
		blksperindir *= NINDIR(&sblock);
		lbn += blksperindir;
		len -= blksperindir;
		DBG_PRINT1("scg indirect_%d blocks checked\n", i + 1);
	}
	if (inodeupdated)
		wtfs(inoblk, sblock.fs_bsize, inobuf);

	DBG_LEAVE;
	return;

 */
static void
indirchk(ufs_lbn_t blksperindir, ufs_lbn_t lbn, ufs2_daddr_t blkno,
    ufs_lbn_t lastlbn, struct gfs_bpp *bp)
{
	DBG_FUNC("indirchk")
	void *ibuf;
	off_t offset;
	int i, last;
	ufs2_daddr_t iptr;


	ibuf = malloc(sblock.fs_bsize);
	if (!ibuf)
		errx(1, "malloc failed");
	rdfs(fsbtodb(&sblock, blkno), (size_t)sblock.fs_bsize, ibuf);
	last = howmany(lastlbn - lbn, blksperindir) < NINDIR(&sblock) ?
	    howmany(lastlbn - lbn, blksperindir) : NINDIR(&sblock);
	for (i = 0; i < last; i++) {

			iptr = ((ufs2_daddr_t *)ibuf)[i];
		if (iptr == 0)
			continue;
		if (cond_bl_upd(&iptr, bp)) {
			if (sblock.fs_magic == FS_UFS1_MAGIC)
				((ufs1_daddr_t *)ibuf)[i] = iptr;
			else

		if (blksperindir == 1)
			continue;
		indirchk(blksperindir / NINDIR(&sblock), lbn + blksperindir * i,
		    iptr, lastlbn, bp);
	}
	free(ibuf);

Return to bug 57018