/*
* Attempt to expand the size of a directory
*/
static int
expanddir(struct ufs1_dinode *dp, char *name)
{
ufs_daddr_t lastbn, newblk;
struct bufarea *bp;
char *cp, firstblk[DIRBLKSIZ];
lastbn = lblkno(&sblock, dp->di_size);
if (lastbn >= NDADDR - 1 || dp->di_db[lastbn] == 0 || dp->di_size == 0)
return (0);
if ((newblk = allocblk(sblock.fs_frag)) == 0)
return (0);
dp->di_db[lastbn + 1] = dp->di_db[lastbn];
dp->di_db[lastbn] = newblk;
dp->di_size += sblock.fs_bsize;
dp->di_blocks += btodb(sblock.fs_bsize);
bp = getdirblk(dp->di_db[lastbn + 1],
(long)dblksize(&sblock, dp, lastbn + 1));
if (bp->b_errs)
goto bad;
memmove(firstblk, bp->b_un.b_buf, DIRBLKSIZ);
bp = getdirblk(newblk, sblock.fs_bsize);
if (bp->b_errs)
goto bad;
memmove(bp->b_un.b_buf, firstblk, DIRBLKSIZ);
for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
cp < &bp->b_un.b_buf[sblock.fs_bsize];
cp += DIRBLKSIZ)
memmove(cp, &emptydir, sizeof emptydir);
dirty(bp);
bp = getdirblk(dp->di_db[lastbn + 1],
(long)dblksize(&sblock, dp, lastbn + 1));
if (bp->b_errs)
goto bad;
memmove(bp->b_un.b_buf, &emptydir, sizeof emptydir);
pwarn("NO SPACE LEFT IN %s", name);
if (preen)
printf(" (EXPANDED)\n");
else if (reply("EXPAND") == 0)
goto bad;
dirty(bp);
inodirty();
return (1);
bad:
dp->di_db[lastbn] = dp->di_db[lastbn + 1];
dp->di_db[lastbn + 1] = 0;
dp->di_size -= sblock.fs_bsize;
dp->di_blocks -= btodb(sblock.fs_bsize);
freeblk(newblk, sblock.fs_frag);
return (0);
}
/*
* get next entry in a directory.
*/
struct direct *
dreaddir(struct dirstuff *dirp)
{
struct direct *dp;
daddr_t lbn, d;
for (;;) {
if (dirp->loc >= (int)dirp->ip->di_size)
return (NULL);
if (blkoff(&sblock, dirp->loc) == 0) {
lbn = lblkno(&sblock, dirp->loc);
d = bmap(lbn);
if (d == 0)
return (NULL);
bread(fsbtodb(&sblock, d), dirp->dbuf,
(int)dblksize(&sblock, dirp->ip, (int)lbn));
}
dp = (struct direct *)
(dirp->dbuf + blkoff(&sblock, dirp->loc));
dirp->loc += dp->d_reclen;
if (dp->d_ino == 0) {
continue;
}
return (dp);
}
}
/*
* Read a portion of a file into an internal buffer.
* Return the location in the buffer and the amount in the buffer.
*/
static int
buf_read_file(struct open_file *f, char **buf_p, size_t *size_p)
{
struct file *fp = (struct file *)f->f_fsdata;
struct fs *fs = fp->f_fs;
long off;
indp_t file_block;
size_t block_size;
int rc;
off = ufs_blkoff(fs, fp->f_seekp);
file_block = ufs_lblkno(fs, fp->f_seekp);
#ifdef LIBSA_LFS
block_size = dblksize(fs, &fp->f_di, file_block);
#else
block_size = ffs_sblksize(fs, (int64_t)fp->f_di.di_size, file_block);
#endif
if (file_block != fp->f_buf_blkno) {
indp_t disk_block = 0; /* XXX: gcc */
rc = block_map(f, file_block, &disk_block);
if (rc)
return rc;
if (disk_block == 0) {
memset(fp->f_buf, 0, block_size);
fp->f_buf_size = block_size;
} else {
twiddle();
rc = DEV_STRATEGY(f->f_dev)(f->f_devdata, F_READ,
FSBTODB(fs, disk_block),
block_size, fp->f_buf, &fp->f_buf_size);
if (rc)
return rc;
}
fp->f_buf_blkno = file_block;
}
/*
* Return address of byte in buffer corresponding to
* offset, and size of remainder of buffer after that
* byte.
*/
*buf_p = fp->f_buf + off;
*size_p = block_size - off;
/*
* But truncate buffer at end of file.
*/
if (*size_p > fp->f_di.di_size - fp->f_seekp)
*size_p = fp->f_di.di_size - fp->f_seekp;
return 0;
}
/*
* Read a portion of a file into an internal buffer. Return
* the location in the buffer and the amount in the buffer.
*
* Parameters:
* buf_p: out
* size_p: out
*/
static int
buf_read_file(struct open_file *f, char **buf_p, size_t *size_p)
{
struct file *fp = (struct file *)f->f_fsdata;
struct fs *fs = fp->f_fs;
long off;
daddr_t file_block;
daddr_t disk_block;
size_t block_size;
int rc;
off = blkoff(fs, fp->f_seekp);
file_block = lblkno(fs, fp->f_seekp);
block_size = dblksize(fs, &fp->f_di, file_block);
if (file_block != fp->f_buf_blkno) {
rc = block_map(f, file_block, &disk_block);
if (rc)
return (rc);
if (fp->f_buf == NULL)
fp->f_buf = malloc(fs->fs_bsize);
if (disk_block == 0) {
bzero(fp->f_buf, block_size);
fp->f_buf_size = block_size;
} else {
twiddle();
rc = (f->f_dev->dv_strategy)(f->f_devdata, F_READ,
fsbtodb(fs, disk_block),
block_size, fp->f_buf, &fp->f_buf_size);
if (rc)
return (rc);
}
fp->f_buf_blkno = file_block;
}
/*
* Return address of byte in buffer corresponding to
* offset, and size of remainder of buffer after that
* byte.
*/
*buf_p = fp->f_buf + off;
*size_p = block_size - off;
/*
* But truncate buffer at end of file.
*/
if (*size_p > fp->f_di.di_size - fp->f_seekp)
*size_p = fp->f_di.di_size - fp->f_seekp;
return (0);
}
/*
* Dump pass 2.
*
* Scan each directory on the filesystem to see if it has any modified
* files in it. If it does, and has not already been added to the dump
* list (because it was itself modified), then add it. If a directory
* has not been modified itself, contains no modified files and has no
* subdirectories, then it can be deleted from the dump list and from
* the list of directories. By deleting it from the list of directories,
* its parent may now qualify for the same treatment on this or a later
* pass using this algorithm.
*/
int
mapdirs(ufs1_ino_t maxino, long *tape_size)
{
struct ufs1_dinode *dp;
int isdir, nodump;
unsigned int i;
char *map;
ufs1_ino_t ino;
struct ufs1_dinode di;
long filesize;
int ret, change = 0;
isdir = 0; /* XXX just to get gcc to shut up */
for (map = dumpdirmap, ino = 1; ino < maxino; ino++) {
if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */
isdir = *map++;
else
isdir >>= 1;
/*
* If a directory has been removed from usedinomap, it
* either has the nodump flag set, or has inherited
* it. Although a directory can't be in dumpinomap if
* it isn't in usedinomap, we have to go through it to
* propagate the nodump flag.
*/
nodump = !nonodump && (TSTINO(ino, usedinomap) == 0);
if ((isdir & 1) == 0 || (TSTINO(ino, dumpinomap) && !nodump))
continue;
dp = getino(ino);
di = *dp; /* inode buf may change in searchdir(). */
filesize = di.di_size;
for (ret = 0, i = 0; filesize > 0 && i < NDADDR; i++) {
if (di.di_db[i] != 0) {
ret |= searchdir(ino, di.di_db[i],
(long)dblksize(sblock, &di, i),
filesize, tape_size, nodump);
}
if (ret & HASDUMPEDFILE)
filesize = 0;
else
filesize -= sblock->fs_bsize;
}
for (i = 0; filesize > 0 && i < NIADDR; i++) {
if (di.di_ib[i] == 0)
continue;
ret |= dirindir(ino, di.di_ib[i], i, &filesize,
tape_size, nodump);
}
if (ret & HASDUMPEDFILE) {
SETINO(ino, dumpinomap);
*tape_size += blockest(&di);
change = 1;
continue;
}
if (nodump) {
if (ret & HASSUBDIRS)
change = 1; /* subdirs inherit nodump */
CLRINO(ino, dumpdirmap);
} else if ((ret & HASSUBDIRS) == 0)
if (!TSTINO(ino, dumpinomap)) {
CLRINO(ino, dumpdirmap);
change = 1;
}
}
return (change);
}