| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * (C) 2001 Clemson University and The University of Chicago |
| * Copyright 2018 Omnibond Systems, L.L.C. |
| * |
| * See COPYING in top-level directory. |
| */ |
| |
| /* |
| * Linux VFS inode operations. |
| */ |
| |
| #include <linux/bvec.h> |
| #include "protocol.h" |
| #include "orangefs-kernel.h" |
| #include "orangefs-bufmap.h" |
| |
| static int orangefs_writepage(struct page *page, struct writeback_control *wbc) |
| { |
| struct inode *inode = page->mapping->host; |
| struct iov_iter iter; |
| struct bio_vec bv; |
| size_t len, wlen; |
| ssize_t ret; |
| loff_t off; |
| |
| set_page_writeback(page); |
| |
| off = page_offset(page); |
| len = i_size_read(inode); |
| if (off > len) { |
| /* The file was truncated; there is nothing to write. */ |
| unlock_page(page); |
| end_page_writeback(page); |
| return 0; |
| } |
| if (off + PAGE_SIZE > len) |
| wlen = len - off; |
| else |
| wlen = PAGE_SIZE; |
| |
| bv.bv_page = page; |
| bv.bv_len = wlen; |
| bv.bv_offset = off % PAGE_SIZE; |
| if (wlen == 0) |
| dump_stack(); |
| iov_iter_bvec(&iter, WRITE, &bv, 1, wlen); |
| |
| ret = wait_for_direct_io(ORANGEFS_IO_WRITE, inode, &off, &iter, wlen, |
| len); |
| if (ret < 0) { |
| SetPageError(page); |
| mapping_set_error(page->mapping, ret); |
| } else { |
| ret = 0; |
| } |
| unlock_page(page); |
| end_page_writeback(page); |
| return ret; |
| } |
| |
| static int orangefs_readpage(struct file *file, struct page *page) |
| { |
| struct inode *inode = page->mapping->host; |
| struct iov_iter iter; |
| struct bio_vec bv; |
| ssize_t ret; |
| loff_t off; |
| |
| off = page_offset(page); |
| bv.bv_page = page; |
| bv.bv_len = PAGE_SIZE; |
| bv.bv_offset = 0; |
| iov_iter_bvec(&iter, READ, &bv, 1, PAGE_SIZE); |
| |
| ret = wait_for_direct_io(ORANGEFS_IO_READ, inode, &off, &iter, |
| PAGE_SIZE, inode->i_size); |
| /* this will only zero remaining unread portions of the page data */ |
| iov_iter_zero(~0U, &iter); |
| /* takes care of potential aliasing */ |
| flush_dcache_page(page); |
| if (ret < 0) { |
| SetPageError(page); |
| } else { |
| SetPageUptodate(page); |
| if (PageError(page)) |
| ClearPageError(page); |
| ret = 0; |
| } |
| /* unlock the page after the ->readpage() routine completes */ |
| unlock_page(page); |
| return ret; |
| } |
| |
| static int orangefs_write_end(struct file *file, struct address_space *mapping, |
| loff_t pos, unsigned len, unsigned copied, struct page *page, void *fsdata) |
| { |
| int r; |
| r = simple_write_end(file, mapping, pos, len, copied, page, fsdata); |
| mark_inode_dirty_sync(file_inode(file)); |
| return r; |
| } |
| |
| static void orangefs_invalidatepage(struct page *page, |
| unsigned int offset, |
| unsigned int length) |
| { |
| gossip_debug(GOSSIP_INODE_DEBUG, |
| "orangefs_invalidatepage called on page %p " |
| "(offset is %u)\n", |
| page, |
| offset); |
| |
| ClearPageUptodate(page); |
| ClearPageMappedToDisk(page); |
| return; |
| |
| } |
| |
| static int orangefs_releasepage(struct page *page, gfp_t foo) |
| { |
| gossip_debug(GOSSIP_INODE_DEBUG, |
| "orangefs_releasepage called on page %p\n", |
| page); |
| return 0; |
| } |
| |
| static ssize_t orangefs_direct_IO(struct kiocb *iocb, |
| struct iov_iter *iter) |
| { |
| struct file *file = iocb->ki_filp; |
| loff_t pos = *(&iocb->ki_pos); |
| return do_readv_writev(iov_iter_rw(iter) == WRITE ? |
| ORANGEFS_IO_WRITE : ORANGEFS_IO_READ, file, &pos, iter); |
| } |
| |
| /** ORANGEFS2 implementation of address space operations */ |
| static const struct address_space_operations orangefs_address_operations = { |
| .writepage = orangefs_writepage, |
| .readpage = orangefs_readpage, |
| .set_page_dirty = __set_page_dirty_nobuffers, |
| .write_begin = simple_write_begin, |
| .write_end = orangefs_write_end, |
| .invalidatepage = orangefs_invalidatepage, |
| .releasepage = orangefs_releasepage, |
| .direct_IO = orangefs_direct_IO, |
| }; |
| |
| static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr) |
| { |
| struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); |
| struct orangefs_kernel_op_s *new_op; |
| loff_t orig_size; |
| int ret = -EINVAL; |
| |
| gossip_debug(GOSSIP_INODE_DEBUG, |
| "%s: %pU: Handle is %pU | fs_id %d | size is %llu\n", |
| __func__, |
| get_khandle_from_ino(inode), |
| &orangefs_inode->refn.khandle, |
| orangefs_inode->refn.fs_id, |
| iattr->ia_size); |
| |
| /* Ensure that we have a up to date size, so we know if it changed. */ |
| ret = orangefs_inode_getattr(inode, ORANGEFS_GETATTR_SIZE); |
| if (ret == -ESTALE) |
| ret = -EIO; |
| if (ret) { |
| gossip_err("%s: orangefs_inode_getattr failed, ret:%d:.\n", |
| __func__, ret); |
| return ret; |
| } |
| orig_size = i_size_read(inode); |
| |
| truncate_setsize(inode, iattr->ia_size); |
| |
| new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE); |
| if (!new_op) |
| return -ENOMEM; |
| |
| new_op->upcall.req.truncate.refn = orangefs_inode->refn; |
| new_op->upcall.req.truncate.size = (__s64) iattr->ia_size; |
| |
| ret = service_operation(new_op, |
| __func__, |
| get_interruptible_flag(inode)); |
| |
| /* |
| * the truncate has no downcall members to retrieve, but |
| * the status value tells us if it went through ok or not |
| */ |
| gossip_debug(GOSSIP_INODE_DEBUG, "%s: ret:%d:\n", __func__, ret); |
| |
| op_release(new_op); |
| |
| if (ret != 0) |
| return ret; |
| |
| if (orig_size != i_size_read(inode)) |
| iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME; |
| |
| return ret; |
| } |
| |
| int __orangefs_setattr(struct inode *inode, struct iattr *iattr) |
| { |
| int ret; |
| |
| if (iattr->ia_valid & ATTR_MODE) { |
| if (iattr->ia_mode & (S_ISVTX)) { |
| if (is_root_handle(inode)) { |
| /* |
| * allow sticky bit to be set on root (since |
| * it shows up that way by default anyhow), |
| * but don't show it to the server |
| */ |
| iattr->ia_mode -= S_ISVTX; |
| } else { |
| gossip_debug(GOSSIP_UTILS_DEBUG, |
| "User attempted to set sticky bit on non-root directory; returning EINVAL.\n"); |
| return -EINVAL; |
| } |
| } |
| if (iattr->ia_mode & (S_ISUID)) { |
| gossip_debug(GOSSIP_UTILS_DEBUG, |
| "Attempting to set setuid bit (not supported); returning EINVAL.\n"); |
| return -EINVAL; |
| } |
| } |
| |
| if (iattr->ia_valid & ATTR_SIZE) { |
| ret = orangefs_setattr_size(inode, iattr); |
| if (ret) |
| goto out; |
| } |
| |
| again: |
| spin_lock(&inode->i_lock); |
| if (ORANGEFS_I(inode)->attr_valid) { |
| if (uid_eq(ORANGEFS_I(inode)->attr_uid, current_fsuid()) && |
| gid_eq(ORANGEFS_I(inode)->attr_gid, current_fsgid())) { |
| ORANGEFS_I(inode)->attr_valid = iattr->ia_valid; |
| } else { |
| spin_unlock(&inode->i_lock); |
| write_inode_now(inode, 1); |
| goto again; |
| } |
| } else { |
| ORANGEFS_I(inode)->attr_valid = iattr->ia_valid; |
| ORANGEFS_I(inode)->attr_uid = current_fsuid(); |
| ORANGEFS_I(inode)->attr_gid = current_fsgid(); |
| } |
| setattr_copy(inode, iattr); |
| spin_unlock(&inode->i_lock); |
| mark_inode_dirty(inode); |
| |
| if (iattr->ia_valid & ATTR_MODE) |
| /* change mod on a file that has ACLs */ |
| ret = posix_acl_chmod(inode, inode->i_mode); |
| |
| ret = 0; |
| out: |
| return ret; |
| } |
| |
| /* |
| * Change attributes of an object referenced by dentry. |
| */ |
| int orangefs_setattr(struct dentry *dentry, struct iattr *iattr) |
| { |
| int ret; |
| gossip_debug(GOSSIP_INODE_DEBUG, "__orangefs_setattr: called on %pd\n", |
| dentry); |
| ret = setattr_prepare(dentry, iattr); |
| if (ret) |
| goto out; |
| ret = __orangefs_setattr(d_inode(dentry), iattr); |
| sync_inode_metadata(d_inode(dentry), 1); |
| out: |
| gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n", |
| ret); |
| return ret; |
| } |
| |
| /* |
| * Obtain attributes of an object given a dentry |
| */ |
| int orangefs_getattr(const struct path *path, struct kstat *stat, |
| u32 request_mask, unsigned int flags) |
| { |
| int ret = -ENOENT; |
| struct inode *inode = path->dentry->d_inode; |
| |
| gossip_debug(GOSSIP_INODE_DEBUG, |
| "orangefs_getattr: called on %pd mask %u\n", |
| path->dentry, request_mask); |
| |
| ret = orangefs_inode_getattr(inode, |
| request_mask & STATX_SIZE ? ORANGEFS_GETATTR_SIZE : 0); |
| if (ret == 0) { |
| generic_fillattr(inode, stat); |
| |
| /* override block size reported to stat */ |
| if (!(request_mask & STATX_SIZE)) |
| stat->result_mask &= ~STATX_SIZE; |
| |
| stat->attributes_mask = STATX_ATTR_IMMUTABLE | |
| STATX_ATTR_APPEND; |
| if (inode->i_flags & S_IMMUTABLE) |
| stat->attributes |= STATX_ATTR_IMMUTABLE; |
| if (inode->i_flags & S_APPEND) |
| stat->attributes |= STATX_ATTR_APPEND; |
| } |
| return ret; |
| } |
| |
| int orangefs_permission(struct inode *inode, int mask) |
| { |
| int ret; |
| |
| if (mask & MAY_NOT_BLOCK) |
| return -ECHILD; |
| |
| gossip_debug(GOSSIP_INODE_DEBUG, "%s: refreshing\n", __func__); |
| |
| /* Make sure the permission (and other common attrs) are up to date. */ |
| ret = orangefs_inode_getattr(inode, 0); |
| if (ret < 0) |
| return ret; |
| |
| return generic_permission(inode, mask); |
| } |
| |
| int orangefs_update_time(struct inode *inode, struct timespec64 *time, int flags) |
| { |
| struct iattr iattr; |
| gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_update_time: %pU\n", |
| get_khandle_from_ino(inode)); |
| generic_update_time(inode, time, flags); |
| memset(&iattr, 0, sizeof iattr); |
| if (flags & S_ATIME) |
| iattr.ia_valid |= ATTR_ATIME; |
| if (flags & S_CTIME) |
| iattr.ia_valid |= ATTR_CTIME; |
| if (flags & S_MTIME) |
| iattr.ia_valid |= ATTR_MTIME; |
| return __orangefs_setattr(inode, &iattr); |
| } |
| |
| /* ORANGEFS2 implementation of VFS inode operations for files */ |
| static const struct inode_operations orangefs_file_inode_operations = { |
| .get_acl = orangefs_get_acl, |
| .set_acl = orangefs_set_acl, |
| .setattr = orangefs_setattr, |
| .getattr = orangefs_getattr, |
| .listxattr = orangefs_listxattr, |
| .permission = orangefs_permission, |
| .update_time = orangefs_update_time, |
| }; |
| |
| static int orangefs_init_iops(struct inode *inode) |
| { |
| inode->i_mapping->a_ops = &orangefs_address_operations; |
| |
| switch (inode->i_mode & S_IFMT) { |
| case S_IFREG: |
| inode->i_op = &orangefs_file_inode_operations; |
| inode->i_fop = &orangefs_file_operations; |
| break; |
| case S_IFLNK: |
| inode->i_op = &orangefs_symlink_inode_operations; |
| break; |
| case S_IFDIR: |
| inode->i_op = &orangefs_dir_inode_operations; |
| inode->i_fop = &orangefs_dir_operations; |
| break; |
| default: |
| gossip_debug(GOSSIP_INODE_DEBUG, |
| "%s: unsupported mode\n", |
| __func__); |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * Given an ORANGEFS object identifier (fsid, handle), convert it into |
| * a ino_t type that will be used as a hash-index from where the handle will |
| * be searched for in the VFS hash table of inodes. |
| */ |
| static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref) |
| { |
| if (!ref) |
| return 0; |
| return orangefs_khandle_to_ino(&(ref->khandle)); |
| } |
| |
| /* |
| * Called to set up an inode from iget5_locked. |
| */ |
| static int orangefs_set_inode(struct inode *inode, void *data) |
| { |
| struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data; |
| ORANGEFS_I(inode)->refn.fs_id = ref->fs_id; |
| ORANGEFS_I(inode)->refn.khandle = ref->khandle; |
| ORANGEFS_I(inode)->attr_valid = 0; |
| hash_init(ORANGEFS_I(inode)->xattr_cache); |
| return 0; |
| } |
| |
| /* |
| * Called to determine if handles match. |
| */ |
| static int orangefs_test_inode(struct inode *inode, void *data) |
| { |
| struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data; |
| struct orangefs_inode_s *orangefs_inode = NULL; |
| |
| orangefs_inode = ORANGEFS_I(inode); |
| /* test handles and fs_ids... */ |
| return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle), |
| &(ref->khandle)) && |
| orangefs_inode->refn.fs_id == ref->fs_id); |
| } |
| |
| /* |
| * Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS |
| * file handle. |
| * |
| * @sb: the file system super block instance. |
| * @ref: The ORANGEFS object for which we are trying to locate an inode. |
| */ |
| struct inode *orangefs_iget(struct super_block *sb, |
| struct orangefs_object_kref *ref) |
| { |
| struct inode *inode = NULL; |
| unsigned long hash; |
| int error; |
| |
| hash = orangefs_handle_hash(ref); |
| inode = iget5_locked(sb, |
| hash, |
| orangefs_test_inode, |
| orangefs_set_inode, |
| ref); |
| |
| if (!inode) |
| return ERR_PTR(-ENOMEM); |
| |
| if (!(inode->i_state & I_NEW)) |
| return inode; |
| |
| error = orangefs_inode_getattr(inode, ORANGEFS_GETATTR_NEW); |
| if (error) { |
| iget_failed(inode); |
| return ERR_PTR(error); |
| } |
| |
| inode->i_ino = hash; /* needed for stat etc */ |
| orangefs_init_iops(inode); |
| unlock_new_inode(inode); |
| |
| gossip_debug(GOSSIP_INODE_DEBUG, |
| "iget handle %pU, fsid %d hash %ld i_ino %lu\n", |
| &ref->khandle, |
| ref->fs_id, |
| hash, |
| inode->i_ino); |
| |
| return inode; |
| } |
| |
| /* |
| * Allocate an inode for a newly created file and insert it into the inode hash. |
| */ |
| struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir, |
| int mode, dev_t dev, struct orangefs_object_kref *ref) |
| { |
| unsigned long hash = orangefs_handle_hash(ref); |
| struct inode *inode; |
| int error; |
| |
| gossip_debug(GOSSIP_INODE_DEBUG, |
| "%s:(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n", |
| __func__, |
| sb, |
| MAJOR(dev), |
| MINOR(dev), |
| mode); |
| |
| inode = new_inode(sb); |
| if (!inode) |
| return ERR_PTR(-ENOMEM); |
| |
| orangefs_set_inode(inode, ref); |
| inode->i_ino = hash; /* needed for stat etc */ |
| |
| error = orangefs_inode_getattr(inode, ORANGEFS_GETATTR_NEW); |
| if (error) |
| goto out_iput; |
| |
| orangefs_init_iops(inode); |
| inode->i_rdev = dev; |
| |
| error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref); |
| if (error < 0) |
| goto out_iput; |
| |
| gossip_debug(GOSSIP_INODE_DEBUG, |
| "Initializing ACL's for inode %pU\n", |
| get_khandle_from_ino(inode)); |
| orangefs_init_acl(inode, dir); |
| return inode; |
| |
| out_iput: |
| iput(inode); |
| return ERR_PTR(error); |
| } |