1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com> |
4 | */ |
5 | #include <linux/fs.h> |
6 | #include <linux/sunrpc/addr.h> |
7 | #include <linux/sunrpc/sched.h> |
8 | #include <linux/nfs.h> |
9 | #include <linux/nfs3.h> |
10 | #include <linux/nfs4.h> |
11 | #include <linux/nfs_xdr.h> |
12 | #include <linux/nfs_fs.h> |
13 | #include "nfs4_fs.h" |
14 | #include "nfs42.h" |
15 | #include "iostat.h" |
16 | #include "pnfs.h" |
17 | #include "nfs4session.h" |
18 | #include "internal.h" |
19 | #include "delegation.h" |
20 | #include "nfs4trace.h" |
21 | |
22 | #define NFSDBG_FACILITY NFSDBG_PROC |
23 | static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std); |
24 | |
25 | static void nfs42_set_netaddr(struct file *filep, struct nfs42_netaddr *naddr) |
26 | { |
27 | struct nfs_client *clp = (NFS_SERVER(inode: file_inode(f: filep)))->nfs_client; |
28 | unsigned short port = 2049; |
29 | |
30 | rcu_read_lock(); |
31 | naddr->netid_len = scnprintf(buf: naddr->netid, |
32 | size: sizeof(naddr->netid), fmt: "%s" , |
33 | rpc_peeraddr2str(clp->cl_rpcclient, |
34 | RPC_DISPLAY_NETID)); |
35 | naddr->addr_len = scnprintf(buf: naddr->addr, |
36 | size: sizeof(naddr->addr), |
37 | fmt: "%s.%u.%u" , |
38 | rpc_peeraddr2str(clp->cl_rpcclient, |
39 | RPC_DISPLAY_ADDR), |
40 | port >> 8, port & 255); |
41 | rcu_read_unlock(); |
42 | } |
43 | |
44 | static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep, |
45 | struct nfs_lock_context *lock, loff_t offset, loff_t len) |
46 | { |
47 | struct inode *inode = file_inode(f: filep); |
48 | struct nfs_server *server = NFS_SERVER(inode); |
49 | u32 bitmask[NFS_BITMASK_SZ]; |
50 | struct nfs42_falloc_args args = { |
51 | .falloc_fh = NFS_FH(inode), |
52 | .falloc_offset = offset, |
53 | .falloc_length = len, |
54 | .falloc_bitmask = bitmask, |
55 | }; |
56 | struct nfs42_falloc_res res = { |
57 | .falloc_server = server, |
58 | }; |
59 | int status; |
60 | |
61 | msg->rpc_argp = &args; |
62 | msg->rpc_resp = &res; |
63 | |
64 | status = nfs4_set_rw_stateid(stateid: &args.falloc_stateid, ctx: lock->open_context, |
65 | l_ctx: lock, FMODE_WRITE); |
66 | if (status) { |
67 | if (status == -EAGAIN) |
68 | status = -NFS4ERR_BAD_STATEID; |
69 | return status; |
70 | } |
71 | |
72 | nfs4_bitmask_set(bitmask, src: server->cache_consistency_bitmask, inode, |
73 | NFS_INO_INVALID_BLOCKS); |
74 | |
75 | res.falloc_fattr = nfs_alloc_fattr(); |
76 | if (!res.falloc_fattr) |
77 | return -ENOMEM; |
78 | |
79 | status = nfs4_call_sync(server->client, server, msg, |
80 | &args.seq_args, &res.seq_res, 0); |
81 | if (status == 0) { |
82 | if (nfs_should_remove_suid(inode)) { |
83 | spin_lock(lock: &inode->i_lock); |
84 | nfs_set_cache_invalid(inode, |
85 | NFS_INO_REVAL_FORCED | NFS_INO_INVALID_MODE); |
86 | spin_unlock(lock: &inode->i_lock); |
87 | } |
88 | status = nfs_post_op_update_inode_force_wcc(inode, |
89 | fattr: res.falloc_fattr); |
90 | } |
91 | if (msg->rpc_proc == &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE]) |
92 | trace_nfs4_fallocate(inode, args: &args, error: status); |
93 | else |
94 | trace_nfs4_deallocate(inode, args: &args, error: status); |
95 | kfree(objp: res.falloc_fattr); |
96 | return status; |
97 | } |
98 | |
99 | static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep, |
100 | loff_t offset, loff_t len) |
101 | { |
102 | struct inode *inode = file_inode(f: filep); |
103 | struct nfs_server *server = NFS_SERVER(inode); |
104 | struct nfs4_exception exception = { }; |
105 | struct nfs_lock_context *lock; |
106 | int err; |
107 | |
108 | lock = nfs_get_lock_context(ctx: nfs_file_open_context(filp: filep)); |
109 | if (IS_ERR(ptr: lock)) |
110 | return PTR_ERR(ptr: lock); |
111 | |
112 | exception.inode = inode; |
113 | exception.state = lock->open_context->state; |
114 | |
115 | err = nfs_sync_inode(inode); |
116 | if (err) |
117 | goto out; |
118 | |
119 | do { |
120 | err = _nfs42_proc_fallocate(msg, filep, lock, offset, len); |
121 | if (err == -ENOTSUPP) { |
122 | err = -EOPNOTSUPP; |
123 | break; |
124 | } |
125 | err = nfs4_handle_exception(server, err, &exception); |
126 | } while (exception.retry); |
127 | out: |
128 | nfs_put_lock_context(l_ctx: lock); |
129 | return err; |
130 | } |
131 | |
132 | int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len) |
133 | { |
134 | struct rpc_message msg = { |
135 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE], |
136 | }; |
137 | struct inode *inode = file_inode(f: filep); |
138 | int err; |
139 | |
140 | if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE)) |
141 | return -EOPNOTSUPP; |
142 | |
143 | inode_lock(inode); |
144 | |
145 | err = nfs42_proc_fallocate(msg: &msg, filep, offset, len); |
146 | if (err == -EOPNOTSUPP) |
147 | NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE; |
148 | |
149 | inode_unlock(inode); |
150 | return err; |
151 | } |
152 | |
153 | int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len) |
154 | { |
155 | struct rpc_message msg = { |
156 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE], |
157 | }; |
158 | struct inode *inode = file_inode(f: filep); |
159 | int err; |
160 | |
161 | if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE)) |
162 | return -EOPNOTSUPP; |
163 | |
164 | inode_lock(inode); |
165 | |
166 | err = nfs42_proc_fallocate(msg: &msg, filep, offset, len); |
167 | if (err == 0) |
168 | truncate_pagecache_range(inode, offset, end: (offset + len) -1); |
169 | if (err == -EOPNOTSUPP) |
170 | NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE; |
171 | |
172 | inode_unlock(inode); |
173 | return err; |
174 | } |
175 | |
176 | static int handle_async_copy(struct nfs42_copy_res *res, |
177 | struct nfs_server *dst_server, |
178 | struct nfs_server *src_server, |
179 | struct file *src, |
180 | struct file *dst, |
181 | nfs4_stateid *src_stateid, |
182 | bool *restart) |
183 | { |
184 | struct nfs4_copy_state *copy, *tmp_copy = NULL, *iter; |
185 | int status = NFS4_OK; |
186 | struct nfs_open_context *dst_ctx = nfs_file_open_context(filp: dst); |
187 | struct nfs_open_context *src_ctx = nfs_file_open_context(filp: src); |
188 | |
189 | copy = kzalloc(size: sizeof(struct nfs4_copy_state), GFP_KERNEL); |
190 | if (!copy) |
191 | return -ENOMEM; |
192 | |
193 | spin_lock(lock: &dst_server->nfs_client->cl_lock); |
194 | list_for_each_entry(iter, |
195 | &dst_server->nfs_client->pending_cb_stateids, |
196 | copies) { |
197 | if (memcmp(p: &res->write_res.stateid, q: &iter->stateid, |
198 | NFS4_STATEID_SIZE)) |
199 | continue; |
200 | tmp_copy = iter; |
201 | list_del(entry: &iter->copies); |
202 | break; |
203 | } |
204 | if (tmp_copy) { |
205 | spin_unlock(lock: &dst_server->nfs_client->cl_lock); |
206 | kfree(objp: copy); |
207 | copy = tmp_copy; |
208 | goto out; |
209 | } |
210 | |
211 | memcpy(©->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE); |
212 | init_completion(x: ©->completion); |
213 | copy->parent_dst_state = dst_ctx->state; |
214 | copy->parent_src_state = src_ctx->state; |
215 | |
216 | list_add_tail(new: ©->copies, head: &dst_server->ss_copies); |
217 | spin_unlock(lock: &dst_server->nfs_client->cl_lock); |
218 | |
219 | if (dst_server != src_server) { |
220 | spin_lock(lock: &src_server->nfs_client->cl_lock); |
221 | list_add_tail(new: ©->src_copies, head: &src_server->ss_copies); |
222 | spin_unlock(lock: &src_server->nfs_client->cl_lock); |
223 | } |
224 | |
225 | status = wait_for_completion_interruptible(x: ©->completion); |
226 | spin_lock(lock: &dst_server->nfs_client->cl_lock); |
227 | list_del_init(entry: ©->copies); |
228 | spin_unlock(lock: &dst_server->nfs_client->cl_lock); |
229 | if (dst_server != src_server) { |
230 | spin_lock(lock: &src_server->nfs_client->cl_lock); |
231 | list_del_init(entry: ©->src_copies); |
232 | spin_unlock(lock: &src_server->nfs_client->cl_lock); |
233 | } |
234 | if (status == -ERESTARTSYS) { |
235 | goto out_cancel; |
236 | } else if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) { |
237 | status = -EAGAIN; |
238 | *restart = true; |
239 | goto out_cancel; |
240 | } |
241 | out: |
242 | res->write_res.count = copy->count; |
243 | memcpy(&res->write_res.verifier, ©->verf, sizeof(copy->verf)); |
244 | status = -copy->error; |
245 | |
246 | out_free: |
247 | kfree(objp: copy); |
248 | return status; |
249 | out_cancel: |
250 | nfs42_do_offload_cancel_async(dst, std: ©->stateid); |
251 | if (!nfs42_files_from_same_server(in: src, out: dst)) |
252 | nfs42_do_offload_cancel_async(dst: src, std: src_stateid); |
253 | goto out_free; |
254 | } |
255 | |
256 | static int process_copy_commit(struct file *dst, loff_t pos_dst, |
257 | struct nfs42_copy_res *res) |
258 | { |
259 | struct nfs_commitres cres; |
260 | int status = -ENOMEM; |
261 | |
262 | cres.verf = kzalloc(size: sizeof(struct nfs_writeverf), GFP_KERNEL); |
263 | if (!cres.verf) |
264 | goto out; |
265 | |
266 | status = nfs4_proc_commit(dst, offset: pos_dst, count: res->write_res.count, res: &cres); |
267 | if (status) |
268 | goto out_free; |
269 | if (nfs_write_verifier_cmp(v1: &res->write_res.verifier.verifier, |
270 | v2: &cres.verf->verifier)) { |
271 | dprintk("commit verf differs from copy verf\n" ); |
272 | status = -EAGAIN; |
273 | } |
274 | out_free: |
275 | kfree(objp: cres.verf); |
276 | out: |
277 | return status; |
278 | } |
279 | |
280 | /** |
281 | * nfs42_copy_dest_done - perform inode cache updates after clone/copy offload |
282 | * @inode: pointer to destination inode |
283 | * @pos: destination offset |
284 | * @len: copy length |
285 | * |
286 | * Punch a hole in the inode page cache, so that the NFS client will |
287 | * know to retrieve new data. |
288 | * Update the file size if necessary, and then mark the inode as having |
289 | * invalid cached values for change attribute, ctime, mtime and space used. |
290 | */ |
291 | static void nfs42_copy_dest_done(struct inode *inode, loff_t pos, loff_t len) |
292 | { |
293 | loff_t newsize = pos + len; |
294 | loff_t end = newsize - 1; |
295 | |
296 | WARN_ON_ONCE(invalidate_inode_pages2_range(inode->i_mapping, |
297 | pos >> PAGE_SHIFT, end >> PAGE_SHIFT)); |
298 | |
299 | spin_lock(lock: &inode->i_lock); |
300 | if (newsize > i_size_read(inode)) |
301 | i_size_write(inode, i_size: newsize); |
302 | nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE | |
303 | NFS_INO_INVALID_CTIME | |
304 | NFS_INO_INVALID_MTIME | |
305 | NFS_INO_INVALID_BLOCKS); |
306 | spin_unlock(lock: &inode->i_lock); |
307 | } |
308 | |
309 | static ssize_t _nfs42_proc_copy(struct file *src, |
310 | struct nfs_lock_context *src_lock, |
311 | struct file *dst, |
312 | struct nfs_lock_context *dst_lock, |
313 | struct nfs42_copy_args *args, |
314 | struct nfs42_copy_res *res, |
315 | struct nl4_server *nss, |
316 | nfs4_stateid *cnr_stateid, |
317 | bool *restart) |
318 | { |
319 | struct rpc_message msg = { |
320 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY], |
321 | .rpc_argp = args, |
322 | .rpc_resp = res, |
323 | }; |
324 | struct inode *dst_inode = file_inode(f: dst); |
325 | struct inode *src_inode = file_inode(f: src); |
326 | struct nfs_server *dst_server = NFS_SERVER(inode: dst_inode); |
327 | struct nfs_server *src_server = NFS_SERVER(inode: src_inode); |
328 | loff_t pos_src = args->src_pos; |
329 | loff_t pos_dst = args->dst_pos; |
330 | size_t count = args->count; |
331 | ssize_t status; |
332 | |
333 | if (nss) { |
334 | args->cp_src = nss; |
335 | nfs4_stateid_copy(dst: &args->src_stateid, src: cnr_stateid); |
336 | } else { |
337 | status = nfs4_set_rw_stateid(stateid: &args->src_stateid, |
338 | ctx: src_lock->open_context, l_ctx: src_lock, FMODE_READ); |
339 | if (status) { |
340 | if (status == -EAGAIN) |
341 | status = -NFS4ERR_BAD_STATEID; |
342 | return status; |
343 | } |
344 | } |
345 | status = nfs_filemap_write_and_wait_range(mapping: src->f_mapping, |
346 | lstart: pos_src, lend: pos_src + (loff_t)count - 1); |
347 | if (status) |
348 | return status; |
349 | |
350 | status = nfs4_set_rw_stateid(stateid: &args->dst_stateid, ctx: dst_lock->open_context, |
351 | l_ctx: dst_lock, FMODE_WRITE); |
352 | if (status) { |
353 | if (status == -EAGAIN) |
354 | status = -NFS4ERR_BAD_STATEID; |
355 | return status; |
356 | } |
357 | |
358 | status = nfs_sync_inode(inode: dst_inode); |
359 | if (status) |
360 | return status; |
361 | |
362 | res->commit_res.verf = NULL; |
363 | if (args->sync) { |
364 | res->commit_res.verf = |
365 | kzalloc(size: sizeof(struct nfs_writeverf), GFP_KERNEL); |
366 | if (!res->commit_res.verf) |
367 | return -ENOMEM; |
368 | } |
369 | set_bit(nr: NFS_CLNT_SRC_SSC_COPY_STATE, |
370 | addr: &src_lock->open_context->state->flags); |
371 | set_bit(nr: NFS_CLNT_DST_SSC_COPY_STATE, |
372 | addr: &dst_lock->open_context->state->flags); |
373 | |
374 | status = nfs4_call_sync(dst_server->client, dst_server, &msg, |
375 | &args->seq_args, &res->seq_res, 0); |
376 | trace_nfs4_copy(src_inode, dst_inode, args, res, nss, error: status); |
377 | if (status == -ENOTSUPP) |
378 | dst_server->caps &= ~NFS_CAP_COPY; |
379 | if (status) |
380 | goto out; |
381 | |
382 | if (args->sync && |
383 | nfs_write_verifier_cmp(v1: &res->write_res.verifier.verifier, |
384 | v2: &res->commit_res.verf->verifier)) { |
385 | status = -EAGAIN; |
386 | goto out; |
387 | } |
388 | |
389 | if (!res->synchronous) { |
390 | status = handle_async_copy(res, dst_server, src_server, src, |
391 | dst, src_stateid: &args->src_stateid, restart); |
392 | if (status) |
393 | goto out; |
394 | } |
395 | |
396 | if ((!res->synchronous || !args->sync) && |
397 | res->write_res.verifier.committed != NFS_FILE_SYNC) { |
398 | status = process_copy_commit(dst, pos_dst, res); |
399 | if (status) |
400 | goto out; |
401 | } |
402 | |
403 | nfs42_copy_dest_done(inode: dst_inode, pos: pos_dst, len: res->write_res.count); |
404 | nfs_invalidate_atime(src_inode); |
405 | status = res->write_res.count; |
406 | out: |
407 | if (args->sync) |
408 | kfree(objp: res->commit_res.verf); |
409 | return status; |
410 | } |
411 | |
412 | ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src, |
413 | struct file *dst, loff_t pos_dst, size_t count, |
414 | struct nl4_server *nss, |
415 | nfs4_stateid *cnr_stateid, bool sync) |
416 | { |
417 | struct nfs_server *server = NFS_SERVER(inode: file_inode(f: dst)); |
418 | struct nfs_lock_context *src_lock; |
419 | struct nfs_lock_context *dst_lock; |
420 | struct nfs42_copy_args args = { |
421 | .src_fh = NFS_FH(inode: file_inode(f: src)), |
422 | .src_pos = pos_src, |
423 | .dst_fh = NFS_FH(inode: file_inode(f: dst)), |
424 | .dst_pos = pos_dst, |
425 | .count = count, |
426 | .sync = sync, |
427 | }; |
428 | struct nfs42_copy_res res; |
429 | struct nfs4_exception src_exception = { |
430 | .inode = file_inode(f: src), |
431 | .stateid = &args.src_stateid, |
432 | }; |
433 | struct nfs4_exception dst_exception = { |
434 | .inode = file_inode(f: dst), |
435 | .stateid = &args.dst_stateid, |
436 | }; |
437 | ssize_t err, err2; |
438 | bool restart = false; |
439 | |
440 | src_lock = nfs_get_lock_context(ctx: nfs_file_open_context(filp: src)); |
441 | if (IS_ERR(ptr: src_lock)) |
442 | return PTR_ERR(ptr: src_lock); |
443 | |
444 | src_exception.state = src_lock->open_context->state; |
445 | |
446 | dst_lock = nfs_get_lock_context(ctx: nfs_file_open_context(filp: dst)); |
447 | if (IS_ERR(ptr: dst_lock)) { |
448 | err = PTR_ERR(ptr: dst_lock); |
449 | goto out_put_src_lock; |
450 | } |
451 | |
452 | dst_exception.state = dst_lock->open_context->state; |
453 | |
454 | do { |
455 | inode_lock(inode: file_inode(f: dst)); |
456 | err = _nfs42_proc_copy(src, src_lock, |
457 | dst, dst_lock, |
458 | args: &args, res: &res, |
459 | nss, cnr_stateid, restart: &restart); |
460 | inode_unlock(inode: file_inode(f: dst)); |
461 | |
462 | if (err >= 0) |
463 | break; |
464 | if ((err == -ENOTSUPP || |
465 | err == -NFS4ERR_OFFLOAD_DENIED) && |
466 | nfs42_files_from_same_server(in: src, out: dst)) { |
467 | err = -EOPNOTSUPP; |
468 | break; |
469 | } else if (err == -EAGAIN) { |
470 | if (!restart) { |
471 | dst_exception.retry = 1; |
472 | continue; |
473 | } |
474 | break; |
475 | } else if (err == -NFS4ERR_OFFLOAD_NO_REQS && |
476 | args.sync != res.synchronous) { |
477 | args.sync = res.synchronous; |
478 | dst_exception.retry = 1; |
479 | continue; |
480 | } else if ((err == -ESTALE || |
481 | err == -NFS4ERR_OFFLOAD_DENIED || |
482 | err == -ENOTSUPP) && |
483 | !nfs42_files_from_same_server(in: src, out: dst)) { |
484 | nfs42_do_offload_cancel_async(dst: src, std: &args.src_stateid); |
485 | err = -EOPNOTSUPP; |
486 | break; |
487 | } |
488 | |
489 | err2 = nfs4_handle_exception(server, err, &src_exception); |
490 | err = nfs4_handle_exception(server, err, &dst_exception); |
491 | if (!err) |
492 | err = err2; |
493 | } while (src_exception.retry || dst_exception.retry); |
494 | |
495 | nfs_put_lock_context(l_ctx: dst_lock); |
496 | out_put_src_lock: |
497 | nfs_put_lock_context(l_ctx: src_lock); |
498 | return err; |
499 | } |
500 | |
501 | struct nfs42_offloadcancel_data { |
502 | struct nfs_server *seq_server; |
503 | struct nfs42_offload_status_args args; |
504 | struct nfs42_offload_status_res res; |
505 | }; |
506 | |
507 | static void nfs42_offload_cancel_prepare(struct rpc_task *task, void *calldata) |
508 | { |
509 | struct nfs42_offloadcancel_data *data = calldata; |
510 | |
511 | nfs4_setup_sequence(client: data->seq_server->nfs_client, |
512 | args: &data->args.osa_seq_args, |
513 | res: &data->res.osr_seq_res, task); |
514 | } |
515 | |
516 | static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata) |
517 | { |
518 | struct nfs42_offloadcancel_data *data = calldata; |
519 | |
520 | trace_nfs4_offload_cancel(args: &data->args, error: task->tk_status); |
521 | nfs41_sequence_done(task, &data->res.osr_seq_res); |
522 | if (task->tk_status && |
523 | nfs4_async_handle_error(task, server: data->seq_server, NULL, |
524 | NULL) == -EAGAIN) |
525 | rpc_restart_call_prepare(task); |
526 | } |
527 | |
528 | static void nfs42_free_offloadcancel_data(void *data) |
529 | { |
530 | kfree(objp: data); |
531 | } |
532 | |
533 | static const struct rpc_call_ops nfs42_offload_cancel_ops = { |
534 | .rpc_call_prepare = nfs42_offload_cancel_prepare, |
535 | .rpc_call_done = nfs42_offload_cancel_done, |
536 | .rpc_release = nfs42_free_offloadcancel_data, |
537 | }; |
538 | |
539 | static int nfs42_do_offload_cancel_async(struct file *dst, |
540 | nfs4_stateid *stateid) |
541 | { |
542 | struct nfs_server *dst_server = NFS_SERVER(inode: file_inode(f: dst)); |
543 | struct nfs42_offloadcancel_data *data = NULL; |
544 | struct nfs_open_context *ctx = nfs_file_open_context(filp: dst); |
545 | struct rpc_task *task; |
546 | struct rpc_message msg = { |
547 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_CANCEL], |
548 | .rpc_cred = ctx->cred, |
549 | }; |
550 | struct rpc_task_setup task_setup_data = { |
551 | .rpc_client = dst_server->client, |
552 | .rpc_message = &msg, |
553 | .callback_ops = &nfs42_offload_cancel_ops, |
554 | .workqueue = nfsiod_workqueue, |
555 | .flags = RPC_TASK_ASYNC, |
556 | }; |
557 | int status; |
558 | |
559 | if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL)) |
560 | return -EOPNOTSUPP; |
561 | |
562 | data = kzalloc(size: sizeof(struct nfs42_offloadcancel_data), GFP_KERNEL); |
563 | if (data == NULL) |
564 | return -ENOMEM; |
565 | |
566 | data->seq_server = dst_server; |
567 | data->args.osa_src_fh = NFS_FH(inode: file_inode(f: dst)); |
568 | memcpy(&data->args.osa_stateid, stateid, |
569 | sizeof(data->args.osa_stateid)); |
570 | msg.rpc_argp = &data->args; |
571 | msg.rpc_resp = &data->res; |
572 | task_setup_data.callback_data = data; |
573 | nfs4_init_sequence(&data->args.osa_seq_args, &data->res.osr_seq_res, |
574 | 1, 0); |
575 | task = rpc_run_task(&task_setup_data); |
576 | if (IS_ERR(ptr: task)) |
577 | return PTR_ERR(ptr: task); |
578 | status = rpc_wait_for_completion_task(task); |
579 | if (status == -ENOTSUPP) |
580 | dst_server->caps &= ~NFS_CAP_OFFLOAD_CANCEL; |
581 | rpc_put_task(task); |
582 | return status; |
583 | } |
584 | |
585 | static int _nfs42_proc_copy_notify(struct file *src, struct file *dst, |
586 | struct nfs42_copy_notify_args *args, |
587 | struct nfs42_copy_notify_res *res) |
588 | { |
589 | struct nfs_server *src_server = NFS_SERVER(inode: file_inode(f: src)); |
590 | struct rpc_message msg = { |
591 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY_NOTIFY], |
592 | .rpc_argp = args, |
593 | .rpc_resp = res, |
594 | }; |
595 | int status; |
596 | struct nfs_open_context *ctx; |
597 | struct nfs_lock_context *l_ctx; |
598 | |
599 | ctx = get_nfs_open_context(ctx: nfs_file_open_context(filp: src)); |
600 | l_ctx = nfs_get_lock_context(ctx); |
601 | if (IS_ERR(ptr: l_ctx)) { |
602 | status = PTR_ERR(ptr: l_ctx); |
603 | goto out; |
604 | } |
605 | |
606 | status = nfs4_set_rw_stateid(stateid: &args->cna_src_stateid, ctx, l_ctx, |
607 | FMODE_READ); |
608 | nfs_put_lock_context(l_ctx); |
609 | if (status) { |
610 | if (status == -EAGAIN) |
611 | status = -NFS4ERR_BAD_STATEID; |
612 | goto out; |
613 | } |
614 | |
615 | status = nfs4_call_sync(src_server->client, src_server, &msg, |
616 | &args->cna_seq_args, &res->cnr_seq_res, 0); |
617 | trace_nfs4_copy_notify(inode: file_inode(f: src), args, res, error: status); |
618 | if (status == -ENOTSUPP) |
619 | src_server->caps &= ~NFS_CAP_COPY_NOTIFY; |
620 | |
621 | out: |
622 | put_nfs_open_context(ctx: nfs_file_open_context(filp: src)); |
623 | return status; |
624 | } |
625 | |
626 | int nfs42_proc_copy_notify(struct file *src, struct file *dst, |
627 | struct nfs42_copy_notify_res *res) |
628 | { |
629 | struct nfs_server *src_server = NFS_SERVER(inode: file_inode(f: src)); |
630 | struct nfs42_copy_notify_args *args; |
631 | struct nfs4_exception exception = { |
632 | .inode = file_inode(f: src), |
633 | }; |
634 | int status; |
635 | |
636 | if (!(src_server->caps & NFS_CAP_COPY_NOTIFY)) |
637 | return -EOPNOTSUPP; |
638 | |
639 | args = kzalloc(size: sizeof(struct nfs42_copy_notify_args), GFP_KERNEL); |
640 | if (args == NULL) |
641 | return -ENOMEM; |
642 | |
643 | args->cna_src_fh = NFS_FH(inode: file_inode(f: src)), |
644 | args->cna_dst.nl4_type = NL4_NETADDR; |
645 | nfs42_set_netaddr(filep: dst, naddr: &args->cna_dst.u.nl4_addr); |
646 | exception.stateid = &args->cna_src_stateid; |
647 | |
648 | do { |
649 | status = _nfs42_proc_copy_notify(src, dst, args, res); |
650 | if (status == -ENOTSUPP) { |
651 | status = -EOPNOTSUPP; |
652 | goto out; |
653 | } |
654 | status = nfs4_handle_exception(src_server, status, &exception); |
655 | } while (exception.retry); |
656 | |
657 | out: |
658 | kfree(objp: args); |
659 | return status; |
660 | } |
661 | |
662 | static loff_t _nfs42_proc_llseek(struct file *filep, |
663 | struct nfs_lock_context *lock, loff_t offset, int whence) |
664 | { |
665 | struct inode *inode = file_inode(f: filep); |
666 | struct nfs42_seek_args args = { |
667 | .sa_fh = NFS_FH(inode), |
668 | .sa_offset = offset, |
669 | .sa_what = (whence == SEEK_HOLE) ? |
670 | NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA, |
671 | }; |
672 | struct nfs42_seek_res res; |
673 | struct rpc_message msg = { |
674 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK], |
675 | .rpc_argp = &args, |
676 | .rpc_resp = &res, |
677 | }; |
678 | struct nfs_server *server = NFS_SERVER(inode); |
679 | int status; |
680 | |
681 | if (!nfs_server_capable(inode, NFS_CAP_SEEK)) |
682 | return -ENOTSUPP; |
683 | |
684 | status = nfs4_set_rw_stateid(stateid: &args.sa_stateid, ctx: lock->open_context, |
685 | l_ctx: lock, FMODE_READ); |
686 | if (status) { |
687 | if (status == -EAGAIN) |
688 | status = -NFS4ERR_BAD_STATEID; |
689 | return status; |
690 | } |
691 | |
692 | status = nfs_filemap_write_and_wait_range(mapping: inode->i_mapping, |
693 | lstart: offset, LLONG_MAX); |
694 | if (status) |
695 | return status; |
696 | |
697 | status = nfs4_call_sync(server->client, server, &msg, |
698 | &args.seq_args, &res.seq_res, 0); |
699 | trace_nfs4_llseek(inode, args: &args, res: &res, error: status); |
700 | if (status == -ENOTSUPP) |
701 | server->caps &= ~NFS_CAP_SEEK; |
702 | if (status) |
703 | return status; |
704 | |
705 | if (whence == SEEK_DATA && res.sr_eof) |
706 | return -NFS4ERR_NXIO; |
707 | else |
708 | return vfs_setpos(file: filep, offset: res.sr_offset, maxsize: inode->i_sb->s_maxbytes); |
709 | } |
710 | |
711 | loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence) |
712 | { |
713 | struct nfs_server *server = NFS_SERVER(inode: file_inode(f: filep)); |
714 | struct nfs4_exception exception = { }; |
715 | struct nfs_lock_context *lock; |
716 | loff_t err; |
717 | |
718 | lock = nfs_get_lock_context(ctx: nfs_file_open_context(filp: filep)); |
719 | if (IS_ERR(ptr: lock)) |
720 | return PTR_ERR(ptr: lock); |
721 | |
722 | exception.inode = file_inode(f: filep); |
723 | exception.state = lock->open_context->state; |
724 | |
725 | do { |
726 | err = _nfs42_proc_llseek(filep, lock, offset, whence); |
727 | if (err >= 0) |
728 | break; |
729 | if (err == -ENOTSUPP) { |
730 | err = -EOPNOTSUPP; |
731 | break; |
732 | } |
733 | err = nfs4_handle_exception(server, err, &exception); |
734 | } while (exception.retry); |
735 | |
736 | nfs_put_lock_context(l_ctx: lock); |
737 | return err; |
738 | } |
739 | |
740 | |
741 | static void |
742 | nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata) |
743 | { |
744 | struct nfs42_layoutstat_data *data = calldata; |
745 | struct inode *inode = data->inode; |
746 | struct nfs_server *server = NFS_SERVER(inode); |
747 | struct pnfs_layout_hdr *lo; |
748 | |
749 | spin_lock(lock: &inode->i_lock); |
750 | lo = NFS_I(inode)->layout; |
751 | if (!pnfs_layout_is_valid(lo)) { |
752 | spin_unlock(lock: &inode->i_lock); |
753 | rpc_exit(task, 0); |
754 | return; |
755 | } |
756 | nfs4_stateid_copy(dst: &data->args.stateid, src: &lo->plh_stateid); |
757 | spin_unlock(lock: &inode->i_lock); |
758 | nfs4_setup_sequence(client: server->nfs_client, args: &data->args.seq_args, |
759 | res: &data->res.seq_res, task); |
760 | } |
761 | |
762 | static void |
763 | nfs42_layoutstat_done(struct rpc_task *task, void *calldata) |
764 | { |
765 | struct nfs42_layoutstat_data *data = calldata; |
766 | struct inode *inode = data->inode; |
767 | struct pnfs_layout_hdr *lo; |
768 | |
769 | if (!nfs4_sequence_done(task, res: &data->res.seq_res)) |
770 | return; |
771 | |
772 | switch (task->tk_status) { |
773 | case 0: |
774 | return; |
775 | case -NFS4ERR_BADHANDLE: |
776 | case -ESTALE: |
777 | pnfs_destroy_layout(NFS_I(inode)); |
778 | break; |
779 | case -NFS4ERR_EXPIRED: |
780 | case -NFS4ERR_ADMIN_REVOKED: |
781 | case -NFS4ERR_DELEG_REVOKED: |
782 | case -NFS4ERR_STALE_STATEID: |
783 | case -NFS4ERR_BAD_STATEID: |
784 | spin_lock(lock: &inode->i_lock); |
785 | lo = NFS_I(inode)->layout; |
786 | if (pnfs_layout_is_valid(lo) && |
787 | nfs4_stateid_match(dst: &data->args.stateid, |
788 | src: &lo->plh_stateid)) { |
789 | LIST_HEAD(head); |
790 | |
791 | /* |
792 | * Mark the bad layout state as invalid, then retry |
793 | * with the current stateid. |
794 | */ |
795 | pnfs_mark_layout_stateid_invalid(lo, lseg_list: &head); |
796 | spin_unlock(lock: &inode->i_lock); |
797 | pnfs_free_lseg_list(tmp_list: &head); |
798 | nfs_commit_inode(inode, 0); |
799 | } else |
800 | spin_unlock(lock: &inode->i_lock); |
801 | break; |
802 | case -NFS4ERR_OLD_STATEID: |
803 | spin_lock(lock: &inode->i_lock); |
804 | lo = NFS_I(inode)->layout; |
805 | if (pnfs_layout_is_valid(lo) && |
806 | nfs4_stateid_match_other(dst: &data->args.stateid, |
807 | src: &lo->plh_stateid)) { |
808 | /* Do we need to delay before resending? */ |
809 | if (!nfs4_stateid_is_newer(s1: &lo->plh_stateid, |
810 | s2: &data->args.stateid)) |
811 | rpc_delay(task, HZ); |
812 | rpc_restart_call_prepare(task); |
813 | } |
814 | spin_unlock(lock: &inode->i_lock); |
815 | break; |
816 | case -ENOTSUPP: |
817 | case -EOPNOTSUPP: |
818 | NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS; |
819 | } |
820 | |
821 | trace_nfs4_layoutstats(inode, stateid: &data->args.stateid, error: task->tk_status); |
822 | } |
823 | |
824 | static void |
825 | nfs42_layoutstat_release(void *calldata) |
826 | { |
827 | struct nfs42_layoutstat_data *data = calldata; |
828 | struct nfs42_layoutstat_devinfo *devinfo = data->args.devinfo; |
829 | int i; |
830 | |
831 | for (i = 0; i < data->args.num_dev; i++) { |
832 | if (devinfo[i].ld_private.ops && devinfo[i].ld_private.ops->free) |
833 | devinfo[i].ld_private.ops->free(&devinfo[i].ld_private); |
834 | } |
835 | |
836 | pnfs_put_layout_hdr(lo: NFS_I(inode: data->args.inode)->layout); |
837 | smp_mb__before_atomic(); |
838 | clear_bit(NFS_INO_LAYOUTSTATS, addr: &NFS_I(inode: data->args.inode)->flags); |
839 | smp_mb__after_atomic(); |
840 | nfs_iput_and_deactive(inode: data->inode); |
841 | kfree(objp: data->args.devinfo); |
842 | kfree(objp: data); |
843 | } |
844 | |
845 | static const struct rpc_call_ops nfs42_layoutstat_ops = { |
846 | .rpc_call_prepare = nfs42_layoutstat_prepare, |
847 | .rpc_call_done = nfs42_layoutstat_done, |
848 | .rpc_release = nfs42_layoutstat_release, |
849 | }; |
850 | |
851 | int nfs42_proc_layoutstats_generic(struct nfs_server *server, |
852 | struct nfs42_layoutstat_data *data) |
853 | { |
854 | struct rpc_message msg = { |
855 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS], |
856 | .rpc_argp = &data->args, |
857 | .rpc_resp = &data->res, |
858 | }; |
859 | struct rpc_task_setup task_setup = { |
860 | .rpc_client = server->client, |
861 | .rpc_message = &msg, |
862 | .callback_ops = &nfs42_layoutstat_ops, |
863 | .callback_data = data, |
864 | .flags = RPC_TASK_ASYNC, |
865 | }; |
866 | struct rpc_task *task; |
867 | |
868 | data->inode = nfs_igrab_and_active(inode: data->args.inode); |
869 | if (!data->inode) { |
870 | nfs42_layoutstat_release(calldata: data); |
871 | return -EAGAIN; |
872 | } |
873 | nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0); |
874 | task = rpc_run_task(&task_setup); |
875 | if (IS_ERR(ptr: task)) |
876 | return PTR_ERR(ptr: task); |
877 | rpc_put_task(task); |
878 | return 0; |
879 | } |
880 | |
881 | static struct nfs42_layouterror_data * |
882 | nfs42_alloc_layouterror_data(struct pnfs_layout_segment *lseg, gfp_t gfp_flags) |
883 | { |
884 | struct nfs42_layouterror_data *data; |
885 | struct inode *inode = lseg->pls_layout->plh_inode; |
886 | |
887 | data = kzalloc(size: sizeof(*data), flags: gfp_flags); |
888 | if (data) { |
889 | data->args.inode = data->inode = nfs_igrab_and_active(inode); |
890 | if (data->inode) { |
891 | data->lseg = pnfs_get_lseg(lseg); |
892 | if (data->lseg) |
893 | return data; |
894 | nfs_iput_and_deactive(inode: data->inode); |
895 | } |
896 | kfree(objp: data); |
897 | } |
898 | return NULL; |
899 | } |
900 | |
901 | static void |
902 | nfs42_free_layouterror_data(struct nfs42_layouterror_data *data) |
903 | { |
904 | pnfs_put_lseg(lseg: data->lseg); |
905 | nfs_iput_and_deactive(inode: data->inode); |
906 | kfree(objp: data); |
907 | } |
908 | |
909 | static void |
910 | nfs42_layouterror_prepare(struct rpc_task *task, void *calldata) |
911 | { |
912 | struct nfs42_layouterror_data *data = calldata; |
913 | struct inode *inode = data->inode; |
914 | struct nfs_server *server = NFS_SERVER(inode); |
915 | struct pnfs_layout_hdr *lo = data->lseg->pls_layout; |
916 | unsigned i; |
917 | |
918 | spin_lock(lock: &inode->i_lock); |
919 | if (!pnfs_layout_is_valid(lo)) { |
920 | spin_unlock(lock: &inode->i_lock); |
921 | rpc_exit(task, 0); |
922 | return; |
923 | } |
924 | for (i = 0; i < data->args.num_errors; i++) |
925 | nfs4_stateid_copy(dst: &data->args.errors[i].stateid, |
926 | src: &lo->plh_stateid); |
927 | spin_unlock(lock: &inode->i_lock); |
928 | nfs4_setup_sequence(client: server->nfs_client, args: &data->args.seq_args, |
929 | res: &data->res.seq_res, task); |
930 | } |
931 | |
932 | static void |
933 | nfs42_layouterror_done(struct rpc_task *task, void *calldata) |
934 | { |
935 | struct nfs42_layouterror_data *data = calldata; |
936 | struct inode *inode = data->inode; |
937 | struct pnfs_layout_hdr *lo = data->lseg->pls_layout; |
938 | |
939 | if (!nfs4_sequence_done(task, res: &data->res.seq_res)) |
940 | return; |
941 | |
942 | switch (task->tk_status) { |
943 | case 0: |
944 | return; |
945 | case -NFS4ERR_BADHANDLE: |
946 | case -ESTALE: |
947 | pnfs_destroy_layout(NFS_I(inode)); |
948 | break; |
949 | case -NFS4ERR_EXPIRED: |
950 | case -NFS4ERR_ADMIN_REVOKED: |
951 | case -NFS4ERR_DELEG_REVOKED: |
952 | case -NFS4ERR_STALE_STATEID: |
953 | case -NFS4ERR_BAD_STATEID: |
954 | spin_lock(lock: &inode->i_lock); |
955 | if (pnfs_layout_is_valid(lo) && |
956 | nfs4_stateid_match(dst: &data->args.errors[0].stateid, |
957 | src: &lo->plh_stateid)) { |
958 | LIST_HEAD(head); |
959 | |
960 | /* |
961 | * Mark the bad layout state as invalid, then retry |
962 | * with the current stateid. |
963 | */ |
964 | pnfs_mark_layout_stateid_invalid(lo, lseg_list: &head); |
965 | spin_unlock(lock: &inode->i_lock); |
966 | pnfs_free_lseg_list(tmp_list: &head); |
967 | nfs_commit_inode(inode, 0); |
968 | } else |
969 | spin_unlock(lock: &inode->i_lock); |
970 | break; |
971 | case -NFS4ERR_OLD_STATEID: |
972 | spin_lock(lock: &inode->i_lock); |
973 | if (pnfs_layout_is_valid(lo) && |
974 | nfs4_stateid_match_other(dst: &data->args.errors[0].stateid, |
975 | src: &lo->plh_stateid)) { |
976 | /* Do we need to delay before resending? */ |
977 | if (!nfs4_stateid_is_newer(s1: &lo->plh_stateid, |
978 | s2: &data->args.errors[0].stateid)) |
979 | rpc_delay(task, HZ); |
980 | rpc_restart_call_prepare(task); |
981 | } |
982 | spin_unlock(lock: &inode->i_lock); |
983 | break; |
984 | case -ENOTSUPP: |
985 | case -EOPNOTSUPP: |
986 | NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTERROR; |
987 | } |
988 | |
989 | trace_nfs4_layouterror(inode, stateid: &data->args.errors[0].stateid, |
990 | error: task->tk_status); |
991 | } |
992 | |
993 | static void |
994 | nfs42_layouterror_release(void *calldata) |
995 | { |
996 | struct nfs42_layouterror_data *data = calldata; |
997 | |
998 | nfs42_free_layouterror_data(data); |
999 | } |
1000 | |
1001 | static const struct rpc_call_ops nfs42_layouterror_ops = { |
1002 | .rpc_call_prepare = nfs42_layouterror_prepare, |
1003 | .rpc_call_done = nfs42_layouterror_done, |
1004 | .rpc_release = nfs42_layouterror_release, |
1005 | }; |
1006 | |
1007 | int nfs42_proc_layouterror(struct pnfs_layout_segment *lseg, |
1008 | const struct nfs42_layout_error *errors, size_t n) |
1009 | { |
1010 | struct inode *inode = lseg->pls_layout->plh_inode; |
1011 | struct nfs42_layouterror_data *data; |
1012 | struct rpc_task *task; |
1013 | struct rpc_message msg = { |
1014 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTERROR], |
1015 | }; |
1016 | struct rpc_task_setup task_setup = { |
1017 | .rpc_message = &msg, |
1018 | .callback_ops = &nfs42_layouterror_ops, |
1019 | .flags = RPC_TASK_ASYNC, |
1020 | }; |
1021 | unsigned int i; |
1022 | |
1023 | if (!nfs_server_capable(inode, NFS_CAP_LAYOUTERROR)) |
1024 | return -EOPNOTSUPP; |
1025 | if (n > NFS42_LAYOUTERROR_MAX) |
1026 | return -EINVAL; |
1027 | data = nfs42_alloc_layouterror_data(lseg, gfp_flags: nfs_io_gfp_mask()); |
1028 | if (!data) |
1029 | return -ENOMEM; |
1030 | for (i = 0; i < n; i++) { |
1031 | data->args.errors[i] = errors[i]; |
1032 | data->args.num_errors++; |
1033 | data->res.num_errors++; |
1034 | } |
1035 | msg.rpc_argp = &data->args; |
1036 | msg.rpc_resp = &data->res; |
1037 | task_setup.callback_data = data; |
1038 | task_setup.rpc_client = NFS_SERVER(inode)->client; |
1039 | nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0); |
1040 | task = rpc_run_task(&task_setup); |
1041 | if (IS_ERR(ptr: task)) |
1042 | return PTR_ERR(ptr: task); |
1043 | rpc_put_task(task); |
1044 | return 0; |
1045 | } |
1046 | EXPORT_SYMBOL_GPL(nfs42_proc_layouterror); |
1047 | |
1048 | static int _nfs42_proc_clone(struct rpc_message *msg, struct file *src_f, |
1049 | struct file *dst_f, struct nfs_lock_context *src_lock, |
1050 | struct nfs_lock_context *dst_lock, loff_t src_offset, |
1051 | loff_t dst_offset, loff_t count) |
1052 | { |
1053 | struct inode *src_inode = file_inode(f: src_f); |
1054 | struct inode *dst_inode = file_inode(f: dst_f); |
1055 | struct nfs_server *server = NFS_SERVER(inode: dst_inode); |
1056 | __u32 dst_bitmask[NFS_BITMASK_SZ]; |
1057 | struct nfs42_clone_args args = { |
1058 | .src_fh = NFS_FH(inode: src_inode), |
1059 | .dst_fh = NFS_FH(inode: dst_inode), |
1060 | .src_offset = src_offset, |
1061 | .dst_offset = dst_offset, |
1062 | .count = count, |
1063 | .dst_bitmask = dst_bitmask, |
1064 | }; |
1065 | struct nfs42_clone_res res = { |
1066 | .server = server, |
1067 | }; |
1068 | int status; |
1069 | |
1070 | msg->rpc_argp = &args; |
1071 | msg->rpc_resp = &res; |
1072 | |
1073 | status = nfs4_set_rw_stateid(stateid: &args.src_stateid, ctx: src_lock->open_context, |
1074 | l_ctx: src_lock, FMODE_READ); |
1075 | if (status) { |
1076 | if (status == -EAGAIN) |
1077 | status = -NFS4ERR_BAD_STATEID; |
1078 | return status; |
1079 | } |
1080 | status = nfs4_set_rw_stateid(stateid: &args.dst_stateid, ctx: dst_lock->open_context, |
1081 | l_ctx: dst_lock, FMODE_WRITE); |
1082 | if (status) { |
1083 | if (status == -EAGAIN) |
1084 | status = -NFS4ERR_BAD_STATEID; |
1085 | return status; |
1086 | } |
1087 | |
1088 | res.dst_fattr = nfs_alloc_fattr(); |
1089 | if (!res.dst_fattr) |
1090 | return -ENOMEM; |
1091 | |
1092 | nfs4_bitmask_set(bitmask: dst_bitmask, src: server->cache_consistency_bitmask, |
1093 | inode: dst_inode, NFS_INO_INVALID_BLOCKS); |
1094 | |
1095 | status = nfs4_call_sync(server->client, server, msg, |
1096 | &args.seq_args, &res.seq_res, 0); |
1097 | trace_nfs4_clone(src_inode, dst_inode, args: &args, error: status); |
1098 | if (status == 0) { |
1099 | /* a zero-length count means clone to EOF in src */ |
1100 | if (count == 0 && res.dst_fattr->valid & NFS_ATTR_FATTR_SIZE) |
1101 | count = nfs_size_to_loff_t(size: res.dst_fattr->size) - dst_offset; |
1102 | nfs42_copy_dest_done(inode: dst_inode, pos: dst_offset, len: count); |
1103 | status = nfs_post_op_update_inode(inode: dst_inode, fattr: res.dst_fattr); |
1104 | } |
1105 | |
1106 | kfree(objp: res.dst_fattr); |
1107 | return status; |
1108 | } |
1109 | |
1110 | int nfs42_proc_clone(struct file *src_f, struct file *dst_f, |
1111 | loff_t src_offset, loff_t dst_offset, loff_t count) |
1112 | { |
1113 | struct rpc_message msg = { |
1114 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLONE], |
1115 | }; |
1116 | struct inode *inode = file_inode(f: src_f); |
1117 | struct nfs_server *server = NFS_SERVER(inode: file_inode(f: src_f)); |
1118 | struct nfs_lock_context *src_lock; |
1119 | struct nfs_lock_context *dst_lock; |
1120 | struct nfs4_exception src_exception = { }; |
1121 | struct nfs4_exception dst_exception = { }; |
1122 | int err, err2; |
1123 | |
1124 | if (!nfs_server_capable(inode, NFS_CAP_CLONE)) |
1125 | return -EOPNOTSUPP; |
1126 | |
1127 | src_lock = nfs_get_lock_context(ctx: nfs_file_open_context(filp: src_f)); |
1128 | if (IS_ERR(ptr: src_lock)) |
1129 | return PTR_ERR(ptr: src_lock); |
1130 | |
1131 | src_exception.inode = file_inode(f: src_f); |
1132 | src_exception.state = src_lock->open_context->state; |
1133 | |
1134 | dst_lock = nfs_get_lock_context(ctx: nfs_file_open_context(filp: dst_f)); |
1135 | if (IS_ERR(ptr: dst_lock)) { |
1136 | err = PTR_ERR(ptr: dst_lock); |
1137 | goto out_put_src_lock; |
1138 | } |
1139 | |
1140 | dst_exception.inode = file_inode(f: dst_f); |
1141 | dst_exception.state = dst_lock->open_context->state; |
1142 | |
1143 | do { |
1144 | err = _nfs42_proc_clone(msg: &msg, src_f, dst_f, src_lock, dst_lock, |
1145 | src_offset, dst_offset, count); |
1146 | if (err == -ENOTSUPP || err == -EOPNOTSUPP) { |
1147 | NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE; |
1148 | err = -EOPNOTSUPP; |
1149 | break; |
1150 | } |
1151 | |
1152 | err2 = nfs4_handle_exception(server, err, &src_exception); |
1153 | err = nfs4_handle_exception(server, err, &dst_exception); |
1154 | if (!err) |
1155 | err = err2; |
1156 | } while (src_exception.retry || dst_exception.retry); |
1157 | |
1158 | nfs_put_lock_context(l_ctx: dst_lock); |
1159 | out_put_src_lock: |
1160 | nfs_put_lock_context(l_ctx: src_lock); |
1161 | return err; |
1162 | } |
1163 | |
1164 | #define NFS4XATTR_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE) |
1165 | |
1166 | static int _nfs42_proc_removexattr(struct inode *inode, const char *name) |
1167 | { |
1168 | struct nfs_server *server = NFS_SERVER(inode); |
1169 | struct nfs42_removexattrargs args = { |
1170 | .fh = NFS_FH(inode), |
1171 | .xattr_name = name, |
1172 | }; |
1173 | struct nfs42_removexattrres res; |
1174 | struct rpc_message msg = { |
1175 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVEXATTR], |
1176 | .rpc_argp = &args, |
1177 | .rpc_resp = &res, |
1178 | }; |
1179 | int ret; |
1180 | unsigned long timestamp = jiffies; |
1181 | |
1182 | ret = nfs4_call_sync(server->client, server, &msg, &args.seq_args, |
1183 | &res.seq_res, 1); |
1184 | trace_nfs4_removexattr(inode, nfs4_removexattr: name, error: ret); |
1185 | if (!ret) |
1186 | nfs4_update_changeattr(dir: inode, cinfo: &res.cinfo, timestamp, cache_validity: 0); |
1187 | |
1188 | return ret; |
1189 | } |
1190 | |
1191 | static int _nfs42_proc_setxattr(struct inode *inode, const char *name, |
1192 | const void *buf, size_t buflen, int flags) |
1193 | { |
1194 | struct nfs_server *server = NFS_SERVER(inode); |
1195 | __u32 bitmask[NFS_BITMASK_SZ]; |
1196 | struct page *pages[NFS4XATTR_MAXPAGES]; |
1197 | struct nfs42_setxattrargs arg = { |
1198 | .fh = NFS_FH(inode), |
1199 | .bitmask = bitmask, |
1200 | .xattr_pages = pages, |
1201 | .xattr_len = buflen, |
1202 | .xattr_name = name, |
1203 | .xattr_flags = flags, |
1204 | }; |
1205 | struct nfs42_setxattrres res = { |
1206 | .server = server, |
1207 | }; |
1208 | struct rpc_message msg = { |
1209 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETXATTR], |
1210 | .rpc_argp = &arg, |
1211 | .rpc_resp = &res, |
1212 | }; |
1213 | int ret, np; |
1214 | unsigned long timestamp = jiffies; |
1215 | |
1216 | if (buflen > server->sxasize) |
1217 | return -ERANGE; |
1218 | |
1219 | res.fattr = nfs_alloc_fattr(); |
1220 | if (!res.fattr) |
1221 | return -ENOMEM; |
1222 | |
1223 | if (buflen > 0) { |
1224 | np = nfs4_buf_to_pages_noslab(buf, buflen, pages: arg.xattr_pages); |
1225 | if (np < 0) { |
1226 | ret = np; |
1227 | goto out; |
1228 | } |
1229 | } else |
1230 | np = 0; |
1231 | |
1232 | nfs4_bitmask_set(bitmask, src: server->cache_consistency_bitmask, |
1233 | inode, NFS_INO_INVALID_CHANGE); |
1234 | |
1235 | ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, |
1236 | &res.seq_res, 1); |
1237 | trace_nfs4_setxattr(inode, nfs4_setxattr: name, error: ret); |
1238 | |
1239 | for (; np > 0; np--) |
1240 | put_page(page: pages[np - 1]); |
1241 | |
1242 | if (!ret) { |
1243 | nfs4_update_changeattr(dir: inode, cinfo: &res.cinfo, timestamp, cache_validity: 0); |
1244 | ret = nfs_post_op_update_inode(inode, fattr: res.fattr); |
1245 | } |
1246 | |
1247 | out: |
1248 | kfree(objp: res.fattr); |
1249 | return ret; |
1250 | } |
1251 | |
1252 | static ssize_t _nfs42_proc_getxattr(struct inode *inode, const char *name, |
1253 | void *buf, size_t buflen, struct page **pages, |
1254 | size_t plen) |
1255 | { |
1256 | struct nfs_server *server = NFS_SERVER(inode); |
1257 | struct nfs42_getxattrargs arg = { |
1258 | .fh = NFS_FH(inode), |
1259 | .xattr_name = name, |
1260 | }; |
1261 | struct nfs42_getxattrres res; |
1262 | struct rpc_message msg = { |
1263 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETXATTR], |
1264 | .rpc_argp = &arg, |
1265 | .rpc_resp = &res, |
1266 | }; |
1267 | ssize_t ret; |
1268 | |
1269 | arg.xattr_len = plen; |
1270 | arg.xattr_pages = pages; |
1271 | |
1272 | ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, |
1273 | &res.seq_res, 0); |
1274 | trace_nfs4_getxattr(inode, nfs4_getxattr: name, error: ret); |
1275 | if (ret < 0) |
1276 | return ret; |
1277 | |
1278 | /* |
1279 | * Normally, the caching is done one layer up, but for successful |
1280 | * RPCS, always cache the result here, even if the caller was |
1281 | * just querying the length, or if the reply was too big for |
1282 | * the caller. This avoids a second RPC in the case of the |
1283 | * common query-alloc-retrieve cycle for xattrs. |
1284 | * |
1285 | * Note that xattr_len is always capped to XATTR_SIZE_MAX. |
1286 | */ |
1287 | |
1288 | nfs4_xattr_cache_add(inode, name, NULL, pages, buflen: res.xattr_len); |
1289 | |
1290 | if (buflen) { |
1291 | if (res.xattr_len > buflen) |
1292 | return -ERANGE; |
1293 | _copy_from_pages(p: buf, pages, pgbase: 0, len: res.xattr_len); |
1294 | } |
1295 | |
1296 | return res.xattr_len; |
1297 | } |
1298 | |
1299 | static ssize_t _nfs42_proc_listxattrs(struct inode *inode, void *buf, |
1300 | size_t buflen, u64 *cookiep, bool *eofp) |
1301 | { |
1302 | struct nfs_server *server = NFS_SERVER(inode); |
1303 | struct page **pages; |
1304 | struct nfs42_listxattrsargs arg = { |
1305 | .fh = NFS_FH(inode), |
1306 | .cookie = *cookiep, |
1307 | }; |
1308 | struct nfs42_listxattrsres res = { |
1309 | .eof = false, |
1310 | .xattr_buf = buf, |
1311 | .xattr_len = buflen, |
1312 | }; |
1313 | struct rpc_message msg = { |
1314 | .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LISTXATTRS], |
1315 | .rpc_argp = &arg, |
1316 | .rpc_resp = &res, |
1317 | }; |
1318 | u32 xdrlen; |
1319 | int ret, np, i; |
1320 | |
1321 | |
1322 | ret = -ENOMEM; |
1323 | res.scratch = alloc_page(GFP_KERNEL); |
1324 | if (!res.scratch) |
1325 | goto out; |
1326 | |
1327 | xdrlen = nfs42_listxattr_xdrsize(buflen); |
1328 | if (xdrlen > server->lxasize) |
1329 | xdrlen = server->lxasize; |
1330 | np = xdrlen / PAGE_SIZE + 1; |
1331 | |
1332 | pages = kcalloc(n: np, size: sizeof(struct page *), GFP_KERNEL); |
1333 | if (!pages) |
1334 | goto out_free_scratch; |
1335 | for (i = 0; i < np; i++) { |
1336 | pages[i] = alloc_page(GFP_KERNEL); |
1337 | if (!pages[i]) |
1338 | goto out_free_pages; |
1339 | } |
1340 | |
1341 | arg.xattr_pages = pages; |
1342 | arg.count = xdrlen; |
1343 | |
1344 | ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, |
1345 | &res.seq_res, 0); |
1346 | trace_nfs4_listxattr(inode, error: ret); |
1347 | |
1348 | if (ret >= 0) { |
1349 | ret = res.copied; |
1350 | *cookiep = res.cookie; |
1351 | *eofp = res.eof; |
1352 | } |
1353 | |
1354 | out_free_pages: |
1355 | while (--np >= 0) { |
1356 | if (pages[np]) |
1357 | __free_page(pages[np]); |
1358 | } |
1359 | kfree(objp: pages); |
1360 | out_free_scratch: |
1361 | __free_page(res.scratch); |
1362 | out: |
1363 | return ret; |
1364 | |
1365 | } |
1366 | |
1367 | ssize_t nfs42_proc_getxattr(struct inode *inode, const char *name, |
1368 | void *buf, size_t buflen) |
1369 | { |
1370 | struct nfs4_exception exception = { }; |
1371 | ssize_t err, np, i; |
1372 | struct page **pages; |
1373 | |
1374 | np = nfs_page_array_len(base: 0, len: buflen ?: XATTR_SIZE_MAX); |
1375 | pages = kmalloc_array(n: np, size: sizeof(*pages), GFP_KERNEL); |
1376 | if (!pages) |
1377 | return -ENOMEM; |
1378 | |
1379 | for (i = 0; i < np; i++) { |
1380 | pages[i] = alloc_page(GFP_KERNEL); |
1381 | if (!pages[i]) { |
1382 | err = -ENOMEM; |
1383 | goto out; |
1384 | } |
1385 | } |
1386 | |
1387 | /* |
1388 | * The GETXATTR op has no length field in the call, and the |
1389 | * xattr data is at the end of the reply. |
1390 | * |
1391 | * There is no downside in using the page-aligned length. It will |
1392 | * allow receiving and caching xattrs that are too large for the |
1393 | * caller but still fit in the page-rounded value. |
1394 | */ |
1395 | do { |
1396 | err = _nfs42_proc_getxattr(inode, name, buf, buflen, |
1397 | pages, plen: np * PAGE_SIZE); |
1398 | if (err >= 0) |
1399 | break; |
1400 | err = nfs4_handle_exception(NFS_SERVER(inode), err, |
1401 | &exception); |
1402 | } while (exception.retry); |
1403 | |
1404 | out: |
1405 | while (--i >= 0) |
1406 | __free_page(pages[i]); |
1407 | kfree(objp: pages); |
1408 | |
1409 | return err; |
1410 | } |
1411 | |
1412 | int nfs42_proc_setxattr(struct inode *inode, const char *name, |
1413 | const void *buf, size_t buflen, int flags) |
1414 | { |
1415 | struct nfs4_exception exception = { }; |
1416 | int err; |
1417 | |
1418 | do { |
1419 | err = _nfs42_proc_setxattr(inode, name, buf, buflen, flags); |
1420 | if (!err) |
1421 | break; |
1422 | err = nfs4_handle_exception(NFS_SERVER(inode), err, |
1423 | &exception); |
1424 | } while (exception.retry); |
1425 | |
1426 | return err; |
1427 | } |
1428 | |
1429 | ssize_t nfs42_proc_listxattrs(struct inode *inode, void *buf, |
1430 | size_t buflen, u64 *cookiep, bool *eofp) |
1431 | { |
1432 | struct nfs4_exception exception = { }; |
1433 | ssize_t err; |
1434 | |
1435 | do { |
1436 | err = _nfs42_proc_listxattrs(inode, buf, buflen, |
1437 | cookiep, eofp); |
1438 | if (err >= 0) |
1439 | break; |
1440 | err = nfs4_handle_exception(NFS_SERVER(inode), err, |
1441 | &exception); |
1442 | } while (exception.retry); |
1443 | |
1444 | return err; |
1445 | } |
1446 | |
1447 | int nfs42_proc_removexattr(struct inode *inode, const char *name) |
1448 | { |
1449 | struct nfs4_exception exception = { }; |
1450 | int err; |
1451 | |
1452 | do { |
1453 | err = _nfs42_proc_removexattr(inode, name); |
1454 | if (!err) |
1455 | break; |
1456 | err = nfs4_handle_exception(NFS_SERVER(inode), err, |
1457 | &exception); |
1458 | } while (exception.retry); |
1459 | |
1460 | return err; |
1461 | } |
1462 | |