1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* AFS filesystem file handling
4 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/init.h>
12 #include <linux/pagemap.h>
13 #include <linux/writeback.h>
14 #include <linux/gfp.h>
15 #include <linux/task_io_accounting_ops.h>
17 #include <linux/swap.h>
18 #include <linux/netfs.h>
21 static int afs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
);
22 static int afs_symlink_read_folio(struct file
*file
, struct folio
*folio
);
23 static void afs_invalidate_folio(struct folio
*folio
, size_t offset
,
25 static bool afs_release_folio(struct folio
*folio
, gfp_t gfp_flags
);
27 static ssize_t
afs_file_read_iter(struct kiocb
*iocb
, struct iov_iter
*iter
);
28 static ssize_t
afs_file_splice_read(struct file
*in
, loff_t
*ppos
,
29 struct pipe_inode_info
*pipe
,
30 size_t len
, unsigned int flags
);
31 static void afs_vm_open(struct vm_area_struct
*area
);
32 static void afs_vm_close(struct vm_area_struct
*area
);
33 static vm_fault_t
afs_vm_map_pages(struct vm_fault
*vmf
, pgoff_t start_pgoff
, pgoff_t end_pgoff
);
35 const struct file_operations afs_file_operations
= {
37 .release
= afs_release
,
38 .llseek
= generic_file_llseek
,
39 .read_iter
= afs_file_read_iter
,
40 .write_iter
= afs_file_write
,
41 .mmap
= afs_file_mmap
,
42 .splice_read
= afs_file_splice_read
,
43 .splice_write
= iter_file_splice_write
,
49 const struct inode_operations afs_file_inode_operations
= {
50 .getattr
= afs_getattr
,
51 .setattr
= afs_setattr
,
52 .permission
= afs_permission
,
55 const struct address_space_operations afs_file_aops
= {
56 .read_folio
= netfs_read_folio
,
57 .readahead
= netfs_readahead
,
58 .dirty_folio
= afs_dirty_folio
,
59 .launder_folio
= afs_launder_folio
,
60 .release_folio
= afs_release_folio
,
61 .invalidate_folio
= afs_invalidate_folio
,
62 .write_begin
= afs_write_begin
,
63 .write_end
= afs_write_end
,
64 .writepages
= afs_writepages
,
65 .migrate_folio
= filemap_migrate_folio
,
68 const struct address_space_operations afs_symlink_aops
= {
69 .read_folio
= afs_symlink_read_folio
,
70 .release_folio
= afs_release_folio
,
71 .invalidate_folio
= afs_invalidate_folio
,
72 .migrate_folio
= filemap_migrate_folio
,
75 static const struct vm_operations_struct afs_vm_ops
= {
77 .close
= afs_vm_close
,
78 .fault
= filemap_fault
,
79 .map_pages
= afs_vm_map_pages
,
80 .page_mkwrite
= afs_page_mkwrite
,
84 * Discard a pin on a writeback key.
86 void afs_put_wb_key(struct afs_wb_key
*wbk
)
88 if (wbk
&& refcount_dec_and_test(&wbk
->usage
)) {
95 * Cache key for writeback.
97 int afs_cache_wb_key(struct afs_vnode
*vnode
, struct afs_file
*af
)
99 struct afs_wb_key
*wbk
, *p
;
101 wbk
= kzalloc(sizeof(struct afs_wb_key
), GFP_KERNEL
);
104 refcount_set(&wbk
->usage
, 2);
107 spin_lock(&vnode
->wb_lock
);
108 list_for_each_entry(p
, &vnode
->wb_keys
, vnode_link
) {
109 if (p
->key
== wbk
->key
)
114 list_add_tail(&wbk
->vnode_link
, &vnode
->wb_keys
);
115 spin_unlock(&vnode
->wb_lock
);
120 refcount_inc(&p
->usage
);
121 spin_unlock(&vnode
->wb_lock
);
128 * open an AFS file or directory and attach a key to it
130 int afs_open(struct inode
*inode
, struct file
*file
)
132 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
137 _enter("{%llx:%llu},", vnode
->fid
.vid
, vnode
->fid
.vnode
);
139 key
= afs_request_key(vnode
->volume
->cell
);
145 af
= kzalloc(sizeof(*af
), GFP_KERNEL
);
152 ret
= afs_validate(vnode
, key
);
156 if (file
->f_mode
& FMODE_WRITE
) {
157 ret
= afs_cache_wb_key(vnode
, af
);
162 if (file
->f_flags
& O_TRUNC
)
163 set_bit(AFS_VNODE_NEW_CONTENT
, &vnode
->flags
);
165 fscache_use_cookie(afs_vnode_cache(vnode
), file
->f_mode
& FMODE_WRITE
);
167 file
->private_data
= af
;
176 _leave(" = %d", ret
);
181 * release an AFS file or directory and discard its key
183 int afs_release(struct inode
*inode
, struct file
*file
)
185 struct afs_vnode_cache_aux aux
;
186 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
187 struct afs_file
*af
= file
->private_data
;
191 _enter("{%llx:%llu},", vnode
->fid
.vid
, vnode
->fid
.vnode
);
193 if ((file
->f_mode
& FMODE_WRITE
))
194 ret
= vfs_fsync(file
, 0);
196 file
->private_data
= NULL
;
198 afs_put_wb_key(af
->wb
);
200 if ((file
->f_mode
& FMODE_WRITE
)) {
201 i_size
= i_size_read(&vnode
->netfs
.inode
);
202 afs_set_cache_aux(vnode
, &aux
);
203 fscache_unuse_cookie(afs_vnode_cache(vnode
), &aux
, &i_size
);
205 fscache_unuse_cookie(afs_vnode_cache(vnode
), NULL
, NULL
);
210 afs_prune_wb_keys(vnode
);
211 _leave(" = %d", ret
);
216 * Allocate a new read record.
218 struct afs_read
*afs_alloc_read(gfp_t gfp
)
220 struct afs_read
*req
;
222 req
= kzalloc(sizeof(struct afs_read
), gfp
);
224 refcount_set(&req
->usage
, 1);
230 * Dispose of a ref to a read record.
232 void afs_put_read(struct afs_read
*req
)
234 if (refcount_dec_and_test(&req
->usage
)) {
242 static void afs_fetch_data_notify(struct afs_operation
*op
)
244 struct afs_read
*req
= op
->fetch
.req
;
245 struct netfs_io_subrequest
*subreq
= req
->subreq
;
246 int error
= afs_op_error(op
);
250 __set_bit(NETFS_SREQ_CLEAR_TAIL
, &subreq
->flags
);
251 netfs_subreq_terminated(subreq
, error
?: req
->actual_len
, false);
253 } else if (req
->done
) {
258 static void afs_fetch_data_success(struct afs_operation
*op
)
260 struct afs_vnode
*vnode
= op
->file
[0].vnode
;
262 _enter("op=%08x", op
->debug_id
);
263 afs_vnode_commit_status(op
, &op
->file
[0]);
264 afs_stat_v(vnode
, n_fetches
);
265 atomic_long_add(op
->fetch
.req
->actual_len
, &op
->net
->n_fetch_bytes
);
266 afs_fetch_data_notify(op
);
269 static void afs_fetch_data_put(struct afs_operation
*op
)
271 op
->fetch
.req
->error
= afs_op_error(op
);
272 afs_put_read(op
->fetch
.req
);
275 static const struct afs_operation_ops afs_fetch_data_operation
= {
276 .issue_afs_rpc
= afs_fs_fetch_data
,
277 .issue_yfs_rpc
= yfs_fs_fetch_data
,
278 .success
= afs_fetch_data_success
,
279 .aborted
= afs_check_for_remote_deletion
,
280 .failed
= afs_fetch_data_notify
,
281 .put
= afs_fetch_data_put
,
285 * Fetch file data from the volume.
287 int afs_fetch_data(struct afs_vnode
*vnode
, struct afs_read
*req
)
289 struct afs_operation
*op
;
291 _enter("%s{%llx:%llu.%u},%x,,,",
296 key_serial(req
->key
));
298 op
= afs_alloc_operation(req
->key
, vnode
->volume
);
301 netfs_subreq_terminated(req
->subreq
, PTR_ERR(op
), false);
305 afs_op_set_vnode(op
, 0, vnode
);
307 op
->fetch
.req
= afs_get_read(req
);
308 op
->ops
= &afs_fetch_data_operation
;
309 return afs_do_sync_operation(op
);
312 static void afs_issue_read(struct netfs_io_subrequest
*subreq
)
314 struct afs_vnode
*vnode
= AFS_FS_I(subreq
->rreq
->inode
);
315 struct afs_read
*fsreq
;
317 fsreq
= afs_alloc_read(GFP_NOFS
);
319 return netfs_subreq_terminated(subreq
, -ENOMEM
, false);
321 fsreq
->subreq
= subreq
;
322 fsreq
->pos
= subreq
->start
+ subreq
->transferred
;
323 fsreq
->len
= subreq
->len
- subreq
->transferred
;
324 fsreq
->key
= key_get(subreq
->rreq
->netfs_priv
);
325 fsreq
->vnode
= vnode
;
326 fsreq
->iter
= &fsreq
->def_iter
;
328 iov_iter_xarray(&fsreq
->def_iter
, ITER_DEST
,
329 &fsreq
->vnode
->netfs
.inode
.i_mapping
->i_pages
,
330 fsreq
->pos
, fsreq
->len
);
332 afs_fetch_data(fsreq
->vnode
, fsreq
);
336 static int afs_symlink_read_folio(struct file
*file
, struct folio
*folio
)
338 struct afs_vnode
*vnode
= AFS_FS_I(folio
->mapping
->host
);
339 struct afs_read
*fsreq
;
342 fsreq
= afs_alloc_read(GFP_NOFS
);
346 fsreq
->pos
= folio_pos(folio
);
347 fsreq
->len
= folio_size(folio
);
348 fsreq
->vnode
= vnode
;
349 fsreq
->iter
= &fsreq
->def_iter
;
350 iov_iter_xarray(&fsreq
->def_iter
, ITER_DEST
, &folio
->mapping
->i_pages
,
351 fsreq
->pos
, fsreq
->len
);
353 ret
= afs_fetch_data(fsreq
->vnode
, fsreq
);
355 folio_mark_uptodate(folio
);
360 static int afs_init_request(struct netfs_io_request
*rreq
, struct file
*file
)
362 rreq
->netfs_priv
= key_get(afs_file_key(file
));
366 static int afs_begin_cache_operation(struct netfs_io_request
*rreq
)
368 #ifdef CONFIG_AFS_FSCACHE
369 struct afs_vnode
*vnode
= AFS_FS_I(rreq
->inode
);
371 return fscache_begin_read_operation(&rreq
->cache_resources
,
372 afs_vnode_cache(vnode
));
378 static int afs_check_write_begin(struct file
*file
, loff_t pos
, unsigned len
,
379 struct folio
**foliop
, void **_fsdata
)
381 struct afs_vnode
*vnode
= AFS_FS_I(file_inode(file
));
383 return test_bit(AFS_VNODE_DELETED
, &vnode
->flags
) ? -ESTALE
: 0;
386 static void afs_free_request(struct netfs_io_request
*rreq
)
388 key_put(rreq
->netfs_priv
);
391 const struct netfs_request_ops afs_req_ops
= {
392 .init_request
= afs_init_request
,
393 .free_request
= afs_free_request
,
394 .begin_cache_operation
= afs_begin_cache_operation
,
395 .check_write_begin
= afs_check_write_begin
,
396 .issue_read
= afs_issue_read
,
399 int afs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
401 fscache_unpin_writeback(wbc
, afs_vnode_cache(AFS_FS_I(inode
)));
406 * Adjust the dirty region of the page on truncation or full invalidation,
407 * getting rid of the markers altogether if the region is entirely invalidated.
409 static void afs_invalidate_dirty(struct folio
*folio
, size_t offset
,
412 struct afs_vnode
*vnode
= AFS_FS_I(folio_inode(folio
));
414 unsigned int f
, t
, end
= offset
+ length
;
416 priv
= (unsigned long)folio_get_private(folio
);
418 /* we clean up only if the entire page is being invalidated */
419 if (offset
== 0 && length
== folio_size(folio
))
420 goto full_invalidate
;
422 /* If the page was dirtied by page_mkwrite(), the PTE stays writable
423 * and we don't get another notification to tell us to expand it
426 if (afs_is_folio_dirty_mmapped(priv
))
429 /* We may need to shorten the dirty region */
430 f
= afs_folio_dirty_from(folio
, priv
);
431 t
= afs_folio_dirty_to(folio
, priv
);
433 if (t
<= offset
|| f
>= end
)
434 return; /* Doesn't overlap */
436 if (f
< offset
&& t
> end
)
437 return; /* Splits the dirty region - just absorb it */
439 if (f
>= offset
&& t
<= end
)
449 priv
= afs_folio_dirty(folio
, f
, t
);
450 folio_change_private(folio
, (void *)priv
);
451 trace_afs_folio_dirty(vnode
, tracepoint_string("trunc"), folio
);
455 trace_afs_folio_dirty(vnode
, tracepoint_string("undirty"), folio
);
456 folio_clear_dirty_for_io(folio
);
458 trace_afs_folio_dirty(vnode
, tracepoint_string("inval"), folio
);
459 folio_detach_private(folio
);
463 * invalidate part or all of a page
464 * - release a page and clean up its private data if offset is 0 (indicating
467 static void afs_invalidate_folio(struct folio
*folio
, size_t offset
,
470 _enter("{%lu},%zu,%zu", folio
->index
, offset
, length
);
472 BUG_ON(!folio_test_locked(folio
));
474 if (folio_get_private(folio
))
475 afs_invalidate_dirty(folio
, offset
, length
);
477 folio_wait_fscache(folio
);
482 * release a page and clean up its private state if it's not busy
483 * - return true if the page can now be released, false if not
485 static bool afs_release_folio(struct folio
*folio
, gfp_t gfp
)
487 struct afs_vnode
*vnode
= AFS_FS_I(folio_inode(folio
));
489 _enter("{{%llx:%llu}[%lu],%lx},%x",
490 vnode
->fid
.vid
, vnode
->fid
.vnode
, folio_index(folio
), folio
->flags
,
493 /* deny if folio is being written to the cache and the caller hasn't
495 #ifdef CONFIG_AFS_FSCACHE
496 if (folio_test_fscache(folio
)) {
497 if (current_is_kswapd() || !(gfp
& __GFP_FS
))
499 folio_wait_fscache(folio
);
501 fscache_note_page_release(afs_vnode_cache(vnode
));
504 if (folio_test_private(folio
)) {
505 trace_afs_folio_dirty(vnode
, tracepoint_string("rel"), folio
);
506 folio_detach_private(folio
);
509 /* Indicate that the folio can be released */
514 static void afs_add_open_mmap(struct afs_vnode
*vnode
)
516 if (atomic_inc_return(&vnode
->cb_nr_mmap
) == 1) {
517 down_write(&vnode
->volume
->open_mmaps_lock
);
519 if (list_empty(&vnode
->cb_mmap_link
))
520 list_add_tail(&vnode
->cb_mmap_link
, &vnode
->volume
->open_mmaps
);
522 up_write(&vnode
->volume
->open_mmaps_lock
);
526 static void afs_drop_open_mmap(struct afs_vnode
*vnode
)
528 if (!atomic_dec_and_test(&vnode
->cb_nr_mmap
))
531 down_write(&vnode
->volume
->open_mmaps_lock
);
533 if (atomic_read(&vnode
->cb_nr_mmap
) == 0)
534 list_del_init(&vnode
->cb_mmap_link
);
536 up_write(&vnode
->volume
->open_mmaps_lock
);
537 flush_work(&vnode
->cb_work
);
541 * Handle setting up a memory mapping on an AFS file.
543 static int afs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
545 struct afs_vnode
*vnode
= AFS_FS_I(file_inode(file
));
548 afs_add_open_mmap(vnode
);
550 ret
= generic_file_mmap(file
, vma
);
552 vma
->vm_ops
= &afs_vm_ops
;
554 afs_drop_open_mmap(vnode
);
558 static void afs_vm_open(struct vm_area_struct
*vma
)
560 afs_add_open_mmap(AFS_FS_I(file_inode(vma
->vm_file
)));
563 static void afs_vm_close(struct vm_area_struct
*vma
)
565 afs_drop_open_mmap(AFS_FS_I(file_inode(vma
->vm_file
)));
568 static vm_fault_t
afs_vm_map_pages(struct vm_fault
*vmf
, pgoff_t start_pgoff
, pgoff_t end_pgoff
)
570 struct afs_vnode
*vnode
= AFS_FS_I(file_inode(vmf
->vma
->vm_file
));
572 if (afs_check_validity(vnode
))
573 return filemap_map_pages(vmf
, start_pgoff
, end_pgoff
);
577 static ssize_t
afs_file_read_iter(struct kiocb
*iocb
, struct iov_iter
*iter
)
579 struct afs_vnode
*vnode
= AFS_FS_I(file_inode(iocb
->ki_filp
));
580 struct afs_file
*af
= iocb
->ki_filp
->private_data
;
583 ret
= afs_validate(vnode
, af
->key
);
587 return generic_file_read_iter(iocb
, iter
);
590 static ssize_t
afs_file_splice_read(struct file
*in
, loff_t
*ppos
,
591 struct pipe_inode_info
*pipe
,
592 size_t len
, unsigned int flags
)
594 struct afs_vnode
*vnode
= AFS_FS_I(file_inode(in
));
595 struct afs_file
*af
= in
->private_data
;
598 ret
= afs_validate(vnode
, af
->key
);
602 return filemap_splice_read(in
, ppos
, pipe
, len
, flags
);