[linux-block.git] / fs / ext4 / symlink.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/fs/ext4/symlink.c
 *
 * Only fast symlinks left here - the rest is done by generic code. AV, 1999
 *
 * Copyright (C) 1992, 1993, 1994, 1995
 * Remy Card (card@masi.ibp.fr)
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 *
 *  from
 *
 *  linux/fs/minix/symlink.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  ext4 symlink handling code
 */

#include <linux/fs.h>
#include <linux/namei.h>
#include "ext4.h"
#include "xattr.h"

static const char *ext4_encrypted_get_link(struct dentry *dentry,
					   struct inode *inode,
					   struct delayed_call *done)
{
	struct buffer_head *bh = NULL;
	const void *caddr;
	unsigned int max_size;
	const char *paddr;

	if (!dentry)
		return ERR_PTR(-ECHILD);

	if (ext4_inode_is_fast_symlink(inode)) {
		caddr = EXT4_I(inode)->i_data;
		max_size = sizeof(EXT4_I(inode)->i_data);
	} else {
		bh = ext4_bread(NULL, inode, 0, 0);
		if (IS_ERR(bh))
			return ERR_CAST(bh);
		if (!bh) {
			EXT4_ERROR_INODE(inode, "bad symlink.");
			return ERR_PTR(-EFSCORRUPTED);
		}
		caddr = bh->b_data;
		max_size = inode->i_sb->s_blocksize;
	}

	paddr = fscrypt_get_symlink(inode, caddr, max_size, done);
	brelse(bh);
	return paddr;
}

static int ext4_encrypted_symlink_getattr(struct mnt_idmap *idmap,
					  const struct path *path,
					  struct kstat *stat, u32 request_mask,
					  unsigned int query_flags)
{
	ext4_getattr(idmap, path, stat, request_mask, query_flags);

	return fscrypt_symlink_getattr(path, stat);
}

static void ext4_free_link(void *bh)
{
	brelse(bh);
}

static const char *ext4_get_link(struct dentry *dentry, struct inode *inode,
				 struct delayed_call *callback)
{
	struct buffer_head *bh;
	char *inline_link;

	/*
	 * Create a new inlined symlink is not supported, just provide a
	 * method to read the leftovers.
	 */
	if (ext4_has_inline_data(inode)) {
		if (!dentry)
			return ERR_PTR(-ECHILD);

		inline_link = ext4_read_inline_link(inode);
		if (!IS_ERR(inline_link))
			set_delayed_call(callback, kfree_link, inline_link);
		return inline_link;
	}

	if (!dentry) {
		bh = ext4_getblk(NULL, inode, 0, EXT4_GET_BLOCKS_CACHED_NOWAIT);
		if (IS_ERR(bh) || !bh)
			return ERR_PTR(-ECHILD);
		if (!ext4_buffer_uptodate(bh)) {
			brelse(bh);
			return ERR_PTR(-ECHILD);
		}
	} else {
		bh = ext4_bread(NULL, inode, 0, 0);
		if (IS_ERR(bh))
			return ERR_CAST(bh);
		if (!bh) {
			EXT4_ERROR_INODE(inode, "bad symlink.");
			return ERR_PTR(-EFSCORRUPTED);
		}
	}

	set_delayed_call(callback, ext4_free_link, bh);
	nd_terminate_link(bh->b_data, inode->i_size,
			  inode->i_sb->s_blocksize - 1);
	return bh->b_data;
}

const struct inode_operations ext4_encrypted_symlink_inode_operations = {
	.get_link	= ext4_encrypted_get_link,
	.setattr	= ext4_setattr,
	.getattr	= ext4_encrypted_symlink_getattr,
	.listxattr	= ext4_listxattr,
};

const struct inode_operations ext4_symlink_inode_operations = {
	.get_link	= ext4_get_link,
	.setattr	= ext4_setattr,
	.getattr	= ext4_getattr,
	.listxattr	= ext4_listxattr,
};

const struct inode_operations ext4_fast_symlink_inode_operations = {
	.get_link	= simple_get_link,
	.setattr	= ext4_setattr,
	.getattr	= ext4_getattr,
	.listxattr	= ext4_listxattr,
};
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
ac27a0ec	2	/*
617ba13b	3	* linux/fs/ext4/symlink.c
ac27a0ec DK	4	*
	5	* Only fast symlinks left here - the rest is done by generic code. AV, 1999
	6	*
	7	* Copyright (C) 1992, 1993, 1994, 1995
	8	* Remy Card (card@masi.ibp.fr)
	9	* Laboratoire MASI - Institut Blaise Pascal
	10	* Universite Pierre et Marie Curie (Paris VI)
	11	*
	12	* from
	13	*
	14	* linux/fs/minix/symlink.c
	15	*
	16	* Copyright (C) 1991, 1992 Linus Torvalds
	17	*
617ba13b	18	* ext4 symlink handling code
ac27a0ec DK	19	*/
	20
	21	#include <linux/fs.h>
ac27a0ec	22	#include <linux/namei.h>
3dcf5451	23	#include "ext4.h"
ac27a0ec DK	24	#include "xattr.h"
ac27a0ec DK	25
6b255391	26	static const char ext4_encrypted_get_link(struct dentry dentry,
fceef393 AV	27	struct inode *inode,
fceef393 AV	28	struct delayed_call *done)
f348c252	29	{
6493792d	30	struct buffer_head *bh = NULL;
6a9269c8 EB	31	const void *caddr;
	32	unsigned int max_size;
	33	const char *paddr;
f348c252	34
6b255391 AV	35	if (!dentry)
	36	return ERR_PTR(-ECHILD);
	37
f348c252	38	if (ext4_inode_is_fast_symlink(inode)) {
6a9269c8	39	caddr = EXT4_I(inode)->i_data;
9ec3a646	40	max_size = sizeof(EXT4_I(inode)->i_data);
f348c252	41	} else {
6493792d ZY	42	bh = ext4_bread(NULL, inode, 0, 0);
	43	if (IS_ERR(bh))
	44	return ERR_CAST(bh);
	45	if (!bh) {
	46	EXT4_ERROR_INODE(inode, "bad symlink.");
	47	return ERR_PTR(-EFSCORRUPTED);
	48	}
	49	caddr = bh->b_data;
6a9269c8	50	max_size = inode->i_sb->s_blocksize;
f348c252 TT	51	}
f348c252 TT	52
6a9269c8	53	paddr = fscrypt_get_symlink(inode, caddr, max_size, done);
6493792d	54	brelse(bh);
fceef393	55	return paddr;
f348c252 TT	56	}
f348c252 TT	57
b74d24f7	58	static int ext4_encrypted_symlink_getattr(struct mnt_idmap *idmap,
8c4bca10 EB	59	const struct path *path,
	60	struct kstat *stat, u32 request_mask,
	61	unsigned int query_flags)
	62	{
b74d24f7	63	ext4_getattr(idmap, path, stat, request_mask, query_flags);
8c4bca10 EB	64
	65	return fscrypt_symlink_getattr(path, stat);
	66	}
	67
6493792d ZY	68	static void ext4_free_link(void *bh)
	69	{
	70	brelse(bh);
	71	}
	72
	73	static const char ext4_get_link(struct dentry dentry, struct inode *inode,
	74	struct delayed_call *callback)
	75	{
	76	struct buffer_head *bh;
5a57bca9 ZY	77	char *inline_link;
	78
	79	/*
	80	* Create a new inlined symlink is not supported, just provide a
	81	* method to read the leftovers.
	82	*/
	83	if (ext4_has_inline_data(inode)) {
	84	if (!dentry)
	85	return ERR_PTR(-ECHILD);
	86
	87	inline_link = ext4_read_inline_link(inode);
	88	if (!IS_ERR(inline_link))
	89	set_delayed_call(callback, kfree_link, inline_link);
	90	return inline_link;
	91	}
6493792d ZY	92
	93	if (!dentry) {
	94	bh = ext4_getblk(NULL, inode, 0, EXT4_GET_BLOCKS_CACHED_NOWAIT);
9fa8e282	95	if (IS_ERR(bh) \|\| !bh)
6493792d	96	return ERR_PTR(-ECHILD);
9fa8e282 AV	97	if (!ext4_buffer_uptodate(bh)) {
	98	brelse(bh);
	99	return ERR_PTR(-ECHILD);
	100	}
6493792d ZY	101	} else {
	102	bh = ext4_bread(NULL, inode, 0, 0);
	103	if (IS_ERR(bh))
	104	return ERR_CAST(bh);
	105	if (!bh) {
	106	EXT4_ERROR_INODE(inode, "bad symlink.");
	107	return ERR_PTR(-EFSCORRUPTED);
	108	}
	109	}
	110
	111	set_delayed_call(callback, ext4_free_link, bh);
	112	nd_terminate_link(bh->b_data, inode->i_size,
	113	inode->i_sb->s_blocksize - 1);
	114	return bh->b_data;
	115	}
	116
a7a67e8a	117	const struct inode_operations ext4_encrypted_symlink_inode_operations = {
6b255391	118	.get_link = ext4_encrypted_get_link,
a7a67e8a	119	.setattr = ext4_setattr,
8c4bca10	120	.getattr = ext4_encrypted_symlink_getattr,
a7a67e8a	121	.listxattr = ext4_listxattr,
a7a67e8a	122	};
f348c252	123
754661f1	124	const struct inode_operations ext4_symlink_inode_operations = {
6493792d	125	.get_link = ext4_get_link,
256a4535	126	.setattr = ext4_setattr,
99652ea5	127	.getattr = ext4_getattr,
617ba13b	128	.listxattr = ext4_listxattr,
ac27a0ec DK	129	};
ac27a0ec DK	130
754661f1	131	const struct inode_operations ext4_fast_symlink_inode_operations = {
6b255391	132	.get_link = simple_get_link,
256a4535	133	.setattr = ext4_setattr,
99652ea5	134	.getattr = ext4_getattr,
617ba13b	135	.listxattr = ext4_listxattr,
ac27a0ec	136	};