ocfs2: Move directory manipulation code into dir.c (316f4b9f) · Commits · e / devices / android_kernel_teracube_2e

fs/ocfs2/dir.c

+423 −7

Original line number	Original line	Diff line number	Diff line
	@@ -55,10 +55,16 @@
	#include "journal.h"		#include "journal.h"
	#include "namei.h"		#include "namei.h"
	#include "suballoc.h"		#include "suballoc.h"
			#include "super.h"
	#include "uptodate.h"		#include "uptodate.h"

	#include "buffer_head_io.h"		#include "buffer_head_io.h"

			#define NAMEI_RA_CHUNKS 2
			#define NAMEI_RA_BLOCKS 4
			#define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
			#define NAMEI_RA_INDEX(c,b) (((c) * NAMEI_RA_BLOCKS) + (b))

	static unsigned char ocfs2_filetype_table[] = {		static unsigned char ocfs2_filetype_table[] = {
	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK		DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
	};		};
	@@ -67,6 +73,347 @@ static int ocfs2_extend_dir(struct ocfs2_super *osb,
	struct inode *dir,		struct inode *dir,
	struct buffer_head *parent_fe_bh,		struct buffer_head *parent_fe_bh,
	struct buffer_head **new_de_bh);		struct buffer_head **new_de_bh);
			static int ocfs2_do_extend_dir(struct super_block *sb,
			handle_t *handle,
			struct inode *dir,
			struct buffer_head *parent_fe_bh,
			struct ocfs2_alloc_context *data_ac,
			struct ocfs2_alloc_context *meta_ac,
			struct buffer_head **new_bh);

			int ocfs2_check_dir_entry(struct inode * dir,
			struct ocfs2_dir_entry * de,
			struct buffer_head * bh,
			unsigned long offset)
			{
			const char *error_msg = NULL;
			const int rlen = le16_to_cpu(de->rec_len);

			if (rlen < OCFS2_DIR_REC_LEN(1))
			error_msg = "rec_len is smaller than minimal";
			else if (rlen % 4 != 0)
			error_msg = "rec_len % 4 != 0";
			else if (rlen < OCFS2_DIR_REC_LEN(de->name_len))
			error_msg = "rec_len is too small for name_len";
			else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)
			error_msg = "directory entry across blocks";

			if (error_msg != NULL)
			mlog(ML_ERROR, "bad entry in directory #%llu: %s - "
			"offset=%lu, inode=%llu, rec_len=%d, name_len=%d\n",
			(unsigned long long)OCFS2_I(dir)->ip_blkno, error_msg,
			offset, (unsigned long long)le64_to_cpu(de->inode), rlen,
			de->name_len);
			return error_msg == NULL ? 1 : 0;
			}

			static inline int ocfs2_match(int len,
			const char * const name,
			struct ocfs2_dir_entry *de)
			{
			if (len != de->name_len)
			return 0;
			if (!de->inode)
			return 0;
			return !memcmp(name, de->name, len);
			}

			/*
			* Returns 0 if not found, -1 on failure, and 1 on success
			*/
			static int inline ocfs2_search_dirblock(struct buffer_head *bh,
			struct inode *dir,
			const char *name, int namelen,
			unsigned long offset,
			struct ocfs2_dir_entry **res_dir)
			{
			struct ocfs2_dir_entry *de;
			char dlimit, de_buf;
			int de_len;
			int ret = 0;

			mlog_entry_void();

			de_buf = bh->b_data;
			dlimit = de_buf + dir->i_sb->s_blocksize;

			while (de_buf < dlimit) {
			/* this code is executed quadratically often */
			/* do minimal checking `by hand' */

			de = (struct ocfs2_dir_entry *) de_buf;

			if (de_buf + namelen <= dlimit &&
			ocfs2_match(namelen, name, de)) {
			/* found a match - just to be sure, do a full check */
			if (!ocfs2_check_dir_entry(dir, de, bh, offset)) {
			ret = -1;
			goto bail;
			}
			*res_dir = de;
			ret = 1;
			goto bail;
			}

			/* prevent looping on a bad block */
			de_len = le16_to_cpu(de->rec_len);
			if (de_len <= 0) {
			ret = -1;
			goto bail;
			}

			de_buf += de_len;
			offset += de_len;
			}

			bail:
			mlog_exit(ret);
			return ret;
			}

			struct buffer_head ocfs2_find_entry(const char name, int namelen,
			struct inode *dir,
			struct ocfs2_dir_entry **res_dir)
			{
			struct super_block *sb;
			struct buffer_head *bh_use[NAMEI_RA_SIZE];
			struct buffer_head bh, ret = NULL;
			unsigned long start, block, b;
			int ra_max = 0; /* Number of bh's in the readahead
			buffer, bh_use[] */
			int ra_ptr = 0; /* Current index into readahead
			buffer */
			int num = 0;
			int nblocks, i, err;

			mlog_entry_void();

			*res_dir = NULL;
			sb = dir->i_sb;

			nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
			start = OCFS2_I(dir)->ip_dir_start_lookup;
			if (start >= nblocks)
			start = 0;
			block = start;

			restart:
			do {
			/*
			* We deal with the read-ahead logic here.
			*/
			if (ra_ptr >= ra_max) {
			/* Refill the readahead buffer */
			ra_ptr = 0;
			b = block;
			for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) {
			/*
			* Terminate if we reach the end of the
			* directory and must wrap, or if our
			* search has finished at this block.
			*/
			if (b >= nblocks \|\| (num && block == start)) {
			bh_use[ra_max] = NULL;
			break;
			}
			num++;

			bh = ocfs2_bread(dir, b++, &err, 1);
			bh_use[ra_max] = bh;
			}
			}
			if ((bh = bh_use[ra_ptr++]) == NULL)
			goto next;
			wait_on_buffer(bh);
			if (!buffer_uptodate(bh)) {
			/* read error, skip block & hope for the best */
			ocfs2_error(dir->i_sb, "reading directory %llu, "
			"offset %lu\n",
			(unsigned long long)OCFS2_I(dir)->ip_blkno,
			block);
			brelse(bh);
			goto next;
			}
			i = ocfs2_search_dirblock(bh, dir, name, namelen,
			block << sb->s_blocksize_bits,
			res_dir);
			if (i == 1) {
			OCFS2_I(dir)->ip_dir_start_lookup = block;
			ret = bh;
			goto cleanup_and_exit;
			} else {
			brelse(bh);
			if (i < 0)
			goto cleanup_and_exit;
			}
			next:
			if (++block >= nblocks)
			block = 0;
			} while (block != start);

			/*
			* If the directory has grown while we were searching, then
			* search the last part of the directory before giving up.
			*/
			block = nblocks;
			nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
			if (block < nblocks) {
			start = 0;
			goto restart;
			}

			cleanup_and_exit:
			/* Clean up the read-ahead blocks */
			for (; ra_ptr < ra_max; ra_ptr++)
			brelse(bh_use[ra_ptr]);

			mlog_exit_ptr(ret);
			return ret;
			}

			/*
			* ocfs2_delete_entry deletes a directory entry by merging it with the
			* previous entry
			*/
			int ocfs2_delete_entry(handle_t *handle,
			struct inode *dir,
			struct ocfs2_dir_entry *de_del,
			struct buffer_head *bh)
			{
			struct ocfs2_dir_entry de, pde;
			int i, status = -ENOENT;

			mlog_entry("(0x%p, 0x%p, 0x%p, 0x%p)\n", handle, dir, de_del, bh);

			i = 0;
			pde = NULL;
			de = (struct ocfs2_dir_entry *) bh->b_data;
			while (i < bh->b_size) {
			if (!ocfs2_check_dir_entry(dir, de, bh, i)) {
			status = -EIO;
			mlog_errno(status);
			goto bail;
			}
			if (de == de_del) {
			status = ocfs2_journal_access(handle, dir, bh,
			OCFS2_JOURNAL_ACCESS_WRITE);
			if (status < 0) {
			status = -EIO;
			mlog_errno(status);
			goto bail;
			}
			if (pde)
			pde->rec_len =
			cpu_to_le16(le16_to_cpu(pde->rec_len) +
			le16_to_cpu(de->rec_len));
			else
			de->inode = 0;
			dir->i_version++;
			status = ocfs2_journal_dirty(handle, bh);
			goto bail;
			}
			i += le16_to_cpu(de->rec_len);
			pde = de;
			de = (struct ocfs2_dir_entry )((char )de + le16_to_cpu(de->rec_len));
			}
			bail:
			mlog_exit(status);
			return status;
			}

			/* we don't always have a dentry for what we want to add, so people
			* like orphan dir can call this instead.
			*
			* If you pass me insert_bh, I'll skip the search of the other dir
			* blocks and put the record in there.
			*/
			int __ocfs2_add_entry(handle_t *handle,
			struct inode *dir,
			const char *name, int namelen,
			struct inode *inode, u64 blkno,
			struct buffer_head *parent_fe_bh,
			struct buffer_head *insert_bh)
			{
			unsigned long offset;
			unsigned short rec_len;
			struct ocfs2_dir_entry de, de1;
			struct super_block *sb;
			int retval, status;

			mlog_entry_void();

			sb = dir->i_sb;

			if (!namelen)
			return -EINVAL;

			rec_len = OCFS2_DIR_REC_LEN(namelen);
			offset = 0;
			de = (struct ocfs2_dir_entry *) insert_bh->b_data;
			while (1) {
			BUG_ON((char *)de >= sb->s_blocksize + insert_bh->b_data);
			/* These checks should've already been passed by the
			* prepare function, but I guess we can leave them
			* here anyway. */
			if (!ocfs2_check_dir_entry(dir, de, insert_bh, offset)) {
			retval = -ENOENT;
			goto bail;
			}
			if (ocfs2_match(namelen, name, de)) {
			retval = -EEXIST;
			goto bail;
			}
			if (((le64_to_cpu(de->inode) == 0) &&
			(le16_to_cpu(de->rec_len) >= rec_len)) \|\|
			(le16_to_cpu(de->rec_len) >=
			(OCFS2_DIR_REC_LEN(de->name_len) + rec_len))) {
			dir->i_mtime = dir->i_ctime = CURRENT_TIME;
			retval = ocfs2_mark_inode_dirty(handle, dir, parent_fe_bh);
			if (retval < 0) {
			mlog_errno(retval);
			goto bail;
			}

			status = ocfs2_journal_access(handle, dir, insert_bh,
			OCFS2_JOURNAL_ACCESS_WRITE);
			/* By now the buffer is marked for journaling */
			offset += le16_to_cpu(de->rec_len);
			if (le64_to_cpu(de->inode)) {
			de1 = (struct ocfs2_dir_entry )((char ) de +
			OCFS2_DIR_REC_LEN(de->name_len));
			de1->rec_len =
			cpu_to_le16(le16_to_cpu(de->rec_len) -
			OCFS2_DIR_REC_LEN(de->name_len));
			de->rec_len = cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
			de = de1;
			}
			de->file_type = OCFS2_FT_UNKNOWN;
			if (blkno) {
			de->inode = cpu_to_le64(blkno);
			ocfs2_set_de_type(de, inode->i_mode);
			} else
			de->inode = 0;
			de->name_len = namelen;
			memcpy(de->name, name, namelen);

			dir->i_version++;
			status = ocfs2_journal_dirty(handle, insert_bh);
			retval = 0;
			goto bail;
			}
			offset += le16_to_cpu(de->rec_len);
			de = (struct ocfs2_dir_entry ) ((char ) de + le16_to_cpu(de->rec_len));
			}

			/* when you think about it, the assert above should prevent us
			* from ever getting here. */
			retval = -ENOSPC;
			bail:

			mlog_exit(retval);
			return retval;
			}

	/*		/*
	* ocfs2_readdir()		* ocfs2_readdir()
	*		*
	@@ -347,8 +694,77 @@ int ocfs2_empty_dir(struct inode *inode)
	return 1;		return 1;
	}		}

			int ocfs2_fill_new_dir(struct ocfs2_super *osb,
			handle_t *handle,
			struct inode *parent,
			struct inode *inode,
			struct buffer_head *fe_bh,
			struct ocfs2_alloc_context *data_ac)
			{
			int status;
			struct buffer_head *new_bh = NULL;
			struct ocfs2_dir_entry *de = NULL;

			mlog_entry_void();

			status = ocfs2_do_extend_dir(osb->sb, handle, inode, fe_bh,
			data_ac, NULL, &new_bh);
			if (status < 0) {
			mlog_errno(status);
			goto bail;
			}

			ocfs2_set_new_buffer_uptodate(inode, new_bh);

			status = ocfs2_journal_access(handle, inode, new_bh,
			OCFS2_JOURNAL_ACCESS_CREATE);
			if (status < 0) {
			mlog_errno(status);
			goto bail;
			}
			memset(new_bh->b_data, 0, osb->sb->s_blocksize);

			de = (struct ocfs2_dir_entry *) new_bh->b_data;
			de->inode = cpu_to_le64(OCFS2_I(inode)->ip_blkno);
			de->name_len = 1;
			de->rec_len =
			cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
			strcpy(de->name, ".");
			ocfs2_set_de_type(de, S_IFDIR);
			de = (struct ocfs2_dir_entry ) ((char )de + le16_to_cpu(de->rec_len));
			de->inode = cpu_to_le64(OCFS2_I(parent)->ip_blkno);
			de->rec_len = cpu_to_le16(inode->i_sb->s_blocksize -
			OCFS2_DIR_REC_LEN(1));
			de->name_len = 2;
			strcpy(de->name, "..");
			ocfs2_set_de_type(de, S_IFDIR);

			status = ocfs2_journal_dirty(handle, new_bh);
			if (status < 0) {
			mlog_errno(status);
			goto bail;
			}

			i_size_write(inode, inode->i_sb->s_blocksize);
			inode->i_nlink = 2;
			inode->i_blocks = ocfs2_inode_sector_count(inode);
			status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
			if (status < 0) {
			mlog_errno(status);
			goto bail;
			}

			status = 0;
			bail:
			if (new_bh)
			brelse(new_bh);

			mlog_exit(status);
			return status;
			}

	/* returns a bh of the 1st new block in the allocation. */		/* returns a bh of the 1st new block in the allocation. */
	int ocfs2_do_extend_dir(struct super_block *sb,		static int ocfs2_do_extend_dir(struct super_block *sb,
	handle_t *handle,		handle_t *handle,
	struct inode *dir,		struct inode *dir,
	struct buffer_head *parent_fe_bh,		struct buffer_head *parent_fe_bh,

fs/ocfs2/dir.h

+37 −7

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,31 @@
	#ifndef OCFS2_DIR_H		#ifndef OCFS2_DIR_H
	#define OCFS2_DIR_H		#define OCFS2_DIR_H

			struct buffer_head ocfs2_find_entry(const char name,
			int namelen,
			struct inode *dir,
			struct ocfs2_dir_entry **res_dir);
			int ocfs2_delete_entry(handle_t *handle,
			struct inode *dir,
			struct ocfs2_dir_entry *de_del,
			struct buffer_head *bh);
			int __ocfs2_add_entry(handle_t *handle,
			struct inode *dir,
			const char *name, int namelen,
			struct inode *inode, u64 blkno,
			struct buffer_head *parent_fe_bh,
			struct buffer_head *insert_bh);
			static inline int ocfs2_add_entry(handle_t *handle,
			struct dentry *dentry,
			struct inode *inode, u64 blkno,
			struct buffer_head *parent_fe_bh,
			struct buffer_head *insert_bh)
			{
			return __ocfs2_add_entry(handle, dentry->d_parent->d_inode,
			dentry->d_name.name, dentry->d_name.len,
			inode, blkno, parent_fe_bh, insert_bh);
			}

	int ocfs2_check_dir_for_entry(struct inode *dir,		int ocfs2_check_dir_for_entry(struct inode *dir,
	const char *name,		const char *name,
	int namelen);		int namelen);
	@@ -44,11 +69,16 @@ int ocfs2_prepare_dir_for_insert(struct ocfs2_super *osb,
	int namelen,		int namelen,
	struct buffer_head **ret_de_bh);		struct buffer_head **ret_de_bh);
	struct ocfs2_alloc_context;		struct ocfs2_alloc_context;
	int ocfs2_do_extend_dir(struct super_block *sb,		int ocfs2_fill_new_dir(struct ocfs2_super *osb,
	handle_t *handle,		handle_t *handle,
	struct inode *dir,		struct inode *parent,
	struct buffer_head *parent_fe_bh,		struct inode *inode,
	struct ocfs2_alloc_context *data_ac,		struct buffer_head *fe_bh,
	struct ocfs2_alloc_context *meta_ac,		struct ocfs2_alloc_context *data_ac);
	struct buffer_head **new_bh);
			int ocfs2_check_dir_entry(struct inode *dir,
			struct ocfs2_dir_entry *de,
			struct buffer_head *bh,
			unsigned long offset);

	#endif /* OCFS2_DIR_H */		#endif /* OCFS2_DIR_H */

fs/ocfs2/journal.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -35,13 +35,13 @@
	#include "ocfs2.h"		#include "ocfs2.h"

	#include "alloc.h"		#include "alloc.h"
			#include "dir.h"
	#include "dlmglue.h"		#include "dlmglue.h"
	#include "extent_map.h"		#include "extent_map.h"
	#include "heartbeat.h"		#include "heartbeat.h"
	#include "inode.h"		#include "inode.h"
	#include "journal.h"		#include "journal.h"
	#include "localalloc.h"		#include "localalloc.h"
	#include "namei.h"
	#include "slot_map.h"		#include "slot_map.h"
	#include "super.h"		#include "super.h"
	#include "vote.h"		#include "vote.h"

fs/ocfs2/namei.c

+0 −433

File changed.

Preview size limit exceeded, changes collapsed.

fs/ocfs2/namei.h

+0 −19

Original line number	Original line	Diff line number	Diff line
	@@ -30,29 +30,10 @@ extern const struct inode_operations ocfs2_dir_iops;

	struct dentry ocfs2_get_parent(struct dentry child);		struct dentry ocfs2_get_parent(struct dentry child);

	int ocfs2_check_dir_entry (struct inode *dir,
	struct ocfs2_dir_entry *de,
	struct buffer_head *bh,
	unsigned long offset);
	struct buffer_head ocfs2_find_entry(const char name,
	int namelen,
	struct inode *dir,
	struct ocfs2_dir_entry **res_dir);
	int ocfs2_orphan_del(struct ocfs2_super *osb,		int ocfs2_orphan_del(struct ocfs2_super *osb,
	handle_t *handle,		handle_t *handle,
	struct inode *orphan_dir_inode,		struct inode *orphan_dir_inode,
	struct inode *inode,		struct inode *inode,
	struct buffer_head *orphan_dir_bh);		struct buffer_head *orphan_dir_bh);

	static inline int ocfs2_match(int len,
	const char * const name,
	struct ocfs2_dir_entry *de)
	{
	if (len != de->name_len)
	return 0;
	if (!de->inode)
	return 0;
	return !memcmp(name, de->name, len);
	}

	#endif /* OCFS2_NAMEI_H */		#endif /* OCFS2_NAMEI_H */