blob: 8314d3f43b716f41560e4517d42eaade5cfc1459 [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>
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050037#include <net/9p/9p.h>
38#include <net/9p/client.h>
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070039
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070040#include "v9fs.h"
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070041#include "v9fs_vfs.h"
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070042#include "fid.h"
43
Arjan van de Ven754661f2007-02-12 00:55:38 -080044static const struct inode_operations v9fs_dir_inode_operations;
45static const struct inode_operations v9fs_dir_inode_operations_ext;
46static const struct inode_operations v9fs_file_inode_operations;
47static const struct inode_operations v9fs_symlink_inode_operations;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070048
49/**
50 * unixmode2p9mode - convert unix mode bits to plan 9
51 * @v9ses: v9fs session information
52 * @mode: mode to convert
53 *
54 */
55
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -070056static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070057{
58 int res;
59 res = mode & 0777;
60 if (S_ISDIR(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050061 res |= P9_DMDIR;
Latchesar Ionkov24056692007-10-17 14:31:07 -050062 if (v9fs_extended(v9ses)) {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070063 if (S_ISLNK(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050064 res |= P9_DMSYMLINK;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070065 if (v9ses->nodev == 0) {
66 if (S_ISSOCK(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050067 res |= P9_DMSOCKET;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070068 if (S_ISFIFO(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050069 res |= P9_DMNAMEDPIPE;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070070 if (S_ISBLK(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050071 res |= P9_DMDEVICE;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070072 if (S_ISCHR(mode))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050073 res |= P9_DMDEVICE;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070074 }
75
76 if ((mode & S_ISUID) == S_ISUID)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050077 res |= P9_DMSETUID;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070078 if ((mode & S_ISGID) == S_ISGID)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050079 res |= P9_DMSETGID;
Anthony Liguorid199d652008-02-06 19:25:06 -060080 if ((mode & S_ISVTX) == S_ISVTX)
81 res |= P9_DMSETVTX;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -050082 if ((mode & P9_DMLINK))
83 res |= P9_DMLINK;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070084 }
85
86 return res;
87}
88
89/**
90 * p9mode2unixmode- convert plan9 mode bits to unix mode bits
91 * @v9ses: v9fs session information
92 * @mode: mode to convert
93 *
94 */
95
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -070096static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -070097{
98 int res;
99
100 res = mode & 0777;
101
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500102 if ((mode & P9_DMDIR) == P9_DMDIR)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700103 res |= S_IFDIR;
Latchesar Ionkov24056692007-10-17 14:31:07 -0500104 else if ((mode & P9_DMSYMLINK) && (v9fs_extended(v9ses)))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700105 res |= S_IFLNK;
Latchesar Ionkov24056692007-10-17 14:31:07 -0500106 else if ((mode & P9_DMSOCKET) && (v9fs_extended(v9ses))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700107 && (v9ses->nodev == 0))
108 res |= S_IFSOCK;
Latchesar Ionkov24056692007-10-17 14:31:07 -0500109 else if ((mode & P9_DMNAMEDPIPE) && (v9fs_extended(v9ses))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700110 && (v9ses->nodev == 0))
111 res |= S_IFIFO;
Latchesar Ionkov24056692007-10-17 14:31:07 -0500112 else if ((mode & P9_DMDEVICE) && (v9fs_extended(v9ses))
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700113 && (v9ses->nodev == 0))
114 res |= S_IFBLK;
115 else
116 res |= S_IFREG;
117
Latchesar Ionkov24056692007-10-17 14:31:07 -0500118 if (v9fs_extended(v9ses)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500119 if ((mode & P9_DMSETUID) == P9_DMSETUID)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700120 res |= S_ISUID;
121
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500122 if ((mode & P9_DMSETGID) == P9_DMSETGID)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700123 res |= S_ISGID;
Anthony Liguorid199d652008-02-06 19:25:06 -0600124
125 if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
126 res |= S_ISVTX;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700127 }
128
129 return res;
130}
131
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600132/**
133 * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
134 * @uflags: flags to convert
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500135 * @extended: if .u extensions are active
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600136 */
137
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500138int v9fs_uflags2omode(int uflags, int extended)
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800139{
140 int ret;
141
142 ret = 0;
143 switch (uflags&3) {
144 default:
145 case O_RDONLY:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500146 ret = P9_OREAD;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800147 break;
148
149 case O_WRONLY:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500150 ret = P9_OWRITE;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800151 break;
152
153 case O_RDWR:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500154 ret = P9_ORDWR;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800155 break;
156 }
157
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800158 if (uflags & O_TRUNC)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500159 ret |= P9_OTRUNC;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800160
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500161 if (extended) {
162 if (uflags & O_EXCL)
163 ret |= P9_OEXCL;
164
165 if (uflags & O_APPEND)
166 ret |= P9_OAPPEND;
167 }
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800168
169 return ret;
170}
171
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700172/**
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800173 * v9fs_blank_wstat - helper function to setup a 9P stat structure
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700174 * @v9ses: 9P session info (for determining extended mode)
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800175 * @wstat: structure to initialize
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700176 *
177 */
178
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700179static void
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500180v9fs_blank_wstat(struct p9_wstat *wstat)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700181{
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800182 wstat->type = ~0;
183 wstat->dev = ~0;
184 wstat->qid.type = ~0;
185 wstat->qid.version = ~0;
186 *((long long *)&wstat->qid.path) = ~0;
187 wstat->mode = ~0;
188 wstat->atime = ~0;
189 wstat->mtime = ~0;
190 wstat->length = ~0;
191 wstat->name = NULL;
192 wstat->uid = NULL;
193 wstat->gid = NULL;
194 wstat->muid = NULL;
195 wstat->n_uid = ~0;
196 wstat->n_gid = ~0;
197 wstat->n_muid = ~0;
198 wstat->extension = NULL;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700199}
200
201/**
202 * v9fs_get_inode - helper function to setup an inode
203 * @sb: superblock
204 * @mode: mode to setup inode with
205 *
206 */
207
208struct inode *v9fs_get_inode(struct super_block *sb, int mode)
209{
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800210 struct inode *inode;
Eric Van Hensbergenb5016112005-09-09 13:04:27 -0700211 struct v9fs_session_info *v9ses = sb->s_fs_info;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700212
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500213 P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700214
215 inode = new_inode(sb);
216 if (inode) {
217 inode->i_mode = mode;
218 inode->i_uid = current->fsuid;
219 inode->i_gid = current->fsgid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700220 inode->i_blocks = 0;
221 inode->i_rdev = 0;
222 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
Eric Van Hensbergen147b31c2006-01-18 17:43:02 -0800223 inode->i_mapping->a_ops = &v9fs_addr_operations;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700224
225 switch (mode & S_IFMT) {
226 case S_IFIFO:
227 case S_IFBLK:
228 case S_IFCHR:
229 case S_IFSOCK:
Latchesar Ionkov24056692007-10-17 14:31:07 -0500230 if (!v9fs_extended(v9ses)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500231 P9_DPRINTK(P9_DEBUG_ERROR,
232 "special files without extended mode\n");
Eric Van Hensbergenb5016112005-09-09 13:04:27 -0700233 return ERR_PTR(-EINVAL);
234 }
Eric Van Hensbergen5d58bec2005-09-09 13:04:27 -0700235 init_special_inode(inode, inode->i_mode,
236 inode->i_rdev);
237 break;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700238 case S_IFREG:
239 inode->i_op = &v9fs_file_inode_operations;
240 inode->i_fop = &v9fs_file_operations;
241 break;
Eric Van Hensbergenb5016112005-09-09 13:04:27 -0700242 case S_IFLNK:
Latchesar Ionkov24056692007-10-17 14:31:07 -0500243 if (!v9fs_extended(v9ses)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500244 P9_DPRINTK(P9_DEBUG_ERROR,
245 "extended modes used w/o 9P2000.u\n");
Eric Van Hensbergenb5016112005-09-09 13:04:27 -0700246 return ERR_PTR(-EINVAL);
247 }
248 inode->i_op = &v9fs_symlink_inode_operations;
249 break;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700250 case S_IFDIR:
Dave Hansend8c76e62006-09-30 23:29:04 -0700251 inc_nlink(inode);
Latchesar Ionkov24056692007-10-17 14:31:07 -0500252 if (v9fs_extended(v9ses))
Eric Van Hensbergenb5016112005-09-09 13:04:27 -0700253 inode->i_op = &v9fs_dir_inode_operations_ext;
254 else
255 inode->i_op = &v9fs_dir_inode_operations;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700256 inode->i_fop = &v9fs_dir_operations;
257 break;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700258 default:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500259 P9_DPRINTK(P9_DEBUG_ERROR,
260 "BAD mode 0x%x S_IFMT 0x%x\n",
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700261 mode, mode & S_IFMT);
262 return ERR_PTR(-EINVAL);
263 }
264 } else {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500265 P9_EPRINTK(KERN_WARNING, "Problem allocating inode\n");
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700266 return ERR_PTR(-ENOMEM);
267 }
268 return inode;
269}
270
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500271/*
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800272static struct v9fs_fid*
273v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
274{
275 int err;
Mika Kukkonen736c4b82006-12-06 20:36:29 -0800276 int nfid;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800277 struct v9fs_fid *ret;
278 struct v9fs_fcall *fcall;
279
280 nfid = v9fs_get_idpool(&v9ses->fidpool);
281 if (nfid < 0) {
282 eprintk(KERN_WARNING, "no free fids available\n");
Latchesar Ionkov731805b2006-03-07 21:55:42 -0800283 return ERR_PTR(-ENOSPC);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800284 }
285
286 err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
287 &fcall);
288
289 if (err < 0) {
Latchesar Ionkov41e5a6a2006-05-15 09:44:21 -0700290 if (fcall && fcall->id == RWALK)
291 goto clunk_fid;
292
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800293 PRINT_FCALL_ERROR("walk error", fcall);
294 v9fs_put_idpool(nfid, &v9ses->fidpool);
295 goto error;
296 }
297
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700298 kfree(fcall);
Latchesar Ionkov3cf64292006-01-08 01:04:58 -0800299 fcall = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800300 ret = v9fs_fid_create(v9ses, nfid);
301 if (!ret) {
302 err = -ENOMEM;
303 goto clunk_fid;
304 }
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700305
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800306 err = v9fs_fid_insert(ret, dentry);
307 if (err < 0) {
308 v9fs_fid_destroy(ret);
309 goto clunk_fid;
Latchesar Ionkov0b8dd172005-09-27 21:45:24 -0700310 }
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800311
312 return ret;
313
314clunk_fid:
315 v9fs_t_clunk(v9ses, nfid);
316
317error:
318 kfree(fcall);
319 return ERR_PTR(err);
320}
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500321*/
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800322
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600323/**
324 * v9fs_inode_from_fid - populate an inode by issuing a attribute request
325 * @v9ses: session information
326 * @fid: fid to issue attribute request for
327 * @sb: superblock on which to create inode
328 *
329 */
330
Latchesar Ionkov5174fda2006-03-25 03:07:25 -0800331static struct inode *
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500332v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800333 struct super_block *sb)
334{
335 int err, umode;
336 struct inode *ret;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500337 struct p9_wstat *st;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800338
339 ret = NULL;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500340 st = p9_client_stat(fid);
341 if (IS_ERR(st)) {
342 err = PTR_ERR(st);
343 st = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800344 goto error;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700345 }
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800346
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500347 umode = p9mode2unixmode(v9ses, st->mode);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800348 ret = v9fs_get_inode(sb, umode);
349 if (IS_ERR(ret)) {
350 err = PTR_ERR(ret);
351 ret = NULL;
352 goto error;
353 }
354
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500355 v9fs_stat2inode(st, ret, sb);
356 ret->i_ino = v9fs_qid2ino(&st->qid);
357 kfree(st);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800358 return ret;
359
360error:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500361 kfree(st);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800362 if (ret)
363 iput(ret);
364
365 return ERR_PTR(err);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700366}
367
368/**
369 * v9fs_remove - helper function to remove files and directories
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700370 * @dir: directory inode that is being deleted
371 * @file: dentry that is being deleted
372 * @rmdir: removing a directory
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700373 *
374 */
375
376static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
377{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500378 struct inode *file_inode;
379 struct v9fs_session_info *v9ses;
380 struct p9_fid *v9fid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700381
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500382 P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700383 rmdir);
384
385 file_inode = file->d_inode;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700386 v9ses = v9fs_inode2v9ses(file_inode);
Latchesar Ionkovc959df92007-04-23 14:41:11 -0700387 v9fid = v9fs_fid_clone(file);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500388 if (IS_ERR(v9fid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800389 return PTR_ERR(v9fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700390
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500391 return p9_client_remove(v9fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700392}
393
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800394static int
395v9fs_open_created(struct inode *inode, struct file *file)
396{
397 return 0;
398}
399
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500400
401/**
402 * v9fs_create - Create a file
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600403 * @v9ses: session information
404 * @dir: directory that dentry is being created in
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500405 * @dentry: dentry that is being created
406 * @perm: create permissions
407 * @mode: open mode
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600408 * @extension: 9p2000.u extension string to support devices, etc.
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500409 *
410 */
411static struct p9_fid *
412v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
413 struct dentry *dentry, char *extension, u32 perm, u8 mode)
414{
415 int err;
416 char *name;
417 struct p9_fid *dfid, *ofid, *fid;
418 struct inode *inode;
419
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500420 P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
421
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500422 err = 0;
423 ofid = NULL;
424 fid = NULL;
425 name = (char *) dentry->d_name.name;
426 dfid = v9fs_fid_clone(dentry->d_parent);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500427 if (IS_ERR(dfid)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500428 err = PTR_ERR(dfid);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500429 P9_DPRINTK(P9_DEBUG_VFS, "fid clone failed %d\n", err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500430 dfid = NULL;
431 goto error;
432 }
433
434 /* clone a fid to use for creation */
435 ofid = p9_client_walk(dfid, 0, NULL, 1);
436 if (IS_ERR(ofid)) {
437 err = PTR_ERR(ofid);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500438 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500439 ofid = NULL;
440 goto error;
441 }
442
443 err = p9_client_fcreate(ofid, name, perm, mode, extension);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500444 if (err < 0) {
445 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500446 goto error;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500447 }
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500448
449 /* now walk from the parent so we can get unopened fid */
450 fid = p9_client_walk(dfid, 1, &name, 0);
451 if (IS_ERR(fid)) {
452 err = PTR_ERR(fid);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500453 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500454 fid = NULL;
455 goto error;
456 } else
457 dfid = NULL;
458
459 /* instantiate inode and assign the unopened fid to the dentry */
460 inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
461 if (IS_ERR(inode)) {
462 err = PTR_ERR(inode);
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500463 P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500464 goto error;
465 }
466
Latchesar Ionkovba176742007-10-17 14:31:07 -0500467 if (v9ses->cache)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500468 dentry->d_op = &v9fs_cached_dentry_operations;
469 else
470 dentry->d_op = &v9fs_dentry_operations;
471
472 d_instantiate(dentry, inode);
473 v9fs_fid_add(dentry, fid);
474 return ofid;
475
476error:
477 if (dfid)
478 p9_client_clunk(dfid);
479
480 if (ofid)
481 p9_client_clunk(ofid);
482
483 if (fid)
484 p9_client_clunk(fid);
485
486 return ERR_PTR(err);
487}
488
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700489/**
490 * v9fs_vfs_create - VFS hook to create files
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600491 * @dir: directory inode that is being created
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700492 * @dentry: dentry that is being deleted
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800493 * @mode: create permissions
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700494 * @nd: path information
495 *
496 */
497
498static int
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800499v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700500 struct nameidata *nd)
501{
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800502 int err;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500503 u32 perm;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800504 int flags;
505 struct v9fs_session_info *v9ses;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500506 struct p9_fid *fid;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800507 struct file *filp;
508
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500509 err = 0;
510 fid = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800511 v9ses = v9fs_inode2v9ses(dir);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800512 perm = unixmode2p9mode(v9ses, mode);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800513 if (nd && nd->flags & LOOKUP_OPEN)
514 flags = nd->intent.open.flags - 1;
515 else
516 flags = O_RDWR;
517
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500518 fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
Eric Van Hensbergen2e4bef42008-06-24 17:39:39 -0500519 v9fs_uflags2omode(flags, v9fs_extended(v9ses)));
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500520 if (IS_ERR(fid)) {
521 err = PTR_ERR(fid);
522 fid = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800523 goto error;
524 }
525
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500526 /* if we are opening a file, assign the open fid to the file */
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800527 if (nd && nd->flags & LOOKUP_OPEN) {
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800528 filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
529 if (IS_ERR(filp)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500530 err = PTR_ERR(filp);
531 goto error;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800532 }
533
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500534 filp->private_data = fid;
535 } else
536 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800537
538 return 0;
539
540error:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500541 if (fid)
542 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800543
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800544 return err;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700545}
546
547/**
548 * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600549 * @dir: inode that is being unlinked
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700550 * @dentry: dentry that is being unlinked
551 * @mode: mode for new directory
552 *
553 */
554
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800555static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700556{
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800557 int err;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500558 u32 perm;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800559 struct v9fs_session_info *v9ses;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500560 struct p9_fid *fid;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800561
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500562 P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
563 err = 0;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800564 v9ses = v9fs_inode2v9ses(dir);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800565 perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500566 fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
567 if (IS_ERR(fid)) {
568 err = PTR_ERR(fid);
569 fid = NULL;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800570 }
571
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500572 if (fid)
573 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800574
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800575 return err;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700576}
577
578/**
579 * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
580 * @dir: inode that is being walked from
581 * @dentry: dentry that is being walked to?
582 * @nameidata: path data
583 *
584 */
585
586static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
587 struct nameidata *nameidata)
588{
589 struct super_block *sb;
590 struct v9fs_session_info *v9ses;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500591 struct p9_fid *dfid, *fid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700592 struct inode *inode;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500593 char *name;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700594 int result = 0;
595
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500596 P9_DPRINTK(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
Latchesar Ionkov731805b2006-03-07 21:55:42 -0800597 dir, dentry->d_name.name, dentry, nameidata);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700598
599 sb = dir->i_sb;
600 v9ses = v9fs_inode2v9ses(dir);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500601 dfid = v9fs_fid_lookup(dentry->d_parent);
602 if (IS_ERR(dfid))
David Howellse231c2e2008-02-07 00:15:26 -0800603 return ERR_CAST(dfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700604
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500605 name = (char *) dentry->d_name.name;
606 fid = p9_client_walk(dfid, 1, &name, 1);
607 if (IS_ERR(fid)) {
608 result = PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700609 if (result == -ENOENT) {
610 d_add(dentry, NULL);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700611 return NULL;
612 }
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700613
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500614 return ERR_PTR(result);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700615 }
616
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500617 inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
618 if (IS_ERR(inode)) {
619 result = PTR_ERR(inode);
620 inode = NULL;
621 goto error;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700622 }
623
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500624 result = v9fs_fid_add(dentry, fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800625 if (result < 0)
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500626 goto error;
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -0800627
Latchesar Ionkovba176742007-10-17 14:31:07 -0500628 if ((fid->qid.version) && (v9ses->cache))
Eric Van Hensbergene03abc02007-02-11 13:21:39 -0600629 dentry->d_op = &v9fs_cached_dentry_operations;
630 else
631 dentry->d_op = &v9fs_dentry_operations;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700632
633 d_add(dentry, inode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700634 return NULL;
635
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500636error:
Julien Brunel62aa5282008-09-24 16:22:22 -0500637 p9_client_clunk(fid);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800638
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700639 return ERR_PTR(result);
640}
641
642/**
643 * v9fs_vfs_unlink - VFS unlink hook to delete an inode
644 * @i: inode that is being unlinked
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700645 * @d: dentry that is being unlinked
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700646 *
647 */
648
649static int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
650{
651 return v9fs_remove(i, d, 0);
652}
653
654/**
655 * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
656 * @i: inode that is being unlinked
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700657 * @d: dentry that is being unlinked
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700658 *
659 */
660
661static int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
662{
663 return v9fs_remove(i, d, 1);
664}
665
666/**
667 * v9fs_vfs_rename - VFS hook to rename an inode
668 * @old_dir: old dir inode
669 * @old_dentry: old dentry
670 * @new_dir: new dir inode
671 * @new_dentry: new dentry
672 *
673 */
674
675static int
676v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
677 struct inode *new_dir, struct dentry *new_dentry)
678{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500679 struct inode *old_inode;
680 struct v9fs_session_info *v9ses;
681 struct p9_fid *oldfid;
682 struct p9_fid *olddirfid;
683 struct p9_fid *newdirfid;
684 struct p9_wstat wstat;
685 int retval;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700686
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500687 P9_DPRINTK(P9_DEBUG_VFS, "\n");
688 retval = 0;
689 old_inode = old_dentry->d_inode;
690 v9ses = v9fs_inode2v9ses(old_inode);
691 oldfid = v9fs_fid_lookup(old_dentry);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500692 if (IS_ERR(oldfid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800693 return PTR_ERR(oldfid);
694
695 olddirfid = v9fs_fid_clone(old_dentry->d_parent);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500696 if (IS_ERR(olddirfid)) {
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800697 retval = PTR_ERR(olddirfid);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500698 goto done;
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800699 }
700
701 newdirfid = v9fs_fid_clone(new_dentry->d_parent);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500702 if (IS_ERR(newdirfid)) {
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800703 retval = PTR_ERR(newdirfid);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500704 goto clunk_olddir;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700705 }
706
707 /* 9P can only handle file rename in the same directory */
708 if (memcmp(&olddirfid->qid, &newdirfid->qid, sizeof(newdirfid->qid))) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500709 P9_DPRINTK(P9_DEBUG_ERROR,
710 "old dir and new dir are different\n");
Eric Van Hensbergen621997c2007-01-26 00:57:04 -0800711 retval = -EXDEV;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500712 goto clunk_newdir;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700713 }
714
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800715 v9fs_blank_wstat(&wstat);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500716 wstat.muid = v9ses->uname;
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800717 wstat.name = (char *) new_dentry->d_name.name;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500718 retval = p9_client_wstat(oldfid, &wstat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700719
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500720clunk_newdir:
Latchesar Ionkov22150c42007-10-23 13:48:33 -0500721 p9_client_clunk(newdirfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700722
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500723clunk_olddir:
Latchesar Ionkov22150c42007-10-23 13:48:33 -0500724 p9_client_clunk(olddirfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700725
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500726done:
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700727 return retval;
728}
729
730/**
Adrian Bunk943ffb52006-01-10 00:10:13 +0100731 * v9fs_vfs_getattr - retrieve file metadata
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600732 * @mnt: mount information
733 * @dentry: file to get attributes on
734 * @stat: metadata structure to populate
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700735 *
736 */
737
738static int
739v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
740 struct kstat *stat)
741{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500742 int err;
743 struct v9fs_session_info *v9ses;
744 struct p9_fid *fid;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500745 struct p9_wstat *st;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700746
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500747 P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
748 err = -EPERM;
749 v9ses = v9fs_inode2v9ses(dentry->d_inode);
Eric Van Hensbergen9523a842007-07-13 13:01:27 -0500750 if (v9ses->cache == CACHE_LOOSE)
751 return simple_getattr(mnt, dentry, stat);
752
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500753 fid = v9fs_fid_lookup(dentry);
754 if (IS_ERR(fid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800755 return PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700756
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500757 st = p9_client_stat(fid);
758 if (IS_ERR(st))
759 return PTR_ERR(st);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700760
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500761 v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700762 generic_fillattr(dentry->d_inode, stat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700763
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500764 kfree(st);
765 return 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700766}
767
768/**
769 * v9fs_vfs_setattr - set file metadata
770 * @dentry: file whose metadata to set
771 * @iattr: metadata assignment structure
772 *
773 */
774
775static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
776{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500777 int retval;
778 struct v9fs_session_info *v9ses;
779 struct p9_fid *fid;
780 struct p9_wstat wstat;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700781
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500782 P9_DPRINTK(P9_DEBUG_VFS, "\n");
783 retval = -EPERM;
784 v9ses = v9fs_inode2v9ses(dentry->d_inode);
785 fid = v9fs_fid_lookup(dentry);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800786 if(IS_ERR(fid))
787 return PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700788
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800789 v9fs_blank_wstat(&wstat);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700790 if (iattr->ia_valid & ATTR_MODE)
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800791 wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700792
793 if (iattr->ia_valid & ATTR_MTIME)
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800794 wstat.mtime = iattr->ia_mtime.tv_sec;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700795
796 if (iattr->ia_valid & ATTR_ATIME)
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800797 wstat.atime = iattr->ia_atime.tv_sec;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700798
799 if (iattr->ia_valid & ATTR_SIZE)
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800800 wstat.length = iattr->ia_size;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700801
Latchesar Ionkov24056692007-10-17 14:31:07 -0500802 if (v9fs_extended(v9ses)) {
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800803 if (iattr->ia_valid & ATTR_UID)
804 wstat.n_uid = iattr->ia_uid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700805
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800806 if (iattr->ia_valid & ATTR_GID)
807 wstat.n_gid = iattr->ia_gid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700808 }
809
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500810 retval = p9_client_wstat(fid, &wstat);
811 if (retval >= 0)
812 retval = inode_setattr(dentry->d_inode, iattr);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700813
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500814 return retval;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700815}
816
817/**
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800818 * v9fs_stat2inode - populate an inode structure with mistat info
819 * @stat: Plan 9 metadata (mistat) structure
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700820 * @inode: inode to populate
821 * @sb: superblock of filesystem
822 *
823 */
824
825void
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500826v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800827 struct super_block *sb)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700828{
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800829 char ext[32];
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700830 struct v9fs_session_info *v9ses = sb->s_fs_info;
831
832 inode->i_nlink = 1;
833
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800834 inode->i_atime.tv_sec = stat->atime;
835 inode->i_mtime.tv_sec = stat->mtime;
836 inode->i_ctime.tv_sec = stat->mtime;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700837
Latchesar Ionkovbd32b822007-10-17 14:31:07 -0500838 inode->i_uid = v9ses->dfltuid;
839 inode->i_gid = v9ses->dfltgid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700840
Latchesar Ionkov24056692007-10-17 14:31:07 -0500841 if (v9fs_extended(v9ses)) {
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800842 inode->i_uid = stat->n_uid;
843 inode->i_gid = stat->n_gid;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700844 }
845
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800846 inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700847 if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
848 char type = 0;
849 int major = -1;
850 int minor = -1;
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800851
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500852 strncpy(ext, stat->extension, sizeof(ext));
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800853 sscanf(ext, "%c %u %u", &type, &major, &minor);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700854 switch (type) {
855 case 'c':
856 inode->i_mode &= ~S_IFBLK;
857 inode->i_mode |= S_IFCHR;
858 break;
859 case 'b':
860 break;
861 default:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500862 P9_DPRINTK(P9_DEBUG_ERROR,
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500863 "Unknown special type %c %s\n", type,
864 stat->extension);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700865 };
866 inode->i_rdev = MKDEV(major, minor);
Magnus Deininger57c7b4e2008-10-17 12:44:46 -0500867 init_special_inode(inode, inode->i_mode, inode->i_rdev);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700868 } else
869 inode->i_rdev = 0;
870
Latchesar Ionkov531b1092006-01-08 01:05:00 -0800871 inode->i_size = stat->length;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700872
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500873 /* not real number of blocks, but 512 byte ones ... */
874 inode->i_blocks = (inode->i_size + 512 - 1) >> 9;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700875}
876
877/**
878 * v9fs_qid2ino - convert qid into inode number
879 * @qid: qid to hash
880 *
881 * BUG: potential for inode number collisions?
882 */
883
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500884ino_t v9fs_qid2ino(struct p9_qid *qid)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700885{
886 u64 path = qid->path + 2;
887 ino_t i = 0;
888
889 if (sizeof(ino_t) == sizeof(path))
890 memcpy(&i, &path, sizeof(ino_t));
891 else
892 i = (ino_t) (path ^ (path >> 32));
893
894 return i;
895}
896
897/**
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700898 * v9fs_readlink - read a symlink's location (internal version)
899 * @dentry: dentry for symlink
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -0700900 * @buffer: buffer to load symlink location into
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700901 * @buflen: length of buffer
902 *
903 */
904
905static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
906{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500907 int retval;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700908
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500909 struct v9fs_session_info *v9ses;
910 struct p9_fid *fid;
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500911 struct p9_wstat *st;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700912
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500913 P9_DPRINTK(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
914 retval = -EPERM;
915 v9ses = v9fs_inode2v9ses(dentry->d_inode);
916 fid = v9fs_fid_lookup(dentry);
Latchesar Ionkovba176742007-10-17 14:31:07 -0500917 if (IS_ERR(fid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -0800918 return PTR_ERR(fid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700919
Latchesar Ionkov24056692007-10-17 14:31:07 -0500920 if (!v9fs_extended(v9ses))
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500921 return -EBADF;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700922
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500923 st = p9_client_stat(fid);
924 if (IS_ERR(st))
925 return PTR_ERR(st);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700926
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500927 if (!(st->mode & P9_DMSYMLINK)) {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700928 retval = -EINVAL;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500929 goto done;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700930 }
931
932 /* copy extension buffer into buffer */
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500933 strncpy(buffer, st->extension, buflen);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700934
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500935 P9_DPRINTK(P9_DEBUG_VFS,
Eric Van Hensbergen51a87c52008-10-16 08:30:07 -0500936 "%s -> %s (%s)\n", dentry->d_name.name, st->extension, buffer);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500937
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700938 retval = buflen;
939
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500940done:
941 kfree(st);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700942 return retval;
943}
944
945/**
946 * v9fs_vfs_readlink - read a symlink's location
947 * @dentry: dentry for symlink
Eric Van Hensbergenee443992008-03-05 07:08:09 -0600948 * @buffer: buffer to load symlink location into
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700949 * @buflen: length of buffer
950 *
951 */
952
953static int v9fs_vfs_readlink(struct dentry *dentry, char __user * buffer,
954 int buflen)
955{
956 int retval;
957 int ret;
958 char *link = __getname();
959
Florin Malita0710d362006-06-25 05:48:31 -0700960 if (unlikely(!link))
961 return -ENOMEM;
962
Latchesar Ionkova1f9d8d2005-09-22 21:43:52 -0700963 if (buflen > PATH_MAX)
964 buflen = PATH_MAX;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700965
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500966 P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700967
968 retval = v9fs_readlink(dentry, link, buflen);
969
970 if (retval > 0) {
971 if ((ret = copy_to_user(buffer, link, retval)) != 0) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500972 P9_DPRINTK(P9_DEBUG_ERROR,
973 "problem copying to user: %d\n", ret);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700974 retval = ret;
975 }
976 }
977
Davi Arnautce44eeb2005-11-07 00:59:36 -0800978 __putname(link);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700979 return retval;
980}
981
982/**
983 * v9fs_vfs_follow_link - follow a symlink path
984 * @dentry: dentry for symlink
985 * @nd: nameidata
986 *
987 */
988
989static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
990{
991 int len = 0;
992 char *link = __getname();
993
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -0500994 P9_DPRINTK(P9_DEBUG_VFS, "%s n", dentry->d_name.name);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -0700995
996 if (!link)
997 link = ERR_PTR(-ENOMEM);
998 else {
Latchesar Ionkov16cce6d2006-03-25 03:07:26 -0800999 len = v9fs_readlink(dentry, link, PATH_MAX);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001000
1001 if (len < 0) {
Davi Arnautce44eeb2005-11-07 00:59:36 -08001002 __putname(link);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001003 link = ERR_PTR(len);
1004 } else
1005 link[len] = 0;
1006 }
1007 nd_set_link(nd, link);
1008
1009 return NULL;
1010}
1011
1012/**
1013 * v9fs_vfs_put_link - release a symlink path
1014 * @dentry: dentry for symlink
1015 * @nd: nameidata
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001016 * @p: unused
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001017 *
1018 */
1019
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001020static void
1021v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001022{
1023 char *s = nd_get_link(nd);
1024
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001025 P9_DPRINTK(P9_DEBUG_VFS, " %s %s\n", dentry->d_name.name, s);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001026 if (!IS_ERR(s))
Davi Arnautce44eeb2005-11-07 00:59:36 -08001027 __putname(s);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001028}
1029
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001030/**
1031 * v9fs_vfs_mkspecial - create a special file
1032 * @dir: inode to create special file in
1033 * @dentry: dentry to create
1034 * @mode: mode to create special file
1035 * @extension: 9p2000.u format extension string representing special file
1036 *
1037 */
1038
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001039static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1040 int mode, const char *extension)
1041{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001042 u32 perm;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001043 struct v9fs_session_info *v9ses;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001044 struct p9_fid *fid;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001045
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -08001046 v9ses = v9fs_inode2v9ses(dir);
Latchesar Ionkov24056692007-10-17 14:31:07 -05001047 if (!v9fs_extended(v9ses)) {
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001048 P9_DPRINTK(P9_DEBUG_ERROR, "not extended\n");
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -08001049 return -EPERM;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001050 }
1051
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001052 perm = unixmode2p9mode(v9ses, mode);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001053 fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1054 P9_OREAD);
1055 if (IS_ERR(fid))
1056 return PTR_ERR(fid);
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001057
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001058 p9_client_clunk(fid);
Latchesar Ionkov6a3124a2006-03-02 02:54:30 -08001059 return 0;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001060}
1061
1062/**
1063 * v9fs_vfs_symlink - helper function to create symlinks
1064 * @dir: directory inode containing symlink
1065 * @dentry: dentry for symlink
1066 * @symname: symlink data
1067 *
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001068 * See Also: 9P2000.u RFC for more information
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001069 *
1070 */
1071
1072static int
1073v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1074{
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001075 P9_DPRINTK(P9_DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino,
1076 dentry->d_name.name, symname);
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001077
1078 return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
1079}
1080
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001081/**
1082 * v9fs_vfs_link - create a hardlink
1083 * @old_dentry: dentry for file to link to
1084 * @dir: inode destination for new link
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001085 * @dentry: dentry for link
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001086 *
1087 */
1088
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001089static int
1090v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1091 struct dentry *dentry)
1092{
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001093 int retval;
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001094 struct p9_fid *oldfid;
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001095 char *name;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001096
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001097 P9_DPRINTK(P9_DEBUG_VFS,
1098 " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001099 old_dentry->d_name.name);
1100
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001101 oldfid = v9fs_fid_clone(old_dentry);
Latchesar Ionkovba176742007-10-17 14:31:07 -05001102 if (IS_ERR(oldfid))
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001103 return PTR_ERR(oldfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001104
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001105 name = __getname();
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001106 if (unlikely(!name)) {
1107 retval = -ENOMEM;
1108 goto clunk_fid;
1109 }
Florin Malita0710d362006-06-25 05:48:31 -07001110
Latchesar Ionkov16cce6d2006-03-25 03:07:26 -08001111 sprintf(name, "%d\n", oldfid->fid);
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001112 retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001113 __putname(name);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001114
Eric Van Hensbergenda977b22007-01-26 00:57:06 -08001115clunk_fid:
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001116 p9_client_clunk(oldfid);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001117 return retval;
1118}
1119
1120/**
1121 * v9fs_vfs_mknod - create a special file
1122 * @dir: inode destination for new link
1123 * @dentry: dentry for file
1124 * @mode: mode for creation
Eric Van Hensbergenee443992008-03-05 07:08:09 -06001125 * @rdev: device associated with special file
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001126 *
1127 */
1128
1129static int
1130v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1131{
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001132 int retval;
1133 char *name;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001134
Latchesar Ionkovbd238fb2007-07-10 17:57:28 -05001135 P9_DPRINTK(P9_DEBUG_VFS,
1136 " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001137 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
1138
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001139 if (!new_valid_dev(rdev))
1140 return -EINVAL;
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001141
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001142 name = __getname();
Eugene Teoc0291a02006-03-25 03:07:27 -08001143 if (!name)
1144 return -ENOMEM;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001145 /* build extension */
1146 if (S_ISBLK(mode))
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001147 sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001148 else if (S_ISCHR(mode))
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001149 sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
Eric Van Hensbergen73c592b2005-09-09 13:04:26 -07001150 else if (S_ISFIFO(mode))
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001151 *name = 0;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001152 else {
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001153 __putname(name);
1154 return -EINVAL;
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001155 }
1156
Latchesar Ionkov531b1092006-01-08 01:05:00 -08001157 retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
1158 __putname(name);
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001159
1160 return retval;
1161}
1162
Arjan van de Ven754661f2007-02-12 00:55:38 -08001163static const struct inode_operations v9fs_dir_inode_operations_ext = {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001164 .create = v9fs_vfs_create,
1165 .lookup = v9fs_vfs_lookup,
1166 .symlink = v9fs_vfs_symlink,
1167 .link = v9fs_vfs_link,
1168 .unlink = v9fs_vfs_unlink,
1169 .mkdir = v9fs_vfs_mkdir,
1170 .rmdir = v9fs_vfs_rmdir,
1171 .mknod = v9fs_vfs_mknod,
1172 .rename = v9fs_vfs_rename,
1173 .readlink = v9fs_vfs_readlink,
1174 .getattr = v9fs_vfs_getattr,
1175 .setattr = v9fs_vfs_setattr,
1176};
1177
Arjan van de Ven754661f2007-02-12 00:55:38 -08001178static const struct inode_operations v9fs_dir_inode_operations = {
Eric Van Hensbergenb5016112005-09-09 13:04:27 -07001179 .create = v9fs_vfs_create,
1180 .lookup = v9fs_vfs_lookup,
1181 .unlink = v9fs_vfs_unlink,
1182 .mkdir = v9fs_vfs_mkdir,
1183 .rmdir = v9fs_vfs_rmdir,
1184 .mknod = v9fs_vfs_mknod,
1185 .rename = v9fs_vfs_rename,
1186 .getattr = v9fs_vfs_getattr,
1187 .setattr = v9fs_vfs_setattr,
1188};
1189
Arjan van de Ven754661f2007-02-12 00:55:38 -08001190static const struct inode_operations v9fs_file_inode_operations = {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001191 .getattr = v9fs_vfs_getattr,
1192 .setattr = v9fs_vfs_setattr,
1193};
1194
Arjan van de Ven754661f2007-02-12 00:55:38 -08001195static const struct inode_operations v9fs_symlink_inode_operations = {
Eric Van Hensbergen2bad8472005-09-09 13:04:19 -07001196 .readlink = v9fs_vfs_readlink,
1197 .follow_link = v9fs_vfs_follow_link,
1198 .put_link = v9fs_vfs_put_link,
1199 .getattr = v9fs_vfs_getattr,
1200 .setattr = v9fs_vfs_setattr,
1201};