1 // SPDX-License-Identifier: GPL-2.0+
3 * NILFS dat/inode allocator
5 * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
7 * Originally written by Koji Sato.
8 * Two allocators were unified by Ryusuke Konishi and Amagai Yoshiji.
11 #include <linux/types.h>
12 #include <linux/buffer_head.h>
14 #include <linux/bitops.h>
15 #include <linux/slab.h>
21 * nilfs_palloc_groups_per_desc_block - get the number of groups that a group
22 * descriptor block can maintain
23 * @inode: inode of metadata file using this allocator
25 static inline unsigned long
26 nilfs_palloc_groups_per_desc_block(const struct inode *inode)
28 return i_blocksize(inode) /
29 sizeof(struct nilfs_palloc_group_desc);
33 * nilfs_palloc_groups_count - get maximum number of groups
34 * @inode: inode of metadata file using this allocator
36 static inline unsigned long
37 nilfs_palloc_groups_count(const struct inode *inode)
39 return 1UL << (BITS_PER_LONG - (inode->i_blkbits + 3 /* log2(8) */));
43 * nilfs_palloc_init_blockgroup - initialize private variables for allocator
44 * @inode: inode of metadata file using this allocator
45 * @entry_size: size of the persistent object
47 int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned int entry_size)
49 struct nilfs_mdt_info *mi = NILFS_MDT(inode);
51 mi->mi_bgl = kmalloc(sizeof(*mi->mi_bgl), GFP_NOFS);
55 bgl_lock_init(mi->mi_bgl);
57 nilfs_mdt_set_entry_size(inode, entry_size, 0);
59 mi->mi_blocks_per_group =
60 DIV_ROUND_UP(nilfs_palloc_entries_per_group(inode),
61 mi->mi_entries_per_block) + 1;
63 * Number of blocks in a group including entry blocks
66 mi->mi_blocks_per_desc_block =
67 nilfs_palloc_groups_per_desc_block(inode) *
68 mi->mi_blocks_per_group + 1;
70 * Number of blocks per descriptor including the
77 * nilfs_palloc_group - get group number and offset from an entry number
78 * @inode: inode of metadata file using this allocator
79 * @nr: serial number of the entry (e.g. inode number)
80 * @offset: pointer to store offset number in the group
82 static unsigned long nilfs_palloc_group(const struct inode *inode, __u64 nr,
83 unsigned long *offset)
87 *offset = do_div(group, nilfs_palloc_entries_per_group(inode));
92 * nilfs_palloc_desc_blkoff - get block offset of a group descriptor block
93 * @inode: inode of metadata file using this allocator
94 * @group: group number
96 * nilfs_palloc_desc_blkoff() returns block offset of the descriptor
97 * block which contains a descriptor of the specified group.
100 nilfs_palloc_desc_blkoff(const struct inode *inode, unsigned long group)
102 unsigned long desc_block =
103 group / nilfs_palloc_groups_per_desc_block(inode);
104 return desc_block * NILFS_MDT(inode)->mi_blocks_per_desc_block;
108 * nilfs_palloc_bitmap_blkoff - get block offset of a bitmap block
109 * @inode: inode of metadata file using this allocator
110 * @group: group number
112 * nilfs_palloc_bitmap_blkoff() returns block offset of the bitmap
113 * block used to allocate/deallocate entries in the specified group.
116 nilfs_palloc_bitmap_blkoff(const struct inode *inode, unsigned long group)
118 unsigned long desc_offset =
119 group % nilfs_palloc_groups_per_desc_block(inode);
120 return nilfs_palloc_desc_blkoff(inode, group) + 1 +
121 desc_offset * NILFS_MDT(inode)->mi_blocks_per_group;
125 * nilfs_palloc_group_desc_nfrees - get the number of free entries in a group
126 * @desc: pointer to descriptor structure for the group
127 * @lock: spin lock protecting @desc
130 nilfs_palloc_group_desc_nfrees(const struct nilfs_palloc_group_desc *desc,
136 nfree = le32_to_cpu(desc->pg_nfrees);
142 * nilfs_palloc_group_desc_add_entries - adjust count of free entries
143 * @desc: pointer to descriptor structure for the group
144 * @lock: spin lock protecting @desc
145 * @n: delta to be added
148 nilfs_palloc_group_desc_add_entries(struct nilfs_palloc_group_desc *desc,
149 spinlock_t *lock, u32 n)
154 le32_add_cpu(&desc->pg_nfrees, n);
155 nfree = le32_to_cpu(desc->pg_nfrees);
161 * nilfs_palloc_entry_blkoff - get block offset of an entry block
162 * @inode: inode of metadata file using this allocator
163 * @nr: serial number of the entry (e.g. inode number)
166 nilfs_palloc_entry_blkoff(const struct inode *inode, __u64 nr)
168 unsigned long group, group_offset;
170 group = nilfs_palloc_group(inode, nr, &group_offset);
172 return nilfs_palloc_bitmap_blkoff(inode, group) + 1 +
173 group_offset / NILFS_MDT(inode)->mi_entries_per_block;
177 * nilfs_palloc_desc_block_init - initialize buffer of a group descriptor block
178 * @inode: inode of metadata file
179 * @bh: buffer head of the buffer to be initialized
180 * @kaddr: kernel address mapped for the page including the buffer
182 static void nilfs_palloc_desc_block_init(struct inode *inode,
183 struct buffer_head *bh, void *kaddr)
185 struct nilfs_palloc_group_desc *desc = kaddr + bh_offset(bh);
186 unsigned long n = nilfs_palloc_groups_per_desc_block(inode);
189 nfrees = cpu_to_le32(nilfs_palloc_entries_per_group(inode));
191 desc->pg_nfrees = nfrees;
196 static int nilfs_palloc_get_block(struct inode *inode, unsigned long blkoff,
198 void (*init_block)(struct inode *,
199 struct buffer_head *,
201 struct buffer_head **bhp,
202 struct nilfs_bh_assoc *prev,
208 if (prev->bh && blkoff == prev->blkoff &&
209 likely(buffer_uptodate(prev->bh))) {
217 ret = nilfs_mdt_get_block(inode, blkoff, create, init_block, bhp);
221 * The following code must be safe for change of the
222 * cache contents during the get block call.
227 prev->blkoff = blkoff;
234 * nilfs_palloc_delete_block - delete a block on the persistent allocator file
235 * @inode: inode of metadata file using this allocator
236 * @blkoff: block offset
237 * @prev: nilfs_bh_assoc struct of the last used buffer
238 * @lock: spin lock protecting @prev
240 static int nilfs_palloc_delete_block(struct inode *inode, unsigned long blkoff,
241 struct nilfs_bh_assoc *prev,
245 if (prev->bh && blkoff == prev->blkoff) {
250 return nilfs_mdt_delete_block(inode, blkoff);
254 * nilfs_palloc_get_desc_block - get buffer head of a group descriptor block
255 * @inode: inode of metadata file using this allocator
256 * @group: group number
257 * @create: create flag
258 * @bhp: pointer to store the resultant buffer head
260 static int nilfs_palloc_get_desc_block(struct inode *inode,
262 int create, struct buffer_head **bhp)
264 struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;
266 return nilfs_palloc_get_block(inode,
267 nilfs_palloc_desc_blkoff(inode, group),
268 create, nilfs_palloc_desc_block_init,
269 bhp, &cache->prev_desc, &cache->lock);
273 * nilfs_palloc_get_bitmap_block - get buffer head of a bitmap block
274 * @inode: inode of metadata file using this allocator
275 * @group: group number
276 * @create: create flag
277 * @bhp: pointer to store the resultant buffer head
279 static int nilfs_palloc_get_bitmap_block(struct inode *inode,
281 int create, struct buffer_head **bhp)
283 struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;
285 return nilfs_palloc_get_block(inode,
286 nilfs_palloc_bitmap_blkoff(inode, group),
288 &cache->prev_bitmap, &cache->lock);
292 * nilfs_palloc_delete_bitmap_block - delete a bitmap block
293 * @inode: inode of metadata file using this allocator
294 * @group: group number
296 static int nilfs_palloc_delete_bitmap_block(struct inode *inode,
299 struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;
301 return nilfs_palloc_delete_block(inode,
302 nilfs_palloc_bitmap_blkoff(inode,
304 &cache->prev_bitmap, &cache->lock);
308 * nilfs_palloc_get_entry_block - get buffer head of an entry block
309 * @inode: inode of metadata file using this allocator
310 * @nr: serial number of the entry (e.g. inode number)
311 * @create: create flag
312 * @bhp: pointer to store the resultant buffer head
314 int nilfs_palloc_get_entry_block(struct inode *inode, __u64 nr,
315 int create, struct buffer_head **bhp)
317 struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;
319 return nilfs_palloc_get_block(inode,
320 nilfs_palloc_entry_blkoff(inode, nr),
322 &cache->prev_entry, &cache->lock);
326 * nilfs_palloc_delete_entry_block - delete an entry block
327 * @inode: inode of metadata file using this allocator
328 * @nr: serial number of the entry
330 static int nilfs_palloc_delete_entry_block(struct inode *inode, __u64 nr)
332 struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;
334 return nilfs_palloc_delete_block(inode,
335 nilfs_palloc_entry_blkoff(inode, nr),
336 &cache->prev_entry, &cache->lock);
340 * nilfs_palloc_block_get_group_desc - get kernel address of a group descriptor
341 * @inode: inode of metadata file using this allocator
342 * @group: group number
343 * @bh: buffer head of the buffer storing the group descriptor block
344 * @kaddr: kernel address mapped for the page including the buffer
346 static struct nilfs_palloc_group_desc *
347 nilfs_palloc_block_get_group_desc(const struct inode *inode,
349 const struct buffer_head *bh, void *kaddr)
351 return (struct nilfs_palloc_group_desc *)(kaddr + bh_offset(bh)) +
352 group % nilfs_palloc_groups_per_desc_block(inode);
356 * nilfs_palloc_block_get_entry - get kernel address of an entry
357 * @inode: inode of metadata file using this allocator
358 * @nr: serial number of the entry (e.g. inode number)
359 * @bh: buffer head of the buffer storing the entry block
360 * @kaddr: kernel address mapped for the page including the buffer
362 void *nilfs_palloc_block_get_entry(const struct inode *inode, __u64 nr,
363 const struct buffer_head *bh, void *kaddr)
365 unsigned long entry_offset, group_offset;
367 nilfs_palloc_group(inode, nr, &group_offset);
368 entry_offset = group_offset % NILFS_MDT(inode)->mi_entries_per_block;
370 return kaddr + bh_offset(bh) +
371 entry_offset * NILFS_MDT(inode)->mi_entry_size;
375 * nilfs_palloc_find_available_slot - find available slot in a group
376 * @bitmap: bitmap of the group
377 * @target: offset number of an entry in the group (start point)
378 * @bsize: size in bits
379 * @lock: spin lock protecting @bitmap
381 static int nilfs_palloc_find_available_slot(unsigned char *bitmap,
382 unsigned long target,
386 int pos, end = bsize;
388 if (likely(target < bsize)) {
391 pos = nilfs_find_next_zero_bit(bitmap, end, pos);
394 if (!nilfs_set_bit_atomic(lock, pos, bitmap))
396 } while (++pos < end);
402 for (pos = 0; pos < end; pos++) {
403 pos = nilfs_find_next_zero_bit(bitmap, end, pos);
406 if (!nilfs_set_bit_atomic(lock, pos, bitmap))
414 * nilfs_palloc_rest_groups_in_desc_block - get the remaining number of groups
415 * in a group descriptor block
416 * @inode: inode of metadata file using this allocator
417 * @curr: current group number
418 * @max: maximum number of groups
421 nilfs_palloc_rest_groups_in_desc_block(const struct inode *inode,
422 unsigned long curr, unsigned long max)
424 return min_t(unsigned long,
425 nilfs_palloc_groups_per_desc_block(inode) -
426 curr % nilfs_palloc_groups_per_desc_block(inode),
431 * nilfs_palloc_count_desc_blocks - count descriptor blocks number
432 * @inode: inode of metadata file using this allocator
433 * @desc_blocks: descriptor blocks number [out]
435 static int nilfs_palloc_count_desc_blocks(struct inode *inode,
436 unsigned long *desc_blocks)
441 ret = nilfs_bmap_last_key(NILFS_I(inode)->i_bmap, &blknum);
443 *desc_blocks = DIV_ROUND_UP(
444 (unsigned long)blknum,
445 NILFS_MDT(inode)->mi_blocks_per_desc_block);
450 * nilfs_palloc_mdt_file_can_grow - check potential opportunity for
452 * @inode: inode of metadata file using this allocator
453 * @desc_blocks: known current descriptor blocks count
455 static inline bool nilfs_palloc_mdt_file_can_grow(struct inode *inode,
456 unsigned long desc_blocks)
458 return (nilfs_palloc_groups_per_desc_block(inode) * desc_blocks) <
459 nilfs_palloc_groups_count(inode);
463 * nilfs_palloc_count_max_entries - count max number of entries that can be
464 * described by descriptor blocks count
465 * @inode: inode of metadata file using this allocator
466 * @nused: current number of used entries
467 * @nmaxp: max number of entries [out]
469 int nilfs_palloc_count_max_entries(struct inode *inode, u64 nused, u64 *nmaxp)
471 unsigned long desc_blocks = 0;
472 u64 entries_per_desc_block, nmax;
475 err = nilfs_palloc_count_desc_blocks(inode, &desc_blocks);
479 entries_per_desc_block = (u64)nilfs_palloc_entries_per_group(inode) *
480 nilfs_palloc_groups_per_desc_block(inode);
481 nmax = entries_per_desc_block * desc_blocks;
484 nilfs_palloc_mdt_file_can_grow(inode, desc_blocks))
485 nmax += entries_per_desc_block;
495 * nilfs_palloc_prepare_alloc_entry - prepare to allocate a persistent object
496 * @inode: inode of metadata file using this allocator
497 * @req: nilfs_palloc_req structure exchanged for the allocation
499 int nilfs_palloc_prepare_alloc_entry(struct inode *inode,
500 struct nilfs_palloc_req *req)
502 struct buffer_head *desc_bh, *bitmap_bh;
503 struct nilfs_palloc_group_desc *desc;
504 unsigned char *bitmap;
505 void *desc_kaddr, *bitmap_kaddr;
506 unsigned long group, maxgroup, ngroups;
507 unsigned long group_offset, maxgroup_offset;
508 unsigned long n, entries_per_group;
513 ngroups = nilfs_palloc_groups_count(inode);
514 maxgroup = ngroups - 1;
515 group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
516 entries_per_group = nilfs_palloc_entries_per_group(inode);
518 for (i = 0; i < ngroups; i += n) {
519 if (group >= ngroups) {
522 maxgroup = nilfs_palloc_group(inode, req->pr_entry_nr,
523 &maxgroup_offset) - 1;
525 ret = nilfs_palloc_get_desc_block(inode, group, 1, &desc_bh);
528 desc_kaddr = kmap_local_page(desc_bh->b_page);
529 desc = nilfs_palloc_block_get_group_desc(
530 inode, group, desc_bh, desc_kaddr);
531 n = nilfs_palloc_rest_groups_in_desc_block(inode, group,
533 for (j = 0; j < n; j++, desc++, group++, group_offset = 0) {
534 lock = nilfs_mdt_bgl_lock(inode, group);
535 if (nilfs_palloc_group_desc_nfrees(desc, lock) == 0)
538 kunmap_local(desc_kaddr);
539 ret = nilfs_palloc_get_bitmap_block(inode, group, 1,
541 if (unlikely(ret < 0)) {
546 desc_kaddr = kmap_local_page(desc_bh->b_page);
547 desc = nilfs_palloc_block_get_group_desc(
548 inode, group, desc_bh, desc_kaddr);
550 bitmap_kaddr = kmap_local_page(bitmap_bh->b_page);
551 bitmap = bitmap_kaddr + bh_offset(bitmap_bh);
552 pos = nilfs_palloc_find_available_slot(
553 bitmap, group_offset, entries_per_group, lock);
554 kunmap_local(bitmap_kaddr);
561 kunmap_local(desc_kaddr);
565 /* no entries left */
569 /* found a free entry */
570 nilfs_palloc_group_desc_add_entries(desc, lock, -1);
571 req->pr_entry_nr = entries_per_group * group + pos;
572 kunmap_local(desc_kaddr);
574 req->pr_desc_bh = desc_bh;
575 req->pr_bitmap_bh = bitmap_bh;
580 * nilfs_palloc_commit_alloc_entry - finish allocation of a persistent object
581 * @inode: inode of metadata file using this allocator
582 * @req: nilfs_palloc_req structure exchanged for the allocation
584 void nilfs_palloc_commit_alloc_entry(struct inode *inode,
585 struct nilfs_palloc_req *req)
587 mark_buffer_dirty(req->pr_bitmap_bh);
588 mark_buffer_dirty(req->pr_desc_bh);
589 nilfs_mdt_mark_dirty(inode);
591 brelse(req->pr_bitmap_bh);
592 brelse(req->pr_desc_bh);
596 * nilfs_palloc_commit_free_entry - finish deallocating a persistent object
597 * @inode: inode of metadata file using this allocator
598 * @req: nilfs_palloc_req structure exchanged for the removal
600 void nilfs_palloc_commit_free_entry(struct inode *inode,
601 struct nilfs_palloc_req *req)
603 struct nilfs_palloc_group_desc *desc;
604 unsigned long group, group_offset;
605 unsigned char *bitmap;
606 void *desc_kaddr, *bitmap_kaddr;
609 group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
610 desc_kaddr = kmap_local_page(req->pr_desc_bh->b_page);
611 desc = nilfs_palloc_block_get_group_desc(inode, group,
612 req->pr_desc_bh, desc_kaddr);
613 bitmap_kaddr = kmap_local_page(req->pr_bitmap_bh->b_page);
614 bitmap = bitmap_kaddr + bh_offset(req->pr_bitmap_bh);
615 lock = nilfs_mdt_bgl_lock(inode, group);
617 if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
618 nilfs_warn(inode->i_sb,
619 "%s (ino=%lu): entry number %llu already freed",
620 __func__, inode->i_ino,
621 (unsigned long long)req->pr_entry_nr);
623 nilfs_palloc_group_desc_add_entries(desc, lock, 1);
625 kunmap_local(bitmap_kaddr);
626 kunmap_local(desc_kaddr);
628 mark_buffer_dirty(req->pr_desc_bh);
629 mark_buffer_dirty(req->pr_bitmap_bh);
630 nilfs_mdt_mark_dirty(inode);
632 brelse(req->pr_bitmap_bh);
633 brelse(req->pr_desc_bh);
637 * nilfs_palloc_abort_alloc_entry - cancel allocation of a persistent object
638 * @inode: inode of metadata file using this allocator
639 * @req: nilfs_palloc_req structure exchanged for the allocation
641 void nilfs_palloc_abort_alloc_entry(struct inode *inode,
642 struct nilfs_palloc_req *req)
644 struct nilfs_palloc_group_desc *desc;
645 void *desc_kaddr, *bitmap_kaddr;
646 unsigned char *bitmap;
647 unsigned long group, group_offset;
650 group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
651 desc_kaddr = kmap_local_page(req->pr_desc_bh->b_page);
652 desc = nilfs_palloc_block_get_group_desc(inode, group,
653 req->pr_desc_bh, desc_kaddr);
654 bitmap_kaddr = kmap_local_page(req->pr_bitmap_bh->b_page);
655 bitmap = bitmap_kaddr + bh_offset(req->pr_bitmap_bh);
656 lock = nilfs_mdt_bgl_lock(inode, group);
658 if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
659 nilfs_warn(inode->i_sb,
660 "%s (ino=%lu): entry number %llu already freed",
661 __func__, inode->i_ino,
662 (unsigned long long)req->pr_entry_nr);
664 nilfs_palloc_group_desc_add_entries(desc, lock, 1);
666 kunmap_local(bitmap_kaddr);
667 kunmap_local(desc_kaddr);
669 brelse(req->pr_bitmap_bh);
670 brelse(req->pr_desc_bh);
672 req->pr_entry_nr = 0;
673 req->pr_bitmap_bh = NULL;
674 req->pr_desc_bh = NULL;
678 * nilfs_palloc_prepare_free_entry - prepare to deallocate a persistent object
679 * @inode: inode of metadata file using this allocator
680 * @req: nilfs_palloc_req structure exchanged for the removal
682 int nilfs_palloc_prepare_free_entry(struct inode *inode,
683 struct nilfs_palloc_req *req)
685 struct buffer_head *desc_bh, *bitmap_bh;
686 unsigned long group, group_offset;
689 group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
690 ret = nilfs_palloc_get_desc_block(inode, group, 1, &desc_bh);
693 ret = nilfs_palloc_get_bitmap_block(inode, group, 1, &bitmap_bh);
699 req->pr_desc_bh = desc_bh;
700 req->pr_bitmap_bh = bitmap_bh;
705 * nilfs_palloc_abort_free_entry - cancel deallocating a persistent object
706 * @inode: inode of metadata file using this allocator
707 * @req: nilfs_palloc_req structure exchanged for the removal
709 void nilfs_palloc_abort_free_entry(struct inode *inode,
710 struct nilfs_palloc_req *req)
712 brelse(req->pr_bitmap_bh);
713 brelse(req->pr_desc_bh);
715 req->pr_entry_nr = 0;
716 req->pr_bitmap_bh = NULL;
717 req->pr_desc_bh = NULL;
721 * nilfs_palloc_freev - deallocate a set of persistent objects
722 * @inode: inode of metadata file using this allocator
723 * @entry_nrs: array of entry numbers to be deallocated
724 * @nitems: number of entries stored in @entry_nrs
726 int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
728 struct buffer_head *desc_bh, *bitmap_bh;
729 struct nilfs_palloc_group_desc *desc;
730 unsigned char *bitmap;
731 void *desc_kaddr, *bitmap_kaddr;
732 unsigned long group, group_offset;
733 __u64 group_min_nr, last_nrs[8];
734 const unsigned long epg = nilfs_palloc_entries_per_group(inode);
735 const unsigned int epb = NILFS_MDT(inode)->mi_entries_per_block;
736 unsigned int entry_start, end, pos;
741 for (i = 0; i < nitems; i = j) {
742 int change_group = false;
743 int nempties = 0, n = 0;
745 group = nilfs_palloc_group(inode, entry_nrs[i], &group_offset);
746 ret = nilfs_palloc_get_desc_block(inode, group, 0, &desc_bh);
749 ret = nilfs_palloc_get_bitmap_block(inode, group, 0,
756 /* Get the first entry number of the group */
757 group_min_nr = (__u64)group * epg;
759 bitmap_kaddr = kmap_local_page(bitmap_bh->b_page);
760 bitmap = bitmap_kaddr + bh_offset(bitmap_bh);
761 lock = nilfs_mdt_bgl_lock(inode, group);
764 entry_start = rounddown(group_offset, epb);
766 if (!nilfs_clear_bit_atomic(lock, group_offset,
768 nilfs_warn(inode->i_sb,
769 "%s (ino=%lu): entry number %llu already freed",
770 __func__, inode->i_ino,
771 (unsigned long long)entry_nrs[j]);
777 if (j >= nitems || entry_nrs[j] < group_min_nr ||
778 entry_nrs[j] >= group_min_nr + epg) {
781 group_offset = entry_nrs[j] - group_min_nr;
782 if (group_offset >= entry_start &&
783 group_offset < entry_start + epb) {
784 /* This entry is in the same block */
789 /* Test if the entry block is empty or not */
790 end = entry_start + epb;
791 pos = nilfs_find_next_bit(bitmap, end, entry_start);
793 last_nrs[nempties++] = entry_nrs[j - 1];
794 if (nempties >= ARRAY_SIZE(last_nrs))
801 /* Go on to the next entry block */
802 entry_start = rounddown(group_offset, epb);
805 kunmap_local(bitmap_kaddr);
806 mark_buffer_dirty(bitmap_bh);
809 for (k = 0; k < nempties; k++) {
810 ret = nilfs_palloc_delete_entry_block(inode,
812 if (ret && ret != -ENOENT)
813 nilfs_warn(inode->i_sb,
814 "error %d deleting block that object (entry=%llu, ino=%lu) belongs to",
815 ret, (unsigned long long)last_nrs[k],
819 desc_kaddr = kmap_local_page(desc_bh->b_page);
820 desc = nilfs_palloc_block_get_group_desc(
821 inode, group, desc_bh, desc_kaddr);
822 nfree = nilfs_palloc_group_desc_add_entries(desc, lock, n);
823 kunmap_local(desc_kaddr);
824 mark_buffer_dirty(desc_bh);
825 nilfs_mdt_mark_dirty(inode);
828 if (nfree == nilfs_palloc_entries_per_group(inode)) {
829 ret = nilfs_palloc_delete_bitmap_block(inode, group);
830 if (ret && ret != -ENOENT)
831 nilfs_warn(inode->i_sb,
832 "error %d deleting bitmap block of group=%lu, ino=%lu",
833 ret, group, inode->i_ino);
839 void nilfs_palloc_setup_cache(struct inode *inode,
840 struct nilfs_palloc_cache *cache)
842 NILFS_MDT(inode)->mi_palloc_cache = cache;
843 spin_lock_init(&cache->lock);
846 void nilfs_palloc_clear_cache(struct inode *inode)
848 struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;
850 spin_lock(&cache->lock);
851 brelse(cache->prev_desc.bh);
852 brelse(cache->prev_bitmap.bh);
853 brelse(cache->prev_entry.bh);
854 cache->prev_desc.bh = NULL;
855 cache->prev_bitmap.bh = NULL;
856 cache->prev_entry.bh = NULL;
857 spin_unlock(&cache->lock);
860 void nilfs_palloc_destroy_cache(struct inode *inode)
862 nilfs_palloc_clear_cache(inode);
863 NILFS_MDT(inode)->mi_palloc_cache = NULL;