1 /* 2 * Implementation of the diskquota system for the LINUX operating system. QUOTA 3 * is implemented using the BSD system call interface as the means of 4 * communication with the user level. This file contains the generic routines 5 * called by the different filesystems on allocation of an inode or block. 6 * These routines take care of the administration needed to have a consistent 7 * diskquota tracking system. The ideas of both user and group quotas are based 8 * on the Melbourne quota system as used on BSD derived systems. The internal 9 * implementation is based on one of the several variants of the LINUX 10 * inode-subsystem with added complexity of the diskquota system. 11 * 12 * Author: Marco van Wieringen <mvw@planets.elm.net> 13 * 14 * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96 15 * 16 * Revised list management to avoid races 17 * -- Bill Hawes, <whawes@star.net>, 9/98 18 * 19 * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...(). 20 * As the consequence the locking was moved from dquot_decr_...(), 21 * dquot_incr_...() to calling functions. 22 * invalidate_dquots() now writes modified dquots. 23 * Serialized quota_off() and quota_on() for mount point. 24 * Fixed a few bugs in grow_dquots(). 25 * Fixed deadlock in write_dquot() - we no longer account quotas on 26 * quota files 27 * remove_dquot_ref() moved to inode.c - it now traverses through inodes 28 * add_dquot_ref() restarts after blocking 29 * Added check for bogus uid and fixed check for group in quotactl. 30 * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99 31 * 32 * Used struct list_head instead of own list struct 33 * Invalidation of referenced dquots is no longer possible 34 * Improved free_dquots list management 35 * Quota and i_blocks are now updated in one place to avoid races 36 * Warnings are now delayed so we won't block in critical section 37 * Write updated not to require dquot lock 38 * Jan Kara, <jack@suse.cz>, 9/2000 39 * 40 * Added dynamic quota structure allocation 41 * Jan Kara <jack@suse.cz> 12/2000 42 * 43 * Rewritten quota interface. Implemented new quota format and 44 * formats registering. 45 * Jan Kara, <jack@suse.cz>, 2001,2002 46 * 47 * New SMP locking. 48 * Jan Kara, <jack@suse.cz>, 10/2002 49 * 50 * Added journalled quota support, fix lock inversion problems 51 * Jan Kara, <jack@suse.cz>, 2003,2004 52 * 53 * (C) Copyright 1994 - 1997 Marco van Wieringen 54 */ 55 56 #include <linux/errno.h> 57 #include <linux/kernel.h> 58 #include <linux/fs.h> 59 #include <linux/mount.h> 60 #include <linux/mm.h> 61 #include <linux/time.h> 62 #include <linux/types.h> 63 #include <linux/string.h> 64 #include <linux/fcntl.h> 65 #include <linux/stat.h> 66 #include <linux/tty.h> 67 #include <linux/file.h> 68 #include <linux/slab.h> 69 #include <linux/sysctl.h> 70 #include <linux/init.h> 71 #include <linux/module.h> 72 #include <linux/proc_fs.h> 73 #include <linux/security.h> 74 #include <linux/sched.h> 75 #include <linux/kmod.h> 76 #include <linux/namei.h> 77 #include <linux/capability.h> 78 #include <linux/quotaops.h> 79 #include "../internal.h" /* ugh */ 80 81 #include <linux/uaccess.h> 82 83 /* 84 * There are three quota SMP locks. dq_list_lock protects all lists with quotas 85 * and quota formats. 86 * dq_data_lock protects data from dq_dqb and also mem_dqinfo structures and 87 * also guards consistency of dquot->dq_dqb with inode->i_blocks, i_bytes. 88 * i_blocks and i_bytes updates itself are guarded by i_lock acquired directly 89 * in inode_add_bytes() and inode_sub_bytes(). dq_state_lock protects 90 * modifications of quota state (on quotaon and quotaoff) and readers who care 91 * about latest values take it as well. 92 * 93 * The spinlock ordering is hence: dq_data_lock > dq_list_lock > i_lock, 94 * dq_list_lock > dq_state_lock 95 * 96 * Note that some things (eg. sb pointer, type, id) doesn't change during 97 * the life of the dquot structure and so needn't to be protected by a lock 98 * 99 * Any operation working on dquots via inode pointers must hold dqptr_sem. If 100 * operation is just reading pointers from inode (or not using them at all) the 101 * read lock is enough. If pointers are altered function must hold write lock. 102 * Special care needs to be taken about S_NOQUOTA inode flag (marking that 103 * inode is a quota file). Functions adding pointers from inode to dquots have 104 * to check this flag under dqptr_sem and then (if S_NOQUOTA is not set) they 105 * have to do all pointer modifications before dropping dqptr_sem. This makes 106 * sure they cannot race with quotaon which first sets S_NOQUOTA flag and 107 * then drops all pointers to dquots from an inode. 108 * 109 * Each dquot has its dq_lock mutex. Locked dquots might not be referenced 110 * from inodes (dquot_alloc_space() and such don't check the dq_lock). 111 * Currently dquot is locked only when it is being read to memory (or space for 112 * it is being allocated) on the first dqget() and when it is being released on 113 * the last dqput(). The allocation and release oparations are serialized by 114 * the dq_lock and by checking the use count in dquot_release(). Write 115 * operations on dquots don't hold dq_lock as they copy data under dq_data_lock 116 * spinlock to internal buffers before writing. 117 * 118 * Lock ordering (including related VFS locks) is the following: 119 * dqonoff_mutex > i_mutex > journal_lock > dqptr_sem > dquot->dq_lock > 120 * dqio_mutex 121 * dqonoff_mutex > i_mutex comes from dquot_quota_sync, dquot_enable, etc. 122 * The lock ordering of dqptr_sem imposed by quota code is only dqonoff_sem > 123 * dqptr_sem. But filesystem has to count with the fact that functions such as 124 * dquot_alloc_space() acquire dqptr_sem and they usually have to be called 125 * from inside a transaction to keep filesystem consistency after a crash. Also 126 * filesystems usually want to do some IO on dquot from ->mark_dirty which is 127 * called with dqptr_sem held. 128 */ 129 130 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock); 131 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock); 132 __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock); 133 EXPORT_SYMBOL(dq_data_lock); 134 135 void __quota_error(struct super_block *sb, const char *func, 136 const char *fmt, ...) 137 { 138 if (printk_ratelimit()) { 139 va_list args; 140 struct va_format vaf; 141 142 va_start(args, fmt); 143 144 vaf.fmt = fmt; 145 vaf.va = &args; 146 147 printk(KERN_ERR "Quota error (device %s): %s: %pV\n", 148 sb->s_id, func, &vaf); 149 150 va_end(args); 151 } 152 } 153 EXPORT_SYMBOL(__quota_error); 154 155 #if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING) 156 static char *quotatypes[] = INITQFNAMES; 157 #endif 158 static struct quota_format_type *quota_formats; /* List of registered formats */ 159 static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES; 160 161 /* SLAB cache for dquot structures */ 162 static struct kmem_cache *dquot_cachep; 163 164 int register_quota_format(struct quota_format_type *fmt) 165 { 166 spin_lock(&dq_list_lock); 167 fmt->qf_next = quota_formats; 168 quota_formats = fmt; 169 spin_unlock(&dq_list_lock); 170 return 0; 171 } 172 EXPORT_SYMBOL(register_quota_format); 173 174 void unregister_quota_format(struct quota_format_type *fmt) 175 { 176 struct quota_format_type **actqf; 177 178 spin_lock(&dq_list_lock); 179 for (actqf = "a_formats; *actqf && *actqf != fmt; 180 actqf = &(*actqf)->qf_next) 181 ; 182 if (*actqf) 183 *actqf = (*actqf)->qf_next; 184 spin_unlock(&dq_list_lock); 185 } 186 EXPORT_SYMBOL(unregister_quota_format); 187 188 static struct quota_format_type *find_quota_format(int id) 189 { 190 struct quota_format_type *actqf; 191 192 spin_lock(&dq_list_lock); 193 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 194 actqf = actqf->qf_next) 195 ; 196 if (!actqf || !try_module_get(actqf->qf_owner)) { 197 int qm; 198 199 spin_unlock(&dq_list_lock); 200 201 for (qm = 0; module_names[qm].qm_fmt_id && 202 module_names[qm].qm_fmt_id != id; qm++) 203 ; 204 if (!module_names[qm].qm_fmt_id || 205 request_module(module_names[qm].qm_mod_name)) 206 return NULL; 207 208 spin_lock(&dq_list_lock); 209 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id; 210 actqf = actqf->qf_next) 211 ; 212 if (actqf && !try_module_get(actqf->qf_owner)) 213 actqf = NULL; 214 } 215 spin_unlock(&dq_list_lock); 216 return actqf; 217 } 218 219 static void put_quota_format(struct quota_format_type *fmt) 220 { 221 module_put(fmt->qf_owner); 222 } 223 224 /* 225 * Dquot List Management: 226 * The quota code uses three lists for dquot management: the inuse_list, 227 * free_dquots, and dquot_hash[] array. A single dquot structure may be 228 * on all three lists, depending on its current state. 229 * 230 * All dquots are placed to the end of inuse_list when first created, and this 231 * list is used for invalidate operation, which must look at every dquot. 232 * 233 * Unused dquots (dq_count == 0) are added to the free_dquots list when freed, 234 * and this list is searched whenever we need an available dquot. Dquots are 235 * removed from the list as soon as they are used again, and 236 * dqstats.free_dquots gives the number of dquots on the list. When 237 * dquot is invalidated it's completely released from memory. 238 * 239 * Dquots with a specific identity (device, type and id) are placed on 240 * one of the dquot_hash[] hash chains. The provides an efficient search 241 * mechanism to locate a specific dquot. 242 */ 243 244 static LIST_HEAD(inuse_list); 245 static LIST_HEAD(free_dquots); 246 static unsigned int dq_hash_bits, dq_hash_mask; 247 static struct hlist_head *dquot_hash; 248 249 struct dqstats dqstats; 250 EXPORT_SYMBOL(dqstats); 251 252 static qsize_t inode_get_rsv_space(struct inode *inode); 253 static void __dquot_initialize(struct inode *inode, int type); 254 255 static inline unsigned int 256 hashfn(const struct super_block *sb, struct kqid qid) 257 { 258 unsigned int id = from_kqid(&init_user_ns, qid); 259 int type = qid.type; 260 unsigned long tmp; 261 262 tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type); 263 return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask; 264 } 265 266 /* 267 * Following list functions expect dq_list_lock to be held 268 */ 269 static inline void insert_dquot_hash(struct dquot *dquot) 270 { 271 struct hlist_head *head; 272 head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id); 273 hlist_add_head(&dquot->dq_hash, head); 274 } 275 276 static inline void remove_dquot_hash(struct dquot *dquot) 277 { 278 hlist_del_init(&dquot->dq_hash); 279 } 280 281 static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb, 282 struct kqid qid) 283 { 284 struct hlist_node *node; 285 struct dquot *dquot; 286 287 hlist_for_each (node, dquot_hash+hashent) { 288 dquot = hlist_entry(node, struct dquot, dq_hash); 289 if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid)) 290 return dquot; 291 } 292 return NULL; 293 } 294 295 /* Add a dquot to the tail of the free list */ 296 static inline void put_dquot_last(struct dquot *dquot) 297 { 298 list_add_tail(&dquot->dq_free, &free_dquots); 299 dqstats_inc(DQST_FREE_DQUOTS); 300 } 301 302 static inline void remove_free_dquot(struct dquot *dquot) 303 { 304 if (list_empty(&dquot->dq_free)) 305 return; 306 list_del_init(&dquot->dq_free); 307 dqstats_dec(DQST_FREE_DQUOTS); 308 } 309 310 static inline void put_inuse(struct dquot *dquot) 311 { 312 /* We add to the back of inuse list so we don't have to restart 313 * when traversing this list and we block */ 314 list_add_tail(&dquot->dq_inuse, &inuse_list); 315 dqstats_inc(DQST_ALLOC_DQUOTS); 316 } 317 318 static inline void remove_inuse(struct dquot *dquot) 319 { 320 dqstats_dec(DQST_ALLOC_DQUOTS); 321 list_del(&dquot->dq_inuse); 322 } 323 /* 324 * End of list functions needing dq_list_lock 325 */ 326 327 static void wait_on_dquot(struct dquot *dquot) 328 { 329 mutex_lock(&dquot->dq_lock); 330 mutex_unlock(&dquot->dq_lock); 331 } 332 333 static inline int dquot_dirty(struct dquot *dquot) 334 { 335 return test_bit(DQ_MOD_B, &dquot->dq_flags); 336 } 337 338 static inline int mark_dquot_dirty(struct dquot *dquot) 339 { 340 return dquot->dq_sb->dq_op->mark_dirty(dquot); 341 } 342 343 /* Mark dquot dirty in atomic manner, and return it's old dirty flag state */ 344 int dquot_mark_dquot_dirty(struct dquot *dquot) 345 { 346 int ret = 1; 347 348 /* If quota is dirty already, we don't have to acquire dq_list_lock */ 349 if (test_bit(DQ_MOD_B, &dquot->dq_flags)) 350 return 1; 351 352 spin_lock(&dq_list_lock); 353 if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) { 354 list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)-> 355 info[dquot->dq_id.type].dqi_dirty_list); 356 ret = 0; 357 } 358 spin_unlock(&dq_list_lock); 359 return ret; 360 } 361 EXPORT_SYMBOL(dquot_mark_dquot_dirty); 362 363 /* Dirtify all the dquots - this can block when journalling */ 364 static inline int mark_all_dquot_dirty(struct dquot * const *dquot) 365 { 366 int ret, err, cnt; 367 368 ret = err = 0; 369 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 370 if (dquot[cnt]) 371 /* Even in case of error we have to continue */ 372 ret = mark_dquot_dirty(dquot[cnt]); 373 if (!err) 374 err = ret; 375 } 376 return err; 377 } 378 379 static inline void dqput_all(struct dquot **dquot) 380 { 381 unsigned int cnt; 382 383 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 384 dqput(dquot[cnt]); 385 } 386 387 /* This function needs dq_list_lock */ 388 static inline int clear_dquot_dirty(struct dquot *dquot) 389 { 390 if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) 391 return 0; 392 list_del_init(&dquot->dq_dirty); 393 return 1; 394 } 395 396 void mark_info_dirty(struct super_block *sb, int type) 397 { 398 set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags); 399 } 400 EXPORT_SYMBOL(mark_info_dirty); 401 402 /* 403 * Read dquot from disk and alloc space for it 404 */ 405 406 int dquot_acquire(struct dquot *dquot) 407 { 408 int ret = 0, ret2 = 0; 409 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 410 411 mutex_lock(&dquot->dq_lock); 412 mutex_lock(&dqopt->dqio_mutex); 413 if (!test_bit(DQ_READ_B, &dquot->dq_flags)) 414 ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot); 415 if (ret < 0) 416 goto out_iolock; 417 set_bit(DQ_READ_B, &dquot->dq_flags); 418 /* Instantiate dquot if needed */ 419 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) { 420 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 421 /* Write the info if needed */ 422 if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 423 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 424 dquot->dq_sb, dquot->dq_id.type); 425 } 426 if (ret < 0) 427 goto out_iolock; 428 if (ret2 < 0) { 429 ret = ret2; 430 goto out_iolock; 431 } 432 } 433 set_bit(DQ_ACTIVE_B, &dquot->dq_flags); 434 out_iolock: 435 mutex_unlock(&dqopt->dqio_mutex); 436 mutex_unlock(&dquot->dq_lock); 437 return ret; 438 } 439 EXPORT_SYMBOL(dquot_acquire); 440 441 /* 442 * Write dquot to disk 443 */ 444 int dquot_commit(struct dquot *dquot) 445 { 446 int ret = 0; 447 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 448 449 mutex_lock(&dqopt->dqio_mutex); 450 spin_lock(&dq_list_lock); 451 if (!clear_dquot_dirty(dquot)) { 452 spin_unlock(&dq_list_lock); 453 goto out_sem; 454 } 455 spin_unlock(&dq_list_lock); 456 /* Inactive dquot can be only if there was error during read/init 457 * => we have better not writing it */ 458 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 459 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot); 460 else 461 ret = -EIO; 462 out_sem: 463 mutex_unlock(&dqopt->dqio_mutex); 464 return ret; 465 } 466 EXPORT_SYMBOL(dquot_commit); 467 468 /* 469 * Release dquot 470 */ 471 int dquot_release(struct dquot *dquot) 472 { 473 int ret = 0, ret2 = 0; 474 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb); 475 476 mutex_lock(&dquot->dq_lock); 477 /* Check whether we are not racing with some other dqget() */ 478 if (atomic_read(&dquot->dq_count) > 1) 479 goto out_dqlock; 480 mutex_lock(&dqopt->dqio_mutex); 481 if (dqopt->ops[dquot->dq_id.type]->release_dqblk) { 482 ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot); 483 /* Write the info */ 484 if (info_dirty(&dqopt->info[dquot->dq_id.type])) { 485 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info( 486 dquot->dq_sb, dquot->dq_id.type); 487 } 488 if (ret >= 0) 489 ret = ret2; 490 } 491 clear_bit(DQ_ACTIVE_B, &dquot->dq_flags); 492 mutex_unlock(&dqopt->dqio_mutex); 493 out_dqlock: 494 mutex_unlock(&dquot->dq_lock); 495 return ret; 496 } 497 EXPORT_SYMBOL(dquot_release); 498 499 void dquot_destroy(struct dquot *dquot) 500 { 501 kmem_cache_free(dquot_cachep, dquot); 502 } 503 EXPORT_SYMBOL(dquot_destroy); 504 505 static inline void do_destroy_dquot(struct dquot *dquot) 506 { 507 dquot->dq_sb->dq_op->destroy_dquot(dquot); 508 } 509 510 /* Invalidate all dquots on the list. Note that this function is called after 511 * quota is disabled and pointers from inodes removed so there cannot be new 512 * quota users. There can still be some users of quotas due to inodes being 513 * just deleted or pruned by prune_icache() (those are not attached to any 514 * list) or parallel quotactl call. We have to wait for such users. 515 */ 516 static void invalidate_dquots(struct super_block *sb, int type) 517 { 518 struct dquot *dquot, *tmp; 519 520 restart: 521 spin_lock(&dq_list_lock); 522 list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) { 523 if (dquot->dq_sb != sb) 524 continue; 525 if (dquot->dq_id.type != type) 526 continue; 527 /* Wait for dquot users */ 528 if (atomic_read(&dquot->dq_count)) { 529 DEFINE_WAIT(wait); 530 531 atomic_inc(&dquot->dq_count); 532 prepare_to_wait(&dquot->dq_wait_unused, &wait, 533 TASK_UNINTERRUPTIBLE); 534 spin_unlock(&dq_list_lock); 535 /* Once dqput() wakes us up, we know it's time to free 536 * the dquot. 537 * IMPORTANT: we rely on the fact that there is always 538 * at most one process waiting for dquot to free. 539 * Otherwise dq_count would be > 1 and we would never 540 * wake up. 541 */ 542 if (atomic_read(&dquot->dq_count) > 1) 543 schedule(); 544 finish_wait(&dquot->dq_wait_unused, &wait); 545 dqput(dquot); 546 /* At this moment dquot() need not exist (it could be 547 * reclaimed by prune_dqcache(). Hence we must 548 * restart. */ 549 goto restart; 550 } 551 /* 552 * Quota now has no users and it has been written on last 553 * dqput() 554 */ 555 remove_dquot_hash(dquot); 556 remove_free_dquot(dquot); 557 remove_inuse(dquot); 558 do_destroy_dquot(dquot); 559 } 560 spin_unlock(&dq_list_lock); 561 } 562 563 /* Call callback for every active dquot on given filesystem */ 564 int dquot_scan_active(struct super_block *sb, 565 int (*fn)(struct dquot *dquot, unsigned long priv), 566 unsigned long priv) 567 { 568 struct dquot *dquot, *old_dquot = NULL; 569 int ret = 0; 570 571 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 572 spin_lock(&dq_list_lock); 573 list_for_each_entry(dquot, &inuse_list, dq_inuse) { 574 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) 575 continue; 576 if (dquot->dq_sb != sb) 577 continue; 578 /* Now we have active dquot so we can just increase use count */ 579 atomic_inc(&dquot->dq_count); 580 spin_unlock(&dq_list_lock); 581 dqstats_inc(DQST_LOOKUPS); 582 dqput(old_dquot); 583 old_dquot = dquot; 584 ret = fn(dquot, priv); 585 if (ret < 0) 586 goto out; 587 spin_lock(&dq_list_lock); 588 /* We are safe to continue now because our dquot could not 589 * be moved out of the inuse list while we hold the reference */ 590 } 591 spin_unlock(&dq_list_lock); 592 out: 593 dqput(old_dquot); 594 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 595 return ret; 596 } 597 EXPORT_SYMBOL(dquot_scan_active); 598 599 /* Write all dquot structures to quota files */ 600 int dquot_writeback_dquots(struct super_block *sb, int type) 601 { 602 struct list_head *dirty; 603 struct dquot *dquot; 604 struct quota_info *dqopt = sb_dqopt(sb); 605 int cnt; 606 int err, ret = 0; 607 608 mutex_lock(&dqopt->dqonoff_mutex); 609 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 610 if (type != -1 && cnt != type) 611 continue; 612 if (!sb_has_quota_active(sb, cnt)) 613 continue; 614 spin_lock(&dq_list_lock); 615 dirty = &dqopt->info[cnt].dqi_dirty_list; 616 while (!list_empty(dirty)) { 617 dquot = list_first_entry(dirty, struct dquot, 618 dq_dirty); 619 /* Dirty and inactive can be only bad dquot... */ 620 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 621 clear_dquot_dirty(dquot); 622 continue; 623 } 624 /* Now we have active dquot from which someone is 625 * holding reference so we can safely just increase 626 * use count */ 627 atomic_inc(&dquot->dq_count); 628 spin_unlock(&dq_list_lock); 629 dqstats_inc(DQST_LOOKUPS); 630 err = sb->dq_op->write_dquot(dquot); 631 if (!ret && err) 632 err = ret; 633 dqput(dquot); 634 spin_lock(&dq_list_lock); 635 } 636 spin_unlock(&dq_list_lock); 637 } 638 639 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 640 if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt) 641 && info_dirty(&dqopt->info[cnt])) 642 sb->dq_op->write_info(sb, cnt); 643 dqstats_inc(DQST_SYNCS); 644 mutex_unlock(&dqopt->dqonoff_mutex); 645 646 return ret; 647 } 648 EXPORT_SYMBOL(dquot_writeback_dquots); 649 650 /* Write all dquot structures to disk and make them visible from userspace */ 651 int dquot_quota_sync(struct super_block *sb, int type) 652 { 653 struct quota_info *dqopt = sb_dqopt(sb); 654 int cnt; 655 int ret; 656 657 ret = dquot_writeback_dquots(sb, type); 658 if (ret) 659 return ret; 660 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 661 return 0; 662 663 /* This is not very clever (and fast) but currently I don't know about 664 * any other simple way of getting quota data to disk and we must get 665 * them there for userspace to be visible... */ 666 if (sb->s_op->sync_fs) 667 sb->s_op->sync_fs(sb, 1); 668 sync_blockdev(sb->s_bdev); 669 670 /* 671 * Now when everything is written we can discard the pagecache so 672 * that userspace sees the changes. 673 */ 674 mutex_lock(&dqopt->dqonoff_mutex); 675 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 676 if (type != -1 && cnt != type) 677 continue; 678 if (!sb_has_quota_active(sb, cnt)) 679 continue; 680 mutex_lock(&dqopt->files[cnt]->i_mutex); 681 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0); 682 mutex_unlock(&dqopt->files[cnt]->i_mutex); 683 } 684 mutex_unlock(&dqopt->dqonoff_mutex); 685 686 return 0; 687 } 688 EXPORT_SYMBOL(dquot_quota_sync); 689 690 /* Free unused dquots from cache */ 691 static void prune_dqcache(int count) 692 { 693 struct list_head *head; 694 struct dquot *dquot; 695 696 head = free_dquots.prev; 697 while (head != &free_dquots && count) { 698 dquot = list_entry(head, struct dquot, dq_free); 699 remove_dquot_hash(dquot); 700 remove_free_dquot(dquot); 701 remove_inuse(dquot); 702 do_destroy_dquot(dquot); 703 count--; 704 head = free_dquots.prev; 705 } 706 } 707 708 /* 709 * This is called from kswapd when we think we need some 710 * more memory 711 */ 712 static int shrink_dqcache_memory(struct shrinker *shrink, 713 struct shrink_control *sc) 714 { 715 int nr = sc->nr_to_scan; 716 717 if (nr) { 718 spin_lock(&dq_list_lock); 719 prune_dqcache(nr); 720 spin_unlock(&dq_list_lock); 721 } 722 return ((unsigned) 723 percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS]) 724 /100) * sysctl_vfs_cache_pressure; 725 } 726 727 static struct shrinker dqcache_shrinker = { 728 .shrink = shrink_dqcache_memory, 729 .seeks = DEFAULT_SEEKS, 730 }; 731 732 /* 733 * Put reference to dquot 734 * NOTE: If you change this function please check whether dqput_blocks() works right... 735 */ 736 void dqput(struct dquot *dquot) 737 { 738 int ret; 739 740 if (!dquot) 741 return; 742 #ifdef CONFIG_QUOTA_DEBUG 743 if (!atomic_read(&dquot->dq_count)) { 744 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d", 745 quotatypes[dquot->dq_id.type], 746 from_kqid(&init_user_ns, dquot->dq_id)); 747 BUG(); 748 } 749 #endif 750 dqstats_inc(DQST_DROPS); 751 we_slept: 752 spin_lock(&dq_list_lock); 753 if (atomic_read(&dquot->dq_count) > 1) { 754 /* We have more than one user... nothing to do */ 755 atomic_dec(&dquot->dq_count); 756 /* Releasing dquot during quotaoff phase? */ 757 if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) && 758 atomic_read(&dquot->dq_count) == 1) 759 wake_up(&dquot->dq_wait_unused); 760 spin_unlock(&dq_list_lock); 761 return; 762 } 763 /* Need to release dquot? */ 764 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) { 765 spin_unlock(&dq_list_lock); 766 /* Commit dquot before releasing */ 767 ret = dquot->dq_sb->dq_op->write_dquot(dquot); 768 if (ret < 0) { 769 quota_error(dquot->dq_sb, "Can't write quota structure" 770 " (error %d). Quota may get out of sync!", 771 ret); 772 /* 773 * We clear dirty bit anyway, so that we avoid 774 * infinite loop here 775 */ 776 spin_lock(&dq_list_lock); 777 clear_dquot_dirty(dquot); 778 spin_unlock(&dq_list_lock); 779 } 780 goto we_slept; 781 } 782 /* Clear flag in case dquot was inactive (something bad happened) */ 783 clear_dquot_dirty(dquot); 784 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) { 785 spin_unlock(&dq_list_lock); 786 dquot->dq_sb->dq_op->release_dquot(dquot); 787 goto we_slept; 788 } 789 atomic_dec(&dquot->dq_count); 790 #ifdef CONFIG_QUOTA_DEBUG 791 /* sanity check */ 792 BUG_ON(!list_empty(&dquot->dq_free)); 793 #endif 794 put_dquot_last(dquot); 795 spin_unlock(&dq_list_lock); 796 } 797 EXPORT_SYMBOL(dqput); 798 799 struct dquot *dquot_alloc(struct super_block *sb, int type) 800 { 801 return kmem_cache_zalloc(dquot_cachep, GFP_NOFS); 802 } 803 EXPORT_SYMBOL(dquot_alloc); 804 805 static struct dquot *get_empty_dquot(struct super_block *sb, int type) 806 { 807 struct dquot *dquot; 808 809 dquot = sb->dq_op->alloc_dquot(sb, type); 810 if(!dquot) 811 return NULL; 812 813 mutex_init(&dquot->dq_lock); 814 INIT_LIST_HEAD(&dquot->dq_free); 815 INIT_LIST_HEAD(&dquot->dq_inuse); 816 INIT_HLIST_NODE(&dquot->dq_hash); 817 INIT_LIST_HEAD(&dquot->dq_dirty); 818 init_waitqueue_head(&dquot->dq_wait_unused); 819 dquot->dq_sb = sb; 820 dquot->dq_id = make_kqid_invalid(type); 821 atomic_set(&dquot->dq_count, 1); 822 823 return dquot; 824 } 825 826 /* 827 * Get reference to dquot 828 * 829 * Locking is slightly tricky here. We are guarded from parallel quotaoff() 830 * destroying our dquot by: 831 * a) checking for quota flags under dq_list_lock and 832 * b) getting a reference to dquot before we release dq_list_lock 833 */ 834 struct dquot *dqget(struct super_block *sb, struct kqid qid) 835 { 836 unsigned int hashent = hashfn(sb, qid); 837 struct dquot *dquot = NULL, *empty = NULL; 838 839 if (!sb_has_quota_active(sb, qid.type)) 840 return NULL; 841 we_slept: 842 spin_lock(&dq_list_lock); 843 spin_lock(&dq_state_lock); 844 if (!sb_has_quota_active(sb, qid.type)) { 845 spin_unlock(&dq_state_lock); 846 spin_unlock(&dq_list_lock); 847 goto out; 848 } 849 spin_unlock(&dq_state_lock); 850 851 dquot = find_dquot(hashent, sb, qid); 852 if (!dquot) { 853 if (!empty) { 854 spin_unlock(&dq_list_lock); 855 empty = get_empty_dquot(sb, qid.type); 856 if (!empty) 857 schedule(); /* Try to wait for a moment... */ 858 goto we_slept; 859 } 860 dquot = empty; 861 empty = NULL; 862 dquot->dq_id = qid; 863 /* all dquots go on the inuse_list */ 864 put_inuse(dquot); 865 /* hash it first so it can be found */ 866 insert_dquot_hash(dquot); 867 spin_unlock(&dq_list_lock); 868 dqstats_inc(DQST_LOOKUPS); 869 } else { 870 if (!atomic_read(&dquot->dq_count)) 871 remove_free_dquot(dquot); 872 atomic_inc(&dquot->dq_count); 873 spin_unlock(&dq_list_lock); 874 dqstats_inc(DQST_CACHE_HITS); 875 dqstats_inc(DQST_LOOKUPS); 876 } 877 /* Wait for dq_lock - after this we know that either dquot_release() is 878 * already finished or it will be canceled due to dq_count > 1 test */ 879 wait_on_dquot(dquot); 880 /* Read the dquot / allocate space in quota file */ 881 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && 882 sb->dq_op->acquire_dquot(dquot) < 0) { 883 dqput(dquot); 884 dquot = NULL; 885 goto out; 886 } 887 #ifdef CONFIG_QUOTA_DEBUG 888 BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */ 889 #endif 890 out: 891 if (empty) 892 do_destroy_dquot(empty); 893 894 return dquot; 895 } 896 EXPORT_SYMBOL(dqget); 897 898 static int dqinit_needed(struct inode *inode, int type) 899 { 900 int cnt; 901 902 if (IS_NOQUOTA(inode)) 903 return 0; 904 if (type != -1) 905 return !inode->i_dquot[type]; 906 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 907 if (!inode->i_dquot[cnt]) 908 return 1; 909 return 0; 910 } 911 912 /* This routine is guarded by dqonoff_mutex mutex */ 913 static void add_dquot_ref(struct super_block *sb, int type) 914 { 915 struct inode *inode, *old_inode = NULL; 916 #ifdef CONFIG_QUOTA_DEBUG 917 int reserved = 0; 918 #endif 919 920 spin_lock(&inode_sb_list_lock); 921 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 922 spin_lock(&inode->i_lock); 923 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) || 924 !atomic_read(&inode->i_writecount) || 925 !dqinit_needed(inode, type)) { 926 spin_unlock(&inode->i_lock); 927 continue; 928 } 929 __iget(inode); 930 spin_unlock(&inode->i_lock); 931 spin_unlock(&inode_sb_list_lock); 932 933 #ifdef CONFIG_QUOTA_DEBUG 934 if (unlikely(inode_get_rsv_space(inode) > 0)) 935 reserved = 1; 936 #endif 937 iput(old_inode); 938 __dquot_initialize(inode, type); 939 940 /* 941 * We hold a reference to 'inode' so it couldn't have been 942 * removed from s_inodes list while we dropped the 943 * inode_sb_list_lock We cannot iput the inode now as we can be 944 * holding the last reference and we cannot iput it under 945 * inode_sb_list_lock. So we keep the reference and iput it 946 * later. 947 */ 948 old_inode = inode; 949 spin_lock(&inode_sb_list_lock); 950 } 951 spin_unlock(&inode_sb_list_lock); 952 iput(old_inode); 953 954 #ifdef CONFIG_QUOTA_DEBUG 955 if (reserved) { 956 quota_error(sb, "Writes happened before quota was turned on " 957 "thus quota information is probably inconsistent. " 958 "Please run quotacheck(8)"); 959 } 960 #endif 961 } 962 963 /* 964 * Return 0 if dqput() won't block. 965 * (note that 1 doesn't necessarily mean blocking) 966 */ 967 static inline int dqput_blocks(struct dquot *dquot) 968 { 969 if (atomic_read(&dquot->dq_count) <= 1) 970 return 1; 971 return 0; 972 } 973 974 /* 975 * Remove references to dquots from inode and add dquot to list for freeing 976 * if we have the last reference to dquot 977 * We can't race with anybody because we hold dqptr_sem for writing... 978 */ 979 static int remove_inode_dquot_ref(struct inode *inode, int type, 980 struct list_head *tofree_head) 981 { 982 struct dquot *dquot = inode->i_dquot[type]; 983 984 inode->i_dquot[type] = NULL; 985 if (dquot) { 986 if (dqput_blocks(dquot)) { 987 #ifdef CONFIG_QUOTA_DEBUG 988 if (atomic_read(&dquot->dq_count) != 1) 989 quota_error(inode->i_sb, "Adding dquot with " 990 "dq_count %d to dispose list", 991 atomic_read(&dquot->dq_count)); 992 #endif 993 spin_lock(&dq_list_lock); 994 /* As dquot must have currently users it can't be on 995 * the free list... */ 996 list_add(&dquot->dq_free, tofree_head); 997 spin_unlock(&dq_list_lock); 998 return 1; 999 } 1000 else 1001 dqput(dquot); /* We have guaranteed we won't block */ 1002 } 1003 return 0; 1004 } 1005 1006 /* 1007 * Free list of dquots 1008 * Dquots are removed from inodes and no new references can be got so we are 1009 * the only ones holding reference 1010 */ 1011 static void put_dquot_list(struct list_head *tofree_head) 1012 { 1013 struct list_head *act_head; 1014 struct dquot *dquot; 1015 1016 act_head = tofree_head->next; 1017 while (act_head != tofree_head) { 1018 dquot = list_entry(act_head, struct dquot, dq_free); 1019 act_head = act_head->next; 1020 /* Remove dquot from the list so we won't have problems... */ 1021 list_del_init(&dquot->dq_free); 1022 dqput(dquot); 1023 } 1024 } 1025 1026 static void remove_dquot_ref(struct super_block *sb, int type, 1027 struct list_head *tofree_head) 1028 { 1029 struct inode *inode; 1030 int reserved = 0; 1031 1032 spin_lock(&inode_sb_list_lock); 1033 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) { 1034 /* 1035 * We have to scan also I_NEW inodes because they can already 1036 * have quota pointer initialized. Luckily, we need to touch 1037 * only quota pointers and these have separate locking 1038 * (dqptr_sem). 1039 */ 1040 if (!IS_NOQUOTA(inode)) { 1041 if (unlikely(inode_get_rsv_space(inode) > 0)) 1042 reserved = 1; 1043 remove_inode_dquot_ref(inode, type, tofree_head); 1044 } 1045 } 1046 spin_unlock(&inode_sb_list_lock); 1047 #ifdef CONFIG_QUOTA_DEBUG 1048 if (reserved) { 1049 printk(KERN_WARNING "VFS (%s): Writes happened after quota" 1050 " was disabled thus quota information is probably " 1051 "inconsistent. Please run quotacheck(8).\n", sb->s_id); 1052 } 1053 #endif 1054 } 1055 1056 /* Gather all references from inodes and drop them */ 1057 static void drop_dquot_ref(struct super_block *sb, int type) 1058 { 1059 LIST_HEAD(tofree_head); 1060 1061 if (sb->dq_op) { 1062 down_write(&sb_dqopt(sb)->dqptr_sem); 1063 remove_dquot_ref(sb, type, &tofree_head); 1064 up_write(&sb_dqopt(sb)->dqptr_sem); 1065 put_dquot_list(&tofree_head); 1066 } 1067 } 1068 1069 static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number) 1070 { 1071 dquot->dq_dqb.dqb_curinodes += number; 1072 } 1073 1074 static inline void dquot_incr_space(struct dquot *dquot, qsize_t number) 1075 { 1076 dquot->dq_dqb.dqb_curspace += number; 1077 } 1078 1079 static inline void dquot_resv_space(struct dquot *dquot, qsize_t number) 1080 { 1081 dquot->dq_dqb.dqb_rsvspace += number; 1082 } 1083 1084 /* 1085 * Claim reserved quota space 1086 */ 1087 static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number) 1088 { 1089 if (dquot->dq_dqb.dqb_rsvspace < number) { 1090 WARN_ON_ONCE(1); 1091 number = dquot->dq_dqb.dqb_rsvspace; 1092 } 1093 dquot->dq_dqb.dqb_curspace += number; 1094 dquot->dq_dqb.dqb_rsvspace -= number; 1095 } 1096 1097 static inline 1098 void dquot_free_reserved_space(struct dquot *dquot, qsize_t number) 1099 { 1100 if (dquot->dq_dqb.dqb_rsvspace >= number) 1101 dquot->dq_dqb.dqb_rsvspace -= number; 1102 else { 1103 WARN_ON_ONCE(1); 1104 dquot->dq_dqb.dqb_rsvspace = 0; 1105 } 1106 } 1107 1108 static void dquot_decr_inodes(struct dquot *dquot, qsize_t number) 1109 { 1110 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1111 dquot->dq_dqb.dqb_curinodes >= number) 1112 dquot->dq_dqb.dqb_curinodes -= number; 1113 else 1114 dquot->dq_dqb.dqb_curinodes = 0; 1115 if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit) 1116 dquot->dq_dqb.dqb_itime = (time_t) 0; 1117 clear_bit(DQ_INODES_B, &dquot->dq_flags); 1118 } 1119 1120 static void dquot_decr_space(struct dquot *dquot, qsize_t number) 1121 { 1122 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE || 1123 dquot->dq_dqb.dqb_curspace >= number) 1124 dquot->dq_dqb.dqb_curspace -= number; 1125 else 1126 dquot->dq_dqb.dqb_curspace = 0; 1127 if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1128 dquot->dq_dqb.dqb_btime = (time_t) 0; 1129 clear_bit(DQ_BLKS_B, &dquot->dq_flags); 1130 } 1131 1132 struct dquot_warn { 1133 struct super_block *w_sb; 1134 struct kqid w_dq_id; 1135 short w_type; 1136 }; 1137 1138 static int warning_issued(struct dquot *dquot, const int warntype) 1139 { 1140 int flag = (warntype == QUOTA_NL_BHARDWARN || 1141 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B : 1142 ((warntype == QUOTA_NL_IHARDWARN || 1143 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0); 1144 1145 if (!flag) 1146 return 0; 1147 return test_and_set_bit(flag, &dquot->dq_flags); 1148 } 1149 1150 #ifdef CONFIG_PRINT_QUOTA_WARNING 1151 static int flag_print_warnings = 1; 1152 1153 static int need_print_warning(struct dquot_warn *warn) 1154 { 1155 if (!flag_print_warnings) 1156 return 0; 1157 1158 switch (warn->w_dq_id.type) { 1159 case USRQUOTA: 1160 return uid_eq(current_fsuid(), warn->w_dq_id.uid); 1161 case GRPQUOTA: 1162 return in_group_p(warn->w_dq_id.gid); 1163 case PRJQUOTA: /* Never taken... Just make gcc happy */ 1164 return 0; 1165 } 1166 return 0; 1167 } 1168 1169 /* Print warning to user which exceeded quota */ 1170 static void print_warning(struct dquot_warn *warn) 1171 { 1172 char *msg = NULL; 1173 struct tty_struct *tty; 1174 int warntype = warn->w_type; 1175 1176 if (warntype == QUOTA_NL_IHARDBELOW || 1177 warntype == QUOTA_NL_ISOFTBELOW || 1178 warntype == QUOTA_NL_BHARDBELOW || 1179 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn)) 1180 return; 1181 1182 tty = get_current_tty(); 1183 if (!tty) 1184 return; 1185 tty_write_message(tty, warn->w_sb->s_id); 1186 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) 1187 tty_write_message(tty, ": warning, "); 1188 else 1189 tty_write_message(tty, ": write failed, "); 1190 tty_write_message(tty, quotatypes[warn->w_dq_id.type]); 1191 switch (warntype) { 1192 case QUOTA_NL_IHARDWARN: 1193 msg = " file limit reached.\r\n"; 1194 break; 1195 case QUOTA_NL_ISOFTLONGWARN: 1196 msg = " file quota exceeded too long.\r\n"; 1197 break; 1198 case QUOTA_NL_ISOFTWARN: 1199 msg = " file quota exceeded.\r\n"; 1200 break; 1201 case QUOTA_NL_BHARDWARN: 1202 msg = " block limit reached.\r\n"; 1203 break; 1204 case QUOTA_NL_BSOFTLONGWARN: 1205 msg = " block quota exceeded too long.\r\n"; 1206 break; 1207 case QUOTA_NL_BSOFTWARN: 1208 msg = " block quota exceeded.\r\n"; 1209 break; 1210 } 1211 tty_write_message(tty, msg); 1212 tty_kref_put(tty); 1213 } 1214 #endif 1215 1216 static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot, 1217 int warntype) 1218 { 1219 if (warning_issued(dquot, warntype)) 1220 return; 1221 warn->w_type = warntype; 1222 warn->w_sb = dquot->dq_sb; 1223 warn->w_dq_id = dquot->dq_id; 1224 } 1225 1226 /* 1227 * Write warnings to the console and send warning messages over netlink. 1228 * 1229 * Note that this function can call into tty and networking code. 1230 */ 1231 static void flush_warnings(struct dquot_warn *warn) 1232 { 1233 int i; 1234 1235 for (i = 0; i < MAXQUOTAS; i++) { 1236 if (warn[i].w_type == QUOTA_NL_NOWARN) 1237 continue; 1238 #ifdef CONFIG_PRINT_QUOTA_WARNING 1239 print_warning(&warn[i]); 1240 #endif 1241 quota_send_warning(warn[i].w_dq_id, 1242 warn[i].w_sb->s_dev, warn[i].w_type); 1243 } 1244 } 1245 1246 static int ignore_hardlimit(struct dquot *dquot) 1247 { 1248 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 1249 1250 return capable(CAP_SYS_RESOURCE) && 1251 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || 1252 !(info->dqi_flags & V1_DQF_RSQUASH)); 1253 } 1254 1255 /* needs dq_data_lock */ 1256 static int check_idq(struct dquot *dquot, qsize_t inodes, 1257 struct dquot_warn *warn) 1258 { 1259 qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes; 1260 1261 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) || 1262 test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1263 return 0; 1264 1265 if (dquot->dq_dqb.dqb_ihardlimit && 1266 newinodes > dquot->dq_dqb.dqb_ihardlimit && 1267 !ignore_hardlimit(dquot)) { 1268 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN); 1269 return -EDQUOT; 1270 } 1271 1272 if (dquot->dq_dqb.dqb_isoftlimit && 1273 newinodes > dquot->dq_dqb.dqb_isoftlimit && 1274 dquot->dq_dqb.dqb_itime && 1275 get_seconds() >= dquot->dq_dqb.dqb_itime && 1276 !ignore_hardlimit(dquot)) { 1277 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN); 1278 return -EDQUOT; 1279 } 1280 1281 if (dquot->dq_dqb.dqb_isoftlimit && 1282 newinodes > dquot->dq_dqb.dqb_isoftlimit && 1283 dquot->dq_dqb.dqb_itime == 0) { 1284 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN); 1285 dquot->dq_dqb.dqb_itime = get_seconds() + 1286 sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace; 1287 } 1288 1289 return 0; 1290 } 1291 1292 /* needs dq_data_lock */ 1293 static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, 1294 struct dquot_warn *warn) 1295 { 1296 qsize_t tspace; 1297 struct super_block *sb = dquot->dq_sb; 1298 1299 if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) || 1300 test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1301 return 0; 1302 1303 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace 1304 + space; 1305 1306 if (dquot->dq_dqb.dqb_bhardlimit && 1307 tspace > dquot->dq_dqb.dqb_bhardlimit && 1308 !ignore_hardlimit(dquot)) { 1309 if (!prealloc) 1310 prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN); 1311 return -EDQUOT; 1312 } 1313 1314 if (dquot->dq_dqb.dqb_bsoftlimit && 1315 tspace > dquot->dq_dqb.dqb_bsoftlimit && 1316 dquot->dq_dqb.dqb_btime && 1317 get_seconds() >= dquot->dq_dqb.dqb_btime && 1318 !ignore_hardlimit(dquot)) { 1319 if (!prealloc) 1320 prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN); 1321 return -EDQUOT; 1322 } 1323 1324 if (dquot->dq_dqb.dqb_bsoftlimit && 1325 tspace > dquot->dq_dqb.dqb_bsoftlimit && 1326 dquot->dq_dqb.dqb_btime == 0) { 1327 if (!prealloc) { 1328 prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN); 1329 dquot->dq_dqb.dqb_btime = get_seconds() + 1330 sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace; 1331 } 1332 else 1333 /* 1334 * We don't allow preallocation to exceed softlimit so exceeding will 1335 * be always printed 1336 */ 1337 return -EDQUOT; 1338 } 1339 1340 return 0; 1341 } 1342 1343 static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1344 { 1345 qsize_t newinodes; 1346 1347 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1348 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 1349 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type)) 1350 return QUOTA_NL_NOWARN; 1351 1352 newinodes = dquot->dq_dqb.dqb_curinodes - inodes; 1353 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit) 1354 return QUOTA_NL_ISOFTBELOW; 1355 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1356 newinodes < dquot->dq_dqb.dqb_ihardlimit) 1357 return QUOTA_NL_IHARDBELOW; 1358 return QUOTA_NL_NOWARN; 1359 } 1360 1361 static int info_bdq_free(struct dquot *dquot, qsize_t space) 1362 { 1363 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1364 dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1365 return QUOTA_NL_NOWARN; 1366 1367 if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit) 1368 return QUOTA_NL_BSOFTBELOW; 1369 if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit && 1370 dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit) 1371 return QUOTA_NL_BHARDBELOW; 1372 return QUOTA_NL_NOWARN; 1373 } 1374 1375 static int dquot_active(const struct inode *inode) 1376 { 1377 struct super_block *sb = inode->i_sb; 1378 1379 if (IS_NOQUOTA(inode)) 1380 return 0; 1381 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb); 1382 } 1383 1384 /* 1385 * Initialize quota pointers in inode 1386 * 1387 * We do things in a bit complicated way but by that we avoid calling 1388 * dqget() and thus filesystem callbacks under dqptr_sem. 1389 * 1390 * It is better to call this function outside of any transaction as it 1391 * might need a lot of space in journal for dquot structure allocation. 1392 */ 1393 static void __dquot_initialize(struct inode *inode, int type) 1394 { 1395 int cnt; 1396 struct dquot *got[MAXQUOTAS]; 1397 struct super_block *sb = inode->i_sb; 1398 qsize_t rsv; 1399 1400 /* First test before acquiring mutex - solves deadlocks when we 1401 * re-enter the quota code and are already holding the mutex */ 1402 if (!dquot_active(inode)) 1403 return; 1404 1405 /* First get references to structures we might need. */ 1406 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1407 struct kqid qid; 1408 got[cnt] = NULL; 1409 if (type != -1 && cnt != type) 1410 continue; 1411 switch (cnt) { 1412 case USRQUOTA: 1413 qid = make_kqid_uid(inode->i_uid); 1414 break; 1415 case GRPQUOTA: 1416 qid = make_kqid_gid(inode->i_gid); 1417 break; 1418 } 1419 got[cnt] = dqget(sb, qid); 1420 } 1421 1422 down_write(&sb_dqopt(sb)->dqptr_sem); 1423 if (IS_NOQUOTA(inode)) 1424 goto out_err; 1425 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1426 if (type != -1 && cnt != type) 1427 continue; 1428 /* Avoid races with quotaoff() */ 1429 if (!sb_has_quota_active(sb, cnt)) 1430 continue; 1431 /* We could race with quotaon or dqget() could have failed */ 1432 if (!got[cnt]) 1433 continue; 1434 if (!inode->i_dquot[cnt]) { 1435 inode->i_dquot[cnt] = got[cnt]; 1436 got[cnt] = NULL; 1437 /* 1438 * Make quota reservation system happy if someone 1439 * did a write before quota was turned on 1440 */ 1441 rsv = inode_get_rsv_space(inode); 1442 if (unlikely(rsv)) 1443 dquot_resv_space(inode->i_dquot[cnt], rsv); 1444 } 1445 } 1446 out_err: 1447 up_write(&sb_dqopt(sb)->dqptr_sem); 1448 /* Drop unused references */ 1449 dqput_all(got); 1450 } 1451 1452 void dquot_initialize(struct inode *inode) 1453 { 1454 __dquot_initialize(inode, -1); 1455 } 1456 EXPORT_SYMBOL(dquot_initialize); 1457 1458 /* 1459 * Release all quotas referenced by inode 1460 */ 1461 static void __dquot_drop(struct inode *inode) 1462 { 1463 int cnt; 1464 struct dquot *put[MAXQUOTAS]; 1465 1466 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1467 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1468 put[cnt] = inode->i_dquot[cnt]; 1469 inode->i_dquot[cnt] = NULL; 1470 } 1471 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1472 dqput_all(put); 1473 } 1474 1475 void dquot_drop(struct inode *inode) 1476 { 1477 int cnt; 1478 1479 if (IS_NOQUOTA(inode)) 1480 return; 1481 1482 /* 1483 * Test before calling to rule out calls from proc and such 1484 * where we are not allowed to block. Note that this is 1485 * actually reliable test even without the lock - the caller 1486 * must assure that nobody can come after the DQUOT_DROP and 1487 * add quota pointers back anyway. 1488 */ 1489 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1490 if (inode->i_dquot[cnt]) 1491 break; 1492 } 1493 1494 if (cnt < MAXQUOTAS) 1495 __dquot_drop(inode); 1496 } 1497 EXPORT_SYMBOL(dquot_drop); 1498 1499 /* 1500 * inode_reserved_space is managed internally by quota, and protected by 1501 * i_lock similar to i_blocks+i_bytes. 1502 */ 1503 static qsize_t *inode_reserved_space(struct inode * inode) 1504 { 1505 /* Filesystem must explicitly define it's own method in order to use 1506 * quota reservation interface */ 1507 BUG_ON(!inode->i_sb->dq_op->get_reserved_space); 1508 return inode->i_sb->dq_op->get_reserved_space(inode); 1509 } 1510 1511 void inode_add_rsv_space(struct inode *inode, qsize_t number) 1512 { 1513 spin_lock(&inode->i_lock); 1514 *inode_reserved_space(inode) += number; 1515 spin_unlock(&inode->i_lock); 1516 } 1517 EXPORT_SYMBOL(inode_add_rsv_space); 1518 1519 void inode_claim_rsv_space(struct inode *inode, qsize_t number) 1520 { 1521 spin_lock(&inode->i_lock); 1522 *inode_reserved_space(inode) -= number; 1523 __inode_add_bytes(inode, number); 1524 spin_unlock(&inode->i_lock); 1525 } 1526 EXPORT_SYMBOL(inode_claim_rsv_space); 1527 1528 void inode_sub_rsv_space(struct inode *inode, qsize_t number) 1529 { 1530 spin_lock(&inode->i_lock); 1531 *inode_reserved_space(inode) -= number; 1532 spin_unlock(&inode->i_lock); 1533 } 1534 EXPORT_SYMBOL(inode_sub_rsv_space); 1535 1536 static qsize_t inode_get_rsv_space(struct inode *inode) 1537 { 1538 qsize_t ret; 1539 1540 if (!inode->i_sb->dq_op->get_reserved_space) 1541 return 0; 1542 spin_lock(&inode->i_lock); 1543 ret = *inode_reserved_space(inode); 1544 spin_unlock(&inode->i_lock); 1545 return ret; 1546 } 1547 1548 static void inode_incr_space(struct inode *inode, qsize_t number, 1549 int reserve) 1550 { 1551 if (reserve) 1552 inode_add_rsv_space(inode, number); 1553 else 1554 inode_add_bytes(inode, number); 1555 } 1556 1557 static void inode_decr_space(struct inode *inode, qsize_t number, int reserve) 1558 { 1559 if (reserve) 1560 inode_sub_rsv_space(inode, number); 1561 else 1562 inode_sub_bytes(inode, number); 1563 } 1564 1565 /* 1566 * This functions updates i_blocks+i_bytes fields and quota information 1567 * (together with appropriate checks). 1568 * 1569 * NOTE: We absolutely rely on the fact that caller dirties the inode 1570 * (usually helpers in quotaops.h care about this) and holds a handle for 1571 * the current transaction so that dquot write and inode write go into the 1572 * same transaction. 1573 */ 1574 1575 /* 1576 * This operation can block, but only after everything is updated 1577 */ 1578 int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags) 1579 { 1580 int cnt, ret = 0; 1581 struct dquot_warn warn[MAXQUOTAS]; 1582 struct dquot **dquots = inode->i_dquot; 1583 int reserve = flags & DQUOT_SPACE_RESERVE; 1584 1585 /* 1586 * First test before acquiring mutex - solves deadlocks when we 1587 * re-enter the quota code and are already holding the mutex 1588 */ 1589 if (!dquot_active(inode)) { 1590 inode_incr_space(inode, number, reserve); 1591 goto out; 1592 } 1593 1594 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1595 warn[cnt].w_type = QUOTA_NL_NOWARN; 1596 1597 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1598 spin_lock(&dq_data_lock); 1599 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1600 if (!dquots[cnt]) 1601 continue; 1602 ret = check_bdq(dquots[cnt], number, 1603 !(flags & DQUOT_SPACE_WARN), &warn[cnt]); 1604 if (ret && !(flags & DQUOT_SPACE_NOFAIL)) { 1605 spin_unlock(&dq_data_lock); 1606 goto out_flush_warn; 1607 } 1608 } 1609 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1610 if (!dquots[cnt]) 1611 continue; 1612 if (reserve) 1613 dquot_resv_space(dquots[cnt], number); 1614 else 1615 dquot_incr_space(dquots[cnt], number); 1616 } 1617 inode_incr_space(inode, number, reserve); 1618 spin_unlock(&dq_data_lock); 1619 1620 if (reserve) 1621 goto out_flush_warn; 1622 mark_all_dquot_dirty(dquots); 1623 out_flush_warn: 1624 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1625 flush_warnings(warn); 1626 out: 1627 return ret; 1628 } 1629 EXPORT_SYMBOL(__dquot_alloc_space); 1630 1631 /* 1632 * This operation can block, but only after everything is updated 1633 */ 1634 int dquot_alloc_inode(const struct inode *inode) 1635 { 1636 int cnt, ret = 0; 1637 struct dquot_warn warn[MAXQUOTAS]; 1638 struct dquot * const *dquots = inode->i_dquot; 1639 1640 /* First test before acquiring mutex - solves deadlocks when we 1641 * re-enter the quota code and are already holding the mutex */ 1642 if (!dquot_active(inode)) 1643 return 0; 1644 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1645 warn[cnt].w_type = QUOTA_NL_NOWARN; 1646 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1647 spin_lock(&dq_data_lock); 1648 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1649 if (!dquots[cnt]) 1650 continue; 1651 ret = check_idq(dquots[cnt], 1, &warn[cnt]); 1652 if (ret) 1653 goto warn_put_all; 1654 } 1655 1656 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1657 if (!dquots[cnt]) 1658 continue; 1659 dquot_incr_inodes(dquots[cnt], 1); 1660 } 1661 1662 warn_put_all: 1663 spin_unlock(&dq_data_lock); 1664 if (ret == 0) 1665 mark_all_dquot_dirty(dquots); 1666 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1667 flush_warnings(warn); 1668 return ret; 1669 } 1670 EXPORT_SYMBOL(dquot_alloc_inode); 1671 1672 /* 1673 * Convert in-memory reserved quotas to real consumed quotas 1674 */ 1675 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number) 1676 { 1677 int cnt; 1678 1679 if (!dquot_active(inode)) { 1680 inode_claim_rsv_space(inode, number); 1681 return 0; 1682 } 1683 1684 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1685 spin_lock(&dq_data_lock); 1686 /* Claim reserved quotas to allocated quotas */ 1687 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1688 if (inode->i_dquot[cnt]) 1689 dquot_claim_reserved_space(inode->i_dquot[cnt], 1690 number); 1691 } 1692 /* Update inode bytes */ 1693 inode_claim_rsv_space(inode, number); 1694 spin_unlock(&dq_data_lock); 1695 mark_all_dquot_dirty(inode->i_dquot); 1696 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1697 return 0; 1698 } 1699 EXPORT_SYMBOL(dquot_claim_space_nodirty); 1700 1701 /* 1702 * This operation can block, but only after everything is updated 1703 */ 1704 void __dquot_free_space(struct inode *inode, qsize_t number, int flags) 1705 { 1706 unsigned int cnt; 1707 struct dquot_warn warn[MAXQUOTAS]; 1708 struct dquot **dquots = inode->i_dquot; 1709 int reserve = flags & DQUOT_SPACE_RESERVE; 1710 1711 /* First test before acquiring mutex - solves deadlocks when we 1712 * re-enter the quota code and are already holding the mutex */ 1713 if (!dquot_active(inode)) { 1714 inode_decr_space(inode, number, reserve); 1715 return; 1716 } 1717 1718 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1719 spin_lock(&dq_data_lock); 1720 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1721 int wtype; 1722 1723 warn[cnt].w_type = QUOTA_NL_NOWARN; 1724 if (!dquots[cnt]) 1725 continue; 1726 wtype = info_bdq_free(dquots[cnt], number); 1727 if (wtype != QUOTA_NL_NOWARN) 1728 prepare_warning(&warn[cnt], dquots[cnt], wtype); 1729 if (reserve) 1730 dquot_free_reserved_space(dquots[cnt], number); 1731 else 1732 dquot_decr_space(dquots[cnt], number); 1733 } 1734 inode_decr_space(inode, number, reserve); 1735 spin_unlock(&dq_data_lock); 1736 1737 if (reserve) 1738 goto out_unlock; 1739 mark_all_dquot_dirty(dquots); 1740 out_unlock: 1741 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1742 flush_warnings(warn); 1743 } 1744 EXPORT_SYMBOL(__dquot_free_space); 1745 1746 /* 1747 * This operation can block, but only after everything is updated 1748 */ 1749 void dquot_free_inode(const struct inode *inode) 1750 { 1751 unsigned int cnt; 1752 struct dquot_warn warn[MAXQUOTAS]; 1753 struct dquot * const *dquots = inode->i_dquot; 1754 1755 /* First test before acquiring mutex - solves deadlocks when we 1756 * re-enter the quota code and are already holding the mutex */ 1757 if (!dquot_active(inode)) 1758 return; 1759 1760 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1761 spin_lock(&dq_data_lock); 1762 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1763 int wtype; 1764 1765 warn[cnt].w_type = QUOTA_NL_NOWARN; 1766 if (!dquots[cnt]) 1767 continue; 1768 wtype = info_idq_free(dquots[cnt], 1); 1769 if (wtype != QUOTA_NL_NOWARN) 1770 prepare_warning(&warn[cnt], dquots[cnt], wtype); 1771 dquot_decr_inodes(dquots[cnt], 1); 1772 } 1773 spin_unlock(&dq_data_lock); 1774 mark_all_dquot_dirty(dquots); 1775 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1776 flush_warnings(warn); 1777 } 1778 EXPORT_SYMBOL(dquot_free_inode); 1779 1780 /* 1781 * Transfer the number of inode and blocks from one diskquota to an other. 1782 * On success, dquot references in transfer_to are consumed and references 1783 * to original dquots that need to be released are placed there. On failure, 1784 * references are kept untouched. 1785 * 1786 * This operation can block, but only after everything is updated 1787 * A transaction must be started when entering this function. 1788 * 1789 */ 1790 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to) 1791 { 1792 qsize_t space, cur_space; 1793 qsize_t rsv_space = 0; 1794 struct dquot *transfer_from[MAXQUOTAS] = {}; 1795 int cnt, ret = 0; 1796 char is_valid[MAXQUOTAS] = {}; 1797 struct dquot_warn warn_to[MAXQUOTAS]; 1798 struct dquot_warn warn_from_inodes[MAXQUOTAS]; 1799 struct dquot_warn warn_from_space[MAXQUOTAS]; 1800 1801 /* First test before acquiring mutex - solves deadlocks when we 1802 * re-enter the quota code and are already holding the mutex */ 1803 if (IS_NOQUOTA(inode)) 1804 return 0; 1805 /* Initialize the arrays */ 1806 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1807 warn_to[cnt].w_type = QUOTA_NL_NOWARN; 1808 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN; 1809 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN; 1810 } 1811 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1812 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */ 1813 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1814 return 0; 1815 } 1816 spin_lock(&dq_data_lock); 1817 cur_space = inode_get_bytes(inode); 1818 rsv_space = inode_get_rsv_space(inode); 1819 space = cur_space + rsv_space; 1820 /* Build the transfer_from list and check the limits */ 1821 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1822 /* 1823 * Skip changes for same uid or gid or for turned off quota-type. 1824 */ 1825 if (!transfer_to[cnt]) 1826 continue; 1827 /* Avoid races with quotaoff() */ 1828 if (!sb_has_quota_active(inode->i_sb, cnt)) 1829 continue; 1830 is_valid[cnt] = 1; 1831 transfer_from[cnt] = inode->i_dquot[cnt]; 1832 ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]); 1833 if (ret) 1834 goto over_quota; 1835 ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]); 1836 if (ret) 1837 goto over_quota; 1838 } 1839 1840 /* 1841 * Finally perform the needed transfer from transfer_from to transfer_to 1842 */ 1843 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1844 if (!is_valid[cnt]) 1845 continue; 1846 /* Due to IO error we might not have transfer_from[] structure */ 1847 if (transfer_from[cnt]) { 1848 int wtype; 1849 wtype = info_idq_free(transfer_from[cnt], 1); 1850 if (wtype != QUOTA_NL_NOWARN) 1851 prepare_warning(&warn_from_inodes[cnt], 1852 transfer_from[cnt], wtype); 1853 wtype = info_bdq_free(transfer_from[cnt], space); 1854 if (wtype != QUOTA_NL_NOWARN) 1855 prepare_warning(&warn_from_space[cnt], 1856 transfer_from[cnt], wtype); 1857 dquot_decr_inodes(transfer_from[cnt], 1); 1858 dquot_decr_space(transfer_from[cnt], cur_space); 1859 dquot_free_reserved_space(transfer_from[cnt], 1860 rsv_space); 1861 } 1862 1863 dquot_incr_inodes(transfer_to[cnt], 1); 1864 dquot_incr_space(transfer_to[cnt], cur_space); 1865 dquot_resv_space(transfer_to[cnt], rsv_space); 1866 1867 inode->i_dquot[cnt] = transfer_to[cnt]; 1868 } 1869 spin_unlock(&dq_data_lock); 1870 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1871 1872 mark_all_dquot_dirty(transfer_from); 1873 mark_all_dquot_dirty(transfer_to); 1874 flush_warnings(warn_to); 1875 flush_warnings(warn_from_inodes); 1876 flush_warnings(warn_from_space); 1877 /* Pass back references to put */ 1878 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1879 if (is_valid[cnt]) 1880 transfer_to[cnt] = transfer_from[cnt]; 1881 return 0; 1882 over_quota: 1883 spin_unlock(&dq_data_lock); 1884 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1885 flush_warnings(warn_to); 1886 return ret; 1887 } 1888 EXPORT_SYMBOL(__dquot_transfer); 1889 1890 /* Wrapper for transferring ownership of an inode for uid/gid only 1891 * Called from FSXXX_setattr() 1892 */ 1893 int dquot_transfer(struct inode *inode, struct iattr *iattr) 1894 { 1895 struct dquot *transfer_to[MAXQUOTAS] = {}; 1896 struct super_block *sb = inode->i_sb; 1897 int ret; 1898 1899 if (!dquot_active(inode)) 1900 return 0; 1901 1902 if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) 1903 transfer_to[USRQUOTA] = dqget(sb, make_kqid_uid(iattr->ia_uid)); 1904 if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid)) 1905 transfer_to[GRPQUOTA] = dqget(sb, make_kqid_gid(iattr->ia_gid)); 1906 1907 ret = __dquot_transfer(inode, transfer_to); 1908 dqput_all(transfer_to); 1909 return ret; 1910 } 1911 EXPORT_SYMBOL(dquot_transfer); 1912 1913 /* 1914 * Write info of quota file to disk 1915 */ 1916 int dquot_commit_info(struct super_block *sb, int type) 1917 { 1918 int ret; 1919 struct quota_info *dqopt = sb_dqopt(sb); 1920 1921 mutex_lock(&dqopt->dqio_mutex); 1922 ret = dqopt->ops[type]->write_file_info(sb, type); 1923 mutex_unlock(&dqopt->dqio_mutex); 1924 return ret; 1925 } 1926 EXPORT_SYMBOL(dquot_commit_info); 1927 1928 /* 1929 * Definitions of diskquota operations. 1930 */ 1931 const struct dquot_operations dquot_operations = { 1932 .write_dquot = dquot_commit, 1933 .acquire_dquot = dquot_acquire, 1934 .release_dquot = dquot_release, 1935 .mark_dirty = dquot_mark_dquot_dirty, 1936 .write_info = dquot_commit_info, 1937 .alloc_dquot = dquot_alloc, 1938 .destroy_dquot = dquot_destroy, 1939 }; 1940 EXPORT_SYMBOL(dquot_operations); 1941 1942 /* 1943 * Generic helper for ->open on filesystems supporting disk quotas. 1944 */ 1945 int dquot_file_open(struct inode *inode, struct file *file) 1946 { 1947 int error; 1948 1949 error = generic_file_open(inode, file); 1950 if (!error && (file->f_mode & FMODE_WRITE)) 1951 dquot_initialize(inode); 1952 return error; 1953 } 1954 EXPORT_SYMBOL(dquot_file_open); 1955 1956 /* 1957 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) 1958 */ 1959 int dquot_disable(struct super_block *sb, int type, unsigned int flags) 1960 { 1961 int cnt, ret = 0; 1962 struct quota_info *dqopt = sb_dqopt(sb); 1963 struct inode *toputinode[MAXQUOTAS]; 1964 1965 /* Cannot turn off usage accounting without turning off limits, or 1966 * suspend quotas and simultaneously turn quotas off. */ 1967 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED)) 1968 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED | 1969 DQUOT_USAGE_ENABLED))) 1970 return -EINVAL; 1971 1972 /* We need to serialize quota_off() for device */ 1973 mutex_lock(&dqopt->dqonoff_mutex); 1974 1975 /* 1976 * Skip everything if there's nothing to do. We have to do this because 1977 * sometimes we are called when fill_super() failed and calling 1978 * sync_fs() in such cases does no good. 1979 */ 1980 if (!sb_any_quota_loaded(sb)) { 1981 mutex_unlock(&dqopt->dqonoff_mutex); 1982 return 0; 1983 } 1984 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1985 toputinode[cnt] = NULL; 1986 if (type != -1 && cnt != type) 1987 continue; 1988 if (!sb_has_quota_loaded(sb, cnt)) 1989 continue; 1990 1991 if (flags & DQUOT_SUSPENDED) { 1992 spin_lock(&dq_state_lock); 1993 dqopt->flags |= 1994 dquot_state_flag(DQUOT_SUSPENDED, cnt); 1995 spin_unlock(&dq_state_lock); 1996 } else { 1997 spin_lock(&dq_state_lock); 1998 dqopt->flags &= ~dquot_state_flag(flags, cnt); 1999 /* Turning off suspended quotas? */ 2000 if (!sb_has_quota_loaded(sb, cnt) && 2001 sb_has_quota_suspended(sb, cnt)) { 2002 dqopt->flags &= ~dquot_state_flag( 2003 DQUOT_SUSPENDED, cnt); 2004 spin_unlock(&dq_state_lock); 2005 iput(dqopt->files[cnt]); 2006 dqopt->files[cnt] = NULL; 2007 continue; 2008 } 2009 spin_unlock(&dq_state_lock); 2010 } 2011 2012 /* We still have to keep quota loaded? */ 2013 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED)) 2014 continue; 2015 2016 /* Note: these are blocking operations */ 2017 drop_dquot_ref(sb, cnt); 2018 invalidate_dquots(sb, cnt); 2019 /* 2020 * Now all dquots should be invalidated, all writes done so we 2021 * should be only users of the info. No locks needed. 2022 */ 2023 if (info_dirty(&dqopt->info[cnt])) 2024 sb->dq_op->write_info(sb, cnt); 2025 if (dqopt->ops[cnt]->free_file_info) 2026 dqopt->ops[cnt]->free_file_info(sb, cnt); 2027 put_quota_format(dqopt->info[cnt].dqi_format); 2028 2029 toputinode[cnt] = dqopt->files[cnt]; 2030 if (!sb_has_quota_loaded(sb, cnt)) 2031 dqopt->files[cnt] = NULL; 2032 dqopt->info[cnt].dqi_flags = 0; 2033 dqopt->info[cnt].dqi_igrace = 0; 2034 dqopt->info[cnt].dqi_bgrace = 0; 2035 dqopt->ops[cnt] = NULL; 2036 } 2037 mutex_unlock(&dqopt->dqonoff_mutex); 2038 2039 /* Skip syncing and setting flags if quota files are hidden */ 2040 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 2041 goto put_inodes; 2042 2043 /* Sync the superblock so that buffers with quota data are written to 2044 * disk (and so userspace sees correct data afterwards). */ 2045 if (sb->s_op->sync_fs) 2046 sb->s_op->sync_fs(sb, 1); 2047 sync_blockdev(sb->s_bdev); 2048 /* Now the quota files are just ordinary files and we can set the 2049 * inode flags back. Moreover we discard the pagecache so that 2050 * userspace sees the writes we did bypassing the pagecache. We 2051 * must also discard the blockdev buffers so that we see the 2052 * changes done by userspace on the next quotaon() */ 2053 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 2054 if (toputinode[cnt]) { 2055 mutex_lock(&dqopt->dqonoff_mutex); 2056 /* If quota was reenabled in the meantime, we have 2057 * nothing to do */ 2058 if (!sb_has_quota_loaded(sb, cnt)) { 2059 mutex_lock(&toputinode[cnt]->i_mutex); 2060 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE | 2061 S_NOATIME | S_NOQUOTA); 2062 truncate_inode_pages(&toputinode[cnt]->i_data, 2063 0); 2064 mutex_unlock(&toputinode[cnt]->i_mutex); 2065 mark_inode_dirty_sync(toputinode[cnt]); 2066 } 2067 mutex_unlock(&dqopt->dqonoff_mutex); 2068 } 2069 if (sb->s_bdev) 2070 invalidate_bdev(sb->s_bdev); 2071 put_inodes: 2072 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 2073 if (toputinode[cnt]) { 2074 /* On remount RO, we keep the inode pointer so that we 2075 * can reenable quota on the subsequent remount RW. We 2076 * have to check 'flags' variable and not use sb_has_ 2077 * function because another quotaon / quotaoff could 2078 * change global state before we got here. We refuse 2079 * to suspend quotas when there is pending delete on 2080 * the quota file... */ 2081 if (!(flags & DQUOT_SUSPENDED)) 2082 iput(toputinode[cnt]); 2083 else if (!toputinode[cnt]->i_nlink) 2084 ret = -EBUSY; 2085 } 2086 return ret; 2087 } 2088 EXPORT_SYMBOL(dquot_disable); 2089 2090 int dquot_quota_off(struct super_block *sb, int type) 2091 { 2092 return dquot_disable(sb, type, 2093 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2094 } 2095 EXPORT_SYMBOL(dquot_quota_off); 2096 2097 /* 2098 * Turn quotas on on a device 2099 */ 2100 2101 /* 2102 * Helper function to turn quotas on when we already have the inode of 2103 * quota file and no quota information is loaded. 2104 */ 2105 static int vfs_load_quota_inode(struct inode *inode, int type, int format_id, 2106 unsigned int flags) 2107 { 2108 struct quota_format_type *fmt = find_quota_format(format_id); 2109 struct super_block *sb = inode->i_sb; 2110 struct quota_info *dqopt = sb_dqopt(sb); 2111 int error; 2112 int oldflags = -1; 2113 2114 if (!fmt) 2115 return -ESRCH; 2116 if (!S_ISREG(inode->i_mode)) { 2117 error = -EACCES; 2118 goto out_fmt; 2119 } 2120 if (IS_RDONLY(inode)) { 2121 error = -EROFS; 2122 goto out_fmt; 2123 } 2124 if (!sb->s_op->quota_write || !sb->s_op->quota_read) { 2125 error = -EINVAL; 2126 goto out_fmt; 2127 } 2128 /* Usage always has to be set... */ 2129 if (!(flags & DQUOT_USAGE_ENABLED)) { 2130 error = -EINVAL; 2131 goto out_fmt; 2132 } 2133 2134 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2135 /* As we bypass the pagecache we must now flush all the 2136 * dirty data and invalidate caches so that kernel sees 2137 * changes from userspace. It is not enough to just flush 2138 * the quota file since if blocksize < pagesize, invalidation 2139 * of the cache could fail because of other unrelated dirty 2140 * data */ 2141 sync_filesystem(sb); 2142 invalidate_bdev(sb->s_bdev); 2143 } 2144 mutex_lock(&dqopt->dqonoff_mutex); 2145 if (sb_has_quota_loaded(sb, type)) { 2146 error = -EBUSY; 2147 goto out_lock; 2148 } 2149 2150 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2151 /* We don't want quota and atime on quota files (deadlocks 2152 * possible) Also nobody should write to the file - we use 2153 * special IO operations which ignore the immutable bit. */ 2154 mutex_lock(&inode->i_mutex); 2155 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE | 2156 S_NOQUOTA); 2157 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE; 2158 mutex_unlock(&inode->i_mutex); 2159 /* 2160 * When S_NOQUOTA is set, remove dquot references as no more 2161 * references can be added 2162 */ 2163 __dquot_drop(inode); 2164 } 2165 2166 error = -EIO; 2167 dqopt->files[type] = igrab(inode); 2168 if (!dqopt->files[type]) 2169 goto out_lock; 2170 error = -EINVAL; 2171 if (!fmt->qf_ops->check_quota_file(sb, type)) 2172 goto out_file_init; 2173 2174 dqopt->ops[type] = fmt->qf_ops; 2175 dqopt->info[type].dqi_format = fmt; 2176 dqopt->info[type].dqi_fmt_id = format_id; 2177 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2178 mutex_lock(&dqopt->dqio_mutex); 2179 error = dqopt->ops[type]->read_file_info(sb, type); 2180 if (error < 0) { 2181 mutex_unlock(&dqopt->dqio_mutex); 2182 goto out_file_init; 2183 } 2184 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 2185 dqopt->info[type].dqi_flags |= DQF_SYS_FILE; 2186 mutex_unlock(&dqopt->dqio_mutex); 2187 spin_lock(&dq_state_lock); 2188 dqopt->flags |= dquot_state_flag(flags, type); 2189 spin_unlock(&dq_state_lock); 2190 2191 add_dquot_ref(sb, type); 2192 mutex_unlock(&dqopt->dqonoff_mutex); 2193 2194 return 0; 2195 2196 out_file_init: 2197 dqopt->files[type] = NULL; 2198 iput(inode); 2199 out_lock: 2200 if (oldflags != -1) { 2201 mutex_lock(&inode->i_mutex); 2202 /* Set the flags back (in the case of accidental quotaon() 2203 * on a wrong file we don't want to mess up the flags) */ 2204 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE); 2205 inode->i_flags |= oldflags; 2206 mutex_unlock(&inode->i_mutex); 2207 } 2208 mutex_unlock(&dqopt->dqonoff_mutex); 2209 out_fmt: 2210 put_quota_format(fmt); 2211 2212 return error; 2213 } 2214 2215 /* Reenable quotas on remount RW */ 2216 int dquot_resume(struct super_block *sb, int type) 2217 { 2218 struct quota_info *dqopt = sb_dqopt(sb); 2219 struct inode *inode; 2220 int ret = 0, cnt; 2221 unsigned int flags; 2222 2223 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 2224 if (type != -1 && cnt != type) 2225 continue; 2226 2227 mutex_lock(&dqopt->dqonoff_mutex); 2228 if (!sb_has_quota_suspended(sb, cnt)) { 2229 mutex_unlock(&dqopt->dqonoff_mutex); 2230 continue; 2231 } 2232 inode = dqopt->files[cnt]; 2233 dqopt->files[cnt] = NULL; 2234 spin_lock(&dq_state_lock); 2235 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED | 2236 DQUOT_LIMITS_ENABLED, 2237 cnt); 2238 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt); 2239 spin_unlock(&dq_state_lock); 2240 mutex_unlock(&dqopt->dqonoff_mutex); 2241 2242 flags = dquot_generic_flag(flags, cnt); 2243 ret = vfs_load_quota_inode(inode, cnt, 2244 dqopt->info[cnt].dqi_fmt_id, flags); 2245 iput(inode); 2246 } 2247 2248 return ret; 2249 } 2250 EXPORT_SYMBOL(dquot_resume); 2251 2252 int dquot_quota_on(struct super_block *sb, int type, int format_id, 2253 struct path *path) 2254 { 2255 int error = security_quota_on(path->dentry); 2256 if (error) 2257 return error; 2258 /* Quota file not on the same filesystem? */ 2259 if (path->dentry->d_sb != sb) 2260 error = -EXDEV; 2261 else 2262 error = vfs_load_quota_inode(path->dentry->d_inode, type, 2263 format_id, DQUOT_USAGE_ENABLED | 2264 DQUOT_LIMITS_ENABLED); 2265 return error; 2266 } 2267 EXPORT_SYMBOL(dquot_quota_on); 2268 2269 /* 2270 * More powerful function for turning on quotas allowing setting 2271 * of individual quota flags 2272 */ 2273 int dquot_enable(struct inode *inode, int type, int format_id, 2274 unsigned int flags) 2275 { 2276 int ret = 0; 2277 struct super_block *sb = inode->i_sb; 2278 struct quota_info *dqopt = sb_dqopt(sb); 2279 2280 /* Just unsuspend quotas? */ 2281 BUG_ON(flags & DQUOT_SUSPENDED); 2282 2283 if (!flags) 2284 return 0; 2285 /* Just updating flags needed? */ 2286 if (sb_has_quota_loaded(sb, type)) { 2287 mutex_lock(&dqopt->dqonoff_mutex); 2288 /* Now do a reliable test... */ 2289 if (!sb_has_quota_loaded(sb, type)) { 2290 mutex_unlock(&dqopt->dqonoff_mutex); 2291 goto load_quota; 2292 } 2293 if (flags & DQUOT_USAGE_ENABLED && 2294 sb_has_quota_usage_enabled(sb, type)) { 2295 ret = -EBUSY; 2296 goto out_lock; 2297 } 2298 if (flags & DQUOT_LIMITS_ENABLED && 2299 sb_has_quota_limits_enabled(sb, type)) { 2300 ret = -EBUSY; 2301 goto out_lock; 2302 } 2303 spin_lock(&dq_state_lock); 2304 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type); 2305 spin_unlock(&dq_state_lock); 2306 out_lock: 2307 mutex_unlock(&dqopt->dqonoff_mutex); 2308 return ret; 2309 } 2310 2311 load_quota: 2312 return vfs_load_quota_inode(inode, type, format_id, flags); 2313 } 2314 EXPORT_SYMBOL(dquot_enable); 2315 2316 /* 2317 * This function is used when filesystem needs to initialize quotas 2318 * during mount time. 2319 */ 2320 int dquot_quota_on_mount(struct super_block *sb, char *qf_name, 2321 int format_id, int type) 2322 { 2323 struct dentry *dentry; 2324 int error; 2325 2326 mutex_lock(&sb->s_root->d_inode->i_mutex); 2327 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name)); 2328 mutex_unlock(&sb->s_root->d_inode->i_mutex); 2329 if (IS_ERR(dentry)) 2330 return PTR_ERR(dentry); 2331 2332 if (!dentry->d_inode) { 2333 error = -ENOENT; 2334 goto out; 2335 } 2336 2337 error = security_quota_on(dentry); 2338 if (!error) 2339 error = vfs_load_quota_inode(dentry->d_inode, type, format_id, 2340 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2341 2342 out: 2343 dput(dentry); 2344 return error; 2345 } 2346 EXPORT_SYMBOL(dquot_quota_on_mount); 2347 2348 static inline qsize_t qbtos(qsize_t blocks) 2349 { 2350 return blocks << QIF_DQBLKSIZE_BITS; 2351 } 2352 2353 static inline qsize_t stoqb(qsize_t space) 2354 { 2355 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS; 2356 } 2357 2358 /* Generic routine for getting common part of quota structure */ 2359 static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di) 2360 { 2361 struct mem_dqblk *dm = &dquot->dq_dqb; 2362 2363 memset(di, 0, sizeof(*di)); 2364 di->d_version = FS_DQUOT_VERSION; 2365 di->d_flags = dquot->dq_id.type == USRQUOTA ? 2366 FS_USER_QUOTA : FS_GROUP_QUOTA; 2367 di->d_id = from_kqid_munged(current_user_ns(), dquot->dq_id); 2368 2369 spin_lock(&dq_data_lock); 2370 di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit); 2371 di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit); 2372 di->d_ino_hardlimit = dm->dqb_ihardlimit; 2373 di->d_ino_softlimit = dm->dqb_isoftlimit; 2374 di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace; 2375 di->d_icount = dm->dqb_curinodes; 2376 di->d_btimer = dm->dqb_btime; 2377 di->d_itimer = dm->dqb_itime; 2378 spin_unlock(&dq_data_lock); 2379 } 2380 2381 int dquot_get_dqblk(struct super_block *sb, struct kqid qid, 2382 struct fs_disk_quota *di) 2383 { 2384 struct dquot *dquot; 2385 2386 dquot = dqget(sb, qid); 2387 if (!dquot) 2388 return -ESRCH; 2389 do_get_dqblk(dquot, di); 2390 dqput(dquot); 2391 2392 return 0; 2393 } 2394 EXPORT_SYMBOL(dquot_get_dqblk); 2395 2396 #define VFS_FS_DQ_MASK \ 2397 (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \ 2398 FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \ 2399 FS_DQ_BTIMER | FS_DQ_ITIMER) 2400 2401 /* Generic routine for setting common part of quota structure */ 2402 static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di) 2403 { 2404 struct mem_dqblk *dm = &dquot->dq_dqb; 2405 int check_blim = 0, check_ilim = 0; 2406 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 2407 2408 if (di->d_fieldmask & ~VFS_FS_DQ_MASK) 2409 return -EINVAL; 2410 2411 if (((di->d_fieldmask & FS_DQ_BSOFT) && 2412 (di->d_blk_softlimit > dqi->dqi_maxblimit)) || 2413 ((di->d_fieldmask & FS_DQ_BHARD) && 2414 (di->d_blk_hardlimit > dqi->dqi_maxblimit)) || 2415 ((di->d_fieldmask & FS_DQ_ISOFT) && 2416 (di->d_ino_softlimit > dqi->dqi_maxilimit)) || 2417 ((di->d_fieldmask & FS_DQ_IHARD) && 2418 (di->d_ino_hardlimit > dqi->dqi_maxilimit))) 2419 return -ERANGE; 2420 2421 spin_lock(&dq_data_lock); 2422 if (di->d_fieldmask & FS_DQ_BCOUNT) { 2423 dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace; 2424 check_blim = 1; 2425 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2426 } 2427 2428 if (di->d_fieldmask & FS_DQ_BSOFT) 2429 dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit); 2430 if (di->d_fieldmask & FS_DQ_BHARD) 2431 dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit); 2432 if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) { 2433 check_blim = 1; 2434 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 2435 } 2436 2437 if (di->d_fieldmask & FS_DQ_ICOUNT) { 2438 dm->dqb_curinodes = di->d_icount; 2439 check_ilim = 1; 2440 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 2441 } 2442 2443 if (di->d_fieldmask & FS_DQ_ISOFT) 2444 dm->dqb_isoftlimit = di->d_ino_softlimit; 2445 if (di->d_fieldmask & FS_DQ_IHARD) 2446 dm->dqb_ihardlimit = di->d_ino_hardlimit; 2447 if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) { 2448 check_ilim = 1; 2449 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 2450 } 2451 2452 if (di->d_fieldmask & FS_DQ_BTIMER) { 2453 dm->dqb_btime = di->d_btimer; 2454 check_blim = 1; 2455 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 2456 } 2457 2458 if (di->d_fieldmask & FS_DQ_ITIMER) { 2459 dm->dqb_itime = di->d_itimer; 2460 check_ilim = 1; 2461 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 2462 } 2463 2464 if (check_blim) { 2465 if (!dm->dqb_bsoftlimit || 2466 dm->dqb_curspace < dm->dqb_bsoftlimit) { 2467 dm->dqb_btime = 0; 2468 clear_bit(DQ_BLKS_B, &dquot->dq_flags); 2469 } else if (!(di->d_fieldmask & FS_DQ_BTIMER)) 2470 /* Set grace only if user hasn't provided his own... */ 2471 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace; 2472 } 2473 if (check_ilim) { 2474 if (!dm->dqb_isoftlimit || 2475 dm->dqb_curinodes < dm->dqb_isoftlimit) { 2476 dm->dqb_itime = 0; 2477 clear_bit(DQ_INODES_B, &dquot->dq_flags); 2478 } else if (!(di->d_fieldmask & FS_DQ_ITIMER)) 2479 /* Set grace only if user hasn't provided his own... */ 2480 dm->dqb_itime = get_seconds() + dqi->dqi_igrace; 2481 } 2482 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || 2483 dm->dqb_isoftlimit) 2484 clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2485 else 2486 set_bit(DQ_FAKE_B, &dquot->dq_flags); 2487 spin_unlock(&dq_data_lock); 2488 mark_dquot_dirty(dquot); 2489 2490 return 0; 2491 } 2492 2493 int dquot_set_dqblk(struct super_block *sb, struct kqid qid, 2494 struct fs_disk_quota *di) 2495 { 2496 struct dquot *dquot; 2497 int rc; 2498 2499 dquot = dqget(sb, qid); 2500 if (!dquot) { 2501 rc = -ESRCH; 2502 goto out; 2503 } 2504 rc = do_set_dqblk(dquot, di); 2505 dqput(dquot); 2506 out: 2507 return rc; 2508 } 2509 EXPORT_SYMBOL(dquot_set_dqblk); 2510 2511 /* Generic routine for getting common part of quota file information */ 2512 int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2513 { 2514 struct mem_dqinfo *mi; 2515 2516 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2517 if (!sb_has_quota_active(sb, type)) { 2518 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2519 return -ESRCH; 2520 } 2521 mi = sb_dqopt(sb)->info + type; 2522 spin_lock(&dq_data_lock); 2523 ii->dqi_bgrace = mi->dqi_bgrace; 2524 ii->dqi_igrace = mi->dqi_igrace; 2525 ii->dqi_flags = mi->dqi_flags & DQF_GETINFO_MASK; 2526 ii->dqi_valid = IIF_ALL; 2527 spin_unlock(&dq_data_lock); 2528 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2529 return 0; 2530 } 2531 EXPORT_SYMBOL(dquot_get_dqinfo); 2532 2533 /* Generic routine for setting common part of quota file information */ 2534 int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2535 { 2536 struct mem_dqinfo *mi; 2537 int err = 0; 2538 2539 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2540 if (!sb_has_quota_active(sb, type)) { 2541 err = -ESRCH; 2542 goto out; 2543 } 2544 mi = sb_dqopt(sb)->info + type; 2545 spin_lock(&dq_data_lock); 2546 if (ii->dqi_valid & IIF_BGRACE) 2547 mi->dqi_bgrace = ii->dqi_bgrace; 2548 if (ii->dqi_valid & IIF_IGRACE) 2549 mi->dqi_igrace = ii->dqi_igrace; 2550 if (ii->dqi_valid & IIF_FLAGS) 2551 mi->dqi_flags = (mi->dqi_flags & ~DQF_SETINFO_MASK) | 2552 (ii->dqi_flags & DQF_SETINFO_MASK); 2553 spin_unlock(&dq_data_lock); 2554 mark_info_dirty(sb, type); 2555 /* Force write to disk */ 2556 sb->dq_op->write_info(sb, type); 2557 out: 2558 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2559 return err; 2560 } 2561 EXPORT_SYMBOL(dquot_set_dqinfo); 2562 2563 const struct quotactl_ops dquot_quotactl_ops = { 2564 .quota_on = dquot_quota_on, 2565 .quota_off = dquot_quota_off, 2566 .quota_sync = dquot_quota_sync, 2567 .get_info = dquot_get_dqinfo, 2568 .set_info = dquot_set_dqinfo, 2569 .get_dqblk = dquot_get_dqblk, 2570 .set_dqblk = dquot_set_dqblk 2571 }; 2572 EXPORT_SYMBOL(dquot_quotactl_ops); 2573 2574 static int do_proc_dqstats(struct ctl_table *table, int write, 2575 void __user *buffer, size_t *lenp, loff_t *ppos) 2576 { 2577 unsigned int type = (int *)table->data - dqstats.stat; 2578 2579 /* Update global table */ 2580 dqstats.stat[type] = 2581 percpu_counter_sum_positive(&dqstats.counter[type]); 2582 return proc_dointvec(table, write, buffer, lenp, ppos); 2583 } 2584 2585 static ctl_table fs_dqstats_table[] = { 2586 { 2587 .procname = "lookups", 2588 .data = &dqstats.stat[DQST_LOOKUPS], 2589 .maxlen = sizeof(int), 2590 .mode = 0444, 2591 .proc_handler = do_proc_dqstats, 2592 }, 2593 { 2594 .procname = "drops", 2595 .data = &dqstats.stat[DQST_DROPS], 2596 .maxlen = sizeof(int), 2597 .mode = 0444, 2598 .proc_handler = do_proc_dqstats, 2599 }, 2600 { 2601 .procname = "reads", 2602 .data = &dqstats.stat[DQST_READS], 2603 .maxlen = sizeof(int), 2604 .mode = 0444, 2605 .proc_handler = do_proc_dqstats, 2606 }, 2607 { 2608 .procname = "writes", 2609 .data = &dqstats.stat[DQST_WRITES], 2610 .maxlen = sizeof(int), 2611 .mode = 0444, 2612 .proc_handler = do_proc_dqstats, 2613 }, 2614 { 2615 .procname = "cache_hits", 2616 .data = &dqstats.stat[DQST_CACHE_HITS], 2617 .maxlen = sizeof(int), 2618 .mode = 0444, 2619 .proc_handler = do_proc_dqstats, 2620 }, 2621 { 2622 .procname = "allocated_dquots", 2623 .data = &dqstats.stat[DQST_ALLOC_DQUOTS], 2624 .maxlen = sizeof(int), 2625 .mode = 0444, 2626 .proc_handler = do_proc_dqstats, 2627 }, 2628 { 2629 .procname = "free_dquots", 2630 .data = &dqstats.stat[DQST_FREE_DQUOTS], 2631 .maxlen = sizeof(int), 2632 .mode = 0444, 2633 .proc_handler = do_proc_dqstats, 2634 }, 2635 { 2636 .procname = "syncs", 2637 .data = &dqstats.stat[DQST_SYNCS], 2638 .maxlen = sizeof(int), 2639 .mode = 0444, 2640 .proc_handler = do_proc_dqstats, 2641 }, 2642 #ifdef CONFIG_PRINT_QUOTA_WARNING 2643 { 2644 .procname = "warnings", 2645 .data = &flag_print_warnings, 2646 .maxlen = sizeof(int), 2647 .mode = 0644, 2648 .proc_handler = proc_dointvec, 2649 }, 2650 #endif 2651 { }, 2652 }; 2653 2654 static ctl_table fs_table[] = { 2655 { 2656 .procname = "quota", 2657 .mode = 0555, 2658 .child = fs_dqstats_table, 2659 }, 2660 { }, 2661 }; 2662 2663 static ctl_table sys_table[] = { 2664 { 2665 .procname = "fs", 2666 .mode = 0555, 2667 .child = fs_table, 2668 }, 2669 { }, 2670 }; 2671 2672 static int __init dquot_init(void) 2673 { 2674 int i, ret; 2675 unsigned long nr_hash, order; 2676 2677 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__); 2678 2679 register_sysctl_table(sys_table); 2680 2681 dquot_cachep = kmem_cache_create("dquot", 2682 sizeof(struct dquot), sizeof(unsigned long) * 4, 2683 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 2684 SLAB_MEM_SPREAD|SLAB_PANIC), 2685 NULL); 2686 2687 order = 0; 2688 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order); 2689 if (!dquot_hash) 2690 panic("Cannot create dquot hash table"); 2691 2692 for (i = 0; i < _DQST_DQSTAT_LAST; i++) { 2693 ret = percpu_counter_init(&dqstats.counter[i], 0); 2694 if (ret) 2695 panic("Cannot create dquot stat counters"); 2696 } 2697 2698 /* Find power-of-two hlist_heads which can fit into allocation */ 2699 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head); 2700 dq_hash_bits = 0; 2701 do { 2702 dq_hash_bits++; 2703 } while (nr_hash >> dq_hash_bits); 2704 dq_hash_bits--; 2705 2706 nr_hash = 1UL << dq_hash_bits; 2707 dq_hash_mask = nr_hash - 1; 2708 for (i = 0; i < nr_hash; i++) 2709 INIT_HLIST_HEAD(dquot_hash + i); 2710 2711 printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n", 2712 nr_hash, order, (PAGE_SIZE << order)); 2713 2714 register_shrinker(&dqcache_shrinker); 2715 2716 return 0; 2717 } 2718 module_init(dquot_init); 2719