Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/fs/quota.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
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/compat.h> 14 #include <linux/kernel.h> 15 #include <linux/security.h> 16 #include <linux/syscalls.h> 17 #include <linux/buffer_head.h> 18 #include <linux/capability.h> 19 #include <linux/quotaops.h> 20 #include <linux/types.h> 21 22 /* Check validity of generic quotactl commands */ 23 static int generic_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id) 24 { 25 if (type >= MAXQUOTAS) 26 return -EINVAL; 27 if (!sb && cmd != Q_SYNC) 28 return -ENODEV; 29 /* Is operation supported? */ 30 if (sb && !sb->s_qcop) 31 return -ENOSYS; 32 33 switch (cmd) { 34 case Q_GETFMT: 35 break; 36 case Q_QUOTAON: 37 if (!sb->s_qcop->quota_on) 38 return -ENOSYS; 39 break; 40 case Q_QUOTAOFF: 41 if (!sb->s_qcop->quota_off) 42 return -ENOSYS; 43 break; 44 case Q_SETINFO: 45 if (!sb->s_qcop->set_info) 46 return -ENOSYS; 47 break; 48 case Q_GETINFO: 49 if (!sb->s_qcop->get_info) 50 return -ENOSYS; 51 break; 52 case Q_SETQUOTA: 53 if (!sb->s_qcop->set_dqblk) 54 return -ENOSYS; 55 break; 56 case Q_GETQUOTA: 57 if (!sb->s_qcop->get_dqblk) 58 return -ENOSYS; 59 break; 60 case Q_SYNC: 61 if (sb && !sb->s_qcop->quota_sync) 62 return -ENOSYS; 63 break; 64 default: 65 return -EINVAL; 66 } 67 68 /* Is quota turned on for commands which need it? */ 69 switch (cmd) { 70 case Q_GETFMT: 71 case Q_GETINFO: 72 case Q_SETINFO: 73 case Q_SETQUOTA: 74 case Q_GETQUOTA: 75 /* This is just informative test so we are satisfied without a lock */ 76 if (!sb_has_quota_enabled(sb, type)) 77 return -ESRCH; 78 } 79 80 /* Check privileges */ 81 if (cmd == Q_GETQUOTA) { 82 if (((type == USRQUOTA && current->euid != id) || 83 (type == GRPQUOTA && !in_egroup_p(id))) && 84 !capable(CAP_SYS_ADMIN)) 85 return -EPERM; 86 } 87 else if (cmd != Q_GETFMT && cmd != Q_SYNC && cmd != Q_GETINFO) 88 if (!capable(CAP_SYS_ADMIN)) 89 return -EPERM; 90 91 return 0; 92 } 93 94 /* Check validity of XFS Quota Manager commands */ 95 static int xqm_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id) 96 { 97 if (type >= XQM_MAXQUOTAS) 98 return -EINVAL; 99 if (!sb) 100 return -ENODEV; 101 if (!sb->s_qcop) 102 return -ENOSYS; 103 104 switch (cmd) { 105 case Q_XQUOTAON: 106 case Q_XQUOTAOFF: 107 case Q_XQUOTARM: 108 if (!sb->s_qcop->set_xstate) 109 return -ENOSYS; 110 break; 111 case Q_XGETQSTAT: 112 if (!sb->s_qcop->get_xstate) 113 return -ENOSYS; 114 break; 115 case Q_XSETQLIM: 116 if (!sb->s_qcop->set_xquota) 117 return -ENOSYS; 118 break; 119 case Q_XGETQUOTA: 120 if (!sb->s_qcop->get_xquota) 121 return -ENOSYS; 122 break; 123 case Q_XQUOTASYNC: 124 if (!sb->s_qcop->quota_sync) 125 return -ENOSYS; 126 break; 127 default: 128 return -EINVAL; 129 } 130 131 /* Check privileges */ 132 if (cmd == Q_XGETQUOTA) { 133 if (((type == XQM_USRQUOTA && current->euid != id) || 134 (type == XQM_GRPQUOTA && !in_egroup_p(id))) && 135 !capable(CAP_SYS_ADMIN)) 136 return -EPERM; 137 } else if (cmd != Q_XGETQSTAT && cmd != Q_XQUOTASYNC) { 138 if (!capable(CAP_SYS_ADMIN)) 139 return -EPERM; 140 } 141 142 return 0; 143 } 144 145 static int check_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id) 146 { 147 int error; 148 149 if (XQM_COMMAND(cmd)) 150 error = xqm_quotactl_valid(sb, type, cmd, id); 151 else 152 error = generic_quotactl_valid(sb, type, cmd, id); 153 if (!error) 154 error = security_quotactl(cmd, type, id, sb); 155 return error; 156 } 157 158 static void quota_sync_sb(struct super_block *sb, int type) 159 { 160 int cnt; 161 162 sb->s_qcop->quota_sync(sb, type); 163 /* This is not very clever (and fast) but currently I don't know about 164 * any other simple way of getting quota data to disk and we must get 165 * them there for userspace to be visible... */ 166 if (sb->s_op->sync_fs) 167 sb->s_op->sync_fs(sb, 1); 168 sync_blockdev(sb->s_bdev); 169 170 /* 171 * Now when everything is written we can discard the pagecache so 172 * that userspace sees the changes. 173 */ 174 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 175 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 176 if (type != -1 && cnt != type) 177 continue; 178 if (!sb_has_quota_enabled(sb, cnt)) 179 continue; 180 mutex_lock_nested(&sb_dqopt(sb)->files[cnt]->i_mutex, I_MUTEX_QUOTA); 181 truncate_inode_pages(&sb_dqopt(sb)->files[cnt]->i_data, 0); 182 mutex_unlock(&sb_dqopt(sb)->files[cnt]->i_mutex); 183 } 184 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 185 } 186 187 void sync_dquots(struct super_block *sb, int type) 188 { 189 int cnt; 190 191 if (sb) { 192 if (sb->s_qcop->quota_sync) 193 quota_sync_sb(sb, type); 194 return; 195 } 196 197 spin_lock(&sb_lock); 198 restart: 199 list_for_each_entry(sb, &super_blocks, s_list) { 200 /* This test just improves performance so it needn't be reliable... */ 201 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 202 if (type != -1 && type != cnt) 203 continue; 204 if (!sb_has_quota_enabled(sb, cnt)) 205 continue; 206 if (!info_dirty(&sb_dqopt(sb)->info[cnt]) && 207 list_empty(&sb_dqopt(sb)->info[cnt].dqi_dirty_list)) 208 continue; 209 break; 210 } 211 if (cnt == MAXQUOTAS) 212 continue; 213 sb->s_count++; 214 spin_unlock(&sb_lock); 215 down_read(&sb->s_umount); 216 if (sb->s_root && sb->s_qcop->quota_sync) 217 quota_sync_sb(sb, type); 218 up_read(&sb->s_umount); 219 spin_lock(&sb_lock); 220 if (__put_super_and_need_restart(sb)) 221 goto restart; 222 } 223 spin_unlock(&sb_lock); 224 } 225 226 /* Copy parameters and call proper function */ 227 static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, void __user *addr) 228 { 229 int ret; 230 231 switch (cmd) { 232 case Q_QUOTAON: { 233 char *pathname; 234 235 if (IS_ERR(pathname = getname(addr))) 236 return PTR_ERR(pathname); 237 ret = sb->s_qcop->quota_on(sb, type, id, pathname, 0); 238 putname(pathname); 239 return ret; 240 } 241 case Q_QUOTAOFF: 242 return sb->s_qcop->quota_off(sb, type, 0); 243 244 case Q_GETFMT: { 245 __u32 fmt; 246 247 down_read(&sb_dqopt(sb)->dqptr_sem); 248 if (!sb_has_quota_enabled(sb, type)) { 249 up_read(&sb_dqopt(sb)->dqptr_sem); 250 return -ESRCH; 251 } 252 fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id; 253 up_read(&sb_dqopt(sb)->dqptr_sem); 254 if (copy_to_user(addr, &fmt, sizeof(fmt))) 255 return -EFAULT; 256 return 0; 257 } 258 case Q_GETINFO: { 259 struct if_dqinfo info; 260 261 if ((ret = sb->s_qcop->get_info(sb, type, &info))) 262 return ret; 263 if (copy_to_user(addr, &info, sizeof(info))) 264 return -EFAULT; 265 return 0; 266 } 267 case Q_SETINFO: { 268 struct if_dqinfo info; 269 270 if (copy_from_user(&info, addr, sizeof(info))) 271 return -EFAULT; 272 return sb->s_qcop->set_info(sb, type, &info); 273 } 274 case Q_GETQUOTA: { 275 struct if_dqblk idq; 276 277 if ((ret = sb->s_qcop->get_dqblk(sb, type, id, &idq))) 278 return ret; 279 if (copy_to_user(addr, &idq, sizeof(idq))) 280 return -EFAULT; 281 return 0; 282 } 283 case Q_SETQUOTA: { 284 struct if_dqblk idq; 285 286 if (copy_from_user(&idq, addr, sizeof(idq))) 287 return -EFAULT; 288 return sb->s_qcop->set_dqblk(sb, type, id, &idq); 289 } 290 case Q_SYNC: 291 sync_dquots(sb, type); 292 return 0; 293 294 case Q_XQUOTAON: 295 case Q_XQUOTAOFF: 296 case Q_XQUOTARM: { 297 __u32 flags; 298 299 if (copy_from_user(&flags, addr, sizeof(flags))) 300 return -EFAULT; 301 return sb->s_qcop->set_xstate(sb, flags, cmd); 302 } 303 case Q_XGETQSTAT: { 304 struct fs_quota_stat fqs; 305 306 if ((ret = sb->s_qcop->get_xstate(sb, &fqs))) 307 return ret; 308 if (copy_to_user(addr, &fqs, sizeof(fqs))) 309 return -EFAULT; 310 return 0; 311 } 312 case Q_XSETQLIM: { 313 struct fs_disk_quota fdq; 314 315 if (copy_from_user(&fdq, addr, sizeof(fdq))) 316 return -EFAULT; 317 return sb->s_qcop->set_xquota(sb, type, id, &fdq); 318 } 319 case Q_XGETQUOTA: { 320 struct fs_disk_quota fdq; 321 322 if ((ret = sb->s_qcop->get_xquota(sb, type, id, &fdq))) 323 return ret; 324 if (copy_to_user(addr, &fdq, sizeof(fdq))) 325 return -EFAULT; 326 return 0; 327 } 328 case Q_XQUOTASYNC: 329 return sb->s_qcop->quota_sync(sb, type); 330 /* We never reach here unless validity check is broken */ 331 default: 332 BUG(); 333 } 334 return 0; 335 } 336 337 /* 338 * look up a superblock on which quota ops will be performed 339 * - use the name of a block device to find the superblock thereon 340 */ 341 static inline struct super_block *quotactl_block(const char __user *special) 342 { 343 #ifdef CONFIG_BLOCK 344 struct block_device *bdev; 345 struct super_block *sb; 346 char *tmp = getname(special); 347 348 if (IS_ERR(tmp)) 349 return ERR_CAST(tmp); 350 bdev = lookup_bdev(tmp); 351 putname(tmp); 352 if (IS_ERR(bdev)) 353 return ERR_CAST(bdev); 354 sb = get_super(bdev); 355 bdput(bdev); 356 if (!sb) 357 return ERR_PTR(-ENODEV); 358 359 return sb; 360 #else 361 return ERR_PTR(-ENODEV); 362 #endif 363 } 364 365 /* 366 * This is the system call interface. This communicates with 367 * the user-level programs. Currently this only supports diskquota 368 * calls. Maybe we need to add the process quotas etc. in the future, 369 * but we probably should use rlimits for that. 370 */ 371 asmlinkage long sys_quotactl(unsigned int cmd, const char __user *special, qid_t id, void __user *addr) 372 { 373 uint cmds, type; 374 struct super_block *sb = NULL; 375 int ret; 376 377 cmds = cmd >> SUBCMDSHIFT; 378 type = cmd & SUBCMDMASK; 379 380 if (cmds != Q_SYNC || special) { 381 sb = quotactl_block(special); 382 if (IS_ERR(sb)) 383 return PTR_ERR(sb); 384 } 385 386 ret = check_quotactl_valid(sb, type, cmds, id); 387 if (ret >= 0) 388 ret = do_quotactl(sb, type, cmds, id, addr); 389 if (sb) 390 drop_super(sb); 391 392 return ret; 393 } 394 395 #if defined(CONFIG_COMPAT_FOR_U64_ALIGNMENT) 396 /* 397 * This code works only for 32 bit quota tools over 64 bit OS (x86_64, ia64) 398 * and is necessary due to alignment problems. 399 */ 400 struct compat_if_dqblk { 401 compat_u64 dqb_bhardlimit; 402 compat_u64 dqb_bsoftlimit; 403 compat_u64 dqb_curspace; 404 compat_u64 dqb_ihardlimit; 405 compat_u64 dqb_isoftlimit; 406 compat_u64 dqb_curinodes; 407 compat_u64 dqb_btime; 408 compat_u64 dqb_itime; 409 compat_uint_t dqb_valid; 410 }; 411 412 /* XFS structures */ 413 struct compat_fs_qfilestat { 414 compat_u64 dqb_bhardlimit; 415 compat_u64 qfs_nblks; 416 compat_uint_t qfs_nextents; 417 }; 418 419 struct compat_fs_quota_stat { 420 __s8 qs_version; 421 __u16 qs_flags; 422 __s8 qs_pad; 423 struct compat_fs_qfilestat qs_uquota; 424 struct compat_fs_qfilestat qs_gquota; 425 compat_uint_t qs_incoredqs; 426 compat_int_t qs_btimelimit; 427 compat_int_t qs_itimelimit; 428 compat_int_t qs_rtbtimelimit; 429 __u16 qs_bwarnlimit; 430 __u16 qs_iwarnlimit; 431 }; 432 433 asmlinkage long sys32_quotactl(unsigned int cmd, const char __user *special, 434 qid_t id, void __user *addr) 435 { 436 unsigned int cmds; 437 struct if_dqblk __user *dqblk; 438 struct compat_if_dqblk __user *compat_dqblk; 439 struct fs_quota_stat __user *fsqstat; 440 struct compat_fs_quota_stat __user *compat_fsqstat; 441 compat_uint_t data; 442 u16 xdata; 443 long ret; 444 445 cmds = cmd >> SUBCMDSHIFT; 446 447 switch (cmds) { 448 case Q_GETQUOTA: 449 dqblk = compat_alloc_user_space(sizeof(struct if_dqblk)); 450 compat_dqblk = addr; 451 ret = sys_quotactl(cmd, special, id, dqblk); 452 if (ret) 453 break; 454 if (copy_in_user(compat_dqblk, dqblk, sizeof(*compat_dqblk)) || 455 get_user(data, &dqblk->dqb_valid) || 456 put_user(data, &compat_dqblk->dqb_valid)) 457 ret = -EFAULT; 458 break; 459 case Q_SETQUOTA: 460 dqblk = compat_alloc_user_space(sizeof(struct if_dqblk)); 461 compat_dqblk = addr; 462 ret = -EFAULT; 463 if (copy_in_user(dqblk, compat_dqblk, sizeof(*compat_dqblk)) || 464 get_user(data, &compat_dqblk->dqb_valid) || 465 put_user(data, &dqblk->dqb_valid)) 466 break; 467 ret = sys_quotactl(cmd, special, id, dqblk); 468 break; 469 case Q_XGETQSTAT: 470 fsqstat = compat_alloc_user_space(sizeof(struct fs_quota_stat)); 471 compat_fsqstat = addr; 472 ret = sys_quotactl(cmd, special, id, fsqstat); 473 if (ret) 474 break; 475 ret = -EFAULT; 476 /* Copying qs_version, qs_flags, qs_pad */ 477 if (copy_in_user(compat_fsqstat, fsqstat, 478 offsetof(struct compat_fs_quota_stat, qs_uquota))) 479 break; 480 /* Copying qs_uquota */ 481 if (copy_in_user(&compat_fsqstat->qs_uquota, 482 &fsqstat->qs_uquota, 483 sizeof(compat_fsqstat->qs_uquota)) || 484 get_user(data, &fsqstat->qs_uquota.qfs_nextents) || 485 put_user(data, &compat_fsqstat->qs_uquota.qfs_nextents)) 486 break; 487 /* Copying qs_gquota */ 488 if (copy_in_user(&compat_fsqstat->qs_gquota, 489 &fsqstat->qs_gquota, 490 sizeof(compat_fsqstat->qs_gquota)) || 491 get_user(data, &fsqstat->qs_gquota.qfs_nextents) || 492 put_user(data, &compat_fsqstat->qs_gquota.qfs_nextents)) 493 break; 494 /* Copying the rest */ 495 if (copy_in_user(&compat_fsqstat->qs_incoredqs, 496 &fsqstat->qs_incoredqs, 497 sizeof(struct compat_fs_quota_stat) - 498 offsetof(struct compat_fs_quota_stat, qs_incoredqs)) || 499 get_user(xdata, &fsqstat->qs_iwarnlimit) || 500 put_user(xdata, &compat_fsqstat->qs_iwarnlimit)) 501 break; 502 ret = 0; 503 break; 504 default: 505 ret = sys_quotactl(cmd, special, id, addr); 506 } 507 return ret; 508 } 509 #endif
Cache object: c29029a330ef4124bf00d5e7d9e62ee4
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]