Remove mon_gfp()
[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 __printf(...)
120
121 #define sprintf(s, fmt, ...) ({ \
122         int ret = -1; \
123         if (__builtin_types_compatible_p(typeof(s), char[])) \
124                 ret = snprintf(s, sizeof(s), fmt, ##__VA_ARGS__); \
125         else \
126                 panic("Not implemented"); \
127         ret; \
128 })
129
130 #define printk_once(fmt, ...) ({ \
131         static bool __print_once; \
132         if (!__print_once) { \
133                 __print_once = true; \
134                 printk(fmt, ##__VA_ARGS__); \
135         } \
136 })
137
138 #define dev_warn(dev, format, ...) \
139         pr_warn(format, ## __VA_ARGS__)
140
141 #define dev_printk(level, dev, fmt, ...) \
142         printk(level fmt, ## __VA_ARGS__)
143
144 /* XXX This is not a tree. */
145 struct radix_tree_node {
146         struct list_head        linkage;
147         unsigned long           index;
148         void                    *item;
149 };
150
151 struct radix_tree_root {
152         struct list_head        hlinks;
153 };
154
155 static inline void INIT_RADIX_TREE(struct radix_tree_root *rp, int mask)
156 {
157         INIT_LIST_HEAD(&rp->hlinks);
158 }
159
160 static inline int radix_tree_insert(struct radix_tree_root *root,
161                                     unsigned long index, void *item)
162 {
163         struct list_head *lp = root->hlinks.next;
164         struct radix_tree_node *p;
165
166         while (lp != &root->hlinks) {
167                 p = (struct radix_tree_node *)lp;
168                 if (p->index == index)
169                         return -EEXIST;
170                 lp = lp->next;
171         }
172
173         p = kmalloc(sizeof(*p), MEM_WAIT);
174         if (!p)
175                 return -ENOMEM;
176         p->index = index;
177         p->item = item;
178         list_add(&p->linkage, &root->hlinks);
179         return 0;
180 }
181
182 static inline void *radix_tree_lookup(struct radix_tree_root *root,
183                                       unsigned long index)
184 {
185         struct list_head *lp = root->hlinks.next;
186         struct radix_tree_node *p;
187
188         while (lp != &root->hlinks) {
189                 p = (struct radix_tree_node *)lp;
190                 if (p->index == index)
191                         return p->item;
192                 lp = lp->next;
193         }
194
195         return NULL;
196 }
197
198 static inline void radix_tree_delete(struct radix_tree_root *root,
199                                       unsigned long index)
200 {
201         struct list_head *lp = root->hlinks.next;
202         struct radix_tree_node *p;
203
204         while (lp != &root->hlinks) {
205                 p = (struct radix_tree_node *)lp;
206                 if (p->index == index) {
207                         list_del(lp);
208                         return;
209                 }
210                 lp = lp->next;
211         }
212         panic("Node not found\n");
213 }
214
215 #define INIT_DEFERRABLE_WORK(_work, _func) \
216         INIT_DELAYED_WORK(_work, _func) /* XXX */
217
218 struct tasklet_struct {
219         uint32_t state;
220         void (*func)(unsigned long);
221         unsigned long data;
222 };
223
224 static void __tasklet_wrapper(uint32_t srcid, long a0, long a1, long a2)
225 {
226         struct tasklet_struct *t = (struct tasklet_struct *)a0;
227
228         if (atomic_cas_u32(&t->state, 1, 0))
229                 t->func(t->data);
230 }
231
232 static inline void tasklet_schedule(struct tasklet_struct *t)
233 {
234         if (atomic_cas_u32(&t->state, 0, 1)) {
235                 send_kernel_message(core_id(), __tasklet_wrapper, (long)t, 0, 0,
236                                     KMSG_ROUTINE);
237         }
238 }
239
240 static inline void tasklet_disable(struct tasklet_struct *t)
241 {
242         panic("tasklet_disable unimplemented");
243         // XXX t->state = 2
244 }
245
246 static inline void tasklet_init(struct tasklet_struct *t,
247                                 void (*func)(unsigned long), unsigned long data)
248 {
249         t->state = 0;
250         t->func = func;
251         t->data = data;
252 }
253
254 struct completion {
255         unsigned int done;
256 };
257
258 static inline void init_completion(struct completion *x)
259 {
260         x->done = 0;
261 }
262
263 static inline void reinit_completion(struct completion *x)
264 {
265         printd("Core %d: reinit_completion %p\n", core_id(), x);
266         x->done = 0;
267 }
268
269 static inline void complete(struct completion *x)
270 {
271         printd("Core %d: complete %p\n", core_id(), x);
272         x->done = 1;
273         wmb();
274 }
275
276 static inline void wait_for_completion(struct completion *x)
277 {
278         while (!x->done)
279                 rmb();
280 }
281
282 static inline unsigned long wait_for_completion_timeout(struct completion *x,
283                                                         unsigned long timeout)
284 {
285         printd("Core %d: wait_for_completion_timeout %p\n", core_id(), x);
286         while (!x->done) {
287                 if (timeout) {
288                         volatile int i = 100000;
289                         while (i--);
290                         timeout--;
291                         rmb();
292                 } else {
293                         break;
294                 }
295         }
296         return timeout;
297 }
298
299 struct timer_list {
300         spinlock_t lock;
301         bool scheduled;
302         unsigned long delay;
303         void (*function)(unsigned long);
304         unsigned long data;
305 };
306
307 static inline void init_timer(struct timer_list *timer)
308 {
309         spinlock_init_irqsave(&timer->lock);
310         timer->scheduled = false;
311         timer->delay = 0;
312         timer->function = 0;
313         timer->data = 0;
314 }
315
316 static void __timer_wrapper(uint32_t srcid, long a0, long a1, long a2)
317 {
318         struct timer_list *timer = (struct timer_list *)a0;
319         unsigned long delay = 0;
320
321         spin_lock_irqsave(&timer->lock);
322         delay = timer->delay;
323         timer->scheduled = false;
324         spin_unlock_irqsave(&timer->lock);
325
326         kthread_usleep(delay * 10000);
327         timer->function(timer->data);
328 }
329
330 static inline void add_timer(struct timer_list *timer)
331 {
332         timer->scheduled = true;
333         send_kernel_message(core_id(), __timer_wrapper, (long)timer, 0, 0,
334                             KMSG_ROUTINE);
335 }
336
337 static inline void mod_timer(struct timer_list *timer, unsigned long delay)
338 {
339         spin_lock_irqsave(&timer->lock);
340         timer->delay = delay;
341         if (timer->scheduled) {
342                 spin_unlock_irqsave(&timer->lock);
343                 return;
344         }
345         timer->scheduled = true;
346         spin_unlock_irqsave(&timer->lock);
347         send_kernel_message(core_id(), __timer_wrapper, (long)timer, 0, 0,
348                             KMSG_ROUTINE);
349 }
350
351 static inline void del_timer_sync(struct timer_list *timer)
352 {
353         panic("del_timer_sync unimplemented");
354 }
355
356 struct cpu_rmap {
357 };
358
359 extern unsigned long saved_max_pfn;
360
361 struct device {
362 };
363
364 struct device_attribute {
365 };
366
367 #define DEFINE_MUTEX(mutexname) \
368         qlock_t mutexname = QLOCK_INITIALIZER(mutexname);
369
370 #define IS_ENABLED(...) (0)
371
372 /* linux/compiler-gcc.h */
373 #define __packed                        __attribute__((packed))
374 #define __attribute_const__             __attribute__((__const__))
375 #define __aligned(n)                    __attribute__((aligned(n)))
376 #define __always_unused                 __attribute__((unused))
377
378 /*
379  * Check at compile time that something is of a particular type.
380  * Always evaluates to 1 so you may use it easily in comparisons.
381  */
382 #define typecheck(type,x) \
383 ({      type __dummy; \
384         typeof(x) __dummy2; \
385         (void)(&__dummy == &__dummy2); \
386         1; \
387 })
388
389 /*
390  * Check at compile time that 'function' is a certain type, or is a pointer
391  * to that type (needs to use typedef for the function type.)
392  */
393 #define typecheck_fn(type,function) \
394 ({      typeof(type) __tmp = function; \
395         (void)__tmp; \
396 })
397
398 #if BITS_PER_LONG > 32
399 #define NET_SKBUFF_DATA_USES_OFFSET 1
400 #endif
401
402 #ifdef NET_SKBUFF_DATA_USES_OFFSET
403 typedef unsigned int sk_buff_data_t;
404 #else
405 typedef unsigned char *sk_buff_data_t;
406 #endif
407
408 typedef struct skb_frag_struct skb_frag_t;
409
410 struct skb_frag_struct {
411         struct {
412                 struct page *p;
413         } page;
414 #if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
415         uint32_t page_offset;
416         uint32_t size;
417 #else
418         uint16_t page_offset;
419         uint16_t size;
420 #endif
421 };
422
423 /* asm-generic/getorder.h */
424 /*
425  * Runtime evaluation of get_order()
426  */
427 static inline __attribute_const__
428 int __get_order(unsigned long size)
429 {
430         int order;
431
432         size--;
433         size >>= PAGE_SHIFT;
434 #if BITS_PER_LONG == 32
435         order = fls(size);
436 #else
437         order = fls64(size);
438 #endif
439         return order;
440 }
441
442 /**
443  * get_order - Determine the allocation order of a memory size
444  * @size: The size for which to get the order
445  *
446  * Determine the allocation order of a particular sized block of memory.  This
447  * is on a logarithmic scale, where:
448  *
449  *      0 -> 2^0 * PAGE_SIZE and below
450  *      1 -> 2^1 * PAGE_SIZE to 2^0 * PAGE_SIZE + 1
451  *      2 -> 2^2 * PAGE_SIZE to 2^1 * PAGE_SIZE + 1
452  *      3 -> 2^3 * PAGE_SIZE to 2^2 * PAGE_SIZE + 1
453  *      4 -> 2^4 * PAGE_SIZE to 2^3 * PAGE_SIZE + 1
454  *      ...
455  *
456  * The order returned is used to find the smallest allocation granule required
457  * to hold an object of the specified size.
458  *
459  * The result is undefined if the size is 0.
460  *
461  * This function may be used to initialise variables with compile time
462  * evaluations of constants.
463  */
464 #define get_order(n)                                            \
465 (                                                               \
466         __builtin_constant_p(n) ? (                             \
467                 ((n) == 0UL) ? BITS_PER_LONG - PAGE_SHIFT :     \
468                 (((n) < (1UL << PAGE_SHIFT)) ? 0 :              \
469                  ilog2((n) - 1) - PAGE_SHIFT + 1)               \
470         ) :                                                     \
471         __get_order(n)                                          \
472 )
473
474 /* asm-generic/io.h */
475 static inline void __raw_writeq(uint64_t value, volatile void *addr)
476 {
477         *(volatile uint64_t *)addr = value;
478 }
479
480 /* linux/export.h */
481 #define EXPORT_SYMBOL_GPL(...)
482
483 /* linux/gfp.h */
484 #define  __GFP_DMA              0x01u
485 #define  __GFP_HIGHMEM          0x02u
486 #define  __GFP_DMA32            0x04u
487 #define  __GFP_MOVABLE          0x08u
488 #define  __GFP_WAIT             0x10u
489 #define  __GFP_HIGH             0x20u
490 #define  __GFP_IO               0x40u
491 #define  __GFP_FS               0x80u
492 #define  __GFP_COLD             0x100u
493 #define  __GFP_NOWARN           0x200u
494 #define  __GFP_REPEAT           0x400u
495 #define  __GFP_NOFAIL           0x800u
496 #define  __GFP_NORETRY          0x1000u
497 #define  __GFP_MEMALLOC         0x2000u
498 #define  __GFP_COMP             0x4000u
499 #define  __GFP_ZERO             0x8000u
500 #define  __GFP_NOMEMALLOC       0x10000u
501 #define  __GFP_HARDWALL         0x20000u
502 #define  __GFP_THISNODE         0x40000u
503 #define  __GFP_RECLAIMABLE      0x80000u
504 #define  __GFP_NOACCOUNT        0x100000u
505 #define  __GFP_NOTRACK          0x200000u
506 #define  __GFP_NO_KSWAPD        0x400000u
507 #define  __GFP_OTHER_NODE       0x800000u
508 #define  __GFP_WRITE            0x1000000u
509 /* If the above are modified, __GFP_BITS_SHIFT may need updating */
510
511 #define GFP_HIGHUSER 0
512
513 /* linux/kernel.h */
514 #define min3(x, y, z) MIN((typeof(x))MIN(x, y), z)
515 #define max3(x, y, z) MAX((typeof(x))MAX(x, y), z)
516
517 typedef unsigned int pci_channel_state_t;
518
519 enum pci_channel_state {
520         /* I/O channel is in normal state */
521         pci_channel_io_normal = 1,
522
523         /* I/O to channel is blocked */
524         pci_channel_io_frozen = 2,
525
526         /* PCI card is dead */
527         pci_channel_io_perm_failure = 3,
528 };
529
530 typedef unsigned int pci_ers_result_t;
531
532 enum pci_ers_result {
533         /* no result/none/not supported in device driver */
534         PCI_ERS_RESULT_NONE = 1,
535
536         /* Device driver can recover without slot reset */
537         PCI_ERS_RESULT_CAN_RECOVER = 2,
538
539         /* Device driver wants slot to be reset. */
540         PCI_ERS_RESULT_NEED_RESET = 3,
541
542         /* Device has completely failed, is unrecoverable */
543         PCI_ERS_RESULT_DISCONNECT = 4,
544
545         /* Device driver is fully recovered and operational */
546         PCI_ERS_RESULT_RECOVERED = 5,
547
548         /* No AER capabilities registered for the driver */
549         PCI_ERS_RESULT_NO_AER_DRIVER = 6,
550 };
551
552 /* These values come from the PCI Express Spec */
553 enum pcie_link_width {
554         PCIE_LNK_WIDTH_RESRV    = 0x00,
555         PCIE_LNK_X1             = 0x01,
556         PCIE_LNK_X2             = 0x02,
557         PCIE_LNK_X4             = 0x04,
558         PCIE_LNK_X8             = 0x08,
559         PCIE_LNK_X12            = 0x0C,
560         PCIE_LNK_X16            = 0x10,
561         PCIE_LNK_X32            = 0x20,
562         PCIE_LNK_WIDTH_UNKNOWN  = 0xFF,
563 };
564
565 /* Based on the PCI Hotplug Spec, but some values are made up by us */
566 enum pci_bus_speed {
567         PCI_SPEED_33MHz                 = 0x00,
568         PCI_SPEED_66MHz                 = 0x01,
569         PCI_SPEED_66MHz_PCIX            = 0x02,
570         PCI_SPEED_100MHz_PCIX           = 0x03,
571         PCI_SPEED_133MHz_PCIX           = 0x04,
572         PCI_SPEED_66MHz_PCIX_ECC        = 0x05,
573         PCI_SPEED_100MHz_PCIX_ECC       = 0x06,
574         PCI_SPEED_133MHz_PCIX_ECC       = 0x07,
575         PCI_SPEED_66MHz_PCIX_266        = 0x09,
576         PCI_SPEED_100MHz_PCIX_266       = 0x0a,
577         PCI_SPEED_133MHz_PCIX_266       = 0x0b,
578         AGP_UNKNOWN                     = 0x0c,
579         AGP_1X                          = 0x0d,
580         AGP_2X                          = 0x0e,
581         AGP_4X                          = 0x0f,
582         AGP_8X                          = 0x10,
583         PCI_SPEED_66MHz_PCIX_533        = 0x11,
584         PCI_SPEED_100MHz_PCIX_533       = 0x12,
585         PCI_SPEED_133MHz_PCIX_533       = 0x13,
586         PCIE_SPEED_2_5GT                = 0x14,
587         PCIE_SPEED_5_0GT                = 0x15,
588         PCIE_SPEED_8_0GT                = 0x16,
589         PCI_SPEED_UNKNOWN               = 0xff,
590 };
591
592 /* linux/slab.h */
593 #define kzalloc_node(...) (0 /* XXX */)
594
595 #define __cpu_to_le32(x) (x)
596 #define __le32_to_cpu(x) (x)
597
598 #define swab32 __builtin_bswap32
599
600 #define cond_resched() { /* XXX */ \
601         volatile int i = 100000; \
602         /* printk("%s:%d %s cond_resched\n", __FILE__, __LINE__, __FUNCTION__); */ \
603         while (i--); \
604 }
605
606 #define iounmap(...) (0 /* XXX */)
607
608 typedef uint64_t phys_addr_t;
609 typedef phys_addr_t resource_size_t;
610
611 struct dma_pool *dma_pool_create(const char *name, void *dev,
612                                  size_t size, size_t align, size_t allocation);
613
614 void dma_pool_destroy(struct dma_pool *pool);
615
616 void *dma_pool_alloc(struct dma_pool *pool, int mem_flags, dma_addr_t *handle);
617
618 void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t addr);
619
620 #define pci_pool dma_pool
621 #define pci_pool_create(name, pdev, size, align, allocation) \
622                 dma_pool_create(name, pdev, size, align, allocation)
623 #define pci_pool_destroy(pool) dma_pool_destroy(pool)
624 #define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
625 #define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
626
627 #define __user
628 #define __bitwise
629
630 struct vm_area_struct {
631 };
632
633 /* uapi/rdma/ib_user_mad.h */
634 #define IB_USER_MAD_USER_RMPP 1
635
636 #define be16_to_cpup(p) be16_to_cpu(*(uint16_t *)(p))
637 #define be32_to_cpup(p) be32_to_cpu(*(uint32_t *)(p))
638
639 /* access_ok.h */
640
641 static inline uint16_t get_unaligned_le16(const void *p)
642 {
643         return le16_to_cpu(*(uint16_t *)p);
644 }
645
646 static inline uint32_t get_unaligned_le32(const void *p)
647 {
648         return le32_to_cpu(*(uint32_t *)p);
649 }
650
651 static inline uint64_t get_unaligned_le64(const void *p)
652 {
653         return le64_to_cpu(*(uint64_t *)p);
654 }
655
656 static inline void put_unaligned_le16(uint16_t val, void *p)
657 {
658         *((uint16_t *)p) = cpu_to_le16(val);
659 }
660
661 static inline void put_unaligned_le32(uint32_t val, void *p)
662 {
663         *((uint32_t *)p) = cpu_to_le32(val);
664 }
665
666 static inline void put_unaligned_le64(uint64_t val, void *p)
667 {
668         *((uint64_t *)p) = cpu_to_le64(val);
669 }
670
671 extern void __bad_unaligned_access_size(void);
672
673 #define __get_unaligned_le(ptr) ({ \
674         __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \
675         __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)), \
676         __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)), \
677         __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)), \
678         __bad_unaligned_access_size())))); \
679 })
680
681 #define __put_unaligned_le(val, ptr) ({                                 \
682         void *__gu_p = (ptr);                                           \
683         switch (sizeof(*(ptr))) {                                       \
684         case 1:                                                         \
685                 *(uint8_t *)__gu_p = (uint8_t)(val);                    \
686                 break;                                                  \
687         case 2:                                                         \
688                 put_unaligned_le16((uint16_t)(val), __gu_p);            \
689                 break;                                                  \
690         case 4:                                                         \
691                 put_unaligned_le32((uint32_t)(val), __gu_p);            \
692                 break;                                                  \
693         case 8:                                                         \
694                 put_unaligned_le64((uint64_t)(val), __gu_p);            \
695                 break;                                                  \
696         default:                                                        \
697                 __bad_unaligned_access_size();                          \
698                 break;                                                  \
699         }                                                               \
700         (void)0; })
701
702 #define get_unaligned __get_unaligned_le
703 #define put_unaligned __put_unaligned_le
704
705 #define vmalloc_node(...) (0 /* XXX */)
706 /* needed by icm.c: */
707 #define kmalloc_node(size, flags, node) 0
708 #define alloc_pages_node(nid, gfp_mask, order) 0
709
710 struct scatterlist {
711         unsigned long   page_link;
712         unsigned int    offset;
713         unsigned int    length;
714         dma_addr_t      dma_address;
715 };
716
717 #define sg_dma_address(sg) ((sg)->dma_address)
718 #define sg_dma_len(sg) ((sg)->length)
719
720 #define sg_is_chain(sg) ((sg)->page_link & 0x01)
721 #define sg_is_last(sg) ((sg)->page_link & 0x02)
722 #define sg_chain_ptr(sg) ((struct scatterlist *) ((sg)->page_link & ~0x03))
723
724 static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
725 {
726         unsigned long page_link = sg->page_link & 0x3;
727         sg->page_link = page_link | (unsigned long) page;
728 }
729
730 /**
731  * sg_set_page - Set sg entry to point at given page
732  * @sg:          SG entry
733  * @page:        The page
734  * @len:         Length of data
735  * @offset:      Offset into page
736  *
737  * Description:
738  *   Use this function to set an sg entry pointing at a page, never assign
739  *   the page directly. We encode sg table information in the lower bits
740  *   of the page pointer. See sg_page() for looking up the page belonging
741  *   to an sg entry.
742  *
743  **/
744 static inline void sg_set_page(struct scatterlist *sg, struct page *page,
745                                unsigned int len, unsigned int offset)
746 {
747         sg_assign_page(sg, page);
748         sg->offset = offset;
749         sg->length = len;
750 }
751
752 static inline struct page *sg_page(struct scatterlist *sg)
753 {
754         return (struct page *)(sg->page_link & ~0x3);
755 }
756
757 static inline void sg_set_buf(struct scatterlist *sg, void *buf,
758                               unsigned int buflen)
759 {
760         sg_set_page(sg, kva2page(buf), buflen, PGOFF(buf));
761 }
762
763 #define for_each_sg(sglist, sg, nr, __i) \
764         for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg))
765
766 static inline void sg_mark_end(struct scatterlist *sg)
767 {
768         /*
769          * Set termination bit, clear potential chain bit
770          */
771         sg->page_link |= 0x02;
772         sg->page_link &= ~0x01;
773 }
774
775 void sg_init_table(struct scatterlist *, unsigned int);
776 struct scatterlist *sg_next(struct scatterlist *);
777
778 static inline int nontranslate_map_sg(void *dev, struct scatterlist *sglist,
779                                       int nelems, int dir)
780 {
781         int i;
782         struct scatterlist *sg;
783
784         for_each_sg(sglist, sg, nelems, i) {
785                 sg_dma_address(sg) = page2pa(sg_page(sg)) + sg->offset;
786                 sg_dma_len(sg) = sg->length;
787         }
788         return nelems;
789 }
790
791 static inline int dma_map_sg(void *dev, struct scatterlist *sg, int nents,
792                              enum dma_data_direction dir)
793 {
794         return nontranslate_map_sg(dev, sg, nents, dir);
795 }
796
797 static inline void dma_unmap_sg(void *dev, struct scatterlist *sg, int nents,
798                                 enum dma_data_direction dir)
799 {
800         /* TODO nop */
801 }
802
803 struct dma_attrs {
804 };
805
806 #define dma_map_sg_attrs(d, s, n, r, a) dma_map_sg(d, s, n, r)
807 #define dma_unmap_sg_attrs(d, s, n, r, a) dma_unmap_sg(d, s, n, r)
808
809 static inline int pci_map_sg(struct pci_device *pdev, struct scatterlist *sg,
810                              int nents, int direction)
811 {
812         return dma_map_sg(NULL, sg, nents, (enum dma_data_direction)direction);
813 }
814
815 static inline void pci_unmap_sg(struct pci_device *pdev, struct scatterlist *sg,
816                                 int nents, int direction)
817 {
818         dma_unmap_sg(NULL, sg, nents, (enum dma_data_direction)direction);
819 }
820
821 /* TODO: get this in an arch-dependent manner.  On x86, be careful of adjacent
822  * cacheline prefetching. */
823 #define cache_line_size() 64
824
825 static inline void *lowmem_page_address(struct page *page)
826 {
827         /* XXX not sure about this */
828         return page2kva(page);
829 }
830
831 #define page_address(page) lowmem_page_address(page)
832
833 #define netif_get_num_default_rss_queues() (8 /* FIXME */)
834
835 static inline void netdev_rss_key_fill(void *buffer, size_t len)
836 {
837         /* XXX */
838         memset(buffer, 0, len);
839 }
840
841 /* Hacked up version of Linux's.  Assuming reg's are implemented and
842  * read_config never fails. */
843 static int pcie_capability_read_dword(struct pci_device *dev, int pos,
844                                       uint32_t *val)
845 {
846         uint32_t pcie_cap;
847         *val = 0;
848         if (pos & 3)
849                 return -EINVAL;
850         if (pci_find_cap(dev, PCI_CAP_ID_EXP, &pcie_cap))
851                 return -EINVAL;
852         pci_read_config_dword(dev, pcie_cap + pos, val);
853         return 0;
854 }
855
856 static inline const char *pci_name(const struct pci_device *pdev)
857 {
858         return pdev->name;
859 }
860
861 #define dev_name(dev) ("ether0" /* XXX */)
862
863 #define pci_request_regions(...) (0 /* XXX */)
864 #define pci_save_state(...) (0 /* XXX */)
865 #define pci_set_consistent_dma_mask(...) (0 /* XXX */)
866 #define pci_set_dma_mask(...) (0 /* XXX */)
867 #define pci_channel_offline(...) (0 /* XXX */)
868 #define dma_set_max_seg_size(...) (0 /* XXX */)
869 #define dma_get_cache_alignment(...) (1 /* XXX */)
870 #define dev_to_node(...) (0 /* XXX */)
871 #define set_dev_node(...) /* TODO */
872 #define num_online_cpus() (1U /* XXX */)
873 #define cpu_to_node(cpu) ((void)(cpu),0)
874
875 #define pcie_get_minimum_link(dev, speed, width) ({ \
876         *(speed) = PCIE_SPEED_8_0GT; \
877         *(width) = PCIE_LNK_X8; \
878         0; })
879
880 static inline void get_random_bytes(char *buf, int nbytes)
881 {
882         // FIXME this is not random
883         for (int i = 0; i < nbytes; i++)
884                 buf[i] = i;
885 }
886
887 /* linux/moduleparam.h */
888 #define module_param_array(...)
889
890 #define ATOMIC_INIT(i) (i)
891
892 /* linux/ioport.h */
893 #define IORESOURCE_MEM          0x00000200
894
895 /* linux/pci_ids.h */
896 #define PCI_VENDOR_ID_MELLANOX          0x15b3
897
898 struct sysinfo {
899         long uptime;             /* Seconds since boot */
900         unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
901         unsigned long totalram;  /* Total usable main memory size */
902         unsigned long freeram;   /* Available memory size */
903         unsigned long sharedram; /* Amount of shared memory */
904         unsigned long bufferram; /* Memory used by buffers */
905         unsigned long totalswap; /* Total swap space size */
906         unsigned long freeswap;  /* swap space still available */
907         unsigned short procs;    /* Number of current processes */
908         unsigned long totalhigh; /* Total high memory size */
909         unsigned long freehigh;  /* Available high memory size */
910         unsigned int mem_unit;   /* Memory unit size in bytes */
911         char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
912 };
913
914 #define pci_pcie_cap(...) (0 /* TODO use pci_device->caps ? */)
915
916 #define NET_IP_ALIGN 2
917 #define ____cacheline_aligned_in_smp
918
919 typedef struct cpumask { } cpumask_t;
920 typedef struct cpumask cpumask_var_t[1];
921
922 #define cpumask_set_cpu(...) (0 /* TODO */)
923 #define zalloc_cpumask_var(...) (1 /* TODO */)
924 #define cpumask_local_spread(...) (0 /* TODO */)
925
926 struct notifier_block {
927 };
928
929 struct net_device_stats {
930         unsigned long tx_dropped;
931         unsigned long rx_dropped;
932 };
933
934 struct hwtstamp_config {
935         int flags;
936         int tx_type;
937         int rx_filter;
938 };
939
940 struct skb_shared_hwtstamps {
941 };
942
943 #define VLAN_N_VID 4096
944
945 /* linux/if_vlan.h */
946 #define VLAN_PRIO_SHIFT 13
947
948 /* linux/pci.h */
949 #define PCI_DMA_BIDIRECTIONAL   0
950 #define PCI_DMA_TODEVICE        1
951 #define PCI_DMA_FROMDEVICE      2
952 #define PCI_DMA_NONE            3
953
954 /* uapi/linux/net_tstamp.h */
955 enum hwtstamp_tx_types {
956         HWTSTAMP_TX_OFF,
957         HWTSTAMP_TX_ON,
958         HWTSTAMP_TX_ONESTEP_SYNC,
959 };
960
961 /* linux/skbuff.h */
962 enum {
963         SKBTX_HW_TSTAMP = 1 << 0,
964         SKBTX_SW_TSTAMP = 1 << 1,
965         SKBTX_IN_PROGRESS = 1 << 2,
966         SKBTX_DEV_ZEROCOPY = 1 << 3,
967         SKBTX_WIFI_STATUS = 1 << 4,
968         SKBTX_SHARED_FRAG = 1 << 5,
969         SKBTX_SCHED_TSTAMP = 1 << 6,
970         SKBTX_ACK_TSTAMP = 1 << 7,
971 };
972 #define CHECKSUM_NONE           0
973 #define CHECKSUM_UNNECESSARY    1
974 #define CHECKSUM_COMPLETE       2
975 #define CHECKSUM_PARTIAL        3
976
977 #define IPPROTO_IP 0
978 #define IPPROTO_ICMP 1
979 #define IPPROTO_TCP 6
980 #define IPPROTO_UDP 17
981 #define IPPROTO_GRE 47
982
983 #define IFNAMSIZ 16
984 #define MAX_ADDR_LEN 32
985
986 /* linux/mmzone.h */
987 #define PAGE_ALLOC_COSTLY_ORDER 3
988
989 /* linux/cache.h */
990 #define L1_CACHE_BYTES (1 << L1_CACHE_SHIFT)
991 #define SMP_CACHE_BYTES L1_CACHE_BYTES
992
993 /* linux/if_vlan.h */
994 #define VLAN_HLEN 4
995
996 #define NETIF_F_RXFCS 0
997
998 #define irq_to_desc(irq) ({ /* I_AM_HERE; */ NULL; /* TODO */ })
999
1000 static inline void eth_broadcast_addr(uint8_t *addr)
1001 {
1002         memset(addr, 0xff, Eaddrlen);
1003 }
1004
1005 static inline bool netif_carrier_ok(struct ether *dev)
1006 {
1007         return true; // XXX
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