1 /*
2 * Copyright (c) 2004-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 #include "xfs.h"
19 #include "xfs_types.h"
20 #include "xfs_inum.h"
21 #include "xfs_log.h"
22 #include "xfs_trans.h"
23 #include "xfs_sb.h"
24 #include "xfs_ag.h"
25 #include "xfs_dmapi.h"
26 #include "xfs_mount.h"
27 #include "xfs_export.h"
28 #include "xfs_vnodeops.h"
29 #include "xfs_bmap_btree.h"
30 #include "xfs_inode.h"
31 #include "xfs_vfsops.h"
32
33 static struct dentry dotdot = { .d_name.name = "..", .d_name.len = 2, };
34
35 /*
36 * Note that we only accept fileids which are long enough rather than allow
37 * the parent generation number to default to zero. XFS considers zero a
38 * valid generation number not an invalid/wildcard value.
39 */
40 static int xfs_fileid_length(int fileid_type)
41 {
42 switch (fileid_type) {
43 case FILEID_INO32_GEN:
44 return 2;
45 case FILEID_INO32_GEN_PARENT:
46 return 4;
47 case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG:
48 return 3;
49 case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG:
50 return 6;
51 }
52 return 255; /* invalid */
53 }
54
55 STATIC int
56 xfs_fs_encode_fh(
57 struct dentry *dentry,
58 __u32 *fh,
59 int *max_len,
60 int connectable)
61 {
62 struct fid *fid = (struct fid *)fh;
63 struct xfs_fid64 *fid64 = (struct xfs_fid64 *)fh;
64 struct inode *inode = dentry->d_inode;
65 int fileid_type;
66 int len;
67
68 /* Directories don't need their parent encoded, they have ".." */
69 if (S_ISDIR(inode->i_mode))
70 fileid_type = FILEID_INO32_GEN;
71 else
72 fileid_type = FILEID_INO32_GEN_PARENT;
73
74 /* filesystem may contain 64bit inode numbers */
75 if (!(XFS_M(inode->i_sb)->m_flags & XFS_MOUNT_SMALL_INUMS))
76 fileid_type |= XFS_FILEID_TYPE_64FLAG;
77
78 /*
79 * Only encode if there is enough space given. In practice
80 * this means we can't export a filesystem with 64bit inodes
81 * over NFSv2 with the subtree_check export option; the other
82 * seven combinations work. The real answer is "don't use v2".
83 */
84 len = xfs_fileid_length(fileid_type);
85 if (*max_len < len)
86 return 255;
87 *max_len = len;
88
89 switch (fileid_type) {
90 case FILEID_INO32_GEN_PARENT:
91 spin_lock(&dentry->d_lock);
92 fid->i32.parent_ino = dentry->d_parent->d_inode->i_ino;
93 fid->i32.parent_gen = dentry->d_parent->d_inode->i_generation;
94 spin_unlock(&dentry->d_lock);
95 /*FALLTHRU*/
96 case FILEID_INO32_GEN:
97 fid->i32.ino = inode->i_ino;
98 fid->i32.gen = inode->i_generation;
99 break;
100 case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG:
101 spin_lock(&dentry->d_lock);
102 fid64->parent_ino = dentry->d_parent->d_inode->i_ino;
103 fid64->parent_gen = dentry->d_parent->d_inode->i_generation;
104 spin_unlock(&dentry->d_lock);
105 /*FALLTHRU*/
106 case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG:
107 fid64->ino = inode->i_ino;
108 fid64->gen = inode->i_generation;
109 break;
110 }
111
112 return fileid_type;
113 }
114
115 STATIC struct inode *
116 xfs_nfs_get_inode(
117 struct super_block *sb,
118 u64 ino,
119 u32 generation)
120 {
121 xfs_mount_t *mp = XFS_M(sb);
122 xfs_inode_t *ip;
123 int error;
124
125 /*
126 * NFS can sometimes send requests for ino 0. Fail them gracefully.
127 */
128 if (ino == 0)
129 return ERR_PTR(-ESTALE);
130
131 error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_SHARED, &ip, 0);
132 if (error)
133 return ERR_PTR(-error);
134 if (!ip)
135 return ERR_PTR(-EIO);
136
137 if (!ip->i_d.di_mode || ip->i_d.di_gen != generation) {
138 xfs_iput_new(ip, XFS_ILOCK_SHARED);
139 return ERR_PTR(-ENOENT);
140 }
141
142 xfs_iunlock(ip, XFS_ILOCK_SHARED);
143 return ip->i_vnode;
144 }
145
146 STATIC struct dentry *
147 xfs_fs_fh_to_dentry(struct super_block *sb, struct fid *fid,
148 int fh_len, int fileid_type)
149 {
150 struct xfs_fid64 *fid64 = (struct xfs_fid64 *)fid;
151 struct inode *inode = NULL;
152 struct dentry *result;
153
154 if (fh_len < xfs_fileid_length(fileid_type))
155 return NULL;
156
157 switch (fileid_type) {
158 case FILEID_INO32_GEN_PARENT:
159 case FILEID_INO32_GEN:
160 inode = xfs_nfs_get_inode(sb, fid->i32.ino, fid->i32.gen);
161 break;
162 case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG:
163 case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG:
164 inode = xfs_nfs_get_inode(sb, fid64->ino, fid64->gen);
165 break;
166 }
167
168 if (!inode)
169 return NULL;
170 if (IS_ERR(inode))
171 return ERR_PTR(PTR_ERR(inode));
172 result = d_alloc_anon(inode);
173 if (!result) {
174 iput(inode);
175 return ERR_PTR(-ENOMEM);
176 }
177 return result;
178 }
179
180 STATIC struct dentry *
181 xfs_fs_fh_to_parent(struct super_block *sb, struct fid *fid,
182 int fh_len, int fileid_type)
183 {
184 struct xfs_fid64 *fid64 = (struct xfs_fid64 *)fid;
185 struct inode *inode = NULL;
186 struct dentry *result;
187
188 switch (fileid_type) {
189 case FILEID_INO32_GEN_PARENT:
190 inode = xfs_nfs_get_inode(sb, fid->i32.parent_ino,
191 fid->i32.parent_gen);
192 break;
193 case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG:
194 inode = xfs_nfs_get_inode(sb, fid64->parent_ino,
195 fid64->parent_gen);
196 break;
197 }
198
199 if (!inode)
200 return NULL;
201 if (IS_ERR(inode))
202 return ERR_PTR(PTR_ERR(inode));
203 result = d_alloc_anon(inode);
204 if (!result) {
205 iput(inode);
206 return ERR_PTR(-ENOMEM);
207 }
208 return result;
209 }
210
211 STATIC struct dentry *
212 xfs_fs_get_parent(
213 struct dentry *child)
214 {
215 int error;
216 bhv_vnode_t *cvp;
217 struct dentry *parent;
218
219 cvp = NULL;
220 error = xfs_lookup(XFS_I(child->d_inode), &dotdot, &cvp);
221 if (unlikely(error))
222 return ERR_PTR(-error);
223
224 parent = d_alloc_anon(vn_to_inode(cvp));
225 if (unlikely(!parent)) {
226 VN_RELE(cvp);
227 return ERR_PTR(-ENOMEM);
228 }
229 return parent;
230 }
231
232 const struct export_operations xfs_export_operations = {
233 .encode_fh = xfs_fs_encode_fh,
234 .fh_to_dentry = xfs_fs_fh_to_dentry,
235 .fh_to_parent = xfs_fs_fh_to_parent,
236 .get_parent = xfs_fs_get_parent,
237 };
238
|
This page was automatically generated by the
LXR engine.
|