1 // SPDX-License-Identifier: GPL-2.0+
3 * btnode.c - NILFS B-tree node cache
5 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
7 * Originally written by Seiji Kihara.
8 * Fully revised by Ryusuke Konishi for stabilization and simplification.
12 #include <linux/types.h>
13 #include <linux/buffer_head.h>
15 #include <linux/backing-dev.h>
16 #include <linux/gfp.h>
25 * nilfs_init_btnc_inode - initialize B-tree node cache inode
26 * @btnc_inode: inode to be initialized
28 * nilfs_init_btnc_inode() sets up an inode for B-tree node cache.
30 void nilfs_init_btnc_inode(struct inode *btnc_inode)
32 struct nilfs_inode_info *ii = NILFS_I(btnc_inode);
34 btnc_inode->i_mode = S_IFREG;
36 memset(&ii->i_bmap_data, 0, sizeof(struct nilfs_bmap));
37 mapping_set_gfp_mask(btnc_inode->i_mapping, GFP_NOFS);
40 void nilfs_btnode_cache_clear(struct address_space *btnc)
42 invalidate_mapping_pages(btnc, 0, -1);
43 truncate_inode_pages(btnc, 0);
47 nilfs_btnode_create_block(struct address_space *btnc, __u64 blocknr)
49 struct inode *inode = btnc->host;
50 struct buffer_head *bh;
52 bh = nilfs_grab_buffer(inode, btnc, blocknr, BIT(BH_NILFS_Node));
56 if (unlikely(buffer_mapped(bh) || buffer_uptodate(bh) ||
61 memset(bh->b_data, 0, i_blocksize(inode));
62 bh->b_bdev = inode->i_sb->s_bdev;
63 bh->b_blocknr = blocknr;
64 set_buffer_mapped(bh);
65 set_buffer_uptodate(bh);
67 unlock_page(bh->b_page);
72 int nilfs_btnode_submit_block(struct address_space *btnc, __u64 blocknr,
73 sector_t pblocknr, int mode, int mode_flags,
74 struct buffer_head **pbh, sector_t *submit_ptr)
76 struct buffer_head *bh;
77 struct inode *inode = btnc->host;
81 bh = nilfs_grab_buffer(inode, btnc, blocknr, BIT(BH_NILFS_Node));
85 err = -EEXIST; /* internal code */
88 if (buffer_uptodate(bh) || buffer_dirty(bh))
93 if (inode->i_ino != NILFS_DAT_INO) {
94 struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
96 /* blocknr is a virtual block number */
97 err = nilfs_dat_translate(nilfs->ns_dat, blocknr,
106 if (mode_flags & REQ_RAHEAD) {
107 if (pblocknr != *submit_ptr + 1 || !trylock_buffer(bh)) {
108 err = -EBUSY; /* internal code */
112 } else { /* mode == READ */
115 if (buffer_uptodate(bh)) {
117 err = -EEXIST; /* internal code */
120 set_buffer_mapped(bh);
121 bh->b_bdev = inode->i_sb->s_bdev;
122 bh->b_blocknr = pblocknr; /* set block address for read */
123 bh->b_end_io = end_buffer_read_sync;
125 submit_bh(mode, mode_flags, bh);
126 bh->b_blocknr = blocknr; /* set back to the given block address */
127 *submit_ptr = pblocknr;
139 * nilfs_btnode_delete - delete B-tree node buffer
140 * @bh: buffer to be deleted
142 * nilfs_btnode_delete() invalidates the specified buffer and delete the page
143 * including the buffer if the page gets unbusy.
145 void nilfs_btnode_delete(struct buffer_head *bh)
147 struct address_space *mapping;
148 struct page *page = bh->b_page;
149 pgoff_t index = page_index(page);
154 wait_on_page_writeback(page);
156 nilfs_forget_buffer(bh);
157 still_dirty = PageDirty(page);
158 mapping = page->mapping;
162 if (!still_dirty && mapping)
163 invalidate_inode_pages2_range(mapping, index, index);
167 * nilfs_btnode_prepare_change_key
168 * prepare to move contents of the block for old key to one of new key.
169 * the old buffer will not be removed, but might be reused for new buffer.
170 * it might return -ENOMEM because of memory allocation errors,
171 * and might return -EIO because of disk read errors.
173 int nilfs_btnode_prepare_change_key(struct address_space *btnc,
174 struct nilfs_btnode_chkey_ctxt *ctxt)
176 struct buffer_head *obh, *nbh;
177 struct inode *inode = btnc->host;
178 __u64 oldkey = ctxt->oldkey, newkey = ctxt->newkey;
181 if (oldkey == newkey)
187 if (inode->i_blkbits == PAGE_SHIFT) {
188 lock_page(obh->b_page);
190 * We cannot call radix_tree_preload for the kernels older
191 * than 2.6.23, because it is not exported for modules.
194 err = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
197 /* BUG_ON(oldkey != obh->b_page->index); */
198 if (unlikely(oldkey != obh->b_page->index))
199 NILFS_PAGE_BUG(obh->b_page,
200 "invalid oldkey %lld (newkey=%lld)",
201 (unsigned long long)oldkey,
202 (unsigned long long)newkey);
204 xa_lock_irq(&btnc->i_pages);
205 err = radix_tree_insert(&btnc->i_pages, newkey, obh->b_page);
206 xa_unlock_irq(&btnc->i_pages);
208 * Note: page->index will not change to newkey until
209 * nilfs_btnode_commit_change_key() will be called.
210 * To protect the page in intermediate state, the page lock
213 radix_tree_preload_end();
216 else if (err != -EEXIST)
219 err = invalidate_inode_pages2_range(btnc, newkey, newkey);
222 /* fallback to copy mode */
223 unlock_page(obh->b_page);
226 nbh = nilfs_btnode_create_block(btnc, newkey);
235 unlock_page(obh->b_page);
240 * nilfs_btnode_commit_change_key
241 * commit the change_key operation prepared by prepare_change_key().
243 void nilfs_btnode_commit_change_key(struct address_space *btnc,
244 struct nilfs_btnode_chkey_ctxt *ctxt)
246 struct buffer_head *obh = ctxt->bh, *nbh = ctxt->newbh;
247 __u64 oldkey = ctxt->oldkey, newkey = ctxt->newkey;
250 if (oldkey == newkey)
253 if (nbh == NULL) { /* blocksize == pagesize */
255 if (unlikely(oldkey != opage->index))
256 NILFS_PAGE_BUG(opage,
257 "invalid oldkey %lld (newkey=%lld)",
258 (unsigned long long)oldkey,
259 (unsigned long long)newkey);
260 mark_buffer_dirty(obh);
262 xa_lock_irq(&btnc->i_pages);
263 radix_tree_delete(&btnc->i_pages, oldkey);
264 radix_tree_tag_set(&btnc->i_pages, newkey,
265 PAGECACHE_TAG_DIRTY);
266 xa_unlock_irq(&btnc->i_pages);
268 opage->index = obh->b_blocknr = newkey;
271 nilfs_copy_buffer(nbh, obh);
272 mark_buffer_dirty(nbh);
274 nbh->b_blocknr = newkey;
276 nilfs_btnode_delete(obh); /* will decrement bh->b_count */
281 * nilfs_btnode_abort_change_key
282 * abort the change_key operation prepared by prepare_change_key().
284 void nilfs_btnode_abort_change_key(struct address_space *btnc,
285 struct nilfs_btnode_chkey_ctxt *ctxt)
287 struct buffer_head *nbh = ctxt->newbh;
288 __u64 oldkey = ctxt->oldkey, newkey = ctxt->newkey;
290 if (oldkey == newkey)
293 if (nbh == NULL) { /* blocksize == pagesize */
294 xa_lock_irq(&btnc->i_pages);
295 radix_tree_delete(&btnc->i_pages, newkey);
296 xa_unlock_irq(&btnc->i_pages);
297 unlock_page(ctxt->bh->b_page);
300 * When canceling a buffer that a prepare operation has
301 * allocated to copy a node block to another location, use
302 * nilfs_btnode_delete() to initialize and release the buffer
303 * so that the buffer flags will not be in an inconsistent
304 * state when it is reallocated.
306 nilfs_btnode_delete(nbh);