PF_RING-5.6.0/drivers/PF_RING_aware/chelsio/cxgb3-2.0.0.1/src/t3_tom/tom_compat_2_6.h - vendor/opensource/pf_ring - Git at Google

 /*
  * Copyright (C) 2003-2009 Chelsio Communications.  All rights reserved.
  *
  * Written by Dimitris Michailidis (dm@chelsio.com),
  *	      Divy Le Ray (divy@chelsio.com)
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the LICENSE file included in this
  * release for licensing terms and conditions.
  */

 #ifndef __TOM_COMPAT_2_6_H
 #define __TOM_COMPAT_2_6_H

 #include <linux/version.h>
 #include <asm/tlbflush.h>
 #include <asm/pgtable.h>
 #include <linux/hugetlb.h>

 /* 2.6.9 */
 #if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,9)

 #ifndef DEFINE_MUTEX
 #define DEFINE_MUTEX	DECLARE_MUTEX
 #endif

 #ifndef ATOMIC_ADD_RETURN
 #if defined(CONFIG_X86_64)
 static __inline__ int atomic_add_return(int i, atomic_t *v)
 {
 	int __i = i;
 	__asm__ __volatile__(
 		LOCK "xaddl %0, %1;"
 		:"=r"(i)
 		:"m"(v->counter), "0"(i));
 	return i + __i;
 }

 #elif defined(CONFIG_X86)
 static __inline__ int atomic_add_return(int i, atomic_t *v)
 {
 	int __i;
 #ifdef CONFIG_M386
 	if(unlikely(boot_cpu_data.x86==3))
 		goto no_xadd;
 #endif
 	/* Modern 486+ processor */
 	__i = i;
 	__asm__ __volatile__(
 		LOCK "xaddl %0, %1;"
 		:"=r"(i)
 		:"m"(v->counter), "0"(i));
 	return i + __i;

 #ifdef CONFIG_M386
 no_xadd: /* Legacy 386 processor */
 	local_irq_disable();
 	__i = atomic_read(v);
 	atomic_set(v, i + __i);
 	local_irq_enable();
 	return i + __i;
 #endif
 }

 #elif defined(CONFIG_IA64)
 #define atomic_add_return(i,v)						\
 ({									\
 	int __ia64_aar_i = (i);						\
 	(__builtin_constant_p(i)					\
 	 && (   (__ia64_aar_i ==  1) || (__ia64_aar_i ==   4)		\
 	     || (__ia64_aar_i ==  8) || (__ia64_aar_i ==  16)		\
 	     || (__ia64_aar_i == -1) || (__ia64_aar_i ==  -4)		\
 	     || (__ia64_aar_i == -8) || (__ia64_aar_i == -16)))		\
 		? ia64_fetch_and_add(__ia64_aar_i, &(v)->counter)	\
 		: ia64_atomic_add(__ia64_aar_i, v);			\
 })
 #endif
 #endif /* ATOMIC_ADD_RETURN */

 #define ROUTE_REQ

 #define dst_mtu(dst) dst_metric(dst, RTAX_MTU)

 #define tcp_sock tcp_opt
 #define inet_sock inet_opt
 #define request_sock open_request

 #define inet_csk(sk) tcp_sk(sk)
 #define inet_csk_destroy_sock(sk) tcp_destroy_sock(sk)
 #define inet_csk_route_req(lsk, oreq) tcp_v4_route_req(lsk, oreq)

 #define inet_connection_sock tcp_opt
 #define icsk_bind_hash bind_hash
 #define icsk_af_ops af_specific
 #define icsk_ack ack
 #define icsk_pmtu_cookie pmtu_cookie
 #define inet_csk_reqsk_queue_removed tcp_synq_removed
 #define inet_csk_delete_keepalive_timer tcp_delete_keepalive_timer
 #define inet_csk_reqsk_queue_is_full tcp_synq_is_full
 #define inet_csk_reqsk_queue_add tcp_acceptq_queue
 #define icsk_retransmit_timer retransmit_timer
 #define inet_csk_reqsk_queue_added(sk, timeo) tcp_synq_added(sk)

 #define __reqsk_free tcp_openreq_fastfree
 #define tcp_rsk
 #define inet_rsk

 #define t3_inet_inherit_port(p_hashinfo, lsk, newsk) tcp_inherit_port(lsk, newsk)
 #define t3_inet_put_port(a, sk) tcp_put_port(sk)

 #define ACCEPT_QUEUE(sk) (&(tcp_sk(sk)->accept_queue))

 #define MSS_CLAMP(tp) ((tp)->mss_clamp)
 #define SND_WSCALE(tp) ((tp)->snd_wscale)
 #define RCV_WSCALE(tp) ((tp)->rcv_wscale)
 #define USER_MSS(tp) ((tp)->user_mss)
 #define TS_RECENT_STAMP(tp) ((tp)->ts_recent_stamp)
 #define WSCALE_OK(tp) ((tp)->wscale_ok)
 #define TSTAMP_OK(tp) ((tp)->tstamp_ok)
 #define SACK_OK(tp) ((tp)->sack_ok)

 #ifdef CONFIG_CHELSIO_T3_OFFLOAD_MODULE
 extern atomic_t tcp_orphan_count_offload;
 extern int ip_route_output_flow_offload(struct rtable **rp,
 					struct flowi *flp,
 					struct sock *sk, int flags);
 #define ip_route_output_flow ip_route_output_flow_offload
 extern void flush_tlb_page_offload(struct vm_area_struct *vma, unsigned long addr);
 #define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count_offload))
 #else
 #define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count))
 #endif

 #define SOCK_QUEUE_SHRUNK SOCK_TIMESTAMP

 /* Added TCP socket option */
 /* XXX Divy. Will we support it when the OS does not ? */

 #define __read_mostly
 struct request_sock_ops {
 	int		family;
 	int		obj_size;
 };

 /* Inet diag stuff. Added for compilation only */
 enum {
 	INET_DIAG_NONE,
 	INET_DIAG_MEMINFO,
 	INET_DIAG_INFO,
 	INET_DIAG_VEGASINFO,
 	INET_DIAG_CONG,
 };
 #define INET_DIAG_MAX INET_DIAG_CONG

 #define rsk_ops class
 #define RSK_OPS(rsk) (struct or_calltable *)(rsk)
 static inline void t3_init_rsk_ops(struct proto *t3_tcp_prot,
 				   struct request_sock_ops *t3_tcp_ops,
 				   struct proto *tcp_prot)
 {}

 /* TCP congestion stuff. Added for compilation only */
 #define TCP_CONGESTION	13	/* Congestion control algorithm */
 #define TCP_CA_NAME_MAX	16

 struct tcp_congestion_ops {
 	void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb);

 	char 		name[TCP_CA_NAME_MAX];
 	struct module 	*owner;
 };

 static inline void t3_set_ca_ops(struct sock *sk,
 				 struct tcp_congestion_ops *t_ops)
 {}

 static inline struct open_request *reqsk_alloc(struct request_sock_ops *rsk)
 {
 	struct open_request *oreq = tcp_openreq_alloc();

 	if (oreq)
 		oreq->class = (struct or_calltable *)rsk;

 	return oreq;
 }

 static inline void t3_set_req_addr(struct open_request *oreq,
 				   __u32 local_ip, __u32 peer_ip)
 {
 	oreq->af.v4_req.loc_addr = local_ip;
 	oreq->af.v4_req.rmt_addr = peer_ip;
 }

 static inline void t3_set_req_opt(struct open_request *oreq,
 				  struct ip_options *ip_opt)
 {
 }

 static inline void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
 {
 	__sk_dst_set(sk, dst);
 	tcp_v4_setup_caps(sk, dst);
 }

 static inline void setup_timer(struct timer_list * timer,
 				void (*function)(unsigned long),
 				unsigned long data)
 {
 	timer->function = function;
 	timer->data = data;
 	init_timer(timer);
 }

 extern int prepare_tom_for_offload(void);

 #if defined(CONFIG_T3_ZCOPY_SENDMSG) || defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
 # define t3_ptep_set_wrprotect(mm, address, ptep) ptep_set_wrprotect(ptep)
 #endif

 #elif LINUX_VERSION_CODE == KERNEL_VERSION(2,6,12)

 #define ROUTE_REQ

 #define request_sock open_request

 #define inet_csk(sk) tcp_sk(sk)

 #define inet_csk(sk) tcp_sk(sk)
 #define inet_csk_destroy_sock(sk) tcp_destroy_sock(sk)
 #define inet_csk_route_req(lsk, oreq) tcp_v4_route_req(lsk, oreq)

 #define inet_connection_sock tcp_sock
 #define icsk_bind_hash bind_hash
 #define icsk_af_ops af_specific
 #define icsk_ack ack
 #define icsk_pmtu_cookie pmtu_cookie
 #define inet_csk_reqsk_queue_removed tcp_synq_removed
 #define inet_csk_delete_keepalive_timer tcp_delete_keepalive_timer
 #define inet_csk_reqsk_queue_is_full tcp_synq_is_full
 #define inet_csk_reqsk_queue_add tcp_acceptq_queue
 #define icsk_retransmit_timer retransmit_timer
 #define inet_csk_reqsk_queue_added(sk, timeo) tcp_synq_added(sk)

 #define ACCEPT_QUEUE(sk) (&(tcp_sk(sk)->accept_queue))

 #define MSS_CLAMP(tp) ((tp)->rx_opt.mss_clamp)
 #define SND_WSCALE(tp) ((tp)->rx_opt.snd_wscale)
 #define RCV_WSCALE(tp) ((tp)->rx_opt.rcv_wscale)
 #define USER_MSS(tp) ((tp)->rx_opt.user_mss)
 #define TS_RECENT_STAMP(tp) ((tp)->rx_opt.ts_recent_stamp)
 #define WSCALE_OK(tp) ((tp)->rx_opt.wscale_ok)
 #define TSTAMP_OK(tp) ((tp)->rx_opt.tstamp_ok)
 #define SACK_OK(tp) ((tp)->rx_opt.sack_ok)

 #define __reqsk_free tcp_openreq_fastfree
 #define tcp_rsk
 #define inet_rsk

 #define t3_inet_inherit_port(p_hashinfo, lsk, newsk) tcp_inherit_port(lsk, newsk)
 #define t3_inet_put_port(a, sk) tcp_put_port(sk)

 #define __read_mostly
 struct request_sock_ops {
 	int		family;
 	int		obj_size;
 };


 #ifdef CONFIG_TCP_OFFLOAD_MODULE
 extern atomic_t tcp_orphan_count_offload;
 extern int ip_route_output_flow_offload(struct rtable **rp,
 					struct flowi *flp,
 					struct sock *sk, int flags);
 #define ip_route_output_flow ip_route_output_flow_offload
 extern void flush_tlb_page_offload(struct vm_area_struct *vma, unsigned long addr);
 #define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count_offload))
 #else
 #define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count))
 #endif

 #define rsk_ops class
 #define RSK_OPS(rsk) (struct or_calltable *)(rsk)
 static inline void t3_init_rsk_ops(struct proto *t3_tcp_prot,
 				   struct request_sock_ops *t3_tcp_ops,
 				   struct proto *tcp_prot)
 {}

 /* Inet diag stuff. Added for compilation only */
 enum {
 	INET_DIAG_NONE,
 	INET_DIAG_MEMINFO,
 	INET_DIAG_INFO,
 	INET_DIAG_VEGASINFO,
 	INET_DIAG_CONG,
 };
 #define INET_DIAG_MAX INET_DIAG_CONG

 /* TCP congestion stuff. Added for compilation only */
 #define TCP_CONGESTION	13	/* Congestion control algorithm */
 #define TCP_CA_NAME_MAX	16

 struct tcp_congestion_ops {
 	void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb);

 	char 		name[TCP_CA_NAME_MAX];
 	struct module 	*owner;
 };

 static inline void t3_set_ca_ops(struct sock *sk,
 				 struct tcp_congestion_ops *t_ops)
 {}

 static inline struct open_request *reqsk_alloc(struct request_sock_ops *rsk)
 {
 	struct open_request *oreq = tcp_openreq_alloc();

 	if (oreq)
 		oreq->class = (struct or_calltable *)rsk;

 	return oreq;
 }

 static inline void t3_set_req_addr(struct open_request *oreq,
 				   __u32 local_ip, __u32 peer_ip)
 {
 	oreq->af.v4_req.loc_addr = local_ip;
 	oreq->af.v4_req.rmt_addr = peer_ip;
 }

 static inline void t3_set_req_opt(struct open_request *oreq,
 				  struct ip_options *ip_opt)
 {
 }

 static inline void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
 {
 	__sk_dst_set(sk, dst);
 	tcp_v4_setup_caps(sk, dst);
 }

 #if defined(CONFIG_T3_ZCOPY_SENDMSG) || defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
 # define t3_ptep_set_wrprotect ptep_set_wrprotect
 #endif

 extern int prepare_tom_for_offload(void);

 /* 2.6.14 and above */
 #elif LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13)

 #include <linux/inet_diag.h>

 #define TCP_CONGESTION_CONTROL

 #define ACCEPT_QUEUE(sk) (&inet_csk(sk)->icsk_accept_queue.rskq_accept_head)

 #define MSS_CLAMP(tp) ((tp)->rx_opt.mss_clamp)
 #define SND_WSCALE(tp) ((tp)->rx_opt.snd_wscale)
 #define RCV_WSCALE(tp) ((tp)->rx_opt.rcv_wscale)
 #define USER_MSS(tp) ((tp)->rx_opt.user_mss)
 #define TS_RECENT_STAMP(tp) ((tp)->rx_opt.ts_recent_stamp)
 #define WSCALE_OK(tp) ((tp)->rx_opt.wscale_ok)
 #define TSTAMP_OK(tp) ((tp)->rx_opt.tstamp_ok)
 #define SACK_OK(tp) ((tp)->rx_opt.sack_ok)

 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
 #define INC_ORPHAN_COUNT(sk) percpu_counter_inc((sk)->sk_prot->orphan_count)
 #else
 #define INC_ORPHAN_COUNT(sk) atomic_inc((sk)->sk_prot->orphan_count)
 #endif

 #define route_req inet_csk_route_req

 #define RSK_OPS

 static inline void t3_init_rsk_ops(struct proto *t3_tcp_prot,
 				   struct request_sock_ops *t3_tcp_ops,
 				   struct proto *tcp_prot)
 {
 	memset(t3_tcp_ops, 0, sizeof(*t3_tcp_ops));
 	t3_tcp_ops->family = PF_INET;
 	t3_tcp_ops->obj_size = sizeof(struct tcp_request_sock);
 	t3_tcp_ops->slab = tcp_prot->rsk_prot->slab;
 	BUG_ON(!t3_tcp_ops->slab);

 	t3_tcp_prot->rsk_prot = t3_tcp_ops;
 }

 static inline void t3_set_ca_ops(struct sock *sk,
 				 struct tcp_congestion_ops *t_ops)
 {
 	inet_csk(sk)->icsk_ca_ops = t_ops;
 }

 static inline void t3_set_req_addr(struct request_sock *oreq,
 				   __u32 local_ip, __u32 peer_ip)
 {
 	inet_rsk(oreq)->loc_addr = local_ip;
 	inet_rsk(oreq)->rmt_addr = peer_ip;
 }

 static inline void t3_set_req_opt(struct request_sock *oreq,
 				  struct ip_options *ip_opt)
 {
 	inet_rsk(oreq)->opt = ip_opt;
 }

 extern int prepare_tom_for_offload(void);

 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,16)) && defined(CONFIG_COMPAT)
 # define TOM_CONFIG_COMPAT
 #endif

 #if defined(CONFIG_T3_ZCOPY_SENDMSG) || defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
 # define t3_ptep_set_wrprotect ptep_set_wrprotect
 extern void flush_tlb_page_offload(struct vm_area_struct *vma, unsigned long addr);
 extern void flush_tlb_mm_offload(struct mm_struct *mm);
 #endif

 #if defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
 #if defined(KALLSYMS_LOOKUP_NAME)
 #include <linux/kallsyms.h>
 #else
 static inline unsigned long kallsyms_lookup_name(const char *name)
 {
         return 0;
 }
 #endif /* KALLSYMS_LOOKUP_NAME */
 #endif

 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
 #define t3_inet_put_port(hash_info, sk) inet_put_port(sk)

 /* Are BHs disabled already? */
 static inline void t3_inet_inherit_port(struct inet_hashinfo *hash_info,
 					struct sock *lsk, struct sock *newsk)
 {
 	local_bh_disable();
 	__inet_inherit_port(lsk, newsk);
 	local_bh_enable();
 }
 #else
 #define t3_inet_put_port inet_put_port
 #define t3_inet_inherit_port inet_inherit_port
 #endif

 #endif /* 2.6.14 and above */

 struct ddp_gather_list;
 #if !defined(SKB_DST_SET)
 static inline struct dst_entry *skb_dst(const struct sk_buff *skb)
 {
 	return skb->dst;
 }

 static inline void skb_dst_set(struct sk_buff *skb,
 			       struct dst_entry *dst)
 {
 	skb->dst = dst;
 }

 static inline struct ddp_gather_list *skb_gl(const struct sk_buff *skb)
 {
 	return (struct ddp_gather_list *)skb->dst;
 }

 static inline void skb_gl_set(struct sk_buff *skb,
 			      struct ddp_gather_list *gl)
 {
 	skb->dst = (void *)gl;
 }

 static inline unsigned long skb_vaddr(const struct sk_buff *skb)
 {
 	return (unsigned long)skb->dst;
 }

 static inline void skb_vaddr_set(struct sk_buff *skb,
 				 unsigned long va)
 {
 	skb->dst = (void *)va;
 }
 #else
 static inline struct ddp_gather_list *skb_gl(const struct sk_buff *skb)
 {
 	return (struct ddp_gather_list *)skb_dst(skb);
 }

 static inline void skb_gl_set(struct sk_buff *skb,
 			      struct ddp_gather_list *gl)
 {
 	skb_dst_set(skb, (void *)gl);
 }

 static inline unsigned long skb_vaddr(const struct sk_buff *skb)
 {
 	return (unsigned long)skb_dst(skb);
 }

 static inline void skb_vaddr_set(struct sk_buff *skb,
 			      unsigned long va)
 {
 	skb_dst_set(skb, (void *)va);
 }

 #endif

 #if defined(NETDMA_IN_KERNEL) && !defined(IOAT_SOCK)
 static inline void tom_eat_skb(struct sock *sk, struct sk_buff *skb,
 			      int copied_early)
 {
 	skb_dst_set(skb, NULL);
 	sk_eat_skb(sk, skb, copied_early);
 }

 #else
 static inline void tom_eat_skb(struct sock *sk, struct sk_buff *skb,
 			      int copied_early)
 {
 	skb_dst_set(skb, NULL);
 	sk_eat_skb(sk, skb);
 }

 #endif

 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 #define DECLARE_TASK_FUNC(task, task_param) \
 	static void task(void *task_param)

 #define T3_INIT_WORK INIT_WORK

 #define WORK2TOMDATA(task_param, task) task_param

 #define T3_DECLARE_WORK(task, func, data) \
 	DECLARE_WORK(task, func, data)
 #else
 #define DECLARE_TASK_FUNC(task, task_param) \
         static void task(struct work_struct *task_param)

 #define WORK2TOMDATA(task_param, task) \
 	container_of(task_param, struct tom_data, task)

 #define T3_INIT_WORK(task_handler, task, adapter) \
         INIT_WORK(task_handler, task)

 #define T3_DECLARE_WORK(task, func, data) \
 	DECLARE_WORK(task, func)
 #endif

 #if defined(CONFIG_T3_ZCOPY_SENDMSG) || defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)

 /* Older kernels don't have a PUD; if that's the case, simply fold that level.
  */
 #ifndef PUD_SIZE
 # define pud_t			pgd_t
 # define pud_offset(pgd, addr)	(pgd)
 # define pud_none(pud)		0
 # define pud_bad(pud)		0
 # define pud_present(pud)	0
 #endif

 /* Unfortunately, flush_tlb_range() is not available on all platforms and
  * configurations and we must fall back to an implementation based on
  * flush_tlb_page(). Good thing that tlb flushing is in the exception path
  * only.
  */
 #if defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
 static inline void _t3_flush_tlb_range(struct vm_area_struct *vma,
                                        unsigned long start, unsigned long end)
 {
         for (; start < end; start += PAGE_SIZE)
                 flush_tlb_page_offload(vma, start);
 }
 #else
 static inline void _t3_flush_tlb_range(struct vm_area_struct *vma,
 				       unsigned long start, unsigned long end)
 {
 	for (; start < end; start += PAGE_SIZE)
 		flush_tlb_page(vma, start);
 }
 #endif

 #if defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)) && defined(CONFIG_64BIT)
 static inline void _t3_flush_tlb_mm(struct vm_area_struct *vma,
                                        unsigned long start, unsigned long end)
 {
 	flush_tlb_mm_offload(vma->vm_mm);
 }
 #else
 static inline void _t3_flush_tlb_mm(struct vm_area_struct *vma,
                                        unsigned long start, unsigned long end)
 {
 	flush_tlb_range(vma, start, end);
 }
 #endif

 #if defined(CONFIG_X86)
 # if !defined(CONFIG_SMP)
 #  define t3_flush_tlb_range flush_tlb_range
 # elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)) && defined(CONFIG_64BIT)
 #  define t3_flush_tlb_range _t3_flush_tlb_mm
 # else
 #  define t3_flush_tlb_range _t3_flush_tlb_range
 # endif
 #elif defined(CONFIG_PPC)
 # define t3_flush_tlb_range _t3_flush_tlb_range
 #else
 # define t3_flush_tlb_range flush_tlb_range
 #endif
 #if defined(CONFIG_T3_ZCOPY_HUGEPAGES)
 static __inline__ int zcopy_vma(struct vm_area_struct *vma) {
 	return !(vma->vm_flags & VM_SHARED);
 }
 #else
 static __inline__ int zcopy_vma(struct vm_area_struct *vma) {
 	return !((vma->vm_flags & VM_SHARED) || is_vm_hugetlb_page(vma));
 }
 #endif

 #if defined(CONFIG_T3_ZCOPY_HUGEPAGES) && defined(CONFIG_HUGETLB_PAGE)
 #if defined(CONFIG_IA64)
 static __inline__ pte_t *t3_huge_pte_offset (struct mm_struct *mm, unsigned long addr)
 {
         unsigned long taddr = htlbpage_to_page(addr);
         pgd_t *pgd;
         pud_t *pud;
         pmd_t *pmd;
         pte_t *pte = NULL;

         pgd = pgd_offset(mm, taddr);
         if (pgd_present(*pgd)) {
                 pud = pud_offset(pgd, taddr);
                 if (pud_present(*pud)) {
                         pmd = pmd_offset(pud, taddr);
                         if (pmd_present(*pmd))
                                 pte = pte_offset_map(pmd, taddr);
                 }
         }

         return pte;
 }
 #endif
 #if defined(CONFIG_X86) || defined(CONFIG_X86_64)
 static __inline__ pte_t *t3_huge_pte_offset(struct mm_struct *mm, unsigned long addr)
 {
         pgd_t *pgd;
         pud_t *pud;
         pmd_t *pmd = NULL;

         pgd = pgd_offset(mm, addr);
         if (pgd_present(*pgd)) {
                 pud = pud_offset(pgd, addr);
                 if (pud_present(*pud))
                         pmd = pmd_offset(pud, addr);
         }
         return (pte_t *) pmd;
 }
 #endif
 #endif
 #endif /* ZCOPY_SENDMSG */

 #ifndef KZALLOC
 static inline void *kzalloc(size_t size, int flags)
 {
 	void *ret = kmalloc(size, flags);
 	if (ret)
 		memset(ret, 0, size);
 	return ret;
 }
 #endif

 #define TCP_PAGE(sk)   (sk->sk_sndmsg_page)
 #define TCP_OFF(sk)    (sk->sk_sndmsg_off)

 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
 static inline void tom_sysctl_set_de(ctl_table *tbl)
 {
 	tbl->de = NULL;
 }
 #define tom_register_sysctl_table register_sysctl_table
 #else
 static inline void tom_sysctl_set_de(ctl_table *tbl)
 {}

 static inline struct ctl_table_header *tom_register_sysctl_table(ctl_table * table,
 						   int insert_at_head)
 {
 	return register_sysctl_table(table);
 }
 #endif

 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
 #define T3_TCP_INC_STATS_BH(net, field)	TCP_INC_STATS_BH(net, field)
 #define T3_NET_INC_STATS_BH(net, field) NET_INC_STATS_BH(net, field)
 #define T3_TCP_INC_STATS(net, field)	TCP_INC_STATS(net, field)
 #define T3_NET_INC_STATS_USER(net, field) NET_INC_STATS_USER(net, field)
 #define t3_type_compat void
 #define t3_pci_dma_mapping_error(p, a) pci_dma_mapping_error(p, a)
 #else
 #define T3_NET_INC_STATS_BH(net, field)	NET_INC_STATS_BH(field)
 #define T3_TCP_INC_STATS_BH(net, field) TCP_INC_STATS_BH(field)
 #define T3_TCP_INC_STATS(net, field)    TCP_INC_STATS(field)
 #define T3_NET_INC_STATS_USER(net, field) NET_INC_STATS_USER(field)
 #define t3_type_compat int
 #define t3_pci_dma_mapping_error(p, a) pci_dma_mapping_error(a)
 #endif

 #endif /* __TOM_COMPAT_2_6_H */
	/*
	* Copyright (C) 2003-2009 Chelsio Communications. All rights reserved.
	*
	* Written by Dimitris Michailidis (dm@chelsio.com),
	* Divy Le Ray (divy@chelsio.com)
	*
	* This program is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the LICENSE file included in this
	* release for licensing terms and conditions.
	*/

	#ifndef __TOM_COMPAT_2_6_H
	#define __TOM_COMPAT_2_6_H

	#include <linux/version.h>
	#include <asm/tlbflush.h>
	#include <asm/pgtable.h>
	#include <linux/hugetlb.h>

	/* 2.6.9 */
	#if LINUX_VERSION_CODE == KERNEL_VERSION(2,6,9)

	#ifndef DEFINE_MUTEX
	#define DEFINE_MUTEX DECLARE_MUTEX
	#endif

	#ifndef ATOMIC_ADD_RETURN
	#if defined(CONFIG_X86_64)
	static __inline__ int atomic_add_return(int i, atomic_t *v)
	{
	int __i = i;
	__asm__ __volatile__(
	LOCK "xaddl %0, %1;"
	:"=r"(i)
	:"m"(v->counter), "0"(i));
	return i + __i;
	}

	#elif defined(CONFIG_X86)
	static __inline__ int atomic_add_return(int i, atomic_t *v)
	{
	int __i;
	#ifdef CONFIG_M386
	if(unlikely(boot_cpu_data.x86==3))
	goto no_xadd;
	#endif
	/* Modern 486+ processor */
	__i = i;
	__asm__ __volatile__(
	LOCK "xaddl %0, %1;"
	:"=r"(i)
	:"m"(v->counter), "0"(i));
	return i + __i;

	#ifdef CONFIG_M386
	no_xadd: /* Legacy 386 processor */
	local_irq_disable();
	__i = atomic_read(v);
	atomic_set(v, i + __i);
	local_irq_enable();
	return i + __i;
	#endif
	}

	#elif defined(CONFIG_IA64)
	#define atomic_add_return(i,v) \
	({ \
	int __ia64_aar_i = (i); \
	(__builtin_constant_p(i) \
	&& ( (__ia64_aar_i == 1) \|\| (__ia64_aar_i == 4) \
	\|\| (__ia64_aar_i == 8) \|\| (__ia64_aar_i == 16) \
	\|\| (__ia64_aar_i == -1) \|\| (__ia64_aar_i == -4) \
	\|\| (__ia64_aar_i == -8) \|\| (__ia64_aar_i == -16))) \
	? ia64_fetch_and_add(__ia64_aar_i, &(v)->counter) \
	: ia64_atomic_add(__ia64_aar_i, v); \
	})
	#endif
	#endif /* ATOMIC_ADD_RETURN */

	#define ROUTE_REQ

	#define dst_mtu(dst) dst_metric(dst, RTAX_MTU)

	#define tcp_sock tcp_opt
	#define inet_sock inet_opt
	#define request_sock open_request

	#define inet_csk(sk) tcp_sk(sk)
	#define inet_csk_destroy_sock(sk) tcp_destroy_sock(sk)
	#define inet_csk_route_req(lsk, oreq) tcp_v4_route_req(lsk, oreq)

	#define inet_connection_sock tcp_opt
	#define icsk_bind_hash bind_hash
	#define icsk_af_ops af_specific
	#define icsk_ack ack
	#define icsk_pmtu_cookie pmtu_cookie
	#define inet_csk_reqsk_queue_removed tcp_synq_removed
	#define inet_csk_delete_keepalive_timer tcp_delete_keepalive_timer
	#define inet_csk_reqsk_queue_is_full tcp_synq_is_full
	#define inet_csk_reqsk_queue_add tcp_acceptq_queue
	#define icsk_retransmit_timer retransmit_timer
	#define inet_csk_reqsk_queue_added(sk, timeo) tcp_synq_added(sk)

	#define __reqsk_free tcp_openreq_fastfree
	#define tcp_rsk
	#define inet_rsk

	#define t3_inet_inherit_port(p_hashinfo, lsk, newsk) tcp_inherit_port(lsk, newsk)
	#define t3_inet_put_port(a, sk) tcp_put_port(sk)

	#define ACCEPT_QUEUE(sk) (&(tcp_sk(sk)->accept_queue))

	#define MSS_CLAMP(tp) ((tp)->mss_clamp)
	#define SND_WSCALE(tp) ((tp)->snd_wscale)
	#define RCV_WSCALE(tp) ((tp)->rcv_wscale)
	#define USER_MSS(tp) ((tp)->user_mss)
	#define TS_RECENT_STAMP(tp) ((tp)->ts_recent_stamp)
	#define WSCALE_OK(tp) ((tp)->wscale_ok)
	#define TSTAMP_OK(tp) ((tp)->tstamp_ok)
	#define SACK_OK(tp) ((tp)->sack_ok)

	#ifdef CONFIG_CHELSIO_T3_OFFLOAD_MODULE
	extern atomic_t tcp_orphan_count_offload;
	extern int ip_route_output_flow_offload(struct rtable **rp,
	struct flowi *flp,
	struct sock *sk, int flags);
	#define ip_route_output_flow ip_route_output_flow_offload
	extern void flush_tlb_page_offload(struct vm_area_struct *vma, unsigned long addr);
	#define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count_offload))
	#else
	#define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count))
	#endif

	#define SOCK_QUEUE_SHRUNK SOCK_TIMESTAMP

	/* Added TCP socket option */
	/* XXX Divy. Will we support it when the OS does not ? */

	#define __read_mostly
	struct request_sock_ops {
	int family;
	int obj_size;
	};

	/* Inet diag stuff. Added for compilation only */
	enum {
	INET_DIAG_NONE,
	INET_DIAG_MEMINFO,
	INET_DIAG_INFO,
	INET_DIAG_VEGASINFO,
	INET_DIAG_CONG,
	};
	#define INET_DIAG_MAX INET_DIAG_CONG

	#define rsk_ops class
	#define RSK_OPS(rsk) (struct or_calltable *)(rsk)
	static inline void t3_init_rsk_ops(struct proto *t3_tcp_prot,
	struct request_sock_ops *t3_tcp_ops,
	struct proto *tcp_prot)
	{}

	/* TCP congestion stuff. Added for compilation only */
	#define TCP_CONGESTION 13 /* Congestion control algorithm */
	#define TCP_CA_NAME_MAX 16

	struct tcp_congestion_ops {
	void (get_info)(struct sock sk, u32 ext, struct sk_buff *skb);

	char name[TCP_CA_NAME_MAX];
	struct module *owner;
	};

	static inline void t3_set_ca_ops(struct sock *sk,
	struct tcp_congestion_ops *t_ops)
	{}

	static inline struct open_request reqsk_alloc(struct request_sock_ops rsk)
	{
	struct open_request *oreq = tcp_openreq_alloc();

	if (oreq)
	oreq->class = (struct or_calltable *)rsk;

	return oreq;
	}

	static inline void t3_set_req_addr(struct open_request *oreq,
	__u32 local_ip, __u32 peer_ip)
	{
	oreq->af.v4_req.loc_addr = local_ip;
	oreq->af.v4_req.rmt_addr = peer_ip;
	}

	static inline void t3_set_req_opt(struct open_request *oreq,
	struct ip_options *ip_opt)
	{
	}

	static inline void sk_setup_caps(struct sock sk, struct dst_entry dst)
	{
	__sk_dst_set(sk, dst);
	tcp_v4_setup_caps(sk, dst);
	}

	static inline void setup_timer(struct timer_list * timer,
	void (*function)(unsigned long),
	unsigned long data)
	{
	timer->function = function;
	timer->data = data;
	init_timer(timer);
	}

	extern int prepare_tom_for_offload(void);

	#if defined(CONFIG_T3_ZCOPY_SENDMSG) \|\| defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
	# define t3_ptep_set_wrprotect(mm, address, ptep) ptep_set_wrprotect(ptep)
	#endif

	#elif LINUX_VERSION_CODE == KERNEL_VERSION(2,6,12)

	#define ROUTE_REQ

	#define request_sock open_request

	#define inet_csk(sk) tcp_sk(sk)

	#define inet_csk(sk) tcp_sk(sk)
	#define inet_csk_destroy_sock(sk) tcp_destroy_sock(sk)
	#define inet_csk_route_req(lsk, oreq) tcp_v4_route_req(lsk, oreq)

	#define inet_connection_sock tcp_sock
	#define icsk_bind_hash bind_hash
	#define icsk_af_ops af_specific
	#define icsk_ack ack
	#define icsk_pmtu_cookie pmtu_cookie
	#define inet_csk_reqsk_queue_removed tcp_synq_removed
	#define inet_csk_delete_keepalive_timer tcp_delete_keepalive_timer
	#define inet_csk_reqsk_queue_is_full tcp_synq_is_full
	#define inet_csk_reqsk_queue_add tcp_acceptq_queue
	#define icsk_retransmit_timer retransmit_timer
	#define inet_csk_reqsk_queue_added(sk, timeo) tcp_synq_added(sk)

	#define ACCEPT_QUEUE(sk) (&(tcp_sk(sk)->accept_queue))

	#define MSS_CLAMP(tp) ((tp)->rx_opt.mss_clamp)
	#define SND_WSCALE(tp) ((tp)->rx_opt.snd_wscale)
	#define RCV_WSCALE(tp) ((tp)->rx_opt.rcv_wscale)
	#define USER_MSS(tp) ((tp)->rx_opt.user_mss)
	#define TS_RECENT_STAMP(tp) ((tp)->rx_opt.ts_recent_stamp)
	#define WSCALE_OK(tp) ((tp)->rx_opt.wscale_ok)
	#define TSTAMP_OK(tp) ((tp)->rx_opt.tstamp_ok)
	#define SACK_OK(tp) ((tp)->rx_opt.sack_ok)

	#define __reqsk_free tcp_openreq_fastfree
	#define tcp_rsk
	#define inet_rsk

	#define t3_inet_inherit_port(p_hashinfo, lsk, newsk) tcp_inherit_port(lsk, newsk)
	#define t3_inet_put_port(a, sk) tcp_put_port(sk)

	#define __read_mostly
	struct request_sock_ops {
	int family;
	int obj_size;
	};


	#ifdef CONFIG_TCP_OFFLOAD_MODULE
	extern atomic_t tcp_orphan_count_offload;
	extern int ip_route_output_flow_offload(struct rtable **rp,
	struct flowi *flp,
	struct sock *sk, int flags);
	#define ip_route_output_flow ip_route_output_flow_offload
	extern void flush_tlb_page_offload(struct vm_area_struct *vma, unsigned long addr);
	#define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count_offload))
	#else
	#define INC_ORPHAN_COUNT(sk) (atomic_inc(&tcp_orphan_count))
	#endif

	#define rsk_ops class
	#define RSK_OPS(rsk) (struct or_calltable *)(rsk)
	static inline void t3_init_rsk_ops(struct proto *t3_tcp_prot,
	struct request_sock_ops *t3_tcp_ops,
	struct proto *tcp_prot)
	{}

	/* Inet diag stuff. Added for compilation only */
	enum {
	INET_DIAG_NONE,
	INET_DIAG_MEMINFO,
	INET_DIAG_INFO,
	INET_DIAG_VEGASINFO,
	INET_DIAG_CONG,
	};
	#define INET_DIAG_MAX INET_DIAG_CONG

	/* TCP congestion stuff. Added for compilation only */
	#define TCP_CONGESTION 13 /* Congestion control algorithm */
	#define TCP_CA_NAME_MAX 16

	struct tcp_congestion_ops {
	void (get_info)(struct sock sk, u32 ext, struct sk_buff *skb);

	char name[TCP_CA_NAME_MAX];
	struct module *owner;
	};

	static inline void t3_set_ca_ops(struct sock *sk,
	struct tcp_congestion_ops *t_ops)
	{}

	static inline struct open_request reqsk_alloc(struct request_sock_ops rsk)
	{
	struct open_request *oreq = tcp_openreq_alloc();

	if (oreq)
	oreq->class = (struct or_calltable *)rsk;

	return oreq;
	}

	static inline void t3_set_req_addr(struct open_request *oreq,
	__u32 local_ip, __u32 peer_ip)
	{
	oreq->af.v4_req.loc_addr = local_ip;
	oreq->af.v4_req.rmt_addr = peer_ip;
	}

	static inline void t3_set_req_opt(struct open_request *oreq,
	struct ip_options *ip_opt)
	{
	}

	static inline void sk_setup_caps(struct sock sk, struct dst_entry dst)
	{
	__sk_dst_set(sk, dst);
	tcp_v4_setup_caps(sk, dst);
	}

	#if defined(CONFIG_T3_ZCOPY_SENDMSG) \|\| defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
	# define t3_ptep_set_wrprotect ptep_set_wrprotect
	#endif

	extern int prepare_tom_for_offload(void);

	/* 2.6.14 and above */
	#elif LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13)

	#include <linux/inet_diag.h>

	#define TCP_CONGESTION_CONTROL

	#define ACCEPT_QUEUE(sk) (&inet_csk(sk)->icsk_accept_queue.rskq_accept_head)

	#define MSS_CLAMP(tp) ((tp)->rx_opt.mss_clamp)
	#define SND_WSCALE(tp) ((tp)->rx_opt.snd_wscale)
	#define RCV_WSCALE(tp) ((tp)->rx_opt.rcv_wscale)
	#define USER_MSS(tp) ((tp)->rx_opt.user_mss)
	#define TS_RECENT_STAMP(tp) ((tp)->rx_opt.ts_recent_stamp)
	#define WSCALE_OK(tp) ((tp)->rx_opt.wscale_ok)
	#define TSTAMP_OK(tp) ((tp)->rx_opt.tstamp_ok)
	#define SACK_OK(tp) ((tp)->rx_opt.sack_ok)

	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)
	#define INC_ORPHAN_COUNT(sk) percpu_counter_inc((sk)->sk_prot->orphan_count)
	#else
	#define INC_ORPHAN_COUNT(sk) atomic_inc((sk)->sk_prot->orphan_count)
	#endif

	#define route_req inet_csk_route_req

	#define RSK_OPS

	static inline void t3_init_rsk_ops(struct proto *t3_tcp_prot,
	struct request_sock_ops *t3_tcp_ops,
	struct proto *tcp_prot)
	{
	memset(t3_tcp_ops, 0, sizeof(*t3_tcp_ops));
	t3_tcp_ops->family = PF_INET;
	t3_tcp_ops->obj_size = sizeof(struct tcp_request_sock);
	t3_tcp_ops->slab = tcp_prot->rsk_prot->slab;
	BUG_ON(!t3_tcp_ops->slab);

	t3_tcp_prot->rsk_prot = t3_tcp_ops;
	}

	static inline void t3_set_ca_ops(struct sock *sk,
	struct tcp_congestion_ops *t_ops)
	{
	inet_csk(sk)->icsk_ca_ops = t_ops;
	}

	static inline void t3_set_req_addr(struct request_sock *oreq,
	__u32 local_ip, __u32 peer_ip)
	{
	inet_rsk(oreq)->loc_addr = local_ip;
	inet_rsk(oreq)->rmt_addr = peer_ip;
	}

	static inline void t3_set_req_opt(struct request_sock *oreq,
	struct ip_options *ip_opt)
	{
	inet_rsk(oreq)->opt = ip_opt;
	}

	extern int prepare_tom_for_offload(void);

	#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,16)) && defined(CONFIG_COMPAT)
	# define TOM_CONFIG_COMPAT
	#endif

	#if defined(CONFIG_T3_ZCOPY_SENDMSG) \|\| defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
	# define t3_ptep_set_wrprotect ptep_set_wrprotect
	extern void flush_tlb_page_offload(struct vm_area_struct *vma, unsigned long addr);
	extern void flush_tlb_mm_offload(struct mm_struct *mm);
	#endif

	#if defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
	#if defined(KALLSYMS_LOOKUP_NAME)
	#include <linux/kallsyms.h>
	#else
	static inline unsigned long kallsyms_lookup_name(const char *name)
	{
	return 0;
	}
	#endif /* KALLSYMS_LOOKUP_NAME */
	#endif

	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
	#define t3_inet_put_port(hash_info, sk) inet_put_port(sk)

	/* Are BHs disabled already? */
	static inline void t3_inet_inherit_port(struct inet_hashinfo *hash_info,
	struct sock lsk, struct sock newsk)
	{
	local_bh_disable();
	__inet_inherit_port(lsk, newsk);
	local_bh_enable();
	}
	#else
	#define t3_inet_put_port inet_put_port
	#define t3_inet_inherit_port inet_inherit_port
	#endif

	#endif /* 2.6.14 and above */

	struct ddp_gather_list;
	#if !defined(SKB_DST_SET)
	static inline struct dst_entry skb_dst(const struct sk_buff skb)
	{
	return skb->dst;
	}

	static inline void skb_dst_set(struct sk_buff *skb,
	struct dst_entry *dst)
	{
	skb->dst = dst;
	}

	static inline struct ddp_gather_list skb_gl(const struct sk_buff skb)
	{
	return (struct ddp_gather_list *)skb->dst;
	}

	static inline void skb_gl_set(struct sk_buff *skb,
	struct ddp_gather_list *gl)
	{
	skb->dst = (void *)gl;
	}

	static inline unsigned long skb_vaddr(const struct sk_buff *skb)
	{
	return (unsigned long)skb->dst;
	}

	static inline void skb_vaddr_set(struct sk_buff *skb,
	unsigned long va)
	{
	skb->dst = (void *)va;
	}
	#else
	static inline struct ddp_gather_list skb_gl(const struct sk_buff skb)
	{
	return (struct ddp_gather_list *)skb_dst(skb);
	}

	static inline void skb_gl_set(struct sk_buff *skb,
	struct ddp_gather_list *gl)
	{
	skb_dst_set(skb, (void *)gl);
	}

	static inline unsigned long skb_vaddr(const struct sk_buff *skb)
	{
	return (unsigned long)skb_dst(skb);
	}

	static inline void skb_vaddr_set(struct sk_buff *skb,
	unsigned long va)
	{
	skb_dst_set(skb, (void *)va);
	}

	#endif

	#if defined(NETDMA_IN_KERNEL) && !defined(IOAT_SOCK)
	static inline void tom_eat_skb(struct sock sk, struct sk_buff skb,
	int copied_early)
	{
	skb_dst_set(skb, NULL);
	sk_eat_skb(sk, skb, copied_early);
	}

	#else
	static inline void tom_eat_skb(struct sock sk, struct sk_buff skb,
	int copied_early)
	{
	skb_dst_set(skb, NULL);
	sk_eat_skb(sk, skb);
	}

	#endif

	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
	#define DECLARE_TASK_FUNC(task, task_param) \
	static void task(void *task_param)

	#define T3_INIT_WORK INIT_WORK

	#define WORK2TOMDATA(task_param, task) task_param

	#define T3_DECLARE_WORK(task, func, data) \
	DECLARE_WORK(task, func, data)
	#else
	#define DECLARE_TASK_FUNC(task, task_param) \
	static void task(struct work_struct *task_param)

	#define WORK2TOMDATA(task_param, task) \
	container_of(task_param, struct tom_data, task)

	#define T3_INIT_WORK(task_handler, task, adapter) \
	INIT_WORK(task_handler, task)

	#define T3_DECLARE_WORK(task, func, data) \
	DECLARE_WORK(task, func)
	#endif

	#if defined(CONFIG_T3_ZCOPY_SENDMSG) \|\| defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)

	/* Older kernels don't have a PUD; if that's the case, simply fold that level.
	*/
	#ifndef PUD_SIZE
	# define pud_t pgd_t
	# define pud_offset(pgd, addr) (pgd)
	# define pud_none(pud) 0
	# define pud_bad(pud) 0
	# define pud_present(pud) 0
	#endif

	/* Unfortunately, flush_tlb_range() is not available on all platforms and
	* configurations and we must fall back to an implementation based on
	* flush_tlb_page(). Good thing that tlb flushing is in the exception path
	* only.
	*/
	#if defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE)
	static inline void _t3_flush_tlb_range(struct vm_area_struct *vma,
	unsigned long start, unsigned long end)
	{
	for (; start < end; start += PAGE_SIZE)
	flush_tlb_page_offload(vma, start);
	}
	#else
	static inline void _t3_flush_tlb_range(struct vm_area_struct *vma,
	unsigned long start, unsigned long end)
	{
	for (; start < end; start += PAGE_SIZE)
	flush_tlb_page(vma, start);
	}
	#endif

	#if defined(CONFIG_T3_ZCOPY_SENDMSG_MODULE) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)) && defined(CONFIG_64BIT)
	static inline void _t3_flush_tlb_mm(struct vm_area_struct *vma,
	unsigned long start, unsigned long end)
	{
	flush_tlb_mm_offload(vma->vm_mm);
	}
	#else
	static inline void _t3_flush_tlb_mm(struct vm_area_struct *vma,
	unsigned long start, unsigned long end)
	{
	flush_tlb_range(vma, start, end);
	}
	#endif

	#if defined(CONFIG_X86)
	# if !defined(CONFIG_SMP)
	# define t3_flush_tlb_range flush_tlb_range
	# elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)) && defined(CONFIG_64BIT)
	# define t3_flush_tlb_range _t3_flush_tlb_mm
	# else
	# define t3_flush_tlb_range _t3_flush_tlb_range
	# endif
	#elif defined(CONFIG_PPC)
	# define t3_flush_tlb_range _t3_flush_tlb_range
	#else
	# define t3_flush_tlb_range flush_tlb_range
	#endif
	#if defined(CONFIG_T3_ZCOPY_HUGEPAGES)
	static __inline__ int zcopy_vma(struct vm_area_struct *vma) {
	return !(vma->vm_flags & VM_SHARED);
	}
	#else
	static __inline__ int zcopy_vma(struct vm_area_struct *vma) {
	return !((vma->vm_flags & VM_SHARED) \|\| is_vm_hugetlb_page(vma));
	}
	#endif

	#if defined(CONFIG_T3_ZCOPY_HUGEPAGES) && defined(CONFIG_HUGETLB_PAGE)
	#if defined(CONFIG_IA64)
	static __inline__ pte_t t3_huge_pte_offset (struct mm_struct mm, unsigned long addr)
	{
	unsigned long taddr = htlbpage_to_page(addr);
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd;
	pte_t *pte = NULL;

	pgd = pgd_offset(mm, taddr);
	if (pgd_present(*pgd)) {
	pud = pud_offset(pgd, taddr);
	if (pud_present(*pud)) {
	pmd = pmd_offset(pud, taddr);
	if (pmd_present(*pmd))
	pte = pte_offset_map(pmd, taddr);
	}
	}

	return pte;
	}
	#endif
	#if defined(CONFIG_X86) \|\| defined(CONFIG_X86_64)
	static __inline__ pte_t t3_huge_pte_offset(struct mm_struct mm, unsigned long addr)
	{
	pgd_t *pgd;
	pud_t *pud;
	pmd_t *pmd = NULL;

	pgd = pgd_offset(mm, addr);
	if (pgd_present(*pgd)) {
	pud = pud_offset(pgd, addr);
	if (pud_present(*pud))
	pmd = pmd_offset(pud, addr);
	}
	return (pte_t *) pmd;
	}
	#endif
	#endif
	#endif /* ZCOPY_SENDMSG */

	#ifndef KZALLOC
	static inline void *kzalloc(size_t size, int flags)
	{
	void *ret = kmalloc(size, flags);
	if (ret)
	memset(ret, 0, size);
	return ret;
	}
	#endif

	#define TCP_PAGE(sk) (sk->sk_sndmsg_page)
	#define TCP_OFF(sk) (sk->sk_sndmsg_off)

	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
	static inline void tom_sysctl_set_de(ctl_table *tbl)
	{
	tbl->de = NULL;
	}
	#define tom_register_sysctl_table register_sysctl_table
	#else
	static inline void tom_sysctl_set_de(ctl_table *tbl)
	{}

	static inline struct ctl_table_header tom_register_sysctl_table(ctl_table table,
	int insert_at_head)
	{
	return register_sysctl_table(table);
	}
	#endif

	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
	#define T3_TCP_INC_STATS_BH(net, field) TCP_INC_STATS_BH(net, field)
	#define T3_NET_INC_STATS_BH(net, field) NET_INC_STATS_BH(net, field)
	#define T3_TCP_INC_STATS(net, field) TCP_INC_STATS(net, field)
	#define T3_NET_INC_STATS_USER(net, field) NET_INC_STATS_USER(net, field)
	#define t3_type_compat void
	#define t3_pci_dma_mapping_error(p, a) pci_dma_mapping_error(p, a)
	#else
	#define T3_NET_INC_STATS_BH(net, field) NET_INC_STATS_BH(field)
	#define T3_TCP_INC_STATS_BH(net, field) TCP_INC_STATS_BH(field)
	#define T3_TCP_INC_STATS(net, field) TCP_INC_STATS(field)
	#define T3_NET_INC_STATS_USER(net, field) NET_INC_STATS_USER(field)
	#define t3_type_compat int
	#define t3_pci_dma_mapping_error(p, a) pci_dma_mapping_error(a)
	#endif

	#endif /* __TOM_COMPAT_2_6_H */