2 * linux/fs/9p/vfs_inode_dotl.c
4 * This file contains vfs inode ops for the 9P2000.L protocol.
6 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
7 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
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.
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.
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
26 #include <linux/module.h>
27 #include <linux/errno.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 <linux/posix_acl.h>
40 #include <net/9p/9p.h>
41 #include <net/9p/client.h>
51 v9fs_vfs_mknod_dotl(struct inode
*dir
, struct dentry
*dentry
, umode_t omode
,
55 * v9fs_get_fsgid_for_create - Helper function to get the gid for creating a
56 * new file system object. This checks the S_ISGID to determine the owning
57 * group of the new file system object.
60 static kgid_t
v9fs_get_fsgid_for_create(struct inode
*dir_inode
)
62 BUG_ON(dir_inode
== NULL
);
64 if (dir_inode
->i_mode
& S_ISGID
) {
65 /* set_gid bit is set.*/
66 return dir_inode
->i_gid
;
68 return current_fsgid();
71 static int v9fs_test_inode_dotl(struct inode
*inode
, void *data
)
73 struct v9fs_inode
*v9inode
= V9FS_I(inode
);
74 struct p9_stat_dotl
*st
= (struct p9_stat_dotl
*)data
;
76 /* don't match inode of different type */
77 if ((inode
->i_mode
& S_IFMT
) != (st
->st_mode
& S_IFMT
))
80 if (inode
->i_generation
!= st
->st_gen
)
83 /* compare qid details */
84 if (memcmp(&v9inode
->qid
.version
,
85 &st
->qid
.version
, sizeof(v9inode
->qid
.version
)))
88 if (v9inode
->qid
.type
!= st
->qid
.type
)
91 if (v9inode
->qid
.path
!= st
->qid
.path
)
96 /* Always get a new inode */
97 static int v9fs_test_new_inode_dotl(struct inode
*inode
, void *data
)
102 static int v9fs_set_inode_dotl(struct inode
*inode
, void *data
)
104 struct v9fs_inode
*v9inode
= V9FS_I(inode
);
105 struct p9_stat_dotl
*st
= (struct p9_stat_dotl
*)data
;
107 memcpy(&v9inode
->qid
, &st
->qid
, sizeof(st
->qid
));
108 inode
->i_generation
= st
->st_gen
;
112 static struct inode
*v9fs_qid_iget_dotl(struct super_block
*sb
,
115 struct p9_stat_dotl
*st
,
121 struct v9fs_session_info
*v9ses
= sb
->s_fs_info
;
122 int (*test
)(struct inode
*, void *);
125 test
= v9fs_test_new_inode_dotl
;
127 test
= v9fs_test_inode_dotl
;
129 i_ino
= v9fs_qid2ino(qid
);
130 inode
= iget5_locked(sb
, i_ino
, test
, v9fs_set_inode_dotl
, st
);
132 return ERR_PTR(-ENOMEM
);
133 if (!(inode
->i_state
& I_NEW
))
136 * initialize the inode with the stat info
137 * FIXME!! we may need support for stale inodes
140 inode
->i_ino
= i_ino
;
141 retval
= v9fs_init_inode(v9ses
, inode
,
142 st
->st_mode
, new_decode_dev(st
->st_rdev
));
146 v9fs_stat2inode_dotl(st
, inode
);
147 v9fs_cache_inode_get_cookie(inode
);
148 retval
= v9fs_get_acl(inode
, fid
);
152 unlock_new_inode(inode
);
156 return ERR_PTR(retval
);
161 v9fs_inode_from_fid_dotl(struct v9fs_session_info
*v9ses
, struct p9_fid
*fid
,
162 struct super_block
*sb
, int new)
164 struct p9_stat_dotl
*st
;
165 struct inode
*inode
= NULL
;
167 st
= p9_client_getattr_dotl(fid
, P9_STATS_BASIC
| P9_STATS_GEN
);
171 inode
= v9fs_qid_iget_dotl(sb
, &st
->qid
, fid
, st
, new);
176 struct dotl_openflag_map
{
181 static int v9fs_mapped_dotl_flags(int flags
)
185 struct dotl_openflag_map dotl_oflag_map
[] = {
186 { O_CREAT
, P9_DOTL_CREATE
},
187 { O_EXCL
, P9_DOTL_EXCL
},
188 { O_NOCTTY
, P9_DOTL_NOCTTY
},
189 { O_APPEND
, P9_DOTL_APPEND
},
190 { O_NONBLOCK
, P9_DOTL_NONBLOCK
},
191 { O_DSYNC
, P9_DOTL_DSYNC
},
192 { FASYNC
, P9_DOTL_FASYNC
},
193 { O_DIRECT
, P9_DOTL_DIRECT
},
194 { O_LARGEFILE
, P9_DOTL_LARGEFILE
},
195 { O_DIRECTORY
, P9_DOTL_DIRECTORY
},
196 { O_NOFOLLOW
, P9_DOTL_NOFOLLOW
},
197 { O_NOATIME
, P9_DOTL_NOATIME
},
198 { O_CLOEXEC
, P9_DOTL_CLOEXEC
},
199 { O_SYNC
, P9_DOTL_SYNC
},
201 for (i
= 0; i
< ARRAY_SIZE(dotl_oflag_map
); i
++) {
202 if (flags
& dotl_oflag_map
[i
].open_flag
)
203 rflags
|= dotl_oflag_map
[i
].dotl_flag
;
209 * v9fs_open_to_dotl_flags- convert Linux specific open flags to
211 * @flags: flags to convert
213 int v9fs_open_to_dotl_flags(int flags
)
218 * We have same bits for P9_DOTL_READONLY, P9_DOTL_WRONLY
219 * and P9_DOTL_NOACCESS
221 rflags
|= flags
& O_ACCMODE
;
222 rflags
|= v9fs_mapped_dotl_flags(flags
);
228 * v9fs_vfs_create_dotl - VFS hook to create files for 9P2000.L protocol.
229 * @dir: directory inode that is being created
230 * @dentry: dentry that is being deleted
231 * @omode: create permissions
236 v9fs_vfs_create_dotl(struct inode
*dir
, struct dentry
*dentry
, umode_t omode
,
239 return v9fs_vfs_mknod_dotl(dir
, dentry
, omode
, 0);
243 v9fs_vfs_atomic_open_dotl(struct inode
*dir
, struct dentry
*dentry
,
244 struct file
*file
, unsigned flags
, umode_t omode
,
253 struct p9_fid
*fid
= NULL
;
254 struct v9fs_inode
*v9inode
;
255 struct p9_fid
*dfid
, *ofid
, *inode_fid
;
256 struct v9fs_session_info
*v9ses
;
257 struct posix_acl
*pacl
= NULL
, *dacl
= NULL
;
258 struct dentry
*res
= NULL
;
260 if (d_unhashed(dentry
)) {
261 res
= v9fs_vfs_lookup(dir
, dentry
, 0);
270 if (!(flags
& O_CREAT
) || d_really_is_positive(dentry
))
271 return finish_no_open(file
, res
);
273 v9ses
= v9fs_inode2v9ses(dir
);
275 name
= (char *) dentry
->d_name
.name
;
276 p9_debug(P9_DEBUG_VFS
, "name:%s flags:0x%x mode:0x%hx\n",
279 dfid
= v9fs_fid_lookup(dentry
->d_parent
);
282 p9_debug(P9_DEBUG_VFS
, "fid lookup failed %d\n", err
);
286 /* clone a fid to use for creation */
287 ofid
= p9_client_walk(dfid
, 0, NULL
, 1);
290 p9_debug(P9_DEBUG_VFS
, "p9_client_walk failed %d\n", err
);
294 gid
= v9fs_get_fsgid_for_create(dir
);
297 /* Update mode based on ACL value */
298 err
= v9fs_acl_mode(dir
, &mode
, &dacl
, &pacl
);
300 p9_debug(P9_DEBUG_VFS
, "Failed to get acl values in creat %d\n",
304 err
= p9_client_create_dotl(ofid
, name
, v9fs_open_to_dotl_flags(flags
),
307 p9_debug(P9_DEBUG_VFS
, "p9_client_open_dotl failed in creat %d\n",
311 v9fs_invalidate_inode_attr(dir
);
313 /* instantiate inode and assign the unopened fid to the dentry */
314 fid
= p9_client_walk(dfid
, 1, &name
, 1);
317 p9_debug(P9_DEBUG_VFS
, "p9_client_walk failed %d\n", err
);
321 inode
= v9fs_get_new_inode_from_fid(v9ses
, fid
, dir
->i_sb
);
323 err
= PTR_ERR(inode
);
324 p9_debug(P9_DEBUG_VFS
, "inode creation failed %d\n", err
);
327 /* Now set the ACL based on the default value */
328 v9fs_set_create_acl(inode
, fid
, dacl
, pacl
);
330 v9fs_fid_add(dentry
, fid
);
331 d_instantiate(dentry
, inode
);
333 v9inode
= V9FS_I(inode
);
334 mutex_lock(&v9inode
->v_mutex
);
335 if ((v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
) &&
336 !v9inode
->writeback_fid
&&
337 ((flags
& O_ACCMODE
) != O_RDONLY
)) {
339 * clone a fid and add it to writeback_fid
340 * we do it during open time instead of
341 * page dirty time via write_begin/page_mkwrite
342 * because we want write after unlink usecase
345 inode_fid
= v9fs_writeback_fid(dentry
);
346 if (IS_ERR(inode_fid
)) {
347 err
= PTR_ERR(inode_fid
);
348 mutex_unlock(&v9inode
->v_mutex
);
349 goto err_clunk_old_fid
;
351 v9inode
->writeback_fid
= (void *) inode_fid
;
353 mutex_unlock(&v9inode
->v_mutex
);
354 /* Since we are opening a file, assign the open fid to the file */
355 err
= finish_open(file
, dentry
, generic_file_open
, opened
);
357 goto err_clunk_old_fid
;
358 file
->private_data
= ofid
;
359 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
)
360 v9fs_cache_inode_set_cookie(inode
, file
);
361 *opened
|= FILE_CREATED
;
363 v9fs_put_acl(dacl
, pacl
);
369 p9_client_clunk(fid
);
372 p9_client_clunk(ofid
);
377 * v9fs_vfs_mkdir_dotl - VFS mkdir hook to create a directory
378 * @dir: inode that is being unlinked
379 * @dentry: dentry that is being unlinked
380 * @omode: mode for new directory
384 static int v9fs_vfs_mkdir_dotl(struct inode
*dir
,
385 struct dentry
*dentry
, umode_t omode
)
388 struct v9fs_session_info
*v9ses
;
389 struct p9_fid
*fid
= NULL
, *dfid
= NULL
;
395 struct dentry
*dir_dentry
;
396 struct posix_acl
*dacl
= NULL
, *pacl
= NULL
;
398 p9_debug(P9_DEBUG_VFS
, "name %pd\n", dentry
);
400 v9ses
= v9fs_inode2v9ses(dir
);
403 if (dir
->i_mode
& S_ISGID
)
406 dir_dentry
= dentry
->d_parent
;
407 dfid
= v9fs_fid_lookup(dir_dentry
);
410 p9_debug(P9_DEBUG_VFS
, "fid lookup failed %d\n", err
);
415 gid
= v9fs_get_fsgid_for_create(dir
);
417 /* Update mode based on ACL value */
418 err
= v9fs_acl_mode(dir
, &mode
, &dacl
, &pacl
);
420 p9_debug(P9_DEBUG_VFS
, "Failed to get acl values in mkdir %d\n",
424 name
= (char *) dentry
->d_name
.name
;
425 err
= p9_client_mkdir_dotl(dfid
, name
, mode
, gid
, &qid
);
429 fid
= p9_client_walk(dfid
, 1, &name
, 1);
432 p9_debug(P9_DEBUG_VFS
, "p9_client_walk failed %d\n",
438 /* instantiate inode and assign the unopened fid to the dentry */
439 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
) {
440 inode
= v9fs_get_new_inode_from_fid(v9ses
, fid
, dir
->i_sb
);
442 err
= PTR_ERR(inode
);
443 p9_debug(P9_DEBUG_VFS
, "inode creation failed %d\n",
447 v9fs_fid_add(dentry
, fid
);
448 v9fs_set_create_acl(inode
, fid
, dacl
, pacl
);
449 d_instantiate(dentry
, inode
);
454 * Not in cached mode. No need to populate
455 * inode with stat. We need to get an inode
456 * so that we can set the acl with dentry
458 inode
= v9fs_get_inode(dir
->i_sb
, mode
, 0);
460 err
= PTR_ERR(inode
);
463 v9fs_set_create_acl(inode
, fid
, dacl
, pacl
);
464 d_instantiate(dentry
, inode
);
467 v9fs_invalidate_inode_attr(dir
);
470 p9_client_clunk(fid
);
471 v9fs_put_acl(dacl
, pacl
);
476 v9fs_vfs_getattr_dotl(struct vfsmount
*mnt
, struct dentry
*dentry
,
479 struct v9fs_session_info
*v9ses
;
481 struct p9_stat_dotl
*st
;
483 p9_debug(P9_DEBUG_VFS
, "dentry: %p\n", dentry
);
484 v9ses
= v9fs_dentry2v9ses(dentry
);
485 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
) {
486 generic_fillattr(d_inode(dentry
), stat
);
489 fid
= v9fs_fid_lookup(dentry
);
493 /* Ask for all the fields in stat structure. Server will return
494 * whatever it supports
497 st
= p9_client_getattr_dotl(fid
, P9_STATS_ALL
);
501 v9fs_stat2inode_dotl(st
, d_inode(dentry
));
502 generic_fillattr(d_inode(dentry
), stat
);
503 /* Change block size to what the server returned */
504 stat
->blksize
= st
->st_blksize
;
513 #define P9_ATTR_MODE (1 << 0)
514 #define P9_ATTR_UID (1 << 1)
515 #define P9_ATTR_GID (1 << 2)
516 #define P9_ATTR_SIZE (1 << 3)
517 #define P9_ATTR_ATIME (1 << 4)
518 #define P9_ATTR_MTIME (1 << 5)
519 #define P9_ATTR_CTIME (1 << 6)
520 #define P9_ATTR_ATIME_SET (1 << 7)
521 #define P9_ATTR_MTIME_SET (1 << 8)
523 struct dotl_iattr_map
{
528 static int v9fs_mapped_iattr_valid(int iattr_valid
)
531 int p9_iattr_valid
= 0;
532 struct dotl_iattr_map dotl_iattr_map
[] = {
533 { ATTR_MODE
, P9_ATTR_MODE
},
534 { ATTR_UID
, P9_ATTR_UID
},
535 { ATTR_GID
, P9_ATTR_GID
},
536 { ATTR_SIZE
, P9_ATTR_SIZE
},
537 { ATTR_ATIME
, P9_ATTR_ATIME
},
538 { ATTR_MTIME
, P9_ATTR_MTIME
},
539 { ATTR_CTIME
, P9_ATTR_CTIME
},
540 { ATTR_ATIME_SET
, P9_ATTR_ATIME_SET
},
541 { ATTR_MTIME_SET
, P9_ATTR_MTIME_SET
},
543 for (i
= 0; i
< ARRAY_SIZE(dotl_iattr_map
); i
++) {
544 if (iattr_valid
& dotl_iattr_map
[i
].iattr_valid
)
545 p9_iattr_valid
|= dotl_iattr_map
[i
].p9_iattr_valid
;
547 return p9_iattr_valid
;
551 * v9fs_vfs_setattr_dotl - set file metadata
552 * @dentry: file whose metadata to set
553 * @iattr: metadata assignment structure
557 int v9fs_vfs_setattr_dotl(struct dentry
*dentry
, struct iattr
*iattr
)
561 struct p9_iattr_dotl p9attr
;
562 struct inode
*inode
= d_inode(dentry
);
564 p9_debug(P9_DEBUG_VFS
, "\n");
566 retval
= inode_change_ok(inode
, iattr
);
570 p9attr
.valid
= v9fs_mapped_iattr_valid(iattr
->ia_valid
);
571 p9attr
.mode
= iattr
->ia_mode
;
572 p9attr
.uid
= iattr
->ia_uid
;
573 p9attr
.gid
= iattr
->ia_gid
;
574 p9attr
.size
= iattr
->ia_size
;
575 p9attr
.atime_sec
= iattr
->ia_atime
.tv_sec
;
576 p9attr
.atime_nsec
= iattr
->ia_atime
.tv_nsec
;
577 p9attr
.mtime_sec
= iattr
->ia_mtime
.tv_sec
;
578 p9attr
.mtime_nsec
= iattr
->ia_mtime
.tv_nsec
;
580 fid
= v9fs_fid_lookup(dentry
);
584 /* Write all dirty data */
585 if (S_ISREG(inode
->i_mode
))
586 filemap_write_and_wait(inode
->i_mapping
);
588 retval
= p9_client_setattr(fid
, &p9attr
);
592 if ((iattr
->ia_valid
& ATTR_SIZE
) &&
593 iattr
->ia_size
!= i_size_read(inode
))
594 truncate_setsize(inode
, iattr
->ia_size
);
596 v9fs_invalidate_inode_attr(inode
);
597 setattr_copy(inode
, iattr
);
598 mark_inode_dirty(inode
);
599 if (iattr
->ia_valid
& ATTR_MODE
) {
600 /* We also want to update ACL when we update mode bits */
601 retval
= v9fs_acl_chmod(inode
, fid
);
609 * v9fs_stat2inode_dotl - populate an inode structure with stat info
610 * @stat: stat structure
611 * @inode: inode to populate
616 v9fs_stat2inode_dotl(struct p9_stat_dotl
*stat
, struct inode
*inode
)
619 struct v9fs_inode
*v9inode
= V9FS_I(inode
);
621 if ((stat
->st_result_mask
& P9_STATS_BASIC
) == P9_STATS_BASIC
) {
622 inode
->i_atime
.tv_sec
= stat
->st_atime_sec
;
623 inode
->i_atime
.tv_nsec
= stat
->st_atime_nsec
;
624 inode
->i_mtime
.tv_sec
= stat
->st_mtime_sec
;
625 inode
->i_mtime
.tv_nsec
= stat
->st_mtime_nsec
;
626 inode
->i_ctime
.tv_sec
= stat
->st_ctime_sec
;
627 inode
->i_ctime
.tv_nsec
= stat
->st_ctime_nsec
;
628 inode
->i_uid
= stat
->st_uid
;
629 inode
->i_gid
= stat
->st_gid
;
630 set_nlink(inode
, stat
->st_nlink
);
632 mode
= stat
->st_mode
& S_IALLUGO
;
633 mode
|= inode
->i_mode
& ~S_IALLUGO
;
634 inode
->i_mode
= mode
;
636 i_size_write(inode
, stat
->st_size
);
637 inode
->i_blocks
= stat
->st_blocks
;
639 if (stat
->st_result_mask
& P9_STATS_ATIME
) {
640 inode
->i_atime
.tv_sec
= stat
->st_atime_sec
;
641 inode
->i_atime
.tv_nsec
= stat
->st_atime_nsec
;
643 if (stat
->st_result_mask
& P9_STATS_MTIME
) {
644 inode
->i_mtime
.tv_sec
= stat
->st_mtime_sec
;
645 inode
->i_mtime
.tv_nsec
= stat
->st_mtime_nsec
;
647 if (stat
->st_result_mask
& P9_STATS_CTIME
) {
648 inode
->i_ctime
.tv_sec
= stat
->st_ctime_sec
;
649 inode
->i_ctime
.tv_nsec
= stat
->st_ctime_nsec
;
651 if (stat
->st_result_mask
& P9_STATS_UID
)
652 inode
->i_uid
= stat
->st_uid
;
653 if (stat
->st_result_mask
& P9_STATS_GID
)
654 inode
->i_gid
= stat
->st_gid
;
655 if (stat
->st_result_mask
& P9_STATS_NLINK
)
656 set_nlink(inode
, stat
->st_nlink
);
657 if (stat
->st_result_mask
& P9_STATS_MODE
) {
658 inode
->i_mode
= stat
->st_mode
;
659 if ((S_ISBLK(inode
->i_mode
)) ||
660 (S_ISCHR(inode
->i_mode
)))
661 init_special_inode(inode
, inode
->i_mode
,
664 if (stat
->st_result_mask
& P9_STATS_RDEV
)
665 inode
->i_rdev
= new_decode_dev(stat
->st_rdev
);
666 if (stat
->st_result_mask
& P9_STATS_SIZE
)
667 i_size_write(inode
, stat
->st_size
);
668 if (stat
->st_result_mask
& P9_STATS_BLOCKS
)
669 inode
->i_blocks
= stat
->st_blocks
;
671 if (stat
->st_result_mask
& P9_STATS_GEN
)
672 inode
->i_generation
= stat
->st_gen
;
674 /* Currently we don't support P9_STATS_BTIME and P9_STATS_DATA_VERSION
675 * because the inode structure does not have fields for them.
677 v9inode
->cache_validity
&= ~V9FS_INO_INVALID_ATTR
;
681 v9fs_vfs_symlink_dotl(struct inode
*dir
, struct dentry
*dentry
,
690 struct p9_fid
*fid
= NULL
;
691 struct v9fs_session_info
*v9ses
;
693 name
= (char *) dentry
->d_name
.name
;
694 p9_debug(P9_DEBUG_VFS
, "%lu,%s,%s\n", dir
->i_ino
, name
, symname
);
695 v9ses
= v9fs_inode2v9ses(dir
);
697 dfid
= v9fs_fid_lookup(dentry
->d_parent
);
700 p9_debug(P9_DEBUG_VFS
, "fid lookup failed %d\n", err
);
704 gid
= v9fs_get_fsgid_for_create(dir
);
706 /* Server doesn't alter fid on TSYMLINK. Hence no need to clone it. */
707 err
= p9_client_symlink(dfid
, name
, (char *)symname
, gid
, &qid
);
710 p9_debug(P9_DEBUG_VFS
, "p9_client_symlink failed %d\n", err
);
714 v9fs_invalidate_inode_attr(dir
);
715 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
) {
716 /* Now walk from the parent so we can get an unopened fid. */
717 fid
= p9_client_walk(dfid
, 1, &name
, 1);
720 p9_debug(P9_DEBUG_VFS
, "p9_client_walk failed %d\n",
726 /* instantiate inode and assign the unopened fid to dentry */
727 inode
= v9fs_get_new_inode_from_fid(v9ses
, fid
, dir
->i_sb
);
729 err
= PTR_ERR(inode
);
730 p9_debug(P9_DEBUG_VFS
, "inode creation failed %d\n",
734 v9fs_fid_add(dentry
, fid
);
735 d_instantiate(dentry
, inode
);
739 /* Not in cached mode. No need to populate inode with stat */
740 inode
= v9fs_get_inode(dir
->i_sb
, S_IFLNK
, 0);
742 err
= PTR_ERR(inode
);
745 d_instantiate(dentry
, inode
);
750 p9_client_clunk(fid
);
756 * v9fs_vfs_link_dotl - create a hardlink for dotl
757 * @old_dentry: dentry for file to link to
758 * @dir: inode destination for new link
759 * @dentry: dentry for link
764 v9fs_vfs_link_dotl(struct dentry
*old_dentry
, struct inode
*dir
,
765 struct dentry
*dentry
)
768 struct dentry
*dir_dentry
;
769 struct p9_fid
*dfid
, *oldfid
;
770 struct v9fs_session_info
*v9ses
;
772 p9_debug(P9_DEBUG_VFS
, "dir ino: %lu, old_name: %pd, new_name: %pd\n",
773 dir
->i_ino
, old_dentry
, dentry
);
775 v9ses
= v9fs_inode2v9ses(dir
);
776 dir_dentry
= dentry
->d_parent
;
777 dfid
= v9fs_fid_lookup(dir_dentry
);
779 return PTR_ERR(dfid
);
781 oldfid
= v9fs_fid_lookup(old_dentry
);
783 return PTR_ERR(oldfid
);
785 err
= p9_client_link(dfid
, oldfid
, (char *)dentry
->d_name
.name
);
788 p9_debug(P9_DEBUG_VFS
, "p9_client_link failed %d\n", err
);
792 v9fs_invalidate_inode_attr(dir
);
793 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
) {
794 /* Get the latest stat info from server. */
796 fid
= v9fs_fid_lookup(old_dentry
);
800 v9fs_refresh_inode_dotl(fid
, d_inode(old_dentry
));
802 ihold(d_inode(old_dentry
));
803 d_instantiate(dentry
, d_inode(old_dentry
));
809 * v9fs_vfs_mknod_dotl - create a special file
810 * @dir: inode destination for new link
811 * @dentry: dentry for file
812 * @omode: mode for creation
813 * @rdev: device associated with special file
817 v9fs_vfs_mknod_dotl(struct inode
*dir
, struct dentry
*dentry
, umode_t omode
,
824 struct v9fs_session_info
*v9ses
;
825 struct p9_fid
*fid
= NULL
, *dfid
= NULL
;
828 struct dentry
*dir_dentry
;
829 struct posix_acl
*dacl
= NULL
, *pacl
= NULL
;
831 p9_debug(P9_DEBUG_VFS
, " %lu,%pd mode: %hx MAJOR: %u MINOR: %u\n",
832 dir
->i_ino
, dentry
, omode
,
833 MAJOR(rdev
), MINOR(rdev
));
835 v9ses
= v9fs_inode2v9ses(dir
);
836 dir_dentry
= dentry
->d_parent
;
837 dfid
= v9fs_fid_lookup(dir_dentry
);
840 p9_debug(P9_DEBUG_VFS
, "fid lookup failed %d\n", err
);
845 gid
= v9fs_get_fsgid_for_create(dir
);
847 /* Update mode based on ACL value */
848 err
= v9fs_acl_mode(dir
, &mode
, &dacl
, &pacl
);
850 p9_debug(P9_DEBUG_VFS
, "Failed to get acl values in mknod %d\n",
854 name
= (char *) dentry
->d_name
.name
;
856 err
= p9_client_mknod_dotl(dfid
, name
, mode
, rdev
, gid
, &qid
);
860 v9fs_invalidate_inode_attr(dir
);
861 fid
= p9_client_walk(dfid
, 1, &name
, 1);
864 p9_debug(P9_DEBUG_VFS
, "p9_client_walk failed %d\n",
870 /* instantiate inode and assign the unopened fid to the dentry */
871 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
) {
872 inode
= v9fs_get_new_inode_from_fid(v9ses
, fid
, dir
->i_sb
);
874 err
= PTR_ERR(inode
);
875 p9_debug(P9_DEBUG_VFS
, "inode creation failed %d\n",
879 v9fs_set_create_acl(inode
, fid
, dacl
, pacl
);
880 v9fs_fid_add(dentry
, fid
);
881 d_instantiate(dentry
, inode
);
886 * Not in cached mode. No need to populate inode with stat.
887 * socket syscall returns a fd, so we need instantiate
889 inode
= v9fs_get_inode(dir
->i_sb
, mode
, rdev
);
891 err
= PTR_ERR(inode
);
894 v9fs_set_create_acl(inode
, fid
, dacl
, pacl
);
895 d_instantiate(dentry
, inode
);
899 p9_client_clunk(fid
);
900 v9fs_put_acl(dacl
, pacl
);
905 * v9fs_vfs_follow_link_dotl - follow a symlink path
906 * @dentry: dentry for symlink
907 * @cookie: place to pass the data to put_link()
911 v9fs_vfs_follow_link_dotl(struct dentry
*dentry
, void **cookie
)
913 struct p9_fid
*fid
= v9fs_fid_lookup(dentry
);
917 p9_debug(P9_DEBUG_VFS
, "%pd\n", dentry
);
920 return ERR_CAST(fid
);
921 retval
= p9_client_readlink(fid
, &target
);
923 return ERR_PTR(retval
);
924 return *cookie
= target
;
927 int v9fs_refresh_inode_dotl(struct p9_fid
*fid
, struct inode
*inode
)
930 struct p9_stat_dotl
*st
;
931 struct v9fs_session_info
*v9ses
;
933 v9ses
= v9fs_inode2v9ses(inode
);
934 st
= p9_client_getattr_dotl(fid
, P9_STATS_ALL
);
938 * Don't update inode if the file type is different
940 if ((inode
->i_mode
& S_IFMT
) != (st
->st_mode
& S_IFMT
))
943 spin_lock(&inode
->i_lock
);
945 * We don't want to refresh inode->i_size,
946 * because we may have cached data
948 i_size
= inode
->i_size
;
949 v9fs_stat2inode_dotl(st
, inode
);
950 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
)
951 inode
->i_size
= i_size
;
952 spin_unlock(&inode
->i_lock
);
958 const struct inode_operations v9fs_dir_inode_operations_dotl
= {
959 .create
= v9fs_vfs_create_dotl
,
960 .atomic_open
= v9fs_vfs_atomic_open_dotl
,
961 .lookup
= v9fs_vfs_lookup
,
962 .link
= v9fs_vfs_link_dotl
,
963 .symlink
= v9fs_vfs_symlink_dotl
,
964 .unlink
= v9fs_vfs_unlink
,
965 .mkdir
= v9fs_vfs_mkdir_dotl
,
966 .rmdir
= v9fs_vfs_rmdir
,
967 .mknod
= v9fs_vfs_mknod_dotl
,
968 .rename
= v9fs_vfs_rename
,
969 .getattr
= v9fs_vfs_getattr_dotl
,
970 .setattr
= v9fs_vfs_setattr_dotl
,
971 .setxattr
= generic_setxattr
,
972 .getxattr
= generic_getxattr
,
973 .removexattr
= generic_removexattr
,
974 .listxattr
= v9fs_listxattr
,
975 .get_acl
= v9fs_iop_get_acl
,
978 const struct inode_operations v9fs_file_inode_operations_dotl
= {
979 .getattr
= v9fs_vfs_getattr_dotl
,
980 .setattr
= v9fs_vfs_setattr_dotl
,
981 .setxattr
= generic_setxattr
,
982 .getxattr
= generic_getxattr
,
983 .removexattr
= generic_removexattr
,
984 .listxattr
= v9fs_listxattr
,
985 .get_acl
= v9fs_iop_get_acl
,
988 const struct inode_operations v9fs_symlink_inode_operations_dotl
= {
989 .readlink
= generic_readlink
,
990 .follow_link
= v9fs_vfs_follow_link_dotl
,
991 .put_link
= kfree_put_link
,
992 .getattr
= v9fs_vfs_getattr_dotl
,
993 .setattr
= v9fs_vfs_setattr_dotl
,
994 .setxattr
= generic_setxattr
,
995 .getxattr
= generic_getxattr
,
996 .removexattr
= generic_removexattr
,
997 .listxattr
= v9fs_listxattr
,