1// SPDX-License-Identifier: GPL-2.0-or-later 2/* AFS filesystem file handling 3 * 4 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8#include <linux/kernel.h> 9#include <linux/module.h> 10#include <linux/init.h> 11#include <linux/fs.h> 12#include <linux/pagemap.h> 13#include <linux/writeback.h> 14#include <linux/gfp.h> 15#include <linux/task_io_accounting_ops.h> 16#include <linux/mm.h> 17#include <linux/swap.h> 18#include <linux/netfs.h> 19#include "internal.h" 20 21static int afs_file_mmap(struct file *file, struct vm_area_struct *vma); 22static int afs_symlink_read_folio(struct file *file, struct folio *folio); 23 24static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter); 25static ssize_t afs_file_splice_read(struct file *in, loff_t *ppos, 26 struct pipe_inode_info *pipe, 27 size_t len, unsigned int flags); 28static void afs_vm_open(struct vm_area_struct *area); 29static void afs_vm_close(struct vm_area_struct *area); 30static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgoff_t end_pgoff); 31 32const struct file_operations afs_file_operations = { 33 .open = afs_open, 34 .release = afs_release, 35 .llseek = generic_file_llseek, 36 .read_iter = afs_file_read_iter, 37 .write_iter = netfs_file_write_iter, 38 .mmap = afs_file_mmap, 39 .splice_read = afs_file_splice_read, 40 .splice_write = iter_file_splice_write, 41 .fsync = afs_fsync, 42 .lock = afs_lock, 43 .flock = afs_flock, 44}; 45 46const struct inode_operations afs_file_inode_operations = { 47 .getattr = afs_getattr, 48 .setattr = afs_setattr, 49 .permission = afs_permission, 50}; 51 52const struct address_space_operations afs_file_aops = { 53 .direct_IO = noop_direct_IO, 54 .read_folio = netfs_read_folio, 55 .readahead = netfs_readahead, 56 .dirty_folio = netfs_dirty_folio, 57 .launder_folio = netfs_launder_folio, 58 .release_folio = netfs_release_folio, 59 .invalidate_folio = netfs_invalidate_folio, 60 .migrate_folio = filemap_migrate_folio, 61 .writepages = afs_writepages, 62}; 63 64const struct address_space_operations afs_symlink_aops = { 65 .read_folio = afs_symlink_read_folio, 66 .release_folio = netfs_release_folio, 67 .invalidate_folio = netfs_invalidate_folio, 68 .migrate_folio = filemap_migrate_folio, 69}; 70 71static const struct vm_operations_struct afs_vm_ops = { 72 .open = afs_vm_open, 73 .close = afs_vm_close, 74 .fault = filemap_fault, 75 .map_pages = afs_vm_map_pages, 76 .page_mkwrite = afs_page_mkwrite, 77}; 78 79/* 80 * Discard a pin on a writeback key. 81 */ 82void afs_put_wb_key(struct afs_wb_key *wbk) 83{ 84 if (wbk && refcount_dec_and_test(&wbk->usage)) { 85 key_put(wbk->key); 86 kfree(wbk); 87 } 88} 89 90/* 91 * Cache key for writeback. 92 */ 93int afs_cache_wb_key(struct afs_vnode *vnode, struct afs_file *af) 94{ 95 struct afs_wb_key *wbk, *p; 96 97 wbk = kzalloc(sizeof(struct afs_wb_key), GFP_KERNEL); 98 if (!wbk) 99 return -ENOMEM; 100 refcount_set(&wbk->usage, 2); 101 wbk->key = af->key; 102 103 spin_lock(&vnode->wb_lock); 104 list_for_each_entry(p, &vnode->wb_keys, vnode_link) { 105 if (p->key == wbk->key) 106 goto found; 107 } 108 109 key_get(wbk->key); 110 list_add_tail(&wbk->vnode_link, &vnode->wb_keys); 111 spin_unlock(&vnode->wb_lock); 112 af->wb = wbk; 113 return 0; 114 115found: 116 refcount_inc(&p->usage); 117 spin_unlock(&vnode->wb_lock); 118 af->wb = p; 119 kfree(wbk); 120 return 0; 121} 122 123/* 124 * open an AFS file or directory and attach a key to it 125 */ 126int afs_open(struct inode *inode, struct file *file) 127{ 128 struct afs_vnode *vnode = AFS_FS_I(inode); 129 struct afs_file *af; 130 struct key *key; 131 int ret; 132 133 _enter("{%llx:%llu},", vnode->fid.vid, vnode->fid.vnode); 134 135 key = afs_request_key(vnode->volume->cell); 136 if (IS_ERR(key)) { 137 ret = PTR_ERR(key); 138 goto error; 139 } 140 141 af = kzalloc(sizeof(*af), GFP_KERNEL); 142 if (!af) { 143 ret = -ENOMEM; 144 goto error_key; 145 } 146 af->key = key; 147 148 ret = afs_validate(vnode, key); 149 if (ret < 0) 150 goto error_af; 151 152 if (file->f_mode & FMODE_WRITE) { 153 ret = afs_cache_wb_key(vnode, af); 154 if (ret < 0) 155 goto error_af; 156 } 157 158 if (file->f_flags & O_TRUNC) 159 set_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags); 160 161 fscache_use_cookie(afs_vnode_cache(vnode), file->f_mode & FMODE_WRITE); 162 163 file->private_data = af; 164 _leave(" = 0"); 165 return 0; 166 167error_af: 168 kfree(af); 169error_key: 170 key_put(key); 171error: 172 _leave(" = %d", ret); 173 return ret; 174} 175 176/* 177 * release an AFS file or directory and discard its key 178 */ 179int afs_release(struct inode *inode, struct file *file) 180{ 181 struct afs_vnode_cache_aux aux; 182 struct afs_vnode *vnode = AFS_FS_I(inode); 183 struct afs_file *af = file->private_data; 184 loff_t i_size; 185 int ret = 0; 186 187 _enter("{%llx:%llu},", vnode->fid.vid, vnode->fid.vnode); 188 189 if ((file->f_mode & FMODE_WRITE)) 190 ret = vfs_fsync(file, 0); 191 192 file->private_data = NULL; 193 if (af->wb) 194 afs_put_wb_key(af->wb); 195 196 if ((file->f_mode & FMODE_WRITE)) { 197 i_size = i_size_read(&vnode->netfs.inode); 198 afs_set_cache_aux(vnode, &aux); 199 fscache_unuse_cookie(afs_vnode_cache(vnode), &aux, &i_size); 200 } else { 201 fscache_unuse_cookie(afs_vnode_cache(vnode), NULL, NULL); 202 } 203 204 key_put(af->key); 205 kfree(af); 206 afs_prune_wb_keys(vnode); 207 _leave(" = %d", ret); 208 return ret; 209} 210 211/* 212 * Allocate a new read record. 213 */ 214struct afs_read *afs_alloc_read(gfp_t gfp) 215{ 216 struct afs_read *req; 217 218 req = kzalloc(sizeof(struct afs_read), gfp); 219 if (req) 220 refcount_set(&req->usage, 1); 221 222 return req; 223} 224 225/* 226 * Dispose of a ref to a read record. 227 */ 228void afs_put_read(struct afs_read *req) 229{ 230 if (refcount_dec_and_test(&req->usage)) { 231 if (req->cleanup) 232 req->cleanup(req); 233 key_put(req->key); 234 kfree(req); 235 } 236} 237 238static void afs_fetch_data_notify(struct afs_operation *op) 239{ 240 struct afs_read *req = op->fetch.req; 241 struct netfs_io_subrequest *subreq = req->subreq; 242 int error = afs_op_error(op); 243 244 req->error = error; 245 if (subreq) { 246 __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags); 247 netfs_subreq_terminated(subreq, error ?: req->actual_len, false); 248 req->subreq = NULL; 249 } else if (req->done) { 250 req->done(req); 251 } 252} 253 254static void afs_fetch_data_success(struct afs_operation *op) 255{ 256 struct afs_vnode *vnode = op->file[0].vnode; 257 258 _enter("op=%08x", op->debug_id); 259 afs_vnode_commit_status(op, &op->file[0]); 260 afs_stat_v(vnode, n_fetches); 261 atomic_long_add(op->fetch.req->actual_len, &op->net->n_fetch_bytes); 262 afs_fetch_data_notify(op); 263} 264 265static void afs_fetch_data_put(struct afs_operation *op) 266{ 267 op->fetch.req->error = afs_op_error(op); 268 afs_put_read(op->fetch.req); 269} 270 271static const struct afs_operation_ops afs_fetch_data_operation = { 272 .issue_afs_rpc = afs_fs_fetch_data, 273 .issue_yfs_rpc = yfs_fs_fetch_data, 274 .success = afs_fetch_data_success, 275 .aborted = afs_check_for_remote_deletion, 276 .failed = afs_fetch_data_notify, 277 .put = afs_fetch_data_put, 278}; 279 280/* 281 * Fetch file data from the volume. 282 */ 283int afs_fetch_data(struct afs_vnode *vnode, struct afs_read *req) 284{ 285 struct afs_operation *op; 286 287 _enter("%s{%llx:%llu.%u},%x,,,", 288 vnode->volume->name, 289 vnode->fid.vid, 290 vnode->fid.vnode, 291 vnode->fid.unique, 292 key_serial(req->key)); 293 294 op = afs_alloc_operation(req->key, vnode->volume); 295 if (IS_ERR(op)) { 296 if (req->subreq) 297 netfs_subreq_terminated(req->subreq, PTR_ERR(op), false); 298 return PTR_ERR(op); 299 } 300 301 afs_op_set_vnode(op, 0, vnode); 302 303 op->fetch.req = afs_get_read(req); 304 op->ops = &afs_fetch_data_operation; 305 return afs_do_sync_operation(op); 306} 307 308static void afs_issue_read(struct netfs_io_subrequest *subreq) 309{ 310 struct afs_vnode *vnode = AFS_FS_I(subreq->rreq->inode); 311 struct afs_read *fsreq; 312 313 fsreq = afs_alloc_read(GFP_NOFS); 314 if (!fsreq) 315 return netfs_subreq_terminated(subreq, -ENOMEM, false); 316 317 fsreq->subreq = subreq; 318 fsreq->pos = subreq->start + subreq->transferred; 319 fsreq->len = subreq->len - subreq->transferred; 320 fsreq->key = key_get(subreq->rreq->netfs_priv); 321 fsreq->vnode = vnode; 322 fsreq->iter = &subreq->io_iter; 323 324 afs_fetch_data(fsreq->vnode, fsreq); 325 afs_put_read(fsreq); 326} 327 328static int afs_symlink_read_folio(struct file *file, struct folio *folio) 329{ 330 struct afs_vnode *vnode = AFS_FS_I(folio->mapping->host); 331 struct afs_read *fsreq; 332 int ret; 333 334 fsreq = afs_alloc_read(GFP_NOFS); 335 if (!fsreq) 336 return -ENOMEM; 337 338 fsreq->pos = folio_pos(folio); 339 fsreq->len = folio_size(folio); 340 fsreq->vnode = vnode; 341 fsreq->iter = &fsreq->def_iter; 342 iov_iter_xarray(&fsreq->def_iter, ITER_DEST, &folio->mapping->i_pages, 343 fsreq->pos, fsreq->len); 344 345 ret = afs_fetch_data(fsreq->vnode, fsreq); 346 if (ret == 0) 347 folio_mark_uptodate(folio); 348 folio_unlock(folio); 349 return ret; 350} 351 352static int afs_init_request(struct netfs_io_request *rreq, struct file *file) 353{ 354 if (file) 355 rreq->netfs_priv = key_get(afs_file_key(file)); 356 rreq->rsize = 256 * 1024; 357 rreq->wsize = 256 * 1024; 358 return 0; 359} 360 361static int afs_check_write_begin(struct file *file, loff_t pos, unsigned len, 362 struct folio **foliop, void **_fsdata) 363{ 364 struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 365 366 return test_bit(AFS_VNODE_DELETED, &vnode->flags) ? -ESTALE : 0; 367} 368 369static void afs_free_request(struct netfs_io_request *rreq) 370{ 371 key_put(rreq->netfs_priv); 372} 373 374static void afs_update_i_size(struct inode *inode, loff_t new_i_size) 375{ 376 struct afs_vnode *vnode = AFS_FS_I(inode); 377 loff_t i_size; 378 379 write_seqlock(&vnode->cb_lock); 380 i_size = i_size_read(&vnode->netfs.inode); 381 if (new_i_size > i_size) { 382 i_size_write(&vnode->netfs.inode, new_i_size); 383 inode_set_bytes(&vnode->netfs.inode, new_i_size); 384 } 385 write_sequnlock(&vnode->cb_lock); 386 fscache_update_cookie(afs_vnode_cache(vnode), NULL, &new_i_size); 387} 388 389static void afs_netfs_invalidate_cache(struct netfs_io_request *wreq) 390{ 391 struct afs_vnode *vnode = AFS_FS_I(wreq->inode); 392 393 afs_invalidate_cache(vnode, 0); 394} 395 396const struct netfs_request_ops afs_req_ops = { 397 .init_request = afs_init_request, 398 .free_request = afs_free_request, 399 .check_write_begin = afs_check_write_begin, 400 .issue_read = afs_issue_read, 401 .update_i_size = afs_update_i_size, 402 .invalidate_cache = afs_netfs_invalidate_cache, 403 .create_write_requests = afs_create_write_requests, 404}; 405 406static void afs_add_open_mmap(struct afs_vnode *vnode) 407{ 408 if (atomic_inc_return(&vnode->cb_nr_mmap) == 1) { 409 down_write(&vnode->volume->open_mmaps_lock); 410 411 if (list_empty(&vnode->cb_mmap_link)) 412 list_add_tail(&vnode->cb_mmap_link, &vnode->volume->open_mmaps); 413 414 up_write(&vnode->volume->open_mmaps_lock); 415 } 416} 417 418static void afs_drop_open_mmap(struct afs_vnode *vnode) 419{ 420 if (atomic_add_unless(&vnode->cb_nr_mmap, -1, 1)) 421 return; 422 423 down_write(&vnode->volume->open_mmaps_lock); 424 425 read_seqlock_excl(&vnode->cb_lock); 426 // the only place where ->cb_nr_mmap may hit 0 427 // see __afs_break_callback() for the other side... 428 if (atomic_dec_and_test(&vnode->cb_nr_mmap)) 429 list_del_init(&vnode->cb_mmap_link); 430 read_sequnlock_excl(&vnode->cb_lock); 431 432 up_write(&vnode->volume->open_mmaps_lock); 433 flush_work(&vnode->cb_work); 434} 435 436/* 437 * Handle setting up a memory mapping on an AFS file. 438 */ 439static int afs_file_mmap(struct file *file, struct vm_area_struct *vma) 440{ 441 struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 442 int ret; 443 444 afs_add_open_mmap(vnode); 445 446 ret = generic_file_mmap(file, vma); 447 if (ret == 0) 448 vma->vm_ops = &afs_vm_ops; 449 else 450 afs_drop_open_mmap(vnode); 451 return ret; 452} 453 454static void afs_vm_open(struct vm_area_struct *vma) 455{ 456 afs_add_open_mmap(AFS_FS_I(file_inode(vma->vm_file))); 457} 458 459static void afs_vm_close(struct vm_area_struct *vma) 460{ 461 afs_drop_open_mmap(AFS_FS_I(file_inode(vma->vm_file))); 462} 463 464static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgoff_t end_pgoff) 465{ 466 struct afs_vnode *vnode = AFS_FS_I(file_inode(vmf->vma->vm_file)); 467 468 if (afs_check_validity(vnode)) 469 return filemap_map_pages(vmf, start_pgoff, end_pgoff); 470 return 0; 471} 472 473static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) 474{ 475 struct inode *inode = file_inode(iocb->ki_filp); 476 struct afs_vnode *vnode = AFS_FS_I(inode); 477 struct afs_file *af = iocb->ki_filp->private_data; 478 ssize_t ret; 479 480 if (iocb->ki_flags & IOCB_DIRECT) 481 return netfs_unbuffered_read_iter(iocb, iter); 482 483 ret = netfs_start_io_read(inode); 484 if (ret < 0) 485 return ret; 486 ret = afs_validate(vnode, af->key); 487 if (ret == 0) 488 ret = filemap_read(iocb, iter, 0); 489 netfs_end_io_read(inode); 490 return ret; 491} 492 493static ssize_t afs_file_splice_read(struct file *in, loff_t *ppos, 494 struct pipe_inode_info *pipe, 495 size_t len, unsigned int flags) 496{ 497 struct inode *inode = file_inode(in); 498 struct afs_vnode *vnode = AFS_FS_I(inode); 499 struct afs_file *af = in->private_data; 500 ssize_t ret; 501 502 ret = netfs_start_io_read(inode); 503 if (ret < 0) 504 return ret; 505 ret = afs_validate(vnode, af->key); 506 if (ret == 0) 507 ret = filemap_splice_read(in, ppos, pipe, len, flags); 508 netfs_end_io_read(inode); 509 return ret; 510} 511