1
2
3
4#include <linux/fs.h>
5#include <linux/sunrpc/sched.h>
6#include <linux/nfs.h>
7#include <linux/nfs3.h>
8#include <linux/nfs4.h>
9#include <linux/nfs_xdr.h>
10#include <linux/nfs_fs.h>
11#include "nfs4_fs.h"
12#include "nfs42.h"
13#include "iostat.h"
14#include "pnfs.h"
15#include "internal.h"
16
17#define NFSDBG_FACILITY NFSDBG_PNFS
18
19static int nfs42_set_rw_stateid(nfs4_stateid *dst, struct file *file,
20 fmode_t fmode)
21{
22 struct nfs_open_context *open;
23 struct nfs_lock_context *lock;
24 int ret;
25
26 open = get_nfs_open_context(nfs_file_open_context(file));
27 lock = nfs_get_lock_context(open);
28 if (IS_ERR(lock)) {
29 put_nfs_open_context(open);
30 return PTR_ERR(lock);
31 }
32
33 ret = nfs4_set_rw_stateid(dst, open, lock, fmode);
34
35 nfs_put_lock_context(lock);
36 put_nfs_open_context(open);
37 return ret;
38}
39
40static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
41 loff_t offset, loff_t len)
42{
43 struct inode *inode = file_inode(filep);
44 struct nfs_server *server = NFS_SERVER(inode);
45 struct nfs42_falloc_args args = {
46 .falloc_fh = NFS_FH(inode),
47 .falloc_offset = offset,
48 .falloc_length = len,
49 .falloc_bitmask = server->cache_consistency_bitmask,
50 };
51 struct nfs42_falloc_res res = {
52 .falloc_server = server,
53 };
54 int status;
55
56 msg->rpc_argp = &args;
57 msg->rpc_resp = &res;
58
59 status = nfs42_set_rw_stateid(&args.falloc_stateid, filep, FMODE_WRITE);
60 if (status)
61 return status;
62
63 res.falloc_fattr = nfs_alloc_fattr();
64 if (!res.falloc_fattr)
65 return -ENOMEM;
66
67 status = nfs4_call_sync(server->client, server, msg,
68 &args.seq_args, &res.seq_res, 0);
69 if (status == 0)
70 status = nfs_post_op_update_inode(inode, res.falloc_fattr);
71
72 kfree(res.falloc_fattr);
73 return status;
74}
75
76static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
77 loff_t offset, loff_t len)
78{
79 struct nfs_server *server = NFS_SERVER(file_inode(filep));
80 struct nfs4_exception exception = { };
81 int err;
82
83 do {
84 err = _nfs42_proc_fallocate(msg, filep, offset, len);
85 if (err == -ENOTSUPP)
86 return -EOPNOTSUPP;
87 err = nfs4_handle_exception(server, err, &exception);
88 } while (exception.retry);
89
90 return err;
91}
92
93int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
94{
95 struct rpc_message msg = {
96 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE],
97 };
98 struct inode *inode = file_inode(filep);
99 int err;
100
101 if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
102 return -EOPNOTSUPP;
103
104 mutex_lock(&inode->i_mutex);
105
106 err = nfs42_proc_fallocate(&msg, filep, offset, len);
107 if (err == -EOPNOTSUPP)
108 NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
109
110 mutex_unlock(&inode->i_mutex);
111 return err;
112}
113
114int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
115{
116 struct rpc_message msg = {
117 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE],
118 };
119 struct inode *inode = file_inode(filep);
120 int err;
121
122 if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
123 return -EOPNOTSUPP;
124
125 nfs_wb_all(inode);
126 mutex_lock(&inode->i_mutex);
127
128 err = nfs42_proc_fallocate(&msg, filep, offset, len);
129 if (err == 0)
130 truncate_pagecache_range(inode, offset, (offset + len) -1);
131 if (err == -EOPNOTSUPP)
132 NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
133
134 mutex_unlock(&inode->i_mutex);
135 return err;
136}
137
138static loff_t _nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
139{
140 struct inode *inode = file_inode(filep);
141 struct nfs42_seek_args args = {
142 .sa_fh = NFS_FH(inode),
143 .sa_offset = offset,
144 .sa_what = (whence == SEEK_HOLE) ?
145 NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
146 };
147 struct nfs42_seek_res res;
148 struct rpc_message msg = {
149 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
150 .rpc_argp = &args,
151 .rpc_resp = &res,
152 };
153 struct nfs_server *server = NFS_SERVER(inode);
154 int status;
155
156 if (!nfs_server_capable(inode, NFS_CAP_SEEK))
157 return -ENOTSUPP;
158
159 status = nfs42_set_rw_stateid(&args.sa_stateid, filep, FMODE_READ);
160 if (status)
161 return status;
162
163 nfs_wb_all(inode);
164 status = nfs4_call_sync(server->client, server, &msg,
165 &args.seq_args, &res.seq_res, 0);
166 if (status == -ENOTSUPP)
167 server->caps &= ~NFS_CAP_SEEK;
168 if (status)
169 return status;
170
171 return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
172}
173
174loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
175{
176 struct nfs_server *server = NFS_SERVER(file_inode(filep));
177 struct nfs4_exception exception = { };
178 int err;
179
180 do {
181 err = _nfs42_proc_llseek(filep, offset, whence);
182 if (err == -ENOTSUPP)
183 return -EOPNOTSUPP;
184 err = nfs4_handle_exception(server, err, &exception);
185 } while (exception.retry);
186
187 return err;
188}
189
190
191static void
192nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata)
193{
194 struct nfs42_layoutstat_data *data = calldata;
195 struct nfs_server *server = NFS_SERVER(data->args.inode);
196
197 nfs41_setup_sequence(nfs4_get_session(server), &data->args.seq_args,
198 &data->res.seq_res, task);
199}
200
201static void
202nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
203{
204 struct nfs42_layoutstat_data *data = calldata;
205
206 if (!nfs4_sequence_done(task, &data->res.seq_res))
207 return;
208
209 switch (task->tk_status) {
210 case 0:
211 break;
212 case -ENOTSUPP:
213 case -EOPNOTSUPP:
214 NFS_SERVER(data->inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
215 default:
216 dprintk("%s server returns %d\n", __func__, task->tk_status);
217 }
218}
219
220static void
221nfs42_layoutstat_release(void *calldata)
222{
223 struct nfs42_layoutstat_data *data = calldata;
224 struct nfs_server *nfss = NFS_SERVER(data->args.inode);
225
226 if (nfss->pnfs_curr_ld->cleanup_layoutstats)
227 nfss->pnfs_curr_ld->cleanup_layoutstats(data);
228
229 pnfs_put_layout_hdr(NFS_I(data->args.inode)->layout);
230 smp_mb__before_atomic();
231 clear_bit(NFS_INO_LAYOUTSTATS, &NFS_I(data->args.inode)->flags);
232 smp_mb__after_atomic();
233 nfs_iput_and_deactive(data->inode);
234 kfree(data->args.devinfo);
235 kfree(data);
236}
237
238static const struct rpc_call_ops nfs42_layoutstat_ops = {
239 .rpc_call_prepare = nfs42_layoutstat_prepare,
240 .rpc_call_done = nfs42_layoutstat_done,
241 .rpc_release = nfs42_layoutstat_release,
242};
243
244int nfs42_proc_layoutstats_generic(struct nfs_server *server,
245 struct nfs42_layoutstat_data *data)
246{
247 struct rpc_message msg = {
248 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS],
249 .rpc_argp = &data->args,
250 .rpc_resp = &data->res,
251 };
252 struct rpc_task_setup task_setup = {
253 .rpc_client = server->client,
254 .rpc_message = &msg,
255 .callback_ops = &nfs42_layoutstat_ops,
256 .callback_data = data,
257 .flags = RPC_TASK_ASYNC,
258 };
259 struct rpc_task *task;
260
261 data->inode = nfs_igrab_and_active(data->args.inode);
262 if (!data->inode) {
263 nfs42_layoutstat_release(data);
264 return -EAGAIN;
265 }
266 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
267 task = rpc_run_task(&task_setup);
268 if (IS_ERR(task))
269 return PTR_ERR(task);
270 return 0;
271}
272
