Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 | /*
* linux/fs/nfs/inode.c
*
* Copyright (C) 1992 Rick Sladkey
*
* nfs inode and superblock handling functions
*
* Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
* experimental NFS changes. Modularisation taken straight from SYS5 fs.
*/
#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#else
#define MOD_INC_USE_COUNT
#define MOD_DEC_USE_COUNT
#endif
#include <asm/system.h>
#include <asm/segment.h>
#include <linux/sched.h>
#include <linux/nfs_fs.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/locks.h>
extern int close_fp(struct file *filp);
static int nfs_notify_change(struct inode *, struct iattr *);
static void nfs_put_inode(struct inode *);
static void nfs_put_super(struct super_block *);
static void nfs_statfs(struct super_block *, struct statfs *, int bufsiz);
static struct super_operations nfs_sops = {
NULL, /* read inode */
nfs_notify_change, /* notify change */
NULL, /* write inode */
nfs_put_inode, /* put inode */
nfs_put_super, /* put superblock */
NULL, /* write superblock */
nfs_statfs, /* stat filesystem */
NULL
};
static void nfs_put_inode(struct inode * inode)
{
clear_inode(inode);
}
void nfs_put_super(struct super_block *sb)
{
close_fp(sb->u.nfs_sb.s_server.file);
lock_super(sb);
sb->s_dev = 0;
unlock_super(sb);
MOD_DEC_USE_COUNT;
}
/*
* The way this works is that the mount process passes a structure
* in the data argument which contains an open socket to the NFS
* server and the root file handle obtained from the server's mount
* daemon. We stash theses away in the private superblock fields.
* Later we can add other mount parameters like caching values.
*/
struct super_block *nfs_read_super(struct super_block *sb, void *raw_data,
int silent)
{
struct nfs_mount_data *data = (struct nfs_mount_data *) raw_data;
struct nfs_server *server;
unsigned int fd;
struct file *filp;
dev_t dev = sb->s_dev;
MOD_INC_USE_COUNT;
if (!data) {
printk("nfs_read_super: missing data argument\n");
sb->s_dev = 0;
MOD_DEC_USE_COUNT;
return NULL;
}
fd = data->fd;
if (data->version != NFS_MOUNT_VERSION) {
printk("nfs warning: mount version %s than kernel\n",
data->version < NFS_MOUNT_VERSION ? "older" : "newer");
}
if (fd >= NR_OPEN || !(filp = current->files->fd[fd])) {
printk("nfs_read_super: invalid file descriptor\n");
sb->s_dev = 0;
MOD_DEC_USE_COUNT;
return NULL;
}
if (!S_ISSOCK(filp->f_inode->i_mode)) {
printk("nfs_read_super: not a socket\n");
sb->s_dev = 0;
MOD_DEC_USE_COUNT;
return NULL;
}
filp->f_count++;
lock_super(sb);
sb->s_blocksize = 1024; /* XXX */
sb->s_blocksize_bits = 10;
sb->s_magic = NFS_SUPER_MAGIC;
sb->s_dev = dev;
sb->s_op = &nfs_sops;
server = &sb->u.nfs_sb.s_server;
server->file = filp;
server->lock = 0;
server->wait = NULL;
server->flags = data->flags;
server->rsize = data->rsize;
if (server->rsize <= 0)
server->rsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
else if (server->rsize >= NFS_MAX_FILE_IO_BUFFER_SIZE)
server->rsize = NFS_MAX_FILE_IO_BUFFER_SIZE;
server->wsize = data->wsize;
if (server->wsize <= 0)
server->wsize = NFS_DEF_FILE_IO_BUFFER_SIZE;
else if (server->wsize >= NFS_MAX_FILE_IO_BUFFER_SIZE)
server->wsize = NFS_MAX_FILE_IO_BUFFER_SIZE;
server->timeo = data->timeo*HZ/10;
server->retrans = data->retrans;
server->acregmin = data->acregmin*HZ;
server->acregmax = data->acregmax*HZ;
server->acdirmin = data->acdirmin*HZ;
server->acdirmax = data->acdirmax*HZ;
strcpy(server->hostname, data->hostname);
sb->u.nfs_sb.s_root = data->root;
unlock_super(sb);
if (!(sb->s_mounted = nfs_fhget(sb, &data->root, NULL))) {
sb->s_dev = 0;
printk("nfs_read_super: get root inode failed\n");
MOD_DEC_USE_COUNT;
return NULL;
}
return sb;
}
void nfs_statfs(struct super_block *sb, struct statfs *buf, int bufsiz)
{
int error;
struct nfs_fsinfo res;
struct statfs tmp;
error = nfs_proc_statfs(&sb->u.nfs_sb.s_server, &sb->u.nfs_sb.s_root,
&res);
if (error) {
printk("nfs_statfs: statfs error = %d\n", -error);
res.bsize = res.blocks = res.bfree = res.bavail = 0;
}
tmp.f_type = NFS_SUPER_MAGIC;
tmp.f_bsize = res.bsize;
tmp.f_blocks = res.blocks;
tmp.f_bfree = res.bfree;
tmp.f_bavail = res.bavail;
tmp.f_files = 0;
tmp.f_ffree = 0;
tmp.f_namelen = NAME_MAX;
memcpy_tofs(buf, &tmp, bufsiz);
}
/*
* This is our own version of iget that looks up inodes by file handle
* instead of inode number. We use this technique instead of using
* the vfs read_inode function because there is no way to pass the
* file handle or current attributes into the read_inode function.
* We just have to be careful not to subvert iget's special handling
* of mount points.
*/
struct inode *nfs_fhget(struct super_block *sb, struct nfs_fh *fhandle,
struct nfs_fattr *fattr)
{
struct nfs_fattr newfattr;
int error;
struct inode *inode;
if (!sb) {
printk("nfs_fhget: super block is NULL\n");
return NULL;
}
if (!fattr) {
error = nfs_proc_getattr(&sb->u.nfs_sb.s_server, fhandle,
&newfattr);
if (error) {
printk("nfs_fhget: getattr error = %d\n", -error);
return NULL;
}
fattr = &newfattr;
}
if (!(inode = iget(sb, fattr->fileid))) {
printk("nfs_fhget: iget failed\n");
return NULL;
}
if (inode->i_dev == sb->s_dev) {
if (inode->i_ino != fattr->fileid) {
printk("nfs_fhget: unexpected inode from iget\n");
return inode;
}
*NFS_FH(inode) = *fhandle;
nfs_refresh_inode(inode, fattr);
}
return inode;
}
int nfs_notify_change(struct inode *inode, struct iattr *attr)
{
struct nfs_sattr sattr;
struct nfs_fattr fattr;
int error;
if (attr->ia_valid & ATTR_MODE)
sattr.mode = attr->ia_mode;
else
sattr.mode = (unsigned) -1;
if (attr->ia_valid & ATTR_UID)
sattr.uid = attr->ia_uid;
else
sattr.uid = (unsigned) -1;
if (attr->ia_valid & ATTR_GID)
sattr.gid = attr->ia_gid;
else
sattr.gid = (unsigned) -1;
if (attr->ia_valid & ATTR_SIZE)
sattr.size = S_ISREG(inode->i_mode) ? attr->ia_size : -1;
else
sattr.size = (unsigned) -1;
if (attr->ia_valid & ATTR_MTIME) {
sattr.mtime.seconds = attr->ia_mtime;
sattr.mtime.useconds = 0;
} else
sattr.mtime.seconds = sattr.mtime.useconds = (unsigned) -1;
if (attr->ia_valid & ATTR_ATIME) {
sattr.atime.seconds = attr->ia_atime;
sattr.atime.useconds = 0;
} else
sattr.atime.seconds = sattr.atime.useconds = (unsigned) -1;
error = nfs_proc_setattr(NFS_SERVER(inode), NFS_FH(inode),
&sattr, &fattr);
if (!error)
nfs_refresh_inode(inode, &fattr);
inode->i_dirt = 0;
return error;
}
#ifdef MODULE
/* Every kernel module contains stuff like this. */
char kernel_version[] = UTS_RELEASE;
static struct file_system_type nfs_fs_type = {
nfs_read_super, "nfs", 0, NULL
};
int init_module(void)
{
register_filesystem(&nfs_fs_type);
return 0;
}
void cleanup_module(void)
{
unregister_filesystem(&nfs_fs_type);
}
#endif
|