312 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 *4 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>5 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>6 */7 8#include <linux/kernel.h>9#include <linux/module.h>10#include <linux/errno.h>11#include <linux/fs.h>12#include <linux/file.h>13#include <linux/stat.h>14#include <linux/string.h>15#include <linux/pagemap.h>16#include <linux/mount.h>17#include <linux/sched.h>18#include <linux/slab.h>19#include <linux/statfs.h>20#include <linux/magic.h>21#include <linux/fscache.h>22#include <net/9p/9p.h>23#include <net/9p/client.h>24 25#include "v9fs.h"26#include "v9fs_vfs.h"27#include "fid.h"28#include "xattr.h"29#include "acl.h"30 31static const struct super_operations v9fs_super_ops, v9fs_super_ops_dotl;32 33/**34 * v9fs_set_super - set the superblock35 * @s: super block36 * @data: file system specific data37 *38 */39 40static int v9fs_set_super(struct super_block *s, void *data)41{42 s->s_fs_info = data;43 return set_anon_super(s, data);44}45 46/**47 * v9fs_fill_super - populate superblock with info48 * @sb: superblock49 * @v9ses: session information50 * @flags: flags propagated from v9fs_mount()51 *52 */53 54static int55v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses,56 int flags)57{58 int ret;59 60 sb->s_maxbytes = MAX_LFS_FILESIZE;61 sb->s_blocksize_bits = fls(v9ses->maxdata - 1);62 sb->s_blocksize = 1 << sb->s_blocksize_bits;63 sb->s_magic = V9FS_MAGIC;64 if (v9fs_proto_dotl(v9ses)) {65 sb->s_op = &v9fs_super_ops_dotl;66 if (!(v9ses->flags & V9FS_NO_XATTR))67 sb->s_xattr = v9fs_xattr_handlers;68 } else {69 sb->s_op = &v9fs_super_ops;70 sb->s_time_max = U32_MAX;71 }72 73 sb->s_time_min = 0;74 75 ret = super_setup_bdi(sb);76 if (ret)77 return ret;78 79 if (!v9ses->cache) {80 sb->s_bdi->ra_pages = 0;81 sb->s_bdi->io_pages = 0;82 } else {83 sb->s_bdi->ra_pages = v9ses->maxdata >> PAGE_SHIFT;84 sb->s_bdi->io_pages = v9ses->maxdata >> PAGE_SHIFT;85 }86 87 sb->s_flags |= SB_ACTIVE;88 89#ifdef CONFIG_9P_FS_POSIX_ACL90 if ((v9ses->flags & V9FS_ACL_MASK) == V9FS_POSIX_ACL)91 sb->s_flags |= SB_POSIXACL;92#endif93 94 return 0;95}96 97/**98 * v9fs_mount - mount a superblock99 * @fs_type: file system type100 * @flags: mount flags101 * @dev_name: device name that was mounted102 * @data: mount options103 *104 */105 106static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,107 const char *dev_name, void *data)108{109 struct super_block *sb = NULL;110 struct inode *inode = NULL;111 struct dentry *root = NULL;112 struct v9fs_session_info *v9ses = NULL;113 struct p9_fid *fid;114 int retval = 0;115 116 p9_debug(P9_DEBUG_VFS, "\n");117 118 v9ses = kzalloc(sizeof(struct v9fs_session_info), GFP_KERNEL);119 if (!v9ses)120 return ERR_PTR(-ENOMEM);121 122 fid = v9fs_session_init(v9ses, dev_name, data);123 if (IS_ERR(fid)) {124 retval = PTR_ERR(fid);125 goto free_session;126 }127 128 sb = sget(fs_type, NULL, v9fs_set_super, flags, v9ses);129 if (IS_ERR(sb)) {130 retval = PTR_ERR(sb);131 goto clunk_fid;132 }133 retval = v9fs_fill_super(sb, v9ses, flags);134 if (retval)135 goto release_sb;136 137 if (v9ses->cache & (CACHE_META|CACHE_LOOSE))138 sb->s_d_op = &v9fs_cached_dentry_operations;139 else140 sb->s_d_op = &v9fs_dentry_operations;141 142 inode = v9fs_get_new_inode_from_fid(v9ses, fid, sb);143 if (IS_ERR(inode)) {144 retval = PTR_ERR(inode);145 goto release_sb;146 }147 148 root = d_make_root(inode);149 if (!root) {150 retval = -ENOMEM;151 goto release_sb;152 }153 sb->s_root = root;154 retval = v9fs_get_acl(inode, fid);155 if (retval)156 goto release_sb;157 v9fs_fid_add(root, &fid);158 159 p9_debug(P9_DEBUG_VFS, " simple set mount, return 0\n");160 return dget(sb->s_root);161 162clunk_fid:163 p9_fid_put(fid);164 v9fs_session_close(v9ses);165free_session:166 kfree(v9ses);167 return ERR_PTR(retval);168 169release_sb:170 /*171 * we will do the session_close and root dentry release172 * in the below call. But we need to clunk fid, because we haven't173 * attached the fid to dentry so it won't get clunked174 * automatically.175 */176 p9_fid_put(fid);177 deactivate_locked_super(sb);178 return ERR_PTR(retval);179}180 181/**182 * v9fs_kill_super - Kill Superblock183 * @s: superblock184 *185 */186 187static void v9fs_kill_super(struct super_block *s)188{189 struct v9fs_session_info *v9ses = s->s_fs_info;190 191 p9_debug(P9_DEBUG_VFS, " %p\n", s);192 193 kill_anon_super(s);194 195 v9fs_session_cancel(v9ses);196 v9fs_session_close(v9ses);197 kfree(v9ses);198 s->s_fs_info = NULL;199 p9_debug(P9_DEBUG_VFS, "exiting kill_super\n");200}201 202static void203v9fs_umount_begin(struct super_block *sb)204{205 struct v9fs_session_info *v9ses;206 207 v9ses = sb->s_fs_info;208 v9fs_session_begin_cancel(v9ses);209}210 211static int v9fs_statfs(struct dentry *dentry, struct kstatfs *buf)212{213 struct v9fs_session_info *v9ses;214 struct p9_fid *fid;215 struct p9_rstatfs rs;216 int res;217 218 fid = v9fs_fid_lookup(dentry);219 if (IS_ERR(fid)) {220 res = PTR_ERR(fid);221 goto done;222 }223 224 v9ses = v9fs_dentry2v9ses(dentry);225 if (v9fs_proto_dotl(v9ses)) {226 res = p9_client_statfs(fid, &rs);227 if (res == 0) {228 buf->f_type = rs.type;229 buf->f_bsize = rs.bsize;230 buf->f_blocks = rs.blocks;231 buf->f_bfree = rs.bfree;232 buf->f_bavail = rs.bavail;233 buf->f_files = rs.files;234 buf->f_ffree = rs.ffree;235 buf->f_fsid = u64_to_fsid(rs.fsid);236 buf->f_namelen = rs.namelen;237 }238 if (res != -ENOSYS)239 goto done;240 }241 res = simple_statfs(dentry, buf);242done:243 p9_fid_put(fid);244 return res;245}246 247static int v9fs_drop_inode(struct inode *inode)248{249 struct v9fs_session_info *v9ses;250 251 v9ses = v9fs_inode2v9ses(inode);252 if (v9ses->cache & (CACHE_META|CACHE_LOOSE))253 return generic_drop_inode(inode);254 /*255 * in case of non cached mode always drop the256 * inode because we want the inode attribute257 * to always match that on the server.258 */259 return 1;260}261 262static int v9fs_write_inode(struct inode *inode,263 struct writeback_control *wbc)264{265 /*266 * send an fsync request to server irrespective of267 * wbc->sync_mode.268 */269 p9_debug(P9_DEBUG_VFS, "%s: inode %p\n", __func__, inode);270 return netfs_unpin_writeback(inode, wbc);271}272 273static int v9fs_write_inode_dotl(struct inode *inode,274 struct writeback_control *wbc)275{276 277 p9_debug(P9_DEBUG_VFS, "%s: inode %p\n", __func__, inode);278 279 return netfs_unpin_writeback(inode, wbc);280}281 282static const struct super_operations v9fs_super_ops = {283 .alloc_inode = v9fs_alloc_inode,284 .free_inode = v9fs_free_inode,285 .statfs = simple_statfs,286 .drop_inode = v9fs_drop_inode,287 .evict_inode = v9fs_evict_inode,288 .show_options = v9fs_show_options,289 .umount_begin = v9fs_umount_begin,290 .write_inode = v9fs_write_inode,291};292 293static const struct super_operations v9fs_super_ops_dotl = {294 .alloc_inode = v9fs_alloc_inode,295 .free_inode = v9fs_free_inode,296 .statfs = v9fs_statfs,297 .drop_inode = v9fs_drop_inode,298 .evict_inode = v9fs_evict_inode,299 .show_options = v9fs_show_options,300 .umount_begin = v9fs_umount_begin,301 .write_inode = v9fs_write_inode_dotl,302};303 304struct file_system_type v9fs_fs_type = {305 .name = "9p",306 .mount = v9fs_mount,307 .kill_sb = v9fs_kill_super,308 .owner = THIS_MODULE,309 .fs_flags = FS_RENAME_DOES_D_MOVE,310};311MODULE_ALIAS_FS("9p");312