2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2002 Red Hat, Inc. All rights reserved.
|
|
|
|
*
|
|
|
|
* This software may be freely redistributed under the terms of the
|
|
|
|
* GNU General Public License.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*
|
2008-06-06 12:46:18 +07:00
|
|
|
* Authors: David Woodhouse <dwmw2@infradead.org>
|
2005-04-17 05:20:36 +07:00
|
|
|
* David Howells <dhowells@redhat.com>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/pagemap.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-21 04:22:52 +07:00
|
|
|
#include <linux/sched.h>
|
2010-08-11 15:38:04 +07:00
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/namei.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "internal.h"
|
|
|
|
|
|
|
|
struct afs_iget_data {
|
|
|
|
struct afs_fid fid;
|
|
|
|
struct afs_volume *volume; /* volume on which resides */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* map the AFS file status to the inode member variables
|
|
|
|
*/
|
2007-04-27 05:57:07 +07:00
|
|
|
static int afs_inode_map_status(struct afs_vnode *vnode, struct key *key)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct inode *inode = AFS_VNODE_TO_I(vnode);
|
|
|
|
|
2007-04-27 05:59:35 +07:00
|
|
|
_debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
|
2005-04-17 05:20:36 +07:00
|
|
|
vnode->status.type,
|
|
|
|
vnode->status.nlink,
|
2007-04-27 06:06:22 +07:00
|
|
|
(unsigned long long) vnode->status.size,
|
2007-04-27 05:55:03 +07:00
|
|
|
vnode->status.data_version,
|
2005-04-17 05:20:36 +07:00
|
|
|
vnode->status.mode);
|
|
|
|
|
|
|
|
switch (vnode->status.type) {
|
|
|
|
case AFS_FTYPE_FILE:
|
|
|
|
inode->i_mode = S_IFREG | vnode->status.mode;
|
|
|
|
inode->i_op = &afs_file_inode_operations;
|
2007-04-27 05:57:07 +07:00
|
|
|
inode->i_fop = &afs_file_operations;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case AFS_FTYPE_DIR:
|
|
|
|
inode->i_mode = S_IFDIR | vnode->status.mode;
|
|
|
|
inode->i_op = &afs_dir_inode_operations;
|
|
|
|
inode->i_fop = &afs_dir_file_operations;
|
|
|
|
break;
|
|
|
|
case AFS_FTYPE_SYMLINK:
|
|
|
|
inode->i_mode = S_IFLNK | vnode->status.mode;
|
|
|
|
inode->i_op = &page_symlink_inode_operations;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk("kAFS: AFS vnode with undefined type\n");
|
|
|
|
return -EBADMSG;
|
|
|
|
}
|
|
|
|
|
2009-04-03 22:42:41 +07:00
|
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
|
|
if (vnode->status.size != inode->i_size)
|
|
|
|
fscache_attr_changed(vnode->cache);
|
|
|
|
#endif
|
|
|
|
|
2011-10-28 19:13:29 +07:00
|
|
|
set_nlink(inode, vnode->status.nlink);
|
2005-04-17 05:20:36 +07:00
|
|
|
inode->i_uid = vnode->status.owner;
|
|
|
|
inode->i_gid = 0;
|
|
|
|
inode->i_size = vnode->status.size;
|
|
|
|
inode->i_ctime.tv_sec = vnode->status.mtime_server;
|
|
|
|
inode->i_ctime.tv_nsec = 0;
|
|
|
|
inode->i_atime = inode->i_mtime = inode->i_ctime;
|
|
|
|
inode->i_blocks = 0;
|
2011-06-14 06:45:44 +07:00
|
|
|
inode->i_generation = vnode->fid.unique;
|
|
|
|
inode->i_version = vnode->status.data_version;
|
2005-04-17 05:20:36 +07:00
|
|
|
inode->i_mapping->a_ops = &afs_fs_aops;
|
|
|
|
|
|
|
|
/* check to see whether a symbolic link is really a mountpoint */
|
|
|
|
if (vnode->status.type == AFS_FTYPE_SYMLINK) {
|
2007-04-27 05:57:07 +07:00
|
|
|
afs_mntpt_check_symlink(vnode, key);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-04-27 05:55:03 +07:00
|
|
|
if (test_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
inode->i_mode = S_IFDIR | vnode->status.mode;
|
|
|
|
inode->i_op = &afs_mntpt_inode_operations;
|
|
|
|
inode->i_fop = &afs_mntpt_file_operations;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2007-04-27 05:49:28 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* iget5() comparator
|
|
|
|
*/
|
|
|
|
static int afs_iget5_test(struct inode *inode, void *opaque)
|
|
|
|
{
|
|
|
|
struct afs_iget_data *data = opaque;
|
|
|
|
|
|
|
|
return inode->i_ino == data->fid.vnode &&
|
2011-06-14 06:45:44 +07:00
|
|
|
inode->i_generation == data->fid.unique;
|
2007-04-27 05:49:28 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-08-11 15:38:04 +07:00
|
|
|
/*
|
|
|
|
* iget5() comparator for inode created by autocell operations
|
|
|
|
*
|
|
|
|
* These pseudo inodes don't match anything.
|
|
|
|
*/
|
|
|
|
static int afs_iget5_autocell_test(struct inode *inode, void *opaque)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* iget5() inode initialiser
|
|
|
|
*/
|
|
|
|
static int afs_iget5_set(struct inode *inode, void *opaque)
|
|
|
|
{
|
|
|
|
struct afs_iget_data *data = opaque;
|
|
|
|
struct afs_vnode *vnode = AFS_FS_I(inode);
|
|
|
|
|
|
|
|
inode->i_ino = data->fid.vnode;
|
2011-06-14 06:45:44 +07:00
|
|
|
inode->i_generation = data->fid.unique;
|
2005-04-17 05:20:36 +07:00
|
|
|
vnode->fid = data->fid;
|
|
|
|
vnode->volume = data->volume;
|
|
|
|
|
|
|
|
return 0;
|
2007-04-27 05:49:28 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-08-11 15:38:04 +07:00
|
|
|
/*
|
|
|
|
* inode retrieval for autocell
|
|
|
|
*/
|
|
|
|
struct inode *afs_iget_autocell(struct inode *dir, const char *dev_name,
|
|
|
|
int namesz, struct key *key)
|
|
|
|
{
|
|
|
|
struct afs_iget_data data;
|
|
|
|
struct afs_super_info *as;
|
|
|
|
struct afs_vnode *vnode;
|
|
|
|
struct super_block *sb;
|
|
|
|
struct inode *inode;
|
|
|
|
static atomic_t afs_autocell_ino;
|
|
|
|
|
|
|
|
_enter("{%x:%u},%*.*s,",
|
|
|
|
AFS_FS_I(dir)->fid.vid, AFS_FS_I(dir)->fid.vnode,
|
|
|
|
namesz, namesz, dev_name ?: "");
|
|
|
|
|
|
|
|
sb = dir->i_sb;
|
|
|
|
as = sb->s_fs_info;
|
|
|
|
data.volume = as->volume;
|
|
|
|
data.fid.vid = as->volume->vid;
|
|
|
|
data.fid.unique = 0;
|
|
|
|
data.fid.vnode = 0;
|
|
|
|
|
|
|
|
inode = iget5_locked(sb, atomic_inc_return(&afs_autocell_ino),
|
|
|
|
afs_iget5_autocell_test, afs_iget5_set,
|
|
|
|
&data);
|
|
|
|
if (!inode) {
|
|
|
|
_leave(" = -ENOMEM");
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
_debug("GOT INODE %p { ino=%lu, vl=%x, vn=%x, u=%x }",
|
|
|
|
inode, inode->i_ino, data.fid.vid, data.fid.vnode,
|
|
|
|
data.fid.unique);
|
|
|
|
|
|
|
|
vnode = AFS_FS_I(inode);
|
|
|
|
|
|
|
|
/* there shouldn't be an existing inode */
|
|
|
|
BUG_ON(!(inode->i_state & I_NEW));
|
|
|
|
|
|
|
|
inode->i_size = 0;
|
|
|
|
inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
|
|
|
|
inode->i_op = &afs_autocell_inode_operations;
|
2011-10-28 19:13:29 +07:00
|
|
|
set_nlink(inode, 2);
|
2010-08-11 15:38:04 +07:00
|
|
|
inode->i_uid = 0;
|
|
|
|
inode->i_gid = 0;
|
|
|
|
inode->i_ctime.tv_sec = get_seconds();
|
|
|
|
inode->i_ctime.tv_nsec = 0;
|
|
|
|
inode->i_atime = inode->i_mtime = inode->i_ctime;
|
|
|
|
inode->i_blocks = 0;
|
|
|
|
inode->i_version = 0;
|
|
|
|
inode->i_generation = 0;
|
|
|
|
|
|
|
|
set_bit(AFS_VNODE_PSEUDODIR, &vnode->flags);
|
2011-01-15 02:04:05 +07:00
|
|
|
set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags);
|
|
|
|
inode->i_flags |= S_AUTOMOUNT | S_NOATIME;
|
2010-08-11 15:38:04 +07:00
|
|
|
unlock_new_inode(inode);
|
|
|
|
_leave(" = %p", inode);
|
|
|
|
return inode;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* inode retrieval
|
|
|
|
*/
|
2007-04-27 05:59:35 +07:00
|
|
|
struct inode *afs_iget(struct super_block *sb, struct key *key,
|
|
|
|
struct afs_fid *fid, struct afs_file_status *status,
|
|
|
|
struct afs_callback *cb)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct afs_iget_data data = { .fid = *fid };
|
|
|
|
struct afs_super_info *as;
|
|
|
|
struct afs_vnode *vnode;
|
|
|
|
struct inode *inode;
|
|
|
|
int ret;
|
|
|
|
|
2007-05-09 16:33:45 +07:00
|
|
|
_enter(",{%x:%u.%u},,", fid->vid, fid->vnode, fid->unique);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
as = sb->s_fs_info;
|
|
|
|
data.volume = as->volume;
|
|
|
|
|
|
|
|
inode = iget5_locked(sb, fid->vnode, afs_iget5_test, afs_iget5_set,
|
|
|
|
&data);
|
|
|
|
if (!inode) {
|
|
|
|
_leave(" = -ENOMEM");
|
2007-04-27 05:55:03 +07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-04-27 05:55:03 +07:00
|
|
|
_debug("GOT INODE %p { vl=%x vn=%x, u=%x }",
|
|
|
|
inode, fid->vid, fid->vnode, fid->unique);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
vnode = AFS_FS_I(inode);
|
|
|
|
|
|
|
|
/* deal with an existing inode */
|
|
|
|
if (!(inode->i_state & I_NEW)) {
|
2007-04-27 05:55:03 +07:00
|
|
|
_leave(" = %p", inode);
|
|
|
|
return inode;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-04-27 05:59:35 +07:00
|
|
|
if (!status) {
|
|
|
|
/* it's a remotely extant inode */
|
|
|
|
set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
|
|
|
|
ret = afs_vnode_fetch_status(vnode, NULL, key);
|
|
|
|
if (ret < 0)
|
|
|
|
goto bad_inode;
|
|
|
|
} else {
|
|
|
|
/* it's an inode we just created */
|
|
|
|
memcpy(&vnode->status, status, sizeof(vnode->status));
|
|
|
|
|
|
|
|
if (!cb) {
|
|
|
|
/* it's a symlink we just created (the fileserver
|
|
|
|
* didn't give us a callback) */
|
|
|
|
vnode->cb_version = 0;
|
|
|
|
vnode->cb_expiry = 0;
|
|
|
|
vnode->cb_type = 0;
|
|
|
|
vnode->cb_expires = get_seconds();
|
|
|
|
} else {
|
|
|
|
vnode->cb_version = cb->version;
|
|
|
|
vnode->cb_expiry = cb->expiry;
|
|
|
|
vnode->cb_type = cb->type;
|
|
|
|
vnode->cb_expires = vnode->cb_expiry + get_seconds();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-03 22:42:41 +07:00
|
|
|
/* set up caching before mapping the status, as map-status reads the
|
|
|
|
* first page of symlinks to see if they're really mountpoints */
|
|
|
|
inode->i_size = vnode->status.size;
|
|
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
|
|
vnode->cache = fscache_acquire_cookie(vnode->volume->cache,
|
|
|
|
&afs_vnode_cache_index_def,
|
|
|
|
vnode);
|
|
|
|
#endif
|
|
|
|
|
2007-04-27 05:57:07 +07:00
|
|
|
ret = afs_inode_map_status(vnode, key);
|
2007-04-27 05:55:03 +07:00
|
|
|
if (ret < 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto bad_inode;
|
|
|
|
|
|
|
|
/* success */
|
2007-04-27 05:59:35 +07:00
|
|
|
clear_bit(AFS_VNODE_UNSET, &vnode->flags);
|
2007-04-27 05:55:03 +07:00
|
|
|
inode->i_flags |= S_NOATIME;
|
2005-04-17 05:20:36 +07:00
|
|
|
unlock_new_inode(inode);
|
2007-04-27 05:55:03 +07:00
|
|
|
_leave(" = %p [CB { v=%u t=%u }]", inode, vnode->cb_version, vnode->cb_type);
|
|
|
|
return inode;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* failure */
|
2007-04-27 05:49:28 +07:00
|
|
|
bad_inode:
|
2009-04-03 22:42:41 +07:00
|
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
|
|
fscache_relinquish_cookie(vnode->cache, 0);
|
|
|
|
vnode->cache = NULL;
|
|
|
|
#endif
|
2008-02-07 15:15:28 +07:00
|
|
|
iget_failed(inode);
|
2005-04-17 05:20:36 +07:00
|
|
|
_leave(" = %d [bad]", ret);
|
2007-04-27 05:55:03 +07:00
|
|
|
return ERR_PTR(ret);
|
2007-04-27 05:49:28 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-05-09 16:33:45 +07:00
|
|
|
/*
|
|
|
|
* mark the data attached to an inode as obsolete due to a write on the server
|
|
|
|
* - might also want to ditch all the outstanding writes and dirty pages
|
|
|
|
*/
|
|
|
|
void afs_zap_data(struct afs_vnode *vnode)
|
|
|
|
{
|
2007-05-11 12:22:20 +07:00
|
|
|
_enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
|
2007-05-09 16:33:45 +07:00
|
|
|
|
|
|
|
/* nuke all the non-dirty pages that aren't locked, mapped or being
|
2007-05-11 12:22:20 +07:00
|
|
|
* written back in a regular file and completely discard the pages in a
|
|
|
|
* directory or symlink */
|
|
|
|
if (S_ISREG(vnode->vfs_inode.i_mode))
|
|
|
|
invalidate_remote_inode(&vnode->vfs_inode);
|
|
|
|
else
|
|
|
|
invalidate_inode_pages2(vnode->vfs_inode.i_mapping);
|
2007-05-09 16:33:45 +07:00
|
|
|
}
|
|
|
|
|
2007-04-27 05:59:35 +07:00
|
|
|
/*
|
|
|
|
* validate a vnode/inode
|
|
|
|
* - there are several things we need to check
|
|
|
|
* - parent dir data changes (rm, rmdir, rename, mkdir, create, link,
|
|
|
|
* symlink)
|
|
|
|
* - parent dir metadata changed (security changes)
|
|
|
|
* - dentry data changed (write, truncate)
|
|
|
|
* - dentry metadata changed (security changes)
|
|
|
|
*/
|
|
|
|
int afs_validate(struct afs_vnode *vnode, struct key *key)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
_enter("{v={%x:%u} fl=%lx},%x",
|
|
|
|
vnode->fid.vid, vnode->fid.vnode, vnode->flags,
|
|
|
|
key_serial(key));
|
|
|
|
|
|
|
|
if (vnode->cb_promised &&
|
|
|
|
!test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags) &&
|
|
|
|
!test_bit(AFS_VNODE_MODIFIED, &vnode->flags) &&
|
|
|
|
!test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) {
|
|
|
|
if (vnode->cb_expires < get_seconds() + 10) {
|
|
|
|
_debug("callback expired");
|
|
|
|
set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
|
|
|
|
} else {
|
|
|
|
goto valid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
|
|
|
|
goto valid;
|
|
|
|
|
|
|
|
mutex_lock(&vnode->validate_lock);
|
|
|
|
|
|
|
|
/* if the promise has expired, we need to check the server again to get
|
|
|
|
* a new promise - note that if the (parent) directory's metadata was
|
|
|
|
* changed then the security may be different and we may no longer have
|
|
|
|
* access */
|
|
|
|
if (!vnode->cb_promised ||
|
|
|
|
test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
|
|
|
|
_debug("not promised");
|
|
|
|
ret = afs_vnode_fetch_status(vnode, NULL, key);
|
|
|
|
if (ret < 0)
|
|
|
|
goto error_unlock;
|
|
|
|
_debug("new promise [fl=%lx]", vnode->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
|
|
|
|
_debug("file already deleted");
|
|
|
|
ret = -ESTALE;
|
|
|
|
goto error_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if the vnode's data version number changed then its contents are
|
|
|
|
* different */
|
2007-05-09 16:33:45 +07:00
|
|
|
if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags))
|
|
|
|
afs_zap_data(vnode);
|
2007-04-27 05:59:35 +07:00
|
|
|
|
|
|
|
clear_bit(AFS_VNODE_MODIFIED, &vnode->flags);
|
|
|
|
mutex_unlock(&vnode->validate_lock);
|
|
|
|
valid:
|
|
|
|
_leave(" = 0");
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_unlock:
|
|
|
|
mutex_unlock(&vnode->validate_lock);
|
|
|
|
_leave(" = %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* read the attributes of an inode
|
|
|
|
*/
|
2007-05-09 16:33:45 +07:00
|
|
|
int afs_getattr(struct vfsmount *mnt, struct dentry *dentry,
|
2005-04-17 05:20:36 +07:00
|
|
|
struct kstat *stat)
|
|
|
|
{
|
|
|
|
struct inode *inode;
|
|
|
|
|
|
|
|
inode = dentry->d_inode;
|
|
|
|
|
2011-06-14 06:45:44 +07:00
|
|
|
_enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
generic_fillattr(inode, stat);
|
|
|
|
return 0;
|
2007-04-27 05:49:28 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-08-11 15:38:04 +07:00
|
|
|
/*
|
|
|
|
* discard an AFS inode
|
|
|
|
*/
|
|
|
|
int afs_drop_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
_enter("");
|
|
|
|
|
|
|
|
if (test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(inode)->flags))
|
|
|
|
return generic_delete_inode(inode);
|
|
|
|
else
|
|
|
|
return generic_drop_inode(inode);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* clear an AFS inode
|
|
|
|
*/
|
2010-06-08 01:34:48 +07:00
|
|
|
void afs_evict_inode(struct inode *inode)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-04-27 05:57:07 +07:00
|
|
|
struct afs_permits *permits;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct afs_vnode *vnode;
|
|
|
|
|
|
|
|
vnode = AFS_FS_I(inode);
|
|
|
|
|
2007-05-09 16:33:45 +07:00
|
|
|
_enter("{%x:%u.%d} v=%u x=%u t=%u }",
|
2007-04-27 05:59:35 +07:00
|
|
|
vnode->fid.vid,
|
2005-04-17 05:20:36 +07:00
|
|
|
vnode->fid.vnode,
|
2007-04-27 05:59:35 +07:00
|
|
|
vnode->fid.unique,
|
2005-04-17 05:20:36 +07:00
|
|
|
vnode->cb_version,
|
|
|
|
vnode->cb_expiry,
|
2007-04-27 05:55:03 +07:00
|
|
|
vnode->cb_type);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-04-27 05:55:03 +07:00
|
|
|
_debug("CLEAR INODE %p", inode);
|
|
|
|
|
|
|
|
ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode);
|
|
|
|
|
2010-06-08 01:34:48 +07:00
|
|
|
truncate_inode_pages(&inode->i_data, 0);
|
|
|
|
end_writeback(inode);
|
|
|
|
|
2007-04-27 05:55:03 +07:00
|
|
|
afs_give_up_callback(vnode);
|
|
|
|
|
|
|
|
if (vnode->server) {
|
|
|
|
spin_lock(&vnode->server->fs_lock);
|
|
|
|
rb_erase(&vnode->server_rb, &vnode->server->fs_vnodes);
|
|
|
|
spin_unlock(&vnode->server->fs_lock);
|
|
|
|
afs_put_server(vnode->server);
|
|
|
|
vnode->server = NULL;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
AFS: implement basic file write support
Implement support for writing to regular AFS files, including:
(1) write
(2) truncate
(3) fsync, fdatasync
(4) chmod, chown, chgrp, utime.
AFS writeback attempts to batch writes into as chunks as large as it can manage
up to the point that it writes back 65535 pages in one chunk or it meets a
locked page.
Furthermore, if a page has been written to using a particular key, then should
another write to that page use some other key, the first write will be flushed
before the second is allowed to take place. If the first write fails due to a
security error, then the page will be scrapped and reread before the second
write takes place.
If a page is dirty and the callback on it is broken by the server, then the
dirty data is not discarded (same behaviour as NFS).
Shared-writable mappings are not supported by this patch.
[akpm@linux-foundation.org: fix a bunch of warnings]
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-09 16:33:46 +07:00
|
|
|
ASSERT(list_empty(&vnode->writebacks));
|
2007-04-27 05:55:03 +07:00
|
|
|
ASSERT(!vnode->cb_promised);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-03 22:42:41 +07:00
|
|
|
#ifdef CONFIG_AFS_FSCACHE
|
|
|
|
fscache_relinquish_cookie(vnode->cache, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
vnode->cache = NULL;
|
|
|
|
#endif
|
|
|
|
|
2007-04-27 05:57:07 +07:00
|
|
|
mutex_lock(&vnode->permits_lock);
|
|
|
|
permits = vnode->permits;
|
|
|
|
rcu_assign_pointer(vnode->permits, NULL);
|
|
|
|
mutex_unlock(&vnode->permits_lock);
|
|
|
|
if (permits)
|
|
|
|
call_rcu(&permits->rcu, afs_zap_permits);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
_leave("");
|
2007-04-27 05:49:28 +07:00
|
|
|
}
|
AFS: implement basic file write support
Implement support for writing to regular AFS files, including:
(1) write
(2) truncate
(3) fsync, fdatasync
(4) chmod, chown, chgrp, utime.
AFS writeback attempts to batch writes into as chunks as large as it can manage
up to the point that it writes back 65535 pages in one chunk or it meets a
locked page.
Furthermore, if a page has been written to using a particular key, then should
another write to that page use some other key, the first write will be flushed
before the second is allowed to take place. If the first write fails due to a
security error, then the page will be scrapped and reread before the second
write takes place.
If a page is dirty and the callback on it is broken by the server, then the
dirty data is not discarded (same behaviour as NFS).
Shared-writable mappings are not supported by this patch.
[akpm@linux-foundation.org: fix a bunch of warnings]
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-09 16:33:46 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* set the attributes of an inode
|
|
|
|
*/
|
|
|
|
int afs_setattr(struct dentry *dentry, struct iattr *attr)
|
|
|
|
{
|
|
|
|
struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
|
|
|
|
struct key *key;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
_enter("{%x:%u},{n=%s},%x",
|
|
|
|
vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name,
|
|
|
|
attr->ia_valid);
|
|
|
|
|
|
|
|
if (!(attr->ia_valid & (ATTR_SIZE | ATTR_MODE | ATTR_UID | ATTR_GID |
|
|
|
|
ATTR_MTIME))) {
|
|
|
|
_leave(" = 0 [unsupported]");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* flush any dirty data outstanding on a regular file */
|
|
|
|
if (S_ISREG(vnode->vfs_inode.i_mode)) {
|
|
|
|
filemap_write_and_wait(vnode->vfs_inode.i_mapping);
|
|
|
|
afs_writeback_all(vnode);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (attr->ia_valid & ATTR_FILE) {
|
|
|
|
key = attr->ia_file->private_data;
|
|
|
|
} else {
|
|
|
|
key = afs_request_key(vnode->volume->cell);
|
|
|
|
if (IS_ERR(key)) {
|
|
|
|
ret = PTR_ERR(key);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = afs_vnode_setattr(vnode, key, attr);
|
|
|
|
if (!(attr->ia_valid & ATTR_FILE))
|
|
|
|
key_put(key);
|
|
|
|
|
|
|
|
error:
|
|
|
|
_leave(" = %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|