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