4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 021110-1307, USA
24 * Copyright (c) 2012, 2015, Intel Corporation.
25 * Use is subject to license terms.
27 * Lustre administrative quota format.
28 * from linux/fs/quota_v2.c
31 #include "osd_internal.h"
32 #include "osd_quota_fmt.h"
34 typedef char *dqbuf_t;
38 struct lustre_disk_dqblk_v2 r1;
39 } emptydquot = { .r1 = { 0 } };
41 static inline dqbuf_t getdqbuf(void)
43 dqbuf_t buf = kmalloc(LUSTRE_DQBLKSIZE, GFP_NOFS);
45 CWARN("Not enough memory for quota buffers.\n");
49 static inline void freedqbuf(dqbuf_t buf)
55 * Read the \a blk into \a buf.
57 static ssize_t quota_read_blk(const struct lu_env *env,
58 struct osd_object *obj,
59 int type, uint blk, dqbuf_t buf)
62 struct super_block *sb = obj->oo_inode->i_sb;
66 memset(buf, 0, LUSTRE_DQBLKSIZE);
67 LASSERTF((type == USRQUOTA || type == GRPQUOTA), "type=%d\n", type);
69 ret = sb->s_op->quota_read(sb, type, buf, LUSTRE_DQBLKSIZE,
70 blk << LUSTRE_DQBLKSIZE_BITS);
72 /* Reading past EOF just returns a block of zeros */
80 * Find entry in block by given \a dqid in the leaf block \a blk
82 * \retval +ve, the offset of the entry in file
83 * \retval 0, entry not found
84 * \retval -ve, unexpected failure
86 static loff_t find_block_dqentry(const struct lu_env *env,
87 struct osd_object *obj, int type,
89 struct osd_it_quota *it)
91 dqbuf_t buf = getdqbuf();
94 struct lustre_disk_dqblk_v2 *ddquot;
99 ddquot = (struct lustre_disk_dqblk_v2 *)GETENTRIES(buf);
100 dqblk_sz = sizeof(struct lustre_disk_dqblk_v2);
103 ret = quota_read_blk(env, obj, type, blk, buf);
105 CERROR("Can't read quota tree block %u.\n", blk);
110 for (i = 0; i < LUSTRE_DQSTRINBLK &&
111 le32_to_cpu(ddquot[i].dqb_id) != dqid; i++)
113 } else { /* ID 0 as a bit more complicated searching... */
114 for (i = 0; i < LUSTRE_DQSTRINBLK; i++)
115 if (!le32_to_cpu(ddquot[i].dqb_id) &&
116 memcmp((char *)&emptydquot, (char *)&ddquot[i],
120 if (i == LUSTRE_DQSTRINBLK) {
121 CDEBUG(D_QUOTA, "Quota for id %u not found.\n", dqid);
125 ret = (blk << LUSTRE_DQBLKSIZE_BITS) +
126 sizeof(struct lustre_disk_dqdbheader) + i * dqblk_sz;
129 it->oiq_blk[LUSTRE_DQTREEDEPTH] = blk;
130 it->oiq_offset = ret;
132 it->oiq_index[LUSTRE_DQTREEDEPTH] = i;
143 * Find entry for given \a dqid in the tree block \a blk
145 * \retval +ve, the offset of the entry in file
146 * \retval 0, entry not found
147 * \retval -ve, unexpected failure
149 loff_t find_tree_dqentry(const struct lu_env *env,
150 struct osd_object *obj, int type,
151 qid_t dqid, uint blk, int depth,
152 struct osd_it_quota *it)
154 dqbuf_t buf = getdqbuf();
156 u32 *ref = (u32 *) buf;
162 ret = quota_read_blk(env, obj, type, blk, buf);
164 CERROR("Can't read quota tree block %u.\n", blk);
168 blk = le32_to_cpu(ref[GETIDINDEX(dqid, depth)]);
169 if (!blk) /* No reference? */
172 if (depth < LUSTRE_DQTREEDEPTH - 1)
173 ret = find_tree_dqentry(env, obj, type, dqid, blk,
176 ret = find_block_dqentry(env, obj, type, dqid, blk, it);
179 it->oiq_blk[depth + 1] = blk;
180 it->oiq_index[depth] = GETIDINDEX(dqid, depth);
189 * Search from \a index within the leaf block \a blk, and fill the \a it with
190 * the first valid entry.
192 * \retval +ve, no valid entry found
193 * \retval 0, entry found
194 * \retval -ve, unexpected failure
196 int walk_block_dqentry(const struct lu_env *env, struct osd_object *obj,
197 int type, uint blk, uint index,
198 struct osd_it_quota *it)
202 struct lustre_disk_dqdbheader *dqhead;
204 struct lustre_disk_dqblk_v2 *ddquot;
205 struct osd_quota_leaf *leaf;
208 /* check if the leaf block has been processed before */
209 list_for_each_entry(leaf, &it->oiq_list, oql_link) {
210 if (leaf->oql_blk == blk)
215 dqhead = (struct lustre_disk_dqdbheader *)buf;
216 dqblk_sz = sizeof(struct lustre_disk_dqblk_v2);
219 ret = quota_read_blk(env, obj, type, blk, buf);
221 CERROR("Can't read quota tree block %u.\n", blk);
226 if (!le16_to_cpu(dqhead->dqdh_entries))
229 ddquot = (struct lustre_disk_dqblk_v2 *)GETENTRIES(buf);
230 LASSERT(index < LUSTRE_DQSTRINBLK);
231 for (i = index; i < LUSTRE_DQSTRINBLK; i++) {
232 /* skip empty entry */
233 if (!memcmp((char *)&emptydquot,
234 (char *)&ddquot[i], dqblk_sz))
237 it->oiq_blk[LUSTRE_DQTREEDEPTH] = blk;
238 it->oiq_id = le32_to_cpu(ddquot[i].dqb_id);
239 it->oiq_offset = (blk << LUSTRE_DQBLKSIZE_BITS) +
240 sizeof(struct lustre_disk_dqdbheader) +
242 it->oiq_index[LUSTRE_DQTREEDEPTH] = i;
253 * Search from \a index within the tree block \a blk, and fill the \a it
254 * with the first valid entry.
256 * \retval +ve, no valid entry found
257 * \retval 0, entry found
258 * \retval -ve, unexpected failure
260 int walk_tree_dqentry(const struct lu_env *env, struct osd_object *obj,
261 int type, uint blk, int depth, uint index,
262 struct osd_it_quota *it)
264 dqbuf_t buf = getdqbuf();
266 u32 *ref = (u32 *) buf;
272 ret = quota_read_blk(env, obj, type, blk, buf);
274 CERROR("Can't read quota tree block %u.\n", blk);
279 for (; index <= 0xff && ret > 0; index++) {
280 blk = le32_to_cpu(ref[index]);
281 if (!blk) /* No reference */
284 if (depth < LUSTRE_DQTREEDEPTH - 1)
285 ret = walk_tree_dqentry(env, obj, type, blk,
288 ret = walk_block_dqentry(env, obj, type, blk, 0, it);
291 it->oiq_blk[depth + 1] = blk;
292 it->oiq_index[depth] = index;