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