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 * skip helpers 137 */ 138 #define ceph_decode_skip_n(p, end, n, bad) \ 139 do { \ 140 ceph_decode_need(p, end, n, bad); \ 141 *p += n; \ 142 } while (0) 143 144 #define ceph_decode_skip_64(p, end, bad) \ 145 ceph_decode_skip_n(p, end, sizeof(u64), bad) 146 147 #define ceph_decode_skip_32(p, end, bad) \ 148 ceph_decode_skip_n(p, end, sizeof(u32), bad) 149 150 #define ceph_decode_skip_16(p, end, bad) \ 151 ceph_decode_skip_n(p, end, sizeof(u16), bad) 152 153 #define ceph_decode_skip_8(p, end, bad) \ 154 ceph_decode_skip_n(p, end, sizeof(u8), bad) 155 156 #define ceph_decode_skip_string(p, end, bad) \ 157 do { \ 158 u32 len; \ 159 \ 160 ceph_decode_32_safe(p, end, len, bad); \ 161 ceph_decode_skip_n(p, end, len, bad); \ 162 } while (0) 163 164 #define ceph_decode_skip_set(p, end, type, bad) \ 165 do { \ 166 u32 len; \ 167 \ 168 ceph_decode_32_safe(p, end, len, bad); \ 169 while (len--) \ 170 ceph_decode_skip_##type(p, end, bad); \ 171 } while (0) 172 173 #define ceph_decode_skip_map(p, end, ktype, vtype, bad) \ 174 do { \ 175 u32 len; \ 176 \ 177 ceph_decode_32_safe(p, end, len, bad); \ 178 while (len--) { \ 179 ceph_decode_skip_##ktype(p, end, bad); \ 180 ceph_decode_skip_##vtype(p, end, bad); \ 181 } \ 182 } while (0) 183 184 #define ceph_decode_skip_map_of_map(p, end, ktype1, ktype2, vtype2, bad) \ 185 do { \ 186 u32 len; \ 187 \ 188 ceph_decode_32_safe(p, end, len, bad); \ 189 while (len--) { \ 190 ceph_decode_skip_##ktype1(p, end, bad); \ 191 ceph_decode_skip_map(p, end, ktype2, vtype2, bad); \ 192 } \ 193 } while (0) 194 195 /* 196 * struct ceph_timespec <-> struct timespec 197 */ 198 static inline void ceph_decode_timespec(struct timespec *ts, 199 const struct ceph_timespec *tv) 200 { 201 ts->tv_sec = (__kernel_time_t)le32_to_cpu(tv->tv_sec); 202 ts->tv_nsec = (long)le32_to_cpu(tv->tv_nsec); 203 } 204 static inline void ceph_encode_timespec(struct ceph_timespec *tv, 205 const struct timespec *ts) 206 { 207 tv->tv_sec = cpu_to_le32((u32)ts->tv_sec); 208 tv->tv_nsec = cpu_to_le32((u32)ts->tv_nsec); 209 } 210 211 /* 212 * sockaddr_storage <-> ceph_sockaddr 213 */ 214 static inline void ceph_encode_addr(struct ceph_entity_addr *a) 215 { 216 __be16 ss_family = htons(a->in_addr.ss_family); 217 a->in_addr.ss_family = *(__u16 *)&ss_family; 218 } 219 static inline void ceph_decode_addr(struct ceph_entity_addr *a) 220 { 221 __be16 ss_family = *(__be16 *)&a->in_addr.ss_family; 222 a->in_addr.ss_family = ntohs(ss_family); 223 WARN_ON(a->in_addr.ss_family == 512); 224 } 225 226 /* 227 * encoders 228 */ 229 static inline void ceph_encode_64(void **p, u64 v) 230 { 231 put_unaligned_le64(v, (__le64 *)*p); 232 *p += sizeof(u64); 233 } 234 static inline void ceph_encode_32(void **p, u32 v) 235 { 236 put_unaligned_le32(v, (__le32 *)*p); 237 *p += sizeof(u32); 238 } 239 static inline void ceph_encode_16(void **p, u16 v) 240 { 241 put_unaligned_le16(v, (__le16 *)*p); 242 *p += sizeof(u16); 243 } 244 static inline void ceph_encode_8(void **p, u8 v) 245 { 246 *(u8 *)*p = v; 247 (*p)++; 248 } 249 static inline void ceph_encode_copy(void **p, const void *s, int len) 250 { 251 memcpy(*p, s, len); 252 *p += len; 253 } 254 255 /* 256 * filepath, string encoders 257 */ 258 static inline void ceph_encode_filepath(void **p, void *end, 259 u64 ino, const char *path) 260 { 261 u32 len = path ? strlen(path) : 0; 262 BUG_ON(*p + 1 + sizeof(ino) + sizeof(len) + len > end); 263 ceph_encode_8(p, 1); 264 ceph_encode_64(p, ino); 265 ceph_encode_32(p, len); 266 if (len) 267 memcpy(*p, path, len); 268 *p += len; 269 } 270 271 static inline void ceph_encode_string(void **p, void *end, 272 const char *s, u32 len) 273 { 274 BUG_ON(*p + sizeof(len) + len > end); 275 ceph_encode_32(p, len); 276 if (len) 277 memcpy(*p, s, len); 278 *p += len; 279 } 280 281 /* 282 * version and length starting block encoders/decoders 283 */ 284 285 /* current code version (u8) + compat code version (u8) + len of struct (u32) */ 286 #define CEPH_ENCODING_START_BLK_LEN 6 287 288 /** 289 * ceph_start_encoding - start encoding block 290 * @struct_v: current (code) version of the encoding 291 * @struct_compat: oldest code version that can decode it 292 * @struct_len: length of struct encoding 293 */ 294 static inline void ceph_start_encoding(void **p, u8 struct_v, u8 struct_compat, 295 u32 struct_len) 296 { 297 ceph_encode_8(p, struct_v); 298 ceph_encode_8(p, struct_compat); 299 ceph_encode_32(p, struct_len); 300 } 301 302 /** 303 * ceph_start_decoding - start decoding block 304 * @v: current version of the encoding that the code supports 305 * @name: name of the struct (free-form) 306 * @struct_v: out param for the encoding version 307 * @struct_len: out param for the length of struct encoding 308 * 309 * Validates the length of struct encoding, so unsafe ceph_decode_* 310 * variants can be used for decoding. 311 */ 312 static inline int ceph_start_decoding(void **p, void *end, u8 v, 313 const char *name, u8 *struct_v, 314 u32 *struct_len) 315 { 316 u8 struct_compat; 317 318 ceph_decode_need(p, end, CEPH_ENCODING_START_BLK_LEN, bad); 319 *struct_v = ceph_decode_8(p); 320 struct_compat = ceph_decode_8(p); 321 if (v < struct_compat) { 322 pr_warn("got struct_v %d struct_compat %d > %d of %s\n", 323 *struct_v, struct_compat, v, name); 324 return -EINVAL; 325 } 326 327 *struct_len = ceph_decode_32(p); 328 ceph_decode_need(p, end, *struct_len, bad); 329 return 0; 330 331 bad: 332 return -ERANGE; 333 } 334 335 #define ceph_encode_need(p, end, n, bad) \ 336 do { \ 337 if (!likely(ceph_has_room(p, end, n))) \ 338 goto bad; \ 339 } while (0) 340 341 #define ceph_encode_64_safe(p, end, v, bad) \ 342 do { \ 343 ceph_encode_need(p, end, sizeof(u64), bad); \ 344 ceph_encode_64(p, v); \ 345 } while (0) 346 #define ceph_encode_32_safe(p, end, v, bad) \ 347 do { \ 348 ceph_encode_need(p, end, sizeof(u32), bad); \ 349 ceph_encode_32(p, v); \ 350 } while (0) 351 #define ceph_encode_16_safe(p, end, v, bad) \ 352 do { \ 353 ceph_encode_need(p, end, sizeof(u16), bad); \ 354 ceph_encode_16(p, v); \ 355 } while (0) 356 #define ceph_encode_8_safe(p, end, v, bad) \ 357 do { \ 358 ceph_encode_need(p, end, sizeof(u8), bad); \ 359 ceph_encode_8(p, v); \ 360 } while (0) 361 362 #define ceph_encode_copy_safe(p, end, pv, n, bad) \ 363 do { \ 364 ceph_encode_need(p, end, n, bad); \ 365 ceph_encode_copy(p, pv, n); \ 366 } while (0) 367 #define ceph_encode_string_safe(p, end, s, n, bad) \ 368 do { \ 369 ceph_encode_need(p, end, n, bad); \ 370 ceph_encode_string(p, end, s, n); \ 371 } while (0) 372 373 374 #endif 375