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 #define ceph_encode_need(p, end, n, bad) \ 222 do { \ 223 if (!likely(ceph_has_room(p, end, n))) \ 224 goto bad; \ 225 } while (0) 226 227 #define ceph_encode_64_safe(p, end, v, bad) \ 228 do { \ 229 ceph_encode_need(p, end, sizeof(u64), bad); \ 230 ceph_encode_64(p, v); \ 231 } while (0) 232 #define ceph_encode_32_safe(p, end, v, bad) \ 233 do { \ 234 ceph_encode_need(p, end, sizeof(u32), bad); \ 235 ceph_encode_32(p, v); \ 236 } while (0) 237 #define ceph_encode_16_safe(p, end, v, bad) \ 238 do { \ 239 ceph_encode_need(p, end, sizeof(u16), bad); \ 240 ceph_encode_16(p, v); \ 241 } while (0) 242 #define ceph_encode_8_safe(p, end, v, bad) \ 243 do { \ 244 ceph_encode_need(p, end, sizeof(u8), bad); \ 245 ceph_encode_8(p, v); \ 246 } while (0) 247 248 #define ceph_encode_copy_safe(p, end, pv, n, bad) \ 249 do { \ 250 ceph_encode_need(p, end, n, bad); \ 251 ceph_encode_copy(p, pv, n); \ 252 } while (0) 253 #define ceph_encode_string_safe(p, end, s, n, bad) \ 254 do { \ 255 ceph_encode_need(p, end, n, bad); \ 256 ceph_encode_string(p, end, s, n); \ 257 } while (0) 258 259 260 #endif 261