39dc795673229bc7870754261ed239fc4b0be617
[linux-2.6.git] / fs / 9p / vfs_inode.c
1 /*
2  *  linux/fs/9p/vfs_inode.c
3  *
4  * This file contains vfs inode ops for the 9P2000 protocol.
5  *
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
10  *  it under the terms of the GNU General Public License version 2
11  *  as published by the Free Software Foundation.
12  *
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>
33 #include <linux/inet.h>
34 #include <linux/namei.h>
35 #include <linux/idr.h>
36 #include <linux/sched.h>
37 #include <linux/slab.h>
38 #include <net/9p/9p.h>
39 #include <net/9p/client.h>
40
41 #include "v9fs.h"
42 #include "v9fs_vfs.h"
43 #include "fid.h"
44 #include "cache.h"
45
46 static const struct inode_operations v9fs_dir_inode_operations;
47 static const struct inode_operations v9fs_dir_inode_operations_dotu;
48 static const struct inode_operations v9fs_dir_inode_operations_dotl;
49 static const struct inode_operations v9fs_file_inode_operations;
50 static const struct inode_operations v9fs_file_inode_operations_dotl;
51 static const struct inode_operations v9fs_symlink_inode_operations;
52 static const struct inode_operations v9fs_symlink_inode_operations_dotl;
53
54 /**
55  * unixmode2p9mode - convert unix mode bits to plan 9
56  * @v9ses: v9fs session information
57  * @mode: mode to convert
58  *
59  */
60
61 static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
62 {
63         int res;
64         res = mode & 0777;
65         if (S_ISDIR(mode))
66                 res |= P9_DMDIR;
67         if (v9fs_proto_dotu(v9ses)) {
68                 if (S_ISLNK(mode))
69                         res |= P9_DMSYMLINK;
70                 if (v9ses->nodev == 0) {
71                         if (S_ISSOCK(mode))
72                                 res |= P9_DMSOCKET;
73                         if (S_ISFIFO(mode))
74                                 res |= P9_DMNAMEDPIPE;
75                         if (S_ISBLK(mode))
76                                 res |= P9_DMDEVICE;
77                         if (S_ISCHR(mode))
78                                 res |= P9_DMDEVICE;
79                 }
80
81                 if ((mode & S_ISUID) == S_ISUID)
82                         res |= P9_DMSETUID;
83                 if ((mode & S_ISGID) == S_ISGID)
84                         res |= P9_DMSETGID;
85                 if ((mode & S_ISVTX) == S_ISVTX)
86                         res |= P9_DMSETVTX;
87                 if ((mode & P9_DMLINK))
88                         res |= P9_DMLINK;
89         }
90
91         return res;
92 }
93
94 /**
95  * p9mode2unixmode- convert plan9 mode bits to unix mode bits
96  * @v9ses: v9fs session information
97  * @mode: mode to convert
98  *
99  */
100
101 static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
102 {
103         int res;
104
105         res = mode & 0777;
106
107         if ((mode & P9_DMDIR) == P9_DMDIR)
108                 res |= S_IFDIR;
109         else if ((mode & P9_DMSYMLINK) && (v9fs_proto_dotu(v9ses)))
110                 res |= S_IFLNK;
111         else if ((mode & P9_DMSOCKET) && (v9fs_proto_dotu(v9ses))
112                  && (v9ses->nodev == 0))
113                 res |= S_IFSOCK;
114         else if ((mode & P9_DMNAMEDPIPE) && (v9fs_proto_dotu(v9ses))
115                  && (v9ses->nodev == 0))
116                 res |= S_IFIFO;
117         else if ((mode & P9_DMDEVICE) && (v9fs_proto_dotu(v9ses))
118                  && (v9ses->nodev == 0))
119                 res |= S_IFBLK;
120         else
121                 res |= S_IFREG;
122
123         if (v9fs_proto_dotu(v9ses)) {
124                 if ((mode & P9_DMSETUID) == P9_DMSETUID)
125                         res |= S_ISUID;
126
127                 if ((mode & P9_DMSETGID) == P9_DMSETGID)
128                         res |= S_ISGID;
129
130                 if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
131                         res |= S_ISVTX;
132         }
133
134         return res;
135 }
136
137 /**
138  * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
139  * @uflags: flags to convert
140  * @extended: if .u extensions are active
141  */
142
143 int v9fs_uflags2omode(int uflags, int extended)
144 {
145         int ret;
146
147         ret = 0;
148         switch (uflags&3) {
149         default:
150         case O_RDONLY:
151                 ret = P9_OREAD;
152                 break;
153
154         case O_WRONLY:
155                 ret = P9_OWRITE;
156                 break;
157
158         case O_RDWR:
159                 ret = P9_ORDWR;
160                 break;
161         }
162
163         if (uflags & O_TRUNC)
164                 ret |= P9_OTRUNC;
165
166         if (extended) {
167                 if (uflags & O_EXCL)
168                         ret |= P9_OEXCL;
169
170                 if (uflags & O_APPEND)
171                         ret |= P9_OAPPEND;
172         }
173
174         return ret;
175 }
176
177 /**
178  * v9fs_blank_wstat - helper function to setup a 9P stat structure
179  * @wstat: structure to initialize
180  *
181  */
182
183 void
184 v9fs_blank_wstat(struct p9_wstat *wstat)
185 {
186         wstat->type = ~0;
187         wstat->dev = ~0;
188         wstat->qid.type = ~0;
189         wstat->qid.version = ~0;
190         *((long long *)&wstat->qid.path) = ~0;
191         wstat->mode = ~0;
192         wstat->atime = ~0;
193         wstat->mtime = ~0;
194         wstat->length = ~0;
195         wstat->name = NULL;
196         wstat->uid = NULL;
197         wstat->gid = NULL;
198         wstat->muid = NULL;
199         wstat->n_uid = ~0;
200         wstat->n_gid = ~0;
201         wstat->n_muid = ~0;
202         wstat->extension = NULL;
203 }
204
205 #ifdef CONFIG_9P_FSCACHE
206 /**
207  * v9fs_alloc_inode - helper function to allocate an inode
208  * This callback is executed before setting up the inode so that we
209  * can associate a vcookie with each inode.
210  *
211  */
212
213 struct inode *v9fs_alloc_inode(struct super_block *sb)
214 {
215         struct v9fs_cookie *vcookie;
216         vcookie = (struct v9fs_cookie *)kmem_cache_alloc(vcookie_cache,
217                                                          GFP_KERNEL);
218         if (!vcookie)
219                 return NULL;
220
221         vcookie->fscache = NULL;
222         vcookie->qid = NULL;
223         spin_lock_init(&vcookie->lock);
224         return &vcookie->inode;
225 }
226
227 /**
228  * v9fs_destroy_inode - destroy an inode
229  *
230  */
231
232 void v9fs_destroy_inode(struct inode *inode)
233 {
234         kmem_cache_free(vcookie_cache, v9fs_inode2cookie(inode));
235 }
236 #endif
237
238 /**
239  * v9fs_get_fsgid_for_create - Helper function to get the gid for creating a
240  * new file system object. This checks the S_ISGID to determine the owning
241  * group of the new file system object.
242  */
243
244 static gid_t v9fs_get_fsgid_for_create(struct inode *dir_inode)
245 {
246         BUG_ON(dir_inode == NULL);
247
248         if (dir_inode->i_mode & S_ISGID) {
249                 /* set_gid bit is set.*/
250                 return dir_inode->i_gid;
251         }
252         return current_fsgid();
253 }
254
255 /**
256  * v9fs_dentry_from_dir_inode - helper function to get the dentry from
257  * dir inode.
258  *
259  */
260
261 struct dentry *v9fs_dentry_from_dir_inode(struct inode *inode)
262 {
263         struct dentry *dentry;
264
265         spin_lock(&dcache_lock);
266         /* Directory should have only one entry. */
267         BUG_ON(S_ISDIR(inode->i_mode) && !list_is_singular(&inode->i_dentry));
268         dentry = list_entry(inode->i_dentry.next, struct dentry, d_alias);
269         spin_unlock(&dcache_lock);
270         return dentry;
271 }
272
273 /**
274  * v9fs_get_inode - helper function to setup an inode
275  * @sb: superblock
276  * @mode: mode to setup inode with
277  *
278  */
279
280 struct inode *v9fs_get_inode(struct super_block *sb, int mode)
281 {
282         int err;
283         struct inode *inode;
284         struct v9fs_session_info *v9ses = sb->s_fs_info;
285
286         P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
287
288         inode = new_inode(sb);
289         if (!inode) {
290                 P9_EPRINTK(KERN_WARNING, "Problem allocating inode\n");
291                 return ERR_PTR(-ENOMEM);
292         }
293
294         inode_init_owner(inode, NULL, mode);
295         inode->i_blocks = 0;
296         inode->i_rdev = 0;
297         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
298         inode->i_mapping->a_ops = &v9fs_addr_operations;
299
300         switch (mode & S_IFMT) {
301         case S_IFIFO:
302         case S_IFBLK:
303         case S_IFCHR:
304         case S_IFSOCK:
305                 if (v9fs_proto_dotl(v9ses)) {
306                         inode->i_op = &v9fs_file_inode_operations_dotl;
307                         inode->i_fop = &v9fs_file_operations_dotl;
308                 } else if (v9fs_proto_dotu(v9ses)) {
309                         inode->i_op = &v9fs_file_inode_operations;
310                         inode->i_fop = &v9fs_file_operations;
311                 } else {
312                         P9_DPRINTK(P9_DEBUG_ERROR,
313                                    "special files without extended mode\n");
314                         err = -EINVAL;
315                         goto error;
316                 }
317                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
318                 break;
319         case S_IFREG:
320                 if (v9fs_proto_dotl(v9ses)) {
321                         inode->i_op = &v9fs_file_inode_operations_dotl;
322                         inode->i_fop = &v9fs_file_operations_dotl;
323                 } else {
324                         inode->i_op = &v9fs_file_inode_operations;
325                         inode->i_fop = &v9fs_file_operations;
326                 }
327
328                 break;
329
330         case S_IFLNK:
331                 if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)) {
332                         P9_DPRINTK(P9_DEBUG_ERROR, "extended modes used with "
333                                                 "legacy protocol.\n");
334                         err = -EINVAL;
335                         goto error;
336                 }
337
338                 if (v9fs_proto_dotl(v9ses))
339                         inode->i_op = &v9fs_symlink_inode_operations_dotl;
340                 else
341                         inode->i_op = &v9fs_symlink_inode_operations;
342
343                 break;
344         case S_IFDIR:
345                 inc_nlink(inode);
346                 if (v9fs_proto_dotl(v9ses))
347                         inode->i_op = &v9fs_dir_inode_operations_dotl;
348                 else if (v9fs_proto_dotu(v9ses))
349                         inode->i_op = &v9fs_dir_inode_operations_dotu;
350                 else
351                         inode->i_op = &v9fs_dir_inode_operations;
352
353                 if (v9fs_proto_dotl(v9ses))
354                         inode->i_fop = &v9fs_dir_operations_dotl;
355                 else
356                         inode->i_fop = &v9fs_dir_operations;
357
358                 break;
359         default:
360                 P9_DPRINTK(P9_DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
361                            mode, mode & S_IFMT);
362                 err = -EINVAL;
363                 goto error;
364         }
365
366         return inode;
367
368 error:
369         iput(inode);
370         return ERR_PTR(err);
371 }
372
373 /*
374 static struct v9fs_fid*
375 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
376 {
377         int err;
378         int nfid;
379         struct v9fs_fid *ret;
380         struct v9fs_fcall *fcall;
381
382         nfid = v9fs_get_idpool(&v9ses->fidpool);
383         if (nfid < 0) {
384                 eprintk(KERN_WARNING, "no free fids available\n");
385                 return ERR_PTR(-ENOSPC);
386         }
387
388         err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
389                 &fcall);
390
391         if (err < 0) {
392                 if (fcall && fcall->id == RWALK)
393                         goto clunk_fid;
394
395                 PRINT_FCALL_ERROR("walk error", fcall);
396                 v9fs_put_idpool(nfid, &v9ses->fidpool);
397                 goto error;
398         }
399
400         kfree(fcall);
401         fcall = NULL;
402         ret = v9fs_fid_create(v9ses, nfid);
403         if (!ret) {
404                 err = -ENOMEM;
405                 goto clunk_fid;
406         }
407
408         err = v9fs_fid_insert(ret, dentry);
409         if (err < 0) {
410                 v9fs_fid_destroy(ret);
411                 goto clunk_fid;
412         }
413
414         return ret;
415
416 clunk_fid:
417         v9fs_t_clunk(v9ses, nfid);
418
419 error:
420         kfree(fcall);
421         return ERR_PTR(err);
422 }
423 */
424
425
426 /**
427  * v9fs_clear_inode - release an inode
428  * @inode: inode to release
429  *
430  */
431 void v9fs_clear_inode(struct inode *inode)
432 {
433         filemap_fdatawrite(inode->i_mapping);
434
435 #ifdef CONFIG_9P_FSCACHE
436         v9fs_cache_inode_put_cookie(inode);
437 #endif
438 }
439
440 static struct inode *
441 v9fs_inode(struct v9fs_session_info *v9ses, struct p9_fid *fid,
442         struct super_block *sb)
443 {
444         int err, umode;
445         struct inode *ret = NULL;
446         struct p9_wstat *st;
447
448         st = p9_client_stat(fid);
449         if (IS_ERR(st))
450                 return ERR_CAST(st);
451
452         umode = p9mode2unixmode(v9ses, st->mode);
453         ret = v9fs_get_inode(sb, umode);
454         if (IS_ERR(ret)) {
455                 err = PTR_ERR(ret);
456                 goto error;
457         }
458
459         v9fs_stat2inode(st, ret, sb);
460         ret->i_ino = v9fs_qid2ino(&st->qid);
461
462 #ifdef CONFIG_9P_FSCACHE
463         v9fs_vcookie_set_qid(ret, &st->qid);
464         v9fs_cache_inode_get_cookie(ret);
465 #endif
466         p9stat_free(st);
467         kfree(st);
468         return ret;
469 error:
470         p9stat_free(st);
471         kfree(st);
472         return ERR_PTR(err);
473 }
474
475 static struct inode *
476 v9fs_inode_dotl(struct v9fs_session_info *v9ses, struct p9_fid *fid,
477         struct super_block *sb)
478 {
479         struct inode *ret = NULL;
480         int err;
481         struct p9_stat_dotl *st;
482
483         st = p9_client_getattr_dotl(fid, P9_STATS_BASIC);
484         if (IS_ERR(st))
485                 return ERR_CAST(st);
486
487         ret = v9fs_get_inode(sb, st->st_mode);
488         if (IS_ERR(ret)) {
489                 err = PTR_ERR(ret);
490                 goto error;
491         }
492
493         v9fs_stat2inode_dotl(st, ret);
494         ret->i_ino = v9fs_qid2ino(&st->qid);
495 #ifdef CONFIG_9P_FSCACHE
496         v9fs_vcookie_set_qid(ret, &st->qid);
497         v9fs_cache_inode_get_cookie(ret);
498 #endif
499         kfree(st);
500         return ret;
501 error:
502         kfree(st);
503         return ERR_PTR(err);
504 }
505
506 /**
507  * v9fs_inode_from_fid - Helper routine to populate an inode by
508  * issuing a attribute request
509  * @v9ses: session information
510  * @fid: fid to issue attribute request for
511  * @sb: superblock on which to create inode
512  *
513  */
514 static inline struct inode *
515 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
516                         struct super_block *sb)
517 {
518         if (v9fs_proto_dotl(v9ses))
519                 return v9fs_inode_dotl(v9ses, fid, sb);
520         else
521                 return v9fs_inode(v9ses, fid, sb);
522 }
523
524 /**
525  * v9fs_remove - helper function to remove files and directories
526  * @dir: directory inode that is being deleted
527  * @file:  dentry that is being deleted
528  * @rmdir: removing a directory
529  *
530  */
531
532 static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
533 {
534         int retval;
535         struct inode *file_inode;
536         struct p9_fid *v9fid;
537
538         P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
539                 rmdir);
540
541         file_inode = file->d_inode;
542         v9fid = v9fs_fid_clone(file);
543         if (IS_ERR(v9fid))
544                 return PTR_ERR(v9fid);
545
546         retval = p9_client_remove(v9fid);
547         if (!retval)
548                 drop_nlink(file_inode);
549         return retval;
550 }
551
552 static int
553 v9fs_open_created(struct inode *inode, struct file *file)
554 {
555         return 0;
556 }
557
558
559 /**
560  * v9fs_create - Create a file
561  * @v9ses: session information
562  * @dir: directory that dentry is being created in
563  * @dentry:  dentry that is being created
564  * @extension: 9p2000.u extension string to support devices, etc.
565  * @perm: create permissions
566  * @mode: open mode
567  *
568  */
569 static struct p9_fid *
570 v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
571                 struct dentry *dentry, char *extension, u32 perm, u8 mode)
572 {
573         int err;
574         char *name;
575         struct p9_fid *dfid, *ofid, *fid;
576         struct inode *inode;
577
578         P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
579
580         err = 0;
581         ofid = NULL;
582         fid = NULL;
583         name = (char *) dentry->d_name.name;
584         dfid = v9fs_fid_lookup(dentry->d_parent);
585         if (IS_ERR(dfid)) {
586                 err = PTR_ERR(dfid);
587                 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
588                 return ERR_PTR(err);
589         }
590
591         /* clone a fid to use for creation */
592         ofid = p9_client_walk(dfid, 0, NULL, 1);
593         if (IS_ERR(ofid)) {
594                 err = PTR_ERR(ofid);
595                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
596                 return ERR_PTR(err);
597         }
598
599         err = p9_client_fcreate(ofid, name, perm, mode, extension);
600         if (err < 0) {
601                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
602                 goto error;
603         }
604
605         /* now walk from the parent so we can get unopened fid */
606         fid = p9_client_walk(dfid, 1, &name, 1);
607         if (IS_ERR(fid)) {
608                 err = PTR_ERR(fid);
609                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
610                 fid = NULL;
611                 goto error;
612         }
613
614         /* instantiate inode and assign the unopened fid to the dentry */
615         inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
616         if (IS_ERR(inode)) {
617                 err = PTR_ERR(inode);
618                 P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
619                 goto error;
620         }
621
622         if (v9ses->cache)
623                 dentry->d_op = &v9fs_cached_dentry_operations;
624         else
625                 dentry->d_op = &v9fs_dentry_operations;
626
627         d_instantiate(dentry, inode);
628         err = v9fs_fid_add(dentry, fid);
629         if (err < 0)
630                 goto error;
631
632         return ofid;
633
634 error:
635         if (ofid)
636                 p9_client_clunk(ofid);
637
638         if (fid)
639                 p9_client_clunk(fid);
640
641         return ERR_PTR(err);
642 }
643
644 /**
645  * v9fs_vfs_create - VFS hook to create files
646  * @dir: directory inode that is being created
647  * @dentry:  dentry that is being deleted
648  * @mode: create permissions
649  * @nd: path information
650  *
651  */
652
653 static int
654 v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
655                 struct nameidata *nd)
656 {
657         int err;
658         u32 perm;
659         int flags;
660         struct v9fs_session_info *v9ses;
661         struct p9_fid *fid;
662         struct file *filp;
663
664         err = 0;
665         fid = NULL;
666         v9ses = v9fs_inode2v9ses(dir);
667         perm = unixmode2p9mode(v9ses, mode);
668         if (nd && nd->flags & LOOKUP_OPEN)
669                 flags = nd->intent.open.flags - 1;
670         else
671                 flags = O_RDWR;
672
673         fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
674                                 v9fs_uflags2omode(flags,
675                                                 v9fs_proto_dotu(v9ses)));
676         if (IS_ERR(fid)) {
677                 err = PTR_ERR(fid);
678                 fid = NULL;
679                 goto error;
680         }
681
682         /* if we are opening a file, assign the open fid to the file */
683         if (nd && nd->flags & LOOKUP_OPEN) {
684                 filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
685                 if (IS_ERR(filp)) {
686                         err = PTR_ERR(filp);
687                         goto error;
688                 }
689
690                 filp->private_data = fid;
691         } else
692                 p9_client_clunk(fid);
693
694         return 0;
695
696 error:
697         if (fid)
698                 p9_client_clunk(fid);
699
700         return err;
701 }
702
703 /**
704  * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
705  * @dir:  inode that is being unlinked
706  * @dentry: dentry that is being unlinked
707  * @mode: mode for new directory
708  *
709  */
710
711 static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
712 {
713         int err;
714         u32 perm;
715         struct v9fs_session_info *v9ses;
716         struct p9_fid *fid;
717
718         P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
719         err = 0;
720         v9ses = v9fs_inode2v9ses(dir);
721         perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
722         fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
723         if (IS_ERR(fid)) {
724                 err = PTR_ERR(fid);
725                 fid = NULL;
726         }
727
728         if (fid)
729                 p9_client_clunk(fid);
730
731         return err;
732 }
733
734
735 /**
736  * v9fs_vfs_mkdir_dotl - VFS mkdir hook to create a directory
737  * @dir:  inode that is being unlinked
738  * @dentry: dentry that is being unlinked
739  * @mode: mode for new directory
740  *
741  */
742
743 static int v9fs_vfs_mkdir_dotl(struct inode *dir, struct dentry *dentry,
744                                         int mode)
745 {
746         int err;
747         struct v9fs_session_info *v9ses;
748         struct p9_fid *fid = NULL, *dfid = NULL;
749         gid_t gid;
750         char *name;
751         struct inode *inode;
752         struct p9_qid qid;
753         struct dentry *dir_dentry;
754
755         P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
756         err = 0;
757         v9ses = v9fs_inode2v9ses(dir);
758
759         mode |= S_IFDIR;
760         dir_dentry = v9fs_dentry_from_dir_inode(dir);
761         dfid = v9fs_fid_lookup(dir_dentry);
762         if (IS_ERR(dfid)) {
763                 err = PTR_ERR(dfid);
764                 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
765                 dfid = NULL;
766                 goto error;
767         }
768
769         gid = v9fs_get_fsgid_for_create(dir);
770         if (gid < 0) {
771                 P9_DPRINTK(P9_DEBUG_VFS, "v9fs_get_fsgid_for_create failed\n");
772                 goto error;
773         }
774
775         name = (char *) dentry->d_name.name;
776         err = p9_client_mkdir_dotl(dfid, name, mode, gid, &qid);
777         if (err < 0)
778                 goto error;
779
780         /* instantiate inode and assign the unopened fid to the dentry */
781         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
782                 fid = p9_client_walk(dfid, 1, &name, 1);
783                 if (IS_ERR(fid)) {
784                         err = PTR_ERR(fid);
785                         P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
786                                 err);
787                         fid = NULL;
788                         goto error;
789                 }
790
791                 inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
792                 if (IS_ERR(inode)) {
793                         err = PTR_ERR(inode);
794                         P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
795                                 err);
796                         goto error;
797                 }
798                 dentry->d_op = &v9fs_cached_dentry_operations;
799                 d_instantiate(dentry, inode);
800                 err = v9fs_fid_add(dentry, fid);
801                 if (err < 0)
802                         goto error;
803                 fid = NULL;
804         }
805 error:
806         if (fid)
807                 p9_client_clunk(fid);
808         return err;
809 }
810
811 /**
812  * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
813  * @dir:  inode that is being walked from
814  * @dentry: dentry that is being walked to?
815  * @nameidata: path data
816  *
817  */
818
819 static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
820                                       struct nameidata *nameidata)
821 {
822         struct super_block *sb;
823         struct v9fs_session_info *v9ses;
824         struct p9_fid *dfid, *fid;
825         struct inode *inode;
826         char *name;
827         int result = 0;
828
829         P9_DPRINTK(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
830                 dir, dentry->d_name.name, dentry, nameidata);
831
832         if (dentry->d_name.len > NAME_MAX)
833                 return ERR_PTR(-ENAMETOOLONG);
834
835         sb = dir->i_sb;
836         v9ses = v9fs_inode2v9ses(dir);
837         dfid = v9fs_fid_lookup(dentry->d_parent);
838         if (IS_ERR(dfid))
839                 return ERR_CAST(dfid);
840
841         name = (char *) dentry->d_name.name;
842         fid = p9_client_walk(dfid, 1, &name, 1);
843         if (IS_ERR(fid)) {
844                 result = PTR_ERR(fid);
845                 if (result == -ENOENT) {
846                         inode = NULL;
847                         goto inst_out;
848                 }
849
850                 return ERR_PTR(result);
851         }
852
853         inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
854         if (IS_ERR(inode)) {
855                 result = PTR_ERR(inode);
856                 inode = NULL;
857                 goto error;
858         }
859
860         result = v9fs_fid_add(dentry, fid);
861         if (result < 0)
862                 goto error;
863
864 inst_out:
865         if (v9ses->cache)
866                 dentry->d_op = &v9fs_cached_dentry_operations;
867         else
868                 dentry->d_op = &v9fs_dentry_operations;
869
870         d_add(dentry, inode);
871         return NULL;
872
873 error:
874         p9_client_clunk(fid);
875
876         return ERR_PTR(result);
877 }
878
879 /**
880  * v9fs_vfs_unlink - VFS unlink hook to delete an inode
881  * @i:  inode that is being unlinked
882  * @d: dentry that is being unlinked
883  *
884  */
885
886 static int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
887 {
888         return v9fs_remove(i, d, 0);
889 }
890
891 /**
892  * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
893  * @i:  inode that is being unlinked
894  * @d: dentry that is being unlinked
895  *
896  */
897
898 static int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
899 {
900         return v9fs_remove(i, d, 1);
901 }
902
903 /**
904  * v9fs_vfs_rename - VFS hook to rename an inode
905  * @old_dir:  old dir inode
906  * @old_dentry: old dentry
907  * @new_dir: new dir inode
908  * @new_dentry: new dentry
909  *
910  */
911
912 static int
913 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
914                 struct inode *new_dir, struct dentry *new_dentry)
915 {
916         struct inode *old_inode;
917         struct v9fs_session_info *v9ses;
918         struct p9_fid *oldfid;
919         struct p9_fid *olddirfid;
920         struct p9_fid *newdirfid;
921         struct p9_wstat wstat;
922         int retval;
923
924         P9_DPRINTK(P9_DEBUG_VFS, "\n");
925         retval = 0;
926         old_inode = old_dentry->d_inode;
927         v9ses = v9fs_inode2v9ses(old_inode);
928         oldfid = v9fs_fid_lookup(old_dentry);
929         if (IS_ERR(oldfid))
930                 return PTR_ERR(oldfid);
931
932         olddirfid = v9fs_fid_clone(old_dentry->d_parent);
933         if (IS_ERR(olddirfid)) {
934                 retval = PTR_ERR(olddirfid);
935                 goto done;
936         }
937
938         newdirfid = v9fs_fid_clone(new_dentry->d_parent);
939         if (IS_ERR(newdirfid)) {
940                 retval = PTR_ERR(newdirfid);
941                 goto clunk_olddir;
942         }
943
944         if (v9fs_proto_dotl(v9ses)) {
945                 retval = p9_client_rename(oldfid, newdirfid,
946                                         (char *) new_dentry->d_name.name);
947                 if (retval != -ENOSYS)
948                         goto clunk_newdir;
949         }
950
951         /* 9P can only handle file rename in the same directory */
952         if (memcmp(&olddirfid->qid, &newdirfid->qid, sizeof(newdirfid->qid))) {
953                 P9_DPRINTK(P9_DEBUG_ERROR,
954                                 "old dir and new dir are different\n");
955                 retval = -EXDEV;
956                 goto clunk_newdir;
957         }
958
959         v9fs_blank_wstat(&wstat);
960         wstat.muid = v9ses->uname;
961         wstat.name = (char *) new_dentry->d_name.name;
962         retval = p9_client_wstat(oldfid, &wstat);
963
964 clunk_newdir:
965         p9_client_clunk(newdirfid);
966
967 clunk_olddir:
968         p9_client_clunk(olddirfid);
969
970 done:
971         return retval;
972 }
973
974 /**
975  * v9fs_vfs_getattr - retrieve file metadata
976  * @mnt: mount information
977  * @dentry: file to get attributes on
978  * @stat: metadata structure to populate
979  *
980  */
981
982 static int
983 v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
984                  struct kstat *stat)
985 {
986         int err;
987         struct v9fs_session_info *v9ses;
988         struct p9_fid *fid;
989         struct p9_wstat *st;
990
991         P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
992         err = -EPERM;
993         v9ses = v9fs_inode2v9ses(dentry->d_inode);
994         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
995                 return simple_getattr(mnt, dentry, stat);
996
997         fid = v9fs_fid_lookup(dentry);
998         if (IS_ERR(fid))
999                 return PTR_ERR(fid);
1000
1001         st = p9_client_stat(fid);
1002         if (IS_ERR(st))
1003                 return PTR_ERR(st);
1004
1005         v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
1006                 generic_fillattr(dentry->d_inode, stat);
1007
1008         kfree(st);
1009         return 0;
1010 }
1011
1012 static int
1013 v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
1014                  struct kstat *stat)
1015 {
1016         int err;
1017         struct v9fs_session_info *v9ses;
1018         struct p9_fid *fid;
1019         struct p9_stat_dotl *st;
1020
1021         P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
1022         err = -EPERM;
1023         v9ses = v9fs_inode2v9ses(dentry->d_inode);
1024         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
1025                 return simple_getattr(mnt, dentry, stat);
1026
1027         fid = v9fs_fid_lookup(dentry);
1028         if (IS_ERR(fid))
1029                 return PTR_ERR(fid);
1030
1031         /* Ask for all the fields in stat structure. Server will return
1032          * whatever it supports
1033          */
1034
1035         st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
1036         if (IS_ERR(st))
1037                 return PTR_ERR(st);
1038
1039         v9fs_stat2inode_dotl(st, dentry->d_inode);
1040         generic_fillattr(dentry->d_inode, stat);
1041         /* Change block size to what the server returned */
1042         stat->blksize = st->st_blksize;
1043
1044         kfree(st);
1045         return 0;
1046 }
1047
1048 /**
1049  * v9fs_vfs_setattr - set file metadata
1050  * @dentry: file whose metadata to set
1051  * @iattr: metadata assignment structure
1052  *
1053  */
1054
1055 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
1056 {
1057         int retval;
1058         struct v9fs_session_info *v9ses;
1059         struct p9_fid *fid;
1060         struct p9_wstat wstat;
1061
1062         P9_DPRINTK(P9_DEBUG_VFS, "\n");
1063         retval = -EPERM;
1064         v9ses = v9fs_inode2v9ses(dentry->d_inode);
1065         fid = v9fs_fid_lookup(dentry);
1066         if(IS_ERR(fid))
1067                 return PTR_ERR(fid);
1068
1069         v9fs_blank_wstat(&wstat);
1070         if (iattr->ia_valid & ATTR_MODE)
1071                 wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
1072
1073         if (iattr->ia_valid & ATTR_MTIME)
1074                 wstat.mtime = iattr->ia_mtime.tv_sec;
1075
1076         if (iattr->ia_valid & ATTR_ATIME)
1077                 wstat.atime = iattr->ia_atime.tv_sec;
1078
1079         if (iattr->ia_valid & ATTR_SIZE)
1080                 wstat.length = iattr->ia_size;
1081
1082         if (v9fs_proto_dotu(v9ses)) {
1083                 if (iattr->ia_valid & ATTR_UID)
1084                         wstat.n_uid = iattr->ia_uid;
1085
1086                 if (iattr->ia_valid & ATTR_GID)
1087                         wstat.n_gid = iattr->ia_gid;
1088         }
1089
1090         retval = p9_client_wstat(fid, &wstat);
1091         if (retval >= 0)
1092                 retval = inode_setattr(dentry->d_inode, iattr);
1093
1094         return retval;
1095 }
1096
1097 /**
1098  * v9fs_vfs_setattr_dotl - set file metadata
1099  * @dentry: file whose metadata to set
1100  * @iattr: metadata assignment structure
1101  *
1102  */
1103
1104 static int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
1105 {
1106         int retval;
1107         struct v9fs_session_info *v9ses;
1108         struct p9_fid *fid;
1109         struct p9_iattr_dotl p9attr;
1110
1111         P9_DPRINTK(P9_DEBUG_VFS, "\n");
1112
1113         retval = inode_change_ok(dentry->d_inode, iattr);
1114         if (retval)
1115                 return retval;
1116
1117         p9attr.valid = iattr->ia_valid;
1118         p9attr.mode = iattr->ia_mode;
1119         p9attr.uid = iattr->ia_uid;
1120         p9attr.gid = iattr->ia_gid;
1121         p9attr.size = iattr->ia_size;
1122         p9attr.atime_sec = iattr->ia_atime.tv_sec;
1123         p9attr.atime_nsec = iattr->ia_atime.tv_nsec;
1124         p9attr.mtime_sec = iattr->ia_mtime.tv_sec;
1125         p9attr.mtime_nsec = iattr->ia_mtime.tv_nsec;
1126
1127         retval = -EPERM;
1128         v9ses = v9fs_inode2v9ses(dentry->d_inode);
1129         fid = v9fs_fid_lookup(dentry);
1130         if (IS_ERR(fid))
1131                 return PTR_ERR(fid);
1132
1133         retval = p9_client_setattr(fid, &p9attr);
1134         if (retval >= 0)
1135                 retval = inode_setattr(dentry->d_inode, iattr);
1136
1137         return retval;
1138 }
1139
1140 /**
1141  * v9fs_stat2inode - populate an inode structure with mistat info
1142  * @stat: Plan 9 metadata (mistat) structure
1143  * @inode: inode to populate
1144  * @sb: superblock of filesystem
1145  *
1146  */
1147
1148 void
1149 v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
1150         struct super_block *sb)
1151 {
1152         char ext[32];
1153         char tag_name[14];
1154         unsigned int i_nlink;
1155         struct v9fs_session_info *v9ses = sb->s_fs_info;
1156
1157         inode->i_nlink = 1;
1158
1159         inode->i_atime.tv_sec = stat->atime;
1160         inode->i_mtime.tv_sec = stat->mtime;
1161         inode->i_ctime.tv_sec = stat->mtime;
1162
1163         inode->i_uid = v9ses->dfltuid;
1164         inode->i_gid = v9ses->dfltgid;
1165
1166         if (v9fs_proto_dotu(v9ses)) {
1167                 inode->i_uid = stat->n_uid;
1168                 inode->i_gid = stat->n_gid;
1169         }
1170         if ((S_ISREG(inode->i_mode)) || (S_ISDIR(inode->i_mode))) {
1171                 if (v9fs_proto_dotu(v9ses) && (stat->extension[0] != '\0')) {
1172                         /*
1173                          * Hadlink support got added later to
1174                          * to the .u extension. So there can be
1175                          * server out there that doesn't support
1176                          * this even with .u extension. So check
1177                          * for non NULL stat->extension
1178                          */
1179                         strncpy(ext, stat->extension, sizeof(ext));
1180                         /* HARDLINKCOUNT %u */
1181                         sscanf(ext, "%13s %u", tag_name, &i_nlink);
1182                         if (!strncmp(tag_name, "HARDLINKCOUNT", 13))
1183                                 inode->i_nlink = i_nlink;
1184                 }
1185         }
1186         inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
1187         if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
1188                 char type = 0;
1189                 int major = -1;
1190                 int minor = -1;
1191
1192                 strncpy(ext, stat->extension, sizeof(ext));
1193                 sscanf(ext, "%c %u %u", &type, &major, &minor);
1194                 switch (type) {
1195                 case 'c':
1196                         inode->i_mode &= ~S_IFBLK;
1197                         inode->i_mode |= S_IFCHR;
1198                         break;
1199                 case 'b':
1200                         break;
1201                 default:
1202                         P9_DPRINTK(P9_DEBUG_ERROR,
1203                                 "Unknown special type %c %s\n", type,
1204                                 stat->extension);
1205                 };
1206                 inode->i_rdev = MKDEV(major, minor);
1207                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1208         } else
1209                 inode->i_rdev = 0;
1210
1211         i_size_write(inode, stat->length);
1212
1213         /* not real number of blocks, but 512 byte ones ... */
1214         inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
1215 }
1216
1217 /**
1218  * v9fs_stat2inode_dotl - populate an inode structure with stat info
1219  * @stat: stat structure
1220  * @inode: inode to populate
1221  * @sb: superblock of filesystem
1222  *
1223  */
1224
1225 void
1226 v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
1227 {
1228
1229         if ((stat->st_result_mask & P9_STATS_BASIC) == P9_STATS_BASIC) {
1230                 inode->i_atime.tv_sec = stat->st_atime_sec;
1231                 inode->i_atime.tv_nsec = stat->st_atime_nsec;
1232                 inode->i_mtime.tv_sec = stat->st_mtime_sec;
1233                 inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
1234                 inode->i_ctime.tv_sec = stat->st_ctime_sec;
1235                 inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
1236                 inode->i_uid = stat->st_uid;
1237                 inode->i_gid = stat->st_gid;
1238                 inode->i_nlink = stat->st_nlink;
1239                 inode->i_mode = stat->st_mode;
1240                 inode->i_rdev = new_decode_dev(stat->st_rdev);
1241
1242                 if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode)))
1243                         init_special_inode(inode, inode->i_mode, inode->i_rdev);
1244
1245                 i_size_write(inode, stat->st_size);
1246                 inode->i_blocks = stat->st_blocks;
1247         } else {
1248                 if (stat->st_result_mask & P9_STATS_ATIME) {
1249                         inode->i_atime.tv_sec = stat->st_atime_sec;
1250                         inode->i_atime.tv_nsec = stat->st_atime_nsec;
1251                 }
1252                 if (stat->st_result_mask & P9_STATS_MTIME) {
1253                         inode->i_mtime.tv_sec = stat->st_mtime_sec;
1254                         inode->i_mtime.tv_nsec = stat->st_mtime_nsec;
1255                 }
1256                 if (stat->st_result_mask & P9_STATS_CTIME) {
1257                         inode->i_ctime.tv_sec = stat->st_ctime_sec;
1258                         inode->i_ctime.tv_nsec = stat->st_ctime_nsec;
1259                 }
1260                 if (stat->st_result_mask & P9_STATS_UID)
1261                         inode->i_uid = stat->st_uid;
1262                 if (stat->st_result_mask & P9_STATS_GID)
1263                         inode->i_gid = stat->st_gid;
1264                 if (stat->st_result_mask & P9_STATS_NLINK)
1265                         inode->i_nlink = stat->st_nlink;
1266                 if (stat->st_result_mask & P9_STATS_MODE) {
1267                         inode->i_mode = stat->st_mode;
1268                         if ((S_ISBLK(inode->i_mode)) ||
1269                                                 (S_ISCHR(inode->i_mode)))
1270                                 init_special_inode(inode, inode->i_mode,
1271                                                                 inode->i_rdev);
1272                 }
1273                 if (stat->st_result_mask & P9_STATS_RDEV)
1274                         inode->i_rdev = new_decode_dev(stat->st_rdev);
1275                 if (stat->st_result_mask & P9_STATS_SIZE)
1276                         i_size_write(inode, stat->st_size);
1277                 if (stat->st_result_mask & P9_STATS_BLOCKS)
1278                         inode->i_blocks = stat->st_blocks;
1279         }
1280         if (stat->st_result_mask & P9_STATS_GEN)
1281                         inode->i_generation = stat->st_gen;
1282
1283         /* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION
1284          * because the inode structure does not have fields for them.
1285          */
1286 }
1287
1288 /**
1289  * v9fs_qid2ino - convert qid into inode number
1290  * @qid: qid to hash
1291  *
1292  * BUG: potential for inode number collisions?
1293  */
1294
1295 ino_t v9fs_qid2ino(struct p9_qid *qid)
1296 {
1297         u64 path = qid->path + 2;
1298         ino_t i = 0;
1299
1300         if (sizeof(ino_t) == sizeof(path))
1301                 memcpy(&i, &path, sizeof(ino_t));
1302         else
1303                 i = (ino_t) (path ^ (path >> 32));
1304
1305         return i;
1306 }
1307
1308 /**
1309  * v9fs_readlink - read a symlink's location (internal version)
1310  * @dentry: dentry for symlink
1311  * @buffer: buffer to load symlink location into
1312  * @buflen: length of buffer
1313  *
1314  */
1315
1316 static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
1317 {
1318         int retval;
1319
1320         struct v9fs_session_info *v9ses;
1321         struct p9_fid *fid;
1322         struct p9_wstat *st;
1323
1324         P9_DPRINTK(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
1325         retval = -EPERM;
1326         v9ses = v9fs_inode2v9ses(dentry->d_inode);
1327         fid = v9fs_fid_lookup(dentry);
1328         if (IS_ERR(fid))
1329                 return PTR_ERR(fid);
1330
1331         if (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses))
1332                 return -EBADF;
1333
1334         st = p9_client_stat(fid);
1335         if (IS_ERR(st))
1336                 return PTR_ERR(st);
1337
1338         if (!(st->mode & P9_DMSYMLINK)) {
1339                 retval = -EINVAL;
1340                 goto done;
1341         }
1342
1343         /* copy extension buffer into buffer */
1344         strncpy(buffer, st->extension, buflen);
1345
1346         P9_DPRINTK(P9_DEBUG_VFS,
1347                 "%s -> %s (%s)\n", dentry->d_name.name, st->extension, buffer);
1348
1349         retval = strnlen(buffer, buflen);
1350 done:
1351         kfree(st);
1352         return retval;
1353 }
1354
1355 /**
1356  * v9fs_vfs_follow_link - follow a symlink path
1357  * @dentry: dentry for symlink
1358  * @nd: nameidata
1359  *
1360  */
1361
1362 static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
1363 {
1364         int len = 0;
1365         char *link = __getname();
1366
1367         P9_DPRINTK(P9_DEBUG_VFS, "%s n", dentry->d_name.name);
1368
1369         if (!link)
1370                 link = ERR_PTR(-ENOMEM);
1371         else {
1372                 len = v9fs_readlink(dentry, link, PATH_MAX);
1373
1374                 if (len < 0) {
1375                         __putname(link);
1376                         link = ERR_PTR(len);
1377                 } else
1378                         link[min(len, PATH_MAX-1)] = 0;
1379         }
1380         nd_set_link(nd, link);
1381
1382         return NULL;
1383 }
1384
1385 /**
1386  * v9fs_vfs_put_link - release a symlink path
1387  * @dentry: dentry for symlink
1388  * @nd: nameidata
1389  * @p: unused
1390  *
1391  */
1392
1393 static void
1394 v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1395 {
1396         char *s = nd_get_link(nd);
1397
1398         P9_DPRINTK(P9_DEBUG_VFS, " %s %s\n", dentry->d_name.name,
1399                 IS_ERR(s) ? "<error>" : s);
1400         if (!IS_ERR(s))
1401                 __putname(s);
1402 }
1403
1404 /**
1405  * v9fs_vfs_mkspecial - create a special file
1406  * @dir: inode to create special file in
1407  * @dentry: dentry to create
1408  * @mode: mode to create special file
1409  * @extension: 9p2000.u format extension string representing special file
1410  *
1411  */
1412
1413 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1414         int mode, const char *extension)
1415 {
1416         u32 perm;
1417         struct v9fs_session_info *v9ses;
1418         struct p9_fid *fid;
1419
1420         v9ses = v9fs_inode2v9ses(dir);
1421         if (!v9fs_proto_dotu(v9ses)) {
1422                 P9_DPRINTK(P9_DEBUG_ERROR, "not extended\n");
1423                 return -EPERM;
1424         }
1425
1426         perm = unixmode2p9mode(v9ses, mode);
1427         fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1428                                                                 P9_OREAD);
1429         if (IS_ERR(fid))
1430                 return PTR_ERR(fid);
1431
1432         p9_client_clunk(fid);
1433         return 0;
1434 }
1435
1436 /**
1437  * v9fs_vfs_symlink_dotl - helper function to create symlinks
1438  * @dir: directory inode containing symlink
1439  * @dentry: dentry for symlink
1440  * @symname: symlink data
1441  *
1442  * See Also: 9P2000.L RFC for more information
1443  *
1444  */
1445
1446 static int
1447 v9fs_vfs_symlink_dotl(struct inode *dir, struct dentry *dentry,
1448                 const char *symname)
1449 {
1450         struct v9fs_session_info *v9ses;
1451         struct p9_fid *dfid;
1452         struct p9_fid *fid = NULL;
1453         struct inode *inode;
1454         struct p9_qid qid;
1455         char *name;
1456         int err;
1457         gid_t gid;
1458
1459         name = (char *) dentry->d_name.name;
1460         P9_DPRINTK(P9_DEBUG_VFS, "v9fs_vfs_symlink_dotl : %lu,%s,%s\n",
1461                         dir->i_ino, name, symname);
1462         v9ses = v9fs_inode2v9ses(dir);
1463
1464         dfid = v9fs_fid_lookup(dentry->d_parent);
1465         if (IS_ERR(dfid)) {
1466                 err = PTR_ERR(dfid);
1467                 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
1468                 return err;
1469         }
1470
1471         gid = v9fs_get_fsgid_for_create(dir);
1472
1473         if (gid < 0) {
1474                 P9_DPRINTK(P9_DEBUG_VFS, "v9fs_get_egid failed %d\n", gid);
1475                 goto error;
1476         }
1477
1478         /* Server doesn't alter fid on TSYMLINK. Hence no need to clone it. */
1479         err = p9_client_symlink(dfid, name, (char *)symname, gid, &qid);
1480
1481         if (err < 0) {
1482                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_symlink failed %d\n", err);
1483                 goto error;
1484         }
1485
1486         if (v9ses->cache) {
1487                 /* Now walk from the parent so we can get an unopened fid. */
1488                 fid = p9_client_walk(dfid, 1, &name, 1);
1489                 if (IS_ERR(fid)) {
1490                         err = PTR_ERR(fid);
1491                         P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
1492                                         err);
1493                         fid = NULL;
1494                         goto error;
1495                 }
1496
1497                 /* instantiate inode and assign the unopened fid to dentry */
1498                 inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
1499                 if (IS_ERR(inode)) {
1500                         err = PTR_ERR(inode);
1501                         P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
1502                                         err);
1503                         goto error;
1504                 }
1505                 dentry->d_op = &v9fs_cached_dentry_operations;
1506                 d_instantiate(dentry, inode);
1507                 err = v9fs_fid_add(dentry, fid);
1508                 if (err < 0)
1509                         goto error;
1510                 fid = NULL;
1511         } else {
1512                 /* Not in cached mode. No need to populate inode with stat */
1513                 inode = v9fs_get_inode(dir->i_sb, S_IFLNK);
1514                 if (IS_ERR(inode)) {
1515                         err = PTR_ERR(inode);
1516                         goto error;
1517                 }
1518                 dentry->d_op = &v9fs_dentry_operations;
1519                 d_instantiate(dentry, inode);
1520         }
1521
1522 error:
1523         if (fid)
1524                 p9_client_clunk(fid);
1525
1526         return err;
1527 }
1528
1529 /**
1530  * v9fs_vfs_symlink - helper function to create symlinks
1531  * @dir: directory inode containing symlink
1532  * @dentry: dentry for symlink
1533  * @symname: symlink data
1534  *
1535  * See Also: 9P2000.u RFC for more information
1536  *
1537  */
1538
1539 static int
1540 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1541 {
1542         P9_DPRINTK(P9_DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino,
1543                                         dentry->d_name.name, symname);
1544
1545         return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
1546 }
1547
1548 /**
1549  * v9fs_vfs_link - create a hardlink
1550  * @old_dentry: dentry for file to link to
1551  * @dir: inode destination for new link
1552  * @dentry: dentry for link
1553  *
1554  */
1555
1556 static int
1557 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1558               struct dentry *dentry)
1559 {
1560         int retval;
1561         struct p9_fid *oldfid;
1562         char *name;
1563
1564         P9_DPRINTK(P9_DEBUG_VFS,
1565                 " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
1566                 old_dentry->d_name.name);
1567
1568         oldfid = v9fs_fid_clone(old_dentry);
1569         if (IS_ERR(oldfid))
1570                 return PTR_ERR(oldfid);
1571
1572         name = __getname();
1573         if (unlikely(!name)) {
1574                 retval = -ENOMEM;
1575                 goto clunk_fid;
1576         }
1577
1578         sprintf(name, "%d\n", oldfid->fid);
1579         retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
1580         __putname(name);
1581
1582 clunk_fid:
1583         p9_client_clunk(oldfid);
1584         return retval;
1585 }
1586
1587 /**
1588  * v9fs_vfs_link_dotl - create a hardlink for dotl
1589  * @old_dentry: dentry for file to link to
1590  * @dir: inode destination for new link
1591  * @dentry: dentry for link
1592  *
1593  */
1594
1595 static int
1596 v9fs_vfs_link_dotl(struct dentry *old_dentry, struct inode *dir,
1597                 struct dentry *dentry)
1598 {
1599         int err;
1600         struct p9_fid *dfid, *oldfid;
1601         char *name;
1602         struct v9fs_session_info *v9ses;
1603         struct dentry *dir_dentry;
1604
1605         P9_DPRINTK(P9_DEBUG_VFS, "dir ino: %lu, old_name: %s, new_name: %s\n",
1606                         dir->i_ino, old_dentry->d_name.name,
1607                         dentry->d_name.name);
1608
1609         v9ses = v9fs_inode2v9ses(dir);
1610         dir_dentry = v9fs_dentry_from_dir_inode(dir);
1611         dfid = v9fs_fid_lookup(dir_dentry);
1612         if (IS_ERR(dfid))
1613                 return PTR_ERR(dfid);
1614
1615         oldfid = v9fs_fid_lookup(old_dentry);
1616         if (IS_ERR(oldfid))
1617                 return PTR_ERR(oldfid);
1618
1619         name = (char *) dentry->d_name.name;
1620
1621         err = p9_client_link(dfid, oldfid, (char *)dentry->d_name.name);
1622
1623         if (err < 0) {
1624                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_link failed %d\n", err);
1625                 return err;
1626         }
1627
1628         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
1629                 /* Get the latest stat info from server. */
1630                 struct p9_fid *fid;
1631                 struct p9_stat_dotl *st;
1632
1633                 fid = v9fs_fid_lookup(old_dentry);
1634                 if (IS_ERR(fid))
1635                         return PTR_ERR(fid);
1636
1637                 st = p9_client_getattr_dotl(fid, P9_STATS_BASIC);
1638                 if (IS_ERR(st))
1639                         return PTR_ERR(st);
1640
1641                 v9fs_stat2inode_dotl(st, old_dentry->d_inode);
1642
1643                 kfree(st);
1644         } else {
1645                 /* Caching disabled. No need to get upto date stat info.
1646                  * This dentry will be released immediately. So, just i_count++
1647                  */
1648                 atomic_inc(&old_dentry->d_inode->i_count);
1649         }
1650
1651         dentry->d_op = old_dentry->d_op;
1652         d_instantiate(dentry, old_dentry->d_inode);
1653
1654         return err;
1655 }
1656
1657 /**
1658  * v9fs_vfs_mknod - create a special file
1659  * @dir: inode destination for new link
1660  * @dentry: dentry for file
1661  * @mode: mode for creation
1662  * @rdev: device associated with special file
1663  *
1664  */
1665
1666 static int
1667 v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1668 {
1669         int retval;
1670         char *name;
1671
1672         P9_DPRINTK(P9_DEBUG_VFS,
1673                 " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
1674                 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
1675
1676         if (!new_valid_dev(rdev))
1677                 return -EINVAL;
1678
1679         name = __getname();
1680         if (!name)
1681                 return -ENOMEM;
1682         /* build extension */
1683         if (S_ISBLK(mode))
1684                 sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
1685         else if (S_ISCHR(mode))
1686                 sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
1687         else if (S_ISFIFO(mode))
1688                 *name = 0;
1689         else if (S_ISSOCK(mode))
1690                 *name = 0;
1691         else {
1692                 __putname(name);
1693                 return -EINVAL;
1694         }
1695
1696         retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
1697         __putname(name);
1698
1699         return retval;
1700 }
1701
1702 /**
1703  * v9fs_vfs_mknod_dotl - create a special file
1704  * @dir: inode destination for new link
1705  * @dentry: dentry for file
1706  * @mode: mode for creation
1707  * @rdev: device associated with special file
1708  *
1709  */
1710 static int
1711 v9fs_vfs_mknod_dotl(struct inode *dir, struct dentry *dentry, int mode,
1712                 dev_t rdev)
1713 {
1714         int err;
1715         char *name;
1716         struct v9fs_session_info *v9ses;
1717         struct p9_fid *fid = NULL, *dfid = NULL;
1718         struct inode *inode;
1719         gid_t gid;
1720         struct p9_qid qid;
1721         struct dentry *dir_dentry;
1722
1723         P9_DPRINTK(P9_DEBUG_VFS,
1724                 " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
1725                 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
1726
1727         if (!new_valid_dev(rdev))
1728                 return -EINVAL;
1729
1730         v9ses = v9fs_inode2v9ses(dir);
1731         dir_dentry = v9fs_dentry_from_dir_inode(dir);
1732         dfid = v9fs_fid_lookup(dir_dentry);
1733         if (IS_ERR(dfid)) {
1734                 err = PTR_ERR(dfid);
1735                 P9_DPRINTK(P9_DEBUG_VFS, "fid lookup failed %d\n", err);
1736                 dfid = NULL;
1737                 goto error;
1738         }
1739
1740         gid = v9fs_get_fsgid_for_create(dir);
1741         if (gid < 0) {
1742                 P9_DPRINTK(P9_DEBUG_VFS, "v9fs_get_fsgid_for_create failed\n");
1743                 goto error;
1744         }
1745
1746         name = (char *) dentry->d_name.name;
1747
1748         err = p9_client_mknod_dotl(dfid, name, mode, rdev, gid, &qid);
1749         if (err < 0)
1750                 goto error;
1751
1752         /* instantiate inode and assign the unopened fid to the dentry */
1753         if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) {
1754                 fid = p9_client_walk(dfid, 1, &name, 1);
1755                 if (IS_ERR(fid)) {
1756                         err = PTR_ERR(fid);
1757                         P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n",
1758                                 err);
1759                         fid = NULL;
1760                         goto error;
1761                 }
1762
1763                 inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
1764                 if (IS_ERR(inode)) {
1765                         err = PTR_ERR(inode);
1766                         P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n",
1767                                 err);
1768                         goto error;
1769                 }
1770                 dentry->d_op = &v9fs_cached_dentry_operations;
1771                 d_instantiate(dentry, inode);
1772                 err = v9fs_fid_add(dentry, fid);
1773                 if (err < 0)
1774                         goto error;
1775                 fid = NULL;
1776         } else {
1777                 /*
1778                  * Not in cached mode. No need to populate inode with stat.
1779                  * socket syscall returns a fd, so we need instantiate
1780                  */
1781                 inode = v9fs_get_inode(dir->i_sb, mode);
1782                 if (IS_ERR(inode)) {
1783                         err = PTR_ERR(inode);
1784                         goto error;
1785                 }
1786                 dentry->d_op = &v9fs_dentry_operations;
1787                 d_instantiate(dentry, inode);
1788         }
1789
1790 error:
1791         if (fid)
1792                 p9_client_clunk(fid);
1793         return err;
1794 }
1795
1796 static const struct inode_operations v9fs_dir_inode_operations_dotu = {
1797         .create = v9fs_vfs_create,
1798         .lookup = v9fs_vfs_lookup,
1799         .symlink = v9fs_vfs_symlink,
1800         .link = v9fs_vfs_link,
1801         .unlink = v9fs_vfs_unlink,
1802         .mkdir = v9fs_vfs_mkdir,
1803         .rmdir = v9fs_vfs_rmdir,
1804         .mknod = v9fs_vfs_mknod_dotl,
1805         .rename = v9fs_vfs_rename,
1806         .getattr = v9fs_vfs_getattr,
1807         .setattr = v9fs_vfs_setattr,
1808 };
1809
1810 static const struct inode_operations v9fs_dir_inode_operations_dotl = {
1811         .create = v9fs_vfs_create,
1812         .lookup = v9fs_vfs_lookup,
1813         .link = v9fs_vfs_link_dotl,
1814         .symlink = v9fs_vfs_symlink_dotl,
1815         .unlink = v9fs_vfs_unlink,
1816         .mkdir = v9fs_vfs_mkdir_dotl,
1817         .rmdir = v9fs_vfs_rmdir,
1818         .mknod = v9fs_vfs_mknod_dotl,
1819         .rename = v9fs_vfs_rename,
1820         .getattr = v9fs_vfs_getattr_dotl,
1821         .setattr = v9fs_vfs_setattr_dotl,
1822 };
1823
1824 static const struct inode_operations v9fs_dir_inode_operations = {
1825         .create = v9fs_vfs_create,
1826         .lookup = v9fs_vfs_lookup,
1827         .unlink = v9fs_vfs_unlink,
1828         .mkdir = v9fs_vfs_mkdir,
1829         .rmdir = v9fs_vfs_rmdir,
1830         .mknod = v9fs_vfs_mknod,
1831         .rename = v9fs_vfs_rename,
1832         .getattr = v9fs_vfs_getattr,
1833         .setattr = v9fs_vfs_setattr,
1834 };
1835
1836 static const struct inode_operations v9fs_file_inode_operations = {
1837         .getattr = v9fs_vfs_getattr,
1838         .setattr = v9fs_vfs_setattr,
1839 };
1840
1841 static const struct inode_operations v9fs_file_inode_operations_dotl = {
1842         .getattr = v9fs_vfs_getattr_dotl,
1843         .setattr = v9fs_vfs_setattr_dotl,
1844 };
1845
1846 static const struct inode_operations v9fs_symlink_inode_operations = {
1847         .readlink = generic_readlink,
1848         .follow_link = v9fs_vfs_follow_link,
1849         .put_link = v9fs_vfs_put_link,
1850         .getattr = v9fs_vfs_getattr,
1851         .setattr = v9fs_vfs_setattr,
1852 };
1853
1854 static const struct inode_operations v9fs_symlink_inode_operations_dotl = {
1855         .readlink = generic_readlink,
1856         .follow_link = v9fs_vfs_follow_link,
1857         .put_link = v9fs_vfs_put_link,
1858         .getattr = v9fs_vfs_getattr_dotl,
1859         .setattr = v9fs_vfs_setattr_dotl,
1860 };