URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [quota.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * Quota code necessary even when VFS quota support is not compiled
 * into the kernel.  The interesting stuff is over in dquot.c, here
 * we have symbols for initial quotactl(2) handling, the sysctl(2)
 * variables, etc - things needed even when quota support disabled.
 */
 
#include <linux/fs.h>
#include <linux/slab.h>
#include <asm/current.h>
#include <asm/uaccess.h>
#include <linux/kernel.h>
#include <linux/smp_lock.h>
#include <linux/quotaops.h>
#include <linux/quotacompat.h>
 
struct dqstats dqstats;
 
/* Check validity of quotactl */
static int check_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id)
{
        if (type >= MAXQUOTAS)
                return -EINVAL;
        if (!sb && cmd != Q_SYNC)
                return -ENODEV;
        /* Is operation supported? */
        if (sb && !sb->s_qcop)
                return -ENOSYS;
 
        switch (cmd) {
                case Q_GETFMT:
                        break;
                case Q_QUOTAON:
                        if (!sb->s_qcop->quota_on)
                                return -ENOSYS;
                        break;
                case Q_QUOTAOFF:
                        if (!sb->s_qcop->quota_off)
                                return -ENOSYS;
                        break;
                case Q_SETINFO:
                        if (!sb->s_qcop->set_info)
                                return -ENOSYS;
                        break;
                case Q_GETINFO:
                        if (!sb->s_qcop->get_info)
                                return -ENOSYS;
                        break;
                case Q_SETQUOTA:
                        if (!sb->s_qcop->set_dqblk)
                                return -ENOSYS;
                        break;
                case Q_GETQUOTA:
                        if (!sb->s_qcop->get_dqblk)
                                return -ENOSYS;
                        break;
                case Q_SYNC:
                        if (sb && !sb->s_qcop->quota_sync)
                                return -ENOSYS;
                        break;
                case Q_XQUOTAON:
                case Q_XQUOTAOFF:
                case Q_XQUOTARM:
                        if (!sb->s_qcop->set_xstate)
                                return -ENOSYS;
                        break;
                case Q_XGETQSTAT:
                        if (!sb->s_qcop->get_xstate)
                                return -ENOSYS;
                        break;
                case Q_XSETQLIM:
                        if (!sb->s_qcop->set_xquota)
                                return -ENOSYS;
                        break;
                case Q_XGETQUOTA:
                        if (!sb->s_qcop->get_xquota)
                                return -ENOSYS;
                        break;
                default:
                        return -EINVAL;
        }
 
        /* Is quota turned on for commands which need it? */
        switch (cmd) {
                case Q_GETFMT:
                case Q_GETINFO:
                case Q_QUOTAOFF:
                case Q_SETINFO:
                case Q_SETQUOTA:
                case Q_GETQUOTA:
                        if (!sb_has_quota_enabled(sb, type))
                                return -ESRCH;
        }
        /* Check privileges */
        if (cmd == Q_GETQUOTA || cmd == Q_XGETQUOTA) {
                if (((type == USRQUOTA && current->euid != id) ||
                     (type == GRPQUOTA && !in_egroup_p(id))) &&
                    !capable(CAP_SYS_ADMIN))
                        return -EPERM;
        }
        else if (cmd != Q_GETFMT && cmd != Q_SYNC && cmd != Q_GETINFO && cmd != Q_XGETQSTAT)
                if (!capable(CAP_SYS_ADMIN))
                        return -EPERM;
        return 0;
}
 
/* Resolve device pathname to superblock */
static struct super_block *resolve_dev(const char *path)
{
        int ret;
        mode_t mode;
        struct nameidata nd;
        kdev_t dev;
        struct super_block *sb;
 
        ret = user_path_walk(path, &nd);
        if (ret)
                goto out;
 
        dev = nd.dentry->d_inode->i_rdev;
        mode = nd.dentry->d_inode->i_mode;
        path_release(&nd);
 
        ret = -ENOTBLK;
        if (!S_ISBLK(mode))
                goto out;
        ret = -ENODEV;
        sb = get_super(dev);
        if (!sb)
                goto out;
        return sb;
out:
        return ERR_PTR(ret);
}
 
/* Copy parameters and call proper function */
static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, caddr_t addr)
{
        int ret;
 
        switch (cmd) {
                case Q_QUOTAON: {
                        char *pathname;
 
                        if (IS_ERR(pathname = getname(addr)))
                                return PTR_ERR(pathname);
                        ret = sb->s_qcop->quota_on(sb, type, id, pathname);
                        putname(pathname);
                        return ret;
                }
                case Q_QUOTAOFF:
                        return sb->s_qcop->quota_off(sb, type);
 
                case Q_GETFMT: {
                        __u32 fmt;
 
                        fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
                        if (copy_to_user(addr, &fmt, sizeof(fmt)))
                                return -EFAULT;
                        return 0;
                }
                case Q_GETINFO: {
                        struct if_dqinfo info;
 
                        if ((ret = sb->s_qcop->get_info(sb, type, &info)))
                                return ret;
                        if (copy_to_user(addr, &info, sizeof(info)))
                                return -EFAULT;
                        return 0;
                }
                case Q_SETINFO: {
                        struct if_dqinfo info;
 
                        if (copy_from_user(&info, addr, sizeof(info)))
                                return -EFAULT;
                        return sb->s_qcop->set_info(sb, type, &info);
                }
                case Q_GETQUOTA: {
                        struct if_dqblk idq;
 
                        if ((ret = sb->s_qcop->get_dqblk(sb, type, id, &idq)))
                                return ret;
                        if (copy_to_user(addr, &idq, sizeof(idq)))
                                return -EFAULT;
                        return 0;
                }
                case Q_SETQUOTA: {
                        struct if_dqblk idq;
 
                        if (copy_from_user(&idq, addr, sizeof(idq)))
                                return -EFAULT;
                        return sb->s_qcop->set_dqblk(sb, type, id, &idq);
                }
                case Q_SYNC:
                        if (sb)
                                return sb->s_qcop->quota_sync(sb, type);
                        sync_dquots_dev(NODEV, type);
                        return 0;
                case Q_XQUOTAON:
                case Q_XQUOTAOFF:
                case Q_XQUOTARM: {
                        __u32 flags;
 
                        if (copy_from_user(&flags, addr, sizeof(flags)))
                                return -EFAULT;
                        return sb->s_qcop->set_xstate(sb, flags, cmd);
                }
                case Q_XGETQSTAT: {
                        struct fs_quota_stat fqs;
 
                        if ((ret = sb->s_qcop->get_xstate(sb, &fqs)))
                                return ret;
                        if (copy_to_user(addr, &fqs, sizeof(fqs)))
                                return -EFAULT;
                        return 0;
                }
                case Q_XSETQLIM: {
                        struct fs_disk_quota fdq;
 
                        if (copy_from_user(&fdq, addr, sizeof(fdq)))
                                return -EFAULT;
                       return sb->s_qcop->set_xquota(sb, type, id, &fdq);
                }
                case Q_XGETQUOTA: {
                        struct fs_disk_quota fdq;
 
                        if ((ret = sb->s_qcop->get_xquota(sb, type, id, &fdq)))
                                return ret;
                        if (copy_to_user(addr, &fdq, sizeof(fdq)))
                                return -EFAULT;
                        return 0;
                }
                /* We never reach here unless validity check is broken */
                default:
                        BUG();
        }
        return 0;
}
 
static int check_compat_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id)
{
        if (type >= MAXQUOTAS)
                return -EINVAL;
        /* Is operation supported? */
        /* sb==NULL for GETSTATS calls */
        if (sb && !sb->s_qcop)
                return -ENOSYS;
 
        switch (cmd) {
                case Q_COMP_QUOTAON:
                        if (!sb->s_qcop->quota_on)
                                return -ENOSYS;
                        break;
                case Q_COMP_QUOTAOFF:
                        if (!sb->s_qcop->quota_off)
                                return -ENOSYS;
                        break;
                case Q_COMP_SYNC:
                        if (sb && !sb->s_qcop->quota_sync)
                                return -ENOSYS;
                        break;
                case Q_V1_SETQLIM:
                case Q_V1_SETUSE:
                case Q_V1_SETQUOTA:
                        if (!sb->s_qcop->set_dqblk)
                                return -ENOSYS;
                        break;
                case Q_V1_GETQUOTA:
                        if (!sb->s_qcop->get_dqblk)
                                return -ENOSYS;
                        break;
                case Q_V1_RSQUASH:
                        if (!sb->s_qcop->set_info)
                                return -ENOSYS;
                        break;
                case Q_V1_GETSTATS:
                        return 0;        /* GETSTATS need no other checks */
                default:
                        return -EINVAL;
        }
 
        /* Is quota turned on for commands which need it? */
        switch (cmd) {
                case Q_V2_SETFLAGS:
                case Q_V2_SETGRACE:
                case Q_V2_SETINFO:
                case Q_V2_GETINFO:
                case Q_COMP_QUOTAOFF:
                case Q_V1_RSQUASH:
                case Q_V1_SETQUOTA:
                case Q_V1_SETQLIM:
                case Q_V1_SETUSE:
                case Q_V2_SETQUOTA:
                /* Q_V2_SETQLIM: collision with Q_V1_SETQLIM */
                case Q_V2_SETUSE:
                case Q_V1_GETQUOTA:
                case Q_V2_GETQUOTA:
                        if (!sb_has_quota_enabled(sb, type))
                                return -ESRCH;
        }
        if (cmd != Q_COMP_QUOTAON &&
            cmd != Q_COMP_QUOTAOFF &&
            cmd != Q_COMP_SYNC &&
            sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id != QFMT_VFS_OLD)
                return -ESRCH;
 
        /* Check privileges */
        if (cmd == Q_V1_GETQUOTA || cmd == Q_V2_GETQUOTA) {
                if (((type == USRQUOTA && current->euid != id) ||
                     (type == GRPQUOTA && !in_egroup_p(id))) &&
                    !capable(CAP_SYS_ADMIN))
                        return -EPERM;
        }
        else if (cmd != Q_V1_GETSTATS && cmd != Q_V2_GETSTATS && cmd != Q_V2_GETINFO && cmd != Q_COMP_SYNC)
                if (!capable(CAP_SYS_ADMIN))
                        return -EPERM;
        return 0;
}
 
static int v1_set_rsquash(struct super_block *sb, int type, int flag)
{
        struct if_dqinfo info;
 
        info.dqi_valid = IIF_FLAGS;
        info.dqi_flags = flag ? V1_DQF_RSQUASH : 0;
        return sb->s_qcop->set_info(sb, type, &info);
}
 
static int v1_get_dqblk(struct super_block *sb, int type, qid_t id, struct v1c_mem_dqblk *mdq)
{
        struct if_dqblk idq;
        int ret;
 
        if ((ret = sb->s_qcop->get_dqblk(sb, type, id, &idq)) < 0)
                return ret;
        mdq->dqb_ihardlimit = idq.dqb_ihardlimit;
        mdq->dqb_isoftlimit = idq.dqb_isoftlimit;
        mdq->dqb_curinodes = idq.dqb_curinodes;
        mdq->dqb_bhardlimit = idq.dqb_bhardlimit;
        mdq->dqb_bsoftlimit = idq.dqb_bsoftlimit;
        mdq->dqb_curblocks = toqb(idq.dqb_curspace);
        mdq->dqb_itime = idq.dqb_itime;
        mdq->dqb_btime = idq.dqb_btime;
        if (id == 0) {   /* Times for id 0 are in fact grace times */
                struct if_dqinfo info;
 
                if ((ret = sb->s_qcop->get_info(sb, type, &info)) < 0)
                        return ret;
                mdq->dqb_btime = info.dqi_bgrace;
                mdq->dqb_itime = info.dqi_igrace;
        }
        return 0;
}
 
static int v1_set_dqblk(struct super_block *sb, int type, int cmd, qid_t id, struct v1c_mem_dqblk *mdq)
{
        struct if_dqblk idq;
        int ret;
 
        idq.dqb_valid = 0;
        if (cmd == Q_V1_SETQUOTA || cmd == Q_V1_SETQLIM) {
                idq.dqb_ihardlimit = mdq->dqb_ihardlimit;
                idq.dqb_isoftlimit = mdq->dqb_isoftlimit;
                idq.dqb_bhardlimit = mdq->dqb_bhardlimit;
                idq.dqb_bsoftlimit = mdq->dqb_bsoftlimit;
                idq.dqb_valid |= QIF_LIMITS;
        }
        if (cmd == Q_V1_SETQUOTA || cmd == Q_V1_SETUSE) {
                idq.dqb_curinodes = mdq->dqb_curinodes;
                idq.dqb_curspace = ((qsize_t)mdq->dqb_curblocks) << QUOTABLOCK_BITS;
                idq.dqb_valid |= QIF_USAGE;
        }
        ret = sb->s_qcop->set_dqblk(sb, type, id, &idq);
        if (!ret && id == 0 && cmd == Q_V1_SETQUOTA) {   /* Times for id 0 are in fact grace times */
                struct if_dqinfo info;
 
                info.dqi_bgrace = mdq->dqb_btime;
                info.dqi_igrace = mdq->dqb_itime;
                info.dqi_valid = IIF_BGRACE | IIF_IGRACE;
                ret = sb->s_qcop->set_info(sb, type, &info);
        }
        return ret;
}
 
static void v1_get_stats(struct v1c_dqstats *dst)
{
        memcpy(dst, &dqstats, sizeof(dqstats));
}
 
/* Handle requests to old interface */
static int do_compat_quotactl(struct super_block *sb, int type, int cmd, qid_t id, caddr_t addr)
{
        int ret;
 
        switch (cmd) {
                case Q_COMP_QUOTAON: {
                        char *pathname;
 
                        if (IS_ERR(pathname = getname(addr)))
                                return PTR_ERR(pathname);
                        ret = sb->s_qcop->quota_on(sb, type, QFMT_VFS_OLD, pathname);
                        putname(pathname);
                        return ret;
                }
                case Q_COMP_QUOTAOFF:
                        return sb->s_qcop->quota_off(sb, type);
                case Q_COMP_SYNC:
                        if (sb)
                                return sb->s_qcop->quota_sync(sb, type);
                        sync_dquots_dev(NODEV, type);
                        return 0;
                case Q_V1_RSQUASH: {
                        int flag;
 
                        if (copy_from_user(&flag, addr, sizeof(flag)))
                                return -EFAULT;
                        return v1_set_rsquash(sb, type, flag);
                }
                case Q_V1_GETQUOTA: {
                        struct v1c_mem_dqblk mdq;
 
                        if ((ret = v1_get_dqblk(sb, type, id, &mdq)))
                                return ret;
                        if (copy_to_user(addr, &mdq, sizeof(mdq)))
                                return -EFAULT;
                        return 0;
                }
                case Q_V1_SETQLIM:
                case Q_V1_SETUSE:
                case Q_V1_SETQUOTA: {
                        struct v1c_mem_dqblk mdq;
 
                        if (copy_from_user(&mdq, addr, sizeof(mdq)))
                                return -EFAULT;
                        return v1_set_dqblk(sb, type, cmd, id, &mdq);
                }
                case Q_V1_GETSTATS: {
                        struct v1c_dqstats dst;
 
                        v1_get_stats(&dst);
                        if (copy_to_user(addr, &dst, sizeof(dst)))
                                return -EFAULT;
                        return 0;
                }
        }
        BUG();
        return 0;
}
 
/* Macros for short-circuiting the compatibility tests */
#define NEW_COMMAND(c) ((c) & (0x80 << 16))
#define XQM_COMMAND(c) (((c) & ('X' << 8)) == ('X' << 8))
 
/*
 * This is the system call interface. This communicates with
 * the user-level programs. Currently this only supports diskquota
 * calls. Maybe we need to add the process quotas etc. in the future,
 * but we probably should use rlimits for that.
 */
asmlinkage long sys_quotactl(unsigned int cmd, const char *special, qid_t id, caddr_t addr)
{
        uint cmds, type;
        struct super_block *sb = NULL;
        int ret = -EINVAL;
 
        lock_kernel();
        cmds = cmd >> SUBCMDSHIFT;
        type = cmd & SUBCMDMASK;
 
        if (cmds != Q_V1_GETSTATS && cmds != Q_V2_GETSTATS && IS_ERR(sb = resolve_dev(special))) {
                ret = PTR_ERR(sb);
                sb = NULL;
                goto out;
        }
        if (!NEW_COMMAND(cmds) && !XQM_COMMAND(cmds)) {
                if ((ret = check_compat_quotactl_valid(sb, type, cmds, id)) < 0)
                        goto out;
                ret = do_compat_quotactl(sb, type, cmds, id, addr);
                goto out;
        }
        if ((ret = check_quotactl_valid(sb, type, cmds, id)) < 0)
                goto out;
        ret = do_quotactl(sb, type, cmds, id, addr);
out:
        if (sb)
                drop_super(sb);
        unlock_kernel();
        return ret;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [quota.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* Quota code necessary even when VFS quota support is not compiled`
3			`* into the kernel. The interesting stuff is over in dquot.c, here`
4			`* we have symbols for initial quotactl(2) handling, the sysctl(2)`
5			`* variables, etc - things needed even when quota support disabled.`
6			`*/`
7
8			`#include <linux/fs.h>`
9			`#include <linux/slab.h>`
10			`#include <asm/current.h>`
11			`#include <asm/uaccess.h>`
12			`#include <linux/kernel.h>`
13			`#include <linux/smp_lock.h>`
14			`#include <linux/quotaops.h>`
15			`#include <linux/quotacompat.h>`
16
17			`struct dqstats dqstats;`
18
19			`/* Check validity of quotactl */`
20			`static int check_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id)`
21			`{`
22			`if (type >= MAXQUOTAS)`
23			`return -EINVAL;`
24			`if (!sb && cmd != Q_SYNC)`
25			`return -ENODEV;`
26			`/* Is operation supported? */`
27			`if (sb && !sb->s_qcop)`
28			`return -ENOSYS;`
29
30			`switch (cmd) {`
31			`case Q_GETFMT:`
32			`break;`
33			`case Q_QUOTAON:`
34			`if (!sb->s_qcop->quota_on)`
35			`return -ENOSYS;`
36			`break;`
37			`case Q_QUOTAOFF:`
38			`if (!sb->s_qcop->quota_off)`
39			`return -ENOSYS;`
40			`break;`
41			`case Q_SETINFO:`
42			`if (!sb->s_qcop->set_info)`
43			`return -ENOSYS;`
44			`break;`
45			`case Q_GETINFO:`
46			`if (!sb->s_qcop->get_info)`
47			`return -ENOSYS;`
48			`break;`
49			`case Q_SETQUOTA:`
50			`if (!sb->s_qcop->set_dqblk)`
51			`return -ENOSYS;`
52			`break;`
53			`case Q_GETQUOTA:`
54			`if (!sb->s_qcop->get_dqblk)`
55			`return -ENOSYS;`
56			`break;`
57			`case Q_SYNC:`
58			`if (sb && !sb->s_qcop->quota_sync)`
59			`return -ENOSYS;`
60			`break;`
61			`case Q_XQUOTAON:`
62			`case Q_XQUOTAOFF:`
63			`case Q_XQUOTARM:`
64			`if (!sb->s_qcop->set_xstate)`
65			`return -ENOSYS;`
66			`break;`
67			`case Q_XGETQSTAT:`
68			`if (!sb->s_qcop->get_xstate)`
69			`return -ENOSYS;`
70			`break;`
71			`case Q_XSETQLIM:`
72			`if (!sb->s_qcop->set_xquota)`
73			`return -ENOSYS;`
74			`break;`
75			`case Q_XGETQUOTA:`
76			`if (!sb->s_qcop->get_xquota)`
77			`return -ENOSYS;`
78			`break;`
79			`default:`
80			`return -EINVAL;`
81			`}`
82
83			`/* Is quota turned on for commands which need it? */`
84			`switch (cmd) {`
85			`case Q_GETFMT:`
86			`case Q_GETINFO:`
87			`case Q_QUOTAOFF:`
88			`case Q_SETINFO:`
89			`case Q_SETQUOTA:`
90			`case Q_GETQUOTA:`
91			`if (!sb_has_quota_enabled(sb, type))`
92			`return -ESRCH;`
93			`}`
94			`/* Check privileges */`
95			`if (cmd == Q_GETQUOTA \|\| cmd == Q_XGETQUOTA) {`
96			`if (((type == USRQUOTA && current->euid != id) \|\|`
97			`(type == GRPQUOTA && !in_egroup_p(id))) &&`
98			`!capable(CAP_SYS_ADMIN))`
99			`return -EPERM;`
100			`}`
101			`else if (cmd != Q_GETFMT && cmd != Q_SYNC && cmd != Q_GETINFO && cmd != Q_XGETQSTAT)`
102			`if (!capable(CAP_SYS_ADMIN))`
103			`return -EPERM;`
104			`return 0;`
105			`}`
106
107			`/* Resolve device pathname to superblock */`
108			`static struct super_block resolve_dev(const char path)`
109			`{`
110			`int ret;`
111			`mode_t mode;`
112			`struct nameidata nd;`
113			`kdev_t dev;`
114			`struct super_block *sb;`
115
116			`ret = user_path_walk(path, &nd);`
117			`if (ret)`
118			`goto out;`
119
120			`dev = nd.dentry->d_inode->i_rdev;`
121			`mode = nd.dentry->d_inode->i_mode;`
122			`path_release(&nd);`
123
124			`ret = -ENOTBLK;`
125			`if (!S_ISBLK(mode))`
126			`goto out;`
127			`ret = -ENODEV;`
128			`sb = get_super(dev);`
129			`if (!sb)`
130			`goto out;`
131			`return sb;`
132			`out:`
133			`return ERR_PTR(ret);`
134			`}`
135
136			`/* Copy parameters and call proper function */`
137			`static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, caddr_t addr)`
138			`{`
139			`int ret;`
140
141			`switch (cmd) {`
142			`case Q_QUOTAON: {`
143			`char *pathname;`
144
145			`if (IS_ERR(pathname = getname(addr)))`
146			`return PTR_ERR(pathname);`
147			`ret = sb->s_qcop->quota_on(sb, type, id, pathname);`
148			`putname(pathname);`
149			`return ret;`
150			`}`
151			`case Q_QUOTAOFF:`
152			`return sb->s_qcop->quota_off(sb, type);`
153
154			`case Q_GETFMT: {`
155			`__u32 fmt;`
156
157			`fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;`
158			`if (copy_to_user(addr, &fmt, sizeof(fmt)))`
159			`return -EFAULT;`
160			`return 0;`
161			`}`
162			`case Q_GETINFO: {`
163			`struct if_dqinfo info;`
164
165			`if ((ret = sb->s_qcop->get_info(sb, type, &info)))`
166			`return ret;`
167			`if (copy_to_user(addr, &info, sizeof(info)))`
168			`return -EFAULT;`
169			`return 0;`
170			`}`
171			`case Q_SETINFO: {`
172			`struct if_dqinfo info;`
173
174			`if (copy_from_user(&info, addr, sizeof(info)))`
175			`return -EFAULT;`
176			`return sb->s_qcop->set_info(sb, type, &info);`
177			`}`
178			`case Q_GETQUOTA: {`
179			`struct if_dqblk idq;`
180
181			`if ((ret = sb->s_qcop->get_dqblk(sb, type, id, &idq)))`
182			`return ret;`
183			`if (copy_to_user(addr, &idq, sizeof(idq)))`
184			`return -EFAULT;`
185			`return 0;`
186			`}`
187			`case Q_SETQUOTA: {`
188			`struct if_dqblk idq;`
189
190			`if (copy_from_user(&idq, addr, sizeof(idq)))`
191			`return -EFAULT;`
192			`return sb->s_qcop->set_dqblk(sb, type, id, &idq);`
193			`}`
194			`case Q_SYNC:`
195			`if (sb)`
196			`return sb->s_qcop->quota_sync(sb, type);`
197			`sync_dquots_dev(NODEV, type);`
198			`return 0;`
199			`case Q_XQUOTAON:`
200			`case Q_XQUOTAOFF:`
201			`case Q_XQUOTARM: {`
202			`__u32 flags;`
203
204			`if (copy_from_user(&flags, addr, sizeof(flags)))`
205			`return -EFAULT;`
206			`return sb->s_qcop->set_xstate(sb, flags, cmd);`
207			`}`
208			`case Q_XGETQSTAT: {`
209			`struct fs_quota_stat fqs;`
210
211			`if ((ret = sb->s_qcop->get_xstate(sb, &fqs)))`
212			`return ret;`
213			`if (copy_to_user(addr, &fqs, sizeof(fqs)))`
214			`return -EFAULT;`
215			`return 0;`
216			`}`
217			`case Q_XSETQLIM: {`
218			`struct fs_disk_quota fdq;`
219
220			`if (copy_from_user(&fdq, addr, sizeof(fdq)))`
221			`return -EFAULT;`
222			`return sb->s_qcop->set_xquota(sb, type, id, &fdq);`
223			`}`
224			`case Q_XGETQUOTA: {`
225			`struct fs_disk_quota fdq;`
226
227			`if ((ret = sb->s_qcop->get_xquota(sb, type, id, &fdq)))`
228			`return ret;`
229			`if (copy_to_user(addr, &fdq, sizeof(fdq)))`
230			`return -EFAULT;`
231			`return 0;`
232			`}`
233			`/* We never reach here unless validity check is broken */`
234			`default:`
235			`BUG();`
236			`}`
237			`return 0;`
238			`}`
239
240			`static int check_compat_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id)`
241			`{`
242			`if (type >= MAXQUOTAS)`
243			`return -EINVAL;`
244			`/* Is operation supported? */`
245			`/* sb==NULL for GETSTATS calls */`
246			`if (sb && !sb->s_qcop)`
247			`return -ENOSYS;`
248
249			`switch (cmd) {`
250			`case Q_COMP_QUOTAON:`
251			`if (!sb->s_qcop->quota_on)`
252			`return -ENOSYS;`
253			`break;`
254			`case Q_COMP_QUOTAOFF:`
255			`if (!sb->s_qcop->quota_off)`
256			`return -ENOSYS;`
257			`break;`
258			`case Q_COMP_SYNC:`
259			`if (sb && !sb->s_qcop->quota_sync)`
260			`return -ENOSYS;`
261			`break;`
262			`case Q_V1_SETQLIM:`
263			`case Q_V1_SETUSE:`
264			`case Q_V1_SETQUOTA:`
265			`if (!sb->s_qcop->set_dqblk)`
266			`return -ENOSYS;`
267			`break;`
268			`case Q_V1_GETQUOTA:`
269			`if (!sb->s_qcop->get_dqblk)`
270			`return -ENOSYS;`
271			`break;`
272			`case Q_V1_RSQUASH:`
273			`if (!sb->s_qcop->set_info)`
274			`return -ENOSYS;`
275			`break;`
276			`case Q_V1_GETSTATS:`
277			`return 0; /* GETSTATS need no other checks */`
278			`default:`
279			`return -EINVAL;`
280			`}`
281
282			`/* Is quota turned on for commands which need it? */`
283			`switch (cmd) {`
284			`case Q_V2_SETFLAGS:`
285			`case Q_V2_SETGRACE:`
286			`case Q_V2_SETINFO:`
287			`case Q_V2_GETINFO:`
288			`case Q_COMP_QUOTAOFF:`
289			`case Q_V1_RSQUASH:`
290			`case Q_V1_SETQUOTA:`
291			`case Q_V1_SETQLIM:`
292			`case Q_V1_SETUSE:`
293			`case Q_V2_SETQUOTA:`
294			`/* Q_V2_SETQLIM: collision with Q_V1_SETQLIM */`
295			`case Q_V2_SETUSE:`
296			`case Q_V1_GETQUOTA:`
297			`case Q_V2_GETQUOTA:`
298			`if (!sb_has_quota_enabled(sb, type))`
299			`return -ESRCH;`
300			`}`
301			`if (cmd != Q_COMP_QUOTAON &&`
302			`cmd != Q_COMP_QUOTAOFF &&`
303			`cmd != Q_COMP_SYNC &&`
304			`sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id != QFMT_VFS_OLD)`
305			`return -ESRCH;`
306
307			`/* Check privileges */`
308			`if (cmd == Q_V1_GETQUOTA \|\| cmd == Q_V2_GETQUOTA) {`
309			`if (((type == USRQUOTA && current->euid != id) \|\|`
310			`(type == GRPQUOTA && !in_egroup_p(id))) &&`
311			`!capable(CAP_SYS_ADMIN))`
312			`return -EPERM;`
313			`}`
314			`else if (cmd != Q_V1_GETSTATS && cmd != Q_V2_GETSTATS && cmd != Q_V2_GETINFO && cmd != Q_COMP_SYNC)`
315			`if (!capable(CAP_SYS_ADMIN))`
316			`return -EPERM;`
317			`return 0;`
318			`}`
319
320			`static int v1_set_rsquash(struct super_block *sb, int type, int flag)`
321			`{`
322			`struct if_dqinfo info;`
323
324			`info.dqi_valid = IIF_FLAGS;`
325			`info.dqi_flags = flag ? V1_DQF_RSQUASH : 0;`
326			`return sb->s_qcop->set_info(sb, type, &info);`
327			`}`
328
329			`static int v1_get_dqblk(struct super_block sb, int type, qid_t id, struct v1c_mem_dqblk mdq)`
330			`{`
331			`struct if_dqblk idq;`
332			`int ret;`
333
334			`if ((ret = sb->s_qcop->get_dqblk(sb, type, id, &idq)) < 0)`
335			`return ret;`
336			`mdq->dqb_ihardlimit = idq.dqb_ihardlimit;`
337			`mdq->dqb_isoftlimit = idq.dqb_isoftlimit;`
338			`mdq->dqb_curinodes = idq.dqb_curinodes;`
339			`mdq->dqb_bhardlimit = idq.dqb_bhardlimit;`
340			`mdq->dqb_bsoftlimit = idq.dqb_bsoftlimit;`
341			`mdq->dqb_curblocks = toqb(idq.dqb_curspace);`
342			`mdq->dqb_itime = idq.dqb_itime;`
343			`mdq->dqb_btime = idq.dqb_btime;`
344			`if (id == 0) { /* Times for id 0 are in fact grace times */`
345			`struct if_dqinfo info;`
346
347			`if ((ret = sb->s_qcop->get_info(sb, type, &info)) < 0)`
348			`return ret;`
349			`mdq->dqb_btime = info.dqi_bgrace;`
350			`mdq->dqb_itime = info.dqi_igrace;`
351			`}`
352			`return 0;`
353			`}`
354
355			`static int v1_set_dqblk(struct super_block sb, int type, int cmd, qid_t id, struct v1c_mem_dqblk mdq)`
356			`{`
357			`struct if_dqblk idq;`
358			`int ret;`
359
360			`idq.dqb_valid = 0;`
361			`if (cmd == Q_V1_SETQUOTA \|\| cmd == Q_V1_SETQLIM) {`
362			`idq.dqb_ihardlimit = mdq->dqb_ihardlimit;`
363			`idq.dqb_isoftlimit = mdq->dqb_isoftlimit;`
364			`idq.dqb_bhardlimit = mdq->dqb_bhardlimit;`
365			`idq.dqb_bsoftlimit = mdq->dqb_bsoftlimit;`
366			`idq.dqb_valid \|= QIF_LIMITS;`
367			`}`
368			`if (cmd == Q_V1_SETQUOTA \|\| cmd == Q_V1_SETUSE) {`
369			`idq.dqb_curinodes = mdq->dqb_curinodes;`
370			`idq.dqb_curspace = ((qsize_t)mdq->dqb_curblocks) << QUOTABLOCK_BITS;`
371			`idq.dqb_valid \|= QIF_USAGE;`
372			`}`
373			`ret = sb->s_qcop->set_dqblk(sb, type, id, &idq);`
374			`if (!ret && id == 0 && cmd == Q_V1_SETQUOTA) { /* Times for id 0 are in fact grace times */`
375			`struct if_dqinfo info;`
376
377			`info.dqi_bgrace = mdq->dqb_btime;`
378			`info.dqi_igrace = mdq->dqb_itime;`
379			`info.dqi_valid = IIF_BGRACE \| IIF_IGRACE;`
380			`ret = sb->s_qcop->set_info(sb, type, &info);`
381			`}`
382			`return ret;`
383			`}`
384
385			`static void v1_get_stats(struct v1c_dqstats *dst)`
386			`{`
387			`memcpy(dst, &dqstats, sizeof(dqstats));`
388			`}`
389
390			`/* Handle requests to old interface */`
391			`static int do_compat_quotactl(struct super_block *sb, int type, int cmd, qid_t id, caddr_t addr)`
392			`{`
393			`int ret;`
394
395			`switch (cmd) {`
396			`case Q_COMP_QUOTAON: {`
397			`char *pathname;`
398
399			`if (IS_ERR(pathname = getname(addr)))`
400			`return PTR_ERR(pathname);`
401			`ret = sb->s_qcop->quota_on(sb, type, QFMT_VFS_OLD, pathname);`
402			`putname(pathname);`
403			`return ret;`
404			`}`
405			`case Q_COMP_QUOTAOFF:`
406			`return sb->s_qcop->quota_off(sb, type);`
407			`case Q_COMP_SYNC:`
408			`if (sb)`
409			`return sb->s_qcop->quota_sync(sb, type);`
410			`sync_dquots_dev(NODEV, type);`
411			`return 0;`
412			`case Q_V1_RSQUASH: {`
413			`int flag;`
414
415			`if (copy_from_user(&flag, addr, sizeof(flag)))`
416			`return -EFAULT;`
417			`return v1_set_rsquash(sb, type, flag);`
418			`}`
419			`case Q_V1_GETQUOTA: {`
420			`struct v1c_mem_dqblk mdq;`
421
422			`if ((ret = v1_get_dqblk(sb, type, id, &mdq)))`
423			`return ret;`
424			`if (copy_to_user(addr, &mdq, sizeof(mdq)))`
425			`return -EFAULT;`
426			`return 0;`
427			`}`
428			`case Q_V1_SETQLIM:`
429			`case Q_V1_SETUSE:`
430			`case Q_V1_SETQUOTA: {`
431			`struct v1c_mem_dqblk mdq;`
432
433			`if (copy_from_user(&mdq, addr, sizeof(mdq)))`
434			`return -EFAULT;`
435			`return v1_set_dqblk(sb, type, cmd, id, &mdq);`
436			`}`
437			`case Q_V1_GETSTATS: {`
438			`struct v1c_dqstats dst;`
439
440			`v1_get_stats(&dst);`
441			`if (copy_to_user(addr, &dst, sizeof(dst)))`
442			`return -EFAULT;`
443			`return 0;`
444			`}`
445			`}`
446			`BUG();`
447			`return 0;`
448			`}`
449
450			`/* Macros for short-circuiting the compatibility tests */`
451			`#define NEW_COMMAND(c) ((c) & (0x80 << 16))`
452			`#define XQM_COMMAND(c) (((c) & ('X' << 8)) == ('X' << 8))`
453
454			`/*`
455			`* This is the system call interface. This communicates with`
456			`* the user-level programs. Currently this only supports diskquota`
457			`* calls. Maybe we need to add the process quotas etc. in the future,`
458			`* but we probably should use rlimits for that.`
459			`*/`
460			`asmlinkage long sys_quotactl(unsigned int cmd, const char *special, qid_t id, caddr_t addr)`
461			`{`
462			`uint cmds, type;`
463			`struct super_block *sb = NULL;`
464			`int ret = -EINVAL;`
465
466			`lock_kernel();`
467			`cmds = cmd >> SUBCMDSHIFT;`
468			`type = cmd & SUBCMDMASK;`
469
470			`if (cmds != Q_V1_GETSTATS && cmds != Q_V2_GETSTATS && IS_ERR(sb = resolve_dev(special))) {`
471			`ret = PTR_ERR(sb);`
472			`sb = NULL;`
473			`goto out;`
474			`}`
475			`if (!NEW_COMMAND(cmds) && !XQM_COMMAND(cmds)) {`
476			`if ((ret = check_compat_quotactl_valid(sb, type, cmds, id)) < 0)`
477			`goto out;`
478			`ret = do_compat_quotactl(sb, type, cmds, id, addr);`
479			`goto out;`
480			`}`
481			`if ((ret = check_quotactl_valid(sb, type, cmds, id)) < 0)`
482			`goto out;`
483			`ret = do_quotactl(sb, type, cmds, id, addr);`
484			`out:`
485			`if (sb)`
486			`drop_super(sb);`
487			`unlock_kernel();`
488			`return ret;`
489			`}`