[net-next-2.6.git] / fs / bad_inode.c

/*
 *  linux/fs/bad_inode.c
 *
 *  Copyright (C) 1997, Stephen Tweedie
 *
 *  Provide stub functions for unreadable inodes
 *
 *  Fabian Frederick : August 2003 - All file operations assigned to EIO
 */

#include <linux/fs.h>
#include <linux/module.h>
#include <linux/stat.h>
#include <linux/time.h>
#include <linux/smp_lock.h>
#include <linux/namei.h>

static int return_EIO(void)
{
	return -EIO;
}

#define EIO_ERROR ((void *) (return_EIO))

static struct file_operations bad_file_ops =
{
	.llseek		= EIO_ERROR,
	.aio_read	= EIO_ERROR,
	.read		= EIO_ERROR,
	.write		= EIO_ERROR,
	.aio_write	= EIO_ERROR,
	.readdir	= EIO_ERROR,
	.poll		= EIO_ERROR,
	.ioctl		= EIO_ERROR,
	.mmap		= EIO_ERROR,
	.open		= EIO_ERROR,
	.flush		= EIO_ERROR,
	.release	= EIO_ERROR,
	.fsync		= EIO_ERROR,
	.aio_fsync	= EIO_ERROR,
	.fasync		= EIO_ERROR,
	.lock		= EIO_ERROR,
	.readv		= EIO_ERROR,
	.writev		= EIO_ERROR,
	.sendfile	= EIO_ERROR,
	.sendpage	= EIO_ERROR,
	.get_unmapped_area = EIO_ERROR,
};

static struct inode_operations bad_inode_ops =
{
	.create		= EIO_ERROR,
	.lookup		= EIO_ERROR,
	.link		= EIO_ERROR,
	.unlink		= EIO_ERROR,
	.symlink	= EIO_ERROR,
	.mkdir		= EIO_ERROR,
	.rmdir		= EIO_ERROR,
	.mknod		= EIO_ERROR,
	.rename		= EIO_ERROR,
	.readlink	= EIO_ERROR,
	/* follow_link must be no-op, otherwise unmounting this inode
	   won't work */
	.truncate	= EIO_ERROR,
	.permission	= EIO_ERROR,
	.getattr	= EIO_ERROR,
	.setattr	= EIO_ERROR,
	.setxattr	= EIO_ERROR,
	.getxattr	= EIO_ERROR,
	.listxattr	= EIO_ERROR,
	.removexattr	= EIO_ERROR,
};


/*
 * When a filesystem is unable to read an inode due to an I/O error in
 * its read_inode() function, it can call make_bad_inode() to return a
 * set of stubs which will return EIO errors as required. 
 *
 * We only need to do limited initialisation: all other fields are
 * preinitialised to zero automatically.
 */
 
/**
 *	make_bad_inode - mark an inode bad due to an I/O error
 *	@inode: Inode to mark bad
 *
 *	When an inode cannot be read due to a media or remote network
 *	failure this function makes the inode "bad" and causes I/O operations
 *	on it to fail from this point on.
 */
 
void make_bad_inode(struct inode * inode) 
{
	remove_inode_hash(inode);

	inode->i_mode = S_IFREG;
	inode->i_atime = inode->i_mtime = inode->i_ctime =
		current_fs_time(inode->i_sb);
	inode->i_op = &bad_inode_ops;	
	inode->i_fop = &bad_file_ops;	
}
EXPORT_SYMBOL(make_bad_inode);

/*
 * This tests whether an inode has been flagged as bad. The test uses
 * &bad_inode_ops to cover the case of invalidated inodes as well as
 * those created by make_bad_inode() above.
 */
 
/**
 *	is_bad_inode - is an inode errored
 *	@inode: inode to test
 *
 *	Returns true if the inode in question has been marked as bad.
 */
 
int is_bad_inode(struct inode * inode) 
{
	return (inode->i_op == &bad_inode_ops);	
}

EXPORT_SYMBOL(is_bad_inode);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/bad_inode.c
	3	*
	4	* Copyright (C) 1997, Stephen Tweedie
	5	*
	6	* Provide stub functions for unreadable inodes
	7	*
	8	* Fabian Frederick : August 2003 - All file operations assigned to EIO
	9	*/
	10
	11	#include <linux/fs.h>
	12	#include <linux/module.h>
	13	#include <linux/stat.h>
	14	#include <linux/time.h>
	15	#include <linux/smp_lock.h>
	16	#include <linux/namei.h>
	17
	18	static int return_EIO(void)
	19	{
	20	return -EIO;
	21	}
	22
	23	#define EIO_ERROR ((void *) (return_EIO))
	24
	25	static struct file_operations bad_file_ops =
	26	{
	27	.llseek = EIO_ERROR,
	28	.aio_read = EIO_ERROR,
	29	.read = EIO_ERROR,
	30	.write = EIO_ERROR,
	31	.aio_write = EIO_ERROR,
	32	.readdir = EIO_ERROR,
	33	.poll = EIO_ERROR,
	34	.ioctl = EIO_ERROR,
	35	.mmap = EIO_ERROR,
	36	.open = EIO_ERROR,
	37	.flush = EIO_ERROR,
	38	.release = EIO_ERROR,
	39	.fsync = EIO_ERROR,
	40	.aio_fsync = EIO_ERROR,
	41	.fasync = EIO_ERROR,
	42	.lock = EIO_ERROR,
	43	.readv = EIO_ERROR,
	44	.writev = EIO_ERROR,
	45	.sendfile = EIO_ERROR,
	46	.sendpage = EIO_ERROR,
	47	.get_unmapped_area = EIO_ERROR,
	48	};
	49
75c96f85	50	static struct inode_operations bad_inode_ops =
1da177e4 LT	51	{
	52	.create = EIO_ERROR,
	53	.lookup = EIO_ERROR,
	54	.link = EIO_ERROR,
	55	.unlink = EIO_ERROR,
	56	.symlink = EIO_ERROR,
	57	.mkdir = EIO_ERROR,
	58	.rmdir = EIO_ERROR,
	59	.mknod = EIO_ERROR,
	60	.rename = EIO_ERROR,
	61	.readlink = EIO_ERROR,
	62	/* follow_link must be no-op, otherwise unmounting this inode
	63	won't work */
	64	.truncate = EIO_ERROR,
	65	.permission = EIO_ERROR,
	66	.getattr = EIO_ERROR,
	67	.setattr = EIO_ERROR,
	68	.setxattr = EIO_ERROR,
	69	.getxattr = EIO_ERROR,
	70	.listxattr = EIO_ERROR,
	71	.removexattr = EIO_ERROR,
	72	};
	73
	74
	75	/*
	76	* When a filesystem is unable to read an inode due to an I/O error in
	77	* its read_inode() function, it can call make_bad_inode() to return a
	78	* set of stubs which will return EIO errors as required.
	79	*
	80	* We only need to do limited initialisation: all other fields are
	81	* preinitialised to zero automatically.
	82	*/
	83
	84	/**
	85	* make_bad_inode - mark an inode bad due to an I/O error
	86	* @inode: Inode to mark bad
	87	*
	88	* When an inode cannot be read due to a media or remote network
	89	* failure this function makes the inode "bad" and causes I/O operations
	90	* on it to fail from this point on.
	91	*/
	92
	93	void make_bad_inode(struct inode * inode)
	94	{
	95	remove_inode_hash(inode);
	96
	97	inode->i_mode = S_IFREG;
	98	inode->i_atime = inode->i_mtime = inode->i_ctime =
	99	current_fs_time(inode->i_sb);
	100	inode->i_op = &bad_inode_ops;
	101	inode->i_fop = &bad_file_ops;
	102	}
	103	EXPORT_SYMBOL(make_bad_inode);
	104
	105	/*
	106	* This tests whether an inode has been flagged as bad. The test uses
	107	* &bad_inode_ops to cover the case of invalidated inodes as well as
	108	* those created by make_bad_inode() above.
	109	*/
	110
	111	/**
	112	* is_bad_inode - is an inode errored
	113	* @inode: inode to test
	114	*
115	* Returns true if the inode in question has been marked as bad.
116	*/
117
118	int is_bad_inode(struct inode * inode)
119	{
120	return (inode->i_op == &bad_inode_ops);
121	}
122
123	EXPORT_SYMBOL(is_bad_inode);