Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 1 | /* |
| 2 | * linux/fs/9p/vfs_super.c |
| 3 | * |
| 4 | * This file contians superblock ops for 9P2000. It is intended that |
| 5 | * you mount this file system on directories. |
| 6 | * |
| 7 | * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> |
| 8 | * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> |
| 9 | * |
| 10 | * This program is free software; you can redistribute it and/or modify |
Eric Van Hensbergen | 42e8c50 | 2006-03-25 03:07:28 -0800 | [diff] [blame] | 11 | * it under the terms of the GNU General Public License version 2 |
| 12 | * as published by the Free Software Foundation. |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 13 | * |
| 14 | * This program is distributed in the hope that it will be useful, |
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 17 | * GNU General Public License for more details. |
| 18 | * |
| 19 | * You should have received a copy of the GNU General Public License |
| 20 | * along with this program; if not, write to: |
| 21 | * Free Software Foundation |
| 22 | * 51 Franklin Street, Fifth Floor |
| 23 | * Boston, MA 02111-1301 USA |
| 24 | * |
| 25 | */ |
| 26 | |
| 27 | #include <linux/kernel.h> |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 28 | #include <linux/module.h> |
| 29 | #include <linux/errno.h> |
| 30 | #include <linux/fs.h> |
| 31 | #include <linux/file.h> |
| 32 | #include <linux/stat.h> |
| 33 | #include <linux/string.h> |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 34 | #include <linux/inet.h> |
| 35 | #include <linux/pagemap.h> |
| 36 | #include <linux/seq_file.h> |
| 37 | #include <linux/mount.h> |
| 38 | #include <linux/idr.h> |
Alexey Dobriyan | e8edc6e | 2007-05-21 01:22:52 +0400 | [diff] [blame] | 39 | #include <linux/sched.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 40 | #include <linux/slab.h> |
Sripathi Kodi | bda8e77 | 2010-03-25 12:45:30 +0000 | [diff] [blame] | 41 | #include <linux/statfs.h> |
M. Mohan Kumar | 368c09d | 2010-09-27 14:17:24 +0530 | [diff] [blame] | 42 | #include <linux/magic.h> |
Latchesar Ionkov | bd238fb | 2007-07-10 17:57:28 -0500 | [diff] [blame] | 43 | #include <net/9p/9p.h> |
| 44 | #include <net/9p/client.h> |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 45 | |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 46 | #include "v9fs.h" |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 47 | #include "v9fs_vfs.h" |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 48 | #include "fid.h" |
Aneesh Kumar K.V | ebf4626 | 2010-05-31 13:22:56 +0530 | [diff] [blame] | 49 | #include "xattr.h" |
Aneesh Kumar K.V | 85ff872 | 2010-09-28 00:27:39 +0530 | [diff] [blame] | 50 | #include "acl.h" |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 51 | |
Sripathi Kodi | 9b6533c | 2010-03-25 12:41:54 +0000 | [diff] [blame] | 52 | static const struct super_operations v9fs_super_ops, v9fs_super_ops_dotl; |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 53 | |
| 54 | /** |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 55 | * v9fs_set_super - set the superblock |
| 56 | * @s: super block |
| 57 | * @data: file system specific data |
| 58 | * |
| 59 | */ |
| 60 | |
| 61 | static int v9fs_set_super(struct super_block *s, void *data) |
| 62 | { |
| 63 | s->s_fs_info = data; |
| 64 | return set_anon_super(s, data); |
| 65 | } |
| 66 | |
| 67 | /** |
| 68 | * v9fs_fill_super - populate superblock with info |
| 69 | * @sb: superblock |
| 70 | * @v9ses: session information |
Al Viro | d2d1ea9 | 2010-07-25 23:56:43 +0400 | [diff] [blame] | 71 | * @flags: flags propagated from v9fs_mount() |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 72 | * |
| 73 | */ |
| 74 | |
| 75 | static void |
| 76 | v9fs_fill_super(struct super_block *sb, struct v9fs_session_info *v9ses, |
Abhishek Kulkarni | 4b53e4b | 2009-08-17 16:42:28 -0500 | [diff] [blame] | 77 | int flags, void *data) |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 78 | { |
| 79 | sb->s_maxbytes = MAX_LFS_FILESIZE; |
| 80 | sb->s_blocksize_bits = fls(v9ses->maxdata - 1); |
| 81 | sb->s_blocksize = 1 << sb->s_blocksize_bits; |
| 82 | sb->s_magic = V9FS_MAGIC; |
Aneesh Kumar K.V | ebf4626 | 2010-05-31 13:22:56 +0530 | [diff] [blame] | 83 | if (v9fs_proto_dotl(v9ses)) { |
Sripathi Kodi | 9b6533c | 2010-03-25 12:41:54 +0000 | [diff] [blame] | 84 | sb->s_op = &v9fs_super_ops_dotl; |
Aneesh Kumar K.V | ebf4626 | 2010-05-31 13:22:56 +0530 | [diff] [blame] | 85 | sb->s_xattr = v9fs_xattr_handlers; |
| 86 | } else |
Sripathi Kodi | 9b6533c | 2010-03-25 12:41:54 +0000 | [diff] [blame] | 87 | sb->s_op = &v9fs_super_ops; |
Jens Axboe | 0ed07dd | 2010-04-22 11:42:00 +0200 | [diff] [blame] | 88 | sb->s_bdi = &v9ses->bdi; |
Aneesh Kumar K.V | 6b36560 | 2011-02-28 17:04:03 +0530 | [diff] [blame] | 89 | if (v9ses->cache) |
| 90 | sb->s_bdi->ra_pages = (VM_MAX_READAHEAD * 1024)/PAGE_CACHE_SIZE; |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 91 | |
Aneesh Kumar K.V | db5841d | 2011-02-28 17:03:59 +0530 | [diff] [blame] | 92 | sb->s_flags = flags | MS_ACTIVE | MS_DIRSYNC | MS_NOATIME; |
| 93 | if (!v9ses->cache) |
| 94 | sb->s_flags |= MS_SYNCHRONOUS; |
Abhishek Kulkarni | 4b53e4b | 2009-08-17 16:42:28 -0500 | [diff] [blame] | 95 | |
Aneesh Kumar K.V | 85ff872 | 2010-09-28 00:27:39 +0530 | [diff] [blame] | 96 | #ifdef CONFIG_9P_FS_POSIX_ACL |
Venkateswararao Jujjuri (JV) | e782ef7 | 2011-01-25 15:40:54 -0800 | [diff] [blame] | 97 | if ((v9ses->flags & V9FS_ACL_MASK) == V9FS_POSIX_ACL) |
Aneesh Kumar K.V | 76381a4 | 2010-09-28 00:27:41 +0530 | [diff] [blame] | 98 | sb->s_flags |= MS_POSIXACL; |
Aneesh Kumar K.V | 85ff872 | 2010-09-28 00:27:39 +0530 | [diff] [blame] | 99 | #endif |
| 100 | |
Abhishek Kulkarni | 4b53e4b | 2009-08-17 16:42:28 -0500 | [diff] [blame] | 101 | save_mount_options(sb, data); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 102 | } |
| 103 | |
| 104 | /** |
Al Viro | d2d1ea9 | 2010-07-25 23:56:43 +0400 | [diff] [blame] | 105 | * v9fs_mount - mount a superblock |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 106 | * @fs_type: file system type |
| 107 | * @flags: mount flags |
| 108 | * @dev_name: device name that was mounted |
| 109 | * @data: mount options |
| 110 | * |
| 111 | */ |
| 112 | |
Al Viro | d2d1ea9 | 2010-07-25 23:56:43 +0400 | [diff] [blame] | 113 | static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags, |
| 114 | const char *dev_name, void *data) |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 115 | { |
| 116 | struct super_block *sb = NULL; |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 117 | struct inode *inode = NULL; |
| 118 | struct dentry *root = NULL; |
| 119 | struct v9fs_session_info *v9ses = NULL; |
Al Viro | 3eda0de | 2011-07-26 02:53:22 -0400 | [diff] [blame] | 120 | umode_t mode = S_IRWXUGO | S_ISVTX; |
Latchesar Ionkov | bd238fb | 2007-07-10 17:57:28 -0500 | [diff] [blame] | 121 | struct p9_fid *fid; |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 122 | int retval = 0; |
| 123 | |
Joe Perches | 5d38515 | 2011-11-28 10:40:46 -0800 | [diff] [blame] | 124 | p9_debug(P9_DEBUG_VFS, "\n"); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 125 | |
Latchesar Ionkov | 1dac06b | 2006-01-08 01:05:02 -0800 | [diff] [blame] | 126 | v9ses = kzalloc(sizeof(struct v9fs_session_info), GFP_KERNEL); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 127 | if (!v9ses) |
Al Viro | d2d1ea9 | 2010-07-25 23:56:43 +0400 | [diff] [blame] | 128 | return ERR_PTR(-ENOMEM); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 129 | |
Latchesar Ionkov | bd238fb | 2007-07-10 17:57:28 -0500 | [diff] [blame] | 130 | fid = v9fs_session_init(v9ses, dev_name, data); |
| 131 | if (IS_ERR(fid)) { |
| 132 | retval = PTR_ERR(fid); |
Aneesh Kumar K.V | 5c25f34 | 2010-08-24 10:30:49 +0000 | [diff] [blame] | 133 | /* |
| 134 | * we need to call session_close to tear down some |
| 135 | * of the data structure setup by session_init |
| 136 | */ |
Eric Van Hensbergen | 887b3ec | 2008-05-08 20:26:37 -0500 | [diff] [blame] | 137 | goto close_session; |
Latchesar Ionkov | bd238fb | 2007-07-10 17:57:28 -0500 | [diff] [blame] | 138 | } |
| 139 | |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 140 | sb = sget(fs_type, NULL, v9fs_set_super, v9ses); |
David Howells | 454e239 | 2006-06-23 02:02:57 -0700 | [diff] [blame] | 141 | if (IS_ERR(sb)) { |
| 142 | retval = PTR_ERR(sb); |
Sripathi Kodi | f085312 | 2010-07-12 20:07:23 +0530 | [diff] [blame] | 143 | goto clunk_fid; |
David Howells | 454e239 | 2006-06-23 02:02:57 -0700 | [diff] [blame] | 144 | } |
Abhishek Kulkarni | 4b53e4b | 2009-08-17 16:42:28 -0500 | [diff] [blame] | 145 | v9fs_fill_super(sb, v9ses, flags, data); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 146 | |
Al Viro | 98cd3fb | 2011-01-12 17:10:55 -0500 | [diff] [blame] | 147 | if (v9ses->cache) |
| 148 | sb->s_d_op = &v9fs_cached_dentry_operations; |
| 149 | else |
| 150 | sb->s_d_op = &v9fs_dentry_operations; |
| 151 | |
Aneesh Kumar K.V | 4508914 | 2011-07-25 18:06:33 +0000 | [diff] [blame] | 152 | inode = v9fs_get_inode(sb, S_IFDIR | mode, 0); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 153 | if (IS_ERR(inode)) { |
| 154 | retval = PTR_ERR(inode); |
Eric Van Hensbergen | 887b3ec | 2008-05-08 20:26:37 -0500 | [diff] [blame] | 155 | goto release_sb; |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 156 | } |
Aneesh Kumar K.V | df5d8c8 | 2011-03-24 20:38:35 +0530 | [diff] [blame] | 157 | |
Al Viro | 48fde70 | 2012-01-08 22:15:13 -0500 | [diff] [blame] | 158 | root = d_make_root(inode); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 159 | if (!root) { |
| 160 | retval = -ENOMEM; |
Eric Van Hensbergen | 887b3ec | 2008-05-08 20:26:37 -0500 | [diff] [blame] | 161 | goto release_sb; |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 162 | } |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 163 | sb->s_root = root; |
Sripathi Kodi | f085312 | 2010-07-12 20:07:23 +0530 | [diff] [blame] | 164 | if (v9fs_proto_dotl(v9ses)) { |
| 165 | struct p9_stat_dotl *st = NULL; |
| 166 | st = p9_client_getattr_dotl(fid, P9_STATS_BASIC); |
| 167 | if (IS_ERR(st)) { |
| 168 | retval = PTR_ERR(st); |
Aneesh Kumar K.V | 5c25f34 | 2010-08-24 10:30:49 +0000 | [diff] [blame] | 169 | goto release_sb; |
Sripathi Kodi | f085312 | 2010-07-12 20:07:23 +0530 | [diff] [blame] | 170 | } |
Aneesh Kumar K.V | 0e43270 | 2011-02-28 17:04:06 +0530 | [diff] [blame] | 171 | root->d_inode->i_ino = v9fs_qid2ino(&st->qid); |
Sripathi Kodi | f085312 | 2010-07-12 20:07:23 +0530 | [diff] [blame] | 172 | v9fs_stat2inode_dotl(st, root->d_inode); |
| 173 | kfree(st); |
| 174 | } else { |
| 175 | struct p9_wstat *st = NULL; |
| 176 | st = p9_client_stat(fid); |
| 177 | if (IS_ERR(st)) { |
| 178 | retval = PTR_ERR(st); |
Aneesh Kumar K.V | 5c25f34 | 2010-08-24 10:30:49 +0000 | [diff] [blame] | 179 | goto release_sb; |
Sripathi Kodi | f085312 | 2010-07-12 20:07:23 +0530 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | root->d_inode->i_ino = v9fs_qid2ino(&st->qid); |
| 183 | v9fs_stat2inode(st, root->d_inode, sb); |
| 184 | |
| 185 | p9stat_free(st); |
| 186 | kfree(st); |
| 187 | } |
Aneesh Kumar K.V | 85ff872 | 2010-09-28 00:27:39 +0530 | [diff] [blame] | 188 | retval = v9fs_get_acl(inode, fid); |
| 189 | if (retval) |
| 190 | goto release_sb; |
Aneesh Kumar K.V | df5d8c8 | 2011-03-24 20:38:35 +0530 | [diff] [blame] | 191 | v9fs_fid_add(root, fid); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 192 | |
Joe Perches | 5d38515 | 2011-11-28 10:40:46 -0800 | [diff] [blame] | 193 | p9_debug(P9_DEBUG_VFS, " simple set mount, return 0\n"); |
Al Viro | d2d1ea9 | 2010-07-25 23:56:43 +0400 | [diff] [blame] | 194 | return dget(sb->s_root); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 195 | |
Eric Van Hensbergen | 887b3ec | 2008-05-08 20:26:37 -0500 | [diff] [blame] | 196 | clunk_fid: |
| 197 | p9_client_clunk(fid); |
Eric Van Hensbergen | 887b3ec | 2008-05-08 20:26:37 -0500 | [diff] [blame] | 198 | close_session: |
| 199 | v9fs_session_close(v9ses); |
| 200 | kfree(v9ses); |
Al Viro | d2d1ea9 | 2010-07-25 23:56:43 +0400 | [diff] [blame] | 201 | return ERR_PTR(retval); |
Aneesh Kumar K.V | df5d8c8 | 2011-03-24 20:38:35 +0530 | [diff] [blame] | 202 | |
Abhishek Kulkarni | 1b5ab3e | 2009-07-19 13:41:52 -0600 | [diff] [blame] | 203 | release_sb: |
Aneesh Kumar K.V | 5c25f34 | 2010-08-24 10:30:49 +0000 | [diff] [blame] | 204 | /* |
Aneesh Kumar K.V | df5d8c8 | 2011-03-24 20:38:35 +0530 | [diff] [blame] | 205 | * we will do the session_close and root dentry release |
| 206 | * in the below call. But we need to clunk fid, because we haven't |
| 207 | * attached the fid to dentry so it won't get clunked |
| 208 | * automatically. |
Aneesh Kumar K.V | 5c25f34 | 2010-08-24 10:30:49 +0000 | [diff] [blame] | 209 | */ |
Aneesh Kumar K.V | df5d8c8 | 2011-03-24 20:38:35 +0530 | [diff] [blame] | 210 | p9_client_clunk(fid); |
Abhishek Kulkarni | 1b5ab3e | 2009-07-19 13:41:52 -0600 | [diff] [blame] | 211 | deactivate_locked_super(sb); |
Al Viro | d2d1ea9 | 2010-07-25 23:56:43 +0400 | [diff] [blame] | 212 | return ERR_PTR(retval); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 213 | } |
| 214 | |
| 215 | /** |
| 216 | * v9fs_kill_super - Kill Superblock |
| 217 | * @s: superblock |
| 218 | * |
| 219 | */ |
| 220 | |
| 221 | static void v9fs_kill_super(struct super_block *s) |
| 222 | { |
| 223 | struct v9fs_session_info *v9ses = s->s_fs_info; |
| 224 | |
Joe Perches | 5d38515 | 2011-11-28 10:40:46 -0800 | [diff] [blame] | 225 | p9_debug(P9_DEBUG_VFS, " %p\n", s); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 226 | |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 227 | kill_anon_super(s); |
Aneesh Kumar K.V | df5d8c8 | 2011-03-24 20:38:35 +0530 | [diff] [blame] | 228 | |
Aneesh Kumar K.V | 6d96d3a | 2010-03-29 18:13:59 -0500 | [diff] [blame] | 229 | v9fs_session_cancel(v9ses); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 230 | v9fs_session_close(v9ses); |
| 231 | kfree(v9ses); |
Abhishek Kulkarni | 1b5ab3e | 2009-07-19 13:41:52 -0600 | [diff] [blame] | 232 | s->s_fs_info = NULL; |
Joe Perches | 5d38515 | 2011-11-28 10:40:46 -0800 | [diff] [blame] | 233 | p9_debug(P9_DEBUG_VFS, "exiting kill_super\n"); |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 234 | } |
| 235 | |
Eric Van Hensbergen | 322b329 | 2005-09-09 13:04:23 -0700 | [diff] [blame] | 236 | static void |
Al Viro | 42faad9 | 2008-04-24 07:21:56 -0400 | [diff] [blame] | 237 | v9fs_umount_begin(struct super_block *sb) |
Eric Van Hensbergen | 322b329 | 2005-09-09 13:04:23 -0700 | [diff] [blame] | 238 | { |
Alessio Igor Bogani | 67e5520 | 2009-04-24 09:06:53 +0200 | [diff] [blame] | 239 | struct v9fs_session_info *v9ses; |
Eric Van Hensbergen | 322b329 | 2005-09-09 13:04:23 -0700 | [diff] [blame] | 240 | |
Alessio Igor Bogani | 67e5520 | 2009-04-24 09:06:53 +0200 | [diff] [blame] | 241 | v9ses = sb->s_fs_info; |
Aneesh Kumar K.V | 6d96d3a | 2010-03-29 18:13:59 -0500 | [diff] [blame] | 242 | v9fs_session_begin_cancel(v9ses); |
Eric Van Hensbergen | 322b329 | 2005-09-09 13:04:23 -0700 | [diff] [blame] | 243 | } |
| 244 | |
Sripathi Kodi | bda8e77 | 2010-03-25 12:45:30 +0000 | [diff] [blame] | 245 | static int v9fs_statfs(struct dentry *dentry, struct kstatfs *buf) |
| 246 | { |
| 247 | struct v9fs_session_info *v9ses; |
| 248 | struct p9_fid *fid; |
| 249 | struct p9_rstatfs rs; |
| 250 | int res; |
| 251 | |
| 252 | fid = v9fs_fid_lookup(dentry); |
| 253 | if (IS_ERR(fid)) { |
| 254 | res = PTR_ERR(fid); |
| 255 | goto done; |
| 256 | } |
| 257 | |
Aneesh Kumar K.V | 42869c8 | 2011-03-08 16:39:50 +0530 | [diff] [blame] | 258 | v9ses = v9fs_dentry2v9ses(dentry); |
Sripathi Kodi | bda8e77 | 2010-03-25 12:45:30 +0000 | [diff] [blame] | 259 | if (v9fs_proto_dotl(v9ses)) { |
| 260 | res = p9_client_statfs(fid, &rs); |
| 261 | if (res == 0) { |
Jim Garlick | 5bdad93 | 2011-06-30 09:03:38 -0700 | [diff] [blame] | 262 | buf->f_type = rs.type; |
Sripathi Kodi | bda8e77 | 2010-03-25 12:45:30 +0000 | [diff] [blame] | 263 | buf->f_bsize = rs.bsize; |
| 264 | buf->f_blocks = rs.blocks; |
| 265 | buf->f_bfree = rs.bfree; |
| 266 | buf->f_bavail = rs.bavail; |
| 267 | buf->f_files = rs.files; |
| 268 | buf->f_ffree = rs.ffree; |
| 269 | buf->f_fsid.val[0] = rs.fsid & 0xFFFFFFFFUL; |
| 270 | buf->f_fsid.val[1] = (rs.fsid >> 32) & 0xFFFFFFFFUL; |
| 271 | buf->f_namelen = rs.namelen; |
| 272 | } |
| 273 | if (res != -ENOSYS) |
| 274 | goto done; |
| 275 | } |
| 276 | res = simple_statfs(dentry, buf); |
| 277 | done: |
| 278 | return res; |
| 279 | } |
| 280 | |
Aneesh Kumar K.V | edd73cf | 2011-02-28 17:04:05 +0530 | [diff] [blame] | 281 | static int v9fs_drop_inode(struct inode *inode) |
| 282 | { |
| 283 | struct v9fs_session_info *v9ses; |
| 284 | v9ses = v9fs_inode2v9ses(inode); |
| 285 | if (v9ses->cache) |
| 286 | return generic_drop_inode(inode); |
| 287 | /* |
| 288 | * in case of non cached mode always drop the |
| 289 | * the inode because we want the inode attribute |
| 290 | * to always match that on the server. |
| 291 | */ |
| 292 | return 1; |
| 293 | } |
| 294 | |
Aneesh Kumar K.V | c2ed388 | 2011-03-23 15:11:27 +0530 | [diff] [blame] | 295 | static int v9fs_write_inode(struct inode *inode, |
| 296 | struct writeback_control *wbc) |
| 297 | { |
| 298 | int ret; |
| 299 | struct p9_wstat wstat; |
| 300 | struct v9fs_inode *v9inode; |
| 301 | /* |
| 302 | * send an fsync request to server irrespective of |
| 303 | * wbc->sync_mode. |
| 304 | */ |
Joe Perches | 5d38515 | 2011-11-28 10:40:46 -0800 | [diff] [blame] | 305 | p9_debug(P9_DEBUG_VFS, "%s: inode %p\n", __func__, inode); |
Aneesh Kumar K.V | c2ed388 | 2011-03-23 15:11:27 +0530 | [diff] [blame] | 306 | v9inode = V9FS_I(inode); |
| 307 | if (!v9inode->writeback_fid) |
| 308 | return 0; |
| 309 | v9fs_blank_wstat(&wstat); |
| 310 | |
| 311 | ret = p9_client_wstat(v9inode->writeback_fid, &wstat); |
| 312 | if (ret < 0) { |
| 313 | __mark_inode_dirty(inode, I_DIRTY_DATASYNC); |
| 314 | return ret; |
| 315 | } |
| 316 | return 0; |
| 317 | } |
| 318 | |
| 319 | static int v9fs_write_inode_dotl(struct inode *inode, |
| 320 | struct writeback_control *wbc) |
| 321 | { |
| 322 | int ret; |
| 323 | struct v9fs_inode *v9inode; |
| 324 | /* |
| 325 | * send an fsync request to server irrespective of |
| 326 | * wbc->sync_mode. |
| 327 | */ |
Joe Perches | 5d38515 | 2011-11-28 10:40:46 -0800 | [diff] [blame] | 328 | p9_debug(P9_DEBUG_VFS, "%s: inode %p\n", __func__, inode); |
Aneesh Kumar K.V | c2ed388 | 2011-03-23 15:11:27 +0530 | [diff] [blame] | 329 | v9inode = V9FS_I(inode); |
| 330 | if (!v9inode->writeback_fid) |
| 331 | return 0; |
| 332 | ret = p9_client_fsync(v9inode->writeback_fid, 0); |
| 333 | if (ret < 0) { |
| 334 | __mark_inode_dirty(inode, I_DIRTY_DATASYNC); |
| 335 | return ret; |
| 336 | } |
| 337 | return 0; |
| 338 | } |
| 339 | |
Josef 'Jeff' Sipek | ee9b6d6 | 2007-02-12 00:55:41 -0800 | [diff] [blame] | 340 | static const struct super_operations v9fs_super_ops = { |
Abhishek Kulkarni | 60e78d2 | 2009-09-23 13:00:27 -0500 | [diff] [blame] | 341 | .alloc_inode = v9fs_alloc_inode, |
| 342 | .destroy_inode = v9fs_destroy_inode, |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 343 | .statfs = simple_statfs, |
Al Viro | b57922d | 2010-06-07 14:34:48 -0400 | [diff] [blame] | 344 | .evict_inode = v9fs_evict_inode, |
Abhishek Kulkarni | 4b53e4b | 2009-08-17 16:42:28 -0500 | [diff] [blame] | 345 | .show_options = generic_show_options, |
Eric Van Hensbergen | 322b329 | 2005-09-09 13:04:23 -0700 | [diff] [blame] | 346 | .umount_begin = v9fs_umount_begin, |
Aneesh Kumar K.V | c2ed388 | 2011-03-23 15:11:27 +0530 | [diff] [blame] | 347 | .write_inode = v9fs_write_inode, |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 348 | }; |
| 349 | |
Sripathi Kodi | 9b6533c | 2010-03-25 12:41:54 +0000 | [diff] [blame] | 350 | static const struct super_operations v9fs_super_ops_dotl = { |
Sripathi Kodi | 9b6533c | 2010-03-25 12:41:54 +0000 | [diff] [blame] | 351 | .alloc_inode = v9fs_alloc_inode, |
| 352 | .destroy_inode = v9fs_destroy_inode, |
Sripathi Kodi | bda8e77 | 2010-03-25 12:45:30 +0000 | [diff] [blame] | 353 | .statfs = v9fs_statfs, |
Aneesh Kumar K.V | edd73cf | 2011-02-28 17:04:05 +0530 | [diff] [blame] | 354 | .drop_inode = v9fs_drop_inode, |
Al Viro | b57922d | 2010-06-07 14:34:48 -0400 | [diff] [blame] | 355 | .evict_inode = v9fs_evict_inode, |
Sripathi Kodi | 9b6533c | 2010-03-25 12:41:54 +0000 | [diff] [blame] | 356 | .show_options = generic_show_options, |
| 357 | .umount_begin = v9fs_umount_begin, |
Aneesh Kumar K.V | c2ed388 | 2011-03-23 15:11:27 +0530 | [diff] [blame] | 358 | .write_inode = v9fs_write_inode_dotl, |
Sripathi Kodi | 9b6533c | 2010-03-25 12:41:54 +0000 | [diff] [blame] | 359 | }; |
| 360 | |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 361 | struct file_system_type v9fs_fs_type = { |
Eric Van Hensbergen | 67543e5 | 2006-03-25 03:07:29 -0800 | [diff] [blame] | 362 | .name = "9p", |
Al Viro | d2d1ea9 | 2010-07-25 23:56:43 +0400 | [diff] [blame] | 363 | .mount = v9fs_mount, |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 364 | .kill_sb = v9fs_kill_super, |
| 365 | .owner = THIS_MODULE, |
Aneesh Kumar K.V | 823fcfd | 2011-02-28 17:04:07 +0530 | [diff] [blame] | 366 | .fs_flags = FS_RENAME_DOES_D_MOVE|FS_REVAL_DOT, |
Eric Van Hensbergen | 9e82cf6 | 2005-09-09 13:04:20 -0700 | [diff] [blame] | 367 | }; |