1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * Copyright (C) 1995, 1996, 1997 Olaf Kirch <okir@monad.swb.de> |
4 | * |
5 | * This file describes the layout of the file handles as passed |
6 | * over the wire. |
7 | */ |
8 | #ifndef _LINUX_NFSD_NFSFH_H |
9 | #define _LINUX_NFSD_NFSFH_H |
10 | |
11 | #include <linux/crc32.h> |
12 | #include <linux/sunrpc/svc.h> |
13 | #include <linux/iversion.h> |
14 | #include <linux/exportfs.h> |
15 | #include <linux/nfs4.h> |
16 | |
17 | /* |
18 | * The file handle starts with a sequence of four-byte words. |
19 | * The first word contains a version number (1) and three descriptor bytes |
20 | * that tell how the remaining 3 variable length fields should be handled. |
21 | * These three bytes are auth_type, fsid_type and fileid_type. |
22 | * |
23 | * All four-byte values are in host-byte-order. |
24 | * |
25 | * The auth_type field is deprecated and must be set to 0. |
26 | * |
27 | * The fsid_type identifies how the filesystem (or export point) is |
28 | * encoded. |
29 | * Current values: |
30 | * 0 - 4 byte device id (ms-2-bytes major, ls-2-bytes minor), 4byte inode number |
31 | * NOTE: we cannot use the kdev_t device id value, because kdev_t.h |
32 | * says we mustn't. We must break it up and reassemble. |
33 | * 1 - 4 byte user specified identifier |
34 | * 2 - 4 byte major, 4 byte minor, 4 byte inode number - DEPRECATED |
35 | * 3 - 4 byte device id, encoded for user-space, 4 byte inode number |
36 | * 4 - 4 byte inode number and 4 byte uuid |
37 | * 5 - 8 byte uuid |
38 | * 6 - 16 byte uuid |
39 | * 7 - 8 byte inode number and 16 byte uuid |
40 | * |
41 | * The fileid_type identifies how the file within the filesystem is encoded. |
42 | * The values for this field are filesystem specific, exccept that |
43 | * filesystems must not use the values '0' or '0xff'. 'See enum fid_type' |
44 | * in include/linux/exportfs.h for currently registered values. |
45 | */ |
46 | |
47 | struct knfsd_fh { |
48 | unsigned int fh_size; /* |
49 | * Points to the current size while |
50 | * building a new file handle. |
51 | */ |
52 | union { |
53 | char fh_raw[NFS4_FHSIZE]; |
54 | struct { |
55 | u8 fh_version; /* == 1 */ |
56 | u8 fh_auth_type; /* deprecated */ |
57 | u8 fh_fsid_type; |
58 | u8 fh_fileid_type; |
59 | u32 fh_fsid[]; /* flexible-array member */ |
60 | }; |
61 | }; |
62 | }; |
63 | |
64 | static inline __u32 ino_t_to_u32(ino_t ino) |
65 | { |
66 | return (__u32) ino; |
67 | } |
68 | |
69 | static inline ino_t u32_to_ino_t(__u32 uino) |
70 | { |
71 | return (ino_t) uino; |
72 | } |
73 | |
74 | /* |
75 | * This is the internal representation of an NFS handle used in knfsd. |
76 | * pre_mtime/post_version will be used to support wcc_attr's in NFSv3. |
77 | */ |
78 | typedef struct svc_fh { |
79 | struct knfsd_fh fh_handle; /* FH data */ |
80 | int fh_maxsize; /* max size for fh_handle */ |
81 | struct dentry * fh_dentry; /* validated dentry */ |
82 | struct svc_export * fh_export; /* export pointer */ |
83 | |
84 | bool fh_want_write; /* remount protection taken */ |
85 | bool fh_no_wcc; /* no wcc data needed */ |
86 | bool fh_no_atomic_attr; |
87 | /* |
88 | * wcc data is not atomic with |
89 | * operation |
90 | */ |
91 | int fh_flags; /* FH flags */ |
92 | bool fh_post_saved; /* post-op attrs saved */ |
93 | bool fh_pre_saved; /* pre-op attrs saved */ |
94 | |
95 | /* Pre-op attributes saved when inode is locked */ |
96 | __u64 fh_pre_size; /* size before operation */ |
97 | struct timespec64 fh_pre_mtime; /* mtime before oper */ |
98 | struct timespec64 fh_pre_ctime; /* ctime before oper */ |
99 | /* |
100 | * pre-op nfsv4 change attr: note must check IS_I_VERSION(inode) |
101 | * to find out if it is valid. |
102 | */ |
103 | u64 fh_pre_change; |
104 | |
105 | /* Post-op attributes saved in fh_fill_post_attrs() */ |
106 | struct kstat fh_post_attr; /* full attrs after operation */ |
107 | u64 fh_post_change; /* nfsv4 change; see above */ |
108 | } svc_fh; |
109 | #define NFSD4_FH_FOREIGN (1<<0) |
110 | #define SET_FH_FLAG(c, f) ((c)->fh_flags |= (f)) |
111 | #define HAS_FH_FLAG(c, f) ((c)->fh_flags & (f)) |
112 | |
113 | enum nfsd_fsid { |
114 | FSID_DEV = 0, |
115 | FSID_NUM, |
116 | FSID_MAJOR_MINOR, |
117 | FSID_ENCODE_DEV, |
118 | FSID_UUID4_INUM, |
119 | FSID_UUID8, |
120 | FSID_UUID16, |
121 | FSID_UUID16_INUM, |
122 | }; |
123 | |
124 | enum fsid_source { |
125 | FSIDSOURCE_DEV, |
126 | FSIDSOURCE_FSID, |
127 | FSIDSOURCE_UUID, |
128 | }; |
129 | extern enum fsid_source fsid_source(const struct svc_fh *fhp); |
130 | |
131 | |
132 | /* |
133 | * This might look a little large to "inline" but in all calls except |
134 | * one, 'vers' is constant so moste of the function disappears. |
135 | * |
136 | * In some cases the values are considered to be host endian and in |
137 | * others, net endian. fsidv is always considered to be u32 as the |
138 | * callers don't know which it will be. So we must use __force to keep |
139 | * sparse from complaining. Since these values are opaque to the |
140 | * client, that shouldn't be a problem. |
141 | */ |
142 | static inline void mk_fsid(int vers, u32 *fsidv, dev_t dev, ino_t ino, |
143 | u32 fsid, unsigned char *uuid) |
144 | { |
145 | u32 *up; |
146 | switch(vers) { |
147 | case FSID_DEV: |
148 | fsidv[0] = (__force __u32)htonl((MAJOR(dev)<<16) | |
149 | MINOR(dev)); |
150 | fsidv[1] = ino_t_to_u32(ino); |
151 | break; |
152 | case FSID_NUM: |
153 | fsidv[0] = fsid; |
154 | break; |
155 | case FSID_MAJOR_MINOR: |
156 | fsidv[0] = (__force __u32)htonl(MAJOR(dev)); |
157 | fsidv[1] = (__force __u32)htonl(MINOR(dev)); |
158 | fsidv[2] = ino_t_to_u32(ino); |
159 | break; |
160 | |
161 | case FSID_ENCODE_DEV: |
162 | fsidv[0] = new_encode_dev(dev); |
163 | fsidv[1] = ino_t_to_u32(ino); |
164 | break; |
165 | |
166 | case FSID_UUID4_INUM: |
167 | /* 4 byte fsid and inode number */ |
168 | up = (u32*)uuid; |
169 | fsidv[0] = ino_t_to_u32(ino); |
170 | fsidv[1] = up[0] ^ up[1] ^ up[2] ^ up[3]; |
171 | break; |
172 | |
173 | case FSID_UUID8: |
174 | /* 8 byte fsid */ |
175 | up = (u32*)uuid; |
176 | fsidv[0] = up[0] ^ up[2]; |
177 | fsidv[1] = up[1] ^ up[3]; |
178 | break; |
179 | |
180 | case FSID_UUID16: |
181 | /* 16 byte fsid - NFSv3+ only */ |
182 | memcpy(fsidv, uuid, 16); |
183 | break; |
184 | |
185 | case FSID_UUID16_INUM: |
186 | /* 8 byte inode and 16 byte fsid */ |
187 | *(u64*)fsidv = (u64)ino; |
188 | memcpy(fsidv+2, uuid, 16); |
189 | break; |
190 | default: BUG(); |
191 | } |
192 | } |
193 | |
194 | static inline int key_len(int type) |
195 | { |
196 | switch(type) { |
197 | case FSID_DEV: return 8; |
198 | case FSID_NUM: return 4; |
199 | case FSID_MAJOR_MINOR: return 12; |
200 | case FSID_ENCODE_DEV: return 8; |
201 | case FSID_UUID4_INUM: return 8; |
202 | case FSID_UUID8: return 8; |
203 | case FSID_UUID16: return 16; |
204 | case FSID_UUID16_INUM: return 24; |
205 | default: return 0; |
206 | } |
207 | } |
208 | |
209 | /* |
210 | * Shorthand for dprintk()'s |
211 | */ |
212 | extern char * SVCFH_fmt(struct svc_fh *fhp); |
213 | |
214 | /* |
215 | * Function prototypes |
216 | */ |
217 | __be32 fh_verify(struct svc_rqst *, struct svc_fh *, umode_t, int); |
218 | __be32 fh_compose(struct svc_fh *, struct svc_export *, struct dentry *, struct svc_fh *); |
219 | __be32 fh_update(struct svc_fh *); |
220 | void fh_put(struct svc_fh *); |
221 | |
222 | static __inline__ struct svc_fh * |
223 | fh_copy(struct svc_fh *dst, const struct svc_fh *src) |
224 | { |
225 | WARN_ON(src->fh_dentry); |
226 | |
227 | *dst = *src; |
228 | return dst; |
229 | } |
230 | |
231 | static inline void |
232 | fh_copy_shallow(struct knfsd_fh *dst, const struct knfsd_fh *src) |
233 | { |
234 | dst->fh_size = src->fh_size; |
235 | memcpy(&dst->fh_raw, &src->fh_raw, src->fh_size); |
236 | } |
237 | |
238 | static __inline__ struct svc_fh * |
239 | fh_init(struct svc_fh *fhp, int maxsize) |
240 | { |
241 | memset(fhp, 0, sizeof(*fhp)); |
242 | fhp->fh_maxsize = maxsize; |
243 | return fhp; |
244 | } |
245 | |
246 | static inline bool fh_match(const struct knfsd_fh *fh1, |
247 | const struct knfsd_fh *fh2) |
248 | { |
249 | if (fh1->fh_size != fh2->fh_size) |
250 | return false; |
251 | if (memcmp(p: fh1->fh_raw, q: fh2->fh_raw, size: fh1->fh_size) != 0) |
252 | return false; |
253 | return true; |
254 | } |
255 | |
256 | static inline bool fh_fsid_match(const struct knfsd_fh *fh1, |
257 | const struct knfsd_fh *fh2) |
258 | { |
259 | if (fh1->fh_fsid_type != fh2->fh_fsid_type) |
260 | return false; |
261 | if (memcmp(p: fh1->fh_fsid, q: fh2->fh_fsid, size: key_len(type: fh1->fh_fsid_type)) != 0) |
262 | return false; |
263 | return true; |
264 | } |
265 | |
266 | #ifdef CONFIG_CRC32 |
267 | /** |
268 | * knfsd_fh_hash - calculate the crc32 hash for the filehandle |
269 | * @fh - pointer to filehandle |
270 | * |
271 | * returns a crc32 hash for the filehandle that is compatible with |
272 | * the one displayed by "wireshark". |
273 | */ |
274 | static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh) |
275 | { |
276 | return ~crc32_le(crc: 0xFFFFFFFF, p: fh->fh_raw, len: fh->fh_size); |
277 | } |
278 | #else |
279 | static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh) |
280 | { |
281 | return 0; |
282 | } |
283 | #endif |
284 | |
285 | /** |
286 | * fh_clear_pre_post_attrs - Reset pre/post attributes |
287 | * @fhp: file handle to be updated |
288 | * |
289 | */ |
290 | static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp) |
291 | { |
292 | fhp->fh_post_saved = false; |
293 | fhp->fh_pre_saved = false; |
294 | } |
295 | |
296 | u64 nfsd4_change_attribute(const struct kstat *stat, |
297 | const struct inode *inode); |
298 | __be32 __must_check fh_fill_pre_attrs(struct svc_fh *fhp); |
299 | __be32 fh_fill_post_attrs(struct svc_fh *fhp); |
300 | __be32 __must_check fh_fill_both_attrs(struct svc_fh *fhp); |
301 | #endif /* _LINUX_NFSD_NFSFH_H */ |
302 | |