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) 2011, 2012, Whamcloud, Inc.
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 = cfs_alloc(LUSTRE_DQBLKSIZE, CFS_ALLOC_IO);
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 ret = sb->s_op->quota_read(sb, type, buf, LUSTRE_DQBLKSIZE,
68 blk << LUSTRE_DQBLKSIZE_BITS);
70 /* Reading past EOF just returns a block of zeros */
78 * Find entry in block by given \a dqid in the leaf block \a blk
80 * \retval +ve, the offset of the entry in file
81 * \retval 0, entry not found
82 * \retval -ve, unexpected failure
84 static loff_t find_block_dqentry(const struct lu_env *env,
85 struct osd_object *obj, int type,
87 struct osd_it_quota *it)
89 dqbuf_t buf = getdqbuf();
92 struct lustre_disk_dqblk_v2 *ddquot;
97 ddquot = (struct lustre_disk_dqblk_v2 *)GETENTRIES(buf);
98 dqblk_sz = sizeof(struct lustre_disk_dqblk_v2);
101 ret = quota_read_blk(env, obj, type, blk, buf);
103 CERROR("Can't read quota tree block %u.\n", blk);
108 for (i = 0; i < LUSTRE_DQSTRINBLK &&
109 le32_to_cpu(ddquot[i].dqb_id) != dqid; i++)
111 } else { /* ID 0 as a bit more complicated searching... */
112 for (i = 0; i < LUSTRE_DQSTRINBLK; i++)
113 if (!le32_to_cpu(ddquot[i].dqb_id) &&
114 memcmp((char *)&emptydquot, (char *)&ddquot[i],
118 if (i == LUSTRE_DQSTRINBLK) {
119 CDEBUG(D_QUOTA, "Quota for id %u not found.\n", dqid);
123 ret = (blk << LUSTRE_DQBLKSIZE_BITS) +
124 sizeof(struct lustre_disk_dqdbheader) + i * dqblk_sz;
127 it->oiq_blk[LUSTRE_DQTREEDEPTH] = blk;
128 it->oiq_offset = ret;
130 it->oiq_index[LUSTRE_DQTREEDEPTH] = i;
141 * Find entry for given \a dqid in the tree block \a blk
143 * \retval +ve, the offset of the entry in file
144 * \retval 0, entry not found
145 * \retval -ve, unexpected failure
147 loff_t find_tree_dqentry(const struct lu_env *env,
148 struct osd_object *obj, int type,
149 qid_t dqid, uint blk, int depth,
150 struct osd_it_quota *it)
152 dqbuf_t buf = getdqbuf();
154 u32 *ref = (u32 *) buf;
160 ret = quota_read_blk(env, obj, 0, blk, buf);
162 CERROR("Can't read quota tree block %u.\n", blk);
166 blk = le32_to_cpu(ref[GETIDINDEX(dqid, depth)]);
167 if (!blk) /* No reference? */
170 if (depth < LUSTRE_DQTREEDEPTH - 1)
171 ret = find_tree_dqentry(env, obj, type, dqid, blk,
174 ret = find_block_dqentry(env, obj, type, dqid, blk, it);
177 it->oiq_blk[depth + 1] = blk;
178 it->oiq_index[depth] = GETIDINDEX(dqid, depth);
187 * Search from \a index within the leaf block \a blk, and fill the \a it with
188 * the first valid entry.
190 * \retval +ve, no valid entry found
191 * \retval 0, entry found
192 * \retval -ve, unexpected failure
194 int walk_block_dqentry(const struct lu_env *env, struct osd_object *obj,
195 int type, uint blk, uint index,
196 struct osd_it_quota *it)
198 dqbuf_t buf = getdqbuf();
200 struct lustre_disk_dqdbheader *dqhead;
202 struct lustre_disk_dqblk_v2 *ddquot;
203 struct osd_quota_leaf *leaf;
206 /* check if the leaf block has been processed before */
207 cfs_list_for_each_entry(leaf, &it->oiq_list, oql_link) {
208 if (leaf->oql_blk == blk)
212 dqhead = (struct lustre_disk_dqdbheader *)buf;
213 dqblk_sz = sizeof(struct lustre_disk_dqblk_v2);
216 ret = quota_read_blk(env, obj, type, blk, buf);
218 CERROR("Can't read quota tree block %u.\n", blk);
223 if (!le32_to_cpu(dqhead->dqdh_entries))
226 ddquot = (struct lustre_disk_dqblk_v2 *)GETENTRIES(buf);
227 LASSERT(index < LUSTRE_DQSTRINBLK);
228 for (i = index; i < LUSTRE_DQSTRINBLK; i++) {
229 /* skip empty entry */
230 if (!memcmp((char *)&emptydquot,
231 (char *)&ddquot[i], dqblk_sz))
234 it->oiq_blk[LUSTRE_DQTREEDEPTH] = blk;
235 it->oiq_id = le32_to_cpu(ddquot[i].dqb_id);
236 it->oiq_offset = (blk << LUSTRE_DQBLKSIZE_BITS) +
237 sizeof(struct lustre_disk_dqdbheader) +
239 it->oiq_index[LUSTRE_DQTREEDEPTH] = i;
250 * Search from \a index within the tree block \a blk, and fill the \a it
251 * with the first valid entry.
253 * \retval +ve, no valid entry found
254 * \retval 0, entry found
255 * \retval -ve, unexpected failure
257 int walk_tree_dqentry(const struct lu_env *env, struct osd_object *obj,
258 int type, uint blk, int depth, uint index,
259 struct osd_it_quota *it)
261 dqbuf_t buf = getdqbuf();
263 u32 *ref = (u32 *) buf;
269 ret = quota_read_blk(env, obj, type, blk, buf);
271 CERROR("Can't read quota tree block %u.\n", blk);
276 for (; index <= 0xff && ret > 0; index++) {
277 blk = le32_to_cpu(ref[index]);
278 if (!blk) /* No reference */
281 if (depth < LUSTRE_DQTREEDEPTH - 1)
282 ret = walk_tree_dqentry(env, obj, type, blk,
285 ret = walk_block_dqentry(env, obj, type, blk, 0, it);
288 if (ret == 0) { /* Entry found */
289 it->oiq_blk[depth + 1] = blk;
290 it->oiq_index[depth] = index;