Merge commit 'v3.14' into next
[linux-2.6-microblaze.git] / fs / xfs / xfs_dquot_item.c
1 /*
2  * Copyright (c) 2000-2003 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_format.h"
21 #include "xfs_log_format.h"
22 #include "xfs_trans_resv.h"
23 #include "xfs_sb.h"
24 #include "xfs_ag.h"
25 #include "xfs_mount.h"
26 #include "xfs_inode.h"
27 #include "xfs_quota.h"
28 #include "xfs_error.h"
29 #include "xfs_trans.h"
30 #include "xfs_buf_item.h"
31 #include "xfs_trans_priv.h"
32 #include "xfs_qm.h"
33 #include "xfs_log.h"
34
35 static inline struct xfs_dq_logitem *DQUOT_ITEM(struct xfs_log_item *lip)
36 {
37         return container_of(lip, struct xfs_dq_logitem, qli_item);
38 }
39
40 /*
41  * returns the number of iovecs needed to log the given dquot item.
42  */
43 STATIC void
44 xfs_qm_dquot_logitem_size(
45         struct xfs_log_item     *lip,
46         int                     *nvecs,
47         int                     *nbytes)
48 {
49         *nvecs += 2;
50         *nbytes += sizeof(struct xfs_dq_logformat) +
51                    sizeof(struct xfs_disk_dquot);
52 }
53
54 /*
55  * fills in the vector of log iovecs for the given dquot log item.
56  */
57 STATIC void
58 xfs_qm_dquot_logitem_format(
59         struct xfs_log_item     *lip,
60         struct xfs_log_vec      *lv)
61 {
62         struct xfs_dq_logitem   *qlip = DQUOT_ITEM(lip);
63         struct xfs_log_iovec    *vecp = NULL;
64         struct xfs_dq_logformat *qlf;
65
66         qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QFORMAT);
67         qlf->qlf_type = XFS_LI_DQUOT;
68         qlf->qlf_size = 2;
69         qlf->qlf_id = be32_to_cpu(qlip->qli_dquot->q_core.d_id);
70         qlf->qlf_blkno = qlip->qli_dquot->q_blkno;
71         qlf->qlf_len = 1;
72         qlf->qlf_boffset = qlip->qli_dquot->q_bufoffset;
73         xlog_finish_iovec(lv, vecp, sizeof(struct xfs_dq_logformat));
74
75         xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_DQUOT,
76                         &qlip->qli_dquot->q_core,
77                         sizeof(struct xfs_disk_dquot));
78 }
79
80 /*
81  * Increment the pin count of the given dquot.
82  */
83 STATIC void
84 xfs_qm_dquot_logitem_pin(
85         struct xfs_log_item     *lip)
86 {
87         struct xfs_dquot        *dqp = DQUOT_ITEM(lip)->qli_dquot;
88
89         ASSERT(XFS_DQ_IS_LOCKED(dqp));
90         atomic_inc(&dqp->q_pincount);
91 }
92
93 /*
94  * Decrement the pin count of the given dquot, and wake up
95  * anyone in xfs_dqwait_unpin() if the count goes to 0.  The
96  * dquot must have been previously pinned with a call to
97  * xfs_qm_dquot_logitem_pin().
98  */
99 STATIC void
100 xfs_qm_dquot_logitem_unpin(
101         struct xfs_log_item     *lip,
102         int                     remove)
103 {
104         struct xfs_dquot        *dqp = DQUOT_ITEM(lip)->qli_dquot;
105
106         ASSERT(atomic_read(&dqp->q_pincount) > 0);
107         if (atomic_dec_and_test(&dqp->q_pincount))
108                 wake_up(&dqp->q_pinwait);
109 }
110
111 STATIC xfs_lsn_t
112 xfs_qm_dquot_logitem_committed(
113         struct xfs_log_item     *lip,
114         xfs_lsn_t               lsn)
115 {
116         /*
117          * We always re-log the entire dquot when it becomes dirty,
118          * so, the latest copy _is_ the only one that matters.
119          */
120         return lsn;
121 }
122
123 /*
124  * This is called to wait for the given dquot to be unpinned.
125  * Most of these pin/unpin routines are plagiarized from inode code.
126  */
127 void
128 xfs_qm_dqunpin_wait(
129         struct xfs_dquot        *dqp)
130 {
131         ASSERT(XFS_DQ_IS_LOCKED(dqp));
132         if (atomic_read(&dqp->q_pincount) == 0)
133                 return;
134
135         /*
136          * Give the log a push so we don't wait here too long.
137          */
138         xfs_log_force(dqp->q_mount, 0);
139         wait_event(dqp->q_pinwait, (atomic_read(&dqp->q_pincount) == 0));
140 }
141
142 STATIC uint
143 xfs_qm_dquot_logitem_push(
144         struct xfs_log_item     *lip,
145         struct list_head        *buffer_list) __releases(&lip->li_ailp->xa_lock)
146                                               __acquires(&lip->li_ailp->xa_lock)
147 {
148         struct xfs_dquot        *dqp = DQUOT_ITEM(lip)->qli_dquot;
149         struct xfs_buf          *bp = NULL;
150         uint                    rval = XFS_ITEM_SUCCESS;
151         int                     error;
152
153         if (atomic_read(&dqp->q_pincount) > 0)
154                 return XFS_ITEM_PINNED;
155
156         if (!xfs_dqlock_nowait(dqp))
157                 return XFS_ITEM_LOCKED;
158
159         /*
160          * Re-check the pincount now that we stabilized the value by
161          * taking the quota lock.
162          */
163         if (atomic_read(&dqp->q_pincount) > 0) {
164                 rval = XFS_ITEM_PINNED;
165                 goto out_unlock;
166         }
167
168         /*
169          * Someone else is already flushing the dquot.  Nothing we can do
170          * here but wait for the flush to finish and remove the item from
171          * the AIL.
172          */
173         if (!xfs_dqflock_nowait(dqp)) {
174                 rval = XFS_ITEM_FLUSHING;
175                 goto out_unlock;
176         }
177
178         spin_unlock(&lip->li_ailp->xa_lock);
179
180         error = xfs_qm_dqflush(dqp, &bp);
181         if (error) {
182                 xfs_warn(dqp->q_mount, "%s: push error %d on dqp %p",
183                         __func__, error, dqp);
184         } else {
185                 if (!xfs_buf_delwri_queue(bp, buffer_list))
186                         rval = XFS_ITEM_FLUSHING;
187                 xfs_buf_relse(bp);
188         }
189
190         spin_lock(&lip->li_ailp->xa_lock);
191 out_unlock:
192         xfs_dqunlock(dqp);
193         return rval;
194 }
195
196 /*
197  * Unlock the dquot associated with the log item.
198  * Clear the fields of the dquot and dquot log item that
199  * are specific to the current transaction.  If the
200  * hold flags is set, do not unlock the dquot.
201  */
202 STATIC void
203 xfs_qm_dquot_logitem_unlock(
204         struct xfs_log_item     *lip)
205 {
206         struct xfs_dquot        *dqp = DQUOT_ITEM(lip)->qli_dquot;
207
208         ASSERT(XFS_DQ_IS_LOCKED(dqp));
209
210         /*
211          * Clear the transaction pointer in the dquot
212          */
213         dqp->q_transp = NULL;
214
215         /*
216          * dquots are never 'held' from getting unlocked at the end of
217          * a transaction.  Their locking and unlocking is hidden inside the
218          * transaction layer, within trans_commit. Hence, no LI_HOLD flag
219          * for the logitem.
220          */
221         xfs_dqunlock(dqp);
222 }
223
224 /*
225  * this needs to stamp an lsn into the dquot, I think.
226  * rpc's that look at user dquot's would then have to
227  * push on the dependency recorded in the dquot
228  */
229 STATIC void
230 xfs_qm_dquot_logitem_committing(
231         struct xfs_log_item     *lip,
232         xfs_lsn_t               lsn)
233 {
234 }
235
236 /*
237  * This is the ops vector for dquots
238  */
239 static const struct xfs_item_ops xfs_dquot_item_ops = {
240         .iop_size       = xfs_qm_dquot_logitem_size,
241         .iop_format     = xfs_qm_dquot_logitem_format,
242         .iop_pin        = xfs_qm_dquot_logitem_pin,
243         .iop_unpin      = xfs_qm_dquot_logitem_unpin,
244         .iop_unlock     = xfs_qm_dquot_logitem_unlock,
245         .iop_committed  = xfs_qm_dquot_logitem_committed,
246         .iop_push       = xfs_qm_dquot_logitem_push,
247         .iop_committing = xfs_qm_dquot_logitem_committing
248 };
249
250 /*
251  * Initialize the dquot log item for a newly allocated dquot.
252  * The dquot isn't locked at this point, but it isn't on any of the lists
253  * either, so we don't care.
254  */
255 void
256 xfs_qm_dquot_logitem_init(
257         struct xfs_dquot        *dqp)
258 {
259         struct xfs_dq_logitem   *lp = &dqp->q_logitem;
260
261         xfs_log_item_init(dqp->q_mount, &lp->qli_item, XFS_LI_DQUOT,
262                                         &xfs_dquot_item_ops);
263         lp->qli_dquot = dqp;
264 }
265
266 /*------------------  QUOTAOFF LOG ITEMS  -------------------*/
267
268 static inline struct xfs_qoff_logitem *QOFF_ITEM(struct xfs_log_item *lip)
269 {
270         return container_of(lip, struct xfs_qoff_logitem, qql_item);
271 }
272
273
274 /*
275  * This returns the number of iovecs needed to log the given quotaoff item.
276  * We only need 1 iovec for an quotaoff item.  It just logs the
277  * quotaoff_log_format structure.
278  */
279 STATIC void
280 xfs_qm_qoff_logitem_size(
281         struct xfs_log_item     *lip,
282         int                     *nvecs,
283         int                     *nbytes)
284 {
285         *nvecs += 1;
286         *nbytes += sizeof(struct xfs_qoff_logitem);
287 }
288
289 STATIC void
290 xfs_qm_qoff_logitem_format(
291         struct xfs_log_item     *lip,
292         struct xfs_log_vec      *lv)
293 {
294         struct xfs_qoff_logitem *qflip = QOFF_ITEM(lip);
295         struct xfs_log_iovec    *vecp = NULL;
296         struct xfs_qoff_logformat *qlf;
297
298         qlf = xlog_prepare_iovec(lv, &vecp, XLOG_REG_TYPE_QUOTAOFF);
299         qlf->qf_type = XFS_LI_QUOTAOFF;
300         qlf->qf_size = 1;
301         qlf->qf_flags = qflip->qql_flags;
302         xlog_finish_iovec(lv, vecp, sizeof(struct xfs_qoff_logitem));
303 }
304
305 /*
306  * Pinning has no meaning for an quotaoff item, so just return.
307  */
308 STATIC void
309 xfs_qm_qoff_logitem_pin(
310         struct xfs_log_item     *lip)
311 {
312 }
313
314 /*
315  * Since pinning has no meaning for an quotaoff item, unpinning does
316  * not either.
317  */
318 STATIC void
319 xfs_qm_qoff_logitem_unpin(
320         struct xfs_log_item     *lip,
321         int                     remove)
322 {
323 }
324
325 /*
326  * There isn't much you can do to push a quotaoff item.  It is simply
327  * stuck waiting for the log to be flushed to disk.
328  */
329 STATIC uint
330 xfs_qm_qoff_logitem_push(
331         struct xfs_log_item     *lip,
332         struct list_head        *buffer_list)
333 {
334         return XFS_ITEM_LOCKED;
335 }
336
337 /*
338  * Quotaoff items have no locking or pushing, so return failure
339  * so that the caller doesn't bother with us.
340  */
341 STATIC void
342 xfs_qm_qoff_logitem_unlock(
343         struct xfs_log_item     *lip)
344 {
345 }
346
347 /*
348  * The quotaoff-start-item is logged only once and cannot be moved in the log,
349  * so simply return the lsn at which it's been logged.
350  */
351 STATIC xfs_lsn_t
352 xfs_qm_qoff_logitem_committed(
353         struct xfs_log_item     *lip,
354         xfs_lsn_t               lsn)
355 {
356         return lsn;
357 }
358
359 STATIC xfs_lsn_t
360 xfs_qm_qoffend_logitem_committed(
361         struct xfs_log_item     *lip,
362         xfs_lsn_t               lsn)
363 {
364         struct xfs_qoff_logitem *qfe = QOFF_ITEM(lip);
365         struct xfs_qoff_logitem *qfs = qfe->qql_start_lip;
366         struct xfs_ail          *ailp = qfs->qql_item.li_ailp;
367
368         /*
369          * Delete the qoff-start logitem from the AIL.
370          * xfs_trans_ail_delete() drops the AIL lock.
371          */
372         spin_lock(&ailp->xa_lock);
373         xfs_trans_ail_delete(ailp, &qfs->qql_item, SHUTDOWN_LOG_IO_ERROR);
374
375         kmem_free(qfs);
376         kmem_free(qfe);
377         return (xfs_lsn_t)-1;
378 }
379
380 /*
381  * XXX rcc - don't know quite what to do with this.  I think we can
382  * just ignore it.  The only time that isn't the case is if we allow
383  * the client to somehow see that quotas have been turned off in which
384  * we can't allow that to get back until the quotaoff hits the disk.
385  * So how would that happen?  Also, do we need different routines for
386  * quotaoff start and quotaoff end?  I suspect the answer is yes but
387  * to be sure, I need to look at the recovery code and see how quota off
388  * recovery is handled (do we roll forward or back or do something else).
389  * If we roll forwards or backwards, then we need two separate routines,
390  * one that does nothing and one that stamps in the lsn that matters
391  * (truly makes the quotaoff irrevocable).  If we do something else,
392  * then maybe we don't need two.
393  */
394 STATIC void
395 xfs_qm_qoff_logitem_committing(
396         struct xfs_log_item     *lip,
397         xfs_lsn_t               commit_lsn)
398 {
399 }
400
401 static const struct xfs_item_ops xfs_qm_qoffend_logitem_ops = {
402         .iop_size       = xfs_qm_qoff_logitem_size,
403         .iop_format     = xfs_qm_qoff_logitem_format,
404         .iop_pin        = xfs_qm_qoff_logitem_pin,
405         .iop_unpin      = xfs_qm_qoff_logitem_unpin,
406         .iop_unlock     = xfs_qm_qoff_logitem_unlock,
407         .iop_committed  = xfs_qm_qoffend_logitem_committed,
408         .iop_push       = xfs_qm_qoff_logitem_push,
409         .iop_committing = xfs_qm_qoff_logitem_committing
410 };
411
412 /*
413  * This is the ops vector shared by all quotaoff-start log items.
414  */
415 static const struct xfs_item_ops xfs_qm_qoff_logitem_ops = {
416         .iop_size       = xfs_qm_qoff_logitem_size,
417         .iop_format     = xfs_qm_qoff_logitem_format,
418         .iop_pin        = xfs_qm_qoff_logitem_pin,
419         .iop_unpin      = xfs_qm_qoff_logitem_unpin,
420         .iop_unlock     = xfs_qm_qoff_logitem_unlock,
421         .iop_committed  = xfs_qm_qoff_logitem_committed,
422         .iop_push       = xfs_qm_qoff_logitem_push,
423         .iop_committing = xfs_qm_qoff_logitem_committing
424 };
425
426 /*
427  * Allocate and initialize an quotaoff item of the correct quota type(s).
428  */
429 struct xfs_qoff_logitem *
430 xfs_qm_qoff_logitem_init(
431         struct xfs_mount        *mp,
432         struct xfs_qoff_logitem *start,
433         uint                    flags)
434 {
435         struct xfs_qoff_logitem *qf;
436
437         qf = kmem_zalloc(sizeof(struct xfs_qoff_logitem), KM_SLEEP);
438
439         xfs_log_item_init(mp, &qf->qql_item, XFS_LI_QUOTAOFF, start ?
440                         &xfs_qm_qoffend_logitem_ops : &xfs_qm_qoff_logitem_ops);
441         qf->qql_item.li_mountp = mp;
442         qf->qql_start_lip = start;
443         qf->qql_flags = flags;
444         return qf;
445 }