/*
* New rpc_call implementation
*/
int rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
{
struct rpc_task my_task, *task = &my_task;
sigset_t oldset;
int status;
/* If this client is slain all further I/O fails */
if (clnt->cl_dead)
return -EIO;
if (flags & RPC_TASK_ASYNC) {
printk("rpc_call_sync: Illegal flag combination for synchronous task\n");
flags &= ~RPC_TASK_ASYNC;
}
rpc_clnt_sigmask(clnt, &oldset);
/* Create/initialize a new RPC task */
rpc_init_task(task, clnt, NULL, flags);
rpc_call_setup(task, msg, 0);
/* Set up the call info struct and execute the task */
if (task->tk_status == 0)
status = rpc_execute(task);
else {
status = task->tk_status;
rpc_release_task(task);
}
rpc_clnt_sigunmask(clnt, &oldset);
return status;
}
/*
* Create a new task for the specified client. We have to
* clean up after an allocation failure, as the client may
* have specified "oneshot".
*/
struct rpc_task *
rpc_new_task(struct rpc_clnt *clnt, rpc_action callback, int flags)
{
struct rpc_task *task;
task = (struct rpc_task *) rpc_allocate(flags, sizeof(*task));
if (!task)
goto cleanup;
rpc_init_task(task, clnt, callback, flags);
dprintk("RPC: %4d allocated task\n", task->tk_pid);
task->tk_flags |= RPC_TASK_DYNAMIC;
out:
return task;
cleanup:
/* Check whether to release the client */
if (clnt) {
printk("rpc_new_task: failed, users=%d, oneshot=%d\n",
clnt->cl_users, clnt->cl_oneshot);
clnt->cl_users++; /* pretend we were used ... */
rpc_release_client(clnt);
}
goto out;
}
/*
* New rpc_call implementation
*/
int
rpc_do_call(struct rpc_clnt *clnt, u32 proc, void *argp, void *resp,
int flags, rpc_action func, void *data)
{
struct rpc_task my_task, *task = &my_task;
sigset_t oldset;
int async, status;
/* If this client is slain all further I/O fails */
if (clnt->cl_dead)
return -EIO;
rpc_clnt_sigmask(clnt, &oldset);
/* Create/initialize a new RPC task */
if ((async = (flags & RPC_TASK_ASYNC)) != 0) {
if (!func)
func = rpc_default_callback;
status = -ENOMEM;
if (!(task = rpc_new_task(clnt, func, flags)))
goto out;
task->tk_calldata = data;
} else {
rpc_init_task(task, clnt, NULL, flags);
}
/* Bind the user cred, set up the call info struct and
* execute the task */
if (rpcauth_lookupcred(task) != NULL) {
rpc_call_setup(task, proc, argp, resp, 0);
rpc_execute(task);
} else
async = 0;
status = 0;
if (!async) {
status = task->tk_status;
rpc_release_task(task);
}
out:
rpc_clnt_sigunmask(clnt, &oldset);
return status;
}
static int
nfs3_proc_lookup(struct inode *dir, struct qstr *name,
struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
struct nfs_fattr dir_attr;
struct nfs3_diropargs arg = {
.fh = NFS_FH(dir),
.name = name->name,
.len = name->len
};
struct nfs3_diropres res = {
.dir_attr = &dir_attr,
.fh = fhandle,
.fattr = fattr
};
int status;
dprintk("NFS call lookup %s\n", name->name);
dir_attr.valid = 0;
fattr->valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFS3PROC_LOOKUP, &arg, &res, 0);
if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR))
status = rpc_call(NFS_CLIENT(dir), NFS3PROC_GETATTR,
fhandle, fattr, 0);
dprintk("NFS reply lookup: %d\n", status);
if (status >= 0)
status = nfs_refresh_inode(dir, &dir_attr);
return status;
}
static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
{
struct nfs_fattr fattr;
struct nfs3_accessargs arg = {
.fh = NFS_FH(inode),
};
struct nfs3_accessres res = {
.fattr = &fattr,
};
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS],
.rpc_argp = &arg,
.rpc_resp = &res,
.rpc_cred = entry->cred
};
int mode = entry->mask;
int status;
dprintk("NFS call access\n");
fattr.valid = 0;
if (mode & MAY_READ)
arg.access |= NFS3_ACCESS_READ;
if (S_ISDIR(inode->i_mode)) {
if (mode & MAY_WRITE)
arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE;
if (mode & MAY_EXEC)
arg.access |= NFS3_ACCESS_LOOKUP;
} else {
if (mode & MAY_WRITE)
arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND;
if (mode & MAY_EXEC)
arg.access |= NFS3_ACCESS_EXECUTE;
}
status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
nfs_refresh_inode(inode, &fattr);
if (status == 0) {
entry->mask = 0;
if (res.access & NFS3_ACCESS_READ)
entry->mask |= MAY_READ;
if (res.access & (NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE))
entry->mask |= MAY_WRITE;
if (res.access & (NFS3_ACCESS_LOOKUP|NFS3_ACCESS_EXECUTE))
entry->mask |= MAY_EXEC;
}
dprintk("NFS reply access: %d\n", status);
return status;
}
static int nfs3_proc_readlink(struct inode *inode, struct page *page,
unsigned int pgbase, unsigned int pglen)
{
struct nfs_fattr fattr;
struct nfs3_readlinkargs args = {
.fh = NFS_FH(inode),
.pgbase = pgbase,
.pglen = pglen,
.pages = &page
};
int status;
dprintk("NFS call readlink\n");
fattr.valid = 0;
status = rpc_call(NFS_CLIENT(inode), NFS3PROC_READLINK,
&args, &fattr, 0);
nfs_refresh_inode(inode, &fattr);
dprintk("NFS reply readlink: %d\n", status);
return status;
}
static int nfs3_proc_read(struct nfs_read_data *rdata)
{
int flags = rdata->flags;
struct inode * inode = rdata->inode;
struct nfs_fattr * fattr = rdata->res.fattr;
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_READ],
.rpc_argp = &rdata->args,
.rpc_resp = &rdata->res,
.rpc_cred = rdata->cred,
};
int status;
dprintk("NFS call read %d @ %Ld\n", rdata->args.count,
(long long) rdata->args.offset);
fattr->valid = 0;
status = rpc_call_sync(NFS_CLIENT(inode), &msg, flags);
if (status >= 0)
nfs_refresh_inode(inode, fattr);
dprintk("NFS reply read: %d\n", status);
return status;
}
static int nfs3_proc_write(struct nfs_write_data *wdata)
{
int rpcflags = wdata->flags;
struct inode * inode = wdata->inode;
struct nfs_fattr * fattr = wdata->res.fattr;
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_WRITE],
.rpc_argp = &wdata->args,
.rpc_resp = &wdata->res,
.rpc_cred = wdata->cred,
};
int status;
dprintk("NFS call write %d @ %Ld\n", wdata->args.count,
(long long) wdata->args.offset);
fattr->valid = 0;
status = rpc_call_sync(NFS_CLIENT(inode), &msg, rpcflags);
if (status >= 0)
nfs_refresh_inode(inode, fattr);
dprintk("NFS reply write: %d\n", status);
return status < 0? status : wdata->res.count;
}
static int nfs3_proc_commit(struct nfs_write_data *cdata)
{
struct inode * inode = cdata->inode;
struct nfs_fattr * fattr = cdata->res.fattr;
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT],
.rpc_argp = &cdata->args,
.rpc_resp = &cdata->res,
.rpc_cred = cdata->cred,
};
int status;
dprintk("NFS call commit %d @ %Ld\n", cdata->args.count,
(long long) cdata->args.offset);
fattr->valid = 0;
status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
if (status >= 0)
nfs_refresh_inode(inode, fattr);
dprintk("NFS reply commit: %d\n", status);
return status;
}
/*
* Create a regular file.
* For now, we don't implement O_EXCL.
*/
static int
nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
int flags)
{
struct nfs_fh fhandle;
struct nfs_fattr fattr;
struct nfs_fattr dir_attr;
struct nfs3_createargs arg = {
.fh = NFS_FH(dir),
.name = dentry->d_name.name,
.len = dentry->d_name.len,
.sattr = sattr,
};
struct nfs3_diropres res = {
.dir_attr = &dir_attr,
.fh = &fhandle,
.fattr = &fattr
};
int status;
dprintk("NFS call create %s\n", dentry->d_name.name);
arg.createmode = NFS3_CREATE_UNCHECKED;
if (flags & O_EXCL) {
arg.createmode = NFS3_CREATE_EXCLUSIVE;
arg.verifier[0] = jiffies;
arg.verifier[1] = current->pid;
}
again:
dir_attr.valid = 0;
fattr.valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFS3PROC_CREATE, &arg, &res, 0);
nfs_refresh_inode(dir, &dir_attr);
/* If the server doesn't support the exclusive creation semantics,
* try again with simple 'guarded' mode. */
if (status == NFSERR_NOTSUPP) {
switch (arg.createmode) {
case NFS3_CREATE_EXCLUSIVE:
arg.createmode = NFS3_CREATE_GUARDED;
break;
case NFS3_CREATE_GUARDED:
arg.createmode = NFS3_CREATE_UNCHECKED;
break;
case NFS3_CREATE_UNCHECKED:
goto out;
}
goto again;
}
if (status == 0)
status = nfs_instantiate(dentry, &fhandle, &fattr);
if (status != 0)
goto out;
/* When we created the file with exclusive semantics, make
* sure we set the attributes afterwards. */
if (arg.createmode == NFS3_CREATE_EXCLUSIVE) {
dprintk("NFS call setattr (post-create)\n");
if (!(sattr->ia_valid & ATTR_ATIME_SET))
sattr->ia_valid |= ATTR_ATIME;
if (!(sattr->ia_valid & ATTR_MTIME_SET))
sattr->ia_valid |= ATTR_MTIME;
/* Note: we could use a guarded setattr here, but I'm
* not sure this buys us anything (and I'd have
* to revamp the NFSv3 XDR code) */
status = nfs3_proc_setattr(dentry, &fattr, sattr);
nfs_refresh_inode(dentry->d_inode, &fattr);
dprintk("NFS reply setattr (post-create): %d\n", status);
}
out:
dprintk("NFS reply create: %d\n", status);
return status;
}
static int
nfs3_proc_remove(struct inode *dir, struct qstr *name)
{
struct nfs_fattr dir_attr;
struct nfs3_diropargs arg = {
.fh = NFS_FH(dir),
.name = name->name,
.len = name->len
};
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
.rpc_argp = &arg,
.rpc_resp = &dir_attr,
};
int status;
dprintk("NFS call remove %s\n", name->name);
dir_attr.valid = 0;
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
nfs_refresh_inode(dir, &dir_attr);
dprintk("NFS reply remove: %d\n", status);
return status;
}
static int
nfs3_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir, struct qstr *name)
{
struct unlinkxdr {
struct nfs3_diropargs arg;
struct nfs_fattr res;
} *ptr;
ptr = (struct unlinkxdr *)kmalloc(sizeof(*ptr), GFP_KERNEL);
if (!ptr)
return -ENOMEM;
ptr->arg.fh = NFS_FH(dir->d_inode);
ptr->arg.name = name->name;
ptr->arg.len = name->len;
ptr->res.valid = 0;
msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
msg->rpc_argp = &ptr->arg;
msg->rpc_resp = &ptr->res;
return 0;
}
static int
nfs3_proc_unlink_done(struct dentry *dir, struct rpc_task *task)
{
struct rpc_message *msg = &task->tk_msg;
struct nfs_fattr *dir_attr;
if (nfs3_async_handle_jukebox(task))
return 1;
if (msg->rpc_argp) {
dir_attr = (struct nfs_fattr*)msg->rpc_resp;
nfs_refresh_inode(dir->d_inode, dir_attr);
kfree(msg->rpc_argp);
}
return 0;
}
static int
nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
struct inode *new_dir, struct qstr *new_name)
{
struct nfs_fattr old_dir_attr, new_dir_attr;
struct nfs3_renameargs arg = {
.fromfh = NFS_FH(old_dir),
.fromname = old_name->name,
.fromlen = old_name->len,
.tofh = NFS_FH(new_dir),
.toname = new_name->name,
.tolen = new_name->len
};
struct nfs3_renameres res = {
.fromattr = &old_dir_attr,
.toattr = &new_dir_attr
};
int status;
dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
old_dir_attr.valid = 0;
new_dir_attr.valid = 0;
status = rpc_call(NFS_CLIENT(old_dir), NFS3PROC_RENAME, &arg, &res, 0);
nfs_refresh_inode(old_dir, &old_dir_attr);
nfs_refresh_inode(new_dir, &new_dir_attr);
dprintk("NFS reply rename: %d\n", status);
return status;
}
static int
nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
{
struct nfs_fattr dir_attr, fattr;
struct nfs3_linkargs arg = {
.fromfh = NFS_FH(inode),
.tofh = NFS_FH(dir),
.toname = name->name,
.tolen = name->len
};
struct nfs3_linkres res = {
.dir_attr = &dir_attr,
.fattr = &fattr
};
int status;
dprintk("NFS call link %s\n", name->name);
dir_attr.valid = 0;
fattr.valid = 0;
status = rpc_call(NFS_CLIENT(inode), NFS3PROC_LINK, &arg, &res, 0);
nfs_refresh_inode(dir, &dir_attr);
nfs_refresh_inode(inode, &fattr);
dprintk("NFS reply link: %d\n", status);
return status;
}
static int
nfs3_proc_symlink(struct inode *dir, struct qstr *name, struct qstr *path,
struct iattr *sattr, struct nfs_fh *fhandle,
struct nfs_fattr *fattr)
{
struct nfs_fattr dir_attr;
struct nfs3_symlinkargs arg = {
.fromfh = NFS_FH(dir),
.fromname = name->name,
.fromlen = name->len,
.topath = path->name,
.tolen = path->len,
.sattr = sattr
};
struct nfs3_diropres res = {
.dir_attr = &dir_attr,
.fh = fhandle,
.fattr = fattr
};
int status;
if (path->len > NFS3_MAXPATHLEN)
return -ENAMETOOLONG;
dprintk("NFS call symlink %s -> %s\n", name->name, path->name);
dir_attr.valid = 0;
fattr->valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFS3PROC_SYMLINK, &arg, &res, 0);
nfs_refresh_inode(dir, &dir_attr);
dprintk("NFS reply symlink: %d\n", status);
return status;
}
static int
nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
{
struct nfs_fh fhandle;
struct nfs_fattr fattr, dir_attr;
struct nfs3_mkdirargs arg = {
.fh = NFS_FH(dir),
.name = dentry->d_name.name,
.len = dentry->d_name.len,
.sattr = sattr
};
struct nfs3_diropres res = {
.dir_attr = &dir_attr,
.fh = &fhandle,
.fattr = &fattr
};
int status;
dprintk("NFS call mkdir %s\n", dentry->d_name.name);
dir_attr.valid = 0;
fattr.valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFS3PROC_MKDIR, &arg, &res, 0);
nfs_refresh_inode(dir, &dir_attr);
if (status == 0)
status = nfs_instantiate(dentry, &fhandle, &fattr);
dprintk("NFS reply mkdir: %d\n", status);
return status;
}
static int
nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
{
struct nfs_fattr dir_attr;
struct nfs3_diropargs arg = {
.fh = NFS_FH(dir),
.name = name->name,
.len = name->len
};
int status;
dprintk("NFS call rmdir %s\n", name->name);
dir_attr.valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFS3PROC_RMDIR, &arg, &dir_attr, 0);
nfs_refresh_inode(dir, &dir_attr);
dprintk("NFS reply rmdir: %d\n", status);
return status;
}
/*
* The READDIR implementation is somewhat hackish - we pass the user buffer
* to the encode function, which installs it in the receive iovec.
* The decode function itself doesn't perform any decoding, it just makes
* sure the reply is syntactically correct.
*
* Also note that this implementation handles both plain readdir and
* readdirplus.
*/
static int
nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
u64 cookie, struct page *page, unsigned int count, int plus)
{
struct inode *dir = dentry->d_inode;
struct nfs_fattr dir_attr;
u32 *verf = NFS_COOKIEVERF(dir);
struct nfs3_readdirargs arg = {
.fh = NFS_FH(dir),
.cookie = cookie,
.verf = {verf[0], verf[1]},
.plus = plus,
.count = count,
.pages = &page
};
struct nfs3_readdirres res = {
.dir_attr = &dir_attr,
.verf = verf,
.plus = plus
};
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_READDIR],
.rpc_argp = &arg,
.rpc_resp = &res,
.rpc_cred = cred
};
int status;
lock_kernel();
if (plus)
msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
dprintk("NFS call readdir%s %d\n",
plus? "plus" : "", (unsigned int) cookie);
dir_attr.valid = 0;
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
nfs_refresh_inode(dir, &dir_attr);
dprintk("NFS reply readdir: %d\n", status);
unlock_kernel();
return status;
}
static int
nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
dev_t rdev)
{
struct nfs_fh fh;
struct nfs_fattr fattr, dir_attr;
struct nfs3_mknodargs arg = {
.fh = NFS_FH(dir),
.name = dentry->d_name.name,
.len = dentry->d_name.len,
.sattr = sattr,
.rdev = rdev
};
struct nfs3_diropres res = {
.dir_attr = &dir_attr,
.fh = &fh,
.fattr = &fattr
};
int status;
switch (sattr->ia_mode & S_IFMT) {
case S_IFBLK: arg.type = NF3BLK; break;
case S_IFCHR: arg.type = NF3CHR; break;
case S_IFIFO: arg.type = NF3FIFO; break;
case S_IFSOCK: arg.type = NF3SOCK; break;
default: return -EINVAL;
}
dprintk("NFS call mknod %s %u:%u\n", dentry->d_name.name,
MAJOR(rdev), MINOR(rdev));
dir_attr.valid = 0;
fattr.valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFS3PROC_MKNOD, &arg, &res, 0);
nfs_refresh_inode(dir, &dir_attr);
if (status == 0)
status = nfs_instantiate(dentry, &fh, &fattr);
dprintk("NFS reply mknod: %d\n", status);
return status;
}
static int
nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
struct nfs_fsstat *stat)
{
int status;
dprintk("NFS call fsstat\n");
stat->fattr->valid = 0;
status = rpc_call(server->client, NFS3PROC_FSSTAT, fhandle, stat, 0);
dprintk("NFS reply statfs: %d\n", status);
return status;
}
static int
nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
struct nfs_fsinfo *info)
{
int status;
dprintk("NFS call fsinfo\n");
info->fattr->valid = 0;
status = rpc_call(server->client_sys, NFS3PROC_FSINFO, fhandle, info, 0);
dprintk("NFS reply fsinfo: %d\n", status);
return status;
}
static int
nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
struct nfs_pathconf *info)
{
int status;
dprintk("NFS call pathconf\n");
info->fattr->valid = 0;
status = rpc_call(server->client, NFS3PROC_PATHCONF, fhandle, info, 0);
dprintk("NFS reply pathconf: %d\n", status);
return status;
}
extern u32 *nfs3_decode_dirent(u32 *, struct nfs_entry *, int);
static void
nfs3_read_done(struct rpc_task *task)
{
struct nfs_write_data *data = (struct nfs_write_data *) task->tk_calldata;
if (nfs3_async_handle_jukebox(task))
return;
/* Call back common NFS readpage processing */
if (task->tk_status >= 0)
nfs_refresh_inode(data->inode, &data->fattr);
nfs_readpage_result(task);
}
static void
nfs3_proc_read_setup(struct nfs_read_data *data)
{
struct rpc_task *task = &data->task;
struct inode *inode = data->inode;
int flags;
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_READ],
.rpc_argp = &data->args,
.rpc_resp = &data->res,
.rpc_cred = data->cred,
};
/* N.B. Do we need to test? Never called for swapfile inode */
flags = RPC_TASK_ASYNC | (IS_SWAPFILE(inode)? NFS_RPC_SWAPFLAGS : 0);
/* Finalize the task. */
rpc_init_task(task, NFS_CLIENT(inode), nfs3_read_done, flags);
rpc_call_setup(task, &msg, 0);
}
static void
nfs3_write_done(struct rpc_task *task)
{
struct nfs_write_data *data;
if (nfs3_async_handle_jukebox(task))
return;
data = (struct nfs_write_data *)task->tk_calldata;
if (task->tk_status >= 0)
nfs_refresh_inode(data->inode, data->res.fattr);
nfs_writeback_done(task);
}
static void
nfs3_proc_write_setup(struct nfs_write_data *data, int how)
{
struct rpc_task *task = &data->task;
struct inode *inode = data->inode;
int stable;
int flags;
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_WRITE],
.rpc_argp = &data->args,
.rpc_resp = &data->res,
.rpc_cred = data->cred,
};
if (how & FLUSH_STABLE) {
if (!NFS_I(inode)->ncommit)
stable = NFS_FILE_SYNC;
else
stable = NFS_DATA_SYNC;
} else
stable = NFS_UNSTABLE;
data->args.stable = stable;
/* Set the initial flags for the task. */
flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
/* Finalize the task. */
rpc_init_task(task, NFS_CLIENT(inode), nfs3_write_done, flags);
rpc_call_setup(task, &msg, 0);
}
static void
nfs3_commit_done(struct rpc_task *task)
{
struct nfs_write_data *data;
if (nfs3_async_handle_jukebox(task))
return;
data = (struct nfs_write_data *)task->tk_calldata;
if (task->tk_status >= 0)
nfs_refresh_inode(data->inode, data->res.fattr);
nfs_commit_done(task);
}
static void
nfs3_proc_commit_setup(struct nfs_write_data *data, int how)
{
struct rpc_task *task = &data->task;
struct inode *inode = data->inode;
int flags;
struct rpc_message msg = {
.rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT],
.rpc_argp = &data->args,
.rpc_resp = &data->res,
.rpc_cred = data->cred,
};
/* Set the initial flags for the task. */
flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
/* Finalize the task. */
rpc_init_task(task, NFS_CLIENT(inode), nfs3_commit_done, flags);
rpc_call_setup(task, &msg, 0);
}
static int
nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
{
return nlmclnt_proc(filp->f_dentry->d_inode, cmd, fl);
}
struct nfs_rpc_ops nfs_v3_clientops = {
.version = 3, /* protocol version */
.dentry_ops = &nfs_dentry_operations,
.dir_inode_ops = &nfs_dir_inode_operations,
.getroot = nfs3_proc_get_root,
.getattr = nfs3_proc_getattr,
.setattr = nfs3_proc_setattr,
.lookup = nfs3_proc_lookup,
.access = nfs3_proc_access,
.readlink = nfs3_proc_readlink,
.read = nfs3_proc_read,
.write = nfs3_proc_write,
.commit = nfs3_proc_commit,
.create = nfs3_proc_create,
.remove = nfs3_proc_remove,
.unlink_setup = nfs3_proc_unlink_setup,
.unlink_done = nfs3_proc_unlink_done,
.rename = nfs3_proc_rename,
.link = nfs3_proc_link,
.symlink = nfs3_proc_symlink,
.mkdir = nfs3_proc_mkdir,
.rmdir = nfs3_proc_rmdir,
.readdir = nfs3_proc_readdir,
.mknod = nfs3_proc_mknod,
.statfs = nfs3_proc_statfs,
.fsinfo = nfs3_proc_fsinfo,
.pathconf = nfs3_proc_pathconf,
.decode_dirent = nfs3_decode_dirent,
.read_setup = nfs3_proc_read_setup,
.write_setup = nfs3_proc_write_setup,
.commit_setup = nfs3_proc_commit_setup,
.file_open = nfs_open,
.file_release = nfs_release,
.lock = nfs3_proc_lock,
};
static int
nfs_proc_lookup(struct inode *dir, struct qstr *name,
struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
struct nfs_diropargs arg = {
.fh = NFS_FH(dir),
.name = name->name,
.len = name->len
};
struct nfs_diropok res = {
.fh = fhandle,
.fattr = fattr
};
int status;
dprintk("NFS call lookup %s\n", name->name);
fattr->valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFSPROC_LOOKUP, &arg, &res, 0);
dprintk("NFS reply lookup: %d\n", status);
return status;
}
static int
nfs_proc_readlink(struct inode *inode, struct page *page)
{
struct nfs_readlinkargs args = {
.fh = NFS_FH(inode),
.count = PAGE_CACHE_SIZE,
.pages = &page
};
int status;
dprintk("NFS call readlink\n");
status = rpc_call(NFS_CLIENT(inode), NFSPROC_READLINK, &args, NULL, 0);
dprintk("NFS reply readlink: %d\n", status);
return status;
}
static int
nfs_proc_read(struct nfs_read_data *rdata, struct file *filp)
{
int flags = rdata->flags;
struct inode * inode = rdata->inode;
struct nfs_fattr * fattr = rdata->res.fattr;
struct rpc_message msg = {
.rpc_proc = &nfs_procedures[NFSPROC_READ],
.rpc_argp = &rdata->args,
.rpc_resp = &rdata->res,
};
int status;
dprintk("NFS call read %d @ %Ld\n", rdata->args.count,
(long long) rdata->args.offset);
fattr->valid = 0;
msg.rpc_cred = nfs_cred(inode, filp);
status = rpc_call_sync(NFS_CLIENT(inode), &msg, flags);
if (status >= 0) {
nfs_refresh_inode(inode, fattr);
/* Emulate the eof flag, which isn't normally needed in NFSv2
* as it is guaranteed to always return the file attributes
*/
if (rdata->args.offset + rdata->args.count >= fattr->size)
rdata->res.eof = 1;
}
dprintk("NFS reply read: %d\n", status);
return status;
}
static int
nfs_proc_write(struct nfs_write_data *wdata, struct file *filp)
{
int flags = wdata->flags;
struct inode * inode = wdata->inode;
struct nfs_fattr * fattr = wdata->res.fattr;
struct rpc_message msg = {
.rpc_proc = &nfs_procedures[NFSPROC_WRITE],
.rpc_argp = &wdata->args,
.rpc_resp = &wdata->res,
};
int status;
dprintk("NFS call write %d @ %Ld\n", wdata->args.count,
(long long) wdata->args.offset);
fattr->valid = 0;
msg.rpc_cred = nfs_cred(inode, filp);
status = rpc_call_sync(NFS_CLIENT(inode), &msg, flags);
if (status >= 0) {
nfs_refresh_inode(inode, fattr);
wdata->res.count = wdata->args.count;
wdata->verf.committed = NFS_FILE_SYNC;
}
dprintk("NFS reply write: %d\n", status);
return status < 0? status : wdata->res.count;
}
static struct inode *
nfs_proc_create(struct inode *dir, struct qstr *name, struct iattr *sattr,
int flags)
{
struct nfs_fh fhandle;
struct nfs_fattr fattr;
struct nfs_createargs arg = {
.fh = NFS_FH(dir),
.name = name->name,
.len = name->len,
.sattr = sattr
};
struct nfs_diropok res = {
.fh = &fhandle,
.fattr = &fattr
};
int status;
fattr.valid = 0;
dprintk("NFS call create %s\n", name->name);
status = rpc_call(NFS_CLIENT(dir), NFSPROC_CREATE, &arg, &res, 0);
dprintk("NFS reply create: %d\n", status);
if (status == 0) {
struct inode *inode;
inode = nfs_fhget(dir->i_sb, &fhandle, &fattr);
if (inode)
return inode;
status = -ENOMEM;
}
return ERR_PTR(status);
}
/*
* In NFSv2, mknod is grafted onto the create call.
*/
static int
nfs_proc_mknod(struct inode *dir, struct qstr *name, struct iattr *sattr,
dev_t rdev, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
struct nfs_createargs arg = {
.fh = NFS_FH(dir),
.name = name->name,
.len = name->len,
.sattr = sattr
};
struct nfs_diropok res = {
.fh = fhandle,
.fattr = fattr
};
int status, mode;
dprintk("NFS call mknod %s\n", name->name);
mode = sattr->ia_mode;
if (S_ISFIFO(mode)) {
sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
sattr->ia_valid &= ~ATTR_SIZE;
} else if (S_ISCHR(mode) || S_ISBLK(mode)) {
sattr->ia_valid |= ATTR_SIZE;
sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
}
fattr->valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFSPROC_CREATE, &arg, &res, 0);
if (status == -EINVAL && S_ISFIFO(mode)) {
sattr->ia_mode = mode;
fattr->valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFSPROC_CREATE, &arg, &res, 0);
}
dprintk("NFS reply mknod: %d\n", status);
return status;
}
static int
nfs_proc_remove(struct inode *dir, struct qstr *name)
{
struct nfs_diropargs arg = {
.fh = NFS_FH(dir),
.name = name->name,
.len = name->len
};
struct rpc_message msg = {
.rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
.rpc_argp = &arg,
.rpc_resp = NULL,
.rpc_cred = NULL
};
int status;
dprintk("NFS call remove %s\n", name->name);
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
dprintk("NFS reply remove: %d\n", status);
return status;
}
static int
nfs_proc_unlink_setup(struct rpc_message *msg, struct dentry *dir, struct qstr *name)
{
struct nfs_diropargs *arg;
arg = (struct nfs_diropargs *)kmalloc(sizeof(*arg), GFP_KERNEL);
if (!arg)
return -ENOMEM;
arg->fh = NFS_FH(dir->d_inode);
arg->name = name->name;
arg->len = name->len;
msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
msg->rpc_argp = arg;
return 0;
}
static int
nfs_proc_unlink_done(struct dentry *dir, struct rpc_task *task)
{
struct rpc_message *msg = &task->tk_msg;
if (msg->rpc_argp)
kfree(msg->rpc_argp);
return 0;
}
static int
nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
struct inode *new_dir, struct qstr *new_name)
{
struct nfs_renameargs arg = {
.fromfh = NFS_FH(old_dir),
.fromname = old_name->name,
.fromlen = old_name->len,
.tofh = NFS_FH(new_dir),
.toname = new_name->name,
.tolen = new_name->len
};
int status;
dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
status = rpc_call(NFS_CLIENT(old_dir), NFSPROC_RENAME, &arg, NULL, 0);
dprintk("NFS reply rename: %d\n", status);
return status;
}
static int
nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
{
struct nfs_linkargs arg = {
.fromfh = NFS_FH(inode),
.tofh = NFS_FH(dir),
.toname = name->name,
.tolen = name->len
};
int status;
dprintk("NFS call link %s\n", name->name);
status = rpc_call(NFS_CLIENT(inode), NFSPROC_LINK, &arg, NULL, 0);
dprintk("NFS reply link: %d\n", status);
return status;
}
static int
nfs_proc_symlink(struct inode *dir, struct qstr *name, struct qstr *path,
struct iattr *sattr, struct nfs_fh *fhandle,
struct nfs_fattr *fattr)
{
struct nfs_symlinkargs arg = {
.fromfh = NFS_FH(dir),
.fromname = name->name,
.fromlen = name->len,
.topath = path->name,
.tolen = path->len,
.sattr = sattr
};
int status;
dprintk("NFS call symlink %s -> %s\n", name->name, path->name);
fattr->valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFSPROC_SYMLINK, &arg, NULL, 0);
dprintk("NFS reply symlink: %d\n", status);
return status;
}
static int
nfs_proc_mkdir(struct inode *dir, struct qstr *name, struct iattr *sattr,
struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
struct nfs_createargs arg = {
.fh = NFS_FH(dir),
.name = name->name,
.len = name->len,
.sattr = sattr
};
struct nfs_diropok res = {
.fh = fhandle,
.fattr = fattr
};
int status;
dprintk("NFS call mkdir %s\n", name->name);
fattr->valid = 0;
status = rpc_call(NFS_CLIENT(dir), NFSPROC_MKDIR, &arg, &res, 0);
dprintk("NFS reply mkdir: %d\n", status);
return status;
}
static int
nfs_proc_rmdir(struct inode *dir, struct qstr *name)
{
struct nfs_diropargs arg = {
.fh = NFS_FH(dir),
.name = name->name,
.len = name->len
};
int status;
dprintk("NFS call rmdir %s\n", name->name);
status = rpc_call(NFS_CLIENT(dir), NFSPROC_RMDIR, &arg, NULL, 0);
dprintk("NFS reply rmdir: %d\n", status);
return status;
}
/*
* The READDIR implementation is somewhat hackish - we pass a temporary
* buffer to the encode function, which installs it in the receive
* the receive iovec. The decode function just parses the reply to make
* sure it is syntactically correct; the entries itself are decoded
* from nfs_readdir by calling the decode_entry function directly.
*/
static int
nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
u64 cookie, struct page *page, unsigned int count, int plus)
{
struct inode *dir = dentry->d_inode;
struct nfs_readdirargs arg = {
.fh = NFS_FH(dir),
.cookie = cookie,
.count = count,
.pages = &page
};
struct rpc_message msg = {
.rpc_proc = &nfs_procedures[NFSPROC_READDIR],
.rpc_argp = &arg,
.rpc_resp = NULL,
.rpc_cred = cred
};
int status;
lock_kernel();
dprintk("NFS call readdir %d\n", (unsigned int)cookie);
status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
dprintk("NFS reply readdir: %d\n", status);
unlock_kernel();
return status;
}
static int
nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
struct nfs_fsstat *stat)
{
struct nfs2_fsstat fsinfo;
int status;
dprintk("NFS call statfs\n");
stat->fattr->valid = 0;
status = rpc_call(server->client, NFSPROC_STATFS, fhandle, &fsinfo, 0);
dprintk("NFS reply statfs: %d\n", status);
if (status)
goto out;
stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize;
stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
stat->tfiles = 0;
stat->ffiles = 0;
stat->afiles = 0;
out:
return status;
}
static int
nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
struct nfs_fsinfo *info)
{
struct nfs2_fsstat fsinfo;
int status;
dprintk("NFS call fsinfo\n");
info->fattr->valid = 0;
status = rpc_call(server->client, NFSPROC_STATFS, fhandle, &fsinfo, 0);
dprintk("NFS reply fsinfo: %d\n", status);
if (status)
goto out;
info->rtmax = NFS_MAXDATA;
info->rtpref = fsinfo.tsize;
info->rtmult = fsinfo.bsize;
info->wtmax = NFS_MAXDATA;
info->wtpref = fsinfo.tsize;
info->wtmult = fsinfo.bsize;
info->dtpref = fsinfo.tsize;
info->maxfilesize = 0x7FFFFFFF;
info->lease_time = 0;
out:
return status;
}
static int
nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
struct nfs_pathconf *info)
{
info->max_link = 0;
info->max_namelen = NFS2_MAXNAMLEN;
return 0;
}
extern u32 * nfs_decode_dirent(u32 *, struct nfs_entry *, int);
static void
nfs_read_done(struct rpc_task *task)
{
struct nfs_read_data *data = (struct nfs_read_data *) task->tk_calldata;
if (task->tk_status >= 0) {
nfs_refresh_inode(data->inode, data->res.fattr);
/* Emulate the eof flag, which isn't normally needed in NFSv2
* as it is guaranteed to always return the file attributes
*/
if (data->args.offset + data->args.count >= data->res.fattr->size)
data->res.eof = 1;
}
nfs_readpage_result(task);
}
static void
nfs_proc_read_setup(struct nfs_read_data *data)
{
struct rpc_task *task = &data->task;
struct inode *inode = data->inode;
int flags;
struct rpc_message msg = {
.rpc_proc = &nfs_procedures[NFSPROC_READ],
.rpc_argp = &data->args,
.rpc_resp = &data->res,
.rpc_cred = data->cred,
};
/* N.B. Do we need to test? Never called for swapfile inode */
flags = RPC_TASK_ASYNC | (IS_SWAPFILE(inode)? NFS_RPC_SWAPFLAGS : 0);
/* Finalize the task. */
rpc_init_task(task, NFS_CLIENT(inode), nfs_read_done, flags);
rpc_call_setup(task, &msg, 0);
}
static void
nfs_write_done(struct rpc_task *task)
{
struct nfs_write_data *data = (struct nfs_write_data *) task->tk_calldata;
if (task->tk_status >= 0)
nfs_refresh_inode(data->inode, data->res.fattr);
nfs_writeback_done(task);
}
static void
nfs_proc_write_setup(struct nfs_write_data *data, int how)
{
struct rpc_task *task = &data->task;
struct inode *inode = data->inode;
int flags;
struct rpc_message msg = {
.rpc_proc = &nfs_procedures[NFSPROC_WRITE],
.rpc_argp = &data->args,
.rpc_resp = &data->res,
.rpc_cred = data->cred,
};
/* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
data->args.stable = NFS_FILE_SYNC;
/* Set the initial flags for the task. */
flags = (how & FLUSH_SYNC) ? 0 : RPC_TASK_ASYNC;
/* Finalize the task. */
rpc_init_task(task, NFS_CLIENT(inode), nfs_write_done, flags);
rpc_call_setup(task, &msg, 0);
}
static void
nfs_proc_commit_setup(struct nfs_write_data *data, int how)
{
BUG();
}
/*
* Set up the nfspage struct with the right credentials
*/
static void
nfs_request_init(struct nfs_page *req, struct file *filp)
{
req->wb_cred = get_rpccred(nfs_cred(req->wb_inode, filp));
}
static int
nfs_request_compatible(struct nfs_page *req, struct file *filp, struct page *page)
{
if (req->wb_file != filp)
return 0;
if (req->wb_page != page)
return 0;
if (req->wb_cred != nfs_file_cred(filp))
return 0;
return 1;
}
static int
nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
{
return nlmclnt_proc(filp->f_dentry->d_inode, cmd, fl);
}
struct nfs_rpc_ops nfs_v2_clientops = {
.version = 2, /* protocol version */
.dentry_ops = &nfs_dentry_operations,
.dir_inode_ops = &nfs_dir_inode_operations,
.getroot = nfs_proc_get_root,
.getattr = nfs_proc_getattr,
.setattr = nfs_proc_setattr,
.lookup = nfs_proc_lookup,
.access = NULL, /* access */
.readlink = nfs_proc_readlink,
.read = nfs_proc_read,
.write = nfs_proc_write,
.commit = NULL, /* commit */
.create = nfs_proc_create,
.remove = nfs_proc_remove,
.unlink_setup = nfs_proc_unlink_setup,
.unlink_done = nfs_proc_unlink_done,
.rename = nfs_proc_rename,
.link = nfs_proc_link,
.symlink = nfs_proc_symlink,
.mkdir = nfs_proc_mkdir,
.rmdir = nfs_proc_rmdir,
.readdir = nfs_proc_readdir,
.mknod = nfs_proc_mknod,
.statfs = nfs_proc_statfs,
.fsinfo = nfs_proc_fsinfo,
.pathconf = nfs_proc_pathconf,
.decode_dirent = nfs_decode_dirent,
.read_setup = nfs_proc_read_setup,
.write_setup = nfs_proc_write_setup,
.commit_setup = nfs_proc_commit_setup,
.file_open = nfs_open,
.file_release = nfs_release,
.request_init = nfs_request_init,
.request_compatible = nfs_request_compatible,
.lock = nfs_proc_lock,
};
static int
rbio_submit(struct ploop_io * io, struct nfs_read_data * nreq,
const struct rpc_call_ops * cb)
{
struct nfs_open_context *ctx = nfs_file_open_context(io->files.file);
struct inode *inode = io->files.inode;
struct rpc_task *task;
struct rpc_message msg = {
.rpc_cred = ctx->cred,
};
struct rpc_task_setup task_setup_data = {
.rpc_client = NFS_CLIENT(inode),
.rpc_message = &msg,
.callback_ops = cb,
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)
.workqueue = nfsio_workqueue,
#endif
.flags = RPC_TASK_ASYNC,
};
nreq->res.count = nreq->args.count;
nreq->header->cred = msg.rpc_cred;
nreq->args.context = ctx;
task_setup_data.task = &nreq->task;
task_setup_data.callback_data = nreq;
msg.rpc_argp = &nreq->args;
msg.rpc_resp = &nreq->res;
NFS_PROTO(inode)->read_setup(nreq, &msg);
task = rpc_run_task(&task_setup_data);
if (unlikely(IS_ERR(task)))
return PTR_ERR(task);
rpc_put_task(task);
return 0;
}
#else
static int
rbio_submit(struct ploop_io * io, struct nfs_read_data * nreq,
const struct rpc_call_ops * cb)
{
struct nfs_open_context *ctx = nfs_file_open_context(io->files.file);
struct inode *inode = io->files.inode;
nreq->res.count = nreq->args.count;
nreq->cred = ctx->cred;
nreq->args.context = ctx;
rpc_init_task(&nreq->task, NFS_CLIENT(inode), RPC_TASK_ASYNC, cb, nreq);
NFS_PROTO(inode)->read_setup(nreq);
nreq->task.tk_cookie = (unsigned long) inode;
lock_kernel();
rpc_execute(&nreq->task);
unlock_kernel();
return 0;
}
#endif
static void
nfsio_submit_read(struct ploop_io *io, struct ploop_request * preq,
struct bio_list *sbl, iblock_t iblk, unsigned int size)
{
struct inode *inode = io->files.inode;
size_t rsize = NFS_SERVER(inode)->rsize;
struct nfs_read_data *nreq = NULL;
loff_t pos;
unsigned int prev_end;
struct bio * b;
ploop_prepare_io_request(preq);
pos = sbl->head->bi_sector;
pos = ((loff_t)iblk << preq->plo->cluster_log) | (pos & ((1<<preq->plo->cluster_log) - 1));
pos <<= 9;
prev_end = PAGE_SIZE;
for (b = sbl->head; b != NULL; b = b->bi_next) {
int bv_idx;
for (bv_idx = 0; bv_idx < b->bi_vcnt; bv_idx++) {
struct bio_vec * bv = &b->bi_io_vec[bv_idx];
if (nreq && nreq->args.count + bv->bv_len <= rsize) {
if (nreq->pages.pagevec[nreq->pages.npages-1] == bv->bv_page &&
prev_end == bv->bv_offset) {
nreq->args.count += bv->bv_len;
pos += bv->bv_len;
prev_end += bv->bv_len;
continue;
}
if (nreq->pages.npages < MAX_NBIO_PAGES &&
bv->bv_offset == 0 && prev_end == PAGE_SIZE) {
nreq->args.count += bv->bv_len;
nreq->pages.pagevec[nreq->pages.npages] = bv->bv_page;
nreq->pages.npages++;
pos += bv->bv_len;
prev_end = bv->bv_offset + bv->bv_len;
continue;
}
}
if (nreq) {
int err;
atomic_inc(&preq->io_count);
err = rbio_submit(io, nreq, &nfsio_read_ops);
if (err) {
PLOOP_REQ_SET_ERROR(preq, err);
ploop_complete_io_request(preq);
goto out;
}
}
nreq = rbio_init(pos, bv->bv_page, bv->bv_offset,
bv->bv_len, preq, inode);
if (nreq == NULL) {
PLOOP_REQ_SET_ERROR(preq, -ENOMEM);
goto out;
}
pos += bv->bv_len;
prev_end = bv->bv_offset + bv->bv_len;
}
}
if (nreq) {
int err;
atomic_inc(&preq->io_count);
err = rbio_submit(io, nreq, &nfsio_read_ops);
if (err) {
PLOOP_REQ_SET_ERROR(preq, err);
ploop_complete_io_request(preq);
goto out;
}
}
out:
ploop_complete_io_request(preq);
}
static void nfsio_write_result(struct rpc_task *task, void *calldata)
{
struct nfs_write_data *data = calldata;
struct nfs_writeargs *argp = &data->args;
struct nfs_writeres *resp = &data->res;
int status;
status = NFS_PROTO(data->header->inode)->write_done(task, data);
if (status != 0)
return;
if (task->tk_status >= 0 && resp->count < argp->count)
task->tk_status = -EIO;
}
static void nfsio_write_release(void *calldata)
{
struct nfs_write_data *nreq = calldata;
struct ploop_request *preq = (struct ploop_request *) nreq->header->req;
int status = nreq->task.tk_status;
if (unlikely(status < 0))
PLOOP_REQ_SET_ERROR(preq, status);
if (!preq->error &&
nreq->res.verf->committed != NFS_FILE_SYNC) {
if (!test_and_set_bit(PLOOP_REQ_UNSTABLE, &preq->state))
memcpy(&preq->verf, &nreq->res.verf->verifier, 8);
}
nfsio_complete_io_request(preq);
nfsio_wbio_release(calldata);
}
static const struct rpc_call_ops nfsio_write_ops = {
.rpc_call_done = nfsio_write_result,
.rpc_release = nfsio_write_release,
};
static struct nfs_write_data *
wbio_init(loff_t pos, struct page * page, unsigned int off, unsigned int len,
void * priv, struct inode * inode)
{
struct nfs_write_data * nreq;
nreq = nfsio_wbio_alloc(MAX_NBIO_PAGES);
if (unlikely(nreq == NULL))
return NULL;
nreq->args.offset = pos;
nreq->args.pgbase = off;
nreq->args.count = len;
nreq->pages.pagevec[0] = page;
nreq->pages.npages = 1;
nreq->header->req = priv;
nreq->header->inode = inode;
nreq->args.fh = NFS_FH(inode);
nreq->args.pages = nreq->pages.pagevec;
nreq->args.stable = NFS_UNSTABLE;
nreq->res.fattr = &nreq->fattr;
nreq->res.verf = &nreq->verf;
return nreq;
}
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18)
static int wbio_submit(struct ploop_io * io, struct nfs_write_data *nreq,
const struct rpc_call_ops * cb)
{
struct nfs_open_context *ctx = nfs_file_open_context(io->files.file);
struct inode *inode = io->files.inode;
struct rpc_task *task;
struct rpc_message msg = {
.rpc_cred = ctx->cred,
};
struct rpc_task_setup task_setup_data = {
.rpc_client = NFS_CLIENT(inode),
.rpc_message = &msg,
.callback_ops = cb,
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)
.workqueue = nfsio_workqueue,
#endif
.flags = RPC_TASK_ASYNC,
};
if (verify_bounce(nreq))
return -ENOMEM;
nreq->res.count = nreq->args.count;
nreq->args.context = ctx;
nreq->header->cred = msg.rpc_cred;
task_setup_data.task = &nreq->task;
task_setup_data.callback_data = nreq;
msg.rpc_argp = &nreq->args;
msg.rpc_resp = &nreq->res;
NFS_PROTO(inode)->write_setup(nreq, &msg);
task = rpc_run_task(&task_setup_data);
if (unlikely(IS_ERR(task)))
return PTR_ERR(task);
rpc_put_task(task);
return 0;
}
#else
static int wbio_submit(struct ploop_io * io, struct nfs_write_data *nreq,
const struct rpc_call_ops * cb)
{
struct nfs_open_context *ctx = nfs_file_open_context(io->files.file);
struct inode *inode = io->files.inode;
if (verify_bounce(nreq))
return -ENOMEM;
nreq->res.count = nreq->args.count;
nreq->args.context = ctx;
nreq->cred = ctx->cred;
rpc_init_task(&nreq->task, NFS_CLIENT(inode), RPC_TASK_ASYNC, cb, nreq);
NFS_PROTO(inode)->write_setup(nreq, NFS_UNSTABLE);
nreq->task.tk_priority = RPC_PRIORITY_NORMAL;
nreq->task.tk_cookie = (unsigned long) inode;
lock_kernel();
rpc_execute(&nreq->task);
unlock_kernel();
return 0;
}
#endif
static void
nfsio_submit_write(struct ploop_io *io, struct ploop_request * preq,
struct bio_list *sbl, iblock_t iblk, unsigned int size)
{
struct inode *inode = io->files.inode;
size_t wsize = NFS_SERVER(inode)->wsize;
struct nfs_write_data *nreq = NULL;
loff_t pos;
struct bio * b;
unsigned int prev_end;
nfsio_prepare_io_request(preq);
pos = sbl->head->bi_sector;
pos = ((loff_t)iblk << preq->plo->cluster_log) | (pos & ((1<<preq->plo->cluster_log) - 1));
ploop_prepare_tracker(preq, pos);
pos <<= 9;
prev_end = PAGE_SIZE;
for (b = sbl->head; b != NULL; b = b->bi_next) {
int bv_idx;
for (bv_idx = 0; bv_idx < b->bi_vcnt; bv_idx++) {
struct bio_vec * bv = &b->bi_io_vec[bv_idx];
if (nreq && nreq->args.count + bv->bv_len <= wsize) {
if (nreq->pages.pagevec[nreq->pages.npages-1] == bv->bv_page &&
prev_end == bv->bv_offset) {
nreq->args.count += bv->bv_len;
pos += bv->bv_len;
prev_end += bv->bv_len;
continue;
}
if (nreq->pages.npages < MAX_NBIO_PAGES &&
bv->bv_offset == 0 && prev_end == PAGE_SIZE) {
nreq->args.count += bv->bv_len;
nreq->pages.pagevec[nreq->pages.npages] = bv->bv_page;
nreq->pages.npages++;
pos += bv->bv_len;
prev_end = bv->bv_offset + bv->bv_len;
continue;
}
}
if (nreq) {
int err;
atomic_inc(&preq->io_count);
err = wbio_submit(io, nreq, &nfsio_write_ops);
if (err) {
PLOOP_REQ_SET_ERROR(preq, err);
nfsio_complete_io_request(preq);
goto out;
}
}
nreq = wbio_init(pos, bv->bv_page, bv->bv_offset,
bv->bv_len, preq, inode);
if (nreq == NULL) {
PLOOP_REQ_SET_ERROR(preq, -ENOMEM);
goto out;
}
prev_end = bv->bv_offset + bv->bv_len;
pos += bv->bv_len;
}
}
if (nreq) {
int err;
atomic_inc(&preq->io_count);
err = wbio_submit(io, nreq, &nfsio_write_ops);
if (err) {
PLOOP_REQ_SET_ERROR(preq, err);
nfsio_complete_io_request(preq);
}
}
out:
nfsio_complete_io_request(preq);
}
static void
nfsio_submit(struct ploop_io *io, struct ploop_request * preq,
unsigned long rw,
struct bio_list *sbl, iblock_t iblk, unsigned int size)
{
if (iblk == PLOOP_ZERO_INDEX)
iblk = 0;
if (rw & (1<<BIO_RW))
nfsio_submit_write(io, preq, sbl, iblk, size);
else
nfsio_submit_read(io, preq, sbl, iblk, size);
}
struct bio_list_walk
{
struct bio * cur;
int idx;
int bv_off;
};
static void
nfsio_submit_write_pad(struct ploop_io *io, struct ploop_request * preq,
struct bio_list *sbl, iblock_t iblk, unsigned int size)
{
struct inode *inode = io->files.inode;
size_t wsize = NFS_SERVER(inode)->wsize;
struct nfs_write_data *nreq = NULL;
struct bio_list_walk bw;
unsigned prev_end;
loff_t pos, end_pos, start, end;
/* pos..end_pos is the range which we are going to write */
pos = (loff_t)iblk << (preq->plo->cluster_log + 9);
end_pos = pos + (1 << (preq->plo->cluster_log + 9));
/* start..end is data that we have. The rest must be zero padded. */
start = pos + ((sbl->head->bi_sector & ((1<<preq->plo->cluster_log) - 1)) << 9);
end = start + (size << 9);
nfsio_prepare_io_request(preq);
ploop_prepare_tracker(preq, start >> 9);
prev_end = PAGE_SIZE;
#if 1
/* GCC, shut up! */
bw.cur = sbl->head;
bw.idx = 0;
bw.bv_off = 0;
BUG_ON(bw.cur->bi_io_vec[0].bv_len & 511);
#endif
while (pos < end_pos) {
struct page * page;
unsigned int poff, plen;
if (pos < start) {
page = ZERO_PAGE(0);
poff = 0;
plen = start - pos;
if (plen > PAGE_SIZE)
plen = PAGE_SIZE;
} else if (pos >= end) {
page = ZERO_PAGE(0);
poff = 0;
plen = end_pos - pos;
if (plen > PAGE_SIZE)
plen = PAGE_SIZE;
} else {
/* pos >= start && pos < end */
struct bio_vec * bv;
if (pos == start) {
bw.cur = sbl->head;
bw.idx = 0;
bw.bv_off = 0;
BUG_ON(bw.cur->bi_io_vec[0].bv_len & 511);
}
bv = bw.cur->bi_io_vec + bw.idx;
if (bw.bv_off >= bv->bv_len) {
bw.idx++;
bv++;
bw.bv_off = 0;
if (bw.idx >= bw.cur->bi_vcnt) {
bw.cur = bw.cur->bi_next;
bw.idx = 0;
bw.bv_off = 0;
bv = bw.cur->bi_io_vec;
}
BUG_ON(bv->bv_len & 511);
}
page = bv->bv_page;
poff = bv->bv_offset + bw.bv_off;
plen = bv->bv_len - bw.bv_off;
}
if (nreq && nreq->args.count + plen <= wsize) {
if (nreq->pages.pagevec[nreq->pages.npages-1] == page &&
prev_end == poff) {
nreq->args.count += plen;
pos += plen;
bw.bv_off += plen;
prev_end += plen;
continue;
}
if (nreq->pages.npages < MAX_NBIO_PAGES &&
poff == 0 && prev_end == PAGE_SIZE) {
nreq->args.count += plen;
nreq->pages.pagevec[nreq->pages.npages] = page;
nreq->pages.npages++;
pos += plen;
bw.bv_off += plen;
prev_end = poff + plen;
continue;
}
}
if (nreq) {
int err;
atomic_inc(&preq->io_count);
err = wbio_submit(io, nreq, &nfsio_write_ops);
if (err) {
PLOOP_REQ_SET_ERROR(preq, err);
nfsio_complete_io_request(preq);
goto out;
}
}
nreq = wbio_init(pos, page, poff, plen, preq, inode);
if (nreq == NULL) {
PLOOP_REQ_SET_ERROR(preq, -ENOMEM);
goto out;
}
prev_end = poff + plen;
pos += plen;
bw.bv_off += plen;
}
if (nreq) {
int err;
atomic_inc(&preq->io_count);
err = wbio_submit(io, nreq, &nfsio_write_ops);
if (err) {
PLOOP_REQ_SET_ERROR(preq, err);
nfsio_complete_io_request(preq);
}
}
out:
nfsio_complete_io_request(preq);
}
static void
nfsio_submit_alloc(struct ploop_io *io, struct ploop_request * preq,
struct bio_list * sbl, unsigned int size)
{
iblock_t iblk = io->alloc_head++;
if (!(io->files.file->f_mode & FMODE_WRITE)) {
PLOOP_FAIL_REQUEST(preq, -EBADF);
return;
}
preq->iblock = iblk;
preq->eng_state = PLOOP_E_DATA_WBI;
nfsio_submit_write_pad(io, preq, sbl, iblk, size);
}
static void nfsio_destroy(struct ploop_io * io)
{
if (io->fsync_thread) {
kthread_stop(io->fsync_thread);
io->fsync_thread = NULL;
}
if (io->files.file) {
struct file * file = io->files.file;
mutex_lock(&io->plo->sysfs_mutex);
io->files.file = NULL;
if (io->files.mapping)
(void)invalidate_inode_pages2(io->files.mapping);
mutex_unlock(&io->plo->sysfs_mutex);
fput(file);
}
}
static int nfsio_sync(struct ploop_io * io)
{
return 0;
}
static int nfsio_stop(struct ploop_io * io)
{
return 0;
}
static int
nfsio_init(struct ploop_io * io)
{
INIT_LIST_HEAD(&io->fsync_queue);
init_waitqueue_head(&io->fsync_waitq);
return 0;
}
