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 <trace/events/netfs.h> 20 #include "internal.h" 21 22 static int afs_file_mmap(struct file *file, struct vm_area_struct *vma); 23 static int afs_symlink_read_folio(struct file *file, struct folio *folio); 24 25 static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter); 26 static ssize_t afs_file_splice_read(struct file *in, loff_t *ppos, 27 struct pipe_inode_info *pipe, 28 size_t len, unsigned int flags); 29 static void afs_vm_open(struct vm_area_struct *area); 30 static void afs_vm_close(struct vm_area_struct *area); 31 static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgoff_t end_pgoff); 32 33 const struct file_operations afs_file_operations = { 34 .open = afs_open, 35 .release = afs_release, 36 .llseek = generic_file_llseek, 37 .read_iter = afs_file_read_iter, 38 .write_iter = netfs_file_write_iter, 39 .mmap = afs_file_mmap, 40 .splice_read = afs_file_splice_read, 41 .splice_write = iter_file_splice_write, 42 .fsync = afs_fsync, 43 .lock = afs_lock, 44 .flock = afs_flock, 45 }; 46 47 const struct inode_operations afs_file_inode_operations = { 48 .getattr = afs_getattr, 49 .setattr = afs_setattr, 50 .permission = afs_permission, 51 }; 52 53 const struct address_space_operations afs_file_aops = { 54 .direct_IO = noop_direct_IO, 55 .read_folio = netfs_read_folio, 56 .readahead = netfs_readahead, 57 .dirty_folio = netfs_dirty_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 64 const 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 71 static 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 */ 82 void 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 */ 93 int 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 115 found: 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 */ 126 int 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 167 error_af: 168 kfree(af); 169 error_key: 170 key_put(key); 171 error: 172 _leave(" = %d", ret); 173 return ret; 174 } 175 176 /* 177 * release an AFS file or directory and discard its key 178 */ 179 int 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 */ 214 struct 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 */ 228 void 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 238 static 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 subreq->rreq->i_size = req->file_size; 247 if (req->pos + req->actual_len >= req->file_size) 248 __set_bit(NETFS_SREQ_HIT_EOF, &subreq->flags); 249 netfs_read_subreq_terminated(subreq, error, false); 250 req->subreq = NULL; 251 } else if (req->done) { 252 req->done(req); 253 } 254 } 255 256 static void afs_fetch_data_success(struct afs_operation *op) 257 { 258 struct afs_vnode *vnode = op->file[0].vnode; 259 260 _enter("op=%08x", op->debug_id); 261 afs_vnode_commit_status(op, &op->file[0]); 262 afs_stat_v(vnode, n_fetches); 263 atomic_long_add(op->fetch.req->actual_len, &op->net->n_fetch_bytes); 264 afs_fetch_data_notify(op); 265 } 266 267 static void afs_fetch_data_aborted(struct afs_operation *op) 268 { 269 afs_check_for_remote_deletion(op); 270 afs_fetch_data_notify(op); 271 } 272 273 static void afs_fetch_data_put(struct afs_operation *op) 274 { 275 op->fetch.req->error = afs_op_error(op); 276 afs_put_read(op->fetch.req); 277 } 278 279 static const struct afs_operation_ops afs_fetch_data_operation = { 280 .issue_afs_rpc = afs_fs_fetch_data, 281 .issue_yfs_rpc = yfs_fs_fetch_data, 282 .success = afs_fetch_data_success, 283 .aborted = afs_fetch_data_aborted, 284 .failed = afs_fetch_data_notify, 285 .put = afs_fetch_data_put, 286 }; 287 288 /* 289 * Fetch file data from the volume. 290 */ 291 int afs_fetch_data(struct afs_vnode *vnode, struct afs_read *req) 292 { 293 struct afs_operation *op; 294 295 _enter("%s{%llx:%llu.%u},%x,,,", 296 vnode->volume->name, 297 vnode->fid.vid, 298 vnode->fid.vnode, 299 vnode->fid.unique, 300 key_serial(req->key)); 301 302 op = afs_alloc_operation(req->key, vnode->volume); 303 if (IS_ERR(op)) { 304 if (req->subreq) 305 netfs_read_subreq_terminated(req->subreq, PTR_ERR(op), false); 306 return PTR_ERR(op); 307 } 308 309 afs_op_set_vnode(op, 0, vnode); 310 311 op->fetch.req = afs_get_read(req); 312 op->ops = &afs_fetch_data_operation; 313 return afs_do_sync_operation(op); 314 } 315 316 static void afs_read_worker(struct work_struct *work) 317 { 318 struct netfs_io_subrequest *subreq = container_of(work, struct netfs_io_subrequest, work); 319 struct afs_vnode *vnode = AFS_FS_I(subreq->rreq->inode); 320 struct afs_read *fsreq; 321 322 fsreq = afs_alloc_read(GFP_NOFS); 323 if (!fsreq) 324 return netfs_read_subreq_terminated(subreq, -ENOMEM, false); 325 326 fsreq->subreq = subreq; 327 fsreq->pos = subreq->start + subreq->transferred; 328 fsreq->len = subreq->len - subreq->transferred; 329 fsreq->key = key_get(subreq->rreq->netfs_priv); 330 fsreq->vnode = vnode; 331 fsreq->iter = &subreq->io_iter; 332 333 trace_netfs_sreq(subreq, netfs_sreq_trace_submit); 334 afs_fetch_data(fsreq->vnode, fsreq); 335 afs_put_read(fsreq); 336 } 337 338 static void afs_issue_read(struct netfs_io_subrequest *subreq) 339 { 340 INIT_WORK(&subreq->work, afs_read_worker); 341 queue_work(system_long_wq, &subreq->work); 342 } 343 344 static int afs_symlink_read_folio(struct file *file, struct folio *folio) 345 { 346 struct afs_vnode *vnode = AFS_FS_I(folio->mapping->host); 347 struct afs_read *fsreq; 348 int ret; 349 350 fsreq = afs_alloc_read(GFP_NOFS); 351 if (!fsreq) 352 return -ENOMEM; 353 354 fsreq->pos = folio_pos(folio); 355 fsreq->len = folio_size(folio); 356 fsreq->vnode = vnode; 357 fsreq->iter = &fsreq->def_iter; 358 iov_iter_xarray(&fsreq->def_iter, ITER_DEST, &folio->mapping->i_pages, 359 fsreq->pos, fsreq->len); 360 361 ret = afs_fetch_data(fsreq->vnode, fsreq); 362 if (ret == 0) 363 folio_mark_uptodate(folio); 364 folio_unlock(folio); 365 return ret; 366 } 367 368 static int afs_init_request(struct netfs_io_request *rreq, struct file *file) 369 { 370 if (file) 371 rreq->netfs_priv = key_get(afs_file_key(file)); 372 rreq->rsize = 256 * 1024; 373 rreq->wsize = 256 * 1024 * 1024; 374 return 0; 375 } 376 377 static int afs_check_write_begin(struct file *file, loff_t pos, unsigned len, 378 struct folio **foliop, void **_fsdata) 379 { 380 struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 381 382 return test_bit(AFS_VNODE_DELETED, &vnode->flags) ? -ESTALE : 0; 383 } 384 385 static void afs_free_request(struct netfs_io_request *rreq) 386 { 387 key_put(rreq->netfs_priv); 388 afs_put_wb_key(rreq->netfs_priv2); 389 } 390 391 static void afs_update_i_size(struct inode *inode, loff_t new_i_size) 392 { 393 struct afs_vnode *vnode = AFS_FS_I(inode); 394 loff_t i_size; 395 396 write_seqlock(&vnode->cb_lock); 397 i_size = i_size_read(&vnode->netfs.inode); 398 if (new_i_size > i_size) { 399 i_size_write(&vnode->netfs.inode, new_i_size); 400 inode_set_bytes(&vnode->netfs.inode, new_i_size); 401 } 402 write_sequnlock(&vnode->cb_lock); 403 fscache_update_cookie(afs_vnode_cache(vnode), NULL, &new_i_size); 404 } 405 406 static void afs_netfs_invalidate_cache(struct netfs_io_request *wreq) 407 { 408 struct afs_vnode *vnode = AFS_FS_I(wreq->inode); 409 410 afs_invalidate_cache(vnode, 0); 411 } 412 413 const struct netfs_request_ops afs_req_ops = { 414 .init_request = afs_init_request, 415 .free_request = afs_free_request, 416 .check_write_begin = afs_check_write_begin, 417 .issue_read = afs_issue_read, 418 .update_i_size = afs_update_i_size, 419 .invalidate_cache = afs_netfs_invalidate_cache, 420 .begin_writeback = afs_begin_writeback, 421 .prepare_write = afs_prepare_write, 422 .issue_write = afs_issue_write, 423 .retry_request = afs_retry_request, 424 }; 425 426 static void afs_add_open_mmap(struct afs_vnode *vnode) 427 { 428 if (atomic_inc_return(&vnode->cb_nr_mmap) == 1) { 429 down_write(&vnode->volume->open_mmaps_lock); 430 431 if (list_empty(&vnode->cb_mmap_link)) 432 list_add_tail(&vnode->cb_mmap_link, &vnode->volume->open_mmaps); 433 434 up_write(&vnode->volume->open_mmaps_lock); 435 } 436 } 437 438 static void afs_drop_open_mmap(struct afs_vnode *vnode) 439 { 440 if (atomic_add_unless(&vnode->cb_nr_mmap, -1, 1)) 441 return; 442 443 down_write(&vnode->volume->open_mmaps_lock); 444 445 read_seqlock_excl(&vnode->cb_lock); 446 // the only place where ->cb_nr_mmap may hit 0 447 // see __afs_break_callback() for the other side... 448 if (atomic_dec_and_test(&vnode->cb_nr_mmap)) 449 list_del_init(&vnode->cb_mmap_link); 450 read_sequnlock_excl(&vnode->cb_lock); 451 452 up_write(&vnode->volume->open_mmaps_lock); 453 flush_work(&vnode->cb_work); 454 } 455 456 /* 457 * Handle setting up a memory mapping on an AFS file. 458 */ 459 static int afs_file_mmap(struct file *file, struct vm_area_struct *vma) 460 { 461 struct afs_vnode *vnode = AFS_FS_I(file_inode(file)); 462 int ret; 463 464 afs_add_open_mmap(vnode); 465 466 ret = generic_file_mmap(file, vma); 467 if (ret == 0) 468 vma->vm_ops = &afs_vm_ops; 469 else 470 afs_drop_open_mmap(vnode); 471 return ret; 472 } 473 474 static void afs_vm_open(struct vm_area_struct *vma) 475 { 476 afs_add_open_mmap(AFS_FS_I(file_inode(vma->vm_file))); 477 } 478 479 static void afs_vm_close(struct vm_area_struct *vma) 480 { 481 afs_drop_open_mmap(AFS_FS_I(file_inode(vma->vm_file))); 482 } 483 484 static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgoff_t end_pgoff) 485 { 486 struct afs_vnode *vnode = AFS_FS_I(file_inode(vmf->vma->vm_file)); 487 488 if (afs_check_validity(vnode)) 489 return filemap_map_pages(vmf, start_pgoff, end_pgoff); 490 return 0; 491 } 492 493 static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) 494 { 495 struct inode *inode = file_inode(iocb->ki_filp); 496 struct afs_vnode *vnode = AFS_FS_I(inode); 497 struct afs_file *af = iocb->ki_filp->private_data; 498 ssize_t ret; 499 500 if (iocb->ki_flags & IOCB_DIRECT) 501 return netfs_unbuffered_read_iter(iocb, iter); 502 503 ret = netfs_start_io_read(inode); 504 if (ret < 0) 505 return ret; 506 ret = afs_validate(vnode, af->key); 507 if (ret == 0) 508 ret = filemap_read(iocb, iter, 0); 509 netfs_end_io_read(inode); 510 return ret; 511 } 512 513 static ssize_t afs_file_splice_read(struct file *in, loff_t *ppos, 514 struct pipe_inode_info *pipe, 515 size_t len, unsigned int flags) 516 { 517 struct inode *inode = file_inode(in); 518 struct afs_vnode *vnode = AFS_FS_I(inode); 519 struct afs_file *af = in->private_data; 520 ssize_t ret; 521 522 ret = netfs_start_io_read(inode); 523 if (ret < 0) 524 return ret; 525 ret = afs_validate(vnode, af->key); 526 if (ret == 0) 527 ret = filemap_splice_read(in, ppos, pipe, len, flags); 528 netfs_end_io_read(inode); 529 return ret; 530 } 531