Viewing file:  dir.c (25.86 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
*
*
* Copyright (C) 2000 Stelias Computing, Inc.
* Copyright (C) 2000 Red Hat, Inc.
* Copyright (C) 2000 Tacitus Systems
* Copyright (C) 2000 Peter J. Braam
*
*/
#include <stdarg.h>
#include <asm/bitops.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <linux/smp_lock.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/ext2_fs.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/sched.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/locks.h>
#include <linux/blkdev.h>
#include <linux/init.h>
#define __NO_VERSION__
#include <linux/module.h>
#include <linux/intermezzo_fs.h>
#include <linux/intermezzo_upcall.h>
#include <linux/intermezzo_psdev.h>
static inline void presto_relock_sem(struct inode *dir)
{
/* the lock from sys_mkdir / lookup_create */
down(&dir->i_sem);
/* the rest is done by the do_{create,mkdir, ...} */
}
static inline void presto_relock_other(struct inode *dir)
{
/* vfs_mkdir locks */
down(&dir->i_zombie);
lock_kernel();
}
static inline void presto_fulllock(struct inode *dir)
{
/* the lock from sys_mkdir / lookup_create */
down(&dir->i_sem);
/* vfs_mkdir locks */
down(&dir->i_zombie);
lock_kernel();
}
static inline void presto_unlock(struct inode *dir)
{
/* vfs_mkdir locks */
unlock_kernel();
up(&dir->i_zombie);
/* the lock from sys_mkdir / lookup_create */
up(&dir->i_sem);
}
/*
* these are initialized in super.c
*/
extern int presto_permission(struct inode *inode, int mask);
int presto_ilookup_uid = 0;
extern int presto_prep(struct dentry *, struct presto_cache **,
struct presto_file_set **);
static int dentry2id(struct dentry *dentry, ino_t *id, unsigned int *generation)
{
char *tmpname;
char *next;
int error = 0;
ENTRY;
if (dentry->d_name.len > EXT2_NAME_LEN) {
EXIT;
return -ENAMETOOLONG;
}
/* prefix is 7 characters: '...ino:' */
if ( dentry->d_name.len < 7 ||
memcmp(dentry->d_name.name, PRESTO_ILOOKUP_MAGIC, 7) != 0 ) {
EXIT;
return 1;
}
PRESTO_ALLOC(tmpname, char *, dentry->d_name.len - 7 + 1);
if ( !tmpname ) {
EXIT;
return -ENOMEM;
}
memcpy(tmpname, dentry->d_name.name + 7, dentry->d_name.len - 7);
*(tmpname + dentry->d_name.len) = '\0';
/* name is of the form <inode number>:<generation> */
*id = simple_strtoul(tmpname, &next, 0);
if ( *next == PRESTO_ILOOKUP_SEP ) {
*generation = simple_strtoul(next + 1, 0, 0);
CDEBUG(D_INODE, "INO to find = %s\n", tmpname);
CDEBUG(D_INODE, "Id = %lx (%lu), generation %x (%d)\n",
*id, *id, *generation, *generation);
} else
error = 1;
PRESTO_FREE(tmpname, dentry->d_name.len - 7 + 1);
EXIT;
return error;
}
static int presto_opendir_upcall(int minor, struct dentry *de,
struct dentry *root, int async)
{
int rc;
char *path, *buffer;
int pathlen;
PRESTO_ALLOC(buffer, char *, PAGE_SIZE);
if ( !buffer ) {
printk("PRESTO: out of memory!\n");
return ENOMEM;
}
path = presto_path(de, root, buffer, PAGE_SIZE);
pathlen = MYPATHLEN(buffer, path);
CDEBUG(D_INODE, "path: %*s, len %d\n", pathlen, path, pathlen);
rc = lento_opendir(minor, pathlen, path, async);
PRESTO_FREE(buffer, PAGE_SIZE);
return rc;
}
inline int presto_can_ilookup(void)
{
return (current->euid == presto_ilookup_uid ||
capable(CAP_DAC_READ_SEARCH));
}
struct dentry *presto_ilookup(struct inode *dir, struct dentry *dentry,
ino_t ino, unsigned int generation)
{
struct inode *inode;
int error;
ENTRY;
/* if we can't ilookup, forbid anything with this name to
* avoid any security issues/name clashes.
*/
if ( !presto_can_ilookup() ) {
CDEBUG(D_CACHE, "ilookup denied: euid %u, ilookup_uid %u\n",
current->euid, presto_ilookup_uid);
EXIT;
return ERR_PTR(-EPERM);
}
inode = iget(dir->i_sb, ino);
if (!inode || !inode->i_nlink || is_bad_inode(inode)) {
CDEBUG(D_PIOCTL, "fatal: invalid inode %ld (%s).\n",
ino, inode ? inode->i_nlink ? "bad inode" :
"no links" : "NULL");
error = -ENOENT;
EXIT;
goto cleanup_iput;
}
/* We need to make sure we have the right inode (by checking the
* generation) so we don't write into the wrong file (old inode was
* deleted and then a new one was created with the same number).
*/
if (inode->i_generation != generation) {
CDEBUG(D_PIOCTL, "fatal: bad generation %u (want %u)\n",
inode->i_generation, generation);
error = -ENOENT;
EXIT;
goto cleanup_iput;
}
d_instantiate(dentry, inode);
dentry->d_flags |= DCACHE_NFSD_DISCONNECTED; /* NFS hack */
EXIT;
return NULL;
cleanup_iput:
if (inode)
iput(inode);
return ERR_PTR(error);
}
struct dentry *presto_lookup(struct inode * dir, struct dentry *dentry)
{
int rc = 0;
struct dentry *de;
struct presto_cache *cache;
struct presto_file_set *fset;
int error;
int minor;
ino_t ino;
unsigned int generation;
ENTRY;
error = presto_prep(dentry->d_parent, &cache, &fset);
if ( error ) {
EXIT;
return ERR_PTR(error);
}
minor = presto_c2m(cache);
CDEBUG(D_CACHE, "dir ino: %ld, name: %*s\n",
dir->i_ino, dentry->d_name.len, dentry->d_name.name);
if ( ISLENTO(minor) )
CDEBUG(D_CACHE, "We are lento\n");
rc = dentry2id(dentry, &ino, &generation);
CDEBUG(D_CACHE, "dentry2id returned %d\n", rc);
if ( rc < 0 ) {
EXIT;
goto exit;
}
if ( rc == 0 ) {
de = presto_ilookup(dir, dentry, ino, generation);
} else {
struct inode_operations *iops = filter_c2cdiops(cache->cache_filter);
rc = 0;
/* recursively do a cache lookup in dir */
if (iops && iops->lookup)
de = iops->lookup(dir, dentry);
else {
printk("filesystem has no lookup\n");
EXIT;
goto exit;
}
}
/* XXX this needs some work to handle returning de if we get it */
filter_setup_dentry_ops(cache->cache_filter,
dentry->d_op, &presto_dentry_ops);
dentry->d_op = filter_c2udops(cache->cache_filter);
if ( IS_ERR(de) ) {
rc = PTR_ERR(de);
CDEBUG(D_CACHE, "dentry lookup error %d\n", rc);
EXIT;
goto exit;
}
/* some file systems set the methods in lookup, not in
read_inode, as a result we should set the methods here
as well as in read_inode
*/
if (dentry->d_inode) {
presto_set_ops(dentry->d_inode, cache->cache_filter);
}
EXIT;
exit:
return ERR_PTR(rc);
}
int presto_setattr(struct dentry *de, struct iattr *iattr)
{
int error;
struct presto_cache *cache;
struct presto_file_set *fset;
struct lento_vfs_context info = { 0, 0, 0 };
ENTRY;
error = presto_prep(de, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
if (!iattr->ia_valid)
CDEBUG(D_INODE, "presto_setattr: iattr is not valid\n");
CDEBUG(D_INODE, "valid %#x, mode %#o, uid %u, gid %u, size %Lu, "
"atime %lu mtime %lu ctime %lu flags %d\n",
iattr->ia_valid, iattr->ia_mode, iattr->ia_uid, iattr->ia_gid,
iattr->ia_size, iattr->ia_atime, iattr->ia_mtime,
iattr->ia_ctime, iattr->ia_attr_flags);
if ( presto_get_permit(de->d_inode) < 0 ) {
EXIT;
return -EROFS;
}
if (!ISLENTO(presto_c2m(cache)))
info.flags = LENTO_FL_KML;
info.flags |= LENTO_FL_IGNORE_TIME;
error = presto_do_setattr(fset, de, iattr, &info);
presto_put_permit(de->d_inode);
return error;
}
/*
* Now the meat: the fs operations that require journaling
*
*
* XXX: some of these need modifications for hierarchical filesets
*/
int presto_prep(struct dentry *dentry, struct presto_cache **cache,
struct presto_file_set **fset)
{
*fset = presto_fset(dentry);
if ( !*fset ) {
CDEBUG(D_INODE, "No file set for dentry at %p\n", dentry);
return -EROFS;
}
*cache = (*fset)->fset_cache;
if ( !*cache ) {
printk("PRESTO: BAD, BAD: cannot find cache\n");
return -EBADF;
}
CDEBUG(D_PIOCTL, "---> cache flags %x, fset flags %x\n",
(*cache)->cache_flags, (*fset)->fset_flags);
if( presto_is_read_only(*fset) ) {
printk("PRESTO: cannot modify read-only fileset, minor %d.\n",
presto_c2m(*cache));
return -EROFS;
}
return 0;
}
static int presto_create(struct inode * dir, struct dentry * dentry, int mode)
{
int error;
struct presto_cache *cache;
struct dentry *parent = dentry->d_parent;
struct lento_vfs_context info;
struct presto_file_set *fset;
ENTRY;
error = presto_prep(dentry->d_parent, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
presto_unlock(dir);
/* Does blocking and non-blocking behavious need to be
checked for. Without blocking (return 1), the permit
was acquired without reintegration
*/
if ( presto_get_permit(dir) < 0 ) {
EXIT;
presto_fulllock(dir);
return -EROFS;
}
presto_relock_sem(dir);
parent = dentry->d_parent;
memset(&info, 0, sizeof(info));
if (!ISLENTO(presto_c2m(cache)))
info.flags = LENTO_FL_KML;
info.flags |= LENTO_FL_IGNORE_TIME;
error = presto_do_create(fset, parent, dentry, mode, &info);
presto_relock_other(dir);
presto_put_permit(dir);
EXIT;
return error;
}
static int presto_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *new_dentry)
{
int error;
struct presto_cache *cache, *new_cache;
struct presto_file_set *fset, *new_fset;
struct dentry *parent = new_dentry->d_parent;
struct lento_vfs_context info;
ENTRY;
error = presto_prep(old_dentry, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
error = presto_prep(new_dentry->d_parent, &new_cache, &new_fset);
if ( error ) {
EXIT;
return error;
}
if (fset != new_fset) {
EXIT;
return -EXDEV;
}
presto_unlock(dir);
if ( presto_get_permit(old_dentry->d_inode) < 0 ) {
EXIT;
presto_fulllock(dir);
return -EROFS;
}
if ( presto_get_permit(dir) < 0 ) {
EXIT;
presto_fulllock(dir);
return -EROFS;
}
presto_relock_sem(dir);
parent = new_dentry->d_parent;
memset(&info, 0, sizeof(info));
if (!ISLENTO(presto_c2m(cache)))
info.flags = LENTO_FL_KML;
info.flags |= LENTO_FL_IGNORE_TIME;
error = presto_do_link(fset, old_dentry, parent,
new_dentry, &info);
presto_relock_other(dir);
presto_put_permit(dir);
presto_put_permit(old_dentry->d_inode);
return error;
}
static int presto_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{
int error;
struct presto_file_set *fset;
struct presto_cache *cache;
struct dentry *parent = dentry->d_parent;
struct lento_vfs_context info;
ENTRY;
error = presto_prep(dentry->d_parent, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
presto_unlock(dir);
if ( presto_get_permit(dir) < 0 ) {
EXIT;
presto_fulllock(dir);
return -EROFS;
}
memset(&info, 0, sizeof(info));
if (!ISLENTO(presto_c2m(cache)))
info.flags = LENTO_FL_KML;
info.flags |= LENTO_FL_IGNORE_TIME;
presto_relock_sem(dir);
parent = dentry->d_parent;
error = presto_do_mkdir(fset, parent, dentry, mode, &info);
presto_relock_other(dir);
presto_put_permit(dir);
return error;
}
static int presto_symlink(struct inode *dir, struct dentry *dentry,
const char *name)
{
int error;
struct presto_cache *cache;
struct presto_file_set *fset;
struct dentry *parent = dentry->d_parent;
struct lento_vfs_context info;
ENTRY;
error = presto_prep(dentry->d_parent, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
presto_unlock(dir);
if ( presto_get_permit(dir) < 0 ) {
EXIT;
presto_fulllock(dir);
return -EROFS;
}
presto_relock_sem(dir);
parent = dentry->d_parent;
memset(&info, 0, sizeof(info));
if (!ISLENTO(presto_c2m(cache)))
info.flags = LENTO_FL_KML;
info.flags |= LENTO_FL_IGNORE_TIME;
error = presto_do_symlink(fset, parent, dentry, name, &info);
presto_relock_other(dir);
presto_put_permit(dir);
return error;
}
int presto_unlink(struct inode *dir, struct dentry *dentry)
{
int error;
struct presto_cache *cache;
struct presto_file_set *fset;
struct dentry *parent = dentry->d_parent;
struct lento_vfs_context info;
ENTRY;
error = presto_prep(dentry->d_parent, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
presto_unlock(dir);
if ( presto_get_permit(dir) < 0 ) {
EXIT;
presto_fulllock(dir);
return -EROFS;
}
presto_relock_sem(dir);
parent = dentry->d_parent;
memset(&info, 0, sizeof(info));
if (!ISLENTO(presto_c2m(cache)))
info.flags = LENTO_FL_KML;
info.flags |= LENTO_FL_IGNORE_TIME;
error = presto_do_unlink(fset, parent, dentry, &info);
presto_relock_other(dir);
presto_put_permit(dir);
return error;
}
static int presto_rmdir(struct inode *dir, struct dentry *dentry)
{
int error;
struct presto_cache *cache;
struct presto_file_set *fset;
struct dentry *parent = dentry->d_parent;
struct lento_vfs_context info;
ENTRY;
CDEBUG(D_FILE, "prepping presto\n");
error = presto_prep(dentry->d_parent, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
CDEBUG(D_FILE, "unlocking\n");
/* We need to dget() before the dput in double_unlock, to ensure we
* still have dentry references. double_lock doesn't do dget for us.
*/
unlock_kernel();
if (d_unhashed(dentry))
d_rehash(dentry);
double_up(&dir->i_zombie, &dentry->d_inode->i_zombie);
double_up(&dir->i_sem, &dentry->d_inode->i_sem);
CDEBUG(D_FILE, "getting permit\n");
if ( presto_get_permit(parent->d_inode) < 0 ) {
EXIT;
double_down(&dir->i_sem, &dentry->d_inode->i_sem);
double_down(&dir->i_zombie, &dentry->d_inode->i_zombie);
lock_kernel();
return -EROFS;
}
CDEBUG(D_FILE, "locking\n");
double_down(&dir->i_sem, &dentry->d_inode->i_sem);
parent = dentry->d_parent;
memset(&info, 0, sizeof(info));
if (!ISLENTO(presto_c2m(cache)))
info.flags = LENTO_FL_KML;
info.flags |= LENTO_FL_IGNORE_TIME;
error = presto_do_rmdir(fset, parent, dentry, &info);
presto_put_permit(parent->d_inode);
lock_kernel();
EXIT;
return error;
}
static int presto_mknod(struct inode * dir, struct dentry * dentry, int mode, int rdev)
{
int error;
struct presto_cache *cache;
struct presto_file_set *fset;
struct dentry *parent = dentry->d_parent;
struct lento_vfs_context info;
ENTRY;
error = presto_prep(dentry->d_parent, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
presto_unlock(dir);
if ( presto_get_permit(dir) < 0 ) {
EXIT;
presto_fulllock(dir);
return -EROFS;
}
presto_relock_sem(dir);
parent = dentry->d_parent;
memset(&info, 0, sizeof(info));
if (!ISLENTO(presto_c2m(cache)))
info.flags = LENTO_FL_KML;
info.flags |= LENTO_FL_IGNORE_TIME;
error = presto_do_mknod(fset, parent, dentry, mode, rdev, &info);
presto_relock_other(dir);
presto_put_permit(dir);
EXIT;
return error;
}
inline void presto_triple_unlock(struct inode *old_dir, struct inode *new_dir,
struct dentry *old_dentry,
struct dentry *new_dentry, int triple)
{
/* rename_dir case */
if (S_ISDIR(old_dentry->d_inode->i_mode)) {
if (triple) {
triple_up(&old_dir->i_zombie,
&new_dir->i_zombie,
&new_dentry->d_inode->i_zombie);
} else {
double_up(&old_dir->i_zombie,
&new_dir->i_zombie);
}
up(&old_dir->i_sb->s_vfs_rename_sem);
} else /* this case is rename_other */
double_up(&old_dir->i_zombie, &new_dir->i_zombie);
/* done by do_rename */
unlock_kernel();
double_up(&old_dir->i_sem, &new_dir->i_sem);
}
inline void presto_triple_fulllock(struct inode *old_dir,
struct inode *new_dir,
struct dentry *old_dentry,
struct dentry *new_dentry, int triple)
{
/* done by do_rename */
double_down(&old_dir->i_sem, &new_dir->i_sem);
lock_kernel();
/* rename_dir case */
if (S_ISDIR(old_dentry->d_inode->i_mode)) {
down(&old_dir->i_sb->s_vfs_rename_sem);
if (triple) {
triple_down(&old_dir->i_zombie,
&new_dir->i_zombie,
&new_dentry->d_inode->i_zombie);
} else {
double_down(&old_dir->i_zombie,
&new_dir->i_zombie);
}
} else /* this case is rename_other */
double_down(&old_dir->i_zombie, &new_dir->i_zombie);
}
inline void presto_triple_relock_sem(struct inode *old_dir,
struct inode *new_dir,
struct dentry *old_dentry,
struct dentry *new_dentry, int triple)
{
/* done by do_rename */
double_down(&old_dir->i_sem, &new_dir->i_sem);
lock_kernel();
}
inline void presto_triple_relock_other(struct inode *old_dir,
struct inode *new_dir,
struct dentry *old_dentry,
struct dentry *new_dentry, int triple)
{
/* rename_dir case */
if (S_ISDIR(old_dentry->d_inode->i_mode)) {
down(&old_dir->i_sb->s_vfs_rename_sem);
if (triple) {
triple_down(&old_dir->i_zombie,
&new_dir->i_zombie,
&new_dentry->d_inode->i_zombie);
} else {
double_down(&old_dir->i_zombie,
&new_dir->i_zombie);
}
} else /* this case is rename_other */
double_down(&old_dir->i_zombie, &new_dir->i_zombie);
}
// XXX this can be optimized: renamtes across filesets only require
// multiple KML records, but can locally be executed normally.
int presto_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry)
{
int error;
struct presto_cache *cache, *new_cache;
struct presto_file_set *fset, *new_fset;
struct lento_vfs_context info;
struct dentry *old_parent = old_dentry->d_parent;
struct dentry *new_parent = new_dentry->d_parent;
int triple;
ENTRY;
error = presto_prep(old_dentry, &cache, &fset);
if ( error ) {
EXIT;
return error;
}
error = presto_prep(new_parent, &new_cache, &new_fset);
if ( error ) {
EXIT;
return error;
}
if ( fset != new_fset ) {
EXIT;
return -EXDEV;
}
/* We need to do dget before the dput in double_unlock, to ensure we
* still have dentry references. double_lock doesn't do dget for us.
*/
triple = (S_ISDIR(old_dentry->d_inode->i_mode) && new_dentry->d_inode)?
1:0;
presto_triple_unlock(old_dir, new_dir, old_dentry, new_dentry, triple);
if ( presto_get_permit(old_dir) < 0 ) {
EXIT;
presto_triple_fulllock(old_dir, new_dir, old_dentry, new_dentry, triple);
return -EROFS;
}
if ( presto_get_permit(new_dir) < 0 ) {
EXIT;
presto_triple_fulllock(old_dir, new_dir, old_dentry, new_dentry, triple);
return -EROFS;
}
presto_triple_relock_sem(old_dir, new_dir, old_dentry, new_dentry, triple);
memset(&info, 0, sizeof(info));
if (!ISLENTO(presto_c2m(cache)))
info.flags = LENTO_FL_KML;
info.flags |= LENTO_FL_IGNORE_TIME;
error = presto_do_rename(fset, old_parent, old_dentry, new_parent,
new_dentry, &info);
presto_triple_relock_other(old_dir, new_dir, old_dentry, new_dentry, triple);
presto_put_permit(new_dir);
presto_put_permit(old_dir);
return error;
}
/* basically this allows the ilookup processes access to all files for
* reading, while not making ilookup totally insecure. This could all
* go away if we could set the CAP_DAC_READ_SEARCH capability for the client.
*/
/* If posix acls are available, the underlying cache fs will export the
* appropriate permission function. Thus we do not worry here about ACLs
* or EAs. -SHP
*/
int presto_permission(struct inode *inode, int mask)
{
unsigned short mode = inode->i_mode;
struct presto_cache *cache;
int rc;
ENTRY;
if ( presto_can_ilookup() && !(mask & S_IWOTH)) {
CDEBUG(D_CACHE, "ilookup on %ld OK\n", inode->i_ino);
EXIT;
return 0;
}
cache = presto_get_cache(inode);
if ( cache ) {
/* we only override the file/dir permission operations */
struct inode_operations *fiops = filter_c2cfiops(cache->cache_filter);
struct inode_operations *diops = filter_c2cdiops(cache->cache_filter);
if ( S_ISREG(mode) && fiops && fiops->permission ) {
EXIT;
return fiops->permission(inode, mask);
}
if ( S_ISDIR(mode) && diops && diops->permission ) {
EXIT;
return diops->permission(inode, mask);
}
}
/* The cache filesystem doesn't have its own permission function,
* but we don't want to duplicate the VFS code here. In order
* to avoid looping from permission calling this function again,
* we temporarily override the permission operation while we call
* the VFS permission function.
*/
inode->i_op->permission = NULL;
rc = permission(inode, mask);
inode->i_op->permission = &presto_permission;
EXIT;
return rc;
}
static int presto_dir_open(struct inode *inode, struct file *file)
{
int rc = 0;
struct dentry *de = file->f_dentry;
struct file_operations *fops;
struct presto_cache *cache;
struct presto_file_set *fset;
int minor;
int error;
ENTRY;
error = presto_prep(file->f_dentry, &cache, &fset);
if ( error ) {
EXIT;
make_bad_inode(inode);
return error;
}
minor = presto_c2m(cache);
CDEBUG(D_CACHE, "minor %d, DATA_OK: %d, ino: %ld\n",
minor, presto_chk(de, PRESTO_DATA), inode->i_ino);
if ( ISLENTO(minor) )
goto cache;
if ( !presto_chk(de, PRESTO_DATA) ) {
CDEBUG(D_CACHE, "doing lento_opendir\n");
rc = presto_opendir_upcall(minor, file->f_dentry, fset->fset_mtpt, SYNCHRONOUS);
}
if ( rc ) {
printk("presto_dir_open: DATA_OK: %d, ino: %ld, error %d\n",
presto_chk(de, PRESTO_DATA), inode->i_ino, rc);
return rc ;
}
cache:
fops = filter_c2cdfops(cache->cache_filter);
if ( fops->open ) {
rc = fops->open(inode, file);
}
presto_set(de, PRESTO_DATA | PRESTO_ATTR);
CDEBUG(D_CACHE, "returns %d, data %d, attr %d\n", rc,
presto_chk(de, PRESTO_DATA), presto_chk(de, PRESTO_ATTR));
return 0;
}
struct file_operations presto_dir_fops = {
open: presto_dir_open
};
struct inode_operations presto_dir_iops = {
create: presto_create,
lookup: presto_lookup,
link: presto_link,
unlink: presto_unlink,
symlink: presto_symlink,
mkdir: presto_mkdir,
rmdir: presto_rmdir,
mknod: presto_mknod,
rename: presto_rename,
permission: presto_permission,
setattr: presto_setattr,
#ifdef CONFIG_FS_EXT_ATTR
set_ext_attr: presto_set_ext_attr,
#endif
};
|