[net-next-2.6.git] / fs / ocfs2 / symlink.c

/* -*- mode: c; c-basic-offset: 8; -*-
 * vim: noexpandtab sw=8 ts=8 sts=0:
 *
 *  linux/cluster/ssi/cfs/symlink.c
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License as
 *	published by the Free Software Foundation; either version 2 of
 *	the License, or (at your option) any later version.
 *
 *	This program is distributed in the hope that it will be useful,
 *	but WITHOUT ANY WARRANTY; without even the implied warranty of
 *	MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE
 *	or NON INFRINGEMENT.  See the GNU General Public License for more
 *	details.
 *
 * 	You should have received a copy of the GNU General Public License
 * 	along with this program; if not, write to the Free Software
 * 	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *	Questions/Comments/Bugfixes to ssic-linux-devel@lists.sourceforge.net
 *
 *  Copyright (C) 1992  Rick Sladkey
 *
 *  Optimization changes Copyright (C) 1994 Florian La Roche
 *
 *  Jun 7 1999, cache symlink lookups in the page cache.  -DaveM
 *
 *  Portions Copyright (C) 2001 Compaq Computer Corporation
 *
 *  ocfs2 symlink handling code.
 *
 *  Copyright (C) 2004, 2005 Oracle.
 *
 */

#include <linux/fs.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/pagemap.h>
#include <linux/namei.h>

#define MLOG_MASK_PREFIX ML_NAMEI
#include <cluster/masklog.h>

#include "ocfs2.h"

#include "alloc.h"
#include "file.h"
#include "inode.h"
#include "journal.h"
#include "symlink.h"
#include "xattr.h"

#include "buffer_head_io.h"


static char *ocfs2_fast_symlink_getlink(struct inode *inode,
					struct buffer_head **bh)
{
	int status;
	char *link = NULL;
	struct ocfs2_dinode *fe;

	mlog_entry_void();

	status = ocfs2_read_inode_block(inode, bh);
	if (status < 0) {
		mlog_errno(status);
		link = ERR_PTR(status);
		goto bail;
	}

	fe = (struct ocfs2_dinode *) (*bh)->b_data;
	link = (char *) fe->id2.i_symlink;
bail:
	mlog_exit(status);

	return link;
}

static int ocfs2_readlink(struct dentry *dentry,
			  char __user *buffer,
			  int buflen)
{
	int ret;
	char *link;
	struct buffer_head *bh = NULL;
	struct inode *inode = dentry->d_inode;

	mlog_entry_void();

	link = ocfs2_fast_symlink_getlink(inode, &bh);
	if (IS_ERR(link)) {
		ret = PTR_ERR(link);
		goto out;
	}

	/*
	 * Without vfsmount we can't update atime now,
	 * but we will update atime here ultimately.
	 */
	ret = vfs_readlink(dentry, buffer, buflen, link);

	brelse(bh);
out:
	mlog_exit(ret);
	return ret;
}

static void *ocfs2_fast_follow_link(struct dentry *dentry,
				    struct nameidata *nd)
{
	int status = 0;
	int len;
	char *target, *link = ERR_PTR(-ENOMEM);
	struct inode *inode = dentry->d_inode;
	struct buffer_head *bh = NULL;

	mlog_entry_void();

	BUG_ON(!ocfs2_inode_is_fast_symlink(inode));
	target = ocfs2_fast_symlink_getlink(inode, &bh);
	if (IS_ERR(target)) {
		status = PTR_ERR(target);
		mlog_errno(status);
		goto bail;
	}

	/* Fast symlinks can't be large */
	len = strnlen(target, ocfs2_fast_symlink_chars(inode->i_sb));
	link = kzalloc(len + 1, GFP_NOFS);
	if (!link) {
		status = -ENOMEM;
		mlog_errno(status);
		goto bail;
	}

	memcpy(link, target, len);

bail:
	nd_set_link(nd, status ? ERR_PTR(status) : link);
	brelse(bh);

	mlog_exit(status);
	return NULL;
}

static void ocfs2_fast_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
{
	char *link = nd_get_link(nd);
	if (!IS_ERR(link))
		kfree(link);
}

const struct inode_operations ocfs2_symlink_inode_operations = {
	.readlink	= page_readlink,
	.follow_link	= page_follow_link_light,
	.put_link	= page_put_link,
	.getattr	= ocfs2_getattr,
	.setattr	= ocfs2_setattr,
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr	= ocfs2_listxattr,
	.removexattr	= generic_removexattr,
	.fiemap		= ocfs2_fiemap,
};
const struct inode_operations ocfs2_fast_symlink_inode_operations = {
	.readlink	= ocfs2_readlink,
	.follow_link	= ocfs2_fast_follow_link,
	.put_link	= ocfs2_fast_put_link,
	.getattr	= ocfs2_getattr,
	.setattr	= ocfs2_setattr,
	.setxattr	= generic_setxattr,
	.getxattr	= generic_getxattr,
	.listxattr	= ocfs2_listxattr,
	.removexattr	= generic_removexattr,
	.fiemap		= ocfs2_fiemap,
};
Commit	Line	Data
ccd979bd MF	1	/* -- mode: c; c-basic-offset: 8; --
	2	* vim: noexpandtab sw=8 ts=8 sts=0:
	3	*
	4	* linux/cluster/ssi/cfs/symlink.c
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License as
	8	* published by the Free Software Foundation; either version 2 of
	9	* the License, or (at your option) any later version.
	10	*
	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, GOOD TITLE
	14	* or NON INFRINGEMENT. See the GNU General Public License for more
	15	* details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	20	*
	21	* Questions/Comments/Bugfixes to ssic-linux-devel@lists.sourceforge.net
	22	*
	23	* Copyright (C) 1992 Rick Sladkey
	24	*
	25	* Optimization changes Copyright (C) 1994 Florian La Roche
	26	*
	27	* Jun 7 1999, cache symlink lookups in the page cache. -DaveM
	28	*
	29	* Portions Copyright (C) 2001 Compaq Computer Corporation
	30	*
	31	* ocfs2 symlink handling code.
	32	*
	33	* Copyright (C) 2004, 2005 Oracle.
	34	*
	35	*/
	36
	37	#include <linux/fs.h>
	38	#include <linux/types.h>
	39	#include <linux/slab.h>
	40	#include <linux/pagemap.h>
a731d12d	41	#include <linux/namei.h>
ccd979bd MF	42
	43	#define MLOG_MASK_PREFIX ML_NAMEI
	44	#include <cluster/masklog.h>
	45
	46	#include "ocfs2.h"
	47
	48	#include "alloc.h"
	49	#include "file.h"
	50	#include "inode.h"
	51	#include "journal.h"
	52	#include "symlink.h"
cf1d6c76	53	#include "xattr.h"
ccd979bd MF	54
	55	#include "buffer_head_io.h"
	56
ccd979bd MF	57
	58	static char ocfs2_fast_symlink_getlink(struct inode inode,
	59	struct buffer_head **bh)
	60	{
	61	int status;
	62	char *link = NULL;
	63	struct ocfs2_dinode *fe;
	64
	65	mlog_entry_void();
	66
b657c95c	67	status = ocfs2_read_inode_block(inode, bh);
ccd979bd MF	68	if (status < 0) {
	69	mlog_errno(status);
	70	link = ERR_PTR(status);
	71	goto bail;
	72	}
	73
	74	fe = (struct ocfs2_dinode ) (bh)->b_data;
	75	link = (char *) fe->id2.i_symlink;
	76	bail:
	77	mlog_exit(status);
	78
	79	return link;
	80	}
	81
	82	static int ocfs2_readlink(struct dentry *dentry,
	83	char __user *buffer,
	84	int buflen)
	85	{
	86	int ret;
	87	char *link;
	88	struct buffer_head *bh = NULL;
	89	struct inode *inode = dentry->d_inode;
	90
	91	mlog_entry_void();
	92
	93	link = ocfs2_fast_symlink_getlink(inode, &bh);
	94	if (IS_ERR(link)) {
	95	ret = PTR_ERR(link);
	96	goto out;
	97	}
	98
25899dee TY	99	/*
	100	* Without vfsmount we can't update atime now,
	101	* but we will update atime here ultimately.
	102	*/
ccd979bd MF	103	ret = vfs_readlink(dentry, buffer, buflen, link);
	104
	105	brelse(bh);
	106	out:
	107	mlog_exit(ret);
	108	return ret;
	109	}
	110
a731d12d JB	111	static void ocfs2_fast_follow_link(struct dentry dentry,
a731d12d JB	112	struct nameidata *nd)
ccd979bd	113	{
a731d12d JB	114	int status = 0;
	115	int len;
	116	char target, link = ERR_PTR(-ENOMEM);
ccd979bd	117	struct inode *inode = dentry->d_inode;
ccd979bd	118	struct buffer_head *bh = NULL;
a731d12d JB	119
	120	mlog_entry_void();
	121
	122	BUG_ON(!ocfs2_inode_is_fast_symlink(inode));
	123	target = ocfs2_fast_symlink_getlink(inode, &bh);
	124	if (IS_ERR(target)) {
	125	status = PTR_ERR(target);
ccd979bd MF	126	mlog_errno(status);
	127	goto bail;
	128	}
	129
a731d12d	130	/* Fast symlinks can't be large */
1fc8a117	131	len = strnlen(target, ocfs2_fast_symlink_chars(inode->i_sb));
a731d12d JB	132	link = kzalloc(len + 1, GFP_NOFS);
	133	if (!link) {
	134	status = -ENOMEM;
	135	mlog_errno(status);
	136	goto bail;
	137	}
	138
	139	memcpy(link, target, len);
72bce507	140
ccd979bd	141	bail:
1dd473fd	142	nd_set_link(nd, status ? ERR_PTR(status) : link);
a81cb88b	143	brelse(bh);
ccd979bd	144
a731d12d	145	mlog_exit(status);
1dd473fd	146	return NULL;
a731d12d JB	147	}
	148
	149	static void ocfs2_fast_put_link(struct dentry dentry, struct nameidata nd, void *cookie)
	150	{
1dd473fd OH	151	char *link = nd_get_link(nd);
	152	if (!IS_ERR(link))
	153	kfree(link);
ccd979bd MF	154	}
ccd979bd MF	155
92e1d5be	156	const struct inode_operations ocfs2_symlink_inode_operations = {
ccd979bd	157	.readlink = page_readlink,
a731d12d JB	158	.follow_link = page_follow_link_light,
a731d12d JB	159	.put_link = page_put_link,
ccd979bd	160	.getattr = ocfs2_getattr,
bc535809	161	.setattr = ocfs2_setattr,
cf1d6c76 TY	162	.setxattr = generic_setxattr,
	163	.getxattr = generic_getxattr,
	164	.listxattr = ocfs2_listxattr,
	165	.removexattr = generic_removexattr,
86239d59	166	.fiemap = ocfs2_fiemap,
ccd979bd	167	};
92e1d5be	168	const struct inode_operations ocfs2_fast_symlink_inode_operations = {
ccd979bd	169	.readlink = ocfs2_readlink,
a731d12d JB	170	.follow_link = ocfs2_fast_follow_link,
a731d12d JB	171	.put_link = ocfs2_fast_put_link,
ccd979bd	172	.getattr = ocfs2_getattr,
bc535809	173	.setattr = ocfs2_setattr,
cf1d6c76 TY	174	.setxattr = generic_setxattr,
	175	.getxattr = generic_getxattr,
	176	.listxattr = ocfs2_listxattr,
	177	.removexattr = generic_removexattr,
86239d59	178	.fiemap = ocfs2_fiemap,
ccd979bd	179	};