1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (c) 2004-2005 Silicon Graphics, Inc. |
4 | * All Rights Reserved. |
5 | */ |
6 | #include "xfs.h" |
7 | #include "xfs_shared.h" |
8 | #include "xfs_format.h" |
9 | #include "xfs_log_format.h" |
10 | #include "xfs_trans_resv.h" |
11 | #include "xfs_mount.h" |
12 | #include "xfs_dir2.h" |
13 | #include "xfs_export.h" |
14 | #include "xfs_inode.h" |
15 | #include "xfs_trans.h" |
16 | #include "xfs_inode_item.h" |
17 | #include "xfs_icache.h" |
18 | #include "xfs_pnfs.h" |
19 | |
20 | /* |
21 | * Note that we only accept fileids which are long enough rather than allow |
22 | * the parent generation number to default to zero. XFS considers zero a |
23 | * valid generation number not an invalid/wildcard value. |
24 | */ |
25 | static int xfs_fileid_length(int fileid_type) |
26 | { |
27 | switch (fileid_type) { |
28 | case FILEID_INO32_GEN: |
29 | return 2; |
30 | case FILEID_INO32_GEN_PARENT: |
31 | return 4; |
32 | case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG: |
33 | return 3; |
34 | case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG: |
35 | return 6; |
36 | } |
37 | return FILEID_INVALID; |
38 | } |
39 | |
40 | STATIC int |
41 | xfs_fs_encode_fh( |
42 | struct inode *inode, |
43 | __u32 *fh, |
44 | int *max_len, |
45 | struct inode *parent) |
46 | { |
47 | struct xfs_mount *mp = XFS_M(inode->i_sb); |
48 | struct fid *fid = (struct fid *)fh; |
49 | struct xfs_fid64 *fid64 = (struct xfs_fid64 *)fh; |
50 | int fileid_type; |
51 | int len; |
52 | |
53 | /* Directories don't need their parent encoded, they have ".." */ |
54 | if (!parent) |
55 | fileid_type = FILEID_INO32_GEN; |
56 | else |
57 | fileid_type = FILEID_INO32_GEN_PARENT; |
58 | |
59 | /* |
60 | * If the filesystem may contain 64bit inode numbers, we need |
61 | * to use larger file handles that can represent them. |
62 | * |
63 | * While we only allocate inodes that do not fit into 32 bits any |
64 | * large enough filesystem may contain them, thus the slightly |
65 | * confusing looking conditional below. |
66 | */ |
67 | if (!xfs_has_small_inums(mp) || xfs_is_inode32(mp)) |
68 | fileid_type |= XFS_FILEID_TYPE_64FLAG; |
69 | |
70 | /* |
71 | * Only encode if there is enough space given. In practice |
72 | * this means we can't export a filesystem with 64bit inodes |
73 | * over NFSv2 with the subtree_check export option; the other |
74 | * seven combinations work. The real answer is "don't use v2". |
75 | */ |
76 | len = xfs_fileid_length(fileid_type); |
77 | if (*max_len < len) { |
78 | *max_len = len; |
79 | return FILEID_INVALID; |
80 | } |
81 | *max_len = len; |
82 | |
83 | switch (fileid_type) { |
84 | case FILEID_INO32_GEN_PARENT: |
85 | fid->i32.parent_ino = XFS_I(inode: parent)->i_ino; |
86 | fid->i32.parent_gen = parent->i_generation; |
87 | fallthrough; |
88 | case FILEID_INO32_GEN: |
89 | fid->i32.ino = XFS_I(inode)->i_ino; |
90 | fid->i32.gen = inode->i_generation; |
91 | break; |
92 | case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG: |
93 | fid64->parent_ino = XFS_I(inode: parent)->i_ino; |
94 | fid64->parent_gen = parent->i_generation; |
95 | fallthrough; |
96 | case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG: |
97 | fid64->ino = XFS_I(inode)->i_ino; |
98 | fid64->gen = inode->i_generation; |
99 | break; |
100 | } |
101 | |
102 | return fileid_type; |
103 | } |
104 | |
105 | STATIC struct inode * |
106 | xfs_nfs_get_inode( |
107 | struct super_block *sb, |
108 | u64 ino, |
109 | u32 generation) |
110 | { |
111 | xfs_mount_t *mp = XFS_M(sb); |
112 | xfs_inode_t *ip; |
113 | int error; |
114 | |
115 | /* |
116 | * NFS can sometimes send requests for ino 0. Fail them gracefully. |
117 | */ |
118 | if (ino == 0) |
119 | return ERR_PTR(error: -ESTALE); |
120 | |
121 | /* |
122 | * The XFS_IGET_UNTRUSTED means that an invalid inode number is just |
123 | * fine and not an indication of a corrupted filesystem as clients can |
124 | * send invalid file handles and we have to handle it gracefully.. |
125 | */ |
126 | error = xfs_iget(mp, NULL, ino, XFS_IGET_UNTRUSTED, lock_flags: 0, ipp: &ip); |
127 | if (error) { |
128 | |
129 | /* |
130 | * EINVAL means the inode cluster doesn't exist anymore. |
131 | * EFSCORRUPTED means the metadata pointing to the inode cluster |
132 | * or the inode cluster itself is corrupt. This implies the |
133 | * filehandle is stale, so we should translate it here. |
134 | * We don't use ESTALE directly down the chain to not |
135 | * confuse applications using bulkstat that expect EINVAL. |
136 | */ |
137 | switch (error) { |
138 | case -EINVAL: |
139 | case -ENOENT: |
140 | case -EFSCORRUPTED: |
141 | error = -ESTALE; |
142 | break; |
143 | default: |
144 | break; |
145 | } |
146 | return ERR_PTR(error); |
147 | } |
148 | |
149 | /* |
150 | * Reload the incore unlinked list to avoid failure in inodegc. |
151 | * Use an unlocked check here because unrecovered unlinked inodes |
152 | * should be somewhat rare. |
153 | */ |
154 | if (xfs_inode_unlinked_incomplete(ip)) { |
155 | error = xfs_inode_reload_unlinked(ip); |
156 | if (error) { |
157 | xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); |
158 | xfs_irele(ip); |
159 | return ERR_PTR(error); |
160 | } |
161 | } |
162 | |
163 | if (VFS_I(ip)->i_generation != generation) { |
164 | xfs_irele(ip); |
165 | return ERR_PTR(error: -ESTALE); |
166 | } |
167 | |
168 | return VFS_I(ip); |
169 | } |
170 | |
171 | STATIC struct dentry * |
172 | xfs_fs_fh_to_dentry(struct super_block *sb, struct fid *fid, |
173 | int fh_len, int fileid_type) |
174 | { |
175 | struct xfs_fid64 *fid64 = (struct xfs_fid64 *)fid; |
176 | struct inode *inode = NULL; |
177 | |
178 | if (fh_len < xfs_fileid_length(fileid_type)) |
179 | return NULL; |
180 | |
181 | switch (fileid_type) { |
182 | case FILEID_INO32_GEN_PARENT: |
183 | case FILEID_INO32_GEN: |
184 | inode = xfs_nfs_get_inode(sb, ino: fid->i32.ino, generation: fid->i32.gen); |
185 | break; |
186 | case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG: |
187 | case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG: |
188 | inode = xfs_nfs_get_inode(sb, ino: fid64->ino, generation: fid64->gen); |
189 | break; |
190 | } |
191 | |
192 | return d_obtain_alias(inode); |
193 | } |
194 | |
195 | STATIC struct dentry * |
196 | xfs_fs_fh_to_parent(struct super_block *sb, struct fid *fid, |
197 | int fh_len, int fileid_type) |
198 | { |
199 | struct xfs_fid64 *fid64 = (struct xfs_fid64 *)fid; |
200 | struct inode *inode = NULL; |
201 | |
202 | if (fh_len < xfs_fileid_length(fileid_type)) |
203 | return NULL; |
204 | |
205 | switch (fileid_type) { |
206 | case FILEID_INO32_GEN_PARENT: |
207 | inode = xfs_nfs_get_inode(sb, ino: fid->i32.parent_ino, |
208 | generation: fid->i32.parent_gen); |
209 | break; |
210 | case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG: |
211 | inode = xfs_nfs_get_inode(sb, ino: fid64->parent_ino, |
212 | generation: fid64->parent_gen); |
213 | break; |
214 | } |
215 | |
216 | return d_obtain_alias(inode); |
217 | } |
218 | |
219 | STATIC struct dentry * |
220 | xfs_fs_get_parent( |
221 | struct dentry *child) |
222 | { |
223 | int error; |
224 | struct xfs_inode *cip; |
225 | |
226 | error = xfs_lookup(dp: XFS_I(inode: d_inode(dentry: child)), name: &xfs_name_dotdot, ipp: &cip, NULL); |
227 | if (unlikely(error)) |
228 | return ERR_PTR(error); |
229 | |
230 | return d_obtain_alias(VFS_I(ip: cip)); |
231 | } |
232 | |
233 | STATIC int |
234 | xfs_fs_nfs_commit_metadata( |
235 | struct inode *inode) |
236 | { |
237 | return xfs_log_force_inode(ip: XFS_I(inode)); |
238 | } |
239 | |
240 | const struct export_operations xfs_export_operations = { |
241 | .encode_fh = xfs_fs_encode_fh, |
242 | .fh_to_dentry = xfs_fs_fh_to_dentry, |
243 | .fh_to_parent = xfs_fs_fh_to_parent, |
244 | .get_parent = xfs_fs_get_parent, |
245 | .commit_metadata = xfs_fs_nfs_commit_metadata, |
246 | #ifdef CONFIG_EXPORTFS_BLOCK_OPS |
247 | .get_uuid = xfs_fs_get_uuid, |
248 | .map_blocks = xfs_fs_map_blocks, |
249 | .commit_blocks = xfs_fs_commit_blocks, |
250 | #endif |
251 | }; |
252 | |