2019-05-28 16:57:16 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-09-09 20:04:19 +00:00
|
|
|
/*
|
2005-09-09 20:04:26 +00:00
|
|
|
* This file contains vfs inode ops for the 9P2000 protocol.
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
|
|
|
|
* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
|
|
|
|
*/
|
|
|
|
|
2011-11-28 18:40:46 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2005-09-09 20:04:19 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/inet.h>
|
|
|
|
#include <linux/namei.h>
|
Detach sched.h from mm.h
First thing mm.h does is including sched.h solely for can_do_mlock() inline
function which has "current" dereference inside. By dealing with can_do_mlock()
mm.h can be detached from sched.h which is good. See below, why.
This patch
a) removes unconditional inclusion of sched.h from mm.h
b) makes can_do_mlock() normal function in mm/mlock.c
c) exports can_do_mlock() to not break compilation
d) adds sched.h inclusions back to files that were getting it indirectly.
e) adds less bloated headers to some files (asm/signal.h, jiffies.h) that were
getting them indirectly
Net result is:
a) mm.h users would get less code to open, read, preprocess, parse, ... if
they don't need sched.h
b) sched.h stops being dependency for significant number of files:
on x86_64 allmodconfig touching sched.h results in recompile of 4083 files,
after patch it's only 3744 (-8.3%).
Cross-compile tested on
all arm defconfigs, all mips defconfigs, all powerpc defconfigs,
alpha alpha-up
arm
i386 i386-up i386-defconfig i386-allnoconfig
ia64 ia64-up
m68k
mips
parisc parisc-up
powerpc powerpc-up
s390 s390-up
sparc sparc-up
sparc64 sparc64-up
um-x86_64
x86_64 x86_64-up x86_64-defconfig x86_64-allnoconfig
as well as my two usual configs.
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-20 21:22:52 +00:00
|
|
|
#include <linux/sched.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2010-05-31 07:52:56 +00:00
|
|
|
#include <linux/xattr.h>
|
2010-09-27 18:57:39 +00:00
|
|
|
#include <linux/posix_acl.h>
|
2007-07-10 22:57:28 +00:00
|
|
|
#include <net/9p/9p.h>
|
|
|
|
#include <net/9p/client.h>
|
2005-09-09 20:04:19 +00:00
|
|
|
|
|
|
|
#include "v9fs.h"
|
|
|
|
#include "v9fs_vfs.h"
|
|
|
|
#include "fid.h"
|
2009-09-23 18:00:27 +00:00
|
|
|
#include "cache.h"
|
2010-05-31 07:52:56 +00:00
|
|
|
#include "xattr.h"
|
2010-09-27 18:57:39 +00:00
|
|
|
#include "acl.h"
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2007-02-12 08:55:38 +00:00
|
|
|
static const struct inode_operations v9fs_dir_inode_operations;
|
2010-03-25 12:41:54 +00:00
|
|
|
static const struct inode_operations v9fs_dir_inode_operations_dotu;
|
2007-02-12 08:55:38 +00:00
|
|
|
static const struct inode_operations v9fs_file_inode_operations;
|
|
|
|
static const struct inode_operations v9fs_symlink_inode_operations;
|
2010-10-12 07:32:25 +00:00
|
|
|
|
2005-09-09 20:04:19 +00:00
|
|
|
/**
|
|
|
|
* unixmode2p9mode - convert unix mode bits to plan 9
|
|
|
|
* @v9ses: v9fs session information
|
|
|
|
* @mode: mode to convert
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-07-26 06:53:22 +00:00
|
|
|
static u32 unixmode2p9mode(struct v9fs_session_info *v9ses, umode_t mode)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
|
|
|
int res;
|
2021-11-02 13:16:43 +00:00
|
|
|
|
2005-09-09 20:04:19 +00:00
|
|
|
res = mode & 0777;
|
|
|
|
if (S_ISDIR(mode))
|
2007-07-10 22:57:28 +00:00
|
|
|
res |= P9_DMDIR;
|
2010-03-05 18:48:00 +00:00
|
|
|
if (v9fs_proto_dotu(v9ses)) {
|
2005-09-09 20:04:19 +00:00
|
|
|
if (v9ses->nodev == 0) {
|
|
|
|
if (S_ISSOCK(mode))
|
2007-07-10 22:57:28 +00:00
|
|
|
res |= P9_DMSOCKET;
|
2005-09-09 20:04:19 +00:00
|
|
|
if (S_ISFIFO(mode))
|
2007-07-10 22:57:28 +00:00
|
|
|
res |= P9_DMNAMEDPIPE;
|
2005-09-09 20:04:19 +00:00
|
|
|
if (S_ISBLK(mode))
|
2007-07-10 22:57:28 +00:00
|
|
|
res |= P9_DMDEVICE;
|
2005-09-09 20:04:19 +00:00
|
|
|
if (S_ISCHR(mode))
|
2007-07-10 22:57:28 +00:00
|
|
|
res |= P9_DMDEVICE;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((mode & S_ISUID) == S_ISUID)
|
2007-07-10 22:57:28 +00:00
|
|
|
res |= P9_DMSETUID;
|
2005-09-09 20:04:19 +00:00
|
|
|
if ((mode & S_ISGID) == S_ISGID)
|
2007-07-10 22:57:28 +00:00
|
|
|
res |= P9_DMSETGID;
|
2008-02-07 01:25:06 +00:00
|
|
|
if ((mode & S_ISVTX) == S_ISVTX)
|
|
|
|
res |= P9_DMSETVTX;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2012-01-05 08:09:49 +00:00
|
|
|
/**
|
|
|
|
* p9mode2perm- convert plan9 mode bits to unix permission bits
|
|
|
|
* @v9ses: v9fs session information
|
|
|
|
* @stat: p9_wstat from which mode need to be derived
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int p9mode2perm(struct v9fs_session_info *v9ses,
|
|
|
|
struct p9_wstat *stat)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
int mode = stat->mode;
|
|
|
|
|
|
|
|
res = mode & S_IALLUGO;
|
|
|
|
if (v9fs_proto_dotu(v9ses)) {
|
|
|
|
if ((mode & P9_DMSETUID) == P9_DMSETUID)
|
|
|
|
res |= S_ISUID;
|
|
|
|
|
|
|
|
if ((mode & P9_DMSETGID) == P9_DMSETGID)
|
|
|
|
res |= S_ISGID;
|
|
|
|
|
|
|
|
if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
|
|
|
|
res |= S_ISVTX;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2005-09-09 20:04:19 +00:00
|
|
|
/**
|
|
|
|
* p9mode2unixmode- convert plan9 mode bits to unix mode bits
|
|
|
|
* @v9ses: v9fs session information
|
2011-07-25 18:06:33 +00:00
|
|
|
* @stat: p9_wstat from which mode need to be derived
|
|
|
|
* @rdev: major number, minor number in case of device files.
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
2011-07-26 06:53:22 +00:00
|
|
|
static umode_t p9mode2unixmode(struct v9fs_session_info *v9ses,
|
|
|
|
struct p9_wstat *stat, dev_t *rdev)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2021-11-02 13:24:22 +00:00
|
|
|
int res, r;
|
2011-07-26 06:53:22 +00:00
|
|
|
u32 mode = stat->mode;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2011-07-25 18:06:33 +00:00
|
|
|
*rdev = 0;
|
2012-01-05 08:09:49 +00:00
|
|
|
res = p9mode2perm(v9ses, stat);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
if ((mode & P9_DMDIR) == P9_DMDIR)
|
2005-09-09 20:04:19 +00:00
|
|
|
res |= S_IFDIR;
|
2010-03-05 18:48:00 +00:00
|
|
|
else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
|
2005-09-09 20:04:19 +00:00
|
|
|
res |= S_IFLNK;
|
2010-03-05 18:48:00 +00:00
|
|
|
else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
|
2005-09-09 20:04:19 +00:00
|
|
|
&& (v9ses->nodev == 0))
|
|
|
|
res |= S_IFSOCK;
|
2010-03-05 18:48:00 +00:00
|
|
|
else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
|
2005-09-09 20:04:19 +00:00
|
|
|
&& (v9ses->nodev == 0))
|
|
|
|
res |= S_IFIFO;
|
2010-03-05 18:48:00 +00:00
|
|
|
else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
|
2011-07-25 18:06:33 +00:00
|
|
|
&& (v9ses->nodev == 0)) {
|
2021-11-02 13:24:22 +00:00
|
|
|
char type = 0;
|
2011-07-25 18:06:33 +00:00
|
|
|
int major = -1, minor = -1;
|
|
|
|
|
2021-11-02 13:24:22 +00:00
|
|
|
r = sscanf(stat->extension, "%c %i %i", &type, &major, &minor);
|
|
|
|
if (r != 3) {
|
|
|
|
p9_debug(P9_DEBUG_ERROR,
|
|
|
|
"invalid device string, umode will be bogus: %s\n",
|
|
|
|
stat->extension);
|
|
|
|
return res;
|
|
|
|
}
|
2011-07-25 18:06:33 +00:00
|
|
|
switch (type) {
|
|
|
|
case 'c':
|
|
|
|
res |= S_IFCHR;
|
|
|
|
break;
|
|
|
|
case 'b':
|
|
|
|
res |= S_IFBLK;
|
|
|
|
break;
|
|
|
|
default:
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "Unknown special type %c %s\n",
|
|
|
|
type, stat->extension);
|
2019-12-19 10:48:37 +00:00
|
|
|
}
|
2011-07-25 18:06:33 +00:00
|
|
|
*rdev = MKDEV(major, minor);
|
|
|
|
} else
|
2005-09-09 20:04:19 +00:00
|
|
|
res |= S_IFREG;
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2008-03-05 13:08:09 +00:00
|
|
|
/**
|
|
|
|
* v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
|
|
|
|
* @uflags: flags to convert
|
2008-06-24 22:39:39 +00:00
|
|
|
* @extended: if .u extensions are active
|
2008-03-05 13:08:09 +00:00
|
|
|
*/
|
|
|
|
|
2008-06-24 22:39:39 +00:00
|
|
|
int v9fs_uflags2omode(int uflags, int extended)
|
2006-03-02 10:54:30 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
switch (uflags&3) {
|
|
|
|
default:
|
|
|
|
case O_RDONLY:
|
2007-07-10 22:57:28 +00:00
|
|
|
ret = P9_OREAD;
|
2006-03-02 10:54:30 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case O_WRONLY:
|
2007-07-10 22:57:28 +00:00
|
|
|
ret = P9_OWRITE;
|
2006-03-02 10:54:30 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case O_RDWR:
|
2007-07-10 22:57:28 +00:00
|
|
|
ret = P9_ORDWR;
|
2006-03-02 10:54:30 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-06-24 22:39:39 +00:00
|
|
|
if (extended) {
|
|
|
|
if (uflags & O_EXCL)
|
|
|
|
ret |= P9_OEXCL;
|
|
|
|
|
|
|
|
if (uflags & O_APPEND)
|
|
|
|
ret |= P9_OAPPEND;
|
|
|
|
}
|
2006-03-02 10:54:30 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-09-09 20:04:19 +00:00
|
|
|
/**
|
2006-01-08 09:05:00 +00:00
|
|
|
* v9fs_blank_wstat - helper function to setup a 9P stat structure
|
|
|
|
* @wstat: structure to initialize
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2010-02-08 21:36:48 +00:00
|
|
|
void
|
2007-07-10 22:57:28 +00:00
|
|
|
v9fs_blank_wstat(struct p9_wstat *wstat)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2006-01-08 09:05:00 +00:00
|
|
|
wstat->type = ~0;
|
|
|
|
wstat->dev = ~0;
|
|
|
|
wstat->qid.type = ~0;
|
|
|
|
wstat->qid.version = ~0;
|
|
|
|
*((long long *)&wstat->qid.path) = ~0;
|
|
|
|
wstat->mode = ~0;
|
|
|
|
wstat->atime = ~0;
|
|
|
|
wstat->mtime = ~0;
|
|
|
|
wstat->length = ~0;
|
|
|
|
wstat->name = NULL;
|
|
|
|
wstat->uid = NULL;
|
|
|
|
wstat->gid = NULL;
|
|
|
|
wstat->muid = NULL;
|
2013-01-30 00:18:50 +00:00
|
|
|
wstat->n_uid = INVALID_UID;
|
|
|
|
wstat->n_gid = INVALID_GID;
|
|
|
|
wstat->n_muid = INVALID_UID;
|
2006-01-08 09:05:00 +00:00
|
|
|
wstat->extension = NULL;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
2009-09-23 18:00:27 +00:00
|
|
|
/**
|
|
|
|
* v9fs_alloc_inode - helper function to allocate an inode
|
2021-10-04 21:07:22 +00:00
|
|
|
* @sb: The superblock to allocate the inode from
|
2009-09-23 18:00:27 +00:00
|
|
|
*/
|
|
|
|
struct inode *v9fs_alloc_inode(struct super_block *sb)
|
|
|
|
{
|
2011-02-28 11:34:02 +00:00
|
|
|
struct v9fs_inode *v9inode;
|
2021-11-02 13:16:43 +00:00
|
|
|
|
2022-03-22 21:41:03 +00:00
|
|
|
v9inode = alloc_inode_sb(sb, v9fs_inode_cache, GFP_KERNEL);
|
2011-02-28 11:34:02 +00:00
|
|
|
if (!v9inode)
|
2009-09-23 18:00:27 +00:00
|
|
|
return NULL;
|
2011-02-28 11:34:03 +00:00
|
|
|
v9inode->writeback_fid = NULL;
|
2011-02-28 11:34:06 +00:00
|
|
|
v9inode->cache_validity = 0;
|
2011-03-08 11:09:46 +00:00
|
|
|
mutex_init(&v9inode->v_mutex);
|
netfs: Fix gcc-12 warning by embedding vfs inode in netfs_i_context
While randstruct was satisfied with using an open-coded "void *" offset
cast for the netfs_i_context <-> inode casting, __builtin_object_size() as
used by FORTIFY_SOURCE was not as easily fooled. This was causing the
following complaint[1] from gcc v12:
In file included from include/linux/string.h:253,
from include/linux/ceph/ceph_debug.h:7,
from fs/ceph/inode.c:2:
In function 'fortify_memset_chk',
inlined from 'netfs_i_context_init' at include/linux/netfs.h:326:2,
inlined from 'ceph_alloc_inode' at fs/ceph/inode.c:463:2:
include/linux/fortify-string.h:242:25: warning: call to '__write_overflow_field' declared with attribute warning: detected write beyond size of field (1st parameter); maybe use struct_group()? [-Wattribute-warning]
242 | __write_overflow_field(p_size_field, size);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Fix this by embedding a struct inode into struct netfs_i_context (which
should perhaps be renamed to struct netfs_inode). The struct inode
vfs_inode fields are then removed from the 9p, afs, ceph and cifs inode
structs and vfs_inode is then simply changed to "netfs.inode" in those
filesystems.
Further, rename netfs_i_context to netfs_inode, get rid of the
netfs_inode() function that converted a netfs_i_context pointer to an
inode pointer (that can now be done with &ctx->inode) and rename the
netfs_i_context() function to netfs_inode() (which is now a wrapper
around container_of()).
Most of the changes were done with:
perl -p -i -e 's/vfs_inode/netfs.inode/'g \
`git grep -l 'vfs_inode' -- fs/{9p,afs,ceph,cifs}/*.[ch]`
Kees suggested doing it with a pair structure[2] and a special
declarator to insert that into the network filesystem's inode
wrapper[3], but I think it's cleaner to embed it - and then it doesn't
matter if struct randomisation reorders things.
Dave Chinner suggested using a filesystem-specific VFS_I() function in
each filesystem to convert that filesystem's own inode wrapper struct
into the VFS inode struct[4].
Version #2:
- Fix a couple of missed name changes due to a disabled cifs option.
- Rename nfs_i_context to nfs_inode
- Use "netfs" instead of "nic" as the member name in per-fs inode wrapper
structs.
[ This also undoes commit 507160f46c55 ("netfs: gcc-12: temporarily
disable '-Wattribute-warning' for now") that is no longer needed ]
Fixes: bc899ee1c898 ("netfs: Add a netfs inode context")
Reported-by: Jeff Layton <jlayton@kernel.org>
Signed-off-by: David Howells <dhowells@redhat.com>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
Reviewed-by: Kees Cook <keescook@chromium.org>
Reviewed-by: Xiubo Li <xiubli@redhat.com>
cc: Jonathan Corbet <corbet@lwn.net>
cc: Eric Van Hensbergen <ericvh@gmail.com>
cc: Latchesar Ionkov <lucho@ionkov.net>
cc: Dominique Martinet <asmadeus@codewreck.org>
cc: Christian Schoenebeck <linux_oss@crudebyte.com>
cc: Marc Dionne <marc.dionne@auristor.com>
cc: Ilya Dryomov <idryomov@gmail.com>
cc: Steve French <smfrench@gmail.com>
cc: William Kucharski <william.kucharski@oracle.com>
cc: "Matthew Wilcox (Oracle)" <willy@infradead.org>
cc: Dave Chinner <david@fromorbit.com>
cc: linux-doc@vger.kernel.org
cc: v9fs-developer@lists.sourceforge.net
cc: linux-afs@lists.infradead.org
cc: ceph-devel@vger.kernel.org
cc: linux-cifs@vger.kernel.org
cc: samba-technical@lists.samba.org
cc: linux-fsdevel@vger.kernel.org
cc: linux-hardening@vger.kernel.org
Link: https://lore.kernel.org/r/d2ad3a3d7bdd794c6efb562d2f2b655fb67756b9.camel@kernel.org/ [1]
Link: https://lore.kernel.org/r/20220517210230.864239-1-keescook@chromium.org/ [2]
Link: https://lore.kernel.org/r/20220518202212.2322058-1-keescook@chromium.org/ [3]
Link: https://lore.kernel.org/r/20220524101205.GI2306852@dread.disaster.area/ [4]
Link: https://lore.kernel.org/r/165296786831.3591209.12111293034669289733.stgit@warthog.procyon.org.uk/ # v1
Link: https://lore.kernel.org/r/165305805651.4094995.7763502506786714216.stgit@warthog.procyon.org.uk # v2
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2022-06-09 20:46:04 +00:00
|
|
|
return &v9inode->netfs.inode;
|
2009-09-23 18:00:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2019-04-10 19:00:26 +00:00
|
|
|
* v9fs_free_inode - destroy an inode
|
2021-10-04 21:07:22 +00:00
|
|
|
* @inode: The inode to be freed
|
2009-09-23 18:00:27 +00:00
|
|
|
*/
|
|
|
|
|
2019-04-10 19:00:26 +00:00
|
|
|
void v9fs_free_inode(struct inode *inode)
|
2009-09-23 18:00:27 +00:00
|
|
|
{
|
2011-02-28 11:34:02 +00:00
|
|
|
kmem_cache_free(v9fs_inode_cache, V9FS_I(inode));
|
2009-09-23 18:00:27 +00:00
|
|
|
}
|
2011-01-07 06:49:49 +00:00
|
|
|
|
2021-06-29 21:37:05 +00:00
|
|
|
/*
|
|
|
|
* Set parameters for the netfs library
|
|
|
|
*/
|
|
|
|
static void v9fs_set_netfs_context(struct inode *inode)
|
|
|
|
{
|
2022-06-09 22:04:01 +00:00
|
|
|
struct v9fs_inode *v9inode = V9FS_I(inode);
|
|
|
|
netfs_inode_init(&v9inode->netfs, &v9fs_req_ops);
|
2021-06-29 21:37:05 +00:00
|
|
|
}
|
|
|
|
|
2011-02-28 11:34:01 +00:00
|
|
|
int v9fs_init_inode(struct v9fs_session_info *v9ses,
|
2011-07-26 06:53:22 +00:00
|
|
|
struct inode *inode, umode_t mode, dev_t rdev)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2011-02-28 11:34:01 +00:00
|
|
|
int err = 0;
|
2009-07-19 19:41:56 +00:00
|
|
|
|
2023-01-13 11:49:25 +00:00
|
|
|
inode_init_owner(&nop_mnt_idmap, inode, NULL, mode);
|
2009-07-19 19:41:56 +00:00
|
|
|
inode->i_blocks = 0;
|
2011-07-25 18:06:33 +00:00
|
|
|
inode->i_rdev = rdev;
|
2016-09-14 14:48:04 +00:00
|
|
|
inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
|
2009-07-19 19:41:56 +00:00
|
|
|
inode->i_mapping->a_ops = &v9fs_addr_operations;
|
2020-09-23 14:11:44 +00:00
|
|
|
inode->i_private = NULL;
|
2009-07-19 19:41:56 +00:00
|
|
|
|
|
|
|
switch (mode & S_IFMT) {
|
|
|
|
case S_IFIFO:
|
|
|
|
case S_IFBLK:
|
|
|
|
case S_IFCHR:
|
|
|
|
case S_IFSOCK:
|
2010-06-16 08:57:01 +00:00
|
|
|
if (v9fs_proto_dotl(v9ses)) {
|
|
|
|
inode->i_op = &v9fs_file_inode_operations_dotl;
|
|
|
|
} else if (v9fs_proto_dotu(v9ses)) {
|
|
|
|
inode->i_op = &v9fs_file_inode_operations;
|
|
|
|
} else {
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_ERROR,
|
|
|
|
"special files without extended mode\n");
|
2009-07-19 19:41:56 +00:00
|
|
|
err = -EINVAL;
|
|
|
|
goto error;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
2009-07-19 19:41:56 +00:00
|
|
|
init_special_inode(inode, inode->i_mode, inode->i_rdev);
|
|
|
|
break;
|
|
|
|
case S_IFREG:
|
2010-03-25 12:41:54 +00:00
|
|
|
if (v9fs_proto_dotl(v9ses)) {
|
|
|
|
inode->i_op = &v9fs_file_inode_operations_dotl;
|
2014-01-10 12:44:09 +00:00
|
|
|
if (v9ses->cache == CACHE_LOOSE ||
|
|
|
|
v9ses->cache == CACHE_FSCACHE)
|
2011-02-28 11:33:54 +00:00
|
|
|
inode->i_fop =
|
|
|
|
&v9fs_cached_file_operations_dotl;
|
2014-01-10 12:44:09 +00:00
|
|
|
else if (v9ses->cache == CACHE_MMAP)
|
|
|
|
inode->i_fop = &v9fs_mmap_file_operations_dotl;
|
2011-02-28 11:33:54 +00:00
|
|
|
else
|
|
|
|
inode->i_fop = &v9fs_file_operations_dotl;
|
2010-03-25 12:41:54 +00:00
|
|
|
} else {
|
|
|
|
inode->i_op = &v9fs_file_inode_operations;
|
2014-01-10 12:44:09 +00:00
|
|
|
if (v9ses->cache == CACHE_LOOSE ||
|
|
|
|
v9ses->cache == CACHE_FSCACHE)
|
|
|
|
inode->i_fop =
|
|
|
|
&v9fs_cached_file_operations;
|
|
|
|
else if (v9ses->cache == CACHE_MMAP)
|
|
|
|
inode->i_fop = &v9fs_mmap_file_operations;
|
2011-02-28 11:33:54 +00:00
|
|
|
else
|
|
|
|
inode->i_fop = &v9fs_file_operations;
|
2010-03-25 12:41:54 +00:00
|
|
|
}
|
|
|
|
|
2009-07-19 19:41:56 +00:00
|
|
|
break;
|
|
|
|
case S_IFLNK:
|
2010-03-25 12:41:54 +00:00
|
|
|
if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_ERROR,
|
|
|
|
"extended modes used with legacy protocol\n");
|
2009-07-19 19:41:56 +00:00
|
|
|
err = -EINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
2010-03-25 12:41:54 +00:00
|
|
|
|
|
|
|
if (v9fs_proto_dotl(v9ses))
|
|
|
|
inode->i_op = &v9fs_symlink_inode_operations_dotl;
|
|
|
|
else
|
|
|
|
inode->i_op = &v9fs_symlink_inode_operations;
|
|
|
|
|
2009-07-19 19:41:56 +00:00
|
|
|
break;
|
|
|
|
case S_IFDIR:
|
|
|
|
inc_nlink(inode);
|
2010-03-25 12:41:54 +00:00
|
|
|
if (v9fs_proto_dotl(v9ses))
|
|
|
|
inode->i_op = &v9fs_dir_inode_operations_dotl;
|
|
|
|
else if (v9fs_proto_dotu(v9ses))
|
|
|
|
inode->i_op = &v9fs_dir_inode_operations_dotu;
|
2009-07-19 19:41:56 +00:00
|
|
|
else
|
|
|
|
inode->i_op = &v9fs_dir_inode_operations;
|
2010-03-25 12:41:54 +00:00
|
|
|
|
|
|
|
if (v9fs_proto_dotl(v9ses))
|
|
|
|
inode->i_fop = &v9fs_dir_operations_dotl;
|
|
|
|
else
|
|
|
|
inode->i_fop = &v9fs_dir_operations;
|
|
|
|
|
2009-07-19 19:41:56 +00:00
|
|
|
break;
|
|
|
|
default:
|
2012-01-10 23:09:01 +00:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "BAD mode 0x%hx S_IFMT 0x%x\n",
|
2011-11-28 18:40:46 +00:00
|
|
|
mode, mode & S_IFMT);
|
2009-07-19 19:41:56 +00:00
|
|
|
err = -EINVAL;
|
|
|
|
goto error;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
2021-06-29 21:37:05 +00:00
|
|
|
|
|
|
|
v9fs_set_netfs_context(inode);
|
2011-02-28 11:34:01 +00:00
|
|
|
error:
|
|
|
|
return err;
|
2009-07-19 19:41:56 +00:00
|
|
|
|
2011-02-28 11:34:01 +00:00
|
|
|
}
|
2009-07-19 19:41:56 +00:00
|
|
|
|
2011-02-28 11:34:01 +00:00
|
|
|
/**
|
|
|
|
* v9fs_get_inode - helper function to setup an inode
|
|
|
|
* @sb: superblock
|
|
|
|
* @mode: mode to setup inode with
|
2021-10-04 21:07:22 +00:00
|
|
|
* @rdev: The device numbers to set
|
2011-02-28 11:34:01 +00:00
|
|
|
*/
|
|
|
|
|
2011-07-26 06:53:22 +00:00
|
|
|
struct inode *v9fs_get_inode(struct super_block *sb, umode_t mode, dev_t rdev)
|
2011-02-28 11:34:01 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct inode *inode;
|
|
|
|
struct v9fs_session_info *v9ses = sb->s_fs_info;
|
|
|
|
|
2012-01-10 23:09:01 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "super block: %p mode: %ho\n", sb, mode);
|
2011-02-28 11:34:01 +00:00
|
|
|
|
|
|
|
inode = new_inode(sb);
|
|
|
|
if (!inode) {
|
2011-11-28 18:40:46 +00:00
|
|
|
pr_warn("%s (%d): Problem allocating inode\n",
|
|
|
|
__func__, task_pid_nr(current));
|
2011-02-28 11:34:01 +00:00
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
2011-07-25 18:06:33 +00:00
|
|
|
err = v9fs_init_inode(v9ses, inode, mode, rdev);
|
2011-02-28 11:34:01 +00:00
|
|
|
if (err) {
|
|
|
|
iput(inode);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
return inode;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
2009-09-23 18:00:27 +00:00
|
|
|
/**
|
2021-10-04 21:07:22 +00:00
|
|
|
* v9fs_evict_inode - Remove an inode from the inode cache
|
2009-09-23 18:00:27 +00:00
|
|
|
* @inode: inode to release
|
|
|
|
*
|
|
|
|
*/
|
2010-06-07 18:34:48 +00:00
|
|
|
void v9fs_evict_inode(struct inode *inode)
|
2009-09-23 18:00:27 +00:00
|
|
|
{
|
2011-02-28 11:34:03 +00:00
|
|
|
struct v9fs_inode *v9inode = V9FS_I(inode);
|
2020-11-18 09:06:42 +00:00
|
|
|
__le32 version;
|
2011-02-28 11:34:03 +00:00
|
|
|
|
2015-12-08 08:07:22 +00:00
|
|
|
truncate_inode_pages_final(&inode->i_data);
|
2020-11-18 09:06:42 +00:00
|
|
|
version = cpu_to_le32(v9inode->qid.version);
|
|
|
|
fscache_clear_inode_writeback(v9fs_inode_cookie(v9inode), inode,
|
|
|
|
&version);
|
2012-05-03 12:48:02 +00:00
|
|
|
clear_inode(inode);
|
2015-12-08 08:07:22 +00:00
|
|
|
filemap_fdatawrite(&inode->i_data);
|
2009-09-23 18:00:27 +00:00
|
|
|
|
2020-11-18 09:06:42 +00:00
|
|
|
fscache_relinquish_cookie(v9fs_inode_cookie(v9inode), false);
|
2011-02-28 11:34:03 +00:00
|
|
|
/* clunk the fid stashed in writeback_fid */
|
2022-06-12 07:05:39 +00:00
|
|
|
p9_fid_put(v9inode->writeback_fid);
|
|
|
|
v9inode->writeback_fid = NULL;
|
2009-09-23 18:00:27 +00:00
|
|
|
}
|
|
|
|
|
2011-07-11 16:40:59 +00:00
|
|
|
static int v9fs_test_inode(struct inode *inode, void *data)
|
|
|
|
{
|
|
|
|
int umode;
|
2011-07-25 18:06:33 +00:00
|
|
|
dev_t rdev;
|
2011-07-11 16:40:59 +00:00
|
|
|
struct v9fs_inode *v9inode = V9FS_I(inode);
|
|
|
|
struct p9_wstat *st = (struct p9_wstat *)data;
|
|
|
|
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
|
|
|
|
|
2011-07-25 18:06:33 +00:00
|
|
|
umode = p9mode2unixmode(v9ses, st, &rdev);
|
2011-07-11 16:40:59 +00:00
|
|
|
/* don't match inode of different type */
|
2021-03-02 01:37:10 +00:00
|
|
|
if (inode_wrong_type(inode, umode))
|
2011-07-11 16:40:59 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* compare qid details */
|
|
|
|
if (memcmp(&v9inode->qid.version,
|
|
|
|
&st->qid.version, sizeof(v9inode->qid.version)))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (v9inode->qid.type != st->qid.type)
|
|
|
|
return 0;
|
2017-09-06 14:59:07 +00:00
|
|
|
|
|
|
|
if (v9inode->qid.path != st->qid.path)
|
|
|
|
return 0;
|
2011-07-11 16:40:59 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-07-06 11:02:31 +00:00
|
|
|
static int v9fs_test_new_inode(struct inode *inode, void *data)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-11 16:40:59 +00:00
|
|
|
static int v9fs_set_inode(struct inode *inode, void *data)
|
|
|
|
{
|
|
|
|
struct v9fs_inode *v9inode = V9FS_I(inode);
|
|
|
|
struct p9_wstat *st = (struct p9_wstat *)data;
|
|
|
|
|
|
|
|
memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-28 11:34:01 +00:00
|
|
|
static struct inode *v9fs_qid_iget(struct super_block *sb,
|
|
|
|
struct p9_qid *qid,
|
2011-07-06 11:02:31 +00:00
|
|
|
struct p9_wstat *st,
|
|
|
|
int new)
|
2006-03-02 10:54:30 +00:00
|
|
|
{
|
2011-07-25 18:06:33 +00:00
|
|
|
dev_t rdev;
|
2011-07-26 06:53:22 +00:00
|
|
|
int retval;
|
|
|
|
umode_t umode;
|
2011-02-28 11:34:01 +00:00
|
|
|
unsigned long i_ino;
|
|
|
|
struct inode *inode;
|
|
|
|
struct v9fs_session_info *v9ses = sb->s_fs_info;
|
2021-11-02 13:16:43 +00:00
|
|
|
int (*test)(struct inode *inode, void *data);
|
2011-07-06 11:02:31 +00:00
|
|
|
|
|
|
|
if (new)
|
|
|
|
test = v9fs_test_new_inode;
|
|
|
|
else
|
|
|
|
test = v9fs_test_inode;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2011-02-28 11:34:01 +00:00
|
|
|
i_ino = v9fs_qid2ino(qid);
|
2011-07-06 11:02:31 +00:00
|
|
|
inode = iget5_locked(sb, i_ino, test, v9fs_set_inode, st);
|
2011-02-28 11:34:01 +00:00
|
|
|
if (!inode)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
if (!(inode->i_state & I_NEW))
|
|
|
|
return inode;
|
|
|
|
/*
|
|
|
|
* initialize the inode with the stat info
|
|
|
|
* FIXME!! we may need support for stale inodes
|
|
|
|
* later.
|
|
|
|
*/
|
2011-07-11 16:40:59 +00:00
|
|
|
inode->i_ino = i_ino;
|
2011-07-25 18:06:33 +00:00
|
|
|
umode = p9mode2unixmode(v9ses, st, &rdev);
|
|
|
|
retval = v9fs_init_inode(v9ses, inode, umode, rdev);
|
2011-02-28 11:34:01 +00:00
|
|
|
if (retval)
|
2006-03-02 10:54:30 +00:00
|
|
|
goto error;
|
2009-09-23 18:00:27 +00:00
|
|
|
|
2019-01-24 06:35:13 +00:00
|
|
|
v9fs_stat2inode(st, inode, sb, 0);
|
2011-02-28 11:34:01 +00:00
|
|
|
v9fs_cache_inode_get_cookie(inode);
|
|
|
|
unlock_new_inode(inode);
|
|
|
|
return inode;
|
2006-03-02 10:54:30 +00:00
|
|
|
error:
|
2015-07-12 14:34:29 +00:00
|
|
|
iget_failed(inode);
|
2011-02-28 11:34:01 +00:00
|
|
|
return ERR_PTR(retval);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
struct inode *
|
2011-02-28 11:34:02 +00:00
|
|
|
v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
|
2011-07-06 11:02:31 +00:00
|
|
|
struct super_block *sb, int new)
|
2011-02-28 11:34:01 +00:00
|
|
|
{
|
|
|
|
struct p9_wstat *st;
|
|
|
|
struct inode *inode = NULL;
|
|
|
|
|
|
|
|
st = p9_client_stat(fid);
|
|
|
|
if (IS_ERR(st))
|
|
|
|
return ERR_CAST(st);
|
|
|
|
|
2011-07-06 11:02:31 +00:00
|
|
|
inode = v9fs_qid_iget(sb, &st->qid, st, new);
|
2009-07-19 19:41:54 +00:00
|
|
|
p9stat_free(st);
|
2007-07-10 22:57:28 +00:00
|
|
|
kfree(st);
|
2011-02-28 11:34:01 +00:00
|
|
|
return inode;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
2011-08-03 14:25:32 +00:00
|
|
|
/**
|
|
|
|
* v9fs_at_to_dotl_flags- convert Linux specific AT flags to
|
|
|
|
* plan 9 AT flag.
|
|
|
|
* @flags: flags to convert
|
|
|
|
*/
|
|
|
|
static int v9fs_at_to_dotl_flags(int flags)
|
|
|
|
{
|
|
|
|
int rflags = 0;
|
2021-11-02 13:16:43 +00:00
|
|
|
|
2011-08-03 14:25:32 +00:00
|
|
|
if (flags & AT_REMOVEDIR)
|
|
|
|
rflags |= P9_DOTL_AT_REMOVEDIR;
|
2021-11-02 13:16:43 +00:00
|
|
|
|
2011-08-03 14:25:32 +00:00
|
|
|
return rflags;
|
|
|
|
}
|
|
|
|
|
9p: don't maintain dir i_nlink if the exported fs doesn't either
If the exported filesystem dir on 9p server doesn't maintain accurate
i_nlink count, e.g. always reports i_nlink as 1, then 9p should not
maintain nlink count either, otherwise drop_link would report warning
with i_nlink being zero.
For example:
- overlayfs sets nlink to 1 for merged dir
- ext4 (with dir_nlink feature enabled) sets nlink to 1 if a dir has
more than EXT4_LINK_MAX (65000) links.
In this case, everytime a stat(2) call (getattr) on such exported dirs
on 9p client side, the i_nlink gets reset to 1, then operations like
rmdir(2), unlink(2) and rename(2) would cause the dir nlink to go to
zero (then negative), which results in warnings in drop_nlink() and/or
inc_nlink() calls.
This can be reproduced easily as the following steps:
- export a merged overlayfs dir via qemu virtfs to guest
- mount the exported virtfs in guest
- create two sub-directories in the root dir of the mounted 9pfs
- stat the root dir of 9pfs, this resets nlink to 1
- remove all subdirs, the second unlink/rmdir would trigger warning
------------[ cut here ]------------
WARNING: CPU: 3 PID: 1284 at fs/inode.c:282 drop_nlink+0x3e/0x50
...
Call Trace:
dump_stack+0x63/0x81
__warn+0xcb/0xf0
warn_slowpath_null+0x1d/0x20
drop_nlink+0x3e/0x50
v9fs_remove+0xaa/0x130 [9p]
v9fs_vfs_rmdir+0x13/0x20 [9p]
vfs_rmdir+0xb7/0x130
do_rmdir+0x1b8/0x230
SyS_unlinkat+0x22/0x30
do_syscall_64+0x67/0x180
---[ end trace 43758d8ba91e603b ]---
Fix it by leaving i_nlink to be 1 and don't drop nlink if a directory
has nlink <= 2, which indicates that the underlying exported fs doesn't
maintain nlink count accurately. This follows what ext4 does in
ext4_dec_count().
Link: http://lkml.kernel.org/r/20180312053829.4367-1-eguan@linux.alibaba.com
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
Reviewed-by: Yiwen Jiang <jiangyiwen@huawei.com>
Tested-by: Roman Kapl <code@rkapl.cz>
Cc: Caspar Zhang <caspar@linux.alibaba.com>
Cc: Eric Van Hensbergen <ericvh@gmail.com>
Cc: Ron Minnich <rminnich@sandia.gov>
Cc: Latchesar Ionkov <lucho@ionkov.net>
Cc: <v9fs-developer@lists.sourceforge.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-05 23:19:49 +00:00
|
|
|
/**
|
|
|
|
* v9fs_dec_count - helper functon to drop i_nlink.
|
|
|
|
*
|
|
|
|
* If a directory had nlink <= 2 (including . and ..), then we should not drop
|
|
|
|
* the link count, which indicates the underlying exported fs doesn't maintain
|
|
|
|
* nlink accurately. e.g.
|
|
|
|
* - overlayfs sets nlink to 1 for merged dir
|
|
|
|
* - ext4 (with dir_nlink feature enabled) sets nlink to 1 if a dir has more
|
|
|
|
* than EXT4_LINK_MAX (65000) links.
|
|
|
|
*
|
|
|
|
* @inode: inode whose nlink is being dropped
|
|
|
|
*/
|
|
|
|
static void v9fs_dec_count(struct inode *inode)
|
|
|
|
{
|
|
|
|
if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
|
|
|
|
drop_nlink(inode);
|
|
|
|
}
|
|
|
|
|
2005-09-09 20:04:19 +00:00
|
|
|
/**
|
|
|
|
* v9fs_remove - helper function to remove files and directories
|
2005-09-09 20:04:26 +00:00
|
|
|
* @dir: directory inode that is being deleted
|
2011-06-28 10:11:18 +00:00
|
|
|
* @dentry: dentry that is being deleted
|
2014-06-04 23:06:26 +00:00
|
|
|
* @flags: removing a directory
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-06-28 10:11:18 +00:00
|
|
|
static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2011-06-28 10:11:18 +00:00
|
|
|
struct inode *inode;
|
|
|
|
int retval = -EOPNOTSUPP;
|
|
|
|
struct p9_fid *v9fid, *dfid;
|
|
|
|
struct v9fs_session_info *v9ses;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %x\n",
|
|
|
|
dir, dentry, flags);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2011-06-28 10:11:18 +00:00
|
|
|
v9ses = v9fs_inode2v9ses(dir);
|
2015-03-17 22:25:59 +00:00
|
|
|
inode = d_inode(dentry);
|
2016-05-29 19:29:26 +00:00
|
|
|
dfid = v9fs_parent_fid(dentry);
|
2011-06-28 10:11:18 +00:00
|
|
|
if (IS_ERR(dfid)) {
|
|
|
|
retval = PTR_ERR(dfid);
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", retval);
|
2011-06-28 10:11:18 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
if (v9fs_proto_dotl(v9ses))
|
2011-08-03 14:25:32 +00:00
|
|
|
retval = p9_client_unlinkat(dfid, dentry->d_name.name,
|
|
|
|
v9fs_at_to_dotl_flags(flags));
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(dfid);
|
2011-06-28 10:11:18 +00:00
|
|
|
if (retval == -EOPNOTSUPP) {
|
|
|
|
/* Try the one based on path */
|
|
|
|
v9fid = v9fs_fid_clone(dentry);
|
|
|
|
if (IS_ERR(v9fid))
|
|
|
|
return PTR_ERR(v9fid);
|
|
|
|
retval = p9_client_remove(v9fid);
|
|
|
|
}
|
2011-02-28 11:34:05 +00:00
|
|
|
if (!retval) {
|
|
|
|
/*
|
|
|
|
* directories on unlink should have zero
|
|
|
|
* link count
|
|
|
|
*/
|
2011-06-28 10:11:18 +00:00
|
|
|
if (flags & AT_REMOVEDIR) {
|
|
|
|
clear_nlink(inode);
|
9p: don't maintain dir i_nlink if the exported fs doesn't either
If the exported filesystem dir on 9p server doesn't maintain accurate
i_nlink count, e.g. always reports i_nlink as 1, then 9p should not
maintain nlink count either, otherwise drop_link would report warning
with i_nlink being zero.
For example:
- overlayfs sets nlink to 1 for merged dir
- ext4 (with dir_nlink feature enabled) sets nlink to 1 if a dir has
more than EXT4_LINK_MAX (65000) links.
In this case, everytime a stat(2) call (getattr) on such exported dirs
on 9p client side, the i_nlink gets reset to 1, then operations like
rmdir(2), unlink(2) and rename(2) would cause the dir nlink to go to
zero (then negative), which results in warnings in drop_nlink() and/or
inc_nlink() calls.
This can be reproduced easily as the following steps:
- export a merged overlayfs dir via qemu virtfs to guest
- mount the exported virtfs in guest
- create two sub-directories in the root dir of the mounted 9pfs
- stat the root dir of 9pfs, this resets nlink to 1
- remove all subdirs, the second unlink/rmdir would trigger warning
------------[ cut here ]------------
WARNING: CPU: 3 PID: 1284 at fs/inode.c:282 drop_nlink+0x3e/0x50
...
Call Trace:
dump_stack+0x63/0x81
__warn+0xcb/0xf0
warn_slowpath_null+0x1d/0x20
drop_nlink+0x3e/0x50
v9fs_remove+0xaa/0x130 [9p]
v9fs_vfs_rmdir+0x13/0x20 [9p]
vfs_rmdir+0xb7/0x130
do_rmdir+0x1b8/0x230
SyS_unlinkat+0x22/0x30
do_syscall_64+0x67/0x180
---[ end trace 43758d8ba91e603b ]---
Fix it by leaving i_nlink to be 1 and don't drop nlink if a directory
has nlink <= 2, which indicates that the underlying exported fs doesn't
maintain nlink count accurately. This follows what ext4 does in
ext4_dec_count().
Link: http://lkml.kernel.org/r/20180312053829.4367-1-eguan@linux.alibaba.com
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
Reviewed-by: Yiwen Jiang <jiangyiwen@huawei.com>
Tested-by: Roman Kapl <code@rkapl.cz>
Cc: Caspar Zhang <caspar@linux.alibaba.com>
Cc: Eric Van Hensbergen <ericvh@gmail.com>
Cc: Ron Minnich <rminnich@sandia.gov>
Cc: Latchesar Ionkov <lucho@ionkov.net>
Cc: <v9fs-developer@lists.sourceforge.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-05 23:19:49 +00:00
|
|
|
v9fs_dec_count(dir);
|
2011-02-28 11:34:05 +00:00
|
|
|
} else
|
9p: don't maintain dir i_nlink if the exported fs doesn't either
If the exported filesystem dir on 9p server doesn't maintain accurate
i_nlink count, e.g. always reports i_nlink as 1, then 9p should not
maintain nlink count either, otherwise drop_link would report warning
with i_nlink being zero.
For example:
- overlayfs sets nlink to 1 for merged dir
- ext4 (with dir_nlink feature enabled) sets nlink to 1 if a dir has
more than EXT4_LINK_MAX (65000) links.
In this case, everytime a stat(2) call (getattr) on such exported dirs
on 9p client side, the i_nlink gets reset to 1, then operations like
rmdir(2), unlink(2) and rename(2) would cause the dir nlink to go to
zero (then negative), which results in warnings in drop_nlink() and/or
inc_nlink() calls.
This can be reproduced easily as the following steps:
- export a merged overlayfs dir via qemu virtfs to guest
- mount the exported virtfs in guest
- create two sub-directories in the root dir of the mounted 9pfs
- stat the root dir of 9pfs, this resets nlink to 1
- remove all subdirs, the second unlink/rmdir would trigger warning
------------[ cut here ]------------
WARNING: CPU: 3 PID: 1284 at fs/inode.c:282 drop_nlink+0x3e/0x50
...
Call Trace:
dump_stack+0x63/0x81
__warn+0xcb/0xf0
warn_slowpath_null+0x1d/0x20
drop_nlink+0x3e/0x50
v9fs_remove+0xaa/0x130 [9p]
v9fs_vfs_rmdir+0x13/0x20 [9p]
vfs_rmdir+0xb7/0x130
do_rmdir+0x1b8/0x230
SyS_unlinkat+0x22/0x30
do_syscall_64+0x67/0x180
---[ end trace 43758d8ba91e603b ]---
Fix it by leaving i_nlink to be 1 and don't drop nlink if a directory
has nlink <= 2, which indicates that the underlying exported fs doesn't
maintain nlink count accurately. This follows what ext4 does in
ext4_dec_count().
Link: http://lkml.kernel.org/r/20180312053829.4367-1-eguan@linux.alibaba.com
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
Reviewed-by: Yiwen Jiang <jiangyiwen@huawei.com>
Tested-by: Roman Kapl <code@rkapl.cz>
Cc: Caspar Zhang <caspar@linux.alibaba.com>
Cc: Eric Van Hensbergen <ericvh@gmail.com>
Cc: Ron Minnich <rminnich@sandia.gov>
Cc: Latchesar Ionkov <lucho@ionkov.net>
Cc: <v9fs-developer@lists.sourceforge.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-05 23:19:49 +00:00
|
|
|
v9fs_dec_count(inode);
|
2011-02-28 11:34:08 +00:00
|
|
|
|
2011-06-28 10:11:18 +00:00
|
|
|
v9fs_invalidate_inode_attr(inode);
|
2011-02-28 11:34:08 +00:00
|
|
|
v9fs_invalidate_inode_attr(dir);
|
2020-09-23 14:11:43 +00:00
|
|
|
|
|
|
|
/* invalidate all fids associated with dentry */
|
|
|
|
/* NOTE: This will not include open fids */
|
|
|
|
dentry->d_op->d_release(dentry);
|
2011-02-28 11:34:05 +00:00
|
|
|
}
|
2010-03-29 23:14:50 +00:00
|
|
|
return retval;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-07-10 22:57:28 +00:00
|
|
|
* v9fs_create - Create a file
|
2008-03-05 13:08:09 +00:00
|
|
|
* @v9ses: session information
|
|
|
|
* @dir: directory that dentry is being created in
|
2007-07-10 22:57:28 +00:00
|
|
|
* @dentry: dentry that is being created
|
2009-07-19 19:41:55 +00:00
|
|
|
* @extension: 9p2000.u extension string to support devices, etc.
|
2007-07-10 22:57:28 +00:00
|
|
|
* @perm: create permissions
|
|
|
|
* @mode: open mode
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
2007-07-10 22:57:28 +00:00
|
|
|
static struct p9_fid *
|
|
|
|
v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
|
|
|
|
struct dentry *dentry, char *extension, u32 perm, u8 mode)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2006-03-02 10:54:30 +00:00
|
|
|
int err;
|
2017-01-12 09:01:17 +00:00
|
|
|
const unsigned char *name;
|
2020-09-23 14:11:46 +00:00
|
|
|
struct p9_fid *dfid, *ofid = NULL, *fid = NULL;
|
2006-03-02 10:54:30 +00:00
|
|
|
struct inode *inode;
|
|
|
|
|
2014-08-20 00:17:38 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
|
2008-10-16 13:30:07 +00:00
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
err = 0;
|
2017-01-12 09:01:17 +00:00
|
|
|
name = dentry->d_name.name;
|
2016-05-29 19:29:26 +00:00
|
|
|
dfid = v9fs_parent_fid(dentry);
|
2007-10-17 19:31:07 +00:00
|
|
|
if (IS_ERR(dfid)) {
|
2007-01-26 08:57:06 +00:00
|
|
|
err = PTR_ERR(dfid);
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
|
2010-05-10 18:08:28 +00:00
|
|
|
return ERR_PTR(err);
|
2007-01-26 08:57:06 +00:00
|
|
|
}
|
2006-03-02 10:54:30 +00:00
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
/* clone a fid to use for creation */
|
2016-08-03 15:12:12 +00:00
|
|
|
ofid = clone_fid(dfid);
|
2007-07-10 22:57:28 +00:00
|
|
|
if (IS_ERR(ofid)) {
|
|
|
|
err = PTR_ERR(ofid);
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
|
2022-06-12 07:05:39 +00:00
|
|
|
goto error;
|
2007-07-10 22:57:28 +00:00
|
|
|
}
|
2006-03-02 10:54:30 +00:00
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
err = p9_client_fcreate(ofid, name, perm, mode, extension);
|
2008-10-16 13:30:07 +00:00
|
|
|
if (err < 0) {
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
|
2006-03-02 10:54:30 +00:00
|
|
|
goto error;
|
2010-05-10 18:08:28 +00:00
|
|
|
}
|
2006-03-02 10:54:30 +00:00
|
|
|
|
2012-01-05 16:42:17 +00:00
|
|
|
if (!(perm & P9_DMLINK)) {
|
|
|
|
/* now walk from the parent so we can get unopened fid */
|
|
|
|
fid = p9_client_walk(dfid, 1, &name, 1);
|
|
|
|
if (IS_ERR(fid)) {
|
|
|
|
err = PTR_ERR(fid);
|
|
|
|
p9_debug(P9_DEBUG_VFS,
|
|
|
|
"p9_client_walk failed %d\n", err);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* instantiate inode and assign the unopened fid to the dentry
|
|
|
|
*/
|
|
|
|
inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
|
|
|
|
if (IS_ERR(inode)) {
|
|
|
|
err = PTR_ERR(inode);
|
|
|
|
p9_debug(P9_DEBUG_VFS,
|
|
|
|
"inode creation failed %d\n", err);
|
|
|
|
goto error;
|
|
|
|
}
|
2022-06-12 07:05:39 +00:00
|
|
|
v9fs_fid_add(dentry, &fid);
|
2012-01-05 16:42:17 +00:00
|
|
|
d_instantiate(dentry, inode);
|
2006-03-02 10:54:30 +00:00
|
|
|
}
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(dfid);
|
2007-07-10 22:57:28 +00:00
|
|
|
return ofid;
|
|
|
|
error:
|
2022-06-12 07:05:39 +00:00
|
|
|
p9_fid_put(dfid);
|
|
|
|
p9_fid_put(ofid);
|
|
|
|
p9_fid_put(fid);
|
2007-07-10 22:57:28 +00:00
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-06-05 13:10:26 +00:00
|
|
|
* v9fs_vfs_create - VFS hook to create a regular file
|
2023-01-13 11:49:13 +00:00
|
|
|
* @idmap: idmap of the mount
|
2021-10-04 21:07:22 +00:00
|
|
|
* @dir: The parent directory
|
|
|
|
* @dentry: The name of file to be created
|
|
|
|
* @mode: The UNIX file mode to set
|
|
|
|
* @excl: True if the file must not yet exist
|
2012-06-05 13:10:26 +00:00
|
|
|
*
|
|
|
|
* open(.., O_CREAT) is handled in v9fs_vfs_atomic_open(). This is only called
|
|
|
|
* for mknod(2).
|
|
|
|
*
|
2007-07-10 22:57:28 +00:00
|
|
|
*/
|
2006-03-02 10:54:30 +00:00
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
static int
|
2023-01-13 11:49:13 +00:00
|
|
|
v9fs_vfs_create(struct mnt_idmap *idmap, struct inode *dir,
|
2021-01-21 13:19:43 +00:00
|
|
|
struct dentry *dentry, umode_t mode, bool excl)
|
2007-07-10 22:57:28 +00:00
|
|
|
{
|
2012-06-05 13:10:26 +00:00
|
|
|
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
|
|
|
|
u32 perm = unixmode2p9mode(v9ses, mode);
|
|
|
|
struct p9_fid *fid;
|
2007-07-10 22:57:28 +00:00
|
|
|
|
2012-06-05 13:10:26 +00:00
|
|
|
/* P9_OEXCL? */
|
|
|
|
fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_ORDWR);
|
|
|
|
if (IS_ERR(fid))
|
|
|
|
return PTR_ERR(fid);
|
2007-07-10 22:57:28 +00:00
|
|
|
|
2011-02-28 11:34:08 +00:00
|
|
|
v9fs_invalidate_inode_attr(dir);
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(fid);
|
2006-03-02 10:54:30 +00:00
|
|
|
|
|
|
|
return 0;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* v9fs_vfs_mkdir - VFS mkdir hook to create a directory
|
2023-01-13 11:49:15 +00:00
|
|
|
* @idmap: idmap of the mount
|
2008-03-05 13:08:09 +00:00
|
|
|
* @dir: inode that is being unlinked
|
2005-09-09 20:04:19 +00:00
|
|
|
* @dentry: dentry that is being unlinked
|
|
|
|
* @mode: mode for new directory
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2023-01-13 11:49:15 +00:00
|
|
|
static int v9fs_vfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
|
2021-01-21 13:19:43 +00:00
|
|
|
struct dentry *dentry, umode_t mode)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2006-03-02 10:54:30 +00:00
|
|
|
int err;
|
2007-07-10 22:57:28 +00:00
|
|
|
u32 perm;
|
|
|
|
struct p9_fid *fid;
|
2011-02-28 11:34:08 +00:00
|
|
|
struct v9fs_session_info *v9ses;
|
2006-03-02 10:54:30 +00:00
|
|
|
|
2014-08-20 00:17:38 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "name %pd\n", dentry);
|
2007-07-10 22:57:28 +00:00
|
|
|
err = 0;
|
2006-03-02 10:54:30 +00:00
|
|
|
v9ses = v9fs_inode2v9ses(dir);
|
|
|
|
perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
|
2007-07-10 22:57:28 +00:00
|
|
|
fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
|
|
|
|
if (IS_ERR(fid)) {
|
|
|
|
err = PTR_ERR(fid);
|
|
|
|
fid = NULL;
|
2011-02-28 11:34:08 +00:00
|
|
|
} else {
|
2011-02-28 11:34:05 +00:00
|
|
|
inc_nlink(dir);
|
2011-02-28 11:34:08 +00:00
|
|
|
v9fs_invalidate_inode_attr(dir);
|
|
|
|
}
|
2006-03-02 10:54:30 +00:00
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
if (fid)
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(fid);
|
2006-03-02 10:54:30 +00:00
|
|
|
|
|
|
|
return err;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
|
|
|
|
* @dir: inode that is being walked from
|
|
|
|
* @dentry: dentry that is being walked to?
|
2014-06-04 23:06:26 +00:00
|
|
|
* @flags: lookup flags (unused)
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-01-10 19:51:47 +00:00
|
|
|
struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
|
2012-06-10 21:13:09 +00:00
|
|
|
unsigned int flags)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2011-08-16 16:49:28 +00:00
|
|
|
struct dentry *res;
|
2005-09-09 20:04:19 +00:00
|
|
|
struct v9fs_session_info *v9ses;
|
2007-07-10 22:57:28 +00:00
|
|
|
struct p9_fid *dfid, *fid;
|
2005-09-09 20:04:19 +00:00
|
|
|
struct inode *inode;
|
2017-01-12 09:01:17 +00:00
|
|
|
const unsigned char *name;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2014-08-20 00:17:38 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "dir: %p dentry: (%pd) %p flags: %x\n",
|
|
|
|
dir, dentry, dentry, flags);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2010-03-29 23:13:59 +00:00
|
|
|
if (dentry->d_name.len > NAME_MAX)
|
|
|
|
return ERR_PTR(-ENAMETOOLONG);
|
|
|
|
|
2005-09-09 20:04:19 +00:00
|
|
|
v9ses = v9fs_inode2v9ses(dir);
|
2010-06-30 13:48:50 +00:00
|
|
|
/* We can walk d_parent because we hold the dir->i_mutex */
|
2016-05-29 19:29:26 +00:00
|
|
|
dfid = v9fs_parent_fid(dentry);
|
2007-07-10 22:57:28 +00:00
|
|
|
if (IS_ERR(dfid))
|
2008-02-07 08:15:26 +00:00
|
|
|
return ERR_CAST(dfid);
|
2007-07-10 22:57:28 +00:00
|
|
|
|
2011-08-16 16:49:28 +00:00
|
|
|
/*
|
|
|
|
* Make sure we don't use a wrong inode due to parallel
|
|
|
|
* unlink. For cached mode create calls request for new
|
|
|
|
* inode. But with cache disabled, lookup should do this.
|
|
|
|
*/
|
2018-05-14 23:24:48 +00:00
|
|
|
name = dentry->d_name.name;
|
|
|
|
fid = p9_client_walk(dfid, 1, &name, 1);
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(dfid);
|
2018-05-14 23:24:48 +00:00
|
|
|
if (fid == ERR_PTR(-ENOENT))
|
|
|
|
inode = NULL;
|
|
|
|
else if (IS_ERR(fid))
|
|
|
|
inode = ERR_CAST(fid);
|
|
|
|
else if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
|
2011-08-16 16:49:28 +00:00
|
|
|
inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
|
|
|
|
else
|
|
|
|
inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
|
|
|
|
/*
|
|
|
|
* If we had a rename on the server and a parallel lookup
|
|
|
|
* for the new name, then make sure we instantiate with
|
|
|
|
* the new name. ie look up for a/b, while on server somebody
|
|
|
|
* moved b under k and client parallely did a lookup for
|
|
|
|
* k/b.
|
|
|
|
*/
|
2014-10-13 02:24:21 +00:00
|
|
|
res = d_splice_alias(inode, dentry);
|
2018-05-14 23:24:48 +00:00
|
|
|
if (!IS_ERR(fid)) {
|
|
|
|
if (!res)
|
2022-06-12 07:05:39 +00:00
|
|
|
v9fs_fid_add(dentry, &fid);
|
2018-05-14 23:24:48 +00:00
|
|
|
else if (!IS_ERR(res))
|
2022-06-12 07:05:39 +00:00
|
|
|
v9fs_fid_add(res, &fid);
|
2018-05-14 23:24:48 +00:00
|
|
|
else
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(fid);
|
2018-05-14 23:24:48 +00:00
|
|
|
}
|
2013-02-28 06:28:21 +00:00
|
|
|
return res;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
2012-06-22 08:39:14 +00:00
|
|
|
static int
|
2012-06-05 13:10:26 +00:00
|
|
|
v9fs_vfs_atomic_open(struct inode *dir, struct dentry *dentry,
|
2021-11-02 13:16:43 +00:00
|
|
|
struct file *file, unsigned int flags, umode_t mode)
|
2012-06-05 13:10:26 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
u32 perm;
|
|
|
|
struct v9fs_inode *v9inode;
|
|
|
|
struct v9fs_session_info *v9ses;
|
|
|
|
struct p9_fid *fid, *inode_fid;
|
|
|
|
struct dentry *res = NULL;
|
2020-09-23 14:11:44 +00:00
|
|
|
struct inode *inode;
|
2012-06-05 13:10:26 +00:00
|
|
|
|
2016-07-05 13:44:53 +00:00
|
|
|
if (d_in_lookup(dentry)) {
|
2012-06-10 21:13:09 +00:00
|
|
|
res = v9fs_vfs_lookup(dir, dentry, 0);
|
2012-06-05 13:10:26 +00:00
|
|
|
if (IS_ERR(res))
|
2012-06-22 08:39:14 +00:00
|
|
|
return PTR_ERR(res);
|
2012-06-05 13:10:26 +00:00
|
|
|
|
|
|
|
if (res)
|
|
|
|
dentry = res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only creates */
|
2015-03-17 22:25:59 +00:00
|
|
|
if (!(flags & O_CREAT) || d_really_is_positive(dentry))
|
2012-06-10 10:48:09 +00:00
|
|
|
return finish_no_open(file, res);
|
2012-06-05 13:10:26 +00:00
|
|
|
|
|
|
|
err = 0;
|
2013-09-28 23:32:15 +00:00
|
|
|
|
2012-06-05 13:10:26 +00:00
|
|
|
v9ses = v9fs_inode2v9ses(dir);
|
|
|
|
perm = unixmode2p9mode(v9ses, mode);
|
|
|
|
fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
|
|
|
|
v9fs_uflags2omode(flags,
|
|
|
|
v9fs_proto_dotu(v9ses)));
|
|
|
|
if (IS_ERR(fid)) {
|
|
|
|
err = PTR_ERR(fid);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
v9fs_invalidate_inode_attr(dir);
|
2020-09-23 14:11:44 +00:00
|
|
|
inode = d_inode(dentry);
|
|
|
|
v9inode = V9FS_I(inode);
|
2012-06-05 13:10:26 +00:00
|
|
|
mutex_lock(&v9inode->v_mutex);
|
2022-12-08 02:03:32 +00:00
|
|
|
if ((v9ses->cache) && !v9inode->writeback_fid &&
|
2012-06-05 13:10:26 +00:00
|
|
|
((flags & O_ACCMODE) != O_RDONLY)) {
|
|
|
|
/*
|
|
|
|
* clone a fid and add it to writeback_fid
|
|
|
|
* we do it during open time instead of
|
|
|
|
* page dirty time via write_begin/page_mkwrite
|
|
|
|
* because we want write after unlink usecase
|
|
|
|
* to work.
|
|
|
|
*/
|
|
|
|
inode_fid = v9fs_writeback_fid(dentry);
|
|
|
|
if (IS_ERR(inode_fid)) {
|
|
|
|
err = PTR_ERR(inode_fid);
|
|
|
|
mutex_unlock(&v9inode->v_mutex);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
v9inode->writeback_fid = (void *) inode_fid;
|
|
|
|
}
|
|
|
|
mutex_unlock(&v9inode->v_mutex);
|
2018-06-08 15:44:56 +00:00
|
|
|
err = finish_open(file, dentry, generic_file_open);
|
2012-06-22 08:40:19 +00:00
|
|
|
if (err)
|
2012-06-05 13:10:26 +00:00
|
|
|
goto error;
|
|
|
|
|
2012-06-22 08:40:19 +00:00
|
|
|
file->private_data = fid;
|
2014-01-10 12:44:09 +00:00
|
|
|
if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
|
2020-11-18 09:06:42 +00:00
|
|
|
fscache_use_cookie(v9fs_inode_cookie(v9inode),
|
|
|
|
file->f_mode & FMODE_WRITE);
|
2022-06-12 07:05:39 +00:00
|
|
|
v9fs_open_fid_add(inode, &fid);
|
2012-06-05 13:10:26 +00:00
|
|
|
|
2018-06-08 17:22:02 +00:00
|
|
|
file->f_mode |= FMODE_CREATED;
|
2012-06-05 13:10:26 +00:00
|
|
|
out:
|
|
|
|
dput(res);
|
2012-06-22 08:39:14 +00:00
|
|
|
return err;
|
2012-06-05 13:10:26 +00:00
|
|
|
|
|
|
|
error:
|
2022-06-12 07:05:39 +00:00
|
|
|
p9_fid_put(fid);
|
2012-06-05 13:10:26 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-09-09 20:04:19 +00:00
|
|
|
/**
|
|
|
|
* v9fs_vfs_unlink - VFS unlink hook to delete an inode
|
|
|
|
* @i: inode that is being unlinked
|
2005-09-09 20:04:26 +00:00
|
|
|
* @d: dentry that is being unlinked
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-01-10 19:51:47 +00:00
|
|
|
int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
|
|
|
return v9fs_remove(i, d, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* v9fs_vfs_rmdir - VFS unlink hook to delete a directory
|
|
|
|
* @i: inode that is being unlinked
|
2005-09-09 20:04:26 +00:00
|
|
|
* @d: dentry that is being unlinked
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-01-10 19:51:47 +00:00
|
|
|
int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2011-06-28 10:11:18 +00:00
|
|
|
return v9fs_remove(i, d, AT_REMOVEDIR);
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* v9fs_vfs_rename - VFS hook to rename an inode
|
2023-01-13 11:49:17 +00:00
|
|
|
* @idmap: The idmap of the mount
|
2005-09-09 20:04:19 +00:00
|
|
|
* @old_dir: old dir inode
|
|
|
|
* @old_dentry: old dentry
|
|
|
|
* @new_dir: new dir inode
|
|
|
|
* @new_dentry: new dentry
|
2021-10-04 21:07:22 +00:00
|
|
|
* @flags: RENAME_* flags
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2011-01-10 19:51:47 +00:00
|
|
|
int
|
2023-01-13 11:49:17 +00:00
|
|
|
v9fs_vfs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
|
2021-01-21 13:19:43 +00:00
|
|
|
struct dentry *old_dentry, struct inode *new_dir,
|
|
|
|
struct dentry *new_dentry, unsigned int flags)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2011-02-28 11:34:08 +00:00
|
|
|
int retval;
|
2007-07-10 22:57:28 +00:00
|
|
|
struct inode *old_inode;
|
2011-02-28 11:34:05 +00:00
|
|
|
struct inode *new_inode;
|
2007-07-10 22:57:28 +00:00
|
|
|
struct v9fs_session_info *v9ses;
|
2022-06-12 07:05:39 +00:00
|
|
|
struct p9_fid *oldfid = NULL, *dfid = NULL;
|
|
|
|
struct p9_fid *olddirfid = NULL;
|
|
|
|
struct p9_fid *newdirfid = NULL;
|
2007-07-10 22:57:28 +00:00
|
|
|
struct p9_wstat wstat;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
fs: make remaining filesystems use .rename2
This is trivial to do:
- add flags argument to foo_rename()
- check if flags is zero
- assign foo_rename() to .rename2 instead of .rename
This doesn't mean it's impossible to support RENAME_NOREPLACE for these
filesystems, but it is not trivial, like for local filesystems.
RENAME_NOREPLACE must guarantee atomicity (i.e. it shouldn't be possible
for a file to be created on one host while it is overwritten by rename on
another host).
Filesystems converted:
9p, afs, ceph, coda, ecryptfs, kernfs, lustre, ncpfs, nfs, ocfs2, orangefs.
After this, we can get rid of the duplicate interfaces for rename.
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
Acked-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Acked-by: David Howells <dhowells@redhat.com> [AFS]
Acked-by: Mike Marshall <hubcap@omnibond.com>
Cc: Eric Van Hensbergen <ericvh@gmail.com>
Cc: Ilya Dryomov <idryomov@gmail.com>
Cc: Jan Harkes <jaharkes@cs.cmu.edu>
Cc: Tyler Hicks <tyhicks@canonical.com>
Cc: Oleg Drokin <oleg.drokin@intel.com>
Cc: Trond Myklebust <trond.myklebust@primarydata.com>
Cc: Mark Fasheh <mfasheh@suse.com>
2016-09-27 09:03:58 +00:00
|
|
|
if (flags)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "\n");
|
2007-07-10 22:57:28 +00:00
|
|
|
retval = 0;
|
2015-03-17 22:25:59 +00:00
|
|
|
old_inode = d_inode(old_dentry);
|
|
|
|
new_inode = d_inode(new_dentry);
|
2007-07-10 22:57:28 +00:00
|
|
|
v9ses = v9fs_inode2v9ses(old_inode);
|
|
|
|
oldfid = v9fs_fid_lookup(old_dentry);
|
2007-10-17 19:31:07 +00:00
|
|
|
if (IS_ERR(oldfid))
|
2007-01-26 08:57:06 +00:00
|
|
|
return PTR_ERR(oldfid);
|
|
|
|
|
2020-09-23 14:11:46 +00:00
|
|
|
dfid = v9fs_parent_fid(old_dentry);
|
|
|
|
olddirfid = clone_fid(dfid);
|
2022-06-12 07:05:39 +00:00
|
|
|
p9_fid_put(dfid);
|
|
|
|
dfid = NULL;
|
2020-09-23 14:11:46 +00:00
|
|
|
|
2007-10-17 19:31:07 +00:00
|
|
|
if (IS_ERR(olddirfid)) {
|
2007-01-26 08:57:06 +00:00
|
|
|
retval = PTR_ERR(olddirfid);
|
2022-06-12 07:05:39 +00:00
|
|
|
goto error;
|
2007-01-26 08:57:06 +00:00
|
|
|
}
|
|
|
|
|
2020-09-23 14:11:46 +00:00
|
|
|
dfid = v9fs_parent_fid(new_dentry);
|
|
|
|
newdirfid = clone_fid(dfid);
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(dfid);
|
2022-06-12 07:05:39 +00:00
|
|
|
dfid = NULL;
|
2020-09-23 14:11:46 +00:00
|
|
|
|
2007-10-17 19:31:07 +00:00
|
|
|
if (IS_ERR(newdirfid)) {
|
2007-01-26 08:57:06 +00:00
|
|
|
retval = PTR_ERR(newdirfid);
|
2022-06-12 07:05:39 +00:00
|
|
|
goto error;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
2010-06-30 13:48:50 +00:00
|
|
|
down_write(&v9ses->rename_sem);
|
2010-03-25 12:47:26 +00:00
|
|
|
if (v9fs_proto_dotl(v9ses)) {
|
2011-06-28 10:11:16 +00:00
|
|
|
retval = p9_client_renameat(olddirfid, old_dentry->d_name.name,
|
|
|
|
newdirfid, new_dentry->d_name.name);
|
|
|
|
if (retval == -EOPNOTSUPP)
|
|
|
|
retval = p9_client_rename(oldfid, newdirfid,
|
|
|
|
new_dentry->d_name.name);
|
|
|
|
if (retval != -EOPNOTSUPP)
|
2022-06-12 07:05:39 +00:00
|
|
|
goto error_locked;
|
2010-03-25 12:47:26 +00:00
|
|
|
}
|
2010-06-30 13:48:50 +00:00
|
|
|
if (old_dentry->d_parent != new_dentry->d_parent) {
|
|
|
|
/*
|
|
|
|
* 9P .u can only handle file rename in the same directory
|
|
|
|
*/
|
2010-03-25 12:47:26 +00:00
|
|
|
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "old dir and new dir are different\n");
|
2007-01-26 08:57:04 +00:00
|
|
|
retval = -EXDEV;
|
2022-06-12 07:05:39 +00:00
|
|
|
goto error_locked;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
2006-01-08 09:05:00 +00:00
|
|
|
v9fs_blank_wstat(&wstat);
|
2007-10-17 19:31:07 +00:00
|
|
|
wstat.muid = v9ses->uname;
|
2017-01-12 09:01:17 +00:00
|
|
|
wstat.name = new_dentry->d_name.name;
|
2007-07-10 22:57:28 +00:00
|
|
|
retval = p9_client_wstat(oldfid, &wstat);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2022-06-12 07:05:39 +00:00
|
|
|
error_locked:
|
2011-02-28 11:34:05 +00:00
|
|
|
if (!retval) {
|
|
|
|
if (new_inode) {
|
|
|
|
if (S_ISDIR(new_inode->i_mode))
|
|
|
|
clear_nlink(new_inode);
|
|
|
|
else
|
9p: don't maintain dir i_nlink if the exported fs doesn't either
If the exported filesystem dir on 9p server doesn't maintain accurate
i_nlink count, e.g. always reports i_nlink as 1, then 9p should not
maintain nlink count either, otherwise drop_link would report warning
with i_nlink being zero.
For example:
- overlayfs sets nlink to 1 for merged dir
- ext4 (with dir_nlink feature enabled) sets nlink to 1 if a dir has
more than EXT4_LINK_MAX (65000) links.
In this case, everytime a stat(2) call (getattr) on such exported dirs
on 9p client side, the i_nlink gets reset to 1, then operations like
rmdir(2), unlink(2) and rename(2) would cause the dir nlink to go to
zero (then negative), which results in warnings in drop_nlink() and/or
inc_nlink() calls.
This can be reproduced easily as the following steps:
- export a merged overlayfs dir via qemu virtfs to guest
- mount the exported virtfs in guest
- create two sub-directories in the root dir of the mounted 9pfs
- stat the root dir of 9pfs, this resets nlink to 1
- remove all subdirs, the second unlink/rmdir would trigger warning
------------[ cut here ]------------
WARNING: CPU: 3 PID: 1284 at fs/inode.c:282 drop_nlink+0x3e/0x50
...
Call Trace:
dump_stack+0x63/0x81
__warn+0xcb/0xf0
warn_slowpath_null+0x1d/0x20
drop_nlink+0x3e/0x50
v9fs_remove+0xaa/0x130 [9p]
v9fs_vfs_rmdir+0x13/0x20 [9p]
vfs_rmdir+0xb7/0x130
do_rmdir+0x1b8/0x230
SyS_unlinkat+0x22/0x30
do_syscall_64+0x67/0x180
---[ end trace 43758d8ba91e603b ]---
Fix it by leaving i_nlink to be 1 and don't drop nlink if a directory
has nlink <= 2, which indicates that the underlying exported fs doesn't
maintain nlink count accurately. This follows what ext4 does in
ext4_dec_count().
Link: http://lkml.kernel.org/r/20180312053829.4367-1-eguan@linux.alibaba.com
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
Reviewed-by: Yiwen Jiang <jiangyiwen@huawei.com>
Tested-by: Roman Kapl <code@rkapl.cz>
Cc: Caspar Zhang <caspar@linux.alibaba.com>
Cc: Eric Van Hensbergen <ericvh@gmail.com>
Cc: Ron Minnich <rminnich@sandia.gov>
Cc: Latchesar Ionkov <lucho@ionkov.net>
Cc: <v9fs-developer@lists.sourceforge.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-05 23:19:49 +00:00
|
|
|
v9fs_dec_count(new_inode);
|
2011-02-28 11:34:05 +00:00
|
|
|
}
|
|
|
|
if (S_ISDIR(old_inode->i_mode)) {
|
|
|
|
if (!new_inode)
|
|
|
|
inc_nlink(new_dir);
|
9p: don't maintain dir i_nlink if the exported fs doesn't either
If the exported filesystem dir on 9p server doesn't maintain accurate
i_nlink count, e.g. always reports i_nlink as 1, then 9p should not
maintain nlink count either, otherwise drop_link would report warning
with i_nlink being zero.
For example:
- overlayfs sets nlink to 1 for merged dir
- ext4 (with dir_nlink feature enabled) sets nlink to 1 if a dir has
more than EXT4_LINK_MAX (65000) links.
In this case, everytime a stat(2) call (getattr) on such exported dirs
on 9p client side, the i_nlink gets reset to 1, then operations like
rmdir(2), unlink(2) and rename(2) would cause the dir nlink to go to
zero (then negative), which results in warnings in drop_nlink() and/or
inc_nlink() calls.
This can be reproduced easily as the following steps:
- export a merged overlayfs dir via qemu virtfs to guest
- mount the exported virtfs in guest
- create two sub-directories in the root dir of the mounted 9pfs
- stat the root dir of 9pfs, this resets nlink to 1
- remove all subdirs, the second unlink/rmdir would trigger warning
------------[ cut here ]------------
WARNING: CPU: 3 PID: 1284 at fs/inode.c:282 drop_nlink+0x3e/0x50
...
Call Trace:
dump_stack+0x63/0x81
__warn+0xcb/0xf0
warn_slowpath_null+0x1d/0x20
drop_nlink+0x3e/0x50
v9fs_remove+0xaa/0x130 [9p]
v9fs_vfs_rmdir+0x13/0x20 [9p]
vfs_rmdir+0xb7/0x130
do_rmdir+0x1b8/0x230
SyS_unlinkat+0x22/0x30
do_syscall_64+0x67/0x180
---[ end trace 43758d8ba91e603b ]---
Fix it by leaving i_nlink to be 1 and don't drop nlink if a directory
has nlink <= 2, which indicates that the underlying exported fs doesn't
maintain nlink count accurately. This follows what ext4 does in
ext4_dec_count().
Link: http://lkml.kernel.org/r/20180312053829.4367-1-eguan@linux.alibaba.com
Signed-off-by: Eryu Guan <eguan@linux.alibaba.com>
Reviewed-by: Yiwen Jiang <jiangyiwen@huawei.com>
Tested-by: Roman Kapl <code@rkapl.cz>
Cc: Caspar Zhang <caspar@linux.alibaba.com>
Cc: Eric Van Hensbergen <ericvh@gmail.com>
Cc: Ron Minnich <rminnich@sandia.gov>
Cc: Latchesar Ionkov <lucho@ionkov.net>
Cc: <v9fs-developer@lists.sourceforge.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-05 23:19:49 +00:00
|
|
|
v9fs_dec_count(old_dir);
|
2011-02-28 11:34:05 +00:00
|
|
|
}
|
2011-02-28 11:34:07 +00:00
|
|
|
v9fs_invalidate_inode_attr(old_inode);
|
2011-02-28 11:34:08 +00:00
|
|
|
v9fs_invalidate_inode_attr(old_dir);
|
|
|
|
v9fs_invalidate_inode_attr(new_dir);
|
2011-02-28 11:34:07 +00:00
|
|
|
|
2010-06-30 13:48:50 +00:00
|
|
|
/* successful rename */
|
|
|
|
d_move(old_dentry, new_dentry);
|
2011-02-28 11:34:05 +00:00
|
|
|
}
|
2010-06-30 13:48:50 +00:00
|
|
|
up_write(&v9ses->rename_sem);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2022-06-12 07:05:39 +00:00
|
|
|
error:
|
|
|
|
p9_fid_put(newdirfid);
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(olddirfid);
|
|
|
|
p9_fid_put(oldfid);
|
2005-09-09 20:04:19 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-01-09 23:10:13 +00:00
|
|
|
* v9fs_vfs_getattr - retrieve file metadata
|
2023-01-13 11:49:12 +00:00
|
|
|
* @idmap: idmap of the mount
|
statx: Add a system call to make enhanced file info available
Add a system call to make extended file information available, including
file creation and some attribute flags where available through the
underlying filesystem.
The getattr inode operation is altered to take two additional arguments: a
u32 request_mask and an unsigned int flags that indicate the
synchronisation mode. This change is propagated to the vfs_getattr*()
function.
Functions like vfs_stat() are now inline wrappers around new functions
vfs_statx() and vfs_statx_fd() to reduce stack usage.
========
OVERVIEW
========
The idea was initially proposed as a set of xattrs that could be retrieved
with getxattr(), but the general preference proved to be for a new syscall
with an extended stat structure.
A number of requests were gathered for features to be included. The
following have been included:
(1) Make the fields a consistent size on all arches and make them large.
(2) Spare space, request flags and information flags are provided for
future expansion.
(3) Better support for the y2038 problem [Arnd Bergmann] (tv_sec is an
__s64).
(4) Creation time: The SMB protocol carries the creation time, which could
be exported by Samba, which will in turn help CIFS make use of
FS-Cache as that can be used for coherency data (stx_btime).
This is also specified in NFSv4 as a recommended attribute and could
be exported by NFSD [Steve French].
(5) Lightweight stat: Ask for just those details of interest, and allow a
netfs (such as NFS) to approximate anything not of interest, possibly
without going to the server [Trond Myklebust, Ulrich Drepper, Andreas
Dilger] (AT_STATX_DONT_SYNC).
(6) Heavyweight stat: Force a netfs to go to the server, even if it thinks
its cached attributes are up to date [Trond Myklebust]
(AT_STATX_FORCE_SYNC).
And the following have been left out for future extension:
(7) Data version number: Could be used by userspace NFS servers [Aneesh
Kumar].
Can also be used to modify fill_post_wcc() in NFSD which retrieves
i_version directly, but has just called vfs_getattr(). It could get
it from the kstat struct if it used vfs_xgetattr() instead.
(There's disagreement on the exact semantics of a single field, since
not all filesystems do this the same way).
(8) BSD stat compatibility: Including more fields from the BSD stat such
as creation time (st_btime) and inode generation number (st_gen)
[Jeremy Allison, Bernd Schubert].
(9) Inode generation number: Useful for FUSE and userspace NFS servers
[Bernd Schubert].
(This was asked for but later deemed unnecessary with the
open-by-handle capability available and caused disagreement as to
whether it's a security hole or not).
(10) Extra coherency data may be useful in making backups [Andreas Dilger].
(No particular data were offered, but things like last backup
timestamp, the data version number and the DOS archive bit would come
into this category).
(11) Allow the filesystem to indicate what it can/cannot provide: A
filesystem can now say it doesn't support a standard stat feature if
that isn't available, so if, for instance, inode numbers or UIDs don't
exist or are fabricated locally...
(This requires a separate system call - I have an fsinfo() call idea
for this).
(12) Store a 16-byte volume ID in the superblock that can be returned in
struct xstat [Steve French].
(Deferred to fsinfo).
(13) Include granularity fields in the time data to indicate the
granularity of each of the times (NFSv4 time_delta) [Steve French].
(Deferred to fsinfo).
(14) FS_IOC_GETFLAGS value. These could be translated to BSD's st_flags.
Note that the Linux IOC flags are a mess and filesystems such as Ext4
define flags that aren't in linux/fs.h, so translation in the kernel
may be a necessity (or, possibly, we provide the filesystem type too).
(Some attributes are made available in stx_attributes, but the general
feeling was that the IOC flags were to ext[234]-specific and shouldn't
be exposed through statx this way).
(15) Mask of features available on file (eg: ACLs, seclabel) [Brad Boyer,
Michael Kerrisk].
(Deferred, probably to fsinfo. Finding out if there's an ACL or
seclabal might require extra filesystem operations).
(16) Femtosecond-resolution timestamps [Dave Chinner].
(A __reserved field has been left in the statx_timestamp struct for
this - if there proves to be a need).
(17) A set multiple attributes syscall to go with this.
===============
NEW SYSTEM CALL
===============
The new system call is:
int ret = statx(int dfd,
const char *filename,
unsigned int flags,
unsigned int mask,
struct statx *buffer);
The dfd, filename and flags parameters indicate the file to query, in a
similar way to fstatat(). There is no equivalent of lstat() as that can be
emulated with statx() by passing AT_SYMLINK_NOFOLLOW in flags. There is
also no equivalent of fstat() as that can be emulated by passing a NULL
filename to statx() with the fd of interest in dfd.
Whether or not statx() synchronises the attributes with the backing store
can be controlled by OR'ing a value into the flags argument (this typically
only affects network filesystems):
(1) AT_STATX_SYNC_AS_STAT tells statx() to behave as stat() does in this
respect.
(2) AT_STATX_FORCE_SYNC will require a network filesystem to synchronise
its attributes with the server - which might require data writeback to
occur to get the timestamps correct.
(3) AT_STATX_DONT_SYNC will suppress synchronisation with the server in a
network filesystem. The resulting values should be considered
approximate.
mask is a bitmask indicating the fields in struct statx that are of
interest to the caller. The user should set this to STATX_BASIC_STATS to
get the basic set returned by stat(). It should be noted that asking for
more information may entail extra I/O operations.
buffer points to the destination for the data. This must be 256 bytes in
size.
======================
MAIN ATTRIBUTES RECORD
======================
The following structures are defined in which to return the main attribute
set:
struct statx_timestamp {
__s64 tv_sec;
__s32 tv_nsec;
__s32 __reserved;
};
struct statx {
__u32 stx_mask;
__u32 stx_blksize;
__u64 stx_attributes;
__u32 stx_nlink;
__u32 stx_uid;
__u32 stx_gid;
__u16 stx_mode;
__u16 __spare0[1];
__u64 stx_ino;
__u64 stx_size;
__u64 stx_blocks;
__u64 __spare1[1];
struct statx_timestamp stx_atime;
struct statx_timestamp stx_btime;
struct statx_timestamp stx_ctime;
struct statx_timestamp stx_mtime;
__u32 stx_rdev_major;
__u32 stx_rdev_minor;
__u32 stx_dev_major;
__u32 stx_dev_minor;
__u64 __spare2[14];
};
The defined bits in request_mask and stx_mask are:
STATX_TYPE Want/got stx_mode & S_IFMT
STATX_MODE Want/got stx_mode & ~S_IFMT
STATX_NLINK Want/got stx_nlink
STATX_UID Want/got stx_uid
STATX_GID Want/got stx_gid
STATX_ATIME Want/got stx_atime{,_ns}
STATX_MTIME Want/got stx_mtime{,_ns}
STATX_CTIME Want/got stx_ctime{,_ns}
STATX_INO Want/got stx_ino
STATX_SIZE Want/got stx_size
STATX_BLOCKS Want/got stx_blocks
STATX_BASIC_STATS [The stuff in the normal stat struct]
STATX_BTIME Want/got stx_btime{,_ns}
STATX_ALL [All currently available stuff]
stx_btime is the file creation time, stx_mask is a bitmask indicating the
data provided and __spares*[] are where as-yet undefined fields can be
placed.
Time fields are structures with separate seconds and nanoseconds fields
plus a reserved field in case we want to add even finer resolution. Note
that times will be negative if before 1970; in such a case, the nanosecond
fields will also be negative if not zero.
The bits defined in the stx_attributes field convey information about a
file, how it is accessed, where it is and what it does. The following
attributes map to FS_*_FL flags and are the same numerical value:
STATX_ATTR_COMPRESSED File is compressed by the fs
STATX_ATTR_IMMUTABLE File is marked immutable
STATX_ATTR_APPEND File is append-only
STATX_ATTR_NODUMP File is not to be dumped
STATX_ATTR_ENCRYPTED File requires key to decrypt in fs
Within the kernel, the supported flags are listed by:
KSTAT_ATTR_FS_IOC_FLAGS
[Are any other IOC flags of sufficient general interest to be exposed
through this interface?]
New flags include:
STATX_ATTR_AUTOMOUNT Object is an automount trigger
These are for the use of GUI tools that might want to mark files specially,
depending on what they are.
Fields in struct statx come in a number of classes:
(0) stx_dev_*, stx_blksize.
These are local system information and are always available.
(1) stx_mode, stx_nlinks, stx_uid, stx_gid, stx_[amc]time, stx_ino,
stx_size, stx_blocks.
These will be returned whether the caller asks for them or not. The
corresponding bits in stx_mask will be set to indicate whether they
actually have valid values.
If the caller didn't ask for them, then they may be approximated. For
example, NFS won't waste any time updating them from the server,
unless as a byproduct of updating something requested.
If the values don't actually exist for the underlying object (such as
UID or GID on a DOS file), then the bit won't be set in the stx_mask,
even if the caller asked for the value. In such a case, the returned
value will be a fabrication.
Note that there are instances where the type might not be valid, for
instance Windows reparse points.
(2) stx_rdev_*.
This will be set only if stx_mode indicates we're looking at a
blockdev or a chardev, otherwise will be 0.
(3) stx_btime.
Similar to (1), except this will be set to 0 if it doesn't exist.
=======
TESTING
=======
The following test program can be used to test the statx system call:
samples/statx/test-statx.c
Just compile and run, passing it paths to the files you want to examine.
The file is built automatically if CONFIG_SAMPLES is enabled.
Here's some example output. Firstly, an NFS directory that crosses to
another FSID. Note that the AUTOMOUNT attribute is set because transiting
this directory will cause d_automount to be invoked by the VFS.
[root@andromeda ~]# /tmp/test-statx -A /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:26 Inode: 1703937 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Attributes: 0000000000001000 (-------- -------- -------- -------- -------- -------- ---m---- --------)
Secondly, the result of automounting on that directory.
[root@andromeda ~]# /tmp/test-statx /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:27 Inode: 2 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2017-01-31 16:46:22 +00:00
|
|
|
* @path: Object to query
|
2008-03-05 13:08:09 +00:00
|
|
|
* @stat: metadata structure to populate
|
statx: Add a system call to make enhanced file info available
Add a system call to make extended file information available, including
file creation and some attribute flags where available through the
underlying filesystem.
The getattr inode operation is altered to take two additional arguments: a
u32 request_mask and an unsigned int flags that indicate the
synchronisation mode. This change is propagated to the vfs_getattr*()
function.
Functions like vfs_stat() are now inline wrappers around new functions
vfs_statx() and vfs_statx_fd() to reduce stack usage.
========
OVERVIEW
========
The idea was initially proposed as a set of xattrs that could be retrieved
with getxattr(), but the general preference proved to be for a new syscall
with an extended stat structure.
A number of requests were gathered for features to be included. The
following have been included:
(1) Make the fields a consistent size on all arches and make them large.
(2) Spare space, request flags and information flags are provided for
future expansion.
(3) Better support for the y2038 problem [Arnd Bergmann] (tv_sec is an
__s64).
(4) Creation time: The SMB protocol carries the creation time, which could
be exported by Samba, which will in turn help CIFS make use of
FS-Cache as that can be used for coherency data (stx_btime).
This is also specified in NFSv4 as a recommended attribute and could
be exported by NFSD [Steve French].
(5) Lightweight stat: Ask for just those details of interest, and allow a
netfs (such as NFS) to approximate anything not of interest, possibly
without going to the server [Trond Myklebust, Ulrich Drepper, Andreas
Dilger] (AT_STATX_DONT_SYNC).
(6) Heavyweight stat: Force a netfs to go to the server, even if it thinks
its cached attributes are up to date [Trond Myklebust]
(AT_STATX_FORCE_SYNC).
And the following have been left out for future extension:
(7) Data version number: Could be used by userspace NFS servers [Aneesh
Kumar].
Can also be used to modify fill_post_wcc() in NFSD which retrieves
i_version directly, but has just called vfs_getattr(). It could get
it from the kstat struct if it used vfs_xgetattr() instead.
(There's disagreement on the exact semantics of a single field, since
not all filesystems do this the same way).
(8) BSD stat compatibility: Including more fields from the BSD stat such
as creation time (st_btime) and inode generation number (st_gen)
[Jeremy Allison, Bernd Schubert].
(9) Inode generation number: Useful for FUSE and userspace NFS servers
[Bernd Schubert].
(This was asked for but later deemed unnecessary with the
open-by-handle capability available and caused disagreement as to
whether it's a security hole or not).
(10) Extra coherency data may be useful in making backups [Andreas Dilger].
(No particular data were offered, but things like last backup
timestamp, the data version number and the DOS archive bit would come
into this category).
(11) Allow the filesystem to indicate what it can/cannot provide: A
filesystem can now say it doesn't support a standard stat feature if
that isn't available, so if, for instance, inode numbers or UIDs don't
exist or are fabricated locally...
(This requires a separate system call - I have an fsinfo() call idea
for this).
(12) Store a 16-byte volume ID in the superblock that can be returned in
struct xstat [Steve French].
(Deferred to fsinfo).
(13) Include granularity fields in the time data to indicate the
granularity of each of the times (NFSv4 time_delta) [Steve French].
(Deferred to fsinfo).
(14) FS_IOC_GETFLAGS value. These could be translated to BSD's st_flags.
Note that the Linux IOC flags are a mess and filesystems such as Ext4
define flags that aren't in linux/fs.h, so translation in the kernel
may be a necessity (or, possibly, we provide the filesystem type too).
(Some attributes are made available in stx_attributes, but the general
feeling was that the IOC flags were to ext[234]-specific and shouldn't
be exposed through statx this way).
(15) Mask of features available on file (eg: ACLs, seclabel) [Brad Boyer,
Michael Kerrisk].
(Deferred, probably to fsinfo. Finding out if there's an ACL or
seclabal might require extra filesystem operations).
(16) Femtosecond-resolution timestamps [Dave Chinner].
(A __reserved field has been left in the statx_timestamp struct for
this - if there proves to be a need).
(17) A set multiple attributes syscall to go with this.
===============
NEW SYSTEM CALL
===============
The new system call is:
int ret = statx(int dfd,
const char *filename,
unsigned int flags,
unsigned int mask,
struct statx *buffer);
The dfd, filename and flags parameters indicate the file to query, in a
similar way to fstatat(). There is no equivalent of lstat() as that can be
emulated with statx() by passing AT_SYMLINK_NOFOLLOW in flags. There is
also no equivalent of fstat() as that can be emulated by passing a NULL
filename to statx() with the fd of interest in dfd.
Whether or not statx() synchronises the attributes with the backing store
can be controlled by OR'ing a value into the flags argument (this typically
only affects network filesystems):
(1) AT_STATX_SYNC_AS_STAT tells statx() to behave as stat() does in this
respect.
(2) AT_STATX_FORCE_SYNC will require a network filesystem to synchronise
its attributes with the server - which might require data writeback to
occur to get the timestamps correct.
(3) AT_STATX_DONT_SYNC will suppress synchronisation with the server in a
network filesystem. The resulting values should be considered
approximate.
mask is a bitmask indicating the fields in struct statx that are of
interest to the caller. The user should set this to STATX_BASIC_STATS to
get the basic set returned by stat(). It should be noted that asking for
more information may entail extra I/O operations.
buffer points to the destination for the data. This must be 256 bytes in
size.
======================
MAIN ATTRIBUTES RECORD
======================
The following structures are defined in which to return the main attribute
set:
struct statx_timestamp {
__s64 tv_sec;
__s32 tv_nsec;
__s32 __reserved;
};
struct statx {
__u32 stx_mask;
__u32 stx_blksize;
__u64 stx_attributes;
__u32 stx_nlink;
__u32 stx_uid;
__u32 stx_gid;
__u16 stx_mode;
__u16 __spare0[1];
__u64 stx_ino;
__u64 stx_size;
__u64 stx_blocks;
__u64 __spare1[1];
struct statx_timestamp stx_atime;
struct statx_timestamp stx_btime;
struct statx_timestamp stx_ctime;
struct statx_timestamp stx_mtime;
__u32 stx_rdev_major;
__u32 stx_rdev_minor;
__u32 stx_dev_major;
__u32 stx_dev_minor;
__u64 __spare2[14];
};
The defined bits in request_mask and stx_mask are:
STATX_TYPE Want/got stx_mode & S_IFMT
STATX_MODE Want/got stx_mode & ~S_IFMT
STATX_NLINK Want/got stx_nlink
STATX_UID Want/got stx_uid
STATX_GID Want/got stx_gid
STATX_ATIME Want/got stx_atime{,_ns}
STATX_MTIME Want/got stx_mtime{,_ns}
STATX_CTIME Want/got stx_ctime{,_ns}
STATX_INO Want/got stx_ino
STATX_SIZE Want/got stx_size
STATX_BLOCKS Want/got stx_blocks
STATX_BASIC_STATS [The stuff in the normal stat struct]
STATX_BTIME Want/got stx_btime{,_ns}
STATX_ALL [All currently available stuff]
stx_btime is the file creation time, stx_mask is a bitmask indicating the
data provided and __spares*[] are where as-yet undefined fields can be
placed.
Time fields are structures with separate seconds and nanoseconds fields
plus a reserved field in case we want to add even finer resolution. Note
that times will be negative if before 1970; in such a case, the nanosecond
fields will also be negative if not zero.
The bits defined in the stx_attributes field convey information about a
file, how it is accessed, where it is and what it does. The following
attributes map to FS_*_FL flags and are the same numerical value:
STATX_ATTR_COMPRESSED File is compressed by the fs
STATX_ATTR_IMMUTABLE File is marked immutable
STATX_ATTR_APPEND File is append-only
STATX_ATTR_NODUMP File is not to be dumped
STATX_ATTR_ENCRYPTED File requires key to decrypt in fs
Within the kernel, the supported flags are listed by:
KSTAT_ATTR_FS_IOC_FLAGS
[Are any other IOC flags of sufficient general interest to be exposed
through this interface?]
New flags include:
STATX_ATTR_AUTOMOUNT Object is an automount trigger
These are for the use of GUI tools that might want to mark files specially,
depending on what they are.
Fields in struct statx come in a number of classes:
(0) stx_dev_*, stx_blksize.
These are local system information and are always available.
(1) stx_mode, stx_nlinks, stx_uid, stx_gid, stx_[amc]time, stx_ino,
stx_size, stx_blocks.
These will be returned whether the caller asks for them or not. The
corresponding bits in stx_mask will be set to indicate whether they
actually have valid values.
If the caller didn't ask for them, then they may be approximated. For
example, NFS won't waste any time updating them from the server,
unless as a byproduct of updating something requested.
If the values don't actually exist for the underlying object (such as
UID or GID on a DOS file), then the bit won't be set in the stx_mask,
even if the caller asked for the value. In such a case, the returned
value will be a fabrication.
Note that there are instances where the type might not be valid, for
instance Windows reparse points.
(2) stx_rdev_*.
This will be set only if stx_mode indicates we're looking at a
blockdev or a chardev, otherwise will be 0.
(3) stx_btime.
Similar to (1), except this will be set to 0 if it doesn't exist.
=======
TESTING
=======
The following test program can be used to test the statx system call:
samples/statx/test-statx.c
Just compile and run, passing it paths to the files you want to examine.
The file is built automatically if CONFIG_SAMPLES is enabled.
Here's some example output. Firstly, an NFS directory that crosses to
another FSID. Note that the AUTOMOUNT attribute is set because transiting
this directory will cause d_automount to be invoked by the VFS.
[root@andromeda ~]# /tmp/test-statx -A /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:26 Inode: 1703937 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Attributes: 0000000000001000 (-------- -------- -------- -------- -------- -------- ---m---- --------)
Secondly, the result of automounting on that directory.
[root@andromeda ~]# /tmp/test-statx /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:27 Inode: 2 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2017-01-31 16:46:22 +00:00
|
|
|
* @request_mask: Mask of STATX_xxx flags indicating the caller's interests
|
|
|
|
* @flags: AT_STATX_xxx setting
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2023-01-13 11:49:12 +00:00
|
|
|
v9fs_vfs_getattr(struct mnt_idmap *idmap, const struct path *path,
|
2021-01-21 13:19:43 +00:00
|
|
|
struct kstat *stat, u32 request_mask, unsigned int flags)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
statx: Add a system call to make enhanced file info available
Add a system call to make extended file information available, including
file creation and some attribute flags where available through the
underlying filesystem.
The getattr inode operation is altered to take two additional arguments: a
u32 request_mask and an unsigned int flags that indicate the
synchronisation mode. This change is propagated to the vfs_getattr*()
function.
Functions like vfs_stat() are now inline wrappers around new functions
vfs_statx() and vfs_statx_fd() to reduce stack usage.
========
OVERVIEW
========
The idea was initially proposed as a set of xattrs that could be retrieved
with getxattr(), but the general preference proved to be for a new syscall
with an extended stat structure.
A number of requests were gathered for features to be included. The
following have been included:
(1) Make the fields a consistent size on all arches and make them large.
(2) Spare space, request flags and information flags are provided for
future expansion.
(3) Better support for the y2038 problem [Arnd Bergmann] (tv_sec is an
__s64).
(4) Creation time: The SMB protocol carries the creation time, which could
be exported by Samba, which will in turn help CIFS make use of
FS-Cache as that can be used for coherency data (stx_btime).
This is also specified in NFSv4 as a recommended attribute and could
be exported by NFSD [Steve French].
(5) Lightweight stat: Ask for just those details of interest, and allow a
netfs (such as NFS) to approximate anything not of interest, possibly
without going to the server [Trond Myklebust, Ulrich Drepper, Andreas
Dilger] (AT_STATX_DONT_SYNC).
(6) Heavyweight stat: Force a netfs to go to the server, even if it thinks
its cached attributes are up to date [Trond Myklebust]
(AT_STATX_FORCE_SYNC).
And the following have been left out for future extension:
(7) Data version number: Could be used by userspace NFS servers [Aneesh
Kumar].
Can also be used to modify fill_post_wcc() in NFSD which retrieves
i_version directly, but has just called vfs_getattr(). It could get
it from the kstat struct if it used vfs_xgetattr() instead.
(There's disagreement on the exact semantics of a single field, since
not all filesystems do this the same way).
(8) BSD stat compatibility: Including more fields from the BSD stat such
as creation time (st_btime) and inode generation number (st_gen)
[Jeremy Allison, Bernd Schubert].
(9) Inode generation number: Useful for FUSE and userspace NFS servers
[Bernd Schubert].
(This was asked for but later deemed unnecessary with the
open-by-handle capability available and caused disagreement as to
whether it's a security hole or not).
(10) Extra coherency data may be useful in making backups [Andreas Dilger].
(No particular data were offered, but things like last backup
timestamp, the data version number and the DOS archive bit would come
into this category).
(11) Allow the filesystem to indicate what it can/cannot provide: A
filesystem can now say it doesn't support a standard stat feature if
that isn't available, so if, for instance, inode numbers or UIDs don't
exist or are fabricated locally...
(This requires a separate system call - I have an fsinfo() call idea
for this).
(12) Store a 16-byte volume ID in the superblock that can be returned in
struct xstat [Steve French].
(Deferred to fsinfo).
(13) Include granularity fields in the time data to indicate the
granularity of each of the times (NFSv4 time_delta) [Steve French].
(Deferred to fsinfo).
(14) FS_IOC_GETFLAGS value. These could be translated to BSD's st_flags.
Note that the Linux IOC flags are a mess and filesystems such as Ext4
define flags that aren't in linux/fs.h, so translation in the kernel
may be a necessity (or, possibly, we provide the filesystem type too).
(Some attributes are made available in stx_attributes, but the general
feeling was that the IOC flags were to ext[234]-specific and shouldn't
be exposed through statx this way).
(15) Mask of features available on file (eg: ACLs, seclabel) [Brad Boyer,
Michael Kerrisk].
(Deferred, probably to fsinfo. Finding out if there's an ACL or
seclabal might require extra filesystem operations).
(16) Femtosecond-resolution timestamps [Dave Chinner].
(A __reserved field has been left in the statx_timestamp struct for
this - if there proves to be a need).
(17) A set multiple attributes syscall to go with this.
===============
NEW SYSTEM CALL
===============
The new system call is:
int ret = statx(int dfd,
const char *filename,
unsigned int flags,
unsigned int mask,
struct statx *buffer);
The dfd, filename and flags parameters indicate the file to query, in a
similar way to fstatat(). There is no equivalent of lstat() as that can be
emulated with statx() by passing AT_SYMLINK_NOFOLLOW in flags. There is
also no equivalent of fstat() as that can be emulated by passing a NULL
filename to statx() with the fd of interest in dfd.
Whether or not statx() synchronises the attributes with the backing store
can be controlled by OR'ing a value into the flags argument (this typically
only affects network filesystems):
(1) AT_STATX_SYNC_AS_STAT tells statx() to behave as stat() does in this
respect.
(2) AT_STATX_FORCE_SYNC will require a network filesystem to synchronise
its attributes with the server - which might require data writeback to
occur to get the timestamps correct.
(3) AT_STATX_DONT_SYNC will suppress synchronisation with the server in a
network filesystem. The resulting values should be considered
approximate.
mask is a bitmask indicating the fields in struct statx that are of
interest to the caller. The user should set this to STATX_BASIC_STATS to
get the basic set returned by stat(). It should be noted that asking for
more information may entail extra I/O operations.
buffer points to the destination for the data. This must be 256 bytes in
size.
======================
MAIN ATTRIBUTES RECORD
======================
The following structures are defined in which to return the main attribute
set:
struct statx_timestamp {
__s64 tv_sec;
__s32 tv_nsec;
__s32 __reserved;
};
struct statx {
__u32 stx_mask;
__u32 stx_blksize;
__u64 stx_attributes;
__u32 stx_nlink;
__u32 stx_uid;
__u32 stx_gid;
__u16 stx_mode;
__u16 __spare0[1];
__u64 stx_ino;
__u64 stx_size;
__u64 stx_blocks;
__u64 __spare1[1];
struct statx_timestamp stx_atime;
struct statx_timestamp stx_btime;
struct statx_timestamp stx_ctime;
struct statx_timestamp stx_mtime;
__u32 stx_rdev_major;
__u32 stx_rdev_minor;
__u32 stx_dev_major;
__u32 stx_dev_minor;
__u64 __spare2[14];
};
The defined bits in request_mask and stx_mask are:
STATX_TYPE Want/got stx_mode & S_IFMT
STATX_MODE Want/got stx_mode & ~S_IFMT
STATX_NLINK Want/got stx_nlink
STATX_UID Want/got stx_uid
STATX_GID Want/got stx_gid
STATX_ATIME Want/got stx_atime{,_ns}
STATX_MTIME Want/got stx_mtime{,_ns}
STATX_CTIME Want/got stx_ctime{,_ns}
STATX_INO Want/got stx_ino
STATX_SIZE Want/got stx_size
STATX_BLOCKS Want/got stx_blocks
STATX_BASIC_STATS [The stuff in the normal stat struct]
STATX_BTIME Want/got stx_btime{,_ns}
STATX_ALL [All currently available stuff]
stx_btime is the file creation time, stx_mask is a bitmask indicating the
data provided and __spares*[] are where as-yet undefined fields can be
placed.
Time fields are structures with separate seconds and nanoseconds fields
plus a reserved field in case we want to add even finer resolution. Note
that times will be negative if before 1970; in such a case, the nanosecond
fields will also be negative if not zero.
The bits defined in the stx_attributes field convey information about a
file, how it is accessed, where it is and what it does. The following
attributes map to FS_*_FL flags and are the same numerical value:
STATX_ATTR_COMPRESSED File is compressed by the fs
STATX_ATTR_IMMUTABLE File is marked immutable
STATX_ATTR_APPEND File is append-only
STATX_ATTR_NODUMP File is not to be dumped
STATX_ATTR_ENCRYPTED File requires key to decrypt in fs
Within the kernel, the supported flags are listed by:
KSTAT_ATTR_FS_IOC_FLAGS
[Are any other IOC flags of sufficient general interest to be exposed
through this interface?]
New flags include:
STATX_ATTR_AUTOMOUNT Object is an automount trigger
These are for the use of GUI tools that might want to mark files specially,
depending on what they are.
Fields in struct statx come in a number of classes:
(0) stx_dev_*, stx_blksize.
These are local system information and are always available.
(1) stx_mode, stx_nlinks, stx_uid, stx_gid, stx_[amc]time, stx_ino,
stx_size, stx_blocks.
These will be returned whether the caller asks for them or not. The
corresponding bits in stx_mask will be set to indicate whether they
actually have valid values.
If the caller didn't ask for them, then they may be approximated. For
example, NFS won't waste any time updating them from the server,
unless as a byproduct of updating something requested.
If the values don't actually exist for the underlying object (such as
UID or GID on a DOS file), then the bit won't be set in the stx_mask,
even if the caller asked for the value. In such a case, the returned
value will be a fabrication.
Note that there are instances where the type might not be valid, for
instance Windows reparse points.
(2) stx_rdev_*.
This will be set only if stx_mode indicates we're looking at a
blockdev or a chardev, otherwise will be 0.
(3) stx_btime.
Similar to (1), except this will be set to 0 if it doesn't exist.
=======
TESTING
=======
The following test program can be used to test the statx system call:
samples/statx/test-statx.c
Just compile and run, passing it paths to the files you want to examine.
The file is built automatically if CONFIG_SAMPLES is enabled.
Here's some example output. Firstly, an NFS directory that crosses to
another FSID. Note that the AUTOMOUNT attribute is set because transiting
this directory will cause d_automount to be invoked by the VFS.
[root@andromeda ~]# /tmp/test-statx -A /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:26 Inode: 1703937 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Attributes: 0000000000001000 (-------- -------- -------- -------- -------- -------- ---m---- --------)
Secondly, the result of automounting on that directory.
[root@andromeda ~]# /tmp/test-statx /warthog/data
statx(/warthog/data) = 0
results=7ff
Size: 4096 Blocks: 8 IO Block: 1048576 directory
Device: 00:27 Inode: 2 Links: 125
Access: (3777/drwxrwxrwx) Uid: 0 Gid: 4041
Access: 2016-11-24 09:02:12.219699527+0000
Modify: 2016-11-17 10:44:36.225653653+0000
Change: 2016-11-17 10:44:36.225653653+0000
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2017-01-31 16:46:22 +00:00
|
|
|
struct dentry *dentry = path->dentry;
|
2007-07-10 22:57:28 +00:00
|
|
|
struct v9fs_session_info *v9ses;
|
|
|
|
struct p9_fid *fid;
|
2008-10-16 13:30:07 +00:00
|
|
|
struct p9_wstat *st;
|
2007-07-10 22:57:28 +00:00
|
|
|
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
|
2011-03-08 11:09:50 +00:00
|
|
|
v9ses = v9fs_dentry2v9ses(dentry);
|
2011-02-28 11:34:01 +00:00
|
|
|
if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
|
2023-01-13 11:49:12 +00:00
|
|
|
generic_fillattr(&nop_mnt_idmap, d_inode(dentry), stat);
|
2011-02-28 11:34:01 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2007-07-10 22:57:28 +00:00
|
|
|
fid = v9fs_fid_lookup(dentry);
|
|
|
|
if (IS_ERR(fid))
|
2007-01-26 08:57:06 +00:00
|
|
|
return PTR_ERR(fid);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
st = p9_client_stat(fid);
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(fid);
|
2007-07-10 22:57:28 +00:00
|
|
|
if (IS_ERR(st))
|
|
|
|
return PTR_ERR(st);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2019-01-24 06:35:13 +00:00
|
|
|
v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb, 0);
|
2023-01-13 11:49:12 +00:00
|
|
|
generic_fillattr(&nop_mnt_idmap, d_inode(dentry), stat);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2010-08-24 18:13:59 +00:00
|
|
|
p9stat_free(st);
|
2007-07-10 22:57:28 +00:00
|
|
|
kfree(st);
|
|
|
|
return 0;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* v9fs_vfs_setattr - set file metadata
|
2023-01-13 11:49:11 +00:00
|
|
|
* @idmap: idmap of the mount
|
2005-09-09 20:04:19 +00:00
|
|
|
* @dentry: file whose metadata to set
|
|
|
|
* @iattr: metadata assignment structure
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2023-01-13 11:49:11 +00:00
|
|
|
static int v9fs_vfs_setattr(struct mnt_idmap *idmap,
|
2021-01-21 13:19:43 +00:00
|
|
|
struct dentry *dentry, struct iattr *iattr)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2020-09-23 14:11:46 +00:00
|
|
|
int retval, use_dentry = 0;
|
2020-11-18 09:06:42 +00:00
|
|
|
struct inode *inode = d_inode(dentry);
|
|
|
|
struct v9fs_inode *v9inode = V9FS_I(inode);
|
2007-07-10 22:57:28 +00:00
|
|
|
struct v9fs_session_info *v9ses;
|
2020-07-10 10:15:48 +00:00
|
|
|
struct p9_fid *fid = NULL;
|
2007-07-10 22:57:28 +00:00
|
|
|
struct p9_wstat wstat;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "\n");
|
2023-01-13 11:49:11 +00:00
|
|
|
retval = setattr_prepare(&nop_mnt_idmap, dentry, iattr);
|
2011-03-08 11:09:48 +00:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
retval = -EPERM;
|
2011-03-08 11:09:50 +00:00
|
|
|
v9ses = v9fs_dentry2v9ses(dentry);
|
2020-07-10 10:15:48 +00:00
|
|
|
if (iattr->ia_valid & ATTR_FILE) {
|
|
|
|
fid = iattr->ia_file->private_data;
|
|
|
|
WARN_ON(!fid);
|
|
|
|
}
|
2020-09-23 14:11:46 +00:00
|
|
|
if (!fid) {
|
2020-07-10 10:15:48 +00:00
|
|
|
fid = v9fs_fid_lookup(dentry);
|
2020-09-23 14:11:46 +00:00
|
|
|
use_dentry = 1;
|
|
|
|
}
|
2021-11-02 13:16:43 +00:00
|
|
|
if (IS_ERR(fid))
|
2007-01-26 08:57:06 +00:00
|
|
|
return PTR_ERR(fid);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2006-01-08 09:05:00 +00:00
|
|
|
v9fs_blank_wstat(&wstat);
|
2005-09-09 20:04:19 +00:00
|
|
|
if (iattr->ia_valid & ATTR_MODE)
|
2006-01-08 09:05:00 +00:00
|
|
|
wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
|
|
|
if (iattr->ia_valid & ATTR_MTIME)
|
2006-01-08 09:05:00 +00:00
|
|
|
wstat.mtime = iattr->ia_mtime.tv_sec;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
|
|
|
if (iattr->ia_valid & ATTR_ATIME)
|
2006-01-08 09:05:00 +00:00
|
|
|
wstat.atime = iattr->ia_atime.tv_sec;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
|
|
|
if (iattr->ia_valid & ATTR_SIZE)
|
2006-01-08 09:05:00 +00:00
|
|
|
wstat.length = iattr->ia_size;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2010-03-05 18:48:00 +00:00
|
|
|
if (v9fs_proto_dotu(v9ses)) {
|
2006-01-08 09:05:00 +00:00
|
|
|
if (iattr->ia_valid & ATTR_UID)
|
|
|
|
wstat.n_uid = iattr->ia_uid;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2006-01-08 09:05:00 +00:00
|
|
|
if (iattr->ia_valid & ATTR_GID)
|
|
|
|
wstat.n_gid = iattr->ia_gid;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
2011-03-08 11:09:48 +00:00
|
|
|
|
2011-02-28 11:34:11 +00:00
|
|
|
/* Write all dirty data */
|
VFS: (Scripted) Convert S_ISLNK/DIR/REG(dentry->d_inode) to d_is_*(dentry)
Convert the following where appropriate:
(1) S_ISLNK(dentry->d_inode) to d_is_symlink(dentry).
(2) S_ISREG(dentry->d_inode) to d_is_reg(dentry).
(3) S_ISDIR(dentry->d_inode) to d_is_dir(dentry). This is actually more
complicated than it appears as some calls should be converted to
d_can_lookup() instead. The difference is whether the directory in
question is a real dir with a ->lookup op or whether it's a fake dir with
a ->d_automount op.
In some circumstances, we can subsume checks for dentry->d_inode not being
NULL into this, provided we the code isn't in a filesystem that expects
d_inode to be NULL if the dirent really *is* negative (ie. if we're going to
use d_inode() rather than d_backing_inode() to get the inode pointer).
Note that the dentry type field may be set to something other than
DCACHE_MISS_TYPE when d_inode is NULL in the case of unionmount, where the VFS
manages the fall-through from a negative dentry to a lower layer. In such a
case, the dentry type of the negative union dentry is set to the same as the
type of the lower dentry.
However, if you know d_inode is not NULL at the call site, then you can use
the d_is_xxx() functions even in a filesystem.
There is one further complication: a 0,0 chardev dentry may be labelled
DCACHE_WHITEOUT_TYPE rather than DCACHE_SPECIAL_TYPE. Strictly, this was
intended for special directory entry types that don't have attached inodes.
The following perl+coccinelle script was used:
use strict;
my @callers;
open($fd, 'git grep -l \'S_IS[A-Z].*->d_inode\' |') ||
die "Can't grep for S_ISDIR and co. callers";
@callers = <$fd>;
close($fd);
unless (@callers) {
print "No matches\n";
exit(0);
}
my @cocci = (
'@@',
'expression E;',
'@@',
'',
'- S_ISLNK(E->d_inode->i_mode)',
'+ d_is_symlink(E)',
'',
'@@',
'expression E;',
'@@',
'',
'- S_ISDIR(E->d_inode->i_mode)',
'+ d_is_dir(E)',
'',
'@@',
'expression E;',
'@@',
'',
'- S_ISREG(E->d_inode->i_mode)',
'+ d_is_reg(E)' );
my $coccifile = "tmp.sp.cocci";
open($fd, ">$coccifile") || die $coccifile;
print($fd "$_\n") || die $coccifile foreach (@cocci);
close($fd);
foreach my $file (@callers) {
chomp $file;
print "Processing ", $file, "\n";
system("spatch", "--sp-file", $coccifile, $file, "--in-place", "--no-show-diff") == 0 ||
die "spatch failed";
}
[AV: overlayfs parts skipped]
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2015-01-29 12:02:35 +00:00
|
|
|
if (d_is_reg(dentry))
|
2020-11-18 09:06:42 +00:00
|
|
|
filemap_write_and_wait(inode->i_mapping);
|
2011-02-28 11:34:11 +00:00
|
|
|
|
2011-02-28 11:34:10 +00:00
|
|
|
retval = p9_client_wstat(fid, &wstat);
|
2020-09-23 14:11:46 +00:00
|
|
|
|
|
|
|
if (use_dentry)
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(fid);
|
2020-09-23 14:11:46 +00:00
|
|
|
|
2011-02-28 11:34:10 +00:00
|
|
|
if (retval < 0)
|
|
|
|
return retval;
|
2011-03-08 11:09:48 +00:00
|
|
|
|
|
|
|
if ((iattr->ia_valid & ATTR_SIZE) &&
|
2020-11-18 09:06:42 +00:00
|
|
|
iattr->ia_size != i_size_read(inode)) {
|
|
|
|
truncate_setsize(inode, iattr->ia_size);
|
|
|
|
fscache_resize_cookie(v9fs_inode_cookie(v9inode), iattr->ia_size);
|
|
|
|
}
|
2011-03-08 11:09:48 +00:00
|
|
|
|
2020-11-18 09:06:42 +00:00
|
|
|
v9fs_invalidate_inode_attr(inode);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2023-01-13 11:49:11 +00:00
|
|
|
setattr_copy(&nop_mnt_idmap, inode, iattr);
|
2020-11-18 09:06:42 +00:00
|
|
|
mark_inode_dirty(inode);
|
2010-06-04 09:30:02 +00:00
|
|
|
return 0;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-01-08 09:05:00 +00:00
|
|
|
* v9fs_stat2inode - populate an inode structure with mistat info
|
|
|
|
* @stat: Plan 9 metadata (mistat) structure
|
2005-09-09 20:04:19 +00:00
|
|
|
* @inode: inode to populate
|
|
|
|
* @sb: superblock of filesystem
|
2019-01-24 06:35:13 +00:00
|
|
|
* @flags: control flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE)
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
2008-10-16 13:30:07 +00:00
|
|
|
v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
|
2019-01-24 06:35:13 +00:00
|
|
|
struct super_block *sb, unsigned int flags)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2011-07-26 06:53:22 +00:00
|
|
|
umode_t mode;
|
2005-09-09 20:04:19 +00:00
|
|
|
struct v9fs_session_info *v9ses = sb->s_fs_info;
|
2011-02-28 11:34:06 +00:00
|
|
|
struct v9fs_inode *v9inode = V9FS_I(inode);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2011-10-28 12:13:29 +00:00
|
|
|
set_nlink(inode, 1);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2006-01-08 09:05:00 +00:00
|
|
|
inode->i_atime.tv_sec = stat->atime;
|
|
|
|
inode->i_mtime.tv_sec = stat->mtime;
|
|
|
|
inode->i_ctime.tv_sec = stat->mtime;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2007-10-17 19:31:07 +00:00
|
|
|
inode->i_uid = v9ses->dfltuid;
|
|
|
|
inode->i_gid = v9ses->dfltgid;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2010-03-05 18:48:00 +00:00
|
|
|
if (v9fs_proto_dotu(v9ses)) {
|
2006-01-08 09:05:00 +00:00
|
|
|
inode->i_uid = stat->n_uid;
|
|
|
|
inode->i_gid = stat->n_gid;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
2010-03-05 20:43:43 +00:00
|
|
|
if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
|
2021-01-31 19:40:40 +00:00
|
|
|
if (v9fs_proto_dotu(v9ses)) {
|
|
|
|
unsigned int i_nlink;
|
2010-03-05 20:43:43 +00:00
|
|
|
/*
|
2021-01-31 19:40:40 +00:00
|
|
|
* Hadlink support got added later to the .u extension.
|
|
|
|
* So there can be a server out there that doesn't
|
|
|
|
* support this even with .u extension. That would
|
|
|
|
* just leave us with stat->extension being an empty
|
|
|
|
* string, though.
|
2010-03-05 20:43:43 +00:00
|
|
|
*/
|
|
|
|
/* HARDLINKCOUNT %u */
|
2021-01-31 19:40:40 +00:00
|
|
|
if (sscanf(stat->extension,
|
|
|
|
" HARDLINKCOUNT %u", &i_nlink) == 1)
|
2011-10-28 12:13:29 +00:00
|
|
|
set_nlink(inode, i_nlink);
|
2010-03-05 20:43:43 +00:00
|
|
|
}
|
|
|
|
}
|
2012-01-05 08:09:49 +00:00
|
|
|
mode = p9mode2perm(v9ses, stat);
|
2011-07-25 18:06:33 +00:00
|
|
|
mode |= inode->i_mode & ~S_IALLUGO;
|
|
|
|
inode->i_mode = mode;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2019-01-24 06:35:13 +00:00
|
|
|
if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE))
|
|
|
|
v9fs_i_size_write(inode, stat->length);
|
2007-07-10 22:57:28 +00:00
|
|
|
/* not real number of blocks, but 512 byte ones ... */
|
2019-01-24 06:35:13 +00:00
|
|
|
inode->i_blocks = (stat->length + 512 - 1) >> 9;
|
2011-02-28 11:34:06 +00:00
|
|
|
v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* v9fs_qid2ino - convert qid into inode number
|
|
|
|
* @qid: qid to hash
|
|
|
|
*
|
|
|
|
* BUG: potential for inode number collisions?
|
|
|
|
*/
|
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
ino_t v9fs_qid2ino(struct p9_qid *qid)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
|
|
|
u64 path = qid->path + 2;
|
|
|
|
ino_t i = 0;
|
|
|
|
|
|
|
|
if (sizeof(ino_t) == sizeof(path))
|
|
|
|
memcpy(&i, &path, sizeof(ino_t));
|
|
|
|
else
|
|
|
|
i = (ino_t) (path ^ (path >> 32));
|
|
|
|
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-11-17 15:20:54 +00:00
|
|
|
* v9fs_vfs_get_link - follow a symlink path
|
2005-09-09 20:04:19 +00:00
|
|
|
* @dentry: dentry for symlink
|
2015-11-17 15:20:54 +00:00
|
|
|
* @inode: inode for symlink
|
2015-12-29 20:58:39 +00:00
|
|
|
* @done: delayed call for when we are done with the return value
|
2005-09-09 20:04:19 +00:00
|
|
|
*/
|
|
|
|
|
2015-11-17 15:20:54 +00:00
|
|
|
static const char *v9fs_vfs_get_link(struct dentry *dentry,
|
2015-12-29 20:58:39 +00:00
|
|
|
struct inode *inode,
|
|
|
|
struct delayed_call *done)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2015-11-17 15:20:54 +00:00
|
|
|
struct v9fs_session_info *v9ses;
|
|
|
|
struct p9_fid *fid;
|
2008-10-16 13:30:07 +00:00
|
|
|
struct p9_wstat *st;
|
2015-05-02 17:32:22 +00:00
|
|
|
char *res;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2015-11-17 15:20:54 +00:00
|
|
|
if (!dentry)
|
|
|
|
return ERR_PTR(-ECHILD);
|
|
|
|
|
|
|
|
v9ses = v9fs_dentry2v9ses(dentry);
|
2022-06-12 08:14:55 +00:00
|
|
|
if (!v9fs_proto_dotu(v9ses))
|
|
|
|
return ERR_PTR(-EBADF);
|
|
|
|
|
2015-04-14 21:42:49 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, "%pd\n", dentry);
|
2022-06-12 08:14:55 +00:00
|
|
|
fid = v9fs_fid_lookup(dentry);
|
2015-04-14 21:42:49 +00:00
|
|
|
|
2007-10-17 19:31:07 +00:00
|
|
|
if (IS_ERR(fid))
|
2015-04-14 21:42:49 +00:00
|
|
|
return ERR_CAST(fid);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
st = p9_client_stat(fid);
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(fid);
|
2007-07-10 22:57:28 +00:00
|
|
|
if (IS_ERR(st))
|
2015-04-14 21:42:49 +00:00
|
|
|
return ERR_CAST(st);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
if (!(st->mode & P9_DMSYMLINK)) {
|
2015-04-14 21:42:49 +00:00
|
|
|
p9stat_free(st);
|
|
|
|
kfree(st);
|
|
|
|
return ERR_PTR(-EINVAL);
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
2015-05-02 17:32:22 +00:00
|
|
|
res = st->extension;
|
2015-04-14 21:42:49 +00:00
|
|
|
st->extension = NULL;
|
2015-05-02 17:32:22 +00:00
|
|
|
if (strlen(res) >= PATH_MAX)
|
|
|
|
res[PATH_MAX - 1] = '\0';
|
|
|
|
|
2010-08-24 18:13:59 +00:00
|
|
|
p9stat_free(st);
|
2007-07-10 22:57:28 +00:00
|
|
|
kfree(st);
|
2015-12-29 20:58:39 +00:00
|
|
|
set_delayed_call(done, kfree_link, res);
|
|
|
|
return res;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
2008-03-05 13:08:09 +00:00
|
|
|
/**
|
|
|
|
* v9fs_vfs_mkspecial - create a special file
|
|
|
|
* @dir: inode to create special file in
|
|
|
|
* @dentry: dentry to create
|
2014-06-04 23:06:26 +00:00
|
|
|
* @perm: mode to create special file
|
2008-03-05 13:08:09 +00:00
|
|
|
* @extension: 9p2000.u format extension string representing special file
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2006-01-08 09:05:00 +00:00
|
|
|
static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
|
2011-07-24 22:59:07 +00:00
|
|
|
u32 perm, const char *extension)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2007-07-10 22:57:28 +00:00
|
|
|
struct p9_fid *fid;
|
2011-02-28 11:34:08 +00:00
|
|
|
struct v9fs_session_info *v9ses;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2006-03-02 10:54:30 +00:00
|
|
|
v9ses = v9fs_inode2v9ses(dir);
|
2010-03-05 18:48:00 +00:00
|
|
|
if (!v9fs_proto_dotu(v9ses)) {
|
2011-11-28 18:40:46 +00:00
|
|
|
p9_debug(P9_DEBUG_ERROR, "not extended\n");
|
2006-03-02 10:54:30 +00:00
|
|
|
return -EPERM;
|
2005-09-09 20:04:19 +00:00
|
|
|
}
|
|
|
|
|
2007-07-10 22:57:28 +00:00
|
|
|
fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
|
|
|
|
P9_OREAD);
|
|
|
|
if (IS_ERR(fid))
|
|
|
|
return PTR_ERR(fid);
|
2007-01-26 08:57:06 +00:00
|
|
|
|
2011-02-28 11:34:08 +00:00
|
|
|
v9fs_invalidate_inode_attr(dir);
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(fid);
|
2006-03-02 10:54:30 +00:00
|
|
|
return 0;
|
2006-01-08 09:05:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* v9fs_vfs_symlink - helper function to create symlinks
|
2023-01-13 11:49:14 +00:00
|
|
|
* @idmap: idmap of the mount
|
2006-01-08 09:05:00 +00:00
|
|
|
* @dir: directory inode containing symlink
|
|
|
|
* @dentry: dentry for symlink
|
|
|
|
* @symname: symlink data
|
|
|
|
*
|
2008-03-05 13:08:09 +00:00
|
|
|
* See Also: 9P2000.u RFC for more information
|
2006-01-08 09:05:00 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2023-01-13 11:49:14 +00:00
|
|
|
v9fs_vfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
|
2021-01-21 13:19:43 +00:00
|
|
|
struct dentry *dentry, const char *symname)
|
2006-01-08 09:05:00 +00:00
|
|
|
{
|
2014-08-20 00:17:38 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, " %lu,%pd,%s\n",
|
|
|
|
dir->i_ino, dentry, symname);
|
2006-01-08 09:05:00 +00:00
|
|
|
|
2011-07-24 22:59:07 +00:00
|
|
|
return v9fs_vfs_mkspecial(dir, dentry, P9_DMSYMLINK, symname);
|
2006-01-08 09:05:00 +00:00
|
|
|
}
|
|
|
|
|
2015-04-14 16:10:34 +00:00
|
|
|
#define U32_MAX_DIGITS 10
|
|
|
|
|
2006-01-08 09:05:00 +00:00
|
|
|
/**
|
|
|
|
* v9fs_vfs_link - create a hardlink
|
|
|
|
* @old_dentry: dentry for file to link to
|
|
|
|
* @dir: inode destination for new link
|
|
|
|
* @dentry: dentry for link
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
|
|
|
v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
|
|
|
|
struct dentry *dentry)
|
|
|
|
{
|
|
|
|
int retval;
|
2015-04-14 16:10:34 +00:00
|
|
|
char name[1 + U32_MAX_DIGITS + 2]; /* sign + number + \n + \0 */
|
2011-02-28 11:34:08 +00:00
|
|
|
struct p9_fid *oldfid;
|
2006-01-08 09:05:00 +00:00
|
|
|
|
2014-08-20 00:17:38 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, " %lu,%pd,%pd\n",
|
|
|
|
dir->i_ino, dentry, old_dentry);
|
2006-01-08 09:05:00 +00:00
|
|
|
|
2007-01-26 08:57:06 +00:00
|
|
|
oldfid = v9fs_fid_clone(old_dentry);
|
2007-10-17 19:31:07 +00:00
|
|
|
if (IS_ERR(oldfid))
|
2007-01-26 08:57:06 +00:00
|
|
|
return PTR_ERR(oldfid);
|
2006-01-08 09:05:00 +00:00
|
|
|
|
2006-03-25 11:07:26 +00:00
|
|
|
sprintf(name, "%d\n", oldfid->fid);
|
2007-07-10 22:57:28 +00:00
|
|
|
retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
|
2011-02-28 11:34:09 +00:00
|
|
|
if (!retval) {
|
2015-03-17 22:25:59 +00:00
|
|
|
v9fs_refresh_inode(oldfid, d_inode(old_dentry));
|
2011-02-28 11:34:08 +00:00
|
|
|
v9fs_invalidate_inode_attr(dir);
|
2011-02-28 11:34:09 +00:00
|
|
|
}
|
2022-06-12 04:42:32 +00:00
|
|
|
p9_fid_put(oldfid);
|
2005-09-09 20:04:19 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* v9fs_vfs_mknod - create a special file
|
2023-01-13 11:49:16 +00:00
|
|
|
* @idmap: idmap of the mount
|
2005-09-09 20:04:19 +00:00
|
|
|
* @dir: inode destination for new link
|
|
|
|
* @dentry: dentry for file
|
|
|
|
* @mode: mode for creation
|
2008-03-05 13:08:09 +00:00
|
|
|
* @rdev: device associated with special file
|
2005-09-09 20:04:19 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2023-01-13 11:49:16 +00:00
|
|
|
v9fs_vfs_mknod(struct mnt_idmap *idmap, struct inode *dir,
|
2021-01-21 13:19:43 +00:00
|
|
|
struct dentry *dentry, umode_t mode, dev_t rdev)
|
2005-09-09 20:04:19 +00:00
|
|
|
{
|
2011-07-24 22:59:07 +00:00
|
|
|
struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
|
2006-01-08 09:05:00 +00:00
|
|
|
int retval;
|
2015-04-14 16:10:34 +00:00
|
|
|
char name[2 + U32_MAX_DIGITS + 1 + U32_MAX_DIGITS + 1];
|
2011-07-24 22:59:07 +00:00
|
|
|
u32 perm;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2021-11-02 13:16:43 +00:00
|
|
|
p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %x MAJOR: %u MINOR: %u\n",
|
2014-08-20 00:17:38 +00:00
|
|
|
dir->i_ino, dentry, mode,
|
2011-11-28 18:40:46 +00:00
|
|
|
MAJOR(rdev), MINOR(rdev));
|
2005-09-09 20:04:19 +00:00
|
|
|
|
|
|
|
/* build extension */
|
|
|
|
if (S_ISBLK(mode))
|
2006-01-08 09:05:00 +00:00
|
|
|
sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
|
2005-09-09 20:04:19 +00:00
|
|
|
else if (S_ISCHR(mode))
|
2006-01-08 09:05:00 +00:00
|
|
|
sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
|
2015-04-14 16:10:34 +00:00
|
|
|
else
|
2010-05-22 17:20:30 +00:00
|
|
|
*name = 0;
|
2005-09-09 20:04:19 +00:00
|
|
|
|
2011-07-24 22:59:07 +00:00
|
|
|
perm = unixmode2p9mode(v9ses, mode);
|
|
|
|
retval = v9fs_vfs_mkspecial(dir, dentry, perm, name);
|
2005-09-09 20:04:19 +00:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2011-02-28 11:34:06 +00:00
|
|
|
int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
|
|
|
|
{
|
2011-07-25 18:06:33 +00:00
|
|
|
int umode;
|
|
|
|
dev_t rdev;
|
2011-02-28 11:34:06 +00:00
|
|
|
struct p9_wstat *st;
|
|
|
|
struct v9fs_session_info *v9ses;
|
2019-01-24 06:35:13 +00:00
|
|
|
unsigned int flags;
|
2011-02-28 11:34:06 +00:00
|
|
|
|
|
|
|
v9ses = v9fs_inode2v9ses(inode);
|
|
|
|
st = p9_client_stat(fid);
|
|
|
|
if (IS_ERR(st))
|
|
|
|
return PTR_ERR(st);
|
2011-07-25 18:06:33 +00:00
|
|
|
/*
|
|
|
|
* Don't update inode if the file type is different
|
|
|
|
*/
|
|
|
|
umode = p9mode2unixmode(v9ses, st, &rdev);
|
2021-03-02 01:37:10 +00:00
|
|
|
if (inode_wrong_type(inode, umode))
|
2011-07-25 18:06:33 +00:00
|
|
|
goto out;
|
2011-02-28 11:34:06 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't want to refresh inode->i_size,
|
|
|
|
* because we may have cached data
|
|
|
|
*/
|
2019-01-24 06:35:13 +00:00
|
|
|
flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ?
|
|
|
|
V9FS_STAT2INODE_KEEP_ISIZE : 0;
|
|
|
|
v9fs_stat2inode(st, inode, inode->i_sb, flags);
|
2011-07-25 18:06:33 +00:00
|
|
|
out:
|
2011-02-28 11:34:06 +00:00
|
|
|
p9stat_free(st);
|
|
|
|
kfree(st);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-25 12:41:54 +00:00
|
|
|
static const struct inode_operations v9fs_dir_inode_operations_dotu = {
|
|
|
|
.create = v9fs_vfs_create,
|
|
|
|
.lookup = v9fs_vfs_lookup,
|
2012-06-05 13:10:26 +00:00
|
|
|
.atomic_open = v9fs_vfs_atomic_open,
|
2010-03-25 12:41:54 +00:00
|
|
|
.symlink = v9fs_vfs_symlink,
|
2010-06-09 22:59:31 +00:00
|
|
|
.link = v9fs_vfs_link,
|
2010-03-25 12:41:54 +00:00
|
|
|
.unlink = v9fs_vfs_unlink,
|
|
|
|
.mkdir = v9fs_vfs_mkdir,
|
|
|
|
.rmdir = v9fs_vfs_rmdir,
|
2010-08-30 17:43:07 +00:00
|
|
|
.mknod = v9fs_vfs_mknod,
|
2010-03-25 12:41:54 +00:00
|
|
|
.rename = v9fs_vfs_rename,
|
|
|
|
.getattr = v9fs_vfs_getattr,
|
|
|
|
.setattr = v9fs_vfs_setattr,
|
|
|
|
};
|
|
|
|
|
2007-02-12 08:55:38 +00:00
|
|
|
static const struct inode_operations v9fs_dir_inode_operations = {
|
2005-09-09 20:04:27 +00:00
|
|
|
.create = v9fs_vfs_create,
|
|
|
|
.lookup = v9fs_vfs_lookup,
|
2012-06-05 13:10:26 +00:00
|
|
|
.atomic_open = v9fs_vfs_atomic_open,
|
2005-09-09 20:04:27 +00:00
|
|
|
.unlink = v9fs_vfs_unlink,
|
|
|
|
.mkdir = v9fs_vfs_mkdir,
|
|
|
|
.rmdir = v9fs_vfs_rmdir,
|
|
|
|
.mknod = v9fs_vfs_mknod,
|
|
|
|
.rename = v9fs_vfs_rename,
|
|
|
|
.getattr = v9fs_vfs_getattr,
|
|
|
|
.setattr = v9fs_vfs_setattr,
|
|
|
|
};
|
|
|
|
|
2007-02-12 08:55:38 +00:00
|
|
|
static const struct inode_operations v9fs_file_inode_operations = {
|
2005-09-09 20:04:19 +00:00
|
|
|
.getattr = v9fs_vfs_getattr,
|
|
|
|
.setattr = v9fs_vfs_setattr,
|
|
|
|
};
|
|
|
|
|
2007-02-12 08:55:38 +00:00
|
|
|
static const struct inode_operations v9fs_symlink_inode_operations = {
|
2015-11-17 15:20:54 +00:00
|
|
|
.get_link = v9fs_vfs_get_link,
|
2005-09-09 20:04:19 +00:00
|
|
|
.getattr = v9fs_vfs_getattr,
|
|
|
|
.setattr = v9fs_vfs_setattr,
|
|
|
|
};
|
2010-03-25 12:41:54 +00:00
|
|
|
|