genevent-new/gentest.c

   1
   2 #include <assert.h>
   3 #include <sys/types.h>
   4 #include <stdint.h>
   5 #include <stdlib.h>
   6
   7 #define min(a,b) (((a)<(b))?a:b)
   8 #define max(a,b) (((a)>(b))?a:b)
   9 #define BUG_ON(a) assert(!(a))
  10
  11 /* Calculate the offset needed to align the type */
  12 static inline unsigned int ltt_align(size_t align_drift,
  13                                                                                                                                                  size_t size_of_type)
  14 {
  15         size_t alignment = min(sizeof(void*), size_of_type);
  16
  17         return ((alignment - align_drift) & (alignment-1));
  18 }
  19
  20
  21 /* TEMPLATE */
  22
  23 enum lttng_tasklet_priority {
  24         LTTNG_LOW,
  25         LTTNG_HIGH,
  26 };
  27
  28 enum lttng_irq_mode {
  29         LTTNG_user,
  30         LTTNG_kernel,
  31 };
  32
  33 struct lttng_mystruct2 {
  34         unsigned int irq_id;
  35         enum lttng_irq_mode mode;
  36         //struct lttng_mystruct teststr1;
  37 };
  38
  39
  40 static inline size_t lttng_get_size_mystruct2(
  41                 struct lttng_mystruct2 * obj)
  42 {
  43         size_t size=0, locsize;
  44
  45         locsize = sizeof(unsigned int);
  46         size += ltt_align(size, locsize) + locsize;
  47
  48         locsize = sizeof(enum lttng_irq_mode);
  49         size += ltt_align(size, locsize) + locsize;
  50
  51         BUG_ON(sizeof(struct lttng_mystruct2) != size);
  52
  53         return sizeof(struct lttng_mystruct2);
  54 }
  55
  56 static inline size_t lttng_get_alignment_mystruct2(
  57                 struct lttng_mystruct2 *obj)
  58 {
  59         size_t align=0, localign;
  60
  61         localign = sizeof(unsigned int);
  62         align = max(align, localign);
  63
  64         localign = sizeof(enum lttng_irq_mode);
  65         align = max(align, localign);
  66
  67         return align;
  68 }
  69
  70 static inline size_t lttng_write_mystruct2(
  71                 void *buf,
  72                 size_t *to,
  73                 void **from,
  74                 size_t *len,
  75                 struct lttng_mystruct2 *obj)
  76 {
  77         size_t align, size, varalign;
  78
  79         align = lttng_get_alignment_mystruct2(obj);
  80         size = lttng_get_size_mystruct2(obj);
  81
  82         if(*len == 0) {
  83                 varalign = ltt_align(*to, align);       /* align output */
  84                 *to += varalign;
  85         } else {
  86                 varalign = ltt_align(*to+*len, align);  /* C alignment, ok to do a memcpy of it */
  87                 *len += varalign;
  88         }
  89
  90         *len += size;
  91
  92         return varalign+size;
  93 }
  94
  95
  96
  97 #define LTTNG_ARRAY_SIZE_mystruct_myarray 10
  98 typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];
  99
 100 static inline size_t lttng_get_size_array_mystruct_myarray(
 101                 lttng_array_mystruct_myarray obj)
 102 {
 103         size_t size=0, locsize;
 104
 105         locsize = sizeof(uint64_t);
 106         /* ltt_align == 0 always*/
 107         //size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
 108         BUG_ON(ltt_align(size, locsize) != 0);
 109         size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;
 110
 111         BUG_ON(size != LTTNG_ARRAY_SIZE_mystruct_myarray * sizeof(uint64_t));
 112
 113         return size;
 114 }
 115
 116 static inline size_t lttng_get_alignment_array_mystruct_myarray(
 117                 lttng_array_mystruct_myarray obj)
 118 {
 119         size_t align=0, localign;
 120
 121         localign = sizeof(uint64_t);
 122         align = max(align, localign);
 123
 124         return align;
 125 }
 126
 127
 128 static inline size_t lttng_write_array_mystruct_myarray(
 129                 void *buf,
 130                 size_t *to,
 131                 void **from,
 132                 size_t *len,
 133                 lttng_array_mystruct_myarray obj)
 134 {
 135         size_t align, size, varalign;
 136
 137         align = lttng_get_alignment_array_mystruct_myarray(obj);
 138         size = lttng_get_size_array_mystruct_myarray(obj);
 139
 140         if(*len == 0) {
 141                 varalign = ltt_align(*to, align);       /* align output */
 142                 *to += varalign;
 143         } else {
 144                 varalign = ltt_align(*to+*len, align);  /* C alignment, ok to do a memcpy of it */
 145                 *len += varalign;
 146         }
 147
 148         *len += size;
 149
 150         return varalign + size; /* offset in the from */
 151 }
 152
 153
 154 typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
 155 struct lttng_sequence_mystruct_mysequence {
 156         unsigned int len;
 157         double *array;
 158 };
 159
 160
 161 static inline size_t lttng_get_size_sequence_mystruct_mysequence(
 162                                                                                                                                  lttng_sequence_mystruct_mysequence *obj)
 163 {
 164         size_t size=0, locsize;
 165
 166         locsize = sizeof(unsigned int);
 167         size += ltt_align(size, locsize) + locsize;
 168
 169         locsize = sizeof(double);
 170         size += ltt_align(size, locsize) + (obj->len * locsize);
 171
 172         return size;
 173 }
 174
 175 static inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
 176                                                                                                                                  lttng_sequence_mystruct_mysequence *obj)
 177 {
 178         size_t align=0, localign;
 179
 180         localign = sizeof(unsigned int);
 181         align = max(align, localign);
 182
 183         localign = sizeof(double);
 184         align = max(align, localign);
 185
 186         return align;
 187 }
 188
 189
 190 static inline size_t lttng_write_sequence_mystruct_mysequence(
 191                 void *buf,
 192                 size_t *to,
 193                 void **from,
 194                 size_t *len,
 195                 lttng_sequence_mystruct_mysequence *obj)
 196 {
 197         size_t align;
 198         size_t size=0;
 199         void *varfrom;
 200         size_t varlen=0;
 201         size_t varalign=0;
 202
 203         /* Flush pending memcpy */
 204         if(*len != 0) {
 205                 memcpy(buf+*to, *from, *len);
 206                 *to += *len;
 207                 *len = 0;
 208         }
 209
 210         align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
 211         //no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
 212
 213         /* Align output */
 214         varalign = ltt_align((size_t)(*to), align);
 215         size += varalign;
 216
 217         /* Copy members */
 218         varalign = ltt_align(size, sizeof(unsigned int));
 219         size += varalign;
 220         varfrom = &obj->len;
 221         varlen += sizeof(unsigned int);
 222         memcpy(buf+*to+size, varfrom, varlen);
 223         size += varlen;
 224         varlen = 0;
 225
 226         varalign = ltt_align(size, sizeof(double));
 227         size += varalign;
 228         varfrom = obj->array;
 229         varlen += obj->len * sizeof(double);
 230         memcpy(buf+*to+size, varfrom, varlen);
 231         size += varlen;
 232         varlen = 0;
 233
 234         *to += size;
 235
 236         /* Put source *from just after the C sequence */
 237         *from = obj+1;
 238
 239         return size;
 240 }
 241
 242
 243
 244 union lttng_mystruct_myunion {
 245         double myfloat;
 246         unsigned long myulong;
 247 };
 248
 249
 250 static inline size_t lttng_get_size_mystruct_myunion(
 251                                                                                                                                  union lttng_mystruct_myunion *obj)
 252 {
 253         size_t size=0, locsize;
 254
 255         locsize = sizeof(double);
 256         size = max(size, locsize);
 257
 258         locsize = sizeof(unsigned long);
 259         size = max(size, locsize);
 260
 261         BUG_ON(size != sizeof(union lttng_mystruct_myunion));
 262
 263         return size;
 264 }
 265
 266
 267 static inline size_t lttng_get_alignment_mystruct_myunion(
 268                                                                                                                                  union lttng_mystruct_myunion *obj)
 269 {
 270         size_t align=0, localign;
 271
 272         localign = sizeof(double);
 273         align = max(align, localign);
 274
 275         localign = sizeof(unsigned long);
 276         align = max(align, localign);
 277
 278         return align;
 279 }
 280
 281
 282 static inline size_t lttng_write_mystruct_myunion(
 283                 void *buf,
 284                 size_t *to,
 285                 void **from,
 286                 size_t *len,
 287                 union lttng_mystruct_myunion *obj)
 288 {
 289         size_t align, size, varalign;
 290
 291         align = lttng_get_alignment_mystruct_myunion(obj);
 292         size = lttng_get_size_mystruct_myunion(obj);
 293
 294         if(*len == 0) {
 295                 varalign = ltt_align(*to, align);       /* align output */
 296                 *to += varalign;
 297         } else {
 298                 varalign = ltt_align(*to+*len, align);  /* C alignment, ok to do a memcpy of it */
 299                 *len += varalign;
 300         }
 301
 302         *len += size;
 303
 304         return varalign + size;
 305 }
 306
 307
 308 struct lttng_mystruct {
 309         unsigned int irq_id;
 310         enum lttng_irq_mode mode;
 311         struct lttng_mystruct2 teststr;
 312         lttng_array_mystruct_myarray myarray;
 313         lttng_sequence_mystruct_mysequence mysequence;
 314         union lttng_mystruct_myunion myunion;
 315 };
 316
 317 static inline size_t lttng_get_size_mystruct(
 318                 struct lttng_mystruct *obj)
 319 {
 320         size_t size=0, locsize, localign;
 321
 322         locsize = sizeof(unsigned int);
 323         size += ltt_align(size, locsize) + locsize;
 324
 325         locsize = sizeof(enum lttng_irq_mode);
 326         size += ltt_align(size, locsize) + locsize;
 327
 328         localign = lttng_get_alignment_mystruct2(&obj->teststr);
 329         locsize = lttng_get_size_mystruct2(&obj->teststr);
 330         size += ltt_align(size, localign) + locsize;
 331
 332         localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
 333         locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
 334         size += ltt_align(size, localign) + locsize;
 335
 336         localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
 337         locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
 338         size += ltt_align(size, localign) + locsize;
 339
 340         localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
 341         locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
 342         size += ltt_align(size, localign) + locsize;
 343
 344         return size;
 345 }
 346
 347
 348 static inline size_t lttng_get_alignment_mystruct(
 349                 struct lttng_mystruct *obj)
 350 {
 351         size_t align=0, localign;
 352
 353         localign = sizeof(unsigned int);
 354         align = max(align, localign);
 355
 356         localign = sizeof(enum lttng_irq_mode);
 357         align = max(align, localign);
 358
 359         localign = lttng_get_alignment_mystruct2(&obj->teststr);
 360         align = max(align, localign);
 361
 362         localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
 363         align = max(align, localign);
 364
 365         localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
 366         align = max(align, localign);
 367
 368         localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
 369         align = max(align, localign);
 370
 371         return align;
 372 }
 373
 374 static inline void lttng_write_mystruct(
 375                 void *buf,
 376                 size_t *to,
 377                 void **from,
 378                 size_t *len,
 379                 struct lttng_mystruct *obj)
 380 {
 381         size_t align, size=0, locsize;
 382
 383         align = lttng_get_alignment_mystruct(obj);
 384         // no need : contains variable size fields.
 385         // locsize = lttng_get_size_mystruct(obj);
 386
 387         if(*len == 0) {
 388                 *to += ltt_align(*to, align);   /* align output */
 389         } else {
 390                 *len += ltt_align(*to+*len, align);     /* C alignment, ok to do a memcpy of it */
 391         }
 392
 393         /* Contains variable sized fields : must explode the structure */
 394
 395         locsize = sizeof(unsigned int);
 396         locsize += ltt_align(size, locsize) + locsize;
 397         *len += locsize;
 398         size += locsize;
 399
 400         locsize = sizeof(enum lttng_irq_mode);
 401         locsize += ltt_align(size, locsize) + locsize;
 402         *len += locsize;
 403         size += locsize;
 404
 405         size += lttng_write_mystruct2(buf, to, from, len, &obj->teststr);
 406
 407         size += lttng_write_array_mystruct_myarray(buf, to, from, len, obj->myarray);
 408
 409         /* Variable length field */
 410         size += lttng_write_sequence_mystruct_mysequence(buf, to, from, len, &obj->mysequence);
 411
 412         size += lttng_write_mystruct_myunion(buf, to, from, len, &obj->myunion);
 413
 414         /* Don't forget to flush last write..... */
 415 }
 416
 417
 418
 419
 420
 421
 422 //void main()
 423 void test()
 424 {
 425         struct lttng_mystruct test;
 426         test.mysequence.len = 20;
 427         test.mysequence.array = malloc(20);
 428
 429         size_t size = lttng_get_size_mystruct(&test);
 430         size_t align = lttng_get_alignment_mystruct(&test);
 431
 432         /* the buffer is allocated on arch_size alignment */
 433         void *buf = malloc(align + size);
 434         size_t to = 0;
 435         void *from = &test;
 436         size_t len = 0;
 437
 438         lttng_write_mystruct(buf, &to, &from, &len, &test);
 439         /* Final flush */
 440         /* Flush pending memcpy */
 441         if(len != 0) {
 442                 memcpy(buf+to, from, len);
 443                 to += len;
 444                 from += len;
 445                 len = 0;
 446         }
 447
 448         free(test.mysequence.array);
 449         free(buf);
 450 }