ulfs_quota2.c revision 1.21 1 1.21 dholland /* $NetBSD: ulfs_quota2.c,v 1.21 2015/07/28 05:09:35 dholland Exp $ */
2 1.1 dholland /* from NetBSD: ufs_quota2.c,v 1.35 2012/09/27 07:47:56 bouyer Exp */
3 1.10 dholland /* from NetBSD: ffs_quota2.c,v 1.4 2011/06/12 03:36:00 rmind Exp */
4 1.1 dholland
5 1.1 dholland /*-
6 1.1 dholland * Copyright (c) 2010 Manuel Bouyer
7 1.1 dholland * All rights reserved.
8 1.1 dholland *
9 1.1 dholland * Redistribution and use in source and binary forms, with or without
10 1.1 dholland * modification, are permitted provided that the following conditions
11 1.1 dholland * are met:
12 1.1 dholland * 1. Redistributions of source code must retain the above copyright
13 1.1 dholland * notice, this list of conditions and the following disclaimer.
14 1.1 dholland * 2. Redistributions in binary form must reproduce the above copyright
15 1.1 dholland * notice, this list of conditions and the following disclaimer in the
16 1.1 dholland * documentation and/or other materials provided with the distribution.
17 1.1 dholland *
18 1.1 dholland * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
19 1.1 dholland * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
20 1.1 dholland * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 1.1 dholland * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
22 1.1 dholland * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 1.1 dholland * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 1.1 dholland * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 1.1 dholland * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 1.1 dholland * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 1.1 dholland * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 1.1 dholland * POSSIBILITY OF SUCH DAMAGE.
29 1.1 dholland */
30 1.1 dholland
31 1.1 dholland #include <sys/cdefs.h>
32 1.21 dholland __KERNEL_RCSID(0, "$NetBSD: ulfs_quota2.c,v 1.21 2015/07/28 05:09:35 dholland Exp $");
33 1.1 dholland
34 1.1 dholland #include <sys/buf.h>
35 1.1 dholland #include <sys/param.h>
36 1.1 dholland #include <sys/kernel.h>
37 1.1 dholland #include <sys/systm.h>
38 1.1 dholland #include <sys/namei.h>
39 1.1 dholland #include <sys/file.h>
40 1.1 dholland #include <sys/proc.h>
41 1.1 dholland #include <sys/vnode.h>
42 1.1 dholland #include <sys/mount.h>
43 1.1 dholland #include <sys/fstrans.h>
44 1.1 dholland #include <sys/kauth.h>
45 1.1 dholland #include <sys/wapbl.h>
46 1.1 dholland #include <sys/quota.h>
47 1.1 dholland #include <sys/quotactl.h>
48 1.1 dholland
49 1.21 dholland #include <ufs/lfs/lfs.h>
50 1.21 dholland #include <ufs/lfs/lfs_accessors.h>
51 1.7 dholland #include <ufs/lfs/lfs_extern.h>
52 1.7 dholland
53 1.2 dholland #include <ufs/lfs/ulfs_quota2.h>
54 1.2 dholland #include <ufs/lfs/ulfs_inode.h>
55 1.2 dholland #include <ufs/lfs/ulfsmount.h>
56 1.2 dholland #include <ufs/lfs/ulfs_bswap.h>
57 1.2 dholland #include <ufs/lfs/ulfs_extern.h>
58 1.2 dholland #include <ufs/lfs/ulfs_quota.h>
59 1.1 dholland
60 1.1 dholland /*
61 1.1 dholland * LOCKING:
62 1.1 dholland * Data in the entries are protected by the associated struct dquot's
63 1.1 dholland * dq_interlock (this means we can't read or change a quota entry without
64 1.1 dholland * grabing a dquot for it).
65 1.1 dholland * The header and lists (including pointers in the data entries, and q2e_uid)
66 1.1 dholland * are protected by the global dqlock.
67 1.1 dholland * the locking order is dq_interlock -> dqlock
68 1.1 dholland */
69 1.1 dholland
70 1.1 dholland static int quota2_bwrite(struct mount *, struct buf *);
71 1.1 dholland static int getinoquota2(struct inode *, bool, bool, struct buf **,
72 1.1 dholland struct quota2_entry **);
73 1.4 dholland static int getq2h(struct ulfsmount *, int, struct buf **,
74 1.1 dholland struct quota2_header **, int);
75 1.4 dholland static int getq2e(struct ulfsmount *, int, daddr_t, int, struct buf **,
76 1.1 dholland struct quota2_entry **, int);
77 1.4 dholland static int quota2_walk_list(struct ulfsmount *, struct buf *, int,
78 1.1 dholland uint64_t *, int, void *,
79 1.4 dholland int (*func)(struct ulfsmount *, uint64_t *, struct quota2_entry *,
80 1.1 dholland uint64_t, void *));
81 1.1 dholland
82 1.1 dholland static const char *limnames[] = INITQLNAMES;
83 1.1 dholland
84 1.1 dholland static void
85 1.1 dholland quota2_dict_update_q2e_limits(int objtype, const struct quotaval *val,
86 1.1 dholland struct quota2_entry *q2e)
87 1.1 dholland {
88 1.1 dholland /* make sure we can index q2e_val[] by the fs-independent objtype */
89 1.1 dholland CTASSERT(QUOTA_OBJTYPE_BLOCKS == QL_BLOCK);
90 1.1 dholland CTASSERT(QUOTA_OBJTYPE_FILES == QL_FILE);
91 1.1 dholland
92 1.1 dholland q2e->q2e_val[objtype].q2v_hardlimit = val->qv_hardlimit;
93 1.1 dholland q2e->q2e_val[objtype].q2v_softlimit = val->qv_softlimit;
94 1.1 dholland q2e->q2e_val[objtype].q2v_grace = val->qv_grace;
95 1.1 dholland }
96 1.1 dholland
97 1.1 dholland /*
98 1.1 dholland * Convert internal representation to FS-independent representation.
99 1.1 dholland * (Note that while the two types are currently identical, the
100 1.1 dholland * internal representation is an on-disk struct and the FS-independent
101 1.1 dholland * representation is not, and they might diverge in the future.)
102 1.1 dholland */
103 1.1 dholland static void
104 1.1 dholland q2val_to_quotaval(struct quota2_val *q2v, struct quotaval *qv)
105 1.1 dholland {
106 1.1 dholland qv->qv_softlimit = q2v->q2v_softlimit;
107 1.1 dholland qv->qv_hardlimit = q2v->q2v_hardlimit;
108 1.1 dholland qv->qv_usage = q2v->q2v_cur;
109 1.1 dholland qv->qv_expiretime = q2v->q2v_time;
110 1.1 dholland qv->qv_grace = q2v->q2v_grace;
111 1.1 dholland }
112 1.1 dholland
113 1.1 dholland /*
114 1.1 dholland * Convert a quota2entry and default-flag to the FS-independent
115 1.1 dholland * representation.
116 1.1 dholland */
117 1.1 dholland static void
118 1.1 dholland q2e_to_quotaval(struct quota2_entry *q2e, int def,
119 1.1 dholland id_t *id, int objtype, struct quotaval *ret)
120 1.1 dholland {
121 1.1 dholland if (def) {
122 1.1 dholland *id = QUOTA_DEFAULTID;
123 1.1 dholland } else {
124 1.1 dholland *id = q2e->q2e_uid;
125 1.1 dholland }
126 1.1 dholland
127 1.1 dholland KASSERT(objtype >= 0 && objtype < N_QL);
128 1.1 dholland q2val_to_quotaval(&q2e->q2e_val[objtype], ret);
129 1.1 dholland }
130 1.1 dholland
131 1.1 dholland
132 1.1 dholland static int
133 1.1 dholland quota2_bwrite(struct mount *mp, struct buf *bp)
134 1.1 dholland {
135 1.1 dholland if (mp->mnt_flag & MNT_SYNCHRONOUS)
136 1.1 dholland return bwrite(bp);
137 1.1 dholland else {
138 1.1 dholland bdwrite(bp);
139 1.1 dholland return 0;
140 1.1 dholland }
141 1.1 dholland }
142 1.1 dholland
143 1.1 dholland static int
144 1.4 dholland getq2h(struct ulfsmount *ump, int type,
145 1.1 dholland struct buf **bpp, struct quota2_header **q2hp, int flags)
146 1.1 dholland {
147 1.9 dholland struct lfs *fs = ump->um_lfs;
148 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
149 1.1 dholland int error;
150 1.1 dholland struct buf *bp;
151 1.1 dholland struct quota2_header *q2h;
152 1.1 dholland
153 1.5 dholland KASSERT(mutex_owned(&lfs_dqlock));
154 1.18 maxv error = bread(ump->um_quotas[type], 0, ump->umq2_bsize, flags, &bp);
155 1.1 dholland if (error)
156 1.1 dholland return error;
157 1.1 dholland if (bp->b_resid != 0)
158 1.5 dholland panic("dq2get: %s quota file truncated", lfs_quotatypes[type]);
159 1.1 dholland
160 1.1 dholland q2h = (void *)bp->b_data;
161 1.4 dholland if (ulfs_rw32(q2h->q2h_magic_number, needswap) != Q2_HEAD_MAGIC ||
162 1.1 dholland q2h->q2h_type != type)
163 1.5 dholland panic("dq2get: corrupted %s quota header", lfs_quotatypes[type]);
164 1.1 dholland *bpp = bp;
165 1.1 dholland *q2hp = q2h;
166 1.1 dholland return 0;
167 1.1 dholland }
168 1.1 dholland
169 1.1 dholland static int
170 1.4 dholland getq2e(struct ulfsmount *ump, int type, daddr_t lblkno, int blkoffset,
171 1.1 dholland struct buf **bpp, struct quota2_entry **q2ep, int flags)
172 1.1 dholland {
173 1.1 dholland int error;
174 1.1 dholland struct buf *bp;
175 1.1 dholland
176 1.1 dholland if (blkoffset & (sizeof(uint64_t) - 1)) {
177 1.1 dholland panic("dq2get: %s quota file corrupted",
178 1.5 dholland lfs_quotatypes[type]);
179 1.1 dholland }
180 1.18 maxv error = bread(ump->um_quotas[type], lblkno, ump->umq2_bsize, flags, &bp);
181 1.1 dholland if (error)
182 1.1 dholland return error;
183 1.1 dholland if (bp->b_resid != 0) {
184 1.1 dholland panic("dq2get: %s quota file corrupted",
185 1.5 dholland lfs_quotatypes[type]);
186 1.1 dholland }
187 1.1 dholland *q2ep = (void *)((char *)bp->b_data + blkoffset);
188 1.1 dholland *bpp = bp;
189 1.1 dholland return 0;
190 1.1 dholland }
191 1.1 dholland
192 1.1 dholland /* walk a quota entry list, calling the callback for each entry */
193 1.1 dholland #define Q2WL_ABORT 0x10000000
194 1.1 dholland
195 1.1 dholland static int
196 1.4 dholland quota2_walk_list(struct ulfsmount *ump, struct buf *hbp, int type,
197 1.1 dholland uint64_t *offp, int flags, void *a,
198 1.4 dholland int (*func)(struct ulfsmount *, uint64_t *, struct quota2_entry *, uint64_t, void *))
199 1.1 dholland {
200 1.9 dholland struct lfs *fs = ump->um_lfs;
201 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
202 1.4 dholland daddr_t off = ulfs_rw64(*offp, needswap);
203 1.1 dholland struct buf *bp, *obp = hbp;
204 1.1 dholland int ret = 0, ret2 = 0;
205 1.1 dholland struct quota2_entry *q2e;
206 1.1 dholland daddr_t lblkno, blkoff, olblkno = 0;
207 1.1 dholland
208 1.5 dholland KASSERT(mutex_owner(&lfs_dqlock));
209 1.1 dholland
210 1.1 dholland while (off != 0) {
211 1.1 dholland lblkno = (off >> ump->um_mountp->mnt_fs_bshift);
212 1.1 dholland blkoff = (off & ump->umq2_bmask);
213 1.1 dholland if (lblkno == 0) {
214 1.1 dholland /* in the header block */
215 1.1 dholland bp = hbp;
216 1.1 dholland } else if (lblkno == olblkno) {
217 1.1 dholland /* still in the same buf */
218 1.1 dholland bp = obp;
219 1.1 dholland } else {
220 1.1 dholland ret = bread(ump->um_quotas[type], lblkno,
221 1.18 maxv ump->umq2_bsize, flags, &bp);
222 1.1 dholland if (ret)
223 1.1 dholland return ret;
224 1.1 dholland if (bp->b_resid != 0) {
225 1.1 dholland panic("quota2_walk_list: %s quota file corrupted",
226 1.5 dholland lfs_quotatypes[type]);
227 1.1 dholland }
228 1.1 dholland }
229 1.1 dholland q2e = (void *)((char *)(bp->b_data) + blkoff);
230 1.1 dholland ret = (*func)(ump, offp, q2e, off, a);
231 1.4 dholland if (off != ulfs_rw64(*offp, needswap)) {
232 1.1 dholland /* callback changed parent's pointer, redo */
233 1.4 dholland off = ulfs_rw64(*offp, needswap);
234 1.1 dholland if (bp != hbp && bp != obp)
235 1.1 dholland ret2 = bwrite(bp);
236 1.1 dholland } else {
237 1.1 dholland /* parent if now current */
238 1.1 dholland if (obp != bp && obp != hbp) {
239 1.1 dholland if (flags & B_MODIFY)
240 1.1 dholland ret2 = bwrite(obp);
241 1.1 dholland else
242 1.1 dholland brelse(obp, 0);
243 1.1 dholland }
244 1.1 dholland obp = bp;
245 1.1 dholland olblkno = lblkno;
246 1.1 dholland offp = &(q2e->q2e_next);
247 1.4 dholland off = ulfs_rw64(*offp, needswap);
248 1.1 dholland }
249 1.1 dholland if (ret)
250 1.1 dholland break;
251 1.1 dholland if (ret2) {
252 1.1 dholland ret = ret2;
253 1.1 dholland break;
254 1.1 dholland }
255 1.1 dholland }
256 1.1 dholland if (obp != hbp) {
257 1.1 dholland if (flags & B_MODIFY)
258 1.1 dholland ret2 = bwrite(obp);
259 1.1 dholland else
260 1.1 dholland brelse(obp, 0);
261 1.1 dholland }
262 1.1 dholland if (ret & Q2WL_ABORT)
263 1.1 dholland return 0;
264 1.1 dholland if (ret == 0)
265 1.1 dholland return ret2;
266 1.1 dholland return ret;
267 1.1 dholland }
268 1.1 dholland
269 1.1 dholland int
270 1.5 dholland lfsquota2_umount(struct mount *mp, int flags)
271 1.1 dholland {
272 1.1 dholland int i, error;
273 1.4 dholland struct ulfsmount *ump = VFSTOULFS(mp);
274 1.9 dholland struct lfs *fs = ump->um_lfs;
275 1.1 dholland
276 1.9 dholland if ((fs->um_flags & ULFS_QUOTA2) == 0)
277 1.1 dholland return 0;
278 1.1 dholland
279 1.4 dholland for (i = 0; i < ULFS_MAXQUOTAS; i++) {
280 1.1 dholland if (ump->um_quotas[i] != NULLVP) {
281 1.1 dholland error = vn_close(ump->um_quotas[i], FREAD|FWRITE,
282 1.1 dholland ump->um_cred[i]);
283 1.1 dholland if (error) {
284 1.1 dholland printf("quota2_umount failed: close(%p) %d\n",
285 1.1 dholland ump->um_quotas[i], error);
286 1.1 dholland return error;
287 1.1 dholland }
288 1.1 dholland }
289 1.1 dholland ump->um_quotas[i] = NULLVP;
290 1.1 dholland }
291 1.1 dholland return 0;
292 1.1 dholland }
293 1.1 dholland
294 1.1 dholland static int
295 1.4 dholland quota2_q2ealloc(struct ulfsmount *ump, int type, uid_t uid, struct dquot *dq)
296 1.1 dholland {
297 1.1 dholland int error, error2;
298 1.1 dholland struct buf *hbp, *bp;
299 1.1 dholland struct quota2_header *q2h;
300 1.1 dholland struct quota2_entry *q2e;
301 1.1 dholland daddr_t offset;
302 1.1 dholland u_long hash_mask;
303 1.12 dholland struct lfs *fs = ump->um_lfs;
304 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
305 1.1 dholland
306 1.1 dholland KASSERT(mutex_owned(&dq->dq_interlock));
307 1.5 dholland KASSERT(mutex_owned(&lfs_dqlock));
308 1.1 dholland error = getq2h(ump, type, &hbp, &q2h, B_MODIFY);
309 1.1 dholland if (error)
310 1.1 dholland return error;
311 1.4 dholland offset = ulfs_rw64(q2h->q2h_free, needswap);
312 1.1 dholland if (offset == 0) {
313 1.1 dholland struct vnode *vp = ump->um_quotas[type];
314 1.1 dholland struct inode *ip = VTOI(vp);
315 1.1 dholland uint64_t size = ip->i_size;
316 1.1 dholland /* need to alocate a new disk block */
317 1.8 dholland error = lfs_balloc(vp, size, ump->umq2_bsize,
318 1.1 dholland ump->um_cred[type], B_CLRBUF | B_SYNC, &bp);
319 1.1 dholland if (error) {
320 1.1 dholland brelse(hbp, 0);
321 1.1 dholland return error;
322 1.1 dholland }
323 1.1 dholland KASSERT((ip->i_size % ump->umq2_bsize) == 0);
324 1.1 dholland ip->i_size += ump->umq2_bsize;
325 1.1 dholland DIP_ASSIGN(ip, size, ip->i_size);
326 1.1 dholland ip->i_flag |= IN_CHANGE | IN_UPDATE;
327 1.1 dholland uvm_vnp_setsize(vp, ip->i_size);
328 1.5 dholland lfsquota2_addfreeq2e(q2h, bp->b_data, size, ump->umq2_bsize,
329 1.1 dholland needswap);
330 1.1 dholland error = bwrite(bp);
331 1.8 dholland error2 = lfs_update(vp, NULL, NULL, UPDATE_WAIT);
332 1.1 dholland if (error || error2) {
333 1.1 dholland brelse(hbp, 0);
334 1.1 dholland if (error)
335 1.1 dholland return error;
336 1.1 dholland return error2;
337 1.1 dholland }
338 1.4 dholland offset = ulfs_rw64(q2h->q2h_free, needswap);
339 1.1 dholland KASSERT(offset != 0);
340 1.1 dholland }
341 1.1 dholland dq->dq2_lblkno = (offset >> ump->um_mountp->mnt_fs_bshift);
342 1.1 dholland dq->dq2_blkoff = (offset & ump->umq2_bmask);
343 1.1 dholland if (dq->dq2_lblkno == 0) {
344 1.1 dholland bp = hbp;
345 1.1 dholland q2e = (void *)((char *)bp->b_data + dq->dq2_blkoff);
346 1.1 dholland } else {
347 1.1 dholland error = getq2e(ump, type, dq->dq2_lblkno,
348 1.1 dholland dq->dq2_blkoff, &bp, &q2e, B_MODIFY);
349 1.1 dholland if (error) {
350 1.1 dholland brelse(hbp, 0);
351 1.1 dholland return error;
352 1.1 dholland }
353 1.1 dholland }
354 1.1 dholland hash_mask = ((1 << q2h->q2h_hash_shift) - 1);
355 1.1 dholland /* remove from free list */
356 1.1 dholland q2h->q2h_free = q2e->q2e_next;
357 1.1 dholland
358 1.1 dholland memcpy(q2e, &q2h->q2h_defentry, sizeof(*q2e));
359 1.4 dholland q2e->q2e_uid = ulfs_rw32(uid, needswap);
360 1.1 dholland /* insert in hash list */
361 1.1 dholland q2e->q2e_next = q2h->q2h_entries[uid & hash_mask];
362 1.4 dholland q2h->q2h_entries[uid & hash_mask] = ulfs_rw64(offset, needswap);
363 1.1 dholland if (hbp != bp) {
364 1.1 dholland bwrite(hbp);
365 1.1 dholland }
366 1.1 dholland bwrite(bp);
367 1.1 dholland return 0;
368 1.1 dholland }
369 1.1 dholland
370 1.1 dholland static int
371 1.1 dholland getinoquota2(struct inode *ip, bool alloc, bool modify, struct buf **bpp,
372 1.1 dholland struct quota2_entry **q2ep)
373 1.1 dholland {
374 1.1 dholland int error;
375 1.1 dholland int i;
376 1.1 dholland struct dquot *dq;
377 1.4 dholland struct ulfsmount *ump = ip->i_ump;
378 1.4 dholland u_int32_t ino_ids[ULFS_MAXQUOTAS];
379 1.1 dholland
380 1.5 dholland error = lfs_getinoquota(ip);
381 1.1 dholland if (error)
382 1.1 dholland return error;
383 1.1 dholland
384 1.4 dholland ino_ids[ULFS_USRQUOTA] = ip->i_uid;
385 1.4 dholland ino_ids[ULFS_GRPQUOTA] = ip->i_gid;
386 1.1 dholland /* first get the interlock for all dquot */
387 1.4 dholland for (i = 0; i < ULFS_MAXQUOTAS; i++) {
388 1.1 dholland dq = ip->i_dquot[i];
389 1.1 dholland if (dq == NODQUOT)
390 1.1 dholland continue;
391 1.1 dholland mutex_enter(&dq->dq_interlock);
392 1.1 dholland }
393 1.1 dholland /* now get the corresponding quota entry */
394 1.4 dholland for (i = 0; i < ULFS_MAXQUOTAS; i++) {
395 1.1 dholland bpp[i] = NULL;
396 1.1 dholland q2ep[i] = NULL;
397 1.1 dholland dq = ip->i_dquot[i];
398 1.1 dholland if (dq == NODQUOT)
399 1.1 dholland continue;
400 1.1 dholland if (__predict_false(ump->um_quotas[i] == NULL)) {
401 1.1 dholland /*
402 1.1 dholland * quotas have been turned off. This can happen
403 1.1 dholland * at umount time.
404 1.1 dholland */
405 1.1 dholland mutex_exit(&dq->dq_interlock);
406 1.5 dholland lfs_dqrele(NULLVP, dq);
407 1.1 dholland ip->i_dquot[i] = NULL;
408 1.1 dholland continue;
409 1.1 dholland }
410 1.1 dholland
411 1.1 dholland if ((dq->dq2_lblkno | dq->dq2_blkoff) == 0) {
412 1.1 dholland if (!alloc) {
413 1.1 dholland continue;
414 1.1 dholland }
415 1.1 dholland /* need to alloc a new on-disk quot */
416 1.5 dholland mutex_enter(&lfs_dqlock);
417 1.1 dholland error = quota2_q2ealloc(ump, i, ino_ids[i], dq);
418 1.5 dholland mutex_exit(&lfs_dqlock);
419 1.1 dholland if (error)
420 1.1 dholland return error;
421 1.1 dholland }
422 1.1 dholland KASSERT(dq->dq2_lblkno != 0 || dq->dq2_blkoff != 0);
423 1.1 dholland error = getq2e(ump, i, dq->dq2_lblkno,
424 1.1 dholland dq->dq2_blkoff, &bpp[i], &q2ep[i],
425 1.1 dholland modify ? B_MODIFY : 0);
426 1.1 dholland if (error)
427 1.1 dholland return error;
428 1.1 dholland }
429 1.1 dholland return 0;
430 1.1 dholland }
431 1.1 dholland
432 1.1 dholland __inline static int __unused
433 1.5 dholland lfsquota2_check_limit(struct quota2_val *q2v, uint64_t change, time_t now)
434 1.1 dholland {
435 1.5 dholland return lfsquota_check_limit(q2v->q2v_cur, change, q2v->q2v_softlimit,
436 1.1 dholland q2v->q2v_hardlimit, q2v->q2v_time, now);
437 1.1 dholland }
438 1.1 dholland
439 1.1 dholland static int
440 1.1 dholland quota2_check(struct inode *ip, int vtype, int64_t change, kauth_cred_t cred,
441 1.1 dholland int flags)
442 1.1 dholland {
443 1.1 dholland int error;
444 1.4 dholland struct buf *bp[ULFS_MAXQUOTAS];
445 1.4 dholland struct quota2_entry *q2e[ULFS_MAXQUOTAS];
446 1.1 dholland struct quota2_val *q2vp;
447 1.1 dholland struct dquot *dq;
448 1.1 dholland uint64_t ncurblks;
449 1.4 dholland struct ulfsmount *ump = ip->i_ump;
450 1.12 dholland struct lfs *fs = ip->i_lfs;
451 1.1 dholland struct mount *mp = ump->um_mountp;
452 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
453 1.1 dholland int i;
454 1.1 dholland
455 1.1 dholland if ((error = getinoquota2(ip, change > 0, change != 0, bp, q2e)) != 0)
456 1.1 dholland return error;
457 1.1 dholland if (change == 0) {
458 1.4 dholland for (i = 0; i < ULFS_MAXQUOTAS; i++) {
459 1.1 dholland dq = ip->i_dquot[i];
460 1.1 dholland if (dq == NODQUOT)
461 1.1 dholland continue;
462 1.1 dholland if (bp[i])
463 1.1 dholland brelse(bp[i], 0);
464 1.1 dholland mutex_exit(&dq->dq_interlock);
465 1.1 dholland }
466 1.1 dholland return 0;
467 1.1 dholland }
468 1.1 dholland if (change < 0) {
469 1.4 dholland for (i = 0; i < ULFS_MAXQUOTAS; i++) {
470 1.1 dholland dq = ip->i_dquot[i];
471 1.1 dholland if (dq == NODQUOT)
472 1.1 dholland continue;
473 1.1 dholland if (q2e[i] == NULL) {
474 1.1 dholland mutex_exit(&dq->dq_interlock);
475 1.1 dholland continue;
476 1.1 dholland }
477 1.1 dholland q2vp = &q2e[i]->q2e_val[vtype];
478 1.4 dholland ncurblks = ulfs_rw64(q2vp->q2v_cur, needswap);
479 1.1 dholland if (ncurblks < -change)
480 1.1 dholland ncurblks = 0;
481 1.1 dholland else
482 1.1 dholland ncurblks += change;
483 1.4 dholland q2vp->q2v_cur = ulfs_rw64(ncurblks, needswap);
484 1.1 dholland quota2_bwrite(mp, bp[i]);
485 1.1 dholland mutex_exit(&dq->dq_interlock);
486 1.1 dholland }
487 1.1 dholland return 0;
488 1.1 dholland }
489 1.1 dholland /* see if the allocation is allowed */
490 1.4 dholland for (i = 0; i < ULFS_MAXQUOTAS; i++) {
491 1.1 dholland struct quota2_val q2v;
492 1.1 dholland int ql_stat;
493 1.1 dholland dq = ip->i_dquot[i];
494 1.1 dholland if (dq == NODQUOT)
495 1.1 dholland continue;
496 1.1 dholland KASSERT(q2e[i] != NULL);
497 1.5 dholland lfsquota2_ulfs_rwq2v(&q2e[i]->q2e_val[vtype], &q2v, needswap);
498 1.5 dholland ql_stat = lfsquota2_check_limit(&q2v, change, time_second);
499 1.1 dholland
500 1.1 dholland if ((flags & FORCE) == 0 &&
501 1.1 dholland kauth_authorize_system(cred, KAUTH_SYSTEM_FS_QUOTA,
502 1.1 dholland KAUTH_REQ_SYSTEM_FS_QUOTA_NOLIMIT,
503 1.1 dholland KAUTH_ARG(i), KAUTH_ARG(vtype), NULL) != 0) {
504 1.1 dholland /* enforce this limit */
505 1.1 dholland switch(QL_STATUS(ql_stat)) {
506 1.1 dholland case QL_S_DENY_HARD:
507 1.1 dholland if ((dq->dq_flags & DQ_WARN(vtype)) == 0) {
508 1.1 dholland uprintf("\n%s: write failed, %s %s "
509 1.1 dholland "limit reached\n",
510 1.1 dholland mp->mnt_stat.f_mntonname,
511 1.5 dholland lfs_quotatypes[i], limnames[vtype]);
512 1.1 dholland dq->dq_flags |= DQ_WARN(vtype);
513 1.1 dholland }
514 1.1 dholland error = EDQUOT;
515 1.1 dholland break;
516 1.1 dholland case QL_S_DENY_GRACE:
517 1.1 dholland if ((dq->dq_flags & DQ_WARN(vtype)) == 0) {
518 1.1 dholland uprintf("\n%s: write failed, %s %s "
519 1.1 dholland "limit reached\n",
520 1.1 dholland mp->mnt_stat.f_mntonname,
521 1.5 dholland lfs_quotatypes[i], limnames[vtype]);
522 1.1 dholland dq->dq_flags |= DQ_WARN(vtype);
523 1.1 dholland }
524 1.1 dholland error = EDQUOT;
525 1.1 dholland break;
526 1.1 dholland case QL_S_ALLOW_SOFT:
527 1.1 dholland if ((dq->dq_flags & DQ_WARN(vtype)) == 0) {
528 1.1 dholland uprintf("\n%s: warning, %s %s "
529 1.1 dholland "quota exceeded\n",
530 1.1 dholland mp->mnt_stat.f_mntonname,
531 1.5 dholland lfs_quotatypes[i], limnames[vtype]);
532 1.1 dholland dq->dq_flags |= DQ_WARN(vtype);
533 1.1 dholland }
534 1.1 dholland break;
535 1.1 dholland }
536 1.1 dholland }
537 1.1 dholland /*
538 1.1 dholland * always do this; we don't know if the allocation will
539 1.1 dholland * succed or not in the end. if we don't do the allocation
540 1.1 dholland * q2v_time will be ignored anyway
541 1.1 dholland */
542 1.1 dholland if (ql_stat & QL_F_CROSS) {
543 1.1 dholland q2v.q2v_time = time_second + q2v.q2v_grace;
544 1.5 dholland lfsquota2_ulfs_rwq2v(&q2v, &q2e[i]->q2e_val[vtype],
545 1.1 dholland needswap);
546 1.1 dholland }
547 1.1 dholland }
548 1.1 dholland
549 1.1 dholland /* now do the allocation if allowed */
550 1.4 dholland for (i = 0; i < ULFS_MAXQUOTAS; i++) {
551 1.1 dholland dq = ip->i_dquot[i];
552 1.1 dholland if (dq == NODQUOT)
553 1.1 dholland continue;
554 1.1 dholland KASSERT(q2e[i] != NULL);
555 1.1 dholland if (error == 0) {
556 1.1 dholland q2vp = &q2e[i]->q2e_val[vtype];
557 1.4 dholland ncurblks = ulfs_rw64(q2vp->q2v_cur, needswap);
558 1.4 dholland q2vp->q2v_cur = ulfs_rw64(ncurblks + change, needswap);
559 1.1 dholland quota2_bwrite(mp, bp[i]);
560 1.1 dholland } else
561 1.1 dholland brelse(bp[i], 0);
562 1.1 dholland mutex_exit(&dq->dq_interlock);
563 1.1 dholland }
564 1.1 dholland return error;
565 1.1 dholland }
566 1.1 dholland
567 1.1 dholland int
568 1.5 dholland lfs_chkdq2(struct inode *ip, int64_t change, kauth_cred_t cred, int flags)
569 1.1 dholland {
570 1.1 dholland return quota2_check(ip, QL_BLOCK, change, cred, flags);
571 1.1 dholland }
572 1.1 dholland
573 1.1 dholland int
574 1.5 dholland lfs_chkiq2(struct inode *ip, int32_t change, kauth_cred_t cred, int flags)
575 1.1 dholland {
576 1.1 dholland return quota2_check(ip, QL_FILE, change, cred, flags);
577 1.1 dholland }
578 1.1 dholland
579 1.1 dholland int
580 1.5 dholland lfsquota2_handle_cmd_put(struct ulfsmount *ump, const struct quotakey *key,
581 1.1 dholland const struct quotaval *val)
582 1.1 dholland {
583 1.1 dholland int error;
584 1.1 dholland struct dquot *dq;
585 1.1 dholland struct quota2_header *q2h;
586 1.1 dholland struct quota2_entry q2e, *q2ep;
587 1.1 dholland struct buf *bp;
588 1.12 dholland struct lfs *fs = ump->um_lfs;
589 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
590 1.1 dholland
591 1.1 dholland /* make sure we can index by the fs-independent idtype */
592 1.4 dholland CTASSERT(QUOTA_IDTYPE_USER == ULFS_USRQUOTA);
593 1.4 dholland CTASSERT(QUOTA_IDTYPE_GROUP == ULFS_GRPQUOTA);
594 1.1 dholland
595 1.1 dholland if (ump->um_quotas[key->qk_idtype] == NULLVP)
596 1.1 dholland return ENODEV;
597 1.1 dholland
598 1.1 dholland if (key->qk_id == QUOTA_DEFAULTID) {
599 1.5 dholland mutex_enter(&lfs_dqlock);
600 1.1 dholland error = getq2h(ump, key->qk_idtype, &bp, &q2h, B_MODIFY);
601 1.1 dholland if (error) {
602 1.5 dholland mutex_exit(&lfs_dqlock);
603 1.1 dholland goto out_wapbl;
604 1.1 dholland }
605 1.5 dholland lfsquota2_ulfs_rwq2e(&q2h->q2h_defentry, &q2e, needswap);
606 1.1 dholland quota2_dict_update_q2e_limits(key->qk_objtype, val, &q2e);
607 1.5 dholland lfsquota2_ulfs_rwq2e(&q2e, &q2h->q2h_defentry, needswap);
608 1.5 dholland mutex_exit(&lfs_dqlock);
609 1.1 dholland quota2_bwrite(ump->um_mountp, bp);
610 1.1 dholland goto out_wapbl;
611 1.1 dholland }
612 1.1 dholland
613 1.5 dholland error = lfs_dqget(NULLVP, key->qk_id, ump, key->qk_idtype, &dq);
614 1.1 dholland if (error)
615 1.1 dholland goto out_wapbl;
616 1.1 dholland
617 1.1 dholland mutex_enter(&dq->dq_interlock);
618 1.1 dholland if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
619 1.1 dholland /* need to alloc a new on-disk quot */
620 1.5 dholland mutex_enter(&lfs_dqlock);
621 1.1 dholland error = quota2_q2ealloc(ump, key->qk_idtype, key->qk_id, dq);
622 1.5 dholland mutex_exit(&lfs_dqlock);
623 1.1 dholland if (error)
624 1.1 dholland goto out_il;
625 1.1 dholland }
626 1.1 dholland KASSERT(dq->dq2_lblkno != 0 || dq->dq2_blkoff != 0);
627 1.1 dholland error = getq2e(ump, key->qk_idtype, dq->dq2_lblkno,
628 1.1 dholland dq->dq2_blkoff, &bp, &q2ep, B_MODIFY);
629 1.1 dholland if (error)
630 1.1 dholland goto out_il;
631 1.1 dholland
632 1.5 dholland lfsquota2_ulfs_rwq2e(q2ep, &q2e, needswap);
633 1.1 dholland quota2_dict_update_q2e_limits(key->qk_objtype, val, &q2e);
634 1.5 dholland lfsquota2_ulfs_rwq2e(&q2e, q2ep, needswap);
635 1.1 dholland quota2_bwrite(ump->um_mountp, bp);
636 1.1 dholland
637 1.1 dholland out_il:
638 1.1 dholland mutex_exit(&dq->dq_interlock);
639 1.5 dholland lfs_dqrele(NULLVP, dq);
640 1.1 dholland out_wapbl:
641 1.1 dholland return error;
642 1.1 dholland }
643 1.1 dholland
644 1.1 dholland struct dq2clear_callback {
645 1.1 dholland uid_t id;
646 1.1 dholland struct dquot *dq;
647 1.1 dholland struct quota2_header *q2h;
648 1.1 dholland };
649 1.1 dholland
650 1.1 dholland static int
651 1.4 dholland dq2clear_callback(struct ulfsmount *ump, uint64_t *offp, struct quota2_entry *q2e,
652 1.1 dholland uint64_t off, void *v)
653 1.1 dholland {
654 1.1 dholland struct dq2clear_callback *c = v;
655 1.9 dholland struct lfs *fs = ump->um_lfs;
656 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
657 1.1 dholland uint64_t myoff;
658 1.1 dholland
659 1.4 dholland if (ulfs_rw32(q2e->q2e_uid, needswap) == c->id) {
660 1.1 dholland KASSERT(mutex_owned(&c->dq->dq_interlock));
661 1.1 dholland c->dq->dq2_lblkno = 0;
662 1.1 dholland c->dq->dq2_blkoff = 0;
663 1.1 dholland myoff = *offp;
664 1.1 dholland /* remove from hash list */
665 1.1 dholland *offp = q2e->q2e_next;
666 1.1 dholland /* add to free list */
667 1.1 dholland q2e->q2e_next = c->q2h->q2h_free;
668 1.1 dholland c->q2h->q2h_free = myoff;
669 1.1 dholland return Q2WL_ABORT;
670 1.1 dholland }
671 1.1 dholland return 0;
672 1.1 dholland }
673 1.1 dholland int
674 1.16 dholland lfsquota2_handle_cmd_del(struct ulfsmount *ump, const struct quotakey *qk)
675 1.1 dholland {
676 1.1 dholland int idtype;
677 1.1 dholland id_t id;
678 1.1 dholland int objtype;
679 1.1 dholland int error, i, canfree;
680 1.1 dholland struct dquot *dq;
681 1.1 dholland struct quota2_header *q2h;
682 1.1 dholland struct quota2_entry q2e, *q2ep;
683 1.1 dholland struct buf *hbp, *bp;
684 1.1 dholland u_long hash_mask;
685 1.1 dholland struct dq2clear_callback c;
686 1.1 dholland
687 1.1 dholland idtype = qk->qk_idtype;
688 1.1 dholland id = qk->qk_id;
689 1.1 dholland objtype = qk->qk_objtype;
690 1.1 dholland
691 1.1 dholland if (ump->um_quotas[idtype] == NULLVP)
692 1.1 dholland return ENODEV;
693 1.1 dholland if (id == QUOTA_DEFAULTID)
694 1.1 dholland return EOPNOTSUPP;
695 1.1 dholland
696 1.1 dholland /* get the default entry before locking the entry's buffer */
697 1.5 dholland mutex_enter(&lfs_dqlock);
698 1.1 dholland error = getq2h(ump, idtype, &hbp, &q2h, 0);
699 1.1 dholland if (error) {
700 1.5 dholland mutex_exit(&lfs_dqlock);
701 1.1 dholland return error;
702 1.1 dholland }
703 1.1 dholland /* we'll copy to another disk entry, so no need to swap */
704 1.1 dholland memcpy(&q2e, &q2h->q2h_defentry, sizeof(q2e));
705 1.5 dholland mutex_exit(&lfs_dqlock);
706 1.1 dholland brelse(hbp, 0);
707 1.1 dholland
708 1.5 dholland error = lfs_dqget(NULLVP, id, ump, idtype, &dq);
709 1.1 dholland if (error)
710 1.1 dholland return error;
711 1.1 dholland
712 1.1 dholland mutex_enter(&dq->dq_interlock);
713 1.1 dholland if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
714 1.1 dholland /* already clear, nothing to do */
715 1.1 dholland error = ENOENT;
716 1.1 dholland goto out_il;
717 1.1 dholland }
718 1.6 dholland
719 1.1 dholland error = getq2e(ump, idtype, dq->dq2_lblkno, dq->dq2_blkoff,
720 1.1 dholland &bp, &q2ep, B_MODIFY);
721 1.1 dholland if (error)
722 1.1 dholland goto out_wapbl;
723 1.1 dholland
724 1.1 dholland /* make sure we can index by the objtype passed in */
725 1.1 dholland CTASSERT(QUOTA_OBJTYPE_BLOCKS == QL_BLOCK);
726 1.1 dholland CTASSERT(QUOTA_OBJTYPE_FILES == QL_FILE);
727 1.1 dholland
728 1.1 dholland /* clear the requested objtype by copying from the default entry */
729 1.1 dholland q2ep->q2e_val[objtype].q2v_softlimit =
730 1.1 dholland q2e.q2e_val[objtype].q2v_softlimit;
731 1.1 dholland q2ep->q2e_val[objtype].q2v_hardlimit =
732 1.1 dholland q2e.q2e_val[objtype].q2v_hardlimit;
733 1.1 dholland q2ep->q2e_val[objtype].q2v_grace =
734 1.1 dholland q2e.q2e_val[objtype].q2v_grace;
735 1.1 dholland q2ep->q2e_val[objtype].q2v_time = 0;
736 1.1 dholland
737 1.1 dholland /* if this entry now contains no information, we can free it */
738 1.1 dholland canfree = 1;
739 1.1 dholland for (i = 0; i < N_QL; i++) {
740 1.1 dholland if (q2ep->q2e_val[i].q2v_cur != 0 ||
741 1.1 dholland (q2ep->q2e_val[i].q2v_softlimit !=
742 1.1 dholland q2e.q2e_val[i].q2v_softlimit) ||
743 1.1 dholland (q2ep->q2e_val[i].q2v_hardlimit !=
744 1.1 dholland q2e.q2e_val[i].q2v_hardlimit) ||
745 1.1 dholland (q2ep->q2e_val[i].q2v_grace !=
746 1.1 dholland q2e.q2e_val[i].q2v_grace)) {
747 1.1 dholland canfree = 0;
748 1.1 dholland break;
749 1.1 dholland }
750 1.1 dholland /* note: do not need to check q2v_time */
751 1.1 dholland }
752 1.1 dholland
753 1.1 dholland if (canfree == 0) {
754 1.1 dholland quota2_bwrite(ump->um_mountp, bp);
755 1.1 dholland goto out_wapbl;
756 1.1 dholland }
757 1.1 dholland /* we can free it. release bp so we can walk the list */
758 1.1 dholland brelse(bp, 0);
759 1.5 dholland mutex_enter(&lfs_dqlock);
760 1.1 dholland error = getq2h(ump, idtype, &hbp, &q2h, 0);
761 1.1 dholland if (error)
762 1.1 dholland goto out_dqlock;
763 1.1 dholland
764 1.1 dholland hash_mask = ((1 << q2h->q2h_hash_shift) - 1);
765 1.1 dholland c.dq = dq;
766 1.1 dholland c.id = id;
767 1.1 dholland c.q2h = q2h;
768 1.1 dholland error = quota2_walk_list(ump, hbp, idtype,
769 1.1 dholland &q2h->q2h_entries[id & hash_mask], B_MODIFY, &c,
770 1.1 dholland dq2clear_callback);
771 1.1 dholland
772 1.1 dholland bwrite(hbp);
773 1.1 dholland
774 1.1 dholland out_dqlock:
775 1.5 dholland mutex_exit(&lfs_dqlock);
776 1.1 dholland out_wapbl:
777 1.1 dholland out_il:
778 1.1 dholland mutex_exit(&dq->dq_interlock);
779 1.5 dholland lfs_dqrele(NULLVP, dq);
780 1.1 dholland return error;
781 1.1 dholland }
782 1.1 dholland
783 1.1 dholland static int
784 1.4 dholland quota2_fetch_q2e(struct ulfsmount *ump, const struct quotakey *qk,
785 1.1 dholland struct quota2_entry *ret)
786 1.1 dholland {
787 1.1 dholland struct dquot *dq;
788 1.1 dholland int error;
789 1.1 dholland struct quota2_entry *q2ep;
790 1.1 dholland struct buf *bp;
791 1.12 dholland struct lfs *fs = ump->um_lfs;
792 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
793 1.1 dholland
794 1.5 dholland error = lfs_dqget(NULLVP, qk->qk_id, ump, qk->qk_idtype, &dq);
795 1.1 dholland if (error)
796 1.1 dholland return error;
797 1.1 dholland
798 1.1 dholland mutex_enter(&dq->dq_interlock);
799 1.1 dholland if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
800 1.1 dholland mutex_exit(&dq->dq_interlock);
801 1.5 dholland lfs_dqrele(NULLVP, dq);
802 1.1 dholland return ENOENT;
803 1.1 dholland }
804 1.1 dholland error = getq2e(ump, qk->qk_idtype, dq->dq2_lblkno, dq->dq2_blkoff,
805 1.1 dholland &bp, &q2ep, 0);
806 1.1 dholland if (error) {
807 1.1 dholland mutex_exit(&dq->dq_interlock);
808 1.5 dholland lfs_dqrele(NULLVP, dq);
809 1.1 dholland return error;
810 1.1 dholland }
811 1.5 dholland lfsquota2_ulfs_rwq2e(q2ep, ret, needswap);
812 1.1 dholland brelse(bp, 0);
813 1.1 dholland mutex_exit(&dq->dq_interlock);
814 1.5 dholland lfs_dqrele(NULLVP, dq);
815 1.1 dholland
816 1.1 dholland return 0;
817 1.1 dholland }
818 1.1 dholland
819 1.1 dholland static int
820 1.4 dholland quota2_fetch_quotaval(struct ulfsmount *ump, const struct quotakey *qk,
821 1.1 dholland struct quotaval *ret)
822 1.1 dholland {
823 1.1 dholland struct dquot *dq;
824 1.1 dholland int error;
825 1.1 dholland struct quota2_entry *q2ep, q2e;
826 1.1 dholland struct buf *bp;
827 1.12 dholland struct lfs *fs = ump->um_lfs;
828 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
829 1.1 dholland id_t id2;
830 1.1 dholland
831 1.5 dholland error = lfs_dqget(NULLVP, qk->qk_id, ump, qk->qk_idtype, &dq);
832 1.1 dholland if (error)
833 1.1 dholland return error;
834 1.1 dholland
835 1.1 dholland mutex_enter(&dq->dq_interlock);
836 1.1 dholland if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
837 1.1 dholland mutex_exit(&dq->dq_interlock);
838 1.5 dholland lfs_dqrele(NULLVP, dq);
839 1.1 dholland return ENOENT;
840 1.1 dholland }
841 1.1 dholland error = getq2e(ump, qk->qk_idtype, dq->dq2_lblkno, dq->dq2_blkoff,
842 1.1 dholland &bp, &q2ep, 0);
843 1.1 dholland if (error) {
844 1.1 dholland mutex_exit(&dq->dq_interlock);
845 1.5 dholland lfs_dqrele(NULLVP, dq);
846 1.1 dholland return error;
847 1.1 dholland }
848 1.5 dholland lfsquota2_ulfs_rwq2e(q2ep, &q2e, needswap);
849 1.1 dholland brelse(bp, 0);
850 1.1 dholland mutex_exit(&dq->dq_interlock);
851 1.5 dholland lfs_dqrele(NULLVP, dq);
852 1.1 dholland
853 1.1 dholland q2e_to_quotaval(&q2e, 0, &id2, qk->qk_objtype, ret);
854 1.1 dholland KASSERT(id2 == qk->qk_id);
855 1.1 dholland return 0;
856 1.1 dholland }
857 1.1 dholland
858 1.1 dholland int
859 1.5 dholland lfsquota2_handle_cmd_get(struct ulfsmount *ump, const struct quotakey *qk,
860 1.1 dholland struct quotaval *qv)
861 1.1 dholland {
862 1.1 dholland int error;
863 1.1 dholland struct quota2_header *q2h;
864 1.1 dholland struct quota2_entry q2e;
865 1.1 dholland struct buf *bp;
866 1.12 dholland struct lfs *fs = ump->um_lfs;
867 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
868 1.1 dholland id_t id2;
869 1.1 dholland
870 1.1 dholland /*
871 1.1 dholland * Make sure the FS-independent codes match the internal ones,
872 1.1 dholland * so we can use the passed-in objtype without having to
873 1.1 dholland * convert it explicitly to QL_BLOCK/QL_FILE.
874 1.1 dholland */
875 1.1 dholland CTASSERT(QL_BLOCK == QUOTA_OBJTYPE_BLOCKS);
876 1.1 dholland CTASSERT(QL_FILE == QUOTA_OBJTYPE_FILES);
877 1.1 dholland CTASSERT(N_QL == 2);
878 1.1 dholland
879 1.1 dholland if (qk->qk_objtype < 0 || qk->qk_objtype >= N_QL) {
880 1.1 dholland return EINVAL;
881 1.1 dholland }
882 1.1 dholland
883 1.1 dholland if (ump->um_quotas[qk->qk_idtype] == NULLVP)
884 1.1 dholland return ENODEV;
885 1.1 dholland if (qk->qk_id == QUOTA_DEFAULTID) {
886 1.5 dholland mutex_enter(&lfs_dqlock);
887 1.1 dholland error = getq2h(ump, qk->qk_idtype, &bp, &q2h, 0);
888 1.1 dholland if (error) {
889 1.5 dholland mutex_exit(&lfs_dqlock);
890 1.1 dholland return error;
891 1.1 dholland }
892 1.5 dholland lfsquota2_ulfs_rwq2e(&q2h->q2h_defentry, &q2e, needswap);
893 1.5 dholland mutex_exit(&lfs_dqlock);
894 1.1 dholland brelse(bp, 0);
895 1.1 dholland q2e_to_quotaval(&q2e, qk->qk_id == QUOTA_DEFAULTID, &id2,
896 1.1 dholland qk->qk_objtype, qv);
897 1.1 dholland (void)id2;
898 1.1 dholland } else
899 1.1 dholland error = quota2_fetch_quotaval(ump, qk, qv);
900 1.1 dholland
901 1.1 dholland return error;
902 1.1 dholland }
903 1.1 dholland
904 1.1 dholland /*
905 1.1 dholland * Cursor structure we used.
906 1.1 dholland *
907 1.1 dholland * This will get stored in userland between calls so we must not assume
908 1.1 dholland * it isn't arbitrarily corrupted.
909 1.1 dholland */
910 1.4 dholland struct ulfsq2_cursor {
911 1.1 dholland uint32_t q2c_magic; /* magic number */
912 1.1 dholland int q2c_hashsize; /* size of hash table at last go */
913 1.1 dholland
914 1.1 dholland int q2c_users_done; /* true if we've returned all user data */
915 1.1 dholland int q2c_groups_done; /* true if we've returned all group data */
916 1.1 dholland int q2c_defaults_done; /* true if we've returned the default values */
917 1.1 dholland int q2c_hashpos; /* slot to start at in hash table */
918 1.1 dholland int q2c_uidpos; /* number of ids we've handled */
919 1.1 dholland int q2c_blocks_done; /* true if we've returned the blocks value */
920 1.1 dholland };
921 1.1 dholland
922 1.1 dholland /*
923 1.1 dholland * State of a single cursorget call, or at least the part of it that
924 1.1 dholland * needs to be passed around.
925 1.1 dholland */
926 1.1 dholland struct q2cursor_state {
927 1.1 dholland /* data return pointers */
928 1.1 dholland struct quotakey *keys;
929 1.1 dholland struct quotaval *vals;
930 1.1 dholland
931 1.1 dholland /* key/value counters */
932 1.1 dholland unsigned maxkeyvals;
933 1.1 dholland unsigned numkeys; /* number of keys assigned */
934 1.1 dholland
935 1.1 dholland /* ID to key/value conversion state */
936 1.1 dholland int skipfirst; /* if true skip first key/value */
937 1.1 dholland int skiplast; /* if true skip last key/value */
938 1.1 dholland
939 1.1 dholland /* ID counters */
940 1.1 dholland unsigned maxids; /* maximum number of IDs to handle */
941 1.1 dholland unsigned numids; /* number of IDs handled */
942 1.1 dholland };
943 1.1 dholland
944 1.1 dholland /*
945 1.1 dholland * Additional structure for getids callback.
946 1.1 dholland */
947 1.1 dholland struct q2cursor_getids {
948 1.1 dholland struct q2cursor_state *state;
949 1.1 dholland int idtype;
950 1.1 dholland unsigned skip; /* number of ids to skip over */
951 1.1 dholland unsigned new_skip; /* number of ids to skip over next time */
952 1.1 dholland unsigned skipped; /* number skipped so far */
953 1.1 dholland int stopped; /* true if we stopped quota_walk_list early */
954 1.1 dholland };
955 1.1 dholland
956 1.1 dholland /*
957 1.1 dholland * Cursor-related functions
958 1.1 dholland */
959 1.1 dholland
960 1.1 dholland /* magic number */
961 1.1 dholland #define Q2C_MAGIC (0xbeebe111)
962 1.1 dholland
963 1.1 dholland /* extract cursor from caller form */
964 1.4 dholland #define Q2CURSOR(qkc) ((struct ulfsq2_cursor *)&qkc->u.qkc_space[0])
965 1.1 dholland
966 1.1 dholland /*
967 1.1 dholland * Check that a cursor we're handed is something like valid. If
968 1.1 dholland * someone munges it and it still passes these checks, they'll get
969 1.1 dholland * partial or odd results back but won't break anything.
970 1.1 dholland */
971 1.1 dholland static int
972 1.4 dholland q2cursor_check(struct ulfsq2_cursor *cursor)
973 1.1 dholland {
974 1.1 dholland if (cursor->q2c_magic != Q2C_MAGIC) {
975 1.1 dholland return EINVAL;
976 1.1 dholland }
977 1.1 dholland if (cursor->q2c_hashsize < 0) {
978 1.1 dholland return EINVAL;
979 1.1 dholland }
980 1.1 dholland
981 1.1 dholland if (cursor->q2c_users_done != 0 && cursor->q2c_users_done != 1) {
982 1.1 dholland return EINVAL;
983 1.1 dholland }
984 1.1 dholland if (cursor->q2c_groups_done != 0 && cursor->q2c_groups_done != 1) {
985 1.1 dholland return EINVAL;
986 1.1 dholland }
987 1.1 dholland if (cursor->q2c_defaults_done != 0 && cursor->q2c_defaults_done != 1) {
988 1.1 dholland return EINVAL;
989 1.1 dholland }
990 1.1 dholland if (cursor->q2c_hashpos < 0 || cursor->q2c_uidpos < 0) {
991 1.1 dholland return EINVAL;
992 1.1 dholland }
993 1.1 dholland if (cursor->q2c_blocks_done != 0 && cursor->q2c_blocks_done != 1) {
994 1.1 dholland return EINVAL;
995 1.1 dholland }
996 1.1 dholland return 0;
997 1.1 dholland }
998 1.1 dholland
999 1.1 dholland /*
1000 1.1 dholland * Set up the q2cursor state.
1001 1.1 dholland */
1002 1.1 dholland static void
1003 1.1 dholland q2cursor_initstate(struct q2cursor_state *state, struct quotakey *keys,
1004 1.1 dholland struct quotaval *vals, unsigned maxkeyvals, int blocks_done)
1005 1.1 dholland {
1006 1.1 dholland state->keys = keys;
1007 1.1 dholland state->vals = vals;
1008 1.1 dholland
1009 1.1 dholland state->maxkeyvals = maxkeyvals;
1010 1.1 dholland state->numkeys = 0;
1011 1.1 dholland
1012 1.1 dholland /*
1013 1.1 dholland * For each ID there are two quotavals to return. If the
1014 1.1 dholland * maximum number of entries to return is odd, we might want
1015 1.1 dholland * to skip the first quotaval of the first ID, or the last
1016 1.1 dholland * quotaval of the last ID, but not both. So the number of IDs
1017 1.1 dholland * we want is (up to) half the number of return slots we have,
1018 1.1 dholland * rounded up.
1019 1.1 dholland */
1020 1.1 dholland
1021 1.1 dholland state->maxids = (state->maxkeyvals + 1) / 2;
1022 1.1 dholland state->numids = 0;
1023 1.1 dholland if (state->maxkeyvals % 2) {
1024 1.1 dholland if (blocks_done) {
1025 1.1 dholland state->skipfirst = 1;
1026 1.1 dholland state->skiplast = 0;
1027 1.1 dholland } else {
1028 1.1 dholland state->skipfirst = 0;
1029 1.1 dholland state->skiplast = 1;
1030 1.1 dholland }
1031 1.1 dholland } else {
1032 1.1 dholland state->skipfirst = 0;
1033 1.1 dholland state->skiplast = 0;
1034 1.1 dholland }
1035 1.1 dholland }
1036 1.1 dholland
1037 1.1 dholland /*
1038 1.1 dholland * Choose which idtype we're going to work on. If doing a full
1039 1.1 dholland * iteration, we do users first, then groups, but either might be
1040 1.1 dholland * disabled or marked to skip via cursorsetidtype(), so don't make
1041 1.1 dholland * silly assumptions.
1042 1.1 dholland */
1043 1.1 dholland static int
1044 1.4 dholland q2cursor_pickidtype(struct ulfsq2_cursor *cursor, int *idtype_ret)
1045 1.1 dholland {
1046 1.1 dholland if (cursor->q2c_users_done == 0) {
1047 1.1 dholland *idtype_ret = QUOTA_IDTYPE_USER;
1048 1.1 dholland } else if (cursor->q2c_groups_done == 0) {
1049 1.1 dholland *idtype_ret = QUOTA_IDTYPE_GROUP;
1050 1.1 dholland } else {
1051 1.1 dholland return EAGAIN;
1052 1.1 dholland }
1053 1.1 dholland return 0;
1054 1.1 dholland }
1055 1.1 dholland
1056 1.1 dholland /*
1057 1.1 dholland * Add an ID to the current state. Sets up either one or two keys to
1058 1.1 dholland * refer to it, depending on whether it's first/last and the setting
1059 1.1 dholland * of skipfirst. (skiplast does not need to be explicitly tested)
1060 1.1 dholland */
1061 1.1 dholland static void
1062 1.1 dholland q2cursor_addid(struct q2cursor_state *state, int idtype, id_t id)
1063 1.1 dholland {
1064 1.1 dholland KASSERT(state->numids < state->maxids);
1065 1.1 dholland KASSERT(state->numkeys < state->maxkeyvals);
1066 1.1 dholland
1067 1.1 dholland if (!state->skipfirst || state->numkeys > 0) {
1068 1.1 dholland state->keys[state->numkeys].qk_idtype = idtype;
1069 1.1 dholland state->keys[state->numkeys].qk_id = id;
1070 1.1 dholland state->keys[state->numkeys].qk_objtype = QUOTA_OBJTYPE_BLOCKS;
1071 1.1 dholland state->numkeys++;
1072 1.1 dholland }
1073 1.1 dholland if (state->numkeys < state->maxkeyvals) {
1074 1.1 dholland state->keys[state->numkeys].qk_idtype = idtype;
1075 1.1 dholland state->keys[state->numkeys].qk_id = id;
1076 1.1 dholland state->keys[state->numkeys].qk_objtype = QUOTA_OBJTYPE_FILES;
1077 1.1 dholland state->numkeys++;
1078 1.1 dholland } else {
1079 1.1 dholland KASSERT(state->skiplast);
1080 1.1 dholland }
1081 1.1 dholland state->numids++;
1082 1.1 dholland }
1083 1.1 dholland
1084 1.1 dholland /*
1085 1.1 dholland * Callback function for getting IDs. Update counting and call addid.
1086 1.1 dholland */
1087 1.1 dholland static int
1088 1.4 dholland q2cursor_getids_callback(struct ulfsmount *ump, uint64_t *offp,
1089 1.1 dholland struct quota2_entry *q2ep, uint64_t off, void *v)
1090 1.1 dholland {
1091 1.1 dholland struct q2cursor_getids *gi = v;
1092 1.1 dholland id_t id;
1093 1.9 dholland struct lfs *fs = ump->um_lfs;
1094 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
1095 1.1 dholland
1096 1.1 dholland if (gi->skipped < gi->skip) {
1097 1.1 dholland gi->skipped++;
1098 1.1 dholland return 0;
1099 1.1 dholland }
1100 1.4 dholland id = ulfs_rw32(q2ep->q2e_uid, needswap);
1101 1.1 dholland q2cursor_addid(gi->state, gi->idtype, id);
1102 1.1 dholland gi->new_skip++;
1103 1.1 dholland if (gi->state->numids >= gi->state->maxids) {
1104 1.1 dholland /* got enough ids, stop now */
1105 1.1 dholland gi->stopped = 1;
1106 1.1 dholland return Q2WL_ABORT;
1107 1.1 dholland }
1108 1.1 dholland return 0;
1109 1.1 dholland }
1110 1.1 dholland
1111 1.1 dholland /*
1112 1.1 dholland * Fill in a batch of quotakeys by scanning one or more hash chains.
1113 1.1 dholland */
1114 1.1 dholland static int
1115 1.4 dholland q2cursor_getkeys(struct ulfsmount *ump, int idtype, struct ulfsq2_cursor *cursor,
1116 1.1 dholland struct q2cursor_state *state,
1117 1.1 dholland int *hashsize_ret, struct quota2_entry *default_q2e_ret)
1118 1.1 dholland {
1119 1.12 dholland struct lfs *fs = ump->um_lfs;
1120 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
1121 1.1 dholland struct buf *hbp;
1122 1.1 dholland struct quota2_header *q2h;
1123 1.1 dholland int quota2_hash_size;
1124 1.1 dholland struct q2cursor_getids gi;
1125 1.1 dholland uint64_t offset;
1126 1.1 dholland int error;
1127 1.1 dholland
1128 1.1 dholland /*
1129 1.1 dholland * Read the header block.
1130 1.1 dholland */
1131 1.1 dholland
1132 1.5 dholland mutex_enter(&lfs_dqlock);
1133 1.1 dholland error = getq2h(ump, idtype, &hbp, &q2h, 0);
1134 1.1 dholland if (error) {
1135 1.5 dholland mutex_exit(&lfs_dqlock);
1136 1.1 dholland return error;
1137 1.1 dholland }
1138 1.1 dholland
1139 1.1 dholland /* if the table size has changed, make the caller start over */
1140 1.4 dholland quota2_hash_size = ulfs_rw16(q2h->q2h_hash_size, needswap);
1141 1.1 dholland if (cursor->q2c_hashsize == 0) {
1142 1.1 dholland cursor->q2c_hashsize = quota2_hash_size;
1143 1.1 dholland } else if (cursor->q2c_hashsize != quota2_hash_size) {
1144 1.1 dholland error = EDEADLK;
1145 1.1 dholland goto scanfail;
1146 1.1 dholland }
1147 1.1 dholland
1148 1.1 dholland /* grab the entry with the default values out of the header */
1149 1.5 dholland lfsquota2_ulfs_rwq2e(&q2h->q2h_defentry, default_q2e_ret, needswap);
1150 1.1 dholland
1151 1.1 dholland /* If we haven't done the defaults yet, that goes first. */
1152 1.1 dholland if (cursor->q2c_defaults_done == 0) {
1153 1.1 dholland q2cursor_addid(state, idtype, QUOTA_DEFAULTID);
1154 1.1 dholland /* if we read both halves, mark it done */
1155 1.1 dholland if (state->numids < state->maxids || !state->skiplast) {
1156 1.1 dholland cursor->q2c_defaults_done = 1;
1157 1.1 dholland }
1158 1.1 dholland }
1159 1.1 dholland
1160 1.1 dholland gi.state = state;
1161 1.1 dholland gi.idtype = idtype;
1162 1.1 dholland
1163 1.1 dholland while (state->numids < state->maxids) {
1164 1.1 dholland if (cursor->q2c_hashpos >= quota2_hash_size) {
1165 1.1 dholland /* nothing more left */
1166 1.1 dholland break;
1167 1.1 dholland }
1168 1.1 dholland
1169 1.1 dholland /* scan this hash chain */
1170 1.1 dholland gi.skip = cursor->q2c_uidpos;
1171 1.1 dholland gi.new_skip = gi.skip;
1172 1.1 dholland gi.skipped = 0;
1173 1.1 dholland gi.stopped = 0;
1174 1.1 dholland offset = q2h->q2h_entries[cursor->q2c_hashpos];
1175 1.1 dholland
1176 1.1 dholland error = quota2_walk_list(ump, hbp, idtype, &offset, 0, &gi,
1177 1.1 dholland q2cursor_getids_callback);
1178 1.1 dholland KASSERT(error != Q2WL_ABORT);
1179 1.1 dholland if (error) {
1180 1.1 dholland break;
1181 1.1 dholland }
1182 1.1 dholland if (gi.stopped) {
1183 1.1 dholland /* callback stopped before reading whole chain */
1184 1.1 dholland cursor->q2c_uidpos = gi.new_skip;
1185 1.1 dholland /* if we didn't get both halves, back up */
1186 1.1 dholland if (state->numids == state->maxids && state->skiplast){
1187 1.1 dholland KASSERT(cursor->q2c_uidpos > 0);
1188 1.1 dholland cursor->q2c_uidpos--;
1189 1.1 dholland }
1190 1.1 dholland } else {
1191 1.1 dholland /* read whole chain */
1192 1.1 dholland /* if we got both halves of the last id, advance */
1193 1.1 dholland if (state->numids < state->maxids || !state->skiplast){
1194 1.1 dholland cursor->q2c_uidpos = 0;
1195 1.1 dholland cursor->q2c_hashpos++;
1196 1.1 dholland }
1197 1.1 dholland }
1198 1.1 dholland }
1199 1.1 dholland
1200 1.1 dholland scanfail:
1201 1.5 dholland mutex_exit(&lfs_dqlock);
1202 1.1 dholland brelse(hbp, 0);
1203 1.1 dholland if (error)
1204 1.1 dholland return error;
1205 1.1 dholland
1206 1.1 dholland *hashsize_ret = quota2_hash_size;
1207 1.1 dholland return 0;
1208 1.1 dholland }
1209 1.1 dholland
1210 1.1 dholland /*
1211 1.1 dholland * Fetch the quotavals for the quotakeys.
1212 1.1 dholland */
1213 1.1 dholland static int
1214 1.4 dholland q2cursor_getvals(struct ulfsmount *ump, struct q2cursor_state *state,
1215 1.1 dholland const struct quota2_entry *default_q2e)
1216 1.1 dholland {
1217 1.1 dholland int hasid;
1218 1.1 dholland id_t loadedid, id;
1219 1.1 dholland unsigned pos;
1220 1.1 dholland struct quota2_entry q2e;
1221 1.1 dholland int objtype;
1222 1.1 dholland int error;
1223 1.1 dholland
1224 1.1 dholland hasid = 0;
1225 1.1 dholland loadedid = 0;
1226 1.1 dholland for (pos = 0; pos < state->numkeys; pos++) {
1227 1.1 dholland id = state->keys[pos].qk_id;
1228 1.1 dholland if (!hasid || id != loadedid) {
1229 1.1 dholland hasid = 1;
1230 1.1 dholland loadedid = id;
1231 1.1 dholland if (id == QUOTA_DEFAULTID) {
1232 1.1 dholland q2e = *default_q2e;
1233 1.1 dholland } else {
1234 1.1 dholland error = quota2_fetch_q2e(ump,
1235 1.1 dholland &state->keys[pos],
1236 1.1 dholland &q2e);
1237 1.1 dholland if (error == ENOENT) {
1238 1.1 dholland /* something changed - start over */
1239 1.1 dholland error = EDEADLK;
1240 1.1 dholland }
1241 1.1 dholland if (error) {
1242 1.1 dholland return error;
1243 1.1 dholland }
1244 1.1 dholland }
1245 1.1 dholland }
1246 1.1 dholland
1247 1.1 dholland
1248 1.1 dholland objtype = state->keys[pos].qk_objtype;
1249 1.1 dholland KASSERT(objtype >= 0 && objtype < N_QL);
1250 1.1 dholland q2val_to_quotaval(&q2e.q2e_val[objtype], &state->vals[pos]);
1251 1.1 dholland }
1252 1.1 dholland
1253 1.1 dholland return 0;
1254 1.1 dholland }
1255 1.1 dholland
1256 1.1 dholland /*
1257 1.1 dholland * Handle cursorget.
1258 1.1 dholland *
1259 1.1 dholland * We can't just read keys and values directly, because we can't walk
1260 1.1 dholland * the list with qdlock and grab dq_interlock to read the entries at
1261 1.1 dholland * the same time. So we're going to do two passes: one to figure out
1262 1.1 dholland * which IDs we want and fill in the keys, and then a second to use
1263 1.1 dholland * the keys to fetch the values.
1264 1.1 dholland */
1265 1.1 dholland int
1266 1.5 dholland lfsquota2_handle_cmd_cursorget(struct ulfsmount *ump, struct quotakcursor *qkc,
1267 1.1 dholland struct quotakey *keys, struct quotaval *vals, unsigned maxreturn,
1268 1.1 dholland unsigned *ret)
1269 1.1 dholland {
1270 1.1 dholland int error;
1271 1.4 dholland struct ulfsq2_cursor *cursor;
1272 1.4 dholland struct ulfsq2_cursor newcursor;
1273 1.1 dholland struct q2cursor_state state;
1274 1.1 dholland struct quota2_entry default_q2e;
1275 1.1 dholland int idtype;
1276 1.17 justin int quota2_hash_size = 0; /* XXXuninit */
1277 1.1 dholland
1278 1.1 dholland /*
1279 1.1 dholland * Convert and validate the cursor.
1280 1.1 dholland */
1281 1.1 dholland cursor = Q2CURSOR(qkc);
1282 1.1 dholland error = q2cursor_check(cursor);
1283 1.1 dholland if (error) {
1284 1.1 dholland return error;
1285 1.1 dholland }
1286 1.1 dholland
1287 1.1 dholland /*
1288 1.1 dholland * Make sure our on-disk codes match the values of the
1289 1.1 dholland * FS-independent ones. This avoids the need for explicit
1290 1.1 dholland * conversion (which would be a NOP anyway and thus easily
1291 1.1 dholland * left out or called in the wrong places...)
1292 1.1 dholland */
1293 1.4 dholland CTASSERT(QUOTA_IDTYPE_USER == ULFS_USRQUOTA);
1294 1.4 dholland CTASSERT(QUOTA_IDTYPE_GROUP == ULFS_GRPQUOTA);
1295 1.1 dholland CTASSERT(QUOTA_OBJTYPE_BLOCKS == QL_BLOCK);
1296 1.1 dholland CTASSERT(QUOTA_OBJTYPE_FILES == QL_FILE);
1297 1.1 dholland
1298 1.1 dholland /*
1299 1.1 dholland * If some of the idtypes aren't configured/enabled, arrange
1300 1.1 dholland * to skip over them.
1301 1.1 dholland */
1302 1.1 dholland if (cursor->q2c_users_done == 0 &&
1303 1.4 dholland ump->um_quotas[ULFS_USRQUOTA] == NULLVP) {
1304 1.1 dholland cursor->q2c_users_done = 1;
1305 1.1 dholland }
1306 1.1 dholland if (cursor->q2c_groups_done == 0 &&
1307 1.4 dholland ump->um_quotas[ULFS_GRPQUOTA] == NULLVP) {
1308 1.1 dholland cursor->q2c_groups_done = 1;
1309 1.1 dholland }
1310 1.1 dholland
1311 1.1 dholland /* Loop over, potentially, both idtypes */
1312 1.1 dholland while (1) {
1313 1.1 dholland
1314 1.1 dholland /* Choose id type */
1315 1.1 dholland error = q2cursor_pickidtype(cursor, &idtype);
1316 1.1 dholland if (error == EAGAIN) {
1317 1.1 dholland /* nothing more to do, return 0 */
1318 1.1 dholland *ret = 0;
1319 1.1 dholland return 0;
1320 1.1 dholland }
1321 1.1 dholland KASSERT(ump->um_quotas[idtype] != NULLVP);
1322 1.1 dholland
1323 1.1 dholland /*
1324 1.1 dholland * Initialize the per-call iteration state. Copy the
1325 1.1 dholland * cursor state so we can update it in place but back
1326 1.1 dholland * out on error.
1327 1.1 dholland */
1328 1.1 dholland q2cursor_initstate(&state, keys, vals, maxreturn,
1329 1.1 dholland cursor->q2c_blocks_done);
1330 1.1 dholland newcursor = *cursor;
1331 1.1 dholland
1332 1.1 dholland /* Assign keys */
1333 1.1 dholland error = q2cursor_getkeys(ump, idtype, &newcursor, &state,
1334 1.1 dholland "a2_hash_size, &default_q2e);
1335 1.1 dholland if (error) {
1336 1.1 dholland return error;
1337 1.1 dholland }
1338 1.1 dholland
1339 1.1 dholland /* Now fill in the values. */
1340 1.1 dholland error = q2cursor_getvals(ump, &state, &default_q2e);
1341 1.1 dholland if (error) {
1342 1.1 dholland return error;
1343 1.1 dholland }
1344 1.1 dholland
1345 1.1 dholland /*
1346 1.1 dholland * Now that we aren't going to fail and lose what we
1347 1.1 dholland * did so far, we can update the cursor state.
1348 1.1 dholland */
1349 1.1 dholland
1350 1.1 dholland if (newcursor.q2c_hashpos >= quota2_hash_size) {
1351 1.1 dholland if (idtype == QUOTA_IDTYPE_USER)
1352 1.1 dholland cursor->q2c_users_done = 1;
1353 1.1 dholland else
1354 1.1 dholland cursor->q2c_groups_done = 1;
1355 1.1 dholland
1356 1.1 dholland /* start over on another id type */
1357 1.1 dholland cursor->q2c_hashsize = 0;
1358 1.1 dholland cursor->q2c_defaults_done = 0;
1359 1.1 dholland cursor->q2c_hashpos = 0;
1360 1.1 dholland cursor->q2c_uidpos = 0;
1361 1.1 dholland cursor->q2c_blocks_done = 0;
1362 1.1 dholland } else {
1363 1.1 dholland *cursor = newcursor;
1364 1.1 dholland cursor->q2c_blocks_done = state.skiplast;
1365 1.1 dholland }
1366 1.1 dholland
1367 1.1 dholland /*
1368 1.1 dholland * If we have something to return, return it.
1369 1.1 dholland * Otherwise, continue to the other idtype, if any,
1370 1.1 dholland * and only return zero at end of iteration.
1371 1.1 dholland */
1372 1.1 dholland if (state.numkeys > 0) {
1373 1.1 dholland break;
1374 1.1 dholland }
1375 1.1 dholland }
1376 1.1 dholland
1377 1.1 dholland *ret = state.numkeys;
1378 1.1 dholland return 0;
1379 1.1 dholland }
1380 1.1 dholland
1381 1.1 dholland int
1382 1.5 dholland lfsquota2_handle_cmd_cursoropen(struct ulfsmount *ump, struct quotakcursor *qkc)
1383 1.1 dholland {
1384 1.4 dholland struct ulfsq2_cursor *cursor;
1385 1.1 dholland
1386 1.1 dholland CTASSERT(sizeof(*cursor) <= sizeof(qkc->u.qkc_space));
1387 1.1 dholland cursor = Q2CURSOR(qkc);
1388 1.1 dholland
1389 1.1 dholland cursor->q2c_magic = Q2C_MAGIC;
1390 1.1 dholland cursor->q2c_hashsize = 0;
1391 1.1 dholland
1392 1.1 dholland cursor->q2c_users_done = 0;
1393 1.1 dholland cursor->q2c_groups_done = 0;
1394 1.1 dholland cursor->q2c_defaults_done = 0;
1395 1.1 dholland cursor->q2c_hashpos = 0;
1396 1.1 dholland cursor->q2c_uidpos = 0;
1397 1.1 dholland cursor->q2c_blocks_done = 0;
1398 1.1 dholland return 0;
1399 1.1 dholland }
1400 1.1 dholland
1401 1.1 dholland int
1402 1.5 dholland lfsquota2_handle_cmd_cursorclose(struct ulfsmount *ump, struct quotakcursor *qkc)
1403 1.1 dholland {
1404 1.4 dholland struct ulfsq2_cursor *cursor;
1405 1.1 dholland int error;
1406 1.1 dholland
1407 1.1 dholland cursor = Q2CURSOR(qkc);
1408 1.1 dholland error = q2cursor_check(cursor);
1409 1.1 dholland if (error) {
1410 1.1 dholland return error;
1411 1.1 dholland }
1412 1.1 dholland
1413 1.1 dholland /* nothing to do */
1414 1.1 dholland
1415 1.1 dholland return 0;
1416 1.1 dholland }
1417 1.1 dholland
1418 1.1 dholland int
1419 1.5 dholland lfsquota2_handle_cmd_cursorskipidtype(struct ulfsmount *ump,
1420 1.1 dholland struct quotakcursor *qkc, int idtype)
1421 1.1 dholland {
1422 1.4 dholland struct ulfsq2_cursor *cursor;
1423 1.1 dholland int error;
1424 1.1 dholland
1425 1.1 dholland cursor = Q2CURSOR(qkc);
1426 1.1 dholland error = q2cursor_check(cursor);
1427 1.1 dholland if (error) {
1428 1.1 dholland return error;
1429 1.1 dholland }
1430 1.1 dholland
1431 1.1 dholland switch (idtype) {
1432 1.1 dholland case QUOTA_IDTYPE_USER:
1433 1.1 dholland cursor->q2c_users_done = 1;
1434 1.1 dholland break;
1435 1.1 dholland case QUOTA_IDTYPE_GROUP:
1436 1.1 dholland cursor->q2c_groups_done = 1;
1437 1.1 dholland break;
1438 1.1 dholland default:
1439 1.1 dholland return EINVAL;
1440 1.1 dholland }
1441 1.1 dholland
1442 1.1 dholland return 0;
1443 1.1 dholland }
1444 1.1 dholland
1445 1.1 dholland int
1446 1.5 dholland lfsquota2_handle_cmd_cursoratend(struct ulfsmount *ump, struct quotakcursor *qkc,
1447 1.1 dholland int *ret)
1448 1.1 dholland {
1449 1.4 dholland struct ulfsq2_cursor *cursor;
1450 1.1 dholland int error;
1451 1.1 dholland
1452 1.1 dholland cursor = Q2CURSOR(qkc);
1453 1.1 dholland error = q2cursor_check(cursor);
1454 1.1 dholland if (error) {
1455 1.1 dholland return error;
1456 1.1 dholland }
1457 1.1 dholland
1458 1.1 dholland *ret = (cursor->q2c_users_done && cursor->q2c_groups_done);
1459 1.1 dholland return 0;
1460 1.1 dholland }
1461 1.1 dholland
1462 1.1 dholland int
1463 1.5 dholland lfsquota2_handle_cmd_cursorrewind(struct ulfsmount *ump, struct quotakcursor *qkc)
1464 1.1 dholland {
1465 1.4 dholland struct ulfsq2_cursor *cursor;
1466 1.1 dholland int error;
1467 1.1 dholland
1468 1.1 dholland cursor = Q2CURSOR(qkc);
1469 1.1 dholland error = q2cursor_check(cursor);
1470 1.1 dholland if (error) {
1471 1.1 dholland return error;
1472 1.1 dholland }
1473 1.1 dholland
1474 1.1 dholland cursor->q2c_hashsize = 0;
1475 1.1 dholland
1476 1.1 dholland cursor->q2c_users_done = 0;
1477 1.1 dholland cursor->q2c_groups_done = 0;
1478 1.1 dholland cursor->q2c_defaults_done = 0;
1479 1.1 dholland cursor->q2c_hashpos = 0;
1480 1.1 dholland cursor->q2c_uidpos = 0;
1481 1.1 dholland cursor->q2c_blocks_done = 0;
1482 1.1 dholland
1483 1.1 dholland return 0;
1484 1.1 dholland }
1485 1.1 dholland
1486 1.1 dholland int
1487 1.5 dholland lfs_q2sync(struct mount *mp)
1488 1.1 dholland {
1489 1.1 dholland return 0;
1490 1.1 dholland }
1491 1.1 dholland
1492 1.1 dholland struct dq2get_callback {
1493 1.1 dholland uid_t id;
1494 1.1 dholland struct dquot *dq;
1495 1.1 dholland };
1496 1.1 dholland
1497 1.1 dholland static int
1498 1.4 dholland dq2get_callback(struct ulfsmount *ump, uint64_t *offp, struct quota2_entry *q2e,
1499 1.1 dholland uint64_t off, void *v)
1500 1.1 dholland {
1501 1.1 dholland struct dq2get_callback *c = v;
1502 1.1 dholland daddr_t lblkno;
1503 1.1 dholland int blkoff;
1504 1.9 dholland struct lfs *fs = ump->um_lfs;
1505 1.9 dholland const int needswap = ULFS_MPNEEDSWAP(fs);
1506 1.1 dholland
1507 1.4 dholland if (ulfs_rw32(q2e->q2e_uid, needswap) == c->id) {
1508 1.1 dholland KASSERT(mutex_owned(&c->dq->dq_interlock));
1509 1.1 dholland lblkno = (off >> ump->um_mountp->mnt_fs_bshift);
1510 1.1 dholland blkoff = (off & ump->umq2_bmask);
1511 1.1 dholland c->dq->dq2_lblkno = lblkno;
1512 1.1 dholland c->dq->dq2_blkoff = blkoff;
1513 1.1 dholland return Q2WL_ABORT;
1514 1.1 dholland }
1515 1.1 dholland return 0;
1516 1.1 dholland }
1517 1.1 dholland
1518 1.1 dholland int
1519 1.5 dholland lfs_dq2get(struct vnode *dqvp, u_long id, struct ulfsmount *ump, int type,
1520 1.1 dholland struct dquot *dq)
1521 1.1 dholland {
1522 1.1 dholland struct buf *bp;
1523 1.1 dholland struct quota2_header *q2h;
1524 1.1 dholland int error;
1525 1.1 dholland daddr_t offset;
1526 1.1 dholland u_long hash_mask;
1527 1.1 dholland struct dq2get_callback c = {
1528 1.1 dholland .id = id,
1529 1.1 dholland .dq = dq
1530 1.1 dholland };
1531 1.1 dholland
1532 1.1 dholland KASSERT(mutex_owned(&dq->dq_interlock));
1533 1.5 dholland mutex_enter(&lfs_dqlock);
1534 1.1 dholland error = getq2h(ump, type, &bp, &q2h, 0);
1535 1.1 dholland if (error)
1536 1.1 dholland goto out_mutex;
1537 1.1 dholland /* look for our entry */
1538 1.1 dholland hash_mask = ((1 << q2h->q2h_hash_shift) - 1);
1539 1.1 dholland offset = q2h->q2h_entries[id & hash_mask];
1540 1.1 dholland error = quota2_walk_list(ump, bp, type, &offset, 0, (void *)&c,
1541 1.1 dholland dq2get_callback);
1542 1.1 dholland brelse(bp, 0);
1543 1.1 dholland out_mutex:
1544 1.5 dholland mutex_exit(&lfs_dqlock);
1545 1.1 dholland return error;
1546 1.1 dholland }
1547 1.1 dholland
1548 1.1 dholland int
1549 1.5 dholland lfs_dq2sync(struct vnode *vp, struct dquot *dq)
1550 1.1 dholland {
1551 1.1 dholland return 0;
1552 1.1 dholland }
1553 1.10 dholland
1554 1.10 dholland int
1555 1.10 dholland lfs_quota2_mount(struct mount *mp)
1556 1.10 dholland {
1557 1.10 dholland struct ulfsmount *ump = VFSTOULFS(mp);
1558 1.10 dholland struct lfs *fs = ump->um_lfs;
1559 1.10 dholland int error = 0;
1560 1.10 dholland struct vnode *vp;
1561 1.10 dholland struct lwp *l = curlwp;
1562 1.10 dholland
1563 1.10 dholland if ((fs->lfs_use_quota2) == 0)
1564 1.10 dholland return 0;
1565 1.10 dholland
1566 1.10 dholland fs->um_flags |= ULFS_QUOTA2;
1567 1.19 dholland ump->umq2_bsize = lfs_sb_getbsize(fs);
1568 1.20 dholland ump->umq2_bmask = lfs_sb_getbmask(fs);
1569 1.10 dholland if (fs->lfs_quota_magic != Q2_HEAD_MAGIC) {
1570 1.10 dholland printf("%s: Invalid quota magic number\n",
1571 1.10 dholland mp->mnt_stat.f_mntonname);
1572 1.10 dholland return EINVAL;
1573 1.10 dholland }
1574 1.10 dholland if ((fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_USRQUOTA)) &&
1575 1.10 dholland fs->lfs_quotaino[ULFS_USRQUOTA] == 0) {
1576 1.10 dholland printf("%s: no user quota inode\n",
1577 1.10 dholland mp->mnt_stat.f_mntonname);
1578 1.10 dholland error = EINVAL;
1579 1.10 dholland }
1580 1.10 dholland if ((fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_GRPQUOTA)) &&
1581 1.10 dholland fs->lfs_quotaino[ULFS_GRPQUOTA] == 0) {
1582 1.10 dholland printf("%s: no group quota inode\n",
1583 1.10 dholland mp->mnt_stat.f_mntonname);
1584 1.10 dholland error = EINVAL;
1585 1.10 dholland }
1586 1.10 dholland if (error)
1587 1.10 dholland return error;
1588 1.10 dholland
1589 1.10 dholland if (fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_USRQUOTA) &&
1590 1.10 dholland ump->um_quotas[ULFS_USRQUOTA] == NULLVP) {
1591 1.10 dholland error = VFS_VGET(mp, fs->lfs_quotaino[ULFS_USRQUOTA], &vp);
1592 1.10 dholland if (error) {
1593 1.10 dholland printf("%s: can't vget() user quota inode: %d\n",
1594 1.10 dholland mp->mnt_stat.f_mntonname, error);
1595 1.10 dholland return error;
1596 1.10 dholland }
1597 1.10 dholland ump->um_quotas[ULFS_USRQUOTA] = vp;
1598 1.10 dholland ump->um_cred[ULFS_USRQUOTA] = l->l_cred;
1599 1.10 dholland mutex_enter(vp->v_interlock);
1600 1.10 dholland vp->v_writecount++;
1601 1.10 dholland mutex_exit(vp->v_interlock);
1602 1.10 dholland VOP_UNLOCK(vp);
1603 1.10 dholland }
1604 1.10 dholland if (fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_GRPQUOTA) &&
1605 1.10 dholland ump->um_quotas[ULFS_GRPQUOTA] == NULLVP) {
1606 1.10 dholland error = VFS_VGET(mp, fs->lfs_quotaino[ULFS_GRPQUOTA], &vp);
1607 1.10 dholland if (error) {
1608 1.10 dholland vn_close(ump->um_quotas[ULFS_USRQUOTA],
1609 1.10 dholland FREAD|FWRITE, l->l_cred);
1610 1.10 dholland printf("%s: can't vget() group quota inode: %d\n",
1611 1.10 dholland mp->mnt_stat.f_mntonname, error);
1612 1.10 dholland return error;
1613 1.10 dholland }
1614 1.10 dholland ump->um_quotas[ULFS_GRPQUOTA] = vp;
1615 1.10 dholland ump->um_cred[ULFS_GRPQUOTA] = l->l_cred;
1616 1.10 dholland mutex_enter(vp->v_interlock);
1617 1.10 dholland vp->v_vflag |= VV_SYSTEM;
1618 1.10 dholland vp->v_writecount++;
1619 1.10 dholland mutex_exit(vp->v_interlock);
1620 1.10 dholland VOP_UNLOCK(vp);
1621 1.10 dholland }
1622 1.10 dholland mp->mnt_flag |= MNT_QUOTA;
1623 1.10 dholland return 0;
1624 1.10 dholland }
1625