0d80a0fab75eefadc9849d81e864166021bfcbbe
[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 struct cpu_rmap {
376 };
377
378 extern unsigned long saved_max_pfn;
379
380 struct device_attribute {
381 };
382
383 #define DEFINE_MUTEX(mutexname) \
384         qlock_t mutexname = QLOCK_INITIALIZER(mutexname);
385
386 /*
387  * Check at compile time that something is of a particular type.
388  * Always evaluates to 1 so you may use it easily in comparisons.
389  */
390 #define typecheck(type,x) \
391 ({      type __dummy; \
392         typeof(x) __dummy2; \
393         (void)(&__dummy == &__dummy2); \
394         1; \
395 })
396
397 /*
398  * Check at compile time that 'function' is a certain type, or is a pointer
399  * to that type (needs to use typedef for the function type.)
400  */
401 #define typecheck_fn(type,function) \
402 ({      typeof(type) __tmp = function; \
403         (void)__tmp; \
404 })
405
406 #if BITS_PER_LONG > 32
407 #define NET_SKBUFF_DATA_USES_OFFSET 1
408 #endif
409
410 #ifdef NET_SKBUFF_DATA_USES_OFFSET
411 typedef unsigned int sk_buff_data_t;
412 #else
413 typedef unsigned char *sk_buff_data_t;
414 #endif
415
416 typedef struct skb_frag_struct skb_frag_t;
417
418 struct skb_frag_struct {
419         struct {
420                 struct page *p;
421         } page;
422 #if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
423         uint32_t page_offset;
424         uint32_t size;
425 #else
426         uint16_t page_offset;
427         uint16_t size;
428 #endif
429 };
430
431 /* asm-generic/getorder.h */
432 /*
433  * Runtime evaluation of get_order()
434  */
435 static inline __attribute_const__
436 int __get_order(unsigned long size)
437 {
438         int order;
439
440         size--;
441         size >>= PAGE_SHIFT;
442 #if BITS_PER_LONG == 32
443         order = fls(size);
444 #else
445         order = fls64(size);
446 #endif
447         return order;
448 }
449
450 /**
451  * get_order - Determine the allocation order of a memory size
452  * @size: The size for which to get the order
453  *
454  * Determine the allocation order of a particular sized block of memory.  This
455  * is on a logarithmic scale, where:
456  *
457  *      0 -> 2^0 * PAGE_SIZE and below
458  *      1 -> 2^1 * PAGE_SIZE to 2^0 * PAGE_SIZE + 1
459  *      2 -> 2^2 * PAGE_SIZE to 2^1 * PAGE_SIZE + 1
460  *      3 -> 2^3 * PAGE_SIZE to 2^2 * PAGE_SIZE + 1
461  *      4 -> 2^4 * PAGE_SIZE to 2^3 * PAGE_SIZE + 1
462  *      ...
463  *
464  * The order returned is used to find the smallest allocation granule required
465  * to hold an object of the specified size.
466  *
467  * The result is undefined if the size is 0.
468  *
469  * This function may be used to initialise variables with compile time
470  * evaluations of constants.
471  */
472 #define get_order(n)                                            \
473 (                                                               \
474         __builtin_constant_p(n) ? (                             \
475                 ((n) == 0UL) ? BITS_PER_LONG - PAGE_SHIFT :     \
476                 (((n) < (1UL << PAGE_SHIFT)) ? 0 :              \
477                  ilog2((n) - 1) - PAGE_SHIFT + 1)               \
478         ) :                                                     \
479         __get_order(n)                                          \
480 )
481
482 /* asm-generic/io.h */
483 static inline void __raw_writeq(uint64_t value, volatile void *addr)
484 {
485         *(volatile uint64_t *)addr = value;
486 }
487
488 /* linux/export.h */
489 #define EXPORT_SYMBOL_GPL(...)
490
491 /* linux/gfp.h */
492 /* These are all set to 0.  Silently passing flags to Akaros's memory allocator
493  * is dangerous - we could be turning on some Akaros feature that shares the
494  * same bit.
495  *
496  * Similarly, note that some Linux flags (__GFP_ZERO) is not here.  Those flags
497  * need to be dealt with.  Silently ignoring them will cause errors. */
498 #define  __GFP_DMA 0
499 #define  __GFP_HIGHMEM 0
500 #define  __GFP_DMA32 0
501 #define  __GFP_MOVABLE 0
502 #define  __GFP_WAIT 0
503 #define  __GFP_HIGH 0
504 #define  __GFP_IO 0
505 #define  __GFP_FS 0
506 #define  __GFP_COLD 0
507 #define  __GFP_NOWARN 0
508 #define  __GFP_REPEAT 0
509 #define  __GFP_NOFAIL 0
510 #define  __GFP_NORETRY 0
511 #define  __GFP_MEMALLOC 0
512 #define  __GFP_COMP 0
513 #define  __GFP_NOMEMALLOC 0
514 #define  __GFP_HARDWALL 0
515 #define  __GFP_THISNODE 0
516 #define  __GFP_RECLAIMABLE 0
517 #define  __GFP_NOACCOUNT 0
518 #define  __GFP_NOTRACK 0
519 #define  __GFP_NO_KSWAPD 0
520 #define  __GFP_OTHER_NODE 0
521 #define  __GFP_WRITE 0
522 #define GFP_HIGHUSER 0
523
524 /* linux/kernel.h */
525 #define min3(x, y, z) MIN((typeof(x))MIN(x, y), z)
526 #define max3(x, y, z) MAX((typeof(x))MAX(x, y), z)
527
528 typedef unsigned int pci_channel_state_t;
529
530 enum pci_channel_state {
531         /* I/O channel is in normal state */
532         pci_channel_io_normal = 1,
533
534         /* I/O to channel is blocked */
535         pci_channel_io_frozen = 2,
536
537         /* PCI card is dead */
538         pci_channel_io_perm_failure = 3,
539 };
540
541 typedef unsigned int pci_ers_result_t;
542
543 enum pci_ers_result {
544         /* no result/none/not supported in device driver */
545         PCI_ERS_RESULT_NONE = 1,
546
547         /* Device driver can recover without slot reset */
548         PCI_ERS_RESULT_CAN_RECOVER = 2,
549
550         /* Device driver wants slot to be reset. */
551         PCI_ERS_RESULT_NEED_RESET = 3,
552
553         /* Device has completely failed, is unrecoverable */
554         PCI_ERS_RESULT_DISCONNECT = 4,
555
556         /* Device driver is fully recovered and operational */
557         PCI_ERS_RESULT_RECOVERED = 5,
558
559         /* No AER capabilities registered for the driver */
560         PCI_ERS_RESULT_NO_AER_DRIVER = 6,
561 };
562
563 /* These values come from the PCI Express Spec */
564 enum pcie_link_width {
565         PCIE_LNK_WIDTH_RESRV    = 0x00,
566         PCIE_LNK_X1             = 0x01,
567         PCIE_LNK_X2             = 0x02,
568         PCIE_LNK_X4             = 0x04,
569         PCIE_LNK_X8             = 0x08,
570         PCIE_LNK_X12            = 0x0C,
571         PCIE_LNK_X16            = 0x10,
572         PCIE_LNK_X32            = 0x20,
573         PCIE_LNK_WIDTH_UNKNOWN  = 0xFF,
574 };
575
576 /* Based on the PCI Hotplug Spec, but some values are made up by us */
577 enum pci_bus_speed {
578         PCI_SPEED_33MHz                 = 0x00,
579         PCI_SPEED_66MHz                 = 0x01,
580         PCI_SPEED_66MHz_PCIX            = 0x02,
581         PCI_SPEED_100MHz_PCIX           = 0x03,
582         PCI_SPEED_133MHz_PCIX           = 0x04,
583         PCI_SPEED_66MHz_PCIX_ECC        = 0x05,
584         PCI_SPEED_100MHz_PCIX_ECC       = 0x06,
585         PCI_SPEED_133MHz_PCIX_ECC       = 0x07,
586         PCI_SPEED_66MHz_PCIX_266        = 0x09,
587         PCI_SPEED_100MHz_PCIX_266       = 0x0a,
588         PCI_SPEED_133MHz_PCIX_266       = 0x0b,
589         AGP_UNKNOWN                     = 0x0c,
590         AGP_1X                          = 0x0d,
591         AGP_2X                          = 0x0e,
592         AGP_4X                          = 0x0f,
593         AGP_8X                          = 0x10,
594         PCI_SPEED_66MHz_PCIX_533        = 0x11,
595         PCI_SPEED_100MHz_PCIX_533       = 0x12,
596         PCI_SPEED_133MHz_PCIX_533       = 0x13,
597         PCIE_SPEED_2_5GT                = 0x14,
598         PCIE_SPEED_5_0GT                = 0x15,
599         PCIE_SPEED_8_0GT                = 0x16,
600         PCI_SPEED_UNKNOWN               = 0xff,
601 };
602
603 /* linux/slab.h */
604 #define kzalloc_node(...) (0 /* XXX */)
605
606 #define __cpu_to_le32(x) (x)
607 #define __le32_to_cpu(x) (x)
608
609 #define swab32 __builtin_bswap32
610 #define swab16 __builtin_bswap16
611
612 #define cond_resched() { /* XXX */ \
613         volatile int i = 100000; \
614         /* printk("%s:%d %s cond_resched\n", __FILE__, __LINE__, __FUNCTION__); */ \
615         while (i--); \
616 }
617
618 #define iounmap(...) (0 /* XXX */)
619
620 typedef uint64_t phys_addr_t;
621 typedef phys_addr_t resource_size_t;
622
623 struct dma_pool *dma_pool_create(const char *name, void *dev,
624                                  size_t size, size_t align, size_t allocation);
625
626 void dma_pool_destroy(struct dma_pool *pool);
627
628 void *dma_pool_alloc(struct dma_pool *pool, int mem_flags, dma_addr_t *handle);
629
630 void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t addr);
631
632 #define pci_pool dma_pool
633 #define pci_pool_create(name, pdev, size, align, allocation) \
634                 dma_pool_create(name, pdev, size, align, allocation)
635 #define pci_pool_destroy(pool) dma_pool_destroy(pool)
636 #define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
637 #define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
638
639 #define __user
640 #define __bitwise
641
642 struct vm_area_struct {
643 };
644
645 /* uapi/rdma/ib_user_mad.h */
646 #define IB_USER_MAD_USER_RMPP 1
647
648 #define be16_to_cpup(p) be16_to_cpu(*(uint16_t *)(p))
649 #define be32_to_cpup(p) be32_to_cpu(*(uint32_t *)(p))
650
651 /* access_ok.h */
652
653 static inline uint16_t get_unaligned_le16(const void *p)
654 {
655         return le16_to_cpu(*(uint16_t *)p);
656 }
657
658 static inline uint32_t get_unaligned_le32(const void *p)
659 {
660         return le32_to_cpu(*(uint32_t *)p);
661 }
662
663 static inline uint64_t get_unaligned_le64(const void *p)
664 {
665         return le64_to_cpu(*(uint64_t *)p);
666 }
667
668 static inline void put_unaligned_le16(uint16_t val, void *p)
669 {
670         *((uint16_t *)p) = cpu_to_le16(val);
671 }
672
673 static inline void put_unaligned_le32(uint32_t val, void *p)
674 {
675         *((uint32_t *)p) = cpu_to_le32(val);
676 }
677
678 static inline void put_unaligned_le64(uint64_t val, void *p)
679 {
680         *((uint64_t *)p) = cpu_to_le64(val);
681 }
682
683 extern void __bad_unaligned_access_size(void);
684
685 #define __get_unaligned_le(ptr) ({ \
686         __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \
687         __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)), \
688         __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)), \
689         __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)), \
690         __bad_unaligned_access_size())))); \
691 })
692
693 #define __put_unaligned_le(val, ptr) ({                                 \
694         void *__gu_p = (ptr);                                           \
695         switch (sizeof(*(ptr))) {                                       \
696         case 1:                                                         \
697                 *(uint8_t *)__gu_p = (uint8_t)(val);                    \
698                 break;                                                  \
699         case 2:                                                         \
700                 put_unaligned_le16((uint16_t)(val), __gu_p);            \
701                 break;                                                  \
702         case 4:                                                         \
703                 put_unaligned_le32((uint32_t)(val), __gu_p);            \
704                 break;                                                  \
705         case 8:                                                         \
706                 put_unaligned_le64((uint64_t)(val), __gu_p);            \
707                 break;                                                  \
708         default:                                                        \
709                 __bad_unaligned_access_size();                          \
710                 break;                                                  \
711         }                                                               \
712         (void)0; })
713
714 #define get_unaligned __get_unaligned_le
715 #define put_unaligned __put_unaligned_le
716
717 #define vmalloc_node(...) (0 /* XXX */)
718 /* needed by icm.c: */
719 #define kmalloc_node(size, flags, node) kmalloc(size, flags)
720 #define alloc_pages_node(nid, gfp_mask, order) 0
721
722 struct scatterlist {
723         unsigned long   page_link;
724         unsigned int    offset;
725         unsigned int    length;
726         dma_addr_t      dma_address;
727 };
728
729 #define sg_dma_address(sg) ((sg)->dma_address)
730 #define sg_dma_len(sg) ((sg)->length)
731
732 #define sg_is_chain(sg) ((sg)->page_link & 0x01)
733 #define sg_is_last(sg) ((sg)->page_link & 0x02)
734 #define sg_chain_ptr(sg) ((struct scatterlist *) ((sg)->page_link & ~0x03))
735
736 static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
737 {
738         unsigned long page_link = sg->page_link & 0x3;
739         sg->page_link = page_link | (unsigned long) page;
740 }
741
742 /**
743  * sg_set_page - Set sg entry to point at given page
744  * @sg:          SG entry
745  * @page:        The page
746  * @len:         Length of data
747  * @offset:      Offset into page
748  *
749  * Description:
750  *   Use this function to set an sg entry pointing at a page, never assign
751  *   the page directly. We encode sg table information in the lower bits
752  *   of the page pointer. See sg_page() for looking up the page belonging
753  *   to an sg entry.
754  *
755  **/
756 static inline void sg_set_page(struct scatterlist *sg, struct page *page,
757                                unsigned int len, unsigned int offset)
758 {
759         sg_assign_page(sg, page);
760         sg->offset = offset;
761         sg->length = len;
762 }
763
764 static inline struct page *sg_page(struct scatterlist *sg)
765 {
766         return (struct page *)(sg->page_link & ~0x3);
767 }
768
769 static inline void sg_set_buf(struct scatterlist *sg, void *buf,
770                               unsigned int buflen)
771 {
772         sg_set_page(sg, kva2page(buf), buflen, PGOFF(buf));
773 }
774
775 #define for_each_sg(sglist, sg, nr, __i) \
776         for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg))
777
778 static inline void sg_mark_end(struct scatterlist *sg)
779 {
780         /*
781          * Set termination bit, clear potential chain bit
782          */
783         sg->page_link |= 0x02;
784         sg->page_link &= ~0x01;
785 }
786
787 void sg_init_table(struct scatterlist *, unsigned int);
788 struct scatterlist *sg_next(struct scatterlist *);
789
790 static inline int nontranslate_map_sg(void *dev, struct scatterlist *sglist,
791                                       int nelems, int dir)
792 {
793         int i;
794         struct scatterlist *sg;
795
796         for_each_sg(sglist, sg, nelems, i) {
797                 sg_dma_address(sg) = page2pa(sg_page(sg)) + sg->offset;
798                 sg_dma_len(sg) = sg->length;
799         }
800         return nelems;
801 }
802
803 static inline int dma_map_sg(void *dev, struct scatterlist *sg, int nents,
804                              enum dma_data_direction dir)
805 {
806         return nontranslate_map_sg(dev, sg, nents, dir);
807 }
808
809 static inline void dma_unmap_sg(void *dev, struct scatterlist *sg, int nents,
810                                 enum dma_data_direction dir)
811 {
812         /* TODO nop */
813 }
814
815 struct dma_attrs {
816 };
817
818 #define dma_map_sg_attrs(d, s, n, r, a) dma_map_sg(d, s, n, r)
819 #define dma_unmap_sg_attrs(d, s, n, r, a) dma_unmap_sg(d, s, n, r)
820
821 static inline int pci_map_sg(struct pci_device *pdev, struct scatterlist *sg,
822                              int nents, int direction)
823 {
824         return dma_map_sg(NULL, sg, nents, (enum dma_data_direction)direction);
825 }
826
827 static inline void pci_unmap_sg(struct pci_device *pdev, struct scatterlist *sg,
828                                 int nents, int direction)
829 {
830         dma_unmap_sg(NULL, sg, nents, (enum dma_data_direction)direction);
831 }
832
833 /* TODO: get this in an arch-dependent manner.  On x86, be careful of adjacent
834  * cacheline prefetching. */
835 #define cache_line_size() 64
836
837 static inline void *lowmem_page_address(struct page *page)
838 {
839         /* XXX not sure about this */
840         return page2kva(page);
841 }
842
843 #define page_address(page) lowmem_page_address(page)
844
845 #define netif_get_num_default_rss_queues() (8 /* FIXME */)
846
847 static inline void netdev_rss_key_fill(void *buffer, size_t len)
848 {
849         /* XXX */
850         memset(buffer, 0, len);
851 }
852
853 /* Hacked up version of Linux's.  Assuming reg's are implemented and
854  * read_config never fails. */
855 static int pcie_capability_read_dword(struct pci_device *dev, int pos,
856                                       uint32_t *val)
857 {
858         uint32_t pcie_cap;
859         *val = 0;
860         if (pos & 3)
861                 return -EINVAL;
862         if (pci_find_cap(dev, PCI_CAP_ID_EXP, &pcie_cap))
863                 return -EINVAL;
864         pci_read_config_dword(dev, pcie_cap + pos, val);
865         return 0;
866 }
867
868 static inline const char *pci_name(const struct pci_device *pdev)
869 {
870         return pdev->name;
871 }
872
873 #define dev_name(dev) ("ether0" /* XXX */)
874
875 #define pci_request_regions(...) (0 /* XXX */)
876 #define pci_save_state(...) (0 /* XXX */)
877 #define pci_set_consistent_dma_mask(...) (0 /* XXX */)
878 #define pci_set_dma_mask(...) (0 /* XXX */)
879 #define pci_channel_offline(...) (0 /* XXX */)
880 #define dma_set_max_seg_size(...) (0 /* XXX */)
881 #define dma_get_cache_alignment(...) (1 /* XXX */)
882 #define dev_to_node(...) (0 /* XXX */)
883 #define set_dev_node(...) /* TODO */
884 #define num_online_cpus() (1U /* XXX */)
885 #define cpu_to_node(cpu) ((void)(cpu),0)
886
887 #define pcie_get_minimum_link(dev, speed, width) ({ \
888         *(speed) = PCIE_SPEED_8_0GT; \
889         *(width) = PCIE_LNK_X8; \
890         0; })
891
892 static inline void get_random_bytes(char *buf, int nbytes)
893 {
894         // FIXME this is not random
895         for (int i = 0; i < nbytes; i++)
896                 buf[i] = i;
897 }
898
899 /* linux/moduleparam.h */
900 #define module_param_array(...)
901
902 #define ATOMIC_INIT(i) (i)
903
904 /* linux/pci_ids.h */
905 #define PCI_VENDOR_ID_MELLANOX          0x15b3
906
907 struct sysinfo {
908         long uptime;             /* Seconds since boot */
909         unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
910         unsigned long totalram;  /* Total usable main memory size */
911         unsigned long freeram;   /* Available memory size */
912         unsigned long sharedram; /* Amount of shared memory */
913         unsigned long bufferram; /* Memory used by buffers */
914         unsigned long totalswap; /* Total swap space size */
915         unsigned long freeswap;  /* swap space still available */
916         unsigned short procs;    /* Number of current processes */
917         unsigned long totalhigh; /* Total high memory size */
918         unsigned long freehigh;  /* Available high memory size */
919         unsigned int mem_unit;   /* Memory unit size in bytes */
920         char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
921 };
922
923 #define pci_pcie_cap(...) (0 /* TODO use pci_device->caps ? */)
924
925 #define NET_IP_ALIGN 2
926 #define ____cacheline_aligned_in_smp
927
928 typedef struct cpumask { } cpumask_t;
929 typedef struct cpumask cpumask_var_t[1];
930
931 #define cpumask_set_cpu(...) (0 /* TODO */)
932 #define zalloc_cpumask_var(...) (1 /* TODO */)
933 #define cpumask_local_spread(...) (0 /* TODO */)
934
935 struct notifier_block {
936 };
937
938 struct hwtstamp_config {
939         int flags;
940         int tx_type;
941         int rx_filter;
942 };
943
944 struct skb_shared_hwtstamps {
945 };
946
947 #define VLAN_N_VID 4096
948
949 /* linux/if_vlan.h */
950 #define VLAN_PRIO_SHIFT 13
951
952 /* linux/pci.h */
953 #define PCI_DMA_BIDIRECTIONAL   0
954 #define PCI_DMA_TODEVICE        1
955 #define PCI_DMA_FROMDEVICE      2
956 #define PCI_DMA_NONE            3
957
958 /* uapi/linux/net_tstamp.h */
959 enum hwtstamp_tx_types {
960         HWTSTAMP_TX_OFF,
961         HWTSTAMP_TX_ON,
962         HWTSTAMP_TX_ONESTEP_SYNC,
963 };
964
965 /* linux/skbuff.h */
966 enum {
967         SKBTX_HW_TSTAMP = 1 << 0,
968         SKBTX_SW_TSTAMP = 1 << 1,
969         SKBTX_IN_PROGRESS = 1 << 2,
970         SKBTX_DEV_ZEROCOPY = 1 << 3,
971         SKBTX_WIFI_STATUS = 1 << 4,
972         SKBTX_SHARED_FRAG = 1 << 5,
973         SKBTX_SCHED_TSTAMP = 1 << 6,
974         SKBTX_ACK_TSTAMP = 1 << 7,
975 };
976 #define CHECKSUM_NONE           0
977 #define CHECKSUM_UNNECESSARY    1
978 #define CHECKSUM_COMPLETE       2
979 #define CHECKSUM_PARTIAL        3
980
981 #define IPPROTO_IP 0
982 #define IPPROTO_ICMP 1
983 #define IPPROTO_TCP 6
984 #define IPPROTO_UDP 17
985 #define IPPROTO_GRE 47
986 #define IPPROTO_RAW 255
987
988 #define IFNAMSIZ 16
989 #define MAX_ADDR_LEN 32
990
991 /* linux/mmzone.h */
992 #define PAGE_ALLOC_COSTLY_ORDER 3
993
994 /* linux/cache.h */
995 #define L1_CACHE_BYTES (1 << L1_CACHE_SHIFT)
996 #define SMP_CACHE_BYTES L1_CACHE_BYTES
997
998 /* linux/if_vlan.h */
999 #define VLAN_HLEN 4
1000
1001 #define NETIF_F_RXFCS 0
1002
1003 #define irq_to_desc(irq) ({ /* I_AM_HERE; */ NULL; /* TODO */ })
1004
1005 static inline void eth_broadcast_addr(uint8_t *addr)
1006 {
1007         memset(addr, 0xff, Eaddrlen);
1008 }
1009
1010 #define BOND_LINK_FAIL 1
1011 #define BOND_LINK_UP 2
1012 #define BOND_MODE_8023AD 1
1013 #define BOND_MODE_ACTIVEBACKUP 2
1014 #define BOND_MODE_XOR 3
1015 #define BOND_STATE_BACKUP 0
1016 #define eth_validate_addr 0
1017 #define HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ 1
1018 #define HWTSTAMP_FILTER_PTP_V1_L4_EVENT 2
1019 #define HWTSTAMP_FILTER_PTP_V1_L4_SYNC 3
1020 #define HWTSTAMP_FILTER_PTP_V2_DELAY_REQ 4
1021 #define HWTSTAMP_FILTER_PTP_V2_EVENT 5
1022 #define HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ 6
1023 #define HWTSTAMP_FILTER_PTP_V2_L2_EVENT 7
1024 #define HWTSTAMP_FILTER_PTP_V2_L2_SYNC 8
1025 #define HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ 9
1026 #define HWTSTAMP_FILTER_PTP_V2_L4_EVENT 10
1027 #define HWTSTAMP_FILTER_PTP_V2_L4_SYNC 11
1028 #define HWTSTAMP_FILTER_PTP_V2_SYNC 12
1029 #define HWTSTAMP_FILTER_SOME 13
1030 #define HWTSTAMP_FILTER_ALL 14
1031 #define HWTSTAMP_FILTER_NONE 15
1032 #define IFF_ALLMULTI 1
1033 #define IFF_PROMISC 2
1034 #define IFF_UNICAST_FLT 3
1035 #define NETDEV_BONDING_INFO 0
1036 #define NETIF_F_HW_VLAN_CTAG_FILTER 1
1037 #define NETIF_F_NTUPLE 2
1038 #define NETIF_F_RXALL 3
1039 #define NOTIFY_DONE 0
1040 #define SIOCGHWTSTAMP 1
1041 #define SIOCSHWTSTAMP 2