~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/ceph/decode.h

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  2 #ifndef __CEPH_DECODE_H
  3 #define __CEPH_DECODE_H
  4 
  5 #include <linux/err.h>
  6 #include <linux/bug.h>
  7 #include <linux/slab.h>
  8 #include <linux/time.h>
  9 #include <asm/unaligned.h>
 10 
 11 #include <linux/ceph/types.h>
 12 
 13 /*
 14  * in all cases,
 15  *   void **p     pointer to position pointer
 16  *   void *end    pointer to end of buffer (last byte + 1)
 17  */
 18 
 19 static inline u64 ceph_decode_64(void **p)
 20 {
 21         u64 v = get_unaligned_le64(*p);
 22         *p += sizeof(u64);
 23         return v;
 24 }
 25 static inline u32 ceph_decode_32(void **p)
 26 {
 27         u32 v = get_unaligned_le32(*p);
 28         *p += sizeof(u32);
 29         return v;
 30 }
 31 static inline u16 ceph_decode_16(void **p)
 32 {
 33         u16 v = get_unaligned_le16(*p);
 34         *p += sizeof(u16);
 35         return v;
 36 }
 37 static inline u8 ceph_decode_8(void **p)
 38 {
 39         u8 v = *(u8 *)*p;
 40         (*p)++;
 41         return v;
 42 }
 43 static inline void ceph_decode_copy(void **p, void *pv, size_t n)
 44 {
 45         memcpy(pv, *p, n);
 46         *p += n;
 47 }
 48 
 49 /*
 50  * bounds check input.
 51  */
 52 static inline bool ceph_has_room(void **p, void *end, size_t n)
 53 {
 54         return end >= *p && n <= end - *p;
 55 }
 56 
 57 #define ceph_decode_need(p, end, n, bad)                        \
 58         do {                                                    \
 59                 if (!likely(ceph_has_room(p, end, n)))          \
 60                         goto bad;                               \
 61         } while (0)
 62 
 63 #define ceph_decode_64_safe(p, end, v, bad)                     \
 64         do {                                                    \
 65                 ceph_decode_need(p, end, sizeof(u64), bad);     \
 66                 v = ceph_decode_64(p);                          \
 67         } while (0)
 68 #define ceph_decode_32_safe(p, end, v, bad)                     \
 69         do {                                                    \
 70                 ceph_decode_need(p, end, sizeof(u32), bad);     \
 71                 v = ceph_decode_32(p);                          \
 72         } while (0)
 73 #define ceph_decode_16_safe(p, end, v, bad)                     \
 74         do {                                                    \
 75                 ceph_decode_need(p, end, sizeof(u16), bad);     \
 76                 v = ceph_decode_16(p);                          \
 77         } while (0)
 78 #define ceph_decode_8_safe(p, end, v, bad)                      \
 79         do {                                                    \
 80                 ceph_decode_need(p, end, sizeof(u8), bad);      \
 81                 v = ceph_decode_8(p);                           \
 82         } while (0)
 83 
 84 #define ceph_decode_copy_safe(p, end, pv, n, bad)               \
 85         do {                                                    \
 86                 ceph_decode_need(p, end, n, bad);               \
 87                 ceph_decode_copy(p, pv, n);                     \
 88         } while (0)
 89 
 90 /*
 91  * Allocate a buffer big enough to hold the wire-encoded string, and
 92  * decode the string into it.  The resulting string will always be
 93  * terminated with '\0'.  If successful, *p will be advanced
 94  * past the decoded data.  Also, if lenp is not a null pointer, the
 95  * length (not including the terminating '\0') will be recorded in
 96  * *lenp.  Note that a zero-length string is a valid return value.
 97  *
 98  * Returns a pointer to the newly-allocated string buffer, or a
 99  * pointer-coded errno if an error occurs.  Neither *p nor *lenp
100  * will have been updated if an error is returned.
101  *
102  * There are two possible failures:
103  *   - converting the string would require accessing memory at or
104  *     beyond the "end" pointer provided (-ERANGE)
105  *   - memory could not be allocated for the result (-ENOMEM)
106  */
107 static inline char *ceph_extract_encoded_string(void **p, void *end,
108                                                 size_t *lenp, gfp_t gfp)
109 {
110         u32 len;
111         void *sp = *p;
112         char *buf;
113 
114         ceph_decode_32_safe(&sp, end, len, bad);
115         if (!ceph_has_room(&sp, end, len))
116                 goto bad;
117 
118         buf = kmalloc(len + 1, gfp);
119         if (!buf)
120                 return ERR_PTR(-ENOMEM);
121 
122         if (len)
123                 memcpy(buf, sp, len);
124         buf[len] = '\0';
125 
126         *p = (char *) *p + sizeof (u32) + len;
127         if (lenp)
128                 *lenp = (size_t) len;
129 
130         return buf;
131 
132 bad:
133         return ERR_PTR(-ERANGE);
134 }
135 
136 /*
137  * skip helpers
138  */
139 #define ceph_decode_skip_n(p, end, n, bad)                      \
140         do {                                                    \
141                 ceph_decode_need(p, end, n, bad);               \
142                 *p += n;                                        \
143         } while (0)
144 
145 #define ceph_decode_skip_64(p, end, bad)                        \
146 ceph_decode_skip_n(p, end, sizeof(u64), bad)
147 
148 #define ceph_decode_skip_32(p, end, bad)                        \
149 ceph_decode_skip_n(p, end, sizeof(u32), bad)
150 
151 #define ceph_decode_skip_16(p, end, bad)                        \
152 ceph_decode_skip_n(p, end, sizeof(u16), bad)
153 
154 #define ceph_decode_skip_8(p, end, bad)                         \
155 ceph_decode_skip_n(p, end, sizeof(u8), bad)
156 
157 #define ceph_decode_skip_string(p, end, bad)                    \
158         do {                                                    \
159                 u32 len;                                        \
160                                                                 \
161                 ceph_decode_32_safe(p, end, len, bad);          \
162                 ceph_decode_skip_n(p, end, len, bad);           \
163         } while (0)
164 
165 #define ceph_decode_skip_set(p, end, type, bad)                 \
166         do {                                                    \
167                 u32 len;                                        \
168                                                                 \
169                 ceph_decode_32_safe(p, end, len, bad);          \
170                 while (len--)                                   \
171                         ceph_decode_skip_##type(p, end, bad);   \
172         } while (0)
173 
174 #define ceph_decode_skip_map(p, end, ktype, vtype, bad)         \
175         do {                                                    \
176                 u32 len;                                        \
177                                                                 \
178                 ceph_decode_32_safe(p, end, len, bad);          \
179                 while (len--) {                                 \
180                         ceph_decode_skip_##ktype(p, end, bad);  \
181                         ceph_decode_skip_##vtype(p, end, bad);  \
182                 }                                               \
183         } while (0)
184 
185 #define ceph_decode_skip_map_of_map(p, end, ktype1, ktype2, vtype2, bad) \
186         do {                                                    \
187                 u32 len;                                        \
188                                                                 \
189                 ceph_decode_32_safe(p, end, len, bad);          \
190                 while (len--) {                                 \
191                         ceph_decode_skip_##ktype1(p, end, bad); \
192                         ceph_decode_skip_map(p, end, ktype2, vtype2, bad); \
193                 }                                               \
194         } while (0)
195 
196 /*
197  * struct ceph_timespec <-> struct timespec64
198  */
199 static inline void ceph_decode_timespec64(struct timespec64 *ts,
200                                           const struct ceph_timespec *tv)
201 {
202         /*
203          * This will still overflow in year 2106.  We could extend
204          * the protocol to steal two more bits from tv_nsec to
205          * add three more 136 year epochs after that the way ext4
206          * does if necessary.
207          */
208         ts->tv_sec = (time64_t)le32_to_cpu(tv->tv_sec);
209         ts->tv_nsec = (long)le32_to_cpu(tv->tv_nsec);
210 }
211 static inline void ceph_encode_timespec64(struct ceph_timespec *tv,
212                                           const struct timespec64 *ts)
213 {
214         tv->tv_sec = cpu_to_le32((u32)ts->tv_sec);
215         tv->tv_nsec = cpu_to_le32((u32)ts->tv_nsec);
216 }
217 
218 /*
219  * sockaddr_storage <-> ceph_sockaddr
220  */
221 #define CEPH_ENTITY_ADDR_TYPE_NONE      0
222 #define CEPH_ENTITY_ADDR_TYPE_LEGACY    __cpu_to_le32(1)
223 
224 static inline void ceph_encode_banner_addr(struct ceph_entity_addr *a)
225 {
226         __be16 ss_family = htons(a->in_addr.ss_family);
227         a->in_addr.ss_family = *(__u16 *)&ss_family;
228 
229         /* Banner addresses require TYPE_NONE */
230         a->type = CEPH_ENTITY_ADDR_TYPE_NONE;
231 }
232 static inline void ceph_decode_banner_addr(struct ceph_entity_addr *a)
233 {
234         __be16 ss_family = *(__be16 *)&a->in_addr.ss_family;
235         a->in_addr.ss_family = ntohs(ss_family);
236         WARN_ON(a->in_addr.ss_family == 512);
237         a->type = CEPH_ENTITY_ADDR_TYPE_LEGACY;
238 }
239 
240 extern int ceph_decode_entity_addr(void **p, void *end,
241                                    struct ceph_entity_addr *addr);
242 /*
243  * encoders
244  */
245 static inline void ceph_encode_64(void **p, u64 v)
246 {
247         put_unaligned_le64(v, (__le64 *)*p);
248         *p += sizeof(u64);
249 }
250 static inline void ceph_encode_32(void **p, u32 v)
251 {
252         put_unaligned_le32(v, (__le32 *)*p);
253         *p += sizeof(u32);
254 }
255 static inline void ceph_encode_16(void **p, u16 v)
256 {
257         put_unaligned_le16(v, (__le16 *)*p);
258         *p += sizeof(u16);
259 }
260 static inline void ceph_encode_8(void **p, u8 v)
261 {
262         *(u8 *)*p = v;
263         (*p)++;
264 }
265 static inline void ceph_encode_copy(void **p, const void *s, int len)
266 {
267         memcpy(*p, s, len);
268         *p += len;
269 }
270 
271 /*
272  * filepath, string encoders
273  */
274 static inline void ceph_encode_filepath(void **p, void *end,
275                                         u64 ino, const char *path)
276 {
277         u32 len = path ? strlen(path) : 0;
278         BUG_ON(*p + 1 + sizeof(ino) + sizeof(len) + len > end);
279         ceph_encode_8(p, 1);
280         ceph_encode_64(p, ino);
281         ceph_encode_32(p, len);
282         if (len)
283                 memcpy(*p, path, len);
284         *p += len;
285 }
286 
287 static inline void ceph_encode_string(void **p, void *end,
288                                       const char *s, u32 len)
289 {
290         BUG_ON(*p + sizeof(len) + len > end);
291         ceph_encode_32(p, len);
292         if (len)
293                 memcpy(*p, s, len);
294         *p += len;
295 }
296 
297 /*
298  * version and length starting block encoders/decoders
299  */
300 
301 /* current code version (u8) + compat code version (u8) + len of struct (u32) */
302 #define CEPH_ENCODING_START_BLK_LEN 6
303 
304 /**
305  * ceph_start_encoding - start encoding block
306  * @struct_v: current (code) version of the encoding
307  * @struct_compat: oldest code version that can decode it
308  * @struct_len: length of struct encoding
309  */
310 static inline void ceph_start_encoding(void **p, u8 struct_v, u8 struct_compat,
311                                        u32 struct_len)
312 {
313         ceph_encode_8(p, struct_v);
314         ceph_encode_8(p, struct_compat);
315         ceph_encode_32(p, struct_len);
316 }
317 
318 /**
319  * ceph_start_decoding - start decoding block
320  * @v: current version of the encoding that the code supports
321  * @name: name of the struct (free-form)
322  * @struct_v: out param for the encoding version
323  * @struct_len: out param for the length of struct encoding
324  *
325  * Validates the length of struct encoding, so unsafe ceph_decode_*
326  * variants can be used for decoding.
327  */
328 static inline int ceph_start_decoding(void **p, void *end, u8 v,
329                                       const char *name, u8 *struct_v,
330                                       u32 *struct_len)
331 {
332         u8 struct_compat;
333 
334         ceph_decode_need(p, end, CEPH_ENCODING_START_BLK_LEN, bad);
335         *struct_v = ceph_decode_8(p);
336         struct_compat = ceph_decode_8(p);
337         if (v < struct_compat) {
338                 pr_warn("got struct_v %d struct_compat %d > %d of %s\n",
339                         *struct_v, struct_compat, v, name);
340                 return -EINVAL;
341         }
342 
343         *struct_len = ceph_decode_32(p);
344         ceph_decode_need(p, end, *struct_len, bad);
345         return 0;
346 
347 bad:
348         return -ERANGE;
349 }
350 
351 #define ceph_encode_need(p, end, n, bad)                        \
352         do {                                                    \
353                 if (!likely(ceph_has_room(p, end, n)))          \
354                         goto bad;                               \
355         } while (0)
356 
357 #define ceph_encode_64_safe(p, end, v, bad)                     \
358         do {                                                    \
359                 ceph_encode_need(p, end, sizeof(u64), bad);     \
360                 ceph_encode_64(p, v);                           \
361         } while (0)
362 #define ceph_encode_32_safe(p, end, v, bad)                     \
363         do {                                                    \
364                 ceph_encode_need(p, end, sizeof(u32), bad);     \
365                 ceph_encode_32(p, v);                           \
366         } while (0)
367 #define ceph_encode_16_safe(p, end, v, bad)                     \
368         do {                                                    \
369                 ceph_encode_need(p, end, sizeof(u16), bad);     \
370                 ceph_encode_16(p, v);                           \
371         } while (0)
372 #define ceph_encode_8_safe(p, end, v, bad)                      \
373         do {                                                    \
374                 ceph_encode_need(p, end, sizeof(u8), bad);      \
375                 ceph_encode_8(p, v);                            \
376         } while (0)
377 
378 #define ceph_encode_copy_safe(p, end, pv, n, bad)               \
379         do {                                                    \
380                 ceph_encode_need(p, end, n, bad);               \
381                 ceph_encode_copy(p, pv, n);                     \
382         } while (0)
383 #define ceph_encode_string_safe(p, end, s, n, bad)              \
384         do {                                                    \
385                 ceph_encode_need(p, end, n, bad);               \
386                 ceph_encode_string(p, end, s, n);               \
387         } while (0)
388 
389 
390 #endif
391 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp