Treat writes as new when holes span across page boundaries
[sfrench/cifs-2.6.git] / fs / ocfs2 / quota_global.c
1 /*
2  *  Implementation of operations over global quota file
3  */
4 #include <linux/spinlock.h>
5 #include <linux/fs.h>
6 #include <linux/slab.h>
7 #include <linux/quota.h>
8 #include <linux/quotaops.h>
9 #include <linux/dqblk_qtree.h>
10 #include <linux/jiffies.h>
11 #include <linux/writeback.h>
12 #include <linux/workqueue.h>
13
14 #include <cluster/masklog.h>
15
16 #include "ocfs2_fs.h"
17 #include "ocfs2.h"
18 #include "alloc.h"
19 #include "blockcheck.h"
20 #include "inode.h"
21 #include "journal.h"
22 #include "file.h"
23 #include "sysfile.h"
24 #include "dlmglue.h"
25 #include "uptodate.h"
26 #include "super.h"
27 #include "buffer_head_io.h"
28 #include "quota.h"
29 #include "ocfs2_trace.h"
30
31 /*
32  * Locking of quotas with OCFS2 is rather complex. Here are rules that
33  * should be obeyed by all the functions:
34  * - any write of quota structure (either to local or global file) is protected
35  *   by dqio_mutex or dquot->dq_lock.
36  * - any modification of global quota file holds inode cluster lock, i_mutex,
37  *   and ip_alloc_sem of the global quota file (achieved by
38  *   ocfs2_lock_global_qf). It also has to hold qinfo_lock.
39  * - an allocation of new blocks for local quota file is protected by
40  *   its ip_alloc_sem
41  *
42  * A rough sketch of locking dependencies (lf = local file, gf = global file):
43  * Normal filesystem operation:
44  *   start_trans -> dqio_mutex -> write to lf
45  * Syncing of local and global file:
46  *   ocfs2_lock_global_qf -> start_trans -> dqio_mutex -> qinfo_lock ->
47  *     write to gf
48  *                                                     -> write to lf
49  * Acquire dquot for the first time:
50  *   dq_lock -> ocfs2_lock_global_qf -> qinfo_lock -> read from gf
51  *                                   -> alloc space for gf
52  *                                   -> start_trans -> qinfo_lock -> write to gf
53  *           -> ip_alloc_sem of lf -> alloc space for lf
54  *           -> write to lf
55  * Release last reference to dquot:
56  *   dq_lock -> ocfs2_lock_global_qf -> start_trans -> qinfo_lock -> write to gf
57  *           -> write to lf
58  * Note that all the above operations also hold the inode cluster lock of lf.
59  * Recovery:
60  *   inode cluster lock of recovered lf
61  *     -> read bitmaps -> ip_alloc_sem of lf
62  *     -> ocfs2_lock_global_qf -> start_trans -> dqio_mutex -> qinfo_lock ->
63  *        write to gf
64  */
65
66 static struct workqueue_struct *ocfs2_quota_wq = NULL;
67
68 static void qsync_work_fn(struct work_struct *work);
69
70 static void ocfs2_global_disk2memdqb(struct dquot *dquot, void *dp)
71 {
72         struct ocfs2_global_disk_dqblk *d = dp;
73         struct mem_dqblk *m = &dquot->dq_dqb;
74
75         /* Update from disk only entries not set by the admin */
76         if (!test_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags)) {
77                 m->dqb_ihardlimit = le64_to_cpu(d->dqb_ihardlimit);
78                 m->dqb_isoftlimit = le64_to_cpu(d->dqb_isoftlimit);
79         }
80         if (!test_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags))
81                 m->dqb_curinodes = le64_to_cpu(d->dqb_curinodes);
82         if (!test_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags)) {
83                 m->dqb_bhardlimit = le64_to_cpu(d->dqb_bhardlimit);
84                 m->dqb_bsoftlimit = le64_to_cpu(d->dqb_bsoftlimit);
85         }
86         if (!test_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags))
87                 m->dqb_curspace = le64_to_cpu(d->dqb_curspace);
88         if (!test_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags))
89                 m->dqb_btime = le64_to_cpu(d->dqb_btime);
90         if (!test_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags))
91                 m->dqb_itime = le64_to_cpu(d->dqb_itime);
92         OCFS2_DQUOT(dquot)->dq_use_count = le32_to_cpu(d->dqb_use_count);
93 }
94
95 static void ocfs2_global_mem2diskdqb(void *dp, struct dquot *dquot)
96 {
97         struct ocfs2_global_disk_dqblk *d = dp;
98         struct mem_dqblk *m = &dquot->dq_dqb;
99
100         d->dqb_id = cpu_to_le32(dquot->dq_id);
101         d->dqb_use_count = cpu_to_le32(OCFS2_DQUOT(dquot)->dq_use_count);
102         d->dqb_ihardlimit = cpu_to_le64(m->dqb_ihardlimit);
103         d->dqb_isoftlimit = cpu_to_le64(m->dqb_isoftlimit);
104         d->dqb_curinodes = cpu_to_le64(m->dqb_curinodes);
105         d->dqb_bhardlimit = cpu_to_le64(m->dqb_bhardlimit);
106         d->dqb_bsoftlimit = cpu_to_le64(m->dqb_bsoftlimit);
107         d->dqb_curspace = cpu_to_le64(m->dqb_curspace);
108         d->dqb_btime = cpu_to_le64(m->dqb_btime);
109         d->dqb_itime = cpu_to_le64(m->dqb_itime);
110         d->dqb_pad1 = d->dqb_pad2 = 0;
111 }
112
113 static int ocfs2_global_is_id(void *dp, struct dquot *dquot)
114 {
115         struct ocfs2_global_disk_dqblk *d = dp;
116         struct ocfs2_mem_dqinfo *oinfo =
117                         sb_dqinfo(dquot->dq_sb, dquot->dq_type)->dqi_priv;
118
119         if (qtree_entry_unused(&oinfo->dqi_gi, dp))
120                 return 0;
121         return le32_to_cpu(d->dqb_id) == dquot->dq_id;
122 }
123
124 struct qtree_fmt_operations ocfs2_global_ops = {
125         .mem2disk_dqblk = ocfs2_global_mem2diskdqb,
126         .disk2mem_dqblk = ocfs2_global_disk2memdqb,
127         .is_id = ocfs2_global_is_id,
128 };
129
130 int ocfs2_validate_quota_block(struct super_block *sb, struct buffer_head *bh)
131 {
132         struct ocfs2_disk_dqtrailer *dqt =
133                 ocfs2_block_dqtrailer(sb->s_blocksize, bh->b_data);
134
135         trace_ocfs2_validate_quota_block((unsigned long long)bh->b_blocknr);
136
137         BUG_ON(!buffer_uptodate(bh));
138
139         /*
140          * If the ecc fails, we return the error but otherwise
141          * leave the filesystem running.  We know any error is
142          * local to this block.
143          */
144         return ocfs2_validate_meta_ecc(sb, bh->b_data, &dqt->dq_check);
145 }
146
147 int ocfs2_read_quota_phys_block(struct inode *inode, u64 p_block,
148                                 struct buffer_head **bhp)
149 {
150         int rc;
151
152         *bhp = NULL;
153         rc = ocfs2_read_blocks(INODE_CACHE(inode), p_block, 1, bhp, 0,
154                                ocfs2_validate_quota_block);
155         if (rc)
156                 mlog_errno(rc);
157         return rc;
158 }
159
160 /* Read data from global quotafile - avoid pagecache and such because we cannot
161  * afford acquiring the locks... We use quota cluster lock to serialize
162  * operations. Caller is responsible for acquiring it. */
163 ssize_t ocfs2_quota_read(struct super_block *sb, int type, char *data,
164                          size_t len, loff_t off)
165 {
166         struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv;
167         struct inode *gqinode = oinfo->dqi_gqinode;
168         loff_t i_size = i_size_read(gqinode);
169         int offset = off & (sb->s_blocksize - 1);
170         sector_t blk = off >> sb->s_blocksize_bits;
171         int err = 0;
172         struct buffer_head *bh;
173         size_t toread, tocopy;
174         u64 pblock = 0, pcount = 0;
175
176         if (off > i_size)
177                 return 0;
178         if (off + len > i_size)
179                 len = i_size - off;
180         toread = len;
181         while (toread > 0) {
182                 tocopy = min_t(size_t, (sb->s_blocksize - offset), toread);
183                 if (!pcount) {
184                         err = ocfs2_extent_map_get_blocks(gqinode, blk, &pblock,
185                                                           &pcount, NULL);
186                         if (err) {
187                                 mlog_errno(err);
188                                 return err;
189                         }
190                 } else {
191                         pcount--;
192                         pblock++;
193                 }
194                 bh = NULL;
195                 err = ocfs2_read_quota_phys_block(gqinode, pblock, &bh);
196                 if (err) {
197                         mlog_errno(err);
198                         return err;
199                 }
200                 memcpy(data, bh->b_data + offset, tocopy);
201                 brelse(bh);
202                 offset = 0;
203                 toread -= tocopy;
204                 data += tocopy;
205                 blk++;
206         }
207         return len;
208 }
209
210 /* Write to quotafile (we know the transaction is already started and has
211  * enough credits) */
212 ssize_t ocfs2_quota_write(struct super_block *sb, int type,
213                           const char *data, size_t len, loff_t off)
214 {
215         struct mem_dqinfo *info = sb_dqinfo(sb, type);
216         struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
217         struct inode *gqinode = oinfo->dqi_gqinode;
218         int offset = off & (sb->s_blocksize - 1);
219         sector_t blk = off >> sb->s_blocksize_bits;
220         int err = 0, new = 0, ja_type;
221         struct buffer_head *bh = NULL;
222         handle_t *handle = journal_current_handle();
223         u64 pblock, pcount;
224
225         if (!handle) {
226                 mlog(ML_ERROR, "Quota write (off=%llu, len=%llu) cancelled "
227                      "because transaction was not started.\n",
228                      (unsigned long long)off, (unsigned long long)len);
229                 return -EIO;
230         }
231         if (len > sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE - offset) {
232                 WARN_ON(1);
233                 len = sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE - offset;
234         }
235
236         if (gqinode->i_size < off + len) {
237                 loff_t rounded_end =
238                                 ocfs2_align_bytes_to_blocks(sb, off + len);
239
240                 /* Space is already allocated in ocfs2_acquire_dquot() */
241                 err = ocfs2_simple_size_update(gqinode,
242                                                oinfo->dqi_gqi_bh,
243                                                rounded_end);
244                 if (err < 0)
245                         goto out;
246                 new = 1;
247         }
248         err = ocfs2_extent_map_get_blocks(gqinode, blk, &pblock, &pcount, NULL);
249         if (err) {
250                 mlog_errno(err);
251                 goto out;
252         }
253         /* Not rewriting whole block? */
254         if ((offset || len < sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE) &&
255             !new) {
256                 err = ocfs2_read_quota_phys_block(gqinode, pblock, &bh);
257                 ja_type = OCFS2_JOURNAL_ACCESS_WRITE;
258         } else {
259                 bh = sb_getblk(sb, pblock);
260                 if (!bh)
261                         err = -ENOMEM;
262                 ja_type = OCFS2_JOURNAL_ACCESS_CREATE;
263         }
264         if (err) {
265                 mlog_errno(err);
266                 goto out;
267         }
268         lock_buffer(bh);
269         if (new)
270                 memset(bh->b_data, 0, sb->s_blocksize);
271         memcpy(bh->b_data + offset, data, len);
272         flush_dcache_page(bh->b_page);
273         set_buffer_uptodate(bh);
274         unlock_buffer(bh);
275         ocfs2_set_buffer_uptodate(INODE_CACHE(gqinode), bh);
276         err = ocfs2_journal_access_dq(handle, INODE_CACHE(gqinode), bh,
277                                       ja_type);
278         if (err < 0) {
279                 brelse(bh);
280                 goto out;
281         }
282         ocfs2_journal_dirty(handle, bh);
283         brelse(bh);
284 out:
285         if (err) {
286                 mlog_errno(err);
287                 return err;
288         }
289         gqinode->i_version++;
290         ocfs2_mark_inode_dirty(handle, gqinode, oinfo->dqi_gqi_bh);
291         return len;
292 }
293
294 int ocfs2_lock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex)
295 {
296         int status;
297         struct buffer_head *bh = NULL;
298
299         status = ocfs2_inode_lock(oinfo->dqi_gqinode, &bh, ex);
300         if (status < 0)
301                 return status;
302         spin_lock(&dq_data_lock);
303         if (!oinfo->dqi_gqi_count++)
304                 oinfo->dqi_gqi_bh = bh;
305         else
306                 WARN_ON(bh != oinfo->dqi_gqi_bh);
307         spin_unlock(&dq_data_lock);
308         if (ex) {
309                 mutex_lock(&oinfo->dqi_gqinode->i_mutex);
310                 down_write(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem);
311         } else {
312                 down_read(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem);
313         }
314         return 0;
315 }
316
317 void ocfs2_unlock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex)
318 {
319         if (ex) {
320                 up_write(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem);
321                 mutex_unlock(&oinfo->dqi_gqinode->i_mutex);
322         } else {
323                 up_read(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem);
324         }
325         ocfs2_inode_unlock(oinfo->dqi_gqinode, ex);
326         brelse(oinfo->dqi_gqi_bh);
327         spin_lock(&dq_data_lock);
328         if (!--oinfo->dqi_gqi_count)
329                 oinfo->dqi_gqi_bh = NULL;
330         spin_unlock(&dq_data_lock);
331 }
332
333 /* Read information header from global quota file */
334 int ocfs2_global_read_info(struct super_block *sb, int type)
335 {
336         struct inode *gqinode = NULL;
337         unsigned int ino[MAXQUOTAS] = { USER_QUOTA_SYSTEM_INODE,
338                                         GROUP_QUOTA_SYSTEM_INODE };
339         struct ocfs2_global_disk_dqinfo dinfo;
340         struct mem_dqinfo *info = sb_dqinfo(sb, type);
341         struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
342         u64 pcount;
343         int status;
344
345         /* Read global header */
346         gqinode = ocfs2_get_system_file_inode(OCFS2_SB(sb), ino[type],
347                         OCFS2_INVALID_SLOT);
348         if (!gqinode) {
349                 mlog(ML_ERROR, "failed to get global quota inode (type=%d)\n",
350                         type);
351                 status = -EINVAL;
352                 goto out_err;
353         }
354         oinfo->dqi_gi.dqi_sb = sb;
355         oinfo->dqi_gi.dqi_type = type;
356         ocfs2_qinfo_lock_res_init(&oinfo->dqi_gqlock, oinfo);
357         oinfo->dqi_gi.dqi_entry_size = sizeof(struct ocfs2_global_disk_dqblk);
358         oinfo->dqi_gi.dqi_ops = &ocfs2_global_ops;
359         oinfo->dqi_gqi_bh = NULL;
360         oinfo->dqi_gqi_count = 0;
361         oinfo->dqi_gqinode = gqinode;
362         status = ocfs2_lock_global_qf(oinfo, 0);
363         if (status < 0) {
364                 mlog_errno(status);
365                 goto out_err;
366         }
367
368         status = ocfs2_extent_map_get_blocks(gqinode, 0, &oinfo->dqi_giblk,
369                                              &pcount, NULL);
370         if (status < 0)
371                 goto out_unlock;
372
373         status = ocfs2_qinfo_lock(oinfo, 0);
374         if (status < 0)
375                 goto out_unlock;
376         status = sb->s_op->quota_read(sb, type, (char *)&dinfo,
377                                       sizeof(struct ocfs2_global_disk_dqinfo),
378                                       OCFS2_GLOBAL_INFO_OFF);
379         ocfs2_qinfo_unlock(oinfo, 0);
380         ocfs2_unlock_global_qf(oinfo, 0);
381         if (status != sizeof(struct ocfs2_global_disk_dqinfo)) {
382                 mlog(ML_ERROR, "Cannot read global quota info (%d).\n",
383                      status);
384                 if (status >= 0)
385                         status = -EIO;
386                 mlog_errno(status);
387                 goto out_err;
388         }
389         info->dqi_bgrace = le32_to_cpu(dinfo.dqi_bgrace);
390         info->dqi_igrace = le32_to_cpu(dinfo.dqi_igrace);
391         oinfo->dqi_syncms = le32_to_cpu(dinfo.dqi_syncms);
392         oinfo->dqi_gi.dqi_blocks = le32_to_cpu(dinfo.dqi_blocks);
393         oinfo->dqi_gi.dqi_free_blk = le32_to_cpu(dinfo.dqi_free_blk);
394         oinfo->dqi_gi.dqi_free_entry = le32_to_cpu(dinfo.dqi_free_entry);
395         oinfo->dqi_gi.dqi_blocksize_bits = sb->s_blocksize_bits;
396         oinfo->dqi_gi.dqi_usable_bs = sb->s_blocksize -
397                                                 OCFS2_QBLK_RESERVED_SPACE;
398         oinfo->dqi_gi.dqi_qtree_depth = qtree_depth(&oinfo->dqi_gi);
399         INIT_DELAYED_WORK(&oinfo->dqi_sync_work, qsync_work_fn);
400         queue_delayed_work(ocfs2_quota_wq, &oinfo->dqi_sync_work,
401                            msecs_to_jiffies(oinfo->dqi_syncms));
402
403 out_err:
404         if (status)
405                 mlog_errno(status);
406         return status;
407 out_unlock:
408         ocfs2_unlock_global_qf(oinfo, 0);
409         mlog_errno(status);
410         goto out_err;
411 }
412
413 /* Write information to global quota file. Expects exlusive lock on quota
414  * file inode and quota info */
415 static int __ocfs2_global_write_info(struct super_block *sb, int type)
416 {
417         struct mem_dqinfo *info = sb_dqinfo(sb, type);
418         struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
419         struct ocfs2_global_disk_dqinfo dinfo;
420         ssize_t size;
421
422         spin_lock(&dq_data_lock);
423         info->dqi_flags &= ~DQF_INFO_DIRTY;
424         dinfo.dqi_bgrace = cpu_to_le32(info->dqi_bgrace);
425         dinfo.dqi_igrace = cpu_to_le32(info->dqi_igrace);
426         spin_unlock(&dq_data_lock);
427         dinfo.dqi_syncms = cpu_to_le32(oinfo->dqi_syncms);
428         dinfo.dqi_blocks = cpu_to_le32(oinfo->dqi_gi.dqi_blocks);
429         dinfo.dqi_free_blk = cpu_to_le32(oinfo->dqi_gi.dqi_free_blk);
430         dinfo.dqi_free_entry = cpu_to_le32(oinfo->dqi_gi.dqi_free_entry);
431         size = sb->s_op->quota_write(sb, type, (char *)&dinfo,
432                                      sizeof(struct ocfs2_global_disk_dqinfo),
433                                      OCFS2_GLOBAL_INFO_OFF);
434         if (size != sizeof(struct ocfs2_global_disk_dqinfo)) {
435                 mlog(ML_ERROR, "Cannot write global quota info structure\n");
436                 if (size >= 0)
437                         size = -EIO;
438                 return size;
439         }
440         return 0;
441 }
442
443 int ocfs2_global_write_info(struct super_block *sb, int type)
444 {
445         int err;
446         struct ocfs2_mem_dqinfo *info = sb_dqinfo(sb, type)->dqi_priv;
447
448         err = ocfs2_qinfo_lock(info, 1);
449         if (err < 0)
450                 return err;
451         err = __ocfs2_global_write_info(sb, type);
452         ocfs2_qinfo_unlock(info, 1);
453         return err;
454 }
455
456 static int ocfs2_global_qinit_alloc(struct super_block *sb, int type)
457 {
458         struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv;
459
460         /*
461          * We may need to allocate tree blocks and a leaf block but not the
462          * root block
463          */
464         return oinfo->dqi_gi.dqi_qtree_depth;
465 }
466
467 static int ocfs2_calc_global_qinit_credits(struct super_block *sb, int type)
468 {
469         /* We modify all the allocated blocks, tree root, info block and
470          * the inode */
471         return (ocfs2_global_qinit_alloc(sb, type) + 2) *
472                         OCFS2_QUOTA_BLOCK_UPDATE_CREDITS + 1;
473 }
474
475 /* Sync local information about quota modifications with global quota file.
476  * Caller must have started the transaction and obtained exclusive lock for
477  * global quota file inode */
478 int __ocfs2_sync_dquot(struct dquot *dquot, int freeing)
479 {
480         int err, err2;
481         struct super_block *sb = dquot->dq_sb;
482         int type = dquot->dq_type;
483         struct ocfs2_mem_dqinfo *info = sb_dqinfo(sb, type)->dqi_priv;
484         struct ocfs2_global_disk_dqblk dqblk;
485         s64 spacechange, inodechange;
486         time_t olditime, oldbtime;
487
488         err = sb->s_op->quota_read(sb, type, (char *)&dqblk,
489                                    sizeof(struct ocfs2_global_disk_dqblk),
490                                    dquot->dq_off);
491         if (err != sizeof(struct ocfs2_global_disk_dqblk)) {
492                 if (err >= 0) {
493                         mlog(ML_ERROR, "Short read from global quota file "
494                                        "(%u read)\n", err);
495                         err = -EIO;
496                 }
497                 goto out;
498         }
499
500         /* Update space and inode usage. Get also other information from
501          * global quota file so that we don't overwrite any changes there.
502          * We are */
503         spin_lock(&dq_data_lock);
504         spacechange = dquot->dq_dqb.dqb_curspace -
505                                         OCFS2_DQUOT(dquot)->dq_origspace;
506         inodechange = dquot->dq_dqb.dqb_curinodes -
507                                         OCFS2_DQUOT(dquot)->dq_originodes;
508         olditime = dquot->dq_dqb.dqb_itime;
509         oldbtime = dquot->dq_dqb.dqb_btime;
510         ocfs2_global_disk2memdqb(dquot, &dqblk);
511         trace_ocfs2_sync_dquot(dquot->dq_id, dquot->dq_dqb.dqb_curspace,
512                                (long long)spacechange,
513                                dquot->dq_dqb.dqb_curinodes,
514                                (long long)inodechange);
515         if (!test_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags))
516                 dquot->dq_dqb.dqb_curspace += spacechange;
517         if (!test_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags))
518                 dquot->dq_dqb.dqb_curinodes += inodechange;
519         /* Set properly space grace time... */
520         if (dquot->dq_dqb.dqb_bsoftlimit &&
521             dquot->dq_dqb.dqb_curspace > dquot->dq_dqb.dqb_bsoftlimit) {
522                 if (!test_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags) &&
523                     oldbtime > 0) {
524                         if (dquot->dq_dqb.dqb_btime > 0)
525                                 dquot->dq_dqb.dqb_btime =
526                                         min(dquot->dq_dqb.dqb_btime, oldbtime);
527                         else
528                                 dquot->dq_dqb.dqb_btime = oldbtime;
529                 }
530         } else {
531                 dquot->dq_dqb.dqb_btime = 0;
532                 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
533         }
534         /* Set properly inode grace time... */
535         if (dquot->dq_dqb.dqb_isoftlimit &&
536             dquot->dq_dqb.dqb_curinodes > dquot->dq_dqb.dqb_isoftlimit) {
537                 if (!test_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags) &&
538                     olditime > 0) {
539                         if (dquot->dq_dqb.dqb_itime > 0)
540                                 dquot->dq_dqb.dqb_itime =
541                                         min(dquot->dq_dqb.dqb_itime, olditime);
542                         else
543                                 dquot->dq_dqb.dqb_itime = olditime;
544                 }
545         } else {
546                 dquot->dq_dqb.dqb_itime = 0;
547                 clear_bit(DQ_INODES_B, &dquot->dq_flags);
548         }
549         /* All information is properly updated, clear the flags */
550         __clear_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
551         __clear_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
552         __clear_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
553         __clear_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
554         __clear_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
555         __clear_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
556         OCFS2_DQUOT(dquot)->dq_origspace = dquot->dq_dqb.dqb_curspace;
557         OCFS2_DQUOT(dquot)->dq_originodes = dquot->dq_dqb.dqb_curinodes;
558         spin_unlock(&dq_data_lock);
559         err = ocfs2_qinfo_lock(info, freeing);
560         if (err < 0) {
561                 mlog(ML_ERROR, "Failed to lock quota info, loosing quota write"
562                                " (type=%d, id=%u)\n", dquot->dq_type,
563                                (unsigned)dquot->dq_id);
564                 goto out;
565         }
566         if (freeing)
567                 OCFS2_DQUOT(dquot)->dq_use_count--;
568         err = qtree_write_dquot(&info->dqi_gi, dquot);
569         if (err < 0)
570                 goto out_qlock;
571         if (freeing && !OCFS2_DQUOT(dquot)->dq_use_count) {
572                 err = qtree_release_dquot(&info->dqi_gi, dquot);
573                 if (info_dirty(sb_dqinfo(sb, type))) {
574                         err2 = __ocfs2_global_write_info(sb, type);
575                         if (!err)
576                                 err = err2;
577                 }
578         }
579 out_qlock:
580         ocfs2_qinfo_unlock(info, freeing);
581 out:
582         if (err < 0)
583                 mlog_errno(err);
584         return err;
585 }
586
587 /*
588  *  Functions for periodic syncing of dquots with global file
589  */
590 static int ocfs2_sync_dquot_helper(struct dquot *dquot, unsigned long type)
591 {
592         handle_t *handle;
593         struct super_block *sb = dquot->dq_sb;
594         struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv;
595         struct ocfs2_super *osb = OCFS2_SB(sb);
596         int status = 0;
597
598         trace_ocfs2_sync_dquot_helper(dquot->dq_id, dquot->dq_type,
599                                       type, sb->s_id);
600         if (type != dquot->dq_type)
601                 goto out;
602         status = ocfs2_lock_global_qf(oinfo, 1);
603         if (status < 0)
604                 goto out;
605
606         handle = ocfs2_start_trans(osb, OCFS2_QSYNC_CREDITS);
607         if (IS_ERR(handle)) {
608                 status = PTR_ERR(handle);
609                 mlog_errno(status);
610                 goto out_ilock;
611         }
612         mutex_lock(&sb_dqopt(sb)->dqio_mutex);
613         status = ocfs2_sync_dquot(dquot);
614         if (status < 0)
615                 mlog_errno(status);
616         /* We have to write local structure as well... */
617         status = ocfs2_local_write_dquot(dquot);
618         if (status < 0)
619                 mlog_errno(status);
620         mutex_unlock(&sb_dqopt(sb)->dqio_mutex);
621         ocfs2_commit_trans(osb, handle);
622 out_ilock:
623         ocfs2_unlock_global_qf(oinfo, 1);
624 out:
625         return status;
626 }
627
628 static void qsync_work_fn(struct work_struct *work)
629 {
630         struct ocfs2_mem_dqinfo *oinfo = container_of(work,
631                                                       struct ocfs2_mem_dqinfo,
632                                                       dqi_sync_work.work);
633         struct super_block *sb = oinfo->dqi_gqinode->i_sb;
634
635         dquot_scan_active(sb, ocfs2_sync_dquot_helper, oinfo->dqi_type);
636         queue_delayed_work(ocfs2_quota_wq, &oinfo->dqi_sync_work,
637                            msecs_to_jiffies(oinfo->dqi_syncms));
638 }
639
640 /*
641  *  Wrappers for generic quota functions
642  */
643
644 static int ocfs2_write_dquot(struct dquot *dquot)
645 {
646         handle_t *handle;
647         struct ocfs2_super *osb = OCFS2_SB(dquot->dq_sb);
648         int status = 0;
649
650         trace_ocfs2_write_dquot(dquot->dq_id, dquot->dq_type);
651
652         handle = ocfs2_start_trans(osb, OCFS2_QWRITE_CREDITS);
653         if (IS_ERR(handle)) {
654                 status = PTR_ERR(handle);
655                 mlog_errno(status);
656                 goto out;
657         }
658         mutex_lock(&sb_dqopt(dquot->dq_sb)->dqio_mutex);
659         status = ocfs2_local_write_dquot(dquot);
660         mutex_unlock(&sb_dqopt(dquot->dq_sb)->dqio_mutex);
661         ocfs2_commit_trans(osb, handle);
662 out:
663         return status;
664 }
665
666 static int ocfs2_calc_qdel_credits(struct super_block *sb, int type)
667 {
668         struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv;
669         /*
670          * We modify tree, leaf block, global info, local chunk header,
671          * global and local inode; OCFS2_QINFO_WRITE_CREDITS already
672          * accounts for inode update
673          */
674         return (oinfo->dqi_gi.dqi_qtree_depth + 2) *
675                OCFS2_QUOTA_BLOCK_UPDATE_CREDITS +
676                OCFS2_QINFO_WRITE_CREDITS +
677                OCFS2_INODE_UPDATE_CREDITS;
678 }
679
680 static int ocfs2_release_dquot(struct dquot *dquot)
681 {
682         handle_t *handle;
683         struct ocfs2_mem_dqinfo *oinfo =
684                         sb_dqinfo(dquot->dq_sb, dquot->dq_type)->dqi_priv;
685         struct ocfs2_super *osb = OCFS2_SB(dquot->dq_sb);
686         int status = 0;
687
688         trace_ocfs2_release_dquot(dquot->dq_id, dquot->dq_type);
689
690         mutex_lock(&dquot->dq_lock);
691         /* Check whether we are not racing with some other dqget() */
692         if (atomic_read(&dquot->dq_count) > 1)
693                 goto out;
694         status = ocfs2_lock_global_qf(oinfo, 1);
695         if (status < 0)
696                 goto out;
697         handle = ocfs2_start_trans(osb,
698                 ocfs2_calc_qdel_credits(dquot->dq_sb, dquot->dq_type));
699         if (IS_ERR(handle)) {
700                 status = PTR_ERR(handle);
701                 mlog_errno(status);
702                 goto out_ilock;
703         }
704
705         status = ocfs2_global_release_dquot(dquot);
706         if (status < 0) {
707                 mlog_errno(status);
708                 goto out_trans;
709         }
710         status = ocfs2_local_release_dquot(handle, dquot);
711         /*
712          * If we fail here, we cannot do much as global structure is
713          * already released. So just complain...
714          */
715         if (status < 0)
716                 mlog_errno(status);
717         clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
718 out_trans:
719         ocfs2_commit_trans(osb, handle);
720 out_ilock:
721         ocfs2_unlock_global_qf(oinfo, 1);
722 out:
723         mutex_unlock(&dquot->dq_lock);
724         if (status)
725                 mlog_errno(status);
726         return status;
727 }
728
729 /*
730  * Read global dquot structure from disk or create it if it does
731  * not exist. Also update use count of the global structure and
732  * create structure in node-local quota file.
733  */
734 static int ocfs2_acquire_dquot(struct dquot *dquot)
735 {
736         int status = 0, err;
737         int ex = 0;
738         struct super_block *sb = dquot->dq_sb;
739         struct ocfs2_super *osb = OCFS2_SB(sb);
740         int type = dquot->dq_type;
741         struct ocfs2_mem_dqinfo *info = sb_dqinfo(sb, type)->dqi_priv;
742         struct inode *gqinode = info->dqi_gqinode;
743         int need_alloc = ocfs2_global_qinit_alloc(sb, type);
744         handle_t *handle;
745
746         trace_ocfs2_acquire_dquot(dquot->dq_id, type);
747         mutex_lock(&dquot->dq_lock);
748         /*
749          * We need an exclusive lock, because we're going to update use count
750          * and instantiate possibly new dquot structure
751          */
752         status = ocfs2_lock_global_qf(info, 1);
753         if (status < 0)
754                 goto out;
755         if (!test_bit(DQ_READ_B, &dquot->dq_flags)) {
756                 status = ocfs2_qinfo_lock(info, 0);
757                 if (status < 0)
758                         goto out_dq;
759                 status = qtree_read_dquot(&info->dqi_gi, dquot);
760                 ocfs2_qinfo_unlock(info, 0);
761                 if (status < 0)
762                         goto out_dq;
763         }
764         set_bit(DQ_READ_B, &dquot->dq_flags);
765
766         OCFS2_DQUOT(dquot)->dq_use_count++;
767         OCFS2_DQUOT(dquot)->dq_origspace = dquot->dq_dqb.dqb_curspace;
768         OCFS2_DQUOT(dquot)->dq_originodes = dquot->dq_dqb.dqb_curinodes;
769         if (!dquot->dq_off) {   /* No real quota entry? */
770                 ex = 1;
771                 /*
772                  * Add blocks to quota file before we start a transaction since
773                  * locking allocators ranks above a transaction start
774                  */
775                 WARN_ON(journal_current_handle());
776                 status = ocfs2_extend_no_holes(gqinode, NULL,
777                         gqinode->i_size + (need_alloc << sb->s_blocksize_bits),
778                         gqinode->i_size);
779                 if (status < 0)
780                         goto out_dq;
781         }
782
783         handle = ocfs2_start_trans(osb,
784                                    ocfs2_calc_global_qinit_credits(sb, type));
785         if (IS_ERR(handle)) {
786                 status = PTR_ERR(handle);
787                 goto out_dq;
788         }
789         status = ocfs2_qinfo_lock(info, ex);
790         if (status < 0)
791                 goto out_trans;
792         status = qtree_write_dquot(&info->dqi_gi, dquot);
793         if (ex && info_dirty(sb_dqinfo(sb, type))) {
794                 err = __ocfs2_global_write_info(sb, type);
795                 if (!status)
796                         status = err;
797         }
798         ocfs2_qinfo_unlock(info, ex);
799 out_trans:
800         ocfs2_commit_trans(osb, handle);
801 out_dq:
802         ocfs2_unlock_global_qf(info, 1);
803         if (status < 0)
804                 goto out;
805
806         status = ocfs2_create_local_dquot(dquot);
807         if (status < 0)
808                 goto out;
809         set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
810 out:
811         mutex_unlock(&dquot->dq_lock);
812         if (status)
813                 mlog_errno(status);
814         return status;
815 }
816
817 static int ocfs2_mark_dquot_dirty(struct dquot *dquot)
818 {
819         unsigned long mask = (1 << (DQ_LASTSET_B + QIF_ILIMITS_B)) |
820                              (1 << (DQ_LASTSET_B + QIF_BLIMITS_B)) |
821                              (1 << (DQ_LASTSET_B + QIF_INODES_B)) |
822                              (1 << (DQ_LASTSET_B + QIF_SPACE_B)) |
823                              (1 << (DQ_LASTSET_B + QIF_BTIME_B)) |
824                              (1 << (DQ_LASTSET_B + QIF_ITIME_B));
825         int sync = 0;
826         int status;
827         struct super_block *sb = dquot->dq_sb;
828         int type = dquot->dq_type;
829         struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv;
830         handle_t *handle;
831         struct ocfs2_super *osb = OCFS2_SB(sb);
832
833         trace_ocfs2_mark_dquot_dirty(dquot->dq_id, type);
834
835         /* In case user set some limits, sync dquot immediately to global
836          * quota file so that information propagates quicker */
837         spin_lock(&dq_data_lock);
838         if (dquot->dq_flags & mask)
839                 sync = 1;
840         spin_unlock(&dq_data_lock);
841         /* This is a slight hack but we can't afford getting global quota
842          * lock if we already have a transaction started. */
843         if (!sync || journal_current_handle()) {
844                 status = ocfs2_write_dquot(dquot);
845                 goto out;
846         }
847         status = ocfs2_lock_global_qf(oinfo, 1);
848         if (status < 0)
849                 goto out;
850         handle = ocfs2_start_trans(osb, OCFS2_QSYNC_CREDITS);
851         if (IS_ERR(handle)) {
852                 status = PTR_ERR(handle);
853                 mlog_errno(status);
854                 goto out_ilock;
855         }
856         mutex_lock(&sb_dqopt(sb)->dqio_mutex);
857         status = ocfs2_sync_dquot(dquot);
858         if (status < 0) {
859                 mlog_errno(status);
860                 goto out_dlock;
861         }
862         /* Now write updated local dquot structure */
863         status = ocfs2_local_write_dquot(dquot);
864 out_dlock:
865         mutex_unlock(&sb_dqopt(sb)->dqio_mutex);
866         ocfs2_commit_trans(osb, handle);
867 out_ilock:
868         ocfs2_unlock_global_qf(oinfo, 1);
869 out:
870         if (status)
871                 mlog_errno(status);
872         return status;
873 }
874
875 /* This should happen only after set_dqinfo(). */
876 static int ocfs2_write_info(struct super_block *sb, int type)
877 {
878         handle_t *handle;
879         int status = 0;
880         struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv;
881
882         status = ocfs2_lock_global_qf(oinfo, 1);
883         if (status < 0)
884                 goto out;
885         handle = ocfs2_start_trans(OCFS2_SB(sb), OCFS2_QINFO_WRITE_CREDITS);
886         if (IS_ERR(handle)) {
887                 status = PTR_ERR(handle);
888                 mlog_errno(status);
889                 goto out_ilock;
890         }
891         status = dquot_commit_info(sb, type);
892         ocfs2_commit_trans(OCFS2_SB(sb), handle);
893 out_ilock:
894         ocfs2_unlock_global_qf(oinfo, 1);
895 out:
896         if (status)
897                 mlog_errno(status);
898         return status;
899 }
900
901 static struct dquot *ocfs2_alloc_dquot(struct super_block *sb, int type)
902 {
903         struct ocfs2_dquot *dquot =
904                                 kmem_cache_zalloc(ocfs2_dquot_cachep, GFP_NOFS);
905
906         if (!dquot)
907                 return NULL;
908         return &dquot->dq_dquot;
909 }
910
911 static void ocfs2_destroy_dquot(struct dquot *dquot)
912 {
913         kmem_cache_free(ocfs2_dquot_cachep, dquot);
914 }
915
916 const struct dquot_operations ocfs2_quota_operations = {
917         /* We never make dquot dirty so .write_dquot is never called */
918         .acquire_dquot  = ocfs2_acquire_dquot,
919         .release_dquot  = ocfs2_release_dquot,
920         .mark_dirty     = ocfs2_mark_dquot_dirty,
921         .write_info     = ocfs2_write_info,
922         .alloc_dquot    = ocfs2_alloc_dquot,
923         .destroy_dquot  = ocfs2_destroy_dquot,
924 };
925
926 int ocfs2_quota_setup(void)
927 {
928         ocfs2_quota_wq = create_workqueue("o2quot");
929         if (!ocfs2_quota_wq)
930                 return -ENOMEM;
931         return 0;
932 }
933
934 void ocfs2_quota_shutdown(void)
935 {
936         if (ocfs2_quota_wq) {
937                 flush_workqueue(ocfs2_quota_wq);
938                 destroy_workqueue(ocfs2_quota_wq);
939                 ocfs2_quota_wq = NULL;
940         }
941 }