From: Vyacheslav Dubeyko <slava@xxxxxxxxxxx>
Subject: [PATCH 19/24] nilfs2: implement superfluous debugging output option
This patch implements DBG_SPAM flag using. This flag requests output
from frequently called functions or detailed debugging output
from function's body.
Signed-off-by: Vyacheslav Dubeyko <slava@xxxxxxxxxxx>
CC: Ryusuke Konishi <konishi.ryusuke@xxxxxxxxxxxxx>
---
fs/nilfs2/alloc.c | 102 +++++++++++++++++++++++++++++++++++++++++++++++++---
fs/nilfs2/btree.c | 19 ++++++++++
fs/nilfs2/dat.c | 77 +++++++++++++++++++++++++++++++++++++++
fs/nilfs2/dir.c | 24 +++++++++++++
fs/nilfs2/inode.c | 24 +++++++++++++
fs/nilfs2/mdt.c | 4 +++
fs/nilfs2/segbuf.c | 28 +++++++++++++++
7 files changed, 273 insertions(+), 5 deletions(-)
diff --git a/fs/nilfs2/alloc.c b/fs/nilfs2/alloc.c
index ee67a07..dc5432d 100644
--- a/fs/nilfs2/alloc.c
+++ b/fs/nilfs2/alloc.c
@@ -99,6 +99,11 @@ static unsigned long nilfs_palloc_group(const struct inode *inode, __u64 nr,
__u64 group = nr;
*offset = do_div(group, nilfs_palloc_entries_per_group(inode));
+
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, nr %llu, offset %lu\n",
+ inode->i_ino, nr, *offset);
+
return group;
}
@@ -113,9 +118,17 @@ static unsigned long nilfs_palloc_group(const struct inode *inode, __u64 nr,
static unsigned long
nilfs_palloc_desc_blkoff(const struct inode *inode, unsigned long group)
{
+ unsigned long blkoff;
unsigned long desc_block =
group / nilfs_palloc_groups_per_desc_block(inode);
- return desc_block * NILFS_MDT(inode)->mi_blocks_per_desc_block;
+
+ blkoff = desc_block * NILFS_MDT(inode)->mi_blocks_per_desc_block;
+
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, group %lu, blkoff %lu\n",
+ inode->i_ino, group, blkoff);
+
+ return blkoff;
}
/**
@@ -129,10 +142,18 @@ nilfs_palloc_desc_blkoff(const struct inode *inode, unsigned long group)
static unsigned long
nilfs_palloc_bitmap_blkoff(const struct inode *inode, unsigned long group)
{
+ unsigned long blkoff;
unsigned long desc_offset =
group % nilfs_palloc_groups_per_desc_block(inode);
- return nilfs_palloc_desc_blkoff(inode, group) + 1 +
+
+ blkoff = nilfs_palloc_desc_blkoff(inode, group) + 1 +
desc_offset * NILFS_MDT(inode)->mi_blocks_per_group;
+
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, group %lu, blkoff %lu\n",
+ inode->i_ino, group, blkoff);
+
+ return blkoff;
}
/**
@@ -150,6 +171,11 @@ nilfs_palloc_group_desc_nfrees(struct inode *inode, unsigned long group,
spin_lock(nilfs_mdt_bgl_lock(inode, group));
nfree = le32_to_cpu(desc->pg_nfrees);
spin_unlock(nilfs_mdt_bgl_lock(inode, group));
+
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, group %lu, nfree %lu\n",
+ inode->i_ino, group, nfree);
+
return nfree;
}
@@ -166,6 +192,10 @@ nilfs_palloc_group_desc_add_entries(struct inode *inode,
struct nilfs_palloc_group_desc *desc,
u32 n)
{
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, group %lu, n %u\n",
+ inode->i_ino, group, n);
+
spin_lock(nilfs_mdt_bgl_lock(inode, group));
le32_add_cpu(&desc->pg_nfrees, n);
spin_unlock(nilfs_mdt_bgl_lock(inode, group));
@@ -179,12 +209,18 @@ nilfs_palloc_group_desc_add_entries(struct inode *inode,
static unsigned long
nilfs_palloc_entry_blkoff(const struct inode *inode, __u64 nr)
{
- unsigned long group, group_offset;
+ unsigned long group, group_offset, blkoff;
group = nilfs_palloc_group(inode, nr, &group_offset);
- return nilfs_palloc_bitmap_blkoff(inode, group) + 1 +
+ blkoff = nilfs_palloc_bitmap_blkoff(inode, group) + 1 +
group_offset / NILFS_MDT(inode)->mi_entries_per_block;
+
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, nr %llu, blkoff %lu\n",
+ inode->i_ino, nr, blkoff);
+
+ return blkoff;
}
/**
@@ -218,6 +254,10 @@ static int nilfs_palloc_get_block(struct inode *inode, unsigned long blkoff,
{
int ret;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM | DBG_DUMP_STACK),
+ "i_ino %lu, blkoff %lu, create %d\n",
+ inode->i_ino, blkoff, create);
+
spin_lock(lock);
if (prev->bh && blkoff == prev->blkoff) {
get_bh(prev->bh);
@@ -256,6 +296,10 @@ static int nilfs_palloc_get_desc_block(struct inode *inode,
{
struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, group %lu, create %d\n",
+ inode->i_ino, group, create);
+
return nilfs_palloc_get_block(inode,
nilfs_palloc_desc_blkoff(inode, group),
create, nilfs_palloc_desc_block_init,
@@ -275,6 +319,10 @@ static int nilfs_palloc_get_bitmap_block(struct inode *inode,
{
struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, group %lu, create %d\n",
+ inode->i_ino, group, create);
+
return nilfs_palloc_get_block(inode,
nilfs_palloc_bitmap_blkoff(inode, group),
create, NULL, bhp,
@@ -293,6 +341,10 @@ int nilfs_palloc_get_entry_block(struct inode *inode, __u64 nr,
{
struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, nr %llu, create %d\n",
+ inode->i_ino, nr, create);
+
return nilfs_palloc_get_block(inode,
nilfs_palloc_entry_blkoff(inode, nr),
create, NULL, bhp,
@@ -311,6 +363,10 @@ nilfs_palloc_block_get_group_desc(const struct inode *inode,
unsigned long group,
const struct buffer_head *bh, void *kaddr)
{
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, group %lu, kaddr %p, bh_offset(bh) %lu\n",
+ inode->i_ino, group, kaddr, bh_offset(bh));
+
return (struct nilfs_palloc_group_desc *)(kaddr + bh_offset(bh)) +
group % nilfs_palloc_groups_per_desc_block(inode);
}
@@ -327,6 +383,10 @@ void *nilfs_palloc_block_get_entry(const struct inode *inode, __u64 nr,
{
unsigned long entry_offset, group_offset;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM | DBG_DUMP_STACK),
+ "i_ino %lu, nr %llu, kaddr %p, bh_offset(bh) %lu\n",
+ inode->i_ino, nr, kaddr, bh_offset(bh));
+
nilfs_palloc_group(inode, nr, &group_offset);
entry_offset = group_offset % NILFS_MDT(inode)->mi_entries_per_block;
@@ -348,7 +408,11 @@ static int nilfs_palloc_find_available_slot(struct inode *inode,
unsigned char *bitmap,
int bsize)
{
- int curr, pos, end, i;
+ unsigned long curr, pos, end, i;
+
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM | DBG_DUMP_STACK),
+ "i_ino %lu, group %lu, target %lu, bitmap %p, %d bsize\n",
+ inode->i_ino, group, target, bitmap, bsize);
if (target > 0) {
end = (target + BITS_PER_LONG - 1) & ~(BITS_PER_LONG - 1);
@@ -419,6 +483,10 @@ int nilfs_palloc_prepare_alloc_entry(struct inode *inode,
unsigned long i, j;
int pos, ret;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM | DBG_DUMP_STACK),
+ "i_ino %lu, req->pr_entry_nr %llu\n",
+ inode->i_ino, req->pr_entry_nr);
+
ngroups = nilfs_palloc_groups_count(inode);
maxgroup = ngroups - 1;
group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
@@ -493,6 +561,10 @@ int nilfs_palloc_prepare_alloc_entry(struct inode *inode,
void nilfs_palloc_commit_alloc_entry(struct inode *inode,
struct nilfs_palloc_req *req)
{
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM | DBG_DUMP_STACK),
+ "i_ino %lu, req->pr_entry_nr %llu\n",
+ inode->i_ino, req->pr_entry_nr);
+
mark_buffer_dirty(req->pr_bitmap_bh);
mark_buffer_dirty(req->pr_desc_bh);
nilfs_mdt_mark_dirty(inode);
@@ -514,6 +586,10 @@ void nilfs_palloc_commit_free_entry(struct inode *inode,
unsigned char *bitmap;
void *desc_kaddr, *bitmap_kaddr;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM | DBG_DUMP_STACK),
+ "i_ino %lu, req->pr_entry_nr %llu\n",
+ inode->i_ino, req->pr_entry_nr);
+
group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
desc_kaddr = kmap(req->pr_desc_bh->b_page);
desc = nilfs_palloc_block_get_group_desc(inode, group,
@@ -552,6 +628,10 @@ void nilfs_palloc_abort_alloc_entry(struct inode *inode,
unsigned char *bitmap;
unsigned long group, group_offset;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM | DBG_DUMP_STACK),
+ "i_ino %lu, req->pr_entry_nr %llu\n",
+ inode->i_ino, req->pr_entry_nr);
+
group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
desc_kaddr = kmap(req->pr_desc_bh->b_page);
desc = nilfs_palloc_block_get_group_desc(inode, group,
@@ -588,6 +668,10 @@ int nilfs_palloc_prepare_free_entry(struct inode *inode,
unsigned long group, group_offset;
int ret;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM | DBG_DUMP_STACK),
+ "i_ino %lu, req->pr_entry_nr %llu\n",
+ inode->i_ino, req->pr_entry_nr);
+
group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
ret = nilfs_palloc_get_desc_block(inode, group, 1, &desc_bh);
if (ret < 0)
@@ -611,6 +695,10 @@ int nilfs_palloc_prepare_free_entry(struct inode *inode,
void nilfs_palloc_abort_free_entry(struct inode *inode,
struct nilfs_palloc_req *req)
{
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM | DBG_DUMP_STACK),
+ "i_ino %lu, req->pr_entry_nr %llu\n",
+ inode->i_ino, req->pr_entry_nr);
+
brelse(req->pr_bitmap_bh);
brelse(req->pr_desc_bh);
@@ -630,6 +718,10 @@ nilfs_palloc_group_is_in(struct inode *inode, unsigned long group, __u64 nr)
{
__u64 first, last;
+ nilfs2_debug((DBG_ALLOC | DBG_SPAM),
+ "i_ino %lu, group %lu, nr %llu\n",
+ inode->i_ino, group, nr);
+
first = group * nilfs_palloc_entries_per_group(inode);
last = first + nilfs_palloc_entries_per_group(inode) - 1;
return (nr >= first) && (nr <= last);
diff --git a/fs/nilfs2/btree.c b/fs/nilfs2/btree.c
index c4af24a..9116be3 100644
--- a/fs/nilfs2/btree.c
+++ b/fs/nilfs2/btree.c
@@ -72,6 +72,10 @@ static int nilfs_btree_get_new_block(const struct nilfs_bmap *btree,
struct address_space *btnc = &NILFS_BMAP_I(btree)->i_btnode_cache;
struct buffer_head *bh;
+ nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, ptr %llu\n",
+ btnc->host->i_ino, ptr);
+
bh = nilfs_btnode_create_block(btnc, ptr);
if (!bh)
return -ENOMEM;
@@ -477,6 +481,10 @@ static int __nilfs_btree_get_block(const struct nilfs_bmap *btree, __u64 ptr,
sector_t submit_ptr = 0;
int ret;
+ nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM),
+ "btree ino %lu, ptr %llu, bhp %p, ra %p\n",
+ btree->b_inode->i_ino, ptr, bhp, ra);
+
ret = nilfs_btnode_submit_block(btnc, ptr, 0, READ, &bh, &submit_ptr);
if (ret) {
if (ret != -EEXIST)
@@ -758,6 +766,10 @@ static void nilfs_btree_promote_key(struct nilfs_bmap *btree,
struct nilfs_btree_path *path,
int level, __u64 key)
{
+ nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM),
+ "btree ino %lu, level %d, key %llu\n",
+ btree->b_inode->i_ino, level, key);
+
if (level < nilfs_btree_height(btree) - 1) {
do {
nilfs_btree_node_set_key(
@@ -1006,6 +1018,9 @@ static __u64 nilfs_btree_find_near(const struct nilfs_bmap *btree,
struct nilfs_btree_node *node;
int level, ncmax;
+ nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM),
+ "btree ino %lu\n", btree->b_inode->i_ino);
+
if (path == NULL)
return NILFS_BMAP_INVALID_PTR;
@@ -1035,6 +1050,10 @@ static __u64 nilfs_btree_find_target_v(const struct nilfs_bmap *btree,
{
__u64 ptr;
+ nilfs2_debug((DBG_BTREE | DBG_DUMP_STACK | DBG_SPAM),
+ "btree ino %lu, key %llu\n",
+ btree->b_inode->i_ino, key);
+
ptr = nilfs_bmap_find_target_seq(btree, key);
if (ptr != NILFS_BMAP_INVALID_PTR)
/* sequential access */
diff --git a/fs/nilfs2/dat.c b/fs/nilfs2/dat.c
index db987db..4b7875e 100644
--- a/fs/nilfs2/dat.c
+++ b/fs/nilfs2/dat.c
@@ -53,6 +53,10 @@ static inline struct nilfs_dat_info *NILFS_DAT_I(struct inode *dat)
static int nilfs_dat_prepare_entry(struct inode *dat,
struct nilfs_palloc_req *req, int create)
{
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu, create %d\n",
+ dat->i_ino, req->pr_entry_nr, create);
+
return nilfs_palloc_get_entry_block(dat, req->pr_entry_nr,
create, &req->pr_entry_bh);
}
@@ -60,6 +64,10 @@ static int nilfs_dat_prepare_entry(struct inode *dat,
static void nilfs_dat_commit_entry(struct inode *dat,
struct nilfs_palloc_req *req)
{
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu\n",
+ dat->i_ino, req->pr_entry_nr);
+
mark_buffer_dirty(req->pr_entry_bh);
nilfs_mdt_mark_dirty(dat);
brelse(req->pr_entry_bh);
@@ -68,6 +76,10 @@ static void nilfs_dat_commit_entry(struct inode *dat,
static void nilfs_dat_abort_entry(struct inode *dat,
struct nilfs_palloc_req *req)
{
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu\n",
+ dat->i_ino, req->pr_entry_nr);
+
brelse(req->pr_entry_bh);
}
@@ -75,6 +87,10 @@ int nilfs_dat_prepare_alloc(struct inode *dat, struct nilfs_palloc_req *req)
{
int ret;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu\n",
+ dat->i_ino, req->pr_entry_nr);
+
ret = nilfs_palloc_prepare_alloc_entry(dat, req);
if (ret < 0)
return ret;
@@ -91,6 +107,10 @@ void nilfs_dat_commit_alloc(struct inode *dat, struct nilfs_palloc_req *req)
struct nilfs_dat_entry *entry;
void *kaddr;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu\n",
+ dat->i_ino, req->pr_entry_nr);
+
kaddr = kmap_atomic(req->pr_entry_bh->b_page);
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
req->pr_entry_bh, kaddr);
@@ -105,6 +125,10 @@ void nilfs_dat_commit_alloc(struct inode *dat, struct nilfs_palloc_req *req)
void nilfs_dat_abort_alloc(struct inode *dat, struct nilfs_palloc_req *req)
{
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu\n",
+ dat->i_ino, req->pr_entry_nr);
+
nilfs_dat_abort_entry(dat, req);
nilfs_palloc_abort_alloc_entry(dat, req);
}
@@ -115,6 +139,10 @@ static void nilfs_dat_commit_free(struct inode *dat,
struct nilfs_dat_entry *entry;
void *kaddr;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu\n",
+ dat->i_ino, req->pr_entry_nr);
+
kaddr = kmap_atomic(req->pr_entry_bh->b_page);
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
req->pr_entry_bh, kaddr);
@@ -131,6 +159,10 @@ int nilfs_dat_prepare_start(struct inode *dat, struct nilfs_palloc_req *req)
{
int ret;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu\n",
+ dat->i_ino, req->pr_entry_nr);
+
ret = nilfs_dat_prepare_entry(dat, req, 0);
WARN_ON(ret == -ENOENT);
return ret;
@@ -142,6 +174,10 @@ void nilfs_dat_commit_start(struct inode *dat, struct nilfs_palloc_req *req,
struct nilfs_dat_entry *entry;
void *kaddr;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu, blocknr %lu\n",
+ dat->i_ino, req->pr_entry_nr, blocknr);
+
kaddr = kmap_atomic(req->pr_entry_bh->b_page);
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
req->pr_entry_bh, kaddr);
@@ -160,6 +196,10 @@ int nilfs_dat_prepare_end(struct inode *dat, struct nilfs_palloc_req *req)
void *kaddr;
int ret;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu\n",
+ dat->i_ino, req->pr_entry_nr);
+
ret = nilfs_dat_prepare_entry(dat, req, 0);
if (ret < 0) {
WARN_ON(ret == -ENOENT);
@@ -192,6 +232,10 @@ void nilfs_dat_commit_end(struct inode *dat, struct nilfs_palloc_req *req,
sector_t blocknr;
void *kaddr;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu, dead %d\n",
+ dat->i_ino, req->pr_entry_nr, dead);
+
kaddr = kmap_atomic(req->pr_entry_bh->b_page);
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
req->pr_entry_bh, kaddr);
@@ -217,6 +261,10 @@ void nilfs_dat_abort_end(struct inode *dat, struct nilfs_palloc_req *req)
sector_t blocknr;
void *kaddr;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, pr_entry_nr %llu\n",
+ dat->i_ino, req->pr_entry_nr);
+
kaddr = kmap_atomic(req->pr_entry_bh->b_page);
entry = nilfs_palloc_block_get_entry(dat, req->pr_entry_nr,
req->pr_entry_bh, kaddr);
@@ -235,6 +283,10 @@ int nilfs_dat_prepare_update(struct inode *dat,
{
int ret;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, old pr_entry_nr %llu, new pr_entry_nr %llu\n",
+ dat->i_ino, oldreq->pr_entry_nr, newreq->pr_entry_nr);
+
ret = nilfs_dat_prepare_end(dat, oldreq);
if (!ret) {
ret = nilfs_dat_prepare_alloc(dat, newreq);
@@ -248,6 +300,11 @@ void nilfs_dat_commit_update(struct inode *dat,
struct nilfs_palloc_req *oldreq,
struct nilfs_palloc_req *newreq, int dead)
{
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, old pr_entry_nr %llu, "
+ "new pr_entry_nr %llu, dead %d\n",
+ dat->i_ino, oldreq->pr_entry_nr, newreq->pr_entry_nr, dead);
+
nilfs_dat_commit_end(dat, oldreq, dead);
nilfs_dat_commit_alloc(dat, newreq);
}
@@ -256,6 +313,10 @@ void nilfs_dat_abort_update(struct inode *dat,
struct nilfs_palloc_req *oldreq,
struct nilfs_palloc_req *newreq)
{
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, old pr_entry_nr %llu, new pr_entry_nr %llu\n",
+ dat->i_ino, oldreq->pr_entry_nr, newreq->pr_entry_nr);
+
nilfs_dat_abort_end(dat, oldreq);
nilfs_dat_abort_alloc(dat, newreq);
}
@@ -279,6 +340,10 @@ int nilfs_dat_mark_dirty(struct inode *dat, __u64 vblocknr)
struct nilfs_palloc_req req;
int ret;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, vblocknr %llu\n",
+ dat->i_ino, vblocknr);
+
req.pr_entry_nr = vblocknr;
ret = nilfs_dat_prepare_entry(dat, &req, 0);
if (ret == 0)
@@ -336,6 +401,10 @@ int nilfs_dat_move(struct inode *dat, __u64 vblocknr, sector_t blocknr)
void *kaddr;
int ret;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, vblocknr %llu, blocknr %lu\n",
+ dat->i_ino, vblocknr, blocknr);
+
ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
if (ret < 0)
return ret;
@@ -406,6 +475,10 @@ int nilfs_dat_translate(struct inode *dat, __u64 vblocknr, sector_t *blocknrp)
void *kaddr;
int ret;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, vblocknr %llu, blocknrp %p\n",
+ dat->i_ino, vblocknr, blocknrp);
+
ret = nilfs_palloc_get_entry_block(dat, vblocknr, 0, &entry_bh);
if (ret < 0)
return ret;
@@ -445,6 +518,10 @@ ssize_t nilfs_dat_get_vinfo(struct inode *dat, void *buf, unsigned visz,
unsigned long entries_per_block = NILFS_MDT(dat)->mi_entries_per_block;
int i, j, n, ret;
+ nilfs2_debug((DBG_DAT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, buf %p, visz %u, nvi %zu\n",
+ dat->i_ino, buf, visz, nvi);
+
for (i = 0; i < nvi; i += n) {
ret = nilfs_palloc_get_entry_block(dat, vinfo->vi_vblocknr,
0, &entry_bh);
diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index 9fc053c..7a5f449 100644
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -57,6 +57,9 @@ static inline unsigned nilfs_chunk_size(struct inode *inode)
static inline void nilfs_put_page(struct page *page)
{
+ nilfs2_debug((DBG_DIR | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu\n", page->mapping->host->i_ino);
+
kunmap(page);
page_cache_release(page);
}
@@ -74,15 +77,26 @@ static unsigned nilfs_last_byte(struct inode *inode, unsigned long page_nr)
{
unsigned last_byte = inode->i_size;
+ nilfs2_debug((DBG_DIR | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, page_nr %lu\n", inode->i_ino, page_nr);
+
last_byte -= page_nr << PAGE_CACHE_SHIFT;
if (last_byte > PAGE_CACHE_SIZE)
last_byte = PAGE_CACHE_SIZE;
+
+ nilfs2_debug((DBG_DIR | DBG_SPAM), "last_byte %u\n", last_byte);
+
return last_byte;
}
static int nilfs_prepare_chunk(struct page *page, unsigned from, unsigned to)
{
loff_t pos = page_offset(page) + from;
+
+ nilfs2_debug((DBG_DIR | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, from %u, to %u\n",
+ page->mapping->host->i_ino, from, to);
+
return __block_write_begin(page, pos, to - from, nilfs_get_block);
}
@@ -96,6 +110,10 @@ static void nilfs_commit_chunk(struct page *page,
unsigned nr_dirty, copied;
int err;
+ nilfs2_debug((DBG_DIR | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, from %u, to %u\n",
+ dir->i_ino, from, to);
+
nr_dirty = nilfs_page_count_clean_buffers(page, from, to);
copied = block_write_end(NULL, mapping, pos, len, len, page, NULL);
if (pos + copied > dir->i_size)
@@ -118,6 +136,9 @@ static void nilfs_check_page(struct page *page)
struct nilfs_dir_entry *p;
char *error;
+ nilfs2_debug((DBG_DIR | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu\n", page->mapping->host->i_ino);
+
if ((dir->i_size >> PAGE_CACHE_SHIFT) == page->index) {
limit = dir->i_size & ~PAGE_CACHE_MASK;
if (limit & (chunk_size - 1))
@@ -187,6 +208,9 @@ static struct page *nilfs_get_page(struct inode *dir, unsigned long n)
struct address_space *mapping = dir->i_mapping;
struct page *page = read_mapping_page(mapping, n, NULL);
+ nilfs2_debug((DBG_DIR | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, n %lu\n", dir->i_ino, n);
+
if (!IS_ERR(page)) {
kmap(page);
if (!PageChecked(page))
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index 26e78f2..ca594f2 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -160,6 +160,12 @@ int nilfs_get_block(struct inode *inode, sector_t blkoff,
*/
static int nilfs_readpage(struct file *file, struct page *page)
{
+ nilfs2_debug((DBG_INODE | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, i_size %llu, offset %llu\n",
+ page->mapping->host->i_ino,
+ i_size_read(page->mapping->host),
+ page_offset(page));
+
return mpage_readpage(page, nilfs_get_block);
}
@@ -174,6 +180,12 @@ static int nilfs_readpage(struct file *file, struct page *page)
static int nilfs_readpages(struct file *file, struct address_space *mapping,
struct list_head *pages, unsigned nr_pages)
{
+ nilfs2_debug((DBG_INODE | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, i_size %llu, nr_pages %u\n",
+ mapping->host->i_ino,
+ i_size_read(mapping->host),
+ nr_pages);
+
return mpage_readpages(mapping, pages, nr_pages, nilfs_get_block);
}
@@ -183,6 +195,12 @@ static int nilfs_writepages(struct address_space *mapping,
struct inode *inode = mapping->host;
int err = 0;
+ nilfs2_debug((DBG_INODE | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, i_size %llu, nr_to_write %lu\n",
+ mapping->host->i_ino,
+ i_size_read(mapping->host),
+ wbc->nr_to_write);
+
if (inode->i_sb->s_flags & MS_RDONLY) {
nilfs_clear_dirty_pages(mapping, false);
return -EROFS;
@@ -200,6 +218,12 @@ static int nilfs_writepage(struct page *page, struct writeback_control *wbc)
struct inode *inode = page->mapping->host;
int err;
+ nilfs2_debug((DBG_INODE | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, i_size %llu, start %llu, end %llu\n",
+ page->mapping->host->i_ino,
+ i_size_read(page->mapping->host),
+ wbc->range_start, wbc->range_end);
+
if (inode->i_sb->s_flags & MS_RDONLY) {
/*
* It means that filesystem was remounted in read-only
diff --git a/fs/nilfs2/mdt.c b/fs/nilfs2/mdt.c
index 292b43e..bcd188d 100644
--- a/fs/nilfs2/mdt.c
+++ b/fs/nilfs2/mdt.c
@@ -427,6 +427,10 @@ nilfs_mdt_write_page(struct page *page, struct writeback_control *wbc)
if (!inode)
return 0;
+ nilfs2_debug((DBG_MDT | DBG_DUMP_STACK | DBG_SPAM),
+ "i_ino %lu, offset %llu\n",
+ inode->i_ino, page_offset(page));
+
sb = inode->i_sb;
if (wbc->sync_mode == WB_SYNC_ALL)
diff --git a/fs/nilfs2/segbuf.c b/fs/nilfs2/segbuf.c
index 2d4c5e0..10e7b38 100644
--- a/fs/nilfs2/segbuf.c
+++ b/fs/nilfs2/segbuf.c
@@ -373,6 +373,10 @@ static void nilfs_end_bio_write(struct bio *bio, int err)
const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
struct nilfs_segment_buffer *segbuf = bio->bi_private;
+ nilfs2_debug((DBG_SEGBUF | DBG_DUMP_STACK | DBG_SPAM),
+ "sb_segnum %llu, sb_pseg_start %lu, err %d\n",
+ segbuf->sb_segnum, segbuf->sb_pseg_start, err);
+
if (err == -EOPNOTSUPP) {
set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
bio_put(bio);
@@ -392,6 +396,12 @@ static int nilfs_segbuf_submit_bio(struct nilfs_segment_buffer *segbuf,
struct bio *bio = wi->bio;
int err;
+ nilfs2_debug((DBG_SEGBUF | DBG_DUMP_STACK | DBG_SPAM),
+ "sb_segnum %llu, sb_pseg_start %lu, "
+ "blocknr %lu, mode %#x\n",
+ segbuf->sb_segnum, segbuf->sb_pseg_start,
+ wi->blocknr, mode);
+
if (segbuf->sb_nbio > 0 &&
bdi_write_congested(segbuf->sb_super->s_bdi)) {
wait_for_completion(&segbuf->sb_bio_event);
@@ -440,6 +450,10 @@ static struct bio *nilfs_alloc_seg_bio(struct the_nilfs *nilfs, sector_t start,
{
struct bio *bio;
+ nilfs2_debug((DBG_SEGBUF | DBG_DUMP_STACK | DBG_SPAM),
+ "nilfs %p, start %lu, nr_vecs %d\n",
+ nilfs, start, nr_vecs);
+
bio = bio_alloc(GFP_NOIO, nr_vecs);
if (bio == NULL) {
while (!bio && (nr_vecs >>= 1))
@@ -469,6 +483,12 @@ static int nilfs_segbuf_submit_bh(struct nilfs_segment_buffer *segbuf,
{
int len, err;
+ nilfs2_debug((DBG_SEGBUF | DBG_DUMP_STACK | DBG_SPAM),
+ "sb_segnum %llu, sb_pseg_start %lu, "
+ "blocknr %lu, mode %#x\n",
+ segbuf->sb_segnum, segbuf->sb_pseg_start,
+ wi->blocknr, mode);
+
BUG_ON(wi->nr_vecs <= 0);
repeat:
if (!wi->bio) {
@@ -510,6 +530,10 @@ static int nilfs_segbuf_write(struct nilfs_segment_buffer *segbuf,
struct buffer_head *bh;
int res = 0, rw = WRITE;
+ nilfs2_debug((DBG_SEGBUF | DBG_DUMP_STACK | DBG_SPAM),
+ "sb_segnum %llu, sb_pseg_start %lu, nilfs %p\n",
+ segbuf->sb_segnum, segbuf->sb_pseg_start, nilfs);
+
wi.nilfs = nilfs;
nilfs_segbuf_prepare_write(segbuf, &wi);
@@ -551,6 +575,10 @@ static int nilfs_segbuf_wait(struct nilfs_segment_buffer *segbuf)
{
int err = 0;
+ nilfs2_debug((DBG_SEGBUF | DBG_DUMP_STACK | DBG_SPAM),
+ "sb_segnum %llu, sb_pseg_start %lu\n",
+ segbuf->sb_segnum, segbuf->sb_pseg_start);
+
if (!segbuf->sb_nbio)
return 0;
--
1.7.9.5
--
To unsubscribe from this list: send the line "unsubscribe linux-nilfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
