Commit | Line | Data |
---|---|---|
1ccd14b9 JK |
1 | /* |
2 | * vfsv0 quota IO operations on file | |
3 | */ | |
4 | ||
5 | #include <linux/errno.h> | |
6 | #include <linux/fs.h> | |
7 | #include <linux/mount.h> | |
8 | #include <linux/dqblk_v2.h> | |
9 | #include <linux/kernel.h> | |
10 | #include <linux/init.h> | |
11 | #include <linux/module.h> | |
12 | #include <linux/slab.h> | |
13 | #include <linux/quotaops.h> | |
14 | ||
15 | #include <asm/byteorder.h> | |
16 | ||
17 | #include "quota_tree.h" | |
18 | ||
19 | MODULE_AUTHOR("Jan Kara"); | |
20 | MODULE_DESCRIPTION("Quota trie support"); | |
21 | MODULE_LICENSE("GPL"); | |
22 | ||
23 | #define __QUOTA_QT_PARANOIA | |
24 | ||
1ccd14b9 JK |
25 | static int get_index(struct qtree_mem_dqinfo *info, qid_t id, int depth) |
26 | { | |
27 | unsigned int epb = info->dqi_usable_bs >> 2; | |
28 | ||
29 | depth = info->dqi_qtree_depth - depth - 1; | |
30 | while (depth--) | |
31 | id /= epb; | |
32 | return id % epb; | |
33 | } | |
34 | ||
35 | /* Number of entries in one blocks */ | |
7a2435d8 | 36 | static int qtree_dqstr_in_blk(struct qtree_mem_dqinfo *info) |
1ccd14b9 JK |
37 | { |
38 | return (info->dqi_usable_bs - sizeof(struct qt_disk_dqdbheader)) | |
39 | / info->dqi_entry_size; | |
40 | } | |
41 | ||
d26ac1a8 | 42 | static char *getdqbuf(size_t size) |
1ccd14b9 | 43 | { |
d26ac1a8 | 44 | char *buf = kmalloc(size, GFP_NOFS); |
1ccd14b9 | 45 | if (!buf) |
268157ba JK |
46 | printk(KERN_WARNING |
47 | "VFS: Not enough memory for quota buffers.\n"); | |
1ccd14b9 JK |
48 | return buf; |
49 | } | |
50 | ||
7a2435d8 | 51 | static ssize_t read_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) |
1ccd14b9 JK |
52 | { |
53 | struct super_block *sb = info->dqi_sb; | |
54 | ||
55 | memset(buf, 0, info->dqi_usable_bs); | |
d26ac1a8 | 56 | return sb->s_op->quota_read(sb, info->dqi_type, buf, |
1ccd14b9 JK |
57 | info->dqi_usable_bs, blk << info->dqi_blocksize_bits); |
58 | } | |
59 | ||
7a2435d8 | 60 | static ssize_t write_blk(struct qtree_mem_dqinfo *info, uint blk, char *buf) |
1ccd14b9 JK |
61 | { |
62 | struct super_block *sb = info->dqi_sb; | |
63 | ||
d26ac1a8 | 64 | return sb->s_op->quota_write(sb, info->dqi_type, buf, |
1ccd14b9 JK |
65 | info->dqi_usable_bs, blk << info->dqi_blocksize_bits); |
66 | } | |
67 | ||
68 | /* Remove empty block from list and return it */ | |
69 | static int get_free_dqblk(struct qtree_mem_dqinfo *info) | |
70 | { | |
d26ac1a8 | 71 | char *buf = getdqbuf(info->dqi_usable_bs); |
1ccd14b9 JK |
72 | struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; |
73 | int ret, blk; | |
74 | ||
75 | if (!buf) | |
76 | return -ENOMEM; | |
77 | if (info->dqi_free_blk) { | |
78 | blk = info->dqi_free_blk; | |
79 | ret = read_blk(info, blk, buf); | |
80 | if (ret < 0) | |
81 | goto out_buf; | |
82 | info->dqi_free_blk = le32_to_cpu(dh->dqdh_next_free); | |
83 | } | |
84 | else { | |
85 | memset(buf, 0, info->dqi_usable_bs); | |
86 | /* Assure block allocation... */ | |
87 | ret = write_blk(info, info->dqi_blocks, buf); | |
88 | if (ret < 0) | |
89 | goto out_buf; | |
90 | blk = info->dqi_blocks++; | |
91 | } | |
92 | mark_info_dirty(info->dqi_sb, info->dqi_type); | |
93 | ret = blk; | |
94 | out_buf: | |
d26ac1a8 | 95 | kfree(buf); |
1ccd14b9 JK |
96 | return ret; |
97 | } | |
98 | ||
99 | /* Insert empty block to the list */ | |
d26ac1a8 | 100 | static int put_free_dqblk(struct qtree_mem_dqinfo *info, char *buf, uint blk) |
1ccd14b9 JK |
101 | { |
102 | struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; | |
103 | int err; | |
104 | ||
105 | dh->dqdh_next_free = cpu_to_le32(info->dqi_free_blk); | |
106 | dh->dqdh_prev_free = cpu_to_le32(0); | |
107 | dh->dqdh_entries = cpu_to_le16(0); | |
108 | err = write_blk(info, blk, buf); | |
109 | if (err < 0) | |
110 | return err; | |
111 | info->dqi_free_blk = blk; | |
112 | mark_info_dirty(info->dqi_sb, info->dqi_type); | |
113 | return 0; | |
114 | } | |
115 | ||
116 | /* Remove given block from the list of blocks with free entries */ | |
268157ba JK |
117 | static int remove_free_dqentry(struct qtree_mem_dqinfo *info, char *buf, |
118 | uint blk) | |
1ccd14b9 | 119 | { |
d26ac1a8 | 120 | char *tmpbuf = getdqbuf(info->dqi_usable_bs); |
1ccd14b9 JK |
121 | struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; |
122 | uint nextblk = le32_to_cpu(dh->dqdh_next_free); | |
123 | uint prevblk = le32_to_cpu(dh->dqdh_prev_free); | |
124 | int err; | |
125 | ||
126 | if (!tmpbuf) | |
127 | return -ENOMEM; | |
128 | if (nextblk) { | |
129 | err = read_blk(info, nextblk, tmpbuf); | |
130 | if (err < 0) | |
131 | goto out_buf; | |
132 | ((struct qt_disk_dqdbheader *)tmpbuf)->dqdh_prev_free = | |
133 | dh->dqdh_prev_free; | |
134 | err = write_blk(info, nextblk, tmpbuf); | |
135 | if (err < 0) | |
136 | goto out_buf; | |
137 | } | |
138 | if (prevblk) { | |
139 | err = read_blk(info, prevblk, tmpbuf); | |
140 | if (err < 0) | |
141 | goto out_buf; | |
142 | ((struct qt_disk_dqdbheader *)tmpbuf)->dqdh_next_free = | |
143 | dh->dqdh_next_free; | |
144 | err = write_blk(info, prevblk, tmpbuf); | |
145 | if (err < 0) | |
146 | goto out_buf; | |
147 | } else { | |
148 | info->dqi_free_entry = nextblk; | |
149 | mark_info_dirty(info->dqi_sb, info->dqi_type); | |
150 | } | |
d26ac1a8 | 151 | kfree(tmpbuf); |
1ccd14b9 JK |
152 | dh->dqdh_next_free = dh->dqdh_prev_free = cpu_to_le32(0); |
153 | /* No matter whether write succeeds block is out of list */ | |
154 | if (write_blk(info, blk, buf) < 0) | |
268157ba JK |
155 | printk(KERN_ERR |
156 | "VFS: Can't write block (%u) with free entries.\n", | |
157 | blk); | |
1ccd14b9 JK |
158 | return 0; |
159 | out_buf: | |
d26ac1a8 | 160 | kfree(tmpbuf); |
1ccd14b9 JK |
161 | return err; |
162 | } | |
163 | ||
164 | /* Insert given block to the beginning of list with free entries */ | |
268157ba JK |
165 | static int insert_free_dqentry(struct qtree_mem_dqinfo *info, char *buf, |
166 | uint blk) | |
1ccd14b9 | 167 | { |
d26ac1a8 | 168 | char *tmpbuf = getdqbuf(info->dqi_usable_bs); |
1ccd14b9 JK |
169 | struct qt_disk_dqdbheader *dh = (struct qt_disk_dqdbheader *)buf; |
170 | int err; | |
171 | ||
172 | if (!tmpbuf) | |
173 | return -ENOMEM; | |
174 | dh->dqdh_next_free = cpu_to_le32(info->dqi_free_entry); | |
175 | dh->dqdh_prev_free = cpu_to_le32(0); | |
176 | err = write_blk(info, blk, buf); | |
177 | if (err < 0) | |
178 | goto out_buf; | |
179 | if (info->dqi_free_entry) { | |
180 | err = read_blk(info, info->dqi_free_entry, tmpbuf); | |
181 | if (err < 0) | |
182 | goto out_buf; | |
183 | ((struct qt_disk_dqdbheader *)tmpbuf)->dqdh_prev_free = | |
184 | cpu_to_le32(blk); | |
185 | err = write_blk(info, info->dqi_free_entry, tmpbuf); | |
186 | if (err < 0) | |
187 | goto out_buf; | |
188 | } | |
d26ac1a8 | 189 | kfree(tmpbuf); |
1ccd14b9 JK |
190 | info->dqi_free_entry = blk; |
191 | mark_info_dirty(info->dqi_sb, info->dqi_type); | |
192 | return 0; | |
193 | out_buf: | |
d26ac1a8 | 194 | kfree(tmpbuf); |
1ccd14b9 JK |
195 | return err; |
196 | } | |
197 | ||
198 | /* Is the entry in the block free? */ | |
199 | int qtree_entry_unused(struct qtree_mem_dqinfo *info, char *disk) | |
200 | { | |
201 | int i; | |
202 | ||
203 | for (i = 0; i < info->dqi_entry_size; i++) | |
204 | if (disk[i]) | |
205 | return 0; | |
206 | return 1; | |
207 | } | |
208 | EXPORT_SYMBOL(qtree_entry_unused); | |
209 | ||
210 | /* Find space for dquot */ | |
211 | static uint find_free_dqentry(struct qtree_mem_dqinfo *info, | |
212 | struct dquot *dquot, int *err) | |
213 | { | |
214 | uint blk, i; | |
215 | struct qt_disk_dqdbheader *dh; | |
d26ac1a8 | 216 | char *buf = getdqbuf(info->dqi_usable_bs); |
1ccd14b9 JK |
217 | char *ddquot; |
218 | ||
219 | *err = 0; | |
220 | if (!buf) { | |
221 | *err = -ENOMEM; | |
222 | return 0; | |
223 | } | |
224 | dh = (struct qt_disk_dqdbheader *)buf; | |
225 | if (info->dqi_free_entry) { | |
226 | blk = info->dqi_free_entry; | |
227 | *err = read_blk(info, blk, buf); | |
228 | if (*err < 0) | |
229 | goto out_buf; | |
230 | } else { | |
231 | blk = get_free_dqblk(info); | |
232 | if ((int)blk < 0) { | |
233 | *err = blk; | |
d26ac1a8 | 234 | kfree(buf); |
1ccd14b9 JK |
235 | return 0; |
236 | } | |
237 | memset(buf, 0, info->dqi_usable_bs); | |
268157ba JK |
238 | /* This is enough as the block is already zeroed and the entry |
239 | * list is empty... */ | |
1ccd14b9 JK |
240 | info->dqi_free_entry = blk; |
241 | mark_info_dirty(dquot->dq_sb, dquot->dq_type); | |
242 | } | |
243 | /* Block will be full? */ | |
244 | if (le16_to_cpu(dh->dqdh_entries) + 1 >= qtree_dqstr_in_blk(info)) { | |
245 | *err = remove_free_dqentry(info, buf, blk); | |
246 | if (*err < 0) { | |
247 | printk(KERN_ERR "VFS: find_free_dqentry(): Can't " | |
248 | "remove block (%u) from entry free list.\n", | |
249 | blk); | |
250 | goto out_buf; | |
251 | } | |
252 | } | |
253 | le16_add_cpu(&dh->dqdh_entries, 1); | |
254 | /* Find free structure in block */ | |
268157ba JK |
255 | ddquot = buf + sizeof(struct qt_disk_dqdbheader); |
256 | for (i = 0; i < qtree_dqstr_in_blk(info); i++) { | |
257 | if (qtree_entry_unused(info, ddquot)) | |
258 | break; | |
259 | ddquot += info->dqi_entry_size; | |
260 | } | |
1ccd14b9 JK |
261 | #ifdef __QUOTA_QT_PARANOIA |
262 | if (i == qtree_dqstr_in_blk(info)) { | |
263 | printk(KERN_ERR "VFS: find_free_dqentry(): Data block full " | |
264 | "but it shouldn't.\n"); | |
265 | *err = -EIO; | |
266 | goto out_buf; | |
267 | } | |
268 | #endif | |
269 | *err = write_blk(info, blk, buf); | |
270 | if (*err < 0) { | |
271 | printk(KERN_ERR "VFS: find_free_dqentry(): Can't write quota " | |
272 | "data block %u.\n", blk); | |
273 | goto out_buf; | |
274 | } | |
275 | dquot->dq_off = (blk << info->dqi_blocksize_bits) + | |
276 | sizeof(struct qt_disk_dqdbheader) + | |
277 | i * info->dqi_entry_size; | |
d26ac1a8 | 278 | kfree(buf); |
1ccd14b9 JK |
279 | return blk; |
280 | out_buf: | |
d26ac1a8 | 281 | kfree(buf); |
1ccd14b9 JK |
282 | return 0; |
283 | } | |
284 | ||
285 | /* Insert reference to structure into the trie */ | |
286 | static int do_insert_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot, | |
287 | uint *treeblk, int depth) | |
288 | { | |
d26ac1a8 | 289 | char *buf = getdqbuf(info->dqi_usable_bs); |
1ccd14b9 JK |
290 | int ret = 0, newson = 0, newact = 0; |
291 | __le32 *ref; | |
292 | uint newblk; | |
293 | ||
294 | if (!buf) | |
295 | return -ENOMEM; | |
296 | if (!*treeblk) { | |
297 | ret = get_free_dqblk(info); | |
298 | if (ret < 0) | |
299 | goto out_buf; | |
300 | *treeblk = ret; | |
301 | memset(buf, 0, info->dqi_usable_bs); | |
302 | newact = 1; | |
303 | } else { | |
304 | ret = read_blk(info, *treeblk, buf); | |
305 | if (ret < 0) { | |
306 | printk(KERN_ERR "VFS: Can't read tree quota block " | |
307 | "%u.\n", *treeblk); | |
308 | goto out_buf; | |
309 | } | |
310 | } | |
311 | ref = (__le32 *)buf; | |
312 | newblk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]); | |
313 | if (!newblk) | |
314 | newson = 1; | |
315 | if (depth == info->dqi_qtree_depth - 1) { | |
316 | #ifdef __QUOTA_QT_PARANOIA | |
317 | if (newblk) { | |
318 | printk(KERN_ERR "VFS: Inserting already present quota " | |
319 | "entry (block %u).\n", | |
320 | le32_to_cpu(ref[get_index(info, | |
321 | dquot->dq_id, depth)])); | |
322 | ret = -EIO; | |
323 | goto out_buf; | |
324 | } | |
325 | #endif | |
326 | newblk = find_free_dqentry(info, dquot, &ret); | |
327 | } else { | |
328 | ret = do_insert_tree(info, dquot, &newblk, depth+1); | |
329 | } | |
330 | if (newson && ret >= 0) { | |
331 | ref[get_index(info, dquot->dq_id, depth)] = | |
332 | cpu_to_le32(newblk); | |
333 | ret = write_blk(info, *treeblk, buf); | |
334 | } else if (newact && ret < 0) { | |
335 | put_free_dqblk(info, buf, *treeblk); | |
336 | } | |
337 | out_buf: | |
d26ac1a8 | 338 | kfree(buf); |
1ccd14b9 JK |
339 | return ret; |
340 | } | |
341 | ||
342 | /* Wrapper for inserting quota structure into tree */ | |
343 | static inline int dq_insert_tree(struct qtree_mem_dqinfo *info, | |
344 | struct dquot *dquot) | |
345 | { | |
346 | int tmp = QT_TREEOFF; | |
347 | return do_insert_tree(info, dquot, &tmp, 0); | |
348 | } | |
349 | ||
350 | /* | |
268157ba JK |
351 | * We don't have to be afraid of deadlocks as we never have quotas on quota |
352 | * files... | |
1ccd14b9 JK |
353 | */ |
354 | int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) | |
355 | { | |
356 | int type = dquot->dq_type; | |
357 | struct super_block *sb = dquot->dq_sb; | |
358 | ssize_t ret; | |
d26ac1a8 | 359 | char *ddquot = getdqbuf(info->dqi_entry_size); |
1ccd14b9 JK |
360 | |
361 | if (!ddquot) | |
362 | return -ENOMEM; | |
363 | ||
364 | /* dq_off is guarded by dqio_mutex */ | |
365 | if (!dquot->dq_off) { | |
366 | ret = dq_insert_tree(info, dquot); | |
367 | if (ret < 0) { | |
368 | printk(KERN_ERR "VFS: Error %zd occurred while " | |
369 | "creating quota.\n", ret); | |
d26ac1a8 | 370 | kfree(ddquot); |
1ccd14b9 JK |
371 | return ret; |
372 | } | |
373 | } | |
374 | spin_lock(&dq_data_lock); | |
375 | info->dqi_ops->mem2disk_dqblk(ddquot, dquot); | |
376 | spin_unlock(&dq_data_lock); | |
d26ac1a8 JK |
377 | ret = sb->s_op->quota_write(sb, type, ddquot, info->dqi_entry_size, |
378 | dquot->dq_off); | |
1ccd14b9 JK |
379 | if (ret != info->dqi_entry_size) { |
380 | printk(KERN_WARNING "VFS: dquota write failed on dev %s\n", | |
381 | sb->s_id); | |
382 | if (ret >= 0) | |
383 | ret = -ENOSPC; | |
384 | } else { | |
385 | ret = 0; | |
386 | } | |
dde95888 | 387 | dqstats_inc(DQST_WRITES); |
d26ac1a8 | 388 | kfree(ddquot); |
1ccd14b9 JK |
389 | |
390 | return ret; | |
391 | } | |
392 | EXPORT_SYMBOL(qtree_write_dquot); | |
393 | ||
394 | /* Free dquot entry in data block */ | |
395 | static int free_dqentry(struct qtree_mem_dqinfo *info, struct dquot *dquot, | |
396 | uint blk) | |
397 | { | |
398 | struct qt_disk_dqdbheader *dh; | |
d26ac1a8 | 399 | char *buf = getdqbuf(info->dqi_usable_bs); |
1ccd14b9 JK |
400 | int ret = 0; |
401 | ||
402 | if (!buf) | |
403 | return -ENOMEM; | |
404 | if (dquot->dq_off >> info->dqi_blocksize_bits != blk) { | |
405 | printk(KERN_ERR "VFS: Quota structure has offset to other " | |
406 | "block (%u) than it should (%u).\n", blk, | |
407 | (uint)(dquot->dq_off >> info->dqi_blocksize_bits)); | |
408 | goto out_buf; | |
409 | } | |
410 | ret = read_blk(info, blk, buf); | |
411 | if (ret < 0) { | |
412 | printk(KERN_ERR "VFS: Can't read quota data block %u\n", blk); | |
413 | goto out_buf; | |
414 | } | |
415 | dh = (struct qt_disk_dqdbheader *)buf; | |
416 | le16_add_cpu(&dh->dqdh_entries, -1); | |
417 | if (!le16_to_cpu(dh->dqdh_entries)) { /* Block got free? */ | |
418 | ret = remove_free_dqentry(info, buf, blk); | |
419 | if (ret >= 0) | |
420 | ret = put_free_dqblk(info, buf, blk); | |
421 | if (ret < 0) { | |
422 | printk(KERN_ERR "VFS: Can't move quota data block (%u) " | |
423 | "to free list.\n", blk); | |
424 | goto out_buf; | |
425 | } | |
426 | } else { | |
427 | memset(buf + | |
428 | (dquot->dq_off & ((1 << info->dqi_blocksize_bits) - 1)), | |
429 | 0, info->dqi_entry_size); | |
430 | if (le16_to_cpu(dh->dqdh_entries) == | |
431 | qtree_dqstr_in_blk(info) - 1) { | |
432 | /* Insert will write block itself */ | |
433 | ret = insert_free_dqentry(info, buf, blk); | |
434 | if (ret < 0) { | |
435 | printk(KERN_ERR "VFS: Can't insert quota data " | |
436 | "block (%u) to free entry list.\n", blk); | |
437 | goto out_buf; | |
438 | } | |
439 | } else { | |
440 | ret = write_blk(info, blk, buf); | |
441 | if (ret < 0) { | |
442 | printk(KERN_ERR "VFS: Can't write quota data " | |
443 | "block %u\n", blk); | |
444 | goto out_buf; | |
445 | } | |
446 | } | |
447 | } | |
448 | dquot->dq_off = 0; /* Quota is now unattached */ | |
449 | out_buf: | |
d26ac1a8 | 450 | kfree(buf); |
1ccd14b9 JK |
451 | return ret; |
452 | } | |
453 | ||
454 | /* Remove reference to dquot from tree */ | |
455 | static int remove_tree(struct qtree_mem_dqinfo *info, struct dquot *dquot, | |
456 | uint *blk, int depth) | |
457 | { | |
d26ac1a8 | 458 | char *buf = getdqbuf(info->dqi_usable_bs); |
1ccd14b9 JK |
459 | int ret = 0; |
460 | uint newblk; | |
461 | __le32 *ref = (__le32 *)buf; | |
462 | ||
463 | if (!buf) | |
464 | return -ENOMEM; | |
465 | ret = read_blk(info, *blk, buf); | |
466 | if (ret < 0) { | |
467 | printk(KERN_ERR "VFS: Can't read quota data block %u\n", *blk); | |
468 | goto out_buf; | |
469 | } | |
470 | newblk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]); | |
471 | if (depth == info->dqi_qtree_depth - 1) { | |
472 | ret = free_dqentry(info, dquot, newblk); | |
473 | newblk = 0; | |
474 | } else { | |
475 | ret = remove_tree(info, dquot, &newblk, depth+1); | |
476 | } | |
477 | if (ret >= 0 && !newblk) { | |
478 | int i; | |
479 | ref[get_index(info, dquot->dq_id, depth)] = cpu_to_le32(0); | |
480 | /* Block got empty? */ | |
d26ac1a8 JK |
481 | for (i = 0; i < (info->dqi_usable_bs >> 2) && !ref[i]; i++) |
482 | ; | |
1ccd14b9 JK |
483 | /* Don't put the root block into the free block list */ |
484 | if (i == (info->dqi_usable_bs >> 2) | |
485 | && *blk != QT_TREEOFF) { | |
486 | put_free_dqblk(info, buf, *blk); | |
487 | *blk = 0; | |
488 | } else { | |
489 | ret = write_blk(info, *blk, buf); | |
490 | if (ret < 0) | |
491 | printk(KERN_ERR "VFS: Can't write quota tree " | |
492 | "block %u.\n", *blk); | |
493 | } | |
494 | } | |
495 | out_buf: | |
d26ac1a8 | 496 | kfree(buf); |
1ccd14b9 JK |
497 | return ret; |
498 | } | |
499 | ||
500 | /* Delete dquot from tree */ | |
501 | int qtree_delete_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) | |
502 | { | |
503 | uint tmp = QT_TREEOFF; | |
504 | ||
505 | if (!dquot->dq_off) /* Even not allocated? */ | |
506 | return 0; | |
507 | return remove_tree(info, dquot, &tmp, 0); | |
508 | } | |
509 | EXPORT_SYMBOL(qtree_delete_dquot); | |
510 | ||
511 | /* Find entry in block */ | |
512 | static loff_t find_block_dqentry(struct qtree_mem_dqinfo *info, | |
513 | struct dquot *dquot, uint blk) | |
514 | { | |
d26ac1a8 | 515 | char *buf = getdqbuf(info->dqi_usable_bs); |
1ccd14b9 JK |
516 | loff_t ret = 0; |
517 | int i; | |
518 | char *ddquot; | |
519 | ||
520 | if (!buf) | |
521 | return -ENOMEM; | |
522 | ret = read_blk(info, blk, buf); | |
523 | if (ret < 0) { | |
524 | printk(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk); | |
525 | goto out_buf; | |
526 | } | |
268157ba JK |
527 | ddquot = buf + sizeof(struct qt_disk_dqdbheader); |
528 | for (i = 0; i < qtree_dqstr_in_blk(info); i++) { | |
529 | if (info->dqi_ops->is_id(ddquot, dquot)) | |
530 | break; | |
531 | ddquot += info->dqi_entry_size; | |
532 | } | |
1ccd14b9 JK |
533 | if (i == qtree_dqstr_in_blk(info)) { |
534 | printk(KERN_ERR "VFS: Quota for id %u referenced " | |
535 | "but not present.\n", dquot->dq_id); | |
536 | ret = -EIO; | |
537 | goto out_buf; | |
538 | } else { | |
539 | ret = (blk << info->dqi_blocksize_bits) + sizeof(struct | |
540 | qt_disk_dqdbheader) + i * info->dqi_entry_size; | |
541 | } | |
542 | out_buf: | |
d26ac1a8 | 543 | kfree(buf); |
1ccd14b9 JK |
544 | return ret; |
545 | } | |
546 | ||
547 | /* Find entry for given id in the tree */ | |
548 | static loff_t find_tree_dqentry(struct qtree_mem_dqinfo *info, | |
549 | struct dquot *dquot, uint blk, int depth) | |
550 | { | |
d26ac1a8 | 551 | char *buf = getdqbuf(info->dqi_usable_bs); |
1ccd14b9 JK |
552 | loff_t ret = 0; |
553 | __le32 *ref = (__le32 *)buf; | |
554 | ||
555 | if (!buf) | |
556 | return -ENOMEM; | |
557 | ret = read_blk(info, blk, buf); | |
558 | if (ret < 0) { | |
559 | printk(KERN_ERR "VFS: Can't read quota tree block %u.\n", blk); | |
560 | goto out_buf; | |
561 | } | |
562 | ret = 0; | |
563 | blk = le32_to_cpu(ref[get_index(info, dquot->dq_id, depth)]); | |
564 | if (!blk) /* No reference? */ | |
565 | goto out_buf; | |
566 | if (depth < info->dqi_qtree_depth - 1) | |
567 | ret = find_tree_dqentry(info, dquot, blk, depth+1); | |
568 | else | |
569 | ret = find_block_dqentry(info, dquot, blk); | |
570 | out_buf: | |
d26ac1a8 | 571 | kfree(buf); |
1ccd14b9 JK |
572 | return ret; |
573 | } | |
574 | ||
575 | /* Find entry for given id in the tree - wrapper function */ | |
576 | static inline loff_t find_dqentry(struct qtree_mem_dqinfo *info, | |
577 | struct dquot *dquot) | |
578 | { | |
579 | return find_tree_dqentry(info, dquot, QT_TREEOFF, 0); | |
580 | } | |
581 | ||
582 | int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) | |
583 | { | |
584 | int type = dquot->dq_type; | |
585 | struct super_block *sb = dquot->dq_sb; | |
586 | loff_t offset; | |
d26ac1a8 | 587 | char *ddquot; |
1ccd14b9 JK |
588 | int ret = 0; |
589 | ||
590 | #ifdef __QUOTA_QT_PARANOIA | |
591 | /* Invalidated quota? */ | |
592 | if (!sb_dqopt(dquot->dq_sb)->files[type]) { | |
593 | printk(KERN_ERR "VFS: Quota invalidated while reading!\n"); | |
594 | return -EIO; | |
595 | } | |
596 | #endif | |
597 | /* Do we know offset of the dquot entry in the quota file? */ | |
598 | if (!dquot->dq_off) { | |
599 | offset = find_dqentry(info, dquot); | |
600 | if (offset <= 0) { /* Entry not present? */ | |
601 | if (offset < 0) | |
602 | printk(KERN_ERR "VFS: Can't read quota " | |
603 | "structure for id %u.\n", dquot->dq_id); | |
604 | dquot->dq_off = 0; | |
605 | set_bit(DQ_FAKE_B, &dquot->dq_flags); | |
606 | memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk)); | |
607 | ret = offset; | |
608 | goto out; | |
609 | } | |
610 | dquot->dq_off = offset; | |
611 | } | |
612 | ddquot = getdqbuf(info->dqi_entry_size); | |
613 | if (!ddquot) | |
614 | return -ENOMEM; | |
d26ac1a8 JK |
615 | ret = sb->s_op->quota_read(sb, type, ddquot, info->dqi_entry_size, |
616 | dquot->dq_off); | |
1ccd14b9 JK |
617 | if (ret != info->dqi_entry_size) { |
618 | if (ret >= 0) | |
619 | ret = -EIO; | |
620 | printk(KERN_ERR "VFS: Error while reading quota " | |
621 | "structure for id %u.\n", dquot->dq_id); | |
622 | set_bit(DQ_FAKE_B, &dquot->dq_flags); | |
623 | memset(&dquot->dq_dqb, 0, sizeof(struct mem_dqblk)); | |
d26ac1a8 | 624 | kfree(ddquot); |
1ccd14b9 JK |
625 | goto out; |
626 | } | |
627 | spin_lock(&dq_data_lock); | |
628 | info->dqi_ops->disk2mem_dqblk(dquot, ddquot); | |
629 | if (!dquot->dq_dqb.dqb_bhardlimit && | |
630 | !dquot->dq_dqb.dqb_bsoftlimit && | |
631 | !dquot->dq_dqb.dqb_ihardlimit && | |
632 | !dquot->dq_dqb.dqb_isoftlimit) | |
633 | set_bit(DQ_FAKE_B, &dquot->dq_flags); | |
634 | spin_unlock(&dq_data_lock); | |
d26ac1a8 | 635 | kfree(ddquot); |
1ccd14b9 | 636 | out: |
dde95888 | 637 | dqstats_inc(DQST_READS); |
1ccd14b9 JK |
638 | return ret; |
639 | } | |
640 | EXPORT_SYMBOL(qtree_read_dquot); | |
641 | ||
642 | /* Check whether dquot should not be deleted. We know we are | |
643 | * the only one operating on dquot (thanks to dq_lock) */ | |
644 | int qtree_release_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) | |
645 | { | |
268157ba JK |
646 | if (test_bit(DQ_FAKE_B, &dquot->dq_flags) && |
647 | !(dquot->dq_dqb.dqb_curinodes | dquot->dq_dqb.dqb_curspace)) | |
1ccd14b9 JK |
648 | return qtree_delete_dquot(info, dquot); |
649 | return 0; | |
650 | } | |
651 | EXPORT_SYMBOL(qtree_release_dquot); |