mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-10 06:06:40 +07:00
09cbfeaf1a
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time ago with promise that one day it will be possible to implement page cache with bigger chunks than PAGE_SIZE. This promise never materialized. And unlikely will. We have many places where PAGE_CACHE_SIZE assumed to be equal to PAGE_SIZE. And it's constant source of confusion on whether PAGE_CACHE_* or PAGE_* constant should be used in a particular case, especially on the border between fs and mm. Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much breakage to be doable. Let's stop pretending that pages in page cache are special. They are not. The changes are pretty straight-forward: - <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>; - <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>; - PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN}; - page_cache_get() -> get_page(); - page_cache_release() -> put_page(); This patch contains automated changes generated with coccinelle using script below. For some reason, coccinelle doesn't patch header files. I've called spatch for them manually. The only adjustment after coccinelle is revert of changes to PAGE_CAHCE_ALIGN definition: we are going to drop it later. There are few places in the code where coccinelle didn't reach. I'll fix them manually in a separate patch. Comments and documentation also will be addressed with the separate patch. virtual patch @@ expression E; @@ - E << (PAGE_CACHE_SHIFT - PAGE_SHIFT) + E @@ expression E; @@ - E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) + E @@ @@ - PAGE_CACHE_SHIFT + PAGE_SHIFT @@ @@ - PAGE_CACHE_SIZE + PAGE_SIZE @@ @@ - PAGE_CACHE_MASK + PAGE_MASK @@ expression E; @@ - PAGE_CACHE_ALIGN(E) + PAGE_ALIGN(E) @@ expression E; @@ - page_cache_get(E) + get_page(E) @@ expression E; @@ - page_cache_release(E) + put_page(E) Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com> Acked-by: Michal Hocko <mhocko@suse.com> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
1019 lines
21 KiB
C
1019 lines
21 KiB
C
/*
|
|
* Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
|
|
* Licensed under the GPL
|
|
*
|
|
* Ported the filesystem routines to 2.5.
|
|
* 2003-02-10 Petr Baudis <pasky@ucw.cz>
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/magic.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/pagemap.h>
|
|
#include <linux/statfs.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/namei.h>
|
|
#include "hostfs.h"
|
|
#include <init.h>
|
|
#include <kern.h>
|
|
|
|
struct hostfs_inode_info {
|
|
int fd;
|
|
fmode_t mode;
|
|
struct inode vfs_inode;
|
|
struct mutex open_mutex;
|
|
};
|
|
|
|
static inline struct hostfs_inode_info *HOSTFS_I(struct inode *inode)
|
|
{
|
|
return list_entry(inode, struct hostfs_inode_info, vfs_inode);
|
|
}
|
|
|
|
#define FILE_HOSTFS_I(file) HOSTFS_I(file_inode(file))
|
|
|
|
/* Changed in hostfs_args before the kernel starts running */
|
|
static char *root_ino = "";
|
|
static int append = 0;
|
|
|
|
static const struct inode_operations hostfs_iops;
|
|
static const struct inode_operations hostfs_dir_iops;
|
|
static const struct inode_operations hostfs_link_iops;
|
|
|
|
#ifndef MODULE
|
|
static int __init hostfs_args(char *options, int *add)
|
|
{
|
|
char *ptr;
|
|
|
|
ptr = strchr(options, ',');
|
|
if (ptr != NULL)
|
|
*ptr++ = '\0';
|
|
if (*options != '\0')
|
|
root_ino = options;
|
|
|
|
options = ptr;
|
|
while (options) {
|
|
ptr = strchr(options, ',');
|
|
if (ptr != NULL)
|
|
*ptr++ = '\0';
|
|
if (*options != '\0') {
|
|
if (!strcmp(options, "append"))
|
|
append = 1;
|
|
else printf("hostfs_args - unsupported option - %s\n",
|
|
options);
|
|
}
|
|
options = ptr;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
__uml_setup("hostfs=", hostfs_args,
|
|
"hostfs=<root dir>,<flags>,...\n"
|
|
" This is used to set hostfs parameters. The root directory argument\n"
|
|
" is used to confine all hostfs mounts to within the specified directory\n"
|
|
" tree on the host. If this isn't specified, then a user inside UML can\n"
|
|
" mount anything on the host that's accessible to the user that's running\n"
|
|
" it.\n"
|
|
" The only flag currently supported is 'append', which specifies that all\n"
|
|
" files opened by hostfs will be opened in append mode.\n\n"
|
|
);
|
|
#endif
|
|
|
|
static char *__dentry_name(struct dentry *dentry, char *name)
|
|
{
|
|
char *p = dentry_path_raw(dentry, name, PATH_MAX);
|
|
char *root;
|
|
size_t len;
|
|
|
|
root = dentry->d_sb->s_fs_info;
|
|
len = strlen(root);
|
|
if (IS_ERR(p)) {
|
|
__putname(name);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* This function relies on the fact that dentry_path_raw() will place
|
|
* the path name at the end of the provided buffer.
|
|
*/
|
|
BUG_ON(p + strlen(p) + 1 != name + PATH_MAX);
|
|
|
|
strlcpy(name, root, PATH_MAX);
|
|
if (len > p - name) {
|
|
__putname(name);
|
|
return NULL;
|
|
}
|
|
|
|
if (p > name + len)
|
|
strcpy(name + len, p);
|
|
|
|
return name;
|
|
}
|
|
|
|
static char *dentry_name(struct dentry *dentry)
|
|
{
|
|
char *name = __getname();
|
|
if (!name)
|
|
return NULL;
|
|
|
|
return __dentry_name(dentry, name);
|
|
}
|
|
|
|
static char *inode_name(struct inode *ino)
|
|
{
|
|
struct dentry *dentry;
|
|
char *name;
|
|
|
|
dentry = d_find_alias(ino);
|
|
if (!dentry)
|
|
return NULL;
|
|
|
|
name = dentry_name(dentry);
|
|
|
|
dput(dentry);
|
|
|
|
return name;
|
|
}
|
|
|
|
static char *follow_link(char *link)
|
|
{
|
|
int len, n;
|
|
char *name, *resolved, *end;
|
|
|
|
name = __getname();
|
|
if (!name) {
|
|
n = -ENOMEM;
|
|
goto out_free;
|
|
}
|
|
|
|
n = hostfs_do_readlink(link, name, PATH_MAX);
|
|
if (n < 0)
|
|
goto out_free;
|
|
else if (n == PATH_MAX) {
|
|
n = -E2BIG;
|
|
goto out_free;
|
|
}
|
|
|
|
if (*name == '/')
|
|
return name;
|
|
|
|
end = strrchr(link, '/');
|
|
if (end == NULL)
|
|
return name;
|
|
|
|
*(end + 1) = '\0';
|
|
len = strlen(link) + strlen(name) + 1;
|
|
|
|
resolved = kmalloc(len, GFP_KERNEL);
|
|
if (resolved == NULL) {
|
|
n = -ENOMEM;
|
|
goto out_free;
|
|
}
|
|
|
|
sprintf(resolved, "%s%s", link, name);
|
|
__putname(name);
|
|
kfree(link);
|
|
return resolved;
|
|
|
|
out_free:
|
|
__putname(name);
|
|
return ERR_PTR(n);
|
|
}
|
|
|
|
static struct inode *hostfs_iget(struct super_block *sb)
|
|
{
|
|
struct inode *inode = new_inode(sb);
|
|
if (!inode)
|
|
return ERR_PTR(-ENOMEM);
|
|
return inode;
|
|
}
|
|
|
|
static int hostfs_statfs(struct dentry *dentry, struct kstatfs *sf)
|
|
{
|
|
/*
|
|
* do_statfs uses struct statfs64 internally, but the linux kernel
|
|
* struct statfs still has 32-bit versions for most of these fields,
|
|
* so we convert them here
|
|
*/
|
|
int err;
|
|
long long f_blocks;
|
|
long long f_bfree;
|
|
long long f_bavail;
|
|
long long f_files;
|
|
long long f_ffree;
|
|
|
|
err = do_statfs(dentry->d_sb->s_fs_info,
|
|
&sf->f_bsize, &f_blocks, &f_bfree, &f_bavail, &f_files,
|
|
&f_ffree, &sf->f_fsid, sizeof(sf->f_fsid),
|
|
&sf->f_namelen);
|
|
if (err)
|
|
return err;
|
|
sf->f_blocks = f_blocks;
|
|
sf->f_bfree = f_bfree;
|
|
sf->f_bavail = f_bavail;
|
|
sf->f_files = f_files;
|
|
sf->f_ffree = f_ffree;
|
|
sf->f_type = HOSTFS_SUPER_MAGIC;
|
|
return 0;
|
|
}
|
|
|
|
static struct inode *hostfs_alloc_inode(struct super_block *sb)
|
|
{
|
|
struct hostfs_inode_info *hi;
|
|
|
|
hi = kmalloc(sizeof(*hi), GFP_KERNEL_ACCOUNT);
|
|
if (hi == NULL)
|
|
return NULL;
|
|
hi->fd = -1;
|
|
hi->mode = 0;
|
|
inode_init_once(&hi->vfs_inode);
|
|
mutex_init(&hi->open_mutex);
|
|
return &hi->vfs_inode;
|
|
}
|
|
|
|
static void hostfs_evict_inode(struct inode *inode)
|
|
{
|
|
truncate_inode_pages_final(&inode->i_data);
|
|
clear_inode(inode);
|
|
if (HOSTFS_I(inode)->fd != -1) {
|
|
close_file(&HOSTFS_I(inode)->fd);
|
|
HOSTFS_I(inode)->fd = -1;
|
|
}
|
|
}
|
|
|
|
static void hostfs_i_callback(struct rcu_head *head)
|
|
{
|
|
struct inode *inode = container_of(head, struct inode, i_rcu);
|
|
kfree(HOSTFS_I(inode));
|
|
}
|
|
|
|
static void hostfs_destroy_inode(struct inode *inode)
|
|
{
|
|
call_rcu(&inode->i_rcu, hostfs_i_callback);
|
|
}
|
|
|
|
static int hostfs_show_options(struct seq_file *seq, struct dentry *root)
|
|
{
|
|
const char *root_path = root->d_sb->s_fs_info;
|
|
size_t offset = strlen(root_ino) + 1;
|
|
|
|
if (strlen(root_path) > offset)
|
|
seq_show_option(seq, root_path + offset, NULL);
|
|
|
|
if (append)
|
|
seq_puts(seq, ",append");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct super_operations hostfs_sbops = {
|
|
.alloc_inode = hostfs_alloc_inode,
|
|
.destroy_inode = hostfs_destroy_inode,
|
|
.evict_inode = hostfs_evict_inode,
|
|
.statfs = hostfs_statfs,
|
|
.show_options = hostfs_show_options,
|
|
};
|
|
|
|
static int hostfs_readdir(struct file *file, struct dir_context *ctx)
|
|
{
|
|
void *dir;
|
|
char *name;
|
|
unsigned long long next, ino;
|
|
int error, len;
|
|
unsigned int type;
|
|
|
|
name = dentry_name(file->f_path.dentry);
|
|
if (name == NULL)
|
|
return -ENOMEM;
|
|
dir = open_dir(name, &error);
|
|
__putname(name);
|
|
if (dir == NULL)
|
|
return -error;
|
|
next = ctx->pos;
|
|
seek_dir(dir, next);
|
|
while ((name = read_dir(dir, &next, &ino, &len, &type)) != NULL) {
|
|
if (!dir_emit(ctx, name, len, ino, type))
|
|
break;
|
|
ctx->pos = next;
|
|
}
|
|
close_dir(dir);
|
|
return 0;
|
|
}
|
|
|
|
static int hostfs_open(struct inode *ino, struct file *file)
|
|
{
|
|
char *name;
|
|
fmode_t mode;
|
|
int err;
|
|
int r, w, fd;
|
|
|
|
mode = file->f_mode & (FMODE_READ | FMODE_WRITE);
|
|
if ((mode & HOSTFS_I(ino)->mode) == mode)
|
|
return 0;
|
|
|
|
mode |= HOSTFS_I(ino)->mode;
|
|
|
|
retry:
|
|
r = w = 0;
|
|
|
|
if (mode & FMODE_READ)
|
|
r = 1;
|
|
if (mode & FMODE_WRITE)
|
|
r = w = 1;
|
|
|
|
name = dentry_name(file->f_path.dentry);
|
|
if (name == NULL)
|
|
return -ENOMEM;
|
|
|
|
fd = open_file(name, r, w, append);
|
|
__putname(name);
|
|
if (fd < 0)
|
|
return fd;
|
|
|
|
mutex_lock(&HOSTFS_I(ino)->open_mutex);
|
|
/* somebody else had handled it first? */
|
|
if ((mode & HOSTFS_I(ino)->mode) == mode) {
|
|
mutex_unlock(&HOSTFS_I(ino)->open_mutex);
|
|
close_file(&fd);
|
|
return 0;
|
|
}
|
|
if ((mode | HOSTFS_I(ino)->mode) != mode) {
|
|
mode |= HOSTFS_I(ino)->mode;
|
|
mutex_unlock(&HOSTFS_I(ino)->open_mutex);
|
|
close_file(&fd);
|
|
goto retry;
|
|
}
|
|
if (HOSTFS_I(ino)->fd == -1) {
|
|
HOSTFS_I(ino)->fd = fd;
|
|
} else {
|
|
err = replace_file(fd, HOSTFS_I(ino)->fd);
|
|
close_file(&fd);
|
|
if (err < 0) {
|
|
mutex_unlock(&HOSTFS_I(ino)->open_mutex);
|
|
return err;
|
|
}
|
|
}
|
|
HOSTFS_I(ino)->mode = mode;
|
|
mutex_unlock(&HOSTFS_I(ino)->open_mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int hostfs_file_release(struct inode *inode, struct file *file)
|
|
{
|
|
filemap_write_and_wait(inode->i_mapping);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int hostfs_fsync(struct file *file, loff_t start, loff_t end,
|
|
int datasync)
|
|
{
|
|
struct inode *inode = file->f_mapping->host;
|
|
int ret;
|
|
|
|
ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
|
|
if (ret)
|
|
return ret;
|
|
|
|
inode_lock(inode);
|
|
ret = fsync_file(HOSTFS_I(inode)->fd, datasync);
|
|
inode_unlock(inode);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const struct file_operations hostfs_file_fops = {
|
|
.llseek = generic_file_llseek,
|
|
.splice_read = generic_file_splice_read,
|
|
.read_iter = generic_file_read_iter,
|
|
.write_iter = generic_file_write_iter,
|
|
.mmap = generic_file_mmap,
|
|
.open = hostfs_open,
|
|
.release = hostfs_file_release,
|
|
.fsync = hostfs_fsync,
|
|
};
|
|
|
|
static const struct file_operations hostfs_dir_fops = {
|
|
.llseek = generic_file_llseek,
|
|
.iterate = hostfs_readdir,
|
|
.read = generic_read_dir,
|
|
.open = hostfs_open,
|
|
.fsync = hostfs_fsync,
|
|
};
|
|
|
|
static int hostfs_writepage(struct page *page, struct writeback_control *wbc)
|
|
{
|
|
struct address_space *mapping = page->mapping;
|
|
struct inode *inode = mapping->host;
|
|
char *buffer;
|
|
loff_t base = page_offset(page);
|
|
int count = PAGE_SIZE;
|
|
int end_index = inode->i_size >> PAGE_SHIFT;
|
|
int err;
|
|
|
|
if (page->index >= end_index)
|
|
count = inode->i_size & (PAGE_SIZE-1);
|
|
|
|
buffer = kmap(page);
|
|
|
|
err = write_file(HOSTFS_I(inode)->fd, &base, buffer, count);
|
|
if (err != count) {
|
|
ClearPageUptodate(page);
|
|
goto out;
|
|
}
|
|
|
|
if (base > inode->i_size)
|
|
inode->i_size = base;
|
|
|
|
if (PageError(page))
|
|
ClearPageError(page);
|
|
err = 0;
|
|
|
|
out:
|
|
kunmap(page);
|
|
|
|
unlock_page(page);
|
|
return err;
|
|
}
|
|
|
|
static int hostfs_readpage(struct file *file, struct page *page)
|
|
{
|
|
char *buffer;
|
|
loff_t start = page_offset(page);
|
|
int bytes_read, ret = 0;
|
|
|
|
buffer = kmap(page);
|
|
bytes_read = read_file(FILE_HOSTFS_I(file)->fd, &start, buffer,
|
|
PAGE_SIZE);
|
|
if (bytes_read < 0) {
|
|
ClearPageUptodate(page);
|
|
SetPageError(page);
|
|
ret = bytes_read;
|
|
goto out;
|
|
}
|
|
|
|
memset(buffer + bytes_read, 0, PAGE_SIZE - bytes_read);
|
|
|
|
ClearPageError(page);
|
|
SetPageUptodate(page);
|
|
|
|
out:
|
|
flush_dcache_page(page);
|
|
kunmap(page);
|
|
unlock_page(page);
|
|
return ret;
|
|
}
|
|
|
|
static int hostfs_write_begin(struct file *file, struct address_space *mapping,
|
|
loff_t pos, unsigned len, unsigned flags,
|
|
struct page **pagep, void **fsdata)
|
|
{
|
|
pgoff_t index = pos >> PAGE_SHIFT;
|
|
|
|
*pagep = grab_cache_page_write_begin(mapping, index, flags);
|
|
if (!*pagep)
|
|
return -ENOMEM;
|
|
return 0;
|
|
}
|
|
|
|
static int hostfs_write_end(struct file *file, struct address_space *mapping,
|
|
loff_t pos, unsigned len, unsigned copied,
|
|
struct page *page, void *fsdata)
|
|
{
|
|
struct inode *inode = mapping->host;
|
|
void *buffer;
|
|
unsigned from = pos & (PAGE_SIZE - 1);
|
|
int err;
|
|
|
|
buffer = kmap(page);
|
|
err = write_file(FILE_HOSTFS_I(file)->fd, &pos, buffer + from, copied);
|
|
kunmap(page);
|
|
|
|
if (!PageUptodate(page) && err == PAGE_SIZE)
|
|
SetPageUptodate(page);
|
|
|
|
/*
|
|
* If err > 0, write_file has added err to pos, so we are comparing
|
|
* i_size against the last byte written.
|
|
*/
|
|
if (err > 0 && (pos > inode->i_size))
|
|
inode->i_size = pos;
|
|
unlock_page(page);
|
|
put_page(page);
|
|
|
|
return err;
|
|
}
|
|
|
|
static const struct address_space_operations hostfs_aops = {
|
|
.writepage = hostfs_writepage,
|
|
.readpage = hostfs_readpage,
|
|
.set_page_dirty = __set_page_dirty_nobuffers,
|
|
.write_begin = hostfs_write_begin,
|
|
.write_end = hostfs_write_end,
|
|
};
|
|
|
|
static int read_name(struct inode *ino, char *name)
|
|
{
|
|
dev_t rdev;
|
|
struct hostfs_stat st;
|
|
int err = stat_file(name, &st, -1);
|
|
if (err)
|
|
return err;
|
|
|
|
/* Reencode maj and min with the kernel encoding.*/
|
|
rdev = MKDEV(st.maj, st.min);
|
|
|
|
switch (st.mode & S_IFMT) {
|
|
case S_IFLNK:
|
|
ino->i_op = &hostfs_link_iops;
|
|
break;
|
|
case S_IFDIR:
|
|
ino->i_op = &hostfs_dir_iops;
|
|
ino->i_fop = &hostfs_dir_fops;
|
|
break;
|
|
case S_IFCHR:
|
|
case S_IFBLK:
|
|
case S_IFIFO:
|
|
case S_IFSOCK:
|
|
init_special_inode(ino, st.mode & S_IFMT, rdev);
|
|
ino->i_op = &hostfs_iops;
|
|
break;
|
|
case S_IFREG:
|
|
ino->i_op = &hostfs_iops;
|
|
ino->i_fop = &hostfs_file_fops;
|
|
ino->i_mapping->a_ops = &hostfs_aops;
|
|
break;
|
|
default:
|
|
return -EIO;
|
|
}
|
|
|
|
ino->i_ino = st.ino;
|
|
ino->i_mode = st.mode;
|
|
set_nlink(ino, st.nlink);
|
|
i_uid_write(ino, st.uid);
|
|
i_gid_write(ino, st.gid);
|
|
ino->i_atime = st.atime;
|
|
ino->i_mtime = st.mtime;
|
|
ino->i_ctime = st.ctime;
|
|
ino->i_size = st.size;
|
|
ino->i_blocks = st.blocks;
|
|
return 0;
|
|
}
|
|
|
|
static int hostfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
|
|
bool excl)
|
|
{
|
|
struct inode *inode;
|
|
char *name;
|
|
int error, fd;
|
|
|
|
inode = hostfs_iget(dir->i_sb);
|
|
if (IS_ERR(inode)) {
|
|
error = PTR_ERR(inode);
|
|
goto out;
|
|
}
|
|
|
|
error = -ENOMEM;
|
|
name = dentry_name(dentry);
|
|
if (name == NULL)
|
|
goto out_put;
|
|
|
|
fd = file_create(name, mode & 0777);
|
|
if (fd < 0)
|
|
error = fd;
|
|
else
|
|
error = read_name(inode, name);
|
|
|
|
__putname(name);
|
|
if (error)
|
|
goto out_put;
|
|
|
|
HOSTFS_I(inode)->fd = fd;
|
|
HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE;
|
|
d_instantiate(dentry, inode);
|
|
return 0;
|
|
|
|
out_put:
|
|
iput(inode);
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
|
|
unsigned int flags)
|
|
{
|
|
struct inode *inode;
|
|
char *name;
|
|
int err;
|
|
|
|
inode = hostfs_iget(ino->i_sb);
|
|
if (IS_ERR(inode)) {
|
|
err = PTR_ERR(inode);
|
|
goto out;
|
|
}
|
|
|
|
err = -ENOMEM;
|
|
name = dentry_name(dentry);
|
|
if (name == NULL)
|
|
goto out_put;
|
|
|
|
err = read_name(inode, name);
|
|
|
|
__putname(name);
|
|
if (err == -ENOENT) {
|
|
iput(inode);
|
|
inode = NULL;
|
|
}
|
|
else if (err)
|
|
goto out_put;
|
|
|
|
d_add(dentry, inode);
|
|
return NULL;
|
|
|
|
out_put:
|
|
iput(inode);
|
|
out:
|
|
return ERR_PTR(err);
|
|
}
|
|
|
|
static int hostfs_link(struct dentry *to, struct inode *ino,
|
|
struct dentry *from)
|
|
{
|
|
char *from_name, *to_name;
|
|
int err;
|
|
|
|
if ((from_name = dentry_name(from)) == NULL)
|
|
return -ENOMEM;
|
|
to_name = dentry_name(to);
|
|
if (to_name == NULL) {
|
|
__putname(from_name);
|
|
return -ENOMEM;
|
|
}
|
|
err = link_file(to_name, from_name);
|
|
__putname(from_name);
|
|
__putname(to_name);
|
|
return err;
|
|
}
|
|
|
|
static int hostfs_unlink(struct inode *ino, struct dentry *dentry)
|
|
{
|
|
char *file;
|
|
int err;
|
|
|
|
if (append)
|
|
return -EPERM;
|
|
|
|
if ((file = dentry_name(dentry)) == NULL)
|
|
return -ENOMEM;
|
|
|
|
err = unlink_file(file);
|
|
__putname(file);
|
|
return err;
|
|
}
|
|
|
|
static int hostfs_symlink(struct inode *ino, struct dentry *dentry,
|
|
const char *to)
|
|
{
|
|
char *file;
|
|
int err;
|
|
|
|
if ((file = dentry_name(dentry)) == NULL)
|
|
return -ENOMEM;
|
|
err = make_symlink(file, to);
|
|
__putname(file);
|
|
return err;
|
|
}
|
|
|
|
static int hostfs_mkdir(struct inode *ino, struct dentry *dentry, umode_t mode)
|
|
{
|
|
char *file;
|
|
int err;
|
|
|
|
if ((file = dentry_name(dentry)) == NULL)
|
|
return -ENOMEM;
|
|
err = do_mkdir(file, mode);
|
|
__putname(file);
|
|
return err;
|
|
}
|
|
|
|
static int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
|
|
{
|
|
char *file;
|
|
int err;
|
|
|
|
if ((file = dentry_name(dentry)) == NULL)
|
|
return -ENOMEM;
|
|
err = do_rmdir(file);
|
|
__putname(file);
|
|
return err;
|
|
}
|
|
|
|
static int hostfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
|
|
{
|
|
struct inode *inode;
|
|
char *name;
|
|
int err;
|
|
|
|
inode = hostfs_iget(dir->i_sb);
|
|
if (IS_ERR(inode)) {
|
|
err = PTR_ERR(inode);
|
|
goto out;
|
|
}
|
|
|
|
err = -ENOMEM;
|
|
name = dentry_name(dentry);
|
|
if (name == NULL)
|
|
goto out_put;
|
|
|
|
init_special_inode(inode, mode, dev);
|
|
err = do_mknod(name, mode, MAJOR(dev), MINOR(dev));
|
|
if (err)
|
|
goto out_free;
|
|
|
|
err = read_name(inode, name);
|
|
__putname(name);
|
|
if (err)
|
|
goto out_put;
|
|
|
|
d_instantiate(dentry, inode);
|
|
return 0;
|
|
|
|
out_free:
|
|
__putname(name);
|
|
out_put:
|
|
iput(inode);
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
static int hostfs_rename2(struct inode *old_dir, struct dentry *old_dentry,
|
|
struct inode *new_dir, struct dentry *new_dentry,
|
|
unsigned int flags)
|
|
{
|
|
char *old_name, *new_name;
|
|
int err;
|
|
|
|
if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
|
|
return -EINVAL;
|
|
|
|
old_name = dentry_name(old_dentry);
|
|
if (old_name == NULL)
|
|
return -ENOMEM;
|
|
new_name = dentry_name(new_dentry);
|
|
if (new_name == NULL) {
|
|
__putname(old_name);
|
|
return -ENOMEM;
|
|
}
|
|
if (!flags)
|
|
err = rename_file(old_name, new_name);
|
|
else
|
|
err = rename2_file(old_name, new_name, flags);
|
|
|
|
__putname(old_name);
|
|
__putname(new_name);
|
|
return err;
|
|
}
|
|
|
|
static int hostfs_permission(struct inode *ino, int desired)
|
|
{
|
|
char *name;
|
|
int r = 0, w = 0, x = 0, err;
|
|
|
|
if (desired & MAY_NOT_BLOCK)
|
|
return -ECHILD;
|
|
|
|
if (desired & MAY_READ) r = 1;
|
|
if (desired & MAY_WRITE) w = 1;
|
|
if (desired & MAY_EXEC) x = 1;
|
|
name = inode_name(ino);
|
|
if (name == NULL)
|
|
return -ENOMEM;
|
|
|
|
if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) ||
|
|
S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode))
|
|
err = 0;
|
|
else
|
|
err = access_file(name, r, w, x);
|
|
__putname(name);
|
|
if (!err)
|
|
err = generic_permission(ino, desired);
|
|
return err;
|
|
}
|
|
|
|
static int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
|
|
{
|
|
struct inode *inode = d_inode(dentry);
|
|
struct hostfs_iattr attrs;
|
|
char *name;
|
|
int err;
|
|
|
|
int fd = HOSTFS_I(inode)->fd;
|
|
|
|
err = inode_change_ok(inode, attr);
|
|
if (err)
|
|
return err;
|
|
|
|
if (append)
|
|
attr->ia_valid &= ~ATTR_SIZE;
|
|
|
|
attrs.ia_valid = 0;
|
|
if (attr->ia_valid & ATTR_MODE) {
|
|
attrs.ia_valid |= HOSTFS_ATTR_MODE;
|
|
attrs.ia_mode = attr->ia_mode;
|
|
}
|
|
if (attr->ia_valid & ATTR_UID) {
|
|
attrs.ia_valid |= HOSTFS_ATTR_UID;
|
|
attrs.ia_uid = from_kuid(&init_user_ns, attr->ia_uid);
|
|
}
|
|
if (attr->ia_valid & ATTR_GID) {
|
|
attrs.ia_valid |= HOSTFS_ATTR_GID;
|
|
attrs.ia_gid = from_kgid(&init_user_ns, attr->ia_gid);
|
|
}
|
|
if (attr->ia_valid & ATTR_SIZE) {
|
|
attrs.ia_valid |= HOSTFS_ATTR_SIZE;
|
|
attrs.ia_size = attr->ia_size;
|
|
}
|
|
if (attr->ia_valid & ATTR_ATIME) {
|
|
attrs.ia_valid |= HOSTFS_ATTR_ATIME;
|
|
attrs.ia_atime = attr->ia_atime;
|
|
}
|
|
if (attr->ia_valid & ATTR_MTIME) {
|
|
attrs.ia_valid |= HOSTFS_ATTR_MTIME;
|
|
attrs.ia_mtime = attr->ia_mtime;
|
|
}
|
|
if (attr->ia_valid & ATTR_CTIME) {
|
|
attrs.ia_valid |= HOSTFS_ATTR_CTIME;
|
|
attrs.ia_ctime = attr->ia_ctime;
|
|
}
|
|
if (attr->ia_valid & ATTR_ATIME_SET) {
|
|
attrs.ia_valid |= HOSTFS_ATTR_ATIME_SET;
|
|
}
|
|
if (attr->ia_valid & ATTR_MTIME_SET) {
|
|
attrs.ia_valid |= HOSTFS_ATTR_MTIME_SET;
|
|
}
|
|
name = dentry_name(dentry);
|
|
if (name == NULL)
|
|
return -ENOMEM;
|
|
err = set_attr(name, &attrs, fd);
|
|
__putname(name);
|
|
if (err)
|
|
return err;
|
|
|
|
if ((attr->ia_valid & ATTR_SIZE) &&
|
|
attr->ia_size != i_size_read(inode))
|
|
truncate_setsize(inode, attr->ia_size);
|
|
|
|
setattr_copy(inode, attr);
|
|
mark_inode_dirty(inode);
|
|
return 0;
|
|
}
|
|
|
|
static const struct inode_operations hostfs_iops = {
|
|
.permission = hostfs_permission,
|
|
.setattr = hostfs_setattr,
|
|
};
|
|
|
|
static const struct inode_operations hostfs_dir_iops = {
|
|
.create = hostfs_create,
|
|
.lookup = hostfs_lookup,
|
|
.link = hostfs_link,
|
|
.unlink = hostfs_unlink,
|
|
.symlink = hostfs_symlink,
|
|
.mkdir = hostfs_mkdir,
|
|
.rmdir = hostfs_rmdir,
|
|
.mknod = hostfs_mknod,
|
|
.rename2 = hostfs_rename2,
|
|
.permission = hostfs_permission,
|
|
.setattr = hostfs_setattr,
|
|
};
|
|
|
|
static const char *hostfs_get_link(struct dentry *dentry,
|
|
struct inode *inode,
|
|
struct delayed_call *done)
|
|
{
|
|
char *link;
|
|
if (!dentry)
|
|
return ERR_PTR(-ECHILD);
|
|
link = kmalloc(PATH_MAX, GFP_KERNEL);
|
|
if (link) {
|
|
char *path = dentry_name(dentry);
|
|
int err = -ENOMEM;
|
|
if (path) {
|
|
err = hostfs_do_readlink(path, link, PATH_MAX);
|
|
if (err == PATH_MAX)
|
|
err = -E2BIG;
|
|
__putname(path);
|
|
}
|
|
if (err < 0) {
|
|
kfree(link);
|
|
return ERR_PTR(err);
|
|
}
|
|
} else {
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
set_delayed_call(done, kfree_link, link);
|
|
return link;
|
|
}
|
|
|
|
static const struct inode_operations hostfs_link_iops = {
|
|
.readlink = generic_readlink,
|
|
.get_link = hostfs_get_link,
|
|
};
|
|
|
|
static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
|
|
{
|
|
struct inode *root_inode;
|
|
char *host_root_path, *req_root = d;
|
|
int err;
|
|
|
|
sb->s_blocksize = 1024;
|
|
sb->s_blocksize_bits = 10;
|
|
sb->s_magic = HOSTFS_SUPER_MAGIC;
|
|
sb->s_op = &hostfs_sbops;
|
|
sb->s_d_op = &simple_dentry_operations;
|
|
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
|
|
|
/* NULL is printed as <NULL> by sprintf: avoid that. */
|
|
if (req_root == NULL)
|
|
req_root = "";
|
|
|
|
err = -ENOMEM;
|
|
sb->s_fs_info = host_root_path =
|
|
kmalloc(strlen(root_ino) + strlen(req_root) + 2, GFP_KERNEL);
|
|
if (host_root_path == NULL)
|
|
goto out;
|
|
|
|
sprintf(host_root_path, "%s/%s", root_ino, req_root);
|
|
|
|
root_inode = new_inode(sb);
|
|
if (!root_inode)
|
|
goto out;
|
|
|
|
err = read_name(root_inode, host_root_path);
|
|
if (err)
|
|
goto out_put;
|
|
|
|
if (S_ISLNK(root_inode->i_mode)) {
|
|
char *name = follow_link(host_root_path);
|
|
if (IS_ERR(name))
|
|
err = PTR_ERR(name);
|
|
else
|
|
err = read_name(root_inode, name);
|
|
kfree(name);
|
|
if (err)
|
|
goto out_put;
|
|
}
|
|
|
|
err = -ENOMEM;
|
|
sb->s_root = d_make_root(root_inode);
|
|
if (sb->s_root == NULL)
|
|
goto out;
|
|
|
|
return 0;
|
|
|
|
out_put:
|
|
iput(root_inode);
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
static struct dentry *hostfs_read_sb(struct file_system_type *type,
|
|
int flags, const char *dev_name,
|
|
void *data)
|
|
{
|
|
return mount_nodev(type, flags, data, hostfs_fill_sb_common);
|
|
}
|
|
|
|
static void hostfs_kill_sb(struct super_block *s)
|
|
{
|
|
kill_anon_super(s);
|
|
kfree(s->s_fs_info);
|
|
}
|
|
|
|
static struct file_system_type hostfs_type = {
|
|
.owner = THIS_MODULE,
|
|
.name = "hostfs",
|
|
.mount = hostfs_read_sb,
|
|
.kill_sb = hostfs_kill_sb,
|
|
.fs_flags = 0,
|
|
};
|
|
MODULE_ALIAS_FS("hostfs");
|
|
|
|
static int __init init_hostfs(void)
|
|
{
|
|
return register_filesystem(&hostfs_type);
|
|
}
|
|
|
|
static void __exit exit_hostfs(void)
|
|
{
|
|
unregister_filesystem(&hostfs_type);
|
|
}
|
|
|
|
module_init(init_hostfs)
|
|
module_exit(exit_hostfs)
|
|
MODULE_LICENSE("GPL");
|