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 } 1164 return 0; 1165 } 1166 1167 /* Print warning to user which exceeded quota */ 1168 static void print_warning(struct dquot_warn *warn) 1169 { 1170 char *msg = NULL; 1171 struct tty_struct *tty; 1172 int warntype = warn->w_type; 1173 1174 if (warntype == QUOTA_NL_IHARDBELOW || 1175 warntype == QUOTA_NL_ISOFTBELOW || 1176 warntype == QUOTA_NL_BHARDBELOW || 1177 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn)) 1178 return; 1179 1180 tty = get_current_tty(); 1181 if (!tty) 1182 return; 1183 tty_write_message(tty, warn->w_sb->s_id); 1184 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN) 1185 tty_write_message(tty, ": warning, "); 1186 else 1187 tty_write_message(tty, ": write failed, "); 1188 tty_write_message(tty, quotatypes[warn->w_dq_id.type]); 1189 switch (warntype) { 1190 case QUOTA_NL_IHARDWARN: 1191 msg = " file limit reached.\r\n"; 1192 break; 1193 case QUOTA_NL_ISOFTLONGWARN: 1194 msg = " file quota exceeded too long.\r\n"; 1195 break; 1196 case QUOTA_NL_ISOFTWARN: 1197 msg = " file quota exceeded.\r\n"; 1198 break; 1199 case QUOTA_NL_BHARDWARN: 1200 msg = " block limit reached.\r\n"; 1201 break; 1202 case QUOTA_NL_BSOFTLONGWARN: 1203 msg = " block quota exceeded too long.\r\n"; 1204 break; 1205 case QUOTA_NL_BSOFTWARN: 1206 msg = " block quota exceeded.\r\n"; 1207 break; 1208 } 1209 tty_write_message(tty, msg); 1210 tty_kref_put(tty); 1211 } 1212 #endif 1213 1214 static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot, 1215 int warntype) 1216 { 1217 if (warning_issued(dquot, warntype)) 1218 return; 1219 warn->w_type = warntype; 1220 warn->w_sb = dquot->dq_sb; 1221 warn->w_dq_id = dquot->dq_id; 1222 } 1223 1224 /* 1225 * Write warnings to the console and send warning messages over netlink. 1226 * 1227 * Note that this function can call into tty and networking code. 1228 */ 1229 static void flush_warnings(struct dquot_warn *warn) 1230 { 1231 int i; 1232 1233 for (i = 0; i < MAXQUOTAS; i++) { 1234 if (warn[i].w_type == QUOTA_NL_NOWARN) 1235 continue; 1236 #ifdef CONFIG_PRINT_QUOTA_WARNING 1237 print_warning(&warn[i]); 1238 #endif 1239 quota_send_warning(warn[i].w_dq_id, 1240 warn[i].w_sb->s_dev, warn[i].w_type); 1241 } 1242 } 1243 1244 static int ignore_hardlimit(struct dquot *dquot) 1245 { 1246 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 1247 1248 return capable(CAP_SYS_RESOURCE) && 1249 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD || 1250 !(info->dqi_flags & V1_DQF_RSQUASH)); 1251 } 1252 1253 /* needs dq_data_lock */ 1254 static int check_idq(struct dquot *dquot, qsize_t inodes, 1255 struct dquot_warn *warn) 1256 { 1257 qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes; 1258 1259 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) || 1260 test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1261 return 0; 1262 1263 if (dquot->dq_dqb.dqb_ihardlimit && 1264 newinodes > dquot->dq_dqb.dqb_ihardlimit && 1265 !ignore_hardlimit(dquot)) { 1266 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN); 1267 return -EDQUOT; 1268 } 1269 1270 if (dquot->dq_dqb.dqb_isoftlimit && 1271 newinodes > dquot->dq_dqb.dqb_isoftlimit && 1272 dquot->dq_dqb.dqb_itime && 1273 get_seconds() >= dquot->dq_dqb.dqb_itime && 1274 !ignore_hardlimit(dquot)) { 1275 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN); 1276 return -EDQUOT; 1277 } 1278 1279 if (dquot->dq_dqb.dqb_isoftlimit && 1280 newinodes > dquot->dq_dqb.dqb_isoftlimit && 1281 dquot->dq_dqb.dqb_itime == 0) { 1282 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN); 1283 dquot->dq_dqb.dqb_itime = get_seconds() + 1284 sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace; 1285 } 1286 1287 return 0; 1288 } 1289 1290 /* needs dq_data_lock */ 1291 static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, 1292 struct dquot_warn *warn) 1293 { 1294 qsize_t tspace; 1295 struct super_block *sb = dquot->dq_sb; 1296 1297 if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) || 1298 test_bit(DQ_FAKE_B, &dquot->dq_flags)) 1299 return 0; 1300 1301 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace 1302 + space; 1303 1304 if (dquot->dq_dqb.dqb_bhardlimit && 1305 tspace > dquot->dq_dqb.dqb_bhardlimit && 1306 !ignore_hardlimit(dquot)) { 1307 if (!prealloc) 1308 prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN); 1309 return -EDQUOT; 1310 } 1311 1312 if (dquot->dq_dqb.dqb_bsoftlimit && 1313 tspace > dquot->dq_dqb.dqb_bsoftlimit && 1314 dquot->dq_dqb.dqb_btime && 1315 get_seconds() >= dquot->dq_dqb.dqb_btime && 1316 !ignore_hardlimit(dquot)) { 1317 if (!prealloc) 1318 prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN); 1319 return -EDQUOT; 1320 } 1321 1322 if (dquot->dq_dqb.dqb_bsoftlimit && 1323 tspace > dquot->dq_dqb.dqb_bsoftlimit && 1324 dquot->dq_dqb.dqb_btime == 0) { 1325 if (!prealloc) { 1326 prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN); 1327 dquot->dq_dqb.dqb_btime = get_seconds() + 1328 sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace; 1329 } 1330 else 1331 /* 1332 * We don't allow preallocation to exceed softlimit so exceeding will 1333 * be always printed 1334 */ 1335 return -EDQUOT; 1336 } 1337 1338 return 0; 1339 } 1340 1341 static int info_idq_free(struct dquot *dquot, qsize_t inodes) 1342 { 1343 qsize_t newinodes; 1344 1345 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1346 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit || 1347 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type)) 1348 return QUOTA_NL_NOWARN; 1349 1350 newinodes = dquot->dq_dqb.dqb_curinodes - inodes; 1351 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit) 1352 return QUOTA_NL_ISOFTBELOW; 1353 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit && 1354 newinodes < dquot->dq_dqb.dqb_ihardlimit) 1355 return QUOTA_NL_IHARDBELOW; 1356 return QUOTA_NL_NOWARN; 1357 } 1358 1359 static int info_bdq_free(struct dquot *dquot, qsize_t space) 1360 { 1361 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) || 1362 dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit) 1363 return QUOTA_NL_NOWARN; 1364 1365 if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit) 1366 return QUOTA_NL_BSOFTBELOW; 1367 if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit && 1368 dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit) 1369 return QUOTA_NL_BHARDBELOW; 1370 return QUOTA_NL_NOWARN; 1371 } 1372 1373 static int dquot_active(const struct inode *inode) 1374 { 1375 struct super_block *sb = inode->i_sb; 1376 1377 if (IS_NOQUOTA(inode)) 1378 return 0; 1379 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb); 1380 } 1381 1382 /* 1383 * Initialize quota pointers in inode 1384 * 1385 * We do things in a bit complicated way but by that we avoid calling 1386 * dqget() and thus filesystem callbacks under dqptr_sem. 1387 * 1388 * It is better to call this function outside of any transaction as it 1389 * might need a lot of space in journal for dquot structure allocation. 1390 */ 1391 static void __dquot_initialize(struct inode *inode, int type) 1392 { 1393 int cnt; 1394 struct dquot *got[MAXQUOTAS]; 1395 struct super_block *sb = inode->i_sb; 1396 qsize_t rsv; 1397 1398 /* First test before acquiring mutex - solves deadlocks when we 1399 * re-enter the quota code and are already holding the mutex */ 1400 if (!dquot_active(inode)) 1401 return; 1402 1403 /* First get references to structures we might need. */ 1404 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1405 struct kqid qid; 1406 got[cnt] = NULL; 1407 if (type != -1 && cnt != type) 1408 continue; 1409 switch (cnt) { 1410 case USRQUOTA: 1411 qid = make_kqid_uid(inode->i_uid); 1412 break; 1413 case GRPQUOTA: 1414 qid = make_kqid_gid(inode->i_gid); 1415 break; 1416 } 1417 got[cnt] = dqget(sb, qid); 1418 } 1419 1420 down_write(&sb_dqopt(sb)->dqptr_sem); 1421 if (IS_NOQUOTA(inode)) 1422 goto out_err; 1423 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1424 if (type != -1 && cnt != type) 1425 continue; 1426 /* Avoid races with quotaoff() */ 1427 if (!sb_has_quota_active(sb, cnt)) 1428 continue; 1429 /* We could race with quotaon or dqget() could have failed */ 1430 if (!got[cnt]) 1431 continue; 1432 if (!inode->i_dquot[cnt]) { 1433 inode->i_dquot[cnt] = got[cnt]; 1434 got[cnt] = NULL; 1435 /* 1436 * Make quota reservation system happy if someone 1437 * did a write before quota was turned on 1438 */ 1439 rsv = inode_get_rsv_space(inode); 1440 if (unlikely(rsv)) 1441 dquot_resv_space(inode->i_dquot[cnt], rsv); 1442 } 1443 } 1444 out_err: 1445 up_write(&sb_dqopt(sb)->dqptr_sem); 1446 /* Drop unused references */ 1447 dqput_all(got); 1448 } 1449 1450 void dquot_initialize(struct inode *inode) 1451 { 1452 __dquot_initialize(inode, -1); 1453 } 1454 EXPORT_SYMBOL(dquot_initialize); 1455 1456 /* 1457 * Release all quotas referenced by inode 1458 */ 1459 static void __dquot_drop(struct inode *inode) 1460 { 1461 int cnt; 1462 struct dquot *put[MAXQUOTAS]; 1463 1464 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1465 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1466 put[cnt] = inode->i_dquot[cnt]; 1467 inode->i_dquot[cnt] = NULL; 1468 } 1469 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1470 dqput_all(put); 1471 } 1472 1473 void dquot_drop(struct inode *inode) 1474 { 1475 int cnt; 1476 1477 if (IS_NOQUOTA(inode)) 1478 return; 1479 1480 /* 1481 * Test before calling to rule out calls from proc and such 1482 * where we are not allowed to block. Note that this is 1483 * actually reliable test even without the lock - the caller 1484 * must assure that nobody can come after the DQUOT_DROP and 1485 * add quota pointers back anyway. 1486 */ 1487 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1488 if (inode->i_dquot[cnt]) 1489 break; 1490 } 1491 1492 if (cnt < MAXQUOTAS) 1493 __dquot_drop(inode); 1494 } 1495 EXPORT_SYMBOL(dquot_drop); 1496 1497 /* 1498 * inode_reserved_space is managed internally by quota, and protected by 1499 * i_lock similar to i_blocks+i_bytes. 1500 */ 1501 static qsize_t *inode_reserved_space(struct inode * inode) 1502 { 1503 /* Filesystem must explicitly define it's own method in order to use 1504 * quota reservation interface */ 1505 BUG_ON(!inode->i_sb->dq_op->get_reserved_space); 1506 return inode->i_sb->dq_op->get_reserved_space(inode); 1507 } 1508 1509 void inode_add_rsv_space(struct inode *inode, qsize_t number) 1510 { 1511 spin_lock(&inode->i_lock); 1512 *inode_reserved_space(inode) += number; 1513 spin_unlock(&inode->i_lock); 1514 } 1515 EXPORT_SYMBOL(inode_add_rsv_space); 1516 1517 void inode_claim_rsv_space(struct inode *inode, qsize_t number) 1518 { 1519 spin_lock(&inode->i_lock); 1520 *inode_reserved_space(inode) -= number; 1521 __inode_add_bytes(inode, number); 1522 spin_unlock(&inode->i_lock); 1523 } 1524 EXPORT_SYMBOL(inode_claim_rsv_space); 1525 1526 void inode_sub_rsv_space(struct inode *inode, qsize_t number) 1527 { 1528 spin_lock(&inode->i_lock); 1529 *inode_reserved_space(inode) -= number; 1530 spin_unlock(&inode->i_lock); 1531 } 1532 EXPORT_SYMBOL(inode_sub_rsv_space); 1533 1534 static qsize_t inode_get_rsv_space(struct inode *inode) 1535 { 1536 qsize_t ret; 1537 1538 if (!inode->i_sb->dq_op->get_reserved_space) 1539 return 0; 1540 spin_lock(&inode->i_lock); 1541 ret = *inode_reserved_space(inode); 1542 spin_unlock(&inode->i_lock); 1543 return ret; 1544 } 1545 1546 static void inode_incr_space(struct inode *inode, qsize_t number, 1547 int reserve) 1548 { 1549 if (reserve) 1550 inode_add_rsv_space(inode, number); 1551 else 1552 inode_add_bytes(inode, number); 1553 } 1554 1555 static void inode_decr_space(struct inode *inode, qsize_t number, int reserve) 1556 { 1557 if (reserve) 1558 inode_sub_rsv_space(inode, number); 1559 else 1560 inode_sub_bytes(inode, number); 1561 } 1562 1563 /* 1564 * This functions updates i_blocks+i_bytes fields and quota information 1565 * (together with appropriate checks). 1566 * 1567 * NOTE: We absolutely rely on the fact that caller dirties the inode 1568 * (usually helpers in quotaops.h care about this) and holds a handle for 1569 * the current transaction so that dquot write and inode write go into the 1570 * same transaction. 1571 */ 1572 1573 /* 1574 * This operation can block, but only after everything is updated 1575 */ 1576 int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags) 1577 { 1578 int cnt, ret = 0; 1579 struct dquot_warn warn[MAXQUOTAS]; 1580 struct dquot **dquots = inode->i_dquot; 1581 int reserve = flags & DQUOT_SPACE_RESERVE; 1582 1583 /* 1584 * First test before acquiring mutex - solves deadlocks when we 1585 * re-enter the quota code and are already holding the mutex 1586 */ 1587 if (!dquot_active(inode)) { 1588 inode_incr_space(inode, number, reserve); 1589 goto out; 1590 } 1591 1592 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1593 warn[cnt].w_type = QUOTA_NL_NOWARN; 1594 1595 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1596 spin_lock(&dq_data_lock); 1597 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1598 if (!dquots[cnt]) 1599 continue; 1600 ret = check_bdq(dquots[cnt], number, 1601 !(flags & DQUOT_SPACE_WARN), &warn[cnt]); 1602 if (ret && !(flags & DQUOT_SPACE_NOFAIL)) { 1603 spin_unlock(&dq_data_lock); 1604 goto out_flush_warn; 1605 } 1606 } 1607 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1608 if (!dquots[cnt]) 1609 continue; 1610 if (reserve) 1611 dquot_resv_space(dquots[cnt], number); 1612 else 1613 dquot_incr_space(dquots[cnt], number); 1614 } 1615 inode_incr_space(inode, number, reserve); 1616 spin_unlock(&dq_data_lock); 1617 1618 if (reserve) 1619 goto out_flush_warn; 1620 mark_all_dquot_dirty(dquots); 1621 out_flush_warn: 1622 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1623 flush_warnings(warn); 1624 out: 1625 return ret; 1626 } 1627 EXPORT_SYMBOL(__dquot_alloc_space); 1628 1629 /* 1630 * This operation can block, but only after everything is updated 1631 */ 1632 int dquot_alloc_inode(const struct inode *inode) 1633 { 1634 int cnt, ret = 0; 1635 struct dquot_warn warn[MAXQUOTAS]; 1636 struct dquot * const *dquots = inode->i_dquot; 1637 1638 /* First test before acquiring mutex - solves deadlocks when we 1639 * re-enter the quota code and are already holding the mutex */ 1640 if (!dquot_active(inode)) 1641 return 0; 1642 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1643 warn[cnt].w_type = QUOTA_NL_NOWARN; 1644 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1645 spin_lock(&dq_data_lock); 1646 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1647 if (!dquots[cnt]) 1648 continue; 1649 ret = check_idq(dquots[cnt], 1, &warn[cnt]); 1650 if (ret) 1651 goto warn_put_all; 1652 } 1653 1654 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1655 if (!dquots[cnt]) 1656 continue; 1657 dquot_incr_inodes(dquots[cnt], 1); 1658 } 1659 1660 warn_put_all: 1661 spin_unlock(&dq_data_lock); 1662 if (ret == 0) 1663 mark_all_dquot_dirty(dquots); 1664 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1665 flush_warnings(warn); 1666 return ret; 1667 } 1668 EXPORT_SYMBOL(dquot_alloc_inode); 1669 1670 /* 1671 * Convert in-memory reserved quotas to real consumed quotas 1672 */ 1673 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number) 1674 { 1675 int cnt; 1676 1677 if (!dquot_active(inode)) { 1678 inode_claim_rsv_space(inode, number); 1679 return 0; 1680 } 1681 1682 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1683 spin_lock(&dq_data_lock); 1684 /* Claim reserved quotas to allocated quotas */ 1685 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1686 if (inode->i_dquot[cnt]) 1687 dquot_claim_reserved_space(inode->i_dquot[cnt], 1688 number); 1689 } 1690 /* Update inode bytes */ 1691 inode_claim_rsv_space(inode, number); 1692 spin_unlock(&dq_data_lock); 1693 mark_all_dquot_dirty(inode->i_dquot); 1694 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1695 return 0; 1696 } 1697 EXPORT_SYMBOL(dquot_claim_space_nodirty); 1698 1699 /* 1700 * This operation can block, but only after everything is updated 1701 */ 1702 void __dquot_free_space(struct inode *inode, qsize_t number, int flags) 1703 { 1704 unsigned int cnt; 1705 struct dquot_warn warn[MAXQUOTAS]; 1706 struct dquot **dquots = inode->i_dquot; 1707 int reserve = flags & DQUOT_SPACE_RESERVE; 1708 1709 /* First test before acquiring mutex - solves deadlocks when we 1710 * re-enter the quota code and are already holding the mutex */ 1711 if (!dquot_active(inode)) { 1712 inode_decr_space(inode, number, reserve); 1713 return; 1714 } 1715 1716 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1717 spin_lock(&dq_data_lock); 1718 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1719 int wtype; 1720 1721 warn[cnt].w_type = QUOTA_NL_NOWARN; 1722 if (!dquots[cnt]) 1723 continue; 1724 wtype = info_bdq_free(dquots[cnt], number); 1725 if (wtype != QUOTA_NL_NOWARN) 1726 prepare_warning(&warn[cnt], dquots[cnt], wtype); 1727 if (reserve) 1728 dquot_free_reserved_space(dquots[cnt], number); 1729 else 1730 dquot_decr_space(dquots[cnt], number); 1731 } 1732 inode_decr_space(inode, number, reserve); 1733 spin_unlock(&dq_data_lock); 1734 1735 if (reserve) 1736 goto out_unlock; 1737 mark_all_dquot_dirty(dquots); 1738 out_unlock: 1739 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1740 flush_warnings(warn); 1741 } 1742 EXPORT_SYMBOL(__dquot_free_space); 1743 1744 /* 1745 * This operation can block, but only after everything is updated 1746 */ 1747 void dquot_free_inode(const struct inode *inode) 1748 { 1749 unsigned int cnt; 1750 struct dquot_warn warn[MAXQUOTAS]; 1751 struct dquot * const *dquots = inode->i_dquot; 1752 1753 /* First test before acquiring mutex - solves deadlocks when we 1754 * re-enter the quota code and are already holding the mutex */ 1755 if (!dquot_active(inode)) 1756 return; 1757 1758 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1759 spin_lock(&dq_data_lock); 1760 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1761 int wtype; 1762 1763 warn[cnt].w_type = QUOTA_NL_NOWARN; 1764 if (!dquots[cnt]) 1765 continue; 1766 wtype = info_idq_free(dquots[cnt], 1); 1767 if (wtype != QUOTA_NL_NOWARN) 1768 prepare_warning(&warn[cnt], dquots[cnt], wtype); 1769 dquot_decr_inodes(dquots[cnt], 1); 1770 } 1771 spin_unlock(&dq_data_lock); 1772 mark_all_dquot_dirty(dquots); 1773 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem); 1774 flush_warnings(warn); 1775 } 1776 EXPORT_SYMBOL(dquot_free_inode); 1777 1778 /* 1779 * Transfer the number of inode and blocks from one diskquota to an other. 1780 * On success, dquot references in transfer_to are consumed and references 1781 * to original dquots that need to be released are placed there. On failure, 1782 * references are kept untouched. 1783 * 1784 * This operation can block, but only after everything is updated 1785 * A transaction must be started when entering this function. 1786 * 1787 */ 1788 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to) 1789 { 1790 qsize_t space, cur_space; 1791 qsize_t rsv_space = 0; 1792 struct dquot *transfer_from[MAXQUOTAS] = {}; 1793 int cnt, ret = 0; 1794 char is_valid[MAXQUOTAS] = {}; 1795 struct dquot_warn warn_to[MAXQUOTAS]; 1796 struct dquot_warn warn_from_inodes[MAXQUOTAS]; 1797 struct dquot_warn warn_from_space[MAXQUOTAS]; 1798 1799 /* First test before acquiring mutex - solves deadlocks when we 1800 * re-enter the quota code and are already holding the mutex */ 1801 if (IS_NOQUOTA(inode)) 1802 return 0; 1803 /* Initialize the arrays */ 1804 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1805 warn_to[cnt].w_type = QUOTA_NL_NOWARN; 1806 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN; 1807 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN; 1808 } 1809 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1810 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */ 1811 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1812 return 0; 1813 } 1814 spin_lock(&dq_data_lock); 1815 cur_space = inode_get_bytes(inode); 1816 rsv_space = inode_get_rsv_space(inode); 1817 space = cur_space + rsv_space; 1818 /* Build the transfer_from list and check the limits */ 1819 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1820 /* 1821 * Skip changes for same uid or gid or for turned off quota-type. 1822 */ 1823 if (!transfer_to[cnt]) 1824 continue; 1825 /* Avoid races with quotaoff() */ 1826 if (!sb_has_quota_active(inode->i_sb, cnt)) 1827 continue; 1828 is_valid[cnt] = 1; 1829 transfer_from[cnt] = inode->i_dquot[cnt]; 1830 ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]); 1831 if (ret) 1832 goto over_quota; 1833 ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]); 1834 if (ret) 1835 goto over_quota; 1836 } 1837 1838 /* 1839 * Finally perform the needed transfer from transfer_from to transfer_to 1840 */ 1841 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1842 if (!is_valid[cnt]) 1843 continue; 1844 /* Due to IO error we might not have transfer_from[] structure */ 1845 if (transfer_from[cnt]) { 1846 int wtype; 1847 wtype = info_idq_free(transfer_from[cnt], 1); 1848 if (wtype != QUOTA_NL_NOWARN) 1849 prepare_warning(&warn_from_inodes[cnt], 1850 transfer_from[cnt], wtype); 1851 wtype = info_bdq_free(transfer_from[cnt], space); 1852 if (wtype != QUOTA_NL_NOWARN) 1853 prepare_warning(&warn_from_space[cnt], 1854 transfer_from[cnt], wtype); 1855 dquot_decr_inodes(transfer_from[cnt], 1); 1856 dquot_decr_space(transfer_from[cnt], cur_space); 1857 dquot_free_reserved_space(transfer_from[cnt], 1858 rsv_space); 1859 } 1860 1861 dquot_incr_inodes(transfer_to[cnt], 1); 1862 dquot_incr_space(transfer_to[cnt], cur_space); 1863 dquot_resv_space(transfer_to[cnt], rsv_space); 1864 1865 inode->i_dquot[cnt] = transfer_to[cnt]; 1866 } 1867 spin_unlock(&dq_data_lock); 1868 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1869 1870 mark_all_dquot_dirty(transfer_from); 1871 mark_all_dquot_dirty(transfer_to); 1872 flush_warnings(warn_to); 1873 flush_warnings(warn_from_inodes); 1874 flush_warnings(warn_from_space); 1875 /* Pass back references to put */ 1876 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 1877 if (is_valid[cnt]) 1878 transfer_to[cnt] = transfer_from[cnt]; 1879 return 0; 1880 over_quota: 1881 spin_unlock(&dq_data_lock); 1882 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem); 1883 flush_warnings(warn_to); 1884 return ret; 1885 } 1886 EXPORT_SYMBOL(__dquot_transfer); 1887 1888 /* Wrapper for transferring ownership of an inode for uid/gid only 1889 * Called from FSXXX_setattr() 1890 */ 1891 int dquot_transfer(struct inode *inode, struct iattr *iattr) 1892 { 1893 struct dquot *transfer_to[MAXQUOTAS] = {}; 1894 struct super_block *sb = inode->i_sb; 1895 int ret; 1896 1897 if (!dquot_active(inode)) 1898 return 0; 1899 1900 if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) 1901 transfer_to[USRQUOTA] = dqget(sb, make_kqid_uid(iattr->ia_uid)); 1902 if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid)) 1903 transfer_to[GRPQUOTA] = dqget(sb, make_kqid_gid(iattr->ia_gid)); 1904 1905 ret = __dquot_transfer(inode, transfer_to); 1906 dqput_all(transfer_to); 1907 return ret; 1908 } 1909 EXPORT_SYMBOL(dquot_transfer); 1910 1911 /* 1912 * Write info of quota file to disk 1913 */ 1914 int dquot_commit_info(struct super_block *sb, int type) 1915 { 1916 int ret; 1917 struct quota_info *dqopt = sb_dqopt(sb); 1918 1919 mutex_lock(&dqopt->dqio_mutex); 1920 ret = dqopt->ops[type]->write_file_info(sb, type); 1921 mutex_unlock(&dqopt->dqio_mutex); 1922 return ret; 1923 } 1924 EXPORT_SYMBOL(dquot_commit_info); 1925 1926 /* 1927 * Definitions of diskquota operations. 1928 */ 1929 const struct dquot_operations dquot_operations = { 1930 .write_dquot = dquot_commit, 1931 .acquire_dquot = dquot_acquire, 1932 .release_dquot = dquot_release, 1933 .mark_dirty = dquot_mark_dquot_dirty, 1934 .write_info = dquot_commit_info, 1935 .alloc_dquot = dquot_alloc, 1936 .destroy_dquot = dquot_destroy, 1937 }; 1938 EXPORT_SYMBOL(dquot_operations); 1939 1940 /* 1941 * Generic helper for ->open on filesystems supporting disk quotas. 1942 */ 1943 int dquot_file_open(struct inode *inode, struct file *file) 1944 { 1945 int error; 1946 1947 error = generic_file_open(inode, file); 1948 if (!error && (file->f_mode & FMODE_WRITE)) 1949 dquot_initialize(inode); 1950 return error; 1951 } 1952 EXPORT_SYMBOL(dquot_file_open); 1953 1954 /* 1955 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount) 1956 */ 1957 int dquot_disable(struct super_block *sb, int type, unsigned int flags) 1958 { 1959 int cnt, ret = 0; 1960 struct quota_info *dqopt = sb_dqopt(sb); 1961 struct inode *toputinode[MAXQUOTAS]; 1962 1963 /* Cannot turn off usage accounting without turning off limits, or 1964 * suspend quotas and simultaneously turn quotas off. */ 1965 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED)) 1966 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED | 1967 DQUOT_USAGE_ENABLED))) 1968 return -EINVAL; 1969 1970 /* We need to serialize quota_off() for device */ 1971 mutex_lock(&dqopt->dqonoff_mutex); 1972 1973 /* 1974 * Skip everything if there's nothing to do. We have to do this because 1975 * sometimes we are called when fill_super() failed and calling 1976 * sync_fs() in such cases does no good. 1977 */ 1978 if (!sb_any_quota_loaded(sb)) { 1979 mutex_unlock(&dqopt->dqonoff_mutex); 1980 return 0; 1981 } 1982 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 1983 toputinode[cnt] = NULL; 1984 if (type != -1 && cnt != type) 1985 continue; 1986 if (!sb_has_quota_loaded(sb, cnt)) 1987 continue; 1988 1989 if (flags & DQUOT_SUSPENDED) { 1990 spin_lock(&dq_state_lock); 1991 dqopt->flags |= 1992 dquot_state_flag(DQUOT_SUSPENDED, cnt); 1993 spin_unlock(&dq_state_lock); 1994 } else { 1995 spin_lock(&dq_state_lock); 1996 dqopt->flags &= ~dquot_state_flag(flags, cnt); 1997 /* Turning off suspended quotas? */ 1998 if (!sb_has_quota_loaded(sb, cnt) && 1999 sb_has_quota_suspended(sb, cnt)) { 2000 dqopt->flags &= ~dquot_state_flag( 2001 DQUOT_SUSPENDED, cnt); 2002 spin_unlock(&dq_state_lock); 2003 iput(dqopt->files[cnt]); 2004 dqopt->files[cnt] = NULL; 2005 continue; 2006 } 2007 spin_unlock(&dq_state_lock); 2008 } 2009 2010 /* We still have to keep quota loaded? */ 2011 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED)) 2012 continue; 2013 2014 /* Note: these are blocking operations */ 2015 drop_dquot_ref(sb, cnt); 2016 invalidate_dquots(sb, cnt); 2017 /* 2018 * Now all dquots should be invalidated, all writes done so we 2019 * should be only users of the info. No locks needed. 2020 */ 2021 if (info_dirty(&dqopt->info[cnt])) 2022 sb->dq_op->write_info(sb, cnt); 2023 if (dqopt->ops[cnt]->free_file_info) 2024 dqopt->ops[cnt]->free_file_info(sb, cnt); 2025 put_quota_format(dqopt->info[cnt].dqi_format); 2026 2027 toputinode[cnt] = dqopt->files[cnt]; 2028 if (!sb_has_quota_loaded(sb, cnt)) 2029 dqopt->files[cnt] = NULL; 2030 dqopt->info[cnt].dqi_flags = 0; 2031 dqopt->info[cnt].dqi_igrace = 0; 2032 dqopt->info[cnt].dqi_bgrace = 0; 2033 dqopt->ops[cnt] = NULL; 2034 } 2035 mutex_unlock(&dqopt->dqonoff_mutex); 2036 2037 /* Skip syncing and setting flags if quota files are hidden */ 2038 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 2039 goto put_inodes; 2040 2041 /* Sync the superblock so that buffers with quota data are written to 2042 * disk (and so userspace sees correct data afterwards). */ 2043 if (sb->s_op->sync_fs) 2044 sb->s_op->sync_fs(sb, 1); 2045 sync_blockdev(sb->s_bdev); 2046 /* Now the quota files are just ordinary files and we can set the 2047 * inode flags back. Moreover we discard the pagecache so that 2048 * userspace sees the writes we did bypassing the pagecache. We 2049 * must also discard the blockdev buffers so that we see the 2050 * changes done by userspace on the next quotaon() */ 2051 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 2052 if (toputinode[cnt]) { 2053 mutex_lock(&dqopt->dqonoff_mutex); 2054 /* If quota was reenabled in the meantime, we have 2055 * nothing to do */ 2056 if (!sb_has_quota_loaded(sb, cnt)) { 2057 mutex_lock(&toputinode[cnt]->i_mutex); 2058 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE | 2059 S_NOATIME | S_NOQUOTA); 2060 truncate_inode_pages(&toputinode[cnt]->i_data, 2061 0); 2062 mutex_unlock(&toputinode[cnt]->i_mutex); 2063 mark_inode_dirty_sync(toputinode[cnt]); 2064 } 2065 mutex_unlock(&dqopt->dqonoff_mutex); 2066 } 2067 if (sb->s_bdev) 2068 invalidate_bdev(sb->s_bdev); 2069 put_inodes: 2070 for (cnt = 0; cnt < MAXQUOTAS; cnt++) 2071 if (toputinode[cnt]) { 2072 /* On remount RO, we keep the inode pointer so that we 2073 * can reenable quota on the subsequent remount RW. We 2074 * have to check 'flags' variable and not use sb_has_ 2075 * function because another quotaon / quotaoff could 2076 * change global state before we got here. We refuse 2077 * to suspend quotas when there is pending delete on 2078 * the quota file... */ 2079 if (!(flags & DQUOT_SUSPENDED)) 2080 iput(toputinode[cnt]); 2081 else if (!toputinode[cnt]->i_nlink) 2082 ret = -EBUSY; 2083 } 2084 return ret; 2085 } 2086 EXPORT_SYMBOL(dquot_disable); 2087 2088 int dquot_quota_off(struct super_block *sb, int type) 2089 { 2090 return dquot_disable(sb, type, 2091 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2092 } 2093 EXPORT_SYMBOL(dquot_quota_off); 2094 2095 /* 2096 * Turn quotas on on a device 2097 */ 2098 2099 /* 2100 * Helper function to turn quotas on when we already have the inode of 2101 * quota file and no quota information is loaded. 2102 */ 2103 static int vfs_load_quota_inode(struct inode *inode, int type, int format_id, 2104 unsigned int flags) 2105 { 2106 struct quota_format_type *fmt = find_quota_format(format_id); 2107 struct super_block *sb = inode->i_sb; 2108 struct quota_info *dqopt = sb_dqopt(sb); 2109 int error; 2110 int oldflags = -1; 2111 2112 if (!fmt) 2113 return -ESRCH; 2114 if (!S_ISREG(inode->i_mode)) { 2115 error = -EACCES; 2116 goto out_fmt; 2117 } 2118 if (IS_RDONLY(inode)) { 2119 error = -EROFS; 2120 goto out_fmt; 2121 } 2122 if (!sb->s_op->quota_write || !sb->s_op->quota_read) { 2123 error = -EINVAL; 2124 goto out_fmt; 2125 } 2126 /* Usage always has to be set... */ 2127 if (!(flags & DQUOT_USAGE_ENABLED)) { 2128 error = -EINVAL; 2129 goto out_fmt; 2130 } 2131 2132 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2133 /* As we bypass the pagecache we must now flush all the 2134 * dirty data and invalidate caches so that kernel sees 2135 * changes from userspace. It is not enough to just flush 2136 * the quota file since if blocksize < pagesize, invalidation 2137 * of the cache could fail because of other unrelated dirty 2138 * data */ 2139 sync_filesystem(sb); 2140 invalidate_bdev(sb->s_bdev); 2141 } 2142 mutex_lock(&dqopt->dqonoff_mutex); 2143 if (sb_has_quota_loaded(sb, type)) { 2144 error = -EBUSY; 2145 goto out_lock; 2146 } 2147 2148 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) { 2149 /* We don't want quota and atime on quota files (deadlocks 2150 * possible) Also nobody should write to the file - we use 2151 * special IO operations which ignore the immutable bit. */ 2152 mutex_lock(&inode->i_mutex); 2153 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE | 2154 S_NOQUOTA); 2155 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE; 2156 mutex_unlock(&inode->i_mutex); 2157 /* 2158 * When S_NOQUOTA is set, remove dquot references as no more 2159 * references can be added 2160 */ 2161 __dquot_drop(inode); 2162 } 2163 2164 error = -EIO; 2165 dqopt->files[type] = igrab(inode); 2166 if (!dqopt->files[type]) 2167 goto out_lock; 2168 error = -EINVAL; 2169 if (!fmt->qf_ops->check_quota_file(sb, type)) 2170 goto out_file_init; 2171 2172 dqopt->ops[type] = fmt->qf_ops; 2173 dqopt->info[type].dqi_format = fmt; 2174 dqopt->info[type].dqi_fmt_id = format_id; 2175 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list); 2176 mutex_lock(&dqopt->dqio_mutex); 2177 error = dqopt->ops[type]->read_file_info(sb, type); 2178 if (error < 0) { 2179 mutex_unlock(&dqopt->dqio_mutex); 2180 goto out_file_init; 2181 } 2182 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) 2183 dqopt->info[type].dqi_flags |= DQF_SYS_FILE; 2184 mutex_unlock(&dqopt->dqio_mutex); 2185 spin_lock(&dq_state_lock); 2186 dqopt->flags |= dquot_state_flag(flags, type); 2187 spin_unlock(&dq_state_lock); 2188 2189 add_dquot_ref(sb, type); 2190 mutex_unlock(&dqopt->dqonoff_mutex); 2191 2192 return 0; 2193 2194 out_file_init: 2195 dqopt->files[type] = NULL; 2196 iput(inode); 2197 out_lock: 2198 if (oldflags != -1) { 2199 mutex_lock(&inode->i_mutex); 2200 /* Set the flags back (in the case of accidental quotaon() 2201 * on a wrong file we don't want to mess up the flags) */ 2202 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE); 2203 inode->i_flags |= oldflags; 2204 mutex_unlock(&inode->i_mutex); 2205 } 2206 mutex_unlock(&dqopt->dqonoff_mutex); 2207 out_fmt: 2208 put_quota_format(fmt); 2209 2210 return error; 2211 } 2212 2213 /* Reenable quotas on remount RW */ 2214 int dquot_resume(struct super_block *sb, int type) 2215 { 2216 struct quota_info *dqopt = sb_dqopt(sb); 2217 struct inode *inode; 2218 int ret = 0, cnt; 2219 unsigned int flags; 2220 2221 for (cnt = 0; cnt < MAXQUOTAS; cnt++) { 2222 if (type != -1 && cnt != type) 2223 continue; 2224 2225 mutex_lock(&dqopt->dqonoff_mutex); 2226 if (!sb_has_quota_suspended(sb, cnt)) { 2227 mutex_unlock(&dqopt->dqonoff_mutex); 2228 continue; 2229 } 2230 inode = dqopt->files[cnt]; 2231 dqopt->files[cnt] = NULL; 2232 spin_lock(&dq_state_lock); 2233 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED | 2234 DQUOT_LIMITS_ENABLED, 2235 cnt); 2236 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt); 2237 spin_unlock(&dq_state_lock); 2238 mutex_unlock(&dqopt->dqonoff_mutex); 2239 2240 flags = dquot_generic_flag(flags, cnt); 2241 ret = vfs_load_quota_inode(inode, cnt, 2242 dqopt->info[cnt].dqi_fmt_id, flags); 2243 iput(inode); 2244 } 2245 2246 return ret; 2247 } 2248 EXPORT_SYMBOL(dquot_resume); 2249 2250 int dquot_quota_on(struct super_block *sb, int type, int format_id, 2251 struct path *path) 2252 { 2253 int error = security_quota_on(path->dentry); 2254 if (error) 2255 return error; 2256 /* Quota file not on the same filesystem? */ 2257 if (path->dentry->d_sb != sb) 2258 error = -EXDEV; 2259 else 2260 error = vfs_load_quota_inode(path->dentry->d_inode, type, 2261 format_id, DQUOT_USAGE_ENABLED | 2262 DQUOT_LIMITS_ENABLED); 2263 return error; 2264 } 2265 EXPORT_SYMBOL(dquot_quota_on); 2266 2267 /* 2268 * More powerful function for turning on quotas allowing setting 2269 * of individual quota flags 2270 */ 2271 int dquot_enable(struct inode *inode, int type, int format_id, 2272 unsigned int flags) 2273 { 2274 int ret = 0; 2275 struct super_block *sb = inode->i_sb; 2276 struct quota_info *dqopt = sb_dqopt(sb); 2277 2278 /* Just unsuspend quotas? */ 2279 BUG_ON(flags & DQUOT_SUSPENDED); 2280 2281 if (!flags) 2282 return 0; 2283 /* Just updating flags needed? */ 2284 if (sb_has_quota_loaded(sb, type)) { 2285 mutex_lock(&dqopt->dqonoff_mutex); 2286 /* Now do a reliable test... */ 2287 if (!sb_has_quota_loaded(sb, type)) { 2288 mutex_unlock(&dqopt->dqonoff_mutex); 2289 goto load_quota; 2290 } 2291 if (flags & DQUOT_USAGE_ENABLED && 2292 sb_has_quota_usage_enabled(sb, type)) { 2293 ret = -EBUSY; 2294 goto out_lock; 2295 } 2296 if (flags & DQUOT_LIMITS_ENABLED && 2297 sb_has_quota_limits_enabled(sb, type)) { 2298 ret = -EBUSY; 2299 goto out_lock; 2300 } 2301 spin_lock(&dq_state_lock); 2302 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type); 2303 spin_unlock(&dq_state_lock); 2304 out_lock: 2305 mutex_unlock(&dqopt->dqonoff_mutex); 2306 return ret; 2307 } 2308 2309 load_quota: 2310 return vfs_load_quota_inode(inode, type, format_id, flags); 2311 } 2312 EXPORT_SYMBOL(dquot_enable); 2313 2314 /* 2315 * This function is used when filesystem needs to initialize quotas 2316 * during mount time. 2317 */ 2318 int dquot_quota_on_mount(struct super_block *sb, char *qf_name, 2319 int format_id, int type) 2320 { 2321 struct dentry *dentry; 2322 int error; 2323 2324 mutex_lock(&sb->s_root->d_inode->i_mutex); 2325 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name)); 2326 mutex_unlock(&sb->s_root->d_inode->i_mutex); 2327 if (IS_ERR(dentry)) 2328 return PTR_ERR(dentry); 2329 2330 if (!dentry->d_inode) { 2331 error = -ENOENT; 2332 goto out; 2333 } 2334 2335 error = security_quota_on(dentry); 2336 if (!error) 2337 error = vfs_load_quota_inode(dentry->d_inode, type, format_id, 2338 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2339 2340 out: 2341 dput(dentry); 2342 return error; 2343 } 2344 EXPORT_SYMBOL(dquot_quota_on_mount); 2345 2346 static inline qsize_t qbtos(qsize_t blocks) 2347 { 2348 return blocks << QIF_DQBLKSIZE_BITS; 2349 } 2350 2351 static inline qsize_t stoqb(qsize_t space) 2352 { 2353 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS; 2354 } 2355 2356 /* Generic routine for getting common part of quota structure */ 2357 static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di) 2358 { 2359 struct mem_dqblk *dm = &dquot->dq_dqb; 2360 2361 memset(di, 0, sizeof(*di)); 2362 di->d_version = FS_DQUOT_VERSION; 2363 di->d_flags = dquot->dq_id.type == USRQUOTA ? 2364 FS_USER_QUOTA : FS_GROUP_QUOTA; 2365 di->d_id = from_kqid_munged(current_user_ns(), dquot->dq_id); 2366 2367 spin_lock(&dq_data_lock); 2368 di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit); 2369 di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit); 2370 di->d_ino_hardlimit = dm->dqb_ihardlimit; 2371 di->d_ino_softlimit = dm->dqb_isoftlimit; 2372 di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace; 2373 di->d_icount = dm->dqb_curinodes; 2374 di->d_btimer = dm->dqb_btime; 2375 di->d_itimer = dm->dqb_itime; 2376 spin_unlock(&dq_data_lock); 2377 } 2378 2379 int dquot_get_dqblk(struct super_block *sb, struct kqid qid, 2380 struct fs_disk_quota *di) 2381 { 2382 struct dquot *dquot; 2383 2384 dquot = dqget(sb, qid); 2385 if (!dquot) 2386 return -ESRCH; 2387 do_get_dqblk(dquot, di); 2388 dqput(dquot); 2389 2390 return 0; 2391 } 2392 EXPORT_SYMBOL(dquot_get_dqblk); 2393 2394 #define VFS_FS_DQ_MASK \ 2395 (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \ 2396 FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \ 2397 FS_DQ_BTIMER | FS_DQ_ITIMER) 2398 2399 /* Generic routine for setting common part of quota structure */ 2400 static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di) 2401 { 2402 struct mem_dqblk *dm = &dquot->dq_dqb; 2403 int check_blim = 0, check_ilim = 0; 2404 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type]; 2405 2406 if (di->d_fieldmask & ~VFS_FS_DQ_MASK) 2407 return -EINVAL; 2408 2409 if (((di->d_fieldmask & FS_DQ_BSOFT) && 2410 (di->d_blk_softlimit > dqi->dqi_maxblimit)) || 2411 ((di->d_fieldmask & FS_DQ_BHARD) && 2412 (di->d_blk_hardlimit > dqi->dqi_maxblimit)) || 2413 ((di->d_fieldmask & FS_DQ_ISOFT) && 2414 (di->d_ino_softlimit > dqi->dqi_maxilimit)) || 2415 ((di->d_fieldmask & FS_DQ_IHARD) && 2416 (di->d_ino_hardlimit > dqi->dqi_maxilimit))) 2417 return -ERANGE; 2418 2419 spin_lock(&dq_data_lock); 2420 if (di->d_fieldmask & FS_DQ_BCOUNT) { 2421 dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace; 2422 check_blim = 1; 2423 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags); 2424 } 2425 2426 if (di->d_fieldmask & FS_DQ_BSOFT) 2427 dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit); 2428 if (di->d_fieldmask & FS_DQ_BHARD) 2429 dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit); 2430 if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) { 2431 check_blim = 1; 2432 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags); 2433 } 2434 2435 if (di->d_fieldmask & FS_DQ_ICOUNT) { 2436 dm->dqb_curinodes = di->d_icount; 2437 check_ilim = 1; 2438 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags); 2439 } 2440 2441 if (di->d_fieldmask & FS_DQ_ISOFT) 2442 dm->dqb_isoftlimit = di->d_ino_softlimit; 2443 if (di->d_fieldmask & FS_DQ_IHARD) 2444 dm->dqb_ihardlimit = di->d_ino_hardlimit; 2445 if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) { 2446 check_ilim = 1; 2447 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags); 2448 } 2449 2450 if (di->d_fieldmask & FS_DQ_BTIMER) { 2451 dm->dqb_btime = di->d_btimer; 2452 check_blim = 1; 2453 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags); 2454 } 2455 2456 if (di->d_fieldmask & FS_DQ_ITIMER) { 2457 dm->dqb_itime = di->d_itimer; 2458 check_ilim = 1; 2459 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags); 2460 } 2461 2462 if (check_blim) { 2463 if (!dm->dqb_bsoftlimit || 2464 dm->dqb_curspace < dm->dqb_bsoftlimit) { 2465 dm->dqb_btime = 0; 2466 clear_bit(DQ_BLKS_B, &dquot->dq_flags); 2467 } else if (!(di->d_fieldmask & FS_DQ_BTIMER)) 2468 /* Set grace only if user hasn't provided his own... */ 2469 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace; 2470 } 2471 if (check_ilim) { 2472 if (!dm->dqb_isoftlimit || 2473 dm->dqb_curinodes < dm->dqb_isoftlimit) { 2474 dm->dqb_itime = 0; 2475 clear_bit(DQ_INODES_B, &dquot->dq_flags); 2476 } else if (!(di->d_fieldmask & FS_DQ_ITIMER)) 2477 /* Set grace only if user hasn't provided his own... */ 2478 dm->dqb_itime = get_seconds() + dqi->dqi_igrace; 2479 } 2480 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit || 2481 dm->dqb_isoftlimit) 2482 clear_bit(DQ_FAKE_B, &dquot->dq_flags); 2483 else 2484 set_bit(DQ_FAKE_B, &dquot->dq_flags); 2485 spin_unlock(&dq_data_lock); 2486 mark_dquot_dirty(dquot); 2487 2488 return 0; 2489 } 2490 2491 int dquot_set_dqblk(struct super_block *sb, struct kqid qid, 2492 struct fs_disk_quota *di) 2493 { 2494 struct dquot *dquot; 2495 int rc; 2496 2497 dquot = dqget(sb, qid); 2498 if (!dquot) { 2499 rc = -ESRCH; 2500 goto out; 2501 } 2502 rc = do_set_dqblk(dquot, di); 2503 dqput(dquot); 2504 out: 2505 return rc; 2506 } 2507 EXPORT_SYMBOL(dquot_set_dqblk); 2508 2509 /* Generic routine for getting common part of quota file information */ 2510 int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2511 { 2512 struct mem_dqinfo *mi; 2513 2514 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2515 if (!sb_has_quota_active(sb, type)) { 2516 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2517 return -ESRCH; 2518 } 2519 mi = sb_dqopt(sb)->info + type; 2520 spin_lock(&dq_data_lock); 2521 ii->dqi_bgrace = mi->dqi_bgrace; 2522 ii->dqi_igrace = mi->dqi_igrace; 2523 ii->dqi_flags = mi->dqi_flags & DQF_GETINFO_MASK; 2524 ii->dqi_valid = IIF_ALL; 2525 spin_unlock(&dq_data_lock); 2526 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2527 return 0; 2528 } 2529 EXPORT_SYMBOL(dquot_get_dqinfo); 2530 2531 /* Generic routine for setting common part of quota file information */ 2532 int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii) 2533 { 2534 struct mem_dqinfo *mi; 2535 int err = 0; 2536 2537 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 2538 if (!sb_has_quota_active(sb, type)) { 2539 err = -ESRCH; 2540 goto out; 2541 } 2542 mi = sb_dqopt(sb)->info + type; 2543 spin_lock(&dq_data_lock); 2544 if (ii->dqi_valid & IIF_BGRACE) 2545 mi->dqi_bgrace = ii->dqi_bgrace; 2546 if (ii->dqi_valid & IIF_IGRACE) 2547 mi->dqi_igrace = ii->dqi_igrace; 2548 if (ii->dqi_valid & IIF_FLAGS) 2549 mi->dqi_flags = (mi->dqi_flags & ~DQF_SETINFO_MASK) | 2550 (ii->dqi_flags & DQF_SETINFO_MASK); 2551 spin_unlock(&dq_data_lock); 2552 mark_info_dirty(sb, type); 2553 /* Force write to disk */ 2554 sb->dq_op->write_info(sb, type); 2555 out: 2556 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 2557 return err; 2558 } 2559 EXPORT_SYMBOL(dquot_set_dqinfo); 2560 2561 const struct quotactl_ops dquot_quotactl_ops = { 2562 .quota_on = dquot_quota_on, 2563 .quota_off = dquot_quota_off, 2564 .quota_sync = dquot_quota_sync, 2565 .get_info = dquot_get_dqinfo, 2566 .set_info = dquot_set_dqinfo, 2567 .get_dqblk = dquot_get_dqblk, 2568 .set_dqblk = dquot_set_dqblk 2569 }; 2570 EXPORT_SYMBOL(dquot_quotactl_ops); 2571 2572 static int do_proc_dqstats(struct ctl_table *table, int write, 2573 void __user *buffer, size_t *lenp, loff_t *ppos) 2574 { 2575 unsigned int type = (int *)table->data - dqstats.stat; 2576 2577 /* Update global table */ 2578 dqstats.stat[type] = 2579 percpu_counter_sum_positive(&dqstats.counter[type]); 2580 return proc_dointvec(table, write, buffer, lenp, ppos); 2581 } 2582 2583 static ctl_table fs_dqstats_table[] = { 2584 { 2585 .procname = "lookups", 2586 .data = &dqstats.stat[DQST_LOOKUPS], 2587 .maxlen = sizeof(int), 2588 .mode = 0444, 2589 .proc_handler = do_proc_dqstats, 2590 }, 2591 { 2592 .procname = "drops", 2593 .data = &dqstats.stat[DQST_DROPS], 2594 .maxlen = sizeof(int), 2595 .mode = 0444, 2596 .proc_handler = do_proc_dqstats, 2597 }, 2598 { 2599 .procname = "reads", 2600 .data = &dqstats.stat[DQST_READS], 2601 .maxlen = sizeof(int), 2602 .mode = 0444, 2603 .proc_handler = do_proc_dqstats, 2604 }, 2605 { 2606 .procname = "writes", 2607 .data = &dqstats.stat[DQST_WRITES], 2608 .maxlen = sizeof(int), 2609 .mode = 0444, 2610 .proc_handler = do_proc_dqstats, 2611 }, 2612 { 2613 .procname = "cache_hits", 2614 .data = &dqstats.stat[DQST_CACHE_HITS], 2615 .maxlen = sizeof(int), 2616 .mode = 0444, 2617 .proc_handler = do_proc_dqstats, 2618 }, 2619 { 2620 .procname = "allocated_dquots", 2621 .data = &dqstats.stat[DQST_ALLOC_DQUOTS], 2622 .maxlen = sizeof(int), 2623 .mode = 0444, 2624 .proc_handler = do_proc_dqstats, 2625 }, 2626 { 2627 .procname = "free_dquots", 2628 .data = &dqstats.stat[DQST_FREE_DQUOTS], 2629 .maxlen = sizeof(int), 2630 .mode = 0444, 2631 .proc_handler = do_proc_dqstats, 2632 }, 2633 { 2634 .procname = "syncs", 2635 .data = &dqstats.stat[DQST_SYNCS], 2636 .maxlen = sizeof(int), 2637 .mode = 0444, 2638 .proc_handler = do_proc_dqstats, 2639 }, 2640 #ifdef CONFIG_PRINT_QUOTA_WARNING 2641 { 2642 .procname = "warnings", 2643 .data = &flag_print_warnings, 2644 .maxlen = sizeof(int), 2645 .mode = 0644, 2646 .proc_handler = proc_dointvec, 2647 }, 2648 #endif 2649 { }, 2650 }; 2651 2652 static ctl_table fs_table[] = { 2653 { 2654 .procname = "quota", 2655 .mode = 0555, 2656 .child = fs_dqstats_table, 2657 }, 2658 { }, 2659 }; 2660 2661 static ctl_table sys_table[] = { 2662 { 2663 .procname = "fs", 2664 .mode = 0555, 2665 .child = fs_table, 2666 }, 2667 { }, 2668 }; 2669 2670 static int __init dquot_init(void) 2671 { 2672 int i, ret; 2673 unsigned long nr_hash, order; 2674 2675 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__); 2676 2677 register_sysctl_table(sys_table); 2678 2679 dquot_cachep = kmem_cache_create("dquot", 2680 sizeof(struct dquot), sizeof(unsigned long) * 4, 2681 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 2682 SLAB_MEM_SPREAD|SLAB_PANIC), 2683 NULL); 2684 2685 order = 0; 2686 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order); 2687 if (!dquot_hash) 2688 panic("Cannot create dquot hash table"); 2689 2690 for (i = 0; i < _DQST_DQSTAT_LAST; i++) { 2691 ret = percpu_counter_init(&dqstats.counter[i], 0); 2692 if (ret) 2693 panic("Cannot create dquot stat counters"); 2694 } 2695 2696 /* Find power-of-two hlist_heads which can fit into allocation */ 2697 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head); 2698 dq_hash_bits = 0; 2699 do { 2700 dq_hash_bits++; 2701 } while (nr_hash >> dq_hash_bits); 2702 dq_hash_bits--; 2703 2704 nr_hash = 1UL << dq_hash_bits; 2705 dq_hash_mask = nr_hash - 1; 2706 for (i = 0; i < nr_hash; i++) 2707 INIT_HLIST_HEAD(dquot_hash + i); 2708 2709 printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n", 2710 nr_hash, order, (PAGE_SIZE << order)); 2711 2712 register_shrinker(&dqcache_shrinker); 2713 2714 return 0; 2715 } 2716 module_init(dquot_init); 2717