blob: c8fe480d0db0e8ef90c4ca37bd0327af78e680d2 [file] [log] [blame]
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001/*
2 * linux/fs/9p/vfs_inode.c
3 *
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07004 * This file contains vfs inode ops for the 9P2000 protocol.
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07005 *
6 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
7 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
8 *
9 * This program is free software; you can redistribute it and/or modify
Eric Van Hensbergen42e8c502006-03-25 03:07:28 -080010 * it under the terms of the GNU General Public License version 2
11 * as published by the Free Software Foundation.
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070012 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to:
20 * Free Software Foundation
21 * 51 Franklin Street, Fifth Floor
22 * Boston, MA 02111-1301 USA
23 *
24 */
25
Joe Perches5d385152011-11-28 10:40:46 -080026#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070028#include <linux/module.h>
29#include <linux/errno.h>
30#include <linux/fs.h>
31#include <linux/file.h>
32#include <linux/pagemap.h>
33#include <linux/stat.h>
34#include <linux/string.h>
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070035#include <linux/inet.h>
36#include <linux/namei.h>
37#include <linux/idr.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040038#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090039#include <linux/slab.h>
Aneesh Kumar K.Vebf46262010-05-31 13:22:56 +053040#include <linux/xattr.h>
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053041#include <linux/posix_acl.h>
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050042#include <net/9p/9p.h>
43#include <net/9p/client.h>
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070044
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070045#include "v9fs.h"
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070046#include "v9fs_vfs.h"
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070047#include "fid.h"
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -050048#include "cache.h"
Aneesh Kumar K.Vebf46262010-05-31 13:22:56 +053049#include "xattr.h"
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053050#include "acl.h"
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070051
Arjan van de Ven754661f2007-02-12 00:55:38 -080052static const struct inode_operations v9fs_dir_inode_operations;
Sripathi Kodi9b6533c2010-03-25 12:41:54 +000053static const struct inode_operations v9fs_dir_inode_operations_dotu;
Arjan van de Ven754661f2007-02-12 00:55:38 -080054static const struct inode_operations v9fs_file_inode_operations;
55static const struct inode_operations v9fs_symlink_inode_operations;
Aneesh Kumar K.Vf5fc6142010-10-12 13:02:25 +053056
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070057/**
58 * unixmode2p9mode - convert unix mode bits to plan 9
59 * @v9ses: v9fs session information
60 * @mode: mode to convert
61 *
62 */
63
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -070064static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070065{
66 int res;
67 res = mode & 0777;
68 if (S_ISDIR(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050069 res |= P9_DMDIR;
Sripathi Kodidd6102f2010-03-05 18:48:00 +000070 if (v9fs_proto_dotu(v9ses)) {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070071 if (S_ISLNK(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050072 res |= P9_DMSYMLINK;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070073 if (v9ses->nodev == 0) {
74 if (S_ISSOCK(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050075 res |= P9_DMSOCKET;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070076 if (S_ISFIFO(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050077 res |= P9_DMNAMEDPIPE;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070078 if (S_ISBLK(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050079 res |= P9_DMDEVICE;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070080 if (S_ISCHR(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050081 res |= P9_DMDEVICE;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070082 }
83
84 if ((mode & S_ISUID) == S_ISUID)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050085 res |= P9_DMSETUID;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070086 if ((mode & S_ISGID) == S_ISGID)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050087 res |= P9_DMSETGID;
Anthony Liguorid199d652008-02-06 19:25:06 -060088 if ((mode & S_ISVTX) == S_ISVTX)
89 res |= P9_DMSETVTX;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050090 if ((mode & P9_DMLINK))
91 res |= P9_DMLINK;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070092 }
93
94 return res;
95}
96
97/**
Aneesh Kumar K.Vdf345c62012-01-05 13:39:49 +053098 * p9mode2perm- convert plan9 mode bits to unix permission bits
99 * @v9ses: v9fs session information
100 * @stat: p9_wstat from which mode need to be derived
101 *
102 */
103static int p9mode2perm(struct v9fs_session_info *v9ses,
104 struct p9_wstat *stat)
105{
106 int res;
107 int mode = stat->mode;
108
109 res = mode & S_IALLUGO;
110 if (v9fs_proto_dotu(v9ses)) {
111 if ((mode & P9_DMSETUID) == P9_DMSETUID)
112 res |= S_ISUID;
113
114 if ((mode & P9_DMSETGID) == P9_DMSETGID)
115 res |= S_ISGID;
116
117 if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
118 res |= S_ISVTX;
119 }
120 return res;
121}
122
123/**
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700124 * p9mode2unixmode- convert plan9 mode bits to unix mode bits
125 * @v9ses: v9fs session information
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000126 * @stat: p9_wstat from which mode need to be derived
127 * @rdev: major number, minor number in case of device files.
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700128 *
129 */
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000130static int p9mode2unixmode(struct v9fs_session_info *v9ses,
131 struct p9_wstat *stat, dev_t *rdev)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700132{
133 int res;
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000134 int mode = stat->mode;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700135
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000136 *rdev = 0;
Aneesh Kumar K.Vdf345c62012-01-05 13:39:49 +0530137 res = p9mode2perm(v9ses, stat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700138
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500139 if ((mode & P9_DMDIR) == P9_DMDIR)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700140 res |= S_IFDIR;
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000141 else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700142 res |= S_IFLNK;
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000143 else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700144 && (v9ses->nodev == 0))
145 res |= S_IFSOCK;
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000146 else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700147 && (v9ses->nodev == 0))
148 res |= S_IFIFO;
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000149 else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000150 && (v9ses->nodev == 0)) {
151 char type = 0, ext[32];
152 int major = -1, minor = -1;
153
154 strncpy(ext, stat->extension, sizeof(ext));
155 sscanf(ext, "%c %u %u", &type, &major, &minor);
156 switch (type) {
157 case 'c':
158 res |= S_IFCHR;
159 break;
160 case 'b':
161 res |= S_IFBLK;
162 break;
163 default:
Joe Perches5d385152011-11-28 10:40:46 -0800164 p9_debug(P9_DEBUG_ERROR, "Unknown special type %c %s\n",
165 type, stat->extension);
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000166 };
167 *rdev = MKDEV(major, minor);
168 } else
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700169 res |= S_IFREG;
170
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700171 return res;
172}
173
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600174/**
175 * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
176 * @uflags: flags to convert
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500177 * @extended: if .u extensions are active
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600178 */
179
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500180int v9fs_uflags2omode(int uflags, int extended)
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800181{
182 int ret;
183
184 ret = 0;
185 switch (uflags&3) {
186 default:
187 case O_RDONLY:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500188 ret = P9_OREAD;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800189 break;
190
191 case O_WRONLY:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500192 ret = P9_OWRITE;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800193 break;
194
195 case O_RDWR:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500196 ret = P9_ORDWR;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800197 break;
198 }
199
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800200 if (uflags & O_TRUNC)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500201 ret |= P9_OTRUNC;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800202
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500203 if (extended) {
204 if (uflags & O_EXCL)
205 ret |= P9_OEXCL;
206
207 if (uflags & O_APPEND)
208 ret |= P9_OAPPEND;
209 }
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800210
211 return ret;
212}
213
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700214/**
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800215 * v9fs_blank_wstat - helper function to setup a 9P stat structure
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800216 * @wstat: structure to initialize
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700217 *
218 */
219
M. Mohan Kumar7a4439c2010-02-08 15:36:48 -0600220void
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500221v9fs_blank_wstat(struct p9_wstat *wstat)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700222{
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800223 wstat->type = ~0;
224 wstat->dev = ~0;
225 wstat->qid.type = ~0;
226 wstat->qid.version = ~0;
227 *((long long *)&wstat->qid.path) = ~0;
228 wstat->mode = ~0;
229 wstat->atime = ~0;
230 wstat->mtime = ~0;
231 wstat->length = ~0;
232 wstat->name = NULL;
233 wstat->uid = NULL;
234 wstat->gid = NULL;
235 wstat->muid = NULL;
236 wstat->n_uid = ~0;
237 wstat->n_gid = ~0;
238 wstat->n_muid = ~0;
239 wstat->extension = NULL;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700240}
241
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500242/**
243 * v9fs_alloc_inode - helper function to allocate an inode
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500244 *
245 */
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500246struct inode *v9fs_alloc_inode(struct super_block *sb)
247{
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530248 struct v9fs_inode *v9inode;
249 v9inode = (struct v9fs_inode *)kmem_cache_alloc(v9fs_inode_cache,
250 GFP_KERNEL);
251 if (!v9inode)
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500252 return NULL;
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530253#ifdef CONFIG_9P_FSCACHE
254 v9inode->fscache = NULL;
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530255 spin_lock_init(&v9inode->fscache_lock);
256#endif
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530257 v9inode->writeback_fid = NULL;
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +0530258 v9inode->cache_validity = 0;
Aneesh Kumar K.V5a7e0a82011-03-08 16:39:46 +0530259 mutex_init(&v9inode->v_mutex);
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530260 return &v9inode->vfs_inode;
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500261}
262
263/**
264 * v9fs_destroy_inode - destroy an inode
265 *
266 */
267
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100268static void v9fs_i_callback(struct rcu_head *head)
269{
270 struct inode *inode = container_of(head, struct inode, i_rcu);
271 INIT_LIST_HEAD(&inode->i_dentry);
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530272 kmem_cache_free(v9fs_inode_cache, V9FS_I(inode));
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100273}
274
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500275void v9fs_destroy_inode(struct inode *inode)
276{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100277 call_rcu(&inode->i_rcu, v9fs_i_callback);
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500278}
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500279
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530280int v9fs_init_inode(struct v9fs_session_info *v9ses,
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000281 struct inode *inode, int mode, dev_t rdev)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700282{
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530283 int err = 0;
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600284
Dmitry Monakhov217f2062010-03-04 17:30:57 +0300285 inode_init_owner(inode, NULL, mode);
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600286 inode->i_blocks = 0;
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000287 inode->i_rdev = rdev;
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600288 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
289 inode->i_mapping->a_ops = &v9fs_addr_operations;
290
291 switch (mode & S_IFMT) {
292 case S_IFIFO:
293 case S_IFBLK:
294 case S_IFCHR:
295 case S_IFSOCK:
M. Mohan Kumar4b435162010-06-16 14:27:01 +0530296 if (v9fs_proto_dotl(v9ses)) {
297 inode->i_op = &v9fs_file_inode_operations_dotl;
M. Mohan Kumar4b435162010-06-16 14:27:01 +0530298 } else if (v9fs_proto_dotu(v9ses)) {
299 inode->i_op = &v9fs_file_inode_operations;
M. Mohan Kumar4b435162010-06-16 14:27:01 +0530300 } else {
Joe Perches5d385152011-11-28 10:40:46 -0800301 p9_debug(P9_DEBUG_ERROR,
302 "special files without extended mode\n");
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600303 err = -EINVAL;
304 goto error;
305 }
306 init_special_inode(inode, inode->i_mode, inode->i_rdev);
307 break;
308 case S_IFREG:
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000309 if (v9fs_proto_dotl(v9ses)) {
310 inode->i_op = &v9fs_file_inode_operations_dotl;
Aneesh Kumar K.V29236f42011-02-28 17:03:54 +0530311 if (v9ses->cache)
312 inode->i_fop =
313 &v9fs_cached_file_operations_dotl;
314 else
315 inode->i_fop = &v9fs_file_operations_dotl;
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000316 } else {
317 inode->i_op = &v9fs_file_inode_operations;
Aneesh Kumar K.V29236f42011-02-28 17:03:54 +0530318 if (v9ses->cache)
319 inode->i_fop = &v9fs_cached_file_operations;
320 else
321 inode->i_fop = &v9fs_file_operations;
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000322 }
323
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600324 break;
325 case S_IFLNK:
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000326 if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
Joe Perches5d385152011-11-28 10:40:46 -0800327 p9_debug(P9_DEBUG_ERROR,
328 "extended modes used with legacy protocol\n");
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600329 err = -EINVAL;
330 goto error;
331 }
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000332
333 if (v9fs_proto_dotl(v9ses))
334 inode->i_op = &v9fs_symlink_inode_operations_dotl;
335 else
336 inode->i_op = &v9fs_symlink_inode_operations;
337
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600338 break;
339 case S_IFDIR:
340 inc_nlink(inode);
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000341 if (v9fs_proto_dotl(v9ses))
342 inode->i_op = &v9fs_dir_inode_operations_dotl;
343 else if (v9fs_proto_dotu(v9ses))
344 inode->i_op = &v9fs_dir_inode_operations_dotu;
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600345 else
346 inode->i_op = &v9fs_dir_inode_operations;
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000347
348 if (v9fs_proto_dotl(v9ses))
349 inode->i_fop = &v9fs_dir_operations_dotl;
350 else
351 inode->i_fop = &v9fs_dir_operations;
352
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600353 break;
354 default:
Joe Perches5d385152011-11-28 10:40:46 -0800355 p9_debug(P9_DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
356 mode, mode & S_IFMT);
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600357 err = -EINVAL;
358 goto error;
359 }
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600360error:
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530361 return err;
362
363}
364
365/**
366 * v9fs_get_inode - helper function to setup an inode
367 * @sb: superblock
368 * @mode: mode to setup inode with
369 *
370 */
371
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000372struct inode *v9fs_get_inode(struct super_block *sb, int mode, dev_t rdev)
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530373{
374 int err;
375 struct inode *inode;
376 struct v9fs_session_info *v9ses = sb->s_fs_info;
377
Joe Perches5d385152011-11-28 10:40:46 -0800378 p9_debug(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530379
380 inode = new_inode(sb);
381 if (!inode) {
Joe Perches5d385152011-11-28 10:40:46 -0800382 pr_warn("%s (%d): Problem allocating inode\n",
383 __func__, task_pid_nr(current));
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530384 return ERR_PTR(-ENOMEM);
385 }
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000386 err = v9fs_init_inode(v9ses, inode, mode, rdev);
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530387 if (err) {
388 iput(inode);
389 return ERR_PTR(err);
390 }
391 return inode;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700392}
393
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500394/*
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800395static struct v9fs_fid*
396v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
397{
398 int err;
Mika Kukkonen736c4b82006-12-06 20:36:29 -0800399 int nfid;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800400 struct v9fs_fid *ret;
401 struct v9fs_fcall *fcall;
402
403 nfid = v9fs_get_idpool(&v9ses->fidpool);
404 if (nfid < 0) {
405 eprintk(KERN_WARNING, "no free fids available\n");
Latchesar Ionkov731805b2006-03-07 21:55:42 -0800406 return ERR_PTR(-ENOSPC);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800407 }
408
409 err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
410 &fcall);
411
412 if (err < 0) {
Latchesar Ionkov41e5a6a2006-05-15 09:44:21 -0700413 if (fcall && fcall->id == RWALK)
414 goto clunk_fid;
415
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800416 PRINT_FCALL_ERROR("walk error", fcall);
417 v9fs_put_idpool(nfid, &v9ses->fidpool);
418 goto error;
419 }
420
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700421 kfree(fcall);
Latchesar Ionkov3cf64292006-01-08 01:04:58 -0800422 fcall = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800423 ret = v9fs_fid_create(v9ses, nfid);
424 if (!ret) {
425 err = -ENOMEM;
426 goto clunk_fid;
427 }
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700428
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800429 err = v9fs_fid_insert(ret, dentry);
430 if (err < 0) {
431 v9fs_fid_destroy(ret);
432 goto clunk_fid;
Latchesar Ionkov0b8dd172005-09-27 21:45:24 -0700433 }
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800434
435 return ret;
436
437clunk_fid:
438 v9fs_t_clunk(v9ses, nfid);
439
440error:
441 kfree(fcall);
442 return ERR_PTR(err);
443}
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500444*/
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800445
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500446
447/**
448 * v9fs_clear_inode - release an inode
449 * @inode: inode to release
450 *
451 */
Al Virob57922d2010-06-07 14:34:48 -0400452void v9fs_evict_inode(struct inode *inode)
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500453{
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530454 struct v9fs_inode *v9inode = V9FS_I(inode);
455
Al Virob57922d2010-06-07 14:34:48 -0400456 truncate_inode_pages(inode->i_mapping, 0);
457 end_writeback(inode);
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500458 filemap_fdatawrite(inode->i_mapping);
459
460#ifdef CONFIG_9P_FSCACHE
461 v9fs_cache_inode_put_cookie(inode);
462#endif
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530463 /* clunk the fid stashed in writeback_fid */
464 if (v9inode->writeback_fid) {
465 p9_client_clunk(v9inode->writeback_fid);
466 v9inode->writeback_fid = NULL;
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530467 }
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500468}
469
Aneesh Kumar K.Vfd2421f2011-07-11 16:40:59 +0000470static int v9fs_test_inode(struct inode *inode, void *data)
471{
472 int umode;
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000473 dev_t rdev;
Aneesh Kumar K.Vfd2421f2011-07-11 16:40:59 +0000474 struct v9fs_inode *v9inode = V9FS_I(inode);
475 struct p9_wstat *st = (struct p9_wstat *)data;
476 struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
477
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000478 umode = p9mode2unixmode(v9ses, st, &rdev);
Aneesh Kumar K.Vfd2421f2011-07-11 16:40:59 +0000479 /* don't match inode of different type */
480 if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
481 return 0;
482
483 /* compare qid details */
484 if (memcmp(&v9inode->qid.version,
485 &st->qid.version, sizeof(v9inode->qid.version)))
486 return 0;
487
488 if (v9inode->qid.type != st->qid.type)
489 return 0;
490 return 1;
491}
492
Aneesh Kumar K.Ved80fcf2011-07-06 16:32:31 +0530493static int v9fs_test_new_inode(struct inode *inode, void *data)
494{
495 return 0;
496}
497
Aneesh Kumar K.Vfd2421f2011-07-11 16:40:59 +0000498static int v9fs_set_inode(struct inode *inode, void *data)
499{
500 struct v9fs_inode *v9inode = V9FS_I(inode);
501 struct p9_wstat *st = (struct p9_wstat *)data;
502
503 memcpy(&v9inode->qid, &st->qid, sizeof(st->qid));
504 return 0;
505}
506
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530507static struct inode *v9fs_qid_iget(struct super_block *sb,
508 struct p9_qid *qid,
Aneesh Kumar K.Ved80fcf2011-07-06 16:32:31 +0530509 struct p9_wstat *st,
510 int new)
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530511{
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000512 dev_t rdev;
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530513 int retval, umode;
514 unsigned long i_ino;
515 struct inode *inode;
516 struct v9fs_session_info *v9ses = sb->s_fs_info;
Aneesh Kumar K.Ved80fcf2011-07-06 16:32:31 +0530517 int (*test)(struct inode *, void *);
518
519 if (new)
520 test = v9fs_test_new_inode;
521 else
522 test = v9fs_test_inode;
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530523
524 i_ino = v9fs_qid2ino(qid);
Aneesh Kumar K.Ved80fcf2011-07-06 16:32:31 +0530525 inode = iget5_locked(sb, i_ino, test, v9fs_set_inode, st);
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530526 if (!inode)
527 return ERR_PTR(-ENOMEM);
528 if (!(inode->i_state & I_NEW))
529 return inode;
530 /*
531 * initialize the inode with the stat info
532 * FIXME!! we may need support for stale inodes
533 * later.
534 */
Aneesh Kumar K.Vfd2421f2011-07-11 16:40:59 +0000535 inode->i_ino = i_ino;
Aneesh Kumar K.V45089142011-07-25 18:06:33 +0000536 umode = p9mode2unixmode(v9ses, st, &rdev);
537 retval = v9fs_init_inode(v9ses, inode, umode, rdev);
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530538 if (retval)
539 goto error;
540
541 v9fs_stat2inode(st, inode, sb);
542#ifdef CONFIG_9P_FSCACHE
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530543 v9fs_cache_inode_get_cookie(inode);
544#endif
545 unlock_new_inode(inode);
546 return inode;
547error:
548 unlock_new_inode(inode);
549 iput(inode);
550 return ERR_PTR(retval);
551
552}
553
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600554struct inode *
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530555v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
Aneesh Kumar K.Ved80fcf2011-07-06 16:32:31 +0530556 struct super_block *sb, int new)
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800557{
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500558 struct p9_wstat *st;
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530559 struct inode *inode = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800560
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500561 st = p9_client_stat(fid);
Abhishek Kulkarni02bc3562009-07-19 13:41:54 -0600562 if (IS_ERR(st))
563 return ERR_CAST(st);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800564
Aneesh Kumar K.Ved80fcf2011-07-06 16:32:31 +0530565 inode = v9fs_qid_iget(sb, &st->qid, st, new);
Abhishek Kulkarni02bc3562009-07-19 13:41:54 -0600566 p9stat_free(st);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500567 kfree(st);
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530568 return inode;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700569}
570
571/**
Aneesh Kumar K.Vf88657c2011-08-03 19:55:32 +0530572 * v9fs_at_to_dotl_flags- convert Linux specific AT flags to
573 * plan 9 AT flag.
574 * @flags: flags to convert
575 */
576static int v9fs_at_to_dotl_flags(int flags)
577{
578 int rflags = 0;
579 if (flags & AT_REMOVEDIR)
580 rflags |= P9_DOTL_AT_REMOVEDIR;
581 return rflags;
582}
583
584/**
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700585 * v9fs_remove - helper function to remove files and directories
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700586 * @dir: directory inode that is being deleted
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530587 * @dentry: dentry that is being deleted
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700588 * @rmdir: removing a directory
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700589 *
590 */
591
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530592static int v9fs_remove(struct inode *dir, struct dentry *dentry, int flags)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700593{
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530594 struct inode *inode;
595 int retval = -EOPNOTSUPP;
596 struct p9_fid *v9fid, *dfid;
597 struct v9fs_session_info *v9ses;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700598
Joe Perches5d385152011-11-28 10:40:46 -0800599 p9_debug(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %x\n",
600 dir, dentry, flags);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700601
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530602 v9ses = v9fs_inode2v9ses(dir);
603 inode = dentry->d_inode;
604 dfid = v9fs_fid_lookup(dentry->d_parent);
605 if (IS_ERR(dfid)) {
606 retval = PTR_ERR(dfid);
Joe Perches5d385152011-11-28 10:40:46 -0800607 p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", retval);
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530608 return retval;
609 }
610 if (v9fs_proto_dotl(v9ses))
Aneesh Kumar K.Vf88657c2011-08-03 19:55:32 +0530611 retval = p9_client_unlinkat(dfid, dentry->d_name.name,
612 v9fs_at_to_dotl_flags(flags));
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530613 if (retval == -EOPNOTSUPP) {
614 /* Try the one based on path */
615 v9fid = v9fs_fid_clone(dentry);
616 if (IS_ERR(v9fid))
617 return PTR_ERR(v9fid);
618 retval = p9_client_remove(v9fid);
619 }
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530620 if (!retval) {
621 /*
622 * directories on unlink should have zero
623 * link count
624 */
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530625 if (flags & AT_REMOVEDIR) {
626 clear_nlink(inode);
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530627 drop_nlink(dir);
628 } else
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530629 drop_nlink(inode);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530630
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530631 v9fs_invalidate_inode_attr(inode);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530632 v9fs_invalidate_inode_attr(dir);
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530633 }
Aneesh Kumar K.Vd994f402010-03-29 18:14:50 -0500634 return retval;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700635}
636
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500637/**
638 * v9fs_create - Create a file
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600639 * @v9ses: session information
640 * @dir: directory that dentry is being created in
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500641 * @dentry: dentry that is being created
Abhishek Kulkarni0e155972009-07-19 13:41:55 -0600642 * @extension: 9p2000.u extension string to support devices, etc.
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500643 * @perm: create permissions
644 * @mode: open mode
645 *
646 */
647static struct p9_fid *
648v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
649 struct dentry *dentry, char *extension, u32 perm, u8 mode)
650{
651 int err;
652 char *name;
653 struct p9_fid *dfid, *ofid, *fid;
654 struct inode *inode;
655
Joe Perches5d385152011-11-28 10:40:46 -0800656 p9_debug(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500657
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500658 err = 0;
659 ofid = NULL;
660 fid = NULL;
661 name = (char *) dentry->d_name.name;
Venkateswararao Jujjuri6d27e642010-05-10 18:08:28 +0000662 dfid = v9fs_fid_lookup(dentry->d_parent);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500663 if (IS_ERR(dfid)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500664 err = PTR_ERR(dfid);
Joe Perches5d385152011-11-28 10:40:46 -0800665 p9_debug(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
Venkateswararao Jujjuri6d27e642010-05-10 18:08:28 +0000666 return ERR_PTR(err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500667 }
668
669 /* clone a fid to use for creation */
670 ofid = p9_client_walk(dfid, 0, NULL, 1);
671 if (IS_ERR(ofid)) {
672 err = PTR_ERR(ofid);
Joe Perches5d385152011-11-28 10:40:46 -0800673 p9_debug(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
Venkateswararao Jujjuri6d27e642010-05-10 18:08:28 +0000674 return ERR_PTR(err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500675 }
676
677 err = p9_client_fcreate(ofid, name, perm, mode, extension);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500678 if (err < 0) {
Joe Perches5d385152011-11-28 10:40:46 -0800679 p9_debug(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500680 goto error;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500681 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500682
Aneesh Kumar K.Vb6054792012-01-05 10:42:17 -0600683 if (!(perm & P9_DMLINK)) {
684 /* now walk from the parent so we can get unopened fid */
685 fid = p9_client_walk(dfid, 1, &name, 1);
686 if (IS_ERR(fid)) {
687 err = PTR_ERR(fid);
688 p9_debug(P9_DEBUG_VFS,
689 "p9_client_walk failed %d\n", err);
690 fid = NULL;
691 goto error;
692 }
693 /*
694 * instantiate inode and assign the unopened fid to the dentry
695 */
696 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
697 if (IS_ERR(inode)) {
698 err = PTR_ERR(inode);
699 p9_debug(P9_DEBUG_VFS,
700 "inode creation failed %d\n", err);
701 goto error;
702 }
703 err = v9fs_fid_add(dentry, fid);
704 if (err < 0)
705 goto error;
706 d_instantiate(dentry, inode);
Venkateswararao Jujjuri6d27e642010-05-10 18:08:28 +0000707 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500708 return ofid;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500709error:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500710 if (ofid)
711 p9_client_clunk(ofid);
712
713 if (fid)
714 p9_client_clunk(fid);
715
716 return ERR_PTR(err);
717}
718
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700719/**
720 * v9fs_vfs_create - VFS hook to create files
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600721 * @dir: directory inode that is being created
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700722 * @dentry: dentry that is being deleted
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800723 * @mode: create permissions
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700724 * @nd: path information
725 *
726 */
727
728static int
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800729v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700730 struct nameidata *nd)
731{
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800732 int err;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500733 u32 perm;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800734 int flags;
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530735 struct file *filp;
736 struct v9fs_inode *v9inode;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800737 struct v9fs_session_info *v9ses;
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530738 struct p9_fid *fid, *inode_fid;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800739
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500740 err = 0;
741 fid = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800742 v9ses = v9fs_inode2v9ses(dir);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800743 perm = unixmode2p9mode(v9ses, mode);
Al Virodd7dd552011-06-25 21:17:17 -0400744 if (nd)
Al Viro8a5e9292011-06-25 19:15:54 -0400745 flags = nd->intent.open.flags;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800746 else
747 flags = O_RDWR;
748
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500749 fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000750 v9fs_uflags2omode(flags,
751 v9fs_proto_dotu(v9ses)));
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500752 if (IS_ERR(fid)) {
753 err = PTR_ERR(fid);
754 fid = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800755 goto error;
756 }
757
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530758 v9fs_invalidate_inode_attr(dir);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500759 /* if we are opening a file, assign the open fid to the file */
Al Virodd7dd552011-06-25 21:17:17 -0400760 if (nd) {
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530761 v9inode = V9FS_I(dentry->d_inode);
Aneesh Kumar K.V5a7e0a82011-03-08 16:39:46 +0530762 mutex_lock(&v9inode->v_mutex);
Aneesh Kumar K.V7add6972011-03-08 16:39:49 +0530763 if (v9ses->cache && !v9inode->writeback_fid &&
764 ((flags & O_ACCMODE) != O_RDONLY)) {
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530765 /*
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530766 * clone a fid and add it to writeback_fid
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530767 * we do it during open time instead of
768 * page dirty time via write_begin/page_mkwrite
769 * because we want write after unlink usecase
770 * to work.
771 */
772 inode_fid = v9fs_writeback_fid(dentry);
773 if (IS_ERR(inode_fid)) {
774 err = PTR_ERR(inode_fid);
Aneesh Kumar K.V5a7e0a82011-03-08 16:39:46 +0530775 mutex_unlock(&v9inode->v_mutex);
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530776 goto error;
777 }
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530778 v9inode->writeback_fid = (void *) inode_fid;
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530779 }
Aneesh Kumar K.V5a7e0a82011-03-08 16:39:46 +0530780 mutex_unlock(&v9inode->v_mutex);
Aneesh Kumar K.V877cb3d2010-09-22 12:42:30 +0530781 filp = lookup_instantiate_filp(nd, dentry, generic_file_open);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800782 if (IS_ERR(filp)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500783 err = PTR_ERR(filp);
784 goto error;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800785 }
786
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500787 filp->private_data = fid;
Aneesh Kumar K.V46848de2011-02-28 17:03:55 +0530788#ifdef CONFIG_9P_FSCACHE
789 if (v9ses->cache)
790 v9fs_cache_inode_set_cookie(dentry->d_inode, filp);
791#endif
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500792 } else
793 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800794
795 return 0;
796
797error:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500798 if (fid)
799 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800800
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800801 return err;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700802}
803
804/**
805 * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600806 * @dir: inode that is being unlinked
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700807 * @dentry: dentry that is being unlinked
808 * @mode: mode for new directory
809 *
810 */
811
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800812static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700813{
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800814 int err;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500815 u32 perm;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500816 struct p9_fid *fid;
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530817 struct v9fs_session_info *v9ses;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800818
Joe Perches5d385152011-11-28 10:40:46 -0800819 p9_debug(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500820 err = 0;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800821 v9ses = v9fs_inode2v9ses(dir);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800822 perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500823 fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
824 if (IS_ERR(fid)) {
825 err = PTR_ERR(fid);
826 fid = NULL;
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530827 } else {
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530828 inc_nlink(dir);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530829 v9fs_invalidate_inode_attr(dir);
830 }
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800831
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500832 if (fid)
833 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800834
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800835 return err;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700836}
837
838/**
839 * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
840 * @dir: inode that is being walked from
841 * @dentry: dentry that is being walked to?
842 * @nameidata: path data
843 *
844 */
845
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600846struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700847 struct nameidata *nameidata)
848{
Aneesh Kumar K.V73f50712011-08-16 22:19:28 +0530849 struct dentry *res;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700850 struct super_block *sb;
851 struct v9fs_session_info *v9ses;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500852 struct p9_fid *dfid, *fid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700853 struct inode *inode;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500854 char *name;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700855 int result = 0;
856
Joe Perches5d385152011-11-28 10:40:46 -0800857 p9_debug(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
858 dir, dentry->d_name.name, dentry, nameidata);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700859
Sripathi Kodi11e9b492010-03-29 18:13:59 -0500860 if (dentry->d_name.len > NAME_MAX)
861 return ERR_PTR(-ENAMETOOLONG);
862
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700863 sb = dir->i_sb;
864 v9ses = v9fs_inode2v9ses(dir);
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +0530865 /* We can walk d_parent because we hold the dir->i_mutex */
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500866 dfid = v9fs_fid_lookup(dentry->d_parent);
867 if (IS_ERR(dfid))
David Howellse231c2e2008-02-07 00:15:26 -0800868 return ERR_CAST(dfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700869
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500870 name = (char *) dentry->d_name.name;
871 fid = p9_client_walk(dfid, 1, &name, 1);
872 if (IS_ERR(fid)) {
873 result = PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700874 if (result == -ENOENT) {
Aneesh Kumar K.V85e0df22010-05-14 13:04:39 +0000875 inode = NULL;
876 goto inst_out;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700877 }
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700878
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500879 return ERR_PTR(result);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700880 }
Aneesh Kumar K.V73f50712011-08-16 22:19:28 +0530881 /*
882 * Make sure we don't use a wrong inode due to parallel
883 * unlink. For cached mode create calls request for new
884 * inode. But with cache disabled, lookup should do this.
885 */
886 if (v9ses->cache)
887 inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
888 else
889 inode = v9fs_get_new_inode_from_fid(v9ses, fid, dir->i_sb);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500890 if (IS_ERR(inode)) {
891 result = PTR_ERR(inode);
892 inode = NULL;
893 goto error;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700894 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500895 result = v9fs_fid_add(dentry, fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800896 if (result < 0)
Aneesh Kumar K.V9856af82010-09-22 12:24:23 +0530897 goto error_iput;
Aneesh Kumar K.V85e0df22010-05-14 13:04:39 +0000898inst_out:
Aneesh Kumar K.V73f50712011-08-16 22:19:28 +0530899 /*
900 * If we had a rename on the server and a parallel lookup
901 * for the new name, then make sure we instantiate with
902 * the new name. ie look up for a/b, while on server somebody
903 * moved b under k and client parallely did a lookup for
904 * k/b.
905 */
906 res = d_materialise_unique(dentry, inode);
907 if (!IS_ERR(res))
908 return res;
909 result = PTR_ERR(res);
Aneesh Kumar K.V9856af82010-09-22 12:24:23 +0530910error_iput:
911 iput(inode);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500912error:
Julien Brunel62aa5282008-09-24 16:22:22 -0500913 p9_client_clunk(fid);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800914
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700915 return ERR_PTR(result);
916}
917
918/**
919 * v9fs_vfs_unlink - VFS unlink hook to delete an inode
920 * @i: inode that is being unlinked
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700921 * @d: dentry that is being unlinked
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700922 *
923 */
924
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600925int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700926{
927 return v9fs_remove(i, d, 0);
928}
929
930/**
931 * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
932 * @i: inode that is being unlinked
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700933 * @d: dentry that is being unlinked
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700934 *
935 */
936
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600937int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700938{
Aneesh Kumar K.V48e370f2011-06-28 15:41:18 +0530939 return v9fs_remove(i, d, AT_REMOVEDIR);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700940}
941
942/**
943 * v9fs_vfs_rename - VFS hook to rename an inode
944 * @old_dir: old dir inode
945 * @old_dentry: old dentry
946 * @new_dir: new dir inode
947 * @new_dentry: new dentry
948 *
949 */
950
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600951int
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700952v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
953 struct inode *new_dir, struct dentry *new_dentry)
954{
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530955 int retval;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500956 struct inode *old_inode;
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530957 struct inode *new_inode;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500958 struct v9fs_session_info *v9ses;
959 struct p9_fid *oldfid;
960 struct p9_fid *olddirfid;
961 struct p9_fid *newdirfid;
962 struct p9_wstat wstat;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700963
Joe Perches5d385152011-11-28 10:40:46 -0800964 p9_debug(P9_DEBUG_VFS, "\n");
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500965 retval = 0;
966 old_inode = old_dentry->d_inode;
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530967 new_inode = new_dentry->d_inode;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500968 v9ses = v9fs_inode2v9ses(old_inode);
969 oldfid = v9fs_fid_lookup(old_dentry);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500970 if (IS_ERR(oldfid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800971 return PTR_ERR(oldfid);
972
973 olddirfid = v9fs_fid_clone(old_dentry->d_parent);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500974 if (IS_ERR(olddirfid)) {
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800975 retval = PTR_ERR(olddirfid);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500976 goto done;
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800977 }
978
979 newdirfid = v9fs_fid_clone(new_dentry->d_parent);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500980 if (IS_ERR(newdirfid)) {
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800981 retval = PTR_ERR(newdirfid);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500982 goto clunk_olddir;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700983 }
984
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +0530985 down_write(&v9ses->rename_sem);
Sripathi Kodi4681dbd2010-03-25 12:47:26 +0000986 if (v9fs_proto_dotl(v9ses)) {
Aneesh Kumar K.V9e8fb382011-06-28 15:41:16 +0530987 retval = p9_client_renameat(olddirfid, old_dentry->d_name.name,
988 newdirfid, new_dentry->d_name.name);
989 if (retval == -EOPNOTSUPP)
990 retval = p9_client_rename(oldfid, newdirfid,
991 new_dentry->d_name.name);
992 if (retval != -EOPNOTSUPP)
Sripathi Kodi4681dbd2010-03-25 12:47:26 +0000993 goto clunk_newdir;
994 }
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +0530995 if (old_dentry->d_parent != new_dentry->d_parent) {
996 /*
997 * 9P .u can only handle file rename in the same directory
998 */
Sripathi Kodi4681dbd2010-03-25 12:47:26 +0000999
Joe Perches5d385152011-11-28 10:40:46 -08001000 p9_debug(P9_DEBUG_ERROR, "old dir and new dir are different\n");
Eric Van Hensbergen621997c2007-01-26 00:57:04 -08001001 retval = -EXDEV;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001002 goto clunk_newdir;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001003 }
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001004 v9fs_blank_wstat(&wstat);
Latchesar Ionkovba176742007-10-17 14:31:07 -05001005 wstat.muid = v9ses->uname;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001006 wstat.name = (char *) new_dentry->d_name.name;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001007 retval = p9_client_wstat(oldfid, &wstat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001008
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001009clunk_newdir:
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +05301010 if (!retval) {
1011 if (new_inode) {
1012 if (S_ISDIR(new_inode->i_mode))
1013 clear_nlink(new_inode);
1014 else
1015 drop_nlink(new_inode);
1016 }
1017 if (S_ISDIR(old_inode->i_mode)) {
1018 if (!new_inode)
1019 inc_nlink(new_dir);
1020 drop_nlink(old_dir);
1021 }
Aneesh Kumar K.V3bc86de2011-02-28 17:04:07 +05301022 v9fs_invalidate_inode_attr(old_inode);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +05301023 v9fs_invalidate_inode_attr(old_dir);
1024 v9fs_invalidate_inode_attr(new_dir);
Aneesh Kumar K.V3bc86de2011-02-28 17:04:07 +05301025
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +05301026 /* successful rename */
1027 d_move(old_dentry, new_dentry);
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +05301028 }
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +05301029 up_write(&v9ses->rename_sem);
Latchesar Ionkov22150c42007-10-23 13:48:33 -05001030 p9_client_clunk(newdirfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001031
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001032clunk_olddir:
Latchesar Ionkov22150c42007-10-23 13:48:33 -05001033 p9_client_clunk(olddirfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001034
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001035done:
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001036 return retval;
1037}
1038
1039/**
Adrian Bunk943ffb52006-01-10 00:10:13 +01001040 * v9fs_vfs_getattr - retrieve file metadata
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001041 * @mnt: mount information
1042 * @dentry: file to get attributes on
1043 * @stat: metadata structure to populate
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001044 *
1045 */
1046
1047static int
1048v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1049 struct kstat *stat)
1050{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001051 int err;
1052 struct v9fs_session_info *v9ses;
1053 struct p9_fid *fid;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001054 struct p9_wstat *st;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001055
Joe Perches5d385152011-11-28 10:40:46 -08001056 p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001057 err = -EPERM;
Aneesh Kumar K.V42869c82011-03-08 16:39:50 +05301058 v9ses = v9fs_dentry2v9ses(dentry);
Aneesh Kumar K.Va1211902011-02-28 17:04:01 +05301059 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
1060 generic_fillattr(dentry->d_inode, stat);
1061 return 0;
1062 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001063 fid = v9fs_fid_lookup(dentry);
1064 if (IS_ERR(fid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001065 return PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001066
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001067 st = p9_client_stat(fid);
1068 if (IS_ERR(st))
1069 return PTR_ERR(st);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001070
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001071 v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
Aneesh Kumar K.V45089142011-07-25 18:06:33 +00001072 generic_fillattr(dentry->d_inode, stat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001073
Latchesar Ionkov62b2be52010-08-24 18:13:59 +00001074 p9stat_free(st);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001075 kfree(st);
1076 return 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001077}
1078
1079/**
1080 * v9fs_vfs_setattr - set file metadata
1081 * @dentry: file whose metadata to set
1082 * @iattr: metadata assignment structure
1083 *
1084 */
1085
1086static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
1087{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001088 int retval;
1089 struct v9fs_session_info *v9ses;
1090 struct p9_fid *fid;
1091 struct p9_wstat wstat;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001092
Joe Perches5d385152011-11-28 10:40:46 -08001093 p9_debug(P9_DEBUG_VFS, "\n");
Aneesh Kumar K.V059c1382011-03-08 16:39:48 +05301094 retval = inode_change_ok(dentry->d_inode, iattr);
1095 if (retval)
1096 return retval;
1097
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001098 retval = -EPERM;
Aneesh Kumar K.V42869c82011-03-08 16:39:50 +05301099 v9ses = v9fs_dentry2v9ses(dentry);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001100 fid = v9fs_fid_lookup(dentry);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001101 if(IS_ERR(fid))
1102 return PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001103
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001104 v9fs_blank_wstat(&wstat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001105 if (iattr->ia_valid & ATTR_MODE)
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001106 wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001107
1108 if (iattr->ia_valid & ATTR_MTIME)
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001109 wstat.mtime = iattr->ia_mtime.tv_sec;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001110
1111 if (iattr->ia_valid & ATTR_ATIME)
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001112 wstat.atime = iattr->ia_atime.tv_sec;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001113
1114 if (iattr->ia_valid & ATTR_SIZE)
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001115 wstat.length = iattr->ia_size;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001116
Sripathi Kodidd6102f2010-03-05 18:48:00 +00001117 if (v9fs_proto_dotu(v9ses)) {
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001118 if (iattr->ia_valid & ATTR_UID)
1119 wstat.n_uid = iattr->ia_uid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001120
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001121 if (iattr->ia_valid & ATTR_GID)
1122 wstat.n_gid = iattr->ia_gid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001123 }
Aneesh Kumar K.V059c1382011-03-08 16:39:48 +05301124
Aneesh Kumar K.V3dc54362011-02-28 17:04:11 +05301125 /* Write all dirty data */
1126 if (S_ISREG(dentry->d_inode->i_mode))
1127 filemap_write_and_wait(dentry->d_inode->i_mapping);
1128
Aneesh Kumar K.Vf10fc502011-02-28 17:04:10 +05301129 retval = p9_client_wstat(fid, &wstat);
1130 if (retval < 0)
1131 return retval;
Aneesh Kumar K.V059c1382011-03-08 16:39:48 +05301132
1133 if ((iattr->ia_valid & ATTR_SIZE) &&
1134 iattr->ia_size != i_size_read(dentry->d_inode))
1135 truncate_setsize(dentry->d_inode, iattr->ia_size);
1136
Aneesh Kumar K.Vf10fc502011-02-28 17:04:10 +05301137 v9fs_invalidate_inode_attr(dentry->d_inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02001138
1139 setattr_copy(dentry->d_inode, iattr);
1140 mark_inode_dirty(dentry->d_inode);
1141 return 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001142}
1143
1144/**
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001145 * v9fs_stat2inode - populate an inode structure with mistat info
1146 * @stat: Plan 9 metadata (mistat) structure
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001147 * @inode: inode to populate
1148 * @sb: superblock of filesystem
1149 *
1150 */
1151
1152void
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001153v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001154 struct super_block *sb)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001155{
Aneesh Kumar K.V45089142011-07-25 18:06:33 +00001156 mode_t mode;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001157 char ext[32];
Aneesh Kumar K.V57171442010-03-05 14:43:43 -06001158 char tag_name[14];
1159 unsigned int i_nlink;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001160 struct v9fs_session_info *v9ses = sb->s_fs_info;
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +05301161 struct v9fs_inode *v9inode = V9FS_I(inode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001162
Miklos Szeredibfe86842011-10-28 14:13:29 +02001163 set_nlink(inode, 1);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001164
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001165 inode->i_atime.tv_sec = stat->atime;
1166 inode->i_mtime.tv_sec = stat->mtime;
1167 inode->i_ctime.tv_sec = stat->mtime;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001168
Latchesar Ionkovbd32b822007-10-17 14:31:07 -05001169 inode->i_uid = v9ses->dfltuid;
1170 inode->i_gid = v9ses->dfltgid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001171
Sripathi Kodidd6102f2010-03-05 18:48:00 +00001172 if (v9fs_proto_dotu(v9ses)) {
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001173 inode->i_uid = stat->n_uid;
1174 inode->i_gid = stat->n_gid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001175 }
Aneesh Kumar K.V57171442010-03-05 14:43:43 -06001176 if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
1177 if (v9fs_proto_dotu(v9ses) && (stat->extension[0] != '\0')) {
1178 /*
1179 * Hadlink support got added later to
1180 * to the .u extension. So there can be
1181 * server out there that doesn't support
1182 * this even with .u extension. So check
1183 * for non NULL stat->extension
1184 */
1185 strncpy(ext, stat->extension, sizeof(ext));
1186 /* HARDLINKCOUNT %u */
1187 sscanf(ext, "%13s %u", tag_name, &i_nlink);
1188 if (!strncmp(tag_name, "HARDLINKCOUNT", 13))
Miklos Szeredibfe86842011-10-28 14:13:29 +02001189 set_nlink(inode, i_nlink);
Aneesh Kumar K.V57171442010-03-05 14:43:43 -06001190 }
1191 }
Aneesh Kumar K.Vdf345c62012-01-05 13:39:49 +05301192 mode = p9mode2perm(v9ses, stat);
Aneesh Kumar K.V45089142011-07-25 18:06:33 +00001193 mode |= inode->i_mode & ~S_IALLUGO;
1194 inode->i_mode = mode;
Abhishek Kulkarni7549ae32009-09-22 11:34:05 -05001195 i_size_write(inode, stat->length);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001196
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001197 /* not real number of blocks, but 512 byte ones ... */
Abhishek Kulkarni7549ae32009-09-22 11:34:05 -05001198 inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +05301199 v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001200}
1201
1202/**
1203 * v9fs_qid2ino - convert qid into inode number
1204 * @qid: qid to hash
1205 *
1206 * BUG: potential for inode number collisions?
1207 */
1208
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001209ino_t v9fs_qid2ino(struct p9_qid *qid)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001210{
1211 u64 path = qid->path + 2;
1212 ino_t i = 0;
1213
1214 if (sizeof(ino_t) == sizeof(path))
1215 memcpy(&i, &path, sizeof(ino_t));
1216 else
1217 i = (ino_t) (path ^ (path >> 32));
1218
1219 return i;
1220}
1221
1222/**
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001223 * v9fs_readlink - read a symlink's location (internal version)
1224 * @dentry: dentry for symlink
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001225 * @buffer: buffer to load symlink location into
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001226 * @buflen: length of buffer
1227 *
1228 */
1229
1230static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
1231{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001232 int retval;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001233
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001234 struct v9fs_session_info *v9ses;
1235 struct p9_fid *fid;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001236 struct p9_wstat *st;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001237
Joe Perches5d385152011-11-28 10:40:46 -08001238 p9_debug(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001239 retval = -EPERM;
Aneesh Kumar K.V42869c82011-03-08 16:39:50 +05301240 v9ses = v9fs_dentry2v9ses(dentry);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001241 fid = v9fs_fid_lookup(dentry);
Latchesar Ionkovba176742007-10-17 14:31:07 -05001242 if (IS_ERR(fid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001243 return PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001244
M. Mohan Kumar329176c2010-09-28 19:59:25 +05301245 if (!v9fs_proto_dotu(v9ses))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001246 return -EBADF;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001247
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001248 st = p9_client_stat(fid);
1249 if (IS_ERR(st))
1250 return PTR_ERR(st);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001251
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001252 if (!(st->mode & P9_DMSYMLINK)) {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001253 retval = -EINVAL;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001254 goto done;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001255 }
1256
1257 /* copy extension buffer into buffer */
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001258 strncpy(buffer, st->extension, buflen);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001259
Joe Perches5d385152011-11-28 10:40:46 -08001260 p9_debug(P9_DEBUG_VFS, "%s -> %s (%s)\n",
1261 dentry->d_name.name, st->extension, buffer);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001262
Martin Stava2511cd02009-11-02 08:39:34 -06001263 retval = strnlen(buffer, buflen);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001264done:
Latchesar Ionkov62b2be52010-08-24 18:13:59 +00001265 p9stat_free(st);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001266 kfree(st);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001267 return retval;
1268}
1269
1270/**
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001271 * v9fs_vfs_follow_link - follow a symlink path
1272 * @dentry: dentry for symlink
1273 * @nd: nameidata
1274 *
1275 */
1276
1277static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
1278{
1279 int len = 0;
1280 char *link = __getname();
1281
Joe Perches5d385152011-11-28 10:40:46 -08001282 p9_debug(P9_DEBUG_VFS, "%s\n", dentry->d_name.name);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001283
1284 if (!link)
1285 link = ERR_PTR(-ENOMEM);
1286 else {
Latchesar Ionkov16cce6d2006-03-25 03:07:26 -08001287 len = v9fs_readlink(dentry, link, PATH_MAX);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001288
1289 if (len < 0) {
Davi Arnautce44eeb2005-11-07 00:59:36 -08001290 __putname(link);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001291 link = ERR_PTR(len);
1292 } else
Martin Stava2511cd02009-11-02 08:39:34 -06001293 link[min(len, PATH_MAX-1)] = 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001294 }
1295 nd_set_link(nd, link);
1296
1297 return NULL;
1298}
1299
1300/**
1301 * v9fs_vfs_put_link - release a symlink path
1302 * @dentry: dentry for symlink
1303 * @nd: nameidata
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001304 * @p: unused
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001305 *
1306 */
1307
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -06001308void
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001309v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001310{
1311 char *s = nd_get_link(nd);
1312
Joe Perches5d385152011-11-28 10:40:46 -08001313 p9_debug(P9_DEBUG_VFS, " %s %s\n",
1314 dentry->d_name.name, IS_ERR(s) ? "<error>" : s);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001315 if (!IS_ERR(s))
Davi Arnautce44eeb2005-11-07 00:59:36 -08001316 __putname(s);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001317}
1318
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001319/**
1320 * v9fs_vfs_mkspecial - create a special file
1321 * @dir: inode to create special file in
1322 * @dentry: dentry to create
1323 * @mode: mode to create special file
1324 * @extension: 9p2000.u format extension string representing special file
1325 *
1326 */
1327
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001328static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1329 int mode, const char *extension)
1330{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001331 u32 perm;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001332 struct p9_fid *fid;
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +05301333 struct v9fs_session_info *v9ses;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001334
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -08001335 v9ses = v9fs_inode2v9ses(dir);
Sripathi Kodidd6102f2010-03-05 18:48:00 +00001336 if (!v9fs_proto_dotu(v9ses)) {
Joe Perches5d385152011-11-28 10:40:46 -08001337 p9_debug(P9_DEBUG_ERROR, "not extended\n");
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -08001338 return -EPERM;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001339 }
1340
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001341 perm = unixmode2p9mode(v9ses, mode);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001342 fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1343 P9_OREAD);
1344 if (IS_ERR(fid))
1345 return PTR_ERR(fid);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001346
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +05301347 v9fs_invalidate_inode_attr(dir);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001348 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -08001349 return 0;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001350}
1351
1352/**
1353 * v9fs_vfs_symlink - helper function to create symlinks
1354 * @dir: directory inode containing symlink
1355 * @dentry: dentry for symlink
1356 * @symname: symlink data
1357 *
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001358 * See Also: 9P2000.u RFC for more information
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001359 *
1360 */
1361
1362static int
1363v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1364{
Joe Perches5d385152011-11-28 10:40:46 -08001365 p9_debug(P9_DEBUG_VFS, " %lu,%s,%s\n",
1366 dir->i_ino, dentry->d_name.name, symname);
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001367
1368 return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
1369}
1370
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001371/**
1372 * v9fs_vfs_link - create a hardlink
1373 * @old_dentry: dentry for file to link to
1374 * @dir: inode destination for new link
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001375 * @dentry: dentry for link
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001376 *
1377 */
1378
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001379static int
1380v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1381 struct dentry *dentry)
1382{
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001383 int retval;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001384 char *name;
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +05301385 struct p9_fid *oldfid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001386
Joe Perches5d385152011-11-28 10:40:46 -08001387 p9_debug(P9_DEBUG_VFS, " %lu,%s,%s\n",
1388 dir->i_ino, dentry->d_name.name, old_dentry->d_name.name);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001389
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001390 oldfid = v9fs_fid_clone(old_dentry);
Latchesar Ionkovba176742007-10-17 14:31:07 -05001391 if (IS_ERR(oldfid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001392 return PTR_ERR(oldfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001393
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001394 name = __getname();
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001395 if (unlikely(!name)) {
1396 retval = -ENOMEM;
1397 goto clunk_fid;
1398 }
Florin Malita0710d362006-06-25 05:48:31 -07001399
Latchesar Ionkov16cce6d2006-03-25 03:07:26 -08001400 sprintf(name, "%d\n", oldfid->fid);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001401 retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001402 __putname(name);
Aneesh Kumar K.Vc06c0662011-02-28 17:04:09 +05301403 if (!retval) {
1404 v9fs_refresh_inode(oldfid, old_dentry->d_inode);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +05301405 v9fs_invalidate_inode_attr(dir);
Aneesh Kumar K.Vc06c0662011-02-28 17:04:09 +05301406 }
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001407clunk_fid:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001408 p9_client_clunk(oldfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001409 return retval;
1410}
1411
1412/**
1413 * v9fs_vfs_mknod - create a special file
1414 * @dir: inode destination for new link
1415 * @dentry: dentry for file
1416 * @mode: mode for creation
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001417 * @rdev: device associated with special file
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001418 *
1419 */
1420
1421static int
1422v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1423{
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001424 int retval;
1425 char *name;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001426
Joe Perches5d385152011-11-28 10:40:46 -08001427 p9_debug(P9_DEBUG_VFS, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n",
1428 dir->i_ino, dentry->d_name.name, mode,
1429 MAJOR(rdev), MINOR(rdev));
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001430
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001431 if (!new_valid_dev(rdev))
1432 return -EINVAL;
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001433
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001434 name = __getname();
Eugene Teoc0291a02006-03-25 03:07:27 -08001435 if (!name)
1436 return -ENOMEM;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001437 /* build extension */
1438 if (S_ISBLK(mode))
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001439 sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001440 else if (S_ISCHR(mode))
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001441 sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001442 else if (S_ISFIFO(mode))
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001443 *name = 0;
Venkateswararao Jujjuri75cc5c92010-05-22 12:20:30 -05001444 else if (S_ISSOCK(mode))
1445 *name = 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001446 else {
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001447 __putname(name);
1448 return -EINVAL;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001449 }
1450
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001451 retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
1452 __putname(name);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001453
1454 return retval;
1455}
1456
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +05301457int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
1458{
Aneesh Kumar K.V45089142011-07-25 18:06:33 +00001459 int umode;
1460 dev_t rdev;
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +05301461 loff_t i_size;
1462 struct p9_wstat *st;
1463 struct v9fs_session_info *v9ses;
1464
1465 v9ses = v9fs_inode2v9ses(inode);
1466 st = p9_client_stat(fid);
1467 if (IS_ERR(st))
1468 return PTR_ERR(st);
Aneesh Kumar K.V45089142011-07-25 18:06:33 +00001469 /*
1470 * Don't update inode if the file type is different
1471 */
1472 umode = p9mode2unixmode(v9ses, st, &rdev);
1473 if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
1474 goto out;
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +05301475
1476 spin_lock(&inode->i_lock);
1477 /*
1478 * We don't want to refresh inode->i_size,
1479 * because we may have cached data
1480 */
1481 i_size = inode->i_size;
1482 v9fs_stat2inode(st, inode, inode->i_sb);
1483 if (v9ses->cache)
1484 inode->i_size = i_size;
1485 spin_unlock(&inode->i_lock);
Aneesh Kumar K.V45089142011-07-25 18:06:33 +00001486out:
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +05301487 p9stat_free(st);
1488 kfree(st);
1489 return 0;
1490}
1491
Sripathi Kodi9b6533c2010-03-25 12:41:54 +00001492static const struct inode_operations v9fs_dir_inode_operations_dotu = {
1493 .create = v9fs_vfs_create,
1494 .lookup = v9fs_vfs_lookup,
1495 .symlink = v9fs_vfs_symlink,
Venkateswararao Jujjuri (JV)50cc42f2010-06-09 15:59:31 -07001496 .link = v9fs_vfs_link,
Sripathi Kodi9b6533c2010-03-25 12:41:54 +00001497 .unlink = v9fs_vfs_unlink,
1498 .mkdir = v9fs_vfs_mkdir,
1499 .rmdir = v9fs_vfs_rmdir,
Aneesh Kumar K.V1d76e312010-08-30 17:43:07 +00001500 .mknod = v9fs_vfs_mknod,
Sripathi Kodi9b6533c2010-03-25 12:41:54 +00001501 .rename = v9fs_vfs_rename,
1502 .getattr = v9fs_vfs_getattr,
1503 .setattr = v9fs_vfs_setattr,
1504};
1505
Arjan van de Ven754661f2007-02-12 00:55:38 -08001506static const struct inode_operations v9fs_dir_inode_operations = {
Eric Van Hensbergenb5016112005-09-09 13:04:27 -07001507 .create = v9fs_vfs_create,
1508 .lookup = v9fs_vfs_lookup,
1509 .unlink = v9fs_vfs_unlink,
1510 .mkdir = v9fs_vfs_mkdir,
1511 .rmdir = v9fs_vfs_rmdir,
1512 .mknod = v9fs_vfs_mknod,
1513 .rename = v9fs_vfs_rename,
1514 .getattr = v9fs_vfs_getattr,
1515 .setattr = v9fs_vfs_setattr,
1516};
1517
Arjan van de Ven754661f2007-02-12 00:55:38 -08001518static const struct inode_operations v9fs_file_inode_operations = {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001519 .getattr = v9fs_vfs_getattr,
1520 .setattr = v9fs_vfs_setattr,
1521};
1522
Arjan van de Ven754661f2007-02-12 00:55:38 -08001523static const struct inode_operations v9fs_symlink_inode_operations = {
Al Viro204f2f02009-12-23 00:35:54 -05001524 .readlink = generic_readlink,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001525 .follow_link = v9fs_vfs_follow_link,
1526 .put_link = v9fs_vfs_put_link,
1527 .getattr = v9fs_vfs_getattr,
1528 .setattr = v9fs_vfs_setattr,
1529};
Sripathi Kodi9b6533c2010-03-25 12:41:54 +00001530