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, 2016, 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 == PRJQUOTA),
70 ret = sb->s_op->quota_read(sb, type, buf, LUSTRE_DQBLKSIZE,
71 blk << LUSTRE_DQBLKSIZE_BITS);
73 /* Reading past EOF just returns a block of zeros */
81 * Find entry in block by given \a dqid in the leaf block \a blk
83 * \retval +ve, the offset of the entry in file
84 * \retval 0, entry not found
85 * \retval -ve, unexpected failure
87 static loff_t find_block_dqentry(const struct lu_env *env,
88 struct osd_object *obj, int type,
90 struct osd_it_quota *it)
92 dqbuf_t buf = getdqbuf();
95 struct lustre_disk_dqblk_v2 *ddquot;
100 ddquot = (struct lustre_disk_dqblk_v2 *)GETENTRIES(buf);
101 dqblk_sz = sizeof(struct lustre_disk_dqblk_v2);
104 ret = quota_read_blk(env, obj, type, blk, buf);
106 CERROR("Can't read quota tree block %u.\n", blk);
111 for (i = 0; i < LUSTRE_DQSTRINBLK &&
112 le32_to_cpu(ddquot[i].dqb_id) != dqid; i++)
114 } else { /* ID 0 as a bit more complicated searching... */
115 for (i = 0; i < LUSTRE_DQSTRINBLK; i++)
116 if (!le32_to_cpu(ddquot[i].dqb_id) &&
117 memcmp((char *)&emptydquot, (char *)&ddquot[i],
121 if (i == LUSTRE_DQSTRINBLK) {
122 CDEBUG(D_QUOTA, "Quota for id %u not found.\n", dqid);
126 ret = (blk << LUSTRE_DQBLKSIZE_BITS) +
127 sizeof(struct lustre_disk_dqdbheader) + i * dqblk_sz;
130 it->oiq_blk[LUSTRE_DQTREEDEPTH] = blk;
131 it->oiq_offset = ret;
133 it->oiq_index[LUSTRE_DQTREEDEPTH] = i;
144 * Find entry for given \a dqid in the tree block \a blk
146 * \retval +ve, the offset of the entry in file
147 * \retval 0, entry not found
148 * \retval -ve, unexpected failure
150 loff_t find_tree_dqentry(const struct lu_env *env,
151 struct osd_object *obj, int type,
152 qid_t dqid, uint blk, int depth,
153 struct osd_it_quota *it)
155 dqbuf_t buf = getdqbuf();
157 u32 *ref = (u32 *) buf;
163 ret = quota_read_blk(env, obj, type, blk, buf);
165 CERROR("Can't read quota tree block %u.\n", blk);
169 blk = le32_to_cpu(ref[GETIDINDEX(dqid, depth)]);
170 if (!blk) /* No reference? */
173 if (depth < LUSTRE_DQTREEDEPTH - 1)
174 ret = find_tree_dqentry(env, obj, type, dqid, blk,
177 ret = find_block_dqentry(env, obj, type, dqid, blk, it);
180 it->oiq_blk[depth + 1] = blk;
181 it->oiq_index[depth] = GETIDINDEX(dqid, depth);
190 * Search from \a index within the leaf block \a blk, and fill the \a it with
191 * the first valid entry.
193 * \retval +ve, no valid entry found
194 * \retval 0, entry found
195 * \retval -ve, unexpected failure
197 int walk_block_dqentry(const struct lu_env *env, struct osd_object *obj,
198 int type, uint blk, uint index,
199 struct osd_it_quota *it)
203 struct lustre_disk_dqdbheader *dqhead;
205 struct lustre_disk_dqblk_v2 *ddquot;
206 struct osd_quota_leaf *leaf;
209 /* check if the leaf block has been processed before */
210 list_for_each_entry(leaf, &it->oiq_list, oql_link) {
211 if (leaf->oql_blk == blk)
216 dqhead = (struct lustre_disk_dqdbheader *)buf;
217 dqblk_sz = sizeof(struct lustre_disk_dqblk_v2);
220 ret = quota_read_blk(env, obj, type, blk, buf);
222 CERROR("Can't read quota tree block %u.\n", blk);
227 if (!le16_to_cpu(dqhead->dqdh_entries))
230 ddquot = (struct lustre_disk_dqblk_v2 *)GETENTRIES(buf);
231 LASSERT(index < LUSTRE_DQSTRINBLK);
232 for (i = index; i < LUSTRE_DQSTRINBLK; i++) {
233 /* skip empty entry */
234 if (!memcmp((char *)&emptydquot,
235 (char *)&ddquot[i], dqblk_sz))
238 it->oiq_blk[LUSTRE_DQTREEDEPTH] = blk;
239 it->oiq_id = le32_to_cpu(ddquot[i].dqb_id);
240 it->oiq_offset = (blk << LUSTRE_DQBLKSIZE_BITS) +
241 sizeof(struct lustre_disk_dqdbheader) +
243 it->oiq_index[LUSTRE_DQTREEDEPTH] = i;
254 * Search from \a index within the tree block \a blk, and fill the \a it
255 * with the first valid entry.
257 * \retval +ve, no valid entry found
258 * \retval 0, entry found
259 * \retval -ve, unexpected failure
261 int walk_tree_dqentry(const struct lu_env *env, struct osd_object *obj,
262 int type, uint blk, int depth, uint index,
263 struct osd_it_quota *it)
265 dqbuf_t buf = getdqbuf();
267 u32 *ref = (u32 *) buf;
273 ret = quota_read_blk(env, obj, type, blk, buf);
275 CERROR("Can't read quota tree block %u.\n", blk);
280 for (; index <= 0xff && ret > 0; index++) {
281 blk = le32_to_cpu(ref[index]);
282 if (!blk) /* No reference */
285 if (depth < LUSTRE_DQTREEDEPTH - 1)
286 ret = walk_tree_dqentry(env, obj, type, blk,
289 ret = walk_block_dqentry(env, obj, type, blk, 0, it);
292 it->oiq_blk[depth + 1] = blk;
293 it->oiq_index[depth] = index;