mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
![Christian Brauner](/assets/img/avatar_default.png)
Extend some inode methods with an additional user namespace argument. A filesystem that is aware of idmapped mounts will receive the user namespace the mount has been marked with. This can be used for additional permission checking and also to enable filesystems to translate between uids and gids if they need to. We have implemented all relevant helpers in earlier patches. As requested we simply extend the exisiting inode method instead of introducing new ones. This is a little more code churn but it's mostly mechanical and doesnt't leave us with additional inode methods. Link: https://lore.kernel.org/r/20210121131959.646623-25-christian.brauner@ubuntu.com Cc: Christoph Hellwig <hch@lst.de> Cc: David Howells <dhowells@redhat.com> Cc: Al Viro <viro@zeniv.linux.org.uk> Cc: linux-fsdevel@vger.kernel.org Reviewed-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Christian Brauner <christian.brauner@ubuntu.com>
192 lines
4.3 KiB
C
192 lines
4.3 KiB
C
/*
|
|
* symlink.c
|
|
*
|
|
* PURPOSE
|
|
* Symlink handling routines for the OSTA-UDF(tm) filesystem.
|
|
*
|
|
* COPYRIGHT
|
|
* This file is distributed under the terms of the GNU General Public
|
|
* License (GPL). Copies of the GPL can be obtained from:
|
|
* ftp://prep.ai.mit.edu/pub/gnu/GPL
|
|
* Each contributing author retains all rights to their own work.
|
|
*
|
|
* (C) 1998-2001 Ben Fennema
|
|
* (C) 1999 Stelias Computing Inc
|
|
*
|
|
* HISTORY
|
|
*
|
|
* 04/16/99 blf Created.
|
|
*
|
|
*/
|
|
|
|
#include "udfdecl.h"
|
|
#include <linux/uaccess.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/time.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/pagemap.h>
|
|
#include "udf_i.h"
|
|
|
|
static int udf_pc_to_char(struct super_block *sb, unsigned char *from,
|
|
int fromlen, unsigned char *to, int tolen)
|
|
{
|
|
struct pathComponent *pc;
|
|
int elen = 0;
|
|
int comp_len;
|
|
unsigned char *p = to;
|
|
|
|
/* Reserve one byte for terminating \0 */
|
|
tolen--;
|
|
while (elen < fromlen) {
|
|
pc = (struct pathComponent *)(from + elen);
|
|
elen += sizeof(struct pathComponent);
|
|
switch (pc->componentType) {
|
|
case 1:
|
|
/*
|
|
* Symlink points to some place which should be agreed
|
|
* upon between originator and receiver of the media. Ignore.
|
|
*/
|
|
if (pc->lengthComponentIdent > 0) {
|
|
elen += pc->lengthComponentIdent;
|
|
break;
|
|
}
|
|
fallthrough;
|
|
case 2:
|
|
if (tolen == 0)
|
|
return -ENAMETOOLONG;
|
|
p = to;
|
|
*p++ = '/';
|
|
tolen--;
|
|
break;
|
|
case 3:
|
|
if (tolen < 3)
|
|
return -ENAMETOOLONG;
|
|
memcpy(p, "../", 3);
|
|
p += 3;
|
|
tolen -= 3;
|
|
break;
|
|
case 4:
|
|
if (tolen < 2)
|
|
return -ENAMETOOLONG;
|
|
memcpy(p, "./", 2);
|
|
p += 2;
|
|
tolen -= 2;
|
|
/* that would be . - just ignore */
|
|
break;
|
|
case 5:
|
|
elen += pc->lengthComponentIdent;
|
|
if (elen > fromlen)
|
|
return -EIO;
|
|
comp_len = udf_get_filename(sb, pc->componentIdent,
|
|
pc->lengthComponentIdent,
|
|
p, tolen);
|
|
if (comp_len < 0)
|
|
return comp_len;
|
|
|
|
p += comp_len;
|
|
tolen -= comp_len;
|
|
if (tolen == 0)
|
|
return -ENAMETOOLONG;
|
|
*p++ = '/';
|
|
tolen--;
|
|
break;
|
|
}
|
|
}
|
|
if (p > to + 1)
|
|
p[-1] = '\0';
|
|
else
|
|
p[0] = '\0';
|
|
return 0;
|
|
}
|
|
|
|
static int udf_symlink_filler(struct file *file, struct page *page)
|
|
{
|
|
struct inode *inode = page->mapping->host;
|
|
struct buffer_head *bh = NULL;
|
|
unsigned char *symlink;
|
|
int err;
|
|
unsigned char *p = page_address(page);
|
|
struct udf_inode_info *iinfo;
|
|
uint32_t pos;
|
|
|
|
/* We don't support symlinks longer than one block */
|
|
if (inode->i_size > inode->i_sb->s_blocksize) {
|
|
err = -ENAMETOOLONG;
|
|
goto out_unmap;
|
|
}
|
|
|
|
iinfo = UDF_I(inode);
|
|
pos = udf_block_map(inode, 0);
|
|
|
|
down_read(&iinfo->i_data_sem);
|
|
if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
|
|
symlink = iinfo->i_data + iinfo->i_lenEAttr;
|
|
} else {
|
|
bh = sb_bread(inode->i_sb, pos);
|
|
|
|
if (!bh) {
|
|
err = -EIO;
|
|
goto out_unlock_inode;
|
|
}
|
|
|
|
symlink = bh->b_data;
|
|
}
|
|
|
|
err = udf_pc_to_char(inode->i_sb, symlink, inode->i_size, p, PAGE_SIZE);
|
|
brelse(bh);
|
|
if (err)
|
|
goto out_unlock_inode;
|
|
|
|
up_read(&iinfo->i_data_sem);
|
|
SetPageUptodate(page);
|
|
unlock_page(page);
|
|
return 0;
|
|
|
|
out_unlock_inode:
|
|
up_read(&iinfo->i_data_sem);
|
|
SetPageError(page);
|
|
out_unmap:
|
|
unlock_page(page);
|
|
return err;
|
|
}
|
|
|
|
static int udf_symlink_getattr(struct user_namespace *mnt_userns,
|
|
const struct path *path, struct kstat *stat,
|
|
u32 request_mask, unsigned int flags)
|
|
{
|
|
struct dentry *dentry = path->dentry;
|
|
struct inode *inode = d_backing_inode(dentry);
|
|
struct page *page;
|
|
|
|
generic_fillattr(&init_user_ns, inode, stat);
|
|
page = read_mapping_page(inode->i_mapping, 0, NULL);
|
|
if (IS_ERR(page))
|
|
return PTR_ERR(page);
|
|
/*
|
|
* UDF uses non-trivial encoding of symlinks so i_size does not match
|
|
* number of characters reported by readlink(2) which apparently some
|
|
* applications expect. Also POSIX says that "The value returned in the
|
|
* st_size field shall be the length of the contents of the symbolic
|
|
* link, and shall not count a trailing null if one is present." So
|
|
* let's report the length of string returned by readlink(2) for
|
|
* st_size.
|
|
*/
|
|
stat->size = strlen(page_address(page));
|
|
put_page(page);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* symlinks can't do much...
|
|
*/
|
|
const struct address_space_operations udf_symlink_aops = {
|
|
.readpage = udf_symlink_filler,
|
|
};
|
|
|
|
const struct inode_operations udf_symlink_inode_operations = {
|
|
.get_link = page_get_link,
|
|
.getattr = udf_symlink_getattr,
|
|
};
|