Fix some minor Linux spatch / conversions
[akaros.git] / kern / include / linux / compat_todo.h
1 /*
2  * Copyright (C) 1991-2015, the Linux Kernel authors
3  *
4  * This source code is licensed under the GNU General Public License,
5  * Version 2. See the file COPYING for more details.
6  *
7  * This file consists of various bits of Linux code used in porting drivers to
8  * Akaros. */
9
10 #pragma once
11
12 #include <arch/types.h>
13 #include <ros/common.h>
14 #include <atomic.h>
15 #include <bitops.h>
16 #include <kthread.h>
17 #include <list.h>
18 #include <stdbool.h>
19 #include <stddef.h>
20 #include <string.h>
21 #include <taskqueue.h>
22 #include <rbtree.h>
23
24 #define ETH_ALEN        6               /* Octets in one ethernet addr   */
25 #define ETH_ZLEN        60              /* Min. octets in frame sans FCS */
26 #define ETH_FCS_LEN     4               /* Octets in the FCS             */
27
28 struct ethhdr {
29         unsigned char   h_dest[ETH_ALEN];       /* destination eth addr */
30         unsigned char   h_source[ETH_ALEN];     /* source ether addr    */
31         uint16_t        h_proto;                /* packet type ID field */
32 } __attribute__((packed));
33
34 extern int ____ilog2_NaN;
35
36 /**
37  * ilog2 - log of base 2 of 32-bit or a 64-bit unsigned value
38  * @n - parameter
39  *
40  * constant-capable log of base 2 calculation
41  * - this can be used to initialise global variables from constant data, hence
42  *   the massive ternary operator construction
43  *
44  * selects the appropriately-sized optimised version depending on sizeof(n)
45  */
46 #define ilog2(n)                                \
47 (                                               \
48         __builtin_constant_p(n) ? (             \
49                 (n) < 1 ? ____ilog2_NaN :       \
50                 (n) & (1ULL << 63) ? 63 :       \
51                 (n) & (1ULL << 62) ? 62 :       \
52                 (n) & (1ULL << 61) ? 61 :       \
53                 (n) & (1ULL << 60) ? 60 :       \
54                 (n) & (1ULL << 59) ? 59 :       \
55                 (n) & (1ULL << 58) ? 58 :       \
56                 (n) & (1ULL << 57) ? 57 :       \
57                 (n) & (1ULL << 56) ? 56 :       \
58                 (n) & (1ULL << 55) ? 55 :       \
59                 (n) & (1ULL << 54) ? 54 :       \
60                 (n) & (1ULL << 53) ? 53 :       \
61                 (n) & (1ULL << 52) ? 52 :       \
62                 (n) & (1ULL << 51) ? 51 :       \
63                 (n) & (1ULL << 50) ? 50 :       \
64                 (n) & (1ULL << 49) ? 49 :       \
65                 (n) & (1ULL << 48) ? 48 :       \
66                 (n) & (1ULL << 47) ? 47 :       \
67                 (n) & (1ULL << 46) ? 46 :       \
68                 (n) & (1ULL << 45) ? 45 :       \
69                 (n) & (1ULL << 44) ? 44 :       \
70                 (n) & (1ULL << 43) ? 43 :       \
71                 (n) & (1ULL << 42) ? 42 :       \
72                 (n) & (1ULL << 41) ? 41 :       \
73                 (n) & (1ULL << 40) ? 40 :       \
74                 (n) & (1ULL << 39) ? 39 :       \
75                 (n) & (1ULL << 38) ? 38 :       \
76                 (n) & (1ULL << 37) ? 37 :       \
77                 (n) & (1ULL << 36) ? 36 :       \
78                 (n) & (1ULL << 35) ? 35 :       \
79                 (n) & (1ULL << 34) ? 34 :       \
80                 (n) & (1ULL << 33) ? 33 :       \
81                 (n) & (1ULL << 32) ? 32 :       \
82                 (n) & (1ULL << 31) ? 31 :       \
83                 (n) & (1ULL << 30) ? 30 :       \
84                 (n) & (1ULL << 29) ? 29 :       \
85                 (n) & (1ULL << 28) ? 28 :       \
86                 (n) & (1ULL << 27) ? 27 :       \
87                 (n) & (1ULL << 26) ? 26 :       \
88                 (n) & (1ULL << 25) ? 25 :       \
89                 (n) & (1ULL << 24) ? 24 :       \
90                 (n) & (1ULL << 23) ? 23 :       \
91                 (n) & (1ULL << 22) ? 22 :       \
92                 (n) & (1ULL << 21) ? 21 :       \
93                 (n) & (1ULL << 20) ? 20 :       \
94                 (n) & (1ULL << 19) ? 19 :       \
95                 (n) & (1ULL << 18) ? 18 :       \
96                 (n) & (1ULL << 17) ? 17 :       \
97                 (n) & (1ULL << 16) ? 16 :       \
98                 (n) & (1ULL << 15) ? 15 :       \
99                 (n) & (1ULL << 14) ? 14 :       \
100                 (n) & (1ULL << 13) ? 13 :       \
101                 (n) & (1ULL << 12) ? 12 :       \
102                 (n) & (1ULL << 11) ? 11 :       \
103                 (n) & (1ULL << 10) ? 10 :       \
104                 (n) & (1ULL <<  9) ?  9 :       \
105                 (n) & (1ULL <<  8) ?  8 :       \
106                 (n) & (1ULL <<  7) ?  7 :       \
107                 (n) & (1ULL <<  6) ?  6 :       \
108                 (n) & (1ULL <<  5) ?  5 :       \
109                 (n) & (1ULL <<  4) ?  4 :       \
110                 (n) & (1ULL <<  3) ?  3 :       \
111                 (n) & (1ULL <<  2) ?  2 :       \
112                 (n) & (1ULL <<  1) ?  1 :       \
113                 (n) & (1ULL <<  0) ?  0 :       \
114                 ____ilog2_NaN                   \
115                                    ) :          \
116         LOG2_UP(n)                              \
117  )
118
119 #define sprintf(s, fmt, ...) ({ \
120         int ret = -1; \
121         if (__builtin_types_compatible_p(typeof(s), char[])) \
122                 ret = snprintf(s, sizeof(s), fmt, ##__VA_ARGS__); \
123         else \
124                 panic("Not implemented"); \
125         ret; \
126 })
127
128 #define printk_once(fmt, ...) ({ \
129         static bool __print_once; \
130         if (!__print_once) { \
131                 __print_once = true; \
132                 printk(fmt, ##__VA_ARGS__); \
133         } \
134 })
135
136 #define dev_warn(dev, format, ...) \
137         pr_warn(format, ## __VA_ARGS__)
138
139 #define dev_printk(level, dev, fmt, ...) \
140         printk(level fmt, ## __VA_ARGS__)
141
142 /* XXX This is not a tree. */
143 struct radix_tree_node {
144         struct list_head        linkage;
145         unsigned long           index;
146         void                    *item;
147 };
148
149 struct radix_tree_root {
150         struct list_head        hlinks;
151 };
152
153 static inline void INIT_RADIX_TREE(struct radix_tree_root *rp, int mask)
154 {
155         INIT_LIST_HEAD(&rp->hlinks);
156 }
157
158 static inline int radix_tree_insert(struct radix_tree_root *root,
159                                     unsigned long index, void *item)
160 {
161         struct list_head *lp = root->hlinks.next;
162         struct radix_tree_node *p;
163
164         while (lp != &root->hlinks) {
165                 p = (struct radix_tree_node *)lp;
166                 if (p->index == index)
167                         return -EEXIST;
168                 lp = lp->next;
169         }
170
171         p = kmalloc(sizeof(*p), MEM_WAIT);
172         if (!p)
173                 return -ENOMEM;
174         p->index = index;
175         p->item = item;
176         list_add(&p->linkage, &root->hlinks);
177         return 0;
178 }
179
180 static inline void *radix_tree_lookup(struct radix_tree_root *root,
181                                       unsigned long index)
182 {
183         struct list_head *lp = root->hlinks.next;
184         struct radix_tree_node *p;
185
186         while (lp != &root->hlinks) {
187                 p = (struct radix_tree_node *)lp;
188                 if (p->index == index)
189                         return p->item;
190                 lp = lp->next;
191         }
192
193         return NULL;
194 }
195
196 static inline void radix_tree_delete(struct radix_tree_root *root,
197                                       unsigned long index)
198 {
199         struct list_head *lp = root->hlinks.next;
200         struct radix_tree_node *p;
201
202         while (lp != &root->hlinks) {
203                 p = (struct radix_tree_node *)lp;
204                 if (p->index == index) {
205                         list_del(lp);
206                         return;
207                 }
208                 lp = lp->next;
209         }
210         panic("Node not found\n");
211 }
212
213 #define INIT_DEFERRABLE_WORK(_work, _func) \
214         INIT_DELAYED_WORK(_work, _func) /* XXX */
215
216 struct tasklet_struct {
217         uint32_t state;
218         void (*func)(unsigned long);
219         unsigned long data;
220 };
221
222 static void __tasklet_wrapper(uint32_t srcid, long a0, long a1, long a2)
223 {
224         struct tasklet_struct *t = (struct tasklet_struct *)a0;
225
226         if (atomic_cas_u32(&t->state, 1, 0))
227                 t->func(t->data);
228 }
229
230 static inline void tasklet_schedule(struct tasklet_struct *t)
231 {
232         if (atomic_cas_u32(&t->state, 0, 1)) {
233                 send_kernel_message(core_id(), __tasklet_wrapper, (long)t, 0, 0,
234                                     KMSG_ROUTINE);
235         }
236 }
237
238 static inline void tasklet_disable(struct tasklet_struct *t)
239 {
240         panic("tasklet_disable unimplemented");
241         // XXX t->state = 2
242 }
243
244 static inline void tasklet_init(struct tasklet_struct *t,
245                                 void (*func)(unsigned long), unsigned long data)
246 {
247         t->state = 0;
248         t->func = func;
249         t->data = data;
250 }
251
252 struct completion {
253         unsigned int done;
254 };
255
256 static inline void init_completion(struct completion *x)
257 {
258         x->done = 0;
259 }
260
261 static inline void reinit_completion(struct completion *x)
262 {
263         printd("Core %d: reinit_completion %p\n", core_id(), x);
264         x->done = 0;
265 }
266
267 static inline void complete(struct completion *x)
268 {
269         printd("Core %d: complete %p\n", core_id(), x);
270         x->done = 1;
271         wmb();
272 }
273
274 static inline void wait_for_completion(struct completion *x)
275 {
276         while (!x->done)
277                 cmb();
278 }
279
280 static inline unsigned long wait_for_completion_timeout(struct completion *x,
281                                                         unsigned long timeout)
282 {
283         printd("Core %d: wait_for_completion_timeout %p\n", core_id(), x);
284         while (!x->done) {
285                 if (timeout) {
286                         kthread_usleep(1000);
287                         timeout--;
288                         cmb();
289                 } else {
290                         break;
291                 }
292         }
293         return timeout;
294 }
295
296 #define jiffies tsc2msec(read_tsc())
297
298 static inline unsigned long round_jiffies(unsigned long j)
299 {
300         return j / 1000 * 1000;
301 }
302
303 static inline unsigned long round_jiffies_relative(unsigned long j)
304 {
305         return round_jiffies(j);
306 }
307
308 struct timer_list {
309         spinlock_t lock;
310         bool scheduled;
311         unsigned long expires;
312         void (*function)(unsigned long);
313         unsigned long data;
314 };
315
316 static inline void init_timer(struct timer_list *timer)
317 {
318         spinlock_init_irqsave(&timer->lock);
319         timer->scheduled = false;
320         timer->expires = -1;
321         timer->function = 0;
322         timer->data = 0;
323 }
324
325 static inline void setup_timer(struct timer_list *timer,
326                                void (*func)(unsigned long), unsigned long data)
327 {
328         init_timer(timer);
329         timer->function = func;
330         timer->data = data;
331 }
332
333 static void __timer_wrapper(uint32_t srcid, long a0, long a1, long a2)
334 {
335         struct timer_list *timer = (struct timer_list *)a0;
336         unsigned long expires, now_j;
337
338         spin_lock_irqsave(&timer->lock);
339         expires = timer->expires;
340         timer->scheduled = false;
341         spin_unlock_irqsave(&timer->lock);
342
343         now_j = jiffies;
344         if (expires > now_j)
345                 kthread_usleep((expires - now_j) * 1000);
346         timer->function(timer->data);
347 }
348
349 static inline void add_timer(struct timer_list *timer)
350 {
351         timer->scheduled = true;
352         send_kernel_message(core_id(), __timer_wrapper, (long)timer, 0, 0,
353                             KMSG_ROUTINE);
354 }
355
356 static inline void mod_timer(struct timer_list *timer, unsigned long expires)
357 {
358         spin_lock_irqsave(&timer->lock);
359         timer->expires = expires;
360         if (timer->scheduled) {
361                 spin_unlock_irqsave(&timer->lock);
362                 return;
363         }
364         timer->scheduled = true;
365         spin_unlock_irqsave(&timer->lock);
366         send_kernel_message(core_id(), __timer_wrapper, (long)timer, 0, 0,
367                             KMSG_ROUTINE);
368 }
369
370 static inline void del_timer_sync(struct timer_list *timer)
371 {
372         panic("del_timer_sync unimplemented");
373 }
374
375 static inline void setup_timer_on_stack(struct timer_list *timer,
376                                         void (*func)(unsigned long),
377                                         unsigned long data)
378 {
379         setup_timer(timer, func, data);
380 }
381
382 static inline void destroy_timer_on_stack(struct timer_list *timer)
383 {
384 }
385
386 /* TODO: This is nasty (all of the timer stuff).  We don't know if a timer
387  * actually finished or not.  Someone could mod_timer repeatedly and have the
388  * same handler running concurrently.  */
389 static inline bool timer_pending(struct timer_list *timer)
390 {
391         return timer->expires >= jiffies;
392 }
393
394 struct cpu_rmap {
395 };
396
397 extern unsigned long saved_max_pfn;
398
399 struct device_attribute {
400 };
401
402 #define DEFINE_MUTEX(mutexname) \
403         qlock_t mutexname = QLOCK_INITIALIZER(mutexname);
404
405 /*
406  * Check at compile time that something is of a particular type.
407  * Always evaluates to 1 so you may use it easily in comparisons.
408  */
409 #define typecheck(type,x) \
410 ({      type __dummy; \
411         typeof(x) __dummy2; \
412         (void)(&__dummy == &__dummy2); \
413         1; \
414 })
415
416 /*
417  * Check at compile time that 'function' is a certain type, or is a pointer
418  * to that type (needs to use typedef for the function type.)
419  */
420 #define typecheck_fn(type,function) \
421 ({      typeof(type) __tmp = function; \
422         (void)__tmp; \
423 })
424
425 #if BITS_PER_LONG > 32
426 #define NET_SKBUFF_DATA_USES_OFFSET 1
427 #endif
428
429 #ifdef NET_SKBUFF_DATA_USES_OFFSET
430 typedef unsigned int sk_buff_data_t;
431 #else
432 typedef unsigned char *sk_buff_data_t;
433 #endif
434
435 typedef struct skb_frag_struct skb_frag_t;
436
437 struct skb_frag_struct {
438         struct {
439                 struct page *p;
440         } page;
441 #if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
442         uint32_t page_offset;
443         uint32_t size;
444 #else
445         uint16_t page_offset;
446         uint16_t size;
447 #endif
448 };
449
450 /* asm-generic/getorder.h */
451 /*
452  * Runtime evaluation of get_order()
453  */
454 static inline __attribute_const__
455 int __get_order(unsigned long size)
456 {
457         int order;
458
459         size--;
460         size >>= PAGE_SHIFT;
461 #if BITS_PER_LONG == 32
462         order = fls(size);
463 #else
464         order = fls64(size);
465 #endif
466         return order;
467 }
468
469 /**
470  * get_order - Determine the allocation order of a memory size
471  * @size: The size for which to get the order
472  *
473  * Determine the allocation order of a particular sized block of memory.  This
474  * is on a logarithmic scale, where:
475  *
476  *      0 -> 2^0 * PAGE_SIZE and below
477  *      1 -> 2^1 * PAGE_SIZE to 2^0 * PAGE_SIZE + 1
478  *      2 -> 2^2 * PAGE_SIZE to 2^1 * PAGE_SIZE + 1
479  *      3 -> 2^3 * PAGE_SIZE to 2^2 * PAGE_SIZE + 1
480  *      4 -> 2^4 * PAGE_SIZE to 2^3 * PAGE_SIZE + 1
481  *      ...
482  *
483  * The order returned is used to find the smallest allocation granule required
484  * to hold an object of the specified size.
485  *
486  * The result is undefined if the size is 0.
487  *
488  * This function may be used to initialise variables with compile time
489  * evaluations of constants.
490  */
491 #define get_order(n)                                            \
492 (                                                               \
493         __builtin_constant_p(n) ? (                             \
494                 ((n) == 0UL) ? BITS_PER_LONG - PAGE_SHIFT :     \
495                 (((n) < (1UL << PAGE_SHIFT)) ? 0 :              \
496                  ilog2((n) - 1) - PAGE_SHIFT + 1)               \
497         ) :                                                     \
498         __get_order(n)                                          \
499 )
500
501 /* asm-generic/io.h */
502 static inline void __raw_writeq(uint64_t value, volatile void *addr)
503 {
504         *(volatile uint64_t *)addr = value;
505 }
506
507 /* linux/export.h */
508 #define EXPORT_SYMBOL_GPL(...)
509
510 /* linux/gfp.h */
511 /* These are all set to 0.  Silently passing flags to Akaros's memory allocator
512  * is dangerous - we could be turning on some Akaros feature that shares the
513  * same bit.
514  *
515  * Similarly, note that some Linux flags (__GFP_ZERO) is not here.  Those flags
516  * need to be dealt with.  Silently ignoring them will cause errors. */
517 #define  __GFP_DMA 0
518 #define  __GFP_HIGHMEM 0
519 #define  __GFP_DMA32 0
520 #define  __GFP_MOVABLE 0
521 #define  __GFP_WAIT 0
522 #define  __GFP_HIGH 0
523 #define  __GFP_IO 0
524 #define  __GFP_FS 0
525 #define  __GFP_COLD 0
526 #define  __GFP_NOWARN 0
527 #define  __GFP_REPEAT 0
528 #define  __GFP_NOFAIL 0
529 #define  __GFP_NORETRY 0
530 #define  __GFP_MEMALLOC 0
531 #define  __GFP_COMP 0
532 #define  __GFP_NOMEMALLOC 0
533 #define  __GFP_HARDWALL 0
534 #define  __GFP_THISNODE 0
535 #define  __GFP_RECLAIMABLE 0
536 #define  __GFP_NOACCOUNT 0
537 #define  __GFP_NOTRACK 0
538 #define  __GFP_NO_KSWAPD 0
539 #define  __GFP_OTHER_NODE 0
540 #define  __GFP_WRITE 0
541 #define GFP_HIGHUSER 0
542
543 /* linux/kernel.h */
544 #define min3(x, y, z) MIN((typeof(x))MIN(x, y), z)
545 #define max3(x, y, z) MAX((typeof(x))MAX(x, y), z)
546
547 typedef unsigned int pci_channel_state_t;
548
549 enum pci_channel_state {
550         /* I/O channel is in normal state */
551         pci_channel_io_normal = 1,
552
553         /* I/O to channel is blocked */
554         pci_channel_io_frozen = 2,
555
556         /* PCI card is dead */
557         pci_channel_io_perm_failure = 3,
558 };
559
560 typedef unsigned int pci_ers_result_t;
561
562 enum pci_ers_result {
563         /* no result/none/not supported in device driver */
564         PCI_ERS_RESULT_NONE = 1,
565
566         /* Device driver can recover without slot reset */
567         PCI_ERS_RESULT_CAN_RECOVER = 2,
568
569         /* Device driver wants slot to be reset. */
570         PCI_ERS_RESULT_NEED_RESET = 3,
571
572         /* Device has completely failed, is unrecoverable */
573         PCI_ERS_RESULT_DISCONNECT = 4,
574
575         /* Device driver is fully recovered and operational */
576         PCI_ERS_RESULT_RECOVERED = 5,
577
578         /* No AER capabilities registered for the driver */
579         PCI_ERS_RESULT_NO_AER_DRIVER = 6,
580 };
581
582 /* These values come from the PCI Express Spec */
583 enum pcie_link_width {
584         PCIE_LNK_WIDTH_RESRV    = 0x00,
585         PCIE_LNK_X1             = 0x01,
586         PCIE_LNK_X2             = 0x02,
587         PCIE_LNK_X4             = 0x04,
588         PCIE_LNK_X8             = 0x08,
589         PCIE_LNK_X12            = 0x0C,
590         PCIE_LNK_X16            = 0x10,
591         PCIE_LNK_X32            = 0x20,
592         PCIE_LNK_WIDTH_UNKNOWN  = 0xFF,
593 };
594
595 /* Based on the PCI Hotplug Spec, but some values are made up by us */
596 enum pci_bus_speed {
597         PCI_SPEED_33MHz                 = 0x00,
598         PCI_SPEED_66MHz                 = 0x01,
599         PCI_SPEED_66MHz_PCIX            = 0x02,
600         PCI_SPEED_100MHz_PCIX           = 0x03,
601         PCI_SPEED_133MHz_PCIX           = 0x04,
602         PCI_SPEED_66MHz_PCIX_ECC        = 0x05,
603         PCI_SPEED_100MHz_PCIX_ECC       = 0x06,
604         PCI_SPEED_133MHz_PCIX_ECC       = 0x07,
605         PCI_SPEED_66MHz_PCIX_266        = 0x09,
606         PCI_SPEED_100MHz_PCIX_266       = 0x0a,
607         PCI_SPEED_133MHz_PCIX_266       = 0x0b,
608         AGP_UNKNOWN                     = 0x0c,
609         AGP_1X                          = 0x0d,
610         AGP_2X                          = 0x0e,
611         AGP_4X                          = 0x0f,
612         AGP_8X                          = 0x10,
613         PCI_SPEED_66MHz_PCIX_533        = 0x11,
614         PCI_SPEED_100MHz_PCIX_533       = 0x12,
615         PCI_SPEED_133MHz_PCIX_533       = 0x13,
616         PCIE_SPEED_2_5GT                = 0x14,
617         PCIE_SPEED_5_0GT                = 0x15,
618         PCIE_SPEED_8_0GT                = 0x16,
619         PCI_SPEED_UNKNOWN               = 0xff,
620 };
621
622 /* linux/slab.h */
623 #define kzalloc_node(...) (0 /* XXX */)
624
625 #define __cpu_to_le32(x) (x)
626 #define __le32_to_cpu(x) (x)
627
628 #define swab32 __builtin_bswap32
629 #define swab16 __builtin_bswap16
630
631 #define cond_resched() { /* XXX */ \
632         volatile int i = 100000; \
633         /* printk("%s:%d %s cond_resched\n", __FILE__, __LINE__, __FUNCTION__); */ \
634         while (i--); \
635 }
636
637 #define iounmap(...) (0 /* XXX */)
638
639 typedef uint64_t phys_addr_t;
640 typedef phys_addr_t resource_size_t;
641
642 struct dma_pool *dma_pool_create(const char *name, void *dev,
643                                  size_t size, size_t align, size_t allocation);
644
645 void dma_pool_destroy(struct dma_pool *pool);
646
647 void *dma_pool_alloc(struct dma_pool *pool, int mem_flags, dma_addr_t *handle);
648
649 void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t addr);
650
651 #define pci_pool dma_pool
652 #define pci_pool_create(name, pdev, size, align, allocation) \
653                 dma_pool_create(name, pdev, size, align, allocation)
654 #define pci_pool_destroy(pool) dma_pool_destroy(pool)
655 #define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
656 #define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
657
658 #define __user
659 #define __bitwise
660
661 struct vm_area_struct {
662 };
663
664 /* uapi/rdma/ib_user_mad.h */
665 #define IB_USER_MAD_USER_RMPP 1
666
667 #define be16_to_cpup(p) be16_to_cpu(*(uint16_t *)(p))
668 #define be32_to_cpup(p) be32_to_cpu(*(uint32_t *)(p))
669
670 /* access_ok.h */
671
672 static inline uint16_t get_unaligned_le16(const void *p)
673 {
674         return le16_to_cpu(*(uint16_t *)p);
675 }
676
677 static inline uint32_t get_unaligned_le32(const void *p)
678 {
679         return le32_to_cpu(*(uint32_t *)p);
680 }
681
682 static inline uint64_t get_unaligned_le64(const void *p)
683 {
684         return le64_to_cpu(*(uint64_t *)p);
685 }
686
687 static inline void put_unaligned_le16(uint16_t val, void *p)
688 {
689         *((uint16_t *)p) = cpu_to_le16(val);
690 }
691
692 static inline void put_unaligned_le32(uint32_t val, void *p)
693 {
694         *((uint32_t *)p) = cpu_to_le32(val);
695 }
696
697 static inline void put_unaligned_le64(uint64_t val, void *p)
698 {
699         *((uint64_t *)p) = cpu_to_le64(val);
700 }
701
702 extern void __bad_unaligned_access_size(void);
703
704 #define __get_unaligned_le(ptr) ({ \
705         __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \
706         __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)), \
707         __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)), \
708         __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)), \
709         __bad_unaligned_access_size())))); \
710 })
711
712 #define __put_unaligned_le(val, ptr) ({                                 \
713         void *__gu_p = (ptr);                                           \
714         switch (sizeof(*(ptr))) {                                       \
715         case 1:                                                         \
716                 *(uint8_t *)__gu_p = (uint8_t)(val);                    \
717                 break;                                                  \
718         case 2:                                                         \
719                 put_unaligned_le16((uint16_t)(val), __gu_p);            \
720                 break;                                                  \
721         case 4:                                                         \
722                 put_unaligned_le32((uint32_t)(val), __gu_p);            \
723                 break;                                                  \
724         case 8:                                                         \
725                 put_unaligned_le64((uint64_t)(val), __gu_p);            \
726                 break;                                                  \
727         default:                                                        \
728                 __bad_unaligned_access_size();                          \
729                 break;                                                  \
730         }                                                               \
731         (void)0; })
732
733 #define get_unaligned __get_unaligned_le
734 #define put_unaligned __put_unaligned_le
735
736 #define vmalloc_node(...) (0 /* XXX */)
737 /* needed by icm.c: */
738 #define kmalloc_node(size, flags, node) kmalloc(size, flags)
739 #define alloc_pages_node(nid, gfp_mask, order) 0
740
741 struct scatterlist {
742         unsigned long   page_link;
743         unsigned int    offset;
744         unsigned int    length;
745         dma_addr_t      dma_address;
746 };
747
748 #define sg_dma_address(sg) ((sg)->dma_address)
749 #define sg_dma_len(sg) ((sg)->length)
750
751 #define sg_is_chain(sg) ((sg)->page_link & 0x01)
752 #define sg_is_last(sg) ((sg)->page_link & 0x02)
753 #define sg_chain_ptr(sg) ((struct scatterlist *) ((sg)->page_link & ~0x03))
754
755 static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
756 {
757         unsigned long page_link = sg->page_link & 0x3;
758         sg->page_link = page_link | (unsigned long) page;
759 }
760
761 /**
762  * sg_set_page - Set sg entry to point at given page
763  * @sg:          SG entry
764  * @page:        The page
765  * @len:         Length of data
766  * @offset:      Offset into page
767  *
768  * Description:
769  *   Use this function to set an sg entry pointing at a page, never assign
770  *   the page directly. We encode sg table information in the lower bits
771  *   of the page pointer. See sg_page() for looking up the page belonging
772  *   to an sg entry.
773  *
774  **/
775 static inline void sg_set_page(struct scatterlist *sg, struct page *page,
776                                unsigned int len, unsigned int offset)
777 {
778         sg_assign_page(sg, page);
779         sg->offset = offset;
780         sg->length = len;
781 }
782
783 static inline struct page *sg_page(struct scatterlist *sg)
784 {
785         return (struct page *)(sg->page_link & ~0x3);
786 }
787
788 static inline void sg_set_buf(struct scatterlist *sg, void *buf,
789                               unsigned int buflen)
790 {
791         sg_set_page(sg, kva2page(buf), buflen, PGOFF(buf));
792 }
793
794 #define for_each_sg(sglist, sg, nr, __i) \
795         for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg))
796
797 static inline void sg_mark_end(struct scatterlist *sg)
798 {
799         /*
800          * Set termination bit, clear potential chain bit
801          */
802         sg->page_link |= 0x02;
803         sg->page_link &= ~0x01;
804 }
805
806 void sg_init_table(struct scatterlist *, unsigned int);
807 struct scatterlist *sg_next(struct scatterlist *);
808
809 static inline int nontranslate_map_sg(void *dev, struct scatterlist *sglist,
810                                       int nelems, int dir)
811 {
812         int i;
813         struct scatterlist *sg;
814
815         for_each_sg(sglist, sg, nelems, i) {
816                 sg_dma_address(sg) = page2pa(sg_page(sg)) + sg->offset;
817                 sg_dma_len(sg) = sg->length;
818         }
819         return nelems;
820 }
821
822 static inline int dma_map_sg(void *dev, struct scatterlist *sg, int nents,
823                              enum dma_data_direction dir)
824 {
825         return nontranslate_map_sg(dev, sg, nents, dir);
826 }
827
828 static inline void dma_unmap_sg(void *dev, struct scatterlist *sg, int nents,
829                                 enum dma_data_direction dir)
830 {
831         /* TODO nop */
832 }
833
834 struct dma_attrs {
835 };
836
837 #define dma_map_sg_attrs(d, s, n, r, a) dma_map_sg(d, s, n, r)
838 #define dma_unmap_sg_attrs(d, s, n, r, a) dma_unmap_sg(d, s, n, r)
839
840 static inline int pci_map_sg(struct pci_device *pdev, struct scatterlist *sg,
841                              int nents, int direction)
842 {
843         return dma_map_sg(NULL, sg, nents, (enum dma_data_direction)direction);
844 }
845
846 static inline void pci_unmap_sg(struct pci_device *pdev, struct scatterlist *sg,
847                                 int nents, int direction)
848 {
849         dma_unmap_sg(NULL, sg, nents, (enum dma_data_direction)direction);
850 }
851
852 /* TODO: get this in an arch-dependent manner.  On x86, be careful of adjacent
853  * cacheline prefetching. */
854 #define cache_line_size() 64
855
856 static inline void *lowmem_page_address(struct page *page)
857 {
858         /* XXX not sure about this */
859         return page2kva(page);
860 }
861
862 #define page_address(page) lowmem_page_address(page)
863
864 #define netif_get_num_default_rss_queues() (8 /* FIXME */)
865
866 static inline void netdev_rss_key_fill(void *buffer, size_t len)
867 {
868         /* XXX */
869         memset(buffer, 0, len);
870 }
871
872 /* Hacked up version of Linux's.  Assuming reg's are implemented and
873  * read_config never fails. */
874 static int pcie_capability_read_dword(struct pci_device *dev, int pos,
875                                       uint32_t *val)
876 {
877         uint32_t pcie_cap;
878         *val = 0;
879         if (pos & 3)
880                 return -EINVAL;
881         if (pci_find_cap(dev, PCI_CAP_ID_EXP, &pcie_cap))
882                 return -EINVAL;
883         pci_read_config_dword(dev, pcie_cap + pos, val);
884         return 0;
885 }
886
887 static inline const char *pci_name(const struct pci_device *pdev)
888 {
889         return pdev->name;
890 }
891
892 #define dev_name(dev) ("ether0" /* XXX */)
893
894 #define pci_request_regions(...) (0 /* XXX */)
895 #define pci_save_state(...) (0 /* XXX */)
896 #define pci_set_consistent_dma_mask(...) (0 /* XXX */)
897 #define pci_set_dma_mask(...) (0 /* XXX */)
898 #define pci_channel_offline(...) (0 /* XXX */)
899 #define dma_set_max_seg_size(...) (0 /* XXX */)
900 #define dma_get_cache_alignment(...) (1 /* XXX */)
901 #define dev_to_node(...) (0 /* XXX */)
902 #define set_dev_node(...) /* TODO */
903 #define num_online_cpus() (1U /* XXX */)
904 #define cpu_to_node(cpu) ((void)(cpu),0)
905
906 #define pcie_get_minimum_link(dev, speed, width) ({ \
907         *(speed) = PCIE_SPEED_8_0GT; \
908         *(width) = PCIE_LNK_X8; \
909         0; })
910
911 static inline void get_random_bytes(char *buf, int nbytes)
912 {
913         // FIXME this is not random
914         for (int i = 0; i < nbytes; i++)
915                 buf[i] = i;
916 }
917
918 /* linux/moduleparam.h */
919 #define module_param_array(...)
920
921 #define ATOMIC_INIT(i) (i)
922
923 /* linux/pci_ids.h */
924 #define PCI_VENDOR_ID_MELLANOX          0x15b3
925
926 struct sysinfo {
927         long uptime;             /* Seconds since boot */
928         unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
929         unsigned long totalram;  /* Total usable main memory size */
930         unsigned long freeram;   /* Available memory size */
931         unsigned long sharedram; /* Amount of shared memory */
932         unsigned long bufferram; /* Memory used by buffers */
933         unsigned long totalswap; /* Total swap space size */
934         unsigned long freeswap;  /* swap space still available */
935         unsigned short procs;    /* Number of current processes */
936         unsigned long totalhigh; /* Total high memory size */
937         unsigned long freehigh;  /* Available high memory size */
938         unsigned int mem_unit;   /* Memory unit size in bytes */
939         char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
940 };
941
942 #define pci_pcie_cap(...) (0 /* TODO use pci_device->caps ? */)
943
944 #define NET_IP_ALIGN 2
945 #define ____cacheline_aligned_in_smp
946
947 typedef struct cpumask { } cpumask_t;
948 typedef struct cpumask cpumask_var_t[1];
949
950 #define cpumask_set_cpu(...) (0 /* TODO */)
951 #define zalloc_cpumask_var(...) (1 /* TODO */)
952 #define cpumask_local_spread(...) (0 /* TODO */)
953
954 struct notifier_block {
955 };
956
957 struct hwtstamp_config {
958         int flags;
959         int tx_type;
960         int rx_filter;
961 };
962
963 struct skb_shared_hwtstamps {
964 };
965
966 #define VLAN_N_VID 4096
967
968 /* linux/if_vlan.h */
969 #define VLAN_PRIO_SHIFT 13
970
971 /* linux/pci.h */
972 #define PCI_DMA_BIDIRECTIONAL   0
973 #define PCI_DMA_TODEVICE        1
974 #define PCI_DMA_FROMDEVICE      2
975 #define PCI_DMA_NONE            3
976
977 /* uapi/linux/net_tstamp.h */
978 enum hwtstamp_tx_types {
979         HWTSTAMP_TX_OFF,
980         HWTSTAMP_TX_ON,
981         HWTSTAMP_TX_ONESTEP_SYNC,
982 };
983
984 /* linux/skbuff.h */
985 enum {
986         SKBTX_HW_TSTAMP = 1 << 0,
987         SKBTX_SW_TSTAMP = 1 << 1,
988         SKBTX_IN_PROGRESS = 1 << 2,
989         SKBTX_DEV_ZEROCOPY = 1 << 3,
990         SKBTX_WIFI_STATUS = 1 << 4,
991         SKBTX_SHARED_FRAG = 1 << 5,
992         SKBTX_SCHED_TSTAMP = 1 << 6,
993         SKBTX_ACK_TSTAMP = 1 << 7,
994 };
995 #define CHECKSUM_NONE           0
996 #define CHECKSUM_UNNECESSARY    1
997 #define CHECKSUM_COMPLETE       2
998 #define CHECKSUM_PARTIAL        3
999
1000 #define IPPROTO_IP 0
1001 #define IPPROTO_ICMP 1
1002 #define IPPROTO_TCP 6
1003 #define IPPROTO_UDP 17
1004 #define IPPROTO_GRE 47
1005 #define IPPROTO_RAW 255
1006
1007 #define IFNAMSIZ 16
1008 #define MAX_ADDR_LEN 32
1009
1010 /* linux/mmzone.h */
1011 #define PAGE_ALLOC_COSTLY_ORDER 3
1012
1013 /* linux/cache.h */
1014 #define L1_CACHE_BYTES (1 << L1_CACHE_SHIFT)
1015 #define SMP_CACHE_BYTES L1_CACHE_BYTES
1016
1017 /* linux/if_vlan.h */
1018 #define VLAN_HLEN 4
1019
1020 #define NETIF_F_RXFCS 0
1021
1022 #define irq_to_desc(irq) ({ /* I_AM_HERE; */ NULL; /* TODO */ })
1023
1024 static inline void eth_broadcast_addr(uint8_t *addr)
1025 {
1026         memset(addr, 0xff, Eaddrlen);
1027 }
1028
1029 #define BOND_LINK_FAIL 1
1030 #define BOND_LINK_UP 2
1031 #define BOND_MODE_8023AD 1
1032 #define BOND_MODE_ACTIVEBACKUP 2
1033 #define BOND_MODE_XOR 3
1034 #define BOND_STATE_BACKUP 0
1035 #define eth_validate_addr 0
1036 #define HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ 1
1037 #define HWTSTAMP_FILTER_PTP_V1_L4_EVENT 2
1038 #define HWTSTAMP_FILTER_PTP_V1_L4_SYNC 3
1039 #define HWTSTAMP_FILTER_PTP_V2_DELAY_REQ 4
1040 #define HWTSTAMP_FILTER_PTP_V2_EVENT 5
1041 #define HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ 6
1042 #define HWTSTAMP_FILTER_PTP_V2_L2_EVENT 7
1043 #define HWTSTAMP_FILTER_PTP_V2_L2_SYNC 8
1044 #define HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ 9
1045 #define HWTSTAMP_FILTER_PTP_V2_L4_EVENT 10
1046 #define HWTSTAMP_FILTER_PTP_V2_L4_SYNC 11
1047 #define HWTSTAMP_FILTER_PTP_V2_SYNC 12
1048 #define HWTSTAMP_FILTER_SOME 13
1049 #define HWTSTAMP_FILTER_ALL 14
1050 #define HWTSTAMP_FILTER_NONE 15
1051 #define IFF_ALLMULTI 1
1052 #define IFF_PROMISC 2
1053 #define IFF_UNICAST_FLT 3
1054 #define NETDEV_BONDING_INFO 0
1055 #define NETIF_F_HW_VLAN_CTAG_FILTER 1
1056 #define NETIF_F_NTUPLE 2
1057 #define NETIF_F_RXALL 3
1058 #define NOTIFY_DONE 0
1059 #define SIOCGHWTSTAMP 1
1060 #define SIOCSHWTSTAMP 2
1061
1062 /* Misc crap (from rcu/torture.c), which might be unused. */
1063 #define DEFINE_SPINLOCK(x) spinlock_t x = SPINLOCK_INITIALIZER_IRQSAVE
1064
1065 #define DEFINE_PER_CPU DEFINE_PERCPU
1066 #define __this_cpu_inc(x) PERCPU_VAR(x)++
1067 #define per_cpu(var, i) _PERCPU_VAR(var, i)
1068 #define for_each_possible_cpu(x) for_each_core(x)
1069
1070 typedef atomic_t atomic_long_t;
1071 #define atomic_long_inc atomic_inc
1072 #define atomic_long_read atomic_read
1073
1074 static inline void local_irq_disable(void)
1075 {
1076         disable_irq();
1077 }
1078
1079 static inline void local_irq_enable(void)
1080 {
1081         enable_irq();
1082 }
1083
1084 static inline void preempt_disable(void)
1085 {
1086 }
1087
1088 static inline void preempt_enable(void)
1089 {
1090 }
1091
1092 static inline void preempt_schedule(void)
1093 {
1094 }