Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/lib/libquota/quota_oldfiles.c

927 lines
20 KiB
C
Raw Permalink Blame History

/* $NetBSD: quota_oldfiles.c,v 1.10 2022/04/26 15:36:42 hannken Exp $ */
/*
* Copyright (c) 1980, 1990, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Robert Elz at The University of Melbourne.
*
* 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.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*/
#include <sys/cdefs.h>
__RCSID("$NetBSD: quota_oldfiles.c,v 1.10 2022/04/26 15:36:42 hannken Exp $");
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <fstab.h>
#include <errno.h>
#include <err.h>
#include <ufs/ufs/quota1.h>
#include <quota.h>
#include "quotapvt.h"
struct oldfiles_fstabentry {
char *ofe_mountpoint;
int ofe_hasuserquota;
int ofe_hasgroupquota;
char *ofe_userquotafile;
char *ofe_groupquotafile;
};
struct oldfiles_quotacursor {
unsigned oqc_doingusers;
unsigned oqc_doinggroups;
unsigned oqc_numusers;
unsigned oqc_numgroups;
unsigned oqc_didusers;
unsigned oqc_didgroups;
unsigned oqc_diddefault;
unsigned oqc_pos;
unsigned oqc_didblocks;
};
static struct oldfiles_fstabentry *__quota_oldfiles_fstab;
static unsigned __quota_oldfiles_numfstab;
static unsigned __quota_oldfiles_maxfstab;
static int __quota_oldfiles_fstab_loaded;
static const struct oldfiles_fstabentry *
__quota_oldfiles_find_fstabentry(const char *mountpoint)
{
unsigned i;
for (i = 0; i < __quota_oldfiles_numfstab; i++) {
if (!strcmp(mountpoint,
__quota_oldfiles_fstab[i].ofe_mountpoint)) {
return &__quota_oldfiles_fstab[i];
}
}
return NULL;
}
static int
__quota_oldfiles_add_fstabentry(struct oldfiles_fstabentry *ofe)
{
unsigned newmax;
struct oldfiles_fstabentry *newptr;
if (__quota_oldfiles_numfstab + 1 >= __quota_oldfiles_maxfstab) {
if (__quota_oldfiles_maxfstab == 0) {
newmax = 4;
} else {
newmax = __quota_oldfiles_maxfstab * 2;
}
newptr = realloc(__quota_oldfiles_fstab,
newmax * sizeof(__quota_oldfiles_fstab[0]));
if (newptr == NULL) {
return -1;
}
__quota_oldfiles_maxfstab = newmax;
__quota_oldfiles_fstab = newptr;
}
__quota_oldfiles_fstab[__quota_oldfiles_numfstab++] = *ofe;
return 0;
}
static int
__quota_oldfiles_fill_fstabentry(const struct fstab *fs,
struct oldfiles_fstabentry *ofe)
{
char buf[256];
char *opt, *state, *s;
int serrno;
int ret = 0;
/*
* Inspect the mount options to find the quota files.
* XXX this info should be gotten from the kernel.
*
* The options are:
* userquota[=path] enable user quotas
* groupquota[=path] enable group quotas
*/
ofe->ofe_mountpoint = NULL;
ofe->ofe_hasuserquota = ofe->ofe_hasgroupquota = 0;
ofe->ofe_userquotafile = ofe->ofe_groupquotafile = NULL;
strlcpy(buf, fs->fs_mntops, sizeof(buf));
for (opt = strtok_r(buf, ",", &state);
opt != NULL;
opt = strtok_r(NULL, ",", &state)) {
s = strchr(opt, '=');
if (s != NULL) {
*(s++) = '\0';
}
if (!strcmp(opt, "userquota")) {
ret = 1;
ofe->ofe_hasuserquota = 1;
if (s != NULL) {
ofe->ofe_userquotafile = strdup(s);
if (ofe->ofe_userquotafile == NULL) {
goto fail;
}
}
} else if (!strcmp(opt, "groupquota")) {
ret = 1;
ofe->ofe_hasgroupquota = 1;
if (s != NULL) {
ofe->ofe_groupquotafile = strdup(s);
if (ofe->ofe_groupquotafile == NULL) {
goto fail;
}
}
}
}
if (ret == 1) {
ofe->ofe_mountpoint = strdup(fs->fs_file);
if (ofe->ofe_mountpoint == NULL) {
goto fail;
}
}
return ret;
fail:
serrno = errno;
if (ofe->ofe_mountpoint != NULL) {
free(ofe->ofe_mountpoint);
}
if (ofe->ofe_groupquotafile != NULL) {
free(ofe->ofe_groupquotafile);
}
if (ofe->ofe_userquotafile != NULL) {
free(ofe->ofe_userquotafile);
}
errno = serrno;
return -1;
}
void
__quota_oldfiles_load_fstab(void)
{
struct oldfiles_fstabentry ofe;
struct fstab *fs;
int result;
if (__quota_oldfiles_fstab_loaded) {
return;
}
/*
* Check if fstab file exists before trying to parse it.
* Avoid warnings from {get,set}fsent() if missing.
*/
if (access(_PATH_FSTAB, F_OK) == -1 && errno == ENOENT)
return;
/*
* XXX: should be able to handle ext2fs quota1 files too
*
* XXX: should use getfsent_r(), but there isn't one.
*/
setfsent();
while ((fs = getfsent()) != NULL) {
if (!strcmp(fs->fs_vfstype, "ffs") ||
!strcmp(fs->fs_vfstype, "lfs")) {
result = __quota_oldfiles_fill_fstabentry(fs, &ofe);
if (result == -1) {
goto failed;
}
if (result == 0) {
continue;
}
if (__quota_oldfiles_add_fstabentry(&ofe)) {
goto failed;
}
}
}
endfsent();
__quota_oldfiles_fstab_loaded = 1;
return;
failed:
warn("Failed reading fstab");
return;
}
int
__quota_oldfiles_infstab(const char *mountpoint)
{
return __quota_oldfiles_find_fstabentry(mountpoint) != NULL;
}
static void
__quota_oldfiles_defquotafile(struct quotahandle *qh, int idtype,
char *buf, size_t maxlen)
{
static const char *const names[] = INITQFNAMES;
(void)snprintf(buf, maxlen, "%s/%s.%s",
qh->qh_mountpoint,
QUOTAFILENAME, names[idtype]);
}
const char *
__quota_oldfiles_getquotafile(struct quotahandle *qh, int idtype,
char *buf, size_t maxlen)
{
const struct oldfiles_fstabentry *ofe;
const char *file;
ofe = __quota_oldfiles_find_fstabentry(qh->qh_mountpoint);
if (ofe == NULL) {
errno = ENXIO;
return NULL;
}
switch (idtype) {
case USRQUOTA:
if (!ofe->ofe_hasuserquota) {
errno = ENXIO;
return NULL;
}
file = ofe->ofe_userquotafile;
break;
case GRPQUOTA:
if (!ofe->ofe_hasgroupquota) {
errno = ENXIO;
return NULL;
}
file = ofe->ofe_groupquotafile;
break;
default:
errno = EINVAL;
return NULL;
}
if (file == NULL) {
__quota_oldfiles_defquotafile(qh, idtype, buf, maxlen);
file = buf;
}
return file;
}
static uint64_t
dqblk_getlimit(uint32_t val)
{
if (val == 0) {
return QUOTA_NOLIMIT;
} else {
return val - 1;
}
}
static uint32_t
dqblk_setlimit(uint64_t val)
{
if (val == QUOTA_NOLIMIT && val >= 0xffffffffUL) {
return 0;
} else {
return (uint32_t)val + 1;
}
}
static void
dqblk_getblocks(const struct dqblk *dq, struct quotaval *qv)
{
qv->qv_hardlimit = dqblk_getlimit(dq->dqb_bhardlimit);
qv->qv_softlimit = dqblk_getlimit(dq->dqb_bsoftlimit);
qv->qv_usage = dq->dqb_curblocks;
qv->qv_expiretime = dq->dqb_btime;
qv->qv_grace = QUOTA_NOTIME;
}
static void
dqblk_getfiles(const struct dqblk *dq, struct quotaval *qv)
{
qv->qv_hardlimit = dqblk_getlimit(dq->dqb_ihardlimit);
qv->qv_softlimit = dqblk_getlimit(dq->dqb_isoftlimit);
qv->qv_usage = dq->dqb_curinodes;
qv->qv_expiretime = dq->dqb_itime;
qv->qv_grace = QUOTA_NOTIME;
}
static void
dqblk_putblocks(const struct quotaval *qv, struct dqblk *dq)
{
dq->dqb_bhardlimit = dqblk_setlimit(qv->qv_hardlimit);
dq->dqb_bsoftlimit = dqblk_setlimit(qv->qv_softlimit);
dq->dqb_curblocks = qv->qv_usage;
dq->dqb_btime = qv->qv_expiretime;
/* ignore qv->qv_grace */
}
static void
dqblk_putfiles(const struct quotaval *qv, struct dqblk *dq)
{
dq->dqb_ihardlimit = dqblk_setlimit(qv->qv_hardlimit);
dq->dqb_isoftlimit = dqblk_setlimit(qv->qv_softlimit);
dq->dqb_curinodes = qv->qv_usage;
dq->dqb_itime = qv->qv_expiretime;
/* ignore qv->qv_grace */
}
static int
__quota_oldfiles_open(struct quotahandle *qh, const char *path, int *fd_ret)
{
int fd;
fd = open(path, O_RDWR);
if (fd < 0 && (errno == EACCES || errno == EROFS)) {
fd = open(path, O_RDONLY);
if (fd < 0) {
return -1;
}
}
*fd_ret = fd;
return 0;
}
int
__quota_oldfiles_initialize(struct quotahandle *qh)
{
const struct oldfiles_fstabentry *ofe;
char path[PATH_MAX];
const char *userquotafile, *groupquotafile;
if (qh->qh_oldfilesopen) {
/* already initialized */
return 0;
}
/*
* Find the fstab entry.
*/
ofe = __quota_oldfiles_find_fstabentry(qh->qh_mountpoint);
if (ofe == NULL) {
warnx("%s not found in fstab", qh->qh_mountpoint);
errno = ENXIO;
return -1;
}
if (!ofe->ofe_hasuserquota && !ofe->ofe_hasgroupquota) {
errno = ENXIO;
return -1;
}
if (ofe->ofe_hasuserquota) {
userquotafile = ofe->ofe_userquotafile;
if (userquotafile == NULL) {
__quota_oldfiles_defquotafile(qh, USRQUOTA,
path, sizeof(path));
userquotafile = path;
}
if (__quota_oldfiles_open(qh, userquotafile,
&qh->qh_userfile)) {
return -1;
}
}
if (ofe->ofe_hasgroupquota) {
groupquotafile = ofe->ofe_groupquotafile;
if (groupquotafile == NULL) {
__quota_oldfiles_defquotafile(qh, GRPQUOTA,
path, sizeof(path));
groupquotafile = path;
}
if (__quota_oldfiles_open(qh, groupquotafile,
&qh->qh_groupfile)) {
return -1;
}
}
qh->qh_oldfilesopen = 1;
return 0;
}
const char *
__quota_oldfiles_getimplname(struct quotahandle *qh)
{
return "ufs/ffs quota v1 file access";
}
int
__quota_oldfiles_quotaon(struct quotahandle *qh, int idtype)
{
int result;
/*
* If we have the quota files open, close them.
*/
if (qh->qh_oldfilesopen) {
if (qh->qh_userfile >= 0) {
close(qh->qh_userfile);
qh->qh_userfile = -1;
}
if (qh->qh_groupfile >= 0) {
close(qh->qh_groupfile);
qh->qh_groupfile = -1;
}
qh->qh_oldfilesopen = 0;
}
/*
* Go over to the syscall interface.
*/
result = __quota_kernel_quotaon(qh, idtype);
if (result < 0) {
return -1;
}
/*
* We succeeded, so all further access should be via the
* kernel.
*/
qh->qh_mode = QUOTA_MODE_KERNEL;
return 0;
}
static int
__quota_oldfiles_doget(struct quotahandle *qh, const struct quotakey *qk,
struct quotaval *qv, int *isallzero)
{
int file;
off_t pos;
struct dqblk dq;
ssize_t result;
if (!qh->qh_oldfilesopen) {
if (__quota_oldfiles_initialize(qh)) {
return -1;
}
}
switch (qk->qk_idtype) {
case QUOTA_IDTYPE_USER:
file = qh->qh_userfile;
break;
case QUOTA_IDTYPE_GROUP:
file = qh->qh_groupfile;
break;
default:
errno = EINVAL;
return -1;
}
if (qk->qk_id == QUOTA_DEFAULTID) {
pos = 0;
} else {
pos = qk->qk_id * sizeof(struct dqblk);
}
result = pread(file, &dq, sizeof(dq), pos);
if (result < 0) {
return -1;
} else if (result == 0) {
/* Past EOF; no quota info on file for this ID */
errno = ENOENT;
return -1;
} else if ((size_t)result != sizeof(dq)) {
errno = EFTYPE;
return -1;
}
switch (qk->qk_objtype) {
case QUOTA_OBJTYPE_BLOCKS:
dqblk_getblocks(&dq, qv);
break;
case QUOTA_OBJTYPE_FILES:
dqblk_getfiles(&dq, qv);
break;
default:
errno = EINVAL;
return -1;
}
if (qk->qk_id == QUOTA_DEFAULTID) {
qv->qv_usage = 0;
qv->qv_grace = qv->qv_expiretime;
qv->qv_expiretime = QUOTA_NOTIME;
} else if (qk->qk_id == 0) {
qv->qv_hardlimit = 0;
qv->qv_softlimit = 0;
qv->qv_expiretime = QUOTA_NOTIME;
qv->qv_grace = QUOTA_NOTIME;
}
if (isallzero != NULL) {
if (dq.dqb_bhardlimit == 0 &&
dq.dqb_bsoftlimit == 0 &&
dq.dqb_curblocks == 0 &&
dq.dqb_ihardlimit == 0 &&
dq.dqb_isoftlimit == 0 &&
dq.dqb_curinodes == 0 &&
dq.dqb_btime == 0 &&
dq.dqb_itime == 0) {
*isallzero = 1;
} else {
*isallzero = 0;
}
}
return 0;
}
static int
__quota_oldfiles_doput(struct quotahandle *qh, const struct quotakey *qk,
const struct quotaval *qv)
{
int file;
off_t pos;
struct quotaval qv2;
struct dqblk dq;
ssize_t result;
if (!qh->qh_oldfilesopen) {
if (__quota_oldfiles_initialize(qh)) {
return -1;
}
}
switch (qk->qk_idtype) {
case QUOTA_IDTYPE_USER:
file = qh->qh_userfile;
break;
case QUOTA_IDTYPE_GROUP:
file = qh->qh_groupfile;
break;
default:
errno = EINVAL;
return -1;
}
if (qk->qk_id == QUOTA_DEFAULTID) {
pos = 0;
} else {
pos = qk->qk_id * sizeof(struct dqblk);
}
result = pread(file, &dq, sizeof(dq), pos);
if (result < 0) {
return -1;
} else if (result == 0) {
/* Past EOF; fill in a blank dq to start from */
dq.dqb_bhardlimit = 0;
dq.dqb_bsoftlimit = 0;
dq.dqb_curblocks = 0;
dq.dqb_ihardlimit = 0;
dq.dqb_isoftlimit = 0;
dq.dqb_curinodes = 0;
dq.dqb_btime = 0;
dq.dqb_itime = 0;
} else if ((size_t)result != sizeof(dq)) {
errno = EFTYPE;
return -1;
}
switch (qk->qk_objtype) {
case QUOTA_OBJTYPE_BLOCKS:
dqblk_getblocks(&dq, &qv2);
break;
case QUOTA_OBJTYPE_FILES:
dqblk_getfiles(&dq, &qv2);
break;
default:
errno = EINVAL;
return -1;
}
if (qk->qk_id == QUOTA_DEFAULTID) {
qv2.qv_hardlimit = qv->qv_hardlimit;
qv2.qv_softlimit = qv->qv_softlimit;
/* leave qv2.qv_usage unchanged */
qv2.qv_expiretime = qv->qv_grace;
/* skip qv2.qv_grace */
/* ignore qv->qv_usage */
/* ignore qv->qv_expiretime */
} else if (qk->qk_id == 0) {
/* leave qv2.qv_hardlimit unchanged */
/* leave qv2.qv_softlimit unchanged */
qv2.qv_usage = qv->qv_usage;
/* leave qv2.qv_expiretime unchanged */
/* skip qv2.qv_grace */
/* ignore qv->qv_hardlimit */
/* ignore qv->qv_softlimit */
/* ignore qv->qv_expiretime */
/* ignore qv->qv_grace */
} else {
qv2 = *qv;
}
switch (qk->qk_objtype) {
case QUOTA_OBJTYPE_BLOCKS:
dqblk_putblocks(&qv2, &dq);
break;
case QUOTA_OBJTYPE_FILES:
dqblk_putfiles(&qv2, &dq);
break;
default:
errno = EINVAL;
return -1;
}
result = pwrite(file, &dq, sizeof(dq), pos);
if (result < 0) {
return -1;
} else if ((size_t)result != sizeof(dq)) {
/* ? */
errno = EFTYPE;
return -1;
}
return 0;
}
int
__quota_oldfiles_get(struct quotahandle *qh, const struct quotakey *qk,
struct quotaval *qv)
{
return __quota_oldfiles_doget(qh, qk, qv, NULL);
}
int
__quota_oldfiles_put(struct quotahandle *qh, const struct quotakey *qk,
const struct quotaval *qv)
{
return __quota_oldfiles_doput(qh, qk, qv);
}
int
__quota_oldfiles_delete(struct quotahandle *qh, const struct quotakey *qk)
{
struct quotaval qv;
quotaval_clear(&qv);
return __quota_oldfiles_doput(qh, qk, &qv);
}
struct oldfiles_quotacursor *
__quota_oldfiles_cursor_create(struct quotahandle *qh)
{
struct oldfiles_quotacursor *oqc;
struct stat st;
int serrno;
/* quota_opencursor calls initialize for us, no need to do it here */
oqc = malloc(sizeof(*oqc));
if (oqc == NULL) {
return NULL;
}
oqc->oqc_didusers = 0;
oqc->oqc_didgroups = 0;
oqc->oqc_diddefault = 0;
oqc->oqc_pos = 0;
oqc->oqc_didblocks = 0;
if (qh->qh_userfile >= 0) {
oqc->oqc_doingusers = 1;
} else {
oqc->oqc_doingusers = 0;
oqc->oqc_didusers = 1;
}
if (qh->qh_groupfile >= 0) {
oqc->oqc_doinggroups = 1;
} else {
oqc->oqc_doinggroups = 0;
oqc->oqc_didgroups = 1;
}
if (fstat(qh->qh_userfile, &st) < 0) {
serrno = errno;
free(oqc);
errno = serrno;
return NULL;
}
oqc->oqc_numusers = st.st_size / sizeof(struct dqblk);
if (fstat(qh->qh_groupfile, &st) < 0) {
serrno = errno;
free(oqc);
errno = serrno;
return NULL;
}
oqc->oqc_numgroups = st.st_size / sizeof(struct dqblk);
return oqc;
}
void
__quota_oldfiles_cursor_destroy(struct oldfiles_quotacursor *oqc)
{
free(oqc);
}
int
__quota_oldfiles_cursor_skipidtype(struct oldfiles_quotacursor *oqc,
int idtype)
{
switch (idtype) {
case QUOTA_IDTYPE_USER:
oqc->oqc_doingusers = 0;
oqc->oqc_didusers = 1;
break;
case QUOTA_IDTYPE_GROUP:
oqc->oqc_doinggroups = 0;
oqc->oqc_didgroups = 1;
break;
default:
errno = EINVAL;
return -1;
}
return 0;
}
int
__quota_oldfiles_cursor_get(struct quotahandle *qh,
struct oldfiles_quotacursor *oqc,
struct quotakey *key, struct quotaval *val)
{
unsigned maxpos;
int isallzero;
/* in case one of the sizes is zero */
if (!oqc->oqc_didusers && oqc->oqc_pos >= oqc->oqc_numusers) {
oqc->oqc_didusers = 1;
}
if (!oqc->oqc_didgroups && oqc->oqc_pos >= oqc->oqc_numgroups) {
oqc->oqc_didgroups = 1;
}
again:
/*
* Figure out what to get
*/
if (!oqc->oqc_didusers) {
key->qk_idtype = QUOTA_IDTYPE_USER;
maxpos = oqc->oqc_numusers;
} else if (!oqc->oqc_didgroups) {
key->qk_idtype = QUOTA_IDTYPE_GROUP;
maxpos = oqc->oqc_numgroups;
} else {
errno = ENOENT;
return -1;
}
if (!oqc->oqc_diddefault) {
key->qk_id = QUOTA_DEFAULTID;
} else {
key->qk_id = oqc->oqc_pos;
}
if (!oqc->oqc_didblocks) {
key->qk_objtype = QUOTA_OBJTYPE_BLOCKS;
} else {
key->qk_objtype = QUOTA_OBJTYPE_FILES;
}
/*
* Get it
*/
if (__quota_oldfiles_doget(qh, key, val, &isallzero)) {
return -1;
}
/*
* Advance the cursor
*/
if (!oqc->oqc_didblocks) {
oqc->oqc_didblocks = 1;
} else {
oqc->oqc_didblocks = 0;
if (!oqc->oqc_diddefault) {
oqc->oqc_diddefault = 1;
} else {
oqc->oqc_pos++;
if (oqc->oqc_pos >= maxpos) {
oqc->oqc_pos = 0;
oqc->oqc_diddefault = 0;
if (!oqc->oqc_didusers) {
oqc->oqc_didusers = 1;
} else {
oqc->oqc_didgroups = 1;
}
}
}
}
/*
* If we got an all-zero dqblk (e.g. from the middle of a hole
* in the quota file) don't bother returning it to the caller.
*
* ...unless we're at the end of the data, to avoid going past
* the end and generating a spurious failure. There's no
* reasonable way to make _atend detect empty entries at the
* end of the quota files.
*/
if (isallzero && (!oqc->oqc_didusers || !oqc->oqc_didgroups)) {
goto again;
}
return 0;
}
int
__quota_oldfiles_cursor_getn(struct quotahandle *qh,
struct oldfiles_quotacursor *oqc,
struct quotakey *keys, struct quotaval *vals,
unsigned maxnum)
{
unsigned i;
if (maxnum > INT_MAX) {
/* joker, eh? */
errno = EINVAL;
return -1;
}
for (i=0; i<maxnum; i++) {
if (__quota_oldfiles_cursor_atend(oqc)) {
break;
}
if (__quota_oldfiles_cursor_get(qh, oqc, &keys[i], &vals[i])) {
if (i > 0) {
/*
* Succeed witih what we have so far;
* the next attempt will hit the same
* error again.
*/
break;
}
return -1;
}
}
return i;
}
int
__quota_oldfiles_cursor_atend(struct oldfiles_quotacursor *oqc)
{
/* in case one of the sizes is zero */
if (!oqc->oqc_didusers && oqc->oqc_pos >= oqc->oqc_numusers) {
oqc->oqc_didusers = 1;
}
if (!oqc->oqc_didgroups && oqc->oqc_pos >= oqc->oqc_numgroups) {
oqc->oqc_didgroups = 1;
}
return oqc->oqc_didusers && oqc->oqc_didgroups;
}
int
__quota_oldfiles_cursor_rewind(struct oldfiles_quotacursor *oqc)
{
oqc->oqc_didusers = 0;
oqc->oqc_didgroups = 0;
oqc->oqc_diddefault = 0;
oqc->oqc_pos = 0;
oqc->oqc_didblocks = 0;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink