2 * mdt.c - meta data file for NILFS
4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 * Written by Ryusuke Konishi <ryusuke@osrg.net>
23 #include <linux/buffer_head.h>
24 #include <linux/mpage.h>
26 #include <linux/writeback.h>
27 #include <linux/backing-dev.h>
28 #include <linux/swap.h>
35 #define NILFS_MDT_MAX_RA_BLOCKS (16 - 1)
37 #define INIT_UNUSED_INODE_FIELDS
40 nilfs_mdt_insert_new_block(struct inode
*inode
, unsigned long block
,
41 struct buffer_head
*bh
,
42 void (*init_block
)(struct inode
*,
43 struct buffer_head
*, void *))
45 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
49 /* Caller exclude read accesses using page lock */
51 /* set_buffer_new(bh); */
54 ret
= nilfs_bmap_insert(ii
->i_bmap
, block
, (unsigned long)bh
);
58 set_buffer_mapped(bh
);
60 kaddr
= kmap_atomic(bh
->b_page
, KM_USER0
);
61 memset(kaddr
+ bh_offset(bh
), 0, 1 << inode
->i_blkbits
);
63 init_block(inode
, bh
, kaddr
);
64 flush_dcache_page(bh
->b_page
);
65 kunmap_atomic(kaddr
, KM_USER0
);
67 set_buffer_uptodate(bh
);
68 nilfs_mark_buffer_dirty(bh
);
69 nilfs_mdt_mark_dirty(inode
);
73 static int nilfs_mdt_create_block(struct inode
*inode
, unsigned long block
,
74 struct buffer_head
**out_bh
,
75 void (*init_block
)(struct inode
*,
79 struct the_nilfs
*nilfs
= NILFS_MDT(inode
)->mi_nilfs
;
80 struct nilfs_sb_info
*writer
= NULL
;
81 struct super_block
*sb
= inode
->i_sb
;
82 struct nilfs_transaction_info ti
;
83 struct buffer_head
*bh
;
87 writer
= nilfs_get_writer(nilfs
);
95 nilfs_transaction_begin(sb
, &ti
, 0);
98 bh
= nilfs_grab_buffer(inode
, inode
->i_mapping
, block
, 0);
103 if (buffer_uptodate(bh
) || buffer_mapped(bh
))
106 /* The uptodate flag is not protected by the page lock, but
107 the mapped flag is. Thus, we don't have to wait the buffer. */
109 if (buffer_uptodate(bh
))
113 bh
->b_bdev
= nilfs
->ns_bdev
;
114 err
= nilfs_mdt_insert_new_block(inode
, block
, bh
, init_block
);
121 unlock_page(bh
->b_page
);
122 page_cache_release(bh
->b_page
);
127 err
= nilfs_transaction_commit(sb
);
129 nilfs_transaction_abort(sb
);
131 nilfs_put_writer(nilfs
);
137 nilfs_mdt_submit_block(struct inode
*inode
, unsigned long blkoff
,
138 int mode
, struct buffer_head
**out_bh
)
140 struct buffer_head
*bh
;
141 unsigned long blknum
= 0;
144 bh
= nilfs_grab_buffer(inode
, inode
->i_mapping
, blkoff
, 0);
148 ret
= -EEXIST
; /* internal code */
149 if (buffer_uptodate(bh
))
153 if (!trylock_buffer(bh
)) {
158 BUG_ON(mode
!= READ
);
162 if (buffer_uptodate(bh
)) {
166 if (!buffer_mapped(bh
)) { /* unused buffer */
167 ret
= nilfs_bmap_lookup(NILFS_I(inode
)->i_bmap
, blkoff
,
173 bh
->b_bdev
= NILFS_MDT(inode
)->mi_nilfs
->ns_bdev
;
174 bh
->b_blocknr
= blknum
;
175 set_buffer_mapped(bh
);
178 bh
->b_end_io
= end_buffer_read_sync
;
187 unlock_page(bh
->b_page
);
188 page_cache_release(bh
->b_page
);
194 static int nilfs_mdt_read_block(struct inode
*inode
, unsigned long block
,
195 struct buffer_head
**out_bh
)
197 struct buffer_head
*first_bh
, *bh
;
198 unsigned long blkoff
;
199 int i
, nr_ra_blocks
= NILFS_MDT_MAX_RA_BLOCKS
;
202 err
= nilfs_mdt_submit_block(inode
, block
, READ
, &first_bh
);
203 if (err
== -EEXIST
) /* internal code */
210 for (i
= 0; i
< nr_ra_blocks
; i
++, blkoff
++) {
211 err
= nilfs_mdt_submit_block(inode
, blkoff
, READA
, &bh
);
212 if (likely(!err
|| err
== -EEXIST
))
214 else if (err
!= -EBUSY
)
215 break; /* abort readahead if bmap lookup failed */
217 if (!buffer_locked(first_bh
))
221 wait_on_buffer(first_bh
);
225 if (!buffer_uptodate(first_bh
))
238 * nilfs_mdt_get_block - read or create a buffer on meta data file.
239 * @inode: inode of the meta data file
240 * @blkoff: block offset
241 * @create: create flag
242 * @init_block: initializer used for newly allocated block
243 * @out_bh: output of a pointer to the buffer_head
245 * nilfs_mdt_get_block() looks up the specified buffer and tries to create
246 * a new buffer if @create is not zero. On success, the returned buffer is
247 * assured to be either existing or formatted using a buffer lock on success.
248 * @out_bh is substituted only when zero is returned.
250 * Return Value: On success, it returns 0. On error, the following negative
251 * error code is returned.
253 * %-ENOMEM - Insufficient memory available.
257 * %-ENOENT - the specified block does not exist (hole block)
259 * %-EINVAL - bmap is broken. (the caller should call nilfs_error())
261 * %-EROFS - Read only filesystem (for create mode)
263 int nilfs_mdt_get_block(struct inode
*inode
, unsigned long blkoff
, int create
,
264 void (*init_block
)(struct inode
*,
265 struct buffer_head
*, void *),
266 struct buffer_head
**out_bh
)
270 /* Should be rewritten with merging nilfs_mdt_read_block() */
272 ret
= nilfs_mdt_read_block(inode
, blkoff
, out_bh
);
273 if (!create
|| ret
!= -ENOENT
)
276 ret
= nilfs_mdt_create_block(inode
, blkoff
, out_bh
, init_block
);
277 if (unlikely(ret
== -EEXIST
)) {
278 /* create = 0; */ /* limit read-create loop retries */
285 * nilfs_mdt_delete_block - make a hole on the meta data file.
286 * @inode: inode of the meta data file
287 * @block: block offset
289 * Return Value: On success, zero is returned.
290 * On error, one of the following negative error code is returned.
292 * %-ENOMEM - Insufficient memory available.
296 * %-EINVAL - bmap is broken. (the caller should call nilfs_error())
298 int nilfs_mdt_delete_block(struct inode
*inode
, unsigned long block
)
300 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
303 err
= nilfs_bmap_delete(ii
->i_bmap
, block
);
305 nilfs_mdt_mark_dirty(inode
);
306 nilfs_mdt_forget_block(inode
, block
);
312 * nilfs_mdt_forget_block - discard dirty state and try to remove the page
313 * @inode: inode of the meta data file
314 * @block: block offset
316 * nilfs_mdt_forget_block() clears a dirty flag of the specified buffer, and
317 * tries to release the page including the buffer from a page cache.
319 * Return Value: On success, 0 is returned. On error, one of the following
320 * negative error code is returned.
322 * %-EBUSY - page has an active buffer.
324 * %-ENOENT - page cache has no page addressed by the offset.
326 int nilfs_mdt_forget_block(struct inode
*inode
, unsigned long block
)
328 pgoff_t index
= (pgoff_t
)block
>>
329 (PAGE_CACHE_SHIFT
- inode
->i_blkbits
);
331 unsigned long first_block
;
335 page
= find_lock_page(inode
->i_mapping
, index
);
339 wait_on_page_writeback(page
);
341 first_block
= (unsigned long)index
<<
342 (PAGE_CACHE_SHIFT
- inode
->i_blkbits
);
343 if (page_has_buffers(page
)) {
344 struct buffer_head
*bh
;
346 bh
= nilfs_page_get_nth_block(page
, block
- first_block
);
347 nilfs_forget_buffer(bh
);
349 still_dirty
= PageDirty(page
);
351 page_cache_release(page
);
354 invalidate_inode_pages2_range(inode
->i_mapping
, index
, index
) != 0)
360 * nilfs_mdt_mark_block_dirty - mark a block on the meta data file dirty.
361 * @inode: inode of the meta data file
362 * @block: block offset
364 * Return Value: On success, it returns 0. On error, the following negative
365 * error code is returned.
367 * %-ENOMEM - Insufficient memory available.
371 * %-ENOENT - the specified block does not exist (hole block)
373 * %-EINVAL - bmap is broken. (the caller should call nilfs_error())
375 int nilfs_mdt_mark_block_dirty(struct inode
*inode
, unsigned long block
)
377 struct buffer_head
*bh
;
380 err
= nilfs_mdt_read_block(inode
, block
, &bh
);
383 nilfs_mark_buffer_dirty(bh
);
384 nilfs_mdt_mark_dirty(inode
);
389 int nilfs_mdt_fetch_dirty(struct inode
*inode
)
391 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
393 if (nilfs_bmap_test_and_clear_dirty(ii
->i_bmap
)) {
394 set_bit(NILFS_I_DIRTY
, &ii
->i_state
);
397 return test_bit(NILFS_I_DIRTY
, &ii
->i_state
);
401 nilfs_mdt_write_page(struct page
*page
, struct writeback_control
*wbc
)
403 struct inode
*inode
= container_of(page
->mapping
,
404 struct inode
, i_data
);
405 struct super_block
*sb
= inode
->i_sb
;
406 struct nilfs_sb_info
*writer
= NULL
;
409 redirty_page_for_writepage(wbc
, page
);
412 if (page
->mapping
->assoc_mapping
)
413 return 0; /* Do not request flush for shadow page cache */
415 writer
= nilfs_get_writer(NILFS_MDT(inode
)->mi_nilfs
);
418 sb
= writer
->s_super
;
421 if (wbc
->sync_mode
== WB_SYNC_ALL
)
422 err
= nilfs_construct_segment(sb
);
423 else if (wbc
->for_reclaim
)
424 nilfs_flush_segment(sb
, inode
->i_ino
);
427 nilfs_put_writer(NILFS_MDT(inode
)->mi_nilfs
);
432 static struct address_space_operations def_mdt_aops
= {
433 .writepage
= nilfs_mdt_write_page
,
436 static struct inode_operations def_mdt_iops
;
437 static struct file_operations def_mdt_fops
;
440 * NILFS2 uses pseudo inodes for meta data files such as DAT, cpfile, sufile,
441 * ifile, or gcinodes. This allows the B-tree code and segment constructor
442 * to treat them like regular files, and this helps to simplify the
444 * On the other hand, some of the pseudo inodes have an irregular point:
445 * They don't have valid inode->i_sb pointer because their lifetimes are
446 * longer than those of the super block structs; they may continue for
447 * several consecutive mounts/umounts. This would need discussions.
450 nilfs_mdt_new_common(struct the_nilfs
*nilfs
, struct super_block
*sb
,
451 ino_t ino
, gfp_t gfp_mask
)
453 struct inode
*inode
= nilfs_alloc_inode(sb
);
458 struct address_space
* const mapping
= &inode
->i_data
;
459 struct nilfs_mdt_info
*mi
= kzalloc(sizeof(*mi
), GFP_NOFS
);
462 nilfs_destroy_inode(inode
);
465 mi
->mi_nilfs
= nilfs
;
466 init_rwsem(&mi
->mi_sem
);
468 inode
->i_sb
= sb
; /* sb may be NULL for some meta data files */
469 inode
->i_blkbits
= nilfs
->ns_blocksize_bits
;
471 atomic_set(&inode
->i_count
, 1);
474 inode
->i_mode
= S_IFREG
;
475 inode
->i_private
= mi
;
477 #ifdef INIT_UNUSED_INODE_FIELDS
478 atomic_set(&inode
->i_writecount
, 0);
482 inode
->i_generation
= 0;
484 memset(&inode
->i_dquot
, 0, sizeof(inode
->i_dquot
));
486 inode
->i_pipe
= NULL
;
487 inode
->i_bdev
= NULL
;
488 inode
->i_cdev
= NULL
;
490 #ifdef CONFIG_SECURITY
491 inode
->i_security
= NULL
;
493 inode
->dirtied_when
= 0;
495 INIT_LIST_HEAD(&inode
->i_list
);
496 INIT_LIST_HEAD(&inode
->i_sb_list
);
500 spin_lock_init(&inode
->i_lock
);
501 mutex_init(&inode
->i_mutex
);
502 init_rwsem(&inode
->i_alloc_sem
);
504 mapping
->host
= NULL
; /* instead of inode */
506 mapping_set_gfp_mask(mapping
, gfp_mask
);
507 mapping
->assoc_mapping
= NULL
;
508 mapping
->backing_dev_info
= nilfs
->ns_bdi
;
510 inode
->i_mapping
= mapping
;
516 struct inode
*nilfs_mdt_new(struct the_nilfs
*nilfs
, struct super_block
*sb
,
517 ino_t ino
, gfp_t gfp_mask
)
519 struct inode
*inode
= nilfs_mdt_new_common(nilfs
, sb
, ino
, gfp_mask
);
524 inode
->i_op
= &def_mdt_iops
;
525 inode
->i_fop
= &def_mdt_fops
;
526 inode
->i_mapping
->a_ops
= &def_mdt_aops
;
530 void nilfs_mdt_set_entry_size(struct inode
*inode
, unsigned entry_size
,
531 unsigned header_size
)
533 struct nilfs_mdt_info
*mi
= NILFS_MDT(inode
);
535 mi
->mi_entry_size
= entry_size
;
536 mi
->mi_entries_per_block
= (1 << inode
->i_blkbits
) / entry_size
;
537 mi
->mi_first_entry_offset
= DIV_ROUND_UP(header_size
, entry_size
);
540 void nilfs_mdt_set_shadow(struct inode
*orig
, struct inode
*shadow
)
542 shadow
->i_mapping
->assoc_mapping
= orig
->i_mapping
;
543 NILFS_I(shadow
)->i_btnode_cache
.assoc_mapping
=
544 &NILFS_I(orig
)->i_btnode_cache
;
547 void nilfs_mdt_clear(struct inode
*inode
)
549 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
551 invalidate_mapping_pages(inode
->i_mapping
, 0, -1);
552 truncate_inode_pages(inode
->i_mapping
, 0);
554 nilfs_bmap_clear(ii
->i_bmap
);
555 nilfs_btnode_cache_clear(&ii
->i_btnode_cache
);
558 void nilfs_mdt_destroy(struct inode
*inode
)
560 struct nilfs_mdt_info
*mdi
= NILFS_MDT(inode
);
562 kfree(mdi
->mi_bgl
); /* kfree(NULL) is safe */
564 nilfs_destroy_inode(inode
);