static int get_smb_linux_xfs_quota(char *path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA *dp) { struct fs_disk_quota D; int ret; ZERO_STRUCT(D); ret = quotactl(QCMD(Q_XGETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D); if (ret) ret = quotactl(QCMD(Q_XGETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D); if (ret) return ret; dp->bsize = (SMB_BIG_UINT)512; dp->softlimit = (SMB_BIG_UINT)D.d_blk_softlimit; dp->hardlimit = (SMB_BIG_UINT)D.d_blk_hardlimit; dp->ihardlimit = (SMB_BIG_UINT)D.d_ino_hardlimit; dp->isoftlimit = (SMB_BIG_UINT)D.d_ino_softlimit; dp->curinodes = (SMB_BIG_UINT)D.d_icount; dp->curblocks = (SMB_BIG_UINT)D.d_bcount; return ret; }
static int generic_quota_get (quota_t *myquota) { struct if_dqblk sysquota; long retval; retval = quotactl(QCMD(Q_GETQUOTA,myquota->_id_type), myquota->_qfile, myquota->_id, (caddr_t) &sysquota); if ( retval < 0 ) { output_error ("Failed fetching quotas (generic): %s", strerror(errno)); return 0; } /* copy the linux-formatted quota info into our struct */ myquota->block_hard = sysquota.dqb_bhardlimit; myquota->block_soft = sysquota.dqb_bsoftlimit; myquota->diskspace_used = sysquota.dqb_curspace; myquota->inode_hard = sysquota.dqb_ihardlimit; myquota->inode_soft = sysquota.dqb_isoftlimit; myquota->inode_used = sysquota.dqb_curinodes; myquota->block_time = sysquota.dqb_btime; myquota->inode_time = sysquota.dqb_itime; retval = quotactl(QCMD(Q_GETINFO,myquota->_id_type), myquota->_qfile, myquota->_id, (caddr_t) myquota->_generic_quotainfo); if ( retval < 0 ) { output_error ("Failed fetching quotainfo (generic): %s", strerror(errno)); return 0; } myquota->block_grace = ((struct if_dqinfo *) myquota->_generic_quotainfo)->dqi_bgrace; myquota->inode_grace = ((struct if_dqinfo *) myquota->_generic_quotainfo)->dqi_igrace; return 1; }
static int get_smb_linux_gen_quota(char *path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA *dp) { struct if_dqblk D; int ret; ZERO_STRUCT(D); ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D); if (ret && errno != EDQUOT) ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D); if (ret && errno != EDQUOT) return ret; dp->bsize = (SMB_BIG_UINT)QUOTABLOCK_SIZE; dp->softlimit = (SMB_BIG_UINT)D.dqb_bsoftlimit; dp->hardlimit = (SMB_BIG_UINT)D.dqb_bhardlimit; dp->ihardlimit = (SMB_BIG_UINT)D.dqb_ihardlimit; dp->isoftlimit = (SMB_BIG_UINT)D.dqb_isoftlimit; dp->curinodes = (SMB_BIG_UINT)D.dqb_curinodes; dp->curblocks = ((SMB_BIG_UINT)D.dqb_curspace) / dp->bsize; return ret; }
static int getfsquota(const AFPObj *obj, struct vol *vol, const int uid, struct dqblk *dq) { struct dqblk dqg; #ifdef __svr4__ struct quotctl qc; #endif memset(dq, 0, sizeof(struct dqblk)); memset(&dqg, 0, sizeof(dqg)); #ifdef __svr4__ qc.op = Q_GETQUOTA; qc.uid = uid; qc.addr = (caddr_t)dq; if ( ioctl( vol->v_qfd, Q_QUOTACTL, &qc ) < 0 ) { return( AFPERR_PARAM ); } #else /* __svr4__ */ #ifdef ultrix if ( quota( Q_GETDLIM, uid, vol->v_gvs, dq ) != 0 ) { return( AFPERR_PARAM ); } #else /* ultrix */ #ifndef USRQUOTA #define USRQUOTA 0 #endif #ifndef QCMD #define QCMD(a,b) (a) #endif #ifndef TRU64 /* for group quotas. we only use these if the user belongs * to one group. */ #endif /* TRU64 */ #ifdef BSD4_4 become_root(); if ( quotactl( vol->v_path, QCMD(Q_GETQUOTA,USRQUOTA), uid, (char *)dq ) != 0 ) { /* try group quotas */ if (obj->ngroups >= 1) { if ( quotactl(vol->v_path, QCMD(Q_GETQUOTA, GRPQUOTA), obj->groups[0], (char *) &dqg) != 0 ) { unbecome_root(); return( AFPERR_PARAM ); } } } unbecome_root(); }
static int xfs_quota_get(quota_t *myquota) { fs_disk_quota_t sysquota; fs_quota_stat_t quotastat; int block_diff; // XFS quota always uses BB (Basic Blocks = 512 bytes) int retval; block_diff = BLOCK_SIZE / 512; retval = quotactl(QCMD(Q_XGETQUOTA, myquota->_id_type), myquota->_qfile, myquota->_id, (caddr_t) &sysquota); /* ** 2005-04-26 : [email protected] - handling a non-set quota for a user/group who owns nothing here */ if ( retval < 0 ) { // This error has to be explained : // if UID/GID has no quota defined, and owns no data, ENOENT error occures // but at this point of the code, whe know that this XFS has quotas. // We make the choice to produce a "0 0 0 0 0 0 0 0" line. if ( errno == ENOENT ) { myquota->block_hard = 0; myquota->block_soft = 0; myquota->diskspace_used = 0; myquota->inode_hard = 0; myquota->inode_soft = 0; myquota->inode_used = 0; myquota->block_grace = 0; myquota->inode_grace = 0; myquota->block_time = 0; myquota->inode_time = 0; return 1; } output_error ("Failed fetching quotas: errno=%d, %s", errno, strerror(errno)); return 0; } retval = quotactl(QCMD(Q_XGETQSTAT, myquota->_id_type), myquota->_qfile, myquota->_id, (caddr_t) "astat); /* copy the linux-xfs-formatted quota info into our struct */ myquota->block_hard = sysquota.d_blk_hardlimit / block_diff; myquota->block_soft = sysquota.d_blk_softlimit / block_diff; // XFS really uses blocks, all other formats in this file use bytes myquota->diskspace_used = (sysquota.d_bcount * 1024) / block_diff; myquota->inode_hard = sysquota.d_ino_hardlimit; myquota->inode_soft = sysquota.d_ino_softlimit; myquota->inode_used = sysquota.d_icount; myquota->block_grace = quotastat.qs_btimelimit; myquota->inode_grace = quotastat.qs_itimelimit; myquota->block_time = sysquota.d_btimer; myquota->inode_time = sysquota.d_itimer; return 1; }
int hasxfsquota(int type, int q, char *device) { fs_quota_stat_t qstat; int qcmd; memset(&qstat, 0, sizeof(fs_quota_stat_t)); qcmd = QCMD(Q_XGETQSTAT, type); if (quotactl(qcmd, device, 0, (caddr_t)&qstat) < 0) { if (verbose) perror("quotactl"); return (1); } else if (q == 0) return (0); else if (q == XFS_QUOTA_UDQ_ENFD && qstat.qs_flags & XFS_QUOTA_UDQ_ENFD) return (0); else if (q == XFS_QUOTA_GDQ_ENFD && qstat.qs_flags & XFS_QUOTA_GDQ_ENFD) return (0); else if (q == XFS_QUOTA_UDQ_ACCT && qstat.qs_flags & XFS_QUOTA_UDQ_ACCT) return (0); else if (q == XFS_QUOTA_GDQ_ACCT && qstat.qs_flags & XFS_QUOTA_GDQ_ACCT) return (0); if (verbose) fprintf(stderr, "quota type (%d) not available\n", q); return (1); }
static int old_quota_set(quota_t *myquota) { struct old_kern_dqblk sysquota; int retval; /* copy our data into the linux dqblk */ sysquota.dqb_bhardlimit = myquota->block_hard; sysquota.dqb_bsoftlimit = myquota->block_soft; sysquota.dqb_curblocks = myquota->diskspace_used; sysquota.dqb_ihardlimit = myquota->inode_hard; sysquota.dqb_isoftlimit = myquota->inode_soft; sysquota.dqb_curinodes = myquota->inode_used; /* is old like xfs - global grace set by root's limits? */ sysquota.dqb_btime = myquota->block_grace; sysquota.dqb_itime = myquota->inode_grace; /* make the syscall */ retval = quotactl (QCMD(Q_OLD_SETQUOTA,myquota->_id_type),myquota->_qfile, myquota->_id, (caddr_t) &sysquota); if ( retval < 0 ) { output_error ("Failed setting quota (old): %s", strerror(errno)); return 0; } /* success */ return 1; }
static void putdiscq(uid_t uid) { struct fsquot *fsqp; for (fsqp = fsqlist; fsqp; fsqp = fsqp->fsq_next) { if (quotactl(Q_SETQLIM, fsqp->fsq_dev, uid, (caddr_t)&fsqp->fsq_dqb) != 0) { int fd; if ((fd = open64(fsqp->fsq_qfile, O_RDWR)) < 0) { (void) fprintf(stderr, "edquota: "); perror(fsqp->fsq_qfile); continue; } (void) llseek(fd, (offset_t)dqoff(uid), L_SET); if (write(fd, (char *)&fsqp->fsq_dqb, sizeof (struct dqblk)) != sizeof (struct dqblk)) { (void) fprintf(stderr, "edquota: "); perror(fsqp->fsq_qfile); } (void) close(fd); } } }
int quota_get (quota_t *myquota) { struct dqblk sysquota; int retval; output_debug ("fetching quotas: device='%s',id='%d'", myquota->_qfile, myquota->_id); retval = quotactl (myquota->_qfile, QCMD(Q_GETQUOTA, myquota->_id_type), myquota->_id, (caddr_t) &sysquota); if ( retval < 0 ) { output_error ("Failed fetching quotas: %s", strerror (errno)); return 0; } /* here, linux.c does a memcpy(), it should also work for darwin, * but it's better to be on the safe side */ myquota->block_hard = sysquota.dqb_bhardlimit; myquota->block_soft = sysquota.dqb_bsoftlimit; myquota->diskspace_used = sysquota.dqb_curbytes; myquota->inode_hard = sysquota.dqb_ihardlimit; myquota->inode_soft = sysquota.dqb_isoftlimit; myquota->inode_used = sysquota.dqb_curinodes ; myquota->block_time = (time_t) sysquota.dqb_btime; myquota->inode_time = (time_t) sysquota.dqb_itime; // FIXME: remove debug //output_info ("BLOCK_SIZE: %d\n", BLOCK_SIZE); //output_info ("Getting quota soft/hard: %llu, %llu\n", myquota->block_soft, myquota->block_hard); return 1; }
static int getufsquota(struct fstab *fs, struct quotause *qup, long id, int quotatype) { char *qfpathname; int fd, qcmd; qcmd = QCMD(Q_GETQUOTA, quotatype); if (!ufshasquota(fs, quotatype, &qfpathname)) return (0); if (quotactl(fs->fs_file, qcmd, id, (char *)&qup->dqblk) != 0) { if ((fd = open(qfpathname, O_RDONLY)) < 0) { warn("%s", qfpathname); return (0); } lseek(fd, (off_t)(id * sizeof(struct ufs_dqblk)), L_SET); switch (read(fd, &qup->dqblk, sizeof(struct ufs_dqblk))) { case 0: /* EOF */ /* * Convert implicit 0 quota (EOF) * into an explicit one (zero'ed dqblk) */ bzero(&qup->dqblk, sizeof(struct ufs_dqblk)); break; case sizeof(struct ufs_dqblk): /* OK */ break; default: /* ERROR */ warn("read error: %s", qfpathname); close(fd); return (0); } close(fd); } return (1); }
static int xfs_quota_set(quota_t *myquota) { fs_disk_quota_t sysquota; int retval; int block_diff= BLOCK_SIZE / 512; memset(&sysquota, 0, sizeof(fs_disk_quota_t)); /* copy our data into the linux dqblk */ sysquota.d_blk_hardlimit = myquota->block_hard * block_diff; sysquota.d_blk_softlimit = myquota->block_soft * block_diff; // XFS really uses blocks, all other formats in this file use bytes sysquota.d_bcount = DIV_UP(myquota->diskspace_used * block_diff, 1024); sysquota.d_ino_hardlimit = myquota->inode_hard; sysquota.d_ino_softlimit = myquota->inode_soft; sysquota.d_icount = myquota->inode_used; /* For XFS, global grace time limits are set by the values set for root */ sysquota.d_btimer = myquota->block_grace; sysquota.d_itimer = myquota->inode_grace; sysquota.d_fieldmask = FS_DQ_LIMIT_MASK; if (myquota->_do_set_global_block_gracetime || myquota->_do_set_global_inode_gracetime) sysquota.d_fieldmask |= FS_DQ_TIMER_MASK; retval = quotactl(QCMD(Q_XSETQLIM,myquota->_id_type), myquota->_qfile, myquota->_id, (caddr_t) &sysquota); if (retval < 0) { output_error ("Failed setting quota (xfs): %s", strerror(errno)); return(0); } /* success */ return 1; }
/** * FSAL_get_quota : * Gets the quota for a given path. * * \param pfsal_path * path to the filesystem whose quota are requested * \param quota_type * the kind of requested quota (user or group) * \param fsal_uid * uid for the user whose quota are requested * \param pquota (input): * Parameter to the structure containing the requested quotas * * \return Major error codes : * - ERR_FSAL_NO_ERROR (no error) * - Another error code if an error occured. */ fsal_status_t COMMON_get_quota(fsal_path_t * pfsal_path, /* IN */ int quota_type, /* IN */ fsal_uid_t fsal_uid, /* IN */ fsal_quota_t * pquota) /* OUT */ { struct dqblk fs_quota; char fs_spec[MAXPATHLEN]; if(!pfsal_path || !pquota) ReturnCode(ERR_FSAL_FAULT, 0); if(fsal_internal_path2fsname(pfsal_path->path, fs_spec) == -1) ReturnCode(ERR_FSAL_INVAL, 0); memset((char *)&fs_quota, 0, sizeof(struct dqblk)); if(quotactl(FSAL_QCMD(Q_GETQUOTA, quota_type), fs_spec, fsal_uid, (caddr_t) & fs_quota) < 0) ReturnCode(posix2fsal_error(errno), errno); /* Convert XFS structure to FSAL one */ pquota->bhardlimit = fs_quota.dqb_bhardlimit; pquota->bsoftlimit = fs_quota.dqb_bsoftlimit; pquota->curblocks = fs_quota.dqb_curspace; pquota->fhardlimit = fs_quota.dqb_ihardlimit; pquota->curfiles = fs_quota.dqb_curinodes; pquota->btimeleft = fs_quota.dqb_btime; pquota->ftimeleft = fs_quota.dqb_itime; pquota->bsize = DEV_BSIZE; ReturnCode(ERR_FSAL_NO_ERROR, 0); } /* FSAL_get_quota */
static int old_quota_get (quota_t *myquota) { struct old_kern_dqblk sysquota; int retval; retval = quotactl(QCMD(Q_OLD_GETQUOTA,myquota->_id_type), myquota->_qfile, myquota->_id, (caddr_t) &sysquota); if ( retval < 0 ) { output_error ("Failed fetching quotas (old): %s", strerror(errno)); return 0; } /* copy the linux-formatted quota info into our struct */ myquota->block_hard = sysquota.dqb_bhardlimit; myquota->block_soft = sysquota.dqb_bsoftlimit; myquota->diskspace_used = sysquota.dqb_curblocks; myquota->inode_hard = sysquota.dqb_ihardlimit; myquota->inode_soft = sysquota.dqb_isoftlimit; myquota->inode_used = sysquota.dqb_curinodes; myquota->block_time = sysquota.dqb_btime; myquota->inode_time = sysquota.dqb_itime; /* yes, something fishy here. quota old seems to lack separate fields for user grace times and global grace times. is it like XFS - root's limits sets global? */ myquota->block_grace = sysquota.dqb_btime; myquota->inode_grace = sysquota.dqb_itime; return 1; }
/** * Prints relevant quota information to stdout for the supplied uid. * On failure, will attempt to print a helpful error messge to stderr. * * @param filesystem Filesystem to report quota information for * @param uid Uid to report quota information for * * @return -1 on error, 0 otherwise */ static int print_quota_usage(const char* filesystem, int uid) { assert(NULL != filesystem); char emsg[1024]; struct dqblk quota_info; memset("a_info, 0, sizeof(quota_info)); if (quotactl(QCMD(Q_GETQUOTA, USRQUOTA), filesystem, uid, (caddr_t) "a_info) < 0) { sprintf(emsg, "Failed retrieving quota for uid=%d", uid); print_quotactl_error(emsg); return -1; } printf("%d ", uid); /* Block info */ printf("%llu %llu %llu %llu ", (long long unsigned int) quota_info.dqb_curspace, (long long unsigned int) quota_info.dqb_bsoftlimit, (long long unsigned int) quota_info.dqb_bhardlimit, (long long unsigned int) quota_info.dqb_btime); /* Inode info */ printf("%llu %llu %llu %llu\n", (long long unsigned int) quota_info.dqb_curinodes, (long long unsigned int) quota_info.dqb_isoftlimit, (long long unsigned int) quota_info.dqb_ihardlimit, (long long unsigned int) quota_info.dqb_itime); return 0; }
static void verify_quota(void) { struct fs_disk_quota res_dquota; res_dquota.d_id = 1; TEST(quotactl(QCMD(Q_XGETNEXTQUOTA, USRQUOTA), tst_device->dev, test_id, (void *)&res_dquota)); if (TST_RET != -1) { tst_res(TFAIL, "quotactl() found the next active ID:" " %u unexpectedly", res_dquota.d_id); return; } if (TST_ERR == EINVAL) { tst_brk(TCONF | TTERRNO, "Q_XGETNEXTQUOTA wasn't supported in quotactl()"); } if (TST_ERR != ENOENT) { tst_res(TFAIL | TTERRNO, "quotactl() failed unexpectedly with" " %s expected ENOENT", tst_strerrno(TST_ERR)); } else { tst_res(TPASS, "quotactl() failed with ENOENT as expected"); } }
/* * do_quotactl() * do a quotactl command */ static void do_quotactl( const char *name, const int flag, const char *cmdname, int *tested, int *failed, int *enosys, int cmd, const char *special, int id, caddr_t addr) { static int failed_mask = 0; int ret = quotactl(cmd, special, id, addr); (*tested)++; if (ret < 0) { if ((failed_mask & flag) == 0) { /* Just issue the warning once, reduce log spamming */ failed_mask |= flag; pr_fail(stderr, "%s: quotactl command %s failed: errno=%d (%s)\n", name, cmdname, errno, strerror(errno)); } if (errno == ENOSYS) (*enosys)++; else (*failed)++; } }
static void check_qlim(int subcmd, char *desp) { int res; static struct fs_disk_quota res_dquota; res_dquota.d_rtb_softlimit = 0; res = quotactl(QCMD(subcmd, USRQUOTA), tst_device->dev, test_id, (void*) &res_dquota); if (res == -1) { if (errno == EINVAL) { tst_brk(TCONF | TERRNO, "%s wasn't supported in quotactl()", desp); } tst_res(TFAIL | TERRNO, "quotactl() failed to get xfs disk quota limits"); return; } if (res_dquota.d_id != test_id) { tst_res(TFAIL, "quotactl() got unexpected user id %u," " expected %u", res_dquota.d_id, test_id); return; } if (res_dquota.d_rtb_hardlimit != set_dquota.d_rtb_hardlimit) { tst_res(TFAIL, "quotactl() got unexpected rtb soft limit %llu," " expected %llu", res_dquota.d_rtb_hardlimit, set_dquota.d_rtb_hardlimit); return; } tst_res(TPASS, "quoactl() succeeded to set and use %s to get xfs disk " "quota limits", desp); }
int quota_on(struct quotafile *qf) { int qcmd; qcmd = QCMD(Q_QUOTAON, qf->quotatype); return (quotactl(qf->fsname, qcmd, 0, qf->qfname)); }
int autoconf_quota(void) { int ret = -1; struct q_request request; ret = quotactl("/", Q_GETQUOTA, &request); return ret; }
int autoconf_quota(void) { int ret = -1; struct dqblk D; ret = quotactl("/",Q_GETQUOTA,0,(char *) &D); return ret; }
int is_quota_on(ext2_filsys fs, int type) { char tmp[1024]; qid_t id = (type == USRQUOTA) ? getuid() : getgid(); if (!quotactl(QCMD(Q_V2_GETQUOTA, type), fs->device_name, id, tmp)) return 1; return 0; }
int quota_write_limits(struct quotafile *qf, struct dqblk *dqb, int id) { struct dqblk dqbuf; int qcmd; if (qf->fd == -1) { qcmd = QCMD(Q_SETQUOTA, qf->quotatype); return (quotactl(qf->fsname, qcmd, id, dqb)); } /* * Have to do read-modify-write of quota in file. */ if ((qf->accmode & O_RDWR) != O_RDWR) { errno = EBADF; return (-1); } if (quota_read(qf, &dqbuf, id) != 0) return (-1); /* * Reset time limit if have a soft limit and were * previously under it, but are now over it * or if there previously was no soft limit, but * now have one and are over it. */ if (dqbuf.dqb_bsoftlimit && id != 0 && dqbuf.dqb_curblocks < dqbuf.dqb_bsoftlimit && dqbuf.dqb_curblocks >= dqb->dqb_bsoftlimit) dqb->dqb_btime = 0; if (dqbuf.dqb_bsoftlimit == 0 && id != 0 && dqb->dqb_bsoftlimit > 0 && dqbuf.dqb_curblocks >= dqb->dqb_bsoftlimit) dqb->dqb_btime = 0; if (dqbuf.dqb_isoftlimit && id != 0 && dqbuf.dqb_curinodes < dqbuf.dqb_isoftlimit && dqbuf.dqb_curinodes >= dqb->dqb_isoftlimit) dqb->dqb_itime = 0; if (dqbuf.dqb_isoftlimit == 0 && id !=0 && dqb->dqb_isoftlimit > 0 && dqbuf.dqb_curinodes >= dqb->dqb_isoftlimit) dqb->dqb_itime = 0; dqb->dqb_curinodes = dqbuf.dqb_curinodes; dqb->dqb_curblocks = dqbuf.dqb_curblocks; /* * Write it back. */ switch (qf->wordsize) { case 32: return (quota_write32(qf, dqb, id)); case 64: return (quota_write64(qf, dqb, id)); default: errno = EINVAL; return (-1); } /* not reached */ }
int autoconf_quota(void) { int ret = -1; struct SYS_DQBLK D; ret = quotactl(Q_GETQUOTA,"/dev/hda1",0,(void *)&D); return ret; }
BOOL disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize) { int r, save_errno; struct dqblk D; SMB_STRUCT_STAT S; uid_t euser_id; /* * This code presumes that OSF1 will only * give out quota info when the real uid * matches the effective uid. JRA. */ euser_id = geteuid(); save_re_uid(); if (set_re_uid() != 0) return False; r= quotactl(path,QCMD(Q_GETQUOTA, USRQUOTA),euser_id,(char *) &D); if (r) { save_errno = errno; } restore_re_uid(); *bsize = DEV_BSIZE; if (r) { if (save_errno == EDQUOT) /* disk quota exceeded */ { *dfree = 0; *dsize = D.dqb_curblocks; return (True); } else return (False); } /* If softlimit is zero, set it equal to hardlimit. */ if (D.dqb_bsoftlimit==0) D.dqb_bsoftlimit = D.dqb_bhardlimit; /* Use softlimit to determine disk space, except when it has been exceeded */ if (D.dqb_bsoftlimit==0) return(False); if ((D.dqb_curblocks>D.dqb_bsoftlimit)) { *dfree = 0; *dsize = D.dqb_curblocks; } else { *dfree = D.dqb_bsoftlimit - D.dqb_curblocks; *dsize = D.dqb_bsoftlimit; } return (True); }
/* Get dquot from kernel */ int vfs_get_dquot(struct dquot *dquot) { struct if_dqblk kdqblk; if (quotactl(QCMD(Q_GETQUOTA, dquot->dq_h->qh_type), dquot->dq_h->qh_quotadev, dquot->dq_id, (void *)&kdqblk) < 0) { errstr(_("Cannot get quota for %s %d from kernel on %s: %s\n"), type2name(dquot->dq_h->qh_type), dquot->dq_id, dquot->dq_h->qh_quotadev, strerror(errno)); return -1; } generic_kern2utildqblk(&dquot->dq_dqb, &kdqblk); return 0; }
/* Get info from kernel to handle */ int vfs_get_info(struct quota_handle *h) { struct if_dqinfo kinfo; if (quotactl(QCMD(Q_GETINFO, h->qh_type), h->qh_quotadev, 0, (void *)&kinfo) < 0) { errstr(_("Cannot get info for %s quota file from kernel on %s: %s\n"), type2name(h->qh_type), h->qh_quotadev, strerror(errno)); return -1; } h->qh_info.dqi_bgrace = kinfo.dqi_bgrace; h->qh_info.dqi_igrace = kinfo.dqi_igrace; return 0; }
/* Set dquot in kernel */ int vfs_set_dquot(struct dquot *dquot, int flags) { struct if_dqblk kdqblk; generic_util2kerndqblk(&kdqblk, &dquot->dq_dqb); kdqblk.dqb_valid = flags; if (quotactl(QCMD(Q_SETQUOTA, dquot->dq_h->qh_type), dquot->dq_h->qh_quotadev, dquot->dq_id, (void *)&kdqblk) < 0) { errstr(_("Cannot set quota for %s %d from kernel on %s: %s\n"), type2name(dquot->dq_h->qh_type), dquot->dq_id, dquot->dq_h->qh_quotadev, strerror(errno)); return -1; } return 0; }
static void verify_quota(unsigned int n) { struct t_case *tc = &tcases[n]; TEST(quotactl(tc->cmd, tst_device->dev, test_id, tc->addr)); if (TEST_RETURN == -1) { tst_res(TFAIL | TTERRNO, "quotactl() failed to %s", tc->des); return; } tc->func_check(tc->des); }
int xfsquotactl( int command, const char *device, uint type, uint id, void *addr) { int qcommand; qcommand = xcommand_to_qcommand(command, type); return quotactl(qcommand, (char *)device, id, addr); }
int quota_set (quota_t *myquota){ struct dqblk sysquota; int retval; if ( geteuid() != 0 ) { output_error ("Only root can set quotas"); return 0; } // FIXME: remove debug //output_info ("Setting quota soft/hard: %llu, %llu\n", myquota->block_soft, myquota->block_hard); sysquota.dqb_bhardlimit = myquota->block_hard; sysquota.dqb_bsoftlimit = myquota->block_soft; sysquota.dqb_curbytes = myquota->diskspace_used; sysquota.dqb_ihardlimit = myquota->inode_hard; sysquota.dqb_isoftlimit = myquota->inode_soft; sysquota.dqb_curinodes = myquota->inode_used; sysquota.dqb_btime = (int32_t) myquota->block_grace; sysquota.dqb_itime = (int32_t) myquota->inode_grace; /* make the syscall */ retval = quotactl (myquota->_qfile, QCMD(Q_SETQUOTA, myquota->_id_type), myquota->_id, (caddr_t) &sysquota); if ( retval < 0 ) { output_error ("Failed setting quota: %s", strerror (errno)); return 0; } retval = quotactl (myquota->_qfile, QCMD(Q_SYNC, myquota->_id_type), 0, NULL); if ( retval < 0 ) { output_error ("Failed syncing quotas on %s: %s", myquota->_qfile, strerror (errno)); return 0; } return 1; }