531 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/* AFS filesystem file handling3 *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 22static int afs_file_mmap(struct file *file, struct vm_area_struct *vma);23static int afs_symlink_read_folio(struct file *file, struct folio *folio);24 25static ssize_t afs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter);26static 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);29static void afs_vm_open(struct vm_area_struct *area);30static void afs_vm_close(struct vm_area_struct *area);31static vm_fault_t afs_vm_map_pages(struct vm_fault *vmf, pgoff_t start_pgoff, pgoff_t end_pgoff);32 33const 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 47const struct inode_operations afs_file_inode_operations = {48 .getattr = afs_getattr,49 .setattr = afs_setattr,50 .permission = afs_permission,51};52 53const 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 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 it125 */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 key178 */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 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 256static 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 267static 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 273static 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 279static 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 */291int 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 316static 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 338static 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 344static 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 368static 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 377static 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 385static 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 391static 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 406static 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 413const 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 426static 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 438static 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 0447 // 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 */459static 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 else470 afs_drop_open_mmap(vnode);471 return ret;472}473 474static 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 479static 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 484static 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 493static 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 513static 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