开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
dquot.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：38k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

dquot.c：源码内容
  1. /*
  2.  * Implementation of the diskquota system for the LINUX operating
  3.  * system. QUOTA is implemented using the BSD system call interface as
  4.  * the means of communication with the user level. Currently only the
  5.  * ext2 filesystem has support for disk quotas. Other filesystems may
  6.  * be added in the future. This file contains the generic routines
  7.  * called by the different filesystems on allocation of an inode or
  8.  * block. These routines take care of the administration needed to
  9.  * have a consistent diskquota tracking system. The ideas of both
  10.  * user and group quotas are based on the Melbourne quota system as
  11.  * used on BSD derived systems. The internal implementation is 
  12.  * based on one of the several variants of the LINUX inode-subsystem
  13.  * with added complexity of the diskquota system.
  14.  * 
  15.  * Version: $Id: dquot.c,v 6.3 1996/11/17 18:35:34 mvw Exp mvw $
  16.  * 
  17.  * Author: Marco van Wieringen <mvw@planets.elm.net>
  18.  *
  19.  * Fixes:   Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
  20.  *
  21.  * Revised list management to avoid races
  22.  * -- Bill Hawes, <whawes@star.net>, 9/98
  23.  *
  24.  * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...().
  25.  * As the consequence the locking was moved from dquot_decr_...(),
  26.  * dquot_incr_...() to calling functions.
  27.  * invalidate_dquots() now writes modified dquots.
  28.  * Serialized quota_off() and quota_on() for mount point.
  29.  * Fixed a few bugs in grow_dquots().
  30.  * Fixed deadlock in write_dquot() - we no longer account quotas on
  31.  * quota files
  32.  * remove_dquot_ref() moved to inode.c - it now traverses through inodes
  33.  * add_dquot_ref() restarts after blocking
  34.  * Added check for bogus uid and fixed check for group in quotactl.
  35.  * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99
  36.  *
  37.  * Used struct list_head instead of own list struct
  38.  * Invalidation of dquots with dq_count > 0 no longer possible
  39.  * Improved free_dquots list management
  40.  * Quota and i_blocks are now updated in one place to avoid races
  41.  * Warnings are now delayed so we won't block in critical section
  42.  * Write updated not to require dquot lock
  43.  * Jan Kara, <jack@suse.cz>, 9/2000
  44.  *
  45.  * Added dynamic quota structure allocation
  46.  * Jan Kara <jack@suse.cz> 12/2000
  47.  *
  48.  * (C) Copyright 1994 - 1997 Marco van Wieringen 
  49.  */
  51. #include <linux/errno.h>
  52. #include <linux/kernel.h>
  53. #include <linux/fs.h>
  54. #include <linux/sched.h>
  55. #include <linux/types.h>
  56. #include <linux/string.h>
  57. #include <linux/fcntl.h>
  58. #include <linux/stat.h>
  59. #include <linux/tty.h>
  60. #include <linux/file.h>
  61. #include <linux/slab.h>
  62. #include <linux/smp_lock.h>
  63. #include <linux/init.h>
  65. #include <asm/uaccess.h>
  67. #define __DQUOT_VERSION__ "dquot_6.4.0"
  69. int nr_dquots, nr_free_dquots;
  71. static char *quotatypes[] = INITQFNAMES;
  73. static inline struct quota_mount_options *sb_dqopt(struct super_block *sb)
  74. {
  75. return &sb->s_dquot;
  76. }
  78. /*
  79.  * Dquot List Management:
  80.  * The quota code uses three lists for dquot management: the inuse_list,
  81.  * free_dquots, and dquot_hash[] array. A single dquot structure may be
  82.  * on all three lists, depending on its current state.
  83.  *
  84.  * All dquots are placed to the end of inuse_list when first created, and this
  85.  * list is used for the sync and invalidate operations, which must look
  86.  * at every dquot.
  87.  *
  88.  * Unused dquots (dq_count == 0) are added to the free_dquots list when
  89.  * freed, and this list is searched whenever we need an available dquot.
  90.  * Dquots are removed from the list as soon as they are used again, and
  91.  * nr_free_dquots gives the number of dquots on the list. When dquot is
  92.  * invalidated it's completely released from memory.
  93.  *
  94.  * Dquots with a specific identity (device, type and id) are placed on
  95.  * one of the dquot_hash[] hash chains. The provides an efficient search
  96.  * mechanism to locate a specific dquot.
  97.  */
  99. /*
  100.  * Note that any operation which operates on dquot data (ie. dq_dqb) mustn't
  101.  * block while it's updating/reading it. Otherwise races would occur.
  102.  *
  103.  * Locked dquots might not be referenced in inodes - operations like
  104.  * add_dquot_space() does dqduplicate() and would complain. Currently
  105.  * dquot it locked only once in its existence - when it's being read
  106.  * to memory on first dqget() and at that time it can't be referenced
  107.  * from inode. Write operations on dquots don't hold dquot lock as they
  108.  * copy data to internal buffers before writing anyway and copying as well
  109.  * as any data update should be atomic. Also nobody can change used
  110.  * entries in dquot structure as this is done only when quota is destroyed
  111.  * and invalidate_dquots() waits for dquot to have dq_count == 0.
  112.  */
  114. static LIST_HEAD(inuse_list);
  115. static LIST_HEAD(free_dquots);
  116. static struct list_head dquot_hash[NR_DQHASH];
  118. static struct dqstats dqstats;
  120. static void dqput(struct dquot *);
  121. static struct dquot *dqduplicate(struct dquot *);
  123. static inline char is_enabled(struct quota_mount_options *dqopt, short type)
  124. {
  125. switch (type) {
  126. case USRQUOTA:
  127. return((dqopt->flags & DQUOT_USR_ENABLED) != 0);
  128. case GRPQUOTA:
  129. return((dqopt->flags & DQUOT_GRP_ENABLED) != 0);
  130. }
  131. return(0);
  132. }
  134. static inline char sb_has_quota_enabled(struct super_block *sb, short type)
  135. {
  136. return is_enabled(sb_dqopt(sb), type);
  137. }
  139. static inline int const hashfn(kdev_t dev, unsigned int id, short type)
  140. {
  141. return((HASHDEV(dev) ^ id) * (MAXQUOTAS - type)) % NR_DQHASH;
  142. }
  144. static inline void insert_dquot_hash(struct dquot *dquot)
  145. {
  146. struct list_head *head = dquot_hash + hashfn(dquot->dq_dev, dquot->dq_id, dquot->dq_type);
  147. list_add(&dquot->dq_hash, head);
  148. }
  150. static inline void remove_dquot_hash(struct dquot *dquot)
  151. {
  152. list_del(&dquot->dq_hash);
  153. INIT_LIST_HEAD(&dquot->dq_hash);
  154. }
  156. static inline struct dquot *find_dquot(unsigned int hashent, kdev_t dev, unsigned int id, short type)
  157. {
  158. struct list_head *head;
  159. struct dquot *dquot;
  161. for (head = dquot_hash[hashent].next; head != dquot_hash+hashent; head = head->next) {
  162. dquot = list_entry(head, struct dquot, dq_hash);
  163. if (dquot->dq_dev == dev && dquot->dq_id == id && dquot->dq_type == type)
  164. return dquot;
  165. }
  166. return NODQUOT;
  167. }
  169. /* Add a dquot to the head of the free list */
  170. static inline void put_dquot_head(struct dquot *dquot)
  171. {
  172. list_add(&dquot->dq_free, &free_dquots);
  173. nr_free_dquots++;
  174. }
  176. /* Add a dquot to the tail of the free list */
  177. static inline void put_dquot_last(struct dquot *dquot)
  178. {
  179. list_add(&dquot->dq_free, free_dquots.prev);
  180. nr_free_dquots++;
  181. }
  183. /* Move dquot to the head of free list (it must be already on it) */
  184. static inline void move_dquot_head(struct dquot *dquot)
  185. {
  186. list_del(&dquot->dq_free);
  187. list_add(&dquot->dq_free, &free_dquots);
  188. }
  190. static inline void remove_free_dquot(struct dquot *dquot)
  191. {
  192. if (list_empty(&dquot->dq_free))
  193. return;
  194. list_del(&dquot->dq_free);
  195. INIT_LIST_HEAD(&dquot->dq_free);
  196. nr_free_dquots--;
  197. }
  199. static inline void put_inuse(struct dquot *dquot)
  200. {
  201. /* We add to the back of inuse list so we don't have to restart
  202.  * when traversing this list and we block */
  203. list_add(&dquot->dq_inuse, inuse_list.prev);
  204. nr_dquots++;
  205. }
  207. static inline void remove_inuse(struct dquot *dquot)
  208. {
  209. nr_dquots--;
  210. list_del(&dquot->dq_inuse);
  211. }
  213. static void __wait_on_dquot(struct dquot *dquot)
  214. {
  215. DECLARE_WAITQUEUE(wait, current);
  217. add_wait_queue(&dquot->dq_wait_lock, &wait);
  218. repeat:
  219. set_current_state(TASK_UNINTERRUPTIBLE);
  220. if (dquot->dq_flags & DQ_LOCKED) {
  221. schedule();
  222. goto repeat;
  223. }
  224. remove_wait_queue(&dquot->dq_wait_lock, &wait);
  225. current->state = TASK_RUNNING;
  226. }
  228. static inline void wait_on_dquot(struct dquot *dquot)
  229. {
  230. if (dquot->dq_flags & DQ_LOCKED)
  231. __wait_on_dquot(dquot);
  232. }
  234. static inline void lock_dquot(struct dquot *dquot)
  235. {
  236. wait_on_dquot(dquot);
  237. dquot->dq_flags |= DQ_LOCKED;
  238. }
  240. static inline void unlock_dquot(struct dquot *dquot)
  241. {
  242. dquot->dq_flags &= ~DQ_LOCKED;
  243. wake_up(&dquot->dq_wait_lock);
  244. }
  246. static void __wait_dquot_unused(struct dquot *dquot)
  247. {
  248. DECLARE_WAITQUEUE(wait, current);
  250. add_wait_queue(&dquot->dq_wait_free, &wait);
  251. repeat:
  252. set_current_state(TASK_UNINTERRUPTIBLE);
  253. if (dquot->dq_count) {
  254. schedule();
  255. goto repeat;
  256. }
  257. remove_wait_queue(&dquot->dq_wait_free, &wait);
  258. current->state = TASK_RUNNING;
  259. }
  261. /*
  262.  * We don't have to be afraid of deadlocks as we never have quotas on quota files...
  263.  */
  264. static void write_dquot(struct dquot *dquot)
  265. {
  266. short type = dquot->dq_type;
  267. struct file *filp;
  268. mm_segment_t fs;
  269. loff_t offset;
  270. ssize_t ret;
  271. struct semaphore *sem = &dquot->dq_sb->s_dquot.dqio_sem;
  272. struct dqblk dqbuf;
  274. down(sem);
  275. filp = dquot->dq_sb->s_dquot.files[type];
  276. offset = dqoff(dquot->dq_id);
  277. fs = get_fs();
  278. set_fs(KERNEL_DS);
  280. /*
  281.  * Note: clear the DQ_MOD flag unconditionally,
  282.  * so we don't loop forever on failure.
  283.  */
  284. memcpy(&dqbuf, &dquot->dq_dqb, sizeof(struct dqblk));
  285. dquot->dq_flags &= ~DQ_MOD;
  286. ret = 0;
  287. if (filp)
  288. ret = filp->f_op->write(filp, (char *)&dqbuf, 
  289. sizeof(struct dqblk), &offset);
  290. if (ret != sizeof(struct dqblk))
  291. printk(KERN_WARNING "VFS: dquota write failed on dev %sn",
  292. kdevname(dquot->dq_dev));
  294. set_fs(fs);
  295. up(sem);
  296. dqstats.writes++;
  297. }
  299. static void read_dquot(struct dquot *dquot)
  300. {
  301. short type = dquot->dq_type;
  302. struct file *filp;
  303. mm_segment_t fs;
  304. loff_t offset;
  306. filp = dquot->dq_sb->s_dquot.files[type];
  307. if (filp == (struct file *)NULL)
  308. return;
  310. lock_dquot(dquot);
  311. if (!dquot->dq_sb) /* Invalidated quota? */
  312. goto out_lock;
  313. /* Now we are sure filp is valid - the dquot isn't invalidated */
  314. down(&dquot->dq_sb->s_dquot.dqio_sem);
  315. offset = dqoff(dquot->dq_id);
  316. fs = get_fs();
  317. set_fs(KERNEL_DS);
  318. filp->f_op->read(filp, (char *)&dquot->dq_dqb, sizeof(struct dqblk), &offset);
  319. up(&dquot->dq_sb->s_dquot.dqio_sem);
  320. set_fs(fs);
  322. if (dquot->dq_bhardlimit == 0 && dquot->dq_bsoftlimit == 0 &&
  323.     dquot->dq_ihardlimit == 0 && dquot->dq_isoftlimit == 0)
  324. dquot->dq_flags |= DQ_FAKE;
  325. dqstats.reads++;
  326. out_lock:
  327. unlock_dquot(dquot);
  328. }
  330. /* Invalidate all dquots on the list, wait for all users. Note that this function is called
  331.  * after quota is disabled so no new quota might be created. As we only insert to the end of
  332.  * inuse list, we don't have to restart searching... */
  333. static void invalidate_dquots(struct super_block *sb, short type)
  334. {
  335. struct dquot *dquot;
  336. struct list_head *head;
  338. restart:
  339. for (head = inuse_list.next; head != &inuse_list; head = head->next) {
  340. dquot = list_entry(head, struct dquot, dq_inuse);
  341. if (dquot->dq_sb != sb)
  342. continue;
  343. if (dquot->dq_type != type)
  344. continue;
  345. dquot->dq_flags |= DQ_INVAL;
  346. if (dquot->dq_count)
  347. /*
  348.  *  Wait for any users of quota. As we have already cleared the flags in
  349.  *  superblock and cleared all pointers from inodes we are assured
  350.  *  that there will be no new users of this quota.
  351.  */
  352. __wait_dquot_unused(dquot);
  353. /* Quota now have no users and it has been written on last dqput() */
  354. remove_dquot_hash(dquot);
  355. remove_free_dquot(dquot);
  356. remove_inuse(dquot);
  357. kmem_cache_free(dquot_cachep, dquot);
  358. goto restart;
  359. }
  360. }
  362. int sync_dquots(kdev_t dev, short type)
  363. {
  364. struct list_head *head;
  365. struct dquot *dquot;
  367. lock_kernel();
  368. restart:
  369. for (head = inuse_list.next; head != &inuse_list; head = head->next) {
  370. dquot = list_entry(head, struct dquot, dq_inuse);
  371. if (dev && dquot->dq_dev != dev)
  372. continue;
  373.                 if (type != -1 && dquot->dq_type != type)
  374. continue;
  375. if (!dquot->dq_sb) /* Invalidated? */
  376. continue;
  377. if (!(dquot->dq_flags & (DQ_MOD | DQ_LOCKED)))
  378. continue;
  379. /* Raise use count so quota won't be invalidated. We can't use dqduplicate() as it does too many tests */
  380. dquot->dq_count++;
  381. if (dquot->dq_flags & DQ_LOCKED)
  382. wait_on_dquot(dquot);
  383. if (dquot->dq_flags & DQ_MOD)
  384. write_dquot(dquot);
  385. dqput(dquot);
  386. goto restart;
  387. }
  388. dqstats.syncs++;
  389. unlock_kernel();
  390. return 0;
  391. }
  393. /* Free unused dquots from cache */
  394. static void prune_dqcache(int count)
  395. {
  396. struct list_head *head;
  397. struct dquot *dquot;
  399. head = free_dquots.prev;
  400. while (head != &free_dquots && count) {
  401. dquot = list_entry(head, struct dquot, dq_free);
  402. remove_dquot_hash(dquot);
  403. remove_free_dquot(dquot);
  404. remove_inuse(dquot);
  405. kmem_cache_free(dquot_cachep, dquot);
  406. count--;
  407. head = free_dquots.prev;
  408. }
  409. }
  411. int shrink_dqcache_memory(int priority, unsigned int gfp_mask)
  412. {
  413. lock_kernel();
  414. prune_dqcache(nr_free_dquots / (priority + 1));
  415. unlock_kernel();
  416. kmem_cache_shrink(dquot_cachep);
  417. return 0;
  418. }
  420. /* NOTE: If you change this function please check whether dqput_blocks() works right... */
  421. static void dqput(struct dquot *dquot)
  422. {
  423. if (!dquot)
  424. return;
  425. if (!dquot->dq_count) {
  426. printk("VFS: dqput: trying to free free dquotn");
  427. printk("VFS: device %s, dquot of %s %dn",
  428. kdevname(dquot->dq_dev), quotatypes[dquot->dq_type],
  429. dquot->dq_id);
  430. return;
  431. }
  433. dqstats.drops++;
  434. we_slept:
  435. if (dquot->dq_count > 1) {
  436. /* We have more than one user... We can simply decrement use count */
  437. dquot->dq_count--;
  438. return;
  439. }
  440. if (dquot->dq_flags & DQ_MOD) {
  441. write_dquot(dquot);
  442. goto we_slept;
  443. }
  445. /* sanity check */
  446. if (!list_empty(&dquot->dq_free)) {
  447. printk(KERN_ERR "dqput: dquot already on free list??n");
  448. dquot->dq_count--; /* J.K. Just decrementing use count seems safer... */
  449. return;
  450. }
  451. dquot->dq_count--;
  452. /* If dquot is going to be invalidated invalidate_dquots() is going to free it so */
  453. if (!(dquot->dq_flags & DQ_INVAL))
  454. put_dquot_last(dquot); /* Place at end of LRU free queue */
  455. wake_up(&dquot->dq_wait_free);
  456. }
  458. static struct dquot *get_empty_dquot(void)
  459. {
  460. struct dquot *dquot;
  462. dquot = kmem_cache_alloc(dquot_cachep, SLAB_KERNEL);
  463. if(!dquot)
  464. return NODQUOT;
  466. memset((caddr_t)dquot, 0, sizeof(struct dquot));
  467. init_waitqueue_head(&dquot->dq_wait_free);
  468. init_waitqueue_head(&dquot->dq_wait_lock);
  469. INIT_LIST_HEAD(&dquot->dq_free);
  470. INIT_LIST_HEAD(&dquot->dq_inuse);
  471. INIT_LIST_HEAD(&dquot->dq_hash);
  472. dquot->dq_count = 1;
  473. /* all dquots go on the inuse_list */
  474. put_inuse(dquot);
  476. return dquot;
  477. }
  479. static struct dquot *dqget(struct super_block *sb, unsigned int id, short type)
  480. {
  481. unsigned int hashent = hashfn(sb->s_dev, id, type);
  482. struct dquot *dquot, *empty = NODQUOT;
  483. struct quota_mount_options *dqopt = sb_dqopt(sb);
  485. we_slept:
  486.         if (!is_enabled(dqopt, type)) {
  487. if (empty)
  488. dqput(empty);
  489.                 return NODQUOT;
  490. }
  492. if ((dquot = find_dquot(hashent, sb->s_dev, id, type)) == NODQUOT) {
  493. if (empty == NODQUOT) {
  494. if ((empty = get_empty_dquot()) == NODQUOT)
  495. schedule(); /* Try to wait for a moment... */
  496. goto we_slept;
  497. }
  498. dquot = empty;
  499.          dquot->dq_id = id;
  500.          dquot->dq_type = type;
  501.          dquot->dq_dev = sb->s_dev;
  502.          dquot->dq_sb = sb;
  503. /* hash it first so it can be found */
  504. insert_dquot_hash(dquot);
  505.          read_dquot(dquot);
  506. } else {
  507. if (!dquot->dq_count++)
  508. remove_free_dquot(dquot);
  509. dqstats.cache_hits++;
  510. wait_on_dquot(dquot);
  511. if (empty)
  512. dqput(empty);
  513. }
  515. if (!dquot->dq_sb) { /* Has somebody invalidated entry under us? */
  516. printk(KERN_ERR "VFS: dqget(): Quota invalidated in dqget()!n");
  517. dqput(dquot);
  518. return NODQUOT;
  519. }
  520. dquot->dq_referenced++;
  521. dqstats.lookups++;
  523. return dquot;
  524. }
  526. static struct dquot *dqduplicate(struct dquot *dquot)
  527. {
  528. if (dquot == NODQUOT)
  529. return NODQUOT;
  530. dquot->dq_count++;
  531. if (!dquot->dq_sb) {
  532. printk(KERN_ERR "VFS: dqduplicate(): Invalidated quota to be duplicated!n");
  533. dquot->dq_count--;
  534. return NODQUOT;
  535. }
  536. if (dquot->dq_flags & DQ_LOCKED)
  537. printk(KERN_ERR "VFS: dqduplicate(): Locked quota to be duplicated!n");
  538. dquot->dq_referenced++;
  539. dqstats.lookups++;
  540. return dquot;
  541. }
  543. static int dqinit_needed(struct inode *inode, short type)
  544. {
  545. int cnt;
  547. if (IS_NOQUOTA(inode))
  548. return 0;
  549. if (type != -1)
  550. return inode->i_dquot[type] == NODQUOT;
  551. for (cnt = 0; cnt < MAXQUOTAS; cnt++)
  552. if (inode->i_dquot[cnt] == NODQUOT)
  553. return 1;
  554. return 0;
  555. }
  557. static void add_dquot_ref(struct super_block *sb, short type)
  558. {
  559. struct list_head *p;
  561. if (!sb->dq_op)
  562. return; /* nothing to do */
  564. restart:
  565. file_list_lock();
  566. for (p = sb->s_files.next; p != &sb->s_files; p = p->next) {
  567. struct file *filp = list_entry(p, struct file, f_list);
  568. struct inode *inode = filp->f_dentry->d_inode;
  569. if (filp->f_mode & FMODE_WRITE && dqinit_needed(inode, type)) {
  570. struct vfsmount *mnt = mntget(filp->f_vfsmnt);
  571. struct dentry *dentry = dget(filp->f_dentry);
  572. file_list_unlock();
  573. sb->dq_op->initialize(inode, type);
  574. dput(dentry);
  575. mntput(mnt);
  576. /* As we may have blocked we had better restart... */
  577. goto restart;
  578. }
  579. }
  580. file_list_unlock();
  581. }
  583. /* Return 0 if dqput() won't block (note that 1 doesn't necessarily mean blocking) */
  584. static inline int dqput_blocks(struct dquot *dquot)
  585. {
  586. if (dquot->dq_count == 1)
  587. return 1;
  588. return 0;
  589. }
  591. /* Remove references to dquots from inode - add dquot to list for freeing if needed */
  592. int remove_inode_dquot_ref(struct inode *inode, short type, struct list_head *tofree_head)
  593. {
  594. struct dquot *dquot = inode->i_dquot[type];
  595. int cnt;
  597. inode->i_dquot[type] = NODQUOT;
  598. /* any other quota in use? */
  599. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  600. if (inode->i_dquot[cnt] != NODQUOT)
  601. goto put_it;
  602. }
  603. inode->i_flags &= ~S_QUOTA;
  604. put_it:
  605. if (dquot != NODQUOT) {
  606. if (dqput_blocks(dquot)) {
  607. if (dquot->dq_count != 1)
  608. printk(KERN_WARNING "VFS: Adding dquot with dq_count %d to dispose list.n", dquot->dq_count);
  609. list_add(&dquot->dq_free, tofree_head); /* As dquot must have currently users it can't be on the free list... */
  610. return 1;
  611. }
  612. else
  613. dqput(dquot);   /* We have guaranteed we won't block */
  614. }
  615. return 0;
  616. }
  618. /* Free list of dquots - called from inode.c */
  619. void put_dquot_list(struct list_head *tofree_head)
  620. {
  621. struct list_head *act_head;
  622. struct dquot *dquot;
  624. lock_kernel();
  625. act_head = tofree_head->next;
  626. /* So now we have dquots on the list... Just free them */
  627. while (act_head != tofree_head) {
  628. dquot = list_entry(act_head, struct dquot, dq_free);
  629. act_head = act_head->next;
  630. list_del(&dquot->dq_free); /* Remove dquot from the list so we won't have problems... */
  631. INIT_LIST_HEAD(&dquot->dq_free);
  632. dqput(dquot);
  633. }
  634. unlock_kernel();
  635. }
  637. static inline void dquot_incr_inodes(struct dquot *dquot, unsigned long number)
  638. {
  639. dquot->dq_curinodes += number;
  640. dquot->dq_flags |= DQ_MOD;
  641. }
  643. static inline void dquot_incr_blocks(struct dquot *dquot, unsigned long number)
  644. {
  645. dquot->dq_curblocks += number;
  646. dquot->dq_flags |= DQ_MOD;
  647. }
  649. static inline void dquot_decr_inodes(struct dquot *dquot, unsigned long number)
  650. {
  651. if (dquot->dq_curinodes > number)
  652. dquot->dq_curinodes -= number;
  653. else
  654. dquot->dq_curinodes = 0;
  655. if (dquot->dq_curinodes < dquot->dq_isoftlimit)
  656. dquot->dq_itime = (time_t) 0;
  657. dquot->dq_flags &= ~DQ_INODES;
  658. dquot->dq_flags |= DQ_MOD;
  659. }
  661. static inline void dquot_decr_blocks(struct dquot *dquot, unsigned long number)
  662. {
  663. if (dquot->dq_curblocks > number)
  664. dquot->dq_curblocks -= number;
  665. else
  666. dquot->dq_curblocks = 0;
  667. if (dquot->dq_curblocks < dquot->dq_bsoftlimit)
  668. dquot->dq_btime = (time_t) 0;
  669. dquot->dq_flags &= ~DQ_BLKS;
  670. dquot->dq_flags |= DQ_MOD;
  671. }
  673. static inline int need_print_warning(struct dquot *dquot, int flag)
  674. {
  675. switch (dquot->dq_type) {
  676. case USRQUOTA:
  677. return current->fsuid == dquot->dq_id && !(dquot->dq_flags & flag);
  678. case GRPQUOTA:
  679. return in_group_p(dquot->dq_id) && !(dquot->dq_flags & flag);
  680. }
  681. return 0;
  682. }
  684. /* Values of warnings */
  685. #define NOWARN 0
  686. #define IHARDWARN 1
  687. #define ISOFTLONGWARN 2
  688. #define ISOFTWARN 3
  689. #define BHARDWARN 4
  690. #define BSOFTLONGWARN 5
  691. #define BSOFTWARN 6
  693. /* Print warning to user which exceeded quota */
  694. static void print_warning(struct dquot *dquot, const char warntype)
  695. {
  696. char *msg = NULL;
  697. int flag = (warntype == BHARDWARN || warntype == BSOFTLONGWARN) ? DQ_BLKS :
  698.   ((warntype == IHARDWARN || warntype == ISOFTLONGWARN) ? DQ_INODES : 0);
  700. if (!need_print_warning(dquot, flag))
  701. return;
  702. dquot->dq_flags |= flag;
  703. tty_write_message(current->tty, (char *)bdevname(dquot->dq_sb->s_dev));
  704. if (warntype == ISOFTWARN || warntype == BSOFTWARN)
  705. tty_write_message(current->tty, ": warning, ");
  706. else
  707. tty_write_message(current->tty, ": write failed, ");
  708. tty_write_message(current->tty, quotatypes[dquot->dq_type]);
  709. switch (warntype) {
  710. case IHARDWARN:
  711. msg = " file limit reached.n";
  712. break;
  713. case ISOFTLONGWARN:
  714. msg = " file quota exceeded too long.n";
  715. break;
  716. case ISOFTWARN:
  717. msg = " file quota exceeded.n";
  718. break;
  719. case BHARDWARN:
  720. msg = " block limit reached.n";
  721. break;
  722. case BSOFTLONGWARN:
  723. msg = " block quota exceeded too long.n";
  724. break;
  725. case BSOFTWARN:
  726. msg = " block quota exceeded.n";
  727. break;
  728. }
  729. tty_write_message(current->tty, msg);
  730. }
  732. static inline void flush_warnings(struct dquot **dquots, char *warntype)
  733. {
  734. int i;
  736. for (i = 0; i < MAXQUOTAS; i++)
  737. if (dquots[i] != NODQUOT && warntype[i] != NOWARN)
  738. print_warning(dquots[i], warntype[i]);
  739. }
  741. static inline char ignore_hardlimit(struct dquot *dquot)
  742. {
  743. return capable(CAP_SYS_RESOURCE) && !dquot->dq_sb->s_dquot.rsquash[dquot->dq_type];
  744. }
  746. static int check_idq(struct dquot *dquot, ulong inodes, char *warntype)
  747. {
  748. *warntype = NOWARN;
  749. if (inodes <= 0 || dquot->dq_flags & DQ_FAKE)
  750. return QUOTA_OK;
  752. if (dquot->dq_ihardlimit &&
  753.    (dquot->dq_curinodes + inodes) > dquot->dq_ihardlimit &&
  754.             !ignore_hardlimit(dquot)) {
  755. *warntype = IHARDWARN;
  756. return NO_QUOTA;
  757. }
  759. if (dquot->dq_isoftlimit &&
  760.    (dquot->dq_curinodes + inodes) > dquot->dq_isoftlimit &&
  761.     dquot->dq_itime && CURRENT_TIME >= dquot->dq_itime &&
  762.             !ignore_hardlimit(dquot)) {
  763. *warntype = ISOFTLONGWARN;
  764. return NO_QUOTA;
  765. }
  767. if (dquot->dq_isoftlimit &&
  768.    (dquot->dq_curinodes + inodes) > dquot->dq_isoftlimit &&
  769.     dquot->dq_itime == 0) {
  770. *warntype = ISOFTWARN;
  771. dquot->dq_itime = CURRENT_TIME + dquot->dq_sb->s_dquot.inode_expire[dquot->dq_type];
  772. }
  774. return QUOTA_OK;
  775. }
  777. static int check_bdq(struct dquot *dquot, ulong blocks, char prealloc, char *warntype)
  778. {
  779. *warntype = 0;
  780. if (blocks <= 0 || dquot->dq_flags & DQ_FAKE)
  781. return QUOTA_OK;
  783. if (dquot->dq_bhardlimit &&
  784.    (dquot->dq_curblocks + blocks) > dquot->dq_bhardlimit &&
  785.             !ignore_hardlimit(dquot)) {
  786. if (!prealloc)
  787. *warntype = BHARDWARN;
  788. return NO_QUOTA;
  789. }
  791. if (dquot->dq_bsoftlimit &&
  792.    (dquot->dq_curblocks + blocks) > dquot->dq_bsoftlimit &&
  793.     dquot->dq_btime && CURRENT_TIME >= dquot->dq_btime &&
  794.             !ignore_hardlimit(dquot)) {
  795. if (!prealloc)
  796. *warntype = BSOFTLONGWARN;
  797. return NO_QUOTA;
  798. }
  800. if (dquot->dq_bsoftlimit &&
  801.    (dquot->dq_curblocks + blocks) > dquot->dq_bsoftlimit &&
  802.     dquot->dq_btime == 0) {
  803. if (!prealloc) {
  804. *warntype = BSOFTWARN;
  805. dquot->dq_btime = CURRENT_TIME + dquot->dq_sb->s_dquot.block_expire[dquot->dq_type];
  806. }
  807. else
  808. /*
  809.  * We don't allow preallocation to exceed softlimit so exceeding will
  810.  * be always printed
  811.  */
  812. return NO_QUOTA;
  813. }
  815. return QUOTA_OK;
  816. }
  818. /*
  819.  * Initialize a dquot-struct with new quota info. This is used by the
  820.  * system call interface functions.
  821.  */ 
  822. static int set_dqblk(struct super_block *sb, int id, short type, int flags, struct dqblk *dqblk)
  823. {
  824. struct dquot *dquot;
  825. int error = -EFAULT;
  826. struct dqblk dq_dqblk;
  828. if (copy_from_user(&dq_dqblk, dqblk, sizeof(struct dqblk)))
  829. return error;
  831. if (sb && (dquot = dqget(sb, id, type)) != NODQUOT) {
  832. /* We can't block while changing quota structure... */
  833. if (id > 0 && ((flags & SET_QUOTA) || (flags & SET_QLIMIT))) {
  834. dquot->dq_bhardlimit = dq_dqblk.dqb_bhardlimit;
  835. dquot->dq_bsoftlimit = dq_dqblk.dqb_bsoftlimit;
  836. dquot->dq_ihardlimit = dq_dqblk.dqb_ihardlimit;
  837. dquot->dq_isoftlimit = dq_dqblk.dqb_isoftlimit;
  838. }
  840. if ((flags & SET_QUOTA) || (flags & SET_USE)) {
  841. if (dquot->dq_isoftlimit &&
  842.     dquot->dq_curinodes < dquot->dq_isoftlimit &&
  843.     dq_dqblk.dqb_curinodes >= dquot->dq_isoftlimit)
  844. dquot->dq_itime = CURRENT_TIME + dquot->dq_sb->s_dquot.inode_expire[type];
  845. dquot->dq_curinodes = dq_dqblk.dqb_curinodes;
  846. if (dquot->dq_curinodes < dquot->dq_isoftlimit)
  847. dquot->dq_flags &= ~DQ_INODES;
  848. if (dquot->dq_bsoftlimit &&
  849.     dquot->dq_curblocks < dquot->dq_bsoftlimit &&
  850.     dq_dqblk.dqb_curblocks >= dquot->dq_bsoftlimit)
  851. dquot->dq_btime = CURRENT_TIME + dquot->dq_sb->s_dquot.block_expire[type];
  852. dquot->dq_curblocks = dq_dqblk.dqb_curblocks;
  853. if (dquot->dq_curblocks < dquot->dq_bsoftlimit)
  854. dquot->dq_flags &= ~DQ_BLKS;
  855. }
  857. if (id == 0) {
  858. dquot->dq_sb->s_dquot.block_expire[type] = dquot->dq_btime = dq_dqblk.dqb_btime;
  859. dquot->dq_sb->s_dquot.inode_expire[type] = dquot->dq_itime = dq_dqblk.dqb_itime;
  860. }
  862. if (dq_dqblk.dqb_bhardlimit == 0 && dq_dqblk.dqb_bsoftlimit == 0 &&
  863.     dq_dqblk.dqb_ihardlimit == 0 && dq_dqblk.dqb_isoftlimit == 0)
  864. dquot->dq_flags |= DQ_FAKE;
  865. else
  866. dquot->dq_flags &= ~DQ_FAKE;
  868. dquot->dq_flags |= DQ_MOD;
  869. dqput(dquot);
  870. }
  871. return 0;
  872. }
  874. static int get_quota(struct super_block *sb, int id, short type, struct dqblk *dqblk)
  875. {
  876. struct dquot *dquot;
  877. struct dqblk data;
  878. int error = -ESRCH;
  880. if (!sb || !sb_has_quota_enabled(sb, type))
  881. goto out;
  882. dquot = dqget(sb, id, type);
  883. if (dquot == NODQUOT)
  884. goto out;
  886. memcpy(&data, &dquot->dq_dqb, sizeof(struct dqblk));        /* We copy data to preserve them from changing */
  887. dqput(dquot);
  888. error = -EFAULT;
  889. if (dqblk && !copy_to_user(dqblk, &data, sizeof(struct dqblk)))
  890. error = 0;
  891. out:
  892. return error;
  893. }
  895. static int get_stats(caddr_t addr)
  896. {
  897. int error = -EFAULT;
  898. struct dqstats stats;
  900. dqstats.allocated_dquots = nr_dquots;
  901. dqstats.free_dquots = nr_free_dquots;
  903. /* make a copy, in case we page-fault in user space */
  904. memcpy(&stats, &dqstats, sizeof(struct dqstats));
  905. if (!copy_to_user(addr, &stats, sizeof(struct dqstats)))
  906. error = 0;
  907. return error;
  908. }
  910. static int quota_root_squash(struct super_block *sb, short type, int *addr)
  911. {
  912. int new_value, error;
  914. if (!sb)
  915. return(-ENODEV);
  917. error = -EFAULT;
  918. if (!copy_from_user(&new_value, addr, sizeof(int))) {
  919. sb_dqopt(sb)->rsquash[type] = new_value;
  920. error = 0;
  921. }
  922. return error;
  923. }
  925. #if 0 /* We are not going to support filesystems without i_blocks... */
  926. /*
  927.  * This is a simple algorithm that calculates the size of a file in blocks.
  928.  * This is only used on filesystems that do not have an i_blocks count.
  929.  */
  930. static u_long isize_to_blocks(loff_t isize, size_t blksize_bits)
  931. {
  932. u_long blocks;
  933. u_long indirect;
  935. if (!blksize_bits)
  936. blksize_bits = BLOCK_SIZE_BITS;
  937. blocks = (isize >> blksize_bits) + ((isize & ~((1 << blksize_bits)-1)) ? 1 : 0);
  938. if (blocks > 10) {
  939. indirect = ((blocks - 11) >> 8) + 1; /* single indirect blocks */
  940. if (blocks > (10 + 256)) {
  941. indirect += ((blocks - 267) >> 16) + 1; /* double indirect blocks */
  942. if (blocks > (10 + 256 + (256 << 8)))
  943. indirect++; /* triple indirect blocks */
  944. }
  945. blocks += indirect;
  946. }
  947. return blocks;
  948. }
  949. #endif
  951. /*
  952.  * Externally referenced functions through dquot_operations in inode.
  953.  *
  954.  * Note: this is a blocking operation.
  955.  */
  956. void dquot_initialize(struct inode *inode, short type)
  957. {
  958. struct dquot *dquot[MAXQUOTAS];
  959. unsigned int id = 0;
  960. short cnt;
  962. if (IS_NOQUOTA(inode))
  963. return;
  964. /* Build list of quotas to initialize... We can block here */
  965. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  966. dquot[cnt] = NODQUOT;
  967. if (type != -1 && cnt != type)
  968. continue;
  969. if (!sb_has_quota_enabled(inode->i_sb, cnt))
  970. continue;
  971. if (inode->i_dquot[cnt] == NODQUOT) {
  972. switch (cnt) {
  973. case USRQUOTA:
  974. id = inode->i_uid;
  975. break;
  976. case GRPQUOTA:
  977. id = inode->i_gid;
  978. break;
  979. }
  980. dquot[cnt] = dqget(inode->i_sb, id, cnt);
  981. }
  982. }
  983. /* NOBLOCK START: Here we shouldn't block */
  984. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  985. if (dquot[cnt] == NODQUOT || !sb_has_quota_enabled(inode->i_sb, cnt) || inode->i_dquot[cnt] != NODQUOT)
  986. continue;
  987. inode->i_dquot[cnt] = dquot[cnt];
  988. dquot[cnt] = NODQUOT;
  989. inode->i_flags |= S_QUOTA;
  990. }
  991. /* NOBLOCK END */
  992. /* Put quotas which we didn't use */
  993. for (cnt = 0; cnt < MAXQUOTAS; cnt++)
  994. if (dquot[cnt] != NODQUOT)
  995. dqput(dquot[cnt]);
  996. }
  998. /*
  999.  * Release all quota for the specified inode.
  1000.  *
  1001.  * Note: this is a blocking operation.
  1002.  */
  1003. void dquot_drop(struct inode *inode)
  1004. {
  1005. struct dquot *dquot;
  1006. short cnt;
  1008. inode->i_flags &= ~S_QUOTA;
  1009. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1010. if (inode->i_dquot[cnt] == NODQUOT)
  1011. continue;
  1012. dquot = inode->i_dquot[cnt];
  1013. inode->i_dquot[cnt] = NODQUOT;
  1014. dqput(dquot);
  1015. }
  1016. }
  1018. /*
  1019.  * This operation can block, but only after everything is updated
  1020.  */
  1021. int dquot_alloc_block(struct inode *inode, unsigned long number, char warn)
  1022. {
  1023. int cnt, ret = NO_QUOTA;
  1024. struct dquot *dquot[MAXQUOTAS];
  1025. char warntype[MAXQUOTAS];
  1027. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1028. dquot[cnt] = NODQUOT;
  1029. warntype[cnt] = NOWARN;
  1030. }
  1031. /* NOBLOCK Start */
  1032. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1033. dquot[cnt] = dqduplicate(inode->i_dquot[cnt]);
  1034. if (dquot[cnt] == NODQUOT)
  1035. continue;
  1036. if (check_bdq(dquot[cnt], number, warn, warntype+cnt) == NO_QUOTA)
  1037. goto warn_put_all;
  1038. }
  1039. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1040. if (dquot[cnt] == NODQUOT)
  1041. continue;
  1042. dquot_incr_blocks(dquot[cnt], number);
  1043. }
  1044. inode->i_blocks += number << (BLOCK_SIZE_BITS - 9);
  1045. /* NOBLOCK End */
  1046. ret = QUOTA_OK;
  1047. warn_put_all:
  1048. flush_warnings(dquot, warntype);
  1049. for (cnt = 0; cnt < MAXQUOTAS; cnt++)
  1050. if (dquot[cnt] != NODQUOT)
  1051. dqput(dquot[cnt]);
  1052. return ret;
  1053. }
  1055. /*
  1056.  * This operation can block, but only after everything is updated
  1057.  */
  1058. int dquot_alloc_inode(const struct inode *inode, unsigned long number)
  1059. {
  1060. int cnt, ret = NO_QUOTA;
  1061. struct dquot *dquot[MAXQUOTAS];
  1062. char warntype[MAXQUOTAS];
  1064. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1065. dquot[cnt] = NODQUOT;
  1066. warntype[cnt] = NOWARN;
  1067. }
  1068. /* NOBLOCK Start */
  1069. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1070. dquot[cnt] = dqduplicate(inode -> i_dquot[cnt]);
  1071. if (dquot[cnt] == NODQUOT)
  1072. continue;
  1073. if (check_idq(dquot[cnt], number, warntype+cnt) == NO_QUOTA)
  1074. goto warn_put_all;
  1075. }
  1077. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1078. if (dquot[cnt] == NODQUOT)
  1079. continue;
  1080. dquot_incr_inodes(dquot[cnt], number);
  1081. }
  1082. /* NOBLOCK End */
  1083. ret = QUOTA_OK;
  1084. warn_put_all:
  1085. flush_warnings(dquot, warntype);
  1086. for (cnt = 0; cnt < MAXQUOTAS; cnt++)
  1087. if (dquot[cnt] != NODQUOT)
  1088. dqput(dquot[cnt]);
  1089. return ret;
  1090. }
  1092. /*
  1093.  * This is a non-blocking operation.
  1094.  */
  1095. void dquot_free_block(struct inode *inode, unsigned long number)
  1096. {
  1097. unsigned short cnt;
  1098. struct dquot *dquot;
  1100. /* NOBLOCK Start */
  1101. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1102. dquot = dqduplicate(inode->i_dquot[cnt]);
  1103. if (dquot == NODQUOT)
  1104. continue;
  1105. dquot_decr_blocks(dquot, number);
  1106. dqput(dquot);
  1107. }
  1108. inode->i_blocks -= number << (BLOCK_SIZE_BITS - 9);
  1109. /* NOBLOCK End */
  1110. }
  1112. /*
  1113.  * This is a non-blocking operation.
  1114.  */
  1115. void dquot_free_inode(const struct inode *inode, unsigned long number)
  1116. {
  1117. unsigned short cnt;
  1118. struct dquot *dquot;
  1120. /* NOBLOCK Start */
  1121. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1122. dquot = dqduplicate(inode->i_dquot[cnt]);
  1123. if (dquot == NODQUOT)
  1124. continue;
  1125. dquot_decr_inodes(dquot, number);
  1126. dqput(dquot);
  1127. }
  1128. /* NOBLOCK End */
  1129. }
  1131. /*
  1132.  * Transfer the number of inode and blocks from one diskquota to an other.
  1133.  *
  1134.  * This operation can block, but only after everything is updated
  1135.  */
  1136. int dquot_transfer(struct inode *inode, struct iattr *iattr)
  1137. {
  1138. unsigned long blocks;
  1139. struct dquot *transfer_from[MAXQUOTAS];
  1140. struct dquot *transfer_to[MAXQUOTAS];
  1141. int cnt, ret = NO_QUOTA, chuid = (iattr->ia_valid & ATTR_UID) && inode->i_uid != iattr->ia_uid,
  1142.     chgid = (iattr->ia_valid & ATTR_GID) && inode->i_gid != iattr->ia_gid;
  1143. char warntype[MAXQUOTAS];
  1145. /* Clear the arrays */
  1146. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1147. transfer_to[cnt] = transfer_from[cnt] = NODQUOT;
  1148. warntype[cnt] = NOWARN;
  1149. }
  1150. /* First build the transfer_to list - here we can block on reading of dquots... */
  1151. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1152. if (!sb_has_quota_enabled(inode->i_sb, cnt))
  1153. continue;
  1154. switch (cnt) {
  1155. case USRQUOTA:
  1156. if (!chuid)
  1157. continue;
  1158. transfer_to[cnt] = dqget(inode->i_sb, iattr->ia_uid, cnt);
  1159. break;
  1160. case GRPQUOTA:
  1161. if (!chgid)
  1162. continue;
  1163. transfer_to[cnt] = dqget(inode->i_sb, iattr->ia_gid, cnt);
  1164. break;
  1165. }
  1166. }
  1167. /* NOBLOCK START: From now on we shouldn't block */
  1168. blocks = (inode->i_blocks >> 1);
  1169. /* Build the transfer_from list and check the limits */
  1170. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1171. /* The second test can fail when quotaoff is in progress... */
  1172. if (transfer_to[cnt] == NODQUOT || !sb_has_quota_enabled(inode->i_sb, cnt))
  1173. continue;
  1174. transfer_from[cnt] = dqduplicate(inode->i_dquot[cnt]);
  1175. if (transfer_from[cnt] == NODQUOT) /* Can happen on quotafiles (quota isn't initialized on them)... */
  1176. continue;
  1177. if (check_idq(transfer_to[cnt], 1, warntype+cnt) == NO_QUOTA ||
  1178.     check_bdq(transfer_to[cnt], blocks, 0, warntype+cnt) == NO_QUOTA)
  1179. goto warn_put_all;
  1180. }
  1182. /*
  1183.  * Finally perform the needed transfer from transfer_from to transfer_to
  1184.  */
  1185. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1186. /*
  1187.  * Skip changes for same uid or gid or for non-existing quota-type.
  1188.  */
  1189. if (transfer_from[cnt] == NODQUOT || transfer_to[cnt] == NODQUOT)
  1190. continue;
  1192. dquot_decr_inodes(transfer_from[cnt], 1);
  1193. dquot_decr_blocks(transfer_from[cnt], blocks);
  1195. dquot_incr_inodes(transfer_to[cnt], 1);
  1196. dquot_incr_blocks(transfer_to[cnt], blocks);
  1198. if (inode->i_dquot[cnt] == NODQUOT)
  1199. BUG();
  1200. inode->i_dquot[cnt] = transfer_to[cnt];
  1201. /*
  1202.  * We've got to release transfer_from[] twice - once for dquot_transfer() and
  1203.  * once for inode. We don't want to release transfer_to[] as it's now placed in inode
  1204.  */
  1205. transfer_to[cnt] = transfer_from[cnt];
  1206. }
  1207. /* NOBLOCK END. From now on we can block as we wish */
  1208. ret = QUOTA_OK;
  1209. warn_put_all:
  1210. flush_warnings(transfer_to, warntype);
  1211. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1212. if (transfer_to[cnt] != NODQUOT)
  1213. dqput(transfer_to[cnt]);
  1214. if (transfer_from[cnt] != NODQUOT)
  1215. dqput(transfer_from[cnt]);
  1216. }
  1217. return ret;
  1218. }
  1220. static int __init dquot_init(void)
  1221. {
  1222. int i;
  1224. for (i = 0; i < NR_DQHASH; i++)
  1225. INIT_LIST_HEAD(dquot_hash + i);
  1226. printk(KERN_NOTICE "VFS: Diskquotas version %s initializedn", __DQUOT_VERSION__);
  1227. return 0;
  1228. }
  1229. __initcall(dquot_init);
  1231. /*
  1232.  * Definitions of diskquota operations.
  1233.  */
  1234. struct dquot_operations dquot_operations = {
  1235. dquot_initialize, /* mandatory */
  1236. dquot_drop, /* mandatory */
  1237. dquot_alloc_block,
  1238. dquot_alloc_inode,
  1239. dquot_free_block,
  1240. dquot_free_inode,
  1241. dquot_transfer
  1242. };
  1244. static inline void set_enable_flags(struct quota_mount_options *dqopt, short type)
  1245. {
  1246. switch (type) {
  1247. case USRQUOTA:
  1248. dqopt->flags |= DQUOT_USR_ENABLED;
  1249. break;
  1250. case GRPQUOTA:
  1251. dqopt->flags |= DQUOT_GRP_ENABLED;
  1252. break;
  1253. }
  1254. }
  1256. static inline void reset_enable_flags(struct quota_mount_options *dqopt, short type)
  1257. {
  1258. switch (type) {
  1259. case USRQUOTA:
  1260. dqopt->flags &= ~DQUOT_USR_ENABLED;
  1261. break;
  1262. case GRPQUOTA:
  1263. dqopt->flags &= ~DQUOT_GRP_ENABLED;
  1264. break;
  1265. }
  1266. }
  1268. /* Function in inode.c - remove pointers to dquots in icache */
  1269. extern void remove_dquot_ref(struct super_block *, short);
  1271. /*
  1272.  * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
  1273.  */
  1274. int quota_off(struct super_block *sb, short type)
  1275. {
  1276. struct file *filp;
  1277. short cnt;
  1278. struct quota_mount_options *dqopt = sb_dqopt(sb);
  1280. lock_kernel();
  1281. if (!sb)
  1282. goto out;
  1284. /* We need to serialize quota_off() for device */
  1285. down(&dqopt->dqoff_sem);
  1286. for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
  1287. if (type != -1 && cnt != type)
  1288. continue;
  1289. if (!is_enabled(dqopt, cnt))
  1290. continue;
  1291. reset_enable_flags(dqopt, cnt);
  1293. /* Note: these are blocking operations */
  1294. remove_dquot_ref(sb, cnt);
  1295. invalidate_dquots(sb, cnt);
  1297. filp = dqopt->files[cnt];
  1298. dqopt->files[cnt] = (struct file *)NULL;
  1299. dqopt->inode_expire[cnt] = 0;
  1300. dqopt->block_expire[cnt] = 0;
  1301. fput(filp);
  1302. }
  1303. up(&dqopt->dqoff_sem);
  1304. out:
  1305. unlock_kernel();
  1306. return 0;
  1307. }
  1309. static inline int check_quotafile_size(loff_t size)
  1310. {
  1311. ulong blocks = size >> BLOCK_SIZE_BITS;
  1312. size_t off = size & (BLOCK_SIZE - 1);
  1314. return !(((blocks % sizeof(struct dqblk)) * BLOCK_SIZE + off % sizeof(struct dqblk)) % sizeof(struct dqblk));
  1315. }
  1317. static int quota_on(struct super_block *sb, short type, char *path)
  1318. {
  1319. struct file *f;
  1320. struct inode *inode;
  1321. struct dquot *dquot;
  1322. struct quota_mount_options *dqopt = sb_dqopt(sb);
  1323. char *tmp;
  1324. int error;
  1326. if (is_enabled(dqopt, type))
  1327. return -EBUSY;
  1329. down(&dqopt->dqoff_sem);
  1330. tmp = getname(path);
  1331. error = PTR_ERR(tmp);
  1332. if (IS_ERR(tmp))
  1333. goto out_lock;
  1335. f = filp_open(tmp, O_RDWR, 0600);
  1336. putname(tmp);
  1338. error = PTR_ERR(f);
  1339. if (IS_ERR(f))
  1340. goto out_lock;
  1341. error = -EIO;
  1342. if (!f->f_op || !f->f_op->read || !f->f_op->write)
  1343. goto out_f;
  1344. inode = f->f_dentry->d_inode;
  1345. error = -EACCES;
  1346. if (!S_ISREG(inode->i_mode))
  1347. goto out_f;
  1348. error = -EINVAL;
  1349. if (inode->i_size == 0 || !check_quotafile_size(inode->i_size))
  1350. goto out_f;
  1351. /* We don't want quota on quota files */
  1352. dquot_drop(inode);
  1353. inode->i_flags |= S_NOQUOTA;
  1355. dqopt->files[type] = f;
  1356. sb->dq_op = &dquot_operations;
  1357. set_enable_flags(dqopt, type);
  1359. dquot = dqget(sb, 0, type);
  1360. dqopt->inode_expire[type] = (dquot != NODQUOT) ? dquot->dq_itime : MAX_IQ_TIME;
  1361. dqopt->block_expire[type] = (dquot != NODQUOT) ? dquot->dq_btime : MAX_DQ_TIME;
  1362. dqput(dquot);
  1364. add_dquot_ref(sb, type);
  1366. up(&dqopt->dqoff_sem);
  1367. return 0;
  1369. out_f:
  1370. filp_close(f, NULL);
  1371. out_lock:
  1372. up(&dqopt->dqoff_sem);
  1374. return error; 
  1375. }
  1377. /*
  1378.  * This is the system call interface. This communicates with
  1379.  * the user-level programs. Currently this only supports diskquota
  1380.  * calls. Maybe we need to add the process quotas etc. in the future,
  1381.  * but we probably should use rlimits for that.
  1382.  */
  1383. asmlinkage long sys_quotactl(int cmd, const char *special, int id, caddr_t addr)
  1384. {
  1385. int cmds = 0, type = 0, flags = 0;
  1386. kdev_t dev;
  1387. struct super_block *sb = NULL;
  1388. int ret = -EINVAL;
  1390. lock_kernel();
  1391. cmds = cmd >> SUBCMDSHIFT;
  1392. type = cmd & SUBCMDMASK;
  1394. if ((u_int) type >= MAXQUOTAS)
  1395. goto out;
  1396. if (id & ~0xFFFF)
  1397. goto out;
  1399. ret = -EPERM;
  1400. switch (cmds) {
  1401. case Q_SYNC:
  1402. case Q_GETSTATS:
  1403. break;
  1404. case Q_GETQUOTA:
  1405. if (((type == USRQUOTA && current->euid != id) ||
  1406.      (type == GRPQUOTA && !in_egroup_p(id))) &&
  1407.     !capable(CAP_SYS_ADMIN))
  1408. goto out;
  1409. break;
  1410. default:
  1411. if (!capable(CAP_SYS_ADMIN))
  1412. goto out;
  1413. }
  1415. ret = -EINVAL;
  1416. dev = NODEV;
  1417. if (special != NULL || (cmds != Q_SYNC && cmds != Q_GETSTATS)) {
  1418. mode_t mode;
  1419. struct nameidata nd;
  1421. ret = user_path_walk(special, &nd);
  1422. if (ret)
  1423. goto out;
  1425. dev = nd.dentry->d_inode->i_rdev;
  1426. mode = nd.dentry->d_inode->i_mode;
  1427. path_release(&nd);
  1429. ret = -ENOTBLK;
  1430. if (!S_ISBLK(mode))
  1431. goto out;
  1432. ret = -ENODEV;
  1433. sb = get_super(dev);
  1434. if (!sb)
  1435. goto out;
  1436. }
  1438. ret = -EINVAL;
  1439. switch (cmds) {
  1440. case Q_QUOTAON:
  1441. ret = quota_on(sb, type, (char *) addr);
  1442. goto out;
  1443. case Q_QUOTAOFF:
  1444. ret = quota_off(sb, type);
  1445. goto out;
  1446. case Q_GETQUOTA:
  1447. ret = get_quota(sb, id, type, (struct dqblk *) addr);
  1448. goto out;
  1449. case Q_SETQUOTA:
  1450. flags |= SET_QUOTA;
  1451. break;
  1452. case Q_SETUSE:
  1453. flags |= SET_USE;
  1454. break;
  1455. case Q_SETQLIM:
  1456. flags |= SET_QLIMIT;
  1457. break;
  1458. case Q_SYNC:
  1459. ret = sync_dquots(dev, type);
  1460. goto out;
  1461. case Q_GETSTATS:
  1462. ret = get_stats(addr);
  1463. goto out;
  1464. case Q_RSQUASH:
  1465. ret = quota_root_squash(sb, type, (int *) addr);
  1466. goto out;
  1467. default:
  1468. goto out;
  1469. }
  1471. ret = -NODEV;
  1472. if (sb && sb_has_quota_enabled(sb, type))
  1473. ret = set_dqblk(sb, id, type, flags, (struct dqblk *) addr);
  1474. out:
  1475. if (sb)
  1476. drop_super(sb);
  1477. unlock_kernel();
  1478. return ret;
  1479. }