projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'v3.10.55' into update
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / xfs / xfs_qm.c
1 /*
2 * Copyright (c) 2000-2005 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_trans.h"
23 #include "xfs_sb.h"
24 #include "xfs_ag.h"
25 #include "xfs_alloc.h"
26 #include "xfs_quota.h"
27 #include "xfs_mount.h"
28 #include "xfs_bmap_btree.h"
29 #include "xfs_ialloc_btree.h"
30 #include "xfs_dinode.h"
31 #include "xfs_inode.h"
32 #include "xfs_ialloc.h"
33 #include "xfs_itable.h"
34 #include "xfs_rtalloc.h"
35 #include "xfs_error.h"
36 #include "xfs_bmap.h"
37 #include "xfs_attr.h"
38 #include "xfs_buf_item.h"
39 #include "xfs_trans_space.h"
40 #include "xfs_utils.h"
41 #include "xfs_qm.h"
42 #include "xfs_trace.h"
43 #include "xfs_icache.h"
44 #include "xfs_cksum.h"
45
46 /*
47 * The global quota manager. There is only one of these for the entire
48 * system, _not_ one per file system. XQM keeps track of the overall
49 * quota functionality, including maintaining the freelist and hash
50 * tables of dquots.
51 */
52 STATIC int xfs_qm_init_quotainos(xfs_mount_t *);
53 STATIC int xfs_qm_init_quotainfo(xfs_mount_t *);
54 STATIC int xfs_qm_shake(struct shrinker *, struct shrink_control *);
55
56 /*
57 * We use the batch lookup interface to iterate over the dquots as it
58 * currently is the only interface into the radix tree code that allows
59 * fuzzy lookups instead of exact matches. Holding the lock over multiple
60 * operations is fine as all callers are used either during mount/umount
61 * or quotaoff.
62 */
63 #define XFS_DQ_LOOKUP_BATCH 32
64
65 STATIC int
66 xfs_qm_dquot_walk(
67 struct xfs_mount *mp,
68 int type,
69 int (*execute)(struct xfs_dquot *dqp, void *data),
70 void *data)
71 {
72 struct xfs_quotainfo *qi = mp->m_quotainfo;
73 struct radix_tree_root *tree = XFS_DQUOT_TREE(qi, type);
74 uint32_t next_index;
75 int last_error = 0;
76 int skipped;
77 int nr_found;
78
79 restart:
80 skipped = 0;
81 next_index = 0;
82 nr_found = 0;
83
84 while (1) {
85 struct xfs_dquot *batch[XFS_DQ_LOOKUP_BATCH];
86 int error = 0;
87 int i;
88
89 mutex_lock(&qi->qi_tree_lock);
90 nr_found = radix_tree_gang_lookup(tree, (void **)batch,
91 next_index, XFS_DQ_LOOKUP_BATCH);
92 if (!nr_found) {
93 mutex_unlock(&qi->qi_tree_lock);
94 break;
95 }
96
97 for (i = 0; i < nr_found; i++) {
98 struct xfs_dquot *dqp = batch[i];
99
100 next_index = be32_to_cpu(dqp->q_core.d_id) + 1;
101
102 error = execute(batch[i], data);
103 if (error == EAGAIN) {
104 skipped++;
105 continue;
106 }
107 if (error && last_error != EFSCORRUPTED)
108 last_error = error;
109 }
110
111 mutex_unlock(&qi->qi_tree_lock);
112
113 /* bail out if the filesystem is corrupted. */
114 if (last_error == EFSCORRUPTED) {
115 skipped = 0;
116 break;
117 }
118 }
119
120 if (skipped) {
121 delay(1);
122 goto restart;
123 }
124
125 return last_error;
126 }
127
128
129 /*
130 * Purge a dquot from all tracking data structures and free it.
131 */
132 STATIC int
133 xfs_qm_dqpurge(
134 struct xfs_dquot *dqp,
135 void *data)
136 {
137 struct xfs_mount *mp = dqp->q_mount;
138 struct xfs_quotainfo *qi = mp->m_quotainfo;
139 struct xfs_dquot *gdqp = NULL;
140
141 xfs_dqlock(dqp);
142 if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0) {
143 xfs_dqunlock(dqp);
144 return EAGAIN;
145 }
146
147 /*
148 * If this quota has a group hint attached, prepare for releasing it
149 * now.
150 */
151 gdqp = dqp->q_gdquot;
152 if (gdqp) {
153 xfs_dqlock(gdqp);
154 dqp->q_gdquot = NULL;
155 }
156
157 dqp->dq_flags |= XFS_DQ_FREEING;
158
159 xfs_dqflock(dqp);
160
161 /*
162 * If we are turning this type of quotas off, we don't care
163 * about the dirty metadata sitting in this dquot. OTOH, if
164 * we're unmounting, we do care, so we flush it and wait.
165 */
166 if (XFS_DQ_IS_DIRTY(dqp)) {
167 struct xfs_buf *bp = NULL;
168 int error;
169
170 /*
171 * We don't care about getting disk errors here. We need
172 * to purge this dquot anyway, so we go ahead regardless.
173 */
174 error = xfs_qm_dqflush(dqp, &bp);
175 if (error) {
176 xfs_warn(mp, "%s: dquot %p flush failed",
177 __func__, dqp);
178 } else {
179 error = xfs_bwrite(bp);
180 xfs_buf_relse(bp);
181 }
182 xfs_dqflock(dqp);
183 }
184
185 ASSERT(atomic_read(&dqp->q_pincount) == 0);
186 ASSERT(XFS_FORCED_SHUTDOWN(mp) ||
187 !(dqp->q_logitem.qli_item.li_flags & XFS_LI_IN_AIL));
188
189 xfs_dqfunlock(dqp);
190 xfs_dqunlock(dqp);
191
192 radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags),
193 be32_to_cpu(dqp->q_core.d_id));
194 qi->qi_dquots--;
195
196 /*
197 * We move dquots to the freelist as soon as their reference count
198 * hits zero, so it really should be on the freelist here.
199 */
200 mutex_lock(&qi->qi_lru_lock);
201 ASSERT(!list_empty(&dqp->q_lru));
202 list_del_init(&dqp->q_lru);
203 qi->qi_lru_count--;
204 XFS_STATS_DEC(xs_qm_dquot_unused);
205 mutex_unlock(&qi->qi_lru_lock);
206
207 xfs_qm_dqdestroy(dqp);
208
209 if (gdqp)
210 xfs_qm_dqput(gdqp);
211 return 0;
212 }
213
214 /*
215 * Purge the dquot cache.
216 */
217 void
218 xfs_qm_dqpurge_all(
219 struct xfs_mount *mp,
220 uint flags)
221 {
222 if (flags & XFS_QMOPT_UQUOTA)
223 xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
224 if (flags & XFS_QMOPT_GQUOTA)
225 xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
226 if (flags & XFS_QMOPT_PQUOTA)
227 xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL);
228 }
229
230 /*
231 * Just destroy the quotainfo structure.
232 */
233 void
234 xfs_qm_unmount(
235 struct xfs_mount *mp)
236 {
237 if (mp->m_quotainfo) {
238 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
239 xfs_qm_destroy_quotainfo(mp);
240 }
241 }
242
243
244 /*
245 * This is called from xfs_mountfs to start quotas and initialize all
246 * necessary data structures like quotainfo. This is also responsible for
247 * running a quotacheck as necessary. We are guaranteed that the superblock
248 * is consistently read in at this point.
249 *
250 * If we fail here, the mount will continue with quota turned off. We don't
251 * need to inidicate success or failure at all.
252 */
253 void
254 xfs_qm_mount_quotas(
255 xfs_mount_t *mp)
256 {
257 int error = 0;
258 uint sbf;
259
260 /*
261 * If quotas on realtime volumes is not supported, we disable
262 * quotas immediately.
263 */
264 if (mp->m_sb.sb_rextents) {
265 xfs_notice(mp, "Cannot turn on quotas for realtime filesystem");
266 mp->m_qflags = 0;
267 goto write_changes;
268 }
269
270 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
271
272 /*
273 * Allocate the quotainfo structure inside the mount struct, and
274 * create quotainode(s), and change/rev superblock if necessary.
275 */
276 error = xfs_qm_init_quotainfo(mp);
277 if (error) {
278 /*
279 * We must turn off quotas.
280 */
281 ASSERT(mp->m_quotainfo == NULL);
282 mp->m_qflags = 0;
283 goto write_changes;
284 }
285 /*
286 * If any of the quotas are not consistent, do a quotacheck.
287 */
288 if (XFS_QM_NEED_QUOTACHECK(mp)) {
289 error = xfs_qm_quotacheck(mp);
290 if (error) {
291 /* Quotacheck failed and disabled quotas. */
292 return;
293 }
294 }
295 /*
296 * If one type of quotas is off, then it will lose its
297 * quotachecked status, since we won't be doing accounting for
298 * that type anymore.
299 */
300 if (!XFS_IS_UQUOTA_ON(mp))
301 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
302 if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
303 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
304
305 write_changes:
306 /*
307 * We actually don't have to acquire the m_sb_lock at all.
308 * This can only be called from mount, and that's single threaded. XXX
309 */
310 spin_lock(&mp->m_sb_lock);
311 sbf = mp->m_sb.sb_qflags;
312 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
313 spin_unlock(&mp->m_sb_lock);
314
315 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
316 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
317 /*
318 * We could only have been turning quotas off.
319 * We aren't in very good shape actually because
320 * the incore structures are convinced that quotas are
321 * off, but the on disk superblock doesn't know that !
322 */
323 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
324 xfs_alert(mp, "%s: Superblock update failed!",
325 __func__);
326 }
327 }
328
329 if (error) {
330 xfs_warn(mp, "Failed to initialize disk quotas.");
331 return;
332 }
333 }
334
335 /*
336 * Called from the vfsops layer.
337 */
338 void
339 xfs_qm_unmount_quotas(
340 xfs_mount_t *mp)
341 {
342 /*
343 * Release the dquots that root inode, et al might be holding,
344 * before we flush quotas and blow away the quotainfo structure.
345 */
346 ASSERT(mp->m_rootip);
347 xfs_qm_dqdetach(mp->m_rootip);
348 if (mp->m_rbmip)
349 xfs_qm_dqdetach(mp->m_rbmip);
350 if (mp->m_rsumip)
351 xfs_qm_dqdetach(mp->m_rsumip);
352
353 /*
354 * Release the quota inodes.
355 */
356 if (mp->m_quotainfo) {
357 if (mp->m_quotainfo->qi_uquotaip) {
358 IRELE(mp->m_quotainfo->qi_uquotaip);
359 mp->m_quotainfo->qi_uquotaip = NULL;
360 }
361 if (mp->m_quotainfo->qi_gquotaip) {
362 IRELE(mp->m_quotainfo->qi_gquotaip);
363 mp->m_quotainfo->qi_gquotaip = NULL;
364 }
365 }
366 }
367
368 STATIC int
369 xfs_qm_dqattach_one(
370 xfs_inode_t *ip,
371 xfs_dqid_t id,
372 uint type,
373 uint doalloc,
374 xfs_dquot_t *udqhint, /* hint */
375 xfs_dquot_t **IO_idqpp)
376 {
377 xfs_dquot_t *dqp;
378 int error;
379
380 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
381 error = 0;
382
383 /*
384 * See if we already have it in the inode itself. IO_idqpp is
385 * &i_udquot or &i_gdquot. This made the code look weird, but
386 * made the logic a lot simpler.
387 */
388 dqp = *IO_idqpp;
389 if (dqp) {
390 trace_xfs_dqattach_found(dqp);
391 return 0;
392 }
393
394 /*
395 * udqhint is the i_udquot field in inode, and is non-NULL only
396 * when the type arg is group/project. Its purpose is to save a
397 * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
398 * the user dquot.
399 */
400 if (udqhint) {
401 ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
402 xfs_dqlock(udqhint);
403
404 /*
405 * No need to take dqlock to look at the id.
406 *
407 * The ID can't change until it gets reclaimed, and it won't
408 * be reclaimed as long as we have a ref from inode and we
409 * hold the ilock.
410 */
411 dqp = udqhint->q_gdquot;
412 if (dqp && be32_to_cpu(dqp->q_core.d_id) == id) {
413 ASSERT(*IO_idqpp == NULL);
414
415 *IO_idqpp = xfs_qm_dqhold(dqp);
416 xfs_dqunlock(udqhint);
417 return 0;
418 }
419
420 /*
421 * We can't hold a dquot lock when we call the dqget code.
422 * We'll deadlock in no time, because of (not conforming to)
423 * lock ordering - the inodelock comes before any dquot lock,
424 * and we may drop and reacquire the ilock in xfs_qm_dqget().
425 */
426 xfs_dqunlock(udqhint);
427 }
428
429 /*
430 * Find the dquot from somewhere. This bumps the
431 * reference count of dquot and returns it locked.
432 * This can return ENOENT if dquot didn't exist on
433 * disk and we didn't ask it to allocate;
434 * ESRCH if quotas got turned off suddenly.
435 */
436 error = xfs_qm_dqget(ip->i_mount, ip, id, type,
437 doalloc | XFS_QMOPT_DOWARN, &dqp);
438 if (error)
439 return error;
440
441 trace_xfs_dqattach_get(dqp);
442
443 /*
444 * dqget may have dropped and re-acquired the ilock, but it guarantees
445 * that the dquot returned is the one that should go in the inode.
446 */
447 *IO_idqpp = dqp;
448 xfs_dqunlock(dqp);
449 return 0;
450 }
451
452
453 /*
454 * Given a udquot and gdquot, attach a ptr to the group dquot in the
455 * udquot as a hint for future lookups.
456 */
457 STATIC void
458 xfs_qm_dqattach_grouphint(
459 xfs_dquot_t *udq,
460 xfs_dquot_t *gdq)
461 {
462 xfs_dquot_t *tmp;
463
464 xfs_dqlock(udq);
465
466 tmp = udq->q_gdquot;
467 if (tmp) {
468 if (tmp == gdq)
469 goto done;
470
471 udq->q_gdquot = NULL;
472 xfs_qm_dqrele(tmp);
473 }
474
475 udq->q_gdquot = xfs_qm_dqhold(gdq);
476 done:
477 xfs_dqunlock(udq);
478 }
479
480 static bool
481 xfs_qm_need_dqattach(
482 struct xfs_inode *ip)
483 {
484 struct xfs_mount *mp = ip->i_mount;
485
486 if (!XFS_IS_QUOTA_RUNNING(mp))
487 return false;
488 if (!XFS_IS_QUOTA_ON(mp))
489 return false;
490 if (!XFS_NOT_DQATTACHED(mp, ip))
491 return false;
492 if (ip->i_ino == mp->m_sb.sb_uquotino ||
493 ip->i_ino == mp->m_sb.sb_gquotino)
494 return false;
495 return true;
496 }
497
498 /*
499 * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
500 * into account.
501 * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
502 * Inode may get unlocked and relocked in here, and the caller must deal with
503 * the consequences.
504 */
505 int
506 xfs_qm_dqattach_locked(
507 xfs_inode_t *ip,
508 uint flags)
509 {
510 xfs_mount_t *mp = ip->i_mount;
511 uint nquotas = 0;
512 int error = 0;
513
514 if (!xfs_qm_need_dqattach(ip))
515 return 0;
516
517 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
518
519 if (XFS_IS_UQUOTA_ON(mp)) {
520 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
521 flags & XFS_QMOPT_DQALLOC,
522 NULL, &ip->i_udquot);
523 if (error)
524 goto done;
525 nquotas++;
526 }
527
528 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
529 if (XFS_IS_OQUOTA_ON(mp)) {
530 error = XFS_IS_GQUOTA_ON(mp) ?
531 xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
532 flags & XFS_QMOPT_DQALLOC,
533 ip->i_udquot, &ip->i_gdquot) :
534 xfs_qm_dqattach_one(ip, xfs_get_projid(ip), XFS_DQ_PROJ,
535 flags & XFS_QMOPT_DQALLOC,
536 ip->i_udquot, &ip->i_gdquot);
537 /*
538 * Don't worry about the udquot that we may have
539 * attached above. It'll get detached, if not already.
540 */
541 if (error)
542 goto done;
543 nquotas++;
544 }
545
546 /*
547 * Attach this group quota to the user quota as a hint.
548 * This WON'T, in general, result in a thrash.
549 */
550 if (nquotas == 2) {
551 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
552 ASSERT(ip->i_udquot);
553 ASSERT(ip->i_gdquot);
554
555 /*
556 * We do not have i_udquot locked at this point, but this check
557 * is OK since we don't depend on the i_gdquot to be accurate
558 * 100% all the time. It is just a hint, and this will
559 * succeed in general.
560 */
561 if (ip->i_udquot->q_gdquot != ip->i_gdquot)
562 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot);
563 }
564
565 done:
566 #ifdef DEBUG
567 if (!error) {
568 if (XFS_IS_UQUOTA_ON(mp))
569 ASSERT(ip->i_udquot);
570 if (XFS_IS_OQUOTA_ON(mp))
571 ASSERT(ip->i_gdquot);
572 }
573 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
574 #endif
575 return error;
576 }
577
578 int
579 xfs_qm_dqattach(
580 struct xfs_inode *ip,
581 uint flags)
582 {
583 int error;
584
585 if (!xfs_qm_need_dqattach(ip))
586 return 0;
587
588 xfs_ilock(ip, XFS_ILOCK_EXCL);
589 error = xfs_qm_dqattach_locked(ip, flags);
590 xfs_iunlock(ip, XFS_ILOCK_EXCL);
591
592 return error;
593 }
594
595 /*
596 * Release dquots (and their references) if any.
597 * The inode should be locked EXCL except when this's called by
598 * xfs_ireclaim.
599 */
600 void
601 xfs_qm_dqdetach(
602 xfs_inode_t *ip)
603 {
604 if (!(ip->i_udquot || ip->i_gdquot))
605 return;
606
607 trace_xfs_dquot_dqdetach(ip);
608
609 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
610 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
611 if (ip->i_udquot) {
612 xfs_qm_dqrele(ip->i_udquot);
613 ip->i_udquot = NULL;
614 }
615 if (ip->i_gdquot) {
616 xfs_qm_dqrele(ip->i_gdquot);
617 ip->i_gdquot = NULL;
618 }
619 }
620
621 int
622 xfs_qm_calc_dquots_per_chunk(
623 struct xfs_mount *mp,
624 unsigned int nbblks) /* basic block units */
625 {
626 unsigned int ndquots;
627
628 ASSERT(nbblks > 0);
629 ndquots = BBTOB(nbblks);
630 do_div(ndquots, sizeof(xfs_dqblk_t));
631
632 return ndquots;
633 }
634
635 /*
636 * This initializes all the quota information that's kept in the
637 * mount structure
638 */
639 STATIC int
640 xfs_qm_init_quotainfo(
641 xfs_mount_t *mp)
642 {
643 xfs_quotainfo_t *qinf;
644 int error;
645 xfs_dquot_t *dqp;
646
647 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
648
649 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
650
651 /*
652 * See if quotainodes are setup, and if not, allocate them,
653 * and change the superblock accordingly.
654 */
655 if ((error = xfs_qm_init_quotainos(mp))) {
656 kmem_free(qinf);
657 mp->m_quotainfo = NULL;
658 return error;
659 }
660
661 INIT_RADIX_TREE(&qinf->qi_uquota_tree, GFP_NOFS);
662 INIT_RADIX_TREE(&qinf->qi_gquota_tree, GFP_NOFS);
663 mutex_init(&qinf->qi_tree_lock);
664
665 INIT_LIST_HEAD(&qinf->qi_lru_list);
666 qinf->qi_lru_count = 0;
667 mutex_init(&qinf->qi_lru_lock);
668
669 /* mutex used to serialize quotaoffs */
670 mutex_init(&qinf->qi_quotaofflock);
671
672 /* Precalc some constants */
673 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
674 qinf->qi_dqperchunk = xfs_qm_calc_dquots_per_chunk(mp,
675 qinf->qi_dqchunklen);
676
677 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
678
679 /*
680 * We try to get the limits from the superuser's limits fields.
681 * This is quite hacky, but it is standard quota practice.
682 *
683 * We look at the USR dquot with id == 0 first, but if user quotas
684 * are not enabled we goto the GRP dquot with id == 0.
685 * We don't really care to keep separate default limits for user
686 * and group quotas, at least not at this point.
687 *
688 * Since we may not have done a quotacheck by this point, just read
689 * the dquot without attaching it to any hashtables or lists.
690 */
691 error = xfs_qm_dqread(mp, 0,
692 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
693 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
694 XFS_DQ_PROJ),
695 XFS_QMOPT_DOWARN, &dqp);
696 if (!error) {
697 xfs_disk_dquot_t *ddqp = &dqp->q_core;
698
699 /*
700 * The warnings and timers set the grace period given to
701 * a user or group before he or she can not perform any
702 * more writing. If it is zero, a default is used.
703 */
704 qinf->qi_btimelimit = ddqp->d_btimer ?
705 be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
706 qinf->qi_itimelimit = ddqp->d_itimer ?
707 be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
708 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
709 be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
710 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
711 be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
712 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
713 be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
714 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
715 be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
716 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
717 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
718 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
719 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
720 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
721 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
722
723 xfs_qm_dqdestroy(dqp);
724 } else {
725 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
726 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
727 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
728 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
729 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
730 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
731 }
732
733 qinf->qi_shrinker.shrink = xfs_qm_shake;
734 qinf->qi_shrinker.seeks = DEFAULT_SEEKS;
735 register_shrinker(&qinf->qi_shrinker);
736 return 0;
737 }
738
739
740 /*
741 * Gets called when unmounting a filesystem or when all quotas get
742 * turned off.
743 * This purges the quota inodes, destroys locks and frees itself.
744 */
745 void
746 xfs_qm_destroy_quotainfo(
747 xfs_mount_t *mp)
748 {
749 xfs_quotainfo_t *qi;
750
751 qi = mp->m_quotainfo;
752 ASSERT(qi != NULL);
753
754 unregister_shrinker(&qi->qi_shrinker);
755
756 if (qi->qi_uquotaip) {
757 IRELE(qi->qi_uquotaip);
758 qi->qi_uquotaip = NULL; /* paranoia */
759 }
760 if (qi->qi_gquotaip) {
761 IRELE(qi->qi_gquotaip);
762 qi->qi_gquotaip = NULL;
763 }
764 mutex_destroy(&qi->qi_quotaofflock);
765 kmem_free(qi);
766 mp->m_quotainfo = NULL;
767 }
768
769 /*
770 * Create an inode and return with a reference already taken, but unlocked
771 * This is how we create quota inodes
772 */
773 STATIC int
774 xfs_qm_qino_alloc(
775 xfs_mount_t *mp,
776 xfs_inode_t **ip,
777 __int64_t sbfields,
778 uint flags)
779 {
780 xfs_trans_t *tp;
781 int error;
782 int committed;
783
784 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
785 if ((error = xfs_trans_reserve(tp,
786 XFS_QM_QINOCREATE_SPACE_RES(mp),
787 XFS_CREATE_LOG_RES(mp), 0,
788 XFS_TRANS_PERM_LOG_RES,
789 XFS_CREATE_LOG_COUNT))) {
790 xfs_trans_cancel(tp, 0);
791 return error;
792 }
793
794 error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, 1, ip, &committed);
795 if (error) {
796 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
797 XFS_TRANS_ABORT);
798 return error;
799 }
800
801 /*
802 * Make the changes in the superblock, and log those too.
803 * sbfields arg may contain fields other than *QUOTINO;
804 * VERSIONNUM for example.
805 */
806 spin_lock(&mp->m_sb_lock);
807 if (flags & XFS_QMOPT_SBVERSION) {
808 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
809 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
810 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
811 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
812 XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
813
814 xfs_sb_version_addquota(&mp->m_sb);
815 mp->m_sb.sb_uquotino = NULLFSINO;
816 mp->m_sb.sb_gquotino = NULLFSINO;
817
818 /* qflags will get updated _after_ quotacheck */
819 mp->m_sb.sb_qflags = 0;
820 }
821 if (flags & XFS_QMOPT_UQUOTA)
822 mp->m_sb.sb_uquotino = (*ip)->i_ino;
823 else
824 mp->m_sb.sb_gquotino = (*ip)->i_ino;
825 spin_unlock(&mp->m_sb_lock);
826 xfs_mod_sb(tp, sbfields);
827
828 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
829 xfs_alert(mp, "%s failed (error %d)!", __func__, error);
830 return error;
831 }
832 return 0;
833 }
834
835
836 STATIC void
837 xfs_qm_reset_dqcounts(
838 xfs_mount_t *mp,
839 xfs_buf_t *bp,
840 xfs_dqid_t id,
841 uint type)
842 {
843 struct xfs_dqblk *dqb;
844 int j;
845
846 trace_xfs_reset_dqcounts(bp, _RET_IP_);
847
848 /*
849 * Reset all counters and timers. They'll be
850 * started afresh by xfs_qm_quotacheck.
851 */
852 #ifdef DEBUG
853 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
854 do_div(j, sizeof(xfs_dqblk_t));
855 ASSERT(mp->m_quotainfo->qi_dqperchunk == j);
856 #endif
857 dqb = bp->b_addr;
858 for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {
859 struct xfs_disk_dquot *ddq;
860
861 ddq = (struct xfs_disk_dquot *)&dqb[j];
862
863 /*
864 * Do a sanity check, and if needed, repair the dqblk. Don't
865 * output any warnings because it's perfectly possible to
866 * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
867 */
868 (void) xfs_qm_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR,
869 "xfs_quotacheck");
870 ddq->d_bcount = 0;
871 ddq->d_icount = 0;
872 ddq->d_rtbcount = 0;
873 ddq->d_btimer = 0;
874 ddq->d_itimer = 0;
875 ddq->d_rtbtimer = 0;
876 ddq->d_bwarns = 0;
877 ddq->d_iwarns = 0;
878 ddq->d_rtbwarns = 0;
879
880 if (xfs_sb_version_hascrc(&mp->m_sb)) {
881 xfs_update_cksum((char *)&dqb[j],
882 sizeof(struct xfs_dqblk),
883 XFS_DQUOT_CRC_OFF);
884 }
885 }
886 }
887
888 STATIC int
889 xfs_qm_dqiter_bufs(
890 struct xfs_mount *mp,
891 xfs_dqid_t firstid,
892 xfs_fsblock_t bno,
893 xfs_filblks_t blkcnt,
894 uint flags,
895 struct list_head *buffer_list)
896 {
897 struct xfs_buf *bp;
898 int error;
899 int type;
900
901 ASSERT(blkcnt > 0);
902 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
903 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
904 error = 0;
905
906 /*
907 * Blkcnt arg can be a very big number, and might even be
908 * larger than the log itself. So, we have to break it up into
909 * manageable-sized transactions.
910 * Note that we don't start a permanent transaction here; we might
911 * not be able to get a log reservation for the whole thing up front,
912 * and we don't really care to either, because we just discard
913 * everything if we were to crash in the middle of this loop.
914 */
915 while (blkcnt--) {
916 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
917 XFS_FSB_TO_DADDR(mp, bno),
918 mp->m_quotainfo->qi_dqchunklen, 0, &bp,
919 &xfs_dquot_buf_ops);
920
921 /*
922 * CRC and validation errors will return a EFSCORRUPTED here. If
923 * this occurs, re-read without CRC validation so that we can
924 * repair the damage via xfs_qm_reset_dqcounts(). This process
925 * will leave a trace in the log indicating corruption has
926 * been detected.
927 */
928 if (error == EFSCORRUPTED) {
929 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
930 XFS_FSB_TO_DADDR(mp, bno),
931 mp->m_quotainfo->qi_dqchunklen, 0, &bp,
932 NULL);
933 }
934
935 if (error)
936 break;
937
938 /*
939 * A corrupt buffer might not have a verifier attached, so
940 * make sure we have the correct one attached before writeback
941 * occurs.
942 */
943 bp->b_ops = &xfs_dquot_buf_ops;
944 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
945 xfs_buf_delwri_queue(bp, buffer_list);
946 xfs_buf_relse(bp);
947
948 /* goto the next block. */
949 bno++;
950 firstid += mp->m_quotainfo->qi_dqperchunk;
951 }
952
953 return error;
954 }
955
956 /*
957 * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
958 * caller supplied function for every chunk of dquots that we find.
959 */
960 STATIC int
961 xfs_qm_dqiterate(
962 struct xfs_mount *mp,
963 struct xfs_inode *qip,
964 uint flags,
965 struct list_head *buffer_list)
966 {
967 struct xfs_bmbt_irec *map;
968 int i, nmaps; /* number of map entries */
969 int error; /* return value */
970 xfs_fileoff_t lblkno;
971 xfs_filblks_t maxlblkcnt;
972 xfs_dqid_t firstid;
973 xfs_fsblock_t rablkno;
974 xfs_filblks_t rablkcnt;
975
976 error = 0;
977 /*
978 * This looks racy, but we can't keep an inode lock across a
979 * trans_reserve. But, this gets called during quotacheck, and that
980 * happens only at mount time which is single threaded.
981 */
982 if (qip->i_d.di_nblocks == 0)
983 return 0;
984
985 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
986
987 lblkno = 0;
988 maxlblkcnt = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
989 do {
990 nmaps = XFS_DQITER_MAP_SIZE;
991 /*
992 * We aren't changing the inode itself. Just changing
993 * some of its data. No new blocks are added here, and
994 * the inode is never added to the transaction.
995 */
996 xfs_ilock(qip, XFS_ILOCK_SHARED);
997 error = xfs_bmapi_read(qip, lblkno, maxlblkcnt - lblkno,
998 map, &nmaps, 0);
999 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1000 if (error)
1001 break;
1002
1003 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1004 for (i = 0; i < nmaps; i++) {
1005 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1006 ASSERT(map[i].br_blockcount);
1007
1008
1009 lblkno += map[i].br_blockcount;
1010
1011 if (map[i].br_startblock == HOLESTARTBLOCK)
1012 continue;
1013
1014 firstid = (xfs_dqid_t) map[i].br_startoff *
1015 mp->m_quotainfo->qi_dqperchunk;
1016 /*
1017 * Do a read-ahead on the next extent.
1018 */
1019 if ((i+1 < nmaps) &&
1020 (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1021 rablkcnt = map[i+1].br_blockcount;
1022 rablkno = map[i+1].br_startblock;
1023 while (rablkcnt--) {
1024 xfs_buf_readahead(mp->m_ddev_targp,
1025 XFS_FSB_TO_DADDR(mp, rablkno),
1026 mp->m_quotainfo->qi_dqchunklen,
1027 &xfs_dquot_buf_ops);
1028 rablkno++;
1029 }
1030 }
1031 /*
1032 * Iterate thru all the blks in the extent and
1033 * reset the counters of all the dquots inside them.
1034 */
1035 error = xfs_qm_dqiter_bufs(mp, firstid,
1036 map[i].br_startblock,
1037 map[i].br_blockcount,
1038 flags, buffer_list);
1039 if (error)
1040 goto out;
1041 }
1042 } while (nmaps > 0);
1043
1044 out:
1045 kmem_free(map);
1046 return error;
1047 }
1048
1049 /*
1050 * Called by dqusage_adjust in doing a quotacheck.
1051 *
1052 * Given the inode, and a dquot id this updates both the incore dqout as well
1053 * as the buffer copy. This is so that once the quotacheck is done, we can
1054 * just log all the buffers, as opposed to logging numerous updates to
1055 * individual dquots.
1056 */
1057 STATIC int
1058 xfs_qm_quotacheck_dqadjust(
1059 struct xfs_inode *ip,
1060 xfs_dqid_t id,
1061 uint type,
1062 xfs_qcnt_t nblks,
1063 xfs_qcnt_t rtblks)
1064 {
1065 struct xfs_mount *mp = ip->i_mount;
1066 struct xfs_dquot *dqp;
1067 int error;
1068
1069 error = xfs_qm_dqget(mp, ip, id, type,
1070 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN, &dqp);
1071 if (error) {
1072 /*
1073 * Shouldn't be able to turn off quotas here.
1074 */
1075 ASSERT(error != ESRCH);
1076 ASSERT(error != ENOENT);
1077 return error;
1078 }
1079
1080 trace_xfs_dqadjust(dqp);
1081
1082 /*
1083 * Adjust the inode count and the block count to reflect this inode's
1084 * resource usage.
1085 */
1086 be64_add_cpu(&dqp->q_core.d_icount, 1);
1087 dqp->q_res_icount++;
1088 if (nblks) {
1089 be64_add_cpu(&dqp->q_core.d_bcount, nblks);
1090 dqp->q_res_bcount += nblks;
1091 }
1092 if (rtblks) {
1093 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
1094 dqp->q_res_rtbcount += rtblks;
1095 }
1096
1097 /*
1098 * Set default limits, adjust timers (since we changed usages)
1099 *
1100 * There are no timers for the default values set in the root dquot.
1101 */
1102 if (dqp->q_core.d_id) {
1103 xfs_qm_adjust_dqlimits(mp, dqp);
1104 xfs_qm_adjust_dqtimers(mp, &dqp->q_core);
1105 }
1106
1107 dqp->dq_flags |= XFS_DQ_DIRTY;
1108 xfs_qm_dqput(dqp);
1109 return 0;
1110 }
1111
1112 STATIC int
1113 xfs_qm_get_rtblks(
1114 xfs_inode_t *ip,
1115 xfs_qcnt_t *O_rtblks)
1116 {
1117 xfs_filblks_t rtblks; /* total rt blks */
1118 xfs_extnum_t idx; /* extent record index */
1119 xfs_ifork_t *ifp; /* inode fork pointer */
1120 xfs_extnum_t nextents; /* number of extent entries */
1121 int error;
1122
1123 ASSERT(XFS_IS_REALTIME_INODE(ip));
1124 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1125 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1126 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
1127 return error;
1128 }
1129 rtblks = 0;
1130 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
1131 for (idx = 0; idx < nextents; idx++)
1132 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
1133 *O_rtblks = (xfs_qcnt_t)rtblks;
1134 return 0;
1135 }
1136
1137 /*
1138 * callback routine supplied to bulkstat(). Given an inumber, find its
1139 * dquots and update them to account for resources taken by that inode.
1140 */
1141 /* ARGSUSED */
1142 STATIC int
1143 xfs_qm_dqusage_adjust(
1144 xfs_mount_t *mp, /* mount point for filesystem */
1145 xfs_ino_t ino, /* inode number to get data for */
1146 void __user *buffer, /* not used */
1147 int ubsize, /* not used */
1148 int *ubused, /* not used */
1149 int *res) /* result code value */
1150 {
1151 xfs_inode_t *ip;
1152 xfs_qcnt_t nblks, rtblks = 0;
1153 int error;
1154
1155 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1156
1157 /*
1158 * rootino must have its resources accounted for, not so with the quota
1159 * inodes.
1160 */
1161 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1162 *res = BULKSTAT_RV_NOTHING;
1163 return XFS_ERROR(EINVAL);
1164 }
1165
1166 /*
1167 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1168 * interface expects the inode to be exclusively locked because that's
1169 * the case in all other instances. It's OK that we do this because
1170 * quotacheck is done only at mount time.
1171 */
1172 error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip);
1173 if (error) {
1174 *res = BULKSTAT_RV_NOTHING;
1175 return error;
1176 }
1177
1178 ASSERT(ip->i_delayed_blks == 0);
1179
1180 if (XFS_IS_REALTIME_INODE(ip)) {
1181 /*
1182 * Walk thru the extent list and count the realtime blocks.
1183 */
1184 error = xfs_qm_get_rtblks(ip, &rtblks);
1185 if (error)
1186 goto error0;
1187 }
1188
1189 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1190
1191 /*
1192 * Add the (disk blocks and inode) resources occupied by this
1193 * inode to its dquots. We do this adjustment in the incore dquot,
1194 * and also copy the changes to its buffer.
1195 * We don't care about putting these changes in a transaction
1196 * envelope because if we crash in the middle of a 'quotacheck'
1197 * we have to start from the beginning anyway.
1198 * Once we're done, we'll log all the dquot bufs.
1199 *
1200 * The *QUOTA_ON checks below may look pretty racy, but quotachecks
1201 * and quotaoffs don't race. (Quotachecks happen at mount time only).
1202 */
1203 if (XFS_IS_UQUOTA_ON(mp)) {
1204 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_uid,
1205 XFS_DQ_USER, nblks, rtblks);
1206 if (error)
1207 goto error0;
1208 }
1209
1210 if (XFS_IS_GQUOTA_ON(mp)) {
1211 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_gid,
1212 XFS_DQ_GROUP, nblks, rtblks);
1213 if (error)
1214 goto error0;
1215 }
1216
1217 if (XFS_IS_PQUOTA_ON(mp)) {
1218 error = xfs_qm_quotacheck_dqadjust(ip, xfs_get_projid(ip),
1219 XFS_DQ_PROJ, nblks, rtblks);
1220 if (error)
1221 goto error0;
1222 }
1223
1224 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1225 IRELE(ip);
1226 *res = BULKSTAT_RV_DIDONE;
1227 return 0;
1228
1229 error0:
1230 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1231 IRELE(ip);
1232 *res = BULKSTAT_RV_GIVEUP;
1233 return error;
1234 }
1235
1236 STATIC int
1237 xfs_qm_flush_one(
1238 struct xfs_dquot *dqp,
1239 void *data)
1240 {
1241 struct list_head *buffer_list = data;
1242 struct xfs_buf *bp = NULL;
1243 int error = 0;
1244
1245 xfs_dqlock(dqp);
1246 if (dqp->dq_flags & XFS_DQ_FREEING)
1247 goto out_unlock;
1248 if (!XFS_DQ_IS_DIRTY(dqp))
1249 goto out_unlock;
1250
1251 xfs_dqflock(dqp);
1252 error = xfs_qm_dqflush(dqp, &bp);
1253 if (error)
1254 goto out_unlock;
1255
1256 xfs_buf_delwri_queue(bp, buffer_list);
1257 xfs_buf_relse(bp);
1258 out_unlock:
1259 xfs_dqunlock(dqp);
1260 return error;
1261 }
1262
1263 /*
1264 * Walk thru all the filesystem inodes and construct a consistent view
1265 * of the disk quota world. If the quotacheck fails, disable quotas.
1266 */
1267 int
1268 xfs_qm_quotacheck(
1269 xfs_mount_t *mp)
1270 {
1271 int done, count, error, error2;
1272 xfs_ino_t lastino;
1273 size_t structsz;
1274 xfs_inode_t *uip, *gip;
1275 uint flags;
1276 LIST_HEAD (buffer_list);
1277
1278 count = INT_MAX;
1279 structsz = 1;
1280 lastino = 0;
1281 flags = 0;
1282
1283 ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip);
1284 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1285
1286 xfs_notice(mp, "Quotacheck needed: Please wait.");
1287
1288 /*
1289 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
1290 * their counters to zero. We need a clean slate.
1291 * We don't log our changes till later.
1292 */
1293 uip = mp->m_quotainfo->qi_uquotaip;
1294 if (uip) {
1295 error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA,
1296 &buffer_list);
1297 if (error)
1298 goto error_return;
1299 flags |= XFS_UQUOTA_CHKD;
1300 }
1301
1302 gip = mp->m_quotainfo->qi_gquotaip;
1303 if (gip) {
1304 error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1305 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA,
1306 &buffer_list);
1307 if (error)
1308 goto error_return;
1309 flags |= XFS_OQUOTA_CHKD;
1310 }
1311
1312 do {
1313 /*
1314 * Iterate thru all the inodes in the file system,
1315 * adjusting the corresponding dquot counters in core.
1316 */
1317 error = xfs_bulkstat(mp, &lastino, &count,
1318 xfs_qm_dqusage_adjust,
1319 structsz, NULL, &done);
1320 if (error)
1321 break;
1322
1323 } while (!done);
1324
1325 /*
1326 * We've made all the changes that we need to make incore. Flush them
1327 * down to disk buffers if everything was updated successfully.
1328 */
1329 if (XFS_IS_UQUOTA_ON(mp)) {
1330 error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one,
1331 &buffer_list);
1332 }
1333 if (XFS_IS_GQUOTA_ON(mp)) {
1334 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one,
1335 &buffer_list);
1336 if (!error)
1337 error = error2;
1338 }
1339 if (XFS_IS_PQUOTA_ON(mp)) {
1340 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one,
1341 &buffer_list);
1342 if (!error)
1343 error = error2;
1344 }
1345
1346 error2 = xfs_buf_delwri_submit(&buffer_list);
1347 if (!error)
1348 error = error2;
1349
1350 /*
1351 * We can get this error if we couldn't do a dquot allocation inside
1352 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1353 * dirty dquots that might be cached, we just want to get rid of them
1354 * and turn quotaoff. The dquots won't be attached to any of the inodes
1355 * at this point (because we intentionally didn't in dqget_noattach).
1356 */
1357 if (error) {
1358 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
1359 goto error_return;
1360 }
1361
1362 /*
1363 * If one type of quotas is off, then it will lose its
1364 * quotachecked status, since we won't be doing accounting for
1365 * that type anymore.
1366 */
1367 mp->m_qflags &= ~XFS_ALL_QUOTA_CHKD;
1368 mp->m_qflags |= flags;
1369
1370 error_return:
1371 while (!list_empty(&buffer_list)) {
1372 struct xfs_buf *bp =
1373 list_first_entry(&buffer_list, struct xfs_buf, b_list);
1374 list_del_init(&bp->b_list);
1375 xfs_buf_relse(bp);
1376 }
1377
1378 if (error) {
1379 xfs_warn(mp,
1380 "Quotacheck: Unsuccessful (Error %d): Disabling quotas.",
1381 error);
1382 /*
1383 * We must turn off quotas.
1384 */
1385 ASSERT(mp->m_quotainfo != NULL);
1386 xfs_qm_destroy_quotainfo(mp);
1387 if (xfs_mount_reset_sbqflags(mp)) {
1388 xfs_warn(mp,
1389 "Quotacheck: Failed to reset quota flags.");
1390 }
1391 } else
1392 xfs_notice(mp, "Quotacheck: Done.");
1393 return (error);
1394 }
1395
1396 /*
1397 * This is called after the superblock has been read in and we're ready to
1398 * iget the quota inodes.
1399 */
1400 STATIC int
1401 xfs_qm_init_quotainos(
1402 xfs_mount_t *mp)
1403 {
1404 xfs_inode_t *uip, *gip;
1405 int error;
1406 __int64_t sbflags;
1407 uint flags;
1408
1409 ASSERT(mp->m_quotainfo);
1410 uip = gip = NULL;
1411 sbflags = 0;
1412 flags = 0;
1413
1414 /*
1415 * Get the uquota and gquota inodes
1416 */
1417 if (xfs_sb_version_hasquota(&mp->m_sb)) {
1418 if (XFS_IS_UQUOTA_ON(mp) &&
1419 mp->m_sb.sb_uquotino != NULLFSINO) {
1420 ASSERT(mp->m_sb.sb_uquotino > 0);
1421 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
1422 0, 0, &uip)))
1423 return XFS_ERROR(error);
1424 }
1425 if (XFS_IS_OQUOTA_ON(mp) &&
1426 mp->m_sb.sb_gquotino != NULLFSINO) {
1427 ASSERT(mp->m_sb.sb_gquotino > 0);
1428 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
1429 0, 0, &gip))) {
1430 if (uip)
1431 IRELE(uip);
1432 return XFS_ERROR(error);
1433 }
1434 }
1435 } else {
1436 flags |= XFS_QMOPT_SBVERSION;
1437 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1438 XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
1439 }
1440
1441 /*
1442 * Create the two inodes, if they don't exist already. The changes
1443 * made above will get added to a transaction and logged in one of
1444 * the qino_alloc calls below. If the device is readonly,
1445 * temporarily switch to read-write to do this.
1446 */
1447 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1448 if ((error = xfs_qm_qino_alloc(mp, &uip,
1449 sbflags | XFS_SB_UQUOTINO,
1450 flags | XFS_QMOPT_UQUOTA)))
1451 return XFS_ERROR(error);
1452
1453 flags &= ~XFS_QMOPT_SBVERSION;
1454 }
1455 if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
1456 flags |= (XFS_IS_GQUOTA_ON(mp) ?
1457 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1458 error = xfs_qm_qino_alloc(mp, &gip,
1459 sbflags | XFS_SB_GQUOTINO, flags);
1460 if (error) {
1461 if (uip)
1462 IRELE(uip);
1463
1464 return XFS_ERROR(error);
1465 }
1466 }
1467
1468 mp->m_quotainfo->qi_uquotaip = uip;
1469 mp->m_quotainfo->qi_gquotaip = gip;
1470
1471 return 0;
1472 }
1473
1474 STATIC void
1475 xfs_qm_dqfree_one(
1476 struct xfs_dquot *dqp)
1477 {
1478 struct xfs_mount *mp = dqp->q_mount;
1479 struct xfs_quotainfo *qi = mp->m_quotainfo;
1480
1481 mutex_lock(&qi->qi_tree_lock);
1482 radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags),
1483 be32_to_cpu(dqp->q_core.d_id));
1484
1485 qi->qi_dquots--;
1486 mutex_unlock(&qi->qi_tree_lock);
1487
1488 xfs_qm_dqdestroy(dqp);
1489 }
1490
1491 STATIC void
1492 xfs_qm_dqreclaim_one(
1493 struct xfs_dquot *dqp,
1494 struct list_head *buffer_list,
1495 struct list_head *dispose_list)
1496 {
1497 struct xfs_mount *mp = dqp->q_mount;
1498 struct xfs_quotainfo *qi = mp->m_quotainfo;
1499 int error;
1500
1501 if (!xfs_dqlock_nowait(dqp))
1502 goto out_move_tail;
1503
1504 /*
1505 * This dquot has acquired a reference in the meantime remove it from
1506 * the freelist and try again.
1507 */
1508 if (dqp->q_nrefs) {
1509 xfs_dqunlock(dqp);
1510
1511 trace_xfs_dqreclaim_want(dqp);
1512 XFS_STATS_INC(xs_qm_dqwants);
1513
1514 list_del_init(&dqp->q_lru);
1515 qi->qi_lru_count--;
1516 XFS_STATS_DEC(xs_qm_dquot_unused);
1517 return;
1518 }
1519
1520 /*
1521 * Try to grab the flush lock. If this dquot is in the process of
1522 * getting flushed to disk, we don't want to reclaim it.
1523 */
1524 if (!xfs_dqflock_nowait(dqp))
1525 goto out_unlock_move_tail;
1526
1527 if (XFS_DQ_IS_DIRTY(dqp)) {
1528 struct xfs_buf *bp = NULL;
1529
1530 trace_xfs_dqreclaim_dirty(dqp);
1531
1532 error = xfs_qm_dqflush(dqp, &bp);
1533 if (error) {
1534 xfs_warn(mp, "%s: dquot %p flush failed",
1535 __func__, dqp);
1536 goto out_unlock_move_tail;
1537 }
1538
1539 xfs_buf_delwri_queue(bp, buffer_list);
1540 xfs_buf_relse(bp);
1541 /*
1542 * Give the dquot another try on the freelist, as the
1543 * flushing will take some time.
1544 */
1545 goto out_unlock_move_tail;
1546 }
1547 xfs_dqfunlock(dqp);
1548
1549 /*
1550 * Prevent lookups now that we are past the point of no return.
1551 */
1552 dqp->dq_flags |= XFS_DQ_FREEING;
1553 xfs_dqunlock(dqp);
1554
1555 ASSERT(dqp->q_nrefs == 0);
1556 list_move_tail(&dqp->q_lru, dispose_list);
1557 qi->qi_lru_count--;
1558 XFS_STATS_DEC(xs_qm_dquot_unused);
1559
1560 trace_xfs_dqreclaim_done(dqp);
1561 XFS_STATS_INC(xs_qm_dqreclaims);
1562 return;
1563
1564 /*
1565 * Move the dquot to the tail of the list so that we don't spin on it.
1566 */
1567 out_unlock_move_tail:
1568 xfs_dqunlock(dqp);
1569 out_move_tail:
1570 list_move_tail(&dqp->q_lru, &qi->qi_lru_list);
1571 trace_xfs_dqreclaim_busy(dqp);
1572 XFS_STATS_INC(xs_qm_dqreclaim_misses);
1573 }
1574
1575 STATIC int
1576 xfs_qm_shake(
1577 struct shrinker *shrink,
1578 struct shrink_control *sc)
1579 {
1580 struct xfs_quotainfo *qi =
1581 container_of(shrink, struct xfs_quotainfo, qi_shrinker);
1582 int nr_to_scan = sc->nr_to_scan;
1583 LIST_HEAD (buffer_list);
1584 LIST_HEAD (dispose_list);
1585 struct xfs_dquot *dqp;
1586 int error;
1587
1588 if ((sc->gfp_mask & (__GFP_FS|__GFP_WAIT)) != (__GFP_FS|__GFP_WAIT))
1589 return 0;
1590 if (!nr_to_scan)
1591 goto out;
1592
1593 mutex_lock(&qi->qi_lru_lock);
1594 while (!list_empty(&qi->qi_lru_list)) {
1595 if (nr_to_scan-- <= 0)
1596 break;
1597 dqp = list_first_entry(&qi->qi_lru_list, struct xfs_dquot,
1598 q_lru);
1599 xfs_qm_dqreclaim_one(dqp, &buffer_list, &dispose_list);
1600 }
1601 mutex_unlock(&qi->qi_lru_lock);
1602
1603 error = xfs_buf_delwri_submit(&buffer_list);
1604 if (error)
1605 xfs_warn(NULL, "%s: dquot reclaim failed", __func__);
1606
1607 while (!list_empty(&dispose_list)) {
1608 dqp = list_first_entry(&dispose_list, struct xfs_dquot, q_lru);
1609 list_del_init(&dqp->q_lru);
1610 xfs_qm_dqfree_one(dqp);
1611 }
1612
1613 out:
1614 return (qi->qi_lru_count / 100) * sysctl_vfs_cache_pressure;
1615 }
1616
1617 /*
1618 * Start a transaction and write the incore superblock changes to
1619 * disk. flags parameter indicates which fields have changed.
1620 */
1621 int
1622 xfs_qm_write_sb_changes(
1623 xfs_mount_t *mp,
1624 __int64_t flags)
1625 {
1626 xfs_trans_t *tp;
1627 int error;
1628
1629 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
1630 error = xfs_trans_reserve(tp, 0, XFS_QM_SBCHANGE_LOG_RES(mp),
1631 0, 0, XFS_DEFAULT_LOG_COUNT);
1632 if (error) {
1633 xfs_trans_cancel(tp, 0);
1634 return error;
1635 }
1636
1637 xfs_mod_sb(tp, flags);
1638 error = xfs_trans_commit(tp, 0);
1639
1640 return error;
1641 }
1642
1643
1644 /* --------------- utility functions for vnodeops ---------------- */
1645
1646
1647 /*
1648 * Given an inode, a uid, gid and prid make sure that we have
1649 * allocated relevant dquot(s) on disk, and that we won't exceed inode
1650 * quotas by creating this file.
1651 * This also attaches dquot(s) to the given inode after locking it,
1652 * and returns the dquots corresponding to the uid and/or gid.
1653 *
1654 * in : inode (unlocked)
1655 * out : udquot, gdquot with references taken and unlocked
1656 */
1657 int
1658 xfs_qm_vop_dqalloc(
1659 struct xfs_inode *ip,
1660 uid_t uid,
1661 gid_t gid,
1662 prid_t prid,
1663 uint flags,
1664 struct xfs_dquot **O_udqpp,
1665 struct xfs_dquot **O_gdqpp)
1666 {
1667 struct xfs_mount *mp = ip->i_mount;
1668 struct xfs_dquot *uq, *gq;
1669 int error;
1670 uint lockflags;
1671
1672 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
1673 return 0;
1674
1675 lockflags = XFS_ILOCK_EXCL;
1676 xfs_ilock(ip, lockflags);
1677
1678 if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
1679 gid = ip->i_d.di_gid;
1680
1681 /*
1682 * Attach the dquot(s) to this inode, doing a dquot allocation
1683 * if necessary. The dquot(s) will not be locked.
1684 */
1685 if (XFS_NOT_DQATTACHED(mp, ip)) {
1686 error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);
1687 if (error) {
1688 xfs_iunlock(ip, lockflags);
1689 return error;
1690 }
1691 }
1692
1693 uq = gq = NULL;
1694 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
1695 if (ip->i_d.di_uid != uid) {
1696 /*
1697 * What we need is the dquot that has this uid, and
1698 * if we send the inode to dqget, the uid of the inode
1699 * takes priority over what's sent in the uid argument.
1700 * We must unlock inode here before calling dqget if
1701 * we're not sending the inode, because otherwise
1702 * we'll deadlock by doing trans_reserve while
1703 * holding ilock.
1704 */
1705 xfs_iunlock(ip, lockflags);
1706 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
1707 XFS_DQ_USER,
1708 XFS_QMOPT_DQALLOC |
1709 XFS_QMOPT_DOWARN,
1710 &uq))) {
1711 ASSERT(error != ENOENT);
1712 return error;
1713 }
1714 /*
1715 * Get the ilock in the right order.
1716 */
1717 xfs_dqunlock(uq);
1718 lockflags = XFS_ILOCK_SHARED;
1719 xfs_ilock(ip, lockflags);
1720 } else {
1721 /*
1722 * Take an extra reference, because we'll return
1723 * this to caller
1724 */
1725 ASSERT(ip->i_udquot);
1726 uq = xfs_qm_dqhold(ip->i_udquot);
1727 }
1728 }
1729 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
1730 if (ip->i_d.di_gid != gid) {
1731 xfs_iunlock(ip, lockflags);
1732 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
1733 XFS_DQ_GROUP,
1734 XFS_QMOPT_DQALLOC |
1735 XFS_QMOPT_DOWARN,
1736 &gq))) {
1737 if (uq)
1738 xfs_qm_dqrele(uq);
1739 ASSERT(error != ENOENT);
1740 return error;
1741 }
1742 xfs_dqunlock(gq);
1743 lockflags = XFS_ILOCK_SHARED;
1744 xfs_ilock(ip, lockflags);
1745 } else {
1746 ASSERT(ip->i_gdquot);
1747 gq = xfs_qm_dqhold(ip->i_gdquot);
1748 }
1749 } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
1750 if (xfs_get_projid(ip) != prid) {
1751 xfs_iunlock(ip, lockflags);
1752 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
1753 XFS_DQ_PROJ,
1754 XFS_QMOPT_DQALLOC |
1755 XFS_QMOPT_DOWARN,
1756 &gq))) {
1757 if (uq)
1758 xfs_qm_dqrele(uq);
1759 ASSERT(error != ENOENT);
1760 return (error);
1761 }
1762 xfs_dqunlock(gq);
1763 lockflags = XFS_ILOCK_SHARED;
1764 xfs_ilock(ip, lockflags);
1765 } else {
1766 ASSERT(ip->i_gdquot);
1767 gq = xfs_qm_dqhold(ip->i_gdquot);
1768 }
1769 }
1770 if (uq)
1771 trace_xfs_dquot_dqalloc(ip);
1772
1773 xfs_iunlock(ip, lockflags);
1774 if (O_udqpp)
1775 *O_udqpp = uq;
1776 else if (uq)
1777 xfs_qm_dqrele(uq);
1778 if (O_gdqpp)
1779 *O_gdqpp = gq;
1780 else if (gq)
1781 xfs_qm_dqrele(gq);
1782 return 0;
1783 }
1784
1785 /*
1786 * Actually transfer ownership, and do dquot modifications.
1787 * These were already reserved.
1788 */
1789 xfs_dquot_t *
1790 xfs_qm_vop_chown(
1791 xfs_trans_t *tp,
1792 xfs_inode_t *ip,
1793 xfs_dquot_t **IO_olddq,
1794 xfs_dquot_t *newdq)
1795 {
1796 xfs_dquot_t *prevdq;
1797 uint bfield = XFS_IS_REALTIME_INODE(ip) ?
1798 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
1799
1800
1801 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1802 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
1803
1804 /* old dquot */
1805 prevdq = *IO_olddq;
1806 ASSERT(prevdq);
1807 ASSERT(prevdq != newdq);
1808
1809 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
1810 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
1811
1812 /* the sparkling new dquot */
1813 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
1814 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
1815
1816 /*
1817 * Take an extra reference, because the inode is going to keep
1818 * this dquot pointer even after the trans_commit.
1819 */
1820 *IO_olddq = xfs_qm_dqhold(newdq);
1821
1822 return prevdq;
1823 }
1824
1825 /*
1826 * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
1827 */
1828 int
1829 xfs_qm_vop_chown_reserve(
1830 xfs_trans_t *tp,
1831 xfs_inode_t *ip,
1832 xfs_dquot_t *udqp,
1833 xfs_dquot_t *gdqp,
1834 uint flags)
1835 {
1836 xfs_mount_t *mp = ip->i_mount;
1837 uint delblks, blkflags, prjflags = 0;
1838 xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq;
1839 int error;
1840
1841
1842 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
1843 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1844
1845 delblks = ip->i_delayed_blks;
1846 delblksudq = delblksgdq = unresudq = unresgdq = NULL;
1847 blkflags = XFS_IS_REALTIME_INODE(ip) ?
1848 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
1849
1850 if (XFS_IS_UQUOTA_ON(mp) && udqp &&
1851 ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
1852 delblksudq = udqp;
1853 /*
1854 * If there are delayed allocation blocks, then we have to
1855 * unreserve those from the old dquot, and add them to the
1856 * new dquot.
1857 */
1858 if (delblks) {
1859 ASSERT(ip->i_udquot);
1860 unresudq = ip->i_udquot;
1861 }
1862 }
1863 if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
1864 if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
1865 xfs_get_projid(ip) != be32_to_cpu(gdqp->q_core.d_id))
1866 prjflags = XFS_QMOPT_ENOSPC;
1867
1868 if (prjflags ||
1869 (XFS_IS_GQUOTA_ON(ip->i_mount) &&
1870 ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
1871 delblksgdq = gdqp;
1872 if (delblks) {
1873 ASSERT(ip->i_gdquot);
1874 unresgdq = ip->i_gdquot;
1875 }
1876 }
1877 }
1878
1879 if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
1880 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
1881 flags | blkflags | prjflags)))
1882 return (error);
1883
1884 /*
1885 * Do the delayed blks reservations/unreservations now. Since, these
1886 * are done without the help of a transaction, if a reservation fails
1887 * its previous reservations won't be automatically undone by trans
1888 * code. So, we have to do it manually here.
1889 */
1890 if (delblks) {
1891 /*
1892 * Do the reservations first. Unreservation can't fail.
1893 */
1894 ASSERT(delblksudq || delblksgdq);
1895 ASSERT(unresudq || unresgdq);
1896 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
1897 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
1898 flags | blkflags | prjflags)))
1899 return (error);
1900 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
1901 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
1902 blkflags);
1903 }
1904
1905 return (0);
1906 }
1907
1908 int
1909 xfs_qm_vop_rename_dqattach(
1910 struct xfs_inode **i_tab)
1911 {
1912 struct xfs_mount *mp = i_tab[0]->i_mount;
1913 int i;
1914
1915 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
1916 return 0;
1917
1918 for (i = 0; (i < 4 && i_tab[i]); i++) {
1919 struct xfs_inode *ip = i_tab[i];
1920 int error;
1921
1922 /*
1923 * Watch out for duplicate entries in the table.
1924 */
1925 if (i == 0 || ip != i_tab[i-1]) {
1926 if (XFS_NOT_DQATTACHED(mp, ip)) {
1927 error = xfs_qm_dqattach(ip, 0);
1928 if (error)
1929 return error;
1930 }
1931 }
1932 }
1933 return 0;
1934 }
1935
1936 void
1937 xfs_qm_vop_create_dqattach(
1938 struct xfs_trans *tp,
1939 struct xfs_inode *ip,
1940 struct xfs_dquot *udqp,
1941 struct xfs_dquot *gdqp)
1942 {
1943 struct xfs_mount *mp = tp->t_mountp;
1944
1945 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
1946 return;
1947
1948 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1949 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1950
1951 if (udqp) {
1952 ASSERT(ip->i_udquot == NULL);
1953 ASSERT(XFS_IS_UQUOTA_ON(mp));
1954 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
1955
1956 ip->i_udquot = xfs_qm_dqhold(udqp);
1957 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
1958 }
1959 if (gdqp) {
1960 ASSERT(ip->i_gdquot == NULL);
1961 ASSERT(XFS_IS_OQUOTA_ON(mp));
1962 ASSERT((XFS_IS_GQUOTA_ON(mp) ?
1963 ip->i_d.di_gid : xfs_get_projid(ip)) ==
1964 be32_to_cpu(gdqp->q_core.d_id));
1965
1966 ip->i_gdquot = xfs_qm_dqhold(gdqp);
1967 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
1968 }
1969 }
1970
kernel source for telekom puls (alcatel/mediatek)