![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ufs_quota.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / ufs|
Return to ufs_quota.c CVS log | Up to [Net/2] / Net2 / ufs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1990 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: * @(#)ufs_quota.c 7.11 (Berkeley) 6/21/91 ! 37: */ ! 38: #include "param.h" ! 39: #include "kernel.h" ! 40: #include "systm.h" ! 41: #include "namei.h" ! 42: #include "malloc.h" ! 43: #include "file.h" ! 44: #include "proc.h" ! 45: #include "vnode.h" ! 46: #include "mount.h" ! 47: ! 48: #include "fs.h" ! 49: #include "quota.h" ! 50: #include "inode.h" ! 51: #include "ufsmount.h" ! 52: ! 53: /* ! 54: * Quota name to error message mapping. ! 55: */ ! 56: static char *quotatypes[] = INITQFNAMES; ! 57: ! 58: /* ! 59: * Set up the quotas for an inode. ! 60: * ! 61: * This routine completely defines the semantics of quotas. ! 62: * If other criterion want to be used to establish quotas, the ! 63: * MAXQUOTAS value in quotas.h should be increased, and the ! 64: * additional dquots set up here. ! 65: */ ! 66: getinoquota(ip) ! 67: register struct inode *ip; ! 68: { ! 69: struct ufsmount *ump; ! 70: struct vnode *vp = ITOV(ip); ! 71: int error; ! 72: ! 73: ump = VFSTOUFS(vp->v_mount); ! 74: /* ! 75: * Set up the user quota based on file uid. ! 76: * EINVAL means that quotas are not enabled. ! 77: */ ! 78: if (ip->i_dquot[USRQUOTA] == NODQUOT && ! 79: (error = ! 80: dqget(vp, ip->i_uid, ump, USRQUOTA, &ip->i_dquot[USRQUOTA])) && ! 81: error != EINVAL) ! 82: return (error); ! 83: /* ! 84: * Set up the group quota based on file gid. ! 85: * EINVAL means that quotas are not enabled. ! 86: */ ! 87: if (ip->i_dquot[GRPQUOTA] == NODQUOT && ! 88: (error = ! 89: dqget(vp, ip->i_gid, ump, GRPQUOTA, &ip->i_dquot[GRPQUOTA])) && ! 90: error != EINVAL) ! 91: return (error); ! 92: return (0); ! 93: } ! 94: ! 95: /* ! 96: * Update disk usage, and take corrective action. ! 97: */ ! 98: chkdq(ip, change, cred, flags) ! 99: register struct inode *ip; ! 100: long change; ! 101: struct ucred *cred; ! 102: int flags; ! 103: { ! 104: register struct dquot *dq; ! 105: register int i; ! 106: int ncurblocks, error; ! 107: ! 108: #ifdef DIAGNOSTIC ! 109: if ((flags & CHOWN) == 0) ! 110: chkdquot(ip); ! 111: #endif ! 112: if (change == 0) ! 113: return (0); ! 114: if (change < 0) { ! 115: for (i = 0; i < MAXQUOTAS; i++) { ! 116: if ((dq = ip->i_dquot[i]) == NODQUOT) ! 117: continue; ! 118: while (dq->dq_flags & DQ_LOCK) { ! 119: dq->dq_flags |= DQ_WANT; ! 120: sleep((caddr_t)dq, PINOD+1); ! 121: } ! 122: ncurblocks = dq->dq_curblocks + change; ! 123: if (ncurblocks >= 0) ! 124: dq->dq_curblocks = ncurblocks; ! 125: else ! 126: dq->dq_curblocks = 0; ! 127: dq->dq_flags &= ~DQ_BLKS; ! 128: dq->dq_flags |= DQ_MOD; ! 129: } ! 130: return (0); ! 131: } ! 132: if ((flags & FORCE) == 0 && cred->cr_uid != 0) { ! 133: for (i = 0; i < MAXQUOTAS; i++) { ! 134: if ((dq = ip->i_dquot[i]) == NODQUOT) ! 135: continue; ! 136: if (error = chkdqchg(ip, change, cred, i)) ! 137: return (error); ! 138: } ! 139: } ! 140: for (i = 0; i < MAXQUOTAS; i++) { ! 141: if ((dq = ip->i_dquot[i]) == NODQUOT) ! 142: continue; ! 143: while (dq->dq_flags & DQ_LOCK) { ! 144: dq->dq_flags |= DQ_WANT; ! 145: sleep((caddr_t)dq, PINOD+1); ! 146: } ! 147: dq->dq_curblocks += change; ! 148: dq->dq_flags |= DQ_MOD; ! 149: } ! 150: return (0); ! 151: } ! 152: ! 153: /* ! 154: * Check for a valid change to a users allocation. ! 155: * Issue an error message if appropriate. ! 156: */ ! 157: chkdqchg(ip, change, cred, type) ! 158: struct inode *ip; ! 159: long change; ! 160: struct ucred *cred; ! 161: int type; ! 162: { ! 163: register struct dquot *dq = ip->i_dquot[type]; ! 164: long ncurblocks = dq->dq_curblocks + change; ! 165: ! 166: /* ! 167: * If user would exceed their hard limit, disallow space allocation. ! 168: */ ! 169: if (ncurblocks >= dq->dq_bhardlimit && dq->dq_bhardlimit) { ! 170: if ((dq->dq_flags & DQ_BLKS) == 0 && ! 171: ip->i_uid == cred->cr_uid) { ! 172: uprintf("\n%s: write failed, %s disk limit reached\n", ! 173: ip->i_fs->fs_fsmnt, quotatypes[type]); ! 174: dq->dq_flags |= DQ_BLKS; ! 175: } ! 176: return (EDQUOT); ! 177: } ! 178: /* ! 179: * If user is over their soft limit for too long, disallow space ! 180: * allocation. Reset time limit as they cross their soft limit. ! 181: */ ! 182: if (ncurblocks >= dq->dq_bsoftlimit && dq->dq_bsoftlimit) { ! 183: if (dq->dq_curblocks < dq->dq_bsoftlimit) { ! 184: dq->dq_btime = time.tv_sec + ! 185: VFSTOUFS(ITOV(ip)->v_mount)->um_btime[type]; ! 186: if (ip->i_uid == cred->cr_uid) ! 187: uprintf("\n%s: warning, %s %s\n", ! 188: ip->i_fs->fs_fsmnt, quotatypes[type], ! 189: "disk quota exceeded"); ! 190: return (0); ! 191: } ! 192: if (time.tv_sec > dq->dq_btime) { ! 193: if ((dq->dq_flags & DQ_BLKS) == 0 && ! 194: ip->i_uid == cred->cr_uid) { ! 195: uprintf("\n%s: write failed, %s %s\n", ! 196: ip->i_fs->fs_fsmnt, quotatypes[type], ! 197: "disk quota exceeded too long"); ! 198: dq->dq_flags |= DQ_BLKS; ! 199: } ! 200: return (EDQUOT); ! 201: } ! 202: } ! 203: return (0); ! 204: } ! 205: ! 206: /* ! 207: * Check the inode limit, applying corrective action. ! 208: */ ! 209: chkiq(ip, change, cred, flags) ! 210: register struct inode *ip; ! 211: long change; ! 212: struct ucred *cred; ! 213: int flags; ! 214: { ! 215: register struct dquot *dq; ! 216: register int i; ! 217: int ncurinodes, error; ! 218: ! 219: #ifdef DIAGNOSTIC ! 220: if ((flags & CHOWN) == 0) ! 221: chkdquot(ip); ! 222: #endif ! 223: if (change == 0) ! 224: return (0); ! 225: if (change < 0) { ! 226: for (i = 0; i < MAXQUOTAS; i++) { ! 227: if ((dq = ip->i_dquot[i]) == NODQUOT) ! 228: continue; ! 229: while (dq->dq_flags & DQ_LOCK) { ! 230: dq->dq_flags |= DQ_WANT; ! 231: sleep((caddr_t)dq, PINOD+1); ! 232: } ! 233: ncurinodes = dq->dq_curinodes + change; ! 234: if (ncurinodes >= 0) ! 235: dq->dq_curinodes = ncurinodes; ! 236: else ! 237: dq->dq_curinodes = 0; ! 238: dq->dq_flags &= ~DQ_INODS; ! 239: dq->dq_flags |= DQ_MOD; ! 240: } ! 241: return (0); ! 242: } ! 243: if ((flags & FORCE) == 0 && cred->cr_uid != 0) { ! 244: for (i = 0; i < MAXQUOTAS; i++) { ! 245: if ((dq = ip->i_dquot[i]) == NODQUOT) ! 246: continue; ! 247: if (error = chkiqchg(ip, change, cred, i)) ! 248: return (error); ! 249: } ! 250: } ! 251: for (i = 0; i < MAXQUOTAS; i++) { ! 252: if ((dq = ip->i_dquot[i]) == NODQUOT) ! 253: continue; ! 254: while (dq->dq_flags & DQ_LOCK) { ! 255: dq->dq_flags |= DQ_WANT; ! 256: sleep((caddr_t)dq, PINOD+1); ! 257: } ! 258: dq->dq_curinodes += change; ! 259: dq->dq_flags |= DQ_MOD; ! 260: } ! 261: return (0); ! 262: } ! 263: ! 264: /* ! 265: * Check for a valid change to a users allocation. ! 266: * Issue an error message if appropriate. ! 267: */ ! 268: chkiqchg(ip, change, cred, type) ! 269: struct inode *ip; ! 270: long change; ! 271: struct ucred *cred; ! 272: int type; ! 273: { ! 274: register struct dquot *dq = ip->i_dquot[type]; ! 275: long ncurinodes = dq->dq_curinodes + change; ! 276: ! 277: /* ! 278: * If user would exceed their hard limit, disallow inode allocation. ! 279: */ ! 280: if (ncurinodes >= dq->dq_ihardlimit && dq->dq_ihardlimit) { ! 281: if ((dq->dq_flags & DQ_INODS) == 0 && ! 282: ip->i_uid == cred->cr_uid) { ! 283: uprintf("\n%s: write failed, %s inode limit reached\n", ! 284: ip->i_fs->fs_fsmnt, quotatypes[type]); ! 285: dq->dq_flags |= DQ_INODS; ! 286: } ! 287: return (EDQUOT); ! 288: } ! 289: /* ! 290: * If user is over their soft limit for too long, disallow inode ! 291: * allocation. Reset time limit as they cross their soft limit. ! 292: */ ! 293: if (ncurinodes >= dq->dq_isoftlimit && dq->dq_isoftlimit) { ! 294: if (dq->dq_curinodes < dq->dq_isoftlimit) { ! 295: dq->dq_itime = time.tv_sec + ! 296: VFSTOUFS(ITOV(ip)->v_mount)->um_itime[type]; ! 297: if (ip->i_uid == cred->cr_uid) ! 298: uprintf("\n%s: warning, %s %s\n", ! 299: ip->i_fs->fs_fsmnt, quotatypes[type], ! 300: "inode quota exceeded"); ! 301: return (0); ! 302: } ! 303: if (time.tv_sec > dq->dq_itime) { ! 304: if ((dq->dq_flags & DQ_INODS) == 0 && ! 305: ip->i_uid == cred->cr_uid) { ! 306: uprintf("\n%s: write failed, %s %s\n", ! 307: ip->i_fs->fs_fsmnt, quotatypes[type], ! 308: "inode quota exceeded too long"); ! 309: dq->dq_flags |= DQ_INODS; ! 310: } ! 311: return (EDQUOT); ! 312: } ! 313: } ! 314: return (0); ! 315: } ! 316: ! 317: #ifdef DIAGNOSTIC ! 318: /* ! 319: * On filesystems with quotas enabled, ! 320: * it is an error for a file to change size and not ! 321: * to have a dquot structure associated with it. ! 322: */ ! 323: chkdquot(ip) ! 324: register struct inode *ip; ! 325: { ! 326: struct ufsmount *ump = VFSTOUFS(ITOV(ip)->v_mount); ! 327: register int i; ! 328: ! 329: for (i = 0; i < MAXQUOTAS; i++) { ! 330: if (ump->um_quotas[i] == NULLVP || ! 331: (ump->um_qflags[i] & (QTF_OPENING|QTF_CLOSING))) ! 332: continue; ! 333: if (ip->i_dquot[i] == NODQUOT) { ! 334: vprint("chkdquot: missing dquot", ITOV(ip)); ! 335: panic("missing dquot"); ! 336: } ! 337: } ! 338: } ! 339: #endif /* DIAGNOSTIC */ ! 340: ! 341: /* ! 342: * Code to process quotactl commands. ! 343: */ ! 344: ! 345: /* ! 346: * Q_QUOTAON - set up a quota file for a particular file system. ! 347: */ ! 348: quotaon(p, mp, type, fname) ! 349: struct proc *p; ! 350: struct mount *mp; ! 351: register int type; ! 352: caddr_t fname; ! 353: { ! 354: register struct ufsmount *ump = VFSTOUFS(mp); ! 355: register struct vnode *vp, **vpp; ! 356: struct vnode *nextvp; ! 357: struct dquot *dq; ! 358: int error; ! 359: struct nameidata nd; ! 360: ! 361: vpp = &ump->um_quotas[type]; ! 362: nd.ni_segflg = UIO_USERSPACE; ! 363: nd.ni_dirp = fname; ! 364: if (error = vn_open(&nd, p, FREAD|FWRITE, 0)) ! 365: return (error); ! 366: vp = nd.ni_vp; ! 367: VOP_UNLOCK(vp); ! 368: if (vp->v_type != VREG) { ! 369: (void) vn_close(vp, FREAD|FWRITE, p->p_ucred, p); ! 370: return (EACCES); ! 371: } ! 372: if (vfs_busy(mp)) { ! 373: (void) vn_close(vp, FREAD|FWRITE, p->p_ucred, p); ! 374: return (EBUSY); ! 375: } ! 376: if (*vpp != vp) ! 377: quotaoff(p, mp, type); ! 378: ump->um_qflags[type] |= QTF_OPENING; ! 379: mp->mnt_flag |= MNT_QUOTA; ! 380: vp->v_flag |= VSYSTEM; ! 381: *vpp = vp; ! 382: /* ! 383: * Save the credential of the process that turned on quotas. ! 384: * Set up the time limits for this quota. ! 385: */ ! 386: crhold(p->p_ucred); ! 387: ump->um_cred[type] = p->p_ucred; ! 388: ump->um_btime[type] = MAX_DQ_TIME; ! 389: ump->um_itime[type] = MAX_IQ_TIME; ! 390: if (dqget(NULLVP, 0, ump, type, &dq) == 0) { ! 391: if (dq->dq_btime > 0) ! 392: ump->um_btime[type] = dq->dq_btime; ! 393: if (dq->dq_itime > 0) ! 394: ump->um_itime[type] = dq->dq_itime; ! 395: dqrele(NULLVP, dq); ! 396: } ! 397: /* ! 398: * Search vnodes associated with this mount point, ! 399: * adding references to quota file being opened. ! 400: * NB: only need to add dquot's for inodes being modified. ! 401: */ ! 402: again: ! 403: for (vp = mp->mnt_mounth; vp; vp = nextvp) { ! 404: nextvp = vp->v_mountf; ! 405: if (vp->v_writecount == 0) ! 406: continue; ! 407: if (vget(vp)) ! 408: goto again; ! 409: if (error = getinoquota(VTOI(vp))) { ! 410: vput(vp); ! 411: break; ! 412: } ! 413: vput(vp); ! 414: if (vp->v_mountf != nextvp || vp->v_mount != mp) ! 415: goto again; ! 416: } ! 417: ump->um_qflags[type] &= ~QTF_OPENING; ! 418: if (error) ! 419: quotaoff(p, mp, type); ! 420: vfs_unbusy(mp); ! 421: return (error); ! 422: } ! 423: ! 424: /* ! 425: * Q_QUOTAOFF - turn off disk quotas for a filesystem. ! 426: */ ! 427: quotaoff(p, mp, type) ! 428: struct proc *p; ! 429: struct mount *mp; ! 430: register int type; ! 431: { ! 432: register struct vnode *vp; ! 433: struct vnode *qvp, *nextvp; ! 434: struct ufsmount *ump = VFSTOUFS(mp); ! 435: register struct dquot *dq; ! 436: register struct inode *ip; ! 437: int error; ! 438: ! 439: if ((mp->mnt_flag & MNT_MPBUSY) == 0) ! 440: panic("quotaoff: not busy"); ! 441: if ((qvp = ump->um_quotas[type]) == NULLVP) ! 442: return (0); ! 443: ump->um_qflags[type] |= QTF_CLOSING; ! 444: /* ! 445: * Search vnodes associated with this mount point, ! 446: * deleting any references to quota file being closed. ! 447: */ ! 448: again: ! 449: for (vp = mp->mnt_mounth; vp; vp = nextvp) { ! 450: nextvp = vp->v_mountf; ! 451: if (vget(vp)) ! 452: goto again; ! 453: ip = VTOI(vp); ! 454: dq = ip->i_dquot[type]; ! 455: ip->i_dquot[type] = NODQUOT; ! 456: dqrele(vp, dq); ! 457: vput(vp); ! 458: if (vp->v_mountf != nextvp || vp->v_mount != mp) ! 459: goto again; ! 460: } ! 461: dqflush(qvp); ! 462: qvp->v_flag &= ~VSYSTEM; ! 463: error = vn_close(qvp, FREAD|FWRITE, p->p_ucred, p); ! 464: ump->um_quotas[type] = NULLVP; ! 465: crfree(ump->um_cred[type]); ! 466: ump->um_cred[type] = NOCRED; ! 467: ump->um_qflags[type] &= ~QTF_CLOSING; ! 468: for (type = 0; type < MAXQUOTAS; type++) ! 469: if (ump->um_quotas[type] != NULLVP) ! 470: break; ! 471: if (type == MAXQUOTAS) ! 472: mp->mnt_flag &= ~MNT_QUOTA; ! 473: return (error); ! 474: } ! 475: ! 476: /* ! 477: * Q_GETQUOTA - return current values in a dqblk structure. ! 478: */ ! 479: getquota(mp, id, type, addr) ! 480: struct mount *mp; ! 481: u_long id; ! 482: int type; ! 483: caddr_t addr; ! 484: { ! 485: struct dquot *dq; ! 486: int error; ! 487: ! 488: if (error = dqget(NULLVP, id, VFSTOUFS(mp), type, &dq)) ! 489: return (error); ! 490: error = copyout((caddr_t)&dq->dq_dqb, addr, sizeof (struct dqblk)); ! 491: dqrele(NULLVP, dq); ! 492: return (error); ! 493: } ! 494: ! 495: /* ! 496: * Q_SETQUOTA - assign an entire dqblk structure. ! 497: */ ! 498: setquota(mp, id, type, addr) ! 499: struct mount *mp; ! 500: u_long id; ! 501: int type; ! 502: caddr_t addr; ! 503: { ! 504: register struct dquot *dq; ! 505: struct dquot *ndq; ! 506: struct ufsmount *ump = VFSTOUFS(mp); ! 507: struct dqblk newlim; ! 508: int error; ! 509: ! 510: if (error = copyin(addr, (caddr_t)&newlim, sizeof (struct dqblk))) ! 511: return (error); ! 512: if (error = dqget(NULLVP, id, ump, type, &ndq)) ! 513: return (error); ! 514: dq = ndq; ! 515: while (dq->dq_flags & DQ_LOCK) { ! 516: dq->dq_flags |= DQ_WANT; ! 517: sleep((caddr_t)dq, PINOD+1); ! 518: } ! 519: /* ! 520: * Copy all but the current values. ! 521: * Reset time limit if previously had no soft limit or were ! 522: * under it, but now have a soft limit and are over it. ! 523: */ ! 524: newlim.dqb_curblocks = dq->dq_curblocks; ! 525: newlim.dqb_curinodes = dq->dq_curinodes; ! 526: if (dq->dq_id != 0) { ! 527: newlim.dqb_btime = dq->dq_btime; ! 528: newlim.dqb_itime = dq->dq_itime; ! 529: } ! 530: if (newlim.dqb_bsoftlimit && ! 531: dq->dq_curblocks >= newlim.dqb_bsoftlimit && ! 532: (dq->dq_bsoftlimit == 0 || dq->dq_curblocks < dq->dq_bsoftlimit)) ! 533: newlim.dqb_btime = time.tv_sec + ump->um_btime[type]; ! 534: if (newlim.dqb_isoftlimit && ! 535: dq->dq_curinodes >= newlim.dqb_isoftlimit && ! 536: (dq->dq_isoftlimit == 0 || dq->dq_curinodes < dq->dq_isoftlimit)) ! 537: newlim.dqb_itime = time.tv_sec + ump->um_itime[type]; ! 538: dq->dq_dqb = newlim; ! 539: if (dq->dq_curblocks < dq->dq_bsoftlimit) ! 540: dq->dq_flags &= ~DQ_BLKS; ! 541: if (dq->dq_curinodes < dq->dq_isoftlimit) ! 542: dq->dq_flags &= ~DQ_INODS; ! 543: if (dq->dq_isoftlimit == 0 && dq->dq_bsoftlimit == 0 && ! 544: dq->dq_ihardlimit == 0 && dq->dq_bhardlimit == 0) ! 545: dq->dq_flags |= DQ_FAKE; ! 546: else ! 547: dq->dq_flags &= ~DQ_FAKE; ! 548: dq->dq_flags |= DQ_MOD; ! 549: dqrele(NULLVP, dq); ! 550: return (0); ! 551: } ! 552: ! 553: /* ! 554: * Q_SETUSE - set current inode and block usage. ! 555: */ ! 556: setuse(mp, id, type, addr) ! 557: struct mount *mp; ! 558: u_long id; ! 559: int type; ! 560: caddr_t addr; ! 561: { ! 562: register struct dquot *dq; ! 563: struct ufsmount *ump = VFSTOUFS(mp); ! 564: struct dquot *ndq; ! 565: struct dqblk usage; ! 566: int error; ! 567: ! 568: if (error = copyin(addr, (caddr_t)&usage, sizeof (struct dqblk))) ! 569: return (error); ! 570: if (error = dqget(NULLVP, id, ump, type, &ndq)) ! 571: return (error); ! 572: dq = ndq; ! 573: while (dq->dq_flags & DQ_LOCK) { ! 574: dq->dq_flags |= DQ_WANT; ! 575: sleep((caddr_t)dq, PINOD+1); ! 576: } ! 577: /* ! 578: * Reset time limit if have a soft limit and were ! 579: * previously under it, but are now over it. ! 580: */ ! 581: if (dq->dq_bsoftlimit && dq->dq_curblocks < dq->dq_bsoftlimit && ! 582: usage.dqb_curblocks >= dq->dq_bsoftlimit) ! 583: dq->dq_btime = time.tv_sec + ump->um_btime[type]; ! 584: if (dq->dq_isoftlimit && dq->dq_curinodes < dq->dq_isoftlimit && ! 585: usage.dqb_curinodes >= dq->dq_isoftlimit) ! 586: dq->dq_itime = time.tv_sec + ump->um_itime[type]; ! 587: dq->dq_curblocks = usage.dqb_curblocks; ! 588: dq->dq_curinodes = usage.dqb_curinodes; ! 589: if (dq->dq_curblocks < dq->dq_bsoftlimit) ! 590: dq->dq_flags &= ~DQ_BLKS; ! 591: if (dq->dq_curinodes < dq->dq_isoftlimit) ! 592: dq->dq_flags &= ~DQ_INODS; ! 593: dq->dq_flags |= DQ_MOD; ! 594: dqrele(NULLVP, dq); ! 595: return (0); ! 596: } ! 597: ! 598: /* ! 599: * Q_SYNC - sync quota files to disk. ! 600: */ ! 601: qsync(mp) ! 602: struct mount *mp; ! 603: { ! 604: struct ufsmount *ump = VFSTOUFS(mp); ! 605: register struct vnode *vp, *nextvp; ! 606: register struct dquot *dq; ! 607: register int i; ! 608: ! 609: /* ! 610: * Check if the mount point has any quotas. ! 611: * If not, simply return. ! 612: */ ! 613: if ((mp->mnt_flag & MNT_MPBUSY) == 0) ! 614: panic("qsync: not busy"); ! 615: for (i = 0; i < MAXQUOTAS; i++) ! 616: if (ump->um_quotas[i] != NULLVP) ! 617: break; ! 618: if (i == MAXQUOTAS) ! 619: return (0); ! 620: /* ! 621: * Search vnodes associated with this mount point, ! 622: * synchronizing any modified dquot structures. ! 623: */ ! 624: again: ! 625: for (vp = mp->mnt_mounth; vp; vp = nextvp) { ! 626: nextvp = vp->v_mountf; ! 627: if (VOP_ISLOCKED(vp)) ! 628: continue; ! 629: if (vget(vp)) ! 630: goto again; ! 631: for (i = 0; i < MAXQUOTAS; i++) { ! 632: dq = VTOI(vp)->i_dquot[i]; ! 633: if (dq != NODQUOT && (dq->dq_flags & DQ_MOD)) ! 634: dqsync(vp, dq); ! 635: } ! 636: vput(vp); ! 637: if (vp->v_mountf != nextvp || vp->v_mount != mp) ! 638: goto again; ! 639: } ! 640: return (0); ! 641: } ! 642: ! 643: /* ! 644: * Code pertaining to management of the in-core dquot data structures. ! 645: */ ! 646: ! 647: /* ! 648: * Dquot cache - hash chain headers. ! 649: */ ! 650: union dqhead { ! 651: union dqhead *dqh_head[2]; ! 652: struct dquot *dqh_chain[2]; ! 653: }; ! 654: #define dqh_forw dqh_chain[0] ! 655: #define dqh_back dqh_chain[1] ! 656: ! 657: union dqhead *dqhashtbl; ! 658: long dqhash; ! 659: ! 660: /* ! 661: * Dquot free list. ! 662: */ ! 663: #define DQUOTINC 5 /* minimum free dquots desired */ ! 664: struct dquot *dqfreel, **dqback = &dqfreel; ! 665: long numdquot, desireddquot = DQUOTINC; ! 666: ! 667: /* ! 668: * Initialize the quota system. ! 669: */ ! 670: dqinit() ! 671: { ! 672: register union dqhead *dhp; ! 673: register long dqhashsize; ! 674: ! 675: dqhashsize = roundup((desiredvnodes + 1) * sizeof *dhp / 2, ! 676: NBPG * CLSIZE); ! 677: dqhashtbl = (union dqhead *)malloc(dqhashsize, M_DQUOT, M_WAITOK); ! 678: for (dqhash = 1; dqhash <= dqhashsize / sizeof *dhp; dqhash <<= 1) ! 679: /* void */; ! 680: dqhash = (dqhash >> 1) - 1; ! 681: for (dhp = &dqhashtbl[dqhash]; dhp >= dqhashtbl; dhp--) { ! 682: dhp->dqh_head[0] = dhp; ! 683: dhp->dqh_head[1] = dhp; ! 684: } ! 685: } ! 686: ! 687: /* ! 688: * Obtain a dquot structure for the specified identifier and quota file ! 689: * reading the information from the file if necessary. ! 690: */ ! 691: dqget(vp, id, ump, type, dqp) ! 692: struct vnode *vp; ! 693: u_long id; ! 694: register struct ufsmount *ump; ! 695: register int type; ! 696: struct dquot **dqp; ! 697: { ! 698: register struct dquot *dq; ! 699: register union dqhead *dh; ! 700: register struct dquot *dp; ! 701: register struct vnode *dqvp; ! 702: struct iovec aiov; ! 703: struct uio auio; ! 704: int error; ! 705: ! 706: dqvp = ump->um_quotas[type]; ! 707: if (dqvp == NULLVP || (ump->um_qflags[type] & QTF_CLOSING)) { ! 708: *dqp = NODQUOT; ! 709: return (EINVAL); ! 710: } ! 711: /* ! 712: * Check the cache first. ! 713: */ ! 714: dh = &dqhashtbl[((((int)(dqvp)) >> 8) + id) & dqhash]; ! 715: for (dq = dh->dqh_forw; dq != (struct dquot *)dh; dq = dq->dq_forw) { ! 716: if (dq->dq_id != id || ! 717: dq->dq_ump->um_quotas[dq->dq_type] != dqvp) ! 718: continue; ! 719: /* ! 720: * Cache hit with no references. Take ! 721: * the structure off the free list. ! 722: */ ! 723: if (dq->dq_cnt == 0) { ! 724: dp = dq->dq_freef; ! 725: if (dp != NODQUOT) ! 726: dp->dq_freeb = dq->dq_freeb; ! 727: else ! 728: dqback = dq->dq_freeb; ! 729: *dq->dq_freeb = dp; ! 730: } ! 731: DQREF(dq); ! 732: *dqp = dq; ! 733: return (0); ! 734: } ! 735: /* ! 736: * Not in cache, allocate a new one. ! 737: */ ! 738: if (dqfreel == NODQUOT && numdquot < MAXQUOTAS * desiredvnodes) ! 739: desireddquot += DQUOTINC; ! 740: if (numdquot < desireddquot) { ! 741: dq = (struct dquot *)malloc(sizeof *dq, M_DQUOT, M_WAITOK); ! 742: bzero((char *)dq, sizeof *dq); ! 743: numdquot++; ! 744: } else { ! 745: if ((dq = dqfreel) == NULL) { ! 746: tablefull("dquot"); ! 747: *dqp = NODQUOT; ! 748: return (EUSERS); ! 749: } ! 750: if (dq->dq_cnt || (dq->dq_flags & DQ_MOD)) ! 751: panic("free dquot isn't"); ! 752: if ((dp = dq->dq_freef) != NODQUOT) ! 753: dp->dq_freeb = &dqfreel; ! 754: else ! 755: dqback = &dqfreel; ! 756: dqfreel = dp; ! 757: dq->dq_freef = NULL; ! 758: dq->dq_freeb = NULL; ! 759: remque(dq); ! 760: } ! 761: /* ! 762: * Initialize the contents of the dquot structure. ! 763: */ ! 764: if (vp != dqvp) ! 765: VOP_LOCK(dqvp); ! 766: insque(dq, dh); ! 767: DQREF(dq); ! 768: dq->dq_flags = DQ_LOCK; ! 769: dq->dq_id = id; ! 770: dq->dq_ump = ump; ! 771: dq->dq_type = type; ! 772: auio.uio_iov = &aiov; ! 773: auio.uio_iovcnt = 1; ! 774: aiov.iov_base = (caddr_t)&dq->dq_dqb; ! 775: aiov.iov_len = sizeof (struct dqblk); ! 776: auio.uio_resid = sizeof (struct dqblk); ! 777: auio.uio_offset = (off_t)(id * sizeof (struct dqblk)); ! 778: auio.uio_segflg = UIO_SYSSPACE; ! 779: auio.uio_rw = UIO_READ; ! 780: auio.uio_procp = (struct proc *)0; ! 781: error = VOP_READ(dqvp, &auio, 0, ump->um_cred[type]); ! 782: if (auio.uio_resid == sizeof(struct dqblk) && error == 0) ! 783: bzero((caddr_t)&dq->dq_dqb, sizeof(struct dqblk)); ! 784: if (vp != dqvp) ! 785: VOP_UNLOCK(dqvp); ! 786: if (dq->dq_flags & DQ_WANT) ! 787: wakeup((caddr_t)dq); ! 788: dq->dq_flags = 0; ! 789: /* ! 790: * I/O error in reading quota file, release ! 791: * quota structure and reflect problem to caller. ! 792: */ ! 793: if (error) { ! 794: remque(dq); ! 795: dq->dq_forw = dq; /* on a private, unfindable hash list */ ! 796: dq->dq_back = dq; ! 797: dqrele(vp, dq); ! 798: *dqp = NODQUOT; ! 799: return (error); ! 800: } ! 801: /* ! 802: * Check for no limit to enforce. ! 803: * Initialize time values if necessary. ! 804: */ ! 805: if (dq->dq_isoftlimit == 0 && dq->dq_bsoftlimit == 0 && ! 806: dq->dq_ihardlimit == 0 && dq->dq_bhardlimit == 0) ! 807: dq->dq_flags |= DQ_FAKE; ! 808: if (dq->dq_id != 0) { ! 809: if (dq->dq_btime == 0) ! 810: dq->dq_btime = time.tv_sec + ump->um_btime[type]; ! 811: if (dq->dq_itime == 0) ! 812: dq->dq_itime = time.tv_sec + ump->um_itime[type]; ! 813: } ! 814: *dqp = dq; ! 815: return (0); ! 816: } ! 817: ! 818: /* ! 819: * Obtain a reference to a dquot. ! 820: */ ! 821: dqref(dq) ! 822: struct dquot *dq; ! 823: { ! 824: ! 825: dq->dq_cnt++; ! 826: } ! 827: ! 828: /* ! 829: * Release a reference to a dquot. ! 830: */ ! 831: dqrele(vp, dq) ! 832: struct vnode *vp; ! 833: register struct dquot *dq; ! 834: { ! 835: ! 836: if (dq == NODQUOT) ! 837: return; ! 838: if (dq->dq_cnt > 1) { ! 839: dq->dq_cnt--; ! 840: return; ! 841: } ! 842: if (dq->dq_flags & DQ_MOD) ! 843: (void) dqsync(vp, dq); ! 844: if (--dq->dq_cnt > 0) ! 845: return; ! 846: if (dqfreel != NODQUOT) { ! 847: *dqback = dq; ! 848: dq->dq_freeb = dqback; ! 849: } else { ! 850: dqfreel = dq; ! 851: dq->dq_freeb = &dqfreel; ! 852: } ! 853: dq->dq_freef = NODQUOT; ! 854: dqback = &dq->dq_freef; ! 855: } ! 856: ! 857: /* ! 858: * Update the disk quota in the quota file. ! 859: */ ! 860: dqsync(vp, dq) ! 861: struct vnode *vp; ! 862: register struct dquot *dq; ! 863: { ! 864: struct vnode *dqvp; ! 865: struct iovec aiov; ! 866: struct uio auio; ! 867: int error; ! 868: ! 869: if (dq == NODQUOT) ! 870: panic("dqsync: dquot"); ! 871: if ((dq->dq_flags & DQ_MOD) == 0) ! 872: return (0); ! 873: if ((dqvp = dq->dq_ump->um_quotas[dq->dq_type]) == NULLVP) ! 874: panic("dqsync: file"); ! 875: if (vp != dqvp) ! 876: VOP_LOCK(dqvp); ! 877: while (dq->dq_flags & DQ_LOCK) { ! 878: dq->dq_flags |= DQ_WANT; ! 879: sleep((caddr_t)dq, PINOD+2); ! 880: if ((dq->dq_flags & DQ_MOD) == 0) { ! 881: if (vp != dqvp) ! 882: VOP_UNLOCK(dqvp); ! 883: return (0); ! 884: } ! 885: } ! 886: dq->dq_flags |= DQ_LOCK; ! 887: auio.uio_iov = &aiov; ! 888: auio.uio_iovcnt = 1; ! 889: aiov.iov_base = (caddr_t)&dq->dq_dqb; ! 890: aiov.iov_len = sizeof (struct dqblk); ! 891: auio.uio_resid = sizeof (struct dqblk); ! 892: auio.uio_offset = (off_t)(dq->dq_id * sizeof (struct dqblk)); ! 893: auio.uio_segflg = UIO_SYSSPACE; ! 894: auio.uio_rw = UIO_WRITE; ! 895: auio.uio_procp = (struct proc *)0; ! 896: error = VOP_WRITE(dqvp, &auio, 0, dq->dq_ump->um_cred[dq->dq_type]); ! 897: if (auio.uio_resid && error == 0) ! 898: error = EIO; ! 899: if (dq->dq_flags & DQ_WANT) ! 900: wakeup((caddr_t)dq); ! 901: dq->dq_flags &= ~(DQ_MOD|DQ_LOCK|DQ_WANT); ! 902: if (vp != dqvp) ! 903: VOP_UNLOCK(dqvp); ! 904: return (error); ! 905: } ! 906: ! 907: /* ! 908: * Flush all entries from the cache for a particular vnode. ! 909: */ ! 910: dqflush(vp) ! 911: register struct vnode *vp; ! 912: { ! 913: register union dqhead *dh; ! 914: register struct dquot *dq, *nextdq; ! 915: ! 916: /* ! 917: * Move all dquot's that used to refer to this quota ! 918: * file off their hash chains (they will eventually ! 919: * fall off the head of the free list and be re-used). ! 920: */ ! 921: for (dh = &dqhashtbl[dqhash]; dh >= dqhashtbl; dh--) { ! 922: for (dq = dh->dqh_forw; dq != (struct dquot *)dh; dq = nextdq) { ! 923: nextdq = dq->dq_forw; ! 924: if (dq->dq_ump->um_quotas[dq->dq_type] != vp) ! 925: continue; ! 926: if (dq->dq_cnt) ! 927: panic("dqflush: stray dquot"); ! 928: remque(dq); ! 929: dq->dq_forw = dq; ! 930: dq->dq_back = dq; ! 931: dq->dq_ump = (struct ufsmount *)0; ! 932: } ! 933: } ! 934: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.