1 #ifndef __CEPH_DECODE_H
2 #define __CEPH_DECODE_H
3
4 #include <linux/err.h>
5 #include <linux/bug.h>
6 #include <linux/slab.h>
7 #include <linux/time.h>
8 #include <asm/unaligned.h>
9
10 #include <linux/ceph/types.h>
11
12 /*
13 * in all cases,
14 * void **p pointer to position pointer
15 * void *end pointer to end of buffer (last byte + 1)
16 */
17
18 static inline u64 ceph_decode_64(void **p)
19 {
20 u64 v = get_unaligned_le64(*p);
21 *p += sizeof(u64);
22 return v;
23 }
24 static inline u32 ceph_decode_32(void **p)
25 {
26 u32 v = get_unaligned_le32(*p);
27 *p += sizeof(u32);
28 return v;
29 }
30 static inline u16 ceph_decode_16(void **p)
31 {
32 u16 v = get_unaligned_le16(*p);
33 *p += sizeof(u16);
34 return v;
35 }
36 static inline u8 ceph_decode_8(void **p)
37 {
38 u8 v = *(u8 *)*p;
39 (*p)++;
40 return v;
41 }
42 static inline void ceph_decode_copy(void **p, void *pv, size_t n)
43 {
44 memcpy(pv, *p, n);
45 *p += n;
46 }
47
48 /*
49 * bounds check input.
50 */
51 static inline bool ceph_has_room(void **p, void *end, size_t n)
52 {
53 return end >= *p && n <= end - *p;
54 }
55
56 #define ceph_decode_need(p, end, n, bad) \
57 do { \
58 if (!likely(ceph_has_room(p, end, n))) \
59 goto bad; \
60 } while (0)
61
62 #define ceph_decode_64_safe(p, end, v, bad) \
63 do { \
64 ceph_decode_need(p, end, sizeof(u64), bad); \
65 v = ceph_decode_64(p); \
66 } while (0)
67 #define ceph_decode_32_safe(p, end, v, bad) \
68 do { \
69 ceph_decode_need(p, end, sizeof(u32), bad); \
70 v = ceph_decode_32(p); \
71 } while (0)
72 #define ceph_decode_16_safe(p, end, v, bad) \
73 do { \
74 ceph_decode_need(p, end, sizeof(u16), bad); \
75 v = ceph_decode_16(p); \
76 } while (0)
77 #define ceph_decode_8_safe(p, end, v, bad) \
78 do { \
79 ceph_decode_need(p, end, sizeof(u8), bad); \
80 v = ceph_decode_8(p); \
81 } while (0)
82
83 #define ceph_decode_copy_safe(p, end, pv, n, bad) \
84 do { \
85 ceph_decode_need(p, end, n, bad); \
86 ceph_decode_copy(p, pv, n); \
87 } while (0)
88
89 /*
90 * Allocate a buffer big enough to hold the wire-encoded string, and
91 * decode the string into it. The resulting string will always be
92 * terminated with '\0'. If successful, *p will be advanced
93 * past the decoded data. Also, if lenp is not a null pointer, the
94 * length (not including the terminating '\0') will be recorded in
95 * *lenp. Note that a zero-length string is a valid return value.
96 *
97 * Returns a pointer to the newly-allocated string buffer, or a
98 * pointer-coded errno if an error occurs. Neither *p nor *lenp
99 * will have been updated if an error is returned.
100 *
101 * There are two possible failures:
102 * - converting the string would require accessing memory at or
103 * beyond the "end" pointer provided (-ERANGE)
104 * - memory could not be allocated for the result (-ENOMEM)
105 */
106 static inline char *ceph_extract_encoded_string(void **p, void *end,
107 size_t *lenp, gfp_t gfp)
108 {
109 u32 len;
110 void *sp = *p;
111 char *buf;
112
113 ceph_decode_32_safe(&sp, end, len, bad);
114 if (!ceph_has_room(&sp, end, len))
115 goto bad;
116
117 buf = kmalloc(len + 1, gfp);
118 if (!buf)
119 return ERR_PTR(-ENOMEM);
120
121 if (len)
122 memcpy(buf, sp, len);
123 buf[len] = '\0';
124
125 *p = (char *) *p + sizeof (u32) + len;
126 if (lenp)
127 *lenp = (size_t) len;
128
129 return buf;
130
131 bad:
132 return ERR_PTR(-ERANGE);
133 }
134
135 /*
136 * struct ceph_timespec <-> struct timespec
137 */
138 static inline void ceph_decode_timespec(struct timespec *ts,
139 const struct ceph_timespec *tv)
140 {
141 ts->tv_sec = (__kernel_time_t)le32_to_cpu(tv->tv_sec);
142 ts->tv_nsec = (long)le32_to_cpu(tv->tv_nsec);
143 }
144 static inline void ceph_encode_timespec(struct ceph_timespec *tv,
145 const struct timespec *ts)
146 {
147 tv->tv_sec = cpu_to_le32((u32)ts->tv_sec);
148 tv->tv_nsec = cpu_to_le32((u32)ts->tv_nsec);
149 }
150
151 /*
152 * sockaddr_storage <-> ceph_sockaddr
153 */
154 static inline void ceph_encode_addr(struct ceph_entity_addr *a)
155 {
156 __be16 ss_family = htons(a->in_addr.ss_family);
157 a->in_addr.ss_family = *(__u16 *)&ss_family;
158 }
159 static inline void ceph_decode_addr(struct ceph_entity_addr *a)
160 {
161 __be16 ss_family = *(__be16 *)&a->in_addr.ss_family;
162 a->in_addr.ss_family = ntohs(ss_family);
163 WARN_ON(a->in_addr.ss_family == 512);
164 }
165
166 /*
167 * encoders
168 */
169 static inline void ceph_encode_64(void **p, u64 v)
170 {
171 put_unaligned_le64(v, (__le64 *)*p);
172 *p += sizeof(u64);
173 }
174 static inline void ceph_encode_32(void **p, u32 v)
175 {
176 put_unaligned_le32(v, (__le32 *)*p);
177 *p += sizeof(u32);
178 }
179 static inline void ceph_encode_16(void **p, u16 v)
180 {
181 put_unaligned_le16(v, (__le16 *)*p);
182 *p += sizeof(u16);
183 }
184 static inline void ceph_encode_8(void **p, u8 v)
185 {
186 *(u8 *)*p = v;
187 (*p)++;
188 }
189 static inline void ceph_encode_copy(void **p, const void *s, int len)
190 {
191 memcpy(*p, s, len);
192 *p += len;
193 }
194
195 /*
196 * filepath, string encoders
197 */
198 static inline void ceph_encode_filepath(void **p, void *end,
199 u64 ino, const char *path)
200 {
201 u32 len = path ? strlen(path) : 0;
202 BUG_ON(*p + 1 + sizeof(ino) + sizeof(len) + len > end);
203 ceph_encode_8(p, 1);
204 ceph_encode_64(p, ino);
205 ceph_encode_32(p, len);
206 if (len)
207 memcpy(*p, path, len);
208 *p += len;
209 }
210
211 static inline void ceph_encode_string(void **p, void *end,
212 const char *s, u32 len)
213 {
214 BUG_ON(*p + sizeof(len) + len > end);
215 ceph_encode_32(p, len);
216 if (len)
217 memcpy(*p, s, len);
218 *p += len;
219 }
220
221 /*
222 * version and length starting block encoders/decoders
223 */
224
225 /* current code version (u8) + compat code version (u8) + len of struct (u32) */
226 #define CEPH_ENCODING_START_BLK_LEN 6
227
228 /**
229 * ceph_start_encoding - start encoding block
230 * @struct_v: current (code) version of the encoding
231 * @struct_compat: oldest code version that can decode it
232 * @struct_len: length of struct encoding
233 */
234 static inline void ceph_start_encoding(void **p, u8 struct_v, u8 struct_compat,
235 u32 struct_len)
236 {
237 ceph_encode_8(p, struct_v);
238 ceph_encode_8(p, struct_compat);
239 ceph_encode_32(p, struct_len);
240 }
241
242 /**
243 * ceph_start_decoding - start decoding block
244 * @v: current version of the encoding that the code supports
245 * @name: name of the struct (free-form)
246 * @struct_v: out param for the encoding version
247 * @struct_len: out param for the length of struct encoding
248 *
249 * Validates the length of struct encoding, so unsafe ceph_decode_*
250 * variants can be used for decoding.
251 */
252 static inline int ceph_start_decoding(void **p, void *end, u8 v,
253 const char *name, u8 *struct_v,
254 u32 *struct_len)
255 {
256 u8 struct_compat;
257
258 ceph_decode_need(p, end, CEPH_ENCODING_START_BLK_LEN, bad);
259 *struct_v = ceph_decode_8(p);
260 struct_compat = ceph_decode_8(p);
261 if (v < struct_compat) {
262 pr_warn("got struct_v %d struct_compat %d > %d of %s\n",
263 *struct_v, struct_compat, v, name);
264 return -EINVAL;
265 }
266
267 *struct_len = ceph_decode_32(p);
268 ceph_decode_need(p, end, *struct_len, bad);
269 return 0;
270
271 bad:
272 return -ERANGE;
273 }
274
275 #define ceph_encode_need(p, end, n, bad) \
276 do { \
277 if (!likely(ceph_has_room(p, end, n))) \
278 goto bad; \
279 } while (0)
280
281 #define ceph_encode_64_safe(p, end, v, bad) \
282 do { \
283 ceph_encode_need(p, end, sizeof(u64), bad); \
284 ceph_encode_64(p, v); \
285 } while (0)
286 #define ceph_encode_32_safe(p, end, v, bad) \
287 do { \
288 ceph_encode_need(p, end, sizeof(u32), bad); \
289 ceph_encode_32(p, v); \
290 } while (0)
291 #define ceph_encode_16_safe(p, end, v, bad) \
292 do { \
293 ceph_encode_need(p, end, sizeof(u16), bad); \
294 ceph_encode_16(p, v); \
295 } while (0)
296 #define ceph_encode_8_safe(p, end, v, bad) \
297 do { \
298 ceph_encode_need(p, end, sizeof(u8), bad); \
299 ceph_encode_8(p, v); \
300 } while (0)
301
302 #define ceph_encode_copy_safe(p, end, pv, n, bad) \
303 do { \
304 ceph_encode_need(p, end, n, bad); \
305 ceph_encode_copy(p, pv, n); \
306 } while (0)
307 #define ceph_encode_string_safe(p, end, s, n, bad) \
308 do { \
309 ceph_encode_need(p, end, n, bad); \
310 ceph_encode_string(p, end, s, n); \
311 } while (0)
312
313
314 #endif
315
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.