Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ryusuke/nilfs2

(*) == default

nobarrier		Disables barriers.

errors=continue(*)	Keep going on a filesystem error.

errors=remount-ro	Remount the filesystem read-only on an error.

errors=continue		Keep going on a filesystem error.

errors=remount-ro(*)	Remount the filesystem read-only on an error.

errors=panic		Panic and halt the machine if an error occurs.

cp=n			Specify the checkpoint-number of the snapshot to be

			mounted.  Checkpoints and snapshots are listed by lscp

#include "alloc.h"

/**

 * nilfs_palloc_groups_per_desc_block - get the number of groups that a group

 *					descriptor block can maintain

 * @inode: inode of metadata file using this allocator

 */

static inline unsigned long

nilfs_palloc_groups_per_desc_block(const struct inode *inode)

{

		sizeof(struct nilfs_palloc_group_desc);

}

/**

 * nilfs_palloc_groups_count - get maximum number of groups

 * @inode: inode of metadata file using this allocator

 */

static inline unsigned long

nilfs_palloc_groups_count(const struct inode *inode)

{

	return 1UL << (BITS_PER_LONG - (inode->i_blkbits + 3 /* log2(8) */));

}

/**

 * nilfs_palloc_init_blockgroup - initialize private variables for allocator

 * @inode: inode of metadata file using this allocator

 * @entry_size: size of the persistent object

 */

int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned entry_size)

{

	struct nilfs_mdt_info *mi = NILFS_MDT(inode);

	return 0;

}

/**

 * nilfs_palloc_group - get group number and offset from an entry number

 * @inode: inode of metadata file using this allocator

 * @nr: serial number of the entry (e.g. inode number)

 * @offset: pointer to store offset number in the group

 */

static unsigned long nilfs_palloc_group(const struct inode *inode, __u64 nr,

					unsigned long *offset)

{

	return group;

}

/**

 * nilfs_palloc_desc_blkoff - get block offset of a group descriptor block

 * @inode: inode of metadata file using this allocator

 * @group: group number

 *

 * nilfs_palloc_desc_blkoff() returns block offset of the descriptor

 * block which contains a descriptor of the specified group.

 */

static unsigned long

nilfs_palloc_desc_blkoff(const struct inode *inode, unsigned long group)

{

	return desc_block * NILFS_MDT(inode)->mi_blocks_per_desc_block;

}

/**

 * nilfs_palloc_bitmap_blkoff - get block offset of a bitmap block

 * @inode: inode of metadata file using this allocator

 * @group: group number

 *

 * nilfs_palloc_bitmap_blkoff() returns block offset of the bitmap

 * block used to allocate/deallocate entries in the specified group.

 */

static unsigned long

nilfs_palloc_bitmap_blkoff(const struct inode *inode, unsigned long group)

{

		desc_offset * NILFS_MDT(inode)->mi_blocks_per_group;

}

/**

 * nilfs_palloc_group_desc_nfrees - get the number of free entries in a group

 * @inode: inode of metadata file using this allocator

 * @group: group number

 * @desc: pointer to descriptor structure for the group

 */

static unsigned long

nilfs_palloc_group_desc_nfrees(struct inode *inode, unsigned long group,

			       const struct nilfs_palloc_group_desc *desc)

	return nfree;

}

/**

 * nilfs_palloc_group_desc_add_entries - adjust count of free entries

 * @inode: inode of metadata file using this allocator

 * @group: group number

 * @desc: pointer to descriptor structure for the group

 * @n: delta to be added

 */

static void

nilfs_palloc_group_desc_add_entries(struct inode *inode,

				    unsigned long group,

	spin_unlock(nilfs_mdt_bgl_lock(inode, group));

}

/**

 * nilfs_palloc_entry_blkoff - get block offset of an entry block

 * @inode: inode of metadata file using this allocator

 * @nr: serial number of the entry (e.g. inode number)

 */

static unsigned long

nilfs_palloc_entry_blkoff(const struct inode *inode, __u64 nr)

{

		group_offset / NILFS_MDT(inode)->mi_entries_per_block;

}

/**

 * nilfs_palloc_desc_block_init - initialize buffer of a group descriptor block

 * @inode: inode of metadata file

 * @bh: buffer head of the buffer to be initialized

 * @kaddr: kernel address mapped for the page including the buffer

 */

static void nilfs_palloc_desc_block_init(struct inode *inode,

					 struct buffer_head *bh, void *kaddr)

{

	return ret;

}

/**

 * nilfs_palloc_get_desc_block - get buffer head of a group descriptor block

 * @inode: inode of metadata file using this allocator

 * @group: group number

 * @create: create flag

 * @bhp: pointer to store the resultant buffer head

 */

static int nilfs_palloc_get_desc_block(struct inode *inode,

				       unsigned long group,

				       int create, struct buffer_head **bhp)

				      bhp, &cache->prev_desc, &cache->lock);

}

/**

 * nilfs_palloc_get_bitmap_block - get buffer head of a bitmap block

 * @inode: inode of metadata file using this allocator

 * @group: group number

 * @create: create flag

 * @bhp: pointer to store the resultant buffer head

 */

static int nilfs_palloc_get_bitmap_block(struct inode *inode,

					 unsigned long group,

					 int create, struct buffer_head **bhp)

				      &cache->prev_bitmap, &cache->lock);

}

/**

 * nilfs_palloc_get_entry_block - get buffer head of an entry block

 * @inode: inode of metadata file using this allocator

 * @nr: serial number of the entry (e.g. inode number)

 * @create: create flag

 * @bhp: pointer to store the resultant buffer head

 */

int nilfs_palloc_get_entry_block(struct inode *inode, __u64 nr,

				 int create, struct buffer_head **bhp)

{

				      &cache->prev_entry, &cache->lock);

}

/**

 * nilfs_palloc_block_get_group_desc - get kernel address of a group descriptor

 * @inode: inode of metadata file using this allocator

 * @group: group number

 * @bh: buffer head of the buffer storing the group descriptor block

 * @kaddr: kernel address mapped for the page including the buffer

 */

static struct nilfs_palloc_group_desc *

nilfs_palloc_block_get_group_desc(const struct inode *inode,

				  unsigned long group,

		group % nilfs_palloc_groups_per_desc_block(inode);

}

/**

 * nilfs_palloc_block_get_entry - get kernel address of an entry

 * @inode: inode of metadata file using this allocator

 * @nr: serial number of the entry (e.g. inode number)

 * @bh: buffer head of the buffer storing the entry block

 * @kaddr: kernel address mapped for the page including the buffer

 */

void *nilfs_palloc_block_get_entry(const struct inode *inode, __u64 nr,

				   const struct buffer_head *bh, void *kaddr)

{

		entry_offset * NILFS_MDT(inode)->mi_entry_size;

}

/**

 * nilfs_palloc_find_available_slot - find available slot in a group

 * @inode: inode of metadata file using this allocator

 * @group: group number

 * @target: offset number of an entry in the group (start point)

 * @bitmap: bitmap of the group

 * @bsize: size in bits

 */

static int nilfs_palloc_find_available_slot(struct inode *inode,

					    unsigned long group,

					    unsigned long target,

					    unsigned char *bitmap,

					    int bsize)  /* size in bits */

					    int bsize)

{

	int curr, pos, end, i;

	return -ENOSPC;

}

/**

 * nilfs_palloc_rest_groups_in_desc_block - get the remaining number of groups

 *					    in a group descriptor block

 * @inode: inode of metadata file using this allocator

 * @curr: current group number

 * @max: maximum number of groups

 */

static unsigned long

nilfs_palloc_rest_groups_in_desc_block(const struct inode *inode,

				       unsigned long curr, unsigned long max)

		     max - curr + 1);

}

/**

 * nilfs_palloc_prepare_alloc_entry - prepare to allocate a persistent object

 * @inode: inode of metadata file using this allocator

 * @req: nilfs_palloc_req structure exchanged for the allocation

 */

int nilfs_palloc_prepare_alloc_entry(struct inode *inode,

				     struct nilfs_palloc_req *req)

{

	return ret;

}

/**

 * nilfs_palloc_commit_alloc_entry - finish allocation of a persistent object

 * @inode: inode of metadata file using this allocator

 * @req: nilfs_palloc_req structure exchanged for the allocation

 */

void nilfs_palloc_commit_alloc_entry(struct inode *inode,

				     struct nilfs_palloc_req *req)

{

	brelse(req->pr_desc_bh);

}

/**

 * nilfs_palloc_commit_free_entry - finish deallocating a persistent object

 * @inode: inode of metadata file using this allocator

 * @req: nilfs_palloc_req structure exchanged for the removal

 */

void nilfs_palloc_commit_free_entry(struct inode *inode,

				    struct nilfs_palloc_req *req)

{

	brelse(req->pr_desc_bh);

}

/**

 * nilfs_palloc_abort_alloc_entry - cancel allocation of a persistent object

 * @inode: inode of metadata file using this allocator

 * @req: nilfs_palloc_req structure exchanged for the allocation

 */

void nilfs_palloc_abort_alloc_entry(struct inode *inode,

				    struct nilfs_palloc_req *req)

{

	req->pr_desc_bh = NULL;

}

/**

 * nilfs_palloc_prepare_free_entry - prepare to deallocate a persistent object

 * @inode: inode of metadata file using this allocator

 * @req: nilfs_palloc_req structure exchanged for the removal

 */

int nilfs_palloc_prepare_free_entry(struct inode *inode,

				    struct nilfs_palloc_req *req)

{

	return 0;

}

/**

 * nilfs_palloc_abort_free_entry - cancel deallocating a persistent object

 * @inode: inode of metadata file using this allocator

 * @req: nilfs_palloc_req structure exchanged for the removal

 */

void nilfs_palloc_abort_free_entry(struct inode *inode,

				   struct nilfs_palloc_req *req)

{

	req->pr_desc_bh = NULL;

}

/**

 * nilfs_palloc_group_is_in - judge if an entry is in a group

 * @inode: inode of metadata file using this allocator

 * @group: group number

 * @nr: serial number of the entry (e.g. inode number)

 */

static int

nilfs_palloc_group_is_in(struct inode *inode, unsigned long group, __u64 nr)

{

	return (nr >= first) && (nr <= last);

}

/**

 * nilfs_palloc_freev - deallocate a set of persistent objects

 * @inode: inode of metadata file using this allocator

 * @entry_nrs: array of entry numbers to be deallocated

 * @nitems: number of entries stored in @entry_nrs

 */

int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)

{

	struct buffer_head *desc_bh, *bitmap_bh;

#include <linux/buffer_head.h>

#include <linux/fs.h>

/**

 * nilfs_palloc_entries_per_group - get the number of entries per group

 * @inode: inode of metadata file using this allocator

 *

 * The number of entries per group is defined by the number of bits

 * that a bitmap block can maintain.

 */

static inline unsigned long

nilfs_palloc_entries_per_group(const struct inode *inode)

{

#include "alloc.h"

#include "dat.h"

/**

 * struct nilfs_btree_path - A path on which B-tree operations are executed

 * @bp_bh: buffer head of node block

 * @bp_sib_bh: buffer head of sibling node block

 * @bp_index: index of child node

 * @bp_oldreq: ptr end request for old ptr

 * @bp_newreq: ptr alloc request for new ptr

 * @bp_op: rebalance operation

 */

struct nilfs_btree_path {

	struct buffer_head *bp_bh;

	struct buffer_head *bp_sib_bh;

	int bp_index;

	union nilfs_bmap_ptr_req bp_oldreq;

	union nilfs_bmap_ptr_req bp_newreq;

	struct nilfs_btnode_chkey_ctxt bp_ctxt;

	void (*bp_op)(struct nilfs_btree *, struct nilfs_btree_path *,

		      int, __u64 *, __u64 *);

};

/*

 * B-tree path operations

 */

static struct kmem_cache *nilfs_btree_path_cache;

int __init nilfs_btree_path_cache_init(void)

{

	nilfs_btree_path_cache =

		kmem_cache_create("nilfs2_btree_path_cache",

				  sizeof(struct nilfs_btree_path) *

				  NILFS_BTREE_LEVEL_MAX, 0, 0, NULL);

	return (nilfs_btree_path_cache != NULL) ? 0 : -ENOMEM;

}

void nilfs_btree_path_cache_destroy(void)

{

	kmem_cache_destroy(nilfs_btree_path_cache);

}

static inline struct nilfs_btree_path *nilfs_btree_alloc_path(void)

{

	return kmem_cache_alloc(nilfs_btree_path_cache, GFP_NOFS);

}

static inline void nilfs_btree_free_path(struct nilfs_btree_path *path)

static struct nilfs_btree_path *nilfs_btree_alloc_path(void)

{

	kmem_cache_free(nilfs_btree_path_cache, path);

}

	struct nilfs_btree_path *path;

	int level = NILFS_BTREE_LEVEL_DATA;

static void nilfs_btree_init_path(struct nilfs_btree_path *path)

{

	int level;

	path = kmem_cache_alloc(nilfs_btree_path_cache, GFP_NOFS);

	if (path == NULL)

		goto out;

	for (level = NILFS_BTREE_LEVEL_DATA;

	     level < NILFS_BTREE_LEVEL_MAX;

	     level++) {

	for (; level < NILFS_BTREE_LEVEL_MAX; level++) {

		path[level].bp_bh = NULL;

		path[level].bp_sib_bh = NULL;

		path[level].bp_index = 0;

		path[level].bp_newreq.bpr_ptr = NILFS_BMAP_INVALID_PTR;

		path[level].bp_op = NULL;

	}

out:

	return path;

}

static void nilfs_btree_release_path(struct nilfs_btree_path *path)

static void nilfs_btree_free_path(struct nilfs_btree_path *path)

{

	int level;

	int level = NILFS_BTREE_LEVEL_DATA;

	for (level = NILFS_BTREE_LEVEL_DATA; level < NILFS_BTREE_LEVEL_MAX;

	     level++)

	for (; level < NILFS_BTREE_LEVEL_MAX; level++)

		brelse(path[level].bp_bh);

	kmem_cache_free(nilfs_btree_path_cache, path);

}

/*

	path = nilfs_btree_alloc_path();

	if (path == NULL)

		return -ENOMEM;

	nilfs_btree_init_path(path);

	ret = nilfs_btree_do_lookup(btree, path, key, &ptr, level);

	if (ptrp != NULL)

		*ptrp = ptr;

	nilfs_btree_release_path(path);

	nilfs_btree_free_path(path);

	return ret;

	path = nilfs_btree_alloc_path();

	if (path == NULL)

		return -ENOMEM;

	nilfs_btree_init_path(path);

	ret = nilfs_btree_do_lookup(btree, path, key, &ptr, level);

	if (ret < 0)

		goto out;

	*ptrp = ptr;

	ret = cnt;

 out:

	nilfs_btree_release_path(path);

	nilfs_btree_free_path(path);

	return ret;

}

	path = nilfs_btree_alloc_path();

	if (path == NULL)

		return -ENOMEM;

	nilfs_btree_init_path(path);

	ret = nilfs_btree_do_lookup(btree, path, key, NULL,

				    NILFS_BTREE_LEVEL_NODE_MIN);

	nilfs_bmap_add_blocks(bmap, stats.bs_nblocks);

 out:

	nilfs_btree_release_path(path);

	nilfs_btree_free_path(path);

	return ret;

}

	path = nilfs_btree_alloc_path();

	if (path == NULL)

		return -ENOMEM;

	nilfs_btree_init_path(path);

	ret = nilfs_btree_do_lookup(btree, path, key, NULL,

				    NILFS_BTREE_LEVEL_NODE_MIN);

	if (ret < 0)

	nilfs_bmap_sub_blocks(bmap, stats.bs_nblocks);

out:

	nilfs_btree_release_path(path);

	nilfs_btree_free_path(path);

	return ret;

}

	path = nilfs_btree_alloc_path();

	if (path == NULL)

		return -ENOMEM;

	nilfs_btree_init_path(path);

	ret = nilfs_btree_do_lookup_last(btree, path, keyp, NULL);

	nilfs_btree_release_path(path);

	nilfs_btree_free_path(path);

	return ret;

	path = nilfs_btree_alloc_path();

	if (path == NULL)

		return -ENOMEM;

	nilfs_btree_init_path(path);

	if (buffer_nilfs_node(bh)) {

		node = (struct nilfs_btree_node *)bh->b_data;

		nilfs_btree_propagate_p(btree, path, level, bh);

 out:

	nilfs_btree_release_path(path);

	nilfs_btree_free_path(path);

	return ret;

	path = nilfs_btree_alloc_path();

	if (path == NULL)

		return -ENOMEM;

	nilfs_btree_init_path(path);

	if (buffer_nilfs_node(*bh)) {

		node = (struct nilfs_btree_node *)(*bh)->b_data;

		nilfs_btree_assign_p(btree, path, level, bh, blocknr, binfo);

 out:

	nilfs_btree_release_path(path);

	nilfs_btree_free_path(path);

	return ret;

	path = nilfs_btree_alloc_path();

	if (path == NULL)

		return -ENOMEM;

	nilfs_btree_init_path(path);

	ret = nilfs_btree_do_lookup(btree, path, key, &ptr, level + 1);

	if (ret < 0) {

		nilfs_bmap_set_dirty(&btree->bt_bmap);

 out:

	nilfs_btree_release_path(path);

	nilfs_btree_free_path(path);

	return ret;

}

#include "btnode.h"

#include "bmap.h"

struct nilfs_btree;

struct nilfs_btree_path;

/**

 * struct nilfs_btree - B-tree structure

 * @bt_bmap: bmap base structure

	struct nilfs_bmap bt_bmap;

};

/**

 * struct nilfs_btree_path - A path on which B-tree operations are executed

 * @bp_bh: buffer head of node block

 * @bp_sib_bh: buffer head of sibling node block

 * @bp_index: index of child node

 * @bp_oldreq: ptr end request for old ptr

 * @bp_newreq: ptr alloc request for new ptr

 * @bp_op: rebalance operation

 */

struct nilfs_btree_path {

	struct buffer_head *bp_bh;

	struct buffer_head *bp_sib_bh;

	int bp_index;

	union nilfs_bmap_ptr_req bp_oldreq;

	union nilfs_bmap_ptr_req bp_newreq;

	struct nilfs_btnode_chkey_ctxt bp_ctxt;

	void (*bp_op)(struct nilfs_btree *, struct nilfs_btree_path *,

		      int, __u64 *, __u64 *);

};

#define NILFS_BTREE_ROOT_SIZE		NILFS_BMAP_SIZE

#define NILFS_BTREE_ROOT_NCHILDREN_MAX					\

#define NILFS_BTREE_KEY_MIN	((__u64)0)

#define NILFS_BTREE_KEY_MAX	(~(__u64)0)

extern struct kmem_cache *nilfs_btree_path_cache;

int nilfs_btree_path_cache_init(void);

void nilfs_btree_path_cache_destroy(void);