Return to quota.h CVS log

Up to [Net/2] / Net2 / ufs

Annotation of Net2/ufs/quota.h, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986 Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * This code is derived from software contributed to Berkeley by
        !             6:  * Robert Elz at The University of Melbourne.
        !             7:  *
        !             8:  * Redistribution and use in source and binary forms, with or without
        !             9:  * modification, are permitted provided that the following conditions
        !            10:  * are met:
        !            11:  * 1. Redistributions of source code must retain the above copyright
        !            12:  *    notice, this list of conditions and the following disclaimer.
        !            13:  * 2. Redistributions in binary form must reproduce the above copyright
        !            14:  *    notice, this list of conditions and the following disclaimer in the
        !            15:  *    documentation and/or other materials provided with the distribution.
        !            16:  * 3. All advertising materials mentioning features or use of this software
        !            17:  *    must display the following acknowledgement:
        !            18:  *     This product includes software developed by the University of
        !            19:  *     California, Berkeley and its contributors.
        !            20:  * 4. Neither the name of the University nor the names of its contributors
        !            21:  *    may be used to endorse or promote products derived from this software
        !            22:  *    without specific prior written permission.
        !            23:  *
        !            24:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            25:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            26:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            27:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            28:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            29:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            30:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            31:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            32:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            33:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            34:  * SUCH DAMAGE.
        !            35:  *
        !            36:  *     @(#)quota.h     7.9 (Berkeley) 2/22/91
        !            37:  */
        !            38: 
        !            39: #ifndef _QUOTA_
        !            40: #define _QUOTA_
        !            41: 
        !            42: /*
        !            43:  * Definitions for disk quotas imposed on the average user
        !            44:  * (big brother finally hits UNIX).
        !            45:  *
        !            46:  * The following constants define the amount of time given a user
        !            47:  * before the soft limits are treated as hard limits (usually resulting
        !            48:  * in an allocation failure). The timer is started when the user crosses
        !            49:  * their soft limit, it is reset when they go below their soft limit.
        !            50:  */
        !            51: #define        MAX_IQ_TIME     (7*24*60*60)    /* 1 week */
        !            52: #define        MAX_DQ_TIME     (7*24*60*60)    /* 1 week */
        !            53: 
        !            54: /*
        !            55:  * The following constants define the usage of the quota file array
        !            56:  * in the ufsmount structure and dquot array in the inode structure.
        !            57:  * The semantics of the elements of these arrays are defined in the
        !            58:  * routine getinoquota; the remainder of the quota code treats them
        !            59:  * generically and need not be inspected when changing the size of
        !            60:  * the array.
        !            61:  */
        !            62: #define        MAXQUOTAS       2
        !            63: #define        USRQUOTA        0       /* element used for user quotas */
        !            64: #define        GRPQUOTA        1       /* element used for group quotas */
        !            65: 
        !            66: /*
        !            67:  * Definitions for the default names of the quotas files.
        !            68:  */
        !            69: #define INITQFNAMES { \
        !            70:        "user",         /* USRQUOTA */ \
        !            71:        "group",        /* GRPQUOTA */ \
        !            72:        "undefined", \
        !            73: };
        !            74: #define QUOTAFILENAME "quota"
        !            75: #define QUOTAGROUP "operator"
        !            76: 
        !            77: /*
        !            78:  * Command definitions for the 'quotactl' system call.
        !            79:  * The commands are broken into a main command defined below
        !            80:  * and a subcommand that is used to convey the type of
        !            81:  * quota that is being manipulated (see above).
        !            82:  */
        !            83: #define SUBCMDMASK     0x00ff
        !            84: #define SUBCMDSHIFT    8
        !            85: #define        QCMD(cmd, type) (((cmd) << SUBCMDSHIFT) | ((type) & SUBCMDMASK))
        !            86: 
        !            87: #define        Q_QUOTAON       0x0100  /* enable quotas */
        !            88: #define        Q_QUOTAOFF      0x0200  /* disable quotas */
        !            89: #define        Q_GETQUOTA      0x0300  /* get limits and usage */
        !            90: #define        Q_SETQUOTA      0x0400  /* set limits and usage */
        !            91: #define        Q_SETUSE        0x0500  /* set usage */
        !            92: #define        Q_SYNC          0x0600  /* sync disk copy of a filesystems quotas */
        !            93: 
        !            94: /*
        !            95:  * The following structure defines the format of the disk quota file
        !            96:  * (as it appears on disk) - the file is an array of these structures
        !            97:  * indexed by user or group number.  The setquota system call establishes
        !            98:  * the vnode for each quota file (a pointer is retained in the ufsmount
        !            99:  * structure).
        !           100:  */
        !           101: struct dqblk {
        !           102:        u_long  dqb_bhardlimit; /* absolute limit on disk blks alloc */
        !           103:        u_long  dqb_bsoftlimit; /* preferred limit on disk blks */
        !           104:        u_long  dqb_curblocks;  /* current block count */
        !           105:        u_long  dqb_ihardlimit; /* maximum # allocated inodes + 1 */
        !           106:        u_long  dqb_isoftlimit; /* preferred inode limit */
        !           107:        u_long  dqb_curinodes;  /* current # allocated inodes */
        !           108:        time_t  dqb_btime;      /* time limit for excessive disk use */
        !           109:        time_t  dqb_itime;      /* time limit for excessive files */
        !           110: };
        !           111: 
        !           112: #ifdef KERNEL
        !           113: /*
        !           114:  * The following structure records disk usage for a user or group on a
        !           115:  * filesystem. There is one allocated for each quota that exists on any
        !           116:  * filesystem for the current user or group. A cache is kept of recently
        !           117:  * used entries.
        !           118:  */
        !           119: struct dquot {
        !           120:        struct  dquot *dq_forw, *dq_back;/* MUST be first entry */
        !           121:        struct  dquot *dq_freef, **dq_freeb; /* free list */
        !           122:        short   dq_flags;               /* flags, see below */
        !           123:        short   dq_cnt;                 /* count of active references */
        !           124:        short   dq_spare;               /* unused spare padding */
        !           125:        short   dq_type;                /* quota type of this dquot */
        !           126:        u_long  dq_id;                  /* identifier this applies to */
        !           127:        struct  ufsmount *dq_ump;       /* filesystem that this is taken from */
        !           128:        struct  dqblk dq_dqb;           /* actual usage & quotas */
        !           129: };
        !           130: /*
        !           131:  * Flag values.
        !           132:  */
        !           133: #define        DQ_LOCK         0x01            /* this quota locked (no MODS) */
        !           134: #define        DQ_WANT         0x02            /* wakeup on unlock */
        !           135: #define        DQ_MOD          0x04            /* this quota modified since read */
        !           136: #define        DQ_FAKE         0x08            /* no limits here, just usage */
        !           137: #define        DQ_BLKS         0x10            /* has been warned about blk limit */
        !           138: #define        DQ_INODS        0x20            /* has been warned about inode limit */
        !           139: /*
        !           140:  * Shorthand notation.
        !           141:  */
        !           142: #define        dq_bhardlimit   dq_dqb.dqb_bhardlimit
        !           143: #define        dq_bsoftlimit   dq_dqb.dqb_bsoftlimit
        !           144: #define        dq_curblocks    dq_dqb.dqb_curblocks
        !           145: #define        dq_ihardlimit   dq_dqb.dqb_ihardlimit
        !           146: #define        dq_isoftlimit   dq_dqb.dqb_isoftlimit
        !           147: #define        dq_curinodes    dq_dqb.dqb_curinodes
        !           148: #define        dq_btime        dq_dqb.dqb_btime
        !           149: #define        dq_itime        dq_dqb.dqb_itime
        !           150: 
        !           151: /*
        !           152:  * If the system has never checked for a quota for this file,
        !           153:  * then it is set to NODQUOT. Once a write attempt is made
        !           154:  * the inode pointer is set to reference a dquot structure.
        !           155:  */
        !           156: #define        NODQUOT         ((struct dquot *) 0)
        !           157: 
        !           158: /*
        !           159:  * Flags to chkdq() and chkiq()
        !           160:  */
        !           161: #define        FORCE   0x01    /* force usage changes independent of limits */
        !           162: #define        CHOWN   0x02    /* (advisory) change initiated by chown */
        !           163: 
        !           164: /*
        !           165:  * Macros to avoid subroutine calls to trivial functions.
        !           166:  */
        !           167: #ifndef DIAGNOSTIC
        !           168: #define        DQREF(dq)       (dq)->dq_cnt++
        !           169: #else
        !           170: #define        DQREF(dq)       dqref(dq)
        !           171: #endif /* DIAGNOSTIC */
        !           172: 
        !           173: #else
        !           174: 
        !           175: #include <sys/cdefs.h>
        !           176: 
        !           177: __BEGIN_DECLS
        !           178: int    quotactl __P((const char *, int, int, void *));
        !           179: __END_DECLS
        !           180: 
        !           181: #endif /* KERNEL */
        !           182: #endif /* _QUOTA_ */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.