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