blob: 7f6c6770319538c3094f7b26eb40fc18a398475d [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
26#include <linux/module.h>
27#include <linux/errno.h>
28#include <linux/fs.h>
29#include <linux/file.h>
30#include <linux/pagemap.h>
31#include <linux/stat.h>
32#include <linux/string.h>
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070033#include <linux/inet.h>
34#include <linux/namei.h>
35#include <linux/idr.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040036#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090037#include <linux/slab.h>
Aneesh Kumar K.Vebf46262010-05-31 13:22:56 +053038#include <linux/xattr.h>
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053039#include <linux/posix_acl.h>
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050040#include <net/9p/9p.h>
41#include <net/9p/client.h>
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070042
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070043#include "v9fs.h"
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070044#include "v9fs_vfs.h"
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070045#include "fid.h"
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -050046#include "cache.h"
Aneesh Kumar K.Vebf46262010-05-31 13:22:56 +053047#include "xattr.h"
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053048#include "acl.h"
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070049
Arjan van de Ven754661f2007-02-12 00:55:38 -080050static const struct inode_operations v9fs_dir_inode_operations;
Sripathi Kodi9b6533c2010-03-25 12:41:54 +000051static const struct inode_operations v9fs_dir_inode_operations_dotu;
Arjan van de Ven754661f2007-02-12 00:55:38 -080052static const struct inode_operations v9fs_file_inode_operations;
53static const struct inode_operations v9fs_symlink_inode_operations;
Aneesh Kumar K.Vf5fc6142010-10-12 13:02:25 +053054
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070055/**
56 * unixmode2p9mode - convert unix mode bits to plan 9
57 * @v9ses: v9fs session information
58 * @mode: mode to convert
59 *
60 */
61
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -070062static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070063{
64 int res;
65 res = mode & 0777;
66 if (S_ISDIR(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050067 res |= P9_DMDIR;
Sripathi Kodidd6102f2010-03-05 18:48:00 +000068 if (v9fs_proto_dotu(v9ses)) {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070069 if (S_ISLNK(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050070 res |= P9_DMSYMLINK;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070071 if (v9ses->nodev == 0) {
72 if (S_ISSOCK(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050073 res |= P9_DMSOCKET;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070074 if (S_ISFIFO(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050075 res |= P9_DMNAMEDPIPE;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070076 if (S_ISBLK(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050077 res |= P9_DMDEVICE;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070078 if (S_ISCHR(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050079 res |= P9_DMDEVICE;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070080 }
81
82 if ((mode & S_ISUID) == S_ISUID)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050083 res |= P9_DMSETUID;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070084 if ((mode & S_ISGID) == S_ISGID)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050085 res |= P9_DMSETGID;
Anthony Liguorid199d652008-02-06 19:25:06 -060086 if ((mode & S_ISVTX) == S_ISVTX)
87 res |= P9_DMSETVTX;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050088 if ((mode & P9_DMLINK))
89 res |= P9_DMLINK;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070090 }
91
92 return res;
93}
94
95/**
96 * p9mode2unixmode- convert plan9 mode bits to unix mode bits
97 * @v9ses: v9fs session information
98 * @mode: mode to convert
99 *
100 */
101
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700102static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700103{
104 int res;
105
106 res = mode & 0777;
107
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500108 if ((mode & P9_DMDIR) == P9_DMDIR)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700109 res |= S_IFDIR;
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000110 else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700111 res |= S_IFLNK;
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000112 else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700113 && (v9ses->nodev == 0))
114 res |= S_IFSOCK;
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000115 else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700116 && (v9ses->nodev == 0))
117 res |= S_IFIFO;
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000118 else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700119 && (v9ses->nodev == 0))
120 res |= S_IFBLK;
121 else
122 res |= S_IFREG;
123
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000124 if (v9fs_proto_dotu(v9ses)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500125 if ((mode & P9_DMSETUID) == P9_DMSETUID)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700126 res |= S_ISUID;
127
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500128 if ((mode & P9_DMSETGID) == P9_DMSETGID)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700129 res |= S_ISGID;
Anthony Liguorid199d652008-02-06 19:25:06 -0600130
131 if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
132 res |= S_ISVTX;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700133 }
134
135 return res;
136}
137
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600138/**
139 * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
140 * @uflags: flags to convert
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500141 * @extended: if .u extensions are active
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600142 */
143
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500144int v9fs_uflags2omode(int uflags, int extended)
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800145{
146 int ret;
147
148 ret = 0;
149 switch (uflags&3) {
150 default:
151 case O_RDONLY:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500152 ret = P9_OREAD;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800153 break;
154
155 case O_WRONLY:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500156 ret = P9_OWRITE;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800157 break;
158
159 case O_RDWR:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500160 ret = P9_ORDWR;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800161 break;
162 }
163
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800164 if (uflags & O_TRUNC)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500165 ret |= P9_OTRUNC;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800166
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500167 if (extended) {
168 if (uflags & O_EXCL)
169 ret |= P9_OEXCL;
170
171 if (uflags & O_APPEND)
172 ret |= P9_OAPPEND;
173 }
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800174
175 return ret;
176}
177
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700178/**
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800179 * v9fs_blank_wstat - helper function to setup a 9P stat structure
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800180 * @wstat: structure to initialize
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700181 *
182 */
183
M. Mohan Kumar7a4439c2010-02-08 15:36:48 -0600184void
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500185v9fs_blank_wstat(struct p9_wstat *wstat)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700186{
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800187 wstat->type = ~0;
188 wstat->dev = ~0;
189 wstat->qid.type = ~0;
190 wstat->qid.version = ~0;
191 *((long long *)&wstat->qid.path) = ~0;
192 wstat->mode = ~0;
193 wstat->atime = ~0;
194 wstat->mtime = ~0;
195 wstat->length = ~0;
196 wstat->name = NULL;
197 wstat->uid = NULL;
198 wstat->gid = NULL;
199 wstat->muid = NULL;
200 wstat->n_uid = ~0;
201 wstat->n_gid = ~0;
202 wstat->n_muid = ~0;
203 wstat->extension = NULL;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700204}
205
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500206/**
207 * v9fs_alloc_inode - helper function to allocate an inode
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500208 *
209 */
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500210struct inode *v9fs_alloc_inode(struct super_block *sb)
211{
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530212 struct v9fs_inode *v9inode;
213 v9inode = (struct v9fs_inode *)kmem_cache_alloc(v9fs_inode_cache,
214 GFP_KERNEL);
215 if (!v9inode)
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500216 return NULL;
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530217#ifdef CONFIG_9P_FSCACHE
218 v9inode->fscache = NULL;
219 v9inode->fscache_key = NULL;
220 spin_lock_init(&v9inode->fscache_lock);
221#endif
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530222 v9inode->writeback_fid = NULL;
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +0530223 v9inode->cache_validity = 0;
Aneesh Kumar K.V5a7e0a82011-03-08 16:39:46 +0530224 mutex_init(&v9inode->v_mutex);
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530225 return &v9inode->vfs_inode;
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500226}
227
228/**
229 * v9fs_destroy_inode - destroy an inode
230 *
231 */
232
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100233static void v9fs_i_callback(struct rcu_head *head)
234{
235 struct inode *inode = container_of(head, struct inode, i_rcu);
236 INIT_LIST_HEAD(&inode->i_dentry);
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530237 kmem_cache_free(v9fs_inode_cache, V9FS_I(inode));
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100238}
239
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500240void v9fs_destroy_inode(struct inode *inode)
241{
Nick Pigginfa0d7e3d2011-01-07 17:49:49 +1100242 call_rcu(&inode->i_rcu, v9fs_i_callback);
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500243}
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500244
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530245int v9fs_init_inode(struct v9fs_session_info *v9ses,
246 struct inode *inode, int mode)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700247{
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530248 int err = 0;
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600249
Dmitry Monakhov217f2062010-03-04 17:30:57 +0300250 inode_init_owner(inode, NULL, mode);
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600251 inode->i_blocks = 0;
252 inode->i_rdev = 0;
253 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
254 inode->i_mapping->a_ops = &v9fs_addr_operations;
255
256 switch (mode & S_IFMT) {
257 case S_IFIFO:
258 case S_IFBLK:
259 case S_IFCHR:
260 case S_IFSOCK:
M. Mohan Kumar4b435162010-06-16 14:27:01 +0530261 if (v9fs_proto_dotl(v9ses)) {
262 inode->i_op = &v9fs_file_inode_operations_dotl;
263 inode->i_fop = &v9fs_file_operations_dotl;
264 } else if (v9fs_proto_dotu(v9ses)) {
265 inode->i_op = &v9fs_file_inode_operations;
266 inode->i_fop = &v9fs_file_operations;
267 } else {
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600268 P9_DPRINTK(P9_DEBUG_ERROR,
269 "special files without extended mode\n");
270 err = -EINVAL;
271 goto error;
272 }
273 init_special_inode(inode, inode->i_mode, inode->i_rdev);
274 break;
275 case S_IFREG:
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000276 if (v9fs_proto_dotl(v9ses)) {
277 inode->i_op = &v9fs_file_inode_operations_dotl;
Aneesh Kumar K.V29236f42011-02-28 17:03:54 +0530278 if (v9ses->cache)
279 inode->i_fop =
280 &v9fs_cached_file_operations_dotl;
281 else
282 inode->i_fop = &v9fs_file_operations_dotl;
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000283 } else {
284 inode->i_op = &v9fs_file_inode_operations;
Aneesh Kumar K.V29236f42011-02-28 17:03:54 +0530285 if (v9ses->cache)
286 inode->i_fop = &v9fs_cached_file_operations;
287 else
288 inode->i_fop = &v9fs_file_operations;
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000289 }
290
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600291 break;
292 case S_IFLNK:
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000293 if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
294 P9_DPRINTK(P9_DEBUG_ERROR, "extended modes used with "
295 "legacy protocol.\n");
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600296 err = -EINVAL;
297 goto error;
298 }
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000299
300 if (v9fs_proto_dotl(v9ses))
301 inode->i_op = &v9fs_symlink_inode_operations_dotl;
302 else
303 inode->i_op = &v9fs_symlink_inode_operations;
304
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600305 break;
306 case S_IFDIR:
307 inc_nlink(inode);
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000308 if (v9fs_proto_dotl(v9ses))
309 inode->i_op = &v9fs_dir_inode_operations_dotl;
310 else if (v9fs_proto_dotu(v9ses))
311 inode->i_op = &v9fs_dir_inode_operations_dotu;
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600312 else
313 inode->i_op = &v9fs_dir_inode_operations;
Sripathi Kodi9b6533c2010-03-25 12:41:54 +0000314
315 if (v9fs_proto_dotl(v9ses))
316 inode->i_fop = &v9fs_dir_operations_dotl;
317 else
318 inode->i_fop = &v9fs_dir_operations;
319
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600320 break;
321 default:
322 P9_DPRINTK(P9_DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
323 mode, mode & S_IFMT);
324 err = -EINVAL;
325 goto error;
326 }
Abhishek Kulkarni2bb54112009-07-19 13:41:56 -0600327error:
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530328 return err;
329
330}
331
332/**
333 * v9fs_get_inode - helper function to setup an inode
334 * @sb: superblock
335 * @mode: mode to setup inode with
336 *
337 */
338
339struct inode *v9fs_get_inode(struct super_block *sb, int mode)
340{
341 int err;
342 struct inode *inode;
343 struct v9fs_session_info *v9ses = sb->s_fs_info;
344
345 P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
346
347 inode = new_inode(sb);
348 if (!inode) {
349 P9_EPRINTK(KERN_WARNING, "Problem allocating inode\n");
350 return ERR_PTR(-ENOMEM);
351 }
352 err = v9fs_init_inode(v9ses, inode, mode);
353 if (err) {
354 iput(inode);
355 return ERR_PTR(err);
356 }
357 return inode;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700358}
359
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500360/*
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800361static struct v9fs_fid*
362v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
363{
364 int err;
Mika Kukkonen736c4b82006-12-06 20:36:29 -0800365 int nfid;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800366 struct v9fs_fid *ret;
367 struct v9fs_fcall *fcall;
368
369 nfid = v9fs_get_idpool(&v9ses->fidpool);
370 if (nfid < 0) {
371 eprintk(KERN_WARNING, "no free fids available\n");
Latchesar Ionkov731805b2006-03-07 21:55:42 -0800372 return ERR_PTR(-ENOSPC);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800373 }
374
375 err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
376 &fcall);
377
378 if (err < 0) {
Latchesar Ionkov41e5a6a2006-05-15 09:44:21 -0700379 if (fcall && fcall->id == RWALK)
380 goto clunk_fid;
381
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800382 PRINT_FCALL_ERROR("walk error", fcall);
383 v9fs_put_idpool(nfid, &v9ses->fidpool);
384 goto error;
385 }
386
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700387 kfree(fcall);
Latchesar Ionkov3cf64292006-01-08 01:04:58 -0800388 fcall = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800389 ret = v9fs_fid_create(v9ses, nfid);
390 if (!ret) {
391 err = -ENOMEM;
392 goto clunk_fid;
393 }
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700394
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800395 err = v9fs_fid_insert(ret, dentry);
396 if (err < 0) {
397 v9fs_fid_destroy(ret);
398 goto clunk_fid;
Latchesar Ionkov0b8dd172005-09-27 21:45:24 -0700399 }
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800400
401 return ret;
402
403clunk_fid:
404 v9fs_t_clunk(v9ses, nfid);
405
406error:
407 kfree(fcall);
408 return ERR_PTR(err);
409}
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500410*/
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800411
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500412
413/**
414 * v9fs_clear_inode - release an inode
415 * @inode: inode to release
416 *
417 */
Al Virob57922d2010-06-07 14:34:48 -0400418void v9fs_evict_inode(struct inode *inode)
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500419{
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530420 struct v9fs_inode *v9inode = V9FS_I(inode);
421
Al Virob57922d2010-06-07 14:34:48 -0400422 truncate_inode_pages(inode->i_mapping, 0);
423 end_writeback(inode);
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500424 filemap_fdatawrite(inode->i_mapping);
425
426#ifdef CONFIG_9P_FSCACHE
427 v9fs_cache_inode_put_cookie(inode);
428#endif
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530429 /* clunk the fid stashed in writeback_fid */
430 if (v9inode->writeback_fid) {
431 p9_client_clunk(v9inode->writeback_fid);
432 v9inode->writeback_fid = NULL;
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530433 }
Abhishek Kulkarni60e78d22009-09-23 13:00:27 -0500434}
435
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530436static struct inode *v9fs_qid_iget(struct super_block *sb,
437 struct p9_qid *qid,
438 struct p9_wstat *st)
439{
440 int retval, umode;
441 unsigned long i_ino;
442 struct inode *inode;
443 struct v9fs_session_info *v9ses = sb->s_fs_info;
444
445 i_ino = v9fs_qid2ino(qid);
446 inode = iget_locked(sb, i_ino);
447 if (!inode)
448 return ERR_PTR(-ENOMEM);
449 if (!(inode->i_state & I_NEW))
450 return inode;
451 /*
452 * initialize the inode with the stat info
453 * FIXME!! we may need support for stale inodes
454 * later.
455 */
456 umode = p9mode2unixmode(v9ses, st->mode);
457 retval = v9fs_init_inode(v9ses, inode, umode);
458 if (retval)
459 goto error;
460
461 v9fs_stat2inode(st, inode, sb);
462#ifdef CONFIG_9P_FSCACHE
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530463 v9fs_fscache_set_key(inode, &st->qid);
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530464 v9fs_cache_inode_get_cookie(inode);
465#endif
466 unlock_new_inode(inode);
467 return inode;
468error:
469 unlock_new_inode(inode);
470 iput(inode);
471 return ERR_PTR(retval);
472
473}
474
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600475struct inode *
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530476v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
477 struct super_block *sb)
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800478{
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500479 struct p9_wstat *st;
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530480 struct inode *inode = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800481
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500482 st = p9_client_stat(fid);
Abhishek Kulkarni02bc3562009-07-19 13:41:54 -0600483 if (IS_ERR(st))
484 return ERR_CAST(st);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800485
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530486 inode = v9fs_qid_iget(sb, &st->qid, st);
Abhishek Kulkarni02bc3562009-07-19 13:41:54 -0600487 p9stat_free(st);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500488 kfree(st);
Aneesh Kumar K.V5ffc0cb2011-02-28 17:04:01 +0530489 return inode;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700490}
491
492/**
493 * v9fs_remove - helper function to remove files and directories
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700494 * @dir: directory inode that is being deleted
495 * @file: dentry that is being deleted
496 * @rmdir: removing a directory
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700497 *
498 */
499
500static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
501{
Aneesh Kumar K.Vd994f402010-03-29 18:14:50 -0500502 int retval;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500503 struct p9_fid *v9fid;
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530504 struct inode *file_inode;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700505
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500506 P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700507 rmdir);
508
509 file_inode = file->d_inode;
Latchesar Ionkovc959df92007-04-23 14:41:11 -0700510 v9fid = v9fs_fid_clone(file);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500511 if (IS_ERR(v9fid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800512 return PTR_ERR(v9fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700513
Aneesh Kumar K.Vd994f402010-03-29 18:14:50 -0500514 retval = p9_client_remove(v9fid);
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530515 if (!retval) {
516 /*
517 * directories on unlink should have zero
518 * link count
519 */
520 if (rmdir) {
521 clear_nlink(file_inode);
522 drop_nlink(dir);
523 } else
524 drop_nlink(file_inode);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530525
Aneesh Kumar K.V3bc86de2011-02-28 17:04:07 +0530526 v9fs_invalidate_inode_attr(file_inode);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530527 v9fs_invalidate_inode_attr(dir);
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530528 }
Aneesh Kumar K.Vd994f402010-03-29 18:14:50 -0500529 return retval;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700530}
531
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500532/**
533 * v9fs_create - Create a file
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600534 * @v9ses: session information
535 * @dir: directory that dentry is being created in
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500536 * @dentry: dentry that is being created
Abhishek Kulkarni0e155972009-07-19 13:41:55 -0600537 * @extension: 9p2000.u extension string to support devices, etc.
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500538 * @perm: create permissions
539 * @mode: open mode
540 *
541 */
542static struct p9_fid *
543v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
544 struct dentry *dentry, char *extension, u32 perm, u8 mode)
545{
546 int err;
547 char *name;
548 struct p9_fid *dfid, *ofid, *fid;
549 struct inode *inode;
550
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500551 P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
552
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500553 err = 0;
554 ofid = NULL;
555 fid = NULL;
556 name = (char *) dentry->d_name.name;
Venkateswararao Jujjuri6d27e642010-05-10 18:08:28 +0000557 dfid = v9fs_fid_lookup(dentry->d_parent);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500558 if (IS_ERR(dfid)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500559 err = PTR_ERR(dfid);
Venkateswararao Jujjuri6d27e642010-05-10 18:08:28 +0000560 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
561 return ERR_PTR(err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500562 }
563
564 /* clone a fid to use for creation */
565 ofid = p9_client_walk(dfid, 0, NULL, 1);
566 if (IS_ERR(ofid)) {
567 err = PTR_ERR(ofid);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500568 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
Venkateswararao Jujjuri6d27e642010-05-10 18:08:28 +0000569 return ERR_PTR(err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500570 }
571
572 err = p9_client_fcreate(ofid, name, perm, mode, extension);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500573 if (err < 0) {
574 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500575 goto error;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500576 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500577
578 /* now walk from the parent so we can get unopened fid */
Venkateswararao Jujjuri6d27e642010-05-10 18:08:28 +0000579 fid = p9_client_walk(dfid, 1, &name, 1);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500580 if (IS_ERR(fid)) {
581 err = PTR_ERR(fid);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500582 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500583 fid = NULL;
584 goto error;
Venkateswararao Jujjuri6d27e642010-05-10 18:08:28 +0000585 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500586
587 /* instantiate inode and assign the unopened fid to the dentry */
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530588 inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500589 if (IS_ERR(inode)) {
590 err = PTR_ERR(inode);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500591 P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500592 goto error;
593 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500594 d_instantiate(dentry, inode);
Abhishek Kulkarni50fb6d22009-07-19 13:41:57 -0600595 err = v9fs_fid_add(dentry, fid);
596 if (err < 0)
597 goto error;
598
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500599 return ofid;
600
601error:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500602 if (ofid)
603 p9_client_clunk(ofid);
604
605 if (fid)
606 p9_client_clunk(fid);
607
608 return ERR_PTR(err);
609}
610
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700611/**
612 * v9fs_vfs_create - VFS hook to create files
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600613 * @dir: directory inode that is being created
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700614 * @dentry: dentry that is being deleted
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800615 * @mode: create permissions
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700616 * @nd: path information
617 *
618 */
619
620static int
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800621v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700622 struct nameidata *nd)
623{
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800624 int err;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500625 u32 perm;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800626 int flags;
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530627 struct file *filp;
628 struct v9fs_inode *v9inode;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800629 struct v9fs_session_info *v9ses;
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530630 struct p9_fid *fid, *inode_fid;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800631
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500632 err = 0;
633 fid = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800634 v9ses = v9fs_inode2v9ses(dir);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800635 perm = unixmode2p9mode(v9ses, mode);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800636 if (nd && nd->flags & LOOKUP_OPEN)
637 flags = nd->intent.open.flags - 1;
638 else
639 flags = O_RDWR;
640
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500641 fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000642 v9fs_uflags2omode(flags,
643 v9fs_proto_dotu(v9ses)));
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500644 if (IS_ERR(fid)) {
645 err = PTR_ERR(fid);
646 fid = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800647 goto error;
648 }
649
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530650 v9fs_invalidate_inode_attr(dir);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500651 /* if we are opening a file, assign the open fid to the file */
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800652 if (nd && nd->flags & LOOKUP_OPEN) {
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530653 v9inode = V9FS_I(dentry->d_inode);
Aneesh Kumar K.V5a7e0a82011-03-08 16:39:46 +0530654 mutex_lock(&v9inode->v_mutex);
Aneesh Kumar K.V7add6972011-03-08 16:39:49 +0530655 if (v9ses->cache && !v9inode->writeback_fid &&
656 ((flags & O_ACCMODE) != O_RDONLY)) {
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530657 /*
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530658 * clone a fid and add it to writeback_fid
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530659 * we do it during open time instead of
660 * page dirty time via write_begin/page_mkwrite
661 * because we want write after unlink usecase
662 * to work.
663 */
664 inode_fid = v9fs_writeback_fid(dentry);
665 if (IS_ERR(inode_fid)) {
666 err = PTR_ERR(inode_fid);
Aneesh Kumar K.V5a7e0a82011-03-08 16:39:46 +0530667 mutex_unlock(&v9inode->v_mutex);
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530668 goto error;
669 }
Aneesh Kumar K.V6b39f6d2011-02-28 17:04:03 +0530670 v9inode->writeback_fid = (void *) inode_fid;
Aneesh Kumar K.V3cf387d2011-02-28 17:03:57 +0530671 }
Aneesh Kumar K.V5a7e0a82011-03-08 16:39:46 +0530672 mutex_unlock(&v9inode->v_mutex);
Aneesh Kumar K.V877cb3d2010-09-22 12:42:30 +0530673 filp = lookup_instantiate_filp(nd, dentry, generic_file_open);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800674 if (IS_ERR(filp)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500675 err = PTR_ERR(filp);
676 goto error;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800677 }
678
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500679 filp->private_data = fid;
Aneesh Kumar K.V46848de2011-02-28 17:03:55 +0530680#ifdef CONFIG_9P_FSCACHE
681 if (v9ses->cache)
682 v9fs_cache_inode_set_cookie(dentry->d_inode, filp);
683#endif
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500684 } else
685 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800686
687 return 0;
688
689error:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500690 if (fid)
691 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800692
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800693 return err;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700694}
695
696/**
697 * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600698 * @dir: inode that is being unlinked
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700699 * @dentry: dentry that is being unlinked
700 * @mode: mode for new directory
701 *
702 */
703
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800704static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700705{
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800706 int err;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500707 u32 perm;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500708 struct p9_fid *fid;
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530709 struct v9fs_session_info *v9ses;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800710
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500711 P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
712 err = 0;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800713 v9ses = v9fs_inode2v9ses(dir);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800714 perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500715 fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
716 if (IS_ERR(fid)) {
717 err = PTR_ERR(fid);
718 fid = NULL;
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530719 } else {
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530720 inc_nlink(dir);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530721 v9fs_invalidate_inode_attr(dir);
722 }
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800723
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500724 if (fid)
725 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800726
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800727 return err;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700728}
729
730/**
731 * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
732 * @dir: inode that is being walked from
733 * @dentry: dentry that is being walked to?
734 * @nameidata: path data
735 *
736 */
737
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600738struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700739 struct nameidata *nameidata)
740{
741 struct super_block *sb;
742 struct v9fs_session_info *v9ses;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500743 struct p9_fid *dfid, *fid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700744 struct inode *inode;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500745 char *name;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700746 int result = 0;
747
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500748 P9_DPRINTK(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
Latchesar Ionkov731805b2006-03-07 21:55:42 -0800749 dir, dentry->d_name.name, dentry, nameidata);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700750
Sripathi Kodi11e9b492010-03-29 18:13:59 -0500751 if (dentry->d_name.len > NAME_MAX)
752 return ERR_PTR(-ENAMETOOLONG);
753
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700754 sb = dir->i_sb;
755 v9ses = v9fs_inode2v9ses(dir);
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +0530756 /* We can walk d_parent because we hold the dir->i_mutex */
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500757 dfid = v9fs_fid_lookup(dentry->d_parent);
758 if (IS_ERR(dfid))
David Howellse231c2e2008-02-07 00:15:26 -0800759 return ERR_CAST(dfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700760
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500761 name = (char *) dentry->d_name.name;
762 fid = p9_client_walk(dfid, 1, &name, 1);
763 if (IS_ERR(fid)) {
764 result = PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700765 if (result == -ENOENT) {
Aneesh Kumar K.V85e0df22010-05-14 13:04:39 +0000766 inode = NULL;
767 goto inst_out;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700768 }
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700769
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500770 return ERR_PTR(result);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700771 }
772
Aneesh Kumar K.Va78ce052011-02-28 17:04:02 +0530773 inode = v9fs_get_inode_from_fid(v9ses, fid, dir->i_sb);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500774 if (IS_ERR(inode)) {
775 result = PTR_ERR(inode);
776 inode = NULL;
777 goto error;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700778 }
779
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500780 result = v9fs_fid_add(dentry, fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800781 if (result < 0)
Aneesh Kumar K.V9856af82010-09-22 12:24:23 +0530782 goto error_iput;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800783
Aneesh Kumar K.V85e0df22010-05-14 13:04:39 +0000784inst_out:
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700785 d_add(dentry, inode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700786 return NULL;
787
Aneesh Kumar K.V9856af82010-09-22 12:24:23 +0530788error_iput:
789 iput(inode);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500790error:
Julien Brunel62aa5282008-09-24 16:22:22 -0500791 p9_client_clunk(fid);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800792
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700793 return ERR_PTR(result);
794}
795
796/**
797 * v9fs_vfs_unlink - VFS unlink hook to delete an inode
798 * @i: inode that is being unlinked
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700799 * @d: dentry that is being unlinked
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700800 *
801 */
802
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600803int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700804{
805 return v9fs_remove(i, d, 0);
806}
807
808/**
809 * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
810 * @i: inode that is being unlinked
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700811 * @d: dentry that is being unlinked
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700812 *
813 */
814
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600815int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700816{
817 return v9fs_remove(i, d, 1);
818}
819
820/**
821 * v9fs_vfs_rename - VFS hook to rename an inode
822 * @old_dir: old dir inode
823 * @old_dentry: old dentry
824 * @new_dir: new dir inode
825 * @new_dentry: new dentry
826 *
827 */
828
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -0600829int
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700830v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
831 struct inode *new_dir, struct dentry *new_dentry)
832{
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530833 int retval;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500834 struct inode *old_inode;
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530835 struct inode *new_inode;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500836 struct v9fs_session_info *v9ses;
837 struct p9_fid *oldfid;
838 struct p9_fid *olddirfid;
839 struct p9_fid *newdirfid;
840 struct p9_wstat wstat;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700841
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500842 P9_DPRINTK(P9_DEBUG_VFS, "\n");
843 retval = 0;
844 old_inode = old_dentry->d_inode;
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530845 new_inode = new_dentry->d_inode;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500846 v9ses = v9fs_inode2v9ses(old_inode);
847 oldfid = v9fs_fid_lookup(old_dentry);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500848 if (IS_ERR(oldfid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800849 return PTR_ERR(oldfid);
850
851 olddirfid = v9fs_fid_clone(old_dentry->d_parent);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500852 if (IS_ERR(olddirfid)) {
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800853 retval = PTR_ERR(olddirfid);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500854 goto done;
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800855 }
856
857 newdirfid = v9fs_fid_clone(new_dentry->d_parent);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500858 if (IS_ERR(newdirfid)) {
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800859 retval = PTR_ERR(newdirfid);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500860 goto clunk_olddir;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700861 }
862
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +0530863 down_write(&v9ses->rename_sem);
Sripathi Kodi4681dbd2010-03-25 12:47:26 +0000864 if (v9fs_proto_dotl(v9ses)) {
865 retval = p9_client_rename(oldfid, newdirfid,
866 (char *) new_dentry->d_name.name);
867 if (retval != -ENOSYS)
868 goto clunk_newdir;
869 }
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +0530870 if (old_dentry->d_parent != new_dentry->d_parent) {
871 /*
872 * 9P .u can only handle file rename in the same directory
873 */
Sripathi Kodi4681dbd2010-03-25 12:47:26 +0000874
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500875 P9_DPRINTK(P9_DEBUG_ERROR,
876 "old dir and new dir are different\n");
Eric Van Hensbergen621997c2007-01-26 00:57:04 -0800877 retval = -EXDEV;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500878 goto clunk_newdir;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700879 }
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800880 v9fs_blank_wstat(&wstat);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500881 wstat.muid = v9ses->uname;
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800882 wstat.name = (char *) new_dentry->d_name.name;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500883 retval = p9_client_wstat(oldfid, &wstat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700884
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500885clunk_newdir:
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530886 if (!retval) {
887 if (new_inode) {
888 if (S_ISDIR(new_inode->i_mode))
889 clear_nlink(new_inode);
890 else
891 drop_nlink(new_inode);
Aneesh Kumar K.V23b08e92011-02-28 17:04:08 +0530892 /*
893 * Work around vfs rename rehash bug with
894 * FS_RENAME_DOES_D_MOVE
895 */
896 v9fs_invalidate_inode_attr(new_inode);
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530897 }
898 if (S_ISDIR(old_inode->i_mode)) {
899 if (!new_inode)
900 inc_nlink(new_dir);
901 drop_nlink(old_dir);
902 }
Aneesh Kumar K.V3bc86de2011-02-28 17:04:07 +0530903 v9fs_invalidate_inode_attr(old_inode);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +0530904 v9fs_invalidate_inode_attr(old_dir);
905 v9fs_invalidate_inode_attr(new_dir);
Aneesh Kumar K.V3bc86de2011-02-28 17:04:07 +0530906
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +0530907 /* successful rename */
908 d_move(old_dentry, new_dentry);
Aneesh Kumar K.Vb271ec42011-02-28 17:04:05 +0530909 }
Aneesh Kumar K.Va534c8d2010-06-30 19:18:50 +0530910 up_write(&v9ses->rename_sem);
Latchesar Ionkov22150c42007-10-23 13:48:33 -0500911 p9_client_clunk(newdirfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700912
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500913clunk_olddir:
Latchesar Ionkov22150c42007-10-23 13:48:33 -0500914 p9_client_clunk(olddirfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700915
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500916done:
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700917 return retval;
918}
919
920/**
Adrian Bunk943ffb52006-01-10 00:10:13 +0100921 * v9fs_vfs_getattr - retrieve file metadata
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600922 * @mnt: mount information
923 * @dentry: file to get attributes on
924 * @stat: metadata structure to populate
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700925 *
926 */
927
928static int
929v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
930 struct kstat *stat)
931{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500932 int err;
933 struct v9fs_session_info *v9ses;
934 struct p9_fid *fid;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500935 struct p9_wstat *st;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700936
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500937 P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
938 err = -EPERM;
Aneesh Kumar K.V42869c82011-03-08 16:39:50 +0530939 v9ses = v9fs_dentry2v9ses(dentry);
Aneesh Kumar K.Va1211902011-02-28 17:04:01 +0530940 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
941 generic_fillattr(dentry->d_inode, stat);
942 return 0;
943 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500944 fid = v9fs_fid_lookup(dentry);
945 if (IS_ERR(fid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800946 return PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700947
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500948 st = p9_client_stat(fid);
949 if (IS_ERR(st))
950 return PTR_ERR(st);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700951
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500952 v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700953 generic_fillattr(dentry->d_inode, stat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700954
Latchesar Ionkov62b2be52010-08-24 18:13:59 +0000955 p9stat_free(st);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500956 kfree(st);
957 return 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700958}
959
960/**
961 * v9fs_vfs_setattr - set file metadata
962 * @dentry: file whose metadata to set
963 * @iattr: metadata assignment structure
964 *
965 */
966
967static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
968{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500969 int retval;
970 struct v9fs_session_info *v9ses;
971 struct p9_fid *fid;
972 struct p9_wstat wstat;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700973
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500974 P9_DPRINTK(P9_DEBUG_VFS, "\n");
Aneesh Kumar K.V059c1382011-03-08 16:39:48 +0530975 retval = inode_change_ok(dentry->d_inode, iattr);
976 if (retval)
977 return retval;
978
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500979 retval = -EPERM;
Aneesh Kumar K.V42869c82011-03-08 16:39:50 +0530980 v9ses = v9fs_dentry2v9ses(dentry);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500981 fid = v9fs_fid_lookup(dentry);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800982 if(IS_ERR(fid))
983 return PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700984
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800985 v9fs_blank_wstat(&wstat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700986 if (iattr->ia_valid & ATTR_MODE)
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800987 wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700988
989 if (iattr->ia_valid & ATTR_MTIME)
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800990 wstat.mtime = iattr->ia_mtime.tv_sec;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700991
992 if (iattr->ia_valid & ATTR_ATIME)
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800993 wstat.atime = iattr->ia_atime.tv_sec;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700994
995 if (iattr->ia_valid & ATTR_SIZE)
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800996 wstat.length = iattr->ia_size;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700997
Sripathi Kodidd6102f2010-03-05 18:48:00 +0000998 if (v9fs_proto_dotu(v9ses)) {
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800999 if (iattr->ia_valid & ATTR_UID)
1000 wstat.n_uid = iattr->ia_uid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001001
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001002 if (iattr->ia_valid & ATTR_GID)
1003 wstat.n_gid = iattr->ia_gid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001004 }
Aneesh Kumar K.V059c1382011-03-08 16:39:48 +05301005
Aneesh Kumar K.V3dc54362011-02-28 17:04:11 +05301006 /* Write all dirty data */
1007 if (S_ISREG(dentry->d_inode->i_mode))
1008 filemap_write_and_wait(dentry->d_inode->i_mapping);
1009
Aneesh Kumar K.Vf10fc502011-02-28 17:04:10 +05301010 retval = p9_client_wstat(fid, &wstat);
1011 if (retval < 0)
1012 return retval;
Aneesh Kumar K.V059c1382011-03-08 16:39:48 +05301013
1014 if ((iattr->ia_valid & ATTR_SIZE) &&
1015 iattr->ia_size != i_size_read(dentry->d_inode))
1016 truncate_setsize(dentry->d_inode, iattr->ia_size);
1017
Aneesh Kumar K.Vf10fc502011-02-28 17:04:10 +05301018 v9fs_invalidate_inode_attr(dentry->d_inode);
Christoph Hellwig10257742010-06-04 11:30:02 +02001019
1020 setattr_copy(dentry->d_inode, iattr);
1021 mark_inode_dirty(dentry->d_inode);
1022 return 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001023}
1024
1025/**
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001026 * v9fs_stat2inode - populate an inode structure with mistat info
1027 * @stat: Plan 9 metadata (mistat) structure
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001028 * @inode: inode to populate
1029 * @sb: superblock of filesystem
1030 *
1031 */
1032
1033void
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001034v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001035 struct super_block *sb)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001036{
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001037 char ext[32];
Aneesh Kumar K.V57171442010-03-05 14:43:43 -06001038 char tag_name[14];
1039 unsigned int i_nlink;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001040 struct v9fs_session_info *v9ses = sb->s_fs_info;
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +05301041 struct v9fs_inode *v9inode = V9FS_I(inode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001042
1043 inode->i_nlink = 1;
1044
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001045 inode->i_atime.tv_sec = stat->atime;
1046 inode->i_mtime.tv_sec = stat->mtime;
1047 inode->i_ctime.tv_sec = stat->mtime;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001048
Latchesar Ionkovbd32b822007-10-17 14:31:07 -05001049 inode->i_uid = v9ses->dfltuid;
1050 inode->i_gid = v9ses->dfltgid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001051
Sripathi Kodidd6102f2010-03-05 18:48:00 +00001052 if (v9fs_proto_dotu(v9ses)) {
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001053 inode->i_uid = stat->n_uid;
1054 inode->i_gid = stat->n_gid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001055 }
Aneesh Kumar K.V57171442010-03-05 14:43:43 -06001056 if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
1057 if (v9fs_proto_dotu(v9ses) && (stat->extension[0] != '\0')) {
1058 /*
1059 * Hadlink support got added later to
1060 * to the .u extension. So there can be
1061 * server out there that doesn't support
1062 * this even with .u extension. So check
1063 * for non NULL stat->extension
1064 */
1065 strncpy(ext, stat->extension, sizeof(ext));
1066 /* HARDLINKCOUNT %u */
1067 sscanf(ext, "%13s %u", tag_name, &i_nlink);
1068 if (!strncmp(tag_name, "HARDLINKCOUNT", 13))
1069 inode->i_nlink = i_nlink;
1070 }
1071 }
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001072 inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001073 if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
1074 char type = 0;
1075 int major = -1;
1076 int minor = -1;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001077
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001078 strncpy(ext, stat->extension, sizeof(ext));
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001079 sscanf(ext, "%c %u %u", &type, &major, &minor);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001080 switch (type) {
1081 case 'c':
1082 inode->i_mode &= ~S_IFBLK;
1083 inode->i_mode |= S_IFCHR;
1084 break;
1085 case 'b':
1086 break;
1087 default:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001088 P9_DPRINTK(P9_DEBUG_ERROR,
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001089 "Unknown special type %c %s\n", type,
1090 stat->extension);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001091 };
1092 inode->i_rdev = MKDEV(major, minor);
Magnus Deininger57c7b4e2008-10-17 12:44:46 -05001093 init_special_inode(inode, inode->i_mode, inode->i_rdev);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001094 } else
1095 inode->i_rdev = 0;
1096
Abhishek Kulkarni7549ae32009-09-22 11:34:05 -05001097 i_size_write(inode, stat->length);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001098
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001099 /* not real number of blocks, but 512 byte ones ... */
Abhishek Kulkarni7549ae32009-09-22 11:34:05 -05001100 inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +05301101 v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001102}
1103
1104/**
1105 * v9fs_qid2ino - convert qid into inode number
1106 * @qid: qid to hash
1107 *
1108 * BUG: potential for inode number collisions?
1109 */
1110
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001111ino_t v9fs_qid2ino(struct p9_qid *qid)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001112{
1113 u64 path = qid->path + 2;
1114 ino_t i = 0;
1115
1116 if (sizeof(ino_t) == sizeof(path))
1117 memcpy(&i, &path, sizeof(ino_t));
1118 else
1119 i = (ino_t) (path ^ (path >> 32));
1120
1121 return i;
1122}
1123
1124/**
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001125 * v9fs_readlink - read a symlink's location (internal version)
1126 * @dentry: dentry for symlink
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001127 * @buffer: buffer to load symlink location into
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001128 * @buflen: length of buffer
1129 *
1130 */
1131
1132static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
1133{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001134 int retval;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001135
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001136 struct v9fs_session_info *v9ses;
1137 struct p9_fid *fid;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001138 struct p9_wstat *st;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001139
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001140 P9_DPRINTK(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
1141 retval = -EPERM;
Aneesh Kumar K.V42869c82011-03-08 16:39:50 +05301142 v9ses = v9fs_dentry2v9ses(dentry);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001143 fid = v9fs_fid_lookup(dentry);
Latchesar Ionkovba176742007-10-17 14:31:07 -05001144 if (IS_ERR(fid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001145 return PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001146
M. Mohan Kumar329176c2010-09-28 19:59:25 +05301147 if (!v9fs_proto_dotu(v9ses))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001148 return -EBADF;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001149
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001150 st = p9_client_stat(fid);
1151 if (IS_ERR(st))
1152 return PTR_ERR(st);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001153
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001154 if (!(st->mode & P9_DMSYMLINK)) {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001155 retval = -EINVAL;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001156 goto done;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001157 }
1158
1159 /* copy extension buffer into buffer */
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001160 strncpy(buffer, st->extension, buflen);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001161
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001162 P9_DPRINTK(P9_DEBUG_VFS,
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -05001163 "%s -> %s (%s)\n", dentry->d_name.name, st->extension, buffer);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001164
Martin Stava2511cd02009-11-02 08:39:34 -06001165 retval = strnlen(buffer, buflen);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001166done:
Latchesar Ionkov62b2be52010-08-24 18:13:59 +00001167 p9stat_free(st);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001168 kfree(st);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001169 return retval;
1170}
1171
1172/**
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001173 * v9fs_vfs_follow_link - follow a symlink path
1174 * @dentry: dentry for symlink
1175 * @nd: nameidata
1176 *
1177 */
1178
1179static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
1180{
1181 int len = 0;
1182 char *link = __getname();
1183
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001184 P9_DPRINTK(P9_DEBUG_VFS, "%s n", dentry->d_name.name);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001185
1186 if (!link)
1187 link = ERR_PTR(-ENOMEM);
1188 else {
Latchesar Ionkov16cce6d2006-03-25 03:07:26 -08001189 len = v9fs_readlink(dentry, link, PATH_MAX);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001190
1191 if (len < 0) {
Davi Arnautce44eeb2005-11-07 00:59:36 -08001192 __putname(link);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001193 link = ERR_PTR(len);
1194 } else
Martin Stava2511cd02009-11-02 08:39:34 -06001195 link[min(len, PATH_MAX-1)] = 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001196 }
1197 nd_set_link(nd, link);
1198
1199 return NULL;
1200}
1201
1202/**
1203 * v9fs_vfs_put_link - release a symlink path
1204 * @dentry: dentry for symlink
1205 * @nd: nameidata
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001206 * @p: unused
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001207 *
1208 */
1209
Aneesh Kumar K.V53c06f42011-01-10 13:51:47 -06001210void
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001211v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001212{
1213 char *s = nd_get_link(nd);
1214
Duane Griffin6ff23202008-12-19 16:45:21 -06001215 P9_DPRINTK(P9_DEBUG_VFS, " %s %s\n", dentry->d_name.name,
1216 IS_ERR(s) ? "<error>" : s);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001217 if (!IS_ERR(s))
Davi Arnautce44eeb2005-11-07 00:59:36 -08001218 __putname(s);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001219}
1220
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001221/**
1222 * v9fs_vfs_mkspecial - create a special file
1223 * @dir: inode to create special file in
1224 * @dentry: dentry to create
1225 * @mode: mode to create special file
1226 * @extension: 9p2000.u format extension string representing special file
1227 *
1228 */
1229
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001230static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1231 int mode, const char *extension)
1232{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001233 u32 perm;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001234 struct p9_fid *fid;
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +05301235 struct v9fs_session_info *v9ses;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001236
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -08001237 v9ses = v9fs_inode2v9ses(dir);
Sripathi Kodidd6102f2010-03-05 18:48:00 +00001238 if (!v9fs_proto_dotu(v9ses)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001239 P9_DPRINTK(P9_DEBUG_ERROR, "not extended\n");
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -08001240 return -EPERM;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001241 }
1242
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001243 perm = unixmode2p9mode(v9ses, mode);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001244 fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1245 P9_OREAD);
1246 if (IS_ERR(fid))
1247 return PTR_ERR(fid);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001248
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +05301249 v9fs_invalidate_inode_attr(dir);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001250 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -08001251 return 0;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001252}
1253
1254/**
1255 * v9fs_vfs_symlink - helper function to create symlinks
1256 * @dir: directory inode containing symlink
1257 * @dentry: dentry for symlink
1258 * @symname: symlink data
1259 *
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001260 * See Also: 9P2000.u RFC for more information
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001261 *
1262 */
1263
1264static int
1265v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1266{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001267 P9_DPRINTK(P9_DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino,
1268 dentry->d_name.name, symname);
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001269
1270 return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
1271}
1272
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001273/**
1274 * v9fs_vfs_link - create a hardlink
1275 * @old_dentry: dentry for file to link to
1276 * @dir: inode destination for new link
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001277 * @dentry: dentry for link
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001278 *
1279 */
1280
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001281static int
1282v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1283 struct dentry *dentry)
1284{
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001285 int retval;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001286 char *name;
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +05301287 struct p9_fid *oldfid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001288
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001289 P9_DPRINTK(P9_DEBUG_VFS,
1290 " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001291 old_dentry->d_name.name);
1292
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001293 oldfid = v9fs_fid_clone(old_dentry);
Latchesar Ionkovba176742007-10-17 14:31:07 -05001294 if (IS_ERR(oldfid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001295 return PTR_ERR(oldfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001296
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001297 name = __getname();
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001298 if (unlikely(!name)) {
1299 retval = -ENOMEM;
1300 goto clunk_fid;
1301 }
Florin Malita0710d362006-06-25 05:48:31 -07001302
Latchesar Ionkov16cce6d2006-03-25 03:07:26 -08001303 sprintf(name, "%d\n", oldfid->fid);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001304 retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001305 __putname(name);
Aneesh Kumar K.Vc06c0662011-02-28 17:04:09 +05301306 if (!retval) {
1307 v9fs_refresh_inode(oldfid, old_dentry->d_inode);
Aneesh Kumar K.Vd28c61f2011-02-28 17:04:08 +05301308 v9fs_invalidate_inode_attr(dir);
Aneesh Kumar K.Vc06c0662011-02-28 17:04:09 +05301309 }
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001310clunk_fid:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001311 p9_client_clunk(oldfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001312 return retval;
1313}
1314
1315/**
1316 * v9fs_vfs_mknod - create a special file
1317 * @dir: inode destination for new link
1318 * @dentry: dentry for file
1319 * @mode: mode for creation
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001320 * @rdev: device associated with special file
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001321 *
1322 */
1323
1324static int
1325v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1326{
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001327 int retval;
1328 char *name;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001329
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001330 P9_DPRINTK(P9_DEBUG_VFS,
1331 " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001332 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
1333
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001334 if (!new_valid_dev(rdev))
1335 return -EINVAL;
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001336
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001337 name = __getname();
Eugene Teoc0291a02006-03-25 03:07:27 -08001338 if (!name)
1339 return -ENOMEM;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001340 /* build extension */
1341 if (S_ISBLK(mode))
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001342 sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001343 else if (S_ISCHR(mode))
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001344 sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001345 else if (S_ISFIFO(mode))
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001346 *name = 0;
Venkateswararao Jujjuri75cc5c92010-05-22 12:20:30 -05001347 else if (S_ISSOCK(mode))
1348 *name = 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001349 else {
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001350 __putname(name);
1351 return -EINVAL;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001352 }
1353
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001354 retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
1355 __putname(name);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001356
1357 return retval;
1358}
1359
Aneesh Kumar K.Vb3cbea02011-02-28 17:04:06 +05301360int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
1361{
1362 loff_t i_size;
1363 struct p9_wstat *st;
1364 struct v9fs_session_info *v9ses;
1365
1366 v9ses = v9fs_inode2v9ses(inode);
1367 st = p9_client_stat(fid);
1368 if (IS_ERR(st))
1369 return PTR_ERR(st);
1370
1371 spin_lock(&inode->i_lock);
1372 /*
1373 * We don't want to refresh inode->i_size,
1374 * because we may have cached data
1375 */
1376 i_size = inode->i_size;
1377 v9fs_stat2inode(st, inode, inode->i_sb);
1378 if (v9ses->cache)
1379 inode->i_size = i_size;
1380 spin_unlock(&inode->i_lock);
1381 p9stat_free(st);
1382 kfree(st);
1383 return 0;
1384}
1385
Sripathi Kodi9b6533c2010-03-25 12:41:54 +00001386static const struct inode_operations v9fs_dir_inode_operations_dotu = {
1387 .create = v9fs_vfs_create,
1388 .lookup = v9fs_vfs_lookup,
1389 .symlink = v9fs_vfs_symlink,
Venkateswararao Jujjuri (JV)50cc42f2010-06-09 15:59:31 -07001390 .link = v9fs_vfs_link,
Sripathi Kodi9b6533c2010-03-25 12:41:54 +00001391 .unlink = v9fs_vfs_unlink,
1392 .mkdir = v9fs_vfs_mkdir,
1393 .rmdir = v9fs_vfs_rmdir,
Aneesh Kumar K.V1d76e312010-08-30 17:43:07 +00001394 .mknod = v9fs_vfs_mknod,
Sripathi Kodi9b6533c2010-03-25 12:41:54 +00001395 .rename = v9fs_vfs_rename,
1396 .getattr = v9fs_vfs_getattr,
1397 .setattr = v9fs_vfs_setattr,
1398};
1399
Arjan van de Ven754661f2007-02-12 00:55:38 -08001400static const struct inode_operations v9fs_dir_inode_operations = {
Eric Van Hensbergenb5016112005-09-09 13:04:27 -07001401 .create = v9fs_vfs_create,
1402 .lookup = v9fs_vfs_lookup,
1403 .unlink = v9fs_vfs_unlink,
1404 .mkdir = v9fs_vfs_mkdir,
1405 .rmdir = v9fs_vfs_rmdir,
1406 .mknod = v9fs_vfs_mknod,
1407 .rename = v9fs_vfs_rename,
1408 .getattr = v9fs_vfs_getattr,
1409 .setattr = v9fs_vfs_setattr,
1410};
1411
Arjan van de Ven754661f2007-02-12 00:55:38 -08001412static const struct inode_operations v9fs_file_inode_operations = {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001413 .getattr = v9fs_vfs_getattr,
1414 .setattr = v9fs_vfs_setattr,
1415};
1416
Arjan van de Ven754661f2007-02-12 00:55:38 -08001417static const struct inode_operations v9fs_symlink_inode_operations = {
Al Viro204f2f02009-12-23 00:35:54 -05001418 .readlink = generic_readlink,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001419 .follow_link = v9fs_vfs_follow_link,
1420 .put_link = v9fs_vfs_put_link,
1421 .getattr = v9fs_vfs_getattr,
1422 .setattr = v9fs_vfs_setattr,
1423};
Sripathi Kodi9b6533c2010-03-25 12:41:54 +00001424