?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
move some stuff from common.c to neighbor.c
[cor.git] / fs / xfs / xfs_trans_dquot.c
bloba6fe2d8dc40f38307f643360a84c80e5eaa6360b
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000-2002 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
13 #include "xfs_inode.h"
14 #include "xfs_trans.h"
15 #include "xfs_trans_priv.h"
16 #include "xfs_quota.h"
17 #include "xfs_qm.h"
18
19 STATIC void xfs_trans_alloc_dqinfo(xfs_trans_t *);
20
21 /*
22 * Add the locked dquot to the transaction.
23 * The dquot must be locked, and it cannot be associated with any
24 * transaction.
25 */
26 void
27 xfs_trans_dqjoin(
28 struct xfs_trans *tp,
29 struct xfs_dquot *dqp)
30 {
31 ASSERT(XFS_DQ_IS_LOCKED(dqp));
32 ASSERT(dqp->q_logitem.qli_dquot == dqp);
33
34 /*
35 * Get a log_item_desc to point at the new item.
36 */
37 xfs_trans_add_item(tp, &dqp->q_logitem.qli_item);
38 }
39
40 /*
41 * This is called to mark the dquot as needing
42 * to be logged when the transaction is committed. The dquot must
43 * already be associated with the given transaction.
44 * Note that it marks the entire transaction as dirty. In the ordinary
45 * case, this gets called via xfs_trans_commit, after the transaction
46 * is already dirty. However, there's nothing stop this from getting
47 * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY
48 * flag.
49 */
50 void
51 xfs_trans_log_dquot(
52 struct xfs_trans *tp,
53 struct xfs_dquot *dqp)
54 {
55 ASSERT(XFS_DQ_IS_LOCKED(dqp));
56
57 tp->t_flags |= XFS_TRANS_DIRTY;
58 set_bit(XFS_LI_DIRTY, &dqp->q_logitem.qli_item.li_flags);
59 }
60
61 /*
62 * Carry forward whatever is left of the quota blk reservation to
63 * the spanky new transaction
64 */
65 void
66 xfs_trans_dup_dqinfo(
67 struct xfs_trans *otp,
68 struct xfs_trans *ntp)
69 {
70 struct xfs_dqtrx *oq, *nq;
71 int i, j;
72 struct xfs_dqtrx *oqa, *nqa;
73 uint64_t blk_res_used;
74
75 if (!otp->t_dqinfo)
76 return;
77
78 xfs_trans_alloc_dqinfo(ntp);
79
80 /*
81 * Because the quota blk reservation is carried forward,
82 * it is also necessary to carry forward the DQ_DIRTY flag.
83 */
84 if (otp->t_flags & XFS_TRANS_DQ_DIRTY)
85 ntp->t_flags |= XFS_TRANS_DQ_DIRTY;
86
87 for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
88 oqa = otp->t_dqinfo->dqs[j];
89 nqa = ntp->t_dqinfo->dqs[j];
90 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
91 blk_res_used = 0;
92
93 if (oqa[i].qt_dquot == NULL)
94 break;
95 oq = &oqa[i];
96 nq = &nqa[i];
97
98 if (oq->qt_blk_res && oq->qt_bcount_delta > 0)
99 blk_res_used = oq->qt_bcount_delta;
100
101 nq->qt_dquot = oq->qt_dquot;
102 nq->qt_bcount_delta = nq->qt_icount_delta = 0;
103 nq->qt_rtbcount_delta = 0;
104
105 /*
106 * Transfer whatever is left of the reservations.
107 */
108 nq->qt_blk_res = oq->qt_blk_res - blk_res_used;
109 oq->qt_blk_res = blk_res_used;
110
111 nq->qt_rtblk_res = oq->qt_rtblk_res -
112 oq->qt_rtblk_res_used;
113 oq->qt_rtblk_res = oq->qt_rtblk_res_used;
114
115 nq->qt_ino_res = oq->qt_ino_res - oq->qt_ino_res_used;
116 oq->qt_ino_res = oq->qt_ino_res_used;
117
118 }
119 }
120 }
121
122 /*
123 * Wrap around mod_dquot to account for both user and group quotas.
124 */
125 void
126 xfs_trans_mod_dquot_byino(
127 xfs_trans_t *tp,
128 xfs_inode_t *ip,
129 uint field,
130 int64_t delta)
131 {
132 xfs_mount_t *mp = tp->t_mountp;
133
134 if (!XFS_IS_QUOTA_RUNNING(mp) ||
135 !XFS_IS_QUOTA_ON(mp) ||
136 xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
137 return;
138
139 if (tp->t_dqinfo == NULL)
140 xfs_trans_alloc_dqinfo(tp);
141
142 if (XFS_IS_UQUOTA_ON(mp) && ip->i_udquot)
143 (void) xfs_trans_mod_dquot(tp, ip->i_udquot, field, delta);
144 if (XFS_IS_GQUOTA_ON(mp) && ip->i_gdquot)
145 (void) xfs_trans_mod_dquot(tp, ip->i_gdquot, field, delta);
146 if (XFS_IS_PQUOTA_ON(mp) && ip->i_pdquot)
147 (void) xfs_trans_mod_dquot(tp, ip->i_pdquot, field, delta);
148 }
149
150 STATIC struct xfs_dqtrx *
151 xfs_trans_get_dqtrx(
152 struct xfs_trans *tp,
153 struct xfs_dquot *dqp)
154 {
155 int i;
156 struct xfs_dqtrx *qa;
157
158 if (XFS_QM_ISUDQ(dqp))
159 qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_USR];
160 else if (XFS_QM_ISGDQ(dqp))
161 qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_GRP];
162 else if (XFS_QM_ISPDQ(dqp))
163 qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_PRJ];
164 else
165 return NULL;
166
167 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
168 if (qa[i].qt_dquot == NULL ||
169 qa[i].qt_dquot == dqp)
170 return &qa[i];
171 }
172
173 return NULL;
174 }
175
176 /*
177 * Make the changes in the transaction structure.
178 * The moral equivalent to xfs_trans_mod_sb().
179 * We don't touch any fields in the dquot, so we don't care
180 * if it's locked or not (most of the time it won't be).
181 */
182 void
183 xfs_trans_mod_dquot(
184 struct xfs_trans *tp,
185 struct xfs_dquot *dqp,
186 uint field,
187 int64_t delta)
188 {
189 struct xfs_dqtrx *qtrx;
190
191 ASSERT(tp);
192 ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
193 qtrx = NULL;
194
195 if (tp->t_dqinfo == NULL)
196 xfs_trans_alloc_dqinfo(tp);
197 /*
198 * Find either the first free slot or the slot that belongs
199 * to this dquot.
200 */
201 qtrx = xfs_trans_get_dqtrx(tp, dqp);
202 ASSERT(qtrx);
203 if (qtrx->qt_dquot == NULL)
204 qtrx->qt_dquot = dqp;
205
206 switch (field) {
207
208 /*
209 * regular disk blk reservation
210 */
211 case XFS_TRANS_DQ_RES_BLKS:
212 qtrx->qt_blk_res += delta;
213 break;
214
215 /*
216 * inode reservation
217 */
218 case XFS_TRANS_DQ_RES_INOS:
219 qtrx->qt_ino_res += delta;
220 break;
221
222 /*
223 * disk blocks used.
224 */
225 case XFS_TRANS_DQ_BCOUNT:
226 qtrx->qt_bcount_delta += delta;
227 break;
228
229 case XFS_TRANS_DQ_DELBCOUNT:
230 qtrx->qt_delbcnt_delta += delta;
231 break;
232
233 /*
234 * Inode Count
235 */
236 case XFS_TRANS_DQ_ICOUNT:
237 if (qtrx->qt_ino_res && delta > 0) {
238 qtrx->qt_ino_res_used += delta;
239 ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used);
240 }
241 qtrx->qt_icount_delta += delta;
242 break;
243
244 /*
245 * rtblk reservation
246 */
247 case XFS_TRANS_DQ_RES_RTBLKS:
248 qtrx->qt_rtblk_res += delta;
249 break;
250
251 /*
252 * rtblk count
253 */
254 case XFS_TRANS_DQ_RTBCOUNT:
255 if (qtrx->qt_rtblk_res && delta > 0) {
256 qtrx->qt_rtblk_res_used += delta;
257 ASSERT(qtrx->qt_rtblk_res >= qtrx->qt_rtblk_res_used);
258 }
259 qtrx->qt_rtbcount_delta += delta;
260 break;
261
262 case XFS_TRANS_DQ_DELRTBCOUNT:
263 qtrx->qt_delrtb_delta += delta;
264 break;
265
266 default:
267 ASSERT(0);
268 }
269 tp->t_flags |= XFS_TRANS_DQ_DIRTY;
270 }
271
272
273 /*
274 * Given an array of dqtrx structures, lock all the dquots associated and join
275 * them to the transaction, provided they have been modified. We know that the
276 * highest number of dquots of one type - usr, grp and prj - involved in a
277 * transaction is 3 so we don't need to make this very generic.
278 */
279 STATIC void
280 xfs_trans_dqlockedjoin(
281 struct xfs_trans *tp,
282 struct xfs_dqtrx *q)
283 {
284 ASSERT(q[0].qt_dquot != NULL);
285 if (q[1].qt_dquot == NULL) {
286 xfs_dqlock(q[0].qt_dquot);
287 xfs_trans_dqjoin(tp, q[0].qt_dquot);
288 } else {
289 ASSERT(XFS_QM_TRANS_MAXDQS == 2);
290 xfs_dqlock2(q[0].qt_dquot, q[1].qt_dquot);
291 xfs_trans_dqjoin(tp, q[0].qt_dquot);
292 xfs_trans_dqjoin(tp, q[1].qt_dquot);
293 }
294 }
295
296
297 /*
298 * Called by xfs_trans_commit() and similar in spirit to
299 * xfs_trans_apply_sb_deltas().
300 * Go thru all the dquots belonging to this transaction and modify the
301 * INCORE dquot to reflect the actual usages.
302 * Unreserve just the reservations done by this transaction.
303 * dquot is still left locked at exit.
304 */
305 void
306 xfs_trans_apply_dquot_deltas(
307 struct xfs_trans *tp)
308 {
309 int i, j;
310 struct xfs_dquot *dqp;
311 struct xfs_dqtrx *qtrx, *qa;
312 struct xfs_disk_dquot *d;
313 int64_t totalbdelta;
314 int64_t totalrtbdelta;
315
316 if (!(tp->t_flags & XFS_TRANS_DQ_DIRTY))
317 return;
318
319 ASSERT(tp->t_dqinfo);
320 for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
321 qa = tp->t_dqinfo->dqs[j];
322 if (qa[0].qt_dquot == NULL)
323 continue;
324
325 /*
326 * Lock all of the dquots and join them to the transaction.
327 */
328 xfs_trans_dqlockedjoin(tp, qa);
329
330 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
331 qtrx = &qa[i];
332 /*
333 * The array of dquots is filled
334 * sequentially, not sparsely.
335 */
336 if ((dqp = qtrx->qt_dquot) == NULL)
337 break;
338
339 ASSERT(XFS_DQ_IS_LOCKED(dqp));
340
341 /*
342 * adjust the actual number of blocks used
343 */
344 d = &dqp->q_core;
345
346 /*
347 * The issue here is - sometimes we don't make a blkquota
348 * reservation intentionally to be fair to users
349 * (when the amount is small). On the other hand,
350 * delayed allocs do make reservations, but that's
351 * outside of a transaction, so we have no
352 * idea how much was really reserved.
353 * So, here we've accumulated delayed allocation blks and
354 * non-delay blks. The assumption is that the
355 * delayed ones are always reserved (outside of a
356 * transaction), and the others may or may not have
357 * quota reservations.
358 */
359 totalbdelta = qtrx->qt_bcount_delta +
360 qtrx->qt_delbcnt_delta;
361 totalrtbdelta = qtrx->qt_rtbcount_delta +
362 qtrx->qt_delrtb_delta;
363 #ifdef DEBUG
364 if (totalbdelta < 0)
365 ASSERT(be64_to_cpu(d->d_bcount) >=
366 -totalbdelta);
367
368 if (totalrtbdelta < 0)
369 ASSERT(be64_to_cpu(d->d_rtbcount) >=
370 -totalrtbdelta);
371
372 if (qtrx->qt_icount_delta < 0)
373 ASSERT(be64_to_cpu(d->d_icount) >=
374 -qtrx->qt_icount_delta);
375 #endif
376 if (totalbdelta)
377 be64_add_cpu(&d->d_bcount, (xfs_qcnt_t)totalbdelta);
378
379 if (qtrx->qt_icount_delta)
380 be64_add_cpu(&d->d_icount, (xfs_qcnt_t)qtrx->qt_icount_delta);
381
382 if (totalrtbdelta)
383 be64_add_cpu(&d->d_rtbcount, (xfs_qcnt_t)totalrtbdelta);
384
385 /*
386 * Get any default limits in use.
387 * Start/reset the timer(s) if needed.
388 */
389 if (d->d_id) {
390 xfs_qm_adjust_dqlimits(tp->t_mountp, dqp);
391 xfs_qm_adjust_dqtimers(tp->t_mountp, d);
392 }
393
394 dqp->dq_flags |= XFS_DQ_DIRTY;
395 /*
396 * add this to the list of items to get logged
397 */
398 xfs_trans_log_dquot(tp, dqp);
399 /*
400 * Take off what's left of the original reservation.
401 * In case of delayed allocations, there's no
402 * reservation that a transaction structure knows of.
403 */
404 if (qtrx->qt_blk_res != 0) {
405 uint64_t blk_res_used = 0;
406
407 if (qtrx->qt_bcount_delta > 0)
408 blk_res_used = qtrx->qt_bcount_delta;
409
410 if (qtrx->qt_blk_res != blk_res_used) {
411 if (qtrx->qt_blk_res > blk_res_used)
412 dqp->q_res_bcount -= (xfs_qcnt_t)
413 (qtrx->qt_blk_res -
414 blk_res_used);
415 else
416 dqp->q_res_bcount -= (xfs_qcnt_t)
417 (blk_res_used -
418 qtrx->qt_blk_res);
419 }
420 } else {
421 /*
422 * These blks were never reserved, either inside
423 * a transaction or outside one (in a delayed
424 * allocation). Also, this isn't always a
425 * negative number since we sometimes
426 * deliberately skip quota reservations.
427 */
428 if (qtrx->qt_bcount_delta) {
429 dqp->q_res_bcount +=
430 (xfs_qcnt_t)qtrx->qt_bcount_delta;
431 }
432 }
433 /*
434 * Adjust the RT reservation.
435 */
436 if (qtrx->qt_rtblk_res != 0) {
437 if (qtrx->qt_rtblk_res != qtrx->qt_rtblk_res_used) {
438 if (qtrx->qt_rtblk_res >
439 qtrx->qt_rtblk_res_used)
440 dqp->q_res_rtbcount -= (xfs_qcnt_t)
441 (qtrx->qt_rtblk_res -
442 qtrx->qt_rtblk_res_used);
443 else
444 dqp->q_res_rtbcount -= (xfs_qcnt_t)
445 (qtrx->qt_rtblk_res_used -
446 qtrx->qt_rtblk_res);
447 }
448 } else {
449 if (qtrx->qt_rtbcount_delta)
450 dqp->q_res_rtbcount +=
451 (xfs_qcnt_t)qtrx->qt_rtbcount_delta;
452 }
453
454 /*
455 * Adjust the inode reservation.
456 */
457 if (qtrx->qt_ino_res != 0) {
458 ASSERT(qtrx->qt_ino_res >=
459 qtrx->qt_ino_res_used);
460 if (qtrx->qt_ino_res > qtrx->qt_ino_res_used)
461 dqp->q_res_icount -= (xfs_qcnt_t)
462 (qtrx->qt_ino_res -
463 qtrx->qt_ino_res_used);
464 } else {
465 if (qtrx->qt_icount_delta)
466 dqp->q_res_icount +=
467 (xfs_qcnt_t)qtrx->qt_icount_delta;
468 }
469
470 ASSERT(dqp->q_res_bcount >=
471 be64_to_cpu(dqp->q_core.d_bcount));
472 ASSERT(dqp->q_res_icount >=
473 be64_to_cpu(dqp->q_core.d_icount));
474 ASSERT(dqp->q_res_rtbcount >=
475 be64_to_cpu(dqp->q_core.d_rtbcount));
476 }
477 }
478 }
479
480 /*
481 * Release the reservations, and adjust the dquots accordingly.
482 * This is called only when the transaction is being aborted. If by
483 * any chance we have done dquot modifications incore (ie. deltas) already,
484 * we simply throw those away, since that's the expected behavior
485 * when a transaction is curtailed without a commit.
486 */
487 void
488 xfs_trans_unreserve_and_mod_dquots(
489 struct xfs_trans *tp)
490 {
491 int i, j;
492 struct xfs_dquot *dqp;
493 struct xfs_dqtrx *qtrx, *qa;
494 bool locked;
495
496 if (!tp->t_dqinfo || !(tp->t_flags & XFS_TRANS_DQ_DIRTY))
497 return;
498
499 for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
500 qa = tp->t_dqinfo->dqs[j];
501
502 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
503 qtrx = &qa[i];
504 /*
505 * We assume that the array of dquots is filled
506 * sequentially, not sparsely.
507 */
508 if ((dqp = qtrx->qt_dquot) == NULL)
509 break;
510 /*
511 * Unreserve the original reservation. We don't care
512 * about the number of blocks used field, or deltas.
513 * Also we don't bother to zero the fields.
514 */
515 locked = false;
516 if (qtrx->qt_blk_res) {
517 xfs_dqlock(dqp);
518 locked = true;
519 dqp->q_res_bcount -=
520 (xfs_qcnt_t)qtrx->qt_blk_res;
521 }
522 if (qtrx->qt_ino_res) {
523 if (!locked) {
524 xfs_dqlock(dqp);
525 locked = true;
526 }
527 dqp->q_res_icount -=
528 (xfs_qcnt_t)qtrx->qt_ino_res;
529 }
530
531 if (qtrx->qt_rtblk_res) {
532 if (!locked) {
533 xfs_dqlock(dqp);
534 locked = true;
535 }
536 dqp->q_res_rtbcount -=
537 (xfs_qcnt_t)qtrx->qt_rtblk_res;
538 }
539 if (locked)
540 xfs_dqunlock(dqp);
541
542 }
543 }
544 }
545
546 STATIC void
547 xfs_quota_warn(
548 struct xfs_mount *mp,
549 struct xfs_dquot *dqp,
550 int type)
551 {
552 enum quota_type qtype;
553
554 if (dqp->dq_flags & XFS_DQ_PROJ)
555 qtype = PRJQUOTA;
556 else if (dqp->dq_flags & XFS_DQ_USER)
557 qtype = USRQUOTA;
558 else
559 qtype = GRPQUOTA;
560
561 quota_send_warning(make_kqid(&init_user_ns, qtype,
562 be32_to_cpu(dqp->q_core.d_id)),
563 mp->m_super->s_dev, type);
564 }
565
566 /*
567 * This reserves disk blocks and inodes against a dquot.
568 * Flags indicate if the dquot is to be locked here and also
569 * if the blk reservation is for RT or regular blocks.
570 * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check.
571 */
572 STATIC int
573 xfs_trans_dqresv(
574 struct xfs_trans *tp,
575 struct xfs_mount *mp,
576 struct xfs_dquot *dqp,
577 int64_t nblks,
578 long ninos,
579 uint flags)
580 {
581 xfs_qcnt_t hardlimit;
582 xfs_qcnt_t softlimit;
583 time_t timer;
584 xfs_qwarncnt_t warns;
585 xfs_qwarncnt_t warnlimit;
586 xfs_qcnt_t total_count;
587 xfs_qcnt_t *resbcountp;
588 struct xfs_quotainfo *q = mp->m_quotainfo;
589 struct xfs_def_quota *defq;
590
591
592 xfs_dqlock(dqp);
593
594 defq = xfs_get_defquota(dqp, q);
595
596 if (flags & XFS_TRANS_DQ_RES_BLKS) {
597 hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
598 if (!hardlimit)
599 hardlimit = defq->bhardlimit;
600 softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit);
601 if (!softlimit)
602 softlimit = defq->bsoftlimit;
603 timer = be32_to_cpu(dqp->q_core.d_btimer);
604 warns = be16_to_cpu(dqp->q_core.d_bwarns);
605 warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit;
606 resbcountp = &dqp->q_res_bcount;
607 } else {
608 ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
609 hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);
610 if (!hardlimit)
611 hardlimit = defq->rtbhardlimit;
612 softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit);
613 if (!softlimit)
614 softlimit = defq->rtbsoftlimit;
615 timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
616 warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
617 warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit;
618 resbcountp = &dqp->q_res_rtbcount;
619 }
620
621 if ((flags & XFS_QMOPT_FORCE_RES) == 0 &&
622 dqp->q_core.d_id &&
623 ((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) ||
624 (XFS_IS_GQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISGDQ(dqp)) ||
625 (XFS_IS_PQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISPDQ(dqp)))) {
626 if (nblks > 0) {
627 /*
628 * dquot is locked already. See if we'd go over the
629 * hardlimit or exceed the timelimit if we allocate
630 * nblks.
631 */
632 total_count = *resbcountp + nblks;
633 if (hardlimit && total_count > hardlimit) {
634 xfs_quota_warn(mp, dqp, QUOTA_NL_BHARDWARN);
635 goto error_return;
636 }
637 if (softlimit && total_count > softlimit) {
638 if ((timer != 0 && get_seconds() > timer) ||
639 (warns != 0 && warns >= warnlimit)) {
640 xfs_quota_warn(mp, dqp,
641 QUOTA_NL_BSOFTLONGWARN);
642 goto error_return;
643 }
644
645 xfs_quota_warn(mp, dqp, QUOTA_NL_BSOFTWARN);
646 }
647 }
648 if (ninos > 0) {
649 total_count = be64_to_cpu(dqp->q_core.d_icount) + ninos;
650 timer = be32_to_cpu(dqp->q_core.d_itimer);
651 warns = be16_to_cpu(dqp->q_core.d_iwarns);
652 warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit;
653 hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
654 if (!hardlimit)
655 hardlimit = defq->ihardlimit;
656 softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);
657 if (!softlimit)
658 softlimit = defq->isoftlimit;
659
660 if (hardlimit && total_count > hardlimit) {
661 xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN);
662 goto error_return;
663 }
664 if (softlimit && total_count > softlimit) {
665 if ((timer != 0 && get_seconds() > timer) ||
666 (warns != 0 && warns >= warnlimit)) {
667 xfs_quota_warn(mp, dqp,
668 QUOTA_NL_ISOFTLONGWARN);
669 goto error_return;
670 }
671 xfs_quota_warn(mp, dqp, QUOTA_NL_ISOFTWARN);
672 }
673 }
674 }
675
676 /*
677 * Change the reservation, but not the actual usage.
678 * Note that q_res_bcount = q_core.d_bcount + resv
679 */
680 (*resbcountp) += (xfs_qcnt_t)nblks;
681 if (ninos != 0)
682 dqp->q_res_icount += (xfs_qcnt_t)ninos;
683
684 /*
685 * note the reservation amt in the trans struct too,
686 * so that the transaction knows how much was reserved by
687 * it against this particular dquot.
688 * We don't do this when we are reserving for a delayed allocation,
689 * because we don't have the luxury of a transaction envelope then.
690 */
691 if (tp) {
692 ASSERT(tp->t_dqinfo);
693 ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
694 if (nblks != 0)
695 xfs_trans_mod_dquot(tp, dqp,
696 flags & XFS_QMOPT_RESBLK_MASK,
697 nblks);
698 if (ninos != 0)
699 xfs_trans_mod_dquot(tp, dqp,
700 XFS_TRANS_DQ_RES_INOS,
701 ninos);
702 }
703 ASSERT(dqp->q_res_bcount >= be64_to_cpu(dqp->q_core.d_bcount));
704 ASSERT(dqp->q_res_rtbcount >= be64_to_cpu(dqp->q_core.d_rtbcount));
705 ASSERT(dqp->q_res_icount >= be64_to_cpu(dqp->q_core.d_icount));
706
707 xfs_dqunlock(dqp);
708 return 0;
709
710 error_return:
711 xfs_dqunlock(dqp);
712 if (flags & XFS_QMOPT_ENOSPC)
713 return -ENOSPC;
714 return -EDQUOT;
715 }
716
717
718 /*
719 * Given dquot(s), make disk block and/or inode reservations against them.
720 * The fact that this does the reservation against user, group and
721 * project quotas is important, because this follows a all-or-nothing
722 * approach.
723 *
724 * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown.
725 * XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT. Used by pquota.
726 * XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks
727 * XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks
728 * dquots are unlocked on return, if they were not locked by caller.
729 */
730 int
731 xfs_trans_reserve_quota_bydquots(
732 struct xfs_trans *tp,
733 struct xfs_mount *mp,
734 struct xfs_dquot *udqp,
735 struct xfs_dquot *gdqp,
736 struct xfs_dquot *pdqp,
737 int64_t nblks,
738 long ninos,
739 uint flags)
740 {
741 int error;
742
743 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
744 return 0;
745
746 if (tp && tp->t_dqinfo == NULL)
747 xfs_trans_alloc_dqinfo(tp);
748
749 ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
750
751 if (udqp) {
752 error = xfs_trans_dqresv(tp, mp, udqp, nblks, ninos,
753 (flags & ~XFS_QMOPT_ENOSPC));
754 if (error)
755 return error;
756 }
757
758 if (gdqp) {
759 error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags);
760 if (error)
761 goto unwind_usr;
762 }
763
764 if (pdqp) {
765 error = xfs_trans_dqresv(tp, mp, pdqp, nblks, ninos, flags);
766 if (error)
767 goto unwind_grp;
768 }
769
770 /*
771 * Didn't change anything critical, so, no need to log
772 */
773 return 0;
774
775 unwind_grp:
776 flags |= XFS_QMOPT_FORCE_RES;
777 if (gdqp)
778 xfs_trans_dqresv(tp, mp, gdqp, -nblks, -ninos, flags);
779 unwind_usr:
780 flags |= XFS_QMOPT_FORCE_RES;
781 if (udqp)
782 xfs_trans_dqresv(tp, mp, udqp, -nblks, -ninos, flags);
783 return error;
784 }
785
786
787 /*
788 * Lock the dquot and change the reservation if we can.
789 * This doesn't change the actual usage, just the reservation.
790 * The inode sent in is locked.
791 */
792 int
793 xfs_trans_reserve_quota_nblks(
794 struct xfs_trans *tp,
795 struct xfs_inode *ip,
796 int64_t nblks,
797 long ninos,
798 uint flags)
799 {
800 struct xfs_mount *mp = ip->i_mount;
801
802 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
803 return 0;
804 if (XFS_IS_PQUOTA_ON(mp))
805 flags |= XFS_QMOPT_ENOSPC;
806
807 ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino));
808
809 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
810 ASSERT((flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
811 XFS_TRANS_DQ_RES_RTBLKS ||
812 (flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
813 XFS_TRANS_DQ_RES_BLKS);
814
815 /*
816 * Reserve nblks against these dquots, with trans as the mediator.
817 */
818 return xfs_trans_reserve_quota_bydquots(tp, mp,
819 ip->i_udquot, ip->i_gdquot,
820 ip->i_pdquot,
821 nblks, ninos, flags);
822 }
823
824 /*
825 * This routine is called to allocate a quotaoff log item.
826 */
827 struct xfs_qoff_logitem *
828 xfs_trans_get_qoff_item(
829 struct xfs_trans *tp,
830 struct xfs_qoff_logitem *startqoff,
831 uint flags)
832 {
833 struct xfs_qoff_logitem *q;
834
835 ASSERT(tp != NULL);
836
837 q = xfs_qm_qoff_logitem_init(tp->t_mountp, startqoff, flags);
838 ASSERT(q != NULL);
839
840 /*
841 * Get a log_item_desc to point at the new item.
842 */
843 xfs_trans_add_item(tp, &q->qql_item);
844 return q;
845 }
846
847
848 /*
849 * This is called to mark the quotaoff logitem as needing
850 * to be logged when the transaction is committed. The logitem must
851 * already be associated with the given transaction.
852 */
853 void
854 xfs_trans_log_quotaoff_item(
855 struct xfs_trans *tp,
856 struct xfs_qoff_logitem *qlp)
857 {
858 tp->t_flags |= XFS_TRANS_DIRTY;
859 set_bit(XFS_LI_DIRTY, &qlp->qql_item.li_flags);
860 }
861
862 STATIC void
863 xfs_trans_alloc_dqinfo(
864 xfs_trans_t *tp)
865 {
866 tp->t_dqinfo = kmem_zone_zalloc(xfs_qm_dqtrxzone, 0);
867 }
868
869 void
870 xfs_trans_free_dqinfo(
871 xfs_trans_t *tp)
872 {
873 if (!tp->t_dqinfo)
874 return;
875 kmem_cache_free(xfs_qm_dqtrxzone, tp->t_dqinfo);
876 tp->t_dqinfo = NULL;
877 }
connection oriented routing