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 struct path *path) 68 { 69 if (!sb->s_qcop->quota_on && !sb->s_qcop->quota_on_meta) 70 return -ENOSYS; 71 if (sb->s_qcop->quota_on_meta) 72 return sb->s_qcop->quota_on_meta(sb, type, id); 73 if (IS_ERR(path)) 74 return PTR_ERR(path); 75 return sb->s_qcop->quota_on(sb, type, id, path); 76 } 77 78 static int quota_getfmt(struct super_block *sb, int type, void __user *addr) 79 { 80 __u32 fmt; 81 82 down_read(&sb_dqopt(sb)->dqptr_sem); 83 if (!sb_has_quota_active(sb, type)) { 84 up_read(&sb_dqopt(sb)->dqptr_sem); 85 return -ESRCH; 86 } 87 fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id; 88 up_read(&sb_dqopt(sb)->dqptr_sem); 89 if (copy_to_user(addr, &fmt, sizeof(fmt))) 90 return -EFAULT; 91 return 0; 92 } 93 94 static int quota_getinfo(struct super_block *sb, int type, void __user *addr) 95 { 96 struct if_dqinfo info; 97 int ret; 98 99 if (!sb->s_qcop->get_info) 100 return -ENOSYS; 101 ret = sb->s_qcop->get_info(sb, type, &info); 102 if (!ret && copy_to_user(addr, &info, sizeof(info))) 103 return -EFAULT; 104 return ret; 105 } 106 107 static int quota_setinfo(struct super_block *sb, int type, void __user *addr) 108 { 109 struct if_dqinfo info; 110 111 if (copy_from_user(&info, addr, sizeof(info))) 112 return -EFAULT; 113 if (!sb->s_qcop->set_info) 114 return -ENOSYS; 115 return sb->s_qcop->set_info(sb, type, &info); 116 } 117 118 static void copy_to_if_dqblk(struct if_dqblk *dst, struct fs_disk_quota *src) 119 { 120 dst->dqb_bhardlimit = src->d_blk_hardlimit; 121 dst->dqb_bsoftlimit = src->d_blk_softlimit; 122 dst->dqb_curspace = src->d_bcount; 123 dst->dqb_ihardlimit = src->d_ino_hardlimit; 124 dst->dqb_isoftlimit = src->d_ino_softlimit; 125 dst->dqb_curinodes = src->d_icount; 126 dst->dqb_btime = src->d_btimer; 127 dst->dqb_itime = src->d_itimer; 128 dst->dqb_valid = QIF_ALL; 129 } 130 131 static int quota_getquota(struct super_block *sb, int type, qid_t id, 132 void __user *addr) 133 { 134 struct fs_disk_quota fdq; 135 struct if_dqblk idq; 136 int ret; 137 138 if (!sb->s_qcop->get_dqblk) 139 return -ENOSYS; 140 ret = sb->s_qcop->get_dqblk(sb, type, id, &fdq); 141 if (ret) 142 return ret; 143 copy_to_if_dqblk(&idq, &fdq); 144 if (copy_to_user(addr, &idq, sizeof(idq))) 145 return -EFAULT; 146 return 0; 147 } 148 149 static void copy_from_if_dqblk(struct fs_disk_quota *dst, struct if_dqblk *src) 150 { 151 dst->d_blk_hardlimit = src->dqb_bhardlimit; 152 dst->d_blk_softlimit = src->dqb_bsoftlimit; 153 dst->d_bcount = src->dqb_curspace; 154 dst->d_ino_hardlimit = src->dqb_ihardlimit; 155 dst->d_ino_softlimit = src->dqb_isoftlimit; 156 dst->d_icount = src->dqb_curinodes; 157 dst->d_btimer = src->dqb_btime; 158 dst->d_itimer = src->dqb_itime; 159 160 dst->d_fieldmask = 0; 161 if (src->dqb_valid & QIF_BLIMITS) 162 dst->d_fieldmask |= FS_DQ_BSOFT | FS_DQ_BHARD; 163 if (src->dqb_valid & QIF_SPACE) 164 dst->d_fieldmask |= FS_DQ_BCOUNT; 165 if (src->dqb_valid & QIF_ILIMITS) 166 dst->d_fieldmask |= FS_DQ_ISOFT | FS_DQ_IHARD; 167 if (src->dqb_valid & QIF_INODES) 168 dst->d_fieldmask |= FS_DQ_ICOUNT; 169 if (src->dqb_valid & QIF_BTIME) 170 dst->d_fieldmask |= FS_DQ_BTIMER; 171 if (src->dqb_valid & QIF_ITIME) 172 dst->d_fieldmask |= FS_DQ_ITIMER; 173 } 174 175 static int quota_setquota(struct super_block *sb, int type, qid_t id, 176 void __user *addr) 177 { 178 struct fs_disk_quota fdq; 179 struct if_dqblk idq; 180 181 if (copy_from_user(&idq, addr, sizeof(idq))) 182 return -EFAULT; 183 if (!sb->s_qcop->set_dqblk) 184 return -ENOSYS; 185 copy_from_if_dqblk(&fdq, &idq); 186 return sb->s_qcop->set_dqblk(sb, type, id, &fdq); 187 } 188 189 static int quota_setxstate(struct super_block *sb, int cmd, void __user *addr) 190 { 191 __u32 flags; 192 193 if (copy_from_user(&flags, addr, sizeof(flags))) 194 return -EFAULT; 195 if (!sb->s_qcop->set_xstate) 196 return -ENOSYS; 197 return sb->s_qcop->set_xstate(sb, flags, cmd); 198 } 199 200 static int quota_getxstate(struct super_block *sb, void __user *addr) 201 { 202 struct fs_quota_stat fqs; 203 int ret; 204 205 if (!sb->s_qcop->get_xstate) 206 return -ENOSYS; 207 ret = sb->s_qcop->get_xstate(sb, &fqs); 208 if (!ret && copy_to_user(addr, &fqs, sizeof(fqs))) 209 return -EFAULT; 210 return ret; 211 } 212 213 static int quota_setxquota(struct super_block *sb, int type, qid_t id, 214 void __user *addr) 215 { 216 struct fs_disk_quota fdq; 217 218 if (copy_from_user(&fdq, addr, sizeof(fdq))) 219 return -EFAULT; 220 if (!sb->s_qcop->set_dqblk) 221 return -ENOSYS; 222 return sb->s_qcop->set_dqblk(sb, type, id, &fdq); 223 } 224 225 static int quota_getxquota(struct super_block *sb, int type, qid_t id, 226 void __user *addr) 227 { 228 struct fs_disk_quota fdq; 229 int ret; 230 231 if (!sb->s_qcop->get_dqblk) 232 return -ENOSYS; 233 ret = sb->s_qcop->get_dqblk(sb, type, id, &fdq); 234 if (!ret && copy_to_user(addr, &fdq, sizeof(fdq))) 235 return -EFAULT; 236 return ret; 237 } 238 239 /* Copy parameters and call proper function */ 240 static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, 241 void __user *addr, struct path *path) 242 { 243 int ret; 244 245 if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS)) 246 return -EINVAL; 247 if (!sb->s_qcop) 248 return -ENOSYS; 249 250 ret = check_quotactl_permission(sb, type, cmd, id); 251 if (ret < 0) 252 return ret; 253 254 switch (cmd) { 255 case Q_QUOTAON: 256 return quota_quotaon(sb, type, cmd, id, path); 257 case Q_QUOTAOFF: 258 if (!sb->s_qcop->quota_off) 259 return -ENOSYS; 260 return sb->s_qcop->quota_off(sb, type); 261 case Q_GETFMT: 262 return quota_getfmt(sb, type, addr); 263 case Q_GETINFO: 264 return quota_getinfo(sb, type, addr); 265 case Q_SETINFO: 266 return quota_setinfo(sb, type, addr); 267 case Q_GETQUOTA: 268 return quota_getquota(sb, type, id, addr); 269 case Q_SETQUOTA: 270 return quota_setquota(sb, type, id, addr); 271 case Q_SYNC: 272 if (!sb->s_qcop->quota_sync) 273 return -ENOSYS; 274 return sb->s_qcop->quota_sync(sb, type, 1); 275 case Q_XQUOTAON: 276 case Q_XQUOTAOFF: 277 case Q_XQUOTARM: 278 return quota_setxstate(sb, cmd, addr); 279 case Q_XGETQSTAT: 280 return quota_getxstate(sb, addr); 281 case Q_XSETQLIM: 282 return quota_setxquota(sb, type, id, addr); 283 case Q_XGETQUOTA: 284 return quota_getxquota(sb, type, id, addr); 285 case Q_XQUOTASYNC: 286 /* caller already holds s_umount */ 287 if (sb->s_flags & MS_RDONLY) 288 return -EROFS; 289 writeback_inodes_sb(sb, WB_REASON_SYNC); 290 return 0; 291 default: 292 return -EINVAL; 293 } 294 } 295 296 /* 297 * look up a superblock on which quota ops will be performed 298 * - use the name of a block device to find the superblock thereon 299 */ 300 static struct super_block *quotactl_block(const char __user *special) 301 { 302 #ifdef CONFIG_BLOCK 303 struct block_device *bdev; 304 struct super_block *sb; 305 char *tmp = getname(special); 306 307 if (IS_ERR(tmp)) 308 return ERR_CAST(tmp); 309 bdev = lookup_bdev(tmp); 310 putname(tmp); 311 if (IS_ERR(bdev)) 312 return ERR_CAST(bdev); 313 sb = get_super(bdev); 314 bdput(bdev); 315 if (!sb) 316 return ERR_PTR(-ENODEV); 317 318 return sb; 319 #else 320 return ERR_PTR(-ENODEV); 321 #endif 322 } 323 324 /* 325 * This is the system call interface. This communicates with 326 * the user-level programs. Currently this only supports diskquota 327 * calls. Maybe we need to add the process quotas etc. in the future, 328 * but we probably should use rlimits for that. 329 */ 330 SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special, 331 qid_t, id, void __user *, addr) 332 { 333 uint cmds, type; 334 struct super_block *sb = NULL; 335 struct path path, *pathp = NULL; 336 int ret; 337 338 cmds = cmd >> SUBCMDSHIFT; 339 type = cmd & SUBCMDMASK; 340 341 /* 342 * As a special case Q_SYNC can be called without a specific device. 343 * It will iterate all superblocks that have quota enabled and call 344 * the sync action on each of them. 345 */ 346 if (!special) { 347 if (cmds == Q_SYNC) 348 return quota_sync_all(type); 349 return -ENODEV; 350 } 351 352 /* 353 * Path for quotaon has to be resolved before grabbing superblock 354 * because that gets s_umount sem which is also possibly needed by path 355 * resolution (think about autofs) and thus deadlocks could arise. 356 */ 357 if (cmds == Q_QUOTAON) { 358 ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path); 359 if (ret) 360 pathp = ERR_PTR(ret); 361 else 362 pathp = &path; 363 } 364 365 sb = quotactl_block(special); 366 if (IS_ERR(sb)) 367 return PTR_ERR(sb); 368 369 ret = do_quotactl(sb, type, cmds, id, addr, pathp); 370 371 drop_super(sb); 372 if (pathp && !IS_ERR(pathp)) 373 path_put(pathp); 374 return ret; 375 } 376