1 /* 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/namei.h> 10 #include <linux/slab.h> 11 #include <asm/current.h> 12 #include <asm/uaccess.h> 13 #include <linux/kernel.h> 14 #include <linux/security.h> 15 #include <linux/syscalls.h> 16 #include <linux/buffer_head.h> 17 #include <linux/capability.h> 18 #include <linux/quotaops.h> 19 #include <linux/types.h> 20 #include <linux/writeback.h> 21 22 static int check_quotactl_permission(struct super_block *sb, int type, int cmd, 23 qid_t id) 24 { 25 switch (cmd) { 26 /* these commands do not require any special privilegues */ 27 case Q_GETFMT: 28 case Q_SYNC: 29 case Q_GETINFO: 30 case Q_XGETQSTAT: 31 case Q_XQUOTASYNC: 32 break; 33 /* allow to query information for dquots we "own" */ 34 case Q_GETQUOTA: 35 case Q_XGETQUOTA: 36 if ((type == USRQUOTA && current_euid() == id) || 37 (type == GRPQUOTA && in_egroup_p(id))) 38 break; 39 /*FALLTHROUGH*/ 40 default: 41 if (!capable(CAP_SYS_ADMIN)) 42 return -EPERM; 43 } 44 45 return security_quotactl(cmd, type, id, sb); 46 } 47 48 static void quota_sync_one(struct super_block *sb, void *arg) 49 { 50 if (sb->s_qcop && sb->s_qcop->quota_sync) 51 sb->s_qcop->quota_sync(sb, *(int *)arg, 1); 52 } 53 54 static int quota_sync_all(int type) 55 { 56 int ret; 57 58 if (type >= MAXQUOTAS) 59 return -EINVAL; 60 ret = security_quotactl(Q_SYNC, type, 0, NULL); 61 if (!ret) 62 iterate_supers(quota_sync_one, &type); 63 return ret; 64 } 65 66 static int quota_quotaon(struct super_block *sb, int type, int cmd, qid_t id, 67 void __user *addr) 68 { 69 char *pathname; 70 int ret = -ENOSYS; 71 72 pathname = getname(addr); 73 if (IS_ERR(pathname)) 74 return PTR_ERR(pathname); 75 if (sb->s_qcop->quota_on) 76 ret = sb->s_qcop->quota_on(sb, type, id, pathname); 77 putname(pathname); 78 return ret; 79 } 80 81 static int quota_getfmt(struct super_block *sb, int type, void __user *addr) 82 { 83 __u32 fmt; 84 85 down_read(&sb_dqopt(sb)->dqptr_sem); 86 if (!sb_has_quota_active(sb, type)) { 87 up_read(&sb_dqopt(sb)->dqptr_sem); 88 return -ESRCH; 89 } 90 fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id; 91 up_read(&sb_dqopt(sb)->dqptr_sem); 92 if (copy_to_user(addr, &fmt, sizeof(fmt))) 93 return -EFAULT; 94 return 0; 95 } 96 97 static int quota_getinfo(struct super_block *sb, int type, void __user *addr) 98 { 99 struct if_dqinfo info; 100 int ret; 101 102 if (!sb->s_qcop->get_info) 103 return -ENOSYS; 104 ret = sb->s_qcop->get_info(sb, type, &info); 105 if (!ret && copy_to_user(addr, &info, sizeof(info))) 106 return -EFAULT; 107 return ret; 108 } 109 110 static int quota_setinfo(struct super_block *sb, int type, void __user *addr) 111 { 112 struct if_dqinfo info; 113 114 if (copy_from_user(&info, addr, sizeof(info))) 115 return -EFAULT; 116 if (!sb->s_qcop->set_info) 117 return -ENOSYS; 118 return sb->s_qcop->set_info(sb, type, &info); 119 } 120 121 static void copy_to_if_dqblk(struct if_dqblk *dst, struct fs_disk_quota *src) 122 { 123 dst->dqb_bhardlimit = src->d_blk_hardlimit; 124 dst->dqb_bsoftlimit = src->d_blk_softlimit; 125 dst->dqb_curspace = src->d_bcount; 126 dst->dqb_ihardlimit = src->d_ino_hardlimit; 127 dst->dqb_isoftlimit = src->d_ino_softlimit; 128 dst->dqb_curinodes = src->d_icount; 129 dst->dqb_btime = src->d_btimer; 130 dst->dqb_itime = src->d_itimer; 131 dst->dqb_valid = QIF_ALL; 132 } 133 134 static int quota_getquota(struct super_block *sb, int type, qid_t id, 135 void __user *addr) 136 { 137 struct fs_disk_quota fdq; 138 struct if_dqblk idq; 139 int ret; 140 141 if (!sb->s_qcop->get_dqblk) 142 return -ENOSYS; 143 ret = sb->s_qcop->get_dqblk(sb, type, id, &fdq); 144 if (ret) 145 return ret; 146 copy_to_if_dqblk(&idq, &fdq); 147 if (copy_to_user(addr, &idq, sizeof(idq))) 148 return -EFAULT; 149 return 0; 150 } 151 152 static void copy_from_if_dqblk(struct fs_disk_quota *dst, struct if_dqblk *src) 153 { 154 dst->d_blk_hardlimit = src->dqb_bhardlimit; 155 dst->d_blk_softlimit = src->dqb_bsoftlimit; 156 dst->d_bcount = src->dqb_curspace; 157 dst->d_ino_hardlimit = src->dqb_ihardlimit; 158 dst->d_ino_softlimit = src->dqb_isoftlimit; 159 dst->d_icount = src->dqb_curinodes; 160 dst->d_btimer = src->dqb_btime; 161 dst->d_itimer = src->dqb_itime; 162 163 dst->d_fieldmask = 0; 164 if (src->dqb_valid & QIF_BLIMITS) 165 dst->d_fieldmask |= FS_DQ_BSOFT | FS_DQ_BHARD; 166 if (src->dqb_valid & QIF_SPACE) 167 dst->d_fieldmask |= FS_DQ_BCOUNT; 168 if (src->dqb_valid & QIF_ILIMITS) 169 dst->d_fieldmask |= FS_DQ_ISOFT | FS_DQ_IHARD; 170 if (src->dqb_valid & QIF_INODES) 171 dst->d_fieldmask |= FS_DQ_ICOUNT; 172 if (src->dqb_valid & QIF_BTIME) 173 dst->d_fieldmask |= FS_DQ_BTIMER; 174 if (src->dqb_valid & QIF_ITIME) 175 dst->d_fieldmask |= FS_DQ_ITIMER; 176 } 177 178 static int quota_setquota(struct super_block *sb, int type, qid_t id, 179 void __user *addr) 180 { 181 struct fs_disk_quota fdq; 182 struct if_dqblk idq; 183 184 if (copy_from_user(&idq, addr, sizeof(idq))) 185 return -EFAULT; 186 if (!sb->s_qcop->set_dqblk) 187 return -ENOSYS; 188 copy_from_if_dqblk(&fdq, &idq); 189 return sb->s_qcop->set_dqblk(sb, type, id, &fdq); 190 } 191 192 static int quota_setxstate(struct super_block *sb, int cmd, void __user *addr) 193 { 194 __u32 flags; 195 196 if (copy_from_user(&flags, addr, sizeof(flags))) 197 return -EFAULT; 198 if (!sb->s_qcop->set_xstate) 199 return -ENOSYS; 200 return sb->s_qcop->set_xstate(sb, flags, cmd); 201 } 202 203 static int quota_getxstate(struct super_block *sb, void __user *addr) 204 { 205 struct fs_quota_stat fqs; 206 int ret; 207 208 if (!sb->s_qcop->get_xstate) 209 return -ENOSYS; 210 ret = sb->s_qcop->get_xstate(sb, &fqs); 211 if (!ret && copy_to_user(addr, &fqs, sizeof(fqs))) 212 return -EFAULT; 213 return ret; 214 } 215 216 static int quota_setxquota(struct super_block *sb, int type, qid_t id, 217 void __user *addr) 218 { 219 struct fs_disk_quota fdq; 220 221 if (copy_from_user(&fdq, addr, sizeof(fdq))) 222 return -EFAULT; 223 if (!sb->s_qcop->set_dqblk) 224 return -ENOSYS; 225 return sb->s_qcop->set_dqblk(sb, type, id, &fdq); 226 } 227 228 static int quota_getxquota(struct super_block *sb, int type, qid_t id, 229 void __user *addr) 230 { 231 struct fs_disk_quota fdq; 232 int ret; 233 234 if (!sb->s_qcop->get_dqblk) 235 return -ENOSYS; 236 ret = sb->s_qcop->get_dqblk(sb, type, id, &fdq); 237 if (!ret && copy_to_user(addr, &fdq, sizeof(fdq))) 238 return -EFAULT; 239 return ret; 240 } 241 242 /* Copy parameters and call proper function */ 243 static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, 244 void __user *addr) 245 { 246 int ret; 247 248 if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS)) 249 return -EINVAL; 250 if (!sb->s_qcop) 251 return -ENOSYS; 252 253 ret = check_quotactl_permission(sb, type, cmd, id); 254 if (ret < 0) 255 return ret; 256 257 switch (cmd) { 258 case Q_QUOTAON: 259 return quota_quotaon(sb, type, cmd, id, addr); 260 case Q_QUOTAOFF: 261 if (!sb->s_qcop->quota_off) 262 return -ENOSYS; 263 return sb->s_qcop->quota_off(sb, type); 264 case Q_GETFMT: 265 return quota_getfmt(sb, type, addr); 266 case Q_GETINFO: 267 return quota_getinfo(sb, type, addr); 268 case Q_SETINFO: 269 return quota_setinfo(sb, type, addr); 270 case Q_GETQUOTA: 271 return quota_getquota(sb, type, id, addr); 272 case Q_SETQUOTA: 273 return quota_setquota(sb, type, id, addr); 274 case Q_SYNC: 275 if (!sb->s_qcop->quota_sync) 276 return -ENOSYS; 277 return sb->s_qcop->quota_sync(sb, type, 1); 278 case Q_XQUOTAON: 279 case Q_XQUOTAOFF: 280 case Q_XQUOTARM: 281 return quota_setxstate(sb, cmd, addr); 282 case Q_XGETQSTAT: 283 return quota_getxstate(sb, addr); 284 case Q_XSETQLIM: 285 return quota_setxquota(sb, type, id, addr); 286 case Q_XGETQUOTA: 287 return quota_getxquota(sb, type, id, addr); 288 case Q_XQUOTASYNC: 289 /* caller already holds s_umount */ 290 if (sb->s_flags & MS_RDONLY) 291 return -EROFS; 292 writeback_inodes_sb(sb); 293 return 0; 294 default: 295 return -EINVAL; 296 } 297 } 298 299 /* 300 * look up a superblock on which quota ops will be performed 301 * - use the name of a block device to find the superblock thereon 302 */ 303 static struct super_block *quotactl_block(const char __user *special) 304 { 305 #ifdef CONFIG_BLOCK 306 struct block_device *bdev; 307 struct super_block *sb; 308 char *tmp = getname(special); 309 310 if (IS_ERR(tmp)) 311 return ERR_CAST(tmp); 312 bdev = lookup_bdev(tmp); 313 putname(tmp); 314 if (IS_ERR(bdev)) 315 return ERR_CAST(bdev); 316 sb = get_super(bdev); 317 bdput(bdev); 318 if (!sb) 319 return ERR_PTR(-ENODEV); 320 321 return sb; 322 #else 323 return ERR_PTR(-ENODEV); 324 #endif 325 } 326 327 /* 328 * This is the system call interface. This communicates with 329 * the user-level programs. Currently this only supports diskquota 330 * calls. Maybe we need to add the process quotas etc. in the future, 331 * but we probably should use rlimits for that. 332 */ 333 SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special, 334 qid_t, id, void __user *, addr) 335 { 336 uint cmds, type; 337 struct super_block *sb = NULL; 338 int ret; 339 340 cmds = cmd >> SUBCMDSHIFT; 341 type = cmd & SUBCMDMASK; 342 343 /* 344 * As a special case Q_SYNC can be called without a specific device. 345 * It will iterate all superblocks that have quota enabled and call 346 * the sync action on each of them. 347 */ 348 if (!special) { 349 if (cmds == Q_SYNC) 350 return quota_sync_all(type); 351 return -ENODEV; 352 } 353 354 sb = quotactl_block(special); 355 if (IS_ERR(sb)) 356 return PTR_ERR(sb); 357 358 ret = do_quotactl(sb, type, cmds, id, addr); 359 360 drop_super(sb); 361 return ret; 362 } 363