include/binproto.h

   1 #ifndef __BIN_PROTO_H__
   2 #define __BIN_PROTO_H__
   3
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <stdint.h>
   8 #include <stdarg.h>
   9
  10 #include <unistd.h>
  11 #include <fcntl.h>
  12
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15
  16 // getpid/gettid
  17 #include <sys/types.h>
  18 #include <unistd.h>
  19 #include <sys/syscall.h>
  20
  21 #include <sys/time.h>
  22
  23 #include <sys/socket.h>
  24 #include "dahelper.h"
  25
  26 #define MSG_PROBE_MEMORY 0x3001
  27 #define MSG_PROBE_UICONTROL 0x3002
  28 #define MSG_PROBE_UIEVENT 0x3003
  29 #define MSG_PROBE_RESOURCE 0x3004
  30 #define MSG_PROBE_LIFECYCLE 0x3005
  31 #define MSG_PROBE_SCREENSHOT 0x3006
  32 #define MSG_PROBE_SCENE 0x3007
  33 #define MSG_PROBE_THREAD 0x3008
  34 #define MSG_PROBE_CUSTOM 0x3009
  35 #define MSG_PROBE_SYNC 0x3010
  36
  37 // TODO: remove this copy-paste
  38 #define CALLER_ADDRESS                                                  \
  39         ((void*) __builtin_extract_return_addr(__builtin_return_address(0)))
  40
  41
  42
  43 // COMMON
  44 static inline char *pack_int32(char *to, uint32_t val)
  45 {
  46         *(uint32_t *)to = val;
  47         return to + sizeof(uint32_t);
  48 }
  49
  50 static inline char *pack_int64(char *to, uint64_t val)
  51 {
  52         *(uint64_t *)to = val;
  53         return to + sizeof(uint64_t);
  54 }
  55
  56 static inline char *pack_string(char *to, const char *str)
  57 {
  58         size_t len = strlen(str) + 1;
  59         strncpy(to, str, len);
  60         return to + len;
  61 }
  62
  63 static inline char *pack_double(char *to, double val)
  64 {
  65         *(double *)to = val;
  66         return to + sizeof(double);
  67 }
  68
  69 static inline char *pack_timestamp(char *to)
  70 {
  71         struct timeval tv;
  72
  73         gettimeofday(&tv, NULL);
  74         to = pack_int32(to, tv.tv_sec);
  75         to = pack_int32(to, tv.tv_usec * 1000);
  76
  77         return to;
  78 }
  79
  80 static inline char *pack_args(char *to, const char *fmt, ...)
  81 {
  82         va_list args;
  83         uint32_t num = strlen(fmt);
  84         const char *t = fmt;
  85
  86         if(*t == '\0') {
  87                 num = 0;
  88         }
  89
  90         memcpy(to, &num, sizeof(num));
  91         to += sizeof(num);
  92
  93         va_start(args, fmt);
  94
  95         uint8_t c;
  96         uint32_t d;
  97         uint64_t x;
  98         uint64_t p;
  99         float f;
 100         double w;
 101         char *s;
 102         int n;
 103
 104         for (t = fmt; *t != '\0'; t++) {
 105                 switch (*t) {
 106                 case 'c':
 107                         c = (uint8_t)va_arg(args, uint32_t);
 108                         *to++ = *t;
 109                         memcpy(to, &c, sizeof(c));
 110                         to += sizeof(c);
 111                         break;
 112                 case 'd':
 113                         d = va_arg(args, uint32_t);
 114                         *to++ = *t;
 115                         memcpy(to, &d, sizeof(d));
 116                         to += sizeof(d);
 117                         break;
 118                 case 'x':
 119                         x = (uint64_t)va_arg(args, uint64_t);
 120                         *to++ = *t;
 121                         memcpy(to, &x, sizeof(x));
 122                         to += sizeof(x);
 123                         break;
 124                 case 'p':
 125                         p = (uintptr_t)va_arg(args, uint64_t);
 126                         *to++ = *t;
 127                         memcpy(to, &p, sizeof(p));
 128                         to += sizeof(p);
 129                         break;
 130                 case 'f':
 131                         f = (float)va_arg(args, double);
 132                         *to++ = *t;
 133                         memcpy(to, &f, sizeof(f));
 134                         to += sizeof(f);
 135                         break;
 136                 case 'w':
 137                         w = va_arg(args, double);
 138                         *to++ = *t;
 139                         memcpy(to, &w, sizeof(w));
 140                         to += sizeof(w);
 141                         break;
 142                 case 's':
 143                         s = va_arg(args, char *);
 144                         *to++ = *t;
 145                         n = strlen(s) + 1;
 146                         strncpy(to, s, n);
 147                         to += n;
 148                         break;
 149                 default:
 150                         break;
 151                 }
 152         }
 153
 154         va_end(args);
 155
 156         return to;
 157 }
 158
 159 #define BUF_PTR p
 160 #define RET_PTR ret_p
 161 #define PACK_INT32(val)                         \
 162         BUF_PTR = pack_int32(BUF_PTR, val);
 163 #define PACK_INT64(val)                         \
 164         BUF_PTR = pack_int64(BUF_PTR, val);
 165 #define PACK_STRING(str)                        \
 166         BUF_PTR = pack_string(BUF_PTR, str);
 167
 168 #define PACK_COMMON_BEGIN(msg_id, api_id, fmt, ...)             \
 169         do {                                                    \
 170                 BUF_PTR = pack_int32(BUF_PTR, msg_id);          \
 171                 BUF_PTR = pack_int32(BUF_PTR, 0);               \
 172                 BUF_PTR = pack_timestamp(BUF_PTR);              \
 173                 BUF_PTR = pack_int32(BUF_PTR, 0);               \
 174                 BUF_PTR = pack_int32(BUF_PTR, api_id);          \
 175                 BUF_PTR = pack_int32(BUF_PTR, getpid());                \
 176                 BUF_PTR = pack_int32(BUF_PTR, syscall(__NR_gettid));    \
 177                 BUF_PTR = pack_args(BUF_PTR, fmt, __VA_ARGS__); \
 178                 RET_PTR = BUF_PTR;              \
 179         } while (0)
 180
 181 #define PACK_COMMON_END(ret, errn, intern_call)         \
 182         do {                                                    \
 183                 BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)(ret));        \
 184                 BUF_PTR = pack_int32(BUF_PTR, (uint32_t)errn);  \
 185                 BUF_PTR = pack_int32(BUF_PTR, (uint32_t)intern_call);   \
 186                 BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)CALLER_ADDRESS); \
 187                 BUF_PTR = pack_int32(BUF_PTR, 0);               \
 188                 BUF_PTR = pack_int32(BUF_PTR, 0);               \
 189         } while (0)
 190
 191 #define PACK_RETURN_END(ret)                                                            \
 192                 RET_PTR = pack_int64(RET_PTR, (uintptr_t)(ret));
 193
 194 #define PACK_MEMORY(size, memory_api_type, addr)                \
 195         do {                                                    \
 196                 BUF_PTR = pack_int64(BUF_PTR, size);                    \
 197                 BUF_PTR = pack_int32(BUF_PTR, memory_api_type); \
 198                 BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)addr); \
 199         } while (0)
 200
 201 #define PACK_UICONTROL(control)                                         \
 202         do {                                                            \
 203                 if (unlikely(control == NULL)) {                        \
 204                         BUF_PTR = pack_string(BUF_PTR, "");             \
 205                         BUF_PTR = pack_string(BUF_PTR, "");             \
 206                         BUF_PTR = pack_int64(BUF_PTR, 0);               \
 207                 } else {                                                \
 208                         char *type = NULL, *name = NULL;                \
 209                         if (find_object_hash((void*)(control),          \
 210                                              &type, &name) == 1) {      \
 211                                 BUF_PTR = pack_string(BUF_PTR, type);   \
 212                                 BUF_PTR = pack_string(BUF_PTR, name);   \
 213                         } else {                                        \
 214                                 BUF_PTR = pack_string(BUF_PTR, "");     \
 215                                 BUF_PTR = pack_string(BUF_PTR, "");     \
 216                         }                                               \
 217                         BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)(control)); \
 218                 }                                                       \
 219         } while(0)
 220
 221 #define PACK_UIEVENT(event_type, detail_type, x, y, info1, info2)       \
 222         do {                                                            \
 223                 BUF_PTR = pack_int32(BUF_PTR, event_type);              \
 224                 BUF_PTR = pack_int32(BUF_PTR, detail_type);             \
 225                 BUF_PTR = pack_int32(BUF_PTR, x);                       \
 226                 BUF_PTR = pack_int32(BUF_PTR, y);                       \
 227                 BUF_PTR = pack_string(BUF_PTR, info1);                  \
 228                 BUF_PTR = pack_int32(BUF_PTR, info2);                   \
 229         } while (0)
 230
 231 #define PACK_RESOURCE(size, fd_value, fd_type, fd_api_type, file_size,  \
 232                       file_path)                                        \
 233         do {                                                            \
 234                 BUF_PTR = pack_int64(BUF_PTR, size);                    \
 235                 BUF_PTR = pack_int32(BUF_PTR, fd_value);                \
 236                 BUF_PTR = pack_int32(BUF_PTR, fd_type);                 \
 237                 BUF_PTR = pack_int32(BUF_PTR, fd_api_type);             \
 238                 BUF_PTR = pack_int64(BUF_PTR, file_size);               \
 239                 BUF_PTR = pack_string(BUF_PTR, file_path);              \
 240         } while (0)
 241
 242 #define PACK_SCREENSHOT(image_file_path, orientation)                           \
 243                 do {                                                            \
 244                           BUF_PTR = pack_string(BUF_PTR, image_file_path);      \
 245                           BUF_PTR = pack_int32(BUF_PTR, orientation);           \
 246                 } while (0)
 247
 248 #define PACK_SCENE(scene_name, formid, pform, panelid, ppanel, transition, user)        \
 249         do {                                                                            \
 250                 BUF_PTR = pack_string(BUF_PTR,  scene_name);                            \
 251                 if (unlikely(pform == NULL)) {                                          \
 252                         BUF_PTR = pack_string(BUF_PTR, "");                             \
 253                         BUF_PTR = pack_int64(BUF_PTR, 0);                               \
 254                 } else {                                                                \
 255                         char *type = NULL, *name = NULL;                                \
 256                         if (find_object_hash((void*)(pform), &type, &name) == 1) {      \
 257                                 BUF_PTR = pack_string(BUF_PTR, name);                   \
 258                         } else {                                                        \
 259                                 BUF_PTR = pack_string(BUF_PTR, "");                     \
 260                         }                                                               \
 261                         BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)pform);                \
 262                 }                                                                       \
 263                 if (unlikely(ppanel == NULL)) {                                         \
 264                         BUF_PTR = pack_string(BUF_PTR, "");                             \
 265                         BUF_PTR = pack_int64(BUF_PTR, 0);                               \
 266                 } else {                                                                \
 267                         char *type = NULL, *name = NULL;                                \
 268                         if (find_object_hash((void*)(ppanel), &type, &name) == 1) {     \
 269                                 BUF_PTR = pack_string(BUF_PTR, name);                   \
 270                         } else {                                                        \
 271                                 BUF_PTR = pack_string(BUF_PTR, "");                     \
 272                         }                                                               \
 273                         BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)(ppanel));             \
 274                 }                                                                       \
 275                 BUF_PTR = pack_int64(BUF_PTR, transition);                              \
 276                 BUF_PTR = pack_int64(BUF_PTR, user);                                    \
 277         } while(0)
 278
 279  #define PACK_THREAD(thread_id, thread_type, api_type)  \
 280          do {                                                           \
 281                 BUF_PTR = pack_int64(BUF_PTR, thread_id);               \
 282                 BUF_PTR = pack_int32(BUF_PTR, thread_type);             \
 283                 BUF_PTR = pack_int32(BUF_PTR, api_type);                \
 284         } while (0)
 285
 286 #define PACK_CUSTOM(handle, type, name, color, value)           \
 287         do {                                                    \
 288                 BUF_PTR = pack_int32(BUF_PTR, handle);          \
 289                 BUF_PTR = pack_int32(BUF_PTR, type);            \
 290                 BUF_PTR = pack_string(BUF_PTR, name);           \
 291                 BUF_PTR = pack_int32(BUF_PTR, color);           \
 292                 BUF_PTR = pack_double(BUF_PTR, value);          \
 293         } while (0)
 294
 295 #define PACK_SYNC(sync_val, sync_type, api_type)                     \
 296         do {                                                         \
 297                 BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)sync_val);  \
 298                 BUF_PTR = pack_int32(BUF_PTR, sync_type);            \
 299                 BUF_PTR = pack_int32(BUF_PTR, api_type);             \
 300         } while (0)
 301
 302 #define LOCAL_BUF_SIZE 1024
 303 #define PREPARE_LOCAL_BUF()                     \
 304                 char buf[LOCAL_BUF_SIZE];       \
 305                 char *p = buf;                  \
 306                 char *ret_p = NULL;
 307
 308 #define MSG_LEN_OFFSET 16
 309 #define MSG_HDR_LEN 20
 310 #define FLUSH_LOCAL_BUF()                                               \
 311                 *(uint32_t *)(buf + MSG_LEN_OFFSET) = (p - buf) - MSG_HDR_LEN; \
 312                 send(gTraceInfo.socket.daemonSock, buf, (p - buf), 0);
 313
 314 // =========================== post block macro ===========================
 315
 316 #define POST_PACK_PROBEBLOCK_BEGIN()                                    \
 317         newerrno = errno;                                               \
 318         if(postBlockBegin(blockresult)) {
 319
 320 #define POST_PACK_PROBEBLOCK_END()                                      \
 321                 postBlockEnd();                                         \
 322         }                                                               \
 323         errno = (newerrno != 0) ? newerrno : olderrno
 324
 325 /* int main(int argc, char **argv) */
 326 /* { */
 327 /*      char buf[1024]; */
 328 /*      char *p = buf; */
 329
 330 /*      p = PACK_COMMON_BEGIN(p, 42, "cdxpfws", 'a', 10, (uint64_t)80, */
 331 /*                            (uint64_t)0, 0.19, 0.33, "hello!"); */
 332 /*      p = PACK_COMMON_END(p, 0); */
 333
 334 /*      int fd = creat("out.bin", 0644); */
 335 /*      if (fd == -1) { */
 336 /*              printf("error\n"); */
 337 /*              exit(1); */
 338 /*      } */
 339
 340 /*      write(fd, buf, p - buf); */
 341 /*      close(fd); */
 342
 343 /*      return 0; */
 344 /* } */
 345
 346 #endif /* __BIN_PROTO_H__ */