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