ext3: ensure fast symlinks are NUL-terminated
[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 <net/9p/9p.h>
38 #include <net/9p/client.h>
39
40 #include "v9fs.h"
41 #include "v9fs_vfs.h"
42 #include "fid.h"
43
44 static const struct inode_operations v9fs_dir_inode_operations;
45 static const struct inode_operations v9fs_dir_inode_operations_ext;
46 static const struct inode_operations v9fs_file_inode_operations;
47 static const struct inode_operations v9fs_symlink_inode_operations;
48
49 /**
50  * unixmode2p9mode - convert unix mode bits to plan 9
51  * @v9ses: v9fs session information
52  * @mode: mode to convert
53  *
54  */
55
56 static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
57 {
58         int res;
59         res = mode & 0777;
60         if (S_ISDIR(mode))
61                 res |= P9_DMDIR;
62         if (v9fs_extended(v9ses)) {
63                 if (S_ISLNK(mode))
64                         res |= P9_DMSYMLINK;
65                 if (v9ses->nodev == 0) {
66                         if (S_ISSOCK(mode))
67                                 res |= P9_DMSOCKET;
68                         if (S_ISFIFO(mode))
69                                 res |= P9_DMNAMEDPIPE;
70                         if (S_ISBLK(mode))
71                                 res |= P9_DMDEVICE;
72                         if (S_ISCHR(mode))
73                                 res |= P9_DMDEVICE;
74                 }
75
76                 if ((mode & S_ISUID) == S_ISUID)
77                         res |= P9_DMSETUID;
78                 if ((mode & S_ISGID) == S_ISGID)
79                         res |= P9_DMSETGID;
80                 if ((mode & S_ISVTX) == S_ISVTX)
81                         res |= P9_DMSETVTX;
82                 if ((mode & P9_DMLINK))
83                         res |= P9_DMLINK;
84         }
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
96 static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
97 {
98         int res;
99
100         res = mode & 0777;
101
102         if ((mode & P9_DMDIR) == P9_DMDIR)
103                 res |= S_IFDIR;
104         else if ((mode & P9_DMSYMLINK) && (v9fs_extended(v9ses)))
105                 res |= S_IFLNK;
106         else if ((mode & P9_DMSOCKET) && (v9fs_extended(v9ses))
107                  && (v9ses->nodev == 0))
108                 res |= S_IFSOCK;
109         else if ((mode & P9_DMNAMEDPIPE) && (v9fs_extended(v9ses))
110                  && (v9ses->nodev == 0))
111                 res |= S_IFIFO;
112         else if ((mode & P9_DMDEVICE) && (v9fs_extended(v9ses))
113                  && (v9ses->nodev == 0))
114                 res |= S_IFBLK;
115         else
116                 res |= S_IFREG;
117
118         if (v9fs_extended(v9ses)) {
119                 if ((mode & P9_DMSETUID) == P9_DMSETUID)
120                         res |= S_ISUID;
121
122                 if ((mode & P9_DMSETGID) == P9_DMSETGID)
123                         res |= S_ISGID;
124
125                 if ((mode & P9_DMSETVTX) == P9_DMSETVTX)
126                         res |= S_ISVTX;
127         }
128
129         return res;
130 }
131
132 /**
133  * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
134  * @uflags: flags to convert
135  * @extended: if .u extensions are active
136  */
137
138 int v9fs_uflags2omode(int uflags, int extended)
139 {
140         int ret;
141
142         ret = 0;
143         switch (uflags&3) {
144         default:
145         case O_RDONLY:
146                 ret = P9_OREAD;
147                 break;
148
149         case O_WRONLY:
150                 ret = P9_OWRITE;
151                 break;
152
153         case O_RDWR:
154                 ret = P9_ORDWR;
155                 break;
156         }
157
158         if (uflags & O_TRUNC)
159                 ret |= P9_OTRUNC;
160
161         if (extended) {
162                 if (uflags & O_EXCL)
163                         ret |= P9_OEXCL;
164
165                 if (uflags & O_APPEND)
166                         ret |= P9_OAPPEND;
167         }
168
169         return ret;
170 }
171
172 /**
173  * v9fs_blank_wstat - helper function to setup a 9P stat structure
174  * @v9ses: 9P session info (for determining extended mode)
175  * @wstat: structure to initialize
176  *
177  */
178
179 static void
180 v9fs_blank_wstat(struct p9_wstat *wstat)
181 {
182         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;
199 }
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
208 struct inode *v9fs_get_inode(struct super_block *sb, int mode)
209 {
210         struct inode *inode;
211         struct v9fs_session_info *v9ses = sb->s_fs_info;
212
213         P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
214
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();
220                 inode->i_blocks = 0;
221                 inode->i_rdev = 0;
222                 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
223                 inode->i_mapping->a_ops = &v9fs_addr_operations;
224
225                 switch (mode & S_IFMT) {
226                 case S_IFIFO:
227                 case S_IFBLK:
228                 case S_IFCHR:
229                 case S_IFSOCK:
230                         if (!v9fs_extended(v9ses)) {
231                                 P9_DPRINTK(P9_DEBUG_ERROR,
232                                       "special files without extended mode\n");
233                                 return ERR_PTR(-EINVAL);
234                         }
235                         init_special_inode(inode, inode->i_mode,
236                                            inode->i_rdev);
237                         break;
238                 case S_IFREG:
239                         inode->i_op = &v9fs_file_inode_operations;
240                         inode->i_fop = &v9fs_file_operations;
241                         break;
242                 case S_IFLNK:
243                         if (!v9fs_extended(v9ses)) {
244                                 P9_DPRINTK(P9_DEBUG_ERROR,
245                                         "extended modes used w/o 9P2000.u\n");
246                                 return ERR_PTR(-EINVAL);
247                         }
248                         inode->i_op = &v9fs_symlink_inode_operations;
249                         break;
250                 case S_IFDIR:
251                         inc_nlink(inode);
252                         if (v9fs_extended(v9ses))
253                                 inode->i_op = &v9fs_dir_inode_operations_ext;
254                         else
255                                 inode->i_op = &v9fs_dir_inode_operations;
256                         inode->i_fop = &v9fs_dir_operations;
257                         break;
258                 default:
259                         P9_DPRINTK(P9_DEBUG_ERROR,
260                                 "BAD mode 0x%x S_IFMT 0x%x\n",
261                                 mode, mode & S_IFMT);
262                         return ERR_PTR(-EINVAL);
263                 }
264         } else {
265                 P9_EPRINTK(KERN_WARNING, "Problem allocating inode\n");
266                 return ERR_PTR(-ENOMEM);
267         }
268         return inode;
269 }
270
271 /*
272 static struct v9fs_fid*
273 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
274 {
275         int err;
276         int nfid;
277         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");
283                 return ERR_PTR(-ENOSPC);
284         }
285
286         err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
287                 &fcall);
288
289         if (err < 0) {
290                 if (fcall && fcall->id == RWALK)
291                         goto clunk_fid;
292
293                 PRINT_FCALL_ERROR("walk error", fcall);
294                 v9fs_put_idpool(nfid, &v9ses->fidpool);
295                 goto error;
296         }
297
298         kfree(fcall);
299         fcall = NULL;
300         ret = v9fs_fid_create(v9ses, nfid);
301         if (!ret) {
302                 err = -ENOMEM;
303                 goto clunk_fid;
304         }
305
306         err = v9fs_fid_insert(ret, dentry);
307         if (err < 0) {
308                 v9fs_fid_destroy(ret);
309                 goto clunk_fid;
310         }
311
312         return ret;
313
314 clunk_fid:
315         v9fs_t_clunk(v9ses, nfid);
316
317 error:
318         kfree(fcall);
319         return ERR_PTR(err);
320 }
321 */
322
323 /**
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
331 static struct inode *
332 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
333         struct super_block *sb)
334 {
335         int err, umode;
336         struct inode *ret;
337         struct p9_wstat *st;
338
339         ret = NULL;
340         st = p9_client_stat(fid);
341         if (IS_ERR(st)) {
342                 err = PTR_ERR(st);
343                 st = NULL;
344                 goto error;
345         }
346
347         umode = p9mode2unixmode(v9ses, st->mode);
348         ret = v9fs_get_inode(sb, umode);
349         if (IS_ERR(ret)) {
350                 err = PTR_ERR(ret);
351                 ret = NULL;
352                 goto error;
353         }
354
355         v9fs_stat2inode(st, ret, sb);
356         ret->i_ino = v9fs_qid2ino(&st->qid);
357         kfree(st);
358         return ret;
359
360 error:
361         kfree(st);
362         if (ret)
363                 iput(ret);
364
365         return ERR_PTR(err);
366 }
367
368 /**
369  * v9fs_remove - helper function to remove files and directories
370  * @dir: directory inode that is being deleted
371  * @file:  dentry that is being deleted
372  * @rmdir: removing a directory
373  *
374  */
375
376 static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
377 {
378         struct inode *file_inode;
379         struct v9fs_session_info *v9ses;
380         struct p9_fid *v9fid;
381
382         P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
383                 rmdir);
384
385         file_inode = file->d_inode;
386         v9ses = v9fs_inode2v9ses(file_inode);
387         v9fid = v9fs_fid_clone(file);
388         if (IS_ERR(v9fid))
389                 return PTR_ERR(v9fid);
390
391         return p9_client_remove(v9fid);
392 }
393
394 static int
395 v9fs_open_created(struct inode *inode, struct file *file)
396 {
397         return 0;
398 }
399
400
401 /**
402  * v9fs_create - Create a file
403  * @v9ses: session information
404  * @dir: directory that dentry is being created in
405  * @dentry:  dentry that is being created
406  * @perm: create permissions
407  * @mode: open mode
408  * @extension: 9p2000.u extension string to support devices, etc.
409  *
410  */
411 static struct p9_fid *
412 v9fs_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
420         P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
421
422         err = 0;
423         ofid = NULL;
424         fid = NULL;
425         name = (char *) dentry->d_name.name;
426         dfid = v9fs_fid_clone(dentry->d_parent);
427         if (IS_ERR(dfid)) {
428                 err = PTR_ERR(dfid);
429                 P9_DPRINTK(P9_DEBUG_VFS, "fid clone failed %d\n", err);
430                 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);
438                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
439                 ofid = NULL;
440                 goto error;
441         }
442
443         err = p9_client_fcreate(ofid, name, perm, mode, extension);
444         if (err < 0) {
445                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_fcreate failed %d\n", err);
446                 goto error;
447         }
448
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);
453                 P9_DPRINTK(P9_DEBUG_VFS, "p9_client_walk failed %d\n", err);
454                 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);
463                 P9_DPRINTK(P9_DEBUG_VFS, "inode creation failed %d\n", err);
464                 goto error;
465         }
466
467         if (v9ses->cache)
468                 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
476 error:
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
489 /**
490  * v9fs_vfs_create - VFS hook to create files
491  * @dir: directory inode that is being created
492  * @dentry:  dentry that is being deleted
493  * @mode: create permissions
494  * @nd: path information
495  *
496  */
497
498 static int
499 v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
500                 struct nameidata *nd)
501 {
502         int err;
503         u32 perm;
504         int flags;
505         struct v9fs_session_info *v9ses;
506         struct p9_fid *fid;
507         struct file *filp;
508
509         err = 0;
510         fid = NULL;
511         v9ses = v9fs_inode2v9ses(dir);
512         perm = unixmode2p9mode(v9ses, mode);
513         if (nd && nd->flags & LOOKUP_OPEN)
514                 flags = nd->intent.open.flags - 1;
515         else
516                 flags = O_RDWR;
517
518         fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
519                                 v9fs_uflags2omode(flags, v9fs_extended(v9ses)));
520         if (IS_ERR(fid)) {
521                 err = PTR_ERR(fid);
522                 fid = NULL;
523                 goto error;
524         }
525
526         /* if we are opening a file, assign the open fid to the file */
527         if (nd && nd->flags & LOOKUP_OPEN) {
528                 filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
529                 if (IS_ERR(filp)) {
530                         err = PTR_ERR(filp);
531                         goto error;
532                 }
533
534                 filp->private_data = fid;
535         } else
536                 p9_client_clunk(fid);
537
538         return 0;
539
540 error:
541         if (fid)
542                 p9_client_clunk(fid);
543
544         return err;
545 }
546
547 /**
548  * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
549  * @dir:  inode that is being unlinked
550  * @dentry: dentry that is being unlinked
551  * @mode: mode for new directory
552  *
553  */
554
555 static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
556 {
557         int err;
558         u32 perm;
559         struct v9fs_session_info *v9ses;
560         struct p9_fid *fid;
561
562         P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
563         err = 0;
564         v9ses = v9fs_inode2v9ses(dir);
565         perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
566         fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
567         if (IS_ERR(fid)) {
568                 err = PTR_ERR(fid);
569                 fid = NULL;
570         }
571
572         if (fid)
573                 p9_client_clunk(fid);
574
575         return err;
576 }
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
586 static 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;
591         struct p9_fid *dfid, *fid;
592         struct inode *inode;
593         char *name;
594         int result = 0;
595
596         P9_DPRINTK(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
597                 dir, dentry->d_name.name, dentry, nameidata);
598
599         sb = dir->i_sb;
600         v9ses = v9fs_inode2v9ses(dir);
601         dfid = v9fs_fid_lookup(dentry->d_parent);
602         if (IS_ERR(dfid))
603                 return ERR_CAST(dfid);
604
605         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);
609                 if (result == -ENOENT) {
610                         d_add(dentry, NULL);
611                         return NULL;
612                 }
613
614                 return ERR_PTR(result);
615         }
616
617         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;
622         }
623
624         result = v9fs_fid_add(dentry, fid);
625         if (result < 0)
626                 goto error;
627
628         if ((fid->qid.version) && (v9ses->cache))
629                 dentry->d_op = &v9fs_cached_dentry_operations;
630         else
631                 dentry->d_op = &v9fs_dentry_operations;
632
633         d_add(dentry, inode);
634         return NULL;
635
636 error:
637         p9_client_clunk(fid);
638
639         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
645  * @d: dentry that is being unlinked
646  *
647  */
648
649 static 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
657  * @d: dentry that is being unlinked
658  *
659  */
660
661 static 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
675 static int
676 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
677                 struct inode *new_dir, struct dentry *new_dentry)
678 {
679         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;
686
687         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);
692         if (IS_ERR(oldfid))
693                 return PTR_ERR(oldfid);
694
695         olddirfid = v9fs_fid_clone(old_dentry->d_parent);
696         if (IS_ERR(olddirfid)) {
697                 retval = PTR_ERR(olddirfid);
698                 goto done;
699         }
700
701         newdirfid = v9fs_fid_clone(new_dentry->d_parent);
702         if (IS_ERR(newdirfid)) {
703                 retval = PTR_ERR(newdirfid);
704                 goto clunk_olddir;
705         }
706
707         /* 9P can only handle file rename in the same directory */
708         if (memcmp(&olddirfid->qid, &newdirfid->qid, sizeof(newdirfid->qid))) {
709                 P9_DPRINTK(P9_DEBUG_ERROR,
710                                 "old dir and new dir are different\n");
711                 retval = -EXDEV;
712                 goto clunk_newdir;
713         }
714
715         v9fs_blank_wstat(&wstat);
716         wstat.muid = v9ses->uname;
717         wstat.name = (char *) new_dentry->d_name.name;
718         retval = p9_client_wstat(oldfid, &wstat);
719
720 clunk_newdir:
721         p9_client_clunk(newdirfid);
722
723 clunk_olddir:
724         p9_client_clunk(olddirfid);
725
726 done:
727         return retval;
728 }
729
730 /**
731  * v9fs_vfs_getattr - retrieve file metadata
732  * @mnt: mount information
733  * @dentry: file to get attributes on
734  * @stat: metadata structure to populate
735  *
736  */
737
738 static int
739 v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
740                  struct kstat *stat)
741 {
742         int err;
743         struct v9fs_session_info *v9ses;
744         struct p9_fid *fid;
745         struct p9_wstat *st;
746
747         P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
748         err = -EPERM;
749         v9ses = v9fs_inode2v9ses(dentry->d_inode);
750         if (v9ses->cache == CACHE_LOOSE)
751                 return simple_getattr(mnt, dentry, stat);
752
753         fid = v9fs_fid_lookup(dentry);
754         if (IS_ERR(fid))
755                 return PTR_ERR(fid);
756
757         st = p9_client_stat(fid);
758         if (IS_ERR(st))
759                 return PTR_ERR(st);
760
761         v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
762                 generic_fillattr(dentry->d_inode, stat);
763
764         kfree(st);
765         return 0;
766 }
767
768 /**
769  * v9fs_vfs_setattr - set file metadata
770  * @dentry: file whose metadata to set
771  * @iattr: metadata assignment structure
772  *
773  */
774
775 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
776 {
777         int retval;
778         struct v9fs_session_info *v9ses;
779         struct p9_fid *fid;
780         struct p9_wstat wstat;
781
782         P9_DPRINTK(P9_DEBUG_VFS, "\n");
783         retval = -EPERM;
784         v9ses = v9fs_inode2v9ses(dentry->d_inode);
785         fid = v9fs_fid_lookup(dentry);
786         if(IS_ERR(fid))
787                 return PTR_ERR(fid);
788
789         v9fs_blank_wstat(&wstat);
790         if (iattr->ia_valid & ATTR_MODE)
791                 wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
792
793         if (iattr->ia_valid & ATTR_MTIME)
794                 wstat.mtime = iattr->ia_mtime.tv_sec;
795
796         if (iattr->ia_valid & ATTR_ATIME)
797                 wstat.atime = iattr->ia_atime.tv_sec;
798
799         if (iattr->ia_valid & ATTR_SIZE)
800                 wstat.length = iattr->ia_size;
801
802         if (v9fs_extended(v9ses)) {
803                 if (iattr->ia_valid & ATTR_UID)
804                         wstat.n_uid = iattr->ia_uid;
805
806                 if (iattr->ia_valid & ATTR_GID)
807                         wstat.n_gid = iattr->ia_gid;
808         }
809
810         retval = p9_client_wstat(fid, &wstat);
811         if (retval >= 0)
812                 retval = inode_setattr(dentry->d_inode, iattr);
813
814         return retval;
815 }
816
817 /**
818  * v9fs_stat2inode - populate an inode structure with mistat info
819  * @stat: Plan 9 metadata (mistat) structure
820  * @inode: inode to populate
821  * @sb: superblock of filesystem
822  *
823  */
824
825 void
826 v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
827         struct super_block *sb)
828 {
829         char ext[32];
830         struct v9fs_session_info *v9ses = sb->s_fs_info;
831
832         inode->i_nlink = 1;
833
834         inode->i_atime.tv_sec = stat->atime;
835         inode->i_mtime.tv_sec = stat->mtime;
836         inode->i_ctime.tv_sec = stat->mtime;
837
838         inode->i_uid = v9ses->dfltuid;
839         inode->i_gid = v9ses->dfltgid;
840
841         if (v9fs_extended(v9ses)) {
842                 inode->i_uid = stat->n_uid;
843                 inode->i_gid = stat->n_gid;
844         }
845
846         inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
847         if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
848                 char type = 0;
849                 int major = -1;
850                 int minor = -1;
851
852                 strncpy(ext, stat->extension, sizeof(ext));
853                 sscanf(ext, "%c %u %u", &type, &major, &minor);
854                 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:
862                         P9_DPRINTK(P9_DEBUG_ERROR,
863                                 "Unknown special type %c %s\n", type,
864                                 stat->extension);
865                 };
866                 inode->i_rdev = MKDEV(major, minor);
867                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
868         } else
869                 inode->i_rdev = 0;
870
871         inode->i_size = stat->length;
872
873         /* not real number of blocks, but 512 byte ones ... */
874         inode->i_blocks = (inode->i_size + 512 - 1) >> 9;
875 }
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
884 ino_t v9fs_qid2ino(struct p9_qid *qid)
885 {
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 /**
898  * v9fs_readlink - read a symlink's location (internal version)
899  * @dentry: dentry for symlink
900  * @buffer: buffer to load symlink location into
901  * @buflen: length of buffer
902  *
903  */
904
905 static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
906 {
907         int retval;
908
909         struct v9fs_session_info *v9ses;
910         struct p9_fid *fid;
911         struct p9_wstat *st;
912
913         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);
917         if (IS_ERR(fid))
918                 return PTR_ERR(fid);
919
920         if (!v9fs_extended(v9ses))
921                 return -EBADF;
922
923         st = p9_client_stat(fid);
924         if (IS_ERR(st))
925                 return PTR_ERR(st);
926
927         if (!(st->mode & P9_DMSYMLINK)) {
928                 retval = -EINVAL;
929                 goto done;
930         }
931
932         /* copy extension buffer into buffer */
933         strncpy(buffer, st->extension, buflen);
934
935         P9_DPRINTK(P9_DEBUG_VFS,
936                 "%s -> %s (%s)\n", dentry->d_name.name, st->extension, buffer);
937
938         retval = buflen;
939
940 done:
941         kfree(st);
942         return retval;
943 }
944
945 /**
946  * v9fs_vfs_readlink - read a symlink's location
947  * @dentry: dentry for symlink
948  * @buffer: buffer to load symlink location into
949  * @buflen: length of buffer
950  *
951  */
952
953 static 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
960         if (unlikely(!link))
961                 return -ENOMEM;
962
963         if (buflen > PATH_MAX)
964                 buflen = PATH_MAX;
965
966         P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_name.name,
967                                                                         dentry);
968
969         retval = v9fs_readlink(dentry, link, buflen);
970
971         if (retval > 0) {
972                 if ((ret = copy_to_user(buffer, link, retval)) != 0) {
973                         P9_DPRINTK(P9_DEBUG_ERROR,
974                                         "problem copying to user: %d\n", ret);
975                         retval = ret;
976                 }
977         }
978
979         __putname(link);
980         return retval;
981 }
982
983 /**
984  * v9fs_vfs_follow_link - follow a symlink path
985  * @dentry: dentry for symlink
986  * @nd: nameidata
987  *
988  */
989
990 static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
991 {
992         int len = 0;
993         char *link = __getname();
994
995         P9_DPRINTK(P9_DEBUG_VFS, "%s n", dentry->d_name.name);
996
997         if (!link)
998                 link = ERR_PTR(-ENOMEM);
999         else {
1000                 len = v9fs_readlink(dentry, link, PATH_MAX);
1001
1002                 if (len < 0) {
1003                         __putname(link);
1004                         link = ERR_PTR(len);
1005                 } else
1006                         link[len] = 0;
1007         }
1008         nd_set_link(nd, link);
1009
1010         return NULL;
1011 }
1012
1013 /**
1014  * v9fs_vfs_put_link - release a symlink path
1015  * @dentry: dentry for symlink
1016  * @nd: nameidata
1017  * @p: unused
1018  *
1019  */
1020
1021 static void
1022 v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
1023 {
1024         char *s = nd_get_link(nd);
1025
1026         P9_DPRINTK(P9_DEBUG_VFS, " %s %s\n", dentry->d_name.name,
1027                 IS_ERR(s) ? "<error>" : s);
1028         if (!IS_ERR(s))
1029                 __putname(s);
1030 }
1031
1032 /**
1033  * v9fs_vfs_mkspecial - create a special file
1034  * @dir: inode to create special file in
1035  * @dentry: dentry to create
1036  * @mode: mode to create special file
1037  * @extension: 9p2000.u format extension string representing special file
1038  *
1039  */
1040
1041 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
1042         int mode, const char *extension)
1043 {
1044         u32 perm;
1045         struct v9fs_session_info *v9ses;
1046         struct p9_fid *fid;
1047
1048         v9ses = v9fs_inode2v9ses(dir);
1049         if (!v9fs_extended(v9ses)) {
1050                 P9_DPRINTK(P9_DEBUG_ERROR, "not extended\n");
1051                 return -EPERM;
1052         }
1053
1054         perm = unixmode2p9mode(v9ses, mode);
1055         fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
1056                                                                 P9_OREAD);
1057         if (IS_ERR(fid))
1058                 return PTR_ERR(fid);
1059
1060         p9_client_clunk(fid);
1061         return 0;
1062 }
1063
1064 /**
1065  * v9fs_vfs_symlink - helper function to create symlinks
1066  * @dir: directory inode containing symlink
1067  * @dentry: dentry for symlink
1068  * @symname: symlink data
1069  *
1070  * See Also: 9P2000.u RFC for more information
1071  *
1072  */
1073
1074 static int
1075 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1076 {
1077         P9_DPRINTK(P9_DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino,
1078                                         dentry->d_name.name, symname);
1079
1080         return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
1081 }
1082
1083 /**
1084  * v9fs_vfs_link - create a hardlink
1085  * @old_dentry: dentry for file to link to
1086  * @dir: inode destination for new link
1087  * @dentry: dentry for link
1088  *
1089  */
1090
1091 static int
1092 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
1093               struct dentry *dentry)
1094 {
1095         int retval;
1096         struct p9_fid *oldfid;
1097         char *name;
1098
1099         P9_DPRINTK(P9_DEBUG_VFS,
1100                 " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
1101                 old_dentry->d_name.name);
1102
1103         oldfid = v9fs_fid_clone(old_dentry);
1104         if (IS_ERR(oldfid))
1105                 return PTR_ERR(oldfid);
1106
1107         name = __getname();
1108         if (unlikely(!name)) {
1109                 retval = -ENOMEM;
1110                 goto clunk_fid;
1111         }
1112
1113         sprintf(name, "%d\n", oldfid->fid);
1114         retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
1115         __putname(name);
1116
1117 clunk_fid:
1118         p9_client_clunk(oldfid);
1119         return retval;
1120 }
1121
1122 /**
1123  * v9fs_vfs_mknod - create a special file
1124  * @dir: inode destination for new link
1125  * @dentry: dentry for file
1126  * @mode: mode for creation
1127  * @rdev: device associated with special file
1128  *
1129  */
1130
1131 static int
1132 v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1133 {
1134         int retval;
1135         char *name;
1136
1137         P9_DPRINTK(P9_DEBUG_VFS,
1138                 " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
1139                 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
1140
1141         if (!new_valid_dev(rdev))
1142                 return -EINVAL;
1143
1144         name = __getname();
1145         if (!name)
1146                 return -ENOMEM;
1147         /* build extension */
1148         if (S_ISBLK(mode))
1149                 sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
1150         else if (S_ISCHR(mode))
1151                 sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
1152         else if (S_ISFIFO(mode))
1153                 *name = 0;
1154         else {
1155                 __putname(name);
1156                 return -EINVAL;
1157         }
1158
1159         retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
1160         __putname(name);
1161
1162         return retval;
1163 }
1164
1165 static const struct inode_operations v9fs_dir_inode_operations_ext = {
1166         .create = v9fs_vfs_create,
1167         .lookup = v9fs_vfs_lookup,
1168         .symlink = v9fs_vfs_symlink,
1169         .link = v9fs_vfs_link,
1170         .unlink = v9fs_vfs_unlink,
1171         .mkdir = v9fs_vfs_mkdir,
1172         .rmdir = v9fs_vfs_rmdir,
1173         .mknod = v9fs_vfs_mknod,
1174         .rename = v9fs_vfs_rename,
1175         .readlink = v9fs_vfs_readlink,
1176         .getattr = v9fs_vfs_getattr,
1177         .setattr = v9fs_vfs_setattr,
1178 };
1179
1180 static const struct inode_operations v9fs_dir_inode_operations = {
1181         .create = v9fs_vfs_create,
1182         .lookup = v9fs_vfs_lookup,
1183         .unlink = v9fs_vfs_unlink,
1184         .mkdir = v9fs_vfs_mkdir,
1185         .rmdir = v9fs_vfs_rmdir,
1186         .mknod = v9fs_vfs_mknod,
1187         .rename = v9fs_vfs_rename,
1188         .getattr = v9fs_vfs_getattr,
1189         .setattr = v9fs_vfs_setattr,
1190 };
1191
1192 static const struct inode_operations v9fs_file_inode_operations = {
1193         .getattr = v9fs_vfs_getattr,
1194         .setattr = v9fs_vfs_setattr,
1195 };
1196
1197 static const struct inode_operations v9fs_symlink_inode_operations = {
1198         .readlink = v9fs_vfs_readlink,
1199         .follow_link = v9fs_vfs_follow_link,
1200         .put_link = v9fs_vfs_put_link,
1201         .getattr = v9fs_vfs_getattr,
1202         .setattr = v9fs_vfs_setattr,
1203 };