static int
quotaonoff(struct fstab *fs, int offmode, int type)
{
struct quotafile *qf;
if ((qf = quota_open(fs, type, O_RDONLY)) == NULL)
return (0);
if (offmode) {
if (quota_off(qf) != 0) {
warn("%s", quota_fsname(qf));
return (1);
}
if (vflag)
printf("%s: quotas turned off\n", quota_fsname(qf));
quota_close(qf);
return(0);
}
if (quota_on(qf) != 0) {
warn("using %s on %s", quota_qfname(qf), quota_fsname(qf));
return (1);
}
if (vflag)
printf("%s: %s quotas turned on with data file %s\n",
quota_fsname(qf), qfextension[type], quota_qfname(qf));
quota_close(qf);
return(0);
}
/*
* Update a specified quota file.
*/
int
update(const char *fsname, struct quotafile *qf, int type)
{
struct fileusage *fup;
u_long id, lastid, highid = 0;
struct dqblk dqbuf;
struct stat sb;
static struct dqblk zerodqbuf;
static struct fileusage zerofileusage;
/*
* Scan the on-disk quota file and record any usage changes.
*/
lastid = quota_maxid(qf);
for (id = 0; id <= lastid; id++) {
if (quota_read(qf, &dqbuf, id) < 0)
dqbuf = zerodqbuf;
if ((fup = lookup(id, type)) == NULL)
fup = &zerofileusage;
if (fup->fu_curinodes || fup->fu_curblocks ||
dqbuf.dqb_bsoftlimit || dqbuf.dqb_bhardlimit ||
dqbuf.dqb_isoftlimit || dqbuf.dqb_ihardlimit)
highid = id;
if (dqbuf.dqb_curinodes == fup->fu_curinodes &&
dqbuf.dqb_curblocks == fup->fu_curblocks) {
fup->fu_curinodes = 0;
fup->fu_curblocks = 0;
continue;
}
printchanges(fsname, type, &dqbuf, fup, id);
dqbuf.dqb_curinodes = fup->fu_curinodes;
dqbuf.dqb_curblocks = fup->fu_curblocks;
(void) quota_write_usage(qf, &dqbuf, id);
fup->fu_curinodes = 0;
fup->fu_curblocks = 0;
}
/*
* Walk the hash table looking for ids with non-zero usage
* that are not currently recorded in the quota file. E.g.
* ids that are past the end of the current file.
*/
for (id = 0; id < FUHASH; id++) {
for (fup = fuhead[type][id]; fup != NULL; fup = fup->fu_next) {
if (fup->fu_id <= lastid)
continue;
if (fup->fu_curinodes == 0 && fup->fu_curblocks == 0)
continue;
bzero(&dqbuf, sizeof(struct dqblk));
if (fup->fu_id > highid)
highid = fup->fu_id;
printchanges(fsname, type, &dqbuf, fup, fup->fu_id);
dqbuf.dqb_curinodes = fup->fu_curinodes;
dqbuf.dqb_curblocks = fup->fu_curblocks;
(void) quota_write_usage(qf, &dqbuf, fup->fu_id);
fup->fu_curinodes = 0;
fup->fu_curblocks = 0;
}
}
/*
* If this is old format file, then size may be smaller,
* so ensure that we only truncate when it will make things
* smaller, and not if it will grow an old format file.
*/
if (highid < lastid &&
stat(quota_qfname(qf), &sb) == 0 &&
sb.st_size > (((off_t)highid + 2) * sizeof(struct dqblk)))
truncate(quota_qfname(qf),
(((off_t)highid + 2) * sizeof(struct dqblk)));
return (0);
}
/*
* Scan the specified file system to check quota(s) present on it.
*/
int
chkquota(char *specname, struct quotafile *qfu, struct quotafile *qfg)
{
struct fileusage *fup;
union dinode *dp;
int cg, i, mode, errs = 0;
ino_t ino, inosused, userino = 0, groupino = 0;
dev_t dev, userdev = 0, groupdev = 0;
struct stat sb;
const char *mntpt;
char *cp;
if (qfu != NULL)
mntpt = quota_fsname(qfu);
else if (qfg != NULL)
mntpt = quota_fsname(qfg);
else
errx(1, "null quotafile information passed to chkquota()\n");
if (cflag) {
if (vflag && qfu != NULL)
printf("%s: convert user quota to %d bits\n",
mntpt, cflag);
if (qfu != NULL && quota_convert(qfu, cflag) < 0) {
if (errno == EBADF)
errx(1,
"%s: cannot convert an active quota file",
mntpt);
err(1, "user quota conversion to size %d failed",
cflag);
}
if (vflag && qfg != NULL)
printf("%s: convert group quota to %d bits\n",
mntpt, cflag);
if (qfg != NULL && quota_convert(qfg, cflag) < 0) {
if (errno == EBADF)
errx(1,
"%s: cannot convert an active quota file",
mntpt);
err(1, "group quota conversion to size %d failed",
cflag);
}
}
if ((fi = open(specname, O_RDONLY, 0)) < 0) {
warn("%s", specname);
return (1);
}
if ((stat(mntpt, &sb)) < 0) {
warn("%s", mntpt);
return (1);
}
dev = sb.st_dev;
if (vflag) {
(void)printf("*** Checking ");
if (qfu)
(void)printf("user%s", qfg ? " and " : "");
if (qfg)
(void)printf("group");
(void)printf(" quotas for %s (%s)\n", specname, mntpt);
}
if (qfu) {
if (stat(quota_qfname(qfu), &sb) == 0) {
userino = sb.st_ino;
userdev = sb.st_dev;
}
}
if (qfg) {
if (stat(quota_qfname(qfg), &sb) == 0) {
groupino = sb.st_ino;
groupdev = sb.st_dev;
}
}
sync();
dev_bsize = 1;
for (i = 0; sblock_try[i] != -1; i++) {
bread(sblock_try[i], (char *)&sblock, (long)SBLOCKSIZE);
if ((sblock.fs_magic == FS_UFS1_MAGIC ||
(sblock.fs_magic == FS_UFS2_MAGIC &&
sblock.fs_sblockloc == sblock_try[i])) &&
sblock.fs_bsize <= MAXBSIZE &&
sblock.fs_bsize >= sizeof(struct fs))
break;
}
if (sblock_try[i] == -1) {
warn("Cannot find file system superblock");
return (1);
}
dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
maxino = sblock.fs_ncg * sblock.fs_ipg;
for (cg = 0; cg < sblock.fs_ncg; cg++) {
ino = cg * sblock.fs_ipg;
setinodebuf(ino);
bread(fsbtodb(&sblock, cgtod(&sblock, cg)), (char *)(&cgblk),
sblock.fs_cgsize);
if (sblock.fs_magic == FS_UFS2_MAGIC)
inosused = cgblk.cg_initediblk;
else
inosused = sblock.fs_ipg;
/*
* If we are using soft updates, then we can trust the
* cylinder group inode allocation maps to tell us which
* inodes are allocated. We will scan the used inode map
* to find the inodes that are really in use, and then
* read only those inodes in from disk.
*/
if (sblock.fs_flags & FS_DOSOFTDEP) {
if (!cg_chkmagic(&cgblk))
errx(1, "CG %d: BAD MAGIC NUMBER\n", cg);
cp = &cg_inosused(&cgblk)[(inosused - 1) / CHAR_BIT];
for ( ; inosused > 0; inosused -= CHAR_BIT, cp--) {
if (*cp == 0)
continue;
for (i = 1 << (CHAR_BIT - 1); i > 0; i >>= 1) {
if (*cp & i)
break;
inosused--;
}
break;
}
if (inosused <= 0)
continue;
}
for (i = 0; i < inosused; i++, ino++) {
if ((dp = getnextinode(ino)) == NULL || ino < ROOTINO ||
(mode = DIP(dp, di_mode) & IFMT) == 0)
continue;
/*
* XXX: Do not account for UIDs or GIDs that appear
* to be negative to prevent generating 100GB+
* quota files.
*/
if ((int)DIP(dp, di_uid) < 0 ||
(int)DIP(dp, di_gid) < 0) {
if (vflag) {
if (aflag)
(void)printf("%s: ", mntpt);
(void)printf("out of range UID/GID (%u/%u) ino=%ju\n",
DIP(dp, di_uid), DIP(dp,di_gid),
(uintmax_t)ino);
}
continue;
}
/*
* Do not account for file system snapshot files
* or the actual quota data files to be consistent
* with how they are handled inside the kernel.
*/
#ifdef SF_SNAPSHOT
if (DIP(dp, di_flags) & SF_SNAPSHOT)
continue;
#endif
if ((ino == userino && dev == userdev) ||
(ino == groupino && dev == groupdev))
continue;
if (qfg) {
fup = addid((u_long)DIP(dp, di_gid), GRPQUOTA,
(char *)0, mntpt);
fup->fu_curinodes++;
if (mode == IFREG || mode == IFDIR ||
mode == IFLNK)
fup->fu_curblocks += DIP(dp, di_blocks);
}
if (qfu) {
fup = addid((u_long)DIP(dp, di_uid), USRQUOTA,
(char *)0, mntpt);
fup->fu_curinodes++;
if (mode == IFREG || mode == IFDIR ||
mode == IFLNK)
fup->fu_curblocks += DIP(dp, di_blocks);
}
}
}
freeinodebuf();
if (qfu)
errs += update(mntpt, qfu, USRQUOTA);
if (qfg)
errs += update(mntpt, qfg, GRPQUOTA);
close(fi);
(void)fflush(stdout);
return (errs);
}