genevent-new/gentest.c

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