1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 /*
30 * University Copyright- Copyright (c) 1982, 1986, 1988
31 * The Regents of the University of California
32 * All Rights Reserved
33 *
34 * University Acknowledgment- Portions of this document are derived from
35 * software developed by the University of California, Berkeley, and its
36 * contributors.
37 */
38
39
40 #pragma ident "%Z%%M% %I% %E% SMI"
41
42 /*
43 * Code pertaining to management of the in-core data structures.
44 */
45 #include <sys/types.h>
46 #include <sys/t_lock.h>
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/signal.h>
50 #include <sys/errno.h>
51 #include <sys/user.h>
52 #include <sys/proc.h>
53 #include <sys/vfs.h>
54 #include <sys/vnode.h>
55 #include <sys/uio.h>
56 #include <sys/buf.h>
57 #include <sys/fs/ufs_fs.h>
58 #include <sys/fs/ufs_inode.h>
59 #include <sys/fs/ufs_quota.h>
60 #include <sys/cmn_err.h>
61 #include <sys/kmem.h>
62 #include <sys/debug.h>
63 #include <sys/file.h>
64 #include <sys/fs/ufs_panic.h>
65 #include <sys/var.h>
66
67
68 /*
69 * Dquot in core hash chain headers
70 */
71 struct dqhead dqhead[NDQHASH];
72
73 static kmutex_t dq_cachelock;
74 static kmutex_t dq_freelock;
75
76 krwlock_t dq_rwlock;
77
78 /*
79 * Dquot free list.
80 */
81 struct dquot dqfreelist;
82
83 #define dqinsheadfree(DQP) { \
84 mutex_enter(&dq_freelock); \
85 (DQP)->dq_freef = dqfreelist.dq_freef; \
86 (DQP)->dq_freeb = &dqfreelist; \
87 dqfreelist.dq_freef->dq_freeb = (DQP); \
88 dqfreelist.dq_freef = (DQP); \
89 mutex_exit(&dq_freelock); \
90 }
91
92 #define dqinstailfree(DQP) { \
93 mutex_enter(&dq_freelock); \
94 (DQP)->dq_freeb = dqfreelist.dq_freeb; \
95 (DQP)->dq_freef = &dqfreelist; \
96 dqfreelist.dq_freeb->dq_freef = (DQP); \
97 dqfreelist.dq_freeb = (DQP); \
98 mutex_exit(&dq_freelock); \
99 }
100
101 /* (clear pointers to make sure we don't use them; catch problems early) */
102 #define dqremfree(DQP) { \
103 (DQP)->dq_freeb->dq_freef = (DQP)->dq_freef; \
104 (DQP)->dq_freef->dq_freeb = (DQP)->dq_freeb; \
105 (DQP)->dq_freef = (DQP)->dq_freeb = NULL; \
106 }
107
108 typedef struct dquot *DQptr;
109
110 /*
111 * Initialize quota sub-system init lock.
112 */
113 void
qtinit()114 qtinit()
115 {
116 rw_init(&dq_rwlock, NULL, RW_DEFAULT, NULL);
117 }
118
119 /*
120 * qtinit2 allocated space for the quota structures. Only do this if
121 * if quotas are going to be used so that we can save the space if quotas
122 * aren't used.
123 */
124 void
qtinit2(void)125 qtinit2(void)
126 {
127 register struct dqhead *dhp;
128 register struct dquot *dqp;
129
130 ASSERT(RW_WRITE_HELD(&dq_rwlock));
131
132 if (ndquot == 0)
133 ndquot = ((maxusers * NMOUNT) / 4) + v.v_proc;
134
135 dquot = kmem_zalloc(ndquot * sizeof (struct dquot), KM_SLEEP);
136 dquotNDQUOT = dquot + ndquot;
137
138 /*
139 * Initialize the cache between the in-core structures
140 * and the per-file system quota files on disk.
141 */
142 for (dhp = &dqhead[0]; dhp < &dqhead[NDQHASH]; dhp++) {
143 dhp->dqh_forw = dhp->dqh_back = (DQptr)dhp;
144 }
145 dqfreelist.dq_freef = dqfreelist.dq_freeb = (DQptr)&dqfreelist;
146 for (dqp = dquot; dqp < dquotNDQUOT; dqp++) {
147 mutex_init(&dqp->dq_lock, NULL, MUTEX_DEFAULT, NULL);
148 dqp->dq_forw = dqp->dq_back = dqp;
149 dqinsheadfree(dqp);
150 }
151 }
152
153 /*
154 * Obtain the user's on-disk quota limit for file system specified.
155 * dqpp is returned locked.
156 */
157 int
getdiskquota(uid_t uid,struct ufsvfs * ufsvfsp,int force,struct dquot ** dqpp)158 getdiskquota(
159 uid_t uid,
160 struct ufsvfs *ufsvfsp,
161 int force, /* don't do enable checks */
162 struct dquot **dqpp) /* resulting dquot ptr */
163 {
164 struct dquot *dqp;
165 struct dqhead *dhp;
166 struct inode *qip;
167 int error;
168 extern struct cred *kcred;
169 daddr_t bn;
170 int contig;
171 int err;
172
173 ASSERT(RW_LOCK_HELD(&ufsvfsp->vfs_dqrwlock));
174
175 dhp = &dqhead[DQHASH(uid, ufsvfsp)];
176 loop:
177 /*
178 * Check for quotas enabled.
179 */
180 if ((ufsvfsp->vfs_qflags & MQ_ENABLED) == 0 && !force)
181 return (ESRCH);
182 qip = ufsvfsp->vfs_qinod;
183 if (!qip)
184 return (ufs_fault(ufsvfsp->vfs_root, "getdiskquota: NULL qip"));
185 /*
186 * Check the cache first.
187 */
188 mutex_enter(&dq_cachelock);
189 for (dqp = dhp->dqh_forw; dqp != (DQptr)dhp; dqp = dqp->dq_forw) {
190 if (dqp->dq_uid != uid || dqp->dq_ufsvfsp != ufsvfsp)
191 continue;
192 mutex_exit(&dq_cachelock);
193 mutex_enter(&dqp->dq_lock);
194 /*
195 * I may have slept in the mutex_enter. Make sure this is
196 * still the one I want.
197 */
198 if (dqp->dq_uid != uid || dqp->dq_ufsvfsp != ufsvfsp) {
199 mutex_exit(&dqp->dq_lock);
200 goto loop;
201 }
202 if (dqp->dq_flags & DQ_ERROR) {
203 mutex_exit(&dqp->dq_lock);
204 return (EINVAL);
205 }
206 /*
207 * Cache hit with no references.
208 * Take the structure off the free list.
209 */
210 if (dqp->dq_cnt == 0) {
211 mutex_enter(&dq_freelock);
212 dqremfree(dqp);
213 mutex_exit(&dq_freelock);
214 }
215 dqp->dq_cnt++;
216 mutex_exit(&dqp->dq_lock);
217 *dqpp = dqp;
218 return (0);
219 }
220 /*
221 * Not in cache.
222 * Get dquot at head of free list.
223 */
224 mutex_enter(&dq_freelock);
225 if ((dqp = dqfreelist.dq_freef) == &dqfreelist) {
226 mutex_exit(&dq_freelock);
227 mutex_exit(&dq_cachelock);
228 cmn_err(CE_WARN, "dquot table full");
229 return (EUSERS);
230 }
231
232 if (dqp->dq_cnt != 0 || dqp->dq_flags != 0) {
233 panic("getdiskquota: dqp->dq_cnt: "
234 "%ld != 0 || dqp->dq_flags: 0x%x != 0 (%s)",
235 dqp->dq_cnt, dqp->dq_flags, qip->i_fs->fs_fsmnt);
236 /*NOTREACHED*/
237 }
238 /*
239 * Take it off the free list, and off the hash chain it was on.
240 * Then put it on the new hash chain.
241 */
242 dqremfree(dqp);
243 mutex_exit(&dq_freelock);
244 remque(dqp);
245 dqp->dq_cnt = 1;
246 dqp->dq_uid = uid;
247 dqp->dq_ufsvfsp = ufsvfsp;
248 dqp->dq_mof = UFS_HOLE;
249 mutex_enter(&dqp->dq_lock);
250 insque(dqp, dhp);
251 mutex_exit(&dq_cachelock);
252 /*
253 * Check the uid in case it's too large to fit into the 2Gbyte
254 * 'quotas' file (higher than 67 million or so).
255 */
256
257 /*
258 * Large Files: i_size need to be accessed atomically now.
259 */
260 rw_enter(&qip->i_contents, RW_READER);
261 if (uid <= MAXUID && dqoff(uid) >= 0 && dqoff(uid) < qip->i_size) {
262 /*
263 * Read quota info off disk.
264 */
265 error = ufs_rdwri(UIO_READ, FREAD, qip, (caddr_t)&dqp->dq_dqb,
266 sizeof (struct dqblk), dqoff(uid), UIO_SYSSPACE,
267 (int *)NULL, kcred);
268 /*
269 * We must set the dq_mof even if not we are not logging in case
270 * we are later remount to logging.
271 */
272 err = bmap_read(qip, dqoff(uid), &bn, &contig);
273 rw_exit(&qip->i_contents);
274 if ((bn != UFS_HOLE) && !err) {
275 dqp->dq_mof = ldbtob(bn) +
276 (offset_t)(dqoff(uid) & (DEV_BSIZE - 1));
277 } else {
278 dqp->dq_mof = UFS_HOLE;
279 }
280 if (error) {
281 /*
282 * I/O error in reading quota file.
283 * Put dquot on a private, unfindable hash list,
284 * put dquot at the head of the free list and
285 * reflect the problem to caller.
286 */
287 dqp->dq_flags = DQ_ERROR;
288 /*
289 * I must exit the dq_lock so that I can acquire the
290 * dq_cachelock. If another thread finds dqp before
291 * I remove it from the cache it will see the
292 * DQ_ERROR and just return EIO.
293 */
294 mutex_exit(&dqp->dq_lock);
295 mutex_enter(&dq_cachelock);
296 mutex_enter(&dqp->dq_lock);
297 remque(dqp);
298 mutex_exit(&dqp->dq_lock);
299 mutex_exit(&dq_cachelock);
300 /*
301 * Don't bother reacquiring dq_lock because the dq is
302 * not on the freelist or in the cache so only I have
303 * access to it.
304 */
305 dqp->dq_cnt = 0;
306 dqp->dq_ufsvfsp = NULL;
307 dqp->dq_forw = dqp;
308 dqp->dq_back = dqp;
309 dqp->dq_mof = UFS_HOLE;
310 dqp->dq_flags = 0;
311 dqinsheadfree(dqp);
312 return (EIO);
313 }
314 } else {
315 rw_exit(&qip->i_contents); /* done with i_size */
316 bzero(&dqp->dq_dqb, sizeof (struct dqblk));
317 dqp->dq_mof = UFS_HOLE;
318 }
319 mutex_exit(&dqp->dq_lock);
320 *dqpp = dqp;
321 return (0);
322 }
323
324 /*
325 * Release dquot.
326 */
327 void
dqput(dqp)328 dqput(dqp)
329 register struct dquot *dqp;
330 {
331
332 ASSERT(dqp->dq_ufsvfsp == NULL ||
333 RW_LOCK_HELD(&dqp->dq_ufsvfsp->vfs_dqrwlock));
334 ASSERT(MUTEX_HELD(&dqp->dq_lock));
335 if (dqp->dq_cnt == 0) {
336 (void) ufs_fault(
337 dqp->dq_ufsvfsp && dqp->dq_ufsvfsp->vfs_root?
338 dqp->dq_ufsvfsp->vfs_root: NULL,
339 "dqput: dqp->dq_cnt == 0");
340 return;
341 }
342 if (--dqp->dq_cnt == 0) {
343 if (dqp->dq_flags & DQ_MOD)
344 dqupdate(dqp);
345 /*
346 * DQ_MOD was cleared by dqupdate().
347 * DQ_ERROR shouldn't be set if this dquot was being used.
348 * DQ_FILES/DQ_BLKS don't matter at this point.
349 */
350 dqp->dq_flags = 0;
351 if (dqp->dq_ufsvfsp == NULL ||
352 dqp->dq_ufsvfsp->vfs_qflags == 0) {
353 /* quotas are disabled, discard this dquot struct */
354 dqinval(dqp);
355 } else
356 dqinstailfree(dqp);
357 }
358 }
359
360 /*
361 * Update on disk quota info.
362 */
363 void
dqupdate(dqp)364 dqupdate(dqp)
365 register struct dquot *dqp;
366 {
367 register struct inode *qip;
368 extern struct cred *kcred;
369 struct ufsvfs *ufsvfsp;
370 int newtrans = 0;
371 struct vnode *vfs_root;
372
373 ASSERT(MUTEX_HELD(&dqp->dq_lock));
374
375 if (!dqp->dq_ufsvfsp) {
376 (void) ufs_fault(NULL, "dqupdate: NULL dq_ufsvfsp");
377 return;
378 }
379 vfs_root = dqp->dq_ufsvfsp->vfs_root;
380 if (!vfs_root) {
381 (void) ufs_fault(NULL, "dqupdate: NULL vfs_root");
382 return;
383 }
384 /*
385 * I don't need to hold dq_rwlock when looking at vfs_qinod here
386 * because vfs_qinod is only cleared by closedq after it has called
387 * dqput on all dq's. Since I am holding dq_lock on this dq, closedq
388 * will have to wait until I am done before it can call dqput on
389 * this dq so vfs_qinod will not change value until after I return.
390 */
391 qip = dqp->dq_ufsvfsp->vfs_qinod;
392 if (!qip) {
393 (void) ufs_fault(vfs_root, "dqupdate: NULL vfs_qinod");
394 return;
395 }
396 ufsvfsp = qip->i_ufsvfs;
397 if (!ufsvfsp) {
398 (void) ufs_fault(vfs_root,
399 "dqupdate: NULL vfs_qinod->i_ufsvfs");
400 return;
401 }
402 if (ufsvfsp != dqp->dq_ufsvfsp) {
403 (void) ufs_fault(vfs_root,
404 "dqupdate: vfs_qinod->i_ufsvfs != dqp->dq_ufsvfsp");
405 return;
406 }
407 if (!(dqp->dq_flags & DQ_MOD)) {
408 (void) ufs_fault(vfs_root,
409 "dqupdate: !(dqp->dq_flags & DQ_MOD)");
410 return;
411 }
412
413 if (!(curthread->t_flag & T_DONTBLOCK)) {
414 newtrans++;
415 curthread->t_flag |= T_DONTBLOCK;
416 TRANS_BEGIN_ASYNC(ufsvfsp, TOP_QUOTA, TOP_QUOTA_SIZE);
417 }
418 if (TRANS_ISTRANS(ufsvfsp)) {
419 TRANS_DELTA(ufsvfsp, dqp->dq_mof, sizeof (struct dqblk),
420 DT_QR, 0, 0);
421 TRANS_LOG(ufsvfsp, (caddr_t)&dqp->dq_dqb, dqp->dq_mof,
422 (int)(sizeof (struct dqblk)), NULL, 0);
423 } else {
424 /*
425 * Locknest gets very confused when I lock the quota inode.
426 * It thinks that qip and ip (the inode that caused the
427 * quota routines to get called) are the same inode.
428 */
429 rw_enter(&qip->i_contents, RW_WRITER);
430 /*
431 * refuse to push if offset would be illegal
432 */
433 if (dqoff(dqp->dq_uid) >= 0) {
434 (void) ufs_rdwri(UIO_WRITE, FWRITE, qip,
435 (caddr_t)&dqp->dq_dqb,
436 sizeof (struct dqblk),
437 dqoff(dqp->dq_uid), UIO_SYSSPACE,
438 (int *)NULL, kcred);
439 }
440 rw_exit(&qip->i_contents);
441 }
442
443 dqp->dq_flags &= ~DQ_MOD;
444 if (newtrans) {
445 TRANS_END_ASYNC(ufsvfsp, TOP_QUOTA, TOP_QUOTA_SIZE);
446 curthread->t_flag &= ~T_DONTBLOCK;
447 }
448 }
449
450 /*
451 * Invalidate a dquot. This function is called when quotas are disabled
452 * for a specific file system via closedq() or when we unmount the file
453 * system and invalidate the quota cache via invalidatedq().
454 *
455 * Take the dquot off its hash list and put it on a private, unfindable
456 * hash list (refers to itself). Also, put it at the head of the free list.
457 * Note that even though dq_cnt is zero, this dquot is NOT yet on the
458 * freelist.
459 */
460 void
dqinval(dqp)461 dqinval(dqp)
462 register struct dquot *dqp;
463 {
464 ASSERT(MUTEX_HELD(&dqp->dq_lock));
465 ASSERT(dqp->dq_cnt == 0);
466 ASSERT(dqp->dq_flags == 0);
467 ASSERT(dqp->dq_freef == NULL && dqp->dq_freeb == NULL);
468 ASSERT(dqp->dq_ufsvfsp &&
469 (dqp->dq_ufsvfsp->vfs_qflags & MQ_ENABLED) == 0);
470
471 /*
472 * To preserve lock order, we have to drop dq_lock in order to
473 * grab dq_cachelock. To prevent someone from grabbing this
474 * dquot from the quota cache via getdiskquota() while we are
475 * "unsafe", we clear dq_ufsvfsp so it won't match anything.
476 */
477 dqp->dq_ufsvfsp = NULL;
478 mutex_exit(&dqp->dq_lock);
479 mutex_enter(&dq_cachelock);
480 mutex_enter(&dqp->dq_lock);
481
482 /*
483 * The following paranoia is to make sure that getdiskquota()
484 * has not been broken:
485 */
486 ASSERT(dqp->dq_cnt == 0);
487 ASSERT(dqp->dq_flags == 0);
488 ASSERT(dqp->dq_freef == NULL && dqp->dq_freeb == NULL);
489 ASSERT(dqp->dq_ufsvfsp == NULL);
490
491 /*
492 * Now we have the locks in the right order so we can do the
493 * rest of the work.
494 */
495 remque(dqp);
496 mutex_exit(&dq_cachelock);
497 dqp->dq_forw = dqp;
498 dqp->dq_back = dqp;
499 dqinsheadfree(dqp);
500 }
501
502 /*
503 * Invalidate all quota information records for the specified file system.
504 */
505 void
invalidatedq(ufsvfsp)506 invalidatedq(ufsvfsp)
507 register struct ufsvfs *ufsvfsp;
508 {
509 register struct dquot *dqp;
510
511
512 /*
513 * If quotas are not initialized, then there is nothing to do.
514 */
515 rw_enter(&dq_rwlock, RW_READER);
516 if (!quotas_initialized) {
517 rw_exit(&dq_rwlock);
518 return;
519 }
520 rw_exit(&dq_rwlock);
521
522
523 rw_enter(&ufsvfsp->vfs_dqrwlock, RW_WRITER);
524
525 ASSERT((ufsvfsp->vfs_qflags & MQ_ENABLED) == 0);
526
527 /*
528 * Invalidate all the quota info records for this file system
529 * that are in the quota cache:
530 */
531 for (dqp = dquot; dqp < dquotNDQUOT; dqp++) {
532 /*
533 * If someone else has it, then ignore it. For the target
534 * file system, this is okay for three reasons:
535 *
536 * 1) This routine is called after closedq() so the quota
537 * sub-system is disabled for this file system.
538 * 2) We have made the quota sub-system quiescent for
539 * this file system.
540 * 3) We are in the process of unmounting this file
541 * system so the quota sub-system can't be enabled
542 * for it.
543 */
544 if (!mutex_tryenter(&dqp->dq_lock)) {
545 continue;
546 }
547
548
549 /*
550 * At this point, any quota info records that are
551 * associated with the target file system, should have a
552 * reference count of zero and be on the free list.
553 * Why? Because these quota info records went to a zero
554 * dq_cnt (via dqput()) before the file system was
555 * unmounted and are waiting to be found in the quota
556 * cache and reused (via getdiskquota()). The exception
557 * is when a quota transaction is sitting in the deltamap,
558 * indicated by DQ_TRANS being set in dq_flags.
559 * This causes a reference to be held on the quota
560 * information record and it will only be cleared once
561 * the transaction has reached the log. If we find
562 * any of these - we ignore them and let logging do
563 * the right thing.
564 */
565 if (dqp->dq_ufsvfsp == ufsvfsp) {
566 ASSERT(dqp->dq_cnt == 0 || (dqp->dq_cnt == 1 &&
567 (dqp->dq_flags & DQ_TRANS)));
568
569 /* Cope with those orphaned dquots. */
570 if (dqp->dq_cnt == 1 && (dqp->dq_flags & DQ_TRANS)) {
571 mutex_exit(&dqp->dq_lock);
572 continue;
573 }
574
575 ASSERT(dqp->dq_cnt == 0);
576 ASSERT(dqp->dq_freef && dqp->dq_freeb);
577
578 /*
579 * Take the quota info record off the free list
580 * so dqinval() can do its job (and put it on the
581 * front of the free list).
582 */
583 mutex_enter(&dq_freelock);
584 dqremfree(dqp);
585 mutex_exit(&dq_freelock);
586 dqinval(dqp);
587 }
588
589 mutex_exit(&dqp->dq_lock);
590 }
591 rw_exit(&ufsvfsp->vfs_dqrwlock);
592 }
593