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