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

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

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ 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 #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 

~ [ 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