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