Deleted Added
sdiff udiff text old ( 280540 ) new ( 282513 )
full compact
linux_compat.c (280540) linux_compat.c (282513)
1/*-
2 * Copyright (c) 2010 Isilon Systems, Inc.
3 * Copyright (c) 2010 iX Systems, Inc.
4 * Copyright (c) 2010 Panasas, Inc.
5 * Copyright (c) 2013, 2014 Mellanox Technologies, Ltd.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 18 unchanged lines hidden (view full) ---

27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/malloc.h>
33#include <sys/kernel.h>
34#include <sys/sysctl.h>
1/*-
2 * Copyright (c) 2010 Isilon Systems, Inc.
3 * Copyright (c) 2010 iX Systems, Inc.
4 * Copyright (c) 2010 Panasas, Inc.
5 * Copyright (c) 2013, 2014 Mellanox Technologies, Ltd.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 18 unchanged lines hidden (view full) ---

27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/malloc.h>
33#include <sys/kernel.h>
34#include <sys/sysctl.h>
35#include <sys/proc.h>
36#include <sys/sleepqueue.h>
35#include <sys/lock.h>
36#include <sys/mutex.h>
37#include <sys/bus.h>
38#include <sys/fcntl.h>
39#include <sys/file.h>
40#include <sys/filio.h>
41#include <sys/rwlock.h>
42

--- 8 unchanged lines hidden (view full) ---

51#include <linux/slab.h>
52#include <linux/module.h>
53#include <linux/cdev.h>
54#include <linux/file.h>
55#include <linux/sysfs.h>
56#include <linux/mm.h>
57#include <linux/io.h>
58#include <linux/vmalloc.h>
37#include <sys/lock.h>
38#include <sys/mutex.h>
39#include <sys/bus.h>
40#include <sys/fcntl.h>
41#include <sys/file.h>
42#include <sys/filio.h>
43#include <sys/rwlock.h>
44

--- 8 unchanged lines hidden (view full) ---

53#include <linux/slab.h>
54#include <linux/module.h>
55#include <linux/cdev.h>
56#include <linux/file.h>
57#include <linux/sysfs.h>
58#include <linux/mm.h>
59#include <linux/io.h>
60#include <linux/vmalloc.h>
61#include <linux/timer.h>
62#include <linux/netdevice.h>
59
60#include <vm/vm_pager.h>
61
62MALLOC_DEFINE(M_KMALLOC, "linux", "Linux kmalloc compat");
63
64#include <linux/rbtree.h>
65/* Undo Linux compat changes. */
66#undef RB_ROOT
67#undef file
68#undef cdev
69#define RB_ROOT(head) (head)->rbh_root
63
64#include <vm/vm_pager.h>
65
66MALLOC_DEFINE(M_KMALLOC, "linux", "Linux kmalloc compat");
67
68#include <linux/rbtree.h>
69/* Undo Linux compat changes. */
70#undef RB_ROOT
71#undef file
72#undef cdev
73#define RB_ROOT(head) (head)->rbh_root
70#undef LIST_HEAD
71/* From sys/queue.h */
72#define LIST_HEAD(name, type) \
73struct name { \
74 struct type *lh_first; /* first element */ \
75}
76
77struct kobject class_root;
78struct device linux_rootdev;
79struct class miscclass;
80struct list_head pci_drivers;
81struct list_head pci_devices;
74
75struct kobject class_root;
76struct device linux_rootdev;
77struct class miscclass;
78struct list_head pci_drivers;
79struct list_head pci_devices;
80struct net init_net;
82spinlock_t pci_lock;
83
81spinlock_t pci_lock;
82
83unsigned long linux_timer_hz_mask;
84
84int
85panic_cmp(struct rb_node *one, struct rb_node *two)
86{
87 panic("no cmp");
88}
89
90RB_GENERATE(linux_root, rb_node, __entry, panic_cmp);
91

--- 500 unchanged lines hidden (view full) ---

592 * caller's idea of the map size to properly unmap.
593 */
594struct vmmap {
595 LIST_ENTRY(vmmap) vm_next;
596 void *vm_addr;
597 unsigned long vm_size;
598};
599
85int
86panic_cmp(struct rb_node *one, struct rb_node *two)
87{
88 panic("no cmp");
89}
90
91RB_GENERATE(linux_root, rb_node, __entry, panic_cmp);
92

--- 500 unchanged lines hidden (view full) ---

593 * caller's idea of the map size to properly unmap.
594 */
595struct vmmap {
596 LIST_ENTRY(vmmap) vm_next;
597 void *vm_addr;
598 unsigned long vm_size;
599};
600
600LIST_HEAD(vmmaphd, vmmap);
601struct vmmaphd {
602 struct vmmap *lh_first;
603};
601#define VMMAP_HASH_SIZE 64
602#define VMMAP_HASH_MASK (VMMAP_HASH_SIZE - 1)
603#define VM_HASH(addr) ((uintptr_t)(addr) >> PAGE_SHIFT) & VMMAP_HASH_MASK
604static struct vmmaphd vmmaphead[VMMAP_HASH_SIZE];
605static struct mtx vmmaplock;
606
607static void
608vmmap_add(void *addr, unsigned long size)

--- 74 unchanged lines hidden (view full) ---

683 vmmap = vmmap_remove(addr);
684 if (vmmap == NULL)
685 return;
686 pmap_qremove((vm_offset_t)addr, vmmap->vm_size / PAGE_SIZE);
687 kva_free((vm_offset_t)addr, vmmap->vm_size);
688 kfree(vmmap);
689}
690
604#define VMMAP_HASH_SIZE 64
605#define VMMAP_HASH_MASK (VMMAP_HASH_SIZE - 1)
606#define VM_HASH(addr) ((uintptr_t)(addr) >> PAGE_SHIFT) & VMMAP_HASH_MASK
607static struct vmmaphd vmmaphead[VMMAP_HASH_SIZE];
608static struct mtx vmmaplock;
609
610static void
611vmmap_add(void *addr, unsigned long size)

--- 74 unchanged lines hidden (view full) ---

686 vmmap = vmmap_remove(addr);
687 if (vmmap == NULL)
688 return;
689 pmap_qremove((vm_offset_t)addr, vmmap->vm_size / PAGE_SIZE);
690 kva_free((vm_offset_t)addr, vmmap->vm_size);
691 kfree(vmmap);
692}
693
694
695char *
696kasprintf(gfp_t gfp, const char *fmt, ...)
697{
698 va_list ap;
699 char *p;
700
701 va_start(ap, fmt);
702 p = kvasprintf(gfp, fmt, ap);
703 va_end(ap);
704
705 return p;
706}
707
708static int
709linux_timer_jiffies_until(unsigned long expires)
710{
711 int delta = expires - jiffies;
712 /* guard against already expired values */
713 if (delta < 1)
714 delta = 1;
715 return (delta);
716}
717
691static void
718static void
719linux_timer_callback_wrapper(void *context)
720{
721 struct timer_list *timer;
722
723 timer = context;
724 timer->function(timer->data);
725}
726
727void
728mod_timer(struct timer_list *timer, unsigned long expires)
729{
730
731 timer->expires = expires;
732 callout_reset(&timer->timer_callout,
733 linux_timer_jiffies_until(expires),
734 &linux_timer_callback_wrapper, timer);
735}
736
737void
738add_timer(struct timer_list *timer)
739{
740
741 callout_reset(&timer->timer_callout,
742 linux_timer_jiffies_until(timer->expires),
743 &linux_timer_callback_wrapper, timer);
744}
745
746static void
747linux_timer_init(void *arg)
748{
749
750 /*
751 * Compute an internal HZ value which can divide 2**32 to
752 * avoid timer rounding problems when the tick value wraps
753 * around 2**32:
754 */
755 linux_timer_hz_mask = 1;
756 while (linux_timer_hz_mask < (unsigned long)hz)
757 linux_timer_hz_mask *= 2;
758 linux_timer_hz_mask--;
759}
760SYSINIT(linux_timer, SI_SUB_DRIVERS, SI_ORDER_FIRST, linux_timer_init, NULL);
761
762void
763linux_complete_common(struct completion *c, int all)
764{
765 int wakeup_swapper;
766
767 sleepq_lock(c);
768 c->done++;
769 if (all)
770 wakeup_swapper = sleepq_broadcast(c, SLEEPQ_SLEEP, 0, 0);
771 else
772 wakeup_swapper = sleepq_signal(c, SLEEPQ_SLEEP, 0, 0);
773 sleepq_release(c);
774 if (wakeup_swapper)
775 kick_proc0();
776}
777
778/*
779 * Indefinite wait for done != 0 with or without signals.
780 */
781long
782linux_wait_for_common(struct completion *c, int flags)
783{
784
785 if (flags != 0)
786 flags = SLEEPQ_INTERRUPTIBLE | SLEEPQ_SLEEP;
787 else
788 flags = SLEEPQ_SLEEP;
789 for (;;) {
790 sleepq_lock(c);
791 if (c->done)
792 break;
793 sleepq_add(c, NULL, "completion", flags, 0);
794 if (flags & SLEEPQ_INTERRUPTIBLE) {
795 if (sleepq_wait_sig(c, 0) != 0)
796 return (-ERESTARTSYS);
797 } else
798 sleepq_wait(c, 0);
799 }
800 c->done--;
801 sleepq_release(c);
802
803 return (0);
804}
805
806/*
807 * Time limited wait for done != 0 with or without signals.
808 */
809long
810linux_wait_for_timeout_common(struct completion *c, long timeout, int flags)
811{
812 long end = jiffies + timeout;
813
814 if (flags != 0)
815 flags = SLEEPQ_INTERRUPTIBLE | SLEEPQ_SLEEP;
816 else
817 flags = SLEEPQ_SLEEP;
818 for (;;) {
819 int ret;
820
821 sleepq_lock(c);
822 if (c->done)
823 break;
824 sleepq_add(c, NULL, "completion", flags, 0);
825 sleepq_set_timeout(c, linux_timer_jiffies_until(end));
826 if (flags & SLEEPQ_INTERRUPTIBLE)
827 ret = sleepq_timedwait_sig(c, 0);
828 else
829 ret = sleepq_timedwait(c, 0);
830 if (ret != 0) {
831 /* check for timeout or signal */
832 if (ret == EWOULDBLOCK)
833 return (0);
834 else
835 return (-ERESTARTSYS);
836 }
837 }
838 c->done--;
839 sleepq_release(c);
840
841 /* return how many jiffies are left */
842 return (linux_timer_jiffies_until(end));
843}
844
845int
846linux_try_wait_for_completion(struct completion *c)
847{
848 int isdone;
849
850 isdone = 1;
851 sleepq_lock(c);
852 if (c->done)
853 c->done--;
854 else
855 isdone = 0;
856 sleepq_release(c);
857 return (isdone);
858}
859
860int
861linux_completion_done(struct completion *c)
862{
863 int isdone;
864
865 isdone = 1;
866 sleepq_lock(c);
867 if (c->done == 0)
868 isdone = 0;
869 sleepq_release(c);
870 return (isdone);
871}
872
873static void
692linux_compat_init(void *arg)
693{
694 struct sysctl_oid *rootoid;
695 int i;
696
697 rootoid = SYSCTL_ADD_NODE(NULL, SYSCTL_STATIC_CHILDREN(),
698 OID_AUTO, "sys", CTLFLAG_RD|CTLFLAG_MPSAFE, NULL, "sys");
699 kobject_init(&class_root, &class_ktype);

--- 29 unchanged lines hidden --- 		874linux_compat_init(void *arg)
875{
876 struct sysctl_oid *rootoid;
877 int i;
878
879 rootoid = SYSCTL_ADD_NODE(NULL, SYSCTL_STATIC_CHILDREN(),
880 OID_AUTO, "sys", CTLFLAG_RD|CTLFLAG_MPSAFE, NULL, "sys");
881 kobject_init(&class_root, &class_ktype);

--- 29 unchanged lines hidden ---