diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/bitops.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/bitops.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/bitops.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/bitops.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,12 @@ +#ifndef BACKPORT_ASM_BITOPS_H +#define BACKPORT_ASM_BITOPS_H + +#include_next + +static inline void clear_bit_unlock(unsigned long nr, volatile unsigned long *addr) +{ + barrier(); + clear_bit(nr, addr); +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/prom.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/prom.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/prom.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/prom.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef ASM_PROM_BACKPORT_TO_2_6_21_H +#define ASM_PROM_BACKPORT_TO_2_6_21_H + +#include_next + +#define of_get_property(a, b, c) get_property((a), (b), (c)) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/scatterlist.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/scatterlist.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/scatterlist.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/scatterlist.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,5 @@ +#if defined(__ia64__) +#include +#endif +#include +#include_next diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/unaligned.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/unaligned.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/unaligned.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm/unaligned.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,7 @@ +#ifndef ASM_UNALIGNED_BACKPORT_TO_2_6_27_H +#define ASM_UNALIGNED_BACKPORT_TO_2_6_27_H + +#include +#include_next + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm-generic/atomic.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm-generic/atomic.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm-generic/atomic.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/asm-generic/atomic.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,40 @@ +#ifndef __BACKPORT_ASM_GENERIC_ATOMIC_H +#define __BACKPORT_ASM_GENERIC_ATOMIC_H + +#include_next + +#if BITS_PER_LONG == 64 + +static inline long atomic_long_inc_return(atomic_long_t *l) +{ + atomic64_t *v = (atomic64_t *)l; + + return (long)atomic64_inc_return(v); +} + +static inline long atomic_long_dec_return(atomic_long_t *l) +{ + atomic64_t *v = (atomic64_t *)l; + + return (long)atomic64_dec_return(v); +} + +#else + +static inline long atomic_long_inc_return(atomic_long_t *l) +{ + atomic_t *v = (atomic_t *)l; + + return (long)atomic_inc_return(v); +} + +static inline long atomic_long_dec_return(atomic_long_t *l) +{ + atomic_t *v = (atomic_t *)l; + + return (long)atomic_dec_return(v); +} + +#endif /* BITS_PER_LONG == 64 */ + +#endif /* __BACKPORT_ASM_GENERIC_ATOMIC_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/backing-dev.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/backing-dev.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/backing-dev.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/backing-dev.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,67 @@ +#ifndef BACKPORT_LINUX_BACK_DEV_H +#define BACKPORT_LINUX_BACK_DEV_H + +#include_next + +enum bdi_stat_item { + BDI_RECLAIMABLE, + BDI_WRITEBACK, + NR_BDI_STAT_ITEMS +}; + + +static inline void inc_bdi_stat(struct backing_dev_info *bdi, + enum bdi_stat_item item) +{ + return; +} + +static inline void __dec_bdi_stat(struct backing_dev_info *bdi, + enum bdi_stat_item item) +{ + return; +} + +static inline void dec_bdi_stat(struct backing_dev_info *bdi, + enum bdi_stat_item item) +{ + return; +} + +static inline int bdi_init(struct backing_dev_info *bdi) +{ + return 0; +} + +static inline void bdi_destroy(struct backing_dev_info *bdi) +{ + return; +} + +static inline int bdi_register(struct backing_dev_info *bdi, struct device *parent, + const char *fmt, ...) +{ + return 0; +} + +static inline int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev) +{ + return bdi_register(bdi, NULL, "%u:%u", MAJOR(dev), MINOR(dev)); +} + +static inline void bdi_unregister(struct backing_dev_info *bdi) +{ + return; +} + +static inline void clear_bdi_congested(struct backing_dev_info *bdi, int rw) +{ + return; +} + +static inline void set_bdi_congested(struct backing_dev_info *bdi, int rw) +{ + return; +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/capability.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/capability.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/capability.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/capability.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,39 @@ +#ifndef BACKPORT_LINUX_CAPABILITY_H +#define BACKPORT_LINUX_CAPABILITY_H + +#include_next + +/* Override MAC access. + The base kernel enforces no MAC policy. + An LSM may enforce a MAC policy, and if it does and it chooses + to implement capability based overrides of that policy, this is + the capability it should use to do so. */ + +#define CAP_MAC_OVERRIDE 32 + +#define CAP_FS_MASK_B0 (CAP_TO_MASK(CAP_CHOWN) \ + | CAP_TO_MASK(CAP_DAC_OVERRIDE) \ + | CAP_TO_MASK(CAP_DAC_READ_SEARCH) \ + | CAP_TO_MASK(CAP_FOWNER) \ + | CAP_TO_MASK(CAP_FSETID)) + +#define CAP_FS_MASK_B1 (CAP_TO_MASK(CAP_MAC_OVERRIDE)) + +#define CAP_NFSD_SET (CAP_FS_MASK_B0|CAP_TO_MASK(CAP_SYS_RESOURCE)) +#define CAP_FS_SET (CAP_FS_MASK_B0) + +static inline kernel_cap_t cap_raise_nfsd_set(const kernel_cap_t a, + const kernel_cap_t permitted) +{ + const kernel_cap_t __cap_nfsd_set = CAP_NFSD_SET; + return cap_combine(a, + cap_intersect(permitted, __cap_nfsd_set)); +} + +static inline kernel_cap_t cap_drop_nfsd_set(const kernel_cap_t a) +{ + const kernel_cap_t __cap_fs_set = CAP_NFSD_SET; + return cap_drop(a, __cap_fs_set); +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/compiler.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/compiler.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/compiler.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/compiler.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,12 @@ +#ifndef BACKPORT_LINUX_COMPILER_TO_2_6_22_H +#define BACKPORT_LINUX_COMPILER_TO_2_6_22_H + +#include_next + +#define uninitialized_var(x) x = x + +#ifndef __maybe_unused +# define __maybe_unused /* unimplemented */ +#endif + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/completion.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/completion.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/completion.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/completion.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef BACKPORT_LINUX_COMPLETION_H +#define BACKPORT_LINUX_COMPLETION_H + +#include_next + +#define wait_for_completion_killable(_args) wait_for_completion_interruptible(_args) + +#endif /* BACKPORT_LINUX_COMPLETION_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/cpumask.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/cpumask.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/cpumask.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/cpumask.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,11 @@ +#ifndef BACKPORT_LINUX_CPUMASK_H +#define BACKPORT_LINUX_CPUMASK_H + +#include_next + +#define cpumask_of(cpu) (cpumask_of_cpu(cpu)) +#define cpumask_of_node(node) (node_to_cpumask(node)) +#define nr_node_ids (highest_possible_processor_id() + 1) +#define nr_cpu_ids (highest_possible_processor_id() + 1) + +#endif /* BACKPORT_LINUX_CPUMASK_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/cred.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/cred.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/cred.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/cred.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,11 @@ +#ifndef BACKPORT_LINUX_CRED_H +#define BACKPORT_LINUX_CRED_H + +#define current_cred_xxx(xxx) \ +({ \ + current->xxx; \ +}) + +#define current_fsuid() (current_cred_xxx(fsuid)) + +#endif /* BACKPORT_LINUX_CRED_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/crypto.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/crypto.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/crypto.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/crypto.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,9 @@ +#ifndef BACKPORT_LINUX_CRYPTO_H +#define BACKPORT_LINUX_CRYPTO_H + +#include_next +#include + +#define CRYPTO_ALG_ASYNC NCRYPTO_ALG_ASYNC + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/device.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/device.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/device.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/device.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,18 @@ +#ifndef BACKPORT_LINUX_DEVICE_H +#define BACKPORT_LINUX_DEVICE_H + +#include_next + +#define dev_alert(dev, format, arg...) \ + dev_printk(KERN_ALERT , dev , format , ## arg) + +#define printk_once(x...) ({ \ + static bool __print_once; \ + \ + if (!__print_once) { \ + __print_once = true; \ + printk(x); \ + } \ + }) + +#endif /* BACKPORT_LINUX_DEVICE_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/dma-attrs.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/dma-attrs.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/dma-attrs.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/dma-attrs.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,47 @@ +#ifndef __BACKPORT_DMA_ATTR_H_TO_2_6_25__ +#define __BACKPORT_DMA_ATTR_H_TO_2_6_25__ + +/** + * an enum dma_attr represents an attribute associated with a DMA + * mapping. The semantics of each attribute should be defined in + * Documentation/DMA-attributes.txt. + */ +enum dma_attr { + DMA_ATTR_WRITE_BARRIER, + DMA_ATTR_MAX, +}; + +#define __DMA_ATTRS_LONGS BITS_TO_LONGS(DMA_ATTR_MAX) + +/** + * struct dma_attrs - an opaque container for DMA attributes + * @flags - bitmask representing a collection of enum dma_attr + */ +struct dma_attrs { + unsigned long flags[__DMA_ATTRS_LONGS]; +}; + +#define DEFINE_DMA_ATTRS(x) \ + struct dma_attrs x = { \ + .flags = { [0 ... __DMA_ATTRS_LONGS-1] = 0 }, \ + } + +#ifdef CONFIG_HAVE_DMA_ATTRS +/** + * dma_set_attr - set a specific attribute + * @attr: attribute to set + * @attrs: struct dma_attrs (may be NULL) + */ +static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs) +{ + if (attrs == NULL) + return; + BUG_ON(attr >= DMA_ATTR_MAX); + __set_bit(attr, attrs->flags); +} +#else /* !CONFIG_HAVE_DMA_ATTRS */ +static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs) +{ +} +#endif /* CONFIG_HAVE_DMA_ATTRS */ +#endif /* __BACKPORT_DMA_ATTR_H_TO_2_6_25__ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/dma-mapping.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/dma-mapping.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/dma-mapping.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/dma-mapping.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,25 @@ +#ifndef __BACKPORT_LINUX_DMA_MAPPING_H_TO_2_6_25__ +#define __BACKPORT_LINUX_DMA_MAPPING_H_TO_2_6_25__ + +#include_next + +#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1)) + +#ifndef CONFIG_HAVE_DMA_ATTRS +struct dma_attrs; + +#define dma_map_single_attrs(dev, cpu_addr, size, dir, attrs) \ + dma_map_single(dev, cpu_addr, size, dir) + +#define dma_unmap_single_attrs(dev, dma_addr, size, dir, attrs) \ + dma_unmap_single(dev, dma_addr, size, dir) + +#define dma_map_sg_attrs(dev, sgl, nents, dir, attrs) \ + dma_map_sg(dev, sgl, nents, dir) + +#define dma_unmap_sg_attrs(dev, sgl, nents, dir, attrs) \ + dma_unmap_sg(dev, sgl, nents, dir) + +#endif /* CONFIG_HAVE_DMA_ATTRS */ + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/err.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/err.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/err.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/err.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,13 @@ +#ifndef BACKPORT_LINUX_ERR_H +#define BACKPORT_LINUX_ERR_H + +#include_next + +#define IS_ERR_VALUE(x) unlikely((x) >= (unsigned long)-MAX_ERRNO) + +static inline long __must_check IS_ERR_OR_NULL(const void *ptr) +{ + return !ptr || IS_ERR_VALUE((unsigned long)ptr); +} + +#endif /* BACKPORT_LINUX_ERR_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/etherdevice.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/etherdevice.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/etherdevice.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/etherdevice.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,17 @@ +#ifndef BACKPORT_LINUX_ETHERDEVICE +#define BACKPORT_LINUX_ETHERDEVICE + +#include_next + +static inline unsigned short backport_eth_type_trans(struct sk_buff *skb, + struct net_device *dev) +{ + skb->dev = dev; + return eth_type_trans(skb, dev); +} + +#define eth_type_trans backport_eth_type_trans + +#define alloc_etherdev_mq(a, b) alloc_etherdev(a) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/ethtool.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/ethtool.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/ethtool.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/ethtool.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,50 @@ +#ifndef BACKPORT_LINUX_ETHTOOL_H_ +#define BACKPORT_LINUX_ETHTOOL_H_ + +#include_next + +/** + * enum ethtool_phys_id_state - indicator state for physical identification + * @ETHTOOL_ID_INACTIVE: Physical ID indicator should be deactivated + * @ETHTOOL_ID_ACTIVE: Physical ID indicator should be activated + * @ETHTOOL_ID_ON: LED should be turned on (used iff %ETHTOOL_ID_ACTIVE + * is not supported) + * @ETHTOOL_ID_OFF: LED should be turned off (used iff %ETHTOOL_ID_ACTIVE + * is not supported) + */ +enum ethtool_phys_id_state { + ETHTOOL_ID_INACTIVE, + ETHTOOL_ID_ACTIVE, + ETHTOOL_ID_ON, + ETHTOOL_ID_OFF +}; + +/* boolean flags controlling per-interface behavior characteristics. + * When reading, the flag indicates whether or not a certain behavior + * is enabled/present. When writing, the flag indicates whether + * or not the driver should turn on (set) or off (clear) a behavior. + * + * Some behaviors may read-only (unconditionally absent or present). + * If such is the case, return EINVAL in the set-flags operation if the + * flag differs from the read-only value. + * + * Adding missing enums for ethtool_flags in 2.6.32 kernel. + */ +enum additional_ethtool_flags { + ETH_FLAG_TXVLAN = (1 << 7), /* TX VLAN offload enabled */ + ETH_FLAG_RXVLAN = (1 << 8), /* RX VLAN offload enabled */ +}; + +#define PORT_DA 0x05 +#define IPV4_FLOW 0x10 /* hash only */ +#define IPV6_FLOW 0x11 /* hash only */ + +/* + * no mdio_support field in ethtool_cmd struct. + * we'll place it in the last reserved field, where it will stay out of the way. + * It is set by the driver, and ignored by all. + */ + +#define mdio_support reserved[3] + +#endif /* BACKPORT_LINUX_ETHTOOL_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/file.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/file.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/file.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/file.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,12 @@ +#ifndef _BACKPORT_LINUX_FILE_H_ +#define _BACKPORT_LINUX_FILE_H_ + +#include_next +#include + +static inline void drop_file_write_access(struct file *filp) +{ + put_write_access(filp->f_dentry->d_inode); +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/freezer.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/freezer.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/freezer.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/freezer.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,6 @@ +#ifndef BACKPORT_LINUX_FREEZER_H +#define BACKPORT_LINUX_FREEZER_H + +static inline void set_freezable(void) {} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/fscache.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/fscache.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/fscache.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/fscache.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,50 @@ +#ifndef BACKPORT_LINUX_FSCACHE_H +#define BACKPORT_LINUX_FSCACHE_H + +#include_next +#include + +#define NFS_PAGE_WRITING 0 +#define NFS_PAGE_CACHED 1 + +#define PageNfsBit(bit, page) test_bit(bit, &(page)->private) + +#define SetPageNfsBit(bit, page) \ +do { \ + SetPagePrivate((page)); \ + set_bit(bit, &(page)->private); \ +} while(0) + +#define ClearPageNfsBit(bit, page) \ +do { \ + clear_bit(bit, &(page)->private); \ +} while(0) + +#define PageNfsWriting(page) PageNfsBit(NFS_PAGE_WRITING, (page)) +#define SetPageNfsWriting(page) SetPageNfsBit(NFS_PAGE_WRITING, (page)) +#define ClearPageNfsWriting(page) ClearPageNfsBit(NFS_PAGE_WRITING, (page)) + +#define PageNfsCached(page) PageNfsBit(NFS_PAGE_CACHED, (page)) +#define SetPageNfsCached(page) SetPageNfsBit(NFS_PAGE_CACHED, (page)) +#define ClearPageNfsCached(page) ClearPageNfsBit(NFS_PAGE_CACHED, (page)) + + +#define PageFsCache(page) PageNfsCached(page) +#define ClearPageFsCache(page) ClearPageNfsCached(page) +#define fscache_check_page_write(cookie, page) PageNfsWriting(page) + +static inline void +fscache_wait_on_page_write(struct fscache_cookie *cookie, struct page *page) +{ + wait_queue_head_t *wq = bit_waitqueue(&(page)->private, 0); + wait_event(*wq, !PageNfsWriting(page)); +} + +static inline int +backport_fscache_write_page(struct fscache_cookie *cookie, struct page *page, gfp_t gfp) +{ + return fscache_write_page(cookie, page, NULL, NULL, gfp); +} +#define fscache_write_page backport_fscache_write_page + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/fs.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/fs.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/fs.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/fs.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,110 @@ +#ifndef BACKPORT_LINUX_FS_H +#define BACKPORT_LINUX_FS_H + +#include_next +#include +#include +#include + +#define ATTR_KILL_PRIV (1 << 14) +#define FILE_LOCK_DEFERRED 1 + +#define __locks_copy_lock locks_copy_lock +#define mandatory_lock(_args) (MANDATORY_LOCK(_args)) +#define vfs_setlease(a, b, c) (setlease(a, b, c)) + +struct lock_manager { + struct list_head list; +}; + +void locks_start_grace(struct lock_manager *); +void locks_end_grace(struct lock_manager *); +int locks_in_grace(void); + +static inline bool execute_ok(struct inode *inode) +{ + return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode); +} + +static inline int current_umask(void) +{ + return current->fs->umask; +} + +static inline void free_fs_struct(struct fs_struct *fs) +{ + struct task_struct *tsk; + + tsk = kzalloc(sizeof(struct task_struct), GFP_KERNEL); + if (!tsk) + return; + + spin_lock_init(&tsk->alloc_lock); + tsk->fs = fs; + + exit_fs(tsk); + kfree(tsk); +} + +static inline int unshare_fs_struct(void) +{ + struct fs_struct *fs = current->fs; + struct fs_struct *new_fs = copy_fs_struct(fs); + int kill; + + if (!new_fs) + return -ENOMEM; + + task_lock(current); + write_lock(&fs->lock); + kill = atomic_read(&fs->count) == 1; + current->fs = new_fs; + write_unlock(&fs->lock); + task_unlock(current); + + if (kill) + free_fs_struct(fs); + + return 0; +} + +static inline int inode_permission(struct inode *inode, int flags) +{ + return permission(inode, flags, NULL); +} + +static inline int backport_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname) +{ + return vfs_symlink(dir, dentry, oldname, 0); +} +#define vfs_symlink(_dir, _dentry, _oldname) backport_vfs_symlink(_dir, _dentry, _oldname) + +#ifdef CONFIG_DEBUG_WRITECOUNT +static inline void file_take_write(struct file *f) +{ + WARN_ON(f->f_mnt_write_state != 0); + f->f_mnt_write_state = FILE_MNT_WRITE_TAKEN; +} +#else +static inline void file_take_write(struct file *filp) {} +#endif + +static inline int __mnt_is_readonly(struct vfsmount *mnt) +{ + if (mnt->mnt_sb->s_flags & MS_RDONLY) + return 1; + return 0; +} + +static inline int __mandatory_lock(struct inode *ino) +{ + return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID; +} + +static inline void deactivate_locked_super(struct super_block *s) +{ + up_write(&s->s_umount); + deactivate_super(s); +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/if.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/if.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/if.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/if.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,10 @@ +#ifndef __BACKPORT_LINUX_IF_H_TO_2_6_18__ +#define __BACKPORT_LINUX_IF_H_TO_2_6_18__ + +#include_next + +#if defined(__powerpc64__) +#define IFF_BONDING 0x20 /* bonding master or slave */ +#endif + +#endif /* __BACKPORT_LINUX_IF_H_TO_2_6_18__ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/if_vlan.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/if_vlan.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/if_vlan.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/if_vlan.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,16 @@ +#ifndef __BACKPORT_LINUX_IF_VLAN_H_TO_2_6_20__ +#define __BACKPORT_LINUX_IF_VLAN_H_TO_2_6_20__ + +#include_next + +#define vlan_dev_info(x) VLAN_DEV_INFO(x) + +static inline u16 vlan_dev_vlan_id(const struct net_device *dev) +{ + return vlan_dev_info(dev)->vlan_id; +} + +#define vlan_dev_real_dev(netdev) (VLAN_DEV_INFO(netdev)->real_dev) +#define vlan_dev_vlan_id(netdev) (VLAN_DEV_INFO(netdev)->vlan_id) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inetdevice.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inetdevice.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inetdevice.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inetdevice.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef _BACKPORT_LINUX_INETDEVICE_H +#define _BACKPORT_LINUX_INETDEVICE_H + +#include_next + +#define ip_dev_find(net, addr) ip_dev_find(addr) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inet.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inet.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inet.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inet.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,208 @@ +#ifndef __BACKPORT_LINUX_INET_H_TO_2_6_26__ +#define __BACKPORT_LINUX_INET_H_TO_2_6_26__ + +#include_next + +#define INET_ADDRSTRLEN (16) +#define INET6_ADDRSTRLEN (48) + +#define IN6PTON_XDIGIT 0x00010000 +#define IN6PTON_DIGIT 0x00020000 +#define IN6PTON_COLON_MASK 0x00700000 +#define IN6PTON_COLON_1 0x00100000 /* single : requested */ +#define IN6PTON_COLON_2 0x00200000 /* second : requested */ +#define IN6PTON_COLON_1_2 0x00400000 /* :: requested */ +#define IN6PTON_DOT 0x00800000 /* . */ +#define IN6PTON_DELIM 0x10000000 +#define IN6PTON_NULL 0x20000000 /* first/tail */ +#define IN6PTON_UNKNOWN 0x40000000 + +static inline int xdigit2bin(char c, int delim) +{ + if (c == delim || c == '\0') + return IN6PTON_DELIM; + if (c == ':') + return IN6PTON_COLON_MASK; + if (c == '.') + return IN6PTON_DOT; + if (c >= '0' && c <= '9') + return (IN6PTON_XDIGIT | IN6PTON_DIGIT| (c - '0')); + if (c >= 'a' && c <= 'f') + return (IN6PTON_XDIGIT | (c - 'a' + 10)); + if (c >= 'A' && c <= 'F') + return (IN6PTON_XDIGIT | (c - 'A' + 10)); + if (delim == -1) + return IN6PTON_DELIM; + return IN6PTON_UNKNOWN; +} + +static inline int in4_pton(const char *src, int srclen, + u8 *dst, + int delim, const char **end) +{ + const char *s; + u8 *d; + u8 dbuf[4]; + int ret = 0; + int i; + int w = 0; + + if (srclen < 0) + srclen = strlen(src); + s = src; + d = dbuf; + i = 0; + while(1) { + int c; + c = xdigit2bin(srclen > 0 ? *s : '\0', delim); + if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK))) { + goto out; + } + if (c & (IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK)) { + if (w == 0) + goto out; + *d++ = w & 0xff; + w = 0; + i++; + if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) { + if (i != 4) + goto out; + break; + } + goto cont; + } + w = (w * 10) + c; + if ((w & 0xffff) > 255) { + goto out; + } +cont: + if (i >= 4) + goto out; + s++; + srclen--; + } + ret = 1; + memcpy(dst, dbuf, sizeof(dbuf)); +out: + if (end) + *end = s; + return ret; +} + +static inline int in6_pton(const char *src, int srclen, + u8 *dst, + int delim, const char **end) +{ + const char *s, *tok = NULL; + u8 *d, *dc = NULL; + u8 dbuf[16]; + int ret = 0; + int i; + int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL; + int w = 0; + + memset(dbuf, 0, sizeof(dbuf)); + + s = src; + d = dbuf; + if (srclen < 0) + srclen = strlen(src); + + while (1) { + int c; + + c = xdigit2bin(srclen > 0 ? *s : '\0', delim); + if (!(c & state)) + goto out; + if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) { + /* process one 16-bit word */ + if (!(state & IN6PTON_NULL)) { + *d++ = (w >> 8) & 0xff; + *d++ = w & 0xff; + } + w = 0; + if (c & IN6PTON_DELIM) { + /* We've processed last word */ + break; + } + /* + * COLON_1 => XDIGIT + * COLON_2 => XDIGIT|DELIM + * COLON_1_2 => COLON_2 + */ + switch (state & IN6PTON_COLON_MASK) { + case IN6PTON_COLON_2: + dc = d; + state = IN6PTON_XDIGIT | IN6PTON_DELIM; + if (dc - dbuf >= sizeof(dbuf)) + state |= IN6PTON_NULL; + break; + case IN6PTON_COLON_1|IN6PTON_COLON_1_2: + state = IN6PTON_XDIGIT | IN6PTON_COLON_2; + break; + case IN6PTON_COLON_1: + state = IN6PTON_XDIGIT; + break; + case IN6PTON_COLON_1_2: + state = IN6PTON_COLON_2; + break; + default: + state = 0; + } + tok = s + 1; + goto cont; + } + + if (c & IN6PTON_DOT) { + ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s); + if (ret > 0) { + d += 4; + break; + } + goto out; + } + + w = (w << 4) | (0xff & c); + state = IN6PTON_COLON_1 | IN6PTON_DELIM; + if (!(w & 0xf000)) { + state |= IN6PTON_XDIGIT; + } + if (!dc && d + 2 < dbuf + sizeof(dbuf)) { + state |= IN6PTON_COLON_1_2; + state &= ~IN6PTON_DELIM; + } + if (d + 2 >= dbuf + sizeof(dbuf)) { + state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2); + } +cont: + if ((dc && d + 4 < dbuf + sizeof(dbuf)) || + d + 4 == dbuf + sizeof(dbuf)) { + state |= IN6PTON_DOT; + } + if (d >= dbuf + sizeof(dbuf)) { + state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK); + } + s++; + srclen--; + } + + i = 15; d--; + + if (dc) { + while(d >= dc) + dst[i--] = *d--; + while(i >= dc - dbuf) + dst[i--] = 0; + while(i >= 0) + dst[i--] = *d--; + } else + memcpy(dst, dbuf, sizeof(dbuf)); + + ret = 1; +out: + if (end) + *end = s; + return ret; +} + +#endif /* __BACKPORT_LINUX_INET_H_TO_2_6_26__ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inet_lro.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inet_lro.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inet_lro.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/inet_lro.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,180 @@ +#ifndef __BACKPORT_INET_LRO_H_TO_2_6_23__ +#define __BACKPORT_INET_LRO_H_TO_2_6_23__ + +/* + * linux/include/linux/inet_lro.h + * + * Large Receive Offload (ipv4 / tcp) + * + * (C) Copyright IBM Corp. 2007 + * + * Authors: + * Jan-Bernd Themann + * Christoph Raisch + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * 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 + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include + +/* + * LRO statistics + */ + +struct net_lro_stats { + unsigned long aggregated; + unsigned long flushed; + unsigned long no_desc; +}; + +/* + * LRO descriptor for a tcp session + */ +struct net_lro_desc { + struct sk_buff *parent; + struct sk_buff *last_skb; + struct skb_frag_struct *next_frag; + struct iphdr *iph; + struct tcphdr *tcph; + struct vlan_group *vgrp; + __wsum data_csum; + __be32 tcp_rcv_tsecr; + __be32 tcp_rcv_tsval; + __be32 tcp_ack; + u32 tcp_next_seq; + u32 skb_tot_frags_len; + u16 ip_tot_len; + u16 tcp_saw_tstamp; /* timestamps enabled */ + __be16 tcp_window; + u16 vlan_tag; + int pkt_aggr_cnt; /* counts aggregated packets */ + int vlan_packet; + int mss; + int active; +}; + +/* + * Large Receive Offload (LRO) Manager + * + * Fields must be set by driver + */ + +struct net_lro_mgr { + struct net_device *dev; + struct net_lro_stats stats; + + /* LRO features */ + unsigned long features; +#define LRO_F_NAPI 1 /* Pass packets to stack via NAPI */ +#define LRO_F_EXTRACT_VLAN_ID 2 /* Set flag if VLAN IDs are extracted + from received packets and eth protocol + is still ETH_P_8021Q */ + + u32 ip_summed; /* Set in non generated SKBs in page mode */ + u32 ip_summed_aggr; /* Set in aggregated SKBs: CHECKSUM_UNNECESSARY + * or CHECKSUM_NONE */ + + int max_desc; /* Max number of LRO descriptors */ + int max_aggr; /* Max number of LRO packets to be aggregated */ + + int frag_align_pad; /* Padding required to properly align layer 3 + * headers in generated skb when using frags */ + + struct net_lro_desc *lro_arr; /* Array of LRO descriptors */ + + /* + * Optimized driver functions + * + * get_skb_header: returns tcp and ip header for packet in SKB + */ + int (*get_skb_header)(struct sk_buff *skb, void **ip_hdr, + void **tcpudp_hdr, u64 *hdr_flags, void *priv); + + /* hdr_flags: */ +#define LRO_IPV4 1 /* ip_hdr is IPv4 header */ +#define LRO_TCP 2 /* tcpudp_hdr is TCP header */ + + /* + * get_frag_header: returns mac, tcp and ip header for packet in SKB + * + * @hdr_flags: Indicate what kind of LRO has to be done + * (IPv4/IPv6/TCP/UDP) + */ + int (*get_frag_header)(struct skb_frag_struct *frag, void **mac_hdr, + void **ip_hdr, void **tcpudp_hdr, u64 *hdr_flags, + void *priv); +}; + +/* + * Processes a SKB + * + * @lro_mgr: LRO manager to use + * @skb: SKB to aggregate + * @priv: Private data that may be used by driver functions + * (for example get_tcp_ip_hdr) + */ + +void lro_receive_skb(struct net_lro_mgr *lro_mgr, + struct sk_buff *skb, + void *priv); + +/* + * Processes a SKB with VLAN HW acceleration support + */ + +void lro_vlan_hwaccel_receive_skb(struct net_lro_mgr *lro_mgr, + struct sk_buff *skb, + struct vlan_group *vgrp, + u16 vlan_tag, + void *priv); + +/* + * Processes a fragment list + * + * This functions aggregate fragments and generate SKBs do pass + * the packets to the stack. + * + * @lro_mgr: LRO manager to use + * @frags: Fragment to be processed. Must contain entire header in first + * element. + * @len: Length of received data + * @true_size: Actual size of memory the fragment is consuming + * @priv: Private data that may be used by driver functions + * (for example get_tcp_ip_hdr) + */ + +void lro_receive_frags(struct net_lro_mgr *lro_mgr, + struct skb_frag_struct *frags, + int len, int true_size, void *priv, __wsum sum); + +void lro_vlan_hwaccel_receive_frags(struct net_lro_mgr *lro_mgr, + struct skb_frag_struct *frags, + int len, int true_size, + struct vlan_group *vgrp, + u16 vlan_tag, + void *priv, __wsum sum); + +/* + * Forward all aggregated SKBs held by lro_mgr to network stack + */ + +void lro_flush_all(struct net_lro_mgr *lro_mgr); + +void lro_flush_pkt(struct net_lro_mgr *lro_mgr, + struct iphdr *iph, struct tcphdr *tcph); + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/in.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/in.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/in.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/in.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,17 @@ +#ifndef __BACKPORT_LINUX_IN_H_TO_2_6_24__ +#define __BACKPORT_LINUX_IN_H_TO_2_6_24__ + +#include_next + + +static inline bool ipv4_is_loopback(__be32 addr) +{ + return (addr & htonl(0xff000000)) == htonl(0x7f000000); +} + +static inline bool ipv4_is_zeronet(__be32 addr) +{ + return (addr & htonl(0xff000000)) == htonl(0x00000000); +} + +#endif /* __BACKPORT_LINUX_IN_H_TO_2_6_24__ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/interrupt.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/interrupt.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/interrupt.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/interrupt.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,20 @@ +#ifndef BACKPORT_LINUX_INTERRUPT_TO_2_6_18 +#define BACKPORT_LINUX_INTERRUPT_TO_2_6_18 +#include_next + +typedef irqreturn_t (*backport_irq_handler_t)(int, void *); + +static inline int +backport_request_irq(unsigned int irq, + irqreturn_t (*handler)(int, void *), + unsigned long flags, const char *dev_name, void *dev_id) +{ + return request_irq(irq, + (irqreturn_t (*)(int, void *, struct pt_regs *))handler, + flags, dev_name, dev_id); +} + +#define request_irq backport_request_irq +#define irq_handler_t backport_irq_handler_t + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/jiffies.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/jiffies.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/jiffies.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/jiffies.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,10 @@ +#ifndef BACKPORT_LINUX_JIFFIES_H +#define BACKPORT_LINUX_JIFFIES_H + +#include_next + +#define time_in_range_open(a,b,c) \ + (time_after_eq(a,b) && \ + time_before(a,c)) + +#endif /* BACKPORT_LINUX_JIFFIES_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/kernel.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/kernel.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/kernel.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/kernel.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,12 @@ +#ifndef BACKPORT_KERNEL_H_2_6_22 +#define BACKPORT_KERNEL_H_2_6_22 + +#include_next + +#include +#include + +#define USHORT_MAX ((u16)(~0U)) + + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/kobject.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/kobject.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/kobject.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/kobject.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,37 @@ +#ifndef __BACKPORT_KOBJECT_H_TO_2_6_24__ +#define __BACKPORT_KOBJECT_H_TO_2_6_24__ + +#include_next + + +/** + * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs + * + * @name: the name for the kset + * @parent: the parent kobject of this kobject, if any. + * + * This function creates a kobject structure dynamically and registers it + * with sysfs. When you are finished with this structure, call + * kobject_put() and the structure will be dynamically freed when + * it is no longer being used. + * + * If the kobject was not able to be created, NULL will be returned. + */ +struct kobject *kobject_create_and_add(const char *name, struct kobject *parent); + +/** + * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy + * @kobj: pointer to the kobject to initialize + * @ktype: pointer to the ktype for this kobject. + * @parent: pointer to the parent of this kobject. + * @fmt: the name of the kobject. + * + * This function combines the call to kobject_init() and + * kobject_add(). The same type of error handling after a call to + * kobject_add() and kobject lifetime rules are the same here. + */ +int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype, + struct kobject *parent, const char *fmt, ...); + + +#endif /* __BACKPORT_KOBJECT_H_TO_2_6_24__ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/list.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/list.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/list.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/list.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,9 @@ +#ifndef __BACKPORT_LINUX_LIST_H_TO_2_6_24__ +#define __BACKPORT_LINUX_LIST_H_TO_2_6_24__ +#include_next + +#define list_first_entry(ptr, type, member) \ + list_entry((ptr)->next, type, member) + + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/log2.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/log2.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/log2.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/log2.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,194 @@ +/* Integer base 2 logarithm calculation + * + * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved. + * Written by David Howells (dhowells@redhat.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version + * 2 of the License, or (at your option) any later version. + */ + +#ifndef _LINUX_BACKPORT_LOG2_H +#define _LINUX_BACKPORT_LOG2_H + +#include_next +#include +#include + +/* + * deal with unrepresentable constant logarithms + */ +extern __attribute__((const, noreturn)) +int ____ilog2_NaN(void); + +/* + * non-constant log of base 2 calculators + * - the arch may override these in asm/bitops.h if they can be implemented + * more efficiently than using fls() and fls64() + * - the arch is not required to handle n==0 if implementing the fallback + */ +#ifndef CONFIG_ARCH_HAS_ILOG2_U32 +static inline __attribute__((const)) +int __ilog2_u32(u32 n) +{ + return fls(n) - 1; +} +#endif + +#ifndef CONFIG_ARCH_HAS_ILOG2_U64 +static inline __attribute__((const)) +int __ilog2_u64(u64 n) +{ + return fls64(n) - 1; +} +#endif + +/* + * Determine whether some value is a power of two, where zero is + * *not* considered a power of two. + */ + +static inline __attribute__((const)) +bool is_power_of_2(unsigned long n) +{ + return (n != 0 && ((n & (n - 1)) == 0)); +} + +/* + * round up to nearest power of two + */ +static inline __attribute__((const)) +unsigned long __roundup_pow_of_two(unsigned long n) +{ + return 1UL << fls_long(n - 1); +} + +/* + * round down to nearest power of two + */ +static inline __attribute__((const)) +unsigned long __rounddown_pow_of_two(unsigned long n) +{ + return 1UL << (fls_long(n) - 1); +} + +/** + * ilog2 - log of base 2 of 32-bit or a 64-bit unsigned value + * @n - parameter + * + * constant-capable log of base 2 calculation + * - this can be used to initialise global variables from constant data, hence + * the massive ternary operator construction + * + * selects the appropriately-sized optimised version depending on sizeof(n) + */ +#define ilog2(n) \ +( \ + __builtin_constant_p(n) ? ( \ + (n) < 1 ? ____ilog2_NaN() : \ + (n) & (1ULL << 63) ? 63 : \ + (n) & (1ULL << 62) ? 62 : \ + (n) & (1ULL << 61) ? 61 : \ + (n) & (1ULL << 60) ? 60 : \ + (n) & (1ULL << 59) ? 59 : \ + (n) & (1ULL << 58) ? 58 : \ + (n) & (1ULL << 57) ? 57 : \ + (n) & (1ULL << 56) ? 56 : \ + (n) & (1ULL << 55) ? 55 : \ + (n) & (1ULL << 54) ? 54 : \ + (n) & (1ULL << 53) ? 53 : \ + (n) & (1ULL << 52) ? 52 : \ + (n) & (1ULL << 51) ? 51 : \ + (n) & (1ULL << 50) ? 50 : \ + (n) & (1ULL << 49) ? 49 : \ + (n) & (1ULL << 48) ? 48 : \ + (n) & (1ULL << 47) ? 47 : \ + (n) & (1ULL << 46) ? 46 : \ + (n) & (1ULL << 45) ? 45 : \ + (n) & (1ULL << 44) ? 44 : \ + (n) & (1ULL << 43) ? 43 : \ + (n) & (1ULL << 42) ? 42 : \ + (n) & (1ULL << 41) ? 41 : \ + (n) & (1ULL << 40) ? 40 : \ + (n) & (1ULL << 39) ? 39 : \ + (n) & (1ULL << 38) ? 38 : \ + (n) & (1ULL << 37) ? 37 : \ + (n) & (1ULL << 36) ? 36 : \ + (n) & (1ULL << 35) ? 35 : \ + (n) & (1ULL << 34) ? 34 : \ + (n) & (1ULL << 33) ? 33 : \ + (n) & (1ULL << 32) ? 32 : \ + (n) & (1ULL << 31) ? 31 : \ + (n) & (1ULL << 30) ? 30 : \ + (n) & (1ULL << 29) ? 29 : \ + (n) & (1ULL << 28) ? 28 : \ + (n) & (1ULL << 27) ? 27 : \ + (n) & (1ULL << 26) ? 26 : \ + (n) & (1ULL << 25) ? 25 : \ + (n) & (1ULL << 24) ? 24 : \ + (n) & (1ULL << 23) ? 23 : \ + (n) & (1ULL << 22) ? 22 : \ + (n) & (1ULL << 21) ? 21 : \ + (n) & (1ULL << 20) ? 20 : \ + (n) & (1ULL << 19) ? 19 : \ + (n) & (1ULL << 18) ? 18 : \ + (n) & (1ULL << 17) ? 17 : \ + (n) & (1ULL << 16) ? 16 : \ + (n) & (1ULL << 15) ? 15 : \ + (n) & (1ULL << 14) ? 14 : \ + (n) & (1ULL << 13) ? 13 : \ + (n) & (1ULL << 12) ? 12 : \ + (n) & (1ULL << 11) ? 11 : \ + (n) & (1ULL << 10) ? 10 : \ + (n) & (1ULL << 9) ? 9 : \ + (n) & (1ULL << 8) ? 8 : \ + (n) & (1ULL << 7) ? 7 : \ + (n) & (1ULL << 6) ? 6 : \ + (n) & (1ULL << 5) ? 5 : \ + (n) & (1ULL << 4) ? 4 : \ + (n) & (1ULL << 3) ? 3 : \ + (n) & (1ULL << 2) ? 2 : \ + (n) & (1ULL << 1) ? 1 : \ + (n) & (1ULL << 0) ? 0 : \ + ____ilog2_NaN() \ + ) : \ + (sizeof(n) <= 4) ? \ + __ilog2_u32(n) : \ + __ilog2_u64(n) \ + ) + +/** + * roundup_pow_of_two - round the given value up to nearest power of two + * @n - parameter + * + * round the given balue up to the nearest power of two + * - the result is undefined when n == 0 + * - this can be used to initialise global variables from constant data + */ +#define roundup_pow_of_two(n) \ +( \ + __builtin_constant_p(n) ? ( \ + (n == 1) ? 0 : \ + (1UL << (ilog2((n) - 1) + 1)) \ + ) : \ + __roundup_pow_of_two(n) \ + ) + +/** + * rounddown_pow_of_two - round the given value down to nearest power of two + * @n - parameter + * + * round the given value down to the nearest power of two + * - the result is undefined when n == 0 + * - this can be used to initialise global variables from constant data + */ +#define rounddown_pow_of_two(n) \ +( \ + __builtin_constant_p(n) ? ( \ + (n == 1) ? 0 : \ + (1UL << ilog2(n))) : \ + __rounddown_pow_of_two(n) \ + ) + +#endif /* _LINUX_BACKPORT_LOG2_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/magic.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/magic.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/magic.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/magic.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,7 @@ +#ifndef BACKPORT_LINUX_MAGIC_H +#define BACKPORT_LINUX_MAGIC_H + +#define NFS_SUPER_MAGIC 0x6969 +#define MSDOS_SUPER_MAGIC 0x4d44 + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mm.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mm.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mm.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mm.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,41 @@ +#ifndef _BACKPORT_LINUX_MM_H_ +#define _BACKPORT_LINUX_MM_H_ + +#include_next +#include + +#if defined(__i386__) +#include +#endif + +#define VM_FAULT_LOCKED 0x0200 /* ->fault locked the returned page */ +#define VM_CAN_NONLINEAR 0x08000000 /* Has ->fault & does nonlinear pages */ + +#define is_vmalloc_addr(x) ((unsigned long)(x) >= VMALLOC_START && (unsigned long)(x) < VMALLOC_END) + +struct shrinker { + shrinker_t shrink; + struct list_head list; + int seeks; /* seeks to recreate an obj */ + long nr; /* objs pending delete */ +}; + +static inline void task_io_account_cancelled_write(size_t bytes) +{ +} + +static inline void cancel_dirty_page(struct page *page, unsigned int account_size) +{ + if (TestClearPageDirty(page)) { + struct address_space *mapping = page->mapping; + if (mapping && mapping_cap_account_dirty(mapping)) { + dec_zone_page_state(page, NR_FILE_DIRTY); + dec_bdi_stat(mapping->backing_dev_info, + BDI_RECLAIMABLE); + if (account_size) + task_io_account_cancelled_write(account_size); + } + } +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mnt_namespace.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mnt_namespace.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mnt_namespace.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mnt_namespace.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,4 @@ +#ifndef BACKPORT_LINUX_MNT_NAMESPACE_H +#define BACKPORT_LINUX_MNT_NAMESPACE_H + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mount.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mount.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mount.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mount.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,11 @@ +#ifndef BACKPORT_LINUX_MOUNT_H +#define BACKPORT_LINUX_MOUNT_H + +#include_next +#include + +extern int mnt_want_write(struct vfsmount *mnt); +extern void mnt_drop_write(struct vfsmount *mnt); +extern int init_mnt_writers(void); + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mpage.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mpage.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mpage.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mpage.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,14 @@ +#ifndef BACKPORT_LINUX_MPAGE_H +#define BACKPORT_LINUX_MPAGE_H + +#include_next + +static inline int backport_write_cache_pages(struct address_space *mapping, + struct writeback_control *wbc, writepage_data_t writepage, + void *data) +{ + return write_cache_pages(mapping, 0, wbc, writepage, data); +} +#define write_cache_pages backport_write_cache_pages + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mutex.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mutex.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mutex.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/mutex.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef LINUX_MUTEX_BACKPORT_H +#define LINUX_MUTEX_BACKPORT_H + +#include_next + +#define mutex_lock_killable(lock) mutex_lock_interruptible(lock) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/namei.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/namei.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/namei.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/namei.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,45 @@ +#ifndef BACKPORT_LINUX_NAMEI_H +#define BACKPORT_LINUX_NAMEI_H + +#include_next + +struct path { + struct vfsmount *mnt; + struct dentry *dentry; +}; + +#include + +static inline int kern_path(const char *name, unsigned int flags, struct path *path) +{ + struct nameidata nd; + int rc = path_lookup(name, flags, &nd); + if (!rc) { + (*path).mnt = nd.mnt; + (*path).dentry = nd.dentry; + } + return rc; +} + +static inline int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt, + const char *name, unsigned int flags, + struct nameidata *nd) +{ + int retval; + + /* same as do_path_lookup */ + nd->last_type = LAST_ROOT; + nd->flags = flags; + nd->depth = 0; + + nd->dentry = dentry; + nd->mnt = mnt; + mntget(nd->mnt); + dget(nd->dentry); + + retval = path_walk(name, nd); + + return retval; +} + +#endif /* BACKPORT_LINUX_NAMEI_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/netdevice.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/netdevice.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/netdevice.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/netdevice.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,164 @@ +#ifndef BACKPORT_LINUX_NETDEVICE_TO_2_6_18 +#define BACKPORT_LINUX_NETDEVICE_TO_2_6_18 + +#include_next + +static inline int skb_checksum_help_to_2_6_18(struct sk_buff *skb) +{ + return skb_checksum_help(skb, 0); +} + +#define skb_checksum_help skb_checksum_help_to_2_6_18 + +#undef SET_ETHTOOL_OPS +#define SET_ETHTOOL_OPS(netdev, ops) \ + ((netdev)->ethtool_ops) = ((struct ethtool_ops *)(ops)) + +#define NETIF_F_LRO 32768 /* large receive offload */ +#define NETIF_F_IPV6_CSUM 16 /* Can checksum TCP/UDP over IPV6 */ + +#define dev_get_by_name(net, name) dev_get_by_name(name) + +#define for_each_netdev(a, dev) \ + for ((dev) = dev_base; (dev) != NULL; (dev) = (dev)->next) + +#define NUMA_NO_NODE (-1) + +/** + * netif_set_real_num_rx_queues - set actual number of RX queues used + * @dev: Network device + * @rxq: Actual number of RX queues + * + * This function actully sets the real_num_rx_queues field in struct + * net_device. Since real_num_rx_queues field is not present in + * net_device structure in 2.6.32 kernel making this function to set that + * field is not possible. Hence adding this function to avoid changes in driver + * source code and making this function to always return success. + */ +static inline int netif_set_real_num_rx_queues(struct net_device *dev, + unsigned int rxq) +{ + return 0; +} + +static inline int netif_set_real_num_tx_queues(struct net_device *dev, + unsigned int rxq) +{ + return 0; +} + +#define NETIF_F_RXHASH (1 << 28) /* Receive hashing offload */ + +#define netdev_uc_count(netdev) 0 +#define netdev_for_each_uc_addr(ha, dev) if (0) +#define netif_tx_wake_queue(dev) netif_wake_queue(dev) + +#define dev_addr_list dev_mc_list + +/* + * Fake this. uc_count is zero and netdev_for_each_uc_addr will do nothing, + * but we still want it to compile. + */ +struct netdev_hw_addr { + u8 *addr; +}; + +static inline void napi_enable(struct net_device *dev) +{ + if (dev) + netif_poll_enable(dev); +} + +static inline void napi_disable(struct net_device *dev) +{ + if (dev) + netif_poll_disable(dev); +} + +/* + * No multiqueue support, so we collapse the netdev_queue back + * to the net_device. + */ +#define netdev_queue net_device +#define netdev_get_tx_queue(dev, j) (dev) +#define netif_tx_stop_queue(txq) netif_stop_queue(txq) +#define skb_get_queue_mapping(skb) 0 +#define skb_record_rx_queue(a, b) do { ; } while (0) + +#define netif_tx_start_all_queues(dev) netif_start_queue(dev) +#define netif_tx_stop_all_queues(dev) netif_stop_queue(dev) + +#define __netdev_alloc_page(a, b) \ + alloc_pages_node(-1, (b), 0) + +#define netdev_free_page(a, b) \ + __free_pages((b), 0) + +static inline void netif_napi_add(struct net_device *dev, + struct napi_struct *napi, + int (*poll)(struct net_device *, int *), int weight) +{ + BUG_ON(dev->atalk_ptr); + + INIT_LIST_HEAD(&napi->poll_list); + napi->gro_count = 0; + napi->gro_list = NULL; + napi->skb = NULL; + + napi->weight = weight; + napi->dev = dev; + + dev->poll = poll; + +} + +static inline void netif_napi_del(struct napi_struct *napi) +{ + struct sk_buff *skb, *next; + + kfree_skb(napi->skb); + + for (skb = napi->gro_list; skb; skb = next) { + next = skb->next; + skb->next = NULL; + kfree_skb(skb); + } + + napi->gro_list = NULL; + napi->gro_count = 0; + + +} + +static inline void napi_schedule(struct net_device *dev) +{ + netif_rx_schedule(dev); +} + +static inline void compat_napi_complete(struct net_device *dev) +{ + netif_rx_complete(dev); +} +#define napi_complete(x) compat_napi_complete(x) + +static inline int napi_reschedule(struct napi_struct *napi) +{ + netif_rx_schedule(napi->dev); + return 1; +} + +static inline int __netif_tx_trylock(struct net_device *txq) +{ + return netif_tx_trylock(txq); +} + +static inline void __netif_tx_unlock(struct net_device *txq) +{ + netif_tx_unlock(txq); +} + +#define netif_tx_start_all_queues(dev) netif_start_queue(dev) +#define netif_tx_stop_all_queues(dev) netif_stop_queue(dev) +#define netif_tx_wake_queue(dev) netif_wake_queue(dev) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/net.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/net.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/net.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/net.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,19 @@ +#ifndef BACKPORT_LINUX_NET_H +#define BACKPORT_LINUX_NET_H + +#include_next +#include + +enum sock_shutdown_cmd { + SHUT_RD = 0, + SHUT_WR = 1, + SHUT_RDWR = 2, +}; + + +static inline int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd flags) +{ + return sock->ops->shutdown(sock, flags); +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/netlink.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/netlink.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/netlink.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/netlink.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,14 @@ +#ifndef BACKPORT_LINUX_NETLINK_H +#define BACKPORT_LINUX_NETLINK_H + +#include_next + +#define netlink_kernel_create(net, uint, groups, input, mutex, mod) \ + netlink_kernel_create(uint, groups, input, mod) + +static inline struct nlmsghdr *nlmsg_hdr(const struct sk_buff *skb) +{ + return (struct nlmsghdr *)skb->data; +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/notifier.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/notifier.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/notifier.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/notifier.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,25 @@ +#ifndef __BACKPORT_LINUX_NOTIFIER_H_TO_2_6_26__ +#define __BACKPORT_LINUX_NOTIFIER_H_TO_2_6_26__ + +#include_next + +#define NOTIFY_DONE 0x0000 /* Don't care */ + +#endif /* __BACKPORT_LINUX_NOTIFIER_H_TO_2_6_26__ */ + +#ifndef LINUX_NOTIFIER_BACKPORT_TO_2_6_21_H +#define LINUX_NOTIFIER_BACKPORT_TO_2_6_21_H + +/* Used for CPU hotplug events occuring while tasks are frozen due to a suspend + * operation in progress + */ +#define CPU_TASKS_FROZEN 0x0010 + +#define CPU_ONLINE_FROZEN (CPU_ONLINE | CPU_TASKS_FROZEN) +#define CPU_UP_PREPARE_FROZEN (CPU_UP_PREPARE | CPU_TASKS_FROZEN) +#define CPU_UP_CANCELED_FROZEN (CPU_UP_CANCELED | CPU_TASKS_FROZEN) +#define CPU_DOWN_PREPARE_FROZEN (CPU_DOWN_PREPARE | CPU_TASKS_FROZEN) +#define CPU_DOWN_FAILED_FROZEN (CPU_DOWN_FAILED | CPU_TASKS_FROZEN) +#define CPU_DEAD_FROZEN (CPU_DEAD | CPU_TASKS_FROZEN) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pagemap.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pagemap.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pagemap.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pagemap.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef BACKPORT_LINUX_PAGEMAP_H +#define BACKPORT_LINUX_PAGEMAP_H + +#include_next + +#define __grab_cache_page grab_cache_page + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pagevec.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pagevec.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pagevec.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pagevec.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,17 @@ +#ifndef BACKPORT_LINUX_PAGEVEC_H +#define BACKPORT_LINUX_PAGEVEC_H + +#include_next + +static inline void __pagevec_lru_add_file(struct pagevec *pvec) +{ + __pagevec_lru_add(pvec); +} + +static inline void pagevec_lru_add_file(struct pagevec *pvec) +{ + if (pagevec_count(pvec)) + __pagevec_lru_add_file(pvec); +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/path.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/path.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/path.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/path.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,31 @@ +#ifndef _BACKPORT_LINUX_PATH_H +#define _BACKPORT_LINUX_PATH_H + +#include +#include + +static inline void path_put(struct path *path) +{ + dput(path->dentry); + mntput(path->mnt); +} + +static inline void path_get(struct path *path) +{ + mntget(path->mnt); + dget(path->dentry); +} + +static inline void backport_path_put(struct nameidata *nd) +{ + dput(nd->dentry); + mntput(nd->mnt); +} + +static inline void backport_path_get(struct nameidata *nd) +{ + mntget(nd->mnt); + dget(nd->dentry); +} + +#endif /* _BACKPORT_LINUX_PATH_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pci.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pci.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pci.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pci.h 2012-09-27 11:41:37.000000000 +0200 @@ -0,0 +1,162 @@ +#ifndef __BACKPORT_LINUX_PCI_TO_2_6_19__ +#define __BACKPORT_LINUX_PCI_TO_2_6_19__ + +#include_next + +#include + +/** + * PCI_VDEVICE - macro used to describe a specific pci device in short form + * @vend: the vendor name + * @dev: the 16 bit PCI Device ID + * + * This macro is used to create a struct pci_device_id that matches a + * specific PCI device. The subvendor, and subdevice fields will be set + * to PCI_ANY_ID. The macro allows the next field to follow as the device + * private data. + */ + +#define PCI_VDEVICE(vendor, device) \ + PCI_VENDOR_ID_##vendor, (device), \ +PCI_ANY_ID, PCI_ANY_ID, 0, 0 + +#define PCI_VPD_LRDT 0x80 /* Large Resource Data Type */ +#define PCI_VPD_LRDT_ID(x) (x | PCI_VPD_LRDT) +#define PCI_VPD_LRDT_ID_STRING PCI_VPD_LRDT_ID(PCI_VPD_LTIN_ID_STRING) +#define PCI_VPD_LRDT_RO_DATA PCI_VPD_LRDT_ID(PCI_VPD_LTIN_RO_DATA) +#define PCI_VPD_LRDT_TAG_SIZE 3 +#define PCI_VPD_INFO_FLD_HDR_SIZE 3 +#define PCI_VPD_LTIN_ID_STRING 0x02 /* Identifier String */ +#define PCI_VPD_LTIN_RO_DATA 0x10 /* Read-Only Data */ +#define PCI_VPD_SRDT_LEN_MASK 0x07 +#define PCI_VPD_STIN_END 0x78 /* End */ +#define PCI_VPD_SRDT_END PCI_VPD_STIN_END +#define PCI_VPD_SRDT_TAG_SIZE 1 +#define PCI_VPD_MAX_POLL 40 +#define PCI_VPD_LEN (1 + PCI_VPD_ADDR_MASK) + +/* + * pci_read_vpd - used by eeprom_rd_pyhs + */ +static inline ssize_t pci_read_vpd(struct pci_dev *dev, + loff_t pos, size_t count, void *arg) +{ + loff_t end = pos + count; + u8 *buf = arg; + u16 v16; + u32 v32; + int attempts = PCI_VPD_MAX_POLL; + int ret; + + static struct cache { + struct pci_dev *dev; + u8 cap; + } cache = {0, 0}; + + if (pos < 0 || pos > PCI_VPD_LEN || end > PCI_VPD_LEN) + return -EINVAL; + + if (cache.dev != dev) { + cache.cap = pci_find_capability(dev, PCI_CAP_ID_VPD); + cache.dev = dev; + } + + while (pos < end) { + unsigned int i, skip; + + ret = pci_write_config_word(dev, cache.cap + PCI_VPD_ADDR, + pos & ~3); + if (ret < 0) + return ret; + + attempts = PCI_VPD_MAX_POLL; + do { + udelay(10); + pci_read_config_word(dev, cache.cap + PCI_VPD_ADDR, + &v16); + } while (!(v16 & PCI_VPD_ADDR_F) && --attempts); + + if (attempts <= 0) + return -ETIMEDOUT; + + ret = pci_read_config_dword(dev, cache.cap + PCI_VPD_DATA, + &v32); + if (ret < 0) + break; + + skip = pos & 3; + for (i = 0; i < sizeof(u32); ++i) { + if (i >= skip) { + *buf++ = v32; + if (++pos == end) + break; + } + v32 >>= 8; + } + } + + return count; +} + +static inline ssize_t pci_write_vpd(struct pci_dev *dev, + loff_t pos, size_t count, const void *arg) +{ + const u8 *buf = arg; + loff_t end = pos + count; + int ret = 0; + u16 v16; + u32 v32; + int attempts = PCI_VPD_MAX_POLL; + + static struct cache { + struct pci_dev *dev; + u8 cap; + } cache = {0, 0}; + + if (pos < 0 || (pos & 3) || (count & 3) || end > PCI_VPD_LEN) + return -EINVAL; + + if (cache.dev != dev) { + cache.cap = pci_find_capability(dev, PCI_CAP_ID_VPD); + cache.dev = dev; + } + + attempts = PCI_VPD_MAX_POLL; + do { + udelay(10); + pci_read_config_word(dev, cache.cap + PCI_VPD_ADDR, &v16); + } while (!(v16 & PCI_VPD_ADDR_F) && --attempts); + + if (attempts <= 0) + return -ETIMEDOUT; + + while (pos < end) { + v32 = *buf++ << 0; + v32 |= *buf++ << 8; + v32 |= *buf++ << 16; + v32 |= *buf++ << 24; + + ret = pci_write_config_dword(dev, cache.cap + PCI_VPD_DATA, + v32); + if (ret < 0) + return ret; + ret = pci_write_config_word(dev, cache.cap + PCI_VPD_ADDR, + pos | PCI_VPD_ADDR_F); + if (ret < 0) + return ret; + + attempts = PCI_VPD_MAX_POLL; + do { + udelay(10); + pci_read_config_word(dev, cache.cap + PCI_VPD_ADDR, + &v16); + } while (!(v16 & PCI_VPD_ADDR_F) && --attempts); + + if (attempts <= 0) + return -ETIMEDOUT; + + pos += sizeof(u32); + } + return count; +} +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pci_regs.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pci_regs.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pci_regs.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/pci_regs.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,9 @@ +#ifndef __PCI_REGS__BACKPORT_H_TO_2_6_32___ +#define __PCI_REGS__BACKPORT_H_TO_2_6_32___ + +#include_next + +#define PCI_EXP_LNKSTA_CLS_2_5GB 0x01 /* Current Link Speed 2.5GT/s */ +#define PCI_EXP_LNKSTA_CLS_5_0GB 0x02 /* Current Link Speed 5.0GT/s */ + +#endif /* __PCI_REGS__BACKPORT_H_TO_2_6_32___ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/proc_fs.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/proc_fs.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/proc_fs.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/proc_fs.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,20 @@ +#ifndef BACKPORT_LINUX_PROC_FS_H +#define BACKPORT_LINUX_PROC_FS_H + +#include_next + +static inline struct proc_dir_entry *proc_create_data(const char *name, mode_t mode, + struct proc_dir_entry *parent, + const struct file_operations *proc_fops, + void *data) +{ + struct proc_dir_entry *pde; + + pde = proc_create(name, mode, parent, proc_fops); + if (pde) + pde->data = data; + + return pde; +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/quotaops.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/quotaops.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/quotaops.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/quotaops.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,70 @@ +#ifndef BACKPORT_LINUX_QUOTAOPS_H +#define BACKPORT_LINUX_QUOTAOPS_H + +#include_next + +/* Quota state flags - they actually come in two flavors - for users and groups */ +enum { + _DQUOT_USAGE_ENABLED = 0, /* Track disk usage for users */ + _DQUOT_LIMITS_ENABLED, /* Enforce quota limits for users */ + _DQUOT_SUSPENDED, /* User diskquotas are off, but + * we have necessary info in + * memory to turn them on */ + _DQUOT_STATE_FLAGS +}; + +#define DQUOT_USAGE_ENABLED (1 << _DQUOT_USAGE_ENABLED) +#define DQUOT_LIMITS_ENABLED (1 << _DQUOT_LIMITS_ENABLED) +#define DQUOT_SUSPENDED (1 << _DQUOT_SUSPENDED) + +static inline unsigned int dquot_state_flag(unsigned int flags, int type) +{ + if (type == USRQUOTA) + return flags; + return flags << _DQUOT_STATE_FLAGS; +} + +static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type) +{ + return sb_dqopt(sb)->flags & + dquot_state_flag(DQUOT_USAGE_ENABLED, type); +} + +static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type) +{ + return sb_dqopt(sb)->flags & + dquot_state_flag(DQUOT_LIMITS_ENABLED, type); +} + +static inline int sb_has_quota_suspended(struct super_block *sb, int type) +{ + return sb_dqopt(sb)->flags & + dquot_state_flag(DQUOT_SUSPENDED, type); +} + +static inline int sb_has_quota_loaded(struct super_block *sb, int type) +{ + /* Currently if anything is on, then quota usage is on as well */ + return sb_has_quota_usage_enabled(sb, type); +} + +static inline int sb_has_quota_active(struct super_block *sb, int type) +{ + return sb_has_quota_loaded(sb, type) && + !sb_has_quota_suspended(sb, type); +} + +static inline int sb_any_quota_active(struct super_block *sb) +{ + return sb_has_quota_active(sb, USRQUOTA) || + sb_has_quota_active(sb, GRPQUOTA); +} + +static inline void vfs_dq_init(struct inode *inode) +{ + BUG_ON(!inode->i_sb); + if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode)) + inode->i_sb->dq_op->initialize(inode, -1); +} + +#endif /* BACKPORT_LINUX_QUOTAOPS_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/random.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/random.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/random.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/random.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef BACKPORT_LINUX_RANDOM_TO_2_6_18 +#define BACKPORT_LINUX_RANDOM_TO_2_6_18 +#include_next +#include_next + +#define random32() net_random() + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rbtree.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rbtree.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rbtree.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rbtree.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,10 @@ +#ifndef BACKPORT_LINUX_RBTREE_TO_2_6_18 +#define BACKPORT_LINUX_RBTREE_TO_2_6_18 +#include_next + +/* Band-aid for buggy rbtree.h */ +#undef RB_EMPTY_NODE +#define RB_EMPTY_NODE(node) (rb_parent(node) == node) + +#endif + diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rculist.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rculist.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rculist.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rculist.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,7 @@ +#ifndef LINUX_RCULIST_BACKPORT_tO_2_6_26_H +#define LINUX_RCULIST_BACKPORT_tO_2_6_26_H + +#include_next +#include_next + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rcupdate.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rcupdate.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rcupdate.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/rcupdate.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef __RCUPDATE__BACKPORT_H_TO_2_6_36___ +#define __RCPUPATE__BACKPORT_H_TO_2_6_36___ + +#include_next + +#define RCU_INIT_POINTER(p, v) p = v + +#endif /*__RCPUPATE__BACKPORT_H_TO_2_6_36___ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/scatterlist.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/scatterlist.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/scatterlist.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/scatterlist.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,24 @@ +#ifndef __BACKPORT_LINUX_SCATTERLIST_H_TO_2_6_23__ +#define __BACKPORT_LINUX_SCATTERLIST_H_TO_2_6_23__ + +#include_next +#include + +static inline void sg_assign_page(struct scatterlist *sg, struct page *page) +{ + sg->page = page; +} + +#define for_each_sg(sglist, sg, nr, __i) \ + for (__i = 0, sg = (sglist); __i < (nr); __i++, sg++) + +static inline struct scatterlist *sg_next(struct scatterlist *sg) +{ + if (!sg) { + BUG(); + return NULL; + } + return sg + 1; +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/sched.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/sched.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/sched.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/sched.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,24 @@ +#ifndef LINUX_SCHED_BACKPORT_H +#define LINUX_SCHED_BACKPORT_H + +#include_next + +#define TASK_WAKEKILL 128 + +#define TASK_KILLABLE (TASK_WAKEKILL | TASK_UNINTERRUPTIBLE) + +#define schedule_timeout_killable(_arg) schedule_timeout_interruptible(_arg) + +static inline pid_t task_pid_nr(struct task_struct *tsk) +{ + return tsk->pid; +} + +static inline int +backport_set_cpus_allowed_ptr(struct task_struct *p, const cpumask_t new_mask) +{ + return set_cpus_allowed(p, new_mask); +} +#define set_cpus_allowed_ptr backport_set_cpus_allowed_ptr + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/security.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/security.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/security.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/security.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,54 @@ +#ifndef BACKPORT_LINUX_SECURITY_H +#define BACKPORT_LINUX_SECURITY_H + +#include_next + +struct security_mnt_opts { + char **mnt_opts; + int *mnt_opts_flags; + int num_mnt_opts; +}; + +static inline void security_init_mnt_opts(struct security_mnt_opts *opts) +{ + opts->mnt_opts = NULL; + opts->mnt_opts_flags = NULL; + opts->num_mnt_opts = 0; +} + +static inline void security_free_mnt_opts(struct security_mnt_opts *opts) +{ + int i; + if (opts->mnt_opts) + for (i = 0; i < opts->num_mnt_opts; i++) + kfree(opts->mnt_opts[i]); + kfree(opts->mnt_opts); + opts->mnt_opts = NULL; + kfree(opts->mnt_opts_flags); + opts->mnt_opts_flags = NULL; + opts->num_mnt_opts = 0; +} + +static inline int security_sb_set_mnt_opts(struct super_block *sb, + struct security_mnt_opts *opts) +{ + return 0; +} + +static inline void security_sb_clone_mnt_opts(const struct super_block *oldsb, + struct super_block *newsb) +{ } + +static inline int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts) +{ + return 0; +} + +static inline int backport_security_sb_copy_data(void *orig, void *copy) +{ + return 0; +} + +#define security_sb_copy_data(a,b) backport_security_sb_copy_data(a,b) + +#endif /* BACKPORT_LINUX_SECURITY_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/semaphore.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/semaphore.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/semaphore.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/semaphore.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,6 @@ +#ifndef __BACKPORT_LINUX_SEMAPHORE_H_TO_2_6_25__ +#define __BACKPORT_LINUX_SEMAPHORE_H_TO_2_6_25__ + +#include_next + +#endif /* __BACKPORT_LINUX_SEMAPHORE_H_TO_2_6_25__ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/skbuff.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/skbuff.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/skbuff.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/skbuff.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,38 @@ +#ifndef LINUX_SKBUFF_H_BACKPORT +#define LINUX_SKBUFF_H_BACKPORT + +#include_next + +#define CHECKSUM_PARTIAL CHECKSUM_HW +#define CHECKSUM_COMPLETE CHECKSUM_HW + +static inline void skb_set_queue_mapping(struct sk_buff *skb, int mapping) +{ + skb->priority = mapping; +} + +#endif +#ifndef __BACKPORT_LINUX_SKBUFF_H_TO_2_6_21__ +#define __BACKPORT_LINUX_SKBUFF_H_TO_2_6_21__ + +#include_next + +#define transport_header h.raw +#define network_header nh.raw + +static inline int skb_csum_unnecessary(const struct sk_buff *skb) +{ + return skb->ip_summed & CHECKSUM_UNNECESSARY; +} + +static inline void skb_record_rx_queue(struct sk_buff *skb, u16 rx_queue) +{ +} + + +#define skb_queue_walk_safe(queue, skb, tmp) \ + for (skb = (queue)->next, tmp = skb->next; \ + skb != (struct sk_buff *)(queue); \ + skb = tmp, tmp = skb->next) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/slab.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/slab.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/slab.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/slab.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,20 @@ +#include_next + +#ifndef LINUX_SLAB_BACKPORT_tO_2_6_22_H +#define LINUX_SLAB_BACKPORT_tO_2_6_22_H + +#include_next + +static inline +struct kmem_cache * +kmem_cache_create_for_2_6_22 (const char *name, size_t size, size_t align, + unsigned long flags, + void (*ctor)(void*, struct kmem_cache *, unsigned long) + ) +{ + return kmem_cache_create(name, size, align, flags, ctor, NULL); +} + +#define kmem_cache_create kmem_cache_create_for_2_6_22 + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/smp_lock.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/smp_lock.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/smp_lock.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/smp_lock.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,18 @@ +#ifndef LINUX_SMPLOCK_BACKPORT_tO_2_6_26_H +#define LINUX_SMPLOCK_BACKPORT_tO_2_6_26_H + +#include_next + +/* + * Various legacy drivers don't really need the BKL in a specific + * function, but they *do* need to know that the BKL became available. + * This function just avoids wrapping a bunch of lock/unlock pairs + * around code which doesn't really need it. + */ +static inline void cycle_kernel_lock(void) +{ + lock_kernel(); + unlock_kernel(); +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/socket.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/socket.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/socket.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/socket.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,10 @@ +#ifndef __BACKPORT__LINUX_SOCKET_H +#define __BACKPORT__LINUX_SOCKET_H + +#include_next + +#define AF_RDS 21 /* RDS sockets */ +#define PF_RDS AF_RDS +#define SOL_RDS 276 + +#endif /* __BACKPORT__LINUX_SOCKET_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/splice.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/splice.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/splice.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/splice.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,4 @@ +#ifndef BACKPORT_LINUX_SPLICE_H +#define BACKPORT_LINUX_SPLICE_H + +#endif /* BACKPORT_LINUX_SPLICE_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/string.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/string.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/string.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/string.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,51 @@ +#ifndef BACKPORT_LINUX_STRING_H +#define BACKPORT_LINUX_STRING_H + +#include_next +#include + +extern void *__kmalloc(size_t, gfp_t); + +static inline char *kstrndup(const char *s, size_t max, gfp_t gfp) +{ + size_t len; + char *buf; + + if (!s) + return NULL; + + len = strnlen(s, max); + buf = __kmalloc(len+1, gfp); + if (buf) { + memcpy(buf, s, len); + buf[len] = '\0'; + } + return buf; +} + +static inline char *skip_spaces(const char *str) +{ + while (isspace(*str)) + ++str; + return (char *)str; +} + +static inline char *strim(char *s) +{ + size_t size; + char *end; + + s = skip_spaces(s); + size = strlen(s); + if (!size) + return s; + + end = s + size - 1; + while (end >= s && isspace(*end)) + end--; + *(end + 1) = '\0'; + + return s; +} + +#endif /* BACKPORT_LINUX_STRING_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/swap.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/swap.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/swap.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/swap.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,28 @@ +#ifndef LINUX_SWAP_BACKPORT_H +#define LINUX_SWAP_BACKPORT_H + +#include_next + +static inline unsigned int backport_nr_free_buffer_pages(void) +{ + /* Just pick one node, since fallback list is circular */ + pg_data_t *pgdat = NODE_DATA(numa_node_id()); + unsigned int sum = 0; + + struct zonelist *zonelist = pgdat->node_zonelists + gfp_zone(GFP_USER); + struct zone **zonep = zonelist->zones; + struct zone *zone; + + for (zone = *zonep++; zone; zone = *zonep++) { + unsigned long size = zone->present_pages; + unsigned long high = zone->pages_high; + if (size > high) + sum += size - high; + } + + return sum; +} + +#define nr_free_buffer_pages backport_nr_free_buffer_pages + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/sysctl.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/sysctl.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/sysctl.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/sysctl.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,83 @@ +#ifndef __BACKPORT_SYSCTL_H_TO_2_6_18__ +#define __BACKPORT_SYSCTL_H_TO_2_6_18__ + +#include +#include +#include_next + +#define CTL_NONE 0 +#define CTL_UNNUMBERED -2 /* sysctl without a binary number */ + +#define CTL_SUNRPC 7249 /* sunrpc debug */ + +/* struct ctl_path describes where in the hierarchy a table is added */ +struct ctl_path { + const char *procname; + int ctl_name; +}; + +#define FAKE_SYSCTL_MAGIC1 ((void *) 0xcafebabe) + +static inline void __fake_sysctl_table_destroy(struct ctl_table *node) +{ + struct ctl_table *next; + + while (node && node[1].extra1 == FAKE_SYSCTL_MAGIC1) { + next = node->child; + kfree(node); + node = next; + } +} + +/* + * Given a ctl_path and a ctl_table, convert this to the old-fashioned + * table hierarchy, linked through table->child. + */ +static inline struct ctl_table_header * +register_sysctl_paths(const struct ctl_path *path, struct ctl_table *table) +{ + struct ctl_table_header *result = NULL; + struct ctl_table *root = NULL, *tp, **prev = &root; + + for (; path->procname; ++path) { + tp = kzalloc(2 * sizeof(struct ctl_table), GFP_KERNEL); + if (!tp) + goto out; + + tp->ctl_name = path->ctl_name; + tp->procname = path->procname; + tp->mode = 0555; + tp[1].extra1 = FAKE_SYSCTL_MAGIC1; + *prev = tp; + prev = &tp->child; + } + *prev = table; + + result = register_sysctl_table(root, 0); + +out: + if (result == NULL) + __fake_sysctl_table_destroy(root); + + return result; +} + +static inline void +fake_unregister_sysctl_table(struct ctl_table_header *hdr) +{ + struct ctl_table *node = hdr->ctl_table; + + unregister_sysctl_table(hdr); + __fake_sysctl_table_destroy(node); +} + +#define unregister_sysctl_table(hdr) fake_unregister_sysctl_table(hdr) + +static inline struct ctl_table_header * +backport_register_sysctl_table(ctl_table *table) { + return register_sysctl_table(table, 0); +} + +#define register_sysctl_table backport_register_sysctl_table + +#endif /* __BACKPORT_SYSCTL_H_TO_2_6_18__ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/types.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/types.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/types.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/types.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,9 @@ +#ifndef BACKPORT_LINUX_TYPES_H +#define BACKPORT_LINUX_TYPES_H + +#include_next + +typedef unsigned long uintptr_t; + +#endif /* BACKPORT_LINUX_TYPES_H */ + diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/unaligned/access_ok.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/unaligned/access_ok.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/unaligned/access_ok.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/unaligned/access_ok.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,67 @@ +#ifndef _LINUX_UNALIGNED_ACCESS_OK_H +#define _LINUX_UNALIGNED_ACCESS_OK_H + +#include +#include + +static inline u16 get_unaligned_le16(const void *p) +{ + return le16_to_cpup((__le16 *)p); +} + +static inline u32 get_unaligned_le32(const void *p) +{ + return le32_to_cpup((__le32 *)p); +} + +static inline u64 get_unaligned_le64(const void *p) +{ + return le64_to_cpup((__le64 *)p); +} + +static inline u16 get_unaligned_be16(const void *p) +{ + return be16_to_cpup((__be16 *)p); +} + +static inline u32 get_unaligned_be32(const void *p) +{ + return be32_to_cpup((__be32 *)p); +} + +static inline u64 get_unaligned_be64(const void *p) +{ + return be64_to_cpup((__be64 *)p); +} + +static inline void put_unaligned_le16(u16 val, void *p) +{ + *((__le16 *)p) = cpu_to_le16(val); +} + +static inline void put_unaligned_le32(u32 val, void *p) +{ + *((__le32 *)p) = cpu_to_le32(val); +} + +static inline void put_unaligned_le64(u64 val, void *p) +{ + *((__le64 *)p) = cpu_to_le64(val); +} + +static inline void put_unaligned_be16(u16 val, void *p) +{ + *((__be16 *)p) = cpu_to_be16(val); +} + +static inline void put_unaligned_be32(u32 val, void *p) +{ + *((__be32 *)p) = cpu_to_be32(val); +} + +static inline void put_unaligned_be64(u64 val, void *p) +{ + *((__be64 *)p) = cpu_to_be64(val); +} + +#endif /* _LINUX_UNALIGNED_ACCESS_OK_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/wait.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/wait.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/wait.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/wait.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,47 @@ +#ifndef BACKPORT_LINUX_WAIT_H +#define BACKPORT_LINUX_WAIT_H + +#include_next + +#define __wait_event_killable(wq, condition, ret) \ +do { \ + DEFINE_WAIT(__wait); \ + \ + for (;;) { \ + prepare_to_wait(&wq, &__wait, TASK_KILLABLE); \ + if (condition) \ + break; \ + if (!fatal_signal_pending(current)) { \ + schedule(); \ + continue; \ + } \ + ret = -ERESTARTSYS; \ + break; \ + } \ + finish_wait(&wq, &__wait); \ +} while (0) + +/** + * wait_event_killable - sleep until a condition gets true + * @wq: the waitqueue to wait on + * @condition: a C expression for the event to wait for + * + * The process is put to sleep (TASK_KILLABLE) until the + * @condition evaluates to true or a signal is received. + * The @condition is checked each time the waitqueue @wq is woken up. + * + * wake_up() has to be called after changing any variable that could + * change the result of the wait condition. + * + * The function will return -ERESTARTSYS if it was interrupted by a + * signal and 0 if @condition evaluated to true. + */ +#define wait_event_killable(wq, condition) \ +({ \ + int __ret = 0; \ + if (!(condition)) \ + __wait_event_killable(wq, condition, __ret); \ + __ret; \ +}) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/workqueue.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/workqueue.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/workqueue.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/linux/workqueue.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,92 @@ +#ifndef BACKPORT_LINUX_WORKQUEUE_TO_2_6_19 +#define BACKPORT_LINUX_WORKQUEUE_TO_2_6_19 + +#include_next + +void msleep(unsigned int msecs); + +static inline void +backport_INIT_WORK(struct work_struct *work, void *func) +{ + INIT_WORK(work, func, work); +} + +static inline int backport_queue_delayed_work(struct workqueue_struct *wq, + struct delayed_work *work, + unsigned long delay) +{ + if (likely(!delay)) + return queue_work(wq, &work->work); + else + return queue_delayed_work(wq, &work->work, delay); +} + +static inline int +backport_delayed_work_pending(struct delayed_work *work) +{ + return delayed_work_pending(&work->work); +} + +static inline int +backport_cancel_delayed_work(struct delayed_work *work) +{ + return cancel_delayed_work(&work->work); +} + +static inline int +backport_cancel_delayed_work_sync(struct delayed_work *work) +{ + cancel_delayed_work(&work->work); + while (delayed_work_pending(&work->work)) + msleep(1); + return 0; +} + +static inline void +backport_cancel_rearming_delayed_workqueue(struct workqueue_struct *wq, struct delayed_work *work) +{ + cancel_rearming_delayed_workqueue(wq, &work->work); +} + +static inline +int backport_schedule_delayed_work(struct delayed_work *work, unsigned long delay) +{ + if (likely(!delay)) + return schedule_work(&work->work); + else + return schedule_delayed_work(&work->work, delay); +} + +#define delayed_work_pending backport_delayed_work_pending + +#undef INIT_WORK +#define INIT_WORK(_work, _func) backport_INIT_WORK(_work, _func) +#undef INIT_DELAYED_WORK +#define INIT_DELAYED_WORK(_work, _func) INIT_WORK(&(_work)->work, _func) +#define INIT_DELAYED_WORK_DEFERRABLE(_work, _func) INIT_DELAYED_WORK(_work, _func) + +#undef DECLARE_WORK +#define DECLARE_WORK(n, f) \ + struct work_struct n = __WORK_INITIALIZER(n, (void (*)(void *))f, &(n)) +#define DECLARE_DELAYED_WORK(n, f) \ + struct delayed_work n = { .work = __WORK_INITIALIZER(n.work, (void (*)(void *))f, &(n.work)) } + +#define queue_delayed_work backport_queue_delayed_work +#define cancel_delayed_work backport_cancel_delayed_work +#define cancel_delayed_work_sync backport_cancel_delayed_work_sync +#define cancel_rearming_delayed_workqueue backport_cancel_rearming_delayed_workqueue +#define schedule_delayed_work backport_schedule_delayed_work + +static inline void backport_cancel_rearming_delayed_work(struct delayed_work *work) +{ + cancel_delayed_work_sync(work); +} + +#define cancel_rearming_delayed_work backport_cancel_rearming_delayed_work + +static inline struct delayed_work *to_delayed_work(struct work_struct *work) +{ + return container_of(work, struct delayed_work, work); +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/ip.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/ip.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/ip.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/ip.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,51 @@ +#ifndef __BACKPORT_NET_IP_H_TO_2_6_23__ +#define __BACKPORT_NET_IP_H_TO_2_6_23__ + +#include_next +#define inet_get_local_port_range(a, b) { *(a) = sysctl_local_port_range[0]; *(b) = sysctl_local_port_range[1]; } + +#endif + + +#ifndef __BACKPORT_IP_H_TO_2_6_24__ +#define __BACKPORT_IP_H_TO_2_6_24__ + +#include_next + +static inline void +backport_ip_ib_mc_map(__be32 naddr, const unsigned char *broadcast, char *buf) +{ + __u32 addr; + unsigned char scope = broadcast[5] & 0xF; + + buf[0] = 0; /* Reserved */ + buf[1] = 0xff; /* Multicast QPN */ + buf[2] = 0xff; + buf[3] = 0xff; + addr = ntohl(naddr); + buf[4] = 0xff; + buf[5] = 0x10 | scope; /* scope from broadcast address */ + buf[6] = 0x40; /* IPv4 signature */ + buf[7] = 0x1b; + buf[8] = broadcast[8]; /* P_Key */ + buf[9] = broadcast[9]; + buf[10] = 0; + buf[11] = 0; + buf[12] = 0; + buf[13] = 0; + buf[14] = 0; + buf[15] = 0; + buf[19] = addr & 0xff; + addr >>= 8; + buf[18] = addr & 0xff; + addr >>= 8; + buf[17] = addr & 0xff; + addr >>= 8; + buf[16] = addr & 0x0f; +} + +#undef ip_ib_mc_map + +#define ip_ib_mc_map(naddr, broadcast, buf) backport_ip_ib_mc_map(naddr, broadcast, buf) + +#endif /* __BACKPORT_IP_H_TO_2_6_24__ */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/ipv6.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/ipv6.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/ipv6.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/ipv6.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,21 @@ +#ifndef BACKPORT_NET_IPV6_H +#define BACKPORT_NET_IPV6_H + +#include_next + +static inline void ipv6_addr_set_v4mapped(const __be32 addr, + struct in6_addr *v4mapped) +{ + ipv6_addr_set(v4mapped, + 0, 0, + htonl(0x0000FFFF), + addr); +} + +static inline int ipv6_addr_v4mapped(const struct in6_addr *a) +{ + return ((a->s6_addr32[0] | a->s6_addr32[1] | + (a->s6_addr32[2] ^ htonl(0x0000ffff))) == 0); +} + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/neighbour.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/neighbour.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/neighbour.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/neighbour.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef __BACKPORT_NET_NEIGHBOUR_TO_2_6_20__ +#define __BACKPORT_NET_NEIGHBOUR_TO_2_6_20__ + +#include_next + +#define neigh_cleanup neigh_destructor + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/net_namespace.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/net_namespace.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/net_namespace.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/net_namespace.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,3 @@ +#ifndef __NET_NAMESPACE_H__ +#define __NET_NAMESPACE_H__ +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/route.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/route.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/route.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/route.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,13 @@ +#ifndef _BACKPORT_NET_ROUTE_H_ +#define _BACKPORT_NET_ROUTE_H_ + +#include_next + +#define ip_route_output_flow(net, rp, fl, sk, flags) \ + ip_route_output_flow(rp, fl, sk, flags) + +#define ip_route_output_key(net, rp, fl) ip_route_output_key(rp, fl) + +#define inet_addr_type(net, addr) inet_addr_type(addr) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/rtnetlink.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/rtnetlink.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/rtnetlink.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/rtnetlink.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,6 @@ +#ifndef __BACKPORT_RTNETLINK_TO_2_6_27__ +#define __BACKPORT_RTNETLINK_TO_2_6_27__ + +#include + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/sock.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/sock.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/sock.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/sock.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,17 @@ +#ifndef _NET_SOCK_LOCKDEP_BACKPORT_H +#define _NET_SOCK_LOCKDEP_BACKPORT_H + +#include_next + +#define lock_sock_nested(_sk, _subclass) lock_sock(sk) + +#endif + +#ifndef _NET_SOCK_MEM_BACKPORT_H +#define _NET_SOCK_MEM_BACKPORT_H + +#define SK_MEM_SEND 0 +#define SK_MEM_RECV 1 + +#endif + diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/udp.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/udp.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/udp.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/net/udp.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,9 @@ +#ifndef BACKPORT_NET_UDP_H +#define BACKPORT_NET_UDP_H + +#include_next + +static inline void UDPX_INC_STATS_BH(struct sock *sk, int field) +{ } + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_cmnd.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_cmnd.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_cmnd.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_cmnd.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,13 @@ +#ifndef SCSI_SCSI_CMND_BACKPORT_TO_2_6_22_H +#define SCSI_SCSI_CMND_BACKPORT_TO_2_6_22_H + +#include_next + +#define scsi_sg_count(cmd) ((cmd)->use_sg) +#define scsi_sglist(cmd) ((struct scatterlist *)(cmd)->request_buffer) +#define scsi_bufflen(cmd) ((cmd)->request_bufflen) + +#define scsi_for_each_sg(cmd, sg, nseg, __i) \ + for (__i = 0, sg = scsi_sglist(cmd); __i < (nseg); __i++, (sg)++) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_device.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_device.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_device.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_device.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,8 @@ +#ifndef SCSI_SCSI_DEVICE_BACKPORT_TO_2_6_26_H +#define SCSI_SCSI_DEVICE_BACKPORT_TO_2_6_26_H + +#include_next + +#define __starget_for_each_device(scsi_target, p, fn) starget_for_each_device(scsi_target, p, fn) + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,7 @@ +#ifndef SCSI_SCSI_H_BACKPORT +#define SCSI_SCSI_H_BACKPORT + +#include_next + +#define SCSI_MAX_VARLEN_CDB_SIZE 260 +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_transport.h ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_transport.h --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_transport.h 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/scsi/scsi_transport.h 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,7 @@ +#ifndef SCSI_SCSI_TRANSPORT_BACKPORT_TO_2_6_22_H +#define SCSI_SCSI_TRANSPORT_BACKPORT_TO_2_6_22_H + +#include +#include_next + +#endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/src/namespace.c ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/src/namespace.c --- prev-ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/src/namespace.c 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_addons/backport/2.6.18-EL5.8/include/src/namespace.c 2012-09-27 11:40:07.000000000 +0200 @@ -0,0 +1,95 @@ +#include +#include +#include +#include + +struct mnt_writer { + /* + * If holding multiple instances of this lock, they + * must be ordered by cpu number. + */ + spinlock_t lock; + struct lock_class_key lock_class; /* compiles out with !lockdep */ + unsigned long count; + struct vfsmount *mnt; +} ____cacheline_aligned_in_smp; +static DEFINE_PER_CPU(struct mnt_writer, mnt_writers); + +int __init init_mnt_writers(void) +{ + int cpu; + for_each_possible_cpu(cpu) { + struct mnt_writer *writer = &per_cpu(mnt_writers, cpu); + spin_lock_init(&writer->lock); + lockdep_set_class(&writer->lock, &writer->lock_class); + writer->count = 0; + } + return 0; +} + +static inline void __clear_mnt_count(struct mnt_writer *cpu_writer) +{ + if (!cpu_writer->mnt) + return; + /* + * This is in case anyone ever leaves an invalid, + * old ->mnt and a count of 0. + */ + if (!cpu_writer->count) + return; + cpu_writer->count = 0; +} + +static inline void use_cpu_writer_for_mount(struct mnt_writer *cpu_writer, + struct vfsmount *mnt) +{ + if (cpu_writer->mnt == mnt) + return; + __clear_mnt_count(cpu_writer); + cpu_writer->mnt = mnt; +} + +int mnt_want_write(struct vfsmount *mnt) +{ + int ret = 0; + struct mnt_writer *cpu_writer; + + cpu_writer = &get_cpu_var(mnt_writers); + spin_lock(&cpu_writer->lock); + if (__mnt_is_readonly(mnt)) { + ret = -EROFS; + goto out; + } + use_cpu_writer_for_mount(cpu_writer, mnt); + cpu_writer->count++; +out: + spin_unlock(&cpu_writer->lock); + put_cpu_var(mnt_writers); + return ret; +} +EXPORT_SYMBOL(mnt_want_write); + +void mnt_drop_write(struct vfsmount *mnt) +{ + struct mnt_writer *cpu_writer; + + cpu_writer = &get_cpu_var(mnt_writers); + spin_lock(&cpu_writer->lock); + + use_cpu_writer_for_mount(cpu_writer, mnt); + if (cpu_writer->count > 0) { + cpu_writer->count--; + } + + spin_unlock(&cpu_writer->lock); + /* + * This could be done right after the spinlock + * is taken because the spinlock keeps us on + * the cpu, and disables preemption. However, + * putting it here bounds the amount that + * __mnt_writers can underflow. Without it, + * we could theoretically wrap __mnt_writers. + */ + put_cpu_var(mnt_writers); +} +EXPORT_SYMBOL(mnt_drop_write); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/2_misc_device_to_2_6_19.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/2_misc_device_to_2_6_19.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/2_misc_device_to_2_6_19.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/2_misc_device_to_2_6_19.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,56 @@ +>Post a replacement to 2_misc_device_to_2_6_19.patch, we'll test. + +I did not test this patch, but you can try replacing the contents of +the 2_misc_device_to_2_6_19.patch with the changes below. (It's +possible that this may lead to some conflict further down in the patch +chain...) The function prototype for show_abi_version changed between +2.6.20 to 2.6.19; this was the missing piece in the original backport +patch. I would have expected a build warning for this. + +Signed-off-by: Sean Hefty + +--- +--- + drivers/infiniband/core/ucma.c | 12 ++++++------ + 1 file changed, 6 insertions(+), 6 deletions(-) + +Index: ofed_kernel/drivers/infiniband/core/ucma.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/ucma.c ++++ ofed_kernel/drivers/infiniband/core/ucma.c +@@ -1207,13 +1207,11 @@ static struct miscdevice ucma_misc = { + .fops = &ucma_fops, + }; + +-static ssize_t show_abi_version(struct device *dev, +- struct device_attribute *attr, +- char *buf) ++static ssize_t show_abi_version(struct class_device *class_dev, char *buf) + { + return sprintf(buf, "%d\n", RDMA_USER_CM_ABI_VERSION); + } +-static DEVICE_ATTR(abi_version, S_IRUGO, show_abi_version, NULL); ++static CLASS_DEVICE_ATTR(abi_version, S_IRUGO, show_abi_version, NULL); + + static int __init ucma_init(void) + { +@@ -1223,7 +1221,8 @@ static int __init ucma_init(void) + if (ret) + return ret; + +- ret = device_create_file(ucma_misc.this_device, &dev_attr_abi_version); ++ ret = class_device_create_file(ucma_misc.class, ++ &class_device_attr_abi_version); + if (ret) { + printk(KERN_ERR "rdma_ucm: couldn't create abi_version attr\n"); + goto err; +@@ -1236,7 +1235,8 @@ err: + + static void __exit ucma_cleanup(void) + { +- device_remove_file(ucma_misc.this_device, &dev_attr_abi_version); ++ class_device_remove_file(ucma_misc.class, ++ &class_device_attr_abi_version); + misc_deregister(&ucma_misc); + idr_destroy(&ctx_idr); + } diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/amso_0010_pass_ird_ord_upwards.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/amso_0010_pass_ird_ord_upwards.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/amso_0010_pass_ird_ord_upwards.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/amso_0010_pass_ird_ord_upwards.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,32 @@ +diff --git a/drivers/infiniband/hw/amso1100/c2_ae.c b/drivers/infiniband/hw/amso1100/c2_ae.c +index 62af742..21145aa 100644 +--- a/drivers/infiniband/hw/amso1100/c2_ae.c ++++ b/drivers/infiniband/hw/amso1100/c2_ae.c +@@ -288,6 +288,11 @@ void c2_ae_event(struct c2_dev *c2dev, u32 mq_index) + cm_event.private_data_len = + be32_to_cpu(req->private_data_length); + cm_event.private_data = req->private_data; ++ /* ++ * Until ird/ord negotiation via MPA_v2 support is added, send ++ * max supported values ++ */ ++ cm_event.ird = cm_event.ord = 128; + + if (cm_id->event_handler) + cm_id->event_handler(cm_id, &cm_event); +diff --git a/drivers/infiniband/hw/amso1100/c2_intr.c b/drivers/infiniband/hw/amso1100/c2_intr.c +index 3b50954..5f5447f 100644 +--- a/drivers/infiniband/hw/amso1100/c2_intr.c ++++ b/drivers/infiniband/hw/amso1100/c2_intr.c +@@ -183,6 +183,11 @@ static void handle_vq(struct c2_dev *c2dev, u32 mq_index) + case IW_CM_EVENT_ESTABLISHED: + c2_set_qp_state(req->qp, + C2_QP_STATE_RTS); ++ /* ++ * Until ird/ord negotiation via MPA_v2 support is added, send ++ * max supported values ++ */ ++ cm_event.ird = cm_event.ord = 128; + case IW_CM_EVENT_CLOSE: + + /* diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cma_to_2_6_23.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cma_to_2_6_23.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cma_to_2_6_23.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cma_to_2_6_23.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,23 @@ +--- + drivers/infiniband/core/cma.c | 5 +---- + 1 file changed, 1 insertion(+), 4 deletions(-) + +Index: ofed_kernel/drivers/infiniband/core/cma.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/cma.c ++++ ofed_kernel/drivers/infiniband/core/cma.c +@@ -2835,13 +2835,10 @@ static int cma_netdev_callback(struct no + struct rdma_id_private *id_priv; + int ret = NOTIFY_DONE; + +- if (dev_net(ndev) != &init_net) +- return NOTIFY_DONE; +- + if (event != NETDEV_BONDING_FAILOVER) + return NOTIFY_DONE; + +- if (!(ndev->flags & IFF_MASTER) || !(ndev->priv_flags & IFF_BONDING)) ++ if (!(ndev->flags & IFF_MASTER)) + return NOTIFY_DONE; + + mutex_lock(&lock); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_u2_6_21_lock-timer-deadlock-undo.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_u2_6_21_lock-timer-deadlock-undo.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_u2_6_21_lock-timer-deadlock-undo.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_u2_6_21_lock-timer-deadlock-undo.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,140 @@ +Backports: IB/mad: Undo Fix possible lock-lock-timer deadlock patch + +Undo commit 922854caaa105594fe3a78b5fea57fc6cbea17ea +Kernels 2.6.21 and earlier do not have cancel_work_sync(). + +Signed-off-by: Jack Morgenstein + +diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c +index de922a0..e8c05b2 100644 +--- a/drivers/infiniband/core/mad.c ++++ b/drivers/infiniband/core/mad.c +@@ -175,15 +175,6 @@ int ib_response_mad(struct ib_mad *mad) + } + EXPORT_SYMBOL(ib_response_mad); + +-static void timeout_callback(unsigned long data) +-{ +- struct ib_mad_agent_private *mad_agent_priv = +- (struct ib_mad_agent_private *) data; +- +- queue_work(mad_agent_priv->qp_info->port_priv->wq, +- &mad_agent_priv->timeout_work); +-} +- + /* + * ib_register_mad_agent - Register to send/receive MADs + */ +@@ -315,9 +306,7 @@ struct ib_mad_agent *ib_register_mad_agent(struct ib_device *device, + INIT_LIST_HEAD(&mad_agent_priv->wait_list); + INIT_LIST_HEAD(&mad_agent_priv->done_list); + INIT_LIST_HEAD(&mad_agent_priv->rmpp_list); ++ INIT_DELAYED_WORK(&mad_agent_priv->timed_work, timeout_sends); +- INIT_WORK(&mad_agent_priv->timeout_work, timeout_sends); +- setup_timer(&mad_agent_priv->timeout_timer, timeout_callback, +- (unsigned long) mad_agent_priv); + INIT_LIST_HEAD(&mad_agent_priv->local_list); + INIT_WORK(&mad_agent_priv->local_work, local_completions); + atomic_set(&mad_agent_priv->refcount, 1); +@@ -524,8 +513,7 @@ static void unregister_mad_agent(struct ib_mad_agent_private *mad_agent_priv) + */ + cancel_mads(mad_agent_priv); + port_priv = mad_agent_priv->qp_info->port_priv; ++ cancel_delayed_work(&mad_agent_priv->timed_work); +- del_timer_sync(&mad_agent_priv->timeout_timer); +- cancel_work_sync(&mad_agent_priv->timeout_work); + + spin_lock_irqsave(&port_priv->reg_lock, flags); + remove_mad_reg_req(mad_agent_priv); +@@ -1983,9 +1971,10 @@ out: + static void adjust_timeout(struct ib_mad_agent_private *mad_agent_priv) + { + struct ib_mad_send_wr_private *mad_send_wr; ++ unsigned long delay; + + if (list_empty(&mad_agent_priv->wait_list)) { ++ cancel_delayed_work(&mad_agent_priv->timed_work); +- del_timer(&mad_agent_priv->timeout_timer); + } else { + mad_send_wr = list_entry(mad_agent_priv->wait_list.next, + struct ib_mad_send_wr_private, +@@ -1994,8 +1983,13 @@ static void adjust_timeout(struct ib_mad_agent_private *mad_agent_priv) + if (time_after(mad_agent_priv->timeout, + mad_send_wr->timeout)) { + mad_agent_priv->timeout = mad_send_wr->timeout; ++ cancel_delayed_work(&mad_agent_priv->timed_work); ++ delay = mad_send_wr->timeout - jiffies; ++ if ((long)delay <= 0) ++ delay = 1; ++ queue_delayed_work(mad_agent_priv->qp_info-> ++ port_priv->wq, ++ &mad_agent_priv->timed_work, delay); +- mod_timer(&mad_agent_priv->timeout_timer, +- mad_send_wr->timeout); + } + } + } +@@ -2022,14 +2016,17 @@ static void wait_for_response(struct ib_mad_send_wr_private *mad_send_wr) + temp_mad_send_wr->timeout)) + break; + } ++ } ++ else +- } else + list_item = &mad_agent_priv->wait_list; + list_add(&mad_send_wr->agent_list, list_item); + + /* Reschedule a work item if we have a shorter timeout */ ++ if (mad_agent_priv->wait_list.next == &mad_send_wr->agent_list) { ++ cancel_delayed_work(&mad_agent_priv->timed_work); ++ queue_delayed_work(mad_agent_priv->qp_info->port_priv->wq, ++ &mad_agent_priv->timed_work, delay); ++ } +- if (mad_agent_priv->wait_list.next == &mad_send_wr->agent_list) +- mod_timer(&mad_agent_priv->timeout_timer, +- mad_send_wr->timeout); + } + + void ib_reset_mad_timeout(struct ib_mad_send_wr_private *mad_send_wr, +@@ -2473,10 +2470,10 @@ static void timeout_sends(struct work_struct *work) + struct ib_mad_agent_private *mad_agent_priv; + struct ib_mad_send_wr_private *mad_send_wr; + struct ib_mad_send_wc mad_send_wc; ++ unsigned long flags, delay; +- unsigned long flags; + + mad_agent_priv = container_of(work, struct ib_mad_agent_private, ++ timed_work.work); +- timeout_work); + mad_send_wc.vendor_err = 0; + + spin_lock_irqsave(&mad_agent_priv->lock, flags); +@@ -2486,8 +2483,12 @@ static void timeout_sends(struct work_struct *work) + agent_list); + + if (time_after(mad_send_wr->timeout, jiffies)) { ++ delay = mad_send_wr->timeout - jiffies; ++ if ((long)delay <= 0) ++ delay = 1; ++ queue_delayed_work(mad_agent_priv->qp_info-> ++ port_priv->wq, ++ &mad_agent_priv->timed_work, delay); +- mod_timer(&mad_agent_priv->timeout_timer, +- mad_send_wr->timeout); + break; + } + +diff --git a/drivers/infiniband/core/mad_priv.h b/drivers/infiniband/core/mad_priv.h +index 05ce331..1526fa2 100644 +--- a/drivers/infiniband/core/mad_priv.h ++++ b/drivers/infiniband/core/mad_priv.h +@@ -99,8 +99,7 @@ struct ib_mad_agent_private { + struct list_head send_list; + struct list_head wait_list; + struct list_head done_list; ++ struct delayed_work timed_work; +- struct work_struct timeout_work; +- struct timer_list timeout_timer; + unsigned long timeout; + struct list_head local_list; + struct work_struct local_work; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_2_25_device_create.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_2_25_device_create.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_2_25_device_create.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_2_25_device_create.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,66 @@ +backports: 2.6.25: fix device_create calls. + +Signed-off-by: Jack Morgenstein + +Index: ofed_kernel-2.6.25/drivers/infiniband/core/cm.c +=================================================================== +--- ofed_kernel-2.6.25.orig/drivers/infiniband/core/cm.c ++++ ofed_kernel-2.6.25/drivers/infiniband/core/cm.c +@@ -3738,7 +3738,7 @@ static void cm_add_one(struct ib_device + cm_get_ack_delay(cm_dev); + + cm_dev->device = device_create(&cm_class, &ib_device->dev, +- MKDEV(0, 0), NULL, ++ MKDEV(0, 0), + "%s", ib_device->name); + if (!cm_dev->device) { + kfree(cm_dev); +Index: ofed_kernel-2.6.25/drivers/infiniband/core/user_mad.c +=================================================================== +--- ofed_kernel-2.6.25.orig/drivers/infiniband/core/user_mad.c ++++ ofed_kernel-2.6.25/drivers/infiniband/core/user_mad.c +@@ -1017,8 +1017,7 @@ static int ib_umad_init_port(struct ib_d + goto err_cdev; + + port->dev = device_create(umad_class, device->dma_device, +- port->cdev->dev, port, +- "umad%d", port->dev_num); ++ port->cdev->dev, "umad%d", port->dev_num); + if (IS_ERR(port->dev)) + goto err_cdev; + +@@ -1037,11 +1036,14 @@ static int ib_umad_init_port(struct ib_d + goto err_sm_cdev; + + port->sm_dev = device_create(umad_class, device->dma_device, +- port->sm_cdev->dev, port, ++ port->sm_cdev->dev, + "issm%d", port->dev_num); + if (IS_ERR(port->sm_dev)) + goto err_sm_cdev; + ++ dev_set_drvdata(port->dev, port); ++ dev_set_drvdata(port->sm_dev, port); ++ + if (device_create_file(port->sm_dev, &dev_attr_ibdev)) + goto err_sm_dev; + if (device_create_file(port->sm_dev, &dev_attr_port)) +Index: ofed_kernel-2.6.25/drivers/infiniband/core/uverbs_main.c +=================================================================== +--- ofed_kernel-2.6.25.orig/drivers/infiniband/core/uverbs_main.c ++++ ofed_kernel-2.6.25/drivers/infiniband/core/uverbs_main.c +@@ -801,11 +801,13 @@ static void ib_uverbs_add_one(struct ib_ + goto err_cdev; + + uverbs_dev->dev = device_create(uverbs_class, device->dma_device, +- uverbs_dev->cdev->dev, uverbs_dev, ++ uverbs_dev->cdev->dev, + "uverbs%d", uverbs_dev->devnum); + if (IS_ERR(uverbs_dev->dev)) + goto err_cdev; + ++ dev_set_drvdata(uverbs_dev->dev, uverbs_dev); ++ + if (device_create_file(uverbs_dev->dev, &dev_attr_ibdev)) + goto err_class; + if (device_create_file(uverbs_dev->dev, &dev_attr_abi_version)) diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_23_dev_get_by_index.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_23_dev_get_by_index.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_23_dev_get_by_index.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_23_dev_get_by_index.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,67 @@ +Backport patches for rdma cm patches + +Backport for dev_get_by_index() for v2.6.23 and earlier kernels. + +Signed-of-by: David Wilder +--- +Index: ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check/drivers/infiniband/core/addr.c +=================================================================== +--- ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check.orig/drivers/infiniband/core/addr.c 2010-02-15 23:26:59.000000000 +0200 ++++ ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check/drivers/infiniband/core/addr.c 2010-02-15 23:32:17.000000000 +0200 +@@ -107,7 +107,7 @@ int rdma_translate_ip(struct sockaddr *a + int ret = -EADDRNOTAVAIL; + + if (dev_addr->bound_dev_if) { +- dev = dev_get_by_index(&init_net, dev_addr->bound_dev_if); ++ dev = dev_get_by_index(dev_addr->bound_dev_if); + if (!dev) + return -ENODEV; + ret = rdma_copy_addr(dev_addr, dev, NULL); +Index: ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check/drivers/infiniband/core/cma.c +=================================================================== +--- ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check.orig/drivers/infiniband/core/cma.c 2010-02-15 23:27:29.000000000 +0200 ++++ ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check/drivers/infiniband/core/cma.c 2010-02-15 23:32:17.000000000 +0200 +@@ -1805,7 +1805,7 @@ static int cma_resolve_iboe_route(struct + route->num_paths = 1; + + if (addr->dev_addr.bound_dev_if) +- ndev = dev_get_by_index(&init_net, addr->dev_addr.bound_dev_if); ++ ndev = dev_get_by_index(addr->dev_addr.bound_dev_if); + if (!ndev) { + ret = -ENODEV; + goto err2; +@@ -3027,7 +3027,7 @@ static int cma_iboe_join_multicast(struc + mc->multicast.ib->rec.qkey = cpu_to_be32(RDMA_UDP_QKEY); + + if (dev_addr->bound_dev_if) +- ndev = dev_get_by_index(&init_net, dev_addr->bound_dev_if); ++ ndev = dev_get_by_index(dev_addr->bound_dev_if); + if (!ndev) { + err = -ENODEV; + goto out2; +Index: ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check/drivers/infiniband/core/ucma.c +=================================================================== +--- ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check.orig/drivers/infiniband/core/ucma.c 2010-02-15 23:27:01.000000000 +0200 ++++ ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check/drivers/infiniband/core/ucma.c 2010-02-15 23:27:29.000000000 +0200 +@@ -591,7 +591,7 @@ static void ucma_copy_iboe_route(struct + switch (route->num_paths) { + case 0: + dev_addr = &route->addr.dev_addr; +- dev = dev_get_by_index(&init_net, dev_addr->bound_dev_if); ++ dev = dev_get_by_index(dev_addr->bound_dev_if); + if (dev) { + vid = vlan_dev_vlan_id(dev); + dev_put(dev); +Index: ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check/include/rdma/ib_addr.h +=================================================================== +--- ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check.orig/include/rdma/ib_addr.h 2010-02-15 23:32:40.000000000 +0200 ++++ ofa_1_5_dev_kernel-20100215-2326_linux-2.6.23_check/include/rdma/ib_addr.h 2010-02-15 23:33:07.000000000 +0200 +@@ -148,7 +148,7 @@ static inline void iboe_addr_get_sgid(st + struct net_device *dev; + u16 vid = 0; + +- dev = dev_get_by_index(&init_net, dev_addr->bound_dev_if); ++ dev = dev_get_by_index(dev_addr->bound_dev_if); + if (dev) { + vid = vlan_dev_vlan_id(dev); + dev_put(dev); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_24_ipv6_ib_mc_map.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_24_ipv6_ib_mc_map.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_24_ipv6_ib_mc_map.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_24_ipv6_ib_mc_map.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,20 @@ +Backport patches for rdma cm patches + +Backport for ipv6_ib_mc_map() for kernel v2.6.24 and earlier. + +Signed-of-by: David Wilder +--- +diff -Naurp ofa_kernel.orig/drivers/infiniband/core/cma.c ofa_kernel/drivers/infiniband/core/cma.c +--- ofa_kernel.orig/drivers/infiniband/core/cma.c 2009-12-08 16:13:37.000000000 -0600 ++++ ofa_kernel/drivers/infiniband/core/cma.c 2009-12-08 16:19:09.000000000 -0600 +@@ -2774,7 +2774,7 @@ static void cma_set_mgid(struct rdma_id_ + /* IPv6 address is an SA assigned MGID. */ + memcpy(mgid, &sin6->sin6_addr, sizeof *mgid); + } else if ((addr->sa_family == AF_INET6)) { +- ipv6_ib_mc_map(&sin6->sin6_addr, dev_addr->broadcast, mc_map); ++ ipv6_ib_mc_map(&sin6->sin6_addr, mc_map); + if (id_priv->id.ps == RDMA_PS_UDP) + mc_map[7] = 0x01; /* Use RDMA CM signature */ + *mgid = *(union ib_gid *) (mc_map + 4); + + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_dev_set_name.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_dev_set_name.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_dev_set_name.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_dev_set_name.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,27 @@ +Index: ofed_kernel-2.6.25/drivers/infiniband/core/sysfs.c +=================================================================== +--- ofed_kernel-2.6.25.orig/drivers/infiniband/core/sysfs.c ++++ ofed_kernel-2.6.25/drivers/infiniband/core/sysfs.c +@@ -769,7 +769,7 @@ int ib_device_register_sysfs(struct ib_d + class_dev->class = &ib_class; + class_dev->driver_data = device; + class_dev->parent = device->dma_device; +- dev_set_name(class_dev, device->name); ++ strlcpy(class_dev->bus_id, device->name, BUS_ID_SIZE); + + INIT_LIST_HEAD(&device->port_list); + +Index: ofed_kernel-2.6.25/drivers/infiniband/core/ucm.c +=================================================================== +--- ofed_kernel-2.6.25.orig/drivers/infiniband/core/ucm.c ++++ ofed_kernel-2.6.25/drivers/infiniband/core/ucm.c +@@ -1266,7 +1266,8 @@ static void ib_ucm_add_one(struct ib_dev + ucm_dev->dev.parent = device->dma_device; + ucm_dev->dev.devt = ucm_dev->cdev.dev; + ucm_dev->dev.release = ib_ucm_release_dev; +- dev_set_name(&ucm_dev->dev, "ucm%d", ucm_dev->devnum); ++ snprintf(ucm_dev->dev.bus_id, BUS_ID_SIZE, "ucm%d", ++ ucm_dev->devnum); + if (device_register(&ucm_dev->dev)) + goto err_cdev; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_ip6_dev_get_saddr.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_ip6_dev_get_saddr.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_ip6_dev_get_saddr.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_ip6_dev_get_saddr.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,21 @@ +Backport patches for rdma cm patches + +Backport for ipv6_dev_get_saddr() for kernel v2.6.25 and earlier. + +Signed-of-by: David Wilder +--- +diff -Naurp ofa_kernel.orig/drivers/infiniband/core/addr.c ofa_kernel/drivers/infiniband/core/addr.c +--- ofa_kernel.orig/drivers/infiniband/core/addr.c 2009-12-10 11:45:06.000000000 -0600 ++++ ofa_kernel/drivers/infiniband/core/addr.c 2009-12-10 11:57:33.000000000 -0600 +@@ -248,8 +248,7 @@ static int addr6_resolve(struct sockaddr + goto put; + + if (ipv6_addr_any(&fl.fl6_src)) { +- ret = ipv6_dev_get_saddr(&init_net, ip6_dst_idev(dst)->dev, +- &fl.fl6_dst, 0, &fl.fl6_src); ++ ret = ipv6_get_saddr(dst, &fl.fl6_dst, &fl.fl6_src); + if (ret) + goto put; + + + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_ip6_route_output.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_ip6_route_output.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_ip6_route_output.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_v2_6_25_ip6_route_output.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,20 @@ +Backport patches for rdma cm patches + +Back port patch for ipv6_route_output() for kernels 2.6.25 and earlier. + +Signed-of-by: David Wilder +--- +diff -Naurp ofa_kernel.orig/drivers/infiniband/core/addr.c ofa_kernel/drivers/infiniband/core/addr.c +--- ofa_kernel.orig/drivers/infiniband/core/addr.c 2009-12-08 11:11:04.000000000 -0600 ++++ ofa_kernel/drivers/infiniband/core/addr.c 2009-12-08 11:13:44.000000000 -0600 +@@ -244,7 +244,7 @@ static int addr6_resolve(struct sockaddr + ipv6_addr_copy(&fl.fl6_src, &src_in->sin6_addr); + fl.oif = addr->bound_dev_if; + +- dst = ip6_route_output(&init_net, NULL, &fl); ++ dst = ip6_route_output(NULL, &fl); + if ((ret = dst->error)) + goto put; + + + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_w2_6_21_ip_check_addr_patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_w2_6_21_ip_check_addr_patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_w2_6_21_ip_check_addr_patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_0000_w2_6_21_ip_check_addr_patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,23 @@ +Backport patches for rdma cm patches + +Backport patch for ipv6_chk_addr() for kernel 2.6.21 and earlier. + +Signed-of-by: David Wilder +--- +diff -Naurp ofa_kernel.orig/drivers/infiniband/core/addr.c ofa_kernel/drivers/infiniband/core/addr.c +--- ofa_kernel.orig/drivers/infiniband/core/addr.c 2009-12-07 15:42:33.000000000 -0600 ++++ ofa_kernel/drivers/infiniband/core/addr.c 2009-12-07 15:57:24.000000000 -0600 +@@ -129,9 +129,8 @@ int rdma_translate_ip(struct sockaddr *a + #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) + case AF_INET6: + read_lock(&dev_base_lock); +- for_each_netdev(&init_net, dev) { +- if (ipv6_chk_addr(&init_net, +- &((struct sockaddr_in6 *) addr)->sin6_addr, ++ for (dev = dev_base; dev; dev = dev->next) { ++ if (ipv6_chk_addr(&((struct sockaddr_in6 *) addr)->sin6_addr, + dev, 1)) { + ret = rdma_copy_addr(dev_addr, dev, NULL); + break; + + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_1_kobject_backport.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_1_kobject_backport.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_1_kobject_backport.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_1_kobject_backport.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,186 @@ +--- + drivers/infiniband/core/Makefile | 4 + drivers/infiniband/core/kobject_backport.c | 160 +++++++++++++++++++++++++++++ + 2 files changed, 162 insertions(+), 2 deletions(-) + +Index: ofed_kernel/drivers/infiniband/core/Makefile +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/Makefile ++++ ofed_kernel/drivers/infiniband/core/Makefile +@@ -8,7 +8,7 @@ obj-$(CONFIG_INFINIBAND_USER_ACCESS) += + $(user_access-y) + + ib_core-y := packer.o ud_header.o verbs.o sysfs.o \ +- device.o fmr_pool.o cache.o ++ device.o fmr_pool.o cache.o kobject_backport.o + ib_core-$(CONFIG_INFINIBAND_USER_MEM) += umem.o + + ib_mad-y := mad.o smi.o agent.o mad_rmpp.o + +Index: ofed_kernel/drivers/infiniband/core/kobject_backport.c +=================================================================== +--- /dev/null ++++ ofed_kernel/drivers/infiniband/core/kobject_backport.c +@@ -0,0 +1,162 @@ ++#include ++#include ++#include ++ ++struct kobj_attribute { ++ struct attribute attr; ++ ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr, ++ char *buf); ++ ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr, ++ const char *buf, size_t count); ++}; ++ ++/* default kobject attribute operations */ ++static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr, ++ char *buf) ++{ ++ struct kobj_attribute *kattr; ++ ssize_t ret = -EIO; ++ ++ kattr = container_of(attr, struct kobj_attribute, attr); ++ if (kattr->show) ++ ret = kattr->show(kobj, kattr, buf); ++ return ret; ++} ++EXPORT_SYMBOL(kobject_create_and_add); ++ ++static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr, ++ const char *buf, size_t count) ++{ ++ struct kobj_attribute *kattr; ++ ssize_t ret = -EIO; ++ ++ kattr = container_of(attr, struct kobj_attribute, attr); ++ if (kattr->store) ++ ret = kattr->store(kobj, kattr, buf, count); ++ return ret; ++} ++ ++static struct sysfs_ops kobj_sysfs_ops = { ++ .show = kobj_attr_show, ++ .store = kobj_attr_store, ++}; ++ ++static void dynamic_kobj_release(struct kobject *kobj) ++{ ++ pr_debug("kobject: (%p): %s\n", kobj, __FUNCTION__); ++ kfree(kobj); ++} ++ ++static struct kobj_type dynamic_kobj_ktype = { ++ .release = dynamic_kobj_release, ++ .sysfs_ops = &kobj_sysfs_ops, ++}; ++ ++/** ++ * kobject_create_and_add - create a struct kobject dynamically and register it with sysfs ++ * ++ * @name: the name for the kset ++ * @parent: the parent kobject of this kobject, if any. ++ * ++ * This function creates a kobject structure dynamically and registers it ++ * with sysfs. When you are finished with this structure, call ++ * kobject_put() and the structure will be dynamically freed when ++ * it is no longer being used. ++ * ++ * If the kobject was not able to be created, NULL will be returned. ++ */ ++struct kobject *kobject_create_and_add(const char *name, struct kobject *parent) ++{ ++ struct kobject *kobj; ++ int retval; ++ ++ kobj = kzalloc(sizeof(*kobj), GFP_KERNEL); ++ if (!kobj) ++ return NULL; ++ ++ kobject_init(kobj); ++ kobj->ktype = &dynamic_kobj_ktype; ++ kobj->parent = parent; ++ ++ retval = kobject_set_name(kobj, "%s", name); ++ if (retval) { ++ printk(KERN_WARNING "%s: kobject_set_name error: %d\n", ++ __FUNCTION__, retval); ++ goto err; ++ } ++ ++ retval = kobject_add(kobj); ++ if (retval) { ++ printk(KERN_WARNING "%s: kobject_add error: %d\n", ++ __FUNCTION__, retval); ++ goto err; ++ } ++ ++ return kobj; ++ ++err: ++ kobject_put(kobj); ++ return NULL; ++} ++ ++/** ++ * kobject_init_and_add - initialize a kobject structure and add it to the kobject hierarchy ++ * @kobj: pointer to the kobject to initialize ++ * @ktype: pointer to the ktype for this kobject. ++ * @parent: pointer to the parent of this kobject. ++ * @fmt: the name of the kobject. ++ * ++ * This function combines the call to kobject_init() and ++ * kobject_add(). The same type of error handling after a call to ++ * kobject_add() and kobject lifetime rules are the same here. ++ */ ++int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype, ++ struct kobject *parent, const char *fmt, ...) ++{ ++ int retval; ++ int limit; ++ int need; ++ va_list args; ++ char *name; ++ ++ /* find out how big a buffer we need */ ++ name = kmalloc(1024, GFP_KERNEL); ++ if (!name) { ++ retval = -ENOMEM; ++ goto out; ++ } ++ va_start(args, fmt); ++ need = vsnprintf(name, 1024, fmt, args); ++ va_end(args); ++ kfree(name); ++ ++ /* Allocate the new space and copy the string in */ ++ limit = need + 1; ++ name = kmalloc(limit, GFP_KERNEL); ++ if (!name) { ++ retval = -ENOMEM; ++ goto out; ++ } ++ ++ va_start(args, fmt); ++ need = vsnprintf(name, limit, fmt, args); ++ va_end(args); ++ ++ kobject_init(kobj); ++ ++ kobj->ktype = ktype; ++ kobj->parent = parent; ++ ++ retval = kobject_set_name(kobj, name); ++ kfree(name); ++ if (retval) ++ goto out; ++ ++ retval = kobject_add(kobj); ++ if (retval) ++ goto out; ++ ++out: ++ return retval; ++} ++EXPORT_SYMBOL(kobject_init_and_add); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_2_kobject_unregister_to_2_6_24.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_2_kobject_unregister_to_2_6_24.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_2_kobject_unregister_to_2_6_24.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_2_kobject_unregister_to_2_6_24.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,64 @@ +--- + drivers/infiniband/core/cm.c | 8 ++++---- + drivers/infiniband/core/sysfs.c | 8 +++++--- + 2 files changed, 9 insertions(+), 7 deletions(-) + +Index: ofed_kernel/drivers/infiniband/core/cm.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/cm.c ++++ ofed_kernel/drivers/infiniband/core/cm.c +@@ -3696,8 +3696,8 @@ static int cm_create_port_fs(struct cm_p + + error: + while (i--) +- kobject_put(&port->counter_group[i].obj); +- kobject_put(&port->port_obj); ++ kobject_unregister(&port->counter_group[i].obj); ++ kobject_unregister(&port->port_obj); + return ret; + + } +@@ -3707,9 +3707,9 @@ static void cm_remove_port_fs(struct cm_ + int i; + + for (i = 0; i < CM_COUNTER_GROUPS; i++) +- kobject_put(&port->counter_group[i].obj); ++ kobject_unregister(&port->counter_group[i].obj); + +- kobject_put(&port->port_obj); ++ kobject_unregister(&port->port_obj); + } + + static void cm_add_one(struct ib_device *ib_device) +Index: ofed_kernel/drivers/infiniband/core/sysfs.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/sysfs.c ++++ ofed_kernel/drivers/infiniband/core/sysfs.c +@@ -838,11 +838,11 @@ err_put: + sysfs_remove_group(p, &pma_group); + sysfs_remove_group(p, &port->pkey_group); + sysfs_remove_group(p, &port->gid_group); +- kobject_put(p); ++ kobject_unregister(p); + } + } + +- kobject_put(&class_dev->kobj); ++ kobject_unregister(&class_dev->kobj); + + err_unregister: + device_unregister(class_dev); +@@ -862,10 +862,12 @@ void ib_device_unregister_sysfs(struct i + sysfs_remove_group(p, &pma_group); + sysfs_remove_group(p, &port->pkey_group); + sysfs_remove_group(p, &port->gid_group); +- kobject_put(p); ++ kobject_unregister(p); + } + + kobject_put(device->ports_parent); ++ /* WA for memory leak */ ++ kfree(device->ports_parent); + device_unregister(&device->dev); + } + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_2_z010_sysfs_to_2.6.18.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_2_z010_sysfs_to_2.6.18.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_2_z010_sysfs_to_2.6.18.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_2_z010_sysfs_to_2.6.18.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,32 @@ +--- a/drivers/infiniband/core/device.c 2009-02-24 14:00:50.387541000 +0200 ++++ b/drivers/infiniband/core/device.c 2009-02-24 14:00:54.891362000 +0200 +@@ -199,7 +199,7 @@ void ib_dealloc_device(struct ib_device + + BUG_ON(device->reg_state != IB_DEV_UNREGISTERED); + +- kobject_put(&device->dev.kobj); ++ ib_device_unregister_sysfs(device); + } + EXPORT_SYMBOL(ib_dealloc_device); + +@@ -356,8 +356,6 @@ void ib_unregister_device(struct ib_devi + + mutex_unlock(&device_mutex); + +- ib_device_unregister_sysfs(device); +- + spin_lock_irqsave(&device->client_data_lock, flags); + list_for_each_entry_safe(context, tmp, &device->client_data_list, list) + kfree(context); +--- a/drivers/infiniband/core/sysfs.c 2009-02-24 13:58:42.509754000 +0200 ++++ b/drivers/infiniband/core/sysfs.c 2009-02-24 14:00:54.894368000 +0200 +@@ -863,9 +863,6 @@ void ib_device_unregister_sysfs(struct i + struct kobject *p, *t; + struct ib_port *port; + +- /* Hold kobject until ib_dealloc_device() */ +- kobject_get(&device->dev.kobj); +- + list_for_each_entry_safe(p, t, &device->port_list, entry) { + list_del(&p->entry); + port = container_of(p, struct ib_port, kobj); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_3_sysfs_to_2_6_18.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_3_sysfs_to_2_6_18.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_3_sysfs_to_2_6_18.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_3_sysfs_to_2_6_18.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,761 @@ +--- + drivers/infiniband/core/cm.c | 2 + drivers/infiniband/core/sysfs.c | 172 ++++++++++++++++------------------ + drivers/infiniband/core/ucm.c | 62 ++++++------ + drivers/infiniband/core/user_mad.c | 109 ++++++++++----------- + drivers/infiniband/core/uverbs.h | 4 + drivers/infiniband/core/uverbs_main.c | 51 ++++------ + include/rdma/ib_verbs.h | 2 + 7 files changed, 199 insertions(+), 203 deletions(-) + +Index: ofed_kernel/drivers/infiniband/core/cm.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/cm.c ++++ ofed_kernel/drivers/infiniband/core/cm.c +@@ -3738,7 +3738,7 @@ static void cm_add_one(struct ib_device + cm_dev->ib_device = ib_device; + cm_get_ack_delay(cm_dev); + +- cm_dev->device = device_create(&cm_class, &ib_device->dev, ++ cm_dev->device = device_create(&cm_class, ib_device->class_dev.dev, + MKDEV(0, 0), + "%s", ib_device->name); + if (!cm_dev->device) { +Index: ofed_kernel/drivers/infiniband/core/sysfs.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/sysfs.c ++++ ofed_kernel/drivers/infiniband/core/sysfs.c +@@ -425,25 +425,28 @@ static struct kobj_type port_type = { + .default_attrs = port_default_attrs + }; + +-static void ib_device_release(struct device *device) ++static void ib_device_release(struct class_device *cdev) + { +- struct ib_device *dev = container_of(device, struct ib_device, dev); ++ struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + + kfree(dev); + } + +-static int ib_device_uevent(struct device *device, +- struct kobj_uevent_env *env) ++static int ib_device_uevent(struct class_device *cdev, char **envp, ++ int num_envp, char *buf, int size) + { +- struct ib_device *dev = container_of(device, struct ib_device, dev); ++ struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); ++ int i = 0, len = 0; + +- if (add_uevent_var(env, "NAME=%s", dev->name)) ++ if (add_uevent_var(envp, num_envp, &i, buf, size, &len, ++ "NAME=%s", dev->name)) + return -ENOMEM; + + /* + * It would be nice to pass the node GUID with the event... + */ + ++ envp[i] = NULL; + return 0; + } + +@@ -565,10 +568,9 @@ err_put: + return ret; + } + +-static ssize_t show_node_type(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_node_type(struct class_device *cdev, char *buf) + { +- struct ib_device *dev = container_of(device, struct ib_device, dev); ++ struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + + if (!ibdev_is_alive(dev)) + return -ENODEV; +@@ -582,10 +584,9 @@ static ssize_t show_node_type(struct dev + } + } + +-static ssize_t show_sys_image_guid(struct device *device, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_sys_image_guid(struct class_device *cdev, char *buf) + { +- struct ib_device *dev = container_of(device, struct ib_device, dev); ++ struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device_attr attr; + ssize_t ret; + +@@ -603,10 +604,9 @@ static ssize_t show_sys_image_guid(struc + be16_to_cpu(((__be16 *) &attr.sys_image_guid)[3])); + } + +-static ssize_t show_node_guid(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_node_guid(struct class_device *cdev, char *buf) + { +- struct ib_device *dev = container_of(device, struct ib_device, dev); ++ struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + + if (!ibdev_is_alive(dev)) + return -ENODEV; +@@ -618,19 +618,17 @@ static ssize_t show_node_guid(struct dev + be16_to_cpu(((__be16 *) &dev->node_guid)[3])); + } + +-static ssize_t show_node_desc(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_node_desc(struct class_device *cdev, char *buf) + { +- struct ib_device *dev = container_of(device, struct ib_device, dev); ++ struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + + return sprintf(buf, "%.64s\n", dev->node_desc); + } + +-static ssize_t set_node_desc(struct device *device, +- struct device_attribute *attr, +- const char *buf, size_t count) ++static ssize_t set_node_desc(struct class_device *cdev, const char *buf, ++ size_t count) + { +- struct ib_device *dev = container_of(device, struct ib_device, dev); ++ struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device_modify desc = {}; + int ret; + +@@ -645,30 +643,30 @@ static ssize_t set_node_desc(struct devi + return count; + } + +-static DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL); +-static DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL); +-static DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL); +-static DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc, set_node_desc); +- +-static struct device_attribute *ib_class_attributes[] = { +- &dev_attr_node_type, +- &dev_attr_sys_image_guid, +- &dev_attr_node_guid, +- &dev_attr_node_desc ++static CLASS_DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL); ++static CLASS_DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL); ++static CLASS_DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL); ++static CLASS_DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc, set_node_desc); ++ ++static struct class_device_attribute *ib_class_attributes[] = { ++ &class_device_attr_node_type, ++ &class_device_attr_sys_image_guid, ++ &class_device_attr_node_guid, ++ &class_device_attr_node_desc + }; + + static struct class ib_class = { + .name = "infiniband", +- .dev_release = ib_device_release, +- .dev_uevent = ib_device_uevent, ++ .release = ib_device_release, ++ .uevent = ib_device_uevent, + }; + + /* Show a given an attribute in the statistics group */ +-static ssize_t show_protocol_stat(const struct device *device, +- struct device_attribute *attr, char *buf, ++static ssize_t show_protocol_stat(struct class_device *cdev, ++ char *buf, + unsigned offset) + { +- struct ib_device *dev = container_of(device, struct ib_device, dev); ++ struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + union rdma_protocol_stats stats; + ssize_t ret; + +@@ -682,14 +680,14 @@ static ssize_t show_protocol_stat(const + + /* generate a read-only iwarp statistics attribute */ + #define IW_STATS_ENTRY(name) \ +-static ssize_t show_##name(struct device *device, \ +- struct device_attribute *attr, char *buf) \ ++static ssize_t show_##name(struct class_device *cdev, \ ++ char *buf) \ + { \ +- return show_protocol_stat(device, attr, buf, \ ++ return show_protocol_stat(cdev, buf, \ + offsetof(struct iw_protocol_stats, name) / \ + sizeof (u64)); \ + } \ +-static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL) ++static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL) + + IW_STATS_ENTRY(ipInReceives); + IW_STATS_ENTRY(ipInHdrErrors); +@@ -731,44 +729,44 @@ IW_STATS_ENTRY(tcpInErrs); + IW_STATS_ENTRY(tcpOutRsts); + + static struct attribute *iw_proto_stats_attrs[] = { +- &dev_attr_ipInReceives.attr, +- &dev_attr_ipInHdrErrors.attr, +- &dev_attr_ipInTooBigErrors.attr, +- &dev_attr_ipInNoRoutes.attr, +- &dev_attr_ipInAddrErrors.attr, +- &dev_attr_ipInUnknownProtos.attr, +- &dev_attr_ipInTruncatedPkts.attr, +- &dev_attr_ipInDiscards.attr, +- &dev_attr_ipInDelivers.attr, +- &dev_attr_ipOutForwDatagrams.attr, +- &dev_attr_ipOutRequests.attr, +- &dev_attr_ipOutDiscards.attr, +- &dev_attr_ipOutNoRoutes.attr, +- &dev_attr_ipReasmTimeout.attr, +- &dev_attr_ipReasmReqds.attr, +- &dev_attr_ipReasmOKs.attr, +- &dev_attr_ipReasmFails.attr, +- &dev_attr_ipFragOKs.attr, +- &dev_attr_ipFragFails.attr, +- &dev_attr_ipFragCreates.attr, +- &dev_attr_ipInMcastPkts.attr, +- &dev_attr_ipOutMcastPkts.attr, +- &dev_attr_ipInBcastPkts.attr, +- &dev_attr_ipOutBcastPkts.attr, +- &dev_attr_tcpRtoAlgorithm.attr, +- &dev_attr_tcpRtoMin.attr, +- &dev_attr_tcpRtoMax.attr, +- &dev_attr_tcpMaxConn.attr, +- &dev_attr_tcpActiveOpens.attr, +- &dev_attr_tcpPassiveOpens.attr, +- &dev_attr_tcpAttemptFails.attr, +- &dev_attr_tcpEstabResets.attr, +- &dev_attr_tcpCurrEstab.attr, +- &dev_attr_tcpInSegs.attr, +- &dev_attr_tcpOutSegs.attr, +- &dev_attr_tcpRetransSegs.attr, +- &dev_attr_tcpInErrs.attr, +- &dev_attr_tcpOutRsts.attr, ++ &class_device_attr_ipInReceives.attr, ++ &class_device_attr_ipInHdrErrors.attr, ++ &class_device_attr_ipInTooBigErrors.attr, ++ &class_device_attr_ipInNoRoutes.attr, ++ &class_device_attr_ipInAddrErrors.attr, ++ &class_device_attr_ipInUnknownProtos.attr, ++ &class_device_attr_ipInTruncatedPkts.attr, ++ &class_device_attr_ipInDiscards.attr, ++ &class_device_attr_ipInDelivers.attr, ++ &class_device_attr_ipOutForwDatagrams.attr, ++ &class_device_attr_ipOutRequests.attr, ++ &class_device_attr_ipOutDiscards.attr, ++ &class_device_attr_ipOutNoRoutes.attr, ++ &class_device_attr_ipReasmTimeout.attr, ++ &class_device_attr_ipReasmReqds.attr, ++ &class_device_attr_ipReasmOKs.attr, ++ &class_device_attr_ipReasmFails.attr, ++ &class_device_attr_ipFragOKs.attr, ++ &class_device_attr_ipFragFails.attr, ++ &class_device_attr_ipFragCreates.attr, ++ &class_device_attr_ipInMcastPkts.attr, ++ &class_device_attr_ipOutMcastPkts.attr, ++ &class_device_attr_ipInBcastPkts.attr, ++ &class_device_attr_ipOutBcastPkts.attr, ++ &class_device_attr_tcpRtoAlgorithm.attr, ++ &class_device_attr_tcpRtoMin.attr, ++ &class_device_attr_tcpRtoMax.attr, ++ &class_device_attr_tcpMaxConn.attr, ++ &class_device_attr_tcpActiveOpens.attr, ++ &class_device_attr_tcpPassiveOpens.attr, ++ &class_device_attr_tcpAttemptFails.attr, ++ &class_device_attr_tcpEstabResets.attr, ++ &class_device_attr_tcpCurrEstab.attr, ++ &class_device_attr_tcpInSegs.attr, ++ &class_device_attr_tcpOutSegs.attr, ++ &class_device_attr_tcpRetransSegs.attr, ++ &class_device_attr_tcpInErrs.attr, ++ &class_device_attr_tcpOutRsts.attr, + NULL + }; + +@@ -779,23 +777,23 @@ static struct attribute_group iw_stats_g + + int ib_device_register_sysfs(struct ib_device *device) + { +- struct device *class_dev = &device->dev; ++ struct class_device *class_dev = &device->class_dev; + int ret; + int i; + + class_dev->class = &ib_class; +- class_dev->driver_data = device; +- class_dev->parent = device->dma_device; +- strlcpy(class_dev->bus_id, device->name, BUS_ID_SIZE); ++ class_dev->class_data = device; ++ class_dev->dev = device->dma_device; ++ strlcpy(class_dev->class_id, device->name, BUS_ID_SIZE); + + INIT_LIST_HEAD(&device->port_list); + +- ret = device_register(class_dev); ++ ret = class_device_register(class_dev); + if (ret) + goto err; + + for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i) { +- ret = device_create_file(class_dev, ib_class_attributes[i]); ++ ret = class_device_create_file(class_dev, ib_class_attributes[i]); + if (ret) + goto err_unregister; + } +@@ -845,7 +843,7 @@ err_put: + kobject_unregister(&class_dev->kobj); + + err_unregister: +- device_unregister(class_dev); ++ class_device_unregister(class_dev); + + err: + return ret; +@@ -868,7 +866,7 @@ void ib_device_unregister_sysfs(struct i + kobject_put(device->ports_parent); + /* WA for memory leak */ + kfree(device->ports_parent); +- device_unregister(&device->dev); ++ class_device_unregister(&device->class_dev); + } + + int ib_sysfs_setup(void) +Index: ofed_kernel/drivers/infiniband/core/ucm.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/ucm.c ++++ ofed_kernel/drivers/infiniband/core/ucm.c +@@ -56,8 +56,8 @@ MODULE_LICENSE("Dual BSD/GPL"); + + struct ib_ucm_device { + int devnum; +- struct cdev cdev; +- struct device dev; ++ struct cdev dev; ++ struct class_device class_dev; + struct ib_device *ib_dev; + }; + +@@ -1177,7 +1177,7 @@ static int ib_ucm_open(struct inode *ino + + filp->private_data = file; + file->filp = filp; +- file->device = container_of(inode->i_cdev, struct ib_ucm_device, cdev); ++ file->device = container_of(inode->i_cdev, struct ib_ucm_device, dev); + + return 0; + } +@@ -1208,14 +1208,14 @@ static int ib_ucm_close(struct inode *in + return 0; + } + +-static void ib_ucm_release_dev(struct device *dev) ++static void ucm_release_class_dev(struct class_device *class_dev) + { +- struct ib_ucm_device *ucm_dev; ++ struct ib_ucm_device *dev; + +- ucm_dev = container_of(dev, struct ib_ucm_device, dev); +- cdev_del(&ucm_dev->cdev); +- clear_bit(ucm_dev->devnum, dev_map); +- kfree(ucm_dev); ++ dev = container_of(class_dev, struct ib_ucm_device, class_dev); ++ cdev_del(&dev->dev); ++ clear_bit(dev->devnum, dev_map); ++ kfree(dev); + } + + static const struct file_operations ucm_fops = { +@@ -1226,15 +1226,14 @@ static const struct file_operations ucm_ + .poll = ib_ucm_poll, + }; + +-static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_ibdev(struct class_device *class_dev, char *buf) + { +- struct ib_ucm_device *ucm_dev; ++ struct ib_ucm_device *dev; + +- ucm_dev = container_of(dev, struct ib_ucm_device, dev); +- return sprintf(buf, "%s\n", ucm_dev->ib_dev->name); ++ dev = container_of(class_dev, struct ib_ucm_device, class_dev); ++ return sprintf(buf, "%s\n", dev->ib_dev->name); + } +-static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); ++static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); + + static void ib_ucm_add_one(struct ib_device *device) + { +@@ -1256,31 +1255,32 @@ static void ib_ucm_add_one(struct ib_dev + + set_bit(ucm_dev->devnum, dev_map); + +- cdev_init(&ucm_dev->cdev, &ucm_fops); +- ucm_dev->cdev.owner = THIS_MODULE; +- kobject_set_name(&ucm_dev->cdev.kobj, "ucm%d", ucm_dev->devnum); +- if (cdev_add(&ucm_dev->cdev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1)) ++ cdev_init(&ucm_dev->dev, &ucm_fops); ++ ucm_dev->dev.owner = THIS_MODULE; ++ kobject_set_name(&ucm_dev->dev.kobj, "ucm%d", ucm_dev->devnum); ++ if (cdev_add(&ucm_dev->dev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1)) + goto err; + +- ucm_dev->dev.class = &cm_class; +- ucm_dev->dev.parent = device->dma_device; +- ucm_dev->dev.devt = ucm_dev->cdev.dev; +- ucm_dev->dev.release = ib_ucm_release_dev; +- snprintf(ucm_dev->dev.bus_id, BUS_ID_SIZE, "ucm%d", ++ ucm_dev->class_dev.class = &cm_class; ++ ucm_dev->class_dev.dev = device->dma_device; ++ ucm_dev->class_dev.devt = ucm_dev->dev.dev; ++ ucm_dev->class_dev.release = ucm_release_class_dev; ++ snprintf(ucm_dev->class_dev.class_id, BUS_ID_SIZE, "ucm%d", + ucm_dev->devnum); +- if (device_register(&ucm_dev->dev)) ++ if (class_device_register(&ucm_dev->class_dev)) + goto err_cdev; + +- if (device_create_file(&ucm_dev->dev, &dev_attr_ibdev)) +- goto err_dev; ++ if (class_device_create_file(&ucm_dev->class_dev, ++ &class_device_attr_ibdev)) ++ goto err_class; + + ib_set_client_data(device, &ucm_client, ucm_dev); + return; + +-err_dev: +- device_unregister(&ucm_dev->dev); ++err_class: ++ class_device_unregister(&ucm_dev->class_dev); + err_cdev: +- cdev_del(&ucm_dev->cdev); ++ cdev_del(&ucm_dev->dev); + clear_bit(ucm_dev->devnum, dev_map); + err: + kfree(ucm_dev); +@@ -1294,7 +1294,7 @@ static void ib_ucm_remove_one(struct ib_ + if (!ucm_dev) + return; + +- device_unregister(&ucm_dev->dev); ++ class_device_unregister(&ucm_dev->class_dev); + } + + static ssize_t show_abi_version(struct class *class, char *buf) +Index: ofed_kernel/drivers/infiniband/core/user_mad.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/user_mad.c ++++ ofed_kernel/drivers/infiniband/core/user_mad.c +@@ -86,11 +86,11 @@ enum { + */ + + struct ib_umad_port { +- struct cdev *cdev; +- struct device *dev; ++ struct cdev *dev; ++ struct class_device *class_dev; + +- struct cdev *sm_cdev; +- struct device *sm_dev; ++ struct cdev *sm_dev; ++ struct class_device *sm_class_dev; + struct semaphore sm_sem; + + struct mutex file_mutex; +@@ -959,29 +959,27 @@ static struct ib_client umad_client = { + .remove = ib_umad_remove_one + }; + +-static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_ibdev(struct class_device *class_dev, char *buf) + { +- struct ib_umad_port *port = dev_get_drvdata(dev); ++ struct ib_umad_port *port = class_get_devdata(class_dev); + + if (!port) + return -ENODEV; + + return sprintf(buf, "%s\n", port->ib_dev->name); + } +-static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); ++static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); + +-static ssize_t show_port(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_port(struct class_device *class_dev, char *buf) + { +- struct ib_umad_port *port = dev_get_drvdata(dev); ++ struct ib_umad_port *port = class_get_devdata(class_dev); + + if (!port) + return -ENODEV; + + return sprintf(buf, "%d\n", port->port_num); + } +-static DEVICE_ATTR(port, S_IRUGO, show_port, NULL); ++static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL); + + static ssize_t show_abi_version(struct class *class, char *buf) + { +@@ -1007,47 +1005,48 @@ static int ib_umad_init_port(struct ib_d + mutex_init(&port->file_mutex); + INIT_LIST_HEAD(&port->file_list); + +- port->cdev = cdev_alloc(); +- if (!port->cdev) ++ port->dev = cdev_alloc(); ++ if (!port->dev) + return -1; +- port->cdev->owner = THIS_MODULE; +- port->cdev->ops = &umad_fops; +- kobject_set_name(&port->cdev->kobj, "umad%d", port->dev_num); +- if (cdev_add(port->cdev, base_dev + port->dev_num, 1)) ++ port->dev->owner = THIS_MODULE; ++ port->dev->ops = &umad_fops; ++ kobject_set_name(&port->dev->kobj, "umad%d", port->dev_num); ++ if (cdev_add(port->dev, base_dev + port->dev_num, 1)) + goto err_cdev; + +- port->dev = device_create(umad_class, device->dma_device, +- port->cdev->dev, "umad%d", port->dev_num); +- if (IS_ERR(port->dev)) ++ port->class_dev = class_device_create(umad_class, NULL, port->dev->dev, ++ device->dma_device, ++ "umad%d", port->dev_num); ++ if (IS_ERR(port->class_dev)) + goto err_cdev; + +- if (device_create_file(port->dev, &dev_attr_ibdev)) +- goto err_dev; +- if (device_create_file(port->dev, &dev_attr_port)) +- goto err_dev; +- +- port->sm_cdev = cdev_alloc(); +- if (!port->sm_cdev) +- goto err_dev; +- port->sm_cdev->owner = THIS_MODULE; +- port->sm_cdev->ops = &umad_sm_fops; +- kobject_set_name(&port->sm_cdev->kobj, "issm%d", port->dev_num); +- if (cdev_add(port->sm_cdev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1)) ++ if (class_device_create_file(port->class_dev, &class_device_attr_ibdev)) ++ goto err_class; ++ if (class_device_create_file(port->class_dev, &class_device_attr_port)) ++ goto err_class; ++ ++ port->sm_dev = cdev_alloc(); ++ if (!port->sm_dev) ++ goto err_class; ++ port->sm_dev->owner = THIS_MODULE; ++ port->sm_dev->ops = &umad_sm_fops; ++ kobject_set_name(&port->sm_dev->kobj, "issm%d", port->dev_num); ++ if (cdev_add(port->sm_dev, base_dev + port->dev_num + IB_UMAD_MAX_PORTS, 1)) + goto err_sm_cdev; + +- port->sm_dev = device_create(umad_class, device->dma_device, +- port->sm_cdev->dev, +- "issm%d", port->dev_num); +- if (IS_ERR(port->sm_dev)) ++ port->sm_class_dev = class_device_create(umad_class, NULL, port->sm_dev->dev, ++ device->dma_device, ++ "issm%d", port->dev_num); ++ if (IS_ERR(port->sm_class_dev)) + goto err_sm_cdev; + +- dev_set_drvdata(port->dev, port); +- dev_set_drvdata(port->sm_dev, port); ++ class_set_devdata(port->class_dev, port); ++ class_set_devdata(port->sm_class_dev, port); + +- if (device_create_file(port->sm_dev, &dev_attr_ibdev)) +- goto err_sm_dev; +- if (device_create_file(port->sm_dev, &dev_attr_port)) +- goto err_sm_dev; ++ if (class_device_create_file(port->sm_class_dev, &class_device_attr_ibdev)) ++ goto err_sm_class; ++ if (class_device_create_file(port->sm_class_dev, &class_device_attr_port)) ++ goto err_sm_class; + + spin_lock(&port_lock); + umad_port[port->dev_num] = port; +@@ -1055,17 +1054,17 @@ static int ib_umad_init_port(struct ib_d + + return 0; + +-err_sm_dev: +- device_destroy(umad_class, port->sm_cdev->dev); ++err_sm_class: ++ class_device_destroy(umad_class, port->sm_dev->dev); + + err_sm_cdev: +- cdev_del(port->sm_cdev); ++ cdev_del(port->sm_dev); + +-err_dev: +- device_destroy(umad_class, port->cdev->dev); ++err_class: ++ class_device_destroy(umad_class, port->dev->dev); + + err_cdev: +- cdev_del(port->cdev); ++ cdev_del(port->dev); + clear_bit(port->dev_num, dev_map); + + return -1; +@@ -1077,14 +1076,14 @@ static void ib_umad_kill_port(struct ib_ + int already_dead; + int id; + +- dev_set_drvdata(port->dev, NULL); +- dev_set_drvdata(port->sm_dev, NULL); ++ class_set_devdata(port->class_dev, NULL); ++ class_set_devdata(port->sm_class_dev, NULL); + +- device_destroy(umad_class, port->cdev->dev); +- device_destroy(umad_class, port->sm_cdev->dev); ++ class_device_destroy(umad_class, port->dev->dev); ++ class_device_destroy(umad_class, port->sm_dev->dev); + +- cdev_del(port->cdev); +- cdev_del(port->sm_cdev); ++ cdev_del(port->dev); ++ cdev_del(port->sm_dev); + + spin_lock(&port_lock); + umad_port[port->dev_num] = NULL; +Index: ofed_kernel/drivers/infiniband/core/uverbs.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/uverbs.h ++++ ofed_kernel/drivers/infiniband/core/uverbs.h +@@ -71,8 +71,8 @@ struct ib_uverbs_device { + struct kref ref; + struct completion comp; + int devnum; +- struct cdev *cdev; +- struct device *dev; ++ struct cdev *dev; ++ struct class_device *class_dev; + struct ib_device *ib_dev; + int num_comp_vectors; + }; +Index: ofed_kernel/drivers/infiniband/core/uverbs_main.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/uverbs_main.c ++++ ofed_kernel/drivers/infiniband/core/uverbs_main.c +@@ -737,29 +737,27 @@ static struct ib_client uverbs_client = + .remove = ib_uverbs_remove_one + }; + +-static ssize_t show_ibdev(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_ibdev(struct class_device *class_dev, char *buf) + { +- struct ib_uverbs_device *dev = dev_get_drvdata(device); ++ struct ib_uverbs_device *dev = class_get_devdata(class_dev); + + if (!dev) + return -ENODEV; + + return sprintf(buf, "%s\n", dev->ib_dev->name); + } +-static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); ++static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); + +-static ssize_t show_dev_abi_version(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_dev_abi_version(struct class_device *class_dev, char *buf) + { +- struct ib_uverbs_device *dev = dev_get_drvdata(device); ++ struct ib_uverbs_device *dev = class_get_devdata(class_dev); + + if (!dev) + return -ENODEV; + + return sprintf(buf, "%d\n", dev->ib_dev->uverbs_abi_ver); + } +-static DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL); ++static CLASS_DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL); + + static ssize_t show_abi_version(struct class *class, char *buf) + { +@@ -793,26 +791,27 @@ static void ib_uverbs_add_one(struct ib_ + uverbs_dev->ib_dev = device; + uverbs_dev->num_comp_vectors = device->num_comp_vectors; + +- uverbs_dev->cdev = cdev_alloc(); +- if (!uverbs_dev->cdev) ++ uverbs_dev->dev = cdev_alloc(); ++ if (!uverbs_dev->dev) + goto err; +- uverbs_dev->cdev->owner = THIS_MODULE; +- uverbs_dev->cdev->ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops; +- kobject_set_name(&uverbs_dev->cdev->kobj, "uverbs%d", uverbs_dev->devnum); +- if (cdev_add(uverbs_dev->cdev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1)) ++ uverbs_dev->dev->owner = THIS_MODULE; ++ uverbs_dev->dev->ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops; ++ kobject_set_name(&uverbs_dev->dev->kobj, "uverbs%d", uverbs_dev->devnum); ++ if (cdev_add(uverbs_dev->dev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1)) + goto err_cdev; + +- uverbs_dev->dev = device_create(uverbs_class, device->dma_device, +- uverbs_dev->cdev->dev, +- "uverbs%d", uverbs_dev->devnum); +- if (IS_ERR(uverbs_dev->dev)) ++ uverbs_dev->class_dev = class_device_create(uverbs_class, NULL, ++ uverbs_dev->dev->dev, ++ device->dma_device, ++ "uverbs%d", uverbs_dev->devnum); ++ if (IS_ERR(uverbs_dev->class_dev)) + goto err_cdev; + +- dev_set_drvdata(uverbs_dev->dev, uverbs_dev); ++ class_set_devdata(uverbs_dev->class_dev, uverbs_dev); + +- if (device_create_file(uverbs_dev->dev, &dev_attr_ibdev)) ++ if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_ibdev)) + goto err_class; +- if (device_create_file(uverbs_dev->dev, &dev_attr_abi_version)) ++ if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_abi_version)) + goto err_class; + + spin_lock(&map_lock); +@@ -824,10 +823,10 @@ static void ib_uverbs_add_one(struct ib_ + return; + + err_class: +- device_destroy(uverbs_class, uverbs_dev->cdev->dev); ++ class_device_destroy(uverbs_class, uverbs_dev->dev->dev); + + err_cdev: +- cdev_del(uverbs_dev->cdev); ++ cdev_del(uverbs_dev->dev); + clear_bit(uverbs_dev->devnum, dev_map); + + err: +@@ -844,9 +843,9 @@ static void ib_uverbs_remove_one(struct + if (!uverbs_dev) + return; + +- dev_set_drvdata(uverbs_dev->dev, NULL); +- device_destroy(uverbs_class, uverbs_dev->cdev->dev); +- cdev_del(uverbs_dev->cdev); ++ class_set_devdata(uverbs_dev->class_dev, NULL); ++ class_device_destroy(uverbs_class, uverbs_dev->dev->dev); ++ cdev_del(uverbs_dev->dev); + + spin_lock(&map_lock); + dev_table[uverbs_dev->devnum] = NULL; +Index: ofed_kernel/include/rdma/ib_verbs.h +=================================================================== +--- ofed_kernel.orig/include/rdma/ib_verbs.h ++++ ofed_kernel/include/rdma/ib_verbs.h +@@ -1196,7 +1196,7 @@ struct ib_device { + struct ib_dma_mapping_ops *dma_ops; + + struct module *owner; +- struct device dev; ++ struct class_device class_dev; + struct kobject *ports_parent; + struct list_head port_list; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_mad_eliminate_krealloc_to_2_6_21.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_mad_eliminate_krealloc_to_2_6_21.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_mad_eliminate_krealloc_to_2_6_21.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_mad_eliminate_krealloc_to_2_6_21.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,29 @@ +diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c +index de922a0..d94f145 100644 +--- a/drivers/infiniband/core/mad.c ++++ b/drivers/infiniband/core/mad.c +@@ -405,15 +405,19 @@ static int register_snoop_agent(struct ib_mad_qp_info *qp_info, + + if (i == qp_info->snoop_table_size) { + /* Grow table. */ +- new_snoop_table = krealloc(qp_info->snoop_table, +- sizeof mad_snoop_priv * +- (qp_info->snoop_table_size + 1), +- GFP_ATOMIC); ++ new_snoop_table = kmalloc(sizeof mad_snoop_priv * ++ (qp_info->snoop_table_size + 1), ++ GFP_ATOMIC); + if (!new_snoop_table) { + i = -ENOMEM; + goto out; + } +- ++ if (qp_info->snoop_table) { ++ memcpy(new_snoop_table, qp_info->snoop_table, ++ sizeof mad_snoop_priv * ++ qp_info->snoop_table_size); ++ kfree(qp_info->snoop_table); ++ } + qp_info->snoop_table = new_snoop_table; + qp_info->snoop_table_size++; + } diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_undo_weak_ordering.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_undo_weak_ordering.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_undo_weak_ordering.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_undo_weak_ordering.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,83 @@ +From 91f5e350089e023d485e42e6f30a7fcf28ea394c Mon Sep 17 00:00:00 2001 +From: Eli Cohen +Date: Tue, 28 Oct 2008 10:19:24 +0200 +Subject: [PATCH] Revert "ib_core: Use weak ordering for data registered memory" + +This reverts commit 4beb8b521a750990346adf47f549c7db5fd50893. + +Doing this for backports since the original patch requires API +available in kernel 2.6.27 and newer. + +Signed-off-by: Eli Cohen +--- + drivers/infiniband/core/umem.c | 12 ++---------- + include/rdma/ib_umem.h | 2 -- + 2 files changed, 2 insertions(+), 12 deletions(-) + +diff --git a/drivers/infiniband/core/umem.c b/drivers/infiniband/core/umem.c +index da5e247..6f7c096 100644 +--- a/drivers/infiniband/core/umem.c ++++ b/drivers/infiniband/core/umem.c +@@ -40,10 +40,6 @@ + + #include "uverbs.h" + +-static int allow_weak_ordering; +-module_param(allow_weak_ordering, bool, 0444); +-MODULE_PARM_DESC(allow_weak_ordering, "Allow weak ordering for data registered memory"); +- + #define IB_UMEM_MAX_PAGE_CHUNK \ + ((PAGE_SIZE - offsetof(struct ib_umem_chunk, page_list)) / \ + ((void *) &((struct ib_umem_chunk *) 0)->page_list[1] - \ +@@ -55,8 +51,8 @@ static void __ib_umem_release(struct ib_device *dev, struct ib_umem *umem, int d + int i; + + list_for_each_entry_safe(chunk, tmp, &umem->chunk_list, list) { +- ib_dma_unmap_sg_attrs(dev, chunk->page_list, +- chunk->nents, DMA_BIDIRECTIONAL, &chunk->attrs); ++ ib_dma_unmap_sg(dev, chunk->page_list, ++ chunk->nents, DMA_BIDIRECTIONAL); + for (i = 0; i < chunk->nents; ++i) { + struct page *page = sg_page(&chunk->page_list[i]); + +@@ -95,9 +91,6 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr, + + if (dmasync) + dma_set_attr(DMA_ATTR_WRITE_BARRIER, &attrs); +- else if (allow_weak_ordering) +- dma_set_attr(DMA_ATTR_WEAK_ORDERING, &attrs); +- + + if (!can_do_mlock()) + return ERR_PTR(-EPERM); +@@ -176,7 +169,6 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr, + goto out; + } + +- chunk->attrs = attrs; + chunk->nents = min_t(int, ret, IB_UMEM_MAX_PAGE_CHUNK); + sg_init_table(chunk->page_list, chunk->nents); + for (i = 0; i < chunk->nents; ++i) { +diff --git a/include/rdma/ib_umem.h b/include/rdma/ib_umem.h +index 90f3712..9ee0d2e 100644 +--- a/include/rdma/ib_umem.h ++++ b/include/rdma/ib_umem.h +@@ -36,7 +36,6 @@ + #include + #include + #include +-#include + + struct ib_ucontext; + +@@ -57,7 +56,6 @@ struct ib_umem_chunk { + struct list_head list; + int nents; + int nmap; +- struct dma_attrs attrs; + struct scatterlist page_list[0]; + }; + +-- +1.6.0.2 + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_z0010_sysfs_race.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_z0010_sysfs_race.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_z0010_sysfs_race.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/core_z0010_sysfs_race.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,543 @@ +ib_core: avoid race condition between sysfs access and low-level module unload. (V2) + +In newer kernels, although a low-level module will not be unloaded (code) +while its sysfs interface is being accessed, it is possible for the module to +free all its resources (data) during such access. This almost always causes +a kernel Oops. + +To avoid this, we protect the device reg_state with a mutex, and perform +all sysfs operations (show, store) atomically within this mutex. + +V2: fix thinko bug in sysfs_state_show changes(found by Ralph Campbell). + +Signed-off-by: Jack Morgenstein +Signed-off-by: Ralph Campbell + +--- + +--- + drivers/infiniband/core/device.c | 12 + + drivers/infiniband/core/sysfs.c | 332 ++++++++++++++++++++++++--------------- + include/rdma/ib_verbs.h | 1 + 3 files changed, 219 insertions(+), 126 deletions(-) + +--- a/drivers/infiniband/core/device.c ++++ b/drivers/infiniband/core/device.c +@@ -178,9 +178,14 @@ static int end_port(struct ib_device *de + */ + struct ib_device *ib_alloc_device(size_t size) + { ++ struct ib_device *ibdev; ++ + BUG_ON(size < sizeof (struct ib_device)); + +- return kzalloc(size, GFP_KERNEL); ++ ibdev = kzalloc(size, GFP_KERNEL); ++ if (ibdev) ++ mutex_init(&ibdev->sysfs_mutex); ++ return ibdev; + } + EXPORT_SYMBOL(ib_alloc_device); + +@@ -313,9 +318,10 @@ int ib_register_device(struct ib_device + goto out; + } + ++ mutex_lock(&device->sysfs_mutex); + list_add_tail(&device->core_list, &device_list); +- + device->reg_state = IB_DEV_REGISTERED; ++ mutex_unlock(&device->sysfs_mutex); + + { + struct ib_client *client; +@@ -361,7 +367,9 @@ void ib_unregister_device(struct ib_devi + kfree(context); + spin_unlock_irqrestore(&device->client_data_lock, flags); + ++ mutex_lock(&device->sysfs_mutex); + device->reg_state = IB_DEV_UNREGISTERED; ++ mutex_unlock(&device->sysfs_mutex); + } + EXPORT_SYMBOL(ib_unregister_device); + +--- a/drivers/infiniband/core/sysfs.c ++++ b/drivers/infiniband/core/sysfs.c +@@ -66,6 +66,11 @@ struct port_table_attribute { + int index; + }; + ++static inline int ibdev_is_alive(const struct ib_device *dev) ++{ ++ return dev->reg_state == IB_DEV_REGISTERED; ++} ++ + static ssize_t port_attr_show(struct kobject *kobj, + struct attribute *attr, char *buf) + { +@@ -87,7 +92,7 @@ static ssize_t state_show(struct ib_port + char *buf) + { + struct ib_port_attr attr; +- ssize_t ret; ++ ssize_t ret = -ENODEV; + + static const char *state_name[] = { + [IB_PORT_NOP] = "NOP", +@@ -98,26 +103,33 @@ static ssize_t state_show(struct ib_port + [IB_PORT_ACTIVE_DEFER] = "ACTIVE_DEFER" + }; + +- ret = ib_query_port(p->ibdev, p->port_num, &attr); +- if (ret) +- return ret; +- +- return sprintf(buf, "%d: %s\n", attr.state, +- attr.state >= 0 && attr.state < ARRAY_SIZE(state_name) ? +- state_name[attr.state] : "UNKNOWN"); ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_port(p->ibdev, p->port_num, &attr); ++ if (!ret) ++ ret = sprintf(buf, "%d: %s\n", attr.state, ++ attr.state >= 0 && ++ attr.state < ARRAY_SIZE(state_name) ? ++ state_name[attr.state] : "UNKNOWN"); ++ } ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + static ssize_t lid_show(struct ib_port *p, struct port_attribute *unused, + char *buf) + { + struct ib_port_attr attr; +- ssize_t ret; ++ ssize_t ret = -ENODEV; + +- ret = ib_query_port(p->ibdev, p->port_num, &attr); +- if (ret) +- return ret; +- +- return sprintf(buf, "0x%x\n", attr.lid); ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_port(p->ibdev, p->port_num, &attr); ++ if (!ret) ++ ret = sprintf(buf, "0x%x\n", attr.lid); ++ } ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + static ssize_t lid_mask_count_show(struct ib_port *p, +@@ -125,52 +137,64 @@ static ssize_t lid_mask_count_show(struc + char *buf) + { + struct ib_port_attr attr; +- ssize_t ret; ++ ssize_t ret = -ENODEV; + +- ret = ib_query_port(p->ibdev, p->port_num, &attr); +- if (ret) +- return ret; +- +- return sprintf(buf, "%d\n", attr.lmc); ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_port(p->ibdev, p->port_num, &attr); ++ if (!ret) ++ ret = sprintf(buf, "%d\n", attr.lmc); ++ } ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + static ssize_t sm_lid_show(struct ib_port *p, struct port_attribute *unused, + char *buf) + { + struct ib_port_attr attr; +- ssize_t ret; +- +- ret = ib_query_port(p->ibdev, p->port_num, &attr); +- if (ret) +- return ret; ++ ssize_t ret = -ENODEV; + +- return sprintf(buf, "0x%x\n", attr.sm_lid); ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_port(p->ibdev, p->port_num, &attr); ++ if (!ret) ++ ret = sprintf(buf, "0x%x\n", attr.sm_lid); ++ } ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + static ssize_t sm_sl_show(struct ib_port *p, struct port_attribute *unused, + char *buf) + { + struct ib_port_attr attr; +- ssize_t ret; +- +- ret = ib_query_port(p->ibdev, p->port_num, &attr); +- if (ret) +- return ret; ++ ssize_t ret = -ENODEV; + +- return sprintf(buf, "%d\n", attr.sm_sl); ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_port(p->ibdev, p->port_num, &attr); ++ if (!ret) ++ ret = sprintf(buf, "%d\n", attr.sm_sl); ++ } ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + static ssize_t cap_mask_show(struct ib_port *p, struct port_attribute *unused, + char *buf) + { + struct ib_port_attr attr; +- ssize_t ret; ++ ssize_t ret = -ENODEV; + +- ret = ib_query_port(p->ibdev, p->port_num, &attr); +- if (ret) +- return ret; +- +- return sprintf(buf, "0x%08x\n", attr.port_cap_flags); ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_port(p->ibdev, p->port_num, &attr); ++ if (!ret) ++ ret = sprintf(buf, "0x%08x\n", attr.port_cap_flags); ++ } ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + static ssize_t rate_show(struct ib_port *p, struct port_attribute *unused, +@@ -179,47 +203,57 @@ static ssize_t rate_show(struct ib_port + struct ib_port_attr attr; + char *speed = ""; + int rate; +- ssize_t ret; ++ ssize_t ret = -ENODEV; + +- ret = ib_query_port(p->ibdev, p->port_num, &attr); +- if (ret) +- return ret; ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_port(p->ibdev, p->port_num, &attr); ++ if (ret) ++ goto out; + +- rate = (25 * attr.active_speed) / 10; ++ rate = (25 * attr.active_speed) / 10; ++ ++ switch (attr.active_speed) { ++ case 2: ++ speed = " DDR"; ++ break; ++ case 4: ++ speed = " QDR"; ++ break; ++ case 8: ++ speed = " FDR10"; ++ rate = 10; ++ break; ++ case 16: ++ speed = " FDR"; ++ rate = 14; ++ break; ++ case 32: ++ speed = " EDR"; ++ rate = 25; ++ break; ++ } ++ ++ rate *= ib_width_enum_to_int(attr.active_width); ++ if (rate < 0) { ++ ret = -EINVAL; ++ goto out; ++ } ++ ++ if (attr.active_speed == 1) { ++ rate = (25 * ib_width_enum_to_int(attr.active_width)) / 10; ++ ret = sprintf(buf, "%d%s Gb/sec (%dX%s)\n", rate, ++ (attr.active_width == IB_WIDTH_1X) ? ".5" : "", ++ ib_width_enum_to_int(attr.active_width), speed); ++ } else ++ ret = sprintf(buf, "%d Gb/sec (%dX%s)\n", rate, ++ ib_width_enum_to_int(attr.active_width), speed); + +- switch (attr.active_speed) { +- case 2: +- speed = " DDR"; +- break; +- case 4: +- speed = " QDR"; +- break; +- case 8: +- speed = " FDR10"; +- rate = 10; +- break; +- case 16: +- speed = " FDR"; +- rate = 14; +- break; +- case 32: +- speed = " EDR"; +- rate = 25; +- break; + } + +- rate *= ib_width_enum_to_int(attr.active_width); +- if (rate < 0) +- return -EINVAL; +- +- if (attr.active_speed == 1) { +- rate = (25 * ib_width_enum_to_int(attr.active_width)) / 10; +- return sprintf(buf, "%d%s Gb/sec (%dX%s)\n", rate, +- (attr.active_width == IB_WIDTH_1X) ? ".5" : "", +- ib_width_enum_to_int(attr.active_width), speed); +- } else +- return sprintf(buf, "%d Gb/sec (%dX%s)\n", rate, +- ib_width_enum_to_int(attr.active_width), speed); ++out: ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + static ssize_t phys_state_show(struct ib_port *p, struct port_attribute *unused, +@@ -227,22 +261,42 @@ static ssize_t phys_state_show(struct ib + { + struct ib_port_attr attr; + +- ssize_t ret; +- +- ret = ib_query_port(p->ibdev, p->port_num, &attr); +- if (ret) +- return ret; ++ ssize_t ret = -ENODEV; + +- switch (attr.phys_state) { +- case 1: return sprintf(buf, "1: Sleep\n"); +- case 2: return sprintf(buf, "2: Polling\n"); +- case 3: return sprintf(buf, "3: Disabled\n"); +- case 4: return sprintf(buf, "4: PortConfigurationTraining\n"); +- case 5: return sprintf(buf, "5: LinkUp\n"); +- case 6: return sprintf(buf, "6: LinkErrorRecovery\n"); +- case 7: return sprintf(buf, "7: Phy Test\n"); +- default: return sprintf(buf, "%d: \n", attr.phys_state); ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_port(p->ibdev, p->port_num, &attr); ++ if (!ret) { ++ switch (attr.phys_state) { ++ case 1: ++ ret = sprintf(buf, "1: Sleep\n"); ++ break; ++ case 2: ++ ret = sprintf(buf, "2: Polling\n"); ++ break; ++ case 3: ++ ret = sprintf(buf, "3: Disabled\n"); ++ break; ++ case 4: ++ ret = sprintf(buf, "4: PortConfigurationTraining\n"); ++ break; ++ case 5: ++ ret = sprintf(buf, "5: LinkUp\n"); ++ break; ++ case 6: ++ ret = sprintf(buf, "6: LinkErrorRecovery\n"); ++ break; ++ case 7: ++ ret = sprintf(buf, "7: Phy Test\n"); ++ break; ++ default: ++ ret = sprintf(buf, "%d: \n", attr.phys_state); ++ break; ++ } ++ } + } ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + static ssize_t link_layer_show(struct ib_port *p, struct port_attribute *unused, +@@ -287,13 +341,24 @@ static ssize_t show_port_gid(struct ib_p + struct port_table_attribute *tab_attr = + container_of(attr, struct port_table_attribute, attr); + union ib_gid gid; +- ssize_t ret; ++ ssize_t ret = -ENODEV; + +- ret = ib_query_gid(p->ibdev, p->port_num, tab_attr->index, &gid); +- if (ret) +- return ret; +- +- return sprintf(buf, "%pI6\n", gid.raw); ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_gid(p->ibdev, p->port_num, tab_attr->index, &gid); ++ if (!ret) ++ ret = sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", ++ be16_to_cpu(((__be16 *) gid.raw)[0]), ++ be16_to_cpu(((__be16 *) gid.raw)[1]), ++ be16_to_cpu(((__be16 *) gid.raw)[2]), ++ be16_to_cpu(((__be16 *) gid.raw)[3]), ++ be16_to_cpu(((__be16 *) gid.raw)[4]), ++ be16_to_cpu(((__be16 *) gid.raw)[5]), ++ be16_to_cpu(((__be16 *) gid.raw)[6]), ++ be16_to_cpu(((__be16 *) gid.raw)[7])); ++ } ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + static ssize_t show_port_pkey(struct ib_port *p, struct port_attribute *attr, +@@ -302,13 +367,16 @@ static ssize_t show_port_pkey(struct ib_ + struct port_table_attribute *tab_attr = + container_of(attr, struct port_table_attribute, attr); + u16 pkey; +- ssize_t ret; +- +- ret = ib_query_pkey(p->ibdev, p->port_num, tab_attr->index, &pkey); +- if (ret) +- return ret; ++ ssize_t ret = -ENODEV; + +- return sprintf(buf, "0x%04x\n", pkey); ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (ibdev_is_alive(p->ibdev)) { ++ ret = ib_query_pkey(p->ibdev, p->port_num, tab_attr->index, &pkey); ++ if (!ret) ++ ret = sprintf(buf, "0x%04x\n", pkey); ++ } ++ mutex_unlock(&p->ibdev->sysfs_mutex); ++ return ret; + } + + #define PORT_PMA_ATTR(_name, _counter, _width, _offset) \ +@@ -331,6 +399,12 @@ static ssize_t show_pma_counter(struct i + if (!p->ibdev->process_mad) + return sprintf(buf, "N/A (no PMA)\n"); + ++ mutex_lock(&p->ibdev->sysfs_mutex); ++ if (!ibdev_is_alive(p->ibdev)) { ++ ret = -ENODEV; ++ goto out; ++ } ++ + in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL); + out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL); + if (!in_mad || !out_mad) { +@@ -377,7 +451,7 @@ static ssize_t show_pma_counter(struct i + out: + kfree(in_mad); + kfree(out_mad); +- ++ mutex_unlock(&p->ibdev->sysfs_mutex); + return ret; + } + +@@ -615,17 +689,20 @@ static ssize_t show_sys_image_guid(struc + { + struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device_attr attr; +- ssize_t ret; +- +- ret = ib_query_device(dev, &attr); +- if (ret) +- return ret; ++ ssize_t ret = -ENODEV; + +- return sprintf(buf, "%04x:%04x:%04x:%04x\n", +- be16_to_cpu(((__be16 *) &attr.sys_image_guid)[0]), +- be16_to_cpu(((__be16 *) &attr.sys_image_guid)[1]), +- be16_to_cpu(((__be16 *) &attr.sys_image_guid)[2]), +- be16_to_cpu(((__be16 *) &attr.sys_image_guid)[3])); ++ mutex_lock(&dev->sysfs_mutex); ++ if (ibdev_is_alive(dev)) { ++ ret = ib_query_device(dev, &attr); ++ if (!ret) ++ ret = sprintf(buf, "%04x:%04x:%04x:%04x\n", ++ be16_to_cpu(((__be16 *) &attr.sys_image_guid)[0]), ++ be16_to_cpu(((__be16 *) &attr.sys_image_guid)[1]), ++ be16_to_cpu(((__be16 *) &attr.sys_image_guid)[2]), ++ be16_to_cpu(((__be16 *) &attr.sys_image_guid)[3])); ++ } ++ mutex_unlock(&dev->sysfs_mutex); ++ return ret; + } + + static ssize_t show_node_guid(struct class_device *cdev, char *buf) +@@ -651,17 +728,20 @@ static ssize_t set_node_desc(struct clas + { + struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + struct ib_device_modify desc = {}; +- int ret; ++ int ret = -ENODEV; + + if (!dev->modify_device) + return -EIO; + + memcpy(desc.node_desc, buf, min_t(int, count, 64)); +- ret = ib_modify_device(dev, IB_DEVICE_MODIFY_NODE_DESC, &desc); +- if (ret) +- return ret; +- +- return count; ++ mutex_lock(&dev->sysfs_mutex); ++ if (ibdev_is_alive(dev)) { ++ ret = ib_modify_device(dev, IB_DEVICE_MODIFY_NODE_DESC, &desc); ++ if (!ret) ++ ret = count; ++ } ++ mutex_unlock(&dev->sysfs_mutex); ++ return ret; + } + + static CLASS_DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL); +@@ -689,14 +769,18 @@ static ssize_t show_protocol_stat(struct + { + struct ib_device *dev = container_of(cdev, struct ib_device, class_dev); + union rdma_protocol_stats stats; +- ssize_t ret; +- +- ret = dev->get_protocol_stats(dev, &stats); +- if (ret) +- return ret; ++ ssize_t ret = -ENODEV; + +- return sprintf(buf, "%llu\n", +- (unsigned long long) ((u64 *) &stats)[offset]); ++ mutex_lock(&dev->sysfs_mutex); ++ if (ibdev_is_alive(dev)) { ++ ret = dev->get_protocol_stats(dev, &stats); ++ if (!ret) ++ ret = sprintf(buf, "%llu\n", ++ (unsigned long long) ++ ((u64 *) &stats)[offset]); ++ } ++ mutex_unlock(&dev->sysfs_mutex); ++ return ret; + } + + /* generate a read-only iwarp statistics attribute */ +--- a/include/rdma/ib_verbs.h ++++ b/include/rdma/ib_verbs.h +@@ -1249,6 +1249,7 @@ struct ib_device { + IB_DEV_REGISTERED, + IB_DEV_UNREGISTERED + } reg_state; ++ struct mutex sysfs_mutex; + + u64 uverbs_cmd_mask; + int uverbs_abi_ver; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0001_backout_multq_netdeviceops.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0001_backout_multq_netdeviceops.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0001_backout_multq_netdeviceops.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0001_backout_multq_netdeviceops.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,228 @@ +commit ffefc559170160b6b25d545429330451e756e57a +Author: root +Date: Tue Jun 16 12:14:38 2009 -0700 + + updated cxgb3_0001_backout_multq_netdeviceops.patch + +diff --git a/drivers/net/cxgb3/adapter.h b/drivers/net/cxgb3/adapter.h +index c888e97..da91aa1 100644 +--- a/drivers/net/cxgb3/adapter.h ++++ b/drivers/net/cxgb3/adapter.h +@@ -199,7 +199,6 @@ struct sge_qset { /* an SGE queue set */ + int lro_enabled; + void *lro_va; + struct net_device *netdev; +- struct netdev_queue *tx_q; /* associated netdev TX queue */ + unsigned long txq_stopped; /* which Tx queues are stopped */ + struct timer_list tx_reclaim_timer; /* reclaims TX buffers */ + struct timer_list rx_reclaim_timer; /* reclaims RX buffers */ +@@ -304,8 +303,7 @@ int t3_mgmt_tx(struct adapter *adap, struct sk_buff *skb); + void t3_update_qset_coalesce(struct sge_qset *qs, const struct qset_params *p); + int t3_sge_alloc_qset(struct adapter *adapter, unsigned int id, int nports, + int irq_vec_idx, const struct qset_params *p, +- int ntxq, struct net_device *dev, +- struct netdev_queue *netdevq); ++ int ntxq, struct net_device *dev); + int t3_get_desc(const struct sge_qset *qs, unsigned int qnum, unsigned int idx, + unsigned char *data); + irqreturn_t t3_sge_intr_msix(int irq, void *cookie); +diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c +index 17858b9..51a3004 100644 +--- a/drivers/net/cxgb3/cxgb3_main.c ++++ b/drivers/net/cxgb3/cxgb3_main.c +@@ -599,8 +599,7 @@ static int setup_sge_qsets(struct adapter *adap) + err = t3_sge_alloc_qset(adap, qset_idx, 1, + (adap->flags & USING_MSIX) ? qset_idx + 1 : + irq_idx, +- &adap->params.sge.qset[qset_idx], ntxq, dev, +- netdev_get_tx_queue(dev, j)); ++ &adap->params.sge.qset[qset_idx], ntxq, dev); + if (err) { + t3_free_sge_resources(adap); + return err; +@@ -1220,10 +1219,9 @@ static int cxgb_open(struct net_device *dev) + "Could not initialize offload capabilities\n"); + } + +- dev->real_num_tx_queues = pi->nqsets; + link_start(dev); + t3_port_intr_enable(adapter, pi->port_id); +- netif_tx_start_all_queues(dev); ++ netif_start_queue(dev); + if (!other_ports) + schedule_chk_task(adapter); + +@@ -1244,7 +1242,7 @@ static int cxgb_close(struct net_device *dev) + t3_read_reg(adapter, A_XGM_INT_STATUS + pi->mac.offset); + + t3_port_intr_disable(adapter, pi->port_id); +- netif_tx_stop_all_queues(dev); ++ netif_stop_queue(dev); + pi->phy.ops->power_down(&pi->phy, 1); + netif_carrier_off(dev); + t3_mac_disable(&pi->mac, MAC_DIRECTION_TX | MAC_DIRECTION_RX); +@@ -2983,22 +2981,6 @@ static void __devinit print_port_info(struct adapter *adap, + } + } + +-static const struct net_device_ops cxgb_netdev_ops = { +- .ndo_open = cxgb_open, +- .ndo_stop = cxgb_close, +- .ndo_start_xmit = t3_eth_xmit, +- .ndo_get_stats = cxgb_get_stats, +- .ndo_validate_addr = eth_validate_addr, +- .ndo_set_multicast_list = cxgb_set_rxmode, +- .ndo_do_ioctl = cxgb_ioctl, +- .ndo_change_mtu = cxgb_change_mtu, +- .ndo_set_mac_address = cxgb_set_mac_addr, +- .ndo_vlan_rx_register = vlan_rx_register, +-#ifdef CONFIG_NET_POLL_CONTROLLER +- .ndo_poll_controller = cxgb_netpoll, +-#endif +-}; +- + static int __devinit init_one(struct pci_dev *pdev, + const struct pci_device_id *ent) + { +@@ -3087,7 +3069,7 @@ static int __devinit init_one(struct pci_dev *pdev, + for (i = 0; i < ai->nports0 + ai->nports1; ++i) { + struct net_device *netdev; + +- netdev = alloc_etherdev_mq(sizeof(struct port_info), SGE_QSETS); ++ netdev = alloc_etherdev(sizeof(struct port_info)); + if (!netdev) { + err = -ENOMEM; + goto out_free_dev; +@@ -3112,7 +3093,18 @@ static int __devinit init_one(struct pci_dev *pdev, + netdev->features |= NETIF_F_HIGHDMA; + + netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; +- netdev->netdev_ops = &cxgb_netdev_ops; ++ netdev->hard_start_xmit = t3_eth_xmit; ++ netdev->vlan_rx_register = vlan_rx_register; ++ netdev->open = cxgb_open; ++ netdev->stop = cxgb_close; ++ netdev->get_stats = cxgb_get_stats; ++ netdev->set_multicast_list = cxgb_set_rxmode; ++ netdev->do_ioctl = cxgb_ioctl; ++ netdev->change_mtu = cxgb_change_mtu; ++ netdev->set_mac_address = cxgb_set_mac_addr; ++#ifdef CONFIG_NET_POLL_CONTROLLER ++ netdev->poll_controller = cxgb_netpoll; ++#endif + SET_ETHTOOL_OPS(netdev, &cxgb_ethtool_ops); + } + +@@ -3325,7 +3325,6 @@ static int __devinit init_one(struct pci + adapter->name = adapter->port[i]->name; + + __set_bit(i, &adapter->registered_device_map); +- netif_tx_stop_all_queues(adapter->port[i]); + } + } + if (!adapter->registered_device_map) { +diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c +index b3ee2bc..d32cf4f 100644 +--- a/drivers/net/cxgb3/sge.c ++++ b/drivers/net/cxgb3/sge.c +@@ -1200,10 +1200,10 @@ static void write_tx_pkt_wr(struct adapter *adap, struct sk_buff *skb, + htonl(V_WR_TID(q->token))); + } + +-static inline void t3_stop_tx_queue(struct netdev_queue *txq, +- struct sge_qset *qs, struct sge_txq *q) ++static inline void t3_stop_queue(struct net_device *dev, struct sge_qset *qs, ++ struct sge_txq *q) + { +- netif_tx_stop_queue(txq); ++ netif_stop_queue(dev); + set_bit(TXQ_ETH, &qs->txq_stopped); + q->stops++; + } +@@ -1217,13 +1217,11 @@ static inline void t3_stop_tx_queue(struct netdev_queue *txq, + */ + int t3_eth_xmit(struct sk_buff *skb, struct net_device *dev) + { +- int qidx; + unsigned int ndesc, pidx, credits, gen, compl; + const struct port_info *pi = netdev_priv(dev); + struct adapter *adap = pi->adapter; +- struct netdev_queue *txq; +- struct sge_qset *qs; +- struct sge_txq *q; ++ struct sge_qset *qs = pi->qs; ++ struct sge_txq *q = &qs->txq[TXQ_ETH]; + + /* + * The chip min packet length is 9 octets but play safe and reject +@@ -1234,11 +1232,6 @@ int t3_eth_xmit(struct sk_buff *skb, struct net_device *dev) + return NETDEV_TX_OK; + } + +- qidx = skb_get_queue_mapping(skb); +- qs = &pi->qs[qidx]; +- q = &qs->txq[TXQ_ETH]; +- txq = netdev_get_tx_queue(dev, qidx); +- + spin_lock(&q->lock); + reclaim_completed_tx(adap, q, TX_RECLAIM_CHUNK); + +@@ -1246,7 +1239,7 @@ int t3_eth_xmit(struct sk_buff *skb, struct net_device *dev) + ndesc = calc_tx_descs(skb); + + if (unlikely(credits < ndesc)) { +- t3_stop_tx_queue(txq, qs, q); ++ t3_stop_queue(dev, qs, q); + dev_err(&adap->pdev->dev, + "%s: Tx ring %u full while queue awake!\n", + dev->name, q->cntxt_id & 7); +@@ -1256,12 +1249,12 @@ int t3_eth_xmit(struct sk_buff *skb, struct net_device *dev) + + q->in_use += ndesc; + if (unlikely(credits - ndesc < q->stop_thres)) { +- t3_stop_tx_queue(txq, qs, q); ++ t3_stop_queue(dev, qs, q); + + if (should_restart_tx(q) && + test_and_clear_bit(TXQ_ETH, &qs->txq_stopped)) { + q->restarts++; +- netif_tx_wake_queue(txq); ++ netif_wake_queue(dev); + } + } + +@@ -1925,7 +1918,7 @@ static void restart_tx(struct sge_qset *qs) + test_and_clear_bit(TXQ_ETH, &qs->txq_stopped)) { + qs->txq[TXQ_ETH].restarts++; + if (netif_running(qs->netdev)) +- netif_tx_wake_queue(qs->tx_q); ++ netif_wake_queue(qs->netdev); + } + + if (test_bit(TXQ_OFLD, &qs->txq_stopped) && +@@ -2944,7 +2937,6 @@ void t3_update_qset_coalesce(struct sge_qset *qs, const struct qset_params *p) + * @p: configuration parameters for this queue set + * @ntxq: number of Tx queues for the queue set + * @netdev: net device associated with this queue set +- * @netdevq: net device TX queue associated with this queue set + * + * Allocate resources and initialize an SGE queue set. A queue set + * comprises a response queue, two Rx free-buffer queues, and up to 3 +@@ -2953,8 +2945,7 @@ void t3_update_qset_coalesce(struct sge_qset *qs, const struct qset_params *p) + */ + int t3_sge_alloc_qset(struct adapter *adapter, unsigned int id, int nports, + int irq_vec_idx, const struct qset_params *p, +- int ntxq, struct net_device *dev, +- struct netdev_queue *netdevq) ++ int ntxq, struct net_device *dev) + { + int i, avail, ret = -ENOMEM; + struct sge_qset *q = &adapter->sge.qs[id]; +@@ -3088,7 +3079,6 @@ int t3_sge_alloc_qset(struct adapter *adapter, unsigned int id, int nports, + + q->adap = adapter; + q->netdev = dev; +- q->tx_q = netdevq; + t3_update_qset_coalesce(q, p); + + avail = refill_fl(adapter, &q->fl[0], q->fl[0].size, diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0002_undo_250.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0002_undo_250.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0002_undo_250.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0002_undo_250.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,164 @@ +commit 6f4acfd8b284f1d20014469f5285f0ff47356c3c +Author: root +Date: Sun Jun 14 07:20:57 2009 -0700 + + cxgb3_0002_undo_250.patch + +diff --git a/drivers/net/cxgb3/common.h b/drivers/net/cxgb3/common.h +index e508dc3..17fc36b 100644 +--- a/drivers/net/cxgb3/common.h ++++ b/drivers/net/cxgb3/common.h +@@ -735,7 +735,6 @@ void early_hw_init(struct adapter *adapter, const struct adapter_info *ai); + int t3_reset_adapter(struct adapter *adapter); + int t3_prep_adapter(struct adapter *adapter, const struct adapter_info *ai, + int reset); +-int t3_replay_prep_adapter(struct adapter *adapter); + void t3_led_ready(struct adapter *adapter); + void t3_fatal_err(struct adapter *adapter); + void t3_set_vlan_accel(struct adapter *adapter, unsigned int ports, int on); +diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c +index d016db5..73ab94b 100644 +--- a/drivers/net/cxgb3/cxgb3_main.c ++++ b/drivers/net/cxgb3/cxgb3_main.c +@@ -2725,6 +2725,9 @@ static int t3_adapter_error(struct adapter *adapter, int reset) + /* Stop SGE timers */ + t3_stop_sge_timers(adapter); + ++ /* Free sge resources */ ++ t3_free_sge_resources(adapter); ++ + adapter->flags &= ~FULL_INIT_DONE; + + if (reset) +@@ -2743,12 +2746,8 @@ static int t3_reenable_adapter(struct adapter *adapter) + goto err; + } + pci_set_master(adapter->pdev); +- pci_restore_state(adapter->pdev); +- +- /* Free sge resources */ +- t3_free_sge_resources(adapter); + +- if (t3_replay_prep_adapter(adapter)) ++ if (t3_prep_adapter(adapter, adapter->params.info, 1)) + goto err; + + return 0; +@@ -3050,7 +3049,6 @@ static int __devinit init_one(struct pci_dev *pdev, + } + + pci_set_master(pdev); +- pci_save_state(pdev); + + mmio_start = pci_resource_start(pdev, 0); + mmio_len = pci_resource_len(pdev, 0); +diff --git a/drivers/net/cxgb3/regs.h b/drivers/net/cxgb3/regs.h +index 1b5327b..932e77a 100644 +--- a/drivers/net/cxgb3/regs.h ++++ b/drivers/net/cxgb3/regs.h +@@ -452,14 +452,6 @@ + + #define A_PCIE_CFG 0x88 + +-#define S_ENABLELINKDWNDRST 21 +-#define V_ENABLELINKDWNDRST(x) ((x) << S_ENABLELINKDWNDRST) +-#define F_ENABLELINKDWNDRST V_ENABLELINKDWNDRST(1U) +- +-#define S_ENABLELINKDOWNRST 20 +-#define V_ENABLELINKDOWNRST(x) ((x) << S_ENABLELINKDOWNRST) +-#define F_ENABLELINKDOWNRST V_ENABLELINKDOWNRST(1U) +- + #define S_PCIE_CLIDECEN 16 + #define V_PCIE_CLIDECEN(x) ((x) << S_PCIE_CLIDECEN) + #define F_PCIE_CLIDECEN V_PCIE_CLIDECEN(1U) +diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c +index d26d04f..364f580 100644 +--- a/drivers/net/cxgb3/sge.c ++++ b/drivers/net/cxgb3/sge.c +@@ -632,33 +632,6 @@ static void *alloc_ring(struct pci_dev *pdev, size_t nelem, size_t elem_size, + } + + /** +- * t3_reset_qset - reset a sge qset +- * @q: the queue set +- * +- * Reset the qset structure. +- * the NAPI structure is preserved in the event of +- * the qset's reincarnation, for example during EEH recovery. +- */ +-static void t3_reset_qset(struct sge_qset *q) +-{ +- if (q->adap && +- !(q->adap->flags & NAPI_INIT)) { +- memset(q, 0, sizeof(*q)); +- return; +- } +- +- q->adap = NULL; +- memset(&q->rspq, 0, sizeof(q->rspq)); +- memset(q->fl, 0, sizeof(struct sge_fl) * SGE_RXQ_PER_SET); +- memset(q->txq, 0, sizeof(struct sge_txq) * SGE_TXQ_PER_SET); +- q->txq_stopped = 0; +- q->tx_reclaim_timer.function = NULL; /* for t3_stop_sge_timers() */ +- q->rx_reclaim_timer.function = NULL; +- q->lro_frag_tbl.nr_frags = q->lro_frag_tbl.len = 0; +-} +- +- +-/** + * free_qset - free the resources of an SGE queue set + * @adapter: the adapter owning the queue set + * @q: the queue set +@@ -711,7 +684,7 @@ static void t3_free_qset(struct adapter *adapter, struct sge_qset *q) + q->rspq.desc, q->rspq.phys_addr); + } + +- t3_reset_qset(q); ++ memset(q, 0, sizeof(*q)); + } + + /** +diff --git a/drivers/net/cxgb3/t3_hw.c b/drivers/net/cxgb3/t3_hw.c +index 31ed31a..de00045 100644 +--- a/drivers/net/cxgb3/t3_hw.c ++++ b/drivers/net/cxgb3/t3_hw.c +@@ -3489,7 +3489,6 @@ static void config_pcie(struct adapter *adap) + + t3_write_reg(adap, A_PCIE_PEX_ERR, 0xffffffff); + t3_set_reg_field(adap, A_PCIE_CFG, 0, +- F_ENABLELINKDWNDRST | F_ENABLELINKDOWNRST | + F_PCIE_DMASTOPEN | F_PCIE_CLIDECEN); + } + +@@ -3908,31 +3907,3 @@ void t3_led_ready(struct adapter *adapter) + F_GPIO0_OUT_VAL); + } + +-int t3_replay_prep_adapter(struct adapter *adapter) +-{ +- const struct adapter_info *ai = adapter->params.info; +- unsigned int i, j = -1; +- int ret; +- +- early_hw_init(adapter, ai); +- ret = init_parity(adapter); +- if (ret) +- return ret; +- +- for_each_port(adapter, i) { +- const struct port_type_info *pti; +- struct port_info *p = adap2pinfo(adapter, i); +- +- while (!adapter->params.vpd.port_type[++j]) +- ; +- +- pti = &port_types[adapter->params.vpd.port_type[j]]; +- ret = pti->phy_prep(&p->phy, adapter, p->phy.addr, NULL); +- if (ret) +- return ret; +- p->phy.ops->power_down(&p->phy, 1); +- } +- +-return 0; +-} +- diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0004_undo_240.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0004_undo_240.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0004_undo_240.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0004_undo_240.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,86 @@ +commit 708fa8bd1abfe3bcf539a074bbe6107578310ee5 +Author: root +Date: Sun Jun 14 08:54:00 2009 -0700 + + cxgb3_0004_undo_240.patch + +diff --git a/drivers/net/cxgb3/adapter.h b/drivers/net/cxgb3/adapter.h +index 900e42e..11ef2c7 100644 +--- a/drivers/net/cxgb3/adapter.h ++++ b/drivers/net/cxgb3/adapter.h +@@ -78,7 +78,6 @@ enum { /* adapter flags */ + USING_MSIX = (1 << 2), + QUEUES_BOUND = (1 << 3), + TP_PARITY_INIT = (1 << 4), +- NAPI_INIT = (1 << 5), + }; + + struct fl_pg_chunk { +diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c +index 73ab94b..3d196c0 100644 +--- a/drivers/net/cxgb3/cxgb3_main.c ++++ b/drivers/net/cxgb3/cxgb3_main.c +@@ -521,13 +521,6 @@ static void init_napi(struct adapter *adap) + netif_napi_add(qs->netdev, &qs->napi, qs->napi.poll, + 64); + } +- +- /* +- * netif_napi_add() can be called only once per napi_struct because it +- * adds each new napi_struct to a list. Be careful not to call it a +- * second time, e.g., during EEH recovery, by making a note of it. +- */ +- adap->flags |= NAPI_INIT; + } + + /* +@@ -1042,8 +1035,7 @@ static int cxgb_up(struct adapter *adap) + goto out; + + setup_rss(adap); +- if (!(adap->flags & NAPI_INIT)) +- init_napi(adap); ++ init_napi(adap); + + t3_start_sge_timers(adap); + adap->flags |= FULL_INIT_DONE; +@@ -1143,7 +1135,7 @@ static int offload_open(struct net_device *dev) + return 0; + + if (!adap_up && (err = cxgb_up(adapter)) < 0) +- goto out; ++ return err; + + t3_tp_set_offload_mode(adapter, 1); + tdev->lldev = adapter->port[0]; +@@ -1205,8 +1197,10 @@ static int cxgb_open(struct net_device *dev) + int other_ports = adapter->open_device_map & PORT_MASK; + int err; + +- if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0) ++ if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0) { ++ quiesce_rx(adapter); + return err; ++ } + + set_bit(pi->port_id, &adapter->open_device_map); + if (is_offload(adapter) && !ofld_disable) { +@@ -2747,8 +2741,7 @@ static int t3_reenable_adapter(struct adapter *adapter) + } + pci_set_master(adapter->pdev); + +- if (t3_prep_adapter(adapter, adapter->params.info, 1)) +- goto err; ++ t3_prep_adapter(adapter, adapter->params.info, 1); + + return 0; + err: +@@ -2837,7 +2830,7 @@ static pci_ers_result_t t3_io_error_detected(struct pci_dev *pdev, + + ret = t3_adapter_error(adapter, 0); + +- /* Request a slot reset. */ ++ /* Request a slot slot reset. */ + return PCI_ERS_RESULT_NEED_RESET; + } + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0008_pci_dma_mapping_error_to_2_6_26.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0008_pci_dma_mapping_error_to_2_6_26.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0008_pci_dma_mapping_error_to_2_6_26.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0008_pci_dma_mapping_error_to_2_6_26.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,17 @@ +--- + drivers/net/cxgb3/sge.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Index: ofed_kernel/drivers/net/cxgb3/sge.c +=================================================================== +--- ofed_kernel.orig/drivers/net/cxgb3/sge.c ++++ ofed_kernel/drivers/net/cxgb3/sge.c +@@ -386,7 +386,7 @@ static inline int add_one_rx_buf(void *v + dma_addr_t mapping; + + mapping = pci_map_single(pdev, va, len, PCI_DMA_FROMDEVICE); +- if (unlikely(pci_dma_mapping_error(pdev, mapping))) ++ if (unlikely(pci_dma_mapping_error(mapping))) + return -ENOMEM; + + pci_unmap_addr_set(sd, dma_addr, mapping); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0010_napi.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0010_napi.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0010_napi.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0010_napi.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,599 @@ +commit ff1cdde3746d4c7b6003eb2d1b4d27d340958c11 +Author: root +Date: Thu Aug 27 11:04:03 2009 -0700 + + cxgb3_0010_napi + +diff --git a/drivers/net/cxgb3/adapter.h b/drivers/net/cxgb3/adapter.h +index f8c6b1b..cc5dbda 100644 +--- a/drivers/net/cxgb3/adapter.h ++++ b/drivers/net/cxgb3/adapter.h +@@ -47,7 +47,6 @@ + + struct vlan_group; + struct adapter; +-struct sge_qset; + + enum { /* rx_offload flags */ + T3_RX_CSUM = 1 << 0, +@@ -57,7 +56,6 @@ enum { /* rx_offload flags */ + struct port_info { + struct adapter *adapter; + struct vlan_group *vlan_grp; +- struct sge_qset *qs; + u8 port_id; + u8 rx_offload; + u8 nqsets; +@@ -189,15 +187,13 @@ enum { /* per port SGE statistics */ + struct napi_gro_fraginfo; + + struct sge_qset { /* an SGE queue set */ +- struct adapter *adap; +- struct napi_struct napi; + struct sge_rspq rspq; + struct sge_fl fl[SGE_RXQ_PER_SET]; + struct sge_txq txq[SGE_TXQ_PER_SET]; + struct napi_gro_fraginfo lro_frag_tbl; + int lro_enabled; + void *lro_va; +- struct net_device *netdev; ++ struct net_device *netdev; /* associated net device */ + unsigned long txq_stopped; /* which Tx queues are stopped */ + struct timer_list tx_reclaim_timer; /* reclaims TX buffers */ + struct timer_list rx_reclaim_timer; /* reclaims RX buffers */ +@@ -246,6 +242,12 @@ struct adapter { + struct work_struct fatal_error_handler_task; + struct work_struct link_fault_handler_task; + ++ /* ++ * Dummy netdevices are needed when using multiple receive queues with ++ * NAPI as each netdevice can service only one queue. ++ */ ++ struct net_device *dummy_netdev[SGE_QSETS - 1]; ++ + struct dentry *debugfs_root; + + struct mutex mdio_lock; +@@ -282,6 +284,12 @@ static inline int phy2portid(struct cphy *phy) + return &port0->phy == phy ? 0 : 1; + } + ++/* ++ * We use the spare atalk_ptr to map a net device to its SGE queue set. ++ * This is a macro so it can be used as l-value. ++ */ ++#define dev2qset(netdev) ((netdev)->atalk_ptr) ++ + #define OFFLOAD_DEVMAP_BIT 15 + + #define tdev2adap(d) container_of(d, struct adapter, tdev) +@@ -312,7 +320,7 @@ int t3_mgmt_tx(struct adapter *adap, struct sk_buff *skb); + void t3_update_qset_coalesce(struct sge_qset *qs, const struct qset_params *p); + int t3_sge_alloc_qset(struct adapter *adapter, unsigned int id, int nports, + int irq_vec_idx, const struct qset_params *p, +- int ntxq, struct net_device *dev); ++ int ntxq, struct net_device *netdev); + int t3_get_desc(const struct sge_qset *qs, unsigned int qnum, unsigned int idx, + unsigned char *data); + irqreturn_t t3_sge_intr_msix(int irq, void *cookie); +diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c +index e15a719..1e793b1 100644 +--- a/drivers/net/cxgb3/cxgb3_main.c ++++ b/drivers/net/cxgb3/cxgb3_main.c +@@ -587,17 +587,49 @@ static void setup_rss(struct adapter *adap) + V_RRCPLCPUSIZE(6) | F_HASHTOEPLITZ, cpus, rspq_map); + } + +-static void init_napi(struct adapter *adap) ++/* ++ * If we have multiple receive queues per port serviced by NAPI we need one ++ * netdevice per queue as NAPI operates on netdevices. We already have one ++ * netdevice, namely the one associated with the interface, so we use dummy ++ * ones for any additional queues. Note that these netdevices exist purely ++ * so that NAPI has something to work with, they do not represent network ++ * ports and are not registered. ++ */ ++static int init_dummy_netdevs(struct adapter *adap) + { +- int i; ++ int i, j, dummy_idx = 0; ++ struct net_device *nd; ++ ++ for_each_port(adap, i) { ++ struct net_device *dev = adap->port[i]; ++ const struct port_info *pi = netdev_priv(dev); + +- for (i = 0; i < SGE_QSETS; i++) { +- struct sge_qset *qs = &adap->sge.qs[i]; ++ for (j = 0; j < pi->nqsets - 1; j++) { ++ if (!adap->dummy_netdev[dummy_idx]) { ++ struct port_info *p; ++ ++ nd = alloc_netdev(sizeof(*p), "", ether_setup); ++ if (!nd) ++ goto free_all; ++ ++ p = netdev_priv(nd); ++ p->adapter = adap; ++ nd->weight = 64; ++ set_bit(__LINK_STATE_START, &nd->state); ++ adap->dummy_netdev[dummy_idx] = nd; ++ } ++ strcpy(adap->dummy_netdev[dummy_idx]->name, dev->name); ++ dummy_idx++; ++ } ++ } ++ return 0; + +- if (qs->adap) +- netif_napi_add(qs->netdev, &qs->napi, qs->napi.poll, +- 64); ++free_all: ++ while (--dummy_idx >= 0) { ++ free_netdev(adap->dummy_netdev[dummy_idx]); ++ adap->dummy_netdev[dummy_idx] = NULL; + } ++ return -ENOMEM; + } + + /* +@@ -608,18 +640,20 @@ static void init_napi(struct adapter *adap) + static void quiesce_rx(struct adapter *adap) + { + int i; ++ struct net_device *dev; + +- for (i = 0; i < SGE_QSETS; i++) +- if (adap->sge.qs[i].adap) +- napi_disable(&adap->sge.qs[i].napi); +-} ++ for_each_port(adap, i) { ++ dev = adap->port[i]; ++ while (test_bit(__LINK_STATE_RX_SCHED, &dev->state)) ++ msleep(1); ++ } + +-static void enable_all_napi(struct adapter *adap) +-{ +- int i; +- for (i = 0; i < SGE_QSETS; i++) +- if (adap->sge.qs[i].adap) +- napi_enable(&adap->sge.qs[i].napi); ++ for (i = 0; i < ARRAY_SIZE(adap->dummy_netdev); i++) { ++ dev = adap->dummy_netdev[i]; ++ if (dev) ++ while (test_bit(__LINK_STATE_RX_SCHED, &dev->state)) ++ msleep(1); ++ } + } + + /** +@@ -652,7 +686,7 @@ static void set_qset_lro(struct net_device *dev, int qset_idx, int val) + */ + static int setup_sge_qsets(struct adapter *adap) + { +- int i, j, err, irq_idx = 0, qset_idx = 0; ++ int i, j, err, irq_idx = 0, qset_idx = 0, dummy_dev_idx = 0; + unsigned int ntxq = SGE_TXQ_PER_SET; + + if (adap->params.rev > 0 && !(adap->flags & USING_MSI)) +@@ -660,15 +694,16 @@ static int setup_sge_qsets(struct adapter *adap) + + for_each_port(adap, i) { + struct net_device *dev = adap->port[i]; +- struct port_info *pi = netdev_priv(dev); ++ const struct port_info *pi = netdev_priv(dev); + +- pi->qs = &adap->sge.qs[pi->first_qset]; + for (j = 0; j < pi->nqsets; ++j, ++qset_idx) { + set_qset_lro(dev, qset_idx, pi->rx_offload & T3_LRO); + err = t3_sge_alloc_qset(adap, qset_idx, 1, + (adap->flags & USING_MSIX) ? qset_idx + 1 : + irq_idx, +- &adap->params.sge.qset[qset_idx], ntxq, dev); ++ &adap->params.sge.qset[qset_idx], ntxq, ++ j == 0 ? dev : ++ adap->dummy_netdev[dummy_dev_idx++]); + if (err) { + t3_free_sge_resources(adap); + return err; +@@ -1179,6 +1214,10 @@ static int cxgb_up(struct adapter *adap) + */ + t3_intr_clear(adap); + ++ err = init_dummy_netdevs(adap); ++ if (err) ++ goto out; ++ + err = t3_init_hw(adap, 0); + if (err) + goto out; +@@ -1191,7 +1230,6 @@ static int cxgb_up(struct adapter *adap) + goto out; + + setup_rss(adap); +- init_napi(adap); + + t3_start_sge_timers(adap); + adap->flags |= FULL_INIT_DONE; +@@ -1221,7 +1259,6 @@ static int cxgb_up(struct adapter *adap) + adap->name, adap))) + goto irq_err; + +- enable_all_napi(adap); + t3_sge_start(adap); + t3_intr_enable(adap); + +@@ -1356,10 +1393,8 @@ static int cxgb_open(struct net_device *dev) + int other_ports = adapter->open_device_map & PORT_MASK; + int err; + +- if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0) { +- quiesce_rx(adapter); ++ if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0) + return err; +- } + + set_bit(pi->port_id, &adapter->open_device_map); + if (is_offload(adapter) && !ofld_disable) { +@@ -3262,6 +3297,7 @@ static int __devinit init_one(struct pci_dev *pdev, + #ifdef CONFIG_NET_POLL_CONTROLLER + netdev->poll_controller = cxgb_netpoll; + #endif ++ netdev->weight = 64; + SET_ETHTOOL_OPS(netdev, &cxgb_ethtool_ops); + } + +@@ -3364,6 +3400,12 @@ static void __devexit remove_one(struct pci_dev *pdev) + t3_free_sge_resources(adapter); + cxgb_disable_msi(adapter); + ++ for (i = 0; i < ARRAY_SIZE(adapter->dummy_netdev); i++) ++ if (adapter->dummy_netdev[i]) { ++ free_netdev(adapter->dummy_netdev[i]); ++ adapter->dummy_netdev[i] = NULL; ++ } ++ + for_each_port(adapter, i) + if (adapter->port[i]) + free_netdev(adapter->port[i]); +diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c +index 210dc8b..3c47c8f 100644 +--- a/drivers/net/cxgb3/sge.c ++++ b/drivers/net/cxgb3/sge.c +@@ -683,6 +683,9 @@ static void t3_free_qset(struct adapter *adapter, struct sge_qset *q) + q->rspq.desc, q->rspq.phys_addr); + } + ++ if (q->netdev) ++ q->netdev->atalk_ptr = NULL; ++ + memset(q, 0, sizeof(*q)); + } + +@@ -1193,7 +1196,7 @@ int t3_eth_xmit(struct sk_buff *skb, struct net_device *dev) + unsigned int ndesc, pidx, credits, gen, compl; + const struct port_info *pi = netdev_priv(dev); + struct adapter *adap = pi->adapter; +- struct sge_qset *qs = pi->qs; ++ struct sge_qset *qs = dev2qset(dev); + struct sge_txq *q = &qs->txq[TXQ_ETH]; + + /* +@@ -1442,12 +1445,13 @@ static void restart_ctrlq(unsigned long data) + struct sk_buff *skb; + struct sge_qset *qs = (struct sge_qset *)data; + struct sge_txq *q = &qs->txq[TXQ_CTRL]; ++ const struct port_info *pi = netdev_priv(qs->netdev); ++ struct adapter *adap = pi->adapter; + + spin_lock(&q->lock); + again:reclaim_completed_tx_imm(q); + +- while (q->in_use < q->size && +- (skb = __skb_dequeue(&q->sendq)) != NULL) { ++ while (q->in_use < q->size && (skb = __skb_dequeue(&q->sendq)) != NULL) { + + write_imm(&q->desc[q->pidx], skb, skb->len, q->gen); + +@@ -1470,7 +1474,7 @@ static void restart_ctrlq(unsigned long data) + + spin_unlock(&q->lock); + wmb(); +- t3_write_reg(qs->adap, A_SG_KDOORBELL, ++ t3_write_reg(adap, A_SG_KDOORBELL, + F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id)); + } + +@@ -1761,7 +1765,8 @@ static inline void offload_enqueue(struct sge_rspq *q, struct sk_buff *skb) + if (was_empty) { + struct sge_qset *qs = rspq_to_qset(q); + +- napi_schedule(&qs->napi); ++ if (__netif_rx_schedule_prep(qs->netdev)) ++ __netif_rx_schedule(qs->netdev); + } + } + +@@ -1795,14 +1800,15 @@ static inline void deliver_partial_bundle(struct t3cdev *tdev, + * receive handler. Batches need to be of modest size as we do prefetches + * on the packets in each. + */ +-static int ofld_poll(struct napi_struct *napi, int budget) ++static int ofld_poll(struct net_device *dev, int *budget) + { +- struct sge_qset *qs = container_of(napi, struct sge_qset, napi); ++ const struct port_info *pi = netdev_priv(dev); ++ struct adapter *adapter = pi->adapter; ++ struct sge_qset *qs = dev2qset(dev); + struct sge_rspq *q = &qs->rspq; +- struct adapter *adapter = qs->adap; +- int work_done = 0; ++ int work_done, limit = min(*budget, dev->quota), avail = limit; + +- while (work_done < budget) { ++ while (avail) { + struct sk_buff *skb, *tmp, *skbs[RX_BUNDLE_SIZE]; + struct sk_buff_head queue; + int ngathered; +@@ -1811,17 +1817,20 @@ static int ofld_poll(struct napi_struct *napi, int budget) + __skb_queue_head_init(&queue); + skb_queue_splice_init(&q->rx_queue, &queue); + if (skb_queue_empty(&queue)) { +- napi_complete(napi); ++ work_done = limit - avail; ++ *budget -= work_done; ++ dev->quota -= work_done; ++ __netif_rx_complete(dev); + spin_unlock_irq(&q->lock); +- return work_done; ++ return 0; + } + spin_unlock_irq(&q->lock); + + ngathered = 0; + skb_queue_walk_safe(&queue, skb, tmp) { +- if (work_done >= budget) ++ if (!avail) + break; +- work_done++; ++ avail--; + + __skb_unlink(skb, &queue); + prefetch(skb->data); +@@ -1841,8 +1850,10 @@ static int ofld_poll(struct napi_struct *napi, int budget) + } + deliver_partial_bundle(&adapter->tdev, q, skbs, ngathered); + } +- +- return work_done; ++ work_done = limit - avail; ++ *budget -= work_done; ++ dev->quota -= work_done; ++ return 1; + } + + /** +@@ -2362,47 +2373,50 @@ static inline int is_pure_response(const struct rsp_desc *r) + + /** + * napi_rx_handler - the NAPI handler for Rx processing +- * @napi: the napi instance ++ * @dev: the net device + * @budget: how many packets we can process in this round + * + * Handler for new data events when using NAPI. + */ +-static int napi_rx_handler(struct napi_struct *napi, int budget) ++static int napi_rx_handler(struct net_device *dev, int *budget) + { +- struct sge_qset *qs = container_of(napi, struct sge_qset, napi); +- struct adapter *adap = qs->adap; +- int work_done = process_responses(adap, qs, budget); ++ const struct port_info *pi = netdev_priv(dev); ++ struct adapter *adap = pi->adapter; ++ struct sge_qset *qs = dev2qset(dev); ++ int effective_budget = min(*budget, dev->quota); + +- if (likely(work_done < budget)) { +- napi_complete(napi); ++ int work_done = process_responses(adap, qs, effective_budget); ++ *budget -= work_done; ++ dev->quota -= work_done; + +- /* +- * Because we don't atomically flush the following +- * write it is possible that in very rare cases it can +- * reach the device in a way that races with a new +- * response being written plus an error interrupt +- * causing the NAPI interrupt handler below to return +- * unhandled status to the OS. To protect against +- * this would require flushing the write and doing +- * both the write and the flush with interrupts off. +- * Way too expensive and unjustifiable given the +- * rarity of the race. +- * +- * The race cannot happen at all with MSI-X. +- */ +- t3_write_reg(adap, A_SG_GTS, V_RSPQ(qs->rspq.cntxt_id) | +- V_NEWTIMER(qs->rspq.next_holdoff) | +- V_NEWINDEX(qs->rspq.cidx)); +- } +- return work_done; ++ if (work_done >= effective_budget) ++ return 1; ++ ++ netif_rx_complete(dev); ++ ++ /* ++ * Because we don't atomically flush the following write it is ++ * possible that in very rare cases it can reach the device in a way ++ * that races with a new response being written plus an error interrupt ++ * causing the NAPI interrupt handler below to return unhandled status ++ * to the OS. To protect against this would require flushing the write ++ * and doing both the write and the flush with interrupts off. Way too ++ * expensive and unjustifiable given the rarity of the race. ++ * ++ * The race cannot happen at all with MSI-X. ++ */ ++ t3_write_reg(adap, A_SG_GTS, V_RSPQ(qs->rspq.cntxt_id) | ++ V_NEWTIMER(qs->rspq.next_holdoff) | ++ V_NEWINDEX(qs->rspq.cidx)); ++ return 0; + } + + /* + * Returns true if the device is already scheduled for polling. + */ +-static inline int napi_is_scheduled(struct napi_struct *napi) ++static inline int napi_is_scheduled(struct net_device *dev) + { +- return test_bit(NAPI_STATE_SCHED, &napi->state); ++ return test_bit(__LINK_STATE_RX_SCHED, &dev->state); + } + + /** +@@ -2485,7 +2499,8 @@ static inline int handle_responses(struct adapter *adap, struct sge_rspq *q) + V_NEWTIMER(q->holdoff_tmr) | V_NEWINDEX(q->cidx)); + return 0; + } +- napi_schedule(&qs->napi); ++ if (likely(__netif_rx_schedule_prep(qs->netdev))) ++ __netif_rx_schedule(qs->netdev); + return 1; + } + +@@ -2496,7 +2511,8 @@ static inline int handle_responses(struct adapter *adap, struct sge_rspq *q) + irqreturn_t t3_sge_intr_msix(int irq, void *cookie) + { + struct sge_qset *qs = cookie; +- struct adapter *adap = qs->adap; ++ const struct port_info *pi = netdev_priv(qs->netdev); ++ struct adapter *adap = pi->adapter; + struct sge_rspq *q = &qs->rspq; + + spin_lock(&q->lock); +@@ -2515,11 +2531,13 @@ irqreturn_t t3_sge_intr_msix(int irq, void *cookie) + static irqreturn_t t3_sge_intr_msix_napi(int irq, void *cookie) + { + struct sge_qset *qs = cookie; ++ const struct port_info *pi = netdev_priv(qs->netdev); ++ struct adapter *adap = pi->adapter; + struct sge_rspq *q = &qs->rspq; + + spin_lock(&q->lock); + +- if (handle_responses(qs->adap, q) < 0) ++ if (handle_responses(adap, q) < 0) + q->unhandled_irqs++; + spin_unlock(&q->lock); + return IRQ_HANDLED; +@@ -2562,13 +2580,11 @@ static irqreturn_t t3_intr_msi(int irq, void *cookie) + return IRQ_HANDLED; + } + +-static int rspq_check_napi(struct sge_qset *qs) ++static int rspq_check_napi(struct net_device *dev, struct sge_rspq *q) + { +- struct sge_rspq *q = &qs->rspq; +- +- if (!napi_is_scheduled(&qs->napi) && +- is_new_response(&q->desc[q->cidx], q)) { +- napi_schedule(&qs->napi); ++ if (!napi_is_scheduled(dev) && is_new_response(&q->desc[q->cidx], q)) { ++ if (likely(__netif_rx_schedule_prep(dev))) ++ __netif_rx_schedule(dev); + return 1; + } + return 0; +@@ -2589,9 +2605,10 @@ static irqreturn_t t3_intr_msi_napi(int irq, void *cookie) + + spin_lock(&q->lock); + +- new_packets = rspq_check_napi(&adap->sge.qs[0]); ++ new_packets = rspq_check_napi(adap->sge.qs[0].netdev, q); + if (adap->params.nports == 2) +- new_packets += rspq_check_napi(&adap->sge.qs[1]); ++ new_packets += rspq_check_napi(adap->sge.qs[1].netdev, ++ &adap->sge.qs[1].rspq); + if (!new_packets && t3_slow_intr_handler(adap) == 0) + q->unhandled_irqs++; + +@@ -2694,9 +2711,9 @@ static irqreturn_t t3b_intr(int irq, void *cookie) + static irqreturn_t t3b_intr_napi(int irq, void *cookie) + { + u32 map; ++ struct net_device *dev; + struct adapter *adap = cookie; +- struct sge_qset *qs0 = &adap->sge.qs[0]; +- struct sge_rspq *q0 = &qs0->rspq; ++ struct sge_rspq *q0 = &adap->sge.qs[0].rspq; + + t3_write_reg(adap, A_PL_CLI, 0); + map = t3_read_reg(adap, A_SG_DATA_INTR); +@@ -2709,11 +2726,18 @@ static irqreturn_t t3b_intr_napi(int irq, void *cookie) + if (unlikely(map & F_ERRINTR)) + t3_slow_intr_handler(adap); + +- if (likely(map & 1)) +- napi_schedule(&qs0->napi); ++ if (likely(map & 1)) { ++ dev = adap->sge.qs[0].netdev; + +- if (map & 2) +- napi_schedule(&adap->sge.qs[1].napi); ++ if (likely(__netif_rx_schedule_prep(dev))) ++ __netif_rx_schedule(dev); ++ } ++ if (map & 2) { ++ dev = adap->sge.qs[1].netdev; ++ ++ if (likely(__netif_rx_schedule_prep(dev))) ++ __netif_rx_schedule(dev); ++ } + + spin_unlock(&q0->lock); + return IRQ_HANDLED; +@@ -2896,9 +2920,12 @@ out: + */ + void t3_update_qset_coalesce(struct sge_qset *qs, const struct qset_params *p) + { ++ if (!qs->netdev) ++ return; ++ + qs->rspq.holdoff_tmr = max(p->coalesce_usecs * 10, 1U);/* can't be 0 */ + qs->rspq.polling = p->polling; +- qs->napi.poll = p->polling ? napi_rx_handler : ofld_poll; ++ qs->netdev->poll = p->polling ? napi_rx_handler : ofld_poll; + } + + /** +@@ -2918,7 +2945,7 @@ void t3_update_qset_coalesce(struct sge_qset *qs, const struct qset_params *p) + */ + int t3_sge_alloc_qset(struct adapter *adapter, unsigned int id, int nports, + int irq_vec_idx, const struct qset_params *p, +- int ntxq, struct net_device *dev) ++ int ntxq, struct net_device *netdev) + { + int i, avail, ret = -ENOMEM; + struct sge_qset *q = &adapter->sge.qs[id]; +@@ -3050,10 +3077,17 @@ int t3_sge_alloc_qset(struct adapter *adapter, unsigned int id, int nports, + + spin_unlock_irq(&adapter->sge.reg_lock); + +- q->adap = adapter; +- q->netdev = dev; ++ q->netdev = netdev; + t3_update_qset_coalesce(q, p); + ++ /* ++ * We use atalk_ptr as a backpointer to a qset. In case a device is ++ * associated with multiple queue sets only the first one sets ++ * atalk_ptr. ++ */ ++ if (netdev->atalk_ptr == NULL) ++ netdev->atalk_ptr = q; ++ + avail = refill_fl(adapter, &q->fl[0], q->fl[0].size, + GFP_KERNEL | __GFP_COMP); + if (!avail) { diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0020_sysfs.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0020_sysfs.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0020_sysfs.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0020_sysfs.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,202 @@ +--- + drivers/net/cxgb3/cxgb3_main.c | 78 +++++++++++++++++++---------------------- + 1 file changed, 38 insertions(+), 40 deletions(-) + +Index: ofed_kernel/drivers/net/cxgb3/cxgb3_main.c +=================================================================== +--- ofed_kernel.orig/drivers/net/cxgb3/cxgb3_main.c ++++ ofed_kernel/drivers/net/cxgb3/cxgb3_main.c +@@ -76,6 +76,8 @@ enum { + + #define EEPROM_MAGIC 0x38E2F10C + ++#define to_net_dev(class) container_of(class, struct net_device, class_dev) ++ + #define CH_DEVICE(devid, idx) \ + { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, idx } + +@@ -516,7 +518,7 @@ static int setup_sge_qsets(struct adapte + return 0; + } + +-static ssize_t attr_show(struct device *d, char *buf, ++static ssize_t attr_show(struct class_device *d, char *buf, + ssize_t(*format) (struct net_device *, char *)) + { + ssize_t len; +@@ -528,7 +530,7 @@ static ssize_t attr_show(struct device * + return len; + } + +-static ssize_t attr_store(struct device *d, ++static ssize_t attr_store(struct class_device *d, + const char *buf, size_t len, + ssize_t(*set) (struct net_device *, unsigned int), + unsigned int min_val, unsigned int max_val) +@@ -559,10 +561,9 @@ static ssize_t format_##name(struct net_ + struct adapter *adap = pi->adapter; \ + return sprintf(buf, "%u\n", val_expr); \ + } \ +-static ssize_t show_##name(struct device *d, struct device_attribute *attr, \ +- char *buf) \ ++static ssize_t show_##name(struct class_device *cd, char *buf) \ + { \ +- return attr_show(d, buf, format_##name); \ ++ return attr_show(cd, buf, format_##name); \ + } + + static ssize_t set_nfilters(struct net_device *dev, unsigned int val) +@@ -582,10 +583,10 @@ static ssize_t set_nfilters(struct net_d + return 0; + } + +-static ssize_t store_nfilters(struct device *d, struct device_attribute *attr, +- const char *buf, size_t len) ++static ssize_t store_nfilters(struct class_device *cd, const char *buf, ++ size_t len) + { +- return attr_store(d, buf, len, set_nfilters, 0, ~0); ++ return attr_store(cd, buf, len, set_nfilters, 0, ~0); + } + + static ssize_t set_nservers(struct net_device *dev, unsigned int val) +@@ -602,35 +603,34 @@ static ssize_t set_nservers(struct net_d + return 0; + } + +-static ssize_t store_nservers(struct device *d, struct device_attribute *attr, +- const char *buf, size_t len) ++static ssize_t store_nservers(struct class_device *cd, const char *buf, ++ size_t len) + { +- return attr_store(d, buf, len, set_nservers, 0, ~0); ++ return attr_store(cd, buf, len, set_nservers, 0, ~0); + } + + #define CXGB3_ATTR_R(name, val_expr) \ + CXGB3_SHOW(name, val_expr) \ +-static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL) ++static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL) + + #define CXGB3_ATTR_RW(name, val_expr, store_method) \ + CXGB3_SHOW(name, val_expr) \ +-static DEVICE_ATTR(name, S_IRUGO | S_IWUSR, show_##name, store_method) ++static CLASS_DEVICE_ATTR(name, S_IRUGO | S_IWUSR, show_##name, store_method) + + CXGB3_ATTR_R(cam_size, t3_mc5_size(&adap->mc5)); + CXGB3_ATTR_RW(nfilters, adap->params.mc5.nfilters, store_nfilters); + CXGB3_ATTR_RW(nservers, adap->params.mc5.nservers, store_nservers); + + static struct attribute *cxgb3_attrs[] = { +- &dev_attr_cam_size.attr, +- &dev_attr_nfilters.attr, +- &dev_attr_nservers.attr, ++ &class_device_attr_cam_size.attr, ++ &class_device_attr_nfilters.attr, ++ &class_device_attr_nservers.attr, + NULL + }; + + static struct attribute_group cxgb3_attr_group = {.attrs = cxgb3_attrs }; + +-static ssize_t tm_attr_show(struct device *d, +- char *buf, int sched) ++static ssize_t tm_attr_show(struct class_device *d, char *buf, int sched) + { + struct port_info *pi = netdev_priv(to_net_dev(d)); + struct adapter *adap = pi->adapter; +@@ -655,8 +655,8 @@ static ssize_t tm_attr_show(struct devic + return len; + } + +-static ssize_t tm_attr_store(struct device *d, +- const char *buf, size_t len, int sched) ++static ssize_t tm_attr_store(struct class_device *d, const char *buf, ++ size_t len, int sched) + { + struct port_info *pi = netdev_priv(to_net_dev(d)); + struct adapter *adap = pi->adapter; +@@ -680,17 +680,15 @@ static ssize_t tm_attr_store(struct devi + } + + #define TM_ATTR(name, sched) \ +-static ssize_t show_##name(struct device *d, struct device_attribute *attr, \ +- char *buf) \ ++static ssize_t show_##name(struct class_device *cd, char *buf) \ + { \ +- return tm_attr_show(d, buf, sched); \ ++ return tm_attr_show(cd, buf, sched); \ + } \ +-static ssize_t store_##name(struct device *d, struct device_attribute *attr, \ +- const char *buf, size_t len) \ ++static ssize_t store_##name(struct class_device *cd, const char *buf, size_t len) \ + { \ +- return tm_attr_store(d, buf, len, sched); \ ++ return tm_attr_store(cd, buf, len, sched); \ + } \ +-static DEVICE_ATTR(name, S_IRUGO | S_IWUSR, show_##name, store_##name) ++static CLASS_DEVICE_ATTR(name, S_IRUGO | S_IWUSR, show_##name, store_##name) + + TM_ATTR(sched0, 0); + TM_ATTR(sched1, 1); +@@ -702,14 +700,14 @@ TM_ATTR(sched6, 6); + TM_ATTR(sched7, 7); + + static struct attribute *offload_attrs[] = { +- &dev_attr_sched0.attr, +- &dev_attr_sched1.attr, +- &dev_attr_sched2.attr, +- &dev_attr_sched3.attr, +- &dev_attr_sched4.attr, +- &dev_attr_sched5.attr, +- &dev_attr_sched6.attr, +- &dev_attr_sched7.attr, ++ &class_device_attr_sched0.attr, ++ &class_device_attr_sched1.attr, ++ &class_device_attr_sched2.attr, ++ &class_device_attr_sched3.attr, ++ &class_device_attr_sched4.attr, ++ &class_device_attr_sched5.attr, ++ &class_device_attr_sched6.attr, ++ &class_device_attr_sched7.attr, + NULL + }; + +@@ -1051,8 +1049,8 @@ static int offload_open(struct net_devic + adapter->port[0]->mtu : 0xffff); + init_smt(adapter); + +- if (sysfs_create_group(&tdev->lldev->dev.kobj, &offload_attr_group)) +- dev_dbg(&dev->dev, "cannot create sysfs group\n"); ++ if (sysfs_create_group(&tdev->lldev->class_dev.kobj, &offload_attr_group)) ++ dev_dbg(&adapter->pdev->dev, "cannot create sysfs group\n"); + + /* Call back all registered clients */ + cxgb3_add_clients(tdev); +@@ -1077,7 +1075,7 @@ static int offload_close(struct t3cdev * + /* Call back all registered clients */ + cxgb3_remove_clients(tdev); + +- sysfs_remove_group(&tdev->lldev->dev.kobj, &offload_attr_group); ++ sysfs_remove_group(&tdev->lldev->class_dev.kobj, &offload_attr_group); + + tdev->lldev = NULL; + cxgb3_set_dummy_ops(tdev); +@@ -2788,7 +2786,7 @@ static int __devinit init_one(struct pci + else if (msi > 0 && pci_enable_msi(pdev) == 0) + adapter->flags |= USING_MSI; + +- err = sysfs_create_group(&adapter->port[0]->dev.kobj, ++ err = sysfs_create_group(&adapter->port[0]->class_dev.kobj, + &cxgb3_attr_group); + + print_port_info(adapter, ai); +@@ -2819,7 +2817,7 @@ static void __devexit remove_one(struct + int i; + + t3_sge_stop(adapter); +- sysfs_remove_group(&adapter->port[0]->dev.kobj, ++ sysfs_remove_group(&adapter->port[0]->class_dev.kobj, + &cxgb3_attr_group); + + if (is_offload(adapter)) { diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0030_sset.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0030_sset.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0030_sset.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0030_sset.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,34 @@ +--- + drivers/net/cxgb3/cxgb3_main.c | 11 +++-------- + 1 file changed, 3 insertions(+), 8 deletions(-) + +Index: ofed_kernel/drivers/net/cxgb3/cxgb3_main.c +=================================================================== +--- ofed_kernel.orig/drivers/net/cxgb3/cxgb3_main.c ++++ ofed_kernel/drivers/net/cxgb3/cxgb3_main.c +@@ -1249,14 +1249,9 @@ static char stats_strings[][ETH_GSTRING_ + + }; + +-static int get_sset_count(struct net_device *dev, int sset) ++static int get_stats_count(struct net_device *dev) + { +- switch (sset) { +- case ETH_SS_STATS: +- return ARRAY_SIZE(stats_strings); +- default: +- return -EOPNOTSUPP; +- } ++ return ARRAY_SIZE(stats_strings); + } + + #define T3_REGMAP_SIZE (3 * 1024) +@@ -1774,7 +1769,7 @@ static const struct ethtool_ops cxgb_eth + .get_strings = get_strings, + .phys_id = cxgb3_phys_id, + .nway_reset = restart_autoneg, +- .get_sset_count = get_sset_count, ++ .get_stats_count = get_stats_count, + .get_ethtool_stats = get_stats, + .get_regs_len = get_regs_len, + .get_regs = get_regs, diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0100_remove_lro.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0100_remove_lro.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0100_remove_lro.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0100_remove_lro.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,391 @@ +commit 378b8944e2d9d41bbfb54b9afcb9e80fd6c72650 +Author: root +Date: Thu Nov 19 06:04:39 2009 -0800 + + cxgb3_0100_remove_lro.patch + +diff --git a/drivers/net/cxgb3/adapter.h b/drivers/net/cxgb3/adapter.h +index fc8054c..5799c29 100644 +--- a/drivers/net/cxgb3/adapter.h ++++ b/drivers/net/cxgb3/adapter.h +@@ -50,7 +50,6 @@ struct adapter; + + enum { /* rx_offload flags */ + T3_RX_CSUM = 1 << 0, +- T3_LRO = 1 << 1, + }; + + struct port_info { +@@ -190,9 +189,6 @@ struct sge_qset { /* an SGE queue set */ + struct sge_rspq rspq; + struct sge_fl fl[SGE_RXQ_PER_SET]; + struct sge_txq txq[SGE_TXQ_PER_SET]; +- struct napi_gro_fraginfo lro_frag_tbl; +- int lro_enabled; +- void *lro_va; + struct net_device *netdev; /* associated net device */ + unsigned long txq_stopped; /* which Tx queues are stopped */ + struct timer_list tx_reclaim_timer; /* reclaims TX buffers */ +diff --git a/drivers/net/cxgb3/common.h b/drivers/net/cxgb3/common.h +index 9d7410b..5229567 100644 +--- a/drivers/net/cxgb3/common.h ++++ b/drivers/net/cxgb3/common.h +@@ -344,7 +344,6 @@ struct tp_params { + + struct qset_params { /* SGE queue set parameters */ + unsigned int polling; /* polling/interrupt service for rspq */ +- unsigned int lro; /* large receive offload */ + unsigned int coalesce_usecs; /* irq coalescing timer */ + unsigned int rspq_size; /* # of entries in response queue */ + unsigned int fl_size; /* # of entries in regular free list */ +diff --git a/drivers/net/cxgb3/cxgb3_ioctl.h b/drivers/net/cxgb3/cxgb3_ioctl.h +index b19e437..f10ddb1 100644 +--- a/drivers/net/cxgb3/cxgb3_ioctl.h ++++ b/drivers/net/cxgb3/cxgb3_ioctl.h +@@ -90,7 +90,6 @@ struct ch_qset_params { + int32_t fl_size[2]; + int32_t intr_lat; + int32_t polling; +- int32_t lro; + int32_t cong_thres; + int32_t vector; + int32_t qnum; +diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c +index dfe5e0a..99ae6e3 100644 +--- a/drivers/net/cxgb3/cxgb3_main.c ++++ b/drivers/net/cxgb3/cxgb3_main.c +@@ -659,26 +659,6 @@ static void quiesce_rx(struct adapter *adap) + } + + /** +- * set_qset_lro - Turn a queue set's LRO capability on and off +- * @dev: the device the qset is attached to +- * @qset_idx: the queue set index +- * @val: the LRO switch +- * +- * Sets LRO on or off for a particular queue set. +- * the device's features flag is updated to reflect the LRO +- * capability when all queues belonging to the device are +- * in the same state. +- */ +-static void set_qset_lro(struct net_device *dev, int qset_idx, int val) +-{ +- struct port_info *pi = netdev_priv(dev); +- struct adapter *adapter = pi->adapter; +- +- adapter->params.sge.qset[qset_idx].lro = !!val; +- adapter->sge.qs[qset_idx].lro_enabled = !!val; +-} +- +-/** + * setup_sge_qsets - configure SGE Tx/Rx/response queues + * @adap: the adapter + * +@@ -699,7 +679,6 @@ static int setup_sge_qsets(struct adapter *adap) + const struct port_info *pi = netdev_priv(dev); + + for (j = 0; j < pi->nqsets; ++j, ++qset_idx) { +- set_qset_lro(dev, qset_idx, pi->rx_offload & T3_LRO); + err = t3_sge_alloc_qset(adap, qset_idx, 1, + (adap->flags & USING_MSIX) ? qset_idx + 1 : + irq_idx, +@@ -1474,9 +1453,6 @@ static char stats_strings[][ETH_GSTRING_LEN] = { + "VLANinsertions ", + "TxCsumOffload ", + "RxCsumGood ", +- "LroAggregated ", +- "LroFlushed ", +- "LroNoDesc ", + "RxDrops ", + + "CheckTXEnToggled ", +@@ -1837,13 +1813,7 @@ static int set_rx_csum(struct net_device *dev, u32 data) + + if (data) { + p->rx_offload |= T3_RX_CSUM; +- } else { +- int i; +- +- p->rx_offload &= ~(T3_RX_CSUM | T3_LRO); +- for (i = p->first_qset; i < p->first_qset + p->nqsets; i++) +- set_qset_lro(dev, i, 0); +- } ++ } + return 0; + } + +@@ -2073,14 +2043,6 @@ static int cxgb_extension_ioctl(struct net_device *dev, void __user *useraddr) + MAX_RSPQ_ENTRIES)) + return -EINVAL; + +- if ((adapter->flags & FULL_INIT_DONE) && t.lro > 0) +- for_each_port(adapter, i) { +- pi = adap2pinfo(adapter, i); +- if (t.qset_idx >= pi->first_qset && +- t.qset_idx < pi->first_qset + pi->nqsets && +- !(pi->rx_offload & T3_RX_CSUM)) +- return -EINVAL; +- } + + if ((adapter->flags & FULL_INIT_DONE) && + (t.rspq_size >= 0 || t.fl_size[0] >= 0 || +@@ -2142,8 +2104,6 @@ static int cxgb_extension_ioctl(struct net_device *dev, void __user *useraddr) + } + } + } +- if (t.lro >= 0) +- set_qset_lro(dev, t.qset_idx, t.lro); + + break; + } +@@ -2177,7 +2137,6 @@ static int cxgb_extension_ioctl(struct net_device *dev, void __user *useraddr) + t.fl_size[0] = q->fl_size; + t.fl_size[1] = q->jumbo_size; + t.polling = q->polling; +- t.lro = q->lro; + t.intr_lat = q->coalesce_usecs; + t.cong_thres = q->cong_thres; + t.qnum = q1; +@@ -3196,7 +3155,7 @@ static int __devinit init_one(struct pci_dev *pdev, + adapter->port[i] = netdev; + pi = netdev_priv(netdev); + pi->adapter = adapter; +- pi->rx_offload = T3_RX_CSUM | T3_LRO; ++ pi->rx_offload = T3_RX_CSUM; + pi->port_id = i; + netif_carrier_off(netdev); + netdev->irq = pdev->irq; +@@ -3204,7 +3163,6 @@ static int __devinit init_one(struct pci_dev *pdev, + netdev->mem_end = mmio_start + mmio_len - 1; + netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO; + netdev->features |= NETIF_F_LLTX; +- netdev->features |= NETIF_F_GRO; + if (pci_using_dac) + netdev->features |= NETIF_F_HIGHDMA; + +diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c +index b6cff80..9ca5fa3 100644 +--- a/drivers/net/cxgb3/sge.c ++++ b/drivers/net/cxgb3/sge.c +@@ -1979,7 +1979,7 @@ static inline int is_arp(struct sk_buff *skb) + * if it was immediate data in a response. + */ + static void rx_eth(struct adapter *adap, struct sge_rspq *rq, +- struct sk_buff *skb, int pad, int lro) ++ struct sk_buff *skb, int pad) + { + struct cpl_rx_pkt *p = (struct cpl_rx_pkt *)(skb->data + pad); + struct sge_qset *qs = rspq_to_qset(rq); +@@ -1990,7 +1990,7 @@ static void rx_eth(struct adapter *adap, struct sge_rspq *rq, + pi = netdev_priv(skb->dev); + if ((pi->rx_offload & T3_RX_CSUM) && p->csum_valid && + p->csum == htons(0xffff) && !p->fragment) { +- qs->port_stats[SGE_PSTAT_RX_CSUM_GOOD]++; ++ rspq_to_qset(rq)->port_stats[SGE_PSTAT_RX_CSUM_GOOD]++; + skb->ip_summed = CHECKSUM_UNNECESSARY; + } else + skb->ip_summed = CHECKSUM_NONE; +@@ -1999,12 +1999,8 @@ static void rx_eth(struct adapter *adap, struct sge_rspq *rq, + if (unlikely(p->vlan_valid)) { + struct vlan_group *grp = pi->vlan_grp; + +- qs->port_stats[SGE_PSTAT_VLANEX]++; +- if (likely(grp)) +- if (lro) +- vlan_gro_receive(&qs->napi, grp, +- ntohs(p->vlan), skb); +- else { ++ rspq_to_qset(rq)->port_stats[SGE_PSTAT_VLANEX]++; ++ if (likely(grp)) { + if (unlikely(pi->iscsi_ipv4addr && + is_arp(skb))) { + unsigned short vtag = ntohs(p->vlan) & +@@ -2019,97 +2015,13 @@ static void rx_eth(struct adapter *adap, struct sge_rspq *rq, + else + dev_kfree_skb_any(skb); + } else if (rq->polling) { +- if (lro) +- napi_gro_receive(&qs->napi, skb); +- else { + if (unlikely(pi->iscsi_ipv4addr && is_arp(skb))) + cxgb3_arp_process(adap, skb); + netif_receive_skb(skb); +- } + } else + netif_rx(skb); + } + +-static inline int is_eth_tcp(u32 rss) +-{ +- return G_HASHTYPE(ntohl(rss)) == RSS_HASH_4_TUPLE; +-} +- +-/** +- * lro_add_page - add a page chunk to an LRO session +- * @adap: the adapter +- * @qs: the associated queue set +- * @fl: the free list containing the page chunk to add +- * @len: packet length +- * @complete: Indicates the last fragment of a frame +- * +- * Add a received packet contained in a page chunk to an existing LRO +- * session. +- */ +-static void lro_add_page(struct adapter *adap, struct sge_qset *qs, +- struct sge_fl *fl, int len, int complete) +-{ +- struct rx_sw_desc *sd = &fl->sdesc[fl->cidx]; +- struct cpl_rx_pkt *cpl; +- struct skb_frag_struct *rx_frag = qs->lro_frag_tbl.frags; +- int nr_frags = qs->lro_frag_tbl.nr_frags; +- int frag_len = qs->lro_frag_tbl.len; +- int offset = 0; +- +- if (!nr_frags) { +- offset = 2 + sizeof(struct cpl_rx_pkt); +- qs->lro_va = cpl = sd->pg_chunk.va + 2; +- } +- +- fl->credits--; +- +- len -= offset; +- pci_dma_sync_single_for_cpu(adap->pdev, +- pci_unmap_addr(sd, dma_addr), +- fl->buf_size - SGE_PG_RSVD, +- PCI_DMA_FROMDEVICE); +- +- (*sd->pg_chunk.p_cnt)--; +- if (!*sd->pg_chunk.p_cnt && sd->pg_chunk.page != fl->pg_chunk.page) +- pci_unmap_page(adap->pdev, +- sd->pg_chunk.mapping, +- fl->alloc_size, +- PCI_DMA_FROMDEVICE); +- +- prefetch(qs->lro_va); +- +- rx_frag += nr_frags; +- rx_frag->page = sd->pg_chunk.page; +- rx_frag->page_offset = sd->pg_chunk.offset + offset; +- rx_frag->size = len; +- frag_len += len; +- qs->lro_frag_tbl.nr_frags++; +- qs->lro_frag_tbl.len = frag_len; +- +- +- if (!complete) +- return; +- +- qs->lro_frag_tbl.ip_summed = CHECKSUM_UNNECESSARY; +- cpl = qs->lro_va; +- +- if (unlikely(cpl->vlan_valid)) { +- struct net_device *dev = qs->netdev; +- struct port_info *pi = netdev_priv(dev); +- struct vlan_group *grp = pi->vlan_grp; +- +- if (likely(grp != NULL)) { +- vlan_gro_frags(&qs->napi, grp, ntohs(cpl->vlan), +- &qs->lro_frag_tbl); +- goto out; +- } +- } +- napi_gro_frags(&qs->napi, &qs->lro_frag_tbl); +- +-out: +- qs->lro_frag_tbl.nr_frags = qs->lro_frag_tbl.len = 0; +-} +- + /** + * handle_rsp_cntrl_info - handles control information in a response + * @qs: the queue set corresponding to the response +@@ -2238,7 +2150,7 @@ static int process_responses(struct adapter *adap, struct sge_qset *qs, + q->next_holdoff = q->holdoff_tmr; + + while (likely(budget_left && is_new_response(r, q))) { +- int packet_complete, eth, ethpad = 2, lro = qs->lro_enabled; ++ int packet_complete, eth, ethpad = 2; + struct sk_buff *skb = NULL; + u32 len, flags = ntohl(r->flags); + __be32 rss_hi = *(const __be32 *)r, +@@ -2270,25 +2182,16 @@ no_mem: + } else if ((len = ntohl(r->len_cq)) != 0) { + struct sge_fl *fl; + +- lro &= eth && is_eth_tcp(rss_hi); +- + fl = (len & F_RSPD_FLQ) ? &qs->fl[1] : &qs->fl[0]; + if (fl->use_pages) { + void *addr = fl->sdesc[fl->cidx].pg_chunk.va; + +- prefetch(&qs->lro_frag_tbl); + + prefetch(addr); + #if L1_CACHE_BYTES < 128 + prefetch(addr + L1_CACHE_BYTES); + #endif + __refill_fl(adap, fl); +- if (lro > 0) { +- lro_add_page(adap, qs, fl, +- G_RSPD_LEN(len), +- flags & F_RSPD_EOP); +- goto next_fl; +- } + + skb = get_packet_pg(adap, fl, q, + G_RSPD_LEN(len), +@@ -2304,7 +2207,7 @@ no_mem: + q->rx_drops++; + } else if (unlikely(r->rss_hdr.opcode == CPL_TRACE_PKT)) + __skb_pull(skb, 2); +-next_fl: ++ + if (++fl->cidx == fl->size) + fl->cidx = 0; + } else +@@ -2334,7 +2237,7 @@ next_fl: + + if (skb != NULL && packet_complete) { + if (eth) +- rx_eth(adap, q, skb, ethpad, lro); ++ rx_eth(adap, q, skb, ethpad); + else { + q->offload_pkts++; + /* Preserve the RSS info in csum & priority */ +@@ -2881,7 +2784,7 @@ static void sge_timer_rx(unsigned long data) + if (!spin_trylock_irq(lock)) + goto out; + +- if (napi_is_scheduled(&qs->napi)) ++ if (napi_is_scheduled(qs->netdev)) + goto unlock; + + if (adap->params.rev < 4) { +diff --git a/drivers/net/cxgb3/t3_cpl.h b/drivers/net/cxgb3/t3_cpl.h +index 852c399..b07ab67 100644 +--- a/drivers/net/cxgb3/t3_cpl.h ++++ b/drivers/net/cxgb3/t3_cpl.h +@@ -174,13 +174,6 @@ enum { /* TCP congestion control algorithms */ + CONG_ALG_HIGHSPEED + }; + +-enum { /* RSS hash type */ +- RSS_HASH_NONE = 0, +- RSS_HASH_2_TUPLE = 1, +- RSS_HASH_4_TUPLE = 2, +- RSS_HASH_TCPV6 = 3 +-}; +- + union opcode_tid { + __be32 opcode_tid; + __u8 opcode; +@@ -194,10 +187,6 @@ union opcode_tid { + #define S_QNUM 0 + #define G_QNUM(x) (((x) >> S_QNUM) & 0xFFFF) + +-#define S_HASHTYPE 22 +-#define M_HASHTYPE 0x3 +-#define G_HASHTYPE(x) (((x) >> S_HASHTYPE) & M_HASHTYPE) +- + /* tid is assumed to be 24-bits */ + #define MK_OPCODE_TID(opcode, tid) (V_OPCODE(opcode) | (tid)) + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0110_provider_sysfs.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0110_provider_sysfs.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0110_provider_sysfs.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0110_provider_sysfs.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,120 @@ +--- + drivers/infiniband/hw/cxgb3/iwch_provider.c | 63 +++++++++++++--------------- + 1 file changed, 30 insertions(+), 33 deletions(-) + +Index: ofed_kernel/drivers/infiniband/hw/cxgb3/iwch_provider.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/hw/cxgb3/iwch_provider.c ++++ ofed_kernel/drivers/infiniband/hw/cxgb3/iwch_provider.c +@@ -1178,46 +1178,43 @@ static int iwch_query_port(struct ib_dev + return 0; + } + +-static ssize_t show_rev(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_rev(struct class_device *cdev, char *buf) + { +- struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev, +- ibdev.dev); +- PDBG("%s dev 0x%p\n", __func__, dev); ++ struct iwch_dev *iwch_dev = container_of(cdev, struct iwch_dev, ++ ibdev.class_dev); ++ PDBG("%s dev 0x%p\n", __func__, cdev); + return sprintf(buf, "%d\n", iwch_dev->rdev.t3cdev_p->type); + } + +-static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr, char *buf) ++static ssize_t show_fw_ver(struct class_device *cdev, char *buf) + { +- struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev, +- ibdev.dev); ++ struct iwch_dev *iwch_dev = container_of(cdev, struct iwch_dev, ++ ibdev.class_dev); + struct ethtool_drvinfo info; + struct net_device *lldev = iwch_dev->rdev.t3cdev_p->lldev; + +- PDBG("%s dev 0x%p\n", __func__, dev); ++ PDBG("%s dev 0x%p\n", __func__, cdev); + lldev->ethtool_ops->get_drvinfo(lldev, &info); + return sprintf(buf, "%s\n", info.fw_version); + } + +-static ssize_t show_hca(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_hca(struct class_device *cdev, char *buf) + { +- struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev, +- ibdev.dev); ++ struct iwch_dev *iwch_dev = container_of(cdev, struct iwch_dev, ++ ibdev.class_dev); + struct ethtool_drvinfo info; + struct net_device *lldev = iwch_dev->rdev.t3cdev_p->lldev; + +- PDBG("%s dev 0x%p\n", __func__, dev); ++ PDBG("%s dev 0x%p\n", __func__, cdev); + lldev->ethtool_ops->get_drvinfo(lldev, &info); + return sprintf(buf, "%s\n", info.driver); + } + +-static ssize_t show_board(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_board(struct class_device *cdev, char *buf) + { +- struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev, +- ibdev.dev); +- PDBG("%s dev 0x%p\n", __func__, dev); ++ struct iwch_dev *iwch_dev = container_of(cdev, struct iwch_dev, ++ ibdev.class_dev); ++ PDBG("%s dev 0x%p\n", __func__, cdev); + return sprintf(buf, "%x.%x\n", iwch_dev->rdev.rnic_info.pdev->vendor, + iwch_dev->rdev.rnic_info.pdev->device); + } +@@ -1281,16 +1278,16 @@ static int iwch_get_mib(struct ib_device + return 0; + } + +-static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +-static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +-static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +-static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); +- +-static struct device_attribute *iwch_class_attributes[] = { +- &dev_attr_hw_rev, +- &dev_attr_fw_ver, +- &dev_attr_hca_type, +- &dev_attr_board_id, ++static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); ++static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); ++static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); ++static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); ++ ++static struct class_device_attribute *iwch_class_attributes[] = { ++ &class_device_attr_hw_rev, ++ &class_device_attr_fw_ver, ++ &class_device_attr_hca_type, ++ &class_device_attr_board_id, + }; + + int iwch_register_device(struct iwch_dev *dev) +@@ -1389,8 +1386,8 @@ int iwch_register_device(struct iwch_dev + goto bail1; + + for (i = 0; i < ARRAY_SIZE(iwch_class_attributes); ++i) { +- ret = device_create_file(&dev->ibdev.dev, +- iwch_class_attributes[i]); ++ ret = class_device_create_file(&dev->ibdev.class_dev, ++ iwch_class_attributes[i]); + if (ret) { + goto bail2; + } +@@ -1408,8 +1405,8 @@ void iwch_unregister_device(struct iwch_ + + PDBG("%s iwch_dev %p\n", __func__, dev); + for (i = 0; i < ARRAY_SIZE(iwch_class_attributes); ++i) +- device_remove_file(&dev->ibdev.dev, +- iwch_class_attributes[i]); ++ class_device_remove_file(&dev->ibdev.class_dev, ++ iwch_class_attributes[i]); + ib_unregister_device(&dev->ibdev); + return; + } diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0120_fixwarnings.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0120_fixwarnings.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0120_fixwarnings.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0120_fixwarnings.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,19 @@ +commit 9e36dc0c4be7ec1a88896f11290578e04ca0e835 +Author: root +Date: Tue Jun 16 14:42:14 2009 -0700 + + cxgb3_0120_fixwarnings.patch + +diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c +index 035d555..6895044 100644 +--- a/drivers/net/cxgb3/cxgb3_main.c ++++ b/drivers/net/cxgb3/cxgb3_main.c +@@ -284,7 +284,7 @@ void t3_os_phymod_changed(struct adapter *adap, int port_id) + NULL, "SR", "LR", "LRM", "TWINAX", "TWINAX", "unknown" + }; + +- const struct net_device *dev = adap->port[port_id]; ++ struct net_device *dev = adap->port[port_id]; + const struct port_info *pi = netdev_priv(dev); + + if (pi->phy.modtype == phy_modtype_none) diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0130_vlanrxkillvid.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0130_vlanrxkillvid.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0130_vlanrxkillvid.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb3_0130_vlanrxkillvid.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,30 @@ +commit ad41a1966a4a7d9925c89860fbdd9118d0a065b3 +Author: root +Date: Tue Oct 6 07:29:29 2009 -0700 + + cxgb3_0130_vlanrxkillvid.patch + +diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c +index b3ccacc..b109b59 100644 +--- a/drivers/net/cxgb3/cxgb3_main.c ++++ b/drivers/net/cxgb3/cxgb3_main.c +@@ -2517,6 +2517,11 @@ static void vlan_rx_register(struct net_device *dev, struct vlan_group *grp) + t3_synchronize_rx(adapter, pi); + } + ++static void vlan_rx_kill_vid(struct net_device *dev, unsigned short vid) ++{ ++ /* nothing */ ++} ++ + #ifdef CONFIG_NET_POLL_CONTROLLER + static void cxgb_netpoll(struct net_device *dev) + { +@@ -3169,6 +3174,7 @@ static int __devinit init_one(struct pci_dev *pdev, + netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; + netdev->hard_start_xmit = t3_eth_xmit; + netdev->vlan_rx_register = vlan_rx_register; ++ netdev->vlan_rx_kill_vid = vlan_rx_kill_vid; + netdev->open = cxgb_open; + netdev->stop = cxgb_close; + netdev->get_stats = cxgb_get_stats; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb4_0001_rhel5_7.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb4_0001_rhel5_7.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb4_0001_rhel5_7.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/cxgb4_0001_rhel5_7.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,1419 @@ +diff --git a/drivers/net/cxgb4/cxgb4.h b/drivers/net/cxgb4/cxgb4.h +--- a/drivers/net/cxgb4/cxgb4.h 2011-08-09 17:24:36.000000000 +0530 ++++ b/drivers/net/cxgb4/cxgb4.h 2011-08-08 13:33:11.000000000 +0530 +@@ -43,6 +43,7 @@ + #include + #include + #include ++#include + #include + #include "cxgb4_uld.h" + #include "t4_hw.h" +@@ -286,13 +287,22 @@ enum { + MAX_INGQ = 64 /* max # of interrupt-capable ingress queues */ + }; + ++/* ++ * Total # of sge_rspq within an adapter ++ */ ++#define NUM_SGE_RSPQ (MAX_ETH_QSETS \ ++ + MAX_OFLD_QSETS \ ++ + MAX_RDMA_QUEUES \ ++ + 2) ++ + struct adapter; + struct vlan_group; + struct sge_rspq; + + struct port_info { + struct adapter *adapter; ++ struct vlan_group *vlan_grp; + u16 viid; + s16 xact_addr_filt; /* index of exact MAC address filter */ + u16 rss_size; /* size of VI's RSS table slice */ + s8 mdio_addr; +@@ -301,13 +311,20 @@ struct port_info { + u8 port_id; + u8 tx_chan; + u8 lport; /* associated offload logical port */ ++ u8 rx_offload; /* CSO, etc */ + u8 nqsets; /* # of qsets */ + u8 first_qset; /* index of first qset */ + u8 rss_mode; + struct link_config link_cfg; ++ struct net_device_stats netstats; + u16 *rss; + }; + ++/* port_info.rx_offload flags */ ++enum { ++ RX_CSO = 1 << 0, ++}; ++ + struct dentry; + struct work_struct; + +@@ -345,9 +362,10 @@ struct pkt_gl { + }; + + typedef int (*rspq_handler_t)(struct sge_rspq *q, const __be64 *rsp, +- const struct pkt_gl *gl); ++ const struct pkt_gl *gl); + + struct sge_rspq { /* state for an SGE response queue */ ++ spinlock_t lock; /* guards response processing */ + struct napi_struct napi; + const __be64 *cur_desc; /* current descriptor in queue */ + unsigned int cidx; /* consumer index */ +@@ -422,7 +440,7 @@ struct sge_txq { + + struct sge_eth_txq { /* state for an SGE Ethernet Tx queue */ + struct sge_txq q; +- struct netdev_queue *txq; /* associated netdev TX queue */ ++ struct net_device *txq; /* associated netdev */ + unsigned long tso; /* # of TSO requests */ + unsigned long tx_cso; /* # of Tx checksum offloads */ + unsigned long vlan_ins; /* # of Tx VLAN insertions */ +@@ -494,6 +512,7 @@ struct adapter { + unsigned int fn; + unsigned int flags; + ++ const char *name; + int msg_enable; + + struct adapter_params params; +@@ -524,6 +543,19 @@ struct adapter { + struct work_struct tid_release_task; + bool tid_release_task_busy; + ++ /* ++ * Dummy netdevices are needed when using multiple receive queues with ++ * NAPI as each netdevice can service only one queue. ++ */ ++ struct net_device *dummy_netdev[NUM_SGE_RSPQ]; ++ unsigned int dummy_netdev_cnt; ++ ++ /* ++ * Need to keep track of the dirents we add to the debugfs ++ * for subsequent removal. ++ */ ++ struct dentry *debugfs_ent[48]; ++ unsigned int debugfs_ent_cnt; + struct dentry *debugfs_root; + + spinlock_t stats_lock; +@@ -570,7 +602,7 @@ static inline void t4_write_reg64(struct + */ + static inline struct port_info *netdev2pinfo(const struct net_device *dev) + { +- return netdev_priv(dev); ++ return netdev_priv((void *)dev); + } + + /** +@@ -603,22 +635,22 @@ void *t4_alloc_mem(size_t size); + + void t4_free_sge_resources(struct adapter *adap); + irq_handler_t t4_intr_handler(struct adapter *adap); +-netdev_tx_t t4_eth_xmit(struct sk_buff *skb, struct net_device *dev); ++int t4_eth_xmit(struct sk_buff *skb, struct net_device *dev); + int t4_ethrx_handler(struct sge_rspq *q, const __be64 *rsp, +- const struct pkt_gl *gl); ++ const struct pkt_gl *gl); + int t4_mgmt_tx(struct adapter *adap, struct sk_buff *skb); + int t4_ofld_send(struct adapter *adap, struct sk_buff *skb); + int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq, +- struct net_device *dev, int intr_idx, +- struct sge_fl *fl, rspq_handler_t hnd); ++ struct net_device *dev, int intr_idx, ++ struct sge_fl *fl, rspq_handler_t hnd); + int t4_sge_alloc_eth_txq(struct adapter *adap, struct sge_eth_txq *txq, +- struct net_device *dev, struct netdev_queue *netdevq, +- unsigned int iqid); ++ struct net_device *dev, struct netdev_queue *netdevq, ++ unsigned int iqid); + int t4_sge_alloc_ctrl_txq(struct adapter *adap, struct sge_ctrl_txq *txq, +- struct net_device *dev, unsigned int iqid, +- unsigned int cmplqid); ++ struct net_device *dev, unsigned int iqid, ++ unsigned int cmplqid); + int t4_sge_alloc_ofld_txq(struct adapter *adap, struct sge_ofld_txq *txq, +- struct net_device *dev, unsigned int iqid); ++ struct net_device *dev, unsigned int iqid); + irqreturn_t t4_sge_intr_msix(int irq, void *cookie); + void t4_sge_init(struct adapter *adap); + void t4_sge_start(struct adapter *adap); +@@ -634,25 +666,25 @@ static inline unsigned int core_ticks_pe + } + + static inline unsigned int us_to_core_ticks(const struct adapter *adap, +- unsigned int us) ++ unsigned int us) + { + return (us * adap->params.vpd.cclk) / 1000; + } + + void t4_set_reg_field(struct adapter *adap, unsigned int addr, u32 mask, +- u32 val); ++ u32 val); + + int t4_wr_mbox_meat(struct adapter *adap, int mbox, const void *cmd, int size, +- void *rpl, bool sleep_ok); ++ void *rpl, bool sleep_ok); + + static inline int t4_wr_mbox(struct adapter *adap, int mbox, const void *cmd, +- int size, void *rpl) ++ int size, void *rpl) + { + return t4_wr_mbox_meat(adap, mbox, cmd, size, rpl, true); + } + + static inline int t4_wr_mbox_ns(struct adapter *adap, int mbox, const void *cmd, +- int size, void *rpl) ++ int size, void *rpl) + { + return t4_wr_mbox_meat(adap, mbox, cmd, size, rpl, false); + } +@@ -663,7 +695,7 @@ int t4_slow_intr_handler(struct adapter + + int t4_wait_dev_ready(struct adapter *adap); + int t4_link_start(struct adapter *adap, unsigned int mbox, unsigned int port, +- struct link_config *lc); ++ struct link_config *lc); + int t4_restart_aneg(struct adapter *adap, unsigned int mbox, unsigned int port); + int t4_seeprom_wp(struct adapter *adapter, bool enable); + int t4_load_fw(struct adapter *adapter, const u8 *fw_data, unsigned int size); +@@ -672,9 +704,9 @@ int t4_prep_adapter(struct adapter *adap + int t4_port_init(struct adapter *adap, int mbox, int pf, int vf); + void t4_fatal_err(struct adapter *adapter); + int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid, +- int start, int n, const u16 *rspq, unsigned int nrspq); ++ int start, int n, const u16 *rspq, unsigned int nrspq); + int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode, +- unsigned int flags); ++ unsigned int flags); + int t4_mc_read(struct adapter *adap, u32 addr, __be32 *data, u64 *parity); + int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, + u64 *parity); +@@ -682,14 +714,14 @@ int t4_edc_read(struct adapter *adap, in + void t4_get_port_stats(struct adapter *adap, int idx, struct port_stats *p); + void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log); + void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4, +- struct tp_tcp_stats *v6); ++ struct tp_tcp_stats *v6); + void t4_load_mtus(struct adapter *adap, const unsigned short *mtus, +- const unsigned short *alpha, const unsigned short *beta); ++ const unsigned short *alpha, const unsigned short *beta); + + void t4_wol_magic_enable(struct adapter *adap, unsigned int port, +- const u8 *addr); ++ const u8 *addr); + int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map, +- u64 mask0, u64 mask1, unsigned int crc, bool enable); ++ u64 mask0, u64 mask1, unsigned int crc, bool enable); + + int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox, + enum dev_master master, enum dev_state *state); +@@ -697,11 +729,11 @@ int t4_fw_bye(struct adapter *adap, unsi + int t4_early_init(struct adapter *adap, unsigned int mbox); + int t4_fw_reset(struct adapter *adap, unsigned int mbox, int reset); + int t4_query_params(struct adapter *adap, unsigned int mbox, unsigned int pf, +- unsigned int vf, unsigned int nparams, const u32 *params, +- u32 *val); ++ unsigned int vf, unsigned int nparams, const u32 *params, ++ u32 *val); + int t4_set_params(struct adapter *adap, unsigned int mbox, unsigned int pf, +- unsigned int vf, unsigned int nparams, const u32 *params, +- const u32 *val); ++ unsigned int vf, unsigned int nparams, const u32 *params, ++ const u32 *val); + int t4_cfg_pfvf(struct adapter *adap, unsigned int mbox, unsigned int pf, + unsigned int vf, unsigned int txq, unsigned int txq_eth_ctrl, + unsigned int rxqi, unsigned int rxq, unsigned int tc, +@@ -714,28 +746,28 @@ int t4_set_rxmode(struct adapter *adap, + int mtu, int promisc, int all_multi, int bcast, int vlanex, + bool sleep_ok); + int t4_alloc_mac_filt(struct adapter *adap, unsigned int mbox, +- unsigned int viid, bool free, unsigned int naddr, +- const u8 **addr, u16 *idx, u64 *hash, bool sleep_ok); ++ unsigned int viid, bool free, unsigned int naddr, ++ const u8 **addr, u16 *idx, u64 *hash, bool sleep_ok); + int t4_change_mac(struct adapter *adap, unsigned int mbox, unsigned int viid, +- int idx, const u8 *addr, bool persist, bool add_smt); ++ int idx, const u8 *addr, bool persist, bool add_smt); + int t4_set_addr_hash(struct adapter *adap, unsigned int mbox, unsigned int viid, +- bool ucast, u64 vec, bool sleep_ok); ++ bool ucast, u64 vec, bool sleep_ok); + int t4_enable_vi(struct adapter *adap, unsigned int mbox, unsigned int viid, +- bool rx_en, bool tx_en); ++ bool rx_en, bool tx_en); + int t4_identify_port(struct adapter *adap, unsigned int mbox, unsigned int viid, +- unsigned int nblinks); ++ unsigned int nblinks); + int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr, +- unsigned int mmd, unsigned int reg, u16 *valp); ++ unsigned int mmd, unsigned int reg, u16 *valp); + int t4_mdio_wr(struct adapter *adap, unsigned int mbox, unsigned int phy_addr, +- unsigned int mmd, unsigned int reg, u16 val); ++ unsigned int mmd, unsigned int reg, u16 val); + int t4_iq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, +- unsigned int vf, unsigned int iqtype, unsigned int iqid, +- unsigned int fl0id, unsigned int fl1id); ++ unsigned int vf, unsigned int iqtype, unsigned int iqid, ++ unsigned int fl0id, unsigned int fl1id); + int t4_eth_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, +- unsigned int vf, unsigned int eqid); ++ unsigned int vf, unsigned int eqid); + int t4_ctrl_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, +- unsigned int vf, unsigned int eqid); ++ unsigned int vf, unsigned int eqid); + int t4_ofld_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf, +- unsigned int vf, unsigned int eqid); ++ unsigned int vf, unsigned int eqid); + int t4_handle_fw_rpl(struct adapter *adap, const __be64 *rpl); + #endif /* __CXGB4_H__ */ +diff --git a/drivers/net/cxgb4/cxgb4_main.c b/drivers/net/cxgb4/cxgb4_main.c +--- a/drivers/net/cxgb4/cxgb4_main.c 2011-08-09 17:24:36.000000000 +0530 ++++ b/drivers/net/cxgb4/cxgb4_main.c 2011-08-08 13:22:03.000000000 +0530 +@@ -302,7 +303,7 @@ void t4_os_portmod_changed(const struct + }; + + const struct net_device *dev = adap->port[port_id]; +- const struct port_info *pi = netdev_priv(dev); ++ const struct port_info *pi = netdev_priv((void *)dev); + + if (pi->mod_type == FW_PORT_MOD_TYPE_NONE) + netdev_info(dev, "port module unplugged\n"); +@@ -322,10 +323,10 @@ static int set_addr_filters(const struct + u16 filt_idx[7]; + const u8 *addr[7]; + int ret, naddr = 0; ++ const struct dev_addr_list *d; + const struct netdev_hw_addr *ha; + int uc_cnt = netdev_uc_count(dev); +- int mc_cnt = netdev_mc_count(dev); +- const struct port_info *pi = netdev_priv(dev); ++ const struct port_info *pi = netdev_priv((void *)dev); + unsigned int mb = pi->adapter->fn; + + /* first do the secondary unicast addresses */ +@@ -343,9 +344,9 @@ static int set_addr_filters(const struct + } + + /* next set up the multicast addresses */ +- netdev_for_each_mc_addr(ha, dev) { +- addr[naddr++] = ha->addr; +- if (--mc_cnt == 0 || naddr >= ARRAY_SIZE(addr)) { ++ netdev_for_each_mc_addr(d, dev) { ++ addr[naddr++] = d->dmi_addr; ++ if (naddr >= ARRAY_SIZE(addr) || d->next == NULL) { + ret = t4_alloc_mac_filt(pi->adapter, mb, pi->viid, free, + naddr, addr, filt_idx, &mhash, sleep); + if (ret < 0) +@@ -406,7 +407,7 @@ static int link_start(struct net_device + * that step explicitly. + */ + ret = t4_set_rxmode(pi->adapter, mb, pi->viid, dev->mtu, -1, -1, -1, +- !!(dev->features & NETIF_F_HW_VLAN_RX), true); ++ pi->vlan_grp != NULL, true); + if (ret == 0) { + ret = t4_change_mac(pi->adapter, mb, pi->viid, + pi->xact_addr_filt, dev->dev_addr, true, +@@ -685,7 +686,7 @@ static void quiesce_rx(struct adapter *a + struct sge_rspq *q = adap->sge.ingr_map[i]; + + if (q && q->handler) +- napi_disable(&q->napi); ++ napi_disable(q->netdev); + } + } + +@@ -702,7 +703,7 @@ static void enable_rx(struct adapter *ad + if (!q) + continue; + if (q->handler) +- napi_enable(&q->napi); ++ napi_enable(q->netdev); + /* 0-increment GTS to start the timer and enable interrupts */ + t4_write_reg(adap, MYPF_REG(SGE_PF_GTS), + SEINTARM(q->intr_params) | +@@ -887,13 +883,16 @@ out: t4_release_firmware(fw); + */ + void *t4_alloc_mem(size_t size) + { +- void *p = kzalloc(size, GFP_KERNEL); ++ void *p = kmalloc(size, GFP_KERNEL); + +- if (!p) +- p = vzalloc(size); +- return p; ++ if (!p) ++ p = vmalloc(size); ++ if (p) ++ memset(p, 0, size); ++ return p; + } + ++ + /* + * Free memory allocated through alloc_mem(). + */ +@@ -1000,14 +999,9 @@ static char stats_strings[][ETH_GSTRING_ + "GROmerged ", + }; + +-static int get_sset_count(struct net_device *dev, int sset) ++static int get_stats_count(struct net_device *dev) + { +- switch (sset) { +- case ETH_SS_STATS: +- return ARRAY_SIZE(stats_strings); +- default: +- return -EOPNOTSUPP; +- } ++ return ARRAY_SIZE(stats_strings); + } + + #define T4_REGMAP_SIZE (160 * 1024) +@@ -1361,20 +1355,15 @@ static int restart_autoneg(struct net_de + return 0; + } + +-static int identify_port(struct net_device *dev, +- enum ethtool_phys_id_state state) ++static int identify_port(struct net_device *dev, u32 data) + { +- unsigned int val; + struct adapter *adap = netdev2adap(dev); + +- if (state == ETHTOOL_ID_ACTIVE) +- val = 0xffff; +- else if (state == ETHTOOL_ID_INACTIVE) +- val = 0; +- else +- return -EINVAL; ++ if (data == 0) ++ data = 2; /* default to 2 seconds */ + +- return t4_identify_port(adap, adap->fn, netdev2pinfo(dev)->viid, val); ++ return t4_identify_port(adap, adap->fn, netdev2pinfo(dev)->viid, ++ data * 5); + } + + static unsigned int from_fw_linkcaps(unsigned int type, unsigned int caps) +@@ -1461,8 +1450,7 @@ static int get_settings(struct net_devic + cmd->supported = from_fw_linkcaps(p->port_type, p->link_cfg.supported); + cmd->advertising = from_fw_linkcaps(p->port_type, + p->link_cfg.advertising); +- ethtool_cmd_speed_set(cmd, +- netif_carrier_ok(dev) ? p->link_cfg.speed : 0); ++ cmd->speed = netif_carrier_ok(dev) ? p->link_cfg.speed : 0; + cmd->duplex = DUPLEX_FULL; + cmd->autoneg = p->link_cfg.autoneg; + cmd->maxtxpkt = 0; +@@ -1486,7 +1474,6 @@ static int set_settings(struct net_devic + unsigned int cap; + struct port_info *p = netdev_priv(dev); + struct link_config *lc = &p->link_cfg; +- u32 speed = ethtool_cmd_speed(cmd); + + if (cmd->duplex != DUPLEX_FULL) /* only full-duplex supported */ + return -EINVAL; +@@ -1497,16 +1484,16 @@ static int set_settings(struct net_devic + * being requested. + */ + if (cmd->autoneg == AUTONEG_DISABLE && +- (lc->supported & speed_to_caps(speed))) +- return 0; ++ (lc->supported & speed_to_caps(cmd->speed))) ++ return 0; + return -EINVAL; + } + + if (cmd->autoneg == AUTONEG_DISABLE) { +- cap = speed_to_caps(speed); ++ cap = speed_to_caps(cmd->speed); + +- if (!(lc->supported & cap) || (speed == SPEED_1000) || +- (speed == SPEED_10000)) ++ if (!(lc->supported & cap) || cmd->speed == SPEED_1000 || ++ cmd->speed == SPEED_10000) + return -EINVAL; + lc->requested_speed = cap; + lc->advertising = 0; +@@ -1558,6 +1545,24 @@ static int set_pauseparam(struct net_dev + return 0; + } + ++static u32 get_rx_csum(struct net_device *dev) ++{ ++ struct port_info *p = netdev_priv(dev); ++ ++ return p->rx_offload & RX_CSO; ++} ++ ++static int set_rx_csum(struct net_device *dev, u32 data) ++{ ++ struct port_info *p = netdev_priv(dev); ++ ++ if (data) ++ p->rx_offload |= RX_CSO; ++ else ++ p->rx_offload &= ~RX_CSO; ++ return 0; ++} ++ + static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e) + { + const struct port_info *pi = netdev_priv(dev); +@@ -1831,6 +1836,7 @@ out: + return err; + } + ++#if 0 + static int set_flash(struct net_device *netdev, struct ethtool_flash *ef) + { + int ret; +@@ -1848,6 +1854,7 @@ static int set_flash(struct net_device * + dev_info(adap->pdev_dev, "loaded firmware %s\n", ef->data); + return ret; + } ++#endif + + #define WOL_SUPPORTED (WAKE_BCAST | WAKE_MAGIC) + #define BCAST_CRC 0xa0ccc1a6 +@@ -1879,115 +1886,17 @@ static int set_wol(struct net_device *de + return err; + } + +-static int cxgb_set_features(struct net_device *dev, u32 features) +-{ +- const struct port_info *pi = netdev_priv(dev); +- u32 changed = dev->features ^ features; +- int err; +- +- if (!(changed & NETIF_F_HW_VLAN_RX)) +- return 0; +- +- err = t4_set_rxmode(pi->adapter, pi->adapter->fn, pi->viid, -1, +- -1, -1, -1, +- !!(features & NETIF_F_HW_VLAN_RX), true); +- if (unlikely(err)) +- dev->features = features ^ NETIF_F_HW_VLAN_RX; +- return err; +-} +- +-static int get_rss_table(struct net_device *dev, struct ethtool_rxfh_indir *p) +-{ +- const struct port_info *pi = netdev_priv(dev); +- unsigned int n = min_t(unsigned int, p->size, pi->rss_size); +- +- p->size = pi->rss_size; +- while (n--) +- p->ring_index[n] = pi->rss[n]; +- return 0; +-} ++#define TSO_FLAGS (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN) + +-static int set_rss_table(struct net_device *dev, +- const struct ethtool_rxfh_indir *p) ++static int set_tso(struct net_device *dev, u32 value) + { +- unsigned int i; +- struct port_info *pi = netdev_priv(dev); +- +- if (p->size != pi->rss_size) +- return -EINVAL; +- for (i = 0; i < p->size; i++) +- if (p->ring_index[i] >= pi->nqsets) +- return -EINVAL; +- for (i = 0; i < p->size; i++) +- pi->rss[i] = p->ring_index[i]; +- if (pi->adapter->flags & FULL_INIT_DONE) +- return write_rss(pi, pi->rss); ++ if (value) ++ dev->features |= TSO_FLAGS; ++ else ++ dev->features &= ~TSO_FLAGS; + return 0; + } + +-static int get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info, +- void *rules) +-{ +- const struct port_info *pi = netdev_priv(dev); +- +- switch (info->cmd) { +- case ETHTOOL_GRXFH: { +- unsigned int v = pi->rss_mode; +- +- info->data = 0; +- switch (info->flow_type) { +- case TCP_V4_FLOW: +- if (v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN) +- info->data = RXH_IP_SRC | RXH_IP_DST | +- RXH_L4_B_0_1 | RXH_L4_B_2_3; +- else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN) +- info->data = RXH_IP_SRC | RXH_IP_DST; +- break; +- case UDP_V4_FLOW: +- if ((v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN) && +- (v & FW_RSS_VI_CONFIG_CMD_UDPEN)) +- info->data = RXH_IP_SRC | RXH_IP_DST | +- RXH_L4_B_0_1 | RXH_L4_B_2_3; +- else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN) +- info->data = RXH_IP_SRC | RXH_IP_DST; +- break; +- case SCTP_V4_FLOW: +- case AH_ESP_V4_FLOW: +- case IPV4_FLOW: +- if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN) +- info->data = RXH_IP_SRC | RXH_IP_DST; +- break; +- case TCP_V6_FLOW: +- if (v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN) +- info->data = RXH_IP_SRC | RXH_IP_DST | +- RXH_L4_B_0_1 | RXH_L4_B_2_3; +- else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN) +- info->data = RXH_IP_SRC | RXH_IP_DST; +- break; +- case UDP_V6_FLOW: +- if ((v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN) && +- (v & FW_RSS_VI_CONFIG_CMD_UDPEN)) +- info->data = RXH_IP_SRC | RXH_IP_DST | +- RXH_L4_B_0_1 | RXH_L4_B_2_3; +- else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN) +- info->data = RXH_IP_SRC | RXH_IP_DST; +- break; +- case SCTP_V6_FLOW: +- case AH_ESP_V6_FLOW: +- case IPV6_FLOW: +- if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN) +- info->data = RXH_IP_SRC | RXH_IP_DST; +- break; +- } +- return 0; +- } +- case ETHTOOL_GRXRINGS: +- info->data = pi->nqsets; +- return 0; +- } +- return -EOPNOTSUPP; +-} +- + static struct ethtool_ops cxgb_ethtool_ops = { + .get_settings = get_settings, + .set_settings = set_settings, +@@ -2003,20 +1912,23 @@ static struct ethtool_ops cxgb_ethtool_o + .set_eeprom = set_eeprom, + .get_pauseparam = get_pauseparam, + .set_pauseparam = set_pauseparam, ++ .get_rx_csum = get_rx_csum, ++ .set_rx_csum = set_rx_csum, ++ .get_tx_csum = ethtool_op_get_tx_csum, ++ .set_sg = ethtool_op_set_sg, ++ .get_sg = ethtool_op_get_sg, + .get_link = ethtool_op_get_link, + .get_strings = get_strings, +- .set_phys_id = identify_port, ++ .phys_id = identify_port, + .nway_reset = restart_autoneg, +- .get_sset_count = get_sset_count, ++ .get_stats_count = get_stats_count, + .get_ethtool_stats = get_stats, + .get_regs_len = get_regs_len, + .get_regs = get_regs, + .get_wol = get_wol, + .set_wol = set_wol, +- .get_rxnfc = get_rxnfc, +- .get_rxfh_indir = get_rss_table, +- .set_rxfh_indir = set_rss_table, +- .flash_device = set_flash, ++ .set_tso = set_tso, ++ .get_tso = ethtool_op_get_tso, + }; + + /* +@@ -2033,7 +1945,7 @@ static ssize_t mem_read(struct file *fil + loff_t *ppos) + { + loff_t pos = *ppos; +- loff_t avail = file->f_path.dentry->d_inode->i_size; ++ loff_t avail = file->f_dentry->d_inode->i_size; + unsigned int mem = (uintptr_t)file->private_data & 3; + struct adapter *adap = file->private_data - mem; + +@@ -2074,9 +1986,21 @@ static const struct file_operations mem_ + .owner = THIS_MODULE, + .open = mem_open, + .read = mem_read, +- .llseek = default_llseek, + }; + ++static void __devinit debugfs_record(struct adapter *ap, struct dentry *dp) ++{ ++ if (!dp) ++ return; ++ ++ if (ap->debugfs_ent_cnt < ARRAY_SIZE(ap->debugfs_ent)) { ++ ap->debugfs_ent[ap->debugfs_ent_cnt++] = dp; ++ } else { ++ pr_warning("Insufficient space to record debugfs entry: removing for safety.\n"); ++ debugfs_remove(dp); ++ } ++} ++ + static void __devinit add_debugfs_mem(struct adapter *adap, const char *name, + unsigned int idx, unsigned int size_mb) + { +@@ -2086,6 +2010,7 @@ static void __devinit add_debugfs_mem(st + (void *)adap + idx, &mem_debugfs_fops); + if (de && de->d_inode) + de->d_inode->i_size = size_mb << 20; ++ debugfs_record(adap, de); + } + + static int __devinit setup_debugfs(struct adapter *adap) +@@ -2104,8 +2029,12 @@ static int __devinit setup_debugfs(struc + add_debugfs_mem(adap, "mc", MEM_MC, + EXT_MEM_SIZE_GET(t4_read_reg(adap, MA_EXT_MEMORY_BAR))); + if (adap->l2t) ++ { ++ struct dentry *de = + debugfs_create_file("l2t", S_IRUSR, adap->debugfs_root, adap, + &t4_l2t_fops); ++ debugfs_record(adap, de); ++ } + return 0; + } + +@@ -2509,14 +2438,17 @@ static struct pci_driver cxgb4_driver; + + static void check_neigh_update(struct neighbour *neigh) + { +- const struct device *parent; ++ const struct class_device *parent; + const struct net_device *netdev = neigh->dev; ++ const struct device *dev; + + if (netdev->priv_flags & IFF_802_1Q_VLAN) + netdev = vlan_dev_real_dev(netdev); +- parent = netdev->dev.parent; +- if (parent && parent->driver == &cxgb4_driver.driver) +- t4_l2t_update(dev_get_drvdata(parent), neigh); ++ parent = netdev->class_dev.parent; ++ dev = parent ? parent->dev : 0; ++ ++ if (dev && dev->driver == &cxgb4_driver.driver) ++ t4_l2t_update(dev_get_drvdata((void *)dev), neigh); + } + + static int netevent_cb(struct notifier_block *nb, unsigned long event, +@@ -2526,6 +2458,7 @@ static int netevent_cb(struct notifier_b + case NETEVENT_NEIGH_UPDATE: + check_neigh_update(data); + break; ++ case NETEVENT_PMTU_UPDATE: + case NETEVENT_REDIRECT: + default: + break; +@@ -2905,7 +2838,6 @@ static int cxgb_open(struct net_device * + struct port_info *pi = netdev_priv(dev); + struct adapter *adapter = pi->adapter; + +- netif_carrier_off(dev); + + if (!(adapter->flags & FULL_INIT_DONE)) { + err = cxgb_up(adapter); +@@ -2929,12 +2861,12 @@ static int cxgb_close(struct net_device + return t4_enable_vi(adapter, adapter->fn, pi->viid, false, false); + } + +-static struct rtnl_link_stats64 *cxgb_get_stats(struct net_device *dev, +- struct rtnl_link_stats64 *ns) ++static struct net_device_stats *cxgb_get_stats(struct net_device *dev) + { + struct port_stats stats; + struct port_info *p = netdev_priv(dev); + struct adapter *adapter = p->adapter; ++ struct net_device_stats *ns = &p->netstats; + + spin_lock(&adapter->stats_lock); + t4_get_port_stats(adapter, p->tx_chan, &stats); +@@ -3049,6 +2981,15 @@ static int cxgb_set_mac_addr(struct net_ + return 0; + } + ++static void vlan_rx_register(struct net_device *dev, struct vlan_group *grp) ++{ ++ struct port_info *pi = netdev_priv(dev); ++ ++ pi->vlan_grp = grp; ++ t4_set_rxmode(pi->adapter, pi->adapter->fn, pi->viid, -1, -1, -1, -1, ++ grp != NULL, true); ++} ++ + #ifdef CONFIG_NET_POLL_CONTROLLER + static void cxgb_netpoll(struct net_device *dev) + { +@@ -3066,6 +3007,7 @@ static void cxgb_netpoll(struct net_devi + } + #endif + ++#if 0 + static const struct net_device_ops cxgb4_netdev_ops = { + .ndo_open = cxgb_open, + .ndo_stop = cxgb_close, +@@ -3073,7 +3015,6 @@ static const struct net_device_ops cxgb4 + .ndo_get_stats64 = cxgb_get_stats, + .ndo_set_rx_mode = cxgb_set_rxmode, + .ndo_set_mac_address = cxgb_set_mac_addr, +- .ndo_set_features = cxgb_set_features, + .ndo_validate_addr = eth_validate_addr, + .ndo_do_ioctl = cxgb_ioctl, + .ndo_change_mtu = cxgb_change_mtu, +@@ -3081,6 +3022,7 @@ static const struct net_device_ops cxgb4 + .ndo_poll_controller = cxgb_netpoll, + #endif + }; ++#endif + + void t4_fatal_err(struct adapter *adap) + { +@@ -3692,7 +3634,7 @@ static void __devinit print_port_info(co + char buf[80]; + char *bufp = buf; + const char *spd = ""; +- const struct port_info *pi = netdev_priv(dev); ++ const struct port_info *pi = netdev_priv((void *)dev); + const struct adapter *adap = pi->adapter; + + if (adap->params.pci.speed == PCI_EXP_LNKSTA_CLS_2_5GB) +@@ -3756,7 +3698,6 @@ static void free_some_resources(struct a + t4_fw_bye(adapter, adapter->fn); + } + +-#define TSO_FLAGS (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN) + #define VLAN_FEAT (NETIF_F_SG | NETIF_F_IP_CSUM | TSO_FLAGS | \ + NETIF_F_IPV6_CSUM | NETIF_F_HIGHDMA) + +@@ -3828,6 +3769,7 @@ static int __devinit init_one(struct pci + adapter->pdev = pdev; + adapter->pdev_dev = &pdev->dev; + adapter->fn = func; ++ adapter->name = pci_name(pdev); + adapter->msg_enable = dflt_msg_enable; + memset(adapter->chan_map, 0xff, sizeof(adapter->chan_map)); + +@@ -3861,17 +3803,31 @@ static int __devinit init_one(struct pci + pi = netdev_priv(netdev); + pi->adapter = adapter; + pi->xact_addr_filt = -1; ++ pi->rx_offload = RX_CSO; + pi->port_id = i; ++ netif_carrier_off(netdev); ++ netif_tx_stop_all_queues(netdev); + netdev->irq = pdev->irq; + +- netdev->hw_features = NETIF_F_SG | TSO_FLAGS | +- NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | +- NETIF_F_RXCSUM | NETIF_F_RXHASH | +- NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; +- netdev->features |= netdev->hw_features | highdma; +- netdev->vlan_features = netdev->features & VLAN_FEAT; +- +- netdev->netdev_ops = &cxgb4_netdev_ops; ++ netdev->features |= NETIF_F_SG | TSO_FLAGS; ++ netdev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; ++ netdev->features |= NETIF_F_GRO; ++ netdev->features |= highdma; ++ netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; ++ ++ netdev->open = cxgb_open; ++ netdev->stop = cxgb_close; ++ netdev->hard_start_xmit = t4_eth_xmit; ++ netdev->get_stats = cxgb_get_stats; ++ netdev->set_multicast_list = cxgb_set_rxmode; ++ netdev->set_mac_address = cxgb_set_mac_addr; ++ netdev->do_ioctl = cxgb_ioctl; ++ netdev->change_mtu = cxgb_change_mtu; ++ netdev->vlan_rx_register = vlan_rx_register; ++#ifdef CONFIG_NET_POLL_CONTROLLER ++ netdev->poll_controller = cxgb_netpoll; ++#endif ++ netdev->weight = 64; + SET_ETHTOOL_OPS(netdev, &cxgb_ethtool_ops); + } + +@@ -3920,8 +3876,6 @@ static int __devinit init_one(struct pci + */ + for_each_port(adapter, i) { + pi = adap2pinfo(adapter, i); +- netif_set_real_num_tx_queues(adapter->port[i], pi->nqsets); +- netif_set_real_num_rx_queues(adapter->port[i], pi->nqsets); + + err = register_netdev(adapter->port[i]); + if (err) +diff --git a/drivers/net/cxgb4/l2t.c b/drivers/net/cxgb4/l2t.c +--- a/drivers/net/cxgb4/l2t.c 2011-08-09 17:24:36.000000000 +0530 ++++ b/drivers/net/cxgb4/l2t.c 2011-08-08 13:16:50.000000000 +0530 +@@ -568,7 +568,7 @@ static int l2t_seq_show(struct seq_file + return 0; + } + +-static const struct seq_operations l2t_seq_ops = { ++static struct seq_operations l2t_seq_ops = { + .start = l2t_seq_start, + .next = l2t_seq_next, + .stop = l2t_seq_stop, +diff --git a/drivers/net/cxgb4/sge.c b/drivers/net/cxgb4/sge.c +--- a/drivers/net/cxgb4/sge.c 2011-08-09 17:24:36.000000000 +0530 ++++ b/drivers/net/cxgb4/sge.c 2011-08-08 12:40:58.000000000 +0530 +@@ -39,7 +39,6 @@ + #include + #include + #include +-#include + #include + #include + #include "cxgb4.h" +@@ -208,7 +207,7 @@ static int map_skb(struct device *dev, c + const struct skb_shared_info *si; + + *addr = dma_map_single(dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE); +- if (dma_mapping_error(dev, *addr)) ++ if (dma_mapping_error(*addr)) + goto out_err; + + si = skb_shinfo(skb); +@@ -217,7 +216,7 @@ static int map_skb(struct device *dev, c + for (fp = si->frags; fp < end; fp++) { + *++addr = dma_map_page(dev, fp->page, fp->page_offset, fp->size, + DMA_TO_DEVICE); +- if (dma_mapping_error(dev, *addr)) ++ if (dma_mapping_error(*addr)) + goto unwind; + } + return 0; +@@ -231,7 +230,25 @@ out_err: + return -ENOMEM; + } + +-#ifdef CONFIG_NEED_DMA_MAP_STATE ++/** ++ * need_skb_unmap - does the platform need unmapping of sk_buffs? ++ * ++ * Returns true if the platfrom needs sk_buff unmapping. The compiler ++ * optimizes away unecessary code if this returns true. ++ */ ++static inline int need_skb_unmap(void) ++{ ++ /* ++ * This structure is used to tell if the platfrom needs buffer ++ * unmapping by checking if DECLARE_PCI_UNMAP_ADDR defines anything. ++ */ ++ struct dummy { ++ DECLARE_PCI_UNMAP_ADDR(addr); ++ }; ++ ++ return sizeof(struct dummy) != 0; ++} ++ + static void unmap_skb(struct device *dev, const struct sk_buff *skb, + const dma_addr_t *addr) + { +@@ -256,9 +273,8 @@ static void unmap_skb(struct device *dev + */ + static void deferred_unmap_destructor(struct sk_buff *skb) + { +- unmap_skb(skb->dev->dev.parent, skb, (dma_addr_t *)skb->head); ++ unmap_skb(netdev2adap(skb->dev)->pdev_dev, skb, (dma_addr_t *)skb->head); + } +-#endif + + static void unmap_sgl(struct device *dev, const struct sk_buff *skb, + const struct ulptx_sgl *sgl, const struct sge_txq *q) +@@ -336,10 +352,12 @@ static void free_tx_desc(struct adapter + unsigned int cidx = q->cidx; + struct device *dev = adap->pdev_dev; + ++ const int need_unmap = need_skb_unmap() && unmap; ++ + d = &q->sdesc[cidx]; + while (n--) { + if (d->skb) { /* an SGL is present */ +- if (unmap) ++ if (need_unmap) + unmap_sgl(dev, d->skb, d->sgl, q); + kfree_skb(d->skb); + d->skb = NULL; +@@ -506,7 +524,7 @@ static unsigned int refill_fl(struct ada + mapping = dma_map_page(adap->pdev_dev, pg, 0, + PAGE_SIZE << FL_PG_ORDER, + PCI_DMA_FROMDEVICE); +- if (unlikely(dma_mapping_error(adap->pdev_dev, mapping))) { ++ if (unlikely(dma_mapping_error(mapping))) { + __free_pages(pg, FL_PG_ORDER); + goto out; /* do not try small pages for this error */ + } +@@ -535,7 +553,7 @@ static unsigned int refill_fl(struct ada + + mapping = dma_map_page(adap->pdev_dev, pg, 0, PAGE_SIZE, + PCI_DMA_FROMDEVICE); +- if (unlikely(dma_mapping_error(adap->pdev_dev, mapping))) { ++ if (unlikely(dma_mapping_error(mapping))) { + netdev_free_page(adap->port[0], pg); + goto out; + } +@@ -592,7 +610,7 @@ static inline void __refill_fl(struct ad + */ + static void *alloc_ring(struct device *dev, size_t nelem, size_t elem_size, + size_t sw_size, dma_addr_t *phys, void *metadata, +- size_t stat_size, int node) ++ size_t stat_size) + { + size_t len = nelem * elem_size + stat_size; + void *s = NULL; +@@ -601,7 +619,7 @@ static void *alloc_ring(struct device *d + if (!p) + return NULL; + if (sw_size) { +- s = kzalloc_node(nelem * sw_size, GFP_KERNEL, node); ++ s = kcalloc(nelem, sw_size, GFP_KERNEL); + + if (!s) { + dma_free_coherent(dev, len, p, *phys); +@@ -849,12 +867,9 @@ nocsum: /* + return TXPKT_CSUM_TYPE(csum_type) | + TXPKT_IPHDR_LEN(skb_network_header_len(skb)) | + TXPKT_ETHHDR_LEN(skb_network_offset(skb) - ETH_HLEN); +- else { +- int start = skb_transport_offset(skb); ++ ++ goto nocsum; + +- return TXPKT_CSUM_TYPE(csum_type) | TXPKT_CSUM_START(start) | +- TXPKT_CSUM_LOC(start + skb->csum_offset); +- } + } + + static void eth_txq_stop(struct sge_eth_txq *q) +@@ -878,7 +893,7 @@ static inline void txq_advance(struct sg + * + * Add a packet to an SGE Ethernet Tx queue. Runs with softirqs disabled. + */ +-netdev_tx_t t4_eth_xmit(struct sk_buff *skb, struct net_device *dev) ++int t4_eth_xmit(struct sk_buff *skb, struct net_device *dev) + { + u32 wr_mid; + u64 cntrl, *end; +@@ -1288,10 +1303,10 @@ static void service_ofldq(struct sge_ofl + write_sgl(skb, &q->q, (void *)pos + hdr_len, + pos + flits, hdr_len, + (dma_addr_t *)skb->head); +-#ifdef CONFIG_NEED_DMA_MAP_STATE +- skb->dev = q->adap->port[0]; +- skb->destructor = deferred_unmap_destructor; +-#endif ++ if (need_skb_unmap()) { ++ skb->dev = q->adap->port[0]; ++ skb->destructor = deferred_unmap_destructor; ++ } + last_desc = q->q.pidx + ndesc - 1; + if (last_desc >= q->q.size) + last_desc -= q->q.size; +@@ -1357,7 +1372,7 @@ static void restart_ofldq(unsigned long + */ + static inline unsigned int skb_txq(const struct sk_buff *skb) + { +- return skb->queue_mapping >> 1; ++ return skb->priority >> 1; + } + + /** +@@ -1369,7 +1384,7 @@ static inline unsigned int skb_txq(const + */ + static inline unsigned int is_ctrl_pkt(const struct sk_buff *skb) + { +- return skb->queue_mapping & 1; ++ return skb->priority & 1; + } + + static inline int ofld_send(struct adapter *adap, struct sk_buff *skb) +@@ -1510,7 +1525,7 @@ static noinline int handle_trace_pkt(str + skb_reset_mac_header(skb); + skb->protocol = htons(0xffff); + skb->dev = adap->port[0]; +- netif_receive_skb(skb); ++ netif_rx(skb); + return 0; + } + +@@ -1533,15 +1548,20 @@ static void do_gro(struct sge_eth_rxq *r + skb->truesize += skb->data_len; + skb->ip_summed = CHECKSUM_UNNECESSARY; + skb_record_rx_queue(skb, rxq->rspq.idx); +- if (rxq->rspq.netdev->features & NETIF_F_RXHASH) +- skb->rxhash = (__force u32)pkt->rsshdr.hash_val; + +- if (unlikely(pkt->vlan_ex)) { +- __vlan_hwaccel_put_tag(skb, ntohs(pkt->vlan)); +- rxq->stats.vlan_ex++; +- } ++ if (unlikely(pkt->vlan_ex)) { ++ struct port_info *pi = netdev_priv(rxq->rspq.napi.dev); ++ struct vlan_group *grp = pi->vlan_grp; ++ ++ rxq->stats.vlan_ex++; ++ if (likely(grp)) { ++ ret = vlan_gro_frags(&rxq->rspq.napi, grp, ++ ntohs(pkt->vlan)); ++ goto stats; ++ } ++ } + ret = napi_gro_frags(&rxq->rspq.napi); +- if (ret == GRO_HELD) ++stats: if (ret == GRO_HELD) + rxq->stats.lro_pkts++; + else if (ret == GRO_MERGED || ret == GRO_MERGED_FREE) + rxq->stats.lro_merged++; +@@ -1562,6 +1582,7 @@ int t4_ethrx_handler(struct sge_rspq *q, + { + bool csum_ok; + struct sk_buff *skb; ++ struct port_info *pi; + const struct cpl_rx_pkt *pkt; + struct sge_eth_rxq *rxq = container_of(q, struct sge_eth_rxq, rspq); + +@@ -1571,7 +1592,7 @@ int t4_ethrx_handler(struct sge_rspq *q, + pkt = (const struct cpl_rx_pkt *)rsp; + csum_ok = pkt->csum_calc && !pkt->err_vec; + if ((pkt->l2info & htonl(RXF_TCP)) && +- (q->netdev->features & NETIF_F_GRO) && csum_ok && !pkt->ip_frag) { ++ (q->napi.dev->features & NETIF_F_GRO) && csum_ok && !pkt->ip_frag) { + do_gro(rxq, si, pkt); + return 0; + } +@@ -1584,14 +1605,13 @@ int t4_ethrx_handler(struct sge_rspq *q, + } + + __skb_pull(skb, RX_PKT_PAD); /* remove ethernet header padding */ +- skb->protocol = eth_type_trans(skb, q->netdev); ++ skb->protocol = eth_type_trans(skb, q->napi.dev); + skb_record_rx_queue(skb, q->idx); +- if (skb->dev->features & NETIF_F_RXHASH) +- skb->rxhash = (__force u32)pkt->rsshdr.hash_val; + ++ pi = netdev_priv(skb->dev); + rxq->stats.pkts++; + +- if (csum_ok && (q->netdev->features & NETIF_F_RXCSUM) && ++ if (csum_ok && (pi->rx_offload & RX_CSO) && + (pkt->l2info & htonl(RXF_UDP | RXF_TCP))) { + if (!pkt->ip_frag) { + skb->ip_summed = CHECKSUM_UNNECESSARY; +@@ -1605,12 +1625,18 @@ int t4_ethrx_handler(struct sge_rspq *q, + } else + skb_checksum_none_assert(skb); + +- if (unlikely(pkt->vlan_ex)) { +- __vlan_hwaccel_put_tag(skb, ntohs(pkt->vlan)); +- rxq->stats.vlan_ex++; +- } +- netif_receive_skb(skb); +- return 0; ++ if (unlikely(pkt->vlan_ex)) { ++ struct vlan_group *grp = pi->vlan_grp; ++ ++ rxq->stats.vlan_ex++; ++ if (likely(grp)) ++ vlan_hwaccel_receive_skb(skb, grp, ntohs(pkt->vlan)); ++ else ++ dev_kfree_skb_any(skb); ++ } else ++ netif_rx(skb); ++ ++ return 0; + } + + /** +@@ -1763,6 +1789,7 @@ static int process_responses(struct sge_ + rspq_next(q); + budget_left--; + } ++ napi_gro_flush(&q->napi); + + if (q->offset >= 0 && rxq->fl.size - rxq->fl.avail >= 16) + __refill_fl(q->adap, &rxq->fl); +@@ -1771,7 +1798,7 @@ static int process_responses(struct sge_ + + /** + * napi_rx_handler - the NAPI handler for Rx processing +- * @napi: the napi instance ++ * @dev: the net device + * @budget: how many packets we can process in this round + * + * Handler for new data events when using NAPI. This does not need any +@@ -1780,22 +1807,40 @@ static int process_responses(struct sge_ + * in not a concern at all with MSI-X as non-data interrupts then have + * a separate handler). + */ +-static int napi_rx_handler(struct napi_struct *napi, int budget) ++static int napi_rx_handler(struct net_device *dev, int *budget) + { +- unsigned int params; +- struct sge_rspq *q = container_of(napi, struct sge_rspq, napi); +- int work_done = process_responses(q, budget); +- +- if (likely(work_done < budget)) { +- napi_complete(napi); +- params = q->next_intr_params; +- q->next_intr_params = q->intr_params; +- } else +- params = QINTR_TIMER_IDX(7); ++ unsigned int params; ++ /* This points back the response queue */ ++ struct sge_rspq *q = dev->atalk_ptr; ++ int effective_budget = min(*budget, dev->quota); ++ int work_done = process_responses(q, effective_budget); + +- t4_write_reg(q->adap, MYPF_REG(SGE_PF_GTS), CIDXINC(work_done) | +- INGRESSQID((u32)q->cntxt_id) | SEINTARM(params)); +- return work_done; ++ *budget -= work_done; ++ dev->quota -= work_done; ++ ++ if (likely(work_done < effective_budget)) { ++ /* To remove the interface from the poll list. This must ++ * work on the net_device which is the one being scheduled ++ * on the event queue ++ */ ++ napi_complete(q->netdev); ++ params = q->next_intr_params; ++ q->next_intr_params = q->intr_params; ++ } else ++ params = QINTR_TIMER_IDX(7); ++ ++ t4_write_reg(q->adap, MYPF_REG(SGE_PF_GTS), CIDXINC(work_done) | ++ INGRESSQID((u32)q->cntxt_id) | SEINTARM(params)); ++ return work_done >= effective_budget; ++} ++ ++/* ++ * Returns true if a NAPI instance is already scheduled for polling. ++ * ++ */ ++static inline int napi_is_scheduled(const struct net_device *dev) ++{ ++ return test_bit(__LINK_STATE_RX_SCHED, &dev->state); + } + + /* +@@ -1805,7 +1850,7 @@ irqreturn_t t4_sge_intr_msix(int irq, vo + { + struct sge_rspq *q = cookie; + +- napi_schedule(&q->napi); ++ napi_schedule(q->netdev); + return IRQ_HANDLED; + } + +@@ -1830,7 +1875,11 @@ static unsigned int process_intrq(struct + unsigned int qid = ntohl(rc->pldbuflen_qid); + + qid -= adap->sge.ingr_start; +- napi_schedule(&adap->sge.ingr_map[qid]->napi); ++ /* This is should be the pointer to the queue dummy ++ * net_device which will be used to add the interface ++ * to the tail of the rx poll list. ++ */ ++ napi_schedule(adap->sge.ingr_map[qid]->netdev); + } + + rspq_next(q); +@@ -1899,17 +1948,22 @@ static void sge_rx_timer_cb(unsigned lon + unsigned int id = __ffs(m) + i * BITS_PER_LONG; + struct sge_fl *fl = s->egr_map[id]; + +- clear_bit(id, s->starving_fl); +- smp_mb__after_clear_bit(); +- +- if (fl_starving(fl)) { +- rxq = container_of(fl, struct sge_eth_rxq, fl); +- if (napi_reschedule(&rxq->rspq.napi)) +- fl->starving++; +- else +- set_bit(id, s->starving_fl); +- } +- } ++ rxq = container_of(fl, struct sge_eth_rxq, fl); ++ if (spin_trylock_irq(&rxq->rspq.lock)) { ++ /* Operates on the dummy net_device found in ++ * sge_rspq. ++ */ ++ if (!napi_is_scheduled(rxq->rspq.netdev)) { ++ if (fl_starving(fl)) { ++ fl->starving++; ++ __refill_fl(adap, fl); ++ } ++ if (!fl_starving(fl)) ++ clear_bit(id, s->starving_fl); ++ } ++ spin_unlock(&rxq->rspq.lock); ++ } ++ } + + t4_write_reg(adap, SGE_DEBUG_INDEX, 13); + cnt[0] = t4_read_reg(adap, SGE_DEBUG_DATA_HIGH); +@@ -1975,6 +2029,37 @@ static void sge_tx_timer_cb(unsigned lon + mod_timer(&s->tx_timer, jiffies + (budget ? TX_QCHECK_PERIOD : 2)); + } + ++/* ++ * If we have multiple receive queues per port serviced by NAPI we need one ++ * netdevice per queue as NAPI operates on netdevices. We already have one ++ * netdevice, namely the one associated with the interface, so we use dummy ++ * ones for any additional queues. Note that these netdevices exist purely ++ * so that NAPI has something to work with, they do not represent network ++ * ports and are not registered. ++ */ ++static struct net_device *dummy_netdev(struct adapter *adap, struct net_device *dev) ++{ ++ struct net_device *nd; ++ ++ BUG_ON(adap->dummy_netdev_cnt >= ARRAY_SIZE(adap->dummy_netdev)); ++ ++ nd = alloc_netdev(sizeof(struct port_info), "", ether_setup); ++ ++ if (nd) { ++ struct port_info *p = netdev_priv(nd); ++ ++ p->adapter = adap; ++ nd->weight = 64; ++ set_bit(__LINK_STATE_START, &nd->state); ++ ++ adap->dummy_netdev[adap->dummy_netdev_cnt++] = nd; ++ ++ strcpy(nd->name, dev->name); ++ } ++ ++ return nd; ++} ++ + int t4_sge_alloc_rxq(struct adapter *adap, struct sge_rspq *iq, bool fwevtq, + struct net_device *dev, int intr_idx, + struct sge_fl *fl, rspq_handler_t hnd) +@@ -1982,12 +2067,13 @@ int t4_sge_alloc_rxq(struct adapter *ada + int ret, flsz = 0; + struct fw_iq_cmd c; + struct port_info *pi = netdev_priv(dev); ++ struct net_device *dummy; + + /* Size needs to be multiple of 16, including status entry. */ + iq->size = roundup(iq->size, 16); + + iq->desc = alloc_ring(adap->pdev_dev, iq->size, iq->iqe_len, 0, +- &iq->phys_addr, NULL, 0, NUMA_NO_NODE); ++ &iq->phys_addr, NULL, 0); + if (!iq->desc) + return -ENOMEM; + +@@ -2013,7 +2099,7 @@ int t4_sge_alloc_rxq(struct adapter *ada + fl->size = roundup(fl->size, 8); + fl->desc = alloc_ring(adap->pdev_dev, fl->size, sizeof(__be64), + sizeof(struct rx_sw_desc), &fl->addr, +- &fl->sdesc, STAT_LEN, NUMA_NO_NODE); ++ &fl->sdesc, STAT_LEN); + if (!fl->desc) + goto fl_nomem; + +@@ -2032,7 +2118,13 @@ int t4_sge_alloc_rxq(struct adapter *ada + if (ret) + goto err; + +- netif_napi_add(dev, &iq->napi, napi_rx_handler, 64); ++ dummy = dummy_netdev(adap, dev); ++ ++ netif_napi_add(dummy, &iq->napi, napi_rx_handler, 64); ++ /* Points back to the queue that is associated with the net_device */ ++ dummy->atalk_ptr = iq; ++ iq->napi.dev = dev; ++ + iq->cur_desc = iq->desc; + iq->cidx = 0; + iq->gen = 1; +@@ -2041,8 +2133,10 @@ int t4_sge_alloc_rxq(struct adapter *ada + iq->abs_id = ntohs(c.physiqid); + iq->size--; /* subtract status entry */ + iq->adap = adap; +- iq->netdev = dev; +- iq->handler = hnd; ++ /* Set the queue's net_device to the dummy net_device */ ++ iq->netdev = dummy; ++ iq->handler = hnd; ++ + + /* set offset to -1 to distinguish ingress queues without FL */ + iq->offset = fl ? 0 : -1; +@@ -2101,8 +2195,7 @@ int t4_sge_alloc_eth_txq(struct adapter + + txq->q.desc = alloc_ring(adap->pdev_dev, txq->q.size, + sizeof(struct tx_desc), sizeof(struct tx_sw_desc), +- &txq->q.phys_addr, &txq->q.sdesc, STAT_LEN, +- netdev_queue_numa_node_read(netdevq)); ++ &txq->q.phys_addr, &txq->q.sdesc, STAT_LEN); + if (!txq->q.desc) + return -ENOMEM; + +@@ -2154,7 +2247,7 @@ int t4_sge_alloc_ctrl_txq(struct adapter + + txq->q.desc = alloc_ring(adap->pdev_dev, nentries, + sizeof(struct tx_desc), 0, &txq->q.phys_addr, +- NULL, 0, NUMA_NO_NODE); ++ NULL, 0); + if (!txq->q.desc) + return -ENOMEM; + +@@ -2205,8 +2297,7 @@ int t4_sge_alloc_ofld_txq(struct adapter + + txq->q.desc = alloc_ring(adap->pdev_dev, txq->q.size, + sizeof(struct tx_desc), sizeof(struct tx_sw_desc), +- &txq->q.phys_addr, &txq->q.sdesc, STAT_LEN, +- NUMA_NO_NODE); ++ &txq->q.phys_addr, &txq->q.sdesc, STAT_LEN); + if (!txq->q.desc) + return -ENOMEM; + +@@ -2268,6 +2360,7 @@ static void free_rspq_fl(struct adapter + dma_free_coherent(adap->pdev_dev, (rq->size + 1) * rq->iqe_len, + rq->desc, rq->phys_addr); + netif_napi_del(&rq->napi); ++ rq->netdev->atalk_ptr = NULL; + rq->netdev = NULL; + rq->cntxt_id = rq->abs_id = 0; + rq->desc = NULL; +@@ -2397,6 +2490,13 @@ void t4_sge_stop(struct adapter *adap) + if (cq->q.desc) + tasklet_kill(&cq->qresume_tsk); + } ++ ++ for (i = 0; i < ARRAY_SIZE(adap->dummy_netdev); ++i) ++ if (adap->dummy_netdev[i]) { ++ free_netdev(adap->dummy_netdev[i]); ++ adap->dummy_netdev[i] = 0; ++ } ++ adap->dummy_netdev_cnt = 0; + } + + /** +diff --git a/drivers/net/cxgb4/t4_msg.h b/drivers/net/cxgb4/t4_msg.h +--- a/drivers/net/cxgb4/t4_msg.h 2011-08-09 17:24:36.000000000 +0530 ++++ b/drivers/net/cxgb4/t4_msg.h 2011-08-08 13:22:36.000000000 +0530 +@@ -123,7 +123,6 @@ enum { + ULP_MODE_NONE = 0, + ULP_MODE_ISCSI = 2, + ULP_MODE_RDMA = 4, +- ULP_MODE_TCPDDP = 5, + ULP_MODE_FCOE = 6, + }; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/dma_mapping_to_2_6_26.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/dma_mapping_to_2_6_26.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/dma_mapping_to_2_6_26.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/dma_mapping_to_2_6_26.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,17 @@ +--- + include/rdma/ib_verbs.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Index: ofed_kernel/include/rdma/ib_verbs.h +=================================================================== +--- ofed_kernel.orig/include/rdma/ib_verbs.h ++++ ofed_kernel/include/rdma/ib_verbs.h +@@ -1682,7 +1682,7 @@ static inline int ib_dma_mapping_error(s + { + if (dev->dma_ops) + return dev->dma_ops->mapping_error(dev, dma_addr); +- return dma_mapping_error(dev->dma_device, dma_addr); ++ return dma_mapping_error(dma_addr); + } + + /** diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-010-revert_dmem.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-010-revert_dmem.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-010-revert_dmem.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-010-revert_dmem.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,721 @@ +diff -Nurp ofa_kernel-1.5.patched/drivers/infiniband/hw/ehca/ehca_main.c ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_main.c +--- ofa_kernel-1.5.patched/drivers/infiniband/hw/ehca/ehca_main.c 2009-09-25 12:18:09.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_main.c 2009-09-23 15:08:25.000000000 +0200 +@@ -506,7 +506,6 @@ static int ehca_init_device(struct ehca_ + shca->ib_device.detach_mcast = ehca_detach_mcast; + shca->ib_device.process_mad = ehca_process_mad; + shca->ib_device.mmap = ehca_mmap; +- shca->ib_device.dma_ops = &ehca_dma_mapping_ops; + + if (EHCA_BMASK_GET(HCA_CAP_SRQ, shca->hca_cap)) { + shca->ib_device.uverbs_cmd_mask |= +@@ -1029,23 +1028,17 @@ static int __init ehca_module_init(void) + goto module_init1; + } + +- ret = ehca_create_busmap(); +- if (ret) { +- ehca_gen_err("Cannot create busmap."); +- goto module_init2; +- } +- + ret = ibmebus_register_driver(&ehca_driver); + if (ret) { + ehca_gen_err("Cannot register eHCA device driver"); + ret = -EINVAL; +- goto module_init3; ++ goto module_init2; + } + + ret = register_memory_notifier(&ehca_mem_nb); + if (ret) { + ehca_gen_err("Failed registering memory add/remove notifier"); +- goto module_init4; ++ goto module_init3; + } + + if (ehca_poll_all_eqs != 1) { +@@ -1060,11 +1053,8 @@ static int __init ehca_module_init(void) + + return 0; + +-module_init4: +- ibmebus_unregister_driver(&ehca_driver); +- + module_init3: +- ehca_destroy_busmap(); ++ ibmebus_unregister_driver(&ehca_driver); + + module_init2: + ehca_destroy_slab_caches(); +@@ -1083,8 +1073,6 @@ static void __exit ehca_module_exit(void + + unregister_memory_notifier(&ehca_mem_nb); + +- ehca_destroy_busmap(); +- + ehca_destroy_slab_caches(); + + ehca_destroy_comp_pool(); +diff -Nurp ofa_kernel-1.5.patched/drivers/infiniband/hw/ehca/ehca_mrmw.c ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_mrmw.c +--- ofa_kernel-1.5.patched/drivers/infiniband/hw/ehca/ehca_mrmw.c 2009-09-25 12:18:09.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_mrmw.c 2009-09-23 15:08:25.000000000 +0200 +@@ -53,38 +53,6 @@ + /* max number of rpages (per hcall register_rpages) */ + #define MAX_RPAGES 512 + +-/* DMEM toleration management */ +-#define EHCA_SECTSHIFT SECTION_SIZE_BITS +-#define EHCA_SECTSIZE (1UL << EHCA_SECTSHIFT) +-#define EHCA_HUGEPAGESHIFT 34 +-#define EHCA_HUGEPAGE_SIZE (1UL << EHCA_HUGEPAGESHIFT) +-#define EHCA_HUGEPAGE_PFN_MASK ((EHCA_HUGEPAGE_SIZE - 1) >> PAGE_SHIFT) +-#define EHCA_INVAL_ADDR 0xFFFFFFFFFFFFFFFFULL +-#define EHCA_DIR_INDEX_SHIFT 13 /* 8k Entries in 64k block */ +-#define EHCA_TOP_INDEX_SHIFT (EHCA_DIR_INDEX_SHIFT * 2) +-#define EHCA_MAP_ENTRIES (1 << EHCA_DIR_INDEX_SHIFT) +-#define EHCA_TOP_MAP_SIZE (0x10000) /* currently fixed map size */ +-#define EHCA_DIR_MAP_SIZE (0x10000) +-#define EHCA_ENT_MAP_SIZE (0x10000) +-#define EHCA_INDEX_MASK (EHCA_MAP_ENTRIES - 1) +- +-static unsigned long ehca_mr_len; +- +-/* +- * Memory map data structures +- */ +-struct ehca_dir_bmap { +- u64 ent[EHCA_MAP_ENTRIES]; +-}; +-struct ehca_top_bmap { +- struct ehca_dir_bmap *dir[EHCA_MAP_ENTRIES]; +-}; +-struct ehca_bmap { +- struct ehca_top_bmap *top[EHCA_MAP_ENTRIES]; +-}; +- +-static struct ehca_bmap *ehca_bmap; +- + static struct kmem_cache *mr_cache; + static struct kmem_cache *mw_cache; + +@@ -100,8 +68,6 @@ enum ehca_mr_pgsize { + #define EHCA_MR_PGSHIFT1M 20 + #define EHCA_MR_PGSHIFT16M 24 + +-static u64 ehca_map_vaddr(void *caddr); +- + static u32 ehca_encode_hwpage_size(u32 pgsize) + { + int log = ilog2(pgsize); +@@ -169,8 +135,7 @@ struct ib_mr *ehca_get_dma_mr(struct ib_ + goto get_dma_mr_exit0; + } + +- ret = ehca_reg_maxmr(shca, e_maxmr, +- (void *)ehca_map_vaddr((void *)KERNELBASE), ++ ret = ehca_reg_maxmr(shca, e_maxmr, (u64 *)KERNELBASE, + mr_access_flags, e_pd, + &e_maxmr->ib.ib_mr.lkey, + &e_maxmr->ib.ib_mr.rkey); +@@ -286,7 +251,7 @@ struct ib_mr *ehca_reg_phys_mr(struct ib + + ret = ehca_reg_mr(shca, e_mr, iova_start, size, mr_access_flags, + e_pd, &pginfo, &e_mr->ib.ib_mr.lkey, +- &e_mr->ib.ib_mr.rkey, EHCA_REG_MR); ++ &e_mr->ib.ib_mr.rkey); + if (ret) { + ib_mr = ERR_PTR(ret); + goto reg_phys_mr_exit1; +@@ -405,7 +370,7 @@ reg_user_mr_fallback: + + ret = ehca_reg_mr(shca, e_mr, (u64 *)virt, length, mr_access_flags, + e_pd, &pginfo, &e_mr->ib.ib_mr.lkey, +- &e_mr->ib.ib_mr.rkey, EHCA_REG_MR); ++ &e_mr->ib.ib_mr.rkey); + if (ret == -EINVAL && pginfo.hwpage_size > PAGE_SIZE) { + ehca_warn(pd->device, "failed to register mr " + "with hwpage_size=%llx", hwpage_size); +@@ -829,7 +794,7 @@ struct ib_fmr *ehca_alloc_fmr(struct ib_ + ret = ehca_reg_mr(shca, e_fmr, NULL, + fmr_attr->max_pages * (1 << fmr_attr->page_shift), + mr_access_flags, e_pd, &pginfo, +- &tmp_lkey, &tmp_rkey, EHCA_REG_MR); ++ &tmp_lkey, &tmp_rkey); + if (ret) { + ib_fmr = ERR_PTR(ret); + goto alloc_fmr_exit1; +@@ -1018,10 +983,6 @@ free_fmr_exit0: + + /*----------------------------------------------------------------------*/ + +-static int ehca_reg_bmap_mr_rpages(struct ehca_shca *shca, +- struct ehca_mr *e_mr, +- struct ehca_mr_pginfo *pginfo); +- + int ehca_reg_mr(struct ehca_shca *shca, + struct ehca_mr *e_mr, + u64 *iova_start, +@@ -1030,8 +991,7 @@ int ehca_reg_mr(struct ehca_shca *shca, + struct ehca_pd *e_pd, + struct ehca_mr_pginfo *pginfo, + u32 *lkey, /*OUT*/ +- u32 *rkey, /*OUT*/ +- enum ehca_reg_type reg_type) ++ u32 *rkey) /*OUT*/ + { + int ret; + u64 h_ret; +@@ -1055,13 +1015,7 @@ int ehca_reg_mr(struct ehca_shca *shca, + + e_mr->ipz_mr_handle = hipzout.handle; + +- if (reg_type == EHCA_REG_BUSMAP_MR) +- ret = ehca_reg_bmap_mr_rpages(shca, e_mr, pginfo); +- else if (reg_type == EHCA_REG_MR) +- ret = ehca_reg_mr_rpages(shca, e_mr, pginfo); +- else +- ret = -EINVAL; +- ++ ret = ehca_reg_mr_rpages(shca, e_mr, pginfo); + if (ret) + goto ehca_reg_mr_exit1; + +@@ -1362,7 +1316,7 @@ int ehca_rereg_mr(struct ehca_shca *shca + e_mr->fmr_map_cnt = save_mr.fmr_map_cnt; + + ret = ehca_reg_mr(shca, e_mr, iova_start, size, acl, +- e_pd, pginfo, lkey, rkey, EHCA_REG_MR); ++ e_pd, pginfo, lkey, rkey); + if (ret) { + u32 offset = (u64)(&e_mr->flags) - (u64)e_mr; + memcpy(&e_mr->flags, &(save_mr.flags), +@@ -1455,7 +1409,7 @@ int ehca_unmap_one_fmr(struct ehca_shca + ret = ehca_reg_mr(shca, e_fmr, NULL, + (e_fmr->fmr_max_pages * e_fmr->fmr_page_size), + e_fmr->acl, e_pd, &pginfo, &tmp_lkey, +- &tmp_rkey, EHCA_REG_MR); ++ &tmp_rkey); + if (ret) { + u32 offset = (u64)(&e_fmr->flags) - (u64)e_fmr; + memcpy(&e_fmr->flags, &(save_mr.flags), +@@ -1524,90 +1478,6 @@ ehca_reg_smr_exit0: + } /* end ehca_reg_smr() */ + + /*----------------------------------------------------------------------*/ +-static inline void *ehca_calc_sectbase(int top, int dir, int idx) +-{ +- unsigned long ret = idx; +- ret |= dir << EHCA_DIR_INDEX_SHIFT; +- ret |= top << EHCA_TOP_INDEX_SHIFT; +- return abs_to_virt(ret << SECTION_SIZE_BITS); +-} +- +-#define ehca_bmap_valid(entry) \ +- ((u64)entry != (u64)EHCA_INVAL_ADDR) +- +-static u64 ehca_reg_mr_section(int top, int dir, int idx, u64 *kpage, +- struct ehca_shca *shca, struct ehca_mr *mr, +- struct ehca_mr_pginfo *pginfo) +-{ +- u64 h_ret = 0; +- unsigned long page = 0; +- u64 rpage = virt_to_abs(kpage); +- int page_count; +- +- void *sectbase = ehca_calc_sectbase(top, dir, idx); +- if ((unsigned long)sectbase & (pginfo->hwpage_size - 1)) { +- ehca_err(&shca->ib_device, "reg_mr_section will probably fail:" +- "hwpage_size does not fit to " +- "section start address"); +- } +- page_count = EHCA_SECTSIZE / pginfo->hwpage_size; +- +- while (page < page_count) { +- u64 rnum; +- for (rnum = 0; (rnum < MAX_RPAGES) && (page < page_count); +- rnum++) { +- void *pg = sectbase + ((page++) * pginfo->hwpage_size); +- kpage[rnum] = virt_to_abs(pg); +- } +- +- h_ret = hipz_h_register_rpage_mr(shca->ipz_hca_handle, mr, +- ehca_encode_hwpage_size(pginfo->hwpage_size), +- 0, rpage, rnum); +- +- if ((h_ret != H_SUCCESS) && (h_ret != H_PAGE_REGISTERED)) { +- ehca_err(&shca->ib_device, "register_rpage_mr failed"); +- return h_ret; +- } +- } +- return h_ret; +-} +- +-static u64 ehca_reg_mr_sections(int top, int dir, u64 *kpage, +- struct ehca_shca *shca, struct ehca_mr *mr, +- struct ehca_mr_pginfo *pginfo) +-{ +- u64 hret = H_SUCCESS; +- int idx; +- +- for (idx = 0; idx < EHCA_MAP_ENTRIES; idx++) { +- if (!ehca_bmap_valid(ehca_bmap->top[top]->dir[dir]->ent[idx])) +- continue; +- +- hret = ehca_reg_mr_section(top, dir, idx, kpage, shca, mr, +- pginfo); +- if ((hret != H_SUCCESS) && (hret != H_PAGE_REGISTERED)) +- return hret; +- } +- return hret; +-} +- +-static u64 ehca_reg_mr_dir_sections(int top, u64 *kpage, struct ehca_shca *shca, +- struct ehca_mr *mr, +- struct ehca_mr_pginfo *pginfo) +-{ +- u64 hret = H_SUCCESS; +- int dir; +- +- for (dir = 0; dir < EHCA_MAP_ENTRIES; dir++) { +- if (!ehca_bmap_valid(ehca_bmap->top[top]->dir[dir])) +- continue; +- +- hret = ehca_reg_mr_sections(top, dir, kpage, shca, mr, pginfo); +- if ((hret != H_SUCCESS) && (hret != H_PAGE_REGISTERED)) +- return hret; +- } +- return hret; +-} + + /* register internal max-MR to internal SHCA */ + int ehca_reg_internal_maxmr( +@@ -1625,11 +1495,6 @@ int ehca_reg_internal_maxmr( + u32 num_hwpages; + u64 hw_pgsize; + +- if (!ehca_bmap) { +- ret = -EFAULT; +- goto ehca_reg_internal_maxmr_exit0; +- } +- + e_mr = ehca_mr_new(); + if (!e_mr) { + ehca_err(&shca->ib_device, "out of memory"); +@@ -1639,8 +1504,8 @@ int ehca_reg_internal_maxmr( + e_mr->flags |= EHCA_MR_FLAG_MAXMR; + + /* register internal max-MR on HCA */ +- size_maxmr = ehca_mr_len; +- iova_start = (u64 *)ehca_map_vaddr((void *)KERNELBASE); ++ size_maxmr = (u64)high_memory - PAGE_OFFSET; ++ iova_start = (u64 *)KERNELBASE; + ib_pbuf.addr = 0; + ib_pbuf.size = size_maxmr; + num_kpages = NUM_CHUNKS(((u64)iova_start % PAGE_SIZE) + size_maxmr, +@@ -1659,7 +1524,7 @@ int ehca_reg_internal_maxmr( + + ret = ehca_reg_mr(shca, e_mr, iova_start, size_maxmr, 0, e_pd, + &pginfo, &e_mr->ib.ib_mr.lkey, +- &e_mr->ib.ib_mr.rkey, EHCA_REG_BUSMAP_MR); ++ &e_mr->ib.ib_mr.rkey); + if (ret) { + ehca_err(&shca->ib_device, "reg of internal max MR failed, " + "e_mr=%p iova_start=%p size_maxmr=%llx num_kpages=%x " +@@ -2212,8 +2077,8 @@ int ehca_mr_is_maxmr(u64 size, + u64 *iova_start) + { + /* a MR is treated as max-MR only if it fits following: */ +- if ((size == ehca_mr_len) && +- (iova_start == (void *)ehca_map_vaddr((void *)KERNELBASE))) { ++ if ((size == ((u64)high_memory - PAGE_OFFSET)) && ++ (iova_start == (void *)KERNELBASE)) { + ehca_gen_dbg("this is a max-MR"); + return 1; + } else +@@ -2319,350 +2184,3 @@ void ehca_cleanup_mrmw_cache(void) + if (mw_cache) + kmem_cache_destroy(mw_cache); + } +- +-static inline int ehca_init_top_bmap(struct ehca_top_bmap *ehca_top_bmap, +- int dir) +-{ +- if (!ehca_bmap_valid(ehca_top_bmap->dir[dir])) { +- ehca_top_bmap->dir[dir] = +- kmalloc(sizeof(struct ehca_dir_bmap), GFP_KERNEL); +- if (!ehca_top_bmap->dir[dir]) +- return -ENOMEM; +- /* Set map block to 0xFF according to EHCA_INVAL_ADDR */ +- memset(ehca_top_bmap->dir[dir], 0xFF, EHCA_ENT_MAP_SIZE); +- } +- return 0; +-} +- +-static inline int ehca_init_bmap(struct ehca_bmap *ehca_bmap, int top, int dir) +-{ +- if (!ehca_bmap_valid(ehca_bmap->top[top])) { +- ehca_bmap->top[top] = +- kmalloc(sizeof(struct ehca_top_bmap), GFP_KERNEL); +- if (!ehca_bmap->top[top]) +- return -ENOMEM; +- /* Set map block to 0xFF according to EHCA_INVAL_ADDR */ +- memset(ehca_bmap->top[top], 0xFF, EHCA_DIR_MAP_SIZE); +- } +- return ehca_init_top_bmap(ehca_bmap->top[top], dir); +-} +- +-static inline int ehca_calc_index(unsigned long i, unsigned long s) +-{ +- return (i >> s) & EHCA_INDEX_MASK; +-} +- +-void ehca_destroy_busmap(void) +-{ +- int top, dir; +- +- if (!ehca_bmap) +- return; +- +- for (top = 0; top < EHCA_MAP_ENTRIES; top++) { +- if (!ehca_bmap_valid(ehca_bmap->top[top])) +- continue; +- for (dir = 0; dir < EHCA_MAP_ENTRIES; dir++) { +- if (!ehca_bmap_valid(ehca_bmap->top[top]->dir[dir])) +- continue; +- +- kfree(ehca_bmap->top[top]->dir[dir]); +- } +- +- kfree(ehca_bmap->top[top]); +- } +- +- kfree(ehca_bmap); +- ehca_bmap = NULL; +-} +- +-static int ehca_update_busmap(unsigned long pfn, unsigned long nr_pages) +-{ +- unsigned long i, start_section, end_section; +- int top, dir, idx; +- +- if (!nr_pages) +- return 0; +- +- if (!ehca_bmap) { +- ehca_bmap = kmalloc(sizeof(struct ehca_bmap), GFP_KERNEL); +- if (!ehca_bmap) +- return -ENOMEM; +- /* Set map block to 0xFF according to EHCA_INVAL_ADDR */ +- memset(ehca_bmap, 0xFF, EHCA_TOP_MAP_SIZE); +- } +- +- start_section = phys_to_abs(pfn * PAGE_SIZE) / EHCA_SECTSIZE; +- end_section = phys_to_abs((pfn + nr_pages) * PAGE_SIZE) / EHCA_SECTSIZE; +- for (i = start_section; i < end_section; i++) { +- int ret; +- top = ehca_calc_index(i, EHCA_TOP_INDEX_SHIFT); +- dir = ehca_calc_index(i, EHCA_DIR_INDEX_SHIFT); +- idx = i & EHCA_INDEX_MASK; +- +- ret = ehca_init_bmap(ehca_bmap, top, dir); +- if (ret) { +- ehca_destroy_busmap(); +- return ret; +- } +- ehca_bmap->top[top]->dir[dir]->ent[idx] = ehca_mr_len; +- ehca_mr_len += EHCA_SECTSIZE; +- } +- return 0; +-} +- +-static int ehca_is_hugepage(unsigned long pfn) +-{ +- int page_order; +- +- if (pfn & EHCA_HUGEPAGE_PFN_MASK) +- return 0; +- +- page_order = compound_order(pfn_to_page(pfn)); +- if (page_order + PAGE_SHIFT != EHCA_HUGEPAGESHIFT) +- return 0; +- +- return 1; +-} +- +-static int ehca_create_busmap_callback(unsigned long initial_pfn, +- unsigned long total_nr_pages, void *arg) +-{ +- int ret; +- unsigned long pfn, start_pfn, end_pfn, nr_pages; +- +- if ((total_nr_pages * PAGE_SIZE) < EHCA_HUGEPAGE_SIZE) +- return ehca_update_busmap(initial_pfn, total_nr_pages); +- +- /* Given chunk is >= 16GB -> check for hugepages */ +- start_pfn = initial_pfn; +- end_pfn = initial_pfn + total_nr_pages; +- pfn = start_pfn; +- +- while (pfn < end_pfn) { +- if (ehca_is_hugepage(pfn)) { +- /* Add mem found in front of the hugepage */ +- nr_pages = pfn - start_pfn; +- ret = ehca_update_busmap(start_pfn, nr_pages); +- if (ret) +- return ret; +- /* Skip the hugepage */ +- pfn += (EHCA_HUGEPAGE_SIZE / PAGE_SIZE); +- start_pfn = pfn; +- } else +- pfn += (EHCA_SECTSIZE / PAGE_SIZE); +- } +- +- /* Add mem found behind the hugepage(s) */ +- nr_pages = pfn - start_pfn; +- return ehca_update_busmap(start_pfn, nr_pages); +-} +- +-int ehca_create_busmap(void) +-{ +- int ret; +- +- ehca_mr_len = 0; +- ret = walk_memory_resource(0, 1ULL << MAX_PHYSMEM_BITS, NULL, +- ehca_create_busmap_callback); +- return ret; +-} +- +-static int ehca_reg_bmap_mr_rpages(struct ehca_shca *shca, +- struct ehca_mr *e_mr, +- struct ehca_mr_pginfo *pginfo) +-{ +- int top; +- u64 hret, *kpage; +- +- kpage = ehca_alloc_fw_ctrlblock(GFP_KERNEL); +- if (!kpage) { +- ehca_err(&shca->ib_device, "kpage alloc failed"); +- return -ENOMEM; +- } +- for (top = 0; top < EHCA_MAP_ENTRIES; top++) { +- if (!ehca_bmap_valid(ehca_bmap->top[top])) +- continue; +- hret = ehca_reg_mr_dir_sections(top, kpage, shca, e_mr, pginfo); +- if ((hret != H_PAGE_REGISTERED) && (hret != H_SUCCESS)) +- break; +- } +- +- ehca_free_fw_ctrlblock(kpage); +- +- if (hret == H_SUCCESS) +- return 0; /* Everything is fine */ +- else { +- ehca_err(&shca->ib_device, "ehca_reg_bmap_mr_rpages failed, " +- "h_ret=%lli e_mr=%p top=%x lkey=%x " +- "hca_hndl=%llx mr_hndl=%llx", hret, e_mr, top, +- e_mr->ib.ib_mr.lkey, +- shca->ipz_hca_handle.handle, +- e_mr->ipz_mr_handle.handle); +- return ehca2ib_return_code(hret); +- } +-} +- +-static u64 ehca_map_vaddr(void *caddr) +-{ +- int top, dir, idx; +- unsigned long abs_addr, offset; +- u64 entry; +- +- if (!ehca_bmap) +- return EHCA_INVAL_ADDR; +- +- abs_addr = virt_to_abs(caddr); +- top = ehca_calc_index(abs_addr, EHCA_TOP_INDEX_SHIFT + EHCA_SECTSHIFT); +- if (!ehca_bmap_valid(ehca_bmap->top[top])) +- return EHCA_INVAL_ADDR; +- +- dir = ehca_calc_index(abs_addr, EHCA_DIR_INDEX_SHIFT + EHCA_SECTSHIFT); +- if (!ehca_bmap_valid(ehca_bmap->top[top]->dir[dir])) +- return EHCA_INVAL_ADDR; +- +- idx = ehca_calc_index(abs_addr, EHCA_SECTSHIFT); +- +- entry = ehca_bmap->top[top]->dir[dir]->ent[idx]; +- if (ehca_bmap_valid(entry)) { +- offset = (unsigned long)caddr & (EHCA_SECTSIZE - 1); +- return entry | offset; +- } else +- return EHCA_INVAL_ADDR; +-} +- +-static int ehca_dma_mapping_error(struct ib_device *dev, u64 dma_addr) +-{ +- return dma_addr == EHCA_INVAL_ADDR; +-} +- +-static u64 ehca_dma_map_single(struct ib_device *dev, void *cpu_addr, +- size_t size, enum dma_data_direction direction) +-{ +- if (cpu_addr) +- return ehca_map_vaddr(cpu_addr); +- else +- return EHCA_INVAL_ADDR; +-} +- +-static void ehca_dma_unmap_single(struct ib_device *dev, u64 addr, size_t size, +- enum dma_data_direction direction) +-{ +- /* This is only a stub; nothing to be done here */ +-} +- +-static u64 ehca_dma_map_page(struct ib_device *dev, struct page *page, +- unsigned long offset, size_t size, +- enum dma_data_direction direction) +-{ +- u64 addr; +- +- if (offset + size > PAGE_SIZE) +- return EHCA_INVAL_ADDR; +- +- addr = ehca_map_vaddr(page_address(page)); +- if (!ehca_dma_mapping_error(dev, addr)) +- addr += offset; +- +- return addr; +-} +- +-static void ehca_dma_unmap_page(struct ib_device *dev, u64 addr, size_t size, +- enum dma_data_direction direction) +-{ +- /* This is only a stub; nothing to be done here */ +-} +- +-static int ehca_dma_map_sg(struct ib_device *dev, struct scatterlist *sgl, +- int nents, enum dma_data_direction direction) +-{ +- struct scatterlist *sg; +- int i; +- +- for_each_sg(sgl, sg, nents, i) { +- u64 addr; +- addr = ehca_map_vaddr(sg_virt(sg)); +- if (ehca_dma_mapping_error(dev, addr)) +- return 0; +- +- sg->dma_address = addr; +- sg->dma_length = sg->length; +- } +- return nents; +-} +- +-static void ehca_dma_unmap_sg(struct ib_device *dev, struct scatterlist *sg, +- int nents, enum dma_data_direction direction) +-{ +- /* This is only a stub; nothing to be done here */ +-} +- +-static u64 ehca_dma_address(struct ib_device *dev, struct scatterlist *sg) +-{ +- return sg->dma_address; +-} +- +-static unsigned int ehca_dma_len(struct ib_device *dev, struct scatterlist *sg) +-{ +- return sg->length; +-} +- +-static void ehca_dma_sync_single_for_cpu(struct ib_device *dev, u64 addr, +- size_t size, +- enum dma_data_direction dir) +-{ +- dma_sync_single_for_cpu(dev->dma_device, addr, size, dir); +-} +- +-static void ehca_dma_sync_single_for_device(struct ib_device *dev, u64 addr, +- size_t size, +- enum dma_data_direction dir) +-{ +- dma_sync_single_for_device(dev->dma_device, addr, size, dir); +-} +- +-static void *ehca_dma_alloc_coherent(struct ib_device *dev, size_t size, +- u64 *dma_handle, gfp_t flag) +-{ +- struct page *p; +- void *addr = NULL; +- u64 dma_addr; +- +- p = alloc_pages(flag, get_order(size)); +- if (p) { +- addr = page_address(p); +- dma_addr = ehca_map_vaddr(addr); +- if (ehca_dma_mapping_error(dev, dma_addr)) { +- free_pages((unsigned long)addr, get_order(size)); +- return NULL; +- } +- if (dma_handle) +- *dma_handle = dma_addr; +- return addr; +- } +- return NULL; +-} +- +-static void ehca_dma_free_coherent(struct ib_device *dev, size_t size, +- void *cpu_addr, u64 dma_handle) +-{ +- if (cpu_addr && size) +- free_pages((unsigned long)cpu_addr, get_order(size)); +-} +- +- +-struct ib_dma_mapping_ops ehca_dma_mapping_ops = { +- .mapping_error = ehca_dma_mapping_error, +- .map_single = ehca_dma_map_single, +- .unmap_single = ehca_dma_unmap_single, +- .map_page = ehca_dma_map_page, +- .unmap_page = ehca_dma_unmap_page, +- .map_sg = ehca_dma_map_sg, +- .unmap_sg = ehca_dma_unmap_sg, +- .dma_address = ehca_dma_address, +- .dma_len = ehca_dma_len, +- .sync_single_for_cpu = ehca_dma_sync_single_for_cpu, +- .sync_single_for_device = ehca_dma_sync_single_for_device, +- .alloc_coherent = ehca_dma_alloc_coherent, +- .free_coherent = ehca_dma_free_coherent, +-}; +diff -Nurp ofa_kernel-1.5.patched/drivers/infiniband/hw/ehca/ehca_mrmw.h ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_mrmw.h +--- ofa_kernel-1.5.patched/drivers/infiniband/hw/ehca/ehca_mrmw.h 2009-09-25 12:18:09.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_mrmw.h 2009-09-23 15:08:25.000000000 +0200 +@@ -42,11 +42,6 @@ + #ifndef _EHCA_MRMW_H_ + #define _EHCA_MRMW_H_ + +-enum ehca_reg_type { +- EHCA_REG_MR, +- EHCA_REG_BUSMAP_MR +-}; +- + int ehca_reg_mr(struct ehca_shca *shca, + struct ehca_mr *e_mr, + u64 *iova_start, +@@ -55,8 +50,7 @@ int ehca_reg_mr(struct ehca_shca *shca, + struct ehca_pd *e_pd, + struct ehca_mr_pginfo *pginfo, + u32 *lkey, +- u32 *rkey, +- enum ehca_reg_type reg_type); ++ u32 *rkey); + + int ehca_reg_mr_rpages(struct ehca_shca *shca, + struct ehca_mr *e_mr, +@@ -124,9 +118,4 @@ void ehca_mrmw_reverse_map_acl(const u32 + + void ehca_mr_deletenew(struct ehca_mr *mr); + +-int ehca_create_busmap(void); +- +-void ehca_destroy_busmap(void); +- +-extern struct ib_dma_mapping_ops ehca_dma_mapping_ops; + #endif /*_EHCA_MRMW_H_*/ diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-020-revert_inhibit_dmem.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-020-revert_inhibit_dmem.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-020-revert_inhibit_dmem.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-020-revert_inhibit_dmem.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,110 @@ +From 8e110a2fff1f110a9211f240acc12b8310e5cbd3 Mon Sep 17 00:00:00 2001 +From: Stefan Roscher +Date: Wed, 22 Oct 2008 15:54:38 -0700 +Subject: [PATCH] IB/ehca: Reject dynamic memory add/remove when ehca adapter is present + +Since the ehca device driver does not support dynamic memory add and +remove operations, the driver must explicitly reject such requests in +order to prevent unpredictable behaviors related to existing memory +regions that cover all of memory being used by InfiniBand protocols in +the kernel. + +The solution (for now at least) is to add a memory notifier to the +ehca device driver and if a request for dynamic memory add or remove +comes in, ehca will always reject it. The user can add or remove +memory by hot-removing the ehca adapter, performing the memory +operation, and then hot-adding the ehca adapter back. + +Signed-off-by: Stefan Roscher +Signed-off-by: Roland Dreier +--- + drivers/infiniband/hw/ehca/ehca_main.c | 47 -------------------------------- + 1 files changed, 0 insertions(+), 47 deletions(-) + +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_main.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_main.c 2009-09-25 12:41:13.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_main.c 2009-09-25 12:42:48.000000000 +0200 +@@ -44,8 +44,6 @@ + #include + #endif + +-#include +-#include + #include "ehca_classes.h" + #include "ehca_iverbs.h" + #include "ehca_mrmw.h" +@@ -973,41 +971,6 @@ + spin_unlock(&shca_list_lock); + } + +-static int ehca_mem_notifier(struct notifier_block *nb, +- unsigned long action, void *data) +-{ +- static unsigned long ehca_dmem_warn_time; +- unsigned long flags; +- +- switch (action) { +- case MEM_CANCEL_OFFLINE: +- case MEM_CANCEL_ONLINE: +- case MEM_ONLINE: +- case MEM_OFFLINE: +- return NOTIFY_OK; +- case MEM_GOING_ONLINE: +- case MEM_GOING_OFFLINE: +- /* only ok if no hca is attached to the lpar */ +- spin_lock_irqsave(&shca_list_lock, flags); +- if (list_empty(&shca_list)) { +- spin_unlock_irqrestore(&shca_list_lock, flags); +- return NOTIFY_OK; +- } else { +- spin_unlock_irqrestore(&shca_list_lock, flags); +- if (printk_timed_ratelimit(&ehca_dmem_warn_time, +- 30 * 1000)) +- ehca_gen_err("DMEM operations are not allowed" +- "in conjunction with eHCA"); +- return NOTIFY_BAD; +- } +- } +- return NOTIFY_OK; +-} +- +-static struct notifier_block ehca_mem_nb = { +- .notifier_call = ehca_mem_notifier, +-}; +- + static int __init ehca_module_init(void) + { + int ret; +@@ -1035,12 +998,6 @@ + goto module_init2; + } + +- ret = register_memory_notifier(&ehca_mem_nb); +- if (ret) { +- ehca_gen_err("Failed registering memory add/remove notifier"); +- goto module_init3; +- } +- + if (ehca_poll_all_eqs != 1) { + ehca_gen_err("WARNING!!!"); + ehca_gen_err("It is possible to lose interrupts."); +@@ -1053,9 +1010,6 @@ + + return 0; + +-module_init3: +- ibmebus_unregister_driver(&ehca_driver); +- + module_init2: + ehca_destroy_slab_caches(); + +@@ -1071,8 +1025,6 @@ + + ibmebus_unregister_driver(&ehca_driver); + +- unregister_memory_notifier(&ehca_mem_nb); +- + ehca_destroy_slab_caches(); + + ehca_destroy_comp_pool(); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-030-ibmebus_loc_code.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-030-ibmebus_loc_code.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-030-ibmebus_loc_code.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-030-ibmebus_loc_code.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,192 @@ +--- + drivers/infiniband/hw/ehca/ehca_classes.h | 2 - + drivers/infiniband/hw/ehca/ehca_eq.c | 6 +-- + drivers/infiniband/hw/ehca/ehca_main.c | 49 ++++++++++++++---------------- + 3 files changed, 27 insertions(+), 30 deletions(-) + +Index: ofed_kernel-2.6.18-EL5.3/drivers/infiniband/hw/ehca/ehca_classes.h +=================================================================== +--- ofed_kernel-2.6.18-EL5.3.orig/drivers/infiniband/hw/ehca/ehca_classes.h 2011-01-03 07:04:10.000000000 -0500 ++++ ofed_kernel-2.6.18-EL5.3/drivers/infiniband/hw/ehca/ehca_classes.h 2011-01-03 07:11:26.000000000 -0500 +@@ -112,7 +112,7 @@ + + struct ehca_shca { + struct ib_device ib_device; +- struct of_device *ofdev; ++ struct ibmebus_dev *ibmebus_dev; + u8 num_ports; + int hw_level; + struct list_head shca_list; +Index: ofed_kernel-2.6.18-EL5.3/drivers/infiniband/hw/ehca/ehca_eq.c +=================================================================== +--- ofed_kernel-2.6.18-EL5.3.orig/drivers/infiniband/hw/ehca/ehca_eq.c 2011-01-03 07:04:11.000000000 -0500 ++++ ofed_kernel-2.6.18-EL5.3/drivers/infiniband/hw/ehca/ehca_eq.c 2011-01-03 07:12:11.000000000 -0500 +@@ -124,7 +124,7 @@ + if (type == EHCA_EQ) { + tasklet_init(&eq->interrupt_task, ehca_tasklet_eq, (long)shca); + +- ret = ibmebus_request_irq(eq->ist, ehca_interrupt_eq, ++ ret = ibmebus_request_irq(NULL, eq->ist, ehca_interrupt_eq, + IRQF_DISABLED, "ehca_eq", + (void *)shca); + if (ret < 0) +@@ -132,7 +132,7 @@ + } else if (type == EHCA_NEQ) { + tasklet_init(&eq->interrupt_task, ehca_tasklet_neq, (long)shca); + +- ret = ibmebus_request_irq(eq->ist, ehca_interrupt_neq, ++ ret = ibmebus_request_irq(NULL, eq->ist, ehca_interrupt_neq, + IRQF_DISABLED, "ehca_neq", + (void *)shca); + if (ret < 0) +@@ -169,7 +169,7 @@ + unsigned long flags; + u64 h_ret; + +- ibmebus_free_irq(eq->ist, (void *)shca); ++ ibmebus_free_irq(NULL, eq->ist, (void *)shca); + + spin_lock_irqsave(&shca_list_lock, flags); + eq->is_initialized = 0; +Index: ofed_kernel-2.6.18-EL5.3/drivers/infiniband/hw/ehca/ehca_main.c +=================================================================== +--- ofed_kernel-2.6.18-EL5.3.orig/drivers/infiniband/hw/ehca/ehca_main.c 2011-01-03 07:04:54.000000000 -0500 ++++ ofed_kernel-2.6.18-EL5.3/drivers/infiniband/hw/ehca/ehca_main.c 2011-01-03 07:11:26.000000000 -0500 +@@ -289,8 +289,8 @@ + }; + + ehca_gen_dbg("Probing adapter %s...", +- shca->ofdev->node->full_name); +- loc_code = of_get_property(shca->ofdev->node, "ibm,loc-code", NULL); ++ shca->ibmebus_dev->ofdev.node->full_name); ++ loc_code = of_get_property(shca->ibmebus_dev->ofdev.node, "ibm,loc-code", NULL); + if (loc_code) + ehca_gen_dbg(" ... location lode=%s", loc_code); + +@@ -460,7 +460,7 @@ + shca->ib_device.node_type = RDMA_NODE_IB_CA; + shca->ib_device.phys_port_cnt = shca->num_ports; + shca->ib_device.num_comp_vectors = 1; +- shca->ib_device.dma_device = &shca->ofdev->dev; ++ shca->ib_device.dma_device = &shca->ibmebus_dev->ofdev.dev; + shca->ib_device.query_device = ehca_query_device; + shca->ib_device.query_port = ehca_query_port; + shca->ib_device.query_gid = ehca_query_gid; +@@ -621,11 +621,6 @@ + .attrs = ehca_drv_attrs + }; + +-static struct attribute_group *ehca_drv_attr_groups[] = { +- &ehca_drv_attr_grp, +- NULL, +-}; +- + #define EHCA_RESOURCE_ATTR(name) \ + static ssize_t ehca_show_##name(struct device *dev, \ + struct device_attribute *attr, \ +@@ -709,7 +704,7 @@ + .attrs = ehca_dev_attrs + }; + +-static int __devinit ehca_probe(struct of_device *dev, ++static int __devinit ehca_probe(struct ibmebus_dev *dev, + const struct of_device_id *id) + { + struct ehca_shca *shca; +@@ -718,16 +713,16 @@ + int ret, i, eq_size; + unsigned long flags; + +- handle = of_get_property(dev->node, "ibm,hca-handle", NULL); ++ handle = of_get_property(dev->ofdev.node, "ibm,hca-handle", NULL); + if (!handle) { + ehca_gen_err("Cannot get eHCA handle for adapter: %s.", +- dev->node->full_name); ++ dev->ofdev.node->full_name); + return -ENODEV; + } + + if (!(*handle)) { + ehca_gen_err("Wrong eHCA handle for adapter: %s.", +- dev->node->full_name); ++ dev->ofdev.node->full_name); + return -ENODEV; + } + +@@ -746,9 +741,9 @@ + for (i = 0; i < ARRAY_SIZE(shca->sport); i++) + spin_lock_init(&shca->sport[i].mod_sqp_lock); + +- shca->ofdev = dev; ++ shca->ibmebus_dev = dev; + shca->ipz_hca_handle.handle = *handle; +- dev->dev.driver_data = shca; ++ dev->ofdev.dev.driver_data = shca; + + ret = ehca_sense_attributes(shca); + if (ret < 0) { +@@ -825,7 +820,7 @@ + } + } + +- ret = sysfs_create_group(&dev->dev.kobj, &ehca_dev_attr_grp); ++ ret = sysfs_create_group(&dev->ofdev.dev.kobj, &ehca_dev_attr_grp); + if (ret) /* only complain; we can live without attributes */ + ehca_err(&shca->ib_device, + "Cannot create device attributes ret=%d", ret); +@@ -875,13 +870,13 @@ + return -EINVAL; + } + +-static int __devexit ehca_remove(struct of_device *dev) ++static int __devexit ehca_remove(struct ibmebus_dev *dev) + { +- struct ehca_shca *shca = dev->dev.driver_data; ++ struct ehca_shca *shca = dev->ofdev.dev.driver_data; + unsigned long flags; + int ret; + +- sysfs_remove_group(&dev->dev.kobj, &ehca_dev_attr_grp); ++ sysfs_remove_group(&dev->ofdev.dev.kobj, &ehca_dev_attr_grp); + + if (ehca_open_aqp1 == 1) { + int i; +@@ -933,14 +928,11 @@ + }; + MODULE_DEVICE_TABLE(of, ehca_device_table); + +-static struct of_platform_driver ehca_driver = { +- .name = "ehca", +- .match_table = ehca_device_table, +- .probe = ehca_probe, +- .remove = ehca_remove, +- .driver = { +- .groups = ehca_drv_attr_groups, +- }, ++static struct ibmebus_driver ehca_driver = { ++ .name = "ehca", ++ .id_table = ehca_device_table, ++ .probe = ehca_probe, ++ .remove = ehca_remove, + }; + + void ehca_poll_eqs(unsigned long data) +@@ -999,6 +991,10 @@ + goto module_init2; + } + ++ ret = sysfs_create_group(&ehca_driver.driver.kobj, &ehca_drv_attr_grp); ++ if (ret) /* only complain; we can live without attributes */ ++ ehca_gen_err("Cannot create driver attributes ret=%d", ret); ++ + if (ehca_poll_all_eqs != 1) { + ehca_gen_err("WARNING!!!"); + ehca_gen_err("It is possible to lose interrupts."); +@@ -1024,6 +1020,7 @@ + if (ehca_poll_all_eqs == 1) + del_timer_sync(&poll_eqs_timer); + ++ sysfs_remove_group(&ehca_driver.driver.kobj, &ehca_drv_attr_grp); + ibmebus_unregister_driver(&ehca_driver); + + ehca_destroy_slab_caches(); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-040-undo_cpumask.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-040-undo_cpumask.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-040-undo_cpumask.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-040-undo_cpumask.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,42 @@ +--- + drivers/infiniband/hw/ehca/ehca_irq.c | 14 ++++++++------ + 1 file changed, 8 insertions(+), 6 deletions(-) + +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_irq.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_irq.c 2009-07-27 08:20:08.000000000 -0400 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_irq.c 2009-07-27 08:26:31.000000000 -0400 +@@ -659,12 +659,12 @@ + + WARN_ON_ONCE(!in_interrupt()); + if (ehca_debug_level >= 3) +- ehca_dmp(cpu_online_mask, cpumask_size(), ""); ++ ehca_dmp(&cpu_online_map, sizeof(cpumask_t), ""); + + spin_lock_irqsave(&pool->last_cpu_lock, flags); +- cpu = cpumask_next(pool->last_cpu, cpu_online_mask); ++ cpu = next_cpu_nr(pool->last_cpu, cpu_online_map); + if (cpu >= nr_cpu_ids) +- cpu = cpumask_first(cpu_online_mask); ++ cpu = first_cpu(cpu_online_map); + pool->last_cpu = cpu; + spin_unlock_irqrestore(&pool->last_cpu_lock, flags); + +@@ -855,7 +855,7 @@ + case CPU_UP_CANCELED_FROZEN: + ehca_gen_dbg("CPU: %x (CPU_CANCELED)", cpu); + cct = per_cpu_ptr(pool->cpu_comp_tasks, cpu); +- kthread_bind(cct->task, cpumask_any(cpu_online_mask)); ++ kthread_bind(cct->task, any_online_cpu(cpu_online_map)); + destroy_comp_task(pool, cpu); + break; + case CPU_ONLINE: +@@ -902,7 +902,7 @@ + return -ENOMEM; + + spin_lock_init(&pool->last_cpu_lock); +- pool->last_cpu = cpumask_any(cpu_online_mask); ++ pool->last_cpu = any_online_cpu(cpu_online_map); + + pool->cpu_comp_tasks = alloc_percpu(struct ehca_cpu_comp_task); + if (pool->cpu_comp_tasks == NULL) { diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-050-undo_unsigned_long.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-050-undo_unsigned_long.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-050-undo_unsigned_long.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-050-undo_unsigned_long.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,994 @@ +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_cq.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_cq.c 2009-09-23 15:08:25.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_cq.c 2009-09-25 13:31:12.000000000 +0200 +@@ -196,7 +196,7 @@ + + if (h_ret != H_SUCCESS) { + ehca_err(device, "hipz_h_alloc_resource_cq() failed " +- "h_ret=%lli device=%p", h_ret, device); ++ "h_ret=%li device=%p", h_ret, device); + cq = ERR_PTR(ehca2ib_return_code(h_ret)); + goto create_cq_exit2; + } +@@ -232,7 +232,7 @@ + + if (h_ret < H_SUCCESS) { + ehca_err(device, "hipz_h_register_rpage_cq() failed " +- "ehca_cq=%p cq_num=%x h_ret=%lli counter=%i " ++ "ehca_cq=%p cq_num=%x h_ret=%li counter=%i " + "act_pages=%i", my_cq, my_cq->cq_number, + h_ret, counter, param.act_pages); + cq = ERR_PTR(-EINVAL); +@@ -244,7 +244,7 @@ + if ((h_ret != H_SUCCESS) || vpage) { + ehca_err(device, "Registration of pages not " + "complete ehca_cq=%p cq_num=%x " +- "h_ret=%lli", my_cq, my_cq->cq_number, ++ "h_ret=%li", my_cq, my_cq->cq_number, + h_ret); + cq = ERR_PTR(-EAGAIN); + goto create_cq_exit4; +@@ -252,7 +252,7 @@ + } else { + if (h_ret != H_PAGE_REGISTERED) { + ehca_err(device, "Registration of page failed " +- "ehca_cq=%p cq_num=%x h_ret=%lli " ++ "ehca_cq=%p cq_num=%x h_ret=%li " + "counter=%i act_pages=%i", + my_cq, my_cq->cq_number, + h_ret, counter, param.act_pages); +@@ -266,7 +266,7 @@ + + gal = my_cq->galpas.kernel; + cqx_fec = hipz_galpa_load(gal, CQTEMM_OFFSET(cqx_fec)); +- ehca_dbg(device, "ehca_cq=%p cq_num=%x CQX_FEC=%llx", ++ ehca_dbg(device, "ehca_cq=%p cq_num=%x CQX_FEC=%lx", + my_cq, my_cq->cq_number, cqx_fec); + + my_cq->ib_cq.cqe = my_cq->nr_of_entries = +@@ -307,7 +307,7 @@ + h_ret = hipz_h_destroy_cq(adapter_handle, my_cq, 1); + if (h_ret != H_SUCCESS) + ehca_err(device, "hipz_h_destroy_cq() failed ehca_cq=%p " +- "cq_num=%x h_ret=%lli", my_cq, my_cq->cq_number, h_ret); ++ "cq_num=%x h_ret=%li", my_cq, my_cq->cq_number, h_ret); + + create_cq_exit2: + write_lock_irqsave(&ehca_cq_idr_lock, flags); +@@ -355,7 +355,7 @@ + h_ret = hipz_h_destroy_cq(adapter_handle, my_cq, 0); + if (h_ret == H_R_STATE) { + /* cq in err: read err data and destroy it forcibly */ +- ehca_dbg(device, "ehca_cq=%p cq_num=%x resource=%llx in err " ++ ehca_dbg(device, "ehca_cq=%p cq_num=%x ressource=%lx in err " + "state. Try to delete it forcibly.", + my_cq, cq_num, my_cq->ipz_cq_handle.handle); + ehca_error_data(shca, my_cq, my_cq->ipz_cq_handle.handle); +@@ -365,7 +365,7 @@ + cq_num); + } + if (h_ret != H_SUCCESS) { +- ehca_err(device, "hipz_h_destroy_cq() failed h_ret=%lli " ++ ehca_err(device, "hipz_h_destroy_cq() failed h_ret=%li " + "ehca_cq=%p cq_num=%x", h_ret, my_cq, cq_num); + return ehca2ib_return_code(h_ret); + } +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_hca.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_hca.c 2009-09-23 15:08:25.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_hca.c 2009-09-25 13:31:12.000000000 +0200 +@@ -393,7 +393,7 @@ + hret = hipz_h_modify_port(shca->ipz_hca_handle, port, + cap, props->init_type, port_modify_mask); + if (hret != H_SUCCESS) { +- ehca_err(&shca->ib_device, "Modify port failed h_ret=%lli", ++ ehca_err(&shca->ib_device, "Modify port failed h_ret=%li", + hret); + ret = -EINVAL; + } +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_irq.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_irq.c 2009-09-25 13:28:31.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_irq.c 2009-09-25 13:31:12.000000000 +0200 +@@ -99,7 +99,7 @@ + return; + + ehca_err(&shca->ib_device, +- "QP 0x%x (resource=%llx) has errors.", ++ "QP 0x%x (resource=%lx) has errors.", + qp->ib_qp.qp_num, resource); + break; + } +@@ -108,21 +108,21 @@ + struct ehca_cq *cq = (struct ehca_cq *)data; + + ehca_err(&shca->ib_device, +- "CQ 0x%x (resource=%llx) has errors.", ++ "CQ 0x%x (resource=%lx) has errors.", + cq->cq_number, resource); + break; + } + default: + ehca_err(&shca->ib_device, +- "Unknown error type: %llx on %s.", ++ "Unknown error type: %lx on %s.", + type, shca->ib_device.name); + break; + } + +- ehca_err(&shca->ib_device, "Error data is available: %llx.", resource); ++ ehca_err(&shca->ib_device, "Error data is available: %lx.", resource); + ehca_err(&shca->ib_device, "EHCA ----- error data begin " + "---------------------------------------------------"); +- ehca_dmp(rblock, length, "resource=%llx", resource); ++ ehca_dmp(rblock, length, "resource=%lx", resource); + ehca_err(&shca->ib_device, "EHCA ----- error data end " + "----------------------------------------------------"); + +@@ -152,7 +152,7 @@ + + if (ret == H_R_STATE) + ehca_err(&shca->ib_device, +- "No error data is available: %llx.", resource); ++ "No error data is available: %lx.", resource); + else if (ret == H_SUCCESS) { + int length; + +@@ -164,7 +164,7 @@ + print_error_data(shca, data, rblock, length); + } else + ehca_err(&shca->ib_device, +- "Error data could not be fetched: %llx", resource); ++ "Error data could not be fetched: %lx", resource); + + ehca_free_fw_ctrlblock(rblock); + +@@ -514,7 +514,7 @@ + struct ehca_cq *cq; + + eqe_value = eqe->entry; +- ehca_dbg(&shca->ib_device, "eqe_value=%llx", eqe_value); ++ ehca_dbg(&shca->ib_device, "eqe_value=%lx", eqe_value); + if (EHCA_BMASK_GET(EQE_COMPLETION_EVENT, eqe_value)) { + ehca_dbg(&shca->ib_device, "Got completion event"); + token = EHCA_BMASK_GET(EQE_CQ_TOKEN, eqe_value); +@@ -603,7 +603,7 @@ + ret = hipz_h_eoi(eq->ist); + if (ret != H_SUCCESS) + ehca_err(&shca->ib_device, +- "bad return code EOI -rc = %lld\n", ret); ++ "bad return code EOI -rc = %ld\n", ret); + ehca_dbg(&shca->ib_device, "deadman found %x eqe", eqe_cnt); + } + if (unlikely(eqe_cnt == EHCA_EQE_CACHE_SIZE)) +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_main.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_main.c 2009-09-25 12:46:08.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_main.c 2009-09-25 13:31:12.000000000 +0200 +@@ -302,7 +302,7 @@ + + h_ret = hipz_h_query_hca(shca->ipz_hca_handle, rblock); + if (h_ret != H_SUCCESS) { +- ehca_gen_err("Cannot query device properties. h_ret=%lli", ++ ehca_gen_err("Cannot query device properties. h_ret=%li", + h_ret); + ret = -EPERM; + goto sense_attributes1; +@@ -389,7 +389,7 @@ + port = (struct hipz_query_port *)rblock; + h_ret = hipz_h_query_port(shca->ipz_hca_handle, 1, port); + if (h_ret != H_SUCCESS) { +- ehca_gen_err("Cannot query port properties. h_ret=%lli", ++ ehca_gen_err("Cannot query port properties. h_ret=%li", + h_ret); + ret = -EPERM; + goto sense_attributes1; +@@ -675,7 +675,7 @@ + { + struct ehca_shca *shca = dev->driver_data; + +- return sprintf(buf, "%llx\n", shca->ipz_hca_handle.handle); ++ return sprintf(buf, "%lx\n", shca->ipz_hca_handle.handle); + + } + static DEVICE_ATTR(adapter_handle, S_IRUGO, ehca_show_adapter_handle, NULL); +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_mcast.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_mcast.c 2009-09-23 15:08:25.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_mcast.c 2009-09-25 13:31:12.000000000 +0200 +@@ -88,7 +88,7 @@ + if (h_ret != H_SUCCESS) + ehca_err(ibqp->device, + "ehca_qp=%p qp_num=%x hipz_h_attach_mcqp() failed " +- "h_ret=%lli", my_qp, ibqp->qp_num, h_ret); ++ "h_ret=%li", my_qp, ibqp->qp_num, h_ret); + + return ehca2ib_return_code(h_ret); + } +@@ -125,7 +125,7 @@ + if (h_ret != H_SUCCESS) + ehca_err(ibqp->device, + "ehca_qp=%p qp_num=%x hipz_h_detach_mcqp() failed " +- "h_ret=%lli", my_qp, ibqp->qp_num, h_ret); ++ "h_ret=%li", my_qp, ibqp->qp_num, h_ret); + + return ehca2ib_return_code(h_ret); + } +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_mrmw.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_mrmw.c 2009-09-25 12:41:13.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_mrmw.c 2009-09-25 13:31:12.000000000 +0200 +@@ -204,7 +204,7 @@ + } + if ((size == 0) || + (((u64)iova_start + size) < (u64)iova_start)) { +- ehca_err(pd->device, "bad input values: size=%llx iova_start=%p", ++ ehca_err(pd->device, "bad input values: size=%lx iova_start=%p", + size, iova_start); + ib_mr = ERR_PTR(-EINVAL); + goto reg_phys_mr_exit0; +@@ -309,8 +309,8 @@ + } + + if (length == 0 || virt + length < virt) { +- ehca_err(pd->device, "bad input values: length=%llx " +- "virt_base=%llx", length, virt); ++ ehca_err(pd->device, "bad input values: length=%lx " ++ "virt_base=%lx", length, virt); + ib_mr = ERR_PTR(-EINVAL); + goto reg_user_mr_exit0; + } +@@ -373,7 +373,7 @@ + &e_mr->ib.ib_mr.rkey); + if (ret == -EINVAL && pginfo.hwpage_size > PAGE_SIZE) { + ehca_warn(pd->device, "failed to register mr " +- "with hwpage_size=%llx", hwpage_size); ++ "with hwpage_size=%lx", hwpage_size); + ehca_info(pd->device, "try to register mr with " + "kpage_size=%lx", PAGE_SIZE); + /* +@@ -509,7 +509,7 @@ + goto rereg_phys_mr_exit1; + if ((new_size == 0) || + (((u64)iova_start + new_size) < (u64)iova_start)) { +- ehca_err(mr->device, "bad input values: new_size=%llx " ++ ehca_err(mr->device, "bad input values: new_size=%lx " + "iova_start=%p", new_size, iova_start); + ret = -EINVAL; + goto rereg_phys_mr_exit1; +@@ -580,8 +580,8 @@ + + h_ret = hipz_h_query_mr(shca->ipz_hca_handle, e_mr, &hipzout); + if (h_ret != H_SUCCESS) { +- ehca_err(mr->device, "hipz_mr_query failed, h_ret=%lli mr=%p " +- "hca_hndl=%llx mr_hndl=%llx lkey=%x", ++ ehca_err(mr->device, "hipz_mr_query failed, h_ret=%li mr=%p " ++ "hca_hndl=%lx mr_hndl=%lx lkey=%x", + h_ret, mr, shca->ipz_hca_handle.handle, + e_mr->ipz_mr_handle.handle, mr->lkey); + ret = ehca2ib_return_code(h_ret); +@@ -630,8 +630,8 @@ + /* TODO: BUSY: MR still has bound window(s) */ + h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_mr); + if (h_ret != H_SUCCESS) { +- ehca_err(mr->device, "hipz_free_mr failed, h_ret=%lli shca=%p " +- "e_mr=%p hca_hndl=%llx mr_hndl=%llx mr->lkey=%x", ++ ehca_err(mr->device, "hipz_free_mr failed, h_ret=%li shca=%p " ++ "e_mr=%p hca_hndl=%lx mr_hndl=%lx mr->lkey=%x", + h_ret, shca, e_mr, shca->ipz_hca_handle.handle, + e_mr->ipz_mr_handle.handle, mr->lkey); + ret = ehca2ib_return_code(h_ret); +@@ -671,8 +671,8 @@ + h_ret = hipz_h_alloc_resource_mw(shca->ipz_hca_handle, e_mw, + e_pd->fw_pd, &hipzout); + if (h_ret != H_SUCCESS) { +- ehca_err(pd->device, "hipz_mw_allocate failed, h_ret=%lli " +- "shca=%p hca_hndl=%llx mw=%p", ++ ehca_err(pd->device, "hipz_mw_allocate failed, h_ret=%li " ++ "shca=%p hca_hndl=%lx mw=%p", + h_ret, shca, shca->ipz_hca_handle.handle, e_mw); + ib_mw = ERR_PTR(ehca2ib_return_code(h_ret)); + goto alloc_mw_exit1; +@@ -713,8 +713,8 @@ + + h_ret = hipz_h_free_resource_mw(shca->ipz_hca_handle, e_mw); + if (h_ret != H_SUCCESS) { +- ehca_err(mw->device, "hipz_free_mw failed, h_ret=%lli shca=%p " +- "mw=%p rkey=%x hca_hndl=%llx mw_hndl=%llx", ++ ehca_err(mw->device, "hipz_free_mw failed, h_ret=%li shca=%p " ++ "mw=%p rkey=%x hca_hndl=%lx mw_hndl=%lx", + h_ret, shca, mw, mw->rkey, shca->ipz_hca_handle.handle, + e_mw->ipz_mw_handle.handle); + return ehca2ib_return_code(h_ret); +@@ -840,7 +840,7 @@ + goto map_phys_fmr_exit0; + if (iova % e_fmr->fmr_page_size) { + /* only whole-numbered pages */ +- ehca_err(fmr->device, "bad iova, iova=%llx fmr_page_size=%x", ++ ehca_err(fmr->device, "bad iova, iova=%lx fmr_page_size=%x", + iova, e_fmr->fmr_page_size); + ret = -EINVAL; + goto map_phys_fmr_exit0; +@@ -878,7 +878,7 @@ + map_phys_fmr_exit0: + if (ret) + ehca_err(fmr->device, "ret=%i fmr=%p page_list=%p list_len=%x " +- "iova=%llx", ret, fmr, page_list, list_len, iova); ++ "iova=%lx", ret, fmr, page_list, list_len, iova); + return ret; + } /* end ehca_map_phys_fmr() */ + +@@ -964,8 +964,8 @@ + + h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_fmr); + if (h_ret != H_SUCCESS) { +- ehca_err(fmr->device, "hipz_free_mr failed, h_ret=%lli e_fmr=%p " +- "hca_hndl=%llx fmr_hndl=%llx fmr->lkey=%x", ++ ehca_err(fmr->device, "hipz_free_mr failed, h_ret=%li e_fmr=%p " ++ "hca_hndl=%lx fmr_hndl=%lx fmr->lkey=%x", + h_ret, e_fmr, shca->ipz_hca_handle.handle, + e_fmr->ipz_mr_handle.handle, fmr->lkey); + ret = ehca2ib_return_code(h_ret); +@@ -1007,8 +1007,8 @@ + (u64)iova_start, size, hipz_acl, + e_pd->fw_pd, &hipzout); + if (h_ret != H_SUCCESS) { +- ehca_err(&shca->ib_device, "hipz_alloc_mr failed, h_ret=%lli " +- "hca_hndl=%llx", h_ret, shca->ipz_hca_handle.handle); ++ ehca_err(&shca->ib_device, "hipz_alloc_mr failed, h_ret=%li " ++ "hca_hndl=%lx", h_ret, shca->ipz_hca_handle.handle); + ret = ehca2ib_return_code(h_ret); + goto ehca_reg_mr_exit0; + } +@@ -1033,9 +1033,9 @@ + ehca_reg_mr_exit1: + h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_mr); + if (h_ret != H_SUCCESS) { +- ehca_err(&shca->ib_device, "h_ret=%lli shca=%p e_mr=%p " +- "iova_start=%p size=%llx acl=%x e_pd=%p lkey=%x " +- "pginfo=%p num_kpages=%llx num_hwpages=%llx ret=%i", ++ ehca_err(&shca->ib_device, "h_ret=%li shca=%p e_mr=%p " ++ "iova_start=%p size=%lx acl=%x e_pd=%p lkey=%x " ++ "pginfo=%p num_kpages=%lx num_hwpages=%lx ret=%i", + h_ret, shca, e_mr, iova_start, size, acl, e_pd, + hipzout.lkey, pginfo, pginfo->num_kpages, + pginfo->num_hwpages, ret); +@@ -1045,8 +1045,8 @@ + ehca_reg_mr_exit0: + if (ret) + ehca_err(&shca->ib_device, "ret=%i shca=%p e_mr=%p " +- "iova_start=%p size=%llx acl=%x e_pd=%p pginfo=%p " +- "num_kpages=%llx num_hwpages=%llx", ++ "iova_start=%p size=%lx acl=%x e_pd=%p pginfo=%p " ++ "num_kpages=%lx num_hwpages=%lx", + ret, shca, e_mr, iova_start, size, acl, e_pd, pginfo, + pginfo->num_kpages, pginfo->num_hwpages); + return ret; +@@ -1116,8 +1116,8 @@ + */ + if (h_ret != H_SUCCESS) { + ehca_err(&shca->ib_device, "last " +- "hipz_reg_rpage_mr failed, h_ret=%lli " +- "e_mr=%p i=%x hca_hndl=%llx mr_hndl=%llx" ++ "hipz_reg_rpage_mr failed, h_ret=%li " ++ "e_mr=%p i=%x hca_hndl=%lx mr_hndl=%lx" + " lkey=%x", h_ret, e_mr, i, + shca->ipz_hca_handle.handle, + e_mr->ipz_mr_handle.handle, +@@ -1128,8 +1128,8 @@ + ret = 0; + } else if (h_ret != H_PAGE_REGISTERED) { + ehca_err(&shca->ib_device, "hipz_reg_rpage_mr failed, " +- "h_ret=%lli e_mr=%p i=%x lkey=%x hca_hndl=%llx " +- "mr_hndl=%llx", h_ret, e_mr, i, ++ "h_ret=%li e_mr=%p i=%x lkey=%x hca_hndl=%lx " ++ "mr_hndl=%lx", h_ret, e_mr, i, + e_mr->ib.ib_mr.lkey, + shca->ipz_hca_handle.handle, + e_mr->ipz_mr_handle.handle); +@@ -1145,7 +1145,7 @@ + ehca_reg_mr_rpages_exit0: + if (ret) + ehca_err(&shca->ib_device, "ret=%i shca=%p e_mr=%p pginfo=%p " +- "num_kpages=%llx num_hwpages=%llx", ret, shca, e_mr, ++ "num_kpages=%lx num_hwpages=%lx", ret, shca, e_mr, + pginfo, pginfo->num_kpages, pginfo->num_hwpages); + return ret; + } /* end ehca_reg_mr_rpages() */ +@@ -1184,7 +1184,7 @@ + ret = ehca_set_pagebuf(pginfo, pginfo->num_hwpages, kpage); + if (ret) { + ehca_err(&shca->ib_device, "set pagebuf failed, e_mr=%p " +- "pginfo=%p type=%x num_kpages=%llx num_hwpages=%llx " ++ "pginfo=%p type=%x num_kpages=%lx num_hwpages=%lx " + "kpage=%p", e_mr, pginfo, pginfo->type, + pginfo->num_kpages, pginfo->num_hwpages, kpage); + goto ehca_rereg_mr_rereg1_exit1; +@@ -1205,13 +1205,13 @@ + * (MW bound or MR is shared) + */ + ehca_warn(&shca->ib_device, "hipz_h_reregister_pmr failed " +- "(Rereg1), h_ret=%lli e_mr=%p", h_ret, e_mr); ++ "(Rereg1), h_ret=%li e_mr=%p", h_ret, e_mr); + *pginfo = pginfo_save; + ret = -EAGAIN; + } else if ((u64 *)hipzout.vaddr != iova_start) { + ehca_err(&shca->ib_device, "PHYP changed iova_start in " +- "rereg_pmr, iova_start=%p iova_start_out=%llx e_mr=%p " +- "mr_handle=%llx lkey=%x lkey_out=%x", iova_start, ++ "rereg_pmr, iova_start=%p iova_start_out=%lx e_mr=%p " ++ "mr_handle=%lx lkey=%x lkey_out=%x", iova_start, + hipzout.vaddr, e_mr, e_mr->ipz_mr_handle.handle, + e_mr->ib.ib_mr.lkey, hipzout.lkey); + ret = -EFAULT; +@@ -1235,7 +1235,7 @@ + ehca_rereg_mr_rereg1_exit0: + if ( ret && (ret != -EAGAIN) ) + ehca_err(&shca->ib_device, "ret=%i lkey=%x rkey=%x " +- "pginfo=%p num_kpages=%llx num_hwpages=%llx", ++ "pginfo=%p num_kpages=%lx num_hwpages=%lx", + ret, *lkey, *rkey, pginfo, pginfo->num_kpages, + pginfo->num_hwpages); + return ret; +@@ -1263,7 +1263,7 @@ + (e_mr->num_hwpages > MAX_RPAGES) || + (pginfo->num_hwpages > e_mr->num_hwpages)) { + ehca_dbg(&shca->ib_device, "Rereg3 case, " +- "pginfo->num_hwpages=%llx e_mr->num_hwpages=%x", ++ "pginfo->num_hwpages=%lx e_mr->num_hwpages=%x", + pginfo->num_hwpages, e_mr->num_hwpages); + rereg_1_hcall = 0; + rereg_3_hcall = 1; +@@ -1295,7 +1295,7 @@ + h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_mr); + if (h_ret != H_SUCCESS) { + ehca_err(&shca->ib_device, "hipz_free_mr failed, " +- "h_ret=%lli e_mr=%p hca_hndl=%llx mr_hndl=%llx " ++ "h_ret=%li e_mr=%p hca_hndl=%lx mr_hndl=%lx " + "mr->lkey=%x", + h_ret, e_mr, shca->ipz_hca_handle.handle, + e_mr->ipz_mr_handle.handle, +@@ -1328,8 +1328,8 @@ + ehca_rereg_mr_exit0: + if (ret) + ehca_err(&shca->ib_device, "ret=%i shca=%p e_mr=%p " +- "iova_start=%p size=%llx acl=%x e_pd=%p pginfo=%p " +- "num_kpages=%llx lkey=%x rkey=%x rereg_1_hcall=%x " ++ "iova_start=%p size=%lx acl=%x e_pd=%p pginfo=%p " ++ "num_kpages=%lx lkey=%x rkey=%x rereg_1_hcall=%x " + "rereg_3_hcall=%x", ret, shca, e_mr, iova_start, size, + acl, e_pd, pginfo, pginfo->num_kpages, *lkey, *rkey, + rereg_1_hcall, rereg_3_hcall); +@@ -1371,8 +1371,8 @@ + * FMRs are not shared and no MW bound to FMRs + */ + ehca_err(&shca->ib_device, "hipz_reregister_pmr failed " +- "(Rereg1), h_ret=%lli e_fmr=%p hca_hndl=%llx " +- "mr_hndl=%llx lkey=%x lkey_out=%x", ++ "(Rereg1), h_ret=%li e_fmr=%p hca_hndl=%lx " ++ "mr_hndl=%lx lkey=%x lkey_out=%x", + h_ret, e_fmr, shca->ipz_hca_handle.handle, + e_fmr->ipz_mr_handle.handle, + e_fmr->ib.ib_fmr.lkey, hipzout.lkey); +@@ -1383,7 +1383,7 @@ + h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_fmr); + if (h_ret != H_SUCCESS) { + ehca_err(&shca->ib_device, "hipz_free_mr failed, " +- "h_ret=%lli e_fmr=%p hca_hndl=%llx mr_hndl=%llx " ++ "h_ret=%li e_fmr=%p hca_hndl=%lx mr_hndl=%lx " + "lkey=%x", + h_ret, e_fmr, shca->ipz_hca_handle.handle, + e_fmr->ipz_mr_handle.handle, +@@ -1447,9 +1447,9 @@ + (u64)iova_start, hipz_acl, e_pd->fw_pd, + &hipzout); + if (h_ret != H_SUCCESS) { +- ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%lli " ++ ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%li " + "shca=%p e_origmr=%p e_newmr=%p iova_start=%p acl=%x " +- "e_pd=%p hca_hndl=%llx mr_hndl=%llx lkey=%x", ++ "e_pd=%p hca_hndl=%lx mr_hndl=%lx lkey=%x", + h_ret, shca, e_origmr, e_newmr, iova_start, acl, e_pd, + shca->ipz_hca_handle.handle, + e_origmr->ipz_mr_handle.handle, +@@ -1527,7 +1527,7 @@ + &e_mr->ib.ib_mr.rkey); + if (ret) { + ehca_err(&shca->ib_device, "reg of internal max MR failed, " +- "e_mr=%p iova_start=%p size_maxmr=%llx num_kpages=%x " ++ "e_mr=%p iova_start=%p size_maxmr=%lx num_kpages=%x " + "num_hwpages=%x", e_mr, iova_start, size_maxmr, + num_kpages, num_hwpages); + goto ehca_reg_internal_maxmr_exit1; +@@ -1573,8 +1573,8 @@ + (u64)iova_start, hipz_acl, e_pd->fw_pd, + &hipzout); + if (h_ret != H_SUCCESS) { +- ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%lli " +- "e_origmr=%p hca_hndl=%llx mr_hndl=%llx lkey=%x", ++ ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%li " ++ "e_origmr=%p hca_hndl=%lx mr_hndl=%lx lkey=%x", + h_ret, e_origmr, shca->ipz_hca_handle.handle, + e_origmr->ipz_mr_handle.handle, + e_origmr->ib.ib_mr.lkey); +@@ -1651,28 +1651,28 @@ + /* check first buffer */ + if (((u64)iova_start & ~PAGE_MASK) != (pbuf->addr & ~PAGE_MASK)) { + ehca_gen_err("iova_start/addr mismatch, iova_start=%p " +- "pbuf->addr=%llx pbuf->size=%llx", ++ "pbuf->addr=%lx pbuf->size=%lx", + iova_start, pbuf->addr, pbuf->size); + return -EINVAL; + } + if (((pbuf->addr + pbuf->size) % PAGE_SIZE) && + (num_phys_buf > 1)) { +- ehca_gen_err("addr/size mismatch in 1st buf, pbuf->addr=%llx " +- "pbuf->size=%llx", pbuf->addr, pbuf->size); ++ ehca_gen_err("addr/size mismatch in 1st buf, pbuf->addr=%lx " ++ "pbuf->size=%lx", pbuf->addr, pbuf->size); + return -EINVAL; + } + + for (i = 0; i < num_phys_buf; i++) { + if ((i > 0) && (pbuf->addr % PAGE_SIZE)) { +- ehca_gen_err("bad address, i=%x pbuf->addr=%llx " +- "pbuf->size=%llx", ++ ehca_gen_err("bad address, i=%x pbuf->addr=%lx " ++ "pbuf->size=%lx", + i, pbuf->addr, pbuf->size); + return -EINVAL; + } + if (((i > 0) && /* not 1st */ + (i < (num_phys_buf - 1)) && /* not last */ + (pbuf->size % PAGE_SIZE)) || (pbuf->size == 0)) { +- ehca_gen_err("bad size, i=%x pbuf->size=%llx", ++ ehca_gen_err("bad size, i=%x pbuf->size=%lx", + i, pbuf->size); + return -EINVAL; + } +@@ -1705,7 +1705,7 @@ + page = page_list; + for (i = 0; i < list_len; i++) { + if (*page % e_fmr->fmr_page_size) { +- ehca_gen_err("bad page, i=%x *page=%llx page=%p fmr=%p " ++ ehca_gen_err("bad page, i=%x *page=%lx page=%p fmr=%p " + "fmr_page_size=%x", i, *page, page, e_fmr, + e_fmr->fmr_page_size); + return -EINVAL; +@@ -1743,9 +1743,9 @@ + (pginfo->next_hwpage * + pginfo->hwpage_size)); + if ( !(*kpage) ) { +- ehca_gen_err("pgaddr=%llx " +- "chunk->page_list[i]=%llx " +- "i=%x next_hwpage=%llx", ++ ehca_gen_err("pgaddr=%lx " ++ "chunk->page_list[i]=%lx " ++ "i=%x next_hwpage=%lx", + pgaddr, (u64)sg_dma_address( + &chunk->page_list[i]), + i, pginfo->next_hwpage); +@@ -1795,11 +1795,11 @@ + for (t = start_idx; t <= end_idx; t++) { + u64 pgaddr = page_to_pfn(sg_page(&page_list[t])) << PAGE_SHIFT; + if (ehca_debug_level >= 3) +- ehca_gen_dbg("chunk_page=%llx value=%016llx", pgaddr, ++ ehca_gen_dbg("chunk_page=%lx value=%016lx", pgaddr, + *(u64 *)abs_to_virt(phys_to_abs(pgaddr))); + if (pgaddr - PAGE_SIZE != *prev_pgaddr) { +- ehca_gen_err("uncontiguous page found pgaddr=%llx " +- "prev_pgaddr=%llx page_list_i=%x", ++ ehca_gen_err("uncontiguous page found pgaddr=%lx " ++ "prev_pgaddr=%lx page_list_i=%x", + pgaddr, *prev_pgaddr, t); + return -EINVAL; + } +@@ -1833,7 +1833,7 @@ + << PAGE_SHIFT ); + *kpage = phys_to_abs(pgaddr); + if ( !(*kpage) ) { +- ehca_gen_err("pgaddr=%llx i=%x", ++ ehca_gen_err("pgaddr=%lx i=%x", + pgaddr, i); + ret = -EFAULT; + return ret; +@@ -1846,8 +1846,8 @@ + if (pginfo->hwpage_cnt) { + ehca_gen_err( + "invalid alignment " +- "pgaddr=%llx i=%x " +- "mr_pgsize=%llx", ++ "pgaddr=%lx i=%x " ++ "mr_pgsize=%lx", + pgaddr, i, + pginfo->hwpage_size); + ret = -EFAULT; +@@ -1866,8 +1866,8 @@ + if (ehca_debug_level >= 3) { + u64 val = *(u64 *)abs_to_virt( + phys_to_abs(pgaddr)); +- ehca_gen_dbg("kpage=%llx chunk_page=%llx " +- "value=%016llx", ++ ehca_gen_dbg("kpage=%lx chunk_page=%lx " ++ "value=%016lx", + *kpage, pgaddr, val); + } + prev_pgaddr = pgaddr; +@@ -1944,9 +1944,9 @@ + if ((pginfo->kpage_cnt >= pginfo->num_kpages) || + (pginfo->hwpage_cnt >= pginfo->num_hwpages)) { + ehca_gen_err("kpage_cnt >= num_kpages, " +- "kpage_cnt=%llx num_kpages=%llx " +- "hwpage_cnt=%llx " +- "num_hwpages=%llx i=%x", ++ "kpage_cnt=%lx num_kpages=%lx " ++ "hwpage_cnt=%lx " ++ "num_hwpages=%lx i=%x", + pginfo->kpage_cnt, + pginfo->num_kpages, + pginfo->hwpage_cnt, +@@ -1957,8 +1957,8 @@ + (pbuf->addr & ~(pginfo->hwpage_size - 1)) + + (pginfo->next_hwpage * pginfo->hwpage_size)); + if ( !(*kpage) && pbuf->addr ) { +- ehca_gen_err("pbuf->addr=%llx pbuf->size=%llx " +- "next_hwpage=%llx", pbuf->addr, ++ ehca_gen_err("pbuf->addr=%lx pbuf->size=%lx " ++ "next_hwpage=%lx", pbuf->addr, + pbuf->size, pginfo->next_hwpage); + return -EFAULT; + } +@@ -1996,8 +1996,8 @@ + *kpage = phys_to_abs((*fmrlist & ~(pginfo->hwpage_size - 1)) + + pginfo->next_hwpage * pginfo->hwpage_size); + if ( !(*kpage) ) { +- ehca_gen_err("*fmrlist=%llx fmrlist=%p " +- "next_listelem=%llx next_hwpage=%llx", ++ ehca_gen_err("*fmrlist=%lx fmrlist=%p " ++ "next_listelem=%lx next_hwpage=%lx", + *fmrlist, fmrlist, + pginfo->u.fmr.next_listelem, + pginfo->next_hwpage); +@@ -2025,7 +2025,7 @@ + ~(pginfo->hwpage_size - 1)); + if (prev + pginfo->u.fmr.fmr_pgsize != p) { + ehca_gen_err("uncontiguous fmr pages " +- "found prev=%llx p=%llx " ++ "found prev=%lx p=%lx " + "idx=%x", prev, p, i + j); + return -EINVAL; + } +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_qp.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_qp.c 2009-09-25 12:40:28.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_qp.c 2009-09-25 13:31:12.000000000 +0200 +@@ -331,7 +331,7 @@ + if (cnt == (nr_q_pages - 1)) { /* last page! */ + if (h_ret != expected_hret) { + ehca_err(ib_dev, "hipz_qp_register_rpage() " +- "h_ret=%lli", h_ret); ++ "h_ret=%li", h_ret); + ret = ehca2ib_return_code(h_ret); + goto init_qp_queue1; + } +@@ -345,7 +345,7 @@ + } else { + if (h_ret != H_PAGE_REGISTERED) { + ehca_err(ib_dev, "hipz_qp_register_rpage() " +- "h_ret=%lli", h_ret); ++ "h_ret=%li", h_ret); + ret = ehca2ib_return_code(h_ret); + goto init_qp_queue1; + } +@@ -711,7 +711,7 @@ + + h_ret = hipz_h_alloc_resource_qp(shca->ipz_hca_handle, &parms, is_user); + if (h_ret != H_SUCCESS) { +- ehca_err(pd->device, "h_alloc_resource_qp() failed h_ret=%lli", ++ ehca_err(pd->device, "h_alloc_resource_qp() failed h_ret=%li", + h_ret); + ret = ehca2ib_return_code(h_ret); + goto create_qp_exit1; +@@ -1015,7 +1015,7 @@ + mqpcb, my_qp->galpas.kernel); + if (hret != H_SUCCESS) { + ehca_err(pd->device, "Could not modify SRQ to INIT " +- "ehca_qp=%p qp_num=%x h_ret=%lli", ++ "ehca_qp=%p qp_num=%x h_ret=%li", + my_qp, my_qp->real_qp_num, hret); + goto create_srq2; + } +@@ -1029,7 +1029,7 @@ + mqpcb, my_qp->galpas.kernel); + if (hret != H_SUCCESS) { + ehca_err(pd->device, "Could not enable SRQ " +- "ehca_qp=%p qp_num=%x h_ret=%lli", ++ "ehca_qp=%p qp_num=%x h_ret=%li", + my_qp, my_qp->real_qp_num, hret); + goto create_srq2; + } +@@ -1043,7 +1043,7 @@ + mqpcb, my_qp->galpas.kernel); + if (hret != H_SUCCESS) { + ehca_err(pd->device, "Could not modify SRQ to RTR " +- "ehca_qp=%p qp_num=%x h_ret=%lli", ++ "ehca_qp=%p qp_num=%x h_ret=%li", + my_qp, my_qp->real_qp_num, hret); + goto create_srq2; + } +@@ -1083,7 +1083,7 @@ + &bad_send_wqe_p, NULL, 2); + if (h_ret != H_SUCCESS) { + ehca_err(&shca->ib_device, "hipz_h_disable_and_get_wqe() failed" +- " ehca_qp=%p qp_num=%x h_ret=%lli", ++ " ehca_qp=%p qp_num=%x h_ret=%li", + my_qp, qp_num, h_ret); + return ehca2ib_return_code(h_ret); + } +@@ -1139,7 +1139,7 @@ + + if (ipz_queue_abs_to_offset(ipz_queue, wqe_p, &q_ofs)) { + ehca_gen_err("Invalid offset for calculating left cqes " +- "wqe_p=%#llx wqe_v=%p\n", wqe_p, wqe_v); ++ "wqe_p=%#lx wqe_v=%p\n", wqe_p, wqe_v); + return -EFAULT; + } + +@@ -1173,7 +1173,7 @@ + &send_wqe_p, &recv_wqe_p, 4); + if (h_ret != H_SUCCESS) { + ehca_err(&shca->ib_device, "disable_and_get_wqe() " +- "failed ehca_qp=%p qp_num=%x h_ret=%lli", ++ "failed ehca_qp=%p qp_num=%x h_ret=%li", + my_qp, qp_num, h_ret); + return ehca2ib_return_code(h_ret); + } +@@ -1267,7 +1267,7 @@ + mqpcb, my_qp->galpas.kernel); + if (h_ret != H_SUCCESS) { + ehca_err(ibqp->device, "hipz_h_query_qp() failed " +- "ehca_qp=%p qp_num=%x h_ret=%lli", ++ "ehca_qp=%p qp_num=%x h_ret=%li", + my_qp, ibqp->qp_num, h_ret); + ret = ehca2ib_return_code(h_ret); + goto modify_qp_exit1; +@@ -1698,7 +1698,7 @@ + + if (h_ret != H_SUCCESS) { + ret = ehca2ib_return_code(h_ret); +- ehca_err(ibqp->device, "hipz_h_modify_qp() failed h_ret=%lli " ++ ehca_err(ibqp->device, "hipz_h_modify_qp() failed h_ret=%li " + "ehca_qp=%p qp_num=%x", h_ret, my_qp, ibqp->qp_num); + goto modify_qp_exit2; + } +@@ -1731,7 +1731,7 @@ + ret = ehca2ib_return_code(h_ret); + ehca_err(ibqp->device, "ENABLE in context of " + "RESET_2_INIT failed! Maybe you didn't get " +- "a LID h_ret=%lli ehca_qp=%p qp_num=%x", ++ "a LID h_ret=%li ehca_qp=%p qp_num=%x", + h_ret, my_qp, ibqp->qp_num); + goto modify_qp_exit2; + } +@@ -1919,7 +1919,7 @@ + if (h_ret != H_SUCCESS) { + ret = ehca2ib_return_code(h_ret); + ehca_err(qp->device, "hipz_h_query_qp() failed " +- "ehca_qp=%p qp_num=%x h_ret=%lli", ++ "ehca_qp=%p qp_num=%x h_ret=%li", + my_qp, qp->qp_num, h_ret); + goto query_qp_exit1; + } +@@ -2077,7 +2077,7 @@ + + if (h_ret != H_SUCCESS) { + ret = ehca2ib_return_code(h_ret); +- ehca_err(ibsrq->device, "hipz_h_modify_qp() failed h_ret=%lli " ++ ehca_err(ibsrq->device, "hipz_h_modify_qp() failed h_ret=%li " + "ehca_qp=%p qp_num=%x", + h_ret, my_qp, my_qp->real_qp_num); + } +@@ -2111,7 +2111,7 @@ + if (h_ret != H_SUCCESS) { + ret = ehca2ib_return_code(h_ret); + ehca_err(srq->device, "hipz_h_query_qp() failed " +- "ehca_qp=%p qp_num=%x h_ret=%lli", ++ "ehca_qp=%p qp_num=%x h_ret=%li", + my_qp, my_qp->real_qp_num, h_ret); + goto query_srq_exit1; + } +@@ -2183,7 +2183,7 @@ + + h_ret = hipz_h_destroy_qp(shca->ipz_hca_handle, my_qp); + if (h_ret != H_SUCCESS) { +- ehca_err(dev, "hipz_h_destroy_qp() failed h_ret=%lli " ++ ehca_err(dev, "hipz_h_destroy_qp() failed h_ret=%li " + "ehca_qp=%p qp_num=%x", h_ret, my_qp, qp_num); + return ehca2ib_return_code(h_ret); + } +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_reqs.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_reqs.c 2009-09-25 12:40:29.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_reqs.c 2009-09-25 13:31:12.000000000 +0200 +@@ -826,7 +826,7 @@ + offset = qmap->next_wqe_idx * ipz_queue->qe_size; + wqe = (struct ehca_wqe *)ipz_qeit_calc(ipz_queue, offset); + if (!wqe) { +- ehca_err(cq->device, "Invalid wqe offset=%#llx on " ++ ehca_err(cq->device, "Invalid wqe offset=%#lx on " + "qp_num=%#x", offset, my_qp->real_qp_num); + return nr; + } +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_sqp.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_sqp.c 2009-09-25 12:40:29.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_sqp.c 2009-09-25 13:31:12.000000000 +0200 +@@ -85,7 +85,7 @@ + + if (ret != H_SUCCESS) { + ehca_err(&shca->ib_device, +- "Can't define AQP1 for port %x. h_ret=%lli", ++ "Can't define AQP1 for port %x. h_ret=%li", + port, ret); + return ret; + } +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_tools.h +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_tools.h 2009-09-23 15:08:25.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_tools.h 2009-09-25 13:31:12.000000000 +0200 +@@ -116,7 +116,7 @@ + unsigned char *deb = (unsigned char *)(adr); \ + for (x = 0; x < l; x += 16) { \ + printk(KERN_INFO "EHCA_DMP:%s " format \ +- " adr=%p ofs=%04x %016llx %016llx\n", \ ++ " adr=%p ofs=%04x %016lx %016lx\n", \ + __func__, ##args, deb, x, \ + *((u64 *)&deb[0]), *((u64 *)&deb[8])); \ + deb += 16; \ +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_uverbs.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/ehca_uverbs.c 2009-09-23 15:08:25.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/ehca_uverbs.c 2009-09-25 13:31:12.000000000 +0200 +@@ -114,7 +114,7 @@ + + physical = galpas->user.fw_handle; + vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); +- ehca_gen_dbg("vsize=%llx physical=%llx", vsize, physical); ++ ehca_gen_dbg("vsize=%lx physical=%lx", vsize, physical); + /* VM_IO | VM_RESERVED are set by remap_pfn_range() */ + ret = remap_4k_pfn(vma, vma->vm_start, physical >> EHCA_PAGESHIFT, + vma->vm_page_prot); +Index: ofa_kernel-1.5/drivers/infiniband/hw/ehca/hcp_if.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/hw/ehca/hcp_if.c 2009-09-25 12:40:28.000000000 +0200 ++++ ofa_kernel-1.5/drivers/infiniband/hw/ehca/hcp_if.c 2009-09-25 13:31:12.000000000 +0200 +@@ -249,7 +249,7 @@ + *eq_ist = (u32)outs[5]; + + if (ret == H_NOT_ENOUGH_RESOURCES) +- ehca_gen_err("Not enough resource - ret=%lli ", ret); ++ ehca_gen_err("Not enough resource - ret=%li ", ret); + + return ret; + } +@@ -287,7 +287,7 @@ + hcp_galpas_ctor(&cq->galpas, 0, outs[5], outs[6]); + + if (ret == H_NOT_ENOUGH_RESOURCES) +- ehca_gen_err("Not enough resources. ret=%lli", ret); ++ ehca_gen_err("Not enough resources. ret=%li", ret); + + return ret; + } +@@ -362,7 +362,7 @@ + hcp_galpas_ctor(&parms->galpas, is_user, outs[6], outs[6]); + + if (ret == H_NOT_ENOUGH_RESOURCES) +- ehca_gen_err("Not enough resources. ret=%lli", ret); ++ ehca_gen_err("Not enough resources. ret=%li", ret); + + return ret; + } +@@ -454,7 +454,7 @@ + const u64 count) + { + if (count != 1) { +- ehca_gen_err("Ppage counter=%llx", count); ++ ehca_gen_err("Ppage counter=%lx", count); + return H_PARAMETER; + } + return hipz_h_register_rpage(adapter_handle, +@@ -489,7 +489,7 @@ + const struct h_galpa gal) + { + if (count != 1) { +- ehca_gen_err("Page counter=%llx", count); ++ ehca_gen_err("Page counter=%lx", count); + return H_PARAMETER; + } + +@@ -508,7 +508,7 @@ + const struct h_galpa galpa) + { + if (count > 1) { +- ehca_gen_err("Page counter=%llx", count); ++ ehca_gen_err("Page counter=%lx", count); + return H_PARAMETER; + } + +@@ -557,7 +557,7 @@ + 0, 0, 0, 0, 0); + + if (ret == H_NOT_ENOUGH_RESOURCES) +- ehca_gen_err("Insufficient resources ret=%lli", ret); ++ ehca_gen_err("Insufficient resources ret=%li", ret); + + return ret; + } +@@ -593,7 +593,7 @@ + qp->ipz_qp_handle.handle, /* r6 */ + 0, 0, 0, 0, 0, 0); + if (ret == H_HARDWARE) +- ehca_gen_err("HCA not operational. ret=%lli", ret); ++ ehca_gen_err("HCA not operational. ret=%li", ret); + + ret = ehca_plpar_hcall_norets(H_FREE_RESOURCE, + adapter_handle.handle, /* r4 */ +@@ -601,7 +601,7 @@ + 0, 0, 0, 0, 0); + + if (ret == H_RESOURCE) +- ehca_gen_err("Resource still in use. ret=%lli", ret); ++ ehca_gen_err("Resource still in use. ret=%li", ret); + + return ret; + } +@@ -636,7 +636,7 @@ + *bma_qp_nr = (u32)outs[1]; + + if (ret == H_ALIAS_EXIST) +- ehca_gen_err("AQP1 already exists. ret=%lli", ret); ++ ehca_gen_err("AQP1 already exists. ret=%li", ret); + + return ret; + } +@@ -658,7 +658,7 @@ + 0, 0); + + if (ret == H_NOT_ENOUGH_RESOURCES) +- ehca_gen_err("Not enough resources. ret=%lli", ret); ++ ehca_gen_err("Not enough resources. ret=%li", ret); + + return ret; + } +@@ -697,7 +697,7 @@ + 0, 0, 0, 0); + + if (ret == H_RESOURCE) +- ehca_gen_err("H_FREE_RESOURCE failed ret=%lli ", ret); ++ ehca_gen_err("H_FREE_RESOURCE failed ret=%li ", ret); + + return ret; + } +@@ -719,7 +719,7 @@ + 0, 0, 0, 0, 0); + + if (ret == H_RESOURCE) +- ehca_gen_err("Resource in use. ret=%lli ", ret); ++ ehca_gen_err("Resource in use. ret=%li ", ret); + + return ret; + } +@@ -774,9 +774,9 @@ + + if ((count > 1) && (logical_address_of_page & (EHCA_PAGESIZE-1))) { + ehca_gen_err("logical_address_of_page not on a 4k boundary " +- "adapter_handle=%llx mr=%p mr_handle=%llx " ++ "adapter_handle=%lx mr=%p mr_handle=%lx " + "pagesize=%x queue_type=%x " +- "logical_address_of_page=%llx count=%llx", ++ "logical_address_of_page=%lx count=%lx", + adapter_handle.handle, mr, + mr->ipz_mr_handle.handle, pagesize, queue_type, + logical_address_of_page, count); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-060-revert_interface_change.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-060-revert_interface_change.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-060-revert_interface_change.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ehca-060-revert_interface_change.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,25 @@ +From 7ef1f7881a8f660654e7d1567213638b37adbbb5 Mon Sep 17 00:00:00 2001 +From: Stefan Roscher +Date: Wed, 6 Aug 2008 16:27:25 +0200 +Subject: [PATCH] Revert "infiniband: use performance variant for_each_cpu_mask_nr" + +This reverts commit 5d7bfd0c4d463d288422032c9903d0452dee141d. +--- + drivers/infiniband/hw/ehca/ehca_irq.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Index: ofed_kernel/drivers/infiniband/hw/ehca/ehca_irq.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/hw/ehca/ehca_irq.c ++++ ofed_kernel/drivers/infiniband/hw/ehca/ehca_irq.c +@@ -650,8 +650,8 @@ static inline int find_next_online_cpu(s + ehca_dmp(&cpu_online_map, sizeof(cpumask_t), ""); + + spin_lock_irqsave(&pool->last_cpu_lock, flags); +- cpu = next_cpu_nr(pool->last_cpu, cpu_online_map); +- if (cpu >= nr_cpu_ids) ++ cpu = next_cpu(pool->last_cpu, cpu_online_map); ++ if (cpu == NR_CPUS) + cpu = first_cpu(cpu_online_map); + pool->last_cpu = cpu; + spin_unlock_irqrestore(&pool->last_cpu_lock, flags); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0000_z2_6_28_netdevice.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0000_z2_6_28_netdevice.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0000_z2_6_28_netdevice.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0000_z2_6_28_netdevice.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,38 @@ +ipoib: undo commit fe8114e8e1d15ba07ddcaebc4741957a1546f307 + +Signed-off-by: Jack Morgenstein + +diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c +index 0bd2a4f..ca837b0 100644 +--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c ++++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c +@@ -1016,22 +1016,18 @@ static void ipoib_lro_setup(struct ipoib_dev_priv *priv) + priv->lro.lro_mgr.ip_summed_aggr = CHECKSUM_UNNECESSARY; + } + +-static const struct net_device_ops ipoib_netdev_ops = { +- .ndo_open = ipoib_open, +- .ndo_stop = ipoib_stop, +- .ndo_change_mtu = ipoib_change_mtu, +- .ndo_start_xmit = ipoib_start_xmit, +- .ndo_tx_timeout = ipoib_timeout, +- .ndo_set_multicast_list = ipoib_set_mcast_list, +- .ndo_neigh_setup = ipoib_neigh_setup_dev, +-}; +- + static void ipoib_setup(struct net_device *dev) + { + struct ipoib_dev_priv *priv = netdev_priv(dev); + ++ dev->open = ipoib_open; ++ dev->stop = ipoib_stop; ++ dev->change_mtu = ipoib_change_mtu; ++ dev->hard_start_xmit = ipoib_start_xmit; ++ dev->tx_timeout = ipoib_timeout; +- dev->netdev_ops = &ipoib_netdev_ops; + dev->header_ops = &ipoib_header_ops; ++ dev->set_multicast_list = ipoib_set_mcast_list; ++ dev->neigh_setup = ipoib_neigh_setup_dev; + + ipoib_set_ethtool_ops(dev); + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0100_to_2.6.21.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0100_to_2.6.21.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0100_to_2.6.21.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0100_to_2.6.21.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,458 @@ +Backport IPOIB to kernel 2.6.23 + +Signed-off-by: Eli Cohen + +--- + +--- + drivers/infiniband/ulp/ipoib/ipoib.h | 6 +- + drivers/infiniband/ulp/ipoib/ipoib_cm.c | 20 ++++----- + drivers/infiniband/ulp/ipoib/ipoib_ib.c | 55 +++++++++++++------------ + drivers/infiniband/ulp/ipoib/ipoib_main.c | 34 +++++---------- + drivers/infiniband/ulp/ipoib/ipoib_multicast.c | 10 ++-- + 5 files changed, 61 insertions(+), 64 deletions(-) + +Index: linux-2.6/drivers/infiniband/ulp/ipoib/ipoib.h +=================================================================== +--- linux-2.6.orig/drivers/infiniband/ulp/ipoib/ipoib.h 2009-04-16 23:35:04.000000000 +0300 ++++ linux-2.6/drivers/infiniband/ulp/ipoib/ipoib.h 2009-04-16 23:46:20.000000000 +0300 +@@ -277,8 +277,6 @@ struct ipoib_dev_priv { + + struct net_device *dev; + +- struct napi_struct napi; +- + unsigned long flags; + + struct mutex vlan_mutex; +@@ -336,6 +334,8 @@ struct ipoib_dev_priv { + + struct ib_event_handler event_handler; + ++ struct net_device_stats stats; ++ + struct net_device *parent; + struct list_head child_intfs; + struct list_head list; +@@ -423,7 +423,7 @@ extern struct workqueue_struct *ipoib_wo + + /* functions */ + +-int ipoib_poll(struct napi_struct *napi, int budget); ++int ipoib_poll(struct net_device *dev, int *budget); + void ipoib_ib_completion(struct ib_cq *cq, void *dev_ptr); + void ipoib_send_comp_handler(struct ib_cq *cq, void *dev_ptr); + +Index: linux-2.6/drivers/infiniband/ulp/ipoib/ipoib_cm.c +=================================================================== +--- linux-2.6.orig/drivers/infiniband/ulp/ipoib/ipoib_cm.c 2009-04-16 23:35:04.000000000 +0300 ++++ linux-2.6/drivers/infiniband/ulp/ipoib/ipoib_cm.c 2009-04-16 23:46:20.000000000 +0300 +@@ -593,7 +593,7 @@ void ipoib_cm_handle_rx_wc(struct net_de + ipoib_dbg(priv, "cm recv error " + "(status=%d, wrid=%d vend_err %x)\n", + wc->status, wr_id, wc->vendor_err); +- ++dev->stats.rx_dropped; ++ ++priv->stats.rx_dropped; + if (has_srq) + goto repost; + else { +@@ -646,7 +646,7 @@ void ipoib_cm_handle_rx_wc(struct net_de + * this packet and reuse the old buffer. + */ + ipoib_dbg(priv, "failed to allocate receive buffer %d\n", wr_id); +- ++dev->stats.rx_dropped; ++ ++priv->stats.rx_dropped; + goto repost; + } + +@@ -664,8 +664,8 @@ copied: + skb_pull(skb, IPOIB_ENCAP_LEN); + + dev->last_rx = jiffies; +- ++dev->stats.rx_packets; +- dev->stats.rx_bytes += skb->len; ++ ++priv->stats.rx_packets; ++ priv->stats.rx_bytes += skb->len; + + skb->dev = dev; + /* XXX get correct PACKET_ type here */ +@@ -714,8 +714,8 @@ void ipoib_cm_send(struct net_device *de + if (unlikely(skb->len > tx->mtu)) { + ipoib_warn(priv, "packet len %d (> %d) too long to send, dropping\n", + skb->len, tx->mtu); +- ++dev->stats.tx_dropped; +- ++dev->stats.tx_errors; ++ ++priv->stats.tx_dropped; ++ ++priv->stats.tx_errors; + ipoib_cm_skb_too_long(dev, skb, tx->mtu - IPOIB_ENCAP_LEN); + return; + } +@@ -734,7 +734,7 @@ void ipoib_cm_send(struct net_device *de + tx_req->skb = skb; + addr = ib_dma_map_single(priv->ca, skb->data, skb->len, DMA_TO_DEVICE); + if (unlikely(ib_dma_mapping_error(priv->ca, addr))) { +- ++dev->stats.tx_errors; ++ ++priv->stats.tx_errors; + dev_kfree_skb_any(skb); + return; + } +@@ -744,7 +744,7 @@ void ipoib_cm_send(struct net_device *de + if (unlikely(post_send(priv, tx, tx->tx_head & (ipoib_sendq_size - 1), + addr, skb->len))) { + ipoib_warn(priv, "post_send failed\n"); +- ++dev->stats.tx_errors; ++ ++priv->stats.tx_errors; + ib_dma_unmap_single(priv->ca, addr, skb->len, DMA_TO_DEVICE); + dev_kfree_skb_any(skb); + } else { +@@ -781,8 +781,8 @@ void ipoib_cm_handle_tx_wc(struct net_de + ib_dma_unmap_single(priv->ca, tx_req->mapping, tx_req->skb->len, DMA_TO_DEVICE); + + /* FIXME: is this right? Shouldn't we only increment on success? */ +- ++dev->stats.tx_packets; +- dev->stats.tx_bytes += tx_req->skb->len; ++ ++priv->stats.tx_packets; ++ priv->stats.tx_bytes += tx_req->skb->len; + + dev_kfree_skb_any(tx_req->skb); + +Index: linux-2.6/drivers/infiniband/ulp/ipoib/ipoib_ib.c +=================================================================== +--- linux-2.6.orig/drivers/infiniband/ulp/ipoib/ipoib_ib.c 2009-04-16 23:43:16.000000000 +0300 ++++ linux-2.6/drivers/infiniband/ulp/ipoib/ipoib_ib.c 2009-04-16 23:49:04.000000000 +0300 +@@ -261,7 +261,7 @@ static void ipoib_ib_handle_rx_wc(struct + * this packet and reuse the old buffer. + */ + if (unlikely(!ipoib_alloc_rx_skb(dev, wr_id))) { +- ++dev->stats.rx_dropped; ++ ++priv->stats.rx_dropped; + goto repost; + } + +@@ -278,8 +278,8 @@ static void ipoib_ib_handle_rx_wc(struct + skb_pull(skb, IPOIB_ENCAP_LEN); + + dev->last_rx = jiffies; +- ++dev->stats.rx_packets; +- dev->stats.rx_bytes += skb->len; ++ ++priv->stats.rx_packets; ++ priv->stats.rx_bytes += skb->len; + + skb->dev = dev; + /* XXX get correct PACKET_ type here */ +@@ -379,8 +379,8 @@ static void ipoib_ib_handle_tx_wc(struct + + ipoib_dma_unmap_tx(priv->ca, tx_req); + +- ++dev->stats.tx_packets; +- dev->stats.tx_bytes += tx_req->skb->len; ++ ++priv->stats.tx_packets; ++ priv->stats.tx_bytes += tx_req->skb->len; + + dev_kfree_skb_any(tx_req->skb); + +@@ -408,19 +408,19 @@ static int poll_tx(struct ipoib_dev_priv + return n == MAX_SEND_CQE; + } + +-int ipoib_poll(struct napi_struct *napi, int budget) ++int ipoib_poll(struct net_device *dev, int *budget) + { +- struct ipoib_dev_priv *priv = container_of(napi, struct ipoib_dev_priv, napi); +- struct net_device *dev = priv->dev; ++ struct ipoib_dev_priv *priv = netdev_priv(dev); ++ int max = min(*budget, dev->quota); + int done; + int t; + int n, i; ++ int ret; + + done = 0; + + poll_more: +- while (done < budget) { +- int max = (budget - done); ++ while (max) { + + t = min(IPOIB_NUM_WC, max); + n = ib_poll_cq(priv->recv_cq, t, priv->ibwc); +@@ -430,6 +430,7 @@ poll_more: + + if (wc->wr_id & IPOIB_OP_RECV) { + ++done; ++ --max; + if (wc->wr_id & IPOIB_OP_CM) + ipoib_cm_handle_rx_wc(dev, wc); + else +@@ -442,27 +443,29 @@ poll_more: + break; + } + +- if (done < budget) { ++ if (max) { + if (dev->features & NETIF_F_LRO) + lro_flush_all(&priv->lro.lro_mgr); + +- napi_complete(napi); ++ netif_rx_complete(dev); + if (unlikely(ib_req_notify_cq(priv->recv_cq, + IB_CQ_NEXT_COMP | + IB_CQ_REPORT_MISSED_EVENTS)) && +- napi_reschedule(napi)) ++ netif_rx_reschedule(dev, 0)) + goto poll_more; +- } ++ ret = 0; ++ } else ++ ret = 1; ++ ++ dev->quota -= done; ++ *budget -= done; + +- return done; ++ return ret; + } + + void ipoib_ib_completion(struct ib_cq *cq, void *dev_ptr) + { +- struct net_device *dev = dev_ptr; +- struct ipoib_dev_priv *priv = netdev_priv(dev); +- +- napi_schedule(&priv->napi); ++ netif_rx_schedule(dev_ptr); + } + + static void drain_tx_cq(struct net_device *dev) +@@ -539,8 +542,8 @@ void ipoib_send(struct net_device *dev, + phead = skb->data; + if (unlikely(!skb_pull(skb, hlen))) { + ipoib_warn(priv, "linear data too small\n"); +- ++dev->stats.tx_dropped; +- ++dev->stats.tx_errors; ++ ++priv->stats.tx_dropped; ++ ++priv->stats.tx_errors; + dev_kfree_skb_any(skb); + return; + } +@@ -548,8 +551,8 @@ void ipoib_send(struct net_device *dev, + if (unlikely(skb->len > priv->mcast_mtu + IPOIB_ENCAP_LEN)) { + ipoib_warn(priv, "packet len %d (> %d) too long to send, dropping\n", + skb->len, priv->mcast_mtu + IPOIB_ENCAP_LEN); +- ++dev->stats.tx_dropped; +- ++dev->stats.tx_errors; ++ ++priv->stats.tx_dropped; ++ ++priv->stats.tx_errors; + ipoib_cm_skb_too_long(dev, skb, priv->mcast_mtu); + return; + } +@@ -570,7 +573,7 @@ void ipoib_send(struct net_device *dev, + tx_req = &priv->tx_ring[priv->tx_head & (ipoib_sendq_size - 1)]; + tx_req->skb = skb; + if (unlikely(ipoib_dma_map_tx(priv->ca, tx_req))) { +- ++dev->stats.tx_errors; ++ ++priv->stats.tx_errors; + dev_kfree_skb_any(skb); + return; + } +@@ -590,7 +593,7 @@ void ipoib_send(struct net_device *dev, + if (unlikely(post_send(priv, priv->tx_head & (ipoib_sendq_size - 1), + address->ah, qpn, tx_req, phead, hlen))) { + ipoib_warn(priv, "post_send failed\n"); +- ++dev->stats.tx_errors; ++ ++priv->stats.tx_errors; + --priv->tx_outstanding; + ipoib_dma_unmap_tx(priv->ca, tx_req); + dev_kfree_skb_any(skb); +@@ -708,8 +711,7 @@ int ipoib_ib_dev_open(struct net_device + queue_delayed_work(ipoib_workqueue, &priv->ah_reap_task, + round_jiffies_relative(HZ)); + +- if (!test_and_set_bit(IPOIB_FLAG_INITIALIZED, &priv->flags)) +- napi_enable(&priv->napi); ++ set_bit(IPOIB_FLAG_INITIALIZED, &priv->flags); + + return 0; + } +@@ -828,8 +830,8 @@ int ipoib_ib_dev_stop(struct net_device + struct ipoib_tx_buf *tx_req; + int i; + +- if (test_and_clear_bit(IPOIB_FLAG_INITIALIZED, &priv->flags)) +- napi_disable(&priv->napi); ++ clear_bit(IPOIB_FLAG_INITIALIZED, &priv->flags); ++ netif_poll_disable(dev); + + ipoib_cm_dev_stop(dev); + +@@ -903,6 +905,7 @@ timeout: + + ipoib_ah_dev_cleanup(dev); + ++ netif_poll_enable(dev); + ib_req_notify_cq(priv->recv_cq, IB_CQ_NEXT_COMP); + + return 0; +Index: linux-2.6/drivers/infiniband/ulp/ipoib/ipoib_main.c +=================================================================== +--- linux-2.6.orig/drivers/infiniband/ulp/ipoib/ipoib_main.c 2009-04-16 23:44:02.000000000 +0300 ++++ linux-2.6/drivers/infiniband/ulp/ipoib/ipoib_main.c 2009-04-16 23:46:20.000000000 +0300 +@@ -585,7 +585,7 @@ static void neigh_add_path(struct sk_buf + + neigh = ipoib_neigh_alloc(skb->dst->neighbour, skb->dev); + if (!neigh) { +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb); + return; + } +@@ -646,7 +646,7 @@ err_list: + err_path: + ipoib_neigh_free(dev, neigh); + err_drop: +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb); + + spin_unlock_irqrestore(&priv->lock, flags); +@@ -697,7 +697,7 @@ static void unicast_arp_send(struct sk_b + } else + __path_add(dev, path); + } else { +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb); + } + +@@ -716,7 +716,7 @@ static void unicast_arp_send(struct sk_b + skb_push(skb, sizeof *phdr); + __skb_queue_tail(&path->queue, skb); + } else { +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb); + } + +@@ -773,7 +773,7 @@ static int ipoib_start_xmit(struct sk_bu + __skb_queue_tail(&neigh->queue, skb); + spin_unlock_irqrestore(&priv->lock, flags); + } else { +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb); + } + } else { +@@ -799,7 +799,7 @@ static int ipoib_start_xmit(struct sk_bu + IPOIB_QPN(phdr->hwaddr), + phdr->hwaddr + 4); + dev_kfree_skb_any(skb); +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + return NETDEV_TX_OK; + } + +@@ -825,7 +825,7 @@ static void ipoib_timeout(struct net_dev + static int ipoib_hard_header(struct sk_buff *skb, + struct net_device *dev, + unsigned short type, +- const void *daddr, const void *saddr, unsigned len) ++ void *daddr, void *saddr, unsigned len) + { + struct ipoib_header *header; + +@@ -914,9 +914,10 @@ struct ipoib_neigh *ipoib_neigh_alloc(st + void ipoib_neigh_free(struct net_device *dev, struct ipoib_neigh *neigh) + { + struct sk_buff *skb; ++ struct ipoib_dev_priv *priv = netdev_priv(dev); + *to_ipoib_neigh(neigh->neighbour) = NULL; + while ((skb = __skb_dequeue(&neigh->queue))) { +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb); + } + if (ipoib_cm_get(neigh)) +@@ -991,10 +992,6 @@ void ipoib_dev_cleanup(struct net_device + priv->tx_ring = NULL; + } + +-static const struct header_ops ipoib_header_ops = { +- .create = ipoib_hard_header, +-}; +- + static int get_skb_hdr(struct sk_buff *skb, void **iphdr, + void **tcph, u64 *hdr_flags, void *priv) + { +@@ -1052,13 +1049,13 @@ static void ipoib_setup(struct net_devic + dev->change_mtu = ipoib_change_mtu; + dev->hard_start_xmit = ipoib_start_xmit; + dev->tx_timeout = ipoib_timeout; +- dev->header_ops = &ipoib_header_ops; ++ dev->hard_header = ipoib_hard_header; + dev->set_multicast_list = ipoib_set_mcast_list; + dev->neigh_setup = ipoib_neigh_setup_dev; +- + ipoib_set_ethtool_ops(dev); ++ dev->poll = ipoib_poll; ++ dev->weight = 100; + +- netif_napi_add(dev, &priv->napi, ipoib_poll, 100); + + dev->watchdog_timeo = HZ; + +Index: linux-2.6/drivers/infiniband/ulp/ipoib/ipoib_multicast.c +=================================================================== +--- linux-2.6.orig/drivers/infiniband/ulp/ipoib/ipoib_multicast.c 2009-04-16 23:35:04.000000000 +0300 ++++ linux-2.6/drivers/infiniband/ulp/ipoib/ipoib_multicast.c 2009-04-16 23:46:20.000000000 +0300 +@@ -100,7 +100,7 @@ static void ipoib_mcast_free(struct ipoi + } + + netif_tx_lock_bh(dev); +- dev->stats.tx_dropped += tx_dropped; ++ priv->stats.tx_dropped += tx_dropped; + netif_tx_unlock_bh(dev); + + kfree(mcast); +@@ -285,6 +285,7 @@ ipoib_mcast_sendonly_join_complete(int s + { + struct ipoib_mcast *mcast = multicast->context; + struct net_device *dev = mcast->dev; ++ struct ipoib_dev_priv *priv = netdev_priv(dev); + + /* We trap for port events ourselves. */ + if (status == -ENETRESET) +@@ -302,7 +303,7 @@ ipoib_mcast_sendonly_join_complete(int s + /* Flush out any queued packets */ + netif_tx_lock_bh(dev); + while (!skb_queue_empty(&mcast->pkt_queue)) { +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb_dequeue(&mcast->pkt_queue)); + } + netif_tx_unlock_bh(dev); +@@ -677,7 +678,7 @@ void ipoib_mcast_send(struct net_device + if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags) || + !priv->broadcast || + !test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) { +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb); + goto unlock; + } +@@ -692,7 +693,7 @@ void ipoib_mcast_send(struct net_device + if (!mcast) { + ipoib_warn(priv, "unable to allocate memory for " + "multicast structure\n"); +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb); + goto out; + } +@@ -707,7 +708,7 @@ void ipoib_mcast_send(struct net_device + if (skb_queue_len(&mcast->pkt_queue) < IPOIB_MAX_MCAST_QUEUE) + skb_queue_tail(&mcast->pkt_queue, skb); + else { +- ++dev->stats.tx_dropped; ++ ++priv->stats.tx_dropped; + dev_kfree_skb_any(skb); + } + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0110_restore_get_stats.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0110_restore_get_stats.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0110_restore_get_stats.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0110_restore_get_stats.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,30 @@ +--- + drivers/infiniband/ulp/ipoib/ipoib_main.c | 8 ++++++++ + 1 file changed, 8 insertions(+) + +Index: ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_main.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/ipoib/ipoib_main.c ++++ ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_main.c +@@ -813,6 +813,13 @@ out: + return NETDEV_TX_OK; + } + ++static struct net_device_stats *ipoib_get_stats(struct net_device *dev) ++{ ++ struct ipoib_dev_priv *priv = netdev_priv(dev); ++ ++ return &priv->stats; ++} ++ + static void ipoib_timeout(struct net_device *dev) + { + struct ipoib_dev_priv *priv = netdev_priv(dev); +@@ -1051,6 +1058,7 @@ static void ipoib_setup(struct net_devic + dev->stop = ipoib_stop; + dev->change_mtu = ipoib_change_mtu; + dev->hard_start_xmit = ipoib_start_xmit; ++ dev->get_stats = ipoib_get_stats; + dev->tx_timeout = ipoib_timeout; + dev->hard_header = ipoib_hard_header; + dev->set_multicast_list = ipoib_set_mcast_list; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0500_warnings_ipoib_fs_to_2_6_19.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0500_warnings_ipoib_fs_to_2_6_19.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0500_warnings_ipoib_fs_to_2_6_19.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0500_warnings_ipoib_fs_to_2_6_19.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,26 @@ +--- + drivers/infiniband/ulp/ipoib/ipoib_fs.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Index: ofa_kernel-1.4/drivers/infiniband/ulp/ipoib/ipoib_fs.c +=================================================================== +--- ofa_kernel-1.4.orig/drivers/infiniband/ulp/ipoib/ipoib_fs.c ++++ ofa_kernel-1.4/drivers/infiniband/ulp/ipoib/ipoib_fs.c +@@ -134,7 +134,7 @@ static int ipoib_mcg_open(struct inode * + struct seq_file *seq; + int ret; + +- ret = seq_open(file, &ipoib_mcg_seq_ops); ++ ret = seq_open(file, (struct seq_operations *) &ipoib_mcg_seq_ops); + if (ret) + return ret; + +@@ -240,7 +240,7 @@ static int ipoib_path_open(struct inode + struct seq_file *seq; + int ret; + +- ret = seq_open(file, &ipoib_path_seq_ops); ++ ret = seq_open(file, (struct seq_operations *) &ipoib_path_seq_ops); + if (ret) + return ret; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0900_netif_lock_to_2_6_26.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0900_netif_lock_to_2_6_26.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0900_netif_lock_to_2_6_26.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0900_netif_lock_to_2_6_26.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,26 @@ +--- + drivers/infiniband/ulp/ipoib/ipoib_multicast.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +Index: ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_multicast.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/ipoib/ipoib_multicast.c ++++ ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_multicast.c +@@ -777,7 +777,7 @@ void ipoib_mcast_restart_task(struct wor + ipoib_mcast_stop_thread(dev, 0); + + local_irq_save(flags); +- netif_addr_lock(dev); ++ netif_tx_lock(dev); + spin_lock(&priv->lock); + + /* +@@ -854,7 +854,7 @@ void ipoib_mcast_restart_task(struct wor + } + + spin_unlock(&priv->lock); +- netif_addr_unlock(dev); ++ netif_tx_unlock(dev); + local_irq_restore(flags); + + /* We have to cancel outside of the spinlock */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0910_show_dev_id_2.6.20.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0910_show_dev_id_2.6.20.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0910_show_dev_id_2.6.20.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_0910_show_dev_id_2.6.20.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,27 @@ +Index: ofa_1_5_dev_kernel-20100831-1137_linux-2.6.20_check/drivers/infiniband/ulp/ipoib/ipoib_main.c +=================================================================== +--- ofa_1_5_dev_kernel-20100831-1137_linux-2.6.20_check.orig/drivers/infiniband/ulp/ipoib/ipoib_main.c 2010-08-31 11:45:06.000000000 +0300 ++++ ofa_1_5_dev_kernel-20100831-1137_linux-2.6.20_check/drivers/infiniband/ulp/ipoib/ipoib_main.c 2010-08-31 12:14:39.000000000 +0300 +@@ -1126,6 +1126,12 @@ struct ipoib_dev_priv *ipoib_intf_alloc( + return netdev_priv(dev); + } + ++static ssize_t show_dev_id(struct class_device *d, char *buf) ++{ ++ return sprintf(buf, "%d\n", to_net_dev(d)->dev_id); ++} ++static CLASS_DEVICE_ATTR(dev_id, S_IRUGO, show_dev_id, NULL); ++ + static ssize_t show_pkey(struct device *dev, + struct device_attribute *attr, char *buf) + { +@@ -1343,6 +1349,9 @@ static struct net_device *ipoib_add_port + goto sysfs_failed; + if (device_create_file(&priv->dev->dev, &dev_attr_delete_child)) + goto sysfs_failed; ++ if (class_device_create_file(&priv->dev->class_dev, ++ &class_device_attr_dev_id)) ++ goto sysfs_failed; + + return priv->dev; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_class_device_to_2_6_20.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_class_device_to_2_6_20.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_class_device_to_2_6_20.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_class_device_to_2_6_20.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,186 @@ +Revert the following patch: + +commit 43cb76d91ee85f579a69d42bc8efc08bac560278 +Author: Greg Kroah-Hartman +Date: Tue Apr 9 12:14:34 2002 -0700 + + Network: convert network devices to use struct device instead of class_device + + This lets the network core have the ability to handle suspend/resume + issues, if it wants to. + + Thanks to Frederik Deweerdt for the arm + driver fixes. + + Signed-off-by: Greg Kroah-Hartman + +--- + drivers/infiniband/ulp/ipoib/ipoib_cm.c | 13 ++++++------- + drivers/infiniband/ulp/ipoib/ipoib_main.c | 26 ++++++++++++++------------ + drivers/infiniband/ulp/ipoib/ipoib_vlan.c | 10 ++++++---- + 3 files changed, 26 insertions(+), 23 deletions(-) + +Index: ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_cm.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/ipoib/ipoib_cm.c ++++ ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_cm.c +@@ -47,6 +47,8 @@ MODULE_PARM_DESC(max_nonsrq_conn_qp, + "Max number of connected-mode QPs per interface " + "(applied only if shared receive queue is not available)"); + ++#define to_net_dev(class) container_of(class, struct net_device, class_dev) ++ + #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG_DATA + static int data_debug_level; + +@@ -1433,9 +1435,7 @@ static void ipoib_cm_stale_task(struct w + spin_unlock_irq(&priv->lock); + } + +- +-static ssize_t show_mode(struct device *d, struct device_attribute *attr, +- char *buf) ++static ssize_t show_mode(struct class_device *d, char *buf) + { + struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(d)); + +@@ -1445,8 +1445,7 @@ static ssize_t show_mode(struct device * + return sprintf(buf, "datagram\n"); + } + +-static ssize_t set_mode(struct device *d, struct device_attribute *attr, +- const char *buf, size_t count) ++static ssize_t set_mode(struct class_device *d, const char *buf, size_t count) + { + struct net_device *dev = to_net_dev(d); + struct ipoib_dev_priv *priv = netdev_priv(dev); +@@ -1490,11 +1489,11 @@ static ssize_t set_mode(struct device *d + return -EINVAL; + } + +-static DEVICE_ATTR(mode, S_IWUSR | S_IRUGO, show_mode, set_mode); ++static CLASS_DEVICE_ATTR(mode, S_IWUSR | S_IRUGO, show_mode, set_mode); + + int ipoib_cm_add_mode_attr(struct net_device *dev) + { +- return device_create_file(&dev->dev, &dev_attr_mode); ++ return class_device_create_file(&dev->class_dev, &class_device_attr_mode); + } + + static void ipoib_cm_create_srq(struct net_device *dev, int max_sge) +Index: ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_main.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/ipoib/ipoib_main.c ++++ ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_main.c +@@ -100,6 +100,8 @@ static struct ib_client ipoib_client = { + .remove = ipoib_remove_one + }; + ++#define to_net_dev(class) container_of(class, struct net_device, class_dev) ++ + int ipoib_open(struct net_device *dev) + { + struct ipoib_dev_priv *priv = netdev_priv(dev); +@@ -1123,14 +1125,13 @@ struct ipoib_dev_priv *ipoib_intf_alloc( + return netdev_priv(dev); + } + +-static ssize_t show_pkey(struct device *dev, +- struct device_attribute *attr, char *buf) ++static ssize_t show_pkey(struct class_device *dev, char *buf) + { + struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev)); + + return sprintf(buf, "0x%04x\n", priv->pkey); + } +-static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); ++static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); + + static ssize_t show_umcast(struct device *dev, + struct device_attribute *attr, char *buf) +@@ -1163,8 +1164,7 @@ int ipoib_add_umcast_attr(struct net_dev + return device_create_file(&dev->dev, &dev_attr_umcast); + } + +-static ssize_t create_child(struct device *dev, +- struct device_attribute *attr, ++static ssize_t create_child(struct class_device *dev, + const char *buf, size_t count) + { + int pkey; +@@ -1186,10 +1186,9 @@ static ssize_t create_child(struct devic + + return ret ? ret : count; + } +-static DEVICE_ATTR(create_child, S_IWUGO, NULL, create_child); ++static CLASS_DEVICE_ATTR(create_child, S_IWUGO, NULL, create_child); + +-static ssize_t delete_child(struct device *dev, +- struct device_attribute *attr, ++static ssize_t delete_child(struct class_device *dev, + const char *buf, size_t count) + { + int pkey; +@@ -1206,11 +1205,12 @@ static ssize_t delete_child(struct devic + return ret ? ret : count; + + } +-static DEVICE_ATTR(delete_child, S_IWUGO, NULL, delete_child); ++static CLASS_DEVICE_ATTR(delete_child, S_IWUGO, NULL, delete_child); + + int ipoib_add_pkey_attr(struct net_device *dev) + { +- return device_create_file(&dev->dev, &dev_attr_pkey); ++ return class_device_create_file(&dev->class_dev, ++ &class_device_attr_pkey); + } + + static struct net_device *ipoib_add_port(const char *format, +@@ -1324,9 +1324,11 @@ static struct net_device *ipoib_add_port + goto sysfs_failed; + if (ipoib_add_umcast_attr(priv->dev)) + goto sysfs_failed; +- if (device_create_file(&priv->dev->dev, &dev_attr_create_child)) ++ if (class_device_create_file(&priv->dev->class_dev, ++ &class_device_attr_create_child)) + goto sysfs_failed; +- if (device_create_file(&priv->dev->dev, &dev_attr_delete_child)) ++ if (class_device_create_file(&priv->dev->class_dev, ++ &class_device_attr_delete_child)) + goto sysfs_failed; + + return priv->dev; +Index: ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_vlan.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/ipoib/ipoib_vlan.c ++++ ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_vlan.c +@@ -40,15 +40,16 @@ + + #include "ipoib.h" + +-static ssize_t show_parent(struct device *d, struct device_attribute *attr, +- char *buf) ++#define to_net_dev(class) container_of(class, struct net_device, class_dev) ++ ++static ssize_t show_parent(struct class_device *d, char *buf) + { + struct net_device *dev = to_net_dev(d); + struct ipoib_dev_priv *priv = netdev_priv(dev); + + return sprintf(buf, "%s\n", priv->parent->name); + } +-static DEVICE_ATTR(parent, S_IRUGO, show_parent, NULL); ++static CLASS_DEVICE_ATTR(parent, S_IRUGO, show_parent, NULL); + + int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey) + { +@@ -124,7 +125,8 @@ int ipoib_vlan_add(struct net_device *pd + if (ipoib_add_umcast_attr(priv->dev)) + goto sysfs_failed; + +- if (device_create_file(&priv->dev->dev, &dev_attr_parent)) ++ if (class_device_create_file(&priv->dev->class_dev, ++ &class_device_attr_parent)) + goto sysfs_failed; + + list_add_tail(&priv->list, &ppriv->child_intfs); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_class_device_to_2_6_20_umcast.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_class_device_to_2_6_20_umcast.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_class_device_to_2_6_20_umcast.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_class_device_to_2_6_20_umcast.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,54 @@ +This patch is the buddy of ipoib_class_device_to_2_6_20.patch, namely it handles +the same issue in the same method for the /sys/class/net/$dev/umcast sysfs entry + +Hence it needs to go to all the directories under kernel_patches/backport that +contain the ipoib_class_device_to_2_6_20.patch + +--- + +backport kernel_patches/fixes/zzz_ipoib_allow_umcast.patch to older kernels + +Signed-off-by: Or Gerlitz + +--- + drivers/infiniband/ulp/ipoib/ipoib_main.c | 11 +++++------ + 1 file changed, 5 insertions(+), 6 deletions(-) + +Index: ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_main.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/ipoib/ipoib_main.c ++++ ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_main.c +@@ -1133,16 +1133,14 @@ static ssize_t show_pkey(struct class_de + } + static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); + +-static ssize_t show_umcast(struct device *dev, +- struct device_attribute *attr, char *buf) ++static ssize_t show_umcast(struct class_device *dev, char *buf) + { + struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev)); + + return sprintf(buf, "%d\n", test_bit(IPOIB_FLAG_UMCAST, &priv->flags)); + } + +-static ssize_t set_umcast(struct device *dev, +- struct device_attribute *attr, ++static ssize_t set_umcast(struct class_device *dev, + const char *buf, size_t count) + { + struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev)); +@@ -1157,11 +1155,12 @@ static ssize_t set_umcast(struct device + + return count; + } +-static DEVICE_ATTR(umcast, S_IWUSR | S_IRUGO, show_umcast, set_umcast); ++static CLASS_DEVICE_ATTR(umcast, S_IWUSR | S_IRUGO, show_umcast, set_umcast); + + int ipoib_add_umcast_attr(struct net_device *dev) + { +- return device_create_file(&dev->dev, &dev_attr_umcast); ++ return class_device_create_file(&dev->class_dev, ++ &class_device_attr_umcast); + } + + static ssize_t create_child(struct class_device *dev, diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_lro_to_2.6.23.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_lro_to_2.6.23.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_lro_to_2.6.23.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_lro_to_2.6.23.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,33 @@ +Index: ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_ethtool.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/ipoib/ipoib_ethtool.c ++++ ofed_kernel/drivers/infiniband/ulp/ipoib/ipoib_ethtool.c +@@ -100,14 +100,9 @@ static void ipoib_get_strings(struct net + } + } + +-static int ipoib_get_sset_count(struct net_device *dev, int sset) ++static int ipoib_get_stats_count(struct net_device *dev) + { +- switch (sset) { +- case ETH_SS_STATS: +- return ARRAY_SIZE(ipoib_stats_keys); +- default: +- return -EOPNOTSUPP; +- } ++ return ARRAY_SIZE(ipoib_stats_keys); + } + + static void ipoib_get_ethtool_stats(struct net_device *dev, +@@ -132,10 +127,8 @@ static const struct ethtool_ops ipoib_et + .get_tso = ethtool_op_get_tso, + .get_coalesce = ipoib_get_coalesce, + .set_coalesce = ipoib_set_coalesce, +- .get_flags = ethtool_op_get_flags, +- .set_flags = ethtool_op_set_flags, + .get_strings = ipoib_get_strings, +- .get_sset_count = ipoib_get_sset_count, ++ .get_stats_count = ipoib_get_stats_count, + .get_ethtool_stats = ipoib_get_ethtool_stats, + }; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_mcast_set_pkey_to_2_6_24.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_mcast_set_pkey_to_2_6_24.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_mcast_set_pkey_to_2_6_24.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_mcast_set_pkey_to_2_6_24.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,34 @@ +--- + drivers/infiniband/ulp/ipoib/ipoib_multicast.c | 4 ++++ + 1 file changed, 4 insertions(+) + +Index: ofed_kernel-2.6.24/drivers/infiniband/ulp/ipoib/ipoib_multicast.c +=================================================================== +--- ofed_kernel-2.6.24.orig/drivers/infiniband/ulp/ipoib/ipoib_multicast.c 2010-03-11 10:12:12.000000000 +0200 ++++ ofed_kernel-2.6.24/drivers/infiniband/ulp/ipoib/ipoib_multicast.c 2010-03-11 10:27:00.000000000 +0200 +@@ -778,10 +778,10 @@ static int ipoib_mcast_addr_is_valid(con + if (addrlen != INFINIBAND_ALEN) + return 0; + /* reserved QPN, prefix, scope */ +- if (memcmp(addr, broadcast, 6)) ++ if (memcmp(addr, broadcast, 5)) + return 0; +- /* signature lower, pkey */ +- if (memcmp(addr + 7, broadcast + 7, 3)) ++ /* signature lower */ ++ if (addr[7] != broadcast[7]) + return 0; + return 1; + } +@@ -826,6 +826,11 @@ void ipoib_mcast_restart_task(struct wor + + memcpy(mgid.raw, mclist->dmi_addr + 4, sizeof mgid); + ++ /* update scope */ ++ mgid.raw[1] = 0x10 | (dev->broadcast[5] & 0xF); ++ /* Add in the P_Key */ ++ mgid.raw[4] = dev->broadcast[8]; ++ mgid.raw[5] = dev->broadcast[9]; + mcast = __ipoib_mcast_find(dev, &mgid); + if (!mcast || test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { + struct ipoib_mcast *nmcast; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_undo_pI6.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_undo_pI6.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_undo_pI6.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_undo_pI6.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,306 @@ +ipoib: Undo %pI6 for printing gids + +(commit 8867cd7c8678ff2d9d0382dbbfbcc7a3e7e61cbc) + +Signed-off-by: Jack Morgenstein + +Index: ofed_kernel-2.6.28/drivers/infiniband/ulp/ipoib/ipoib_cm.c +=================================================================== +--- ofed_kernel-2.6.28.orig/drivers/infiniband/ulp/ipoib/ipoib_cm.c 2009-07-20 15:39:58.000000000 +0300 ++++ ofed_kernel-2.6.28/drivers/infiniband/ulp/ipoib/ipoib_cm.c 2009-07-20 16:03:30.000000000 +0300 +@@ -1128,8 +1128,8 @@ static int ipoib_cm_tx_init(struct ipoib + goto err_send_cm; + } + +- ipoib_dbg(priv, "Request connection 0x%x for gid %pI6 qpn 0x%x\n", +- p->qp->qp_num, pathrec->dgid.raw, qpn); ++ ipoib_dbg(priv, "Request connection 0x%x for gid " IPOIB_GID_FMT " qpn 0x%x\n", ++ p->qp->qp_num, IPOIB_GID_ARG(pathrec->dgid), qpn); + + return 0; + +@@ -1276,8 +1276,8 @@ void ipoib_cm_destroy_tx(struct ipoib_cm + if (test_and_clear_bit(IPOIB_FLAG_INITIALIZED, &tx->flags)) { + list_move(&tx->list, &priv->cm.reap_list); + queue_work(ipoib_workqueue, &priv->cm.reap_task); +- ipoib_dbg(priv, "Reap connection for gid %pI6\n", +- tx->neigh->dgid.raw); ++ ipoib_dbg(priv, "Reap connection for gid " IPOIB_GID_FMT "\n", ++ IPOIB_GID_ARG(tx->neigh->dgid)); + tx->neigh = NULL; + } + } +Index: ofed_kernel-2.6.28/drivers/infiniband/ulp/ipoib/ipoib_main.c +=================================================================== +--- ofed_kernel-2.6.28.orig/drivers/infiniband/ulp/ipoib/ipoib_main.c 2009-07-20 15:40:07.000000000 +0300 ++++ ofed_kernel-2.6.28/drivers/infiniband/ulp/ipoib/ipoib_main.c 2009-07-20 16:03:30.000000000 +0300 +@@ -362,9 +362,9 @@ void ipoib_mark_paths_invalid(struct net + spin_lock_irq(&priv->lock); + + list_for_each_entry_safe(path, tp, &priv->path_list, list) { +- ipoib_dbg(priv, "mark path LID 0x%04x GID %pI6 invalid\n", ++ ipoib_dbg(priv, "mark path LID 0x%04x GID " IPOIB_GID_FMT " invalid\n", + be16_to_cpu(path->pathrec.dlid), +- path->pathrec.dgid.raw); ++ IPOIB_GID_ARG(path->pathrec.dgid)); + path->valid = 0; + } + +@@ -416,11 +416,11 @@ static void path_rec_completion(int stat + unsigned long flags; + + if (!status) +- ipoib_dbg(priv, "PathRec LID 0x%04x for GID %pI6\n", +- be16_to_cpu(pathrec->dlid), pathrec->dgid.raw); ++ ipoib_dbg(priv, "PathRec LID 0x%04x for GID " IPOIB_GID_FMT "\n", ++ be16_to_cpu(pathrec->dlid), IPOIB_GID_ARG(pathrec->dgid)); + else +- ipoib_dbg(priv, "PathRec status %d for GID %pI6\n", +- status, path->pathrec.dgid.raw); ++ ipoib_dbg(priv, "PathRec status %d for GID " IPOIB_GID_FMT "\n", ++ status, IPOIB_GID_ARG(path->pathrec.dgid)); + + skb_queue_head_init(&skqueue); + +@@ -555,8 +555,8 @@ static int path_rec_start(struct net_dev + p_rec.mtu_selector = 0; + } + +- ipoib_dbg(priv, "Start path record lookup for %pI6 MTU > %d\n", +- p_rec.dgid.raw, ++ ipoib_dbg(priv, "Start path record lookup for " IPOIB_GID_FMT " > %d\n", ++ IPOIB_GID_ARG(p_rec.dgid), + comp_mask ? ib_mtu_enum_to_int(p_rec.mtu) : 0); + + init_completion(&path->done); +@@ -799,11 +799,12 @@ static int ipoib_start_xmit(struct sk_bu + + if ((be16_to_cpup((__be16 *) skb->data) != ETH_P_ARP) && + (be16_to_cpup((__be16 *) skb->data) != ETH_P_RARP)) { +- ipoib_warn(priv, "Unicast, no %s: type %04x, QPN %06x %pI6\n", ++ ipoib_warn(priv, "Unicast, no %s: type %04x, QPN %06x " ++ IPOIB_GID_FMT "\n", + skb->dst ? "neigh" : "dst", + be16_to_cpup((__be16 *) skb->data), + IPOIB_QPN(phdr->hwaddr), +- phdr->hwaddr + 4); ++ IPOIB_GID_RAW_ARG(phdr->hwaddr + 4)); + dev_kfree_skb_any(skb); + ++dev->stats.tx_dropped; + return NETDEV_TX_OK; +@@ -882,9 +883,9 @@ static void ipoib_neigh_cleanup(struct n + else + return; + ipoib_dbg(priv, +- "neigh_cleanup for %06x %pI6\n", ++ "neigh_cleanup for %06x " IPOIB_GID_FMT "\n", + IPOIB_QPN(n->ha), +- n->ha + 4); ++ IPOIB_GID_RAW_ARG(n->ha + 4)); + + spin_lock_irqsave(&priv->lock, flags); + +Index: ofed_kernel-2.6.28/drivers/infiniband/ulp/ipoib/ipoib_multicast.c +=================================================================== +--- ofed_kernel-2.6.28.orig/drivers/infiniband/ulp/ipoib/ipoib_multicast.c 2009-07-20 15:39:58.000000000 +0300 ++++ ofed_kernel-2.6.28/drivers/infiniband/ulp/ipoib/ipoib_multicast.c 2009-07-20 16:03:30.000000000 +0300 +@@ -71,8 +71,9 @@ static void ipoib_mcast_free(struct ipoi + struct ipoib_neigh *neigh, *tmp; + int tx_dropped = 0; + +- ipoib_dbg_mcast(netdev_priv(dev), "deleting multicast group %pI6\n", +- mcast->mcmember.mgid.raw); ++ ipoib_dbg_mcast(netdev_priv(dev), ++ "deleting multicast group " IPOIB_GID_FMT "\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid)); + + spin_lock_irq(&priv->lock); + +@@ -204,8 +205,9 @@ static int ipoib_mcast_join_finish(struc + + if (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { + if (test_and_set_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags)) { +- ipoib_warn(priv, "multicast group %pI6 already attached\n", +- mcast->mcmember.mgid.raw); ++ ipoib_warn(priv, "multicast group " IPOIB_GID_FMT ++ " already attached\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid)); + + return 0; + } +@@ -213,8 +215,9 @@ static int ipoib_mcast_join_finish(struc + ret = ipoib_mcast_attach(dev, be16_to_cpu(mcast->mcmember.mlid), + &mcast->mcmember.mgid, set_qkey); + if (ret < 0) { +- ipoib_warn(priv, "couldn't attach QP to multicast group %pI6\n", +- mcast->mcmember.mgid.raw); ++ ipoib_warn(priv, "couldn't attach QP to multicast group " ++ IPOIB_GID_FMT "\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid)); + + clear_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags); + return ret; +@@ -245,8 +248,9 @@ static int ipoib_mcast_join_finish(struc + mcast->ah = ah; + spin_unlock_irq(&priv->lock); + +- ipoib_dbg_mcast(priv, "MGID %pI6 AV %p, LID 0x%04x, SL %d\n", +- mcast->mcmember.mgid.raw, ++ ipoib_dbg_mcast(priv, "MGID " IPOIB_GID_FMT ++ " AV %p, LID 0x%04x, SL %d\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid), + mcast->ah->ah, + be16_to_cpu(mcast->mcmember.mlid), + mcast->mcmember.sl); +@@ -291,8 +295,9 @@ ipoib_mcast_sendonly_join_complete(int s + + if (status) { + if (mcast->logcount++ < 20) +- ipoib_dbg_mcast(netdev_priv(dev), "multicast join failed for %pI6, status %d\n", +- mcast->mcmember.mgid.raw, status); ++ ipoib_dbg_mcast(netdev_priv(dev), "multicast join failed for " ++ IPOIB_GID_FMT ", status %d\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid), status); + + /* Flush out any queued packets */ + netif_tx_lock_bh(dev); +@@ -351,8 +356,9 @@ static int ipoib_mcast_sendonly_join(str + ipoib_warn(priv, "ib_sa_join_multicast failed (ret = %d)\n", + ret); + } else { +- ipoib_dbg_mcast(priv, "no multicast record for %pI6, starting join\n", +- mcast->mcmember.mgid.raw); ++ ipoib_dbg_mcast(priv, "no multicast record for " IPOIB_GID_FMT ++ ", starting join\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid)); + } + + return ret; +@@ -380,8 +386,9 @@ static int ipoib_mcast_join_complete(int + struct net_device *dev = mcast->dev; + struct ipoib_dev_priv *priv = netdev_priv(dev); + +- ipoib_dbg_mcast(priv, "join completion for %pI6 (status %d)\n", +- mcast->mcmember.mgid.raw, status); ++ ipoib_dbg_mcast(priv, "join completion for " IPOIB_GID_FMT ++ " (status %d)\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid), status); + + /* We trap for port events ourselves. */ + if (status == -ENETRESET) +@@ -410,11 +417,15 @@ static int ipoib_mcast_join_complete(int + + if (mcast->logcount++ < 20) { + if (status == -ETIMEDOUT || status == -EAGAIN) { +- ipoib_dbg_mcast(priv, "multicast join failed for %pI6, status %d\n", +- mcast->mcmember.mgid.raw, status); ++ ipoib_dbg_mcast(priv, "multicast join failed for " IPOIB_GID_FMT ++ ", status %d\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid), ++ status); + } else { +- ipoib_warn(priv, "multicast join failed for %pI6, status %d\n", +- mcast->mcmember.mgid.raw, status); ++ ipoib_warn(priv, "multicast join failed for " ++ IPOIB_GID_FMT ", status %d\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid), ++ status); + } + } + +@@ -446,7 +457,8 @@ static void ipoib_mcast_join(struct net_ + ib_sa_comp_mask comp_mask; + int ret = 0; + +- ipoib_dbg_mcast(priv, "joining MGID %pI6\n", mcast->mcmember.mgid.raw); ++ ipoib_dbg_mcast(priv, "joining MGID " IPOIB_GID_FMT "\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid)); + + rec.mgid = mcast->mcmember.mgid; + rec.port_gid = priv->local_gid; +@@ -641,8 +653,8 @@ static int ipoib_mcast_leave(struct net_ + ib_sa_free_multicast(mcast->mc); + + if (test_and_clear_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags)) { +- ipoib_dbg_mcast(priv, "leaving MGID %pI6\n", +- mcast->mcmember.mgid.raw); ++ ipoib_dbg_mcast(priv, "leaving MGID " IPOIB_GID_FMT "\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid)); + + /* Remove ourselves from the multicast group */ + ret = ib_detach_mcast(priv->qp, &mcast->mcmember.mgid, +@@ -673,8 +685,8 @@ void ipoib_mcast_send(struct net_device + mcast = __ipoib_mcast_find(dev, mgid); + if (!mcast) { + /* Let's create a new send only group now */ +- ipoib_dbg_mcast(priv, "setting up send only multicast group for %pI6\n", +- mgid); ++ ipoib_dbg_mcast(priv, "setting up send only multicast group for " ++ IPOIB_GID_FMT "\n", IPOIB_GID_RAW_ARG(mgid)); + + mcast = ipoib_mcast_alloc(dev, 0); + if (!mcast) { +@@ -807,14 +819,14 @@ void ipoib_mcast_restart_task(struct wor + /* ignore group which is directly joined by userspace */ + if (test_bit(IPOIB_FLAG_UMCAST, &priv->flags) && + !ib_sa_get_mcmember_rec(priv->ca, priv->port, &mgid, &rec)) { +- ipoib_dbg_mcast(priv, "ignoring multicast entry for mgid %pI6\n", +- mgid.raw); ++ ipoib_dbg_mcast(priv, "ignoring multicast entry for mgid " ++ IPOIB_GID_FMT "\n", IPOIB_GID_ARG(mgid)); + continue; + } + + /* Not found or send-only group, let's add a new entry */ +- ipoib_dbg_mcast(priv, "adding multicast entry for mgid %pI6\n", +- mgid.raw); ++ ipoib_dbg_mcast(priv, "adding multicast entry for mgid " ++ IPOIB_GID_FMT "\n", IPOIB_GID_ARG(mgid)); + + nmcast = ipoib_mcast_alloc(dev, 0); + if (!nmcast) { +@@ -847,8 +859,8 @@ void ipoib_mcast_restart_task(struct wor + list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) { + if (!test_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags) && + !test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { +- ipoib_dbg_mcast(priv, "deleting multicast group %pI6\n", +- mcast->mcmember.mgid.raw); ++ ipoib_dbg_mcast(priv, "deleting multicast group " IPOIB_GID_FMT "\n", ++ IPOIB_GID_ARG(mcast->mcmember.mgid)); + + rb_erase(&mcast->rb_node, &priv->multicast_tree); + +Index: ofed_kernel-2.6.28/drivers/infiniband/ulp/ipoib/ipoib.h +=================================================================== +--- ofed_kernel-2.6.28.orig/drivers/infiniband/ulp/ipoib/ipoib.h 2009-07-20 15:39:50.000000000 +0300 ++++ ofed_kernel-2.6.28/drivers/infiniband/ulp/ipoib/ipoib.h 2009-07-20 16:11:55.000000000 +0300 +@@ -732,6 +732,29 @@ extern int ipoib_debug_level; + do { (void) (priv); } while (0) + #endif /* CONFIG_INFINIBAND_IPOIB_DEBUG_DATA */ + ++ ++#define IPOIB_GID_FMT "%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:" \ ++ "%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x:%2.2x%2.2x" ++ ++#define IPOIB_GID_RAW_ARG(gid) ((u8 *)(gid))[0], \ ++ ((u8 *)(gid))[1], \ ++ ((u8 *)(gid))[2], \ ++ ((u8 *)(gid))[3], \ ++ ((u8 *)(gid))[4], \ ++ ((u8 *)(gid))[5], \ ++ ((u8 *)(gid))[6], \ ++ ((u8 *)(gid))[7], \ ++ ((u8 *)(gid))[8], \ ++ ((u8 *)(gid))[9], \ ++ ((u8 *)(gid))[10],\ ++ ((u8 *)(gid))[11],\ ++ ((u8 *)(gid))[12],\ ++ ((u8 *)(gid))[13],\ ++ ((u8 *)(gid))[14],\ ++ ((u8 *)(gid))[15] ++ ++#define IPOIB_GID_ARG(gid) IPOIB_GID_RAW_ARG((gid).raw) ++ + #define IPOIB_QPN(ha) (be32_to_cpup((__be32 *) ha) & 0xffffff) + + #endif /* _IPOIB_H */ diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_x_neigh_cleanup.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_x_neigh_cleanup.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_x_neigh_cleanup.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/ipoib_x_neigh_cleanup.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,182 @@ +IB/ipoib: Fix neigh destructor oops + +For kernels 2.6.20 and older, it may happen that the pointer to +ipoib_neigh_cleanup() is called after IPoIB has been unloades, +causing a kernel oops. This problem has been fixed for 2.6.21 with +the following commit: ecbb416939da77c0d107409976499724baddce7b + +The idea with this patch is to have a helper module which remains +always loaded, and this modules provides the destructor for +neighbours which calls IPoIB's destructor through a function poiner. +When IPoIB is unloaded, the function pointer is cleared so subsequent +calls to a neighbour destructor will be made to valid addresses but +IPoIB's destructor won't get called. + +Signed-off-by: Eli Cohen +--- + +Index: ofa_1_3_dev_kernel/drivers/infiniband/ulp/ipoib/ipoib_main.c +=================================================================== +--- ofa_1_3_dev_kernel.orig/drivers/infiniband/ulp/ipoib/ipoib_main.c 2008-05-14 12:49:11.000000000 +0300 ++++ ofa_1_3_dev_kernel/drivers/infiniband/ulp/ipoib/ipoib_main.c 2008-05-14 12:49:32.000000000 +0300 +@@ -49,6 +49,7 @@ + + #include + #include ++#include + + MODULE_AUTHOR("Roland Dreier"); + MODULE_DESCRIPTION("IP-over-InfiniBand net driver"); +@@ -916,7 +917,7 @@ void ipoib_neigh_free(struct net_device + + static int ipoib_neigh_setup_dev(struct net_device *dev, struct neigh_parms *parms) + { +- parms->neigh_cleanup = ipoib_neigh_cleanup; ++ parms->neigh_cleanup = ipoib_neigh_cleanup_container; + + return 0; + } +@@ -1383,9 +1384,13 @@ static int __init ipoib_init_module(void + ipoib_max_conn_qp = min(ipoib_max_conn_qp, IPOIB_CM_MAX_CONN_QP); + #endif + ++ ++ ipoib_set_cleanup_function(ipoib_neigh_cleanup); + ret = ipoib_register_debugfs(); +- if (ret) ++ if (ret) { ++ ipoib_set_cleanup_function(NULL); + return ret; ++ } + + /* + * We create our own workqueue mainly because we want to be +@@ -1397,6 +1402,7 @@ static int __init ipoib_init_module(void + */ + ipoib_workqueue = create_singlethread_workqueue("ipoib"); + if (!ipoib_workqueue) { ++ ipoib_set_cleanup_function(NULL); + ret = -ENOMEM; + goto err_fs; + } +@@ -1404,8 +1410,10 @@ static int __init ipoib_init_module(void + ib_sa_register_client(&ipoib_sa_client); + + ret = ib_register_client(&ipoib_client); +- if (ret) ++ if (ret) { ++ ipoib_set_cleanup_function(NULL); + goto err_sa; ++ } + + return 0; + +@@ -1421,7 +1429,16 @@ err_fs: + + static void __exit ipoib_cleanup_module(void) + { ++ int ret; ++ + ib_unregister_client(&ipoib_client); ++ ++ do { ++ ret = ipoib_set_cleanup_function(NULL); ++ if (ret) ++ msleep(10); ++ } while(ret); ++ + ib_sa_unregister_client(&ipoib_sa_client); + ipoib_unregister_debugfs(); + destroy_workqueue(ipoib_workqueue); +Index: ofa_1_3_dev_kernel/drivers/infiniband/ulp/ipoib/Makefile +=================================================================== +--- ofa_1_3_dev_kernel.orig/drivers/infiniband/ulp/ipoib/Makefile 2008-05-14 12:49:11.000000000 +0300 ++++ ofa_1_3_dev_kernel/drivers/infiniband/ulp/ipoib/Makefile 2008-05-14 12:49:32.000000000 +0300 +@@ -1,4 +1,4 @@ +-obj-$(CONFIG_INFINIBAND_IPOIB) += ib_ipoib.o ++obj-$(CONFIG_INFINIBAND_IPOIB) += ib_ipoib.o ipoib_helper.o + + ib_ipoib-y := ipoib_main.o \ + ipoib_ib.o \ +Index: ofa_1_3_dev_kernel/drivers/infiniband/ulp/ipoib/ipoib.h +=================================================================== +--- ofa_1_3_dev_kernel.orig/drivers/infiniband/ulp/ipoib/ipoib.h 2008-05-14 12:49:11.000000000 +0300 ++++ ofa_1_3_dev_kernel/drivers/infiniband/ulp/ipoib/ipoib.h 2008-05-14 12:49:32.000000000 +0300 +@@ -554,6 +554,9 @@ int ipoib_mcast_stop_thread(struct net_d + void ipoib_mcast_dev_down(struct net_device *dev); + void ipoib_mcast_dev_flush(struct net_device *dev); + ++int ipoib_set_cleanup_function(void (*func)(struct neighbour *n)); ++void ipoib_neigh_cleanup_container(struct neighbour *n); ++ + #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG + struct ipoib_mcast_iter *ipoib_mcast_iter_init(struct net_device *dev); + int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter); +Index: ofa_1_3_dev_kernel/drivers/infiniband/ulp/ipoib/ipoib_helper.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ ofa_1_3_dev_kernel/drivers/infiniband/ulp/ipoib/ipoib_helper.c 2008-05-14 12:49:32.000000000 +0300 +@@ -0,0 +1,63 @@ ++#include ++#include ++#include ++ ++MODULE_AUTHOR("Eli Cohen"); ++MODULE_DESCRIPTION("container for ipoib neighbour destructor"); ++MODULE_LICENSE("Dual BSD/GPL"); ++ ++DEFINE_SPINLOCK(spl); ++static int busy; ++ ++static void (*cleanup_func)(struct neighbour *n); ++ ++static int ipoib_set_cleanup_function(void (*func)(struct neighbour *n)) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&spl, flags); ++ if (busy) { ++ spin_unlock_irqrestore(&spl, flags); ++ return -EBUSY; ++ } ++ cleanup_func = func; ++ spin_unlock_irqrestore(&spl, flags); ++ ++ return 0; ++} ++ ++static void ipoib_neigh_cleanup_container(struct neighbour *n) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&spl, flags); ++ busy = 1; ++ spin_unlock_irqrestore(&spl, flags); ++ if (cleanup_func) ++ cleanup_func(n); ++ ++ spin_lock_irqsave(&spl, flags); ++ busy = 0; ++ spin_unlock_irqrestore(&spl, flags); ++} ++ ++ ++EXPORT_SYMBOL(ipoib_set_cleanup_function); ++EXPORT_SYMBOL(ipoib_neigh_cleanup_container); ++ ++ ++static int __init ipoib_helper_init(void) ++{ ++ if (!try_module_get(THIS_MODULE)) ++ return -1; ++ ++ return 0; ++} ++ ++ ++static void __exit ipoib_helper_cleanup(void) ++{ ++} ++ ++module_init(ipoib_helper_init); ++module_exit(ipoib_helper_cleanup); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iser_000_to_rhel5.4.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iser_000_to_rhel5.4.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iser_000_to_rhel5.4.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iser_000_to_rhel5.4.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,385 @@ +from: Or Gerlitz + +patch the ofed provided iser code to match the RHEL 5.4 provided +iser code, mainly by doing iscsi2_xxx instead of iscsi_xxx calls. +This trivial transformation works since the 5.4 iser/iscsi stack +was upgraded to 2.6.30 or so. + +Index: ofa_kernel-1.5/drivers/infiniband/ulp/iser/Kconfig +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/ulp/iser/Kconfig ++++ ofa_kernel-1.5/drivers/infiniband/ulp/iser/Kconfig +@@ -1,7 +1,7 @@ + config INFINIBAND_ISER + tristate "iSCSI Extensions for RDMA (iSER)" + depends on SCSI && INET && INFINIBAND_ADDR_TRANS +- select SCSI_ISCSI_ATTRS ++ select SCSI_ISCSI2_ATTRS + ---help--- + Support for the iSCSI Extensions for RDMA (iSER) Protocol + over InfiniBand. This allows you to access storage devices +Index: ofa_kernel-1.5/drivers/infiniband/ulp/iser/iscsi_iser.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/ulp/iser/iscsi_iser.c ++++ ofa_kernel-1.5/drivers/infiniband/ulp/iser/iscsi_iser.c +@@ -67,7 +67,7 @@ + #include + #include + #include +-#include ++#include + + #include "iscsi_iser.h" + +@@ -110,13 +110,13 @@ iscsi_iser_recv(struct iscsi_conn *conn, + /* read AHS */ + ahslen = hdr->hlength * 4; + +- rc = iscsi_complete_pdu(conn, hdr, rx_data, rx_data_len); ++ rc = iscsi2_complete_pdu(conn, hdr, rx_data, rx_data_len); + if (rc && rc != ISCSI_ERR_NO_SCSI_CMD) + goto error; + + return; + error: +- iscsi_conn_failure(conn, rc); ++ iscsi2_conn_failure(conn, rc); + } + + static int iscsi_iser_pdu_alloc(struct iscsi_task *task, uint8_t opcode) +@@ -179,7 +179,7 @@ iscsi_iser_mtask_xmit(struct iscsi_conn + * - if no, the task is recycled at iser_snd_completion + */ + if (error && error != -ENOBUFS) +- iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); ++ iscsi2_conn_failure(conn, ISCSI_ERR_CONN_FAILED); + + return error; + } +@@ -194,7 +194,7 @@ iscsi_iser_task_xmit_unsol_data(struct i + + /* Send data-out PDUs while there's still unsolicited data to send */ + while (iscsi_task_has_unsol_data(task)) { +- iscsi_prep_data_out_pdu(task, r2t, &hdr); ++ iscsi2_prep_data_out_pdu(task, r2t, &hdr); + iser_dbg("Sending data-out: itt 0x%x, data count %d\n", + hdr.itt, r2t->data_count); + +@@ -249,7 +249,7 @@ iscsi_iser_task_xmit(struct iscsi_task * + + iscsi_iser_task_xmit_exit: + if (error && error != -ENOBUFS) +- iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); ++ iscsi2_conn_failure(conn, ISCSI_ERR_CONN_FAILED); + return error; + } + +@@ -257,11 +257,8 @@ static void iscsi_iser_cleanup_task(stru + { + struct iscsi_iser_task *iser_task = task->dd_data; + +- /* +- * mgmt tasks do not need special cleanup and we do not +- * allocate anything in the init task callout +- */ +- if (!task->sc || task->state == ISCSI_TASK_PENDING) ++ /* mgmt tasks do not need special cleanup */ ++ if (!task->sc) + return; + + if (iser_task->status == ISER_TASK_STATUS_STARTED) { +@@ -277,7 +274,7 @@ iscsi_iser_conn_create(struct iscsi_cls_ + struct iscsi_cls_conn *cls_conn; + struct iscsi_iser_conn *iser_conn; + +- cls_conn = iscsi_conn_setup(cls_session, sizeof(*iser_conn), conn_idx); ++ cls_conn = iscsi2_conn_setup(cls_session, sizeof(*iser_conn), conn_idx); + if (!cls_conn) + return NULL; + conn = cls_conn->dd_data; +@@ -302,7 +299,7 @@ iscsi_iser_conn_destroy(struct iscsi_cls + struct iscsi_iser_conn *iser_conn = conn->dd_data; + struct iser_conn *ib_conn = iser_conn->ib_conn; + +- iscsi_conn_teardown(cls_conn); ++ iscsi2_conn_teardown(cls_conn); + /* + * Userspace will normally call the stop callback and + * already have freed the ib_conn, but if it goofed up then +@@ -325,13 +322,13 @@ iscsi_iser_conn_bind(struct iscsi_cls_se + struct iscsi_endpoint *ep; + int error; + +- error = iscsi_conn_bind(cls_session, cls_conn, is_leading); ++ error = iscsi2_conn_bind(cls_session, cls_conn, is_leading); + if (error) + return error; + + /* the transport ep handle comes from user space so it must be + * verified against the global ib connections list */ +- ep = iscsi_lookup_endpoint(transport_eph); ++ ep = iscsi2_lookup_endpoint(transport_eph); + if (!ep) { + iser_err("can't bind eph %llx\n", + (unsigned long long)transport_eph); +@@ -362,7 +359,7 @@ iscsi_iser_conn_stop(struct iscsi_cls_co + * might have only partially setup the connection. + */ + if (ib_conn) { +- iscsi_conn_stop(cls_conn, flag); ++ iscsi2_conn_stop(cls_conn, flag); + /* + * There is no unbind event so the stop callback + * must release the ref from the bind. +@@ -382,16 +379,16 @@ iscsi_iser_conn_start(struct iscsi_cls_c + if (err) + return err; + +- return iscsi_conn_start(cls_conn); ++ return iscsi2_conn_start(cls_conn); + } + + static void iscsi_iser_session_destroy(struct iscsi_cls_session *cls_session) + { + struct Scsi_Host *shost = iscsi_session_to_shost(cls_session); + +- iscsi_session_teardown(cls_session); +- iscsi_host_remove(shost); +- iscsi_host_free(shost); ++ iscsi2_session_teardown(cls_session); ++ iscsi2_host_remove(shost); ++ iscsi2_host_free(shost); + } + + static struct iscsi_cls_session * +@@ -404,7 +401,7 @@ iscsi_iser_session_create(struct iscsi_e + struct Scsi_Host *shost; + struct iser_conn *ib_conn; + +- shost = iscsi_host_alloc(&iscsi_iser_sht, 0, 1); ++ shost = iscsi2_host_alloc(&iscsi_iser_sht, 0, 1); + if (!shost) + return NULL; + shost->transportt = iscsi_iser_scsi_transport; +@@ -420,7 +417,7 @@ iscsi_iser_session_create(struct iscsi_e + if (ep) + ib_conn = ep->dd_data; + +- if (iscsi_host_add(shost, ++ if (iscsi2_host_add(shost, + ep ? ib_conn->device->ib_device->dma_device : NULL)) + goto free_host; + +@@ -428,7 +425,7 @@ iscsi_iser_session_create(struct iscsi_e + * we do not support setting can_queue cmd_per_lun from userspace yet + * because we preallocate so many resources + */ +- cls_session = iscsi_session_setup(&iscsi_iser_transport, shost, ++ cls_session = iscsi2_session_setup(&iscsi_iser_transport, shost, + ISCSI_DEF_XMIT_CMDS_MAX, + sizeof(struct iscsi_iser_task), + initial_cmdsn, 0); +@@ -440,9 +437,9 @@ iscsi_iser_session_create(struct iscsi_e + return cls_session; + + remove_host: +- iscsi_host_remove(shost); ++ iscsi2_host_remove(shost); + free_host: +- iscsi_host_free(shost); ++ iscsi2_host_free(shost); + return NULL; + } + +@@ -485,7 +482,7 @@ iscsi_iser_set_param(struct iscsi_cls_co + } + break; + default: +- return iscsi_set_param(cls_conn, param, buf, buflen); ++ return iscsi2_set_param(cls_conn, param, buf, buflen); + } + + return 0; +@@ -517,13 +514,14 @@ iscsi_iser_conn_get_stats(struct iscsi_c + } + + static struct iscsi_endpoint * +-iscsi_iser_ep_connect(struct sockaddr *dst_addr, int non_blocking) ++iscsi_iser_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr, ++ int non_blocking) + { + int err; + struct iser_conn *ib_conn; + struct iscsi_endpoint *ep; + +- ep = iscsi_create_endpoint(sizeof(*ib_conn)); ++ ep = iscsi2_create_endpoint(sizeof(*ib_conn)); + if (!ep) + return ERR_PTR(-ENOMEM); + +@@ -534,7 +532,7 @@ iscsi_iser_ep_connect(struct sockaddr *d + err = iser_connect(ib_conn, NULL, (struct sockaddr_in *)dst_addr, + non_blocking); + if (err) { +- iscsi_destroy_endpoint(ep); ++ iscsi2_destroy_endpoint(ep); + return ERR_PTR(err); + } + return ep; +@@ -581,7 +579,7 @@ iscsi_iser_ep_disconnect(struct iscsi_en + * + * This may not be bound if the ep poll failed. + */ +- iscsi_suspend_tx(ib_conn->iser_conn->iscsi_conn); ++ iscsi2_suspend_tx(ib_conn->iser_conn->iscsi_conn); + + + iser_err("ib conn %p state %d\n",ib_conn, ib_conn->state); +@@ -591,15 +589,14 @@ iscsi_iser_ep_disconnect(struct iscsi_en + static struct scsi_host_template iscsi_iser_sht = { + .module = THIS_MODULE, + .name = "iSCSI Initiator over iSER, v." DRV_VER, +- .queuecommand = iscsi_queuecommand, +- .change_queue_depth = iscsi_change_queue_depth, ++ .queuecommand = iscsi2_queuecommand, ++ .change_queue_depth = iscsi2_change_queue_depth, + .sg_tablesize = ISCSI_ISER_SG_TABLESIZE, + .max_sectors = 1024, + .cmd_per_lun = ISER_DEF_CMD_PER_LUN, +- .eh_abort_handler = iscsi_eh_abort, +- .eh_device_reset_handler= iscsi_eh_device_reset, +- .eh_target_reset_handler= iscsi_eh_target_reset, +- .target_alloc = iscsi_target_alloc, ++ .eh_abort_handler = iscsi2_eh_abort, ++ .eh_device_reset_handler= iscsi2_eh_device_reset, ++ .eh_host_reset_handler= iscsi2_eh_target_reset, + .use_clustering = DISABLE_CLUSTERING, + .proc_name = "iscsi_iser", + .this_id = -1, +@@ -640,22 +637,22 @@ static struct iscsi_transport iscsi_iser + .bind_conn = iscsi_iser_conn_bind, + .destroy_conn = iscsi_iser_conn_destroy, + .set_param = iscsi_iser_set_param, +- .get_conn_param = iscsi_conn_get_param, +- .get_session_param = iscsi_session_get_param, ++ .get_conn_param = iscsi2_conn_get_param, ++ .get_session_param = iscsi2_session_get_param, + .start_conn = iscsi_iser_conn_start, + .stop_conn = iscsi_iser_conn_stop, + /* iscsi host params */ +- .get_host_param = iscsi_host_get_param, +- .set_host_param = iscsi_host_set_param, ++ .get_host_param = iscsi2_host_get_param, ++ .set_host_param = iscsi2_host_set_param, + /* IO */ +- .send_pdu = iscsi_conn_send_pdu, ++ .send_pdu = iscsi2_conn_send_pdu, + .get_stats = iscsi_iser_conn_get_stats, + .init_task = iscsi_iser_task_init, + .xmit_task = iscsi_iser_task_xmit, + .cleanup_task = iscsi_iser_cleanup_task, + .alloc_pdu = iscsi_iser_pdu_alloc, + /* recovery */ +- .session_recovery_timedout = iscsi_session_recovery_timedout, ++ .session_recovery_timedout = iscsi2_session_recovery_timedout, + + .ep_connect = iscsi_iser_ep_connect, + .ep_poll = iscsi_iser_ep_poll, +@@ -688,7 +685,7 @@ static int __init iser_init(void) + mutex_init(&ig.connlist_mutex); + INIT_LIST_HEAD(&ig.connlist); + +- iscsi_iser_scsi_transport = iscsi_register_transport( ++ iscsi_iser_scsi_transport = iscsi2_register_transport( + &iscsi_iser_transport); + if (!iscsi_iser_scsi_transport) { + iser_err("iscsi_register_transport failed\n"); +@@ -707,7 +704,7 @@ register_transport_failure: + static void __exit iser_exit(void) + { + iser_dbg("Removing iSER datamover...\n"); +- iscsi_unregister_transport(&iscsi_iser_transport); ++ iscsi2_unregister_transport(&iscsi_iser_transport); + kmem_cache_destroy(ig.desc_cache); + } + +Index: ofa_kernel-1.5/drivers/infiniband/ulp/iser/iscsi_iser.h +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/ulp/iser/iscsi_iser.h ++++ ofa_kernel-1.5/drivers/infiniband/ulp/iser/iscsi_iser.h +@@ -42,8 +42,8 @@ + + #include + #include +-#include +-#include ++#include ++#include + + #include + #include +Index: ofa_kernel-1.5/drivers/infiniband/ulp/iser/iser_initiator.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/ulp/iser/iser_initiator.c ++++ ofa_kernel-1.5/drivers/infiniband/ulp/iser/iser_initiator.c +@@ -592,9 +592,9 @@ void iser_rcv_completion(struct iser_des + + if (opcode == ISCSI_OP_SCSI_CMD_RSP) { + spin_lock(&conn->iscsi_conn->session->lock); +- task = iscsi_itt_to_ctask(conn->iscsi_conn, hdr->itt); ++ task = iscsi2_itt_to_ctask(conn->iscsi_conn, hdr->itt); + if (task) +- __iscsi_get_task(task); ++ __iscsi2_get_task(task); + spin_unlock(&conn->iscsi_conn->session->lock); + + if (!task) +@@ -606,7 +606,7 @@ void iser_rcv_completion(struct iser_des + iser_dbg("itt %d task %p\n",hdr->itt, task); + iser_task->status = ISER_TASK_STATUS_COMPLETED; + iser_task_rdma_finalize(iser_task); +- iscsi_put_task(task); ++ iscsi2_put_task(task); + } + } + iser_dto_buffs_release(dto); +@@ -669,7 +669,7 @@ void iser_snd_completion(struct iser_des + task = (void *) ((long)(void *)tx_desc - + sizeof(struct iscsi_task)); + if (task->hdr->itt == RESERVED_ITT) +- iscsi_put_task(task); ++ iscsi2_put_task(task); + } + } + +Index: ofa_kernel-1.5/drivers/infiniband/ulp/iser/iser_verbs.c +=================================================================== +--- ofa_kernel-1.5.orig/drivers/infiniband/ulp/iser/iser_verbs.c ++++ ofa_kernel-1.5/drivers/infiniband/ulp/iser/iser_verbs.c +@@ -322,7 +322,7 @@ static void iser_conn_release(struct ise + iser_device_try_release(device); + if (ib_conn->iser_conn) + ib_conn->iser_conn->ib_conn = NULL; +- iscsi_destroy_endpoint(ib_conn->ep); ++ iscsi2_destroy_endpoint(ib_conn->ep); + } + + void iser_conn_get(struct iser_conn *ib_conn) +@@ -438,7 +438,7 @@ static void iser_disconnected_handler(st + * terminated asynchronously from the iSCSI layer's perspective. */ + if (iser_conn_state_comp_exch(ib_conn, ISER_CONN_UP, + ISER_CONN_TERMINATING)) +- iscsi_conn_failure(ib_conn->iser_conn->iscsi_conn, ++ iscsi2_conn_failure(ib_conn->iser_conn->iscsi_conn, + ISCSI_ERR_CONN_FAILED); + + /* Complete the termination process if no posts are pending */ +@@ -762,7 +762,7 @@ static void iser_handle_comp_error(struc + * perspective. */ + if (iser_conn_state_comp_exch(ib_conn, ISER_CONN_UP, + ISER_CONN_TERMINATING)) +- iscsi_conn_failure(ib_conn->iser_conn->iscsi_conn, ++ iscsi2_conn_failure(ib_conn->iser_conn->iscsi_conn, + ISCSI_ERR_CONN_FAILED); + + /* complete the termination process if disconnect event was delivered * diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb3_pass_ird_ord_upwards.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb3_pass_ird_ord_upwards.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb3_pass_ird_ord_upwards.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb3_pass_ird_ord_upwards.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,28 @@ +diff --git a/drivers/infiniband/hw/cxgb3/iwch_cm.c b/drivers/infiniband/hw/cxgb3/iwch_cm.c +index 675fc04..71a62b3 100644 +--- a/drivers/infiniband/hw/cxgb3/iwch_cm.c ++++ b/drivers/infiniband/hw/cxgb3/iwch_cm.c +@@ -787,6 +787,11 @@ static void connect_request_upcall(struct iwch_ep *ep) + event.private_data_len = ep->plen; + event.private_data = ep->mpa_pkt + sizeof(struct mpa_message); + event.provider_data = ep; ++ /* ++ * Until ird/ord negotiation via MPA_v2 support is added, send max ++ * supported values ++ */ ++ event.ird = event.ord = 8; + if (state_read(&ep->parent_ep->com) != DEAD) { + get_ep(&ep->com); + ep->parent_ep->com.cm_id->event_handler( +@@ -804,6 +809,11 @@ static void established_upcall(struct iwch_ep *ep) + PDBG("%s ep %p\n", __func__, ep); + memset(&event, 0, sizeof(event)); + event.event = IW_CM_EVENT_ESTABLISHED; ++ /* ++ * Until ird/ord negotiation via MPA_v2 support is added, send max ++ * supported values ++ */ ++ event.ird = event.ord = 8; + if (ep->com.cm_id) { + PDBG("%s ep %p tid %d\n", __func__, ep, ep->hwtid); + ep->com.cm_id->event_handler(ep->com.cm_id, &event); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0010_to_2_6_38.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0010_to_2_6_38.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0010_to_2_6_38.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0010_to_2_6_38.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,47 @@ +diff --git a/drivers/infiniband/hw/cxgb4/cm.c b/drivers/infiniband/hw/cxgb4/cm.c +index 31fb440..bdb0711 100644 +--- a/drivers/infiniband/hw/cxgb4/cm.c ++++ b/drivers/infiniband/hw/cxgb4/cm.c +@@ -316,12 +316,23 @@ static struct rtable *find_route(struct c4iw_dev *dev, __be32 local_ip, + __be16 peer_port, u8 tos) + { + struct rtable *rt; +- struct flowi4 fl4; ++ struct flowi fl = { ++ .oif = 0, ++ .nl_u = { ++ .ip4_u = { ++ .daddr = peer_ip, ++ .saddr = local_ip, ++ .tos = tos} ++ }, ++ .proto = IPPROTO_TCP, ++ .uli_u = { ++ .ports = { ++ .sport = local_port, ++ .dport = peer_port} ++ } ++ }; + +- rt = ip_route_output_ports(&init_net, &fl4, NULL, peer_ip, local_ip, +- peer_port, local_port, IPPROTO_TCP, +- tos, 0); +- if (IS_ERR(rt)) ++ if (ip_route_output_flow(&init_net, &rt, &fl, NULL, false)) + return NULL; + return rt; + } + +diff --git a/drivers/infiniband/hw/cxgb4/provider.c b/drivers/infiniband/hw/cxgb4/provider.c +index 5b9e422..92187a9 100644 +--- a/drivers/infiniband/hw/cxgb4/provider.c ++++ b/drivers/infiniband/hw/cxgb4/provider.c +@@ -513,7 +513,7 @@ int c4iw_register_device(struct c4iw_dev *dev) + dev->ibdev.iwcm->rem_ref = c4iw_qp_rem_ref; + dev->ibdev.iwcm->get_qp = c4iw_get_qp; + +- ret = ib_register_device(&dev->ibdev, NULL); ++ ret = ib_register_device(&dev->ibdev); + if (ret) + goto bail1; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0020_to_2_6_35.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0020_to_2_6_35.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0020_to_2_6_35.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0020_to_2_6_35.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,22 @@ +diff --git a/drivers/infiniband/hw/cxgb4/cm.c b/drivers/infiniband/hw/cxgb4/cm.c +index 31fb440..6750877 100644 +--- a/drivers/infiniband/hw/cxgb4/cm.c ++++ b/drivers/infiniband/hw/cxgb4/cm.c +@@ -1625,7 +1625,7 @@ static int pass_accept_req(struct c4iw_dev *dev, struct sk_buff *skb) + __func__); + goto reject; + } +- dst = &rt->dst; ++ dst = &rt->u.dst; + if (dst->neighbour->dev->flags & IFF_LOOPBACK) { + pdev = ip_dev_find(&init_net, peer_ip); + BUG_ON(!pdev); +@@ -2331,7 +2331,7 @@ int c4iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param) + err = -EHOSTUNREACH; + goto fail3; + } +- ep->dst = &rt->dst; ++ ep->dst = &rt->u.dst; + + /* get a l2t entry */ + if (ep->dst->neighbour->dev->flags & IFF_LOOPBACK) { diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0030_to_2_6_33.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0030_to_2_6_33.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0030_to_2_6_33.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0030_to_2_6_33.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,137 @@ +diff --git a/drivers/infiniband/hw/cxgb4/cq.c b/drivers/infiniband/hw/cxgb4/cq.c +index 1720dc7..5bdc87c 100644 +--- a/drivers/infiniband/hw/cxgb4/cq.c ++++ b/drivers/infiniband/hw/cxgb4/cq.c +@@ -70,7 +70,7 @@ static int destroy_cq(struct c4iw_rdev *rdev, struct t4_cq *cq, + kfree(cq->sw_queue); + dma_free_coherent(&(rdev->lldi.pdev->dev), + cq->memsize, cq->queue, +- dma_unmap_addr(cq, mapping)); ++ pci_unmap_addr(cq, mapping)); + c4iw_put_cqid(rdev, cq->cqid, uctx); + return ret; + } +@@ -105,7 +105,7 @@ static int create_cq(struct c4iw_rdev *rdev, struct t4_cq *cq, + ret = -ENOMEM; + goto err3; + } +- dma_unmap_addr_set(cq, mapping, cq->dma_addr); ++ pci_unmap_addr_set(cq, mapping, cq->dma_addr); + memset(cq->queue, 0, cq->memsize); + + /* build fw_ri_res_wr */ +@@ -165,7 +165,7 @@ static int create_cq(struct c4iw_rdev *rdev, struct t4_cq *cq, + return 0; + err4: + dma_free_coherent(&rdev->lldi.pdev->dev, cq->memsize, cq->queue, +- dma_unmap_addr(cq, mapping)); ++ pci_unmap_addr(cq, mapping)); + err3: + kfree(cq->sw_queue); + err2: +diff --git a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h +index 4f04537..aca2daf 100644 +--- a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h ++++ b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h +@@ -359,7 +359,7 @@ static inline struct c4iw_mw *to_c4iw_mw(struct ib_mw *ibmw) + + struct c4iw_fr_page_list { + struct ib_fast_reg_page_list ibpl; +- DEFINE_DMA_UNMAP_ADDR(mapping); ++ DECLARE_PCI_UNMAP_ADDR(mapping); + dma_addr_t dma_addr; + struct c4iw_dev *dev; + int size; +diff --git a/drivers/infiniband/hw/cxgb4/mem.c b/drivers/infiniband/hw/cxgb4/mem.c +index 0347eed..b762743 100644 +--- a/drivers/infiniband/hw/cxgb4/mem.c ++++ b/drivers/infiniband/hw/cxgb4/mem.c +@@ -764,7 +764,7 @@ struct ib_fast_reg_page_list *c4iw_alloc_fastreg_pbl(struct ib_device *device, + if (!c4pl) + return ERR_PTR(-ENOMEM); + +- dma_unmap_addr_set(c4pl, mapping, dma_addr); ++ pci_unmap_addr_set(c4pl, mapping, dma_addr); + c4pl->dma_addr = dma_addr; + c4pl->dev = dev; + c4pl->size = size; +@@ -779,7 +779,7 @@ void c4iw_free_fastreg_pbl(struct ib_fast_reg_page_list *ibpl) + struct c4iw_fr_page_list *c4pl = to_c4iw_fr_page_list(ibpl); + + dma_free_coherent(&c4pl->dev->rdev.lldi.pdev->dev, c4pl->size, +- c4pl, dma_unmap_addr(c4pl, mapping)); ++ c4pl, pci_unmap_addr(c4pl, mapping)); + } + + int c4iw_dereg_mr(struct ib_mr *ib_mr) +diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c +index a41578e..1bf48ae 100644 +--- a/drivers/infiniband/hw/cxgb4/qp.c ++++ b/drivers/infiniband/hw/cxgb4/qp.c +@@ -106,7 +106,7 @@ static int destroy_qp(struct c4iw_rdev *rdev, struct t4_wq *wq, + */ + dma_free_coherent(&(rdev->lldi.pdev->dev), + wq->rq.memsize, wq->rq.queue, +- dma_unmap_addr(&wq->rq, mapping)); ++ pci_unmap_addr(&wq->rq, mapping)); + dealloc_sq(rdev, &wq->sq); + c4iw_rqtpool_free(rdev, wq->rq.rqt_hwaddr, wq->rq.rqt_size); + kfree(wq->rq.sw_rq); +@@ -164,7 +164,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq, + if (alloc_host_sq(rdev, &wq->sq)) + goto err5; + memset(wq->sq.queue, 0, wq->sq.memsize); +- dma_unmap_addr_set(&wq->sq, mapping, wq->sq.dma_addr); ++ pci_unmap_addr_set(&wq->sq, mapping, wq->sq.dma_addr); + + wq->rq.queue = dma_alloc_coherent(&(rdev->lldi.pdev->dev), + wq->rq.memsize, &(wq->rq.dma_addr), +@@ -177,7 +177,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq, + wq->rq.queue, + (unsigned long long)virt_to_phys(wq->rq.queue)); + memset(wq->rq.queue, 0, wq->rq.memsize); +- dma_unmap_addr_set(&wq->rq, mapping, wq->rq.dma_addr); ++ pci_unmap_addr_set(&wq->rq, mapping, wq->rq.dma_addr); + + wq->db = rdev->lldi.db_reg; + wq->gts = rdev->lldi.gts_reg; +@@ -276,7 +276,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq, + err7: + dma_free_coherent(&(rdev->lldi.pdev->dev), + wq->rq.memsize, wq->rq.queue, +- dma_unmap_addr(&wq->rq, mapping)); ++ pci_unmap_addr(&wq->rq, mapping)); + err6: + dealloc_sq(rdev, &wq->sq); + err5: +diff --git a/drivers/infiniband/hw/cxgb4/t4.h b/drivers/infiniband/hw/cxgb4/t4.h +index c0221ee..47a9bd2 100644 +--- a/drivers/infiniband/hw/cxgb4/t4.h ++++ b/drivers/infiniband/hw/cxgb4/t4.h +@@ -296,7 +296,7 @@ enum { + struct t4_sq { + union t4_wr *queue; + dma_addr_t dma_addr; +- DEFINE_DMA_UNMAP_ADDR(mapping); ++ DECLARE_PCI_UNMAP_ADDR(mapping); + unsigned long phys_addr; + struct t4_swsqe *sw_sq; + struct t4_swsqe *oldest_read; +@@ -318,7 +318,7 @@ struct t4_swrqe { + struct t4_rq { + union t4_recv_wr *queue; + dma_addr_t dma_addr; +- DEFINE_DMA_UNMAP_ADDR(mapping); ++ DECLARE_PCI_UNMAP_ADDR(mapping); + struct t4_swrqe *sw_rq; + u64 udb; + size_t memsize; +@@ -476,7 +476,7 @@ static inline int t4_wq_db_enabled(struct t4_wq *wq) + struct t4_cq { + struct t4_cqe *queue; + dma_addr_t dma_addr; +- DEFINE_DMA_UNMAP_ADDR(mapping); ++ DECLARE_PCI_UNMAP_ADDR(mapping); + struct t4_cqe *sw_queue; + void __iomem *gts; + struct c4iw_rdev *rdev; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0050_to_2_6_18.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0050_to_2_6_18.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0050_to_2_6_18.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0050_to_2_6_18.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,169 @@ +diff --git a/drivers/infiniband/hw/cxgb4/Makefile b/drivers/infiniband/hw/cxgb4/Makefile +index 82af901..7f62cd3 100644 +--- a/drivers/infiniband/hw/cxgb4/Makefile ++++ b/drivers/infiniband/hw/cxgb4/Makefile +@@ -1,4 +1,4 @@ +-ccflags-y := -I$(CWD)/drivers/net/cxgb4 ++EXTRA_CFLAGS += -I$(CWD)/drivers/net/cxgb4 + + obj-$(CONFIG_INFINIBAND_CXGB4) += iw_cxgb4.o + +diff --git a/drivers/infiniband/hw/cxgb4/cm.c b/drivers/infiniband/hw/cxgb4/cm.c +index 31fb440..c40fc98 100644 +--- a/drivers/infiniband/hw/cxgb4/cm.c ++++ b/drivers/infiniband/hw/cxgb4/cm.c +@@ -483,7 +483,6 @@ static int send_connect(struct c4iw_ep *ep) + TX_CHAN(ep->tx_chan) | + SMAC_SEL(ep->smac_idx) | + DSCP(ep->tos) | +- ULP_MODE(ULP_MODE_TCPDDP) | + RCV_BUFSIZ(rcv_win>>10); + opt2 = RX_CHANNEL(0) | + RSS_QUEUE_VALID | RSS_QUEUE(ep->rss_qid); +@@ -1529,7 +1528,6 @@ static void accept_cr(struct c4iw_ep *ep, __be32 peer_ip, struct sk_buff *skb, + TX_CHAN(ep->tx_chan) | + SMAC_SEL(ep->smac_idx) | + DSCP(ep->tos) | +- ULP_MODE(ULP_MODE_TCPDDP) | + RCV_BUFSIZ(rcv_win>>10); + opt2 = RX_CHANNEL(0) | + RSS_QUEUE_VALID | RSS_QUEUE(ep->rss_qid); +diff --git a/drivers/infiniband/hw/cxgb4/device.c b/drivers/infiniband/hw/cxgb4/device.c +index 40a13cc..e28e13a 100644 +--- a/drivers/infiniband/hw/cxgb4/device.c ++++ b/drivers/infiniband/hw/cxgb4/device.c +@@ -513,7 +513,7 @@ static struct c4iw_dev *c4iw_alloc(const struct cxgb4_lld_info *infop) + devp->rdev.oc_mw_pa = pci_resource_start(devp->rdev.lldi.pdev, 2) + + (pci_resource_len(devp->rdev.lldi.pdev, 2) - + roundup_pow_of_two(devp->rdev.lldi.vr->ocq.size)); +- devp->rdev.oc_mw_kva = ioremap_wc(devp->rdev.oc_mw_pa, ++ devp->rdev.oc_mw_kva = ioremap_nocache(devp->rdev.oc_mw_pa, + devp->rdev.lldi.vr->ocq.size); + + PDBG(KERN_INFO MOD "ocq memory: " +diff --git a/drivers/infiniband/hw/cxgb4/provider.c b/drivers/infiniband/hw/cxgb4/provider.c +index 5b9e422..7f80c2a 100644 +--- a/drivers/infiniband/hw/cxgb4/provider.c ++++ b/drivers/infiniband/hw/cxgb4/provider.c +@@ -347,20 +347,18 @@ static int c4iw_query_port(struct ib_device *ibdev, u8 port, + return 0; + } + +-static ssize_t show_rev(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_rev(struct device *dev, char *buf) + { + struct c4iw_dev *c4iw_dev = container_of(dev, struct c4iw_dev, +- ibdev.dev); ++ ibdev.class_dev); + PDBG("%s dev 0x%p\n", __func__, dev); + return sprintf(buf, "%d\n", c4iw_dev->rdev.lldi.adapter_type); + } + +-static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_fw_ver(struct device *dev, char *buf) + { + struct c4iw_dev *c4iw_dev = container_of(dev, struct c4iw_dev, +- ibdev.dev); ++ ibdev.class_dev); + PDBG("%s dev 0x%p\n", __func__, dev); + + return sprintf(buf, "%u.%u.%u.%u\n", +@@ -370,11 +368,10 @@ static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr, + FW_HDR_FW_VER_BUILD_GET(c4iw_dev->rdev.lldi.fw_vers)); + } + +-static ssize_t show_hca(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_hca(struct device *dev, char *buf) + { + struct c4iw_dev *c4iw_dev = container_of(dev, struct c4iw_dev, +- ibdev.dev); ++ ibdev.class_dev); + struct ethtool_drvinfo info; + struct net_device *lldev = c4iw_dev->rdev.lldi.ports[0]; + +@@ -383,11 +380,10 @@ static ssize_t show_hca(struct device *dev, struct device_attribute *attr, + return sprintf(buf, "%s\n", info.driver); + } + +-static ssize_t show_board(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_board(struct device *dev, char *buf) + { + struct c4iw_dev *c4iw_dev = container_of(dev, struct c4iw_dev, +- ibdev.dev); ++ ibdev.class_dev); + PDBG("%s dev 0x%p\n", __func__, dev); + return sprintf(buf, "%x.%x\n", c4iw_dev->rdev.lldi.pdev->vendor, + c4iw_dev->rdev.lldi.pdev->device); +@@ -409,16 +405,16 @@ static int c4iw_get_mib(struct ib_device *ibdev, + return 0; + } + +-static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +-static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +-static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +-static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); ++static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); ++static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); ++static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); ++static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); + + static struct device_attribute *c4iw_class_attributes[] = { +- &dev_attr_hw_rev, +- &dev_attr_fw_ver, +- &dev_attr_hca_type, +- &dev_attr_board_id, ++ &class_device_attr_hw_rev, ++ &class_device_attr_fw_ver, ++ &class_device_attr_hca_type, ++ &class_device_attr_board_id, + }; + + int c4iw_register_device(struct c4iw_dev *dev) +@@ -518,7 +516,7 @@ int c4iw_register_device(struct c4iw_dev *dev) + goto bail1; + + for (i = 0; i < ARRAY_SIZE(c4iw_class_attributes); ++i) { +- ret = device_create_file(&dev->ibdev.dev, ++ ret = class_device_create_file(&dev->ibdev.class_dev, + c4iw_class_attributes[i]); + if (ret) + goto bail2; +@@ -537,7 +533,7 @@ void c4iw_unregister_device(struct c4iw_dev *dev) + + PDBG("%s c4iw_dev %p\n", __func__, dev); + for (i = 0; i < ARRAY_SIZE(c4iw_class_attributes); ++i) +- device_remove_file(&dev->ibdev.dev, ++ class_device_remove_file(&dev->ibdev.class_dev, + c4iw_class_attributes[i]); + ib_unregister_device(&dev->ibdev); + kfree(dev->ibdev.iwcm); +diff --git a/drivers/infiniband/hw/cxgb4/t4.h b/drivers/infiniband/hw/cxgb4/t4.h +index c0221ee..d5979b1 100644 +--- a/drivers/infiniband/hw/cxgb4/t4.h ++++ b/drivers/infiniband/hw/cxgb4/t4.h +@@ -273,20 +273,12 @@ struct t4_swsqe { + + static inline pgprot_t t4_pgprot_wc(pgprot_t prot) + { +-#if defined(__i386__) || defined(__x86_64__) || defined(CONFIG_PPC64) +- return pgprot_writecombine(prot); +-#else + return pgprot_noncached(prot); +-#endif + } + + static inline int t4_ocqp_supported(void) + { +-#if defined(__i386__) || defined(__x86_64__) || defined(CONFIG_PPC64) +- return 1; +-#else + return 0; +-#endif + } + + enum { + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0060_mpav2.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0060_mpav2.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0060_mpav2.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0060_mpav2.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,61 @@ +diff --git a/drivers/infiniband/hw/cxgb4/cm.c b/drivers/infiniband/hw/cxgb4/cm.c +index d10e475..a567f7f 100644 +--- a/drivers/infiniband/hw/cxgb4/cm.c ++++ b/drivers/infiniband/hw/cxgb4/cm.c +@@ -1822,7 +1822,6 @@ static int c4iw_reconnect(struct c4iw_ep *ep) + int err = 0; + struct rtable *rt; + struct net_device *pdev; +- struct neighbour *neigh; + int step; + + PDBG("%s qp %p cm_id %p\n", __func__, ep->com.qp, ep->com.cm_id); +@@ -1849,17 +1848,16 @@ static int c4iw_reconnect(struct c4iw_ep *ep) + err = -EHOSTUNREACH; + goto fail3; + } +- ep->dst = &rt->dst; +- +- neigh = dst_get_neighbour(ep->dst); ++ ep->dst = &rt->u.dst; + + /* get a l2t entry */ +- if (neigh->dev->flags & IFF_LOOPBACK) { ++ if (ep->dst->neighbour->dev->flags & IFF_LOOPBACK) { + PDBG("%s LOOPBACK\n", __func__); + pdev = ip_dev_find(&init_net, + ep->com.cm_id->remote_addr.sin_addr.s_addr); + ep->l2t = cxgb4_l2t_get(ep->com.dev->rdev.lldi.l2t, +- neigh, pdev, 0); ++ ep->dst->neighbour, ++ pdev, 0); + ep->mtu = pdev->mtu; + ep->tx_chan = cxgb4_port_chan(pdev); + ep->smac_idx = (cxgb4_port_viid(pdev) & 0x7F) << 1; +@@ -1874,18 +1872,20 @@ static int c4iw_reconnect(struct c4iw_ep *ep) + dev_put(pdev); + } else { + ep->l2t = cxgb4_l2t_get(ep->com.dev->rdev.lldi.l2t, +- neigh, neigh->dev, 0); ++ ep->dst->neighbour, ++ ep->dst->neighbour->dev, 0); + ep->mtu = dst_mtu(ep->dst); +- ep->tx_chan = cxgb4_port_chan(neigh->dev); +- ep->smac_idx = (cxgb4_port_viid(neigh->dev) & 0x7F) << 1; ++ ep->tx_chan = cxgb4_port_chan(ep->dst->neighbour->dev); ++ ep->smac_idx = (cxgb4_port_viid(ep->dst->neighbour->dev) & ++ 0x7F) << 1; + step = ep->com.dev->rdev.lldi.ntxq / + ep->com.dev->rdev.lldi.nchan; +- ep->txq_idx = cxgb4_port_idx(neigh->dev) * step; +- ep->ctrlq_idx = cxgb4_port_idx(neigh->dev); ++ ep->txq_idx = cxgb4_port_idx(ep->dst->neighbour->dev) * step; ++ ep->ctrlq_idx = cxgb4_port_idx(ep->dst->neighbour->dev); + step = ep->com.dev->rdev.lldi.nrxq / + ep->com.dev->rdev.lldi.nchan; + ep->rss_qid = ep->com.dev->rdev.lldi.rxq_ids[ +- cxgb4_port_idx(neigh->dev) * step]; ++ cxgb4_port_idx(ep->dst->neighbour->dev) * step]; + } + if (!ep->l2t) { + printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __func__); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0070_use_NIPQUAD.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0070_use_NIPQUAD.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0070_use_NIPQUAD.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0070_use_NIPQUAD.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,71 @@ +diff --git a/drivers/infiniband/hw/cxgb4/device.c b/drivers/infiniband/hw/cxgb4/device.c +index 53d74bf..21eb158 100644 +--- a/drivers/infiniband/hw/cxgb4/device.c ++++ b/drivers/infiniband/hw/cxgb4/device.c +@@ -95,13 +95,14 @@ static int dump_qp(int id, void *p, void *data) + if (qp->ep) + cc = snprintf(qpd->buf + qpd->pos, space, + "qp sq id %u rq id %u state %u onchip %u " +- "ep tid %u state %u %pI4:%u->%pI4:%u\n", ++ "ep tid %u state %u %u.%u.%u.%u:%u->" ++ "%u.%u.%u.%u:%u\n", + qp->wq.sq.qid, qp->wq.rq.qid, (int)qp->attr.state, + qp->wq.sq.flags & T4_SQ_ONCHIP, + qp->ep->hwtid, (int)qp->ep->com.state, +- &qp->ep->com.local_addr.sin_addr.s_addr, ++ NIPQUAD(qp->ep->com.local_addr.sin_addr.s_addr), + ntohs(qp->ep->com.local_addr.sin_port), +- &qp->ep->com.remote_addr.sin_addr.s_addr, ++ NIPQUAD(qp->ep->com.remote_addr.sin_addr.s_addr), + ntohs(qp->ep->com.remote_addr.sin_port)); + else + cc = snprintf(qpd->buf + qpd->pos, space, +diff --git a/drivers/infiniband/hw/cxgb4/provider.c b/drivers/infiniband/hw/cxgb4/provider.c +index 4345a4c..28d76e3 100644 +--- a/drivers/infiniband/hw/cxgb4/provider.c ++++ b/drivers/infiniband/hw/cxgb4/provider.c +@@ -347,7 +347,7 @@ static int c4iw_query_port(struct ib_device *ibdev, u8 port, + return 0; + } + +-static ssize_t show_rev(struct device *dev, char *buf) ++static ssize_t show_rev(struct class_device *dev, char *buf) + { + struct c4iw_dev *c4iw_dev = container_of(dev, struct c4iw_dev, + ibdev.class_dev); +@@ -355,7 +355,7 @@ static ssize_t show_rev(struct device *dev, char *buf) + return sprintf(buf, "%d\n", c4iw_dev->rdev.lldi.adapter_type); + } + +-static ssize_t show_fw_ver(struct device *dev, char *buf) ++static ssize_t show_fw_ver(struct class_device *dev, char *buf) + { + struct c4iw_dev *c4iw_dev = container_of(dev, struct c4iw_dev, + ibdev.class_dev); +@@ -368,7 +368,7 @@ static ssize_t show_fw_ver(struct device *dev, char *buf) + FW_HDR_FW_VER_BUILD_GET(c4iw_dev->rdev.lldi.fw_vers)); + } + +-static ssize_t show_hca(struct device *dev, char *buf) ++static ssize_t show_hca(struct class_device *dev, char *buf) + { + struct c4iw_dev *c4iw_dev = container_of(dev, struct c4iw_dev, + ibdev.class_dev); +@@ -380,7 +380,7 @@ static ssize_t show_hca(struct device *dev, char *buf) + return sprintf(buf, "%s\n", info.driver); + } + +-static ssize_t show_board(struct device *dev, char *buf) ++static ssize_t show_board(struct class_device *dev, char *buf) + { + struct c4iw_dev *c4iw_dev = container_of(dev, struct c4iw_dev, + ibdev.class_dev); +@@ -410,7 +410,7 @@ static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); + static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); + static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); + +-static struct device_attribute *c4iw_class_attributes[] = { ++static struct class_device_attribute *c4iw_class_attributes[] = { + &class_device_attr_hw_rev, + &class_device_attr_fw_ver, + &class_device_attr_hca_type, diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0080_include_seqfile.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0080_include_seqfile.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0080_include_seqfile.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_cxgb4_0080_include_seqfile.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,12 @@ +diff --git a/drivers/infiniband/hw/cxgb4/device.c b/drivers/infiniband/hw/cxgb4/device.c +--- a/drivers/infiniband/hw/cxgb4/device.c ++++ b/drivers/infiniband/hw/cxgb4/device.c +@@ -32,6 +32,7 @@ + #include + #include + #include ++#include + + #include + + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_800_to_2_6_28.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_800_to_2_6_28.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_800_to_2_6_28.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_800_to_2_6_28.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,82 @@ +diff -Nurp linux-2.6/drivers/infiniband/hw/nes/nes_hw.c nes.2_6_28_patch/drivers/infiniband/hw/nes/nes_hw.c +--- linux-2.6/drivers/infiniband/hw/nes/nes_hw.c 2010-05-10 11:20:11.024367000 +0200 ++++ nes.2_6_28_patch/drivers/infiniband/hw/nes/nes_hw.c 2010-05-10 11:21:29.624499000 +0200 +@@ -2647,7 +2647,7 @@ static void nes_nic_napi_ce_handler(stru + { + struct nes_vnic *nesvnic = container_of(cq, struct nes_vnic, nic_cq); + +- napi_schedule(&nesvnic->napi); ++ netif_rx_schedule(nesdev->netdev[nesvnic->netdev_index], &nesvnic->napi); + } + + +diff -Nurp linux-2.6/drivers/infiniband/hw/nes/nes_nic.c nes.2_6_28_patch/drivers/infiniband/hw/nes/nes_nic.c +--- linux-2.6/drivers/infiniband/hw/nes/nes_nic.c 2010-05-10 11:20:11.075361000 +0200 ++++ nes.2_6_28_patch/drivers/infiniband/hw/nes/nes_nic.c 2010-05-10 11:21:29.631496000 +0200 +@@ -99,6 +99,7 @@ static int nics_per_function = 1; + static int nes_netdev_poll(struct napi_struct *napi, int budget) + { + struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi); ++ struct net_device *netdev = nesvnic->netdev; + struct nes_device *nesdev = nesvnic->nesdev; + struct nes_hw_nic_cq *nescq = &nesvnic->nic_cq; + +@@ -111,7 +112,7 @@ static int nes_netdev_poll(struct napi_s + nes_nic_ce_handler(nesdev, nescq); + + if (nescq->cqes_pending == 0) { +- napi_complete(napi); ++ netif_rx_complete(netdev, napi); + /* clear out completed cqes and arm */ + nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT | + nescq->cq_number | (nescq->cqe_allocs_pending << 16)); +@@ -1595,18 +1596,6 @@ static void nes_netdev_vlan_rx_register( + spin_unlock_irqrestore(&nesadapter->phy_lock, flags); + } + +-static const struct net_device_ops nes_netdev_ops = { +- .ndo_open = nes_netdev_open, +- .ndo_stop = nes_netdev_stop, +- .ndo_start_xmit = nes_netdev_start_xmit, +- .ndo_get_stats = nes_netdev_get_stats, +- .ndo_tx_timeout = nes_netdev_tx_timeout, +- .ndo_set_mac_address = nes_netdev_set_mac_address, +- .ndo_set_multicast_list = nes_netdev_set_multicast_list, +- .ndo_change_mtu = nes_netdev_change_mtu, +- .ndo_validate_addr = eth_validate_addr, +- .ndo_vlan_rx_register = nes_netdev_vlan_rx_register, +-}; + + /** + * nes_netdev_init - initialize network device +@@ -1631,6 +1620,17 @@ struct net_device *nes_netdev_init(struc + + SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev); + ++ nesvnic = netdev_priv(netdev); ++ memset(nesvnic, 0, sizeof(*nesvnic)); ++ ++ netdev->open = nes_netdev_open; ++ netdev->stop = nes_netdev_stop; ++ netdev->hard_start_xmit = nes_netdev_start_xmit; ++ netdev->get_stats = nes_netdev_get_stats; ++ netdev->tx_timeout = nes_netdev_tx_timeout; ++ netdev->set_mac_address = nes_netdev_set_mac_address; ++ netdev->set_multicast_list = nes_netdev_set_multicast_list; ++ netdev->change_mtu = nes_netdev_change_mtu; + netdev->watchdog_timeo = NES_TX_TIMEOUT; + netdev->irq = nesdev->pcidev->irq; + netdev->mtu = ETH_DATA_LEN; +@@ -1638,11 +1638,11 @@ struct net_device *nes_netdev_init(struc + netdev->addr_len = ETH_ALEN; + netdev->type = ARPHRD_ETHER; + netdev->features = NETIF_F_HIGHDMA; +- netdev->netdev_ops = &nes_netdev_ops; + netdev->ethtool_ops = &nes_ethtool_ops; + netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128); + nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n"); + netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; ++ netdev->vlan_rx_register = nes_netdev_vlan_rx_register; + + /* Fill in the port structure */ + nesvnic->netdev = netdev; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_870_to_2_6_24.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_870_to_2_6_24.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_870_to_2_6_24.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_870_to_2_6_24.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,27 @@ +diff -Nurp linux-2.6/drivers/infiniband/hw/nes/nes.c nes.2_6_24_patch/drivers/infiniband/hw/nes/nes.c +--- linux-2.6/drivers/infiniband/hw/nes/nes.c 2010-05-10 11:20:10.905359000 +0200 ++++ nes.2_6_24_patch/drivers/infiniband/hw/nes/nes.c 2010-05-10 11:21:29.680495000 +0200 +@@ -1104,19 +1104,19 @@ static ssize_t nes_show_wqm_quanta(struc + static ssize_t nes_store_wqm_quanta(struct device_driver *ddp, + const char *buf, size_t count) + { +- unsigned long wqm_quanta_value; ++ u32 wqm_quanta; + u32 wqm_config1; + u32 i = 0; + struct nes_device *nesdev; + +- strict_strtoul(buf, 0, &wqm_quanta_value); ++ wqm_quanta = simple_strtoul(buf, NULL, 0); + list_for_each_entry(nesdev, &nes_dev_list, list) { + if (i == ee_flsh_adapter) { +- nesdev->nesadapter->wqm_quanta = wqm_quanta_value; ++ nesdev->nesadapter->wqm_quanta = wqm_quanta; + wqm_config1 = nes_read_indexed(nesdev, + NES_IDX_WQM_CONFIG1); + nes_write_indexed(nesdev, NES_IDX_WQM_CONFIG1, +- ((wqm_quanta_value << 1) | ++ ((wqm_quanta << 1) | + (wqm_config1 & 0x00000001))); + break; + } diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_880_to_2_6_23.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_880_to_2_6_23.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_880_to_2_6_23.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_880_to_2_6_23.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,281 @@ +diff --git a/drivers/infiniband/hw/nes/Kconfig b/drivers/infiniband/hw/nes/Kconfig +index 846dc97..7964eba 100644 +--- a/drivers/infiniband/hw/nes/Kconfig ++++ b/drivers/infiniband/hw/nes/Kconfig +@@ -2,7 +2,6 @@ config INFINIBAND_NES + tristate "NetEffect RNIC Driver" + depends on PCI && INET && INFINIBAND + select LIBCRC32C +- select INET_LRO + ---help--- + This is the RDMA Network Interface Card (RNIC) driver for + NetEffect Ethernet Cluster Server Adapters. +diff --git a/drivers/infiniband/hw/nes/nes_hw.c b/drivers/infiniband/hw/nes/nes_hw.c +index 9835893..3c5ae9b 100644 +--- a/drivers/infiniband/hw/nes/nes_hw.c ++++ b/drivers/infiniband/hw/nes/nes_hw.c +@@ -38,14 +38,9 @@ + #include + #include + #include +-#include + + #include "nes.h" + +-static unsigned int nes_lro_max_aggr = NES_LRO_MAX_AGGR; +-module_param(nes_lro_max_aggr, uint, 0444); +-MODULE_PARM_DESC(nes_lro_max_aggr, "NIC LRO max packet aggregation"); +- + static int wide_ppm_offset; + module_param(wide_ppm_offset, int, 0644); + MODULE_PARM_DESC(wide_ppm_offset, "Increase CX4 interface clock ppm offset, 0=100ppm (default), 1=300ppm"); +@@ -1643,25 +1638,6 @@ static void nes_rq_wqes_timeout(unsigned long parm) + } + + +-static int nes_lro_get_skb_hdr(struct sk_buff *skb, void **iphdr, +- void **tcph, u64 *hdr_flags, void *priv) +-{ +- unsigned int ip_len; +- struct iphdr *iph; +- skb_reset_network_header(skb); +- iph = ip_hdr(skb); +- if (iph->protocol != IPPROTO_TCP) +- return -1; +- ip_len = ip_hdrlen(skb); +- skb_set_transport_header(skb, ip_len); +- *tcph = tcp_hdr(skb); +- +- *hdr_flags = LRO_IPV4 | LRO_TCP; +- *iphdr = iph; +- return 0; +-} +- +- + /** + * nes_init_nic_qp + */ +@@ -1896,14 +1872,6 @@ int nes_init_nic_qp(struct nes_device *nesdev, struct net_device *netdev) + return -ENOMEM; + } + +- nesvnic->lro_mgr.max_aggr = nes_lro_max_aggr; +- nesvnic->lro_mgr.max_desc = NES_MAX_LRO_DESCRIPTORS; +- nesvnic->lro_mgr.lro_arr = nesvnic->lro_desc; +- nesvnic->lro_mgr.get_skb_header = nes_lro_get_skb_hdr; +- nesvnic->lro_mgr.features = LRO_F_NAPI | LRO_F_EXTRACT_VLAN_ID; +- nesvnic->lro_mgr.dev = netdev; +- nesvnic->lro_mgr.ip_summed = CHECKSUM_UNNECESSARY; +- nesvnic->lro_mgr.ip_summed_aggr = CHECKSUM_UNNECESSARY; + return 0; + } + +@@ -2776,7 +2744,7 @@ static void nes_nic_napi_ce_handler(struct nes_device *nesdev, struct nes_hw_nic + { + struct nes_vnic *nesvnic = container_of(cq, struct nes_vnic, nic_cq); + +- netif_rx_schedule(nesdev->netdev[nesvnic->netdev_index], &nesvnic->napi); ++ netif_rx_schedule(nesdev->netdev[nesvnic->netdev_index]); + } + + +@@ -2812,13 +2780,10 @@ void nes_nic_ce_handler(struct nes_device *nesdev, struct nes_hw_nic_cq *cq) + u16 pkt_type; + u16 rqes_processed = 0; + u8 sq_cqes = 0; +- u8 nes_use_lro = 0; + + head = cq->cq_head; + cq_size = cq->cq_size; + cq->cqes_pending = 1; +- if (nesvnic->netdev->features & NETIF_F_LRO) +- nes_use_lro = 1; + do { + if (le32_to_cpu(cq->cq_vbase[head].cqe_words[NES_NIC_CQE_MISC_IDX]) & + NES_NIC_CQE_VALID) { +@@ -2952,17 +2917,9 @@ void nes_nic_ce_handler(struct nes_device *nesdev, struct nes_hw_nic_cq *cq) + >> 16); + nes_debug(NES_DBG_CQ, "%s: Reporting stripped VLAN packet. Tag = 0x%04X\n", + nesvnic->netdev->name, vlan_tag); +- if (nes_use_lro) +- lro_vlan_hwaccel_receive_skb(&nesvnic->lro_mgr, rx_skb, +- nesvnic->vlan_grp, vlan_tag, NULL); +- else +- nes_vlan_rx(rx_skb, nesvnic->vlan_grp, vlan_tag); +- } else { +- if (nes_use_lro) +- lro_receive_skb(&nesvnic->lro_mgr, rx_skb, NULL); +- else +- nes_netif_rx(rx_skb); +- } ++ nes_vlan_rx(rx_skb, nesvnic->vlan_grp, vlan_tag); ++ } else ++ nes_netif_rx(rx_skb); + + skip_rx_indicate0: + ; +@@ -2993,8 +2950,6 @@ skip_rx_indicate0: + + } while (1); + +- if (nes_use_lro) +- lro_flush_all(&nesvnic->lro_mgr); + if (sq_cqes) { + barrier(); + /* restart the queue if it had been stopped */ +diff --git a/drivers/infiniband/hw/nes/nes_hw.h b/drivers/infiniband/hw/nes/nes_hw.h +index 11012e5..5cf7a2a 100644 +--- a/drivers/infiniband/hw/nes/nes_hw.h ++++ b/drivers/infiniband/hw/nes/nes_hw.h +@@ -33,8 +33,6 @@ + #ifndef __NES_HW_H + #define __NES_HW_H + +-#include +- + #define NES_PHY_TYPE_CX4 1 + #define NES_PHY_TYPE_1G 2 + #define NES_PHY_TYPE_ARGUS 4 +@@ -1049,8 +1047,6 @@ struct nes_hw_tune_timer { + #define NES_TIMER_ENABLE_LIMIT 4 + #define NES_MAX_LINK_INTERRUPTS 128 + #define NES_MAX_LINK_CHECK 200 +-#define NES_MAX_LRO_DESCRIPTORS 32 +-#define NES_LRO_MAX_AGGR 64 + + struct nes_adapter { + u64 fw_ver; +@@ -1230,7 +1226,6 @@ struct nes_vnic { + u32 msg_enable; + /* u32 tx_avail; */ + __be32 local_ipaddr; +- struct napi_struct napi; + spinlock_t tx_lock; /* could use netdev tx lock? */ + struct timer_list rq_wqes_timer; + u32 nic_mem_size; +@@ -1258,9 +1253,6 @@ struct nes_vnic { + u8 of_device_registered; + u8 rdma_enabled; + u8 rx_checksum_disabled; +- u32 lro_max_aggr; +- struct net_lro_mgr lro_mgr; +- struct net_lro_desc lro_desc[NES_MAX_LRO_DESCRIPTORS]; + struct timer_list event_timer; + enum ib_event_type delayed_event; + enum ib_event_type last_dispatched_event; +diff --git a/drivers/infiniband/hw/nes/nes_nic.c b/drivers/infiniband/hw/nes/nes_nic.c +index 35a581a..37cbcc2 100644 +--- a/drivers/infiniband/hw/nes/nes_nic.c ++++ b/drivers/infiniband/hw/nes/nes_nic.c +@@ -96,35 +96,38 @@ static int nics_per_function = 1; + /** + * nes_netdev_poll + */ +-static int nes_netdev_poll(struct napi_struct *napi, int budget) ++static int nes_netdev_poll(struct net_device *netdev, int *budget_ptr) + { +- struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi); +- struct net_device *netdev = nesvnic->netdev; ++ struct nes_vnic *nesvnic = netdev_priv(netdev); + struct nes_device *nesdev = nesvnic->nesdev; + struct nes_hw_nic_cq *nescq = &nesvnic->nic_cq; +- +- nesvnic->budget = budget; ++ nesvnic->budget = min(netdev->quota, *budget_ptr); + nescq->cqes_pending = 0; + nescq->rx_cqes_completed = 0; + nescq->cqe_allocs_pending = 0; + nescq->rx_pkts_indicated = 0; + + nes_nic_ce_handler(nesdev, nescq); ++ netdev->quota -= nescq->rx_pkts_indicated; ++ *budget_ptr -= nescq->rx_pkts_indicated; + +- if (nescq->cqes_pending == 0) { +- netif_rx_complete(netdev, napi); ++ if ((nescq->cqes_pending == 0) && (netdev->quota != 0)) { ++ netif_rx_complete(netdev); + /* clear out completed cqes and arm */ + nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT | + nescq->cq_number | (nescq->cqe_allocs_pending << 16)); + nes_read32(nesdev->regs+NES_CQE_ALLOC); ++ ++ return 0; + } else { + /* clear out completed cqes but don't arm */ + nes_write32(nesdev->regs+NES_CQE_ALLOC, + nescq->cq_number | (nescq->cqe_allocs_pending << 16)); + nes_debug(NES_DBG_NETDEV, "%s: exiting with work pending\n", + nesvnic->netdev->name); ++ ++ return 1; + } +- return nescq->rx_pkts_indicated; + } + + +@@ -264,7 +267,6 @@ static int nes_netdev_open(struct net_device *netdev) + } + spin_unlock_irqrestore(&nesvnic->port_ibevent_lock, flags); + +- napi_enable(&nesvnic->napi); + nesvnic->netdev_open = 1; + + return 0; +@@ -294,7 +296,6 @@ static int nes_netdev_stop(struct net_device *netdev) + netif_carrier_off(netdev); + + /* Disable network packets */ +- napi_disable(&nesvnic->napi); + netif_stop_queue(netdev); + list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) { + first_nesvnic = container_of(list_pos, struct nes_vnic, list); +@@ -1071,9 +1072,6 @@ static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = { + "Free 4Kpbls", + "Free 256pbls", + "Timer Inits", +- "LRO aggregated", +- "LRO flushed", +- "LRO no_desc", + }; + #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset) + +@@ -1311,9 +1309,6 @@ static void nes_netdev_get_ethtool_stats(struct net_device *netdev, + target_stat_values[++index] = nesadapter->free_4kpbl; + target_stat_values[++index] = nesadapter->free_256pbl; + target_stat_values[++index] = int_mod_timer_init; +- target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated; +- target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed; +- target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc; + } + + /** +@@ -1600,8 +1595,6 @@ static struct ethtool_ops nes_ethtool_ops = { + .set_sg = ethtool_op_set_sg, + .get_tso = ethtool_op_get_tso, + .set_tso = ethtool_op_set_tso, +- .get_flags = ethtool_op_get_flags, +- .set_flags = ethtool_op_set_flags, + }; + + +@@ -1672,7 +1665,8 @@ struct net_device *nes_netdev_init(struct nes_device *nesdev, + netdev->type = ARPHRD_ETHER; + netdev->features = NETIF_F_HIGHDMA; + netdev->ethtool_ops = &nes_ethtool_ops; +- netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128); ++ netdev->poll = nes_netdev_poll; ++ netdev->weight = 128; + nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n"); + netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; + netdev->vlan_rx_register = nes_netdev_vlan_rx_register; +@@ -1704,7 +1698,6 @@ struct net_device *nes_netdev_init(struct nes_device *nesdev, + + if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV)) { + netdev->features |= NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM; +- netdev->features |= NETIF_F_GSO | NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM; + } else { + netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM; + } +-- +1.7.4.2 diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_890_to_2_6_22.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_890_to_2_6_22.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_890_to_2_6_22.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_890_to_2_6_22.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,55 @@ +diff -Nurp linux-2.6/drivers/infiniband/hw/nes/nes.c nes.2_6_22_patch/drivers/infiniband/hw/nes/nes.c +--- linux-2.6/drivers/infiniband/hw/nes/nes.c 2010-05-10 16:43:23.186012000 +0200 ++++ nes.2_6_22_patch/drivers/infiniband/hw/nes/nes.c 2010-05-10 11:21:29.873498000 +0200 +@@ -579,16 +579,22 @@ static int __devinit nes_probe(struct pc + nesdev->nesadapter->port_count; + } + +- if ((limit_maxrdreqsz || +- ((nesdev->nesadapter->phy_type[0] == NES_PHY_TYPE_GLADIUS) && +- (hw_rev == NE020_REV1))) && +- (pcie_get_readrq(pcidev) > 256)) { +- if (pcie_set_readrq(pcidev, 256)) +- printk(KERN_ERR PFX "Unable to set max read request" +- " to 256 bytes\n"); +- else +- nes_debug(NES_DBG_INIT, "Max read request size set" +- " to 256 bytes\n"); ++ if (limit_maxrdreqsz || ++ ((nesdev->nesadapter->phy_type[0] == NES_PHY_TYPE_GLADIUS) && ++ (hw_rev == NE020_REV1))) { ++ u16 maxrdreqword; ++ pci_read_config_word(pcidev, 0x68, &maxrdreqword); ++ /* set bits 12-14 to 001b = 256 bytes */ ++ if ((maxrdreqword & 0x7000) > 0x1000) { ++ maxrdreqword &= 0x8fff; ++ maxrdreqword |= 0x1000; ++ if (pci_write_config_word(pcidev, 0x68, maxrdreqword)) ++ printk(KERN_ERR PFX "Unable to set max read " ++ "request to 256 bytes\n"); ++ else ++ nes_debug(NES_DBG_INIT, "Max read request size" ++ "set to 256 bytes\n"); ++ } + } + + tasklet_init(&nesdev->dpc_tasklet, nes_dpc, (unsigned long)nesdev); +diff -Nurp linux-2.6/drivers/infiniband/hw/nes/nes.h nes.2_6_22_patch/drivers/infiniband/hw/nes/nes.h +--- linux-2.6/drivers/infiniband/hw/nes/nes.h 2010-05-10 11:20:10.950358000 +0200 ++++ nes.2_6_22_patch/drivers/infiniband/hw/nes/nes.h 2010-05-10 11:21:29.878493000 +0200 +@@ -277,14 +277,7 @@ static inline __le32 get_crc_value(struc + u32 crc_value; + crc_value = crc32c(~0, (void *)nes_quad, sizeof (struct nes_v4_quad)); + +- /* +- * With commit ef19454b ("[LIB] crc32c: Keep intermediate crc +- * state in cpu order"), behavior of crc32c changes on +- * big-endian platforms. Our algorithm expects the previous +- * behavior; otherwise we have RDMA connection establishment +- * issue on big-endian. +- */ +- return cpu_to_le32(crc_value); ++ return crc_value; + } + + static inline void diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_900_to_2_6_21.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_900_to_2_6_21.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_900_to_2_6_21.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_900_to_2_6_21.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,23 @@ +diff -Nurp linux-2.6/drivers/infiniband/hw/nes/nes_nic.c nes.2_6_21_patch/drivers/infiniband/hw/nes/nes_nic.c +--- linux-2.6/drivers/infiniband/hw/nes/nes_nic.c 2010-05-10 16:43:23.239012000 +0200 ++++ nes.2_6_21_patch/drivers/infiniband/hw/nes/nes_nic.c 2010-05-10 11:21:30.011485000 +0200 +@@ -1589,6 +1589,11 @@ static void nes_netdev_vlan_rx_register( + spin_unlock_irqrestore(&nesadapter->phy_lock, flags); + } + ++static void nes_netdev_vlan_rx_kill_vid(struct net_device *netdev, ++ unsigned short vid) ++{ ++} ++ + + /** + * nes_netdev_init - initialize network device +@@ -1637,6 +1642,7 @@ struct net_device *nes_netdev_init(struc + nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n"); + netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; + netdev->vlan_rx_register = nes_netdev_vlan_rx_register; ++ netdev->vlan_rx_kill_vid = nes_netdev_vlan_rx_kill_vid; + + /* Fill in the port structure */ + nesvnic->netdev = netdev; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_930_to_2_6_18.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_930_to_2_6_18.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_930_to_2_6_18.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/iw_nes_930_to_2_6_18.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,115 @@ +diff -Nurp linux-2.6/drivers/infiniband/hw/nes/nes_verbs.c nes.2_6_18_patch/drivers/infiniband/hw/nes/nes_verbs.c +--- linux-2.6/drivers/infiniband/hw/nes/nes_verbs.c 2010-05-10 11:20:11.178354000 +0200 ++++ nes.2_6_18_patch/drivers/infiniband/hw/nes/nes_verbs.c 2010-05-10 11:21:30.165489000 +0200 +@@ -2933,11 +2933,10 @@ static int nes_dereg_mr(struct ib_mr *ib + /** + * show_rev + */ +-static ssize_t show_rev(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_rev(struct class_device *cdev, char *buf) + { + struct nes_ib_device *nesibdev = +- container_of(dev, struct nes_ib_device, ibdev.dev); ++ container_of(cdev, struct nes_ib_device, ibdev.class_dev); + struct nes_vnic *nesvnic = nesibdev->nesvnic; + + nes_debug(NES_DBG_INIT, "\n"); +@@ -2948,11 +2947,10 @@ static ssize_t show_rev(struct device *d + /** + * show_fw_ver + */ +-static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_fw_ver(struct class_device *cdev, char *buf) + { + struct nes_ib_device *nesibdev = +- container_of(dev, struct nes_ib_device, ibdev.dev); ++ container_of(cdev, struct nes_ib_device, ibdev.class_dev); + struct nes_vnic *nesvnic = nesibdev->nesvnic; + + nes_debug(NES_DBG_INIT, "\n"); +@@ -2965,8 +2963,7 @@ static ssize_t show_fw_ver(struct device + /** + * show_hca + */ +-static ssize_t show_hca(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_hca(struct class_device *cdev, char *buf) + { + nes_debug(NES_DBG_INIT, "\n"); + return sprintf(buf, "NES020\n"); +@@ -2976,24 +2973,23 @@ static ssize_t show_hca(struct device *d + /** + * show_board + */ +-static ssize_t show_board(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_board(struct class_device *cdev, char *buf) + { + nes_debug(NES_DBG_INIT, "\n"); + return sprintf(buf, "%.*s\n", 32, "NES020 Board ID"); + } + + +-static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +-static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +-static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +-static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); +- +-static struct device_attribute *nes_dev_attributes[] = { +- &dev_attr_hw_rev, +- &dev_attr_fw_ver, +- &dev_attr_hca_type, +- &dev_attr_board_id ++static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); ++static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); ++static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); ++static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); ++ ++static struct class_device_attribute *nes_class_attributes[] = { ++ &class_device_attr_hw_rev, ++ &class_device_attr_fw_ver, ++ &class_device_attr_hca_type, ++ &class_device_attr_board_id + }; + + +@@ -4089,7 +4085,7 @@ struct nes_ib_device *nes_init_ofa_devic + nesibdev->ibdev.phys_port_cnt = 1; + nesibdev->ibdev.num_comp_vectors = 1; + nesibdev->ibdev.dma_device = &nesdev->pcidev->dev; +- nesibdev->ibdev.dev.parent = &nesdev->pcidev->dev; ++ nesibdev->ibdev.class_dev.dev = &nesdev->pcidev->dev; + nesibdev->ibdev.query_device = nes_query_device; + nesibdev->ibdev.query_port = nes_query_port; + nesibdev->ibdev.modify_port = nes_modify_port; +@@ -4184,13 +4180,13 @@ int nes_register_ofa_device(struct nes_i + nesibdev->max_qp = (nesadapter->max_qp-NES_FIRST_QPN) / nesadapter->port_count; + nesibdev->max_pd = nesadapter->max_pd / nesadapter->port_count; + +- for (i = 0; i < ARRAY_SIZE(nes_dev_attributes); ++i) { +- ret = device_create_file(&nesibdev->ibdev.dev, nes_dev_attributes[i]); ++ for (i = 0; i < ARRAY_SIZE(nes_class_attributes); ++i) { ++ ret = class_device_create_file(&nesibdev->ibdev.class_dev, nes_class_attributes[i]); + if (ret) { + while (i > 0) { + i--; +- device_remove_file(&nesibdev->ibdev.dev, +- nes_dev_attributes[i]); ++ class_device_remove_file(&nesibdev->ibdev.class_dev, ++ nes_class_attributes[i]); + } + ib_unregister_device(&nesibdev->ibdev); + return ret; +@@ -4211,8 +4207,8 @@ static void nes_unregister_ofa_device(st + struct nes_vnic *nesvnic = nesibdev->nesvnic; + int i; + +- for (i = 0; i < ARRAY_SIZE(nes_dev_attributes); ++i) { +- device_remove_file(&nesibdev->ibdev.dev, nes_dev_attributes[i]); ++ for (i = 0; i < ARRAY_SIZE(nes_class_attributes); ++i) { ++ class_device_remove_file(&nesibdev->ibdev.class_dev, nes_class_attributes[i]); + } + + if (nesvnic->of_device_registered) { diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0000_z2_6_28_wc.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0000_z2_6_28_wc.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0000_z2_6_28_wc.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0000_z2_6_28_wc.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,235 @@ +Index: ofed_kernel-2.6.16_sles10_sp2/drivers/infiniband/hw/mlx4/wc.c +=================================================================== +--- ofed_kernel-2.6.16_sles10_sp2.orig/drivers/infiniband/hw/mlx4/wc.c 2010-01-07 15:19:15.000000000 +0200 ++++ ofed_kernel-2.6.16_sles10_sp2/drivers/infiniband/hw/mlx4/wc.c 2010-01-07 15:59:22.000000000 +0200 +@@ -35,31 +35,189 @@ + + #if defined(__i386__) || defined(__x86_64__) + ++#define MLX4_PAT_MASK (0xFFFFF8FF) ++#define MLX4_PAT_MOD (0x00000100) ++#define MLX4_WC_FLAGS (_PAGE_PWT) ++#define X86_MSR_PAT_OFFSET 0x277 ++ ++static unsigned int wc_enabled = 0; ++static u32 old_pat_lo[NR_CPUS] = {0}; ++static u32 old_pat_hi[NR_CPUS] = {0}; ++ ++/* Returns non-zero if we have a chipset write-combining problem */ ++static int have_wc_errata(void) ++{ ++ struct pci_dev *dev; ++ u8 rev; ++ ++ if ((dev = pci_get_class(PCI_CLASS_BRIDGE_HOST << 8, NULL)) != NULL) { ++ /* ++ * ServerWorks LE chipsets < rev 6 have problems with ++ * write-combining. ++ */ ++ if (dev->vendor == PCI_VENDOR_ID_SERVERWORKS && ++ dev->device == PCI_DEVICE_ID_SERVERWORKS_LE) { ++ pci_read_config_byte(dev, PCI_CLASS_REVISION, &rev); ++ if (rev <= 5) { ++ printk(KERN_INFO "ib_mlx4: Serverworks LE rev < 6" ++ " detected. Write-combining disabled.\n"); ++ pci_dev_put(dev); ++ return -ENOSYS; ++ } ++ } ++ /* Intel 450NX errata # 23. Non ascending cacheline evictions ++ to write combining memory may resulting in data corruption */ ++ if (dev->vendor == PCI_VENDOR_ID_INTEL && ++ dev->device == PCI_DEVICE_ID_INTEL_82451NX) { ++ printk(KERN_INFO "ib_mlx4: Intel 450NX MMC detected." ++ " Write-combining disabled.\n"); ++ pci_dev_put(dev); ++ return -ENOSYS; ++ } ++ pci_dev_put(dev); ++ } ++ return 0; ++} ++ ++static void rd_old_pat(void *err) ++{ ++ *(int *)err |= rdmsr_safe(X86_MSR_PAT_OFFSET, ++ &old_pat_lo[smp_processor_id()], ++ &old_pat_hi[smp_processor_id()]); ++} ++ ++static void wr_new_pat(void *err) ++{ ++ u32 new_pat_lo = (old_pat_lo[smp_processor_id()] & MLX4_PAT_MASK) | ++ MLX4_PAT_MOD; ++ ++ *(int *)err |= wrmsr_safe(X86_MSR_PAT_OFFSET, ++ new_pat_lo, ++ old_pat_hi[smp_processor_id()]); ++} ++ ++static void wr_old_pat(void *err) ++{ ++ *(int *)err |= wrmsr_safe(X86_MSR_PAT_OFFSET, ++ old_pat_lo[smp_processor_id()], ++ old_pat_hi[smp_processor_id()]); ++} ++ ++static int read_and_modify_pat(void) ++{ ++ int ret = 0; ++ ++ preempt_disable(); ++ rd_old_pat(&ret); ++ if (!ret) ++ smp_call_function(rd_old_pat, &ret, 1); ++ if (ret) ++ goto out; ++ ++ wr_new_pat(&ret); ++ if (ret) ++ goto out; ++ ++ smp_call_function(wr_new_pat, &ret, 1); ++ BUG_ON(ret); /* have inconsistent PAT state */ ++out: ++ preempt_enable(); ++ return ret; ++} ++ ++static int restore_pat(void) ++{ ++ int ret = 0; ++ ++ preempt_disable(); ++ wr_old_pat(&ret); ++ if (!ret) { ++ smp_call_function(wr_old_pat, &ret, 1); ++ BUG_ON(ret); /* have inconsistent PAT state */ ++ } ++ ++ preempt_enable(); ++ return ret; ++} ++ ++int mlx4_enable_wc(void) ++{ ++ struct cpuinfo_x86 *c = &cpu_data(0); ++ int ret; ++ ++ if (wc_enabled) ++ return 0; ++ ++ if (!cpu_has(c, X86_FEATURE_MSR) || ++ !cpu_has(c, X86_FEATURE_PAT)) { ++ printk(KERN_INFO "ib_mlx4: WC not available" ++ " on this processor\n"); ++ return -ENOSYS; ++ } ++ ++ if (have_wc_errata()) ++ return -ENOSYS; ++ ++ if (!(ret = read_and_modify_pat())) ++ wc_enabled = 1; ++ else ++ printk(KERN_INFO "ib_mlx4: failed to enable WC\n"); ++ return ret ? -EIO : 0; ++} ++ ++void mlx4_disable_wc(void) ++{ ++ if (wc_enabled) { ++ if (!restore_pat()) ++ wc_enabled = 0; ++ else ++ printk(KERN_INFO "ib_mlx4: failed to disable WC\n"); ++ } ++} ++ + pgprot_t pgprot_wc(pgprot_t _prot) + { +- return pgprot_writecombine(_prot); ++ return wc_enabled ? __pgprot(pgprot_val(_prot) | MLX4_WC_FLAGS) : ++ pgprot_noncached(_prot); + } + + int mlx4_wc_enabled(void) + { +- return 1; ++ return wc_enabled; + } + + #elif defined(CONFIG_PPC64) + ++static unsigned int wc_enabled = 0; ++ ++int mlx4_enable_wc(void) ++{ ++ wc_enabled = 1; ++ return 0; ++} ++ ++void mlx4_disable_wc(void) ++{ ++ wc_enabled = 0; ++} ++ + pgprot_t pgprot_wc(pgprot_t _prot) + { +- return __pgprot((pgprot_val(_prot) | _PAGE_NO_CACHE) & +- ~(pgprot_t)_PAGE_GUARDED); ++ return wc_enabled ? __pgprot((pgprot_val(_prot) | _PAGE_NO_CACHE) & ++ ~(pgprot_t)_PAGE_GUARDED) : ++ pgprot_noncached(_prot); + } + + int mlx4_wc_enabled(void) + { +- return 1; ++ return wc_enabled; + } + + #else /* !(defined(__i386__) || defined(__x86_64__)) */ + ++int mlx4_enable_wc(void){ return 0; } ++void mlx4_disable_wc(void){} ++ + pgprot_t pgprot_wc(pgprot_t _prot) + { + return pgprot_noncached(_prot); +Index: ofed_kernel-2.6.16_sles10_sp2/drivers/infiniband/hw/mlx4/wc.h +=================================================================== +--- ofed_kernel-2.6.16_sles10_sp2.orig/drivers/infiniband/hw/mlx4/wc.h 2010-01-07 15:19:15.000000000 +0200 ++++ ofed_kernel-2.6.16_sles10_sp2/drivers/infiniband/hw/mlx4/wc.h 2010-01-07 15:59:22.000000000 +0200 +@@ -35,6 +35,8 @@ + + #include + ++int mlx4_enable_wc(void); ++void mlx4_disable_wc(void); + int mlx4_wc_enabled(void); + pgprot_t pgprot_wc(pgprot_t _prot); + +Index: ofed_kernel-2.6.16_sles10_sp2/drivers/infiniband/hw/mlx4/main.c +=================================================================== +--- ofed_kernel-2.6.16_sles10_sp2.orig/drivers/infiniband/hw/mlx4/main.c 2010-01-07 15:19:24.000000000 +0200 ++++ ofed_kernel-2.6.16_sles10_sp2/drivers/infiniband/hw/mlx4/main.c 2010-01-07 16:06:44.000000000 +0200 +@@ -1444,8 +1444,10 @@ static int __init mlx4_ib_init(void) + if (!wq) + return -ENOMEM; + ++ mlx4_enable_wc(); + err = mlx4_register_interface(&mlx4_ib_interface); + if (err) { ++ mlx4_disable_wc(); + destroy_workqueue(wq); + return err; + } +@@ -1456,6 +1458,7 @@ static int __init mlx4_ib_init(void) + static void __exit mlx4_ib_cleanup(void) + { + mlx4_unregister_interface(&mlx4_ib_interface); ++ mlx4_disable_wc(); + destroy_workqueue(wq); + } + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0020_cmd_tout.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0020_cmd_tout.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0020_cmd_tout.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0020_cmd_tout.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,33 @@ +When the system is busy it may happen that the command actually +completed but it took more than the specified timeout till the +task executing the command was actually given CPU time. This test +checks that the completion is really missing before failing. + +Signed-off-by: Eli Cohen + +--- + +--- + drivers/net/mlx4/cmd.c | 9 +++++---- + 1 file changed, 5 insertions(+), 4 deletions(-) + +Index: ofed_kernel/drivers/net/mlx4/cmd.c +=================================================================== +--- ofed_kernel.orig/drivers/net/mlx4/cmd.c ++++ ofed_kernel/drivers/net/mlx4/cmd.c +@@ -282,10 +282,11 @@ static int mlx4_cmd_wait(struct mlx4_dev + mlx4_cmd_post(dev, in_param, out_param ? *out_param : 0, + in_modifier, op_modifier, op, context->token, 1); + +- if (!wait_for_completion_timeout(&context->done, msecs_to_jiffies(timeout))) { +- err = -EBUSY; +- goto out; +- } ++ if (!wait_for_completion_timeout(&context->done, msecs_to_jiffies(timeout))) ++ if (!context->done.done) { ++ err = -EBUSY; ++ goto out; ++ } + + err = context->result; + if (err) diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0030_smp_call_function.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0030_smp_call_function.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0030_smp_call_function.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0030_smp_call_function.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,35 @@ +--- + drivers/infiniband/hw/mlx4/wc.c | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +Index: ofed_kernel/drivers/infiniband/hw/mlx4/wc.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/hw/mlx4/wc.c ++++ ofed_kernel/drivers/infiniband/hw/mlx4/wc.c +@@ -111,7 +111,7 @@ static int read_and_modify_pat(void) + preempt_disable(); + rd_old_pat(&ret); + if (!ret) +- smp_call_function(rd_old_pat, &ret, 1); ++ smp_call_function(rd_old_pat, &ret, 1, 1); + if (ret) + goto out; + +@@ -119,7 +119,7 @@ static int read_and_modify_pat(void) + if (ret) + goto out; + +- smp_call_function(wr_new_pat, &ret, 1); ++ smp_call_function(wr_new_pat, &ret, 1, 1); + BUG_ON(ret); /* have inconsistent PAT state */ + out: + preempt_enable(); +@@ -133,7 +133,7 @@ static int restore_pat(void) + preempt_disable(); + wr_old_pat(&ret); + if (!ret) { +- smp_call_function(wr_old_pat, &ret, 1); ++ smp_call_function(wr_old_pat, &ret, 1, 1); + BUG_ON(ret); /* have inconsistent PAT state */ + } + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0050_wc.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0050_wc.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0050_wc.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0050_wc.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,17 @@ +--- + drivers/infiniband/hw/mlx4/wc.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Index: ofed_kernel/drivers/infiniband/hw/mlx4/wc.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/hw/mlx4/wc.c ++++ ofed_kernel/drivers/infiniband/hw/mlx4/wc.c +@@ -143,7 +143,7 @@ static int restore_pat(void) + + int mlx4_enable_wc(void) + { +- struct cpuinfo_x86 *c = &cpu_data(0); ++ struct cpuinfo_x86 *c = &(cpu_data)[0]; + int ret; + + if (wc_enabled) diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0060_sysfs.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0060_sysfs.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0060_sysfs.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0060_sysfs.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,236 @@ +--- + drivers/infiniband/hw/mlx4/main.c | 153 +++++++++++++++++--------------------- + 1 file changed, 71 insertions(+), 82 deletions(-) + +Index: ofed_kernel-2.6.18-EL5.3/drivers/infiniband/hw/mlx4/main.c +=================================================================== +--- ofed_kernel-2.6.18-EL5.3.orig/drivers/infiniband/hw/mlx4/main.c 2010-02-15 12:03:49.000000000 +0200 ++++ ofed_kernel-2.6.18-EL5.3/drivers/infiniband/hw/mlx4/main.c 2010-02-15 12:05:43.000000000 +0200 +@@ -854,51 +854,42 @@ out: + return err; + } + +-static ssize_t show_hca(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_hca(struct class_device *cdev, char *buf) + { +- struct mlx4_ib_dev *dev = +- container_of(device, struct mlx4_ib_dev, ib_dev.dev); ++ struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev); + return sprintf(buf, "MT%d\n", dev->dev->pdev->device); + } + +-static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_fw_ver(struct class_device *cdev, char *buf) + { +- struct mlx4_ib_dev *dev = +- container_of(device, struct mlx4_ib_dev, ib_dev.dev); ++ struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev); + return sprintf(buf, "%d.%d.%d\n", (int) (dev->dev->caps.fw_ver >> 32), + (int) (dev->dev->caps.fw_ver >> 16) & 0xffff, + (int) dev->dev->caps.fw_ver & 0xffff); + } + +-static ssize_t show_rev(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_rev(struct class_device *cdev, char *buf) + { +- struct mlx4_ib_dev *dev = +- container_of(device, struct mlx4_ib_dev, ib_dev.dev); ++ struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev); + return sprintf(buf, "%x\n", dev->dev->rev_id); + } + +-static ssize_t show_board(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_board(struct class_device *cdev, char *buf) + { +- struct mlx4_ib_dev *dev = +- container_of(device, struct mlx4_ib_dev, ib_dev.dev); +- return sprintf(buf, "%.*s\n", MLX4_BOARD_ID_LEN, +- dev->dev->board_id); +-} +- +-static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +-static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +-static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +-static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); +- +-static struct device_attribute *mlx4_class_attributes[] = { +- &dev_attr_hw_rev, +- &dev_attr_fw_ver, +- &dev_attr_hca_type, +- &dev_attr_board_id ++ struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ib_dev.class_dev); ++ return sprintf(buf, "%.*s\n", MLX4_BOARD_ID_LEN, dev->dev->board_id); ++} ++ ++static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); ++static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); ++static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); ++static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); ++ ++static struct class_device_attribute *mlx4_class_attributes[] = { ++ &class_device_attr_hw_rev, ++ &class_device_attr_fw_ver, ++ &class_device_attr_hca_type, ++ &class_device_attr_board_id + }; + + /* +@@ -906,23 +897,22 @@ static struct device_attribute *mlx4_cla + * the function for _name + */ + #define DEVICE_DIAG_RPRT_ATTR(_name, _offset, _op_mod) \ +-static ssize_t show_rprt_##_name(struct device *dev, \ +- struct device_attribute *attr, \ ++static ssize_t show_rprt_##_name(struct class_device *cdev, \ + char *buf){ \ +- return show_diag_rprt(dev, buf, _offset, _op_mod); \ ++ return show_diag_rprt(cdev, buf, _offset, _op_mod); \ + } \ +-static DEVICE_ATTR(_name, S_IRUGO, show_rprt_##_name, NULL); ++static CLASS_DEVICE_ATTR(_name, S_IRUGO, show_rprt_##_name, NULL); + + #define MLX4_DIAG_RPRT_CLEAR_DIAGS 3 + +-static size_t show_diag_rprt(struct device *device, char *buf, ++static size_t show_diag_rprt(struct class_device *cdev, char *buf, + u32 offset, u8 op_modifier) + { + size_t ret; + u32 counter_offset = offset; + u32 diag_counter = 0; +- struct mlx4_ib_dev *dev = container_of(device, struct mlx4_ib_dev, +- ib_dev.dev); ++ struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ++ ib_dev.class_dev); + + ret = mlx4_query_diag_counters(dev->dev, 1, op_modifier, + &counter_offset, &diag_counter); +@@ -932,13 +922,12 @@ static size_t show_diag_rprt(struct devi + return sprintf(buf,"%d\n", diag_counter); + } + +-static ssize_t clear_diag_counters(struct device *device, +- struct device_attribute *attr, ++static ssize_t clear_diag_counters(struct class_device *cdev, + const char *buf, size_t length) + { + size_t ret; +- struct mlx4_ib_dev *dev = container_of(device, struct mlx4_ib_dev, +- ib_dev.dev); ++ struct mlx4_ib_dev *dev = container_of(cdev, struct mlx4_ib_dev, ++ ib_dev.class_dev); + + ret = mlx4_query_diag_counters(dev->dev, 0, MLX4_DIAG_RPRT_CLEAR_DIAGS, + NULL, NULL); +@@ -984,45 +973,45 @@ DEVICE_DIAG_RPRT_ATTR(num_cqovf , 0x1A0 + DEVICE_DIAG_RPRT_ATTR(num_eqovf , 0x1A4, 2); + DEVICE_DIAG_RPRT_ATTR(num_baddb , 0x1A8, 2); + +-static DEVICE_ATTR(clear_diag, S_IWUGO, NULL, clear_diag_counters); ++static CLASS_DEVICE_ATTR(clear_diag, S_IWUGO, NULL, clear_diag_counters); + + static struct attribute *diag_rprt_attrs[] = { +- &dev_attr_rq_num_lle.attr, +- &dev_attr_sq_num_lle.attr, +- &dev_attr_rq_num_lqpoe.attr, +- &dev_attr_sq_num_lqpoe.attr, +- &dev_attr_rq_num_leeoe.attr, +- &dev_attr_sq_num_leeoe.attr, +- &dev_attr_rq_num_lpe.attr, +- &dev_attr_sq_num_lpe.attr, +- &dev_attr_rq_num_wrfe.attr, +- &dev_attr_sq_num_wrfe.attr, +- &dev_attr_sq_num_mwbe.attr, +- &dev_attr_sq_num_bre.attr, +- &dev_attr_rq_num_lae.attr, +- &dev_attr_sq_num_rire.attr, +- &dev_attr_rq_num_rire.attr, +- &dev_attr_sq_num_rae.attr, +- &dev_attr_rq_num_rae.attr, +- &dev_attr_sq_num_roe.attr, +- &dev_attr_sq_num_tree.attr, +- &dev_attr_sq_num_rree.attr, +- &dev_attr_rq_num_rnr.attr, +- &dev_attr_sq_num_rnr.attr, +- &dev_attr_sq_num_rabrte.attr, +- &dev_attr_sq_num_ieecne.attr, +- &dev_attr_sq_num_ieecse.attr, +- &dev_attr_rq_num_oos.attr, +- &dev_attr_sq_num_oos.attr, +- &dev_attr_rq_num_mce.attr, +- &dev_attr_rq_num_rsync.attr, +- &dev_attr_sq_num_rsync.attr, +- &dev_attr_rq_num_udsdprd.attr, +- &dev_attr_rq_num_ucsdprd.attr, +- &dev_attr_num_cqovf.attr, +- &dev_attr_num_eqovf.attr, +- &dev_attr_num_baddb.attr, +- &dev_attr_clear_diag.attr, ++ &class_device_attr_rq_num_lle.attr, ++ &class_device_attr_sq_num_lle.attr, ++ &class_device_attr_rq_num_lqpoe.attr, ++ &class_device_attr_sq_num_lqpoe.attr, ++ &class_device_attr_rq_num_leeoe.attr, ++ &class_device_attr_sq_num_leeoe.attr, ++ &class_device_attr_rq_num_lpe.attr, ++ &class_device_attr_sq_num_lpe.attr, ++ &class_device_attr_rq_num_wrfe.attr, ++ &class_device_attr_sq_num_wrfe.attr, ++ &class_device_attr_sq_num_mwbe.attr, ++ &class_device_attr_sq_num_bre.attr, ++ &class_device_attr_rq_num_lae.attr, ++ &class_device_attr_sq_num_rire.attr, ++ &class_device_attr_rq_num_rire.attr, ++ &class_device_attr_sq_num_rae.attr, ++ &class_device_attr_rq_num_rae.attr, ++ &class_device_attr_sq_num_roe.attr, ++ &class_device_attr_sq_num_tree.attr, ++ &class_device_attr_sq_num_rree.attr, ++ &class_device_attr_rq_num_rnr.attr, ++ &class_device_attr_sq_num_rnr.attr, ++ &class_device_attr_sq_num_rabrte.attr, ++ &class_device_attr_sq_num_ieecne.attr, ++ &class_device_attr_sq_num_ieecse.attr, ++ &class_device_attr_rq_num_oos.attr, ++ &class_device_attr_sq_num_oos.attr, ++ &class_device_attr_rq_num_mce.attr, ++ &class_device_attr_rq_num_rsync.attr, ++ &class_device_attr_sq_num_rsync.attr, ++ &class_device_attr_rq_num_udsdprd.attr, ++ &class_device_attr_rq_num_ucsdprd.attr, ++ &class_device_attr_num_cqovf.attr, ++ &class_device_attr_num_eqovf.attr, ++ &class_device_attr_num_baddb.attr, ++ &class_device_attr_clear_diag.attr, + NULL + }; + +@@ -1331,12 +1320,12 @@ static void *mlx4_ib_add(struct mlx4_dev + goto err_reg; + } + for (i = 0; i < ARRAY_SIZE(mlx4_class_attributes); ++i) { +- if (device_create_file(&ibdev->ib_dev.dev, +- mlx4_class_attributes[i])) ++ if (class_device_create_file(&ibdev->ib_dev.class_dev, ++ mlx4_class_attributes[i])) + goto err_notif; + } + +- if(sysfs_create_group(&ibdev->ib_dev.dev.kobj, &diag_counters_group)) ++ if(sysfs_create_group(&ibdev->ib_dev.class_dev.kobj, &diag_counters_group)) + goto err_notif; + + ibdev->ib_active = 1; +@@ -1376,7 +1365,7 @@ static void mlx4_ib_remove(struct mlx4_d + int p; + int k; + +- sysfs_remove_group(&ibdev->ib_dev.dev.kobj, &diag_counters_group); ++ sysfs_remove_group(&ibdev->ib_dev.class_dev.kobj, &diag_counters_group); + + mlx4_ib_mad_cleanup(ibdev); + ib_unregister_device(&ibdev->ib_dev); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0060_undo_pI6.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0060_undo_pI6.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0060_undo_pI6.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0060_undo_pI6.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,47 @@ +mlx4: Undo %pI6 for printing gids + +(commit 8867cd7c8678ff2d9d0382dbbfbcc7a3e7e61cbc) + +Signed-off-by: Jack Morgenstein + +Index: ofed_kernel-fixes/drivers/net/mlx4/mcg.c +=================================================================== +--- ofed_kernel-fixes.orig/drivers/net/mlx4/mcg.c 2009-07-20 13:50:08.000000000 +0300 ++++ ofed_kernel-fixes/drivers/net/mlx4/mcg.c 2009-07-20 13:55:05.000000000 +0300 +@@ -118,7 +118,17 @@ static int find_mgm(struct mlx4_dev *dev + return err; + + if (0) +- mlx4_dbg(dev, "Hash for %pI6 is %04x\n", gid, *hash); ++ mlx4_dbg(dev, "Hash for %04x:%04x:%04x:%04x:" ++ "%04x:%04x:%04x:%04x is %04x\n", ++ be16_to_cpu(((__be16 *) gid)[0]), ++ be16_to_cpu(((__be16 *) gid)[1]), ++ be16_to_cpu(((__be16 *) gid)[2]), ++ be16_to_cpu(((__be16 *) gid)[3]), ++ be16_to_cpu(((__be16 *) gid)[4]), ++ be16_to_cpu(((__be16 *) gid)[5]), ++ be16_to_cpu(((__be16 *) gid)[6]), ++ be16_to_cpu(((__be16 *) gid)[7]), ++ *hash); + + *index = *hash; + *prev = -1; +@@ -264,7 +274,16 @@ int mlx4_multicast_detach(struct mlx4_de + goto out; + + if (index == -1) { +- mlx4_err(dev, "MGID %pI6 not found\n", gid); ++ mlx4_err(dev, "MGID %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x " ++ "not found\n", ++ be16_to_cpu(((__be16 *) gid)[0]), ++ be16_to_cpu(((__be16 *) gid)[1]), ++ be16_to_cpu(((__be16 *) gid)[2]), ++ be16_to_cpu(((__be16 *) gid)[3]), ++ be16_to_cpu(((__be16 *) gid)[4]), ++ be16_to_cpu(((__be16 *) gid)[5]), ++ be16_to_cpu(((__be16 *) gid)[6]), ++ be16_to_cpu(((__be16 *) gid)[7])); + err = -EINVAL; + goto out; + } diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0070_disable_blue_flame_to_2.6.27.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0070_disable_blue_flame_to_2.6.27.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0070_disable_blue_flame_to_2.6.27.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0070_disable_blue_flame_to_2.6.27.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,163 @@ +From edf73c0165394d31f02b6e1438b987931981556d Mon Sep 17 00:00:00 2001 +From: Eli Cohen +Date: Tue, 30 Nov 2010 15:15:00 +0200 +Subject: [PATCH] Disable blue flame for kernels without WC + +kernels older than 2.6.28 do not support WC so disable blue flame for them. + +Signed-off-by: Eli Cohen +--- + drivers/net/mlx4/pd.c | 88 ++----------------------------------------------- + 1 files changed, 3 insertions(+), 85 deletions(-) + +Index: ofa_1_5_dev_kernel-20101214-1002_linux-2.6.24.3_check/drivers/net/mlx4/pd.c +=================================================================== +--- ofa_1_5_dev_kernel-20101214-1002_linux-2.6.24.3_check.orig/drivers/net/mlx4/pd.c 2010-12-14 10:08:30.000000000 +0200 ++++ ofa_1_5_dev_kernel-20101214-1002_linux-2.6.24.3_check/drivers/net/mlx4/pd.c 2010-12-14 12:26:57.000000000 +0200 +@@ -33,7 +33,6 @@ + + #include + #include +-#include + + #include + +@@ -97,97 +96,14 @@ EXPORT_SYMBOL_GPL(mlx4_uar_free); + + int mlx4_bf_alloc(struct mlx4_dev *dev, struct mlx4_bf *bf) + { +- struct mlx4_priv *priv = mlx4_priv(dev); +- struct mlx4_uar *uar; +- int err = 0; +- int idx; +- +- if (!priv->bf_mapping) +- return -ENOMEM; +- +- mutex_lock(&priv->bf_mutex); +- if (!list_empty(&priv->bf_list)) +- uar = list_entry(priv->bf_list.next, struct mlx4_uar, bf_list); +- else { +- if (mlx4_bitmap_avail(&priv->uar_table.bitmap) < MLX4_NUM_RESERVED_UARS) { +- err = -ENOMEM; +- goto out; +- } +- uar = kmalloc(sizeof *uar, GFP_KERNEL); +- if (!uar) { +- err = -ENOMEM; +- goto out; +- } +- err = mlx4_uar_alloc(dev, uar); +- if (err) +- goto free_kmalloc; +- +- uar->map = ioremap(uar->pfn << PAGE_SHIFT, PAGE_SIZE); +- if (!uar->map) { +- err = -ENOMEM; +- goto free_uar; +- } +- +- uar->bf_map = io_mapping_map_wc(priv->bf_mapping, uar->index << PAGE_SHIFT); +- if (!uar->bf_map) { +- err = -ENOMEM; +- goto unamp_uar; +- } +- uar->free_bf_bmap = 0; +- list_add(&uar->bf_list, &priv->bf_list); +- } +- +- bf->uar = uar; +- idx = ffz(uar->free_bf_bmap); +- uar->free_bf_bmap |= 1 << idx; +- bf->uar = uar; +- bf->offset = 0; +- bf->buf_size = dev->caps.bf_reg_size / 2; +- bf->reg = uar->bf_map + idx * dev->caps.bf_reg_size; +- if (uar->free_bf_bmap == (1 << dev->caps.bf_regs_per_page) - 1) +- list_del_init(&uar->bf_list); +- +- goto out; +- +-unamp_uar: +- bf->uar = NULL; +- iounmap(uar->map); +- +-free_uar: +- mlx4_uar_free(dev, uar); +- +-free_kmalloc: +- kfree(uar); +- +-out: +- mutex_unlock(&priv->bf_mutex); +- return err; ++ memset(bf, 0, sizeof *bf); ++ return -ENOSYS; + } + EXPORT_SYMBOL_GPL(mlx4_bf_alloc); + + void mlx4_bf_free(struct mlx4_dev *dev, struct mlx4_bf *bf) + { +- struct mlx4_priv *priv = mlx4_priv(dev); +- int idx; +- +- if (!bf->uar || !bf->uar->bf_map) +- return; +- +- mutex_lock(&priv->bf_mutex); +- idx = (bf->reg - bf->uar->bf_map) / dev->caps.bf_reg_size; +- bf->uar->free_bf_bmap &= ~(1 << idx); +- if (!bf->uar->free_bf_bmap) { +- if (!list_empty(&bf->uar->bf_list)) +- list_del(&bf->uar->bf_list); +- +- io_mapping_unmap(bf->uar->bf_map); +- iounmap(bf->uar->map); +- mlx4_uar_free(dev, bf->uar); +- kfree(bf->uar); +- } else if (list_empty(&bf->uar->bf_list)) +- list_add(&bf->uar->bf_list, &priv->bf_list); +- +- mutex_unlock(&priv->bf_mutex); ++ return; + } + EXPORT_SYMBOL_GPL(mlx4_bf_free); + +Index: ofa_1_5_dev_kernel-20101214-1002_linux-2.6.24.3_check/drivers/net/mlx4/main.c +=================================================================== +--- ofa_1_5_dev_kernel-20101214-1002_linux-2.6.24.3_check.orig/drivers/net/mlx4/main.c 2010-12-14 10:08:29.000000000 +0200 ++++ ofa_1_5_dev_kernel-20101214-1002_linux-2.6.24.3_check/drivers/net/mlx4/main.c 2010-12-14 12:25:25.000000000 +0200 +@@ -38,7 +38,6 @@ + #include + #include + #include +-#include + + #include + #include +@@ -876,24 +875,11 @@ static void mlx4_free_icms(struct mlx4_d + + static int map_bf_area(struct mlx4_dev *dev) + { +- struct mlx4_priv *priv = mlx4_priv(dev); +- resource_size_t bf_start; +- resource_size_t bf_len; +- int err = 0; +- +- bf_start = pci_resource_start(dev->pdev, 2) + (dev->caps.num_uars << PAGE_SHIFT); +- bf_len = pci_resource_len(dev->pdev, 2) - (dev->caps.num_uars << PAGE_SHIFT); +- priv->bf_mapping = io_mapping_create_wc(bf_start, bf_len); +- if (!priv->bf_mapping) +- err = -ENOMEM; +- +- return err; ++ return -1; + } + + static void unmap_bf_area(struct mlx4_dev *dev) + { +- if (mlx4_priv(dev)->bf_mapping) +- io_mapping_free(mlx4_priv(dev)->bf_mapping); + } + + static void mlx4_close_hca(struct mlx4_dev *dev) diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0070_rhel_large_kmalloc.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0070_rhel_large_kmalloc.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0070_rhel_large_kmalloc.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0070_rhel_large_kmalloc.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,64 @@ +commit a7f18a776785aecb5eb9967aef6f0f603b698ba0 +Author: Doug Ledford +Date: Thu Jul 16 12:47:55 2009 -0400 + +mlx4: Fix attempts to use kmalloc on overly large allocations + +Based on Doug Ledford's patch for mthca. + +Signed-off-by: Jack Morgenstein + +diff --git a/drivers/net/mlx4/mr.c b/drivers/net/mlx4/mr.c +index d606edf..312e18d 100644 +--- a/drivers/net/mlx4/mr.c ++++ b/drivers/net/mlx4/mr.c +@@ -145,8 +145,11 @@ static int lx4_buddy_init(struct mlx4_buddy *buddy, int max_order) + goto err_out; + + for (i = 0; i <= buddy->max_order; ++i) { +- s = BITS_TO_LONGS(1 << (buddy->max_order - i)); +- buddy->bits[i] = kmalloc(s * sizeof (long), GFP_KERNEL); ++ s = BITS_TO_LONGS(1 << (buddy->max_order - i)) * sizeof(long); ++ if(s > PAGE_SIZE) ++ buddy->bits[i] = (unsigned long *)__get_free_pages(GFP_KERNEL, get_order(s)); ++ else ++ buddy->bits[i] = kmalloc(s, GFP_KERNEL); + if (!buddy->bits[i]) + goto err_out_free; + bitmap_zero(buddy->bits[i], 1 << (buddy->max_order - i)); +@@ -159,9 +162,13 @@ static int mlx4_buddy_init(struct mlx4_buddy *buddy, int max_order) + return 0; + + err_out_free: +- for (i = 0; i <= buddy->max_order; ++i) +- kfree(buddy->bits[i]); +- ++ for (i = 0; i <= buddy->max_order; ++i){ ++ s = BITS_TO_LONGS(1 << (buddy->max_order - i)) * sizeof(long); ++ if(s > PAGE_SIZE) ++ free_pages((unsigned long)buddy->bits[i], get_order(s)); ++ else ++ kfree(buddy->bits[i]); ++ } + err_out: + kfree(buddy->bits); + kfree(buddy->num_free); +@@ -171,10 +178,15 @@ err_out: + + static void mlx4_buddy_cleanup(struct mlx4_buddy *buddy) + { +- int i; ++ int i, s; + +- for (i = 0; i <= buddy->max_order; ++i) +- kfree(buddy->bits[i]); ++ for (i = 0; i <= buddy->max_order; ++i){ ++ s = BITS_TO_LONGS(1 << (buddy->max_order - i)) * sizeof(long); ++ if(s > PAGE_SIZE) ++ free_pages((unsigned long)buddy->bits[i], get_order(s)); ++ else ++ kfree(buddy->bits[i]); ++ } + + kfree(buddy->bits); + kfree(buddy->num_free); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0100_net_eq_to_2.6.25.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0100_net_eq_to_2.6.25.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0100_net_eq_to_2.6.25.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0100_net_eq_to_2.6.25.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,14 @@ +Index: ofed_kernel-2.6.16_sles10_sp2/drivers/infiniband/hw/mlx4/main.c +=================================================================== +--- ofed_kernel-2.6.16_sles10_sp2.orig/drivers/infiniband/hw/mlx4/main.c 2010-02-15 13:46:29.000000000 +0200 ++++ ofed_kernel-2.6.16_sles10_sp2/drivers/infiniband/hw/mlx4/main.c 2010-02-15 13:51:19.000000000 +0200 +@@ -1117,9 +1117,6 @@ static int mlx4_ib_netdev_event(struct n + struct mlx4_ib_iboe *iboe; + int port; + +- if (!net_eq(dev_net(dev), &init_net)) +- return NOTIFY_DONE; +- + ibdev = container_of(this, struct mlx4_ib_dev, iboe.nb); + iboe = &ibdev->iboe; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0110_to_2.6.18_el5.5.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0110_to_2.6.18_el5.5.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0110_to_2.6.18_el5.5.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_0110_to_2.6.18_el5.5.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,13 @@ +Index: ofa_1_5_dev_kernel-20100822-1825_linux-2.6.18-194.el5_check/drivers/infiniband/hw/mlx4/main.c +=================================================================== +--- ofa_1_5_dev_kernel-20100822-1825_linux-2.6.18-194.el5_check.orig/drivers/infiniband/hw/mlx4/main.c 2010-08-22 18:40:28.000000000 +0300 ++++ ofa_1_5_dev_kernel-20100822-1825_linux-2.6.18-194.el5_check/drivers/infiniband/hw/mlx4/main.c 2010-08-22 18:43:45.000000000 +0300 +@@ -1083,7 +1083,7 @@ static int update_ipv6_gids(struct mlx4_ + } + + read_lock(&dev_base_lock); +- for_each_netdev(&init_net, tmp) { ++ for (tmp = dev_base; tmp; tmp = tmp->next) { + if (ndev && (tmp == ndev || rdma_vlan_dev_real_dev(tmp) == ndev)) { + gid.global.subnet_prefix = cpu_to_be64(0xfe80000000000000LL); + vid = rdma_vlan_dev_vlan_id(tmp); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0010_do_not_use_netdev_ops.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0010_do_not_use_netdev_ops.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0010_do_not_use_netdev_ops.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0010_do_not_use_netdev_ops.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,65 @@ +From 34a43622ec035aa41a5383c31245838472784c1b Mon Sep 17 00:00:00 2001 +From: Yevgeny Petrilin +Date: Sun, 31 May 2009 11:59:25 +0300 +Subject: [PATCH 1/8] mlx4_en: Don't use netdev_ops + +Signed-off-by: Yevgeny Petrilin +--- + drivers/net/mlx4/en_netdev.c | 34 +++++++++++++++------------------- + 1 files changed, 15 insertions(+), 19 deletions(-) + +diff --git a/drivers/net/mlx4/en_netdev.c b/drivers/net/mlx4/en_netdev.c +index a38adf5..4ad5f3c 100644 +--- a/drivers/net/mlx4/en_netdev.c ++++ b/drivers/net/mlx4/en_netdev.c +@@ -933,24 +933,6 @@ static int mlx4_en_change_mtu(struct net_device *dev, int new_mtu) + return 0; + } + +-static const struct net_device_ops mlx4_netdev_ops = { +- .ndo_open = mlx4_en_open, +- .ndo_stop = mlx4_en_close, +- .ndo_start_xmit = mlx4_en_xmit, +- .ndo_select_queue = mlx4_en_select_queue, +- .ndo_get_stats = mlx4_en_get_stats, +- .ndo_set_multicast_list = mlx4_en_set_multicast, +- .ndo_set_mac_address = mlx4_en_set_mac, +- .ndo_validate_addr = eth_validate_addr, +- .ndo_change_mtu = mlx4_en_change_mtu, +- .ndo_tx_timeout = mlx4_en_tx_timeout, +- .ndo_vlan_rx_register = mlx4_en_vlan_rx_register, +- .ndo_vlan_rx_add_vid = mlx4_en_vlan_rx_add_vid, +- .ndo_vlan_rx_kill_vid = mlx4_en_vlan_rx_kill_vid, +-#ifdef CONFIG_NET_POLL_CONTROLLER +- .ndo_poll_controller = mlx4_en_netpoll, +-#endif +-}; + + int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, + struct mlx4_en_port_profile *prof) +@@ -1026,7 +1008,21 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, + /* + * Initialize netdev entry points + */ +- dev->netdev_ops = &mlx4_netdev_ops; ++ dev->open = mlx4_en_open; ++ dev->stop = mlx4_en_close; ++ dev->hard_start_xmit = mlx4_en_xmit, ++ dev->select_queue = mlx4_en_select_queue, ++ dev->get_stats = mlx4_en_get_stats, ++ dev->set_multicast_list = mlx4_en_set_multicast, ++ dev->set_mac_address = mlx4_en_set_mac, ++ dev->change_mtu = mlx4_en_change_mtu, ++ dev->tx_timeout = mlx4_en_tx_timeout, ++ dev->vlan_rx_register = mlx4_en_vlan_rx_register, ++ dev->vlan_rx_add_vid = mlx4_en_vlan_rx_add_vid, ++ dev->vlan_rx_kill_vid = mlx4_en_vlan_rx_kill_vid, ++#ifdef CONFIG_NET_POLL_CONTROLLER ++ dev->poll_controller = mlx4_en_netpoll, ++#endif + dev->watchdog_timeo = MLX4_EN_WATCHDOG_TIMEOUT; + + SET_ETHTOOL_OPS(dev, &mlx4_en_ethtool_ops); +-- +1.6.1.3 + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0020_cancel_multiqueue.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0020_cancel_multiqueue.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0020_cancel_multiqueue.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0020_cancel_multiqueue.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,106 @@ +From b2e4cdd87beed5971b2f5f0c7c2d75458afb78d7 Mon Sep 17 00:00:00 2001 +From: Yevgeny Petrilin +Date: Sun, 21 Jun 2009 14:47:46 +0300 +Subject: [PATCH] mlx4_en: Cancel multiqueue + +Signed-off-by: Yevgeny Petrilin +--- + drivers/net/mlx4/en_netdev.c | 7 +++---- + drivers/net/mlx4/en_tx.c | 8 ++++---- + drivers/net/mlx4/mlx4_en.h | 1 - + 3 files changed, 7 insertions(+), 9 deletions(-) + +diff --git a/drivers/net/mlx4/en_netdev.c b/drivers/net/mlx4/en_netdev.c +index 63647c0..d8e73ec 100644 +--- a/drivers/net/mlx4/en_netdev.c ++++ b/drivers/net/mlx4/en_netdev.c +@@ -672,7 +672,7 @@ int mlx4_en_start_port(struct net_device *dev) + queue_work(mdev->workqueue, &priv->mcast_task); + + priv->port_up = true; +- netif_tx_start_all_queues(dev); ++ netif_start_queue(dev); + return 0; + + mac_err: +@@ -707,7 +707,7 @@ void mlx4_en_stop_port(struct net_device *dev) + + /* Synchronize with tx routine */ + netif_tx_lock_bh(dev); +- netif_tx_stop_all_queues(dev); ++ netif_stop_queue(dev); + netif_tx_unlock_bh(dev); + + /* close port*/ +@@ -946,7 +946,7 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, + int i; + int err; + +- dev = alloc_etherdev_mq(sizeof(struct mlx4_en_priv), prof->tx_ring_num); ++ dev = alloc_etherdev(sizeof(struct mlx4_en_priv)); + if (dev == NULL) { + mlx4_err(mdev, "Net device allocation failed\n"); + return -ENOMEM; +@@ -1014,7 +1014,6 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, + dev->open = mlx4_en_open; + dev->stop = mlx4_en_close; + dev->hard_start_xmit = mlx4_en_xmit, +- dev->select_queue = mlx4_en_select_queue, + dev->get_stats = mlx4_en_get_stats, + dev->set_multicast_list = mlx4_en_set_multicast, + dev->set_mac_address = mlx4_en_set_mac, +diff --git a/drivers/net/mlx4/en_tx.c b/drivers/net/mlx4/en_tx.c +index b421dfd..180f2c3 100644 +--- a/drivers/net/mlx4/en_tx.c ++++ b/drivers/net/mlx4/en_tx.c +@@ -387,7 +387,7 @@ static void mlx4_en_process_tx_cq(struct net_device *dev, struct mlx4_en_cq *cq) + if ((u32) (ring->prod - ring->cons) <= + ring->size - HEADROOM - MAX_DESC_TXBBS) { + ring->blocked = 0; +- netif_tx_wake_queue(netdev_get_tx_queue(dev, cq->ring)); ++ netif_wake_queue(dev); + priv->port_stats.wake_queue++; + } + } +@@ -599,7 +599,7 @@ static void build_inline_wqe(struct mlx4_en_tx_desc *tx_desc, struct sk_buff *sk + tx_desc->ctrl.fence_size = (real_size / 16) & 0x3f; + } + +-u16 mlx4_en_select_queue(struct net_device *dev, struct sk_buff *skb) ++static int mlx4_en_select_queue(struct net_device *dev, struct sk_buff *skb) + { + struct mlx4_en_priv *priv = netdev_priv(dev); + u16 vlan_tag = 0; +@@ -686,7 +686,7 @@ int mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev) + goto tx_drop; + } + +- tx_ind = skb->queue_mapping; ++ tx_ind = mlx4_en_select_queue(dev, skb); + ring = &priv->tx_ring[tx_ind]; + if (priv->vlgrp && vlan_tx_tag_present(skb)) + vlan_tag = vlan_tx_tag_get(skb); +@@ -695,7 +695,7 @@ int mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev) + if (unlikely(((int)(ring->prod - ring->cons)) > + ring->size - HEADROOM - MAX_DESC_TXBBS)) { + /* every full Tx ring stops queue */ +- netif_tx_stop_queue(netdev_get_tx_queue(dev, tx_ind)); ++ netif_stop_queue(dev); + ring->blocked = 1; + priv->port_stats.queue_stopped++; + +diff --git a/drivers/net/mlx4/mlx4_en.h b/drivers/net/mlx4/mlx4_en.h +index 7ffad46..efb308b 100644 +--- a/drivers/net/mlx4/mlx4_en.h ++++ b/drivers/net/mlx4/mlx4_en.h +@@ -552,7 +552,6 @@ int mlx4_en_arm_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq); + + void mlx4_en_poll_tx_cq(unsigned long data); + void mlx4_en_tx_irq(struct mlx4_cq *mcq); +-u16 mlx4_en_select_queue(struct net_device *dev, struct sk_buff *skb); + int mlx4_en_xmit(struct sk_buff *skb, struct net_device *dev); + + int mlx4_en_create_tx_ring(struct mlx4_en_priv *priv, struct mlx4_en_tx_ring *ring, +-- +1.6.3 + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0030_lro_backport.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0030_lro_backport.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0030_lro_backport.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0030_lro_backport.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,864 @@ +From 7b8147a850d4b509b983dfa20afcbf7776a3b3a3 Mon Sep 17 00:00:00 2001 +From: Yevgeny Petrilin +Date: Tue, 4 Aug 2009 15:02:48 +0300 +Subject: [PATCH] mlx4_en: use own lro implemetation + +Signed-off-by: Yevgeny Petrilin +--- + drivers/net/mlx4/Makefile | 2 +- + drivers/net/mlx4/en_ethtool.c | 17 -- + drivers/net/mlx4/en_lro.c | 538 +++++++++++++++++++++++++++++++++++++++++ + drivers/net/mlx4/en_rx.c | 109 +++------ + drivers/net/mlx4/mlx4_en.h | 51 ++++- + 5 files changed, 619 insertions(+), 98 deletions(-) + create mode 100644 drivers/net/mlx4/en_lro.c + +Index: ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/Makefile +=================================================================== +--- ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check.orig/drivers/net/mlx4/Makefile 2010-12-02 10:43:03.000000000 +0200 ++++ ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/Makefile 2010-12-02 13:13:51.000000000 +0200 +@@ -6,4 +6,4 @@ + obj-$(CONFIG_MLX4_EN) += mlx4_en.o + + mlx4_en-y := en_main.o en_tx.o en_rx.o en_ethtool.o en_port.o en_cq.o \ +- en_resources.o en_netdev.o en_frag.o en_selftest.o ++ en_resources.o en_netdev.o en_frag.o en_selftest.o en_lro.o +Index: ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/en_ethtool.c +=================================================================== +--- ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check.orig/drivers/net/mlx4/en_ethtool.c 2010-12-02 10:43:21.000000000 +0200 ++++ ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/en_ethtool.c 2010-12-02 13:13:51.000000000 +0200 +@@ -40,21 +40,6 @@ + #include "en_port.h" + + +-static void mlx4_en_update_lro_stats(struct mlx4_en_priv *priv) +-{ +- int i; +- +- priv->port_stats.lro_aggregated = 0; +- priv->port_stats.lro_flushed = 0; +- priv->port_stats.lro_no_desc = 0; +- +- for (i = 0; i < priv->rx_ring_num; i++) { +- priv->port_stats.lro_aggregated += priv->rx_ring[i].lro.stats.aggregated; +- priv->port_stats.lro_flushed += priv->rx_ring[i].lro.stats.flushed; +- priv->port_stats.lro_no_desc += priv->rx_ring[i].lro.stats.no_desc; +- } +-} +- + static void + mlx4_en_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo) + { +@@ -208,8 +193,6 @@ + + spin_lock_bh(&priv->stats_lock); + +- mlx4_en_update_lro_stats(priv); +- + for (i = 0; i < NUM_MAIN_STATS; i++) + data[index++] = ((unsigned long *) &priv->stats)[i]; + for (i = 0; i < NUM_PORT_STATS; i++) +Index: ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/en_lro.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/en_lro.c 2010-12-02 13:13:51.000000000 +0200 +@@ -0,0 +1,539 @@ ++/* ++ * Copyright (c) 2007 Mellanox Technologies. All rights reserved. ++ * ++ * This software is available to you under a choice of one of two ++ * licenses. You may choose to be licensed under the terms of the GNU ++ * General Public License (GPL) Version 2, available from the file ++ * COPYING in the main directory of this source tree, or the ++ * OpenIB.org BSD license below: ++ * ++ * Redistribution and use in source and binary forms, with or ++ * without modification, are permitted provided that the following ++ * conditions are met: ++ * ++ * - Redistributions of source code must retain the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer. ++ * ++ * - Redistributions in binary form must reproduce the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer in the documentation and/or other materials ++ * provided with the distribution. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ++ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS ++ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ++ * SOFTWARE. ++ * ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "mlx4_en.h" ++ ++/* LRO hash function - using sum of source and destination port LSBs is ++ * good enough */ ++#define LRO_INDEX(th, size) \ ++ ((*((u8 *) &th->source + 1) + *((u8 *) &th->dest + 1)) & (size - 1)) ++ ++/* #define CONFIG_MLX4_EN_DEBUG_LRO */ ++ ++#ifdef CONFIG_MLX4_EN_DEBUG_LRO ++static void mlx4_en_lro_validate(struct mlx4_en_priv *priv, struct mlx4_en_lro *lro) ++{ ++ int i; ++ int size, size2; ++ struct sk_buff *skb = lro->skb; ++ skb_frag_t *frags; ++ int len, len2; ++ int cur_skb = 0; ++ ++ /* Sum fragment sizes of first skb */ ++ len = skb->len; ++ size = skb_headlen(skb); ++ frags = skb_shinfo(skb)->frags; ++ for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) ++ size += frags[i].size; ++ ++ /* Add in fragments of linked skb's */ ++ skb = skb_shinfo(skb)->frag_list; ++ while (skb) { ++ cur_skb++; ++ len2 = skb->len; ++ if (skb_headlen(skb)) { ++ mlx4_err(priv->mdev, "Bad LRO format: non-zero headlen " ++ "in fraglist (skb:%d)\n", cur_skb); ++ return; ++ } ++ ++ size2 = 0; ++ frags = skb_shinfo(skb)->frags; ++ for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) ++ size2 += frags[i].size; ++ ++ if (size2 != len2) { ++ mlx4_err(priv->mdev, "Bad skb size:%d in LRO fraglist. " ++ "Expected:%d (skb:%d)\n", size2, len2, cur_skb); ++ return; ++ } ++ size += size2; ++ skb = skb->next; ++ } ++ ++ if (size != len) ++ mlx4_err(priv->mdev, "Bad LRO size:%d expected:%d\n", size, len); ++} ++#endif /* MLX4_EN_DEBUG_LRO */ ++ ++static void mlx4_en_lro_flush_single(struct mlx4_en_priv *priv, ++ struct mlx4_en_rx_ring *ring, struct mlx4_en_lro *lro) ++{ ++ struct sk_buff *skb = lro->skb; ++ struct iphdr *iph = (struct iphdr *) skb->data; ++ struct tcphdr *th = (struct tcphdr *)(iph + 1); ++ unsigned int headlen = skb_headlen(skb); ++ __wsum tcp_hdr_csum; ++ u32 *ts; ++ ++ /* Update IP length and checksum */ ++ iph->tot_len = htons(lro->tot_len); ++ iph->check = 0; ++ iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl); ++ ++ /* Update latest TCP ack, window, psh, and timestamp */ ++ th->ack_seq = lro->ack_seq; ++ th->window = lro->window; ++ th->psh = !!lro->psh; ++ if (lro->has_timestamp) { ++ ts = (u32 *) (th + 1); ++ ts[1] = htonl(lro->tsval); ++ ts[2] = lro->tsecr; ++ } ++ th->check = 0; ++ tcp_hdr_csum = csum_partial((u8 *)th, th->doff << 2, 0); ++ lro->data_csum = csum_add(lro->data_csum, tcp_hdr_csum); ++ th->check = csum_tcpudp_magic(iph->saddr, iph->daddr, ++ lro->tot_len - (iph->ihl << 2), ++ IPPROTO_TCP, lro->data_csum); ++ ++ /* Update skb */ ++ skb->len = lro->tot_len; ++ skb->data_len = lro->tot_len - headlen; ++ skb->truesize = skb->len + sizeof(struct sk_buff); ++ skb_shinfo(skb)->gso_size = lro->mss; ++ skb_shinfo(skb)->gso_type |= SKB_GSO_TCPV4; ++ ++#ifdef CONFIG_MLX4_EN_DEBUG_LRO ++ mlx4_en_lro_validate(priv, lro); ++#endif /* CONFIG_MLX4_EN_DEBUG_LRO */ ++ ++ /* Push it up the stack */ ++ if (priv->vlgrp && lro->has_vlan) ++ vlan_hwaccel_receive_skb(skb, priv->vlgrp, ++ be16_to_cpu(lro->vlan_prio)); ++ else ++ netif_receive_skb(skb); ++ priv->dev->last_rx = jiffies; ++ ++ /* Increment stats */ ++ priv->port_stats.lro_flushed++; ++ ++ /* Move session back to the free list */ ++ hlist_del(&lro->node); ++ hlist_del(&lro->flush_node); ++ hlist_add_head(&lro->node, &ring->lro_free); ++} ++ ++void mlx4_en_lro_flush(struct mlx4_en_priv *priv, struct mlx4_en_rx_ring *ring, u8 all) ++{ ++ struct mlx4_en_lro *lro; ++ struct hlist_node *node, *tmp; ++ ++ hlist_for_each_entry_safe(lro, node, tmp, &ring->lro_flush, flush_node) { ++ if (all || time_after(jiffies, lro->expires)) ++ mlx4_en_lro_flush_single(priv, ring, lro); ++ } ++} ++ ++static inline int mlx4_en_lro_append(struct mlx4_en_priv *priv, ++ struct mlx4_en_lro *lro, ++ struct mlx4_en_rx_desc *rx_desc, ++ struct skb_frag_struct *skb_frags, ++ struct mlx4_en_rx_alloc *page_alloc, ++ unsigned int data_len, ++ int hlen) ++{ ++ struct sk_buff *skb = lro->skb_last; ++ struct skb_shared_info *info; ++ struct skb_frag_struct *frags_copy; ++ int nr_frags; ++ ++ if (skb_shinfo(skb)->nr_frags + priv->num_frags > MAX_SKB_FRAGS) ++ return -ENOMEM; ++ ++ info = skb_shinfo(skb); ++ ++ /* Copy fragments from descriptor ring to skb */ ++ frags_copy = info->frags + info->nr_frags; ++ nr_frags = mlx4_en_complete_rx_desc(priv, rx_desc, skb_frags, ++ frags_copy, ++ page_alloc, ++ data_len + hlen); ++ if (!nr_frags) { ++ en_dbg(DRV, priv, "Failed completing rx desc during LRO append\n"); ++ return -ENOMEM; ++ } ++ ++ /* Skip over headers */ ++ frags_copy[0].page_offset += hlen; ++ ++ if (nr_frags == 1) ++ frags_copy[0].size = data_len; ++ else { ++ /* Adjust size of last fragment to match packet length. ++ * Note: if this fragment is also the first one, the ++ * operation is completed in the next line */ ++ frags_copy[nr_frags - 1].size = hlen + data_len - ++ priv->frag_info[nr_frags - 1].frag_prefix_size; ++ ++ /* Adjust size of first fragment */ ++ frags_copy[0].size -= hlen; ++ } ++ ++ /* Update skb bookkeeping */ ++ skb->len += data_len; ++ skb->data_len += data_len; ++ info->nr_frags += nr_frags; ++ return 0; ++} ++ ++static inline struct mlx4_en_lro *mlx4_en_lro_find_session(struct mlx4_en_dev *mdev, ++ struct mlx4_en_rx_ring *ring, ++ struct iphdr *iph, ++ struct tcphdr *th) ++{ ++ struct mlx4_en_lro *lro; ++ struct hlist_node *node; ++ int index = LRO_INDEX(th, mdev->profile.num_lro); ++ struct hlist_head *list = &ring->lro_hash[index]; ++ ++ hlist_for_each_entry(lro, node, list, node) { ++ if (lro->sport_dport == *((u32 *) &th->source) && ++ lro->saddr == iph->saddr && ++ lro->daddr == iph->daddr) ++ return lro; ++ } ++ return NULL; ++} ++ ++static inline struct mlx4_en_lro *mlx4_en_lro_alloc_session(struct mlx4_en_priv *priv, ++ struct mlx4_en_rx_ring *ring) ++{ ++ return hlist_empty(&ring->lro_free) ? NULL : ++ hlist_entry(ring->lro_free.first, struct mlx4_en_lro, node); ++} ++ ++static __wsum mlx4_en_lro_tcp_data_csum(struct iphdr *iph, ++ struct tcphdr *th, int len) ++{ ++ __wsum tcp_csum; ++ __wsum tcp_hdr_csum; ++ __wsum tcp_ps_hdr_csum; ++ ++ tcp_csum = ~csum_unfold(th->check); ++ tcp_hdr_csum = csum_partial((u8 *)th, th->doff << 2, tcp_csum); ++ ++ tcp_ps_hdr_csum = csum_tcpudp_nofold(iph->saddr, iph->daddr, ++ len + (th->doff << 2), ++ IPPROTO_TCP, 0); ++ ++ return csum_sub(csum_sub(tcp_csum, tcp_hdr_csum), ++ tcp_ps_hdr_csum); ++} ++ ++int mlx4_en_lro_rx(struct mlx4_en_priv *priv, struct mlx4_en_rx_ring *ring, ++ struct mlx4_en_rx_desc *rx_desc, ++ struct skb_frag_struct *skb_frags, ++ unsigned int length, ++ struct mlx4_cqe *cqe) ++{ ++ struct mlx4_en_dev *mdev = priv->mdev; ++ struct mlx4_en_lro *lro; ++ struct sk_buff *skb; ++ struct iphdr *iph; ++ struct tcphdr *th; ++ dma_addr_t dma; ++ int tcp_hlen; ++ int tcp_data_len; ++ int hlen; ++ u16 ip_len; ++ void *va; ++ u32 *ts; ++ u32 seq; ++ u32 tsval = (u32) ~0UL; ++ u32 tsecr = 0; ++ u32 ack_seq; ++ u16 window; ++ ++ /* This packet is eligible for LRO if it is: ++ * - DIX Ethernet (type interpretation) ++ * - TCP/IP (v4) ++ * - without IP options ++ * - not an IP fragment */ ++ if (!mlx4_en_can_lro(cqe->status)) ++ return -1; ++ ++ /* Get pointer to TCP header. We already know that the packet is DIX Ethernet/IPv4/TCP ++ * with no VLAN (HW stripped it) and no IP options */ ++ va = page_address(skb_frags[0].page) + skb_frags[0].page_offset; ++ iph = va + ETH_HLEN; ++ th = (struct tcphdr *)(iph + 1); ++ ++ /* Synchronsize headers for processing */ ++ dma = be64_to_cpu(rx_desc->data[0].addr); ++#define MAX_LRO_HEADER (ETH_HLEN + \ ++ sizeof(*iph) + \ ++ sizeof(*th) + \ ++ TCPOLEN_TSTAMP_ALIGNED) ++ dma_sync_single_range_for_cpu(&mdev->pdev->dev, dma, 0, ++ MAX_LRO_HEADER, DMA_FROM_DEVICE); ++ ++ /* We only handle aligned timestamp options */ ++ tcp_hlen = (th->doff << 2); ++ if (tcp_hlen == sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) { ++ ts = (u32 *) (th + 1); ++ if (unlikely(*ts != htonl((TCPOPT_NOP << 24) | ++ (TCPOPT_NOP << 16) | ++ (TCPOPT_TIMESTAMP << 8) | ++ TCPOLEN_TIMESTAMP))) ++ goto sync_device; ++ tsval = ntohl(ts[1]); ++ tsecr = ts[2]; ++ } else if (tcp_hlen != sizeof(*th)) ++ goto sync_device; ++ ++ ++ /* At this point we know we have a TCP packet that is likely to be ++ * eligible for LRO. Therefore, see now if we have an oustanding ++ * session that corresponds to this packet so we could flush it if ++ * something still prevents LRO */ ++ lro = mlx4_en_lro_find_session(mdev, ring, iph, th); ++ ++ /* ensure no bits set besides ack or psh */ ++ if (th->fin || th->syn || th->rst || th->urg || th->ece || ++ th->cwr || !th->ack) { ++ if (lro) { ++ /* First flush session to keep packets in-order */ ++ mlx4_en_lro_flush_single(priv, ring, lro); ++ } ++ goto sync_device; ++ } ++ ++ /* Get ip length and verify that the frame is big enough */ ++ ip_len = ntohs(iph->tot_len); ++ if (unlikely(length < ETH_HLEN + ip_len)) { ++ en_warn(priv, "Cannot LRO - ip payload exceeds frame!\n"); ++ goto sync_device; ++ } ++ ++ /* Get TCP payload length */ ++ tcp_data_len = ip_len - tcp_hlen - sizeof(struct iphdr); ++ seq = ntohl(th->seq); ++ if (!tcp_data_len) ++ goto flush_session; ++ ++ if (lro) { ++ /* Check VLAN tag */ ++ if (be32_to_cpu(cqe->vlan_my_qpn) & MLX4_CQE_VLAN_PRESENT_MASK) { ++ if (cqe->sl_vid != lro->vlan_prio || !lro->has_vlan) { ++ mlx4_en_lro_flush_single(priv, ring, lro); ++ goto sync_device; ++ } ++ } else if (lro->has_vlan) { ++ mlx4_en_lro_flush_single(priv, ring, lro); ++ goto sync_device; ++ } ++ ++ /* Check sequence number */ ++ if (unlikely(seq != lro->next_seq)) { ++ mlx4_en_lro_flush_single(priv, ring, lro); ++ goto sync_device; ++ } ++ ++ /* If the cummulative IP length is over 64K, flush and start ++ * a new session */ ++ if (lro->tot_len + tcp_data_len > 0xffff) { ++ mlx4_en_lro_flush_single(priv, ring, lro); ++ goto new_session; ++ } ++ ++ /* Check timestamps */ ++ if (tcp_hlen != sizeof(*th)) { ++ if (unlikely(lro->tsval > tsval || !tsecr)) ++ goto sync_device; ++ } ++ ++ window = th->window; ++ ack_seq = th->ack_seq; ++ if (likely(tcp_data_len)) { ++ /* Append the data! */ ++ hlen = ETH_HLEN + sizeof(struct iphdr) + tcp_hlen; ++ if (mlx4_en_lro_append(priv, lro, rx_desc, skb_frags, ++ ring->page_alloc, ++ tcp_data_len, hlen)) { ++ mlx4_en_lro_flush_single(priv, ring, lro); ++ goto sync_device; ++ } ++ } else { ++ /* No data */ ++ dma_sync_single_range_for_device(&mdev->dev->pdev->dev, dma, ++ 0, MAX_LRO_HEADER, ++ DMA_FROM_DEVICE); ++ } ++ ++ /* Update session */ ++ lro->psh |= th->psh; ++ lro->next_seq += tcp_data_len; ++ lro->data_csum = csum_block_add(lro->data_csum, ++ mlx4_en_lro_tcp_data_csum(iph, th, ++ tcp_data_len), ++ lro->tot_len); ++ lro->tot_len += tcp_data_len; ++ lro->tsval = tsval; ++ lro->tsecr = tsecr; ++ lro->ack_seq = ack_seq; ++ lro->window = window; ++ if (tcp_data_len > lro->mss) ++ lro->mss = tcp_data_len; ++ priv->port_stats.lro_aggregated++; ++ if (th->psh) ++ mlx4_en_lro_flush_single(priv, ring, lro); ++ return 0; ++ } ++ ++new_session: ++ if (th->psh) ++ goto sync_device; ++ lro = mlx4_en_lro_alloc_session(priv, ring); ++ if (lro) { ++ skb = mlx4_en_rx_skb(priv, rx_desc, skb_frags, ring->page_alloc, ++ ETH_HLEN + ip_len); ++ if (skb) { ++ int index; ++ ++ /* Add in the skb */ ++ lro->skb = skb; ++ lro->skb_last = skb; ++ skb->protocol = eth_type_trans(skb, priv->dev); ++ skb->ip_summed = CHECKSUM_UNNECESSARY; ++ ++ /* Initialize session */ ++ lro->saddr = iph->saddr; ++ lro->daddr = iph->daddr; ++ lro->sport_dport = *((u32 *) &th->source); ++ ++ lro->next_seq = seq + tcp_data_len; ++ lro->tot_len = ip_len; ++ lro->psh = th->psh; ++ lro->ack_seq = th->ack_seq; ++ lro->window = th->window; ++ lro->mss = tcp_data_len; ++ lro->data_csum = mlx4_en_lro_tcp_data_csum(iph, th, ++ tcp_data_len); ++ ++ /* Handle vlans */ ++ if (be32_to_cpu(cqe->vlan_my_qpn) & MLX4_CQE_VLAN_PRESENT_MASK) { ++ lro->vlan_prio = cqe->sl_vid; ++ lro->has_vlan = 1; ++ } else ++ lro->has_vlan = 0; ++ ++ /* Handle timestamps */ ++ if (tcp_hlen != sizeof(*th)) { ++ lro->tsval = tsval; ++ lro->tsecr = tsecr; ++ lro->has_timestamp = 1; ++ } else { ++ lro->tsval = (u32) ~0UL; ++ lro->has_timestamp = 0; ++ } ++ ++ /* Activate this session */ ++ lro->expires = jiffies + HZ / 25; ++ hlist_del(&lro->node); ++ index = LRO_INDEX(th, mdev->profile.num_lro); ++ ++ hlist_add_head(&lro->node, &ring->lro_hash[index]); ++ hlist_add_head(&lro->flush_node, &ring->lro_flush); ++ priv->port_stats.lro_aggregated++; ++ return 0; ++ } else { ++ /* Packet is dropped because we were not able to allocate new ++ * page for fragments */ ++ dma_sync_single_range_for_device(&mdev->pdev->dev, dma, ++ 0, MAX_LRO_HEADER, ++ DMA_FROM_DEVICE); ++ return 0; ++ } ++ } else { ++ priv->port_stats.lro_no_desc++; ++ } ++ ++flush_session: ++ if (lro) ++ mlx4_en_lro_flush_single(priv, ring, lro); ++sync_device: ++ dma_sync_single_range_for_device(&mdev->pdev->dev, dma, 0, ++ MAX_LRO_HEADER, DMA_FROM_DEVICE); ++ return -1; ++} ++ ++void mlx4_en_lro_destroy(struct mlx4_en_rx_ring *ring) ++{ ++ struct mlx4_en_lro *lro; ++ struct hlist_node *node, *tmp; ++ ++ hlist_for_each_entry_safe(lro, node, tmp, &ring->lro_free, node) { ++ hlist_del(&lro->node); ++ kfree(lro); ++ } ++ kfree(ring->lro_hash); ++} ++ ++int mlx4_en_lro_init(struct mlx4_en_rx_ring *ring, int num_lro) ++{ ++ struct mlx4_en_lro *lro; ++ int i; ++ ++ INIT_HLIST_HEAD(&ring->lro_free); ++ INIT_HLIST_HEAD(&ring->lro_flush); ++ ring->lro_hash = kmalloc(sizeof(struct hlist_head) * num_lro, ++ GFP_KERNEL); ++ if (!ring->lro_hash) ++ return -ENOMEM; ++ ++ for (i = 0; i < num_lro; i++) { ++ INIT_HLIST_HEAD(&ring->lro_hash[i]); ++ lro = kzalloc(sizeof(struct mlx4_en_lro), GFP_KERNEL); ++ if (!lro) { ++ mlx4_en_lro_destroy(ring); ++ return -ENOMEM; ++ } ++ INIT_HLIST_NODE(&lro->node); ++ INIT_HLIST_NODE(&lro->flush_node); ++ hlist_add_head(&lro->node, &ring->lro_free); ++ } ++ return 0; ++} ++ ++ +Index: ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/en_rx.c +=================================================================== +--- ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check.orig/drivers/net/mlx4/en_rx.c 2010-12-02 10:43:26.000000000 +0200 ++++ ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/en_rx.c 2010-12-02 13:13:51.000000000 +0200 +@@ -41,18 +41,6 @@ + #include "mlx4_en.h" + + +-static int mlx4_en_get_frag_header(struct skb_frag_struct *frags, void **mac_hdr, +- void **ip_hdr, void **tcpudp_hdr, +- u64 *hdr_flags, void *priv) +-{ +- *mac_hdr = page_address(frags->page) + frags->page_offset; +- *ip_hdr = *mac_hdr + ETH_HLEN; +- *tcpudp_hdr = (struct tcphdr *)(*ip_hdr + sizeof(struct iphdr)); +- *hdr_flags = LRO_IPV4 | LRO_TCP; +- +- return 0; +-} +- + enum { + MIN_RX_ARM = 1024, + }; +@@ -381,23 +369,14 @@ + } + ring->buf = ring->wqres.buf.direct.buf; + +- /* Configure lro mngr */ +- memset(&ring->lro, 0, sizeof(struct net_lro_mgr)); +- ring->lro.dev = priv->dev; +- ring->lro.features = LRO_F_NAPI; +- ring->lro.frag_align_pad = NET_IP_ALIGN; +- ring->lro.ip_summed = CHECKSUM_UNNECESSARY; +- ring->lro.ip_summed_aggr = CHECKSUM_UNNECESSARY; +- ring->lro.max_desc = mdev->profile.num_lro; +- ring->lro.max_aggr = MAX_SKB_FRAGS; +- ring->lro.lro_arr = kzalloc(mdev->profile.num_lro * +- sizeof(struct net_lro_desc), +- GFP_KERNEL); +- if (!ring->lro.lro_arr) { +- en_err(priv, "Failed to allocate lro array\n"); +- goto err_map; ++ /* Allocate LRO sessions */ ++ if (mdev->profile.num_lro) { ++ err = mlx4_en_lro_init(ring, mdev->profile.num_lro); ++ if (err) { ++ en_err(priv, "Failed allocating lro sessions\n"); ++ goto err_map; ++ } + } +- ring->lro.get_frag_header = mlx4_en_get_frag_header; + + return 0; + +@@ -488,7 +467,8 @@ + { + struct mlx4_en_dev *mdev = priv->mdev; + +- kfree(ring->lro.lro_arr); ++ if (mdev->profile.num_lro) ++ mlx4_en_lro_destroy(ring); + mlx4_en_unmap_buffer(&ring->wqres.buf); + mlx4_free_hwq_res(mdev->dev, &ring->wqres, ring->buf_size + TXBB_SIZE); + vfree(ring->rx_info); +@@ -507,12 +487,12 @@ + + + /* Unmap a completed descriptor and free unused pages */ +-static int mlx4_en_complete_rx_desc(struct mlx4_en_priv *priv, +- struct mlx4_en_rx_desc *rx_desc, +- struct skb_frag_struct *skb_frags, +- struct skb_frag_struct *skb_frags_rx, +- struct mlx4_en_rx_alloc *page_alloc, +- int length) ++int mlx4_en_complete_rx_desc(struct mlx4_en_priv *priv, ++ struct mlx4_en_rx_desc *rx_desc, ++ struct skb_frag_struct *skb_frags, ++ struct skb_frag_struct *skb_frags_rx, ++ struct mlx4_en_rx_alloc *page_alloc, ++ int length) + { + struct mlx4_en_dev *mdev = priv->mdev; + struct mlx4_en_frag_info *frag_info; +@@ -555,11 +535,11 @@ + } + + +-static struct sk_buff *mlx4_en_rx_skb(struct mlx4_en_priv *priv, +- struct mlx4_en_rx_desc *rx_desc, +- struct skb_frag_struct *skb_frags, +- struct mlx4_en_rx_alloc *page_alloc, +- unsigned int length) ++struct sk_buff *mlx4_en_rx_skb(struct mlx4_en_priv *priv, ++ struct mlx4_en_rx_desc *rx_desc, ++ struct skb_frag_struct *skb_frags, ++ struct mlx4_en_rx_alloc *page_alloc, ++ unsigned int length) + { + struct mlx4_en_dev *mdev = priv->mdev; + struct sk_buff *skb; +@@ -793,14 +773,13 @@ + int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int budget) + { + struct mlx4_en_priv *priv = netdev_priv(dev); ++ struct mlx4_en_dev *mdev = priv->mdev; + struct mlx4_cqe *cqe; + struct mlx4_en_rx_ring *ring = &priv->rx_ring[cq->ring]; + struct skb_frag_struct *skb_frags; +- struct skb_frag_struct lro_frags[MLX4_EN_MAX_RX_FRAGS]; + struct mlx4_en_rx_desc *rx_desc; + struct sk_buff *skb; + int index; +- int nr; + unsigned int length; + int polled = 0; + int ip_summed; +@@ -838,40 +817,12 @@ + + if (likely(priv->rx_csum)) { + if ((cqe->status & cpu_to_be16(MLX4_CQE_STATUS_IPOK)) && +- (cqe->checksum == cpu_to_be16(0xffff))) { ++ (cqe->checksum == 0xffff)) { + priv->port_stats.rx_chksum_good++; +- /* This packet is eligible for LRO if it is: +- * - DIX Ethernet (type interpretation) +- * - TCP/IP (v4) +- * - without IP options +- * - not an IP fragment */ +- if (mlx4_en_can_lro(cqe->status) && +- dev->features & NETIF_F_LRO) { +- +- nr = mlx4_en_complete_rx_desc( +- priv, rx_desc, +- skb_frags, lro_frags, +- ring->page_alloc, length); +- if (!nr) +- goto next; +- +- if (priv->vlgrp && (cqe->vlan_my_qpn & +- cpu_to_be32(MLX4_CQE_VLAN_PRESENT_MASK))) { +- lro_vlan_hwaccel_receive_frags( +- &ring->lro, lro_frags, +- length, length, +- priv->vlgrp, +- be16_to_cpu(cqe->sl_vid), +- NULL, 0); +- } else +- lro_receive_frags(&ring->lro, +- lro_frags, +- length, +- length, +- NULL, 0); +- +- goto next; +- } ++ if (mdev->profile.num_lro && ++ !mlx4_en_lro_rx(priv, ring, rx_desc, ++ skb_frags, length, cqe)) ++ goto next; + + /* LRO not possible, complete processing here */ + ip_summed = CHECKSUM_UNNECESSARY; +@@ -899,7 +850,6 @@ + + skb->ip_summed = ip_summed; + skb->protocol = eth_type_trans(skb, dev); +- skb_record_rx_queue(skb, cq->ring); + + /* Push it up the stack */ + if (priv->vlgrp && (be32_to_cpu(cqe->vlan_my_qpn) & +@@ -916,13 +866,15 @@ + if (++polled == budget) { + /* We are here because we reached the NAPI budget - + * flush only pending LRO sessions */ +- lro_flush_all(&ring->lro); ++ if (mdev->profile.num_lro) ++ mlx4_en_lro_flush(priv, ring, 0); + goto out; + } + } + + /* If CQ is empty flush all LRO sessions unconditionally */ +- lro_flush_all(&ring->lro); ++ if (mdev->profile.num_lro) ++ mlx4_en_lro_flush(priv, ring, 1); + + out: + AVG_PERF_COUNTER(priv->pstats.rx_coal_avg, polled); +Index: ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/mlx4_en.h +=================================================================== +--- ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check.orig/drivers/net/mlx4/mlx4_en.h 2010-12-02 10:43:26.000000000 +0200 ++++ ofa_1_5_dev_kernel-20101202-1037_linux-2.6.28_check/drivers/net/mlx4/mlx4_en.h 2010-12-02 13:17:49.000000000 +0200 +@@ -300,10 +300,40 @@ + struct mlx4_wqe_data_seg data[0]; + }; + ++struct mlx4_en_lro { ++ struct hlist_node node; ++ struct hlist_node flush_node; ++ ++ /* Id fields come first: */ ++ u32 saddr; ++ u32 daddr; ++ u32 sport_dport; ++ u32 next_seq; ++ u16 tot_len; ++ u8 psh; ++ ++ u32 tsval; ++ u32 tsecr; ++ u32 ack_seq; ++ u16 window; ++ __be16 vlan_prio; ++ u16 has_vlan; ++ u16 has_timestamp; ++ u16 mss; ++ __wsum data_csum; ++ ++ unsigned long expires; ++ struct sk_buff *skb; ++ struct sk_buff *skb_last; ++}; ++ + struct mlx4_en_rx_ring { + struct mlx4_hwq_resources wqres; + struct mlx4_en_rx_alloc page_alloc[MLX4_EN_MAX_RX_FRAGS]; +- struct net_lro_mgr lro; ++ struct mlx4_en_lro lro; ++ struct hlist_head *lro_hash; ++ struct hlist_head lro_free; ++ struct hlist_head lro_flush; + u32 size ; /* number of Rx descs*/ + u32 actual_size; + u32 size_mask; +@@ -611,6 +641,25 @@ + int mlx4_en_free_tx_buf(struct net_device *dev, struct mlx4_en_tx_ring *ring); + void mlx4_en_rx_irq(struct mlx4_cq *mcq); + ++struct sk_buff *mlx4_en_rx_skb(struct mlx4_en_priv *priv, ++ struct mlx4_en_rx_desc *rx_desc, ++ struct skb_frag_struct *skb_frags, ++ struct mlx4_en_rx_alloc *page_alloc, ++ unsigned int length); ++int mlx4_en_complete_rx_desc(struct mlx4_en_priv *priv, ++ struct mlx4_en_rx_desc *rx_desc, ++ struct skb_frag_struct *skb_frags, ++ struct skb_frag_struct *skb_frags_rx, ++ struct mlx4_en_rx_alloc *page_alloc, ++ int length); ++void mlx4_en_lro_flush(struct mlx4_en_priv *priv, struct mlx4_en_rx_ring *ring, u8 all); ++int mlx4_en_lro_rx(struct mlx4_en_priv *priv, struct mlx4_en_rx_ring *ring, ++ struct mlx4_en_rx_desc *rx_desc, ++ struct skb_frag_struct *skb_frags, ++ unsigned int length, struct mlx4_cqe *cqe); ++void mlx4_en_lro_destroy(struct mlx4_en_rx_ring *ring); ++int mlx4_en_lro_init(struct mlx4_en_rx_ring *ring, int num_lro); ++ + int mlx4_SET_VLAN_FLTR(struct mlx4_dev *dev, u8 port, struct vlan_group *grp); + int mlx4_SET_PORT_general(struct mlx4_dev *dev, u8 port, int mtu, + u8 pptx, u8 pfctx, u8 pprx, u8 pfcrx); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0040_napi_backports.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0040_napi_backports.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0040_napi_backports.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0040_napi_backports.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,165 @@ +From 455790331499dd90a37c14cebdeef88fbee15357 Mon Sep 17 00:00:00 2001 +From: Yevgeny Petrilin +Date: Sun, 31 May 2009 15:11:45 +0300 +Subject: [PATCH 4/8] mlx4_en: napi backport + +Signed-off-by: Yevgeny Petrilin +--- + drivers/net/mlx4/en_cq.c | 21 +++++++++++++++++---- + drivers/net/mlx4/en_netdev.c | 5 ++--- + drivers/net/mlx4/en_rx.c | 26 +++++++++++++++----------- + drivers/net/mlx4/mlx4_en.h | 4 ++-- + 4 files changed, 36 insertions(+), 20 deletions(-) + +Index: ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check/drivers/net/mlx4/en_cq.c +=================================================================== +--- ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check.orig/drivers/net/mlx4/en_cq.c 2010-06-13 10:20:08.000000000 +0300 ++++ ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check/drivers/net/mlx4/en_cq.c 2010-06-13 10:44:25.000000000 +0300 +@@ -34,6 +34,7 @@ + #include + #include + #include ++#include + + #include "mlx4_en.h" + +@@ -106,8 +107,17 @@ int mlx4_en_activate_cq(struct mlx4_en_p + cq->timer.function = mlx4_en_poll_tx_cq; + cq->timer.data = (unsigned long) cq; + } else { +- netif_napi_add(cq->dev, &cq->napi, mlx4_en_poll_rx_cq, 64); +- napi_enable(&cq->napi); ++ char name[IFNAMSIZ]; ++ ++ snprintf(name, IFNAMSIZ, "mlx4_en-%d-%d", priv->port, cq->ring); ++ cq->poll_dev = alloc_netdev(0, name, ether_setup); ++ if (!cq->poll_dev) ++ return -ENOMEM; ++ ++ cq->poll_dev->priv = cq; ++ cq->poll_dev->weight = 64; ++ cq->poll_dev->poll = mlx4_en_poll_rx_cq; ++ set_bit(__LINK_STATE_START, &cq->poll_dev->state); + } + + return 0; +@@ -130,8 +140,11 @@ void mlx4_en_deactivate_cq(struct mlx4_e + if (cq->is_tx) + del_timer(&cq->timer); + else { +- napi_disable(&cq->napi); +- netif_napi_del(&cq->napi); ++ while (test_bit(__LINK_STATE_RX_SCHED, ++ &cq->poll_dev->state)) ++ msleep(1); ++ free_netdev(cq->poll_dev); ++ cq->poll_dev = NULL; + } + + mlx4_cq_free(mdev->dev, &cq->mcq); +Index: ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check/drivers/net/mlx4/en_netdev.c +=================================================================== +--- ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check.orig/drivers/net/mlx4/en_netdev.c 2010-06-13 10:22:20.000000000 +0300 ++++ ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check/drivers/net/mlx4/en_netdev.c 2010-06-13 10:44:25.000000000 +0300 +@@ -348,7 +348,8 @@ static void mlx4_en_netpoll(struct net_d + for (i = 0; i < priv->rx_ring_num; i++) { + cq = &priv->rx_cq[i]; + spin_lock_irqsave(&cq->lock, flags); +- napi_synchronize(&cq->napi); ++ while (test_bit(__LINK_STATE_RX_SCHED, &cq->poll_dev->state)) ++ msleep(1); + if (priv->rx_ring[i].use_frags) + mlx4_en_process_rx_cq(dev, cq, 0); + else +@@ -757,8 +758,6 @@ void mlx4_en_stop_port(struct net_device + /* Free RX Rings */ + for (i = 0; i < priv->rx_ring_num; i++) { + mlx4_en_deactivate_rx_ring(priv, &priv->rx_ring[i]); +- while (test_bit(NAPI_STATE_SCHED, &priv->rx_cq[i].napi.state)) +- msleep(1); + mlx4_en_deactivate_cq(priv, &priv->rx_cq[i]); + } + +Index: ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check/drivers/net/mlx4/en_rx.c +=================================================================== +--- ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check.orig/drivers/net/mlx4/en_rx.c 2010-06-13 10:22:21.000000000 +0300 ++++ ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check/drivers/net/mlx4/en_rx.c 2010-06-13 10:59:44.000000000 +0300 +@@ -893,40 +893,43 @@ void mlx4_en_rx_irq(struct mlx4_cq *mcq) + struct mlx4_en_priv *priv = netdev_priv(cq->dev); + + if (priv->port_up) +- napi_schedule(&cq->napi); ++ netif_rx_schedule(cq->poll_dev); + else + mlx4_en_arm_cq(priv, cq); + } + + /* Rx CQ polling - called by NAPI */ +-int mlx4_en_poll_rx_cq(struct napi_struct *napi, int budget) ++int mlx4_en_poll_rx_cq(struct net_device *poll_dev, int *budget) + { +- struct mlx4_en_cq *cq = container_of(napi, struct mlx4_en_cq, napi); ++ struct mlx4_en_cq *cq = poll_dev->priv; + struct net_device *dev = cq->dev; + struct mlx4_en_priv *priv = netdev_priv(dev); + int done; ++ int work = min(*budget, poll_dev->quota); + + if (priv->rx_ring[cq->ring].use_frags) +- done = mlx4_en_process_rx_cq(dev, cq, budget); ++ done = mlx4_en_process_rx_cq(dev, cq, work); + else +- done = mlx4_en_process_rx_cq_skb(dev, cq, budget); ++ done = mlx4_en_process_rx_cq_skb(dev, cq, work); ++ dev->quota -= done; ++ *budget -= done; + + /* If we used up all the quota - we're probably not done yet... */ + cq->tot_rx += done; +- if (done == budget) { ++ if (done == work) { + INC_PERF_COUNTER(priv->pstats.napi_quota); + if (cq->tot_rx >= MIN_RX_ARM) { + cq->tot_rx -= MIN_RX_ARM; + mlx4_en_arm_cq(priv, cq); + } ++ return 1; + } +- else { +- /* Done for now */ +- napi_complete(napi); +- mlx4_en_arm_cq(priv, cq); +- cq->tot_rx = 0; +- } +- return done; ++ ++ /* Done for now */ ++ netif_rx_complete(poll_dev); ++ mlx4_en_arm_cq(priv, cq); ++ cq->tot_rx = 0; ++ return 0; + } + + +Index: ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check/drivers/net/mlx4/mlx4_en.h +=================================================================== +--- ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check.orig/drivers/net/mlx4/mlx4_en.h 2010-06-13 10:22:21.000000000 +0300 ++++ ofa_1_5_dev_kernel-20100613-1015_linux-2.6.23_check/drivers/net/mlx4/mlx4_en.h 2010-06-13 10:44:25.000000000 +0300 +@@ -371,7 +371,7 @@ struct mlx4_en_cq { + int ring; + spinlock_t lock; + struct net_device *dev; +- struct napi_struct napi; ++ struct net_device *poll_dev; /* for napi */ + /* Per-core Tx cq processing support */ + struct timer_list timer; + int size; +@@ -623,7 +623,7 @@ int mlx4_en_process_rx_cq(struct net_dev + int mlx4_en_process_rx_cq_skb(struct net_device *dev, + struct mlx4_en_cq *cq, + int budget); +-int mlx4_en_poll_rx_cq(struct napi_struct *napi, int budget); ++int mlx4_en_poll_rx_cq(struct net_device *poll_dev, int *budget);; + void mlx4_en_fill_qp_context(struct mlx4_en_priv *priv, int size, int stride, + int is_tx, int rss, int qpn, int cqn, + struct mlx4_qp_context *context); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0050_missing_devid_sysfs-2.6.20.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0050_missing_devid_sysfs-2.6.20.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0050_missing_devid_sysfs-2.6.20.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0050_missing_devid_sysfs-2.6.20.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,49 @@ +commit 27113dda650ecea8ea81f664931641f09027f216 +Author: Eli Cohen +Date: Thu May 27 10:55:55 2010 +0300 + + Backport: Add missing dev_id sysfs file + + Signed-off-by: Eli Cohen + +Index: ofa_kernel-1.5.2/drivers/net/mlx4/en_netdev.c +=================================================================== +--- ofa_kernel-1.5.2.orig/drivers/net/mlx4/en_netdev.c 2010-08-31 11:07:02.000000000 +0300 ++++ ofa_kernel-1.5.2/drivers/net/mlx4/en_netdev.c 2010-08-31 11:08:18.000000000 +0300 +@@ -44,6 +44,9 @@ + #include "mlx4_en.h" + #include "en_port.h" + ++#ifndef to_net_dev ++#define to_net_dev(class) container_of(class, struct net_device, class_dev) ++#endif + + static void mlx4_en_vlan_rx_register(struct net_device *dev, struct vlan_group *grp) + { +@@ -963,6 +966,12 @@ + return 0; + } + ++static ssize_t show_dev_id(struct class_device *d, char *buf) ++{ ++ return sprintf(buf, "%d\n", to_net_dev(d)->dev_id); ++} ++ ++static CLASS_DEVICE_ATTR(dev_id, S_IRUGO, show_dev_id, NULL); + + int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, + struct mlx4_en_port_profile *prof) +@@ -1099,6 +1108,13 @@ + en_warn(priv, "Using %d RX rings\n", prof->rx_ring_num); + + priv->registered = 1; ++ ++ err = class_device_create_file(&dev->class_dev, &class_device_attr_dev_id); ++ if (err) { ++ mlx4_err(mdev, "Faild to create dev_id sysfs file for port %d\n", port); ++ goto out; ++ } ++ + queue_delayed_work(mdev->workqueue, &priv->stats_task, STATS_DELAY); + return 0; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0050_no_set_flags_support.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0050_no_set_flags_support.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0050_no_set_flags_support.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0050_no_set_flags_support.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,26 @@ +From 9e8b37de6c50238ded500d77e7a6317798842fc5 Mon Sep 17 00:00:00 2001 +From: Yevgeny Petrilin +Date: Sun, 31 May 2009 15:17:17 +0300 +Subject: [PATCH 5/8] mlx4_en: no set_flag support + +Signed-off-by: Yevgeny Petrilin +--- + drivers/net/mlx4/en_ethtool.c | 2 -- + 1 files changed, 0 insertions(+), 2 deletions(-) + +diff --git a/drivers/net/mlx4/en_ethtool.c b/drivers/net/mlx4/en_ethtool.c +index 397ceb9..a30ba2c 100644 +--- a/drivers/net/mlx4/en_ethtool.c ++++ b/drivers/net/mlx4/en_ethtool.c +@@ -414,8 +414,6 @@ const struct ethtool_ops mlx4_en_ethtool_ops = { + .set_pauseparam = mlx4_en_set_pauseparam, + .get_ringparam = mlx4_en_get_ringparam, + .set_ringparam = mlx4_en_set_ringparam, +- .get_flags = ethtool_op_get_flags, +- .set_flags = ethtool_op_set_flags, + }; + + +-- +1.6.1.3 + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0060_ethtool_interface.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0060_ethtool_interface.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0060_ethtool_interface.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mlx4_en_0060_ethtool_interface.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,46 @@ +diff --git a/drivers/net/mlx4/en_ethtool.c b/drivers/net/mlx4/en_ethtool.c +index 107f9a0..ac2f076 100644 +--- a/drivers/net/mlx4/en_ethtool.c ++++ b/drivers/net/mlx4/en_ethtool.c +@@ -152,19 +152,17 @@ static void mlx4_en_get_wol(struct net_device *netdev, + return; + } + +-static int mlx4_en_get_sset_count(struct net_device *dev, int sset) ++static int mlx4_en_get_sset_count(struct net_device *dev) + { + struct mlx4_en_priv *priv = netdev_priv(dev); + +- switch (sset) { +- case ETH_SS_STATS: +- return NUM_ALL_STATS + +- (priv->tx_ring_num + priv->rx_ring_num) * 2; +- case ETH_SS_TEST: +- return MLX4_EN_NUM_SELF_TEST - !(priv->mdev->dev->caps.loopback_support) * 2; +- default: +- return -EOPNOTSUPP; +- } ++ return NUM_ALL_STATS + (priv->tx_ring_num + priv->rx_ring_num) * 2; ++} ++ ++static int mlx4_en_self_test_count(struct net_device *dev) ++{ ++ struct mlx4_en_priv *priv = netdev_priv(dev); ++ return MLX4_EN_NUM_SELF_TEST - !(priv->mdev->dev->caps.loopback_support) * 2; + } + + static void mlx4_en_get_ethtool_stats(struct net_device *dev, +@@ -432,10 +430,11 @@ const struct ethtool_ops mlx4_en_ethtool_ops = { + .get_rx_csum = mlx4_en_get_rx_csum, + .set_rx_csum = mlx4_en_set_rx_csum, + .get_tx_csum = ethtool_op_get_tx_csum, +- .set_tx_csum = ethtool_op_set_tx_ipv6_csum, ++ .set_tx_csum = ethtool_op_set_tx_csum, + .get_strings = mlx4_en_get_strings, +- .get_sset_count = mlx4_en_get_sset_count, ++ .get_stats_count = mlx4_en_get_sset_count, + .get_ethtool_stats = mlx4_en_get_ethtool_stats, ++ .self_test_count = mlx4_en_self_test_count, + .self_test = mlx4_en_self_test, + .get_wol = mlx4_en_get_wol, + .get_msglevel = mlx4_en_get_msglevel, diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0000_pci_dma_mapping_error_to_2_6_26.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0000_pci_dma_mapping_error_to_2_6_26.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0000_pci_dma_mapping_error_to_2_6_26.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0000_pci_dma_mapping_error_to_2_6_26.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,17 @@ +--- + drivers/infiniband/hw/mthca/mthca_eq.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +Index: ofed_kernel/drivers/infiniband/hw/mthca/mthca_eq.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/hw/mthca/mthca_eq.c ++++ ofed_kernel/drivers/infiniband/hw/mthca/mthca_eq.c +@@ -780,7 +780,7 @@ int mthca_map_eq_icm(struct mthca_dev *d + return -ENOMEM; + dev->eq_table.icm_dma = pci_map_page(dev->pdev, dev->eq_table.icm_page, 0, + PAGE_SIZE, PCI_DMA_BIDIRECTIONAL); +- if (pci_dma_mapping_error(dev->pdev, dev->eq_table.icm_dma)) { ++ if (pci_dma_mapping_error(dev->eq_table.icm_dma)) { + __free_page(dev->eq_table.icm_page); + return -ENOMEM; + } diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0010_sysfs.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0010_sysfs.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0010_sysfs.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0010_sysfs.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,94 @@ +--- + drivers/infiniband/hw/mthca/mthca_provider.c | 50 +++++++++++---------------- + 1 file changed, 21 insertions(+), 29 deletions(-) + +Index: ofed_kernel/drivers/infiniband/hw/mthca/mthca_provider.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/hw/mthca/mthca_provider.c ++++ ofed_kernel/drivers/infiniband/hw/mthca/mthca_provider.c +@@ -1186,29 +1186,23 @@ static int mthca_unmap_fmr(struct list_h + return 0; + } + +-static ssize_t show_rev(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_rev(struct class_device *cdev, char *buf) + { +- struct mthca_dev *dev = +- container_of(device, struct mthca_dev, ib_dev.dev); ++ struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev); + return sprintf(buf, "%x\n", dev->rev_id); + } + +-static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_fw_ver(struct class_device *cdev, char *buf) + { +- struct mthca_dev *dev = +- container_of(device, struct mthca_dev, ib_dev.dev); ++ struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev); + return sprintf(buf, "%d.%d.%d\n", (int) (dev->fw_ver >> 32), + (int) (dev->fw_ver >> 16) & 0xffff, + (int) dev->fw_ver & 0xffff); + } + +-static ssize_t show_hca(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_hca(struct class_device *cdev, char *buf) + { +- struct mthca_dev *dev = +- container_of(device, struct mthca_dev, ib_dev.dev); ++ struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev); + switch (dev->pdev->device) { + case PCI_DEVICE_ID_MELLANOX_TAVOR: + return sprintf(buf, "MT23108\n"); +@@ -1224,24 +1218,22 @@ static ssize_t show_hca(struct device *d + } + } + +-static ssize_t show_board(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_board(struct class_device *cdev, char *buf) + { +- struct mthca_dev *dev = +- container_of(device, struct mthca_dev, ib_dev.dev); ++ struct mthca_dev *dev = container_of(cdev, struct mthca_dev, ib_dev.class_dev); + return sprintf(buf, "%.*s\n", MTHCA_BOARD_ID_LEN, dev->board_id); + } + +-static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +-static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); +-static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +-static DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); +- +-static struct device_attribute *mthca_dev_attributes[] = { +- &dev_attr_hw_rev, +- &dev_attr_fw_ver, +- &dev_attr_hca_type, +- &dev_attr_board_id ++static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); ++static CLASS_DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL); ++static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); ++static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_board, NULL); ++ ++static struct class_device_attribute *mthca_class_attributes[] = { ++ &class_device_attr_hw_rev, ++ &class_device_attr_fw_ver, ++ &class_device_attr_hca_type, ++ &class_device_attr_board_id + }; + + static int mthca_init_node_data(struct mthca_dev *dev) +@@ -1403,9 +1395,9 @@ int mthca_register_device(struct mthca_d + if (ret) + return ret; + +- for (i = 0; i < ARRAY_SIZE(mthca_dev_attributes); ++i) { +- ret = device_create_file(&dev->ib_dev.dev, +- mthca_dev_attributes[i]); ++ for (i = 0; i < ARRAY_SIZE(mthca_class_attributes); ++i) { ++ ret = class_device_create_file(&dev->ib_dev.class_dev, ++ mthca_class_attributes[i]); + if (ret) { + ib_unregister_device(&dev->ib_dev); + return ret; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0020_undo_pI6.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0020_undo_pI6.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0020_undo_pI6.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0020_undo_pI6.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,47 @@ +mthca: Undo %pI6 for printing gids + +(commit 8867cd7c8678ff2d9d0382dbbfbcc7a3e7e61cbc) + +Signed-off-by: Jack Morgenstein + +Index: ofed_kernel-fixes/drivers/infiniband/hw/mthca/mthca_mcg.c +=================================================================== +--- ofed_kernel-fixes.orig/drivers/infiniband/hw/mthca/mthca_mcg.c 2009-07-20 13:50:08.000000000 +0300 ++++ ofed_kernel-fixes/drivers/infiniband/hw/mthca/mthca_mcg.c 2009-07-20 13:55:05.000000000 +0300 +@@ -87,7 +87,17 @@ static int find_mgm(struct mthca_dev *de + } + + if (0) +- mthca_dbg(dev, "Hash for %pI6 is %04x\n", gid, *hash); ++ mthca_dbg(dev, "Hash for %04x:%04x:%04x:%04x:" ++ "%04x:%04x:%04x:%04x is %04x\n", ++ be16_to_cpu(((__be16 *) gid)[0]), ++ be16_to_cpu(((__be16 *) gid)[1]), ++ be16_to_cpu(((__be16 *) gid)[2]), ++ be16_to_cpu(((__be16 *) gid)[3]), ++ be16_to_cpu(((__be16 *) gid)[4]), ++ be16_to_cpu(((__be16 *) gid)[5]), ++ be16_to_cpu(((__be16 *) gid)[6]), ++ be16_to_cpu(((__be16 *) gid)[7]), ++ *hash); + + *index = *hash; + *prev = -1; +@@ -254,7 +264,16 @@ int mthca_multicast_detach(struct ib_qp + goto out; + + if (index == -1) { +- mthca_err(dev, "MGID %pI6 not found\n", gid->raw); ++ mthca_err(dev, "MGID %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x " ++ "not found\n", ++ be16_to_cpu(((__be16 *) gid->raw)[0]), ++ be16_to_cpu(((__be16 *) gid->raw)[1]), ++ be16_to_cpu(((__be16 *) gid->raw)[2]), ++ be16_to_cpu(((__be16 *) gid->raw)[3]), ++ be16_to_cpu(((__be16 *) gid->raw)[4]), ++ be16_to_cpu(((__be16 *) gid->raw)[5]), ++ be16_to_cpu(((__be16 *) gid->raw)[6]), ++ be16_to_cpu(((__be16 *) gid->raw)[7])); + err = -EINVAL; + goto out; + } diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0030_rhel_large_kmalloc.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0030_rhel_large_kmalloc.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0030_rhel_large_kmalloc.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/mthca_0030_rhel_large_kmalloc.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,62 @@ +commit a7f18a776785aecb5eb9967aef6f0f603b698ba0 +Author: Doug Ledford +Date: Thu Jul 16 12:47:55 2009 -0400 + + [mthca] Fix attempts to use kmalloc on overly large allocations + + Signed-off-by: Doug Ledford + +diff --git a/drivers/infiniband/hw/mthca/mthca_mr.c b/drivers/infiniband/hw/mthca/mthca_mr.c +index d606edf..312e18d 100644 +--- a/drivers/infiniband/hw/mthca/mthca_mr.c ++++ b/drivers/infiniband/hw/mthca/mthca_mr.c +@@ -152,8 +152,11 @@ static int mthca_buddy_init(struct mthca_buddy *buddy, int max_order) + goto err_out; + + for (i = 0; i <= buddy->max_order; ++i) { +- s = BITS_TO_LONGS(1 << (buddy->max_order - i)); +- buddy->bits[i] = kmalloc(s * sizeof (long), GFP_KERNEL); ++ s = BITS_TO_LONGS(1 << (buddy->max_order - i)) * sizeof(long); ++ if(s > PAGE_SIZE) ++ buddy->bits[i] = (unsigned long *)__get_free_pages(GFP_KERNEL, get_order(s)); ++ else ++ buddy->bits[i] = kmalloc(s, GFP_KERNEL); + if (!buddy->bits[i]) + goto err_out_free; + bitmap_zero(buddy->bits[i], +@@ -166,9 +169,13 @@ static int mthca_buddy_init(struct mthca_buddy *buddy, int max_order) + return 0; + + err_out_free: +- for (i = 0; i <= buddy->max_order; ++i) +- kfree(buddy->bits[i]); +- ++ for (i = 0; i <= buddy->max_order; ++i){ ++ s = BITS_TO_LONGS(1 << (buddy->max_order - i)) * sizeof(long); ++ if(s > PAGE_SIZE) ++ free_pages((unsigned long)buddy->bits[i], get_order(s)); ++ else ++ kfree(buddy->bits[i]); ++ } + err_out: + kfree(buddy->bits); + kfree(buddy->num_free); +@@ -178,10 +185,15 @@ err_out: + + static void mthca_buddy_cleanup(struct mthca_buddy *buddy) + { +- int i; ++ int i, s; + +- for (i = 0; i <= buddy->max_order; ++i) +- kfree(buddy->bits[i]); ++ for (i = 0; i <= buddy->max_order; ++i){ ++ s = BITS_TO_LONGS(1 << (buddy->max_order - i)) * sizeof(long); ++ if(s > PAGE_SIZE) ++ free_pages((unsigned long)buddy->bits[i], get_order(s)); ++ else ++ kfree(buddy->bits[i]); ++ } + + kfree(buddy->bits); + kfree(buddy->num_free); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qib_to_2.6.18-EL5.5.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qib_to_2.6.18-EL5.5.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qib_to_2.6.18-EL5.5.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qib_to_2.6.18-EL5.5.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,1432 @@ +diff -up a/drivers/infiniband/hw/qib/Makefile b/drivers/infiniband/hw/qib/Makefile +--- a/drivers/infiniband/hw/qib/Makefile 2010-04-20 16:01:02.000000000 -0700 ++++ b/drivers/infiniband/hw/qib/Makefile 2010-04-20 15:58:32.000000000 -0700 +@@ -1,4 +1,4 @@ +-ccflags-y += -DQIB_KERN_TYPE=0 -DQIB_IDSTR='"QLogic kernel.org driver"' ++EXTRA_CFLAGS += -DQIB_KERN_TYPE=0 -DQIB_IDSTR='"QLogic kernel.org driver"' + + obj-$(CONFIG_INFINIBAND_QIB) += ib_qib.o + +diff --git a/drivers/infiniband/hw/qib/qib.h b/drivers/infiniband/hw/qib/qib.h +index 305f9b6..91fc9d0 100644 +--- a/drivers/infiniband/hw/qib/qib.h ++++ b/drivers/infiniband/hw/qib/qib.h +@@ -660,8 +660,8 @@ struct qib_devdata { + struct pci_dev *pcidev; + struct cdev *user_cdev; + struct cdev *diag_cdev; +- struct device *user_device; +- struct device *diag_device; ++ struct class_device *user_class_dev; ++ struct class_device *diag_class_dev; + + /* mem-mapped pointer to base of chip regs */ + u64 __iomem *kregbase; +@@ -1055,8 +1055,8 @@ int qib_count_active_units(void); + + int qib_cdev_init(int minor, const char *name, + const struct file_operations *fops, +- struct cdev **cdevp, struct device **devp); +-void qib_cdev_cleanup(struct cdev **cdevp, struct device **devp); ++ struct cdev **cdevp, struct class_device **class_devp); ++void qib_cdev_cleanup(struct cdev **cdevp, struct class_device **class_devp); + int qib_dev_init(void); + void qib_dev_cleanup(void); + +diff --git a/drivers/infiniband/hw/qib/qib_cq.c b/drivers/infiniband/hw/qib/qib_cq.c +index e0f4ac8..ed241db 100644 +--- a/drivers/infiniband/hw/qib/qib_cq.c ++++ b/drivers/infiniband/hw/qib/qib_cq.c +@@ -237,11 +237,12 @@ struct ib_cq *qib_create_cq(struct ib_device *ibdev, int entries, + sz += sizeof(struct ib_uverbs_wc) * (entries + 1); + else + sz += sizeof(struct ib_wc) * (entries + 1); +- wc = vmalloc_user(sz); ++ wc = vmalloc(sz); + if (!wc) { + ret = ERR_PTR(-ENOMEM); + goto bail_cq; + } ++ memset(wc, 0, sz); + + /* + * Return the address of the WC as the offset to mmap. +@@ -322,7 +323,7 @@ int qib_destroy_cq(struct ib_cq *ibcq) + struct qib_ibdev *dev = to_idev(ibcq->device); + struct qib_cq *cq = to_icq(ibcq); + +- flush_work(&cq->comptask); ++ flush_workqueue(qib_cq_wq); + spin_lock(&dev->n_cqs_lock); + dev->n_cqs_allocated--; + spin_unlock(&dev->n_cqs_lock); +@@ -396,11 +397,12 @@ int qib_resize_cq(struct ib_cq *ibcq, int cqe, struct ib_udata *udata) + sz += sizeof(struct ib_uverbs_wc) * (cqe + 1); + else + sz += sizeof(struct ib_wc) * (cqe + 1); +- wc = vmalloc_user(sz); ++ wc = vmalloc(sz); + if (!wc) { + ret = -ENOMEM; + goto bail; + } ++ memset(wc, 0, sz); + + /* Check that we can write the offset to mmap. */ + if (udata && udata->outlen >= sizeof(__u64)) { +diff --git a/drivers/infiniband/hw/qib/qib_diag.c b/drivers/infiniband/hw/qib/qib_diag.c +index 74ab8e8..e6520f4 100644 +--- a/drivers/infiniband/hw/qib/qib_diag.c ++++ b/drivers/infiniband/hw/qib/qib_diag.c +@@ -140,7 +140,7 @@ static const struct file_operations diag_file_ops = { + + static atomic_t diagpkt_count = ATOMIC_INIT(0); + static struct cdev *diagpkt_cdev; +-static struct device *diagpkt_device; ++static struct class_device *diagpkt_class_dev; + + static ssize_t qib_diagpkt_write(struct file *fp, const char __user *data, + size_t count, loff_t *off); +@@ -158,7 +158,7 @@ int qib_diag_add(struct qib_devdata *dd) + if (atomic_inc_return(&diagpkt_count) == 1) { + ret = qib_cdev_init(QIB_DIAGPKT_MINOR, "ipath_diagpkt", + &diagpkt_file_ops, &diagpkt_cdev, +- &diagpkt_device); ++ &diagpkt_class_dev); + if (ret) + goto done; + } +@@ -166,7 +166,7 @@ int qib_diag_add(struct qib_devdata *dd) + snprintf(name, sizeof(name), "ipath_diag%d", dd->unit); + ret = qib_cdev_init(QIB_DIAG_MINOR_BASE + dd->unit, name, + &diag_file_ops, &dd->diag_cdev, +- &dd->diag_device); ++ &dd->diag_class_dev); + done: + return ret; + } +@@ -178,9 +178,9 @@ void qib_diag_remove(struct qib_devdata *dd) + struct qib_diag_client *dc; + + if (atomic_dec_and_test(&diagpkt_count)) +- qib_cdev_cleanup(&diagpkt_cdev, &diagpkt_device); ++ qib_cdev_cleanup(&diagpkt_cdev, &diagpkt_class_dev); + +- qib_cdev_cleanup(&dd->diag_cdev, &dd->diag_device); ++ qib_cdev_cleanup(&dd->diag_cdev, &dd->diag_class_dev); + + /* + * Return all diag_clients of this device. There should be none, +diff --git a/drivers/infiniband/hw/qib/qib_file_ops.c b/drivers/infiniband/hw/qib/qib_file_ops.c +index 65f86cd..1c8bbea 100644 +--- a/drivers/infiniband/hw/qib/qib_file_ops.c ++++ b/drivers/infiniband/hw/qib/qib_file_ops.c +@@ -52,15 +52,15 @@ + static int qib_open(struct inode *, struct file *); + static int qib_close(struct inode *, struct file *); + static ssize_t qib_write(struct file *, const char __user *, size_t, loff_t *); +-static ssize_t qib_aio_write(struct kiocb *, const struct iovec *, +- unsigned long, loff_t); ++static ssize_t qib_writev(struct file *, const struct iovec *, ++ unsigned long , loff_t *); + static unsigned int qib_poll(struct file *, struct poll_table_struct *); + static int qib_mmapf(struct file *, struct vm_area_struct *); + + static const struct file_operations qib_file_ops = { + .owner = THIS_MODULE, + .write = qib_write, +- .aio_write = qib_aio_write, ++ .writev = qib_writev, + .open = qib_open, + .release = qib_close, + .poll = qib_poll, +@@ -968,24 +968,33 @@ bail: + } + + /* +- * qib_file_vma_fault - handle a VMA page fault. ++ * qib_file_vma_nopage - handle a VMA page fault. + */ +-static int qib_file_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf) ++static struct page *qib_file_vma_nopage(struct vm_area_struct *vma, ++ unsigned long address, int *type) + { +- struct page *page; ++ unsigned long offset = address - vma->vm_start; ++ struct page *page = NOPAGE_SIGBUS; ++ void *pageptr; + +- page = vmalloc_to_page((void *)(vmf->pgoff << PAGE_SHIFT)); ++ /* ++ * Convert the vmalloc address into a struct page. ++ */ ++ pageptr = (void *)(offset + (vma->vm_pgoff << PAGE_SHIFT)); ++ page = vmalloc_to_page(pageptr); + if (!page) +- return VM_FAULT_SIGBUS; ++ goto out; + ++ /* Increment the reference count. */ + get_page(page); +- vmf->page = page; +- +- return 0; ++ if (type) ++ *type = VM_FAULT_MINOR; ++out: ++ return page; + } + + static struct vm_operations_struct qib_file_vm_ops = { +- .fault = qib_file_vma_fault, ++ .nopage = qib_file_vma_nopage, + }; + + static int mmap_kvaddr(struct vm_area_struct *vma, u64 pgaddr, +@@ -1314,7 +1323,7 @@ static int init_subctxts(struct qib_devdata *dd, + goto bail; + } + +- rcd->subctxt_uregbase = vmalloc_user(PAGE_SIZE * num_subctxts); ++ rcd->subctxt_uregbase = vmalloc(PAGE_SIZE * num_subctxts); + if (!rcd->subctxt_uregbase) { + ret = -ENOMEM; + goto bail; +@@ -1322,15 +1331,15 @@ static int init_subctxts(struct qib_devdata *dd, + /* Note: rcd->rcvhdrq_size isn't initialized yet. */ + size = ALIGN(dd->rcvhdrcnt * dd->rcvhdrentsize * + sizeof(u32), PAGE_SIZE) * num_subctxts; +- rcd->subctxt_rcvhdr_base = vmalloc_user(size); ++ rcd->subctxt_rcvhdr_base = vmalloc(size); + if (!rcd->subctxt_rcvhdr_base) { + ret = -ENOMEM; + goto bail_ureg; + } + +- rcd->subctxt_rcvegrbuf = vmalloc_user(rcd->rcvegrbuf_chunks * +- rcd->rcvegrbuf_size * +- num_subctxts); ++ rcd->subctxt_rcvegrbuf = vmalloc(rcd->rcvegrbuf_chunks * ++ rcd->rcvegrbuf_size * ++ num_subctxts); + if (!rcd->subctxt_rcvegrbuf) { + ret = -ENOMEM; + goto bail_rhdr; +@@ -1341,6 +1350,11 @@ static int init_subctxts(struct qib_devdata *dd, + rcd->active_slaves = 1; + rcd->redirect_seq_cnt = 1; + set_bit(QIB_CTXT_MASTER_UNINIT, &rcd->flag); ++ memset(rcd->subctxt_uregbase, 0, PAGE_SIZE * num_subctxts); ++ memset(rcd->subctxt_rcvhdr_base, 0, size); ++ memset(rcd->subctxt_rcvegrbuf, 0, rcd->rcvegrbuf_chunks * ++ rcd->rcvegrbuf_size * ++ num_subctxts); + goto bail; + + bail_rhdr: +@@ -1686,7 +1700,7 @@ done_chk_sdma: + * it just means that sooner or later we don't recommend + * a cpu, and let the scheduler do it's best. + */ +- weight = cpumask_weight(¤t->cpus_allowed); ++ weight = cpus_weight(current->cpus_allowed); + if (!ret && weight >= qib_cpulist_count) { + int cpu; + cpu = find_first_zero_bit(qib_cpulist, +@@ -1704,12 +1718,12 @@ done_chk_sdma: + rcd->ctxt, subctxt_fp(fp)); + } + } else if (weight == 1 && +- test_bit(cpumask_first(¤t->cpus_allowed), ++ test_bit(first_cpu(current->cpus_allowed), + qib_cpulist)) + qib_devinfo(dd->pcidev, "%s PID %u affinity " + "set to cpu %d; already allocated\n", + current->comm, current->pid, +- cpumask_first(¤t->cpus_allowed)); ++ first_cpu(current->cpus_allowed)); + else if (!ret) + qib_cdbg(PROC, "affinity set for %d cpus of %d, not " + "allocating cpu\n", +@@ -2353,11 +2367,11 @@ bail: + return ret; + } + +-static ssize_t qib_aio_write(struct kiocb *iocb, const struct iovec *iov, +- unsigned long dim, loff_t off) ++static ssize_t qib_writev(struct file *filp, const struct iovec *iov, ++ unsigned long dim, loff_t *off) + { +- struct qib_filedata *fp = iocb->ki_filp->private_data; +- struct qib_ctxtdata *rcd = ctxt_fp(iocb->ki_filp); ++ struct qib_filedata *fp = filp->private_data; ++ struct qib_ctxtdata *rcd = ctxt_fp(filp); + struct qib_user_sdma_queue *pq = fp->pq; + + if (!dim || !pq) +@@ -2371,11 +2385,11 @@ static dev_t qib_dev; + + int qib_cdev_init(int minor, const char *name, + const struct file_operations *fops, +- struct cdev **cdevp, struct device **devp) ++ struct cdev **cdevp, struct class_device **class_devp) + { + const dev_t dev = MKDEV(MAJOR(qib_dev), minor); + struct cdev *cdev; +- struct device *device = NULL; ++ struct class_device *class_dev = NULL; + int ret; + + cdev = cdev_alloc(); +@@ -2399,11 +2413,12 @@ int qib_cdev_init(int minor, const char *name, + goto err_cdev; + } + +- device = device_create(qib_class, NULL, dev, NULL, name); +- if (!IS_ERR(device)) ++ class_dev = class_device_create(qib_class, NULL, dev, NULL, ++ (char *)name); ++ if (!IS_ERR(class_dev)) + goto done; +- ret = PTR_ERR(device); +- device = NULL; ++ ret = PTR_ERR(class_dev); ++ class_dev = NULL; + printk(KERN_ERR QIB_DRV_NAME ": Could not create " + "device for minor %d, %s (err %d)\n", + minor, name, -ret); +@@ -2412,17 +2427,17 @@ err_cdev: + cdev = NULL; + done: + *cdevp = cdev; +- *devp = device; ++ *class_devp = class_dev; + return ret; + } + +-void qib_cdev_cleanup(struct cdev **cdevp, struct device **devp) ++void qib_cdev_cleanup(struct cdev **cdevp, struct class_device **class_devp) + { +- struct device *device = *devp; ++ struct class_device *class_dev = *class_devp; + +- if (device) { +- device_unregister(device); +- *devp = NULL; ++ if (class_dev) { ++ class_device_unregister(class_dev); ++ *class_devp = NULL; + } + + if (*cdevp) { +@@ -2432,7 +2447,7 @@ void qib_cdev_cleanup(struct cdev **cdevp, struct device **devp) + } + + static struct cdev *wildcard_cdev; +-static struct device *wildcard_device; ++static struct class_device *wildcard_class_dev; + + int __init qib_dev_init(void) + { +@@ -2472,9 +2487,9 @@ static atomic_t user_count = ATOMIC_INIT(0); + static void qib_user_remove(struct qib_devdata *dd) + { + if (atomic_dec_return(&user_count) == 0) +- qib_cdev_cleanup(&wildcard_cdev, &wildcard_device); ++ qib_cdev_cleanup(&wildcard_cdev, &wildcard_class_dev); + +- qib_cdev_cleanup(&dd->user_cdev, &dd->user_device); ++ qib_cdev_cleanup(&dd->user_cdev, &dd->user_class_dev); + } + + static int qib_user_add(struct qib_devdata *dd) +@@ -2484,14 +2499,14 @@ static int qib_user_add(struct qib_devdata *dd) + + if (atomic_inc_return(&user_count) == 1) { + ret = qib_cdev_init(0, "ipath", &qib_file_ops, +- &wildcard_cdev, &wildcard_device); ++ &wildcard_cdev, &wildcard_class_dev); + if (ret) + goto done; + } + + snprintf(name, sizeof(name), "ipath%d", dd->unit); + ret = qib_cdev_init(dd->unit + 1, name, &qib_file_ops, +- &dd->user_cdev, &dd->user_device); ++ &dd->user_cdev, &dd->user_class_dev); + if (ret) + qib_user_remove(dd); + done: +diff --git a/drivers/infiniband/hw/qib/qib_iba7322.c b/drivers/infiniband/hw/qib/qib_iba7322.c +index 4e3a621..b83f797 100644 +--- a/drivers/infiniband/hw/qib/qib_iba7322.c ++++ b/drivers/infiniband/hw/qib/qib_iba7322.c +@@ -1395,16 +1395,16 @@ static void flush_fifo(struct qib_pportdata *ppd) + u64 pbc; + const unsigned hdrwords = 7; + static struct qib_ib_header ibhdr = { +- .lrh[0] = cpu_to_be16(0xF000 | QIB_LRH_BTH), ++ .lrh[0] = __constant_cpu_to_be16(0xF000 | QIB_LRH_BTH), + .lrh[1] = IB_LID_PERMISSIVE, +- .lrh[2] = cpu_to_be16(hdrwords + SIZE_OF_CRC), ++ .lrh[2] = __constant_cpu_to_be16(hdrwords + SIZE_OF_CRC), + .lrh[3] = IB_LID_PERMISSIVE, +- .u.oth.bth[0] = cpu_to_be32( ++ .u.oth.bth[0] = __constant_cpu_to_be32( + (IB_OPCODE_UD_SEND_ONLY << 24) | QIB_DEFAULT_P_KEY), +- .u.oth.bth[1] = cpu_to_be32(0), +- .u.oth.bth[2] = cpu_to_be32(0), +- .u.oth.u.ud.deth[0] = cpu_to_be32(0), +- .u.oth.u.ud.deth[1] = cpu_to_be32(0), ++ .u.oth.bth[1] = __constant_cpu_to_be32(0), ++ .u.oth.bth[2] = __constant_cpu_to_be32(0), ++ .u.oth.u.ud.deth[0] = __constant_cpu_to_be32(0), ++ .u.oth.u.ud.deth[1] = __constant_cpu_to_be32(0), + }; + + /* +@@ -5490,7 +5490,7 @@ static void try_7322_ipg(struct qib_pportdata *ppd) + struct ib_ah *ah; + + memset(&attr, 0, sizeof attr); +- attr.dlid = be16_to_cpu(IB_LID_PERMISSIVE); ++ attr.dlid = __constant_be16_to_cpu(IB_LID_PERMISSIVE); + attr.port_num = ppd->port; + ah = ib_create_ah(ibp->qp0->ibqp.pd, &attr); + if (IS_ERR(ah)) +diff --git a/drivers/infiniband/hw/qib/qib_init.c b/drivers/infiniband/hw/qib/qib_init.c +index 493e314..0230bba 100644 +--- a/drivers/infiniband/hw/qib/qib_init.c ++++ b/drivers/infiniband/hw/qib/qib_init.c +@@ -1437,9 +1437,10 @@ int qib_create_rcvhdrq(struct qib_devdata *dd, struct qib_ctxtdata *rcd) + } + + if (rcd->ctxt >= dd->first_user_ctxt) { +- rcd->user_event_mask = vmalloc_user(PAGE_SIZE); ++ rcd->user_event_mask = vmalloc(PAGE_SIZE); + if (!rcd->user_event_mask) + goto bail_free_hdrq; ++ memset(rcd->user_event_mask, 0, PAGE_SIZE); + } + + if (!(dd->flags & QIB_NODMA_RTAIL)) { +diff --git a/drivers/infiniband/hw/qib/qib_mad.c b/drivers/infiniband/hw/qib/qib_mad.c +index f6a71ae..2c6b3ff 100644 +--- a/drivers/infiniband/hw/qib/qib_mad.c ++++ b/drivers/infiniband/hw/qib/qib_mad.c +@@ -88,7 +88,7 @@ static void qib_send_trap(struct qib_ibport *ibp, void *data, unsigned len) + + spin_lock_irqsave(&ibp->lock, flags); + if (!ibp->sm_ah) { +- if (ibp->sm_lid != be16_to_cpu(IB_LID_PERMISSIVE)) { ++ if (ibp->sm_lid != __constant_be16_to_cpu(IB_LID_PERMISSIVE)) { + struct ib_ah *ah; + struct ib_ah_attr attr; + +@@ -1400,7 +1400,7 @@ static int pma_get_portsamplesresult_ext(struct ib_perf *pmp, + status = dd->f_portcntr(ppd, QIBPORTCNTR_PSSTAT); + p->sample_status = cpu_to_be16(status); + /* 64 bits */ +- p->extended_width = cpu_to_be32(0x80000000); ++ p->extended_width = __constant_cpu_to_be32(0x80000000); + if (status == IB_PMA_SAMPLE_STATUS_DONE) { + cache_hw_sample_counters(ppd); + ppd->cong_stats.counter = +@@ -1457,7 +1457,7 @@ static int pma_get_portcounters(struct ib_perf *pmp, + pmp->status |= IB_SMP_INVALID_FIELD; + + if (cntrs.symbol_error_counter > 0xFFFFUL) +- p->symbol_error_counter = cpu_to_be16(0xFFFF); ++ p->symbol_error_counter = __constant_cpu_to_be16(0xFFFF); + else + p->symbol_error_counter = + cpu_to_be16((u16)cntrs.symbol_error_counter); +@@ -1471,17 +1471,17 @@ static int pma_get_portcounters(struct ib_perf *pmp, + else + p->link_downed_counter = (u8)cntrs.link_downed_counter; + if (cntrs.port_rcv_errors > 0xFFFFUL) +- p->port_rcv_errors = cpu_to_be16(0xFFFF); ++ p->port_rcv_errors = __constant_cpu_to_be16(0xFFFF); + else + p->port_rcv_errors = + cpu_to_be16((u16) cntrs.port_rcv_errors); + if (cntrs.port_rcv_remphys_errors > 0xFFFFUL) +- p->port_rcv_remphys_errors = cpu_to_be16(0xFFFF); ++ p->port_rcv_remphys_errors = __constant_cpu_to_be16(0xFFFF); + else + p->port_rcv_remphys_errors = + cpu_to_be16((u16)cntrs.port_rcv_remphys_errors); + if (cntrs.port_xmit_discards > 0xFFFFUL) +- p->port_xmit_discards = cpu_to_be16(0xFFFF); ++ p->port_xmit_discards = __constant_cpu_to_be16(0xFFFF); + else + p->port_xmit_discards = + cpu_to_be16((u16)cntrs.port_xmit_discards); +@@ -1492,24 +1492,24 @@ static int pma_get_portcounters(struct ib_perf *pmp, + p->lli_ebor_errors = (cntrs.local_link_integrity_errors << 4) | + cntrs.excessive_buffer_overrun_errors; + if (cntrs.vl15_dropped > 0xFFFFUL) +- p->vl15_dropped = cpu_to_be16(0xFFFF); ++ p->vl15_dropped = __constant_cpu_to_be16(0xFFFF); + else + p->vl15_dropped = cpu_to_be16((u16)cntrs.vl15_dropped); + if (cntrs.port_xmit_data > 0xFFFFFFFFUL) +- p->port_xmit_data = cpu_to_be32(0xFFFFFFFF); ++ p->port_xmit_data = __constant_cpu_to_be32(0xFFFFFFFF); + else + p->port_xmit_data = cpu_to_be32((u32)cntrs.port_xmit_data); + if (cntrs.port_rcv_data > 0xFFFFFFFFUL) +- p->port_rcv_data = cpu_to_be32(0xFFFFFFFF); ++ p->port_rcv_data = __constant_cpu_to_be32(0xFFFFFFFF); + else + p->port_rcv_data = cpu_to_be32((u32)cntrs.port_rcv_data); + if (cntrs.port_xmit_packets > 0xFFFFFFFFUL) +- p->port_xmit_packets = cpu_to_be32(0xFFFFFFFF); ++ p->port_xmit_packets = __constant_cpu_to_be32(0xFFFFFFFF); + else + p->port_xmit_packets = + cpu_to_be32((u32)cntrs.port_xmit_packets); + if (cntrs.port_rcv_packets > 0xFFFFFFFFUL) +- p->port_rcv_packets = cpu_to_be32(0xFFFFFFFF); ++ p->port_rcv_packets = __constant_cpu_to_be32(0xFFFFFFFF); + else + p->port_rcv_packets = + cpu_to_be32((u32) cntrs.port_rcv_packets); +@@ -1576,7 +1576,7 @@ static int pma_get_portcounters_cong(struct ib_perf *pmp, + cpu_to_be16((QIB_XMIT_RATE_PICO << 13) | + (dd->psxmitwait_check_rate & + ~(QIB_XMIT_RATE_PICO << 13))); +- p->port_adr_events = cpu_to_be64(0); ++ p->port_adr_events = __constant_cpu_to_be64(0); + p->port_xmit_wait = cpu_to_be64(xmit_wait_counter); + p->port_xmit_data = cpu_to_be64(cntrs.port_xmit_data); + p->port_rcv_data = cpu_to_be64(cntrs.port_rcv_data); +@@ -1585,7 +1585,7 @@ static int pma_get_portcounters_cong(struct ib_perf *pmp, + p->port_rcv_packets = + cpu_to_be64(cntrs.port_rcv_packets); + if (cntrs.symbol_error_counter > 0xFFFFUL) +- p->symbol_error_counter = cpu_to_be16(0xFFFF); ++ p->symbol_error_counter = __constant_cpu_to_be16(0xFFFF); + else + p->symbol_error_counter = + cpu_to_be16( +@@ -1601,18 +1601,18 @@ static int pma_get_portcounters_cong(struct ib_perf *pmp, + p->link_downed_counter = + (u8)cntrs.link_downed_counter; + if (cntrs.port_rcv_errors > 0xFFFFUL) +- p->port_rcv_errors = cpu_to_be16(0xFFFF); ++ p->port_rcv_errors = __constant_cpu_to_be16(0xFFFF); + else + p->port_rcv_errors = + cpu_to_be16((u16) cntrs.port_rcv_errors); + if (cntrs.port_rcv_remphys_errors > 0xFFFFUL) +- p->port_rcv_remphys_errors = cpu_to_be16(0xFFFF); ++ p->port_rcv_remphys_errors = __constant_cpu_to_be16(0xFFFF); + else + p->port_rcv_remphys_errors = + cpu_to_be16( + (u16)cntrs.port_rcv_remphys_errors); + if (cntrs.port_xmit_discards > 0xFFFFUL) +- p->port_xmit_discards = cpu_to_be16(0xFFFF); ++ p->port_xmit_discards = __constant_cpu_to_be16(0xFFFF); + else + p->port_xmit_discards = + cpu_to_be16((u16)cntrs.port_xmit_discards); +@@ -1623,7 +1623,7 @@ static int pma_get_portcounters_cong(struct ib_perf *pmp, + p->lli_ebor_errors = (cntrs.local_link_integrity_errors << 4) | + cntrs.excessive_buffer_overrun_errors; + if (cntrs.vl15_dropped > 0xFFFFUL) +- p->vl15_dropped = cpu_to_be16(0xFFFF); ++ p->vl15_dropped = __constant_cpu_to_be16(0xFFFF); + else + p->vl15_dropped = cpu_to_be16((u16)cntrs.vl15_dropped); + +diff --git a/drivers/infiniband/hw/qib/qib_mad.h b/drivers/infiniband/hw/qib/qib_mad.h +index a699ce7..6f6f245 100644 +--- a/drivers/infiniband/hw/qib/qib_mad.h ++++ b/drivers/infiniband/hw/qib/qib_mad.h +@@ -32,10 +32,10 @@ + * SOFTWARE. + */ + +-#define IB_SMP_UNSUP_VERSION cpu_to_be16(0x0004) +-#define IB_SMP_UNSUP_METHOD cpu_to_be16(0x0008) +-#define IB_SMP_UNSUP_METH_ATTR cpu_to_be16(0x000C) +-#define IB_SMP_INVALID_FIELD cpu_to_be16(0x001C) ++#define IB_SMP_UNSUP_VERSION __constant_cpu_to_be16(0x0004) ++#define IB_SMP_UNSUP_METHOD __constant_cpu_to_be16(0x0008) ++#define IB_SMP_UNSUP_METH_ATTR __constant_cpu_to_be16(0x000C) ++#define IB_SMP_INVALID_FIELD __constant_cpu_to_be16(0x001C) + + struct ib_node_info { + u8 base_version; +@@ -128,22 +128,22 @@ struct ib_mad_notice_attr { + /* + * Generic trap/notice producers + */ +-#define IB_NOTICE_PROD_CA cpu_to_be16(1) +-#define IB_NOTICE_PROD_SWITCH cpu_to_be16(2) +-#define IB_NOTICE_PROD_ROUTER cpu_to_be16(3) +-#define IB_NOTICE_PROD_CLASS_MGR cpu_to_be16(4) ++#define IB_NOTICE_PROD_CA __constant_cpu_to_be16(1) ++#define IB_NOTICE_PROD_SWITCH __constant_cpu_to_be16(2) ++#define IB_NOTICE_PROD_ROUTER __constant_cpu_to_be16(3) ++#define IB_NOTICE_PROD_CLASS_MGR __constant_cpu_to_be16(4) + + /* + * Generic trap/notice numbers + */ +-#define IB_NOTICE_TRAP_LLI_THRESH cpu_to_be16(129) +-#define IB_NOTICE_TRAP_EBO_THRESH cpu_to_be16(130) +-#define IB_NOTICE_TRAP_FLOW_UPDATE cpu_to_be16(131) +-#define IB_NOTICE_TRAP_CAP_MASK_CHG cpu_to_be16(144) +-#define IB_NOTICE_TRAP_SYS_GUID_CHG cpu_to_be16(145) +-#define IB_NOTICE_TRAP_BAD_MKEY cpu_to_be16(256) +-#define IB_NOTICE_TRAP_BAD_PKEY cpu_to_be16(257) +-#define IB_NOTICE_TRAP_BAD_QKEY cpu_to_be16(258) ++#define IB_NOTICE_TRAP_LLI_THRESH __constant_cpu_to_be16(129) ++#define IB_NOTICE_TRAP_EBO_THRESH __constant_cpu_to_be16(130) ++#define IB_NOTICE_TRAP_FLOW_UPDATE __constant_cpu_to_be16(131) ++#define IB_NOTICE_TRAP_CAP_MASK_CHG __constant_cpu_to_be16(144) ++#define IB_NOTICE_TRAP_SYS_GUID_CHG __constant_cpu_to_be16(145) ++#define IB_NOTICE_TRAP_BAD_MKEY __constant_cpu_to_be16(256) ++#define IB_NOTICE_TRAP_BAD_PKEY __constant_cpu_to_be16(257) ++#define IB_NOTICE_TRAP_BAD_QKEY __constant_cpu_to_be16(258) + + /* + * Repress trap/notice flags +@@ -183,17 +183,17 @@ struct ib_vl_weight_elem { + /* + * PMA class portinfo capability mask bits + */ +-#define IB_PMA_CLASS_CAP_ALLPORTSELECT cpu_to_be16(1 << 8) +-#define IB_PMA_CLASS_CAP_EXT_WIDTH cpu_to_be16(1 << 9) +-#define IB_PMA_CLASS_CAP_XMIT_WAIT cpu_to_be16(1 << 12) +- +-#define IB_PMA_CLASS_PORT_INFO cpu_to_be16(0x0001) +-#define IB_PMA_PORT_SAMPLES_CONTROL cpu_to_be16(0x0010) +-#define IB_PMA_PORT_SAMPLES_RESULT cpu_to_be16(0x0011) +-#define IB_PMA_PORT_COUNTERS cpu_to_be16(0x0012) +-#define IB_PMA_PORT_COUNTERS_EXT cpu_to_be16(0x001D) +-#define IB_PMA_PORT_SAMPLES_RESULT_EXT cpu_to_be16(0x001E) +-#define IB_PMA_PORT_COUNTERS_CONG cpu_to_be16(0xFF00) ++#define IB_PMA_CLASS_CAP_ALLPORTSELECT __constant_cpu_to_be16(1 << 8) ++#define IB_PMA_CLASS_CAP_EXT_WIDTH __constant_cpu_to_be16(1 << 9) ++#define IB_PMA_CLASS_CAP_XMIT_WAIT __constant_cpu_to_be16(1 << 12) ++ ++#define IB_PMA_CLASS_PORT_INFO __constant_cpu_to_be16(0x0001) ++#define IB_PMA_PORT_SAMPLES_CONTROL __constant_cpu_to_be16(0x0010) ++#define IB_PMA_PORT_SAMPLES_RESULT __constant_cpu_to_be16(0x0011) ++#define IB_PMA_PORT_COUNTERS __constant_cpu_to_be16(0x0012) ++#define IB_PMA_PORT_COUNTERS_EXT __constant_cpu_to_be16(0x001D) ++#define IB_PMA_PORT_SAMPLES_RESULT_EXT __constant_cpu_to_be16(0x001E) ++#define IB_PMA_PORT_COUNTERS_CONG __constant_cpu_to_be16(0xFF00) + + struct ib_perf { + u8 base_version; +@@ -316,19 +316,19 @@ struct ib_pma_portcounters_cong { + /* number of 4nsec cycles equaling 2secs */ + #define QIB_CONG_TIMER_PSINTERVAL 0x1DCD64EC + +-#define IB_PMA_SEL_SYMBOL_ERROR cpu_to_be16(0x0001) +-#define IB_PMA_SEL_LINK_ERROR_RECOVERY cpu_to_be16(0x0002) +-#define IB_PMA_SEL_LINK_DOWNED cpu_to_be16(0x0004) +-#define IB_PMA_SEL_PORT_RCV_ERRORS cpu_to_be16(0x0008) +-#define IB_PMA_SEL_PORT_RCV_REMPHYS_ERRORS cpu_to_be16(0x0010) +-#define IB_PMA_SEL_PORT_XMIT_DISCARDS cpu_to_be16(0x0040) +-#define IB_PMA_SEL_LOCAL_LINK_INTEGRITY_ERRORS cpu_to_be16(0x0200) +-#define IB_PMA_SEL_EXCESSIVE_BUFFER_OVERRUNS cpu_to_be16(0x0400) +-#define IB_PMA_SEL_PORT_VL15_DROPPED cpu_to_be16(0x0800) +-#define IB_PMA_SEL_PORT_XMIT_DATA cpu_to_be16(0x1000) +-#define IB_PMA_SEL_PORT_RCV_DATA cpu_to_be16(0x2000) +-#define IB_PMA_SEL_PORT_XMIT_PACKETS cpu_to_be16(0x4000) +-#define IB_PMA_SEL_PORT_RCV_PACKETS cpu_to_be16(0x8000) ++#define IB_PMA_SEL_SYMBOL_ERROR __constant_cpu_to_be16(0x0001) ++#define IB_PMA_SEL_LINK_ERROR_RECOVERY __constant_cpu_to_be16(0x0002) ++#define IB_PMA_SEL_LINK_DOWNED __constant_cpu_to_be16(0x0004) ++#define IB_PMA_SEL_PORT_RCV_ERRORS __constant_cpu_to_be16(0x0008) ++#define IB_PMA_SEL_PORT_RCV_REMPHYS_ERRORS __constant_cpu_to_be16(0x0010) ++#define IB_PMA_SEL_PORT_XMIT_DISCARDS __constant_cpu_to_be16(0x0040) ++#define IB_PMA_SEL_LOCAL_LINK_INTEGRITY_ERRORS __constant_cpu_to_be16(0x0200) ++#define IB_PMA_SEL_EXCESSIVE_BUFFER_OVERRUNS __constant_cpu_to_be16(0x0400) ++#define IB_PMA_SEL_PORT_VL15_DROPPED __constant_cpu_to_be16(0x0800) ++#define IB_PMA_SEL_PORT_XMIT_DATA __constant_cpu_to_be16(0x1000) ++#define IB_PMA_SEL_PORT_RCV_DATA __constant_cpu_to_be16(0x2000) ++#define IB_PMA_SEL_PORT_XMIT_PACKETS __constant_cpu_to_be16(0x4000) ++#define IB_PMA_SEL_PORT_RCV_PACKETS __constant_cpu_to_be16(0x8000) + + #define IB_PMA_SEL_CONG_ALL 0x01 + #define IB_PMA_SEL_CONG_PORT_DATA 0x02 +@@ -350,14 +350,14 @@ struct ib_pma_portcounters_ext { + __be64 port_multicast_rcv_packets; + } __attribute__ ((packed)); + +-#define IB_PMA_SELX_PORT_XMIT_DATA cpu_to_be16(0x0001) +-#define IB_PMA_SELX_PORT_RCV_DATA cpu_to_be16(0x0002) +-#define IB_PMA_SELX_PORT_XMIT_PACKETS cpu_to_be16(0x0004) +-#define IB_PMA_SELX_PORT_RCV_PACKETS cpu_to_be16(0x0008) +-#define IB_PMA_SELX_PORT_UNI_XMIT_PACKETS cpu_to_be16(0x0010) +-#define IB_PMA_SELX_PORT_UNI_RCV_PACKETS cpu_to_be16(0x0020) +-#define IB_PMA_SELX_PORT_MULTI_XMIT_PACKETS cpu_to_be16(0x0040) +-#define IB_PMA_SELX_PORT_MULTI_RCV_PACKETS cpu_to_be16(0x0080) ++#define IB_PMA_SELX_PORT_XMIT_DATA __constant_cpu_to_be16(0x0001) ++#define IB_PMA_SELX_PORT_RCV_DATA __constant_cpu_to_be16(0x0002) ++#define IB_PMA_SELX_PORT_XMIT_PACKETS __constant_cpu_to_be16(0x0004) ++#define IB_PMA_SELX_PORT_RCV_PACKETS __constant_cpu_to_be16(0x0008) ++#define IB_PMA_SELX_PORT_UNI_XMIT_PACKETS __constant_cpu_to_be16(0x0010) ++#define IB_PMA_SELX_PORT_UNI_RCV_PACKETS __constant_cpu_to_be16(0x0020) ++#define IB_PMA_SELX_PORT_MULTI_XMIT_PACKETS __constant_cpu_to_be16(0x0040) ++#define IB_PMA_SELX_PORT_MULTI_RCV_PACKETS __constant_cpu_to_be16(0x0080) + + /* + * The PortSamplesControl.CounterMasks field is an array of 3 bit fields +@@ -366,9 +366,9 @@ struct ib_pma_portcounters_ext { + */ + #define COUNTER_MASK(q, n) (q << ((9 - n) * 3)) + #define COUNTER_MASK0_9 \ +- cpu_to_be32(COUNTER_MASK(1, 0) | \ +- COUNTER_MASK(1, 1) | \ +- COUNTER_MASK(1, 2) | \ +- COUNTER_MASK(1, 3) | \ +- COUNTER_MASK(1, 4)) ++ __constant_cpu_to_be32(COUNTER_MASK(1, 0) | \ ++ COUNTER_MASK(1, 1) | \ ++ COUNTER_MASK(1, 2) | \ ++ COUNTER_MASK(1, 3) | \ ++ COUNTER_MASK(1, 4)) + +diff --git a/drivers/infiniband/hw/qib/qib_mmap.c b/drivers/infiniband/hw/qib/qib_mmap.c +index ae15d38..4e37009 100644 +--- a/drivers/infiniband/hw/qib/qib_mmap.c ++++ b/drivers/infiniband/hw/qib/qib_mmap.c +@@ -74,9 +74,40 @@ static void qib_vma_close(struct vm_area_struct *vma) + kref_put(&ip->ref, qib_release_mmap_info); + } + ++/* ++ * qib_vma_nopage - handle a VMA page fault. ++ */ ++static struct page *qib_vma_nopage(struct vm_area_struct *vma, ++ unsigned long address, int *type) ++{ ++ struct qib_mmap_info *ip = vma->vm_private_data; ++ unsigned long offset = address - vma->vm_start; ++ struct page *page = NOPAGE_SIGBUS; ++ void *pageptr; ++ ++ if (offset >= ip->size) ++ goto out; /* out of range */ ++ ++ /* ++ * Convert the vmalloc address into a struct page. ++ */ ++ pageptr = (void *)(offset + ip->obj); ++ page = vmalloc_to_page(pageptr); ++ if (!page) ++ goto out; ++ ++ /* Increment the reference count. */ ++ get_page(page); ++ if (type) ++ *type = VM_FAULT_MINOR; ++out: ++ return page; ++} ++ + static struct vm_operations_struct qib_vm_ops = { + .open = qib_vma_open, + .close = qib_vma_close, ++ .nopage = qib_vma_nopage, + }; + + /** +@@ -111,10 +142,10 @@ int qib_mmap(struct ib_ucontext *context, struct vm_area_struct *vma) + list_del_init(&ip->pending_mmaps); + spin_unlock_irq(&dev->pending_lock); + +- ret = remap_vmalloc_range(vma, ip->obj, 0); +- if (ret) +- goto done; ++ ret = 0; ++ + vma->vm_ops = &qib_vm_ops; ++ vma->vm_flags |= VM_RESERVED | VM_DONTEXPAND; + vma->vm_private_data = ip; + qib_vma_open(vma); + goto done; +diff --git a/drivers/infiniband/hw/qib/qib_qp.c b/drivers/infiniband/hw/qib/qib_qp.c +index 371af8a..c8af73f 100644 +--- a/drivers/infiniband/hw/qib/qib_qp.c ++++ b/drivers/infiniband/hw/qib/qib_qp.c +@@ -37,6 +37,9 @@ + + #include "qib.h" + ++/* Undo OFED backport changes so we get the real cancel_delayed_work() */ ++#undef cancel_delayed_work ++ + #define BITS_PER_PAGE (PAGE_SIZE*BITS_PER_BYTE) + #define BITS_PER_PAGE_MASK (BITS_PER_PAGE-1) + +@@ -680,7 +683,8 @@ int qib_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr, + spin_unlock(&qp->s_lock); + spin_unlock_irq(&qp->r_lock); + /* Stop the sending work queue and retry timer */ +- cancel_work_sync(&qp->s_work); ++ cancel_delayed_work(&qp->s_work); ++ flush_workqueue(qib_wq); + del_timer_sync(&qp->s_timer); + wait_event(qp->wait_dma, !atomic_read(&qp->s_dma_busy)); + if (qp->s_tx) { +@@ -1019,12 +1023,14 @@ struct ib_qp *qib_create_qp(struct ib_pd *ibpd, + qp->r_rq.max_sge = init_attr->cap.max_recv_sge; + sz = (sizeof(struct ib_sge) * qp->r_rq.max_sge) + + sizeof(struct qib_rwqe); +- qp->r_rq.wq = vmalloc_user(sizeof(struct qib_rwq) + +- qp->r_rq.size * sz); ++ qp->r_rq.wq = vmalloc(sizeof(struct qib_rwq) + ++ qp->r_rq.size * sz); + if (!qp->r_rq.wq) { + ret = ERR_PTR(-ENOMEM); + goto bail_qp; + } ++ memset(qp->r_rq.wq, 0, ++ sizeof(struct qib_rwq) + qp->r_rq.size * sz); + } + + /* +@@ -1161,7 +1167,8 @@ int qib_destroy_qp(struct ib_qp *ibqp) + spin_unlock(&dev->pending_lock); + qp->s_flags &= ~(QIB_S_TIMER | QIB_S_ANY_WAIT); + spin_unlock_irq(&qp->s_lock); +- cancel_work_sync(&qp->s_work); ++ cancel_delayed_work(&qp->s_work); ++ flush_workqueue(qib_wq); + del_timer_sync(&qp->s_timer); + wait_event(qp->wait_dma, !atomic_read(&qp->s_dma_busy)); + if (qp->s_tx) { +diff --git a/drivers/infiniband/hw/qib/qib_rc.c b/drivers/infiniband/hw/qib/qib_rc.c +index 82e8d98..02d4cd5 100644 +--- a/drivers/infiniband/hw/qib/qib_rc.c ++++ b/drivers/infiniband/hw/qib/qib_rc.c +@@ -2060,7 +2060,7 @@ send_last: + /* Signal completion event if the solicited bit is set. */ + qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc, + (ohdr->bth[0] & +- cpu_to_be32(IB_BTH_SOLICITED)) != 0); ++ __constant_cpu_to_be32(IB_BTH_SOLICITED)) != 0); + break; + + case OP(RDMA_WRITE_FIRST): +@@ -2167,7 +2167,7 @@ send_last: + qp->r_nak_state = 0; + qp->r_head_ack_queue = next; + +- /* Schedule the send tasklet. */ ++ /* Schedule the send tasklet */ + qp->s_flags |= QIB_S_RESP_PENDING; + qib_schedule_send(qp); + +diff --git a/drivers/infiniband/hw/qib/qib_sdma.c b/drivers/infiniband/hw/qib/qib_sdma.c +index 878831c..3da10bb 100644 +--- a/drivers/infiniband/hw/qib/qib_sdma.c ++++ b/drivers/infiniband/hw/qib/qib_sdma.c +@@ -591,7 +591,7 @@ retry: + dw = (len + 3) >> 2; + addr = dma_map_single(&ppd->dd->pcidev->dev, sge->vaddr, + dw << 2, DMA_TO_DEVICE); +- if (dma_mapping_error(&ppd->dd->pcidev->dev, addr)) ++ if (dma_mapping_error(addr)) + goto unmap; + sdmadesc[0] = 0; + make_sdma_desc(ppd, sdmadesc, (u64) addr, dw, dwoffset); +@@ -633,11 +633,11 @@ retry: + if (!tail) + descqp = &ppd->sdma_descq[ppd->sdma_descq_cnt].qw[0]; + descqp -= 2; +- descqp[0] |= cpu_to_le64(SDMA_DESC_LAST); ++ descqp[0] |= __constant_cpu_to_le64(SDMA_DESC_LAST); + if (tx->txreq.flags & QIB_SDMA_TXREQ_F_HEADTOHOST) +- descqp[0] |= cpu_to_le64(SDMA_DESC_DMA_HEAD); ++ descqp[0] |= __constant_cpu_to_le64(SDMA_DESC_DMA_HEAD); + if (tx->txreq.flags & QIB_SDMA_TXREQ_F_INTREQ) +- descqp[0] |= cpu_to_le64(SDMA_DESC_INTR); ++ descqp[0] |= __constant_cpu_to_le64(SDMA_DESC_INTR); + + atomic_inc(&tx->qp->s_dma_busy); + tx->txreq.next_descq_idx = tail; +diff --git a/drivers/infiniband/hw/qib/qib_srq.c b/drivers/infiniband/hw/qib/qib_srq.c +index d79ae33..189e88a 100644 +--- a/drivers/infiniband/hw/qib/qib_srq.c ++++ b/drivers/infiniband/hw/qib/qib_srq.c +@@ -127,11 +127,12 @@ struct ib_srq *qib_create_srq(struct ib_pd *ibpd, + srq->rq.max_sge = srq_init_attr->attr.max_sge; + sz = sizeof(struct ib_sge) * srq->rq.max_sge + + sizeof(struct qib_rwqe); +- srq->rq.wq = vmalloc_user(sizeof(struct qib_rwq) + srq->rq.size * sz); ++ srq->rq.wq = vmalloc(sizeof(struct qib_rwq) + srq->rq.size * sz); + if (!srq->rq.wq) { + ret = ERR_PTR(-ENOMEM); + goto bail_srq; + } ++ memset(srq->rq.wq, 0, sizeof(struct qib_rwq) + srq->rq.size * sz); + + /* + * Return the address of the RWQ as the offset to mmap. +@@ -226,11 +227,12 @@ int qib_modify_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr, + sz = sizeof(struct qib_rwqe) + + srq->rq.max_sge * sizeof(struct ib_sge); + size = attr->max_wr + 1; +- wq = vmalloc_user(sizeof(struct qib_rwq) + size * sz); ++ wq = vmalloc(sizeof(struct qib_rwq) + size * sz); + if (!wq) { + ret = -ENOMEM; + goto bail; + } ++ memset(wq, 0, sizeof(struct qib_rwq) + size * sz); + + /* Check that we can write the offset to mmap. */ + if (udata && udata->inlen >= sizeof(__u64)) { +diff --git a/drivers/infiniband/hw/qib/qib_sysfs.c b/drivers/infiniband/hw/qib/qib_sysfs.c +index 0ae19ab..719d3e0 100644 +--- a/drivers/infiniband/hw/qib/qib_sysfs.c ++++ b/drivers/infiniband/hw/qib/qib_sysfs.c +@@ -262,18 +262,12 @@ static ssize_t qib_portattr_store(struct kobject *kobj, + return pattr->store(ppd, buf, len); + } + +-static void qib_port_release(struct kobject *kobj) +-{ +- /* nothing to do since memory is freed by qib_free_devdata() */ +-} +- + static struct sysfs_ops qib_port_ops = { + .show = qib_portattr_show, + .store = qib_portattr_store, + }; + + static struct kobj_type qib_port_ktype = { +- .release = qib_port_release, + .sysfs_ops = &qib_port_ops, + .default_attrs = port_default_attributes + }; +@@ -345,7 +339,6 @@ static struct sysfs_ops qib_sl2vl_ops = { + }; + + static struct kobj_type qib_sl2vl_ktype = { +- .release = qib_port_release, + .sysfs_ops = &qib_sl2vl_ops, + .default_attrs = sl2vl_default_attributes + }; +@@ -356,22 +349,20 @@ static struct kobj_type qib_sl2vl_ktype = { + + /* + * Start of per-unit (or driver, in some cases, but replicated +- * per unit) functions (these get a device *) ++ * per unit) functions (these get a class_device *) + */ +-static ssize_t show_rev(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_rev(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + + return sprintf(buf, "%x\n", dd_from_dev(dev)->minrev); + } + +-static ssize_t show_hca(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_hca(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + int ret; + +@@ -386,11 +377,10 @@ static const char *qp_type_str[] = { + "SMI", "GSI", "RC", "UC", "UD", + }; + +-static ssize_t show_stats(struct device *device, struct device_attribute *attr, +- char *buf) ++static ssize_t show_stats(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + unsigned pidx; + unsigned i; +@@ -487,18 +477,16 @@ static ssize_t show_stats(struct device *device, struct device_attribute *attr, + return len; + } + +-static ssize_t show_version(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_version(struct class_device *cdev, char *buf) + { + /* The string printed here is already newline-terminated. */ + return scnprintf(buf, PAGE_SIZE, "%s", (char *)ib_qib_version); + } + +-static ssize_t show_boardversion(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_boardversion(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + + /* The string printed here is already newline-terminated. */ +@@ -506,11 +494,10 @@ static ssize_t show_boardversion(struct device *device, + } + + +-static ssize_t show_localbus_info(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_localbus_info(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + + /* The string printed here is already newline-terminated. */ +@@ -518,11 +505,10 @@ static ssize_t show_localbus_info(struct device *device, + } + + +-static ssize_t show_nctxts(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_nctxts(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + + /* Return the number of user ports (contexts) available. */ +@@ -530,11 +516,10 @@ static ssize_t show_nctxts(struct device *device, + dd->first_user_ctxt); + } + +-static ssize_t show_nfreectxts(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_nfreectxts(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + + /* Return the number of free user ports (contexts) available. */ +@@ -542,11 +527,10 @@ static ssize_t show_nfreectxts(struct device *device, + dd->first_user_ctxt - (u32)qib_stats.sps_ctxts); + } + +-static ssize_t show_serial(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_serial(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + + buf[sizeof dd->serial] = '\0'; +@@ -555,12 +539,11 @@ static ssize_t show_serial(struct device *device, + return strlen(buf); + } + +-static ssize_t store_chip_reset(struct device *device, +- struct device_attribute *attr, const char *buf, ++static ssize_t store_chip_reset(struct class_device *cdev, const char *buf, + size_t count) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + int ret; + +@@ -574,11 +557,10 @@ bail: + return ret < 0 ? ret : count; + } + +-static ssize_t show_logged_errs(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_logged_errs(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + int idx, count; + +@@ -599,11 +581,10 @@ static ssize_t show_logged_errs(struct device *device, + /* + * Dump tempsense regs. in decimal, to ease shell-scripts. + */ +-static ssize_t show_tempsense(struct device *device, +- struct device_attribute *attr, char *buf) ++static ssize_t show_tempsense(struct class_device *cdev, char *buf) + { + struct qib_ibdev *dev = +- container_of(device, struct qib_ibdev, ibdev.dev); ++ container_of(cdev, struct qib_ibdev, ibdev.class_dev); + struct qib_devdata *dd = dd_from_dev(dev); + int ret; + int idx; +@@ -634,34 +615,34 @@ static ssize_t show_tempsense(struct device *device, + */ + + /* start of per-unit file structures and support code */ +-static DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); +-static DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); +-static DEVICE_ATTR(board_id, S_IRUGO, show_hca, NULL); +-static DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL); +-static DEVICE_ATTR(version, S_IRUGO, show_version, NULL); +-static DEVICE_ATTR(nctxts, S_IRUGO, show_nctxts, NULL); +-static DEVICE_ATTR(nfreectxts, S_IRUGO, show_nfreectxts, NULL); +-static DEVICE_ATTR(serial, S_IRUGO, show_serial, NULL); +-static DEVICE_ATTR(boardversion, S_IRUGO, show_boardversion, NULL); +-static DEVICE_ATTR(logged_errors, S_IRUGO, show_logged_errs, NULL); +-static DEVICE_ATTR(tempsense, S_IRUGO, show_tempsense, NULL); +-static DEVICE_ATTR(localbus_info, S_IRUGO, show_localbus_info, NULL); +-static DEVICE_ATTR(chip_reset, S_IWUSR, NULL, store_chip_reset); +- +-static struct device_attribute *qib_attributes[] = { +- &dev_attr_hw_rev, +- &dev_attr_hca_type, +- &dev_attr_board_id, +- &dev_attr_stats, +- &dev_attr_version, +- &dev_attr_nctxts, +- &dev_attr_nfreectxts, +- &dev_attr_serial, +- &dev_attr_boardversion, +- &dev_attr_logged_errors, +- &dev_attr_tempsense, +- &dev_attr_localbus_info, +- &dev_attr_chip_reset, ++static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL); ++static CLASS_DEVICE_ATTR(hca_type, S_IRUGO, show_hca, NULL); ++static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_hca, NULL); ++static CLASS_DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL); ++static CLASS_DEVICE_ATTR(version, S_IRUGO, show_version, NULL); ++static CLASS_DEVICE_ATTR(nctxts, S_IRUGO, show_nctxts, NULL); ++static CLASS_DEVICE_ATTR(nfreectxts, S_IRUGO, show_nfreectxts, NULL); ++static CLASS_DEVICE_ATTR(serial, S_IRUGO, show_serial, NULL); ++static CLASS_DEVICE_ATTR(boardversion, S_IRUGO, show_boardversion, NULL); ++static CLASS_DEVICE_ATTR(logged_errors, S_IRUGO, show_logged_errs, NULL); ++static CLASS_DEVICE_ATTR(tempsense, S_IRUGO, show_tempsense, NULL); ++static CLASS_DEVICE_ATTR(localbus_info, S_IRUGO, show_localbus_info, NULL); ++static CLASS_DEVICE_ATTR(chip_reset, S_IWUSR, NULL, store_chip_reset); ++ ++static struct class_device_attribute *qib_class_attributes[] = { ++ &class_device_attr_hw_rev, ++ &class_device_attr_hca_type, ++ &class_device_attr_board_id, ++ &class_device_attr_stats, ++ &class_device_attr_version, ++ &class_device_attr_nctxts, ++ &class_device_attr_nfreectxts, ++ &class_device_attr_serial, ++ &class_device_attr_boardversion, ++ &class_device_attr_logged_errors, ++ &class_device_attr_tempsense, ++ &class_device_attr_localbus_info, ++ &class_device_attr_chip_reset, + }; + + static int create_port_files(struct ib_device *ibdev, u8 port_num, +@@ -723,8 +704,9 @@ int qib_verbs_register_sysfs(struct qib_devdata *dd) + struct ib_device *dev = &dd->verbs_dev.ibdev; + int i, ret; + +- for (i = 0; i < ARRAY_SIZE(qib_attributes); ++i) +- if (device_create_file(&dev->dev, qib_attributes[i])) { ++ for (i = 0; i < ARRAY_SIZE(qib_class_attributes); ++i) ++ if (class_device_create_file(&dev->class_dev, ++ qib_class_attributes[i])) { + ret = 1; + goto bail; + } +diff --git a/drivers/infiniband/hw/qib/qib_trace.c b/drivers/infiniband/hw/qib/qib_trace.c +index 180ca20..84a7aac 100644 +--- a/drivers/infiniband/hw/qib/qib_trace.c ++++ b/drivers/infiniband/hw/qib/qib_trace.c +@@ -245,7 +245,7 @@ struct qib_evt_file { + + struct evt_trace_device { + struct cdev *cdev; +- struct device *device; ++ struct class_device *class_dev; + }; + + static int qib_trace_set_bufsize(const char *val, struct kernel_param *kp); +@@ -1318,7 +1318,7 @@ int __init qib_trace_init(void) + } + + ret = qib_cdev_init(QIB_TRACE_MINOR, QIB_TRACE_FILE, &qib_trace_fops, +- &evt_dev.cdev, &evt_dev.device); ++ &evt_dev.cdev, &evt_dev.class_dev); + if (ret) + goto bail_buf; + +@@ -1341,7 +1341,7 @@ bail: + void qib_trace_fini(void) + { + if (qib_trace_buf) { +- qib_cdev_cleanup(&evt_dev.cdev, &evt_dev.device); ++ qib_cdev_cleanup(&evt_dev.cdev, &evt_dev.class_dev); + atomic_notifier_chain_unregister(&panic_notifier_list, + &qibtrace_panic_block); + qib_evt_buf_destroy(qib_trace_buf); +diff --git a/drivers/infiniband/hw/qib/qib_uc.c b/drivers/infiniband/hw/qib/qib_uc.c +index 5fc0fb0..167e5a6 100644 +--- a/drivers/infiniband/hw/qib/qib_uc.c ++++ b/drivers/infiniband/hw/qib/qib_uc.c +@@ -419,7 +419,7 @@ last_imm: + /* Signal completion event if the solicited bit is set. */ + qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc, + (ohdr->bth[0] & +- cpu_to_be32(IB_BTH_SOLICITED)) != 0); ++ __constant_cpu_to_be32(IB_BTH_SOLICITED)) != 0); + break; + + case OP(RDMA_WRITE_FIRST): +diff --git a/drivers/infiniband/hw/qib/qib_ud.c b/drivers/infiniband/hw/qib/qib_ud.c +index 4a51fd1..3e0ebd7 100644 +--- a/drivers/infiniband/hw/qib/qib_ud.c ++++ b/drivers/infiniband/hw/qib/qib_ud.c +@@ -367,7 +367,7 @@ int qib_make_ud_req(struct qib_qp *qp) + */ + ohdr->bth[1] = ah_attr->dlid >= QIB_MULTICAST_LID_BASE && + ah_attr->dlid != QIB_PERMISSIVE_LID ? +- cpu_to_be32(QIB_MULTICAST_QPN) : ++ __constant_cpu_to_be32(QIB_MULTICAST_QPN) : + cpu_to_be32(wqe->wr.wr.ud.remote_qpn); + ohdr->bth[2] = cpu_to_be32(qp->s_next_psn++ & QIB_PSN_MASK); + /* +@@ -583,7 +583,7 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr, + /* Signal completion event if the solicited bit is set. */ + qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc, + (ohdr->bth[0] & +- cpu_to_be32(IB_BTH_SOLICITED)) != 0); ++ __constant_cpu_to_be32(IB_BTH_SOLICITED)) != 0); + return; + + drop: +diff --git a/drivers/infiniband/hw/qib/qib_user_sdma.c b/drivers/infiniband/hw/qib/qib_user_sdma.c +index f83031f..cb85e03 100644 +--- a/drivers/infiniband/hw/qib/qib_user_sdma.c ++++ b/drivers/infiniband/hw/qib/qib_user_sdma.c +@@ -207,7 +207,7 @@ static int qib_user_sdma_coalesce(const struct qib_devdata *dd, + + dma_addr = dma_map_page(&dd->pcidev->dev, page, 0, len, + DMA_TO_DEVICE); +- if (dma_mapping_error(&dd->pcidev->dev, dma_addr)) { ++ if (dma_mapping_error(dma_addr)) { + ret = -ENOMEM; + goto free_unmap; + } +@@ -305,7 +305,7 @@ static int qib_user_sdma_pin_pages(const struct qib_devdata *dd, + pages[j], 0, flen, DMA_TO_DEVICE); + unsigned long fofs = addr & ~PAGE_MASK; + +- if (dma_mapping_error(&dd->pcidev->dev, dma_addr)) { ++ if (dma_mapping_error(dma_addr)) { + ret = -ENOMEM; + goto done; + } +@@ -517,7 +517,7 @@ static int qib_user_sdma_queue_pkts(const struct qib_devdata *dd, + if (page) { + dma_addr = dma_map_page(&dd->pcidev->dev, + page, 0, len, DMA_TO_DEVICE); +- if (dma_mapping_error(&dd->pcidev->dev, dma_addr)) { ++ if (dma_mapping_error(dma_addr)) { + ret = -ENOMEM; + goto free_pbc; + } +@@ -687,13 +687,13 @@ static inline __le64 qib_sdma_make_desc0(struct qib_pportdata *ppd, + + static inline __le64 qib_sdma_make_first_desc0(__le64 descq) + { +- return descq | cpu_to_le64(1ULL << 12); ++ return descq | __constant_cpu_to_le64(1ULL << 12); + } + + static inline __le64 qib_sdma_make_last_desc0(__le64 descq) + { + /* last */ /* dma head */ +- return descq | cpu_to_le64(1ULL << 11 | 1ULL << 13); ++ return descq | __constant_cpu_to_le64(1ULL << 11 | 1ULL << 13); + } + + static inline __le64 qib_sdma_make_desc1(u64 addr) +@@ -790,7 +790,7 @@ static int qib_user_sdma_push_pkts(struct qib_pportdata *ppd, + if (ofs > dd->piosize2kmax_dwords) { + for (i = 0; i < pkt->naddr; i++) { + ppd->sdma_descq[dtail].qw[0] |= +- cpu_to_le64(1ULL << 14); ++ __constant_cpu_to_le64(1ULL << 14); + if (++dtail == ppd->sdma_descq_cnt) + dtail = 0; + } +diff --git a/drivers/infiniband/hw/qib/qib_verbs.c b/drivers/infiniband/hw/qib/qib_verbs.c +index 8706883..a27e0ba 100644 +--- a/drivers/infiniband/hw/qib/qib_verbs.c ++++ b/drivers/infiniband/hw/qib/qib_verbs.c +@@ -1324,7 +1324,7 @@ static int qib_verbs_send_dma(struct qib_qp *qp, struct qib_ib_header *hdr, + + tx->txreq.addr = dma_map_single(&dd->pcidev->dev, phdr, + tx->hdr_dwords << 2, DMA_TO_DEVICE); +- if (dma_mapping_error(&dd->pcidev->dev, tx->txreq.addr)) ++ if (dma_mapping_error(tx->txreq.addr)) + goto map_err; + tx->align_buf = phdr; + tx->txreq.flags |= QIB_SDMA_TXREQ_F_FREEBUF; +@@ -1719,7 +1719,7 @@ static int qib_query_port(struct ib_device *ibdev, u8 port, + u16 lid = ppd->lid; + + memset(props, 0, sizeof(*props)); +- props->lid = lid ? lid : be16_to_cpu(IB_LID_PERMISSIVE); ++ props->lid = lid ? lid : __constant_be16_to_cpu(IB_LID_PERMISSIVE); + props->lmc = ppd->lmc; + props->sm_lid = ibp->sm_lid; + props->sm_sl = ibp->sm_sl; +@@ -2093,7 +2093,7 @@ static void init_ibport(struct qib_pportdata *ppd) + spin_lock_init(&ibp->lock); + /* Set the prefix to the default value (see ch. 4.1.1) */ + ibp->gid_prefix = IB_DEFAULT_GID_PREFIX; +- ibp->sm_lid = be16_to_cpu(IB_LID_PERMISSIVE); ++ ibp->sm_lid = __constant_be16_to_cpu(IB_LID_PERMISSIVE); + ibp->port_cap_flags = IB_PORT_SYS_IMAGE_GUID_SUP | + IB_PORT_CLIENT_REG_SUP | IB_PORT_SL_MAP_SUP | + IB_PORT_TRAP_SUP | IB_PORT_AUTO_MIGR_SUP | +@@ -2260,6 +2260,7 @@ int qib_register_ib_device(struct qib_devdata *dd) + ibdev->phys_port_cnt = dd->num_pports; + ibdev->num_comp_vectors = 1; + ibdev->dma_device = &dd->pcidev->dev; ++ ibdev->class_dev.dev = ibdev->dma_device; + ibdev->query_device = qib_query_device; + ibdev->modify_device = qib_modify_device; + ibdev->query_port = qib_query_port; +diff --git a/drivers/infiniband/hw/qib/qib_verbs.h b/drivers/infiniband/hw/qib/qib_verbs.h +index 2b37481..9666cb5 100644 +--- a/drivers/infiniband/hw/qib/qib_verbs.h ++++ b/drivers/infiniband/hw/qib/qib_verbs.h +@@ -94,13 +94,13 @@ struct qib_verbs_txreq; + #define IB_PMA_SAMPLE_STATUS_RUNNING 0x02 + + /* Mandatory IB performance counter select values. */ +-#define IB_PMA_PORT_XMIT_DATA cpu_to_be16(0x0001) +-#define IB_PMA_PORT_RCV_DATA cpu_to_be16(0x0002) +-#define IB_PMA_PORT_XMIT_PKTS cpu_to_be16(0x0003) +-#define IB_PMA_PORT_RCV_PKTS cpu_to_be16(0x0004) +-#define IB_PMA_PORT_XMIT_WAIT cpu_to_be16(0x0005) ++#define IB_PMA_PORT_XMIT_DATA __constant_cpu_to_be16(0x0001) ++#define IB_PMA_PORT_RCV_DATA __constant_cpu_to_be16(0x0002) ++#define IB_PMA_PORT_XMIT_PKTS __constant_cpu_to_be16(0x0003) ++#define IB_PMA_PORT_RCV_PKTS __constant_cpu_to_be16(0x0004) ++#define IB_PMA_PORT_XMIT_WAIT __constant_cpu_to_be16(0x0005) + +-#define QIB_VENDOR_IPG cpu_to_be16(0xFFA0) ++#define QIB_VENDOR_IPG __constant_cpu_to_be16(0xFFA0) + + #define IB_BTH_REQ_ACK (1 << 31) + #define IB_BTH_SOLICITED (1 << 23) +diff --git a/drivers/infiniband/hw/qib/qib_verbs_mcast.c b/drivers/infiniband/hw/qib/qib_verbs_mcast.c +index dabb697..4edfe65 100644 +--- a/drivers/infiniband/hw/qib/qib_verbs_mcast.c ++++ b/drivers/infiniband/hw/qib/qib_verbs_mcast.c +@@ -31,7 +31,8 @@ + * SOFTWARE. + */ + +-#include ++#include ++#include + + #include "qib.h" + +diff --git a/drivers/infiniband/hw/qib/qib_wc_pat.c b/drivers/infiniband/hw/qib/qib_wc_pat.c +index 5d137db..eb7cead 100644 +--- a/drivers/infiniband/hw/qib/qib_wc_pat.c ++++ b/drivers/infiniband/hw/qib/qib_wc_pat.c +@@ -171,7 +171,7 @@ static int read_and_modify_pat(void) + preempt_disable(); + rd_old_pat(&ret); + if (!ret) +- smp_call_function(rd_old_pat, &ret, 1); ++ smp_call_function(rd_old_pat, &ret, 1, 1); + if (ret) + goto out; + +@@ -182,7 +182,7 @@ static int read_and_modify_pat(void) + if (ret) + goto out; + +- smp_call_function(wr_new_pat, &ret, 1); ++ smp_call_function(wr_new_pat, &ret, 1, 1); + BUG_ON(ret); /* have inconsistent PAT state */ + out: + preempt_enable(); +@@ -196,7 +196,7 @@ static int restore_pat(void) + preempt_disable(); + wr_old_pat(&ret); + if (!ret) { +- smp_call_function(wr_old_pat, &ret, 1); ++ smp_call_function(wr_old_pat, &ret, 1, 1); + BUG_ON(ret); /* have inconsistent PAT state */ + } + +@@ -206,7 +206,7 @@ static int restore_pat(void) + + int qib_enable_wc_pat(void) + { +- struct cpuinfo_x86 *c = &cpu_data(0); ++ struct cpuinfo_x86 *c = &(cpu_data)[0]; + int ret; + + if (wc_enabled) +@@ -246,6 +246,11 @@ pgprot_t pgprot_writecombine(pgprot_t _prot) + pgprot_noncached(_prot); + } + ++void __iomem *ioremap_wc(unsigned long phys_addr, unsigned long size) ++{ ++ return __ioremap(phys_addr, size, QIB_WC_FLAGS); ++} ++ + int qib_wc_pat_enabled(void) + { + return wc_enabled; +@@ -261,6 +266,11 @@ pgprot_t pgprot_writecombine(pgprot_t _prot) + return pgprot_noncached(_prot); + } + ++void __iomem *ioremap_wc(unsigned long phys_addr, unsigned long size) ++{ ++ return ioremap_nocache(phys_addr, size); ++} ++ + int qib_wc_pat_enabled(void) + { + return 0; +diff --git a/drivers/infiniband/hw/qib/qib_wc_pat.h b/drivers/infiniband/hw/qib/qib_wc_pat.h +index 998029d..d016f4e 100644 +--- a/drivers/infiniband/hw/qib/qib_wc_pat.h ++++ b/drivers/infiniband/hw/qib/qib_wc_pat.h +@@ -44,5 +44,6 @@ int qib_enable_wc_pat(void); + void qib_disable_wc_pat(void); + int qib_wc_pat_enabled(void); + pgprot_t pgprot_writecombine(pgprot_t _prot); ++void __iomem *ioremap_wc(unsigned long phys_addr, unsigned long size); + + #endif diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_00_dev_set_name.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_00_dev_set_name.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_00_dev_set_name.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_00_dev_set_name.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,56 @@ +--- + drivers/infiniband/ulp/qlgc_vnic/vnic_ib.c | 7 ++++--- + drivers/infiniband/ulp/qlgc_vnic/vnic_sys.c | 5 +++-- + 2 files changed, 7 insertions(+), 5 deletions(-) + +diff --git a/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.c b/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.c +index 9bf7bcf..451dc4e 100644 +--- a/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.c ++++ b/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.c +@@ -91,7 +91,8 @@ int vnic_ib_init(void) + + interface_dev.dev.class = &vnic_class; + interface_dev.dev.release = vnic_release_dev; +- dev_set_name(&interface_dev.dev, "interfaces"); ++ snprintf(interface_dev.dev.bus_id, ++ BUS_ID_SIZE, "interfaces"); + init_completion(&interface_dev.released); + ret = device_register(&interface_dev.dev); + if (ret) { +@@ -154,8 +155,8 @@ static struct vnic_ib_port *vnic_add_port(struct vnic_ib_device *device, + port->pdev_info.dev.class = &vnic_class; + port->pdev_info.dev.parent = NULL; + port->pdev_info.dev.release = vnic_release_dev; +- dev_set_name(&port->pdev_info.dev, "vnic-%s-%d", +- device->dev->name, port_num); ++ snprintf(port->pdev_info.dev.bus_id, BUS_ID_SIZE, ++ "vnic-%s-%d", device->dev->name, port_num); + + if (device_register(&port->pdev_info.dev)) + goto free_port; +diff --git a/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.c b/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.c +index f3a35c4..0ba1583 100644 +--- a/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.c ++++ b/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.c +@@ -518,7 +518,8 @@ static struct vnic *create_vnic(struct path_param *param) + vnic->dev_info.dev.class = NULL; + vnic->dev_info.dev.parent = &interface_dev.dev; + vnic->dev_info.dev.release = vnic_release_dev; +- dev_set_name(&vnic->dev_info.dev, vnic_config->name); ++ snprintf(vnic->dev_info.dev.bus_id, BUS_ID_SIZE, ++ vnic_config->name); + + if (device_register(&vnic->dev_info.dev)) { + SYS_ERROR("create_vnic: error in registering" +@@ -897,7 +898,7 @@ static int setup_path_class_files(struct netpath *path, char *name) + path->dev_info.dev.class = NULL; + path->dev_info.dev.parent = &path->parent->dev_info.dev; + path->dev_info.dev.release = vnic_release_dev; +- dev_set_name(&path->dev_info.dev, name); ++ snprintf(path->dev_info.dev.bus_id, BUS_ID_SIZE, name); + + if (device_register(&path->dev_info.dev)) { + SYS_ERROR("error in registering path class dev\n"); +-- +1.5.2 + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_01_class_device.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_01_class_device.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_01_class_device.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_01_class_device.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,1099 @@ +--- + drivers/infiniband/ulp/qlgc_vnic/vnic_ib.c | 75 ++++--- + drivers/infiniband/ulp/qlgc_vnic/vnic_ib.h | 2 +- + drivers/infiniband/ulp/qlgc_vnic/vnic_main.c | 11 +- + drivers/infiniband/ulp/qlgc_vnic/vnic_main.h | 5 +- + drivers/infiniband/ulp/qlgc_vnic/vnic_netpath.c | 6 +- + drivers/infiniband/ulp/qlgc_vnic/vnic_netpath.h | 2 +- + drivers/infiniband/ulp/qlgc_vnic/vnic_stats.c | 126 ++++++------ + drivers/infiniband/ulp/qlgc_vnic/vnic_stats.h | 18 +- + drivers/infiniband/ulp/qlgc_vnic/vnic_sys.c | 257 ++++++++++++----------- + drivers/infiniband/ulp/qlgc_vnic/vnic_sys.h | 18 +- + 10 files changed, 266 insertions(+), 254 deletions(-) + +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.c ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.c +@@ -89,33 +89,34 @@ int vnic_ib_init(void) + goto err_ib_reg; + } + +- interface_dev.dev.class = &vnic_class; +- interface_dev.dev.release = vnic_release_dev; +- snprintf(interface_dev.dev.bus_id, ++ interface_cdev.class_dev.class = &vnic_class; ++ snprintf(interface_cdev.class_dev.class_id, + BUS_ID_SIZE, "interfaces"); +- init_completion(&interface_dev.released); +- ret = device_register(&interface_dev.dev); ++ init_completion(&interface_cdev.released); ++ ret = class_device_register(&interface_cdev.class_dev); + if (ret) { + printk(KERN_ERR PFX "couldn't register class interfaces;" + " error %d", ret); + goto err_class_dev; + } +- ret = device_create_file(&interface_dev.dev, +- &dev_attr_delete_vnic); ++ ret = class_device_create_file(&interface_cdev.class_dev, ++ &class_device_attr_delete_vnic); + if (ret) { + printk(KERN_ERR PFX "couldn't create class file" + " 'delete_vnic'; error %d", ret); + goto err_class_file; + } + +- ret = device_create_file(&interface_dev.dev, &dev_attr_force_failover); ++ ret = class_device_create_file(&interface_cdev.class_dev, ++ &class_device_attr_force_failover); + if (ret) { + printk(KERN_ERR PFX "couldn't create class file" + " 'force_failover'; error %d", ret); + goto err_force_failover_file; + } + +- ret = device_create_file(&interface_dev.dev, &dev_attr_unfailover); ++ ret = class_device_create_file(&interface_cdev.class_dev, ++ &class_device_attr_unfailover); + if (ret) { + printk(KERN_ERR PFX "couldn't create class file" + " 'unfailover'; error %d", ret); +@@ -125,11 +126,13 @@ int vnic_ib_init(void) + + return ret; + err_unfailover_file: +- device_remove_file(&interface_dev.dev, &dev_attr_force_failover); ++ class_device_remove_file(&interface_cdev.class_dev, ++ &class_device_attr_force_failover); + err_force_failover_file: +- device_remove_file(&interface_dev.dev, &dev_attr_delete_vnic); ++ class_device_remove_file(&interface_cdev.class_dev, ++ &class_device_attr_delete_vnic); + err_class_file: +- device_unregister(&interface_dev.dev); ++ class_device_unregister(&interface_cdev.class_dev); + err_class_dev: + ib_unregister_client(&vnic_client); + err_ib_reg: +@@ -148,29 +151,29 @@ static struct vnic_ib_port *vnic_add_port(struct vnic_ib_device *device, + if (!port) + return NULL; + +- init_completion(&port->pdev_info.released); ++ init_completion(&port->cdev_info.released); + port->dev = device; + port->port_num = port_num; + +- port->pdev_info.dev.class = &vnic_class; +- port->pdev_info.dev.parent = NULL; +- port->pdev_info.dev.release = vnic_release_dev; +- snprintf(port->pdev_info.dev.bus_id, BUS_ID_SIZE, ++ port->cdev_info.class_dev.class = &vnic_class; ++ port->cdev_info.class_dev.dev = device->dev->dma_device; ++ snprintf(port->cdev_info.class_dev.class_id, BUS_ID_SIZE, + "vnic-%s-%d", device->dev->name, port_num); + +- if (device_register(&port->pdev_info.dev)) ++ if (class_device_register(&port->cdev_info.class_dev)) + goto free_port; + +- if (device_create_file(&port->pdev_info.dev, +- &dev_attr_create_primary)) ++ if (class_device_create_file(&port->cdev_info.class_dev, ++ &class_device_attr_create_primary)) + goto err_class; +- if (device_create_file(&port->pdev_info.dev, +- &dev_attr_create_secondary)) ++ ++ if (class_device_create_file(&port->cdev_info.class_dev, ++ &class_device_attr_create_secondary)) + goto err_class; + + return port; + err_class: +- device_unregister(&port->pdev_info.dev); ++ class_device_unregister(&port->cdev_info.class_dev); + free_port: + kfree(port); + +@@ -219,14 +222,16 @@ static void vnic_remove_one(struct ib_device *device) + list_for_each_entry_safe(port, tmp_port, + &vnic_dev->port_list, list) { + +- device_remove_file(&port->pdev_info.dev, &dev_attr_create_primary); +- device_remove_file(&port->pdev_info.dev, &dev_attr_create_secondary); +- device_unregister(&port->pdev_info.dev); ++ class_device_remove_file(&port->cdev_info.class_dev, ++ &class_device_attr_create_primary); ++ class_device_remove_file(&port->cdev_info.class_dev, ++ &class_device_attr_create_secondary); ++ class_device_unregister(&port->cdev_info.class_dev); + /* + * wait for sysfs entries to go away, so that no new vnics + * are created + */ +- wait_for_completion(&port->pdev_info.released); ++ wait_for_completion(&port->cdev_info.released); + kfree(port); + + } +@@ -254,13 +259,15 @@ void vnic_ib_cleanup(void) + + if (!vnic_ib_inited) + return; +- +- device_remove_file(&interface_dev.dev, &dev_attr_unfailover); +- device_remove_file(&interface_dev.dev, &dev_attr_force_failover); +- device_remove_file(&interface_dev.dev, &dev_attr_delete_vnic); +- +- device_unregister(&interface_dev.dev); +- wait_for_completion(&interface_dev.released); ++ class_device_remove_file(&interface_cdev.class_dev, ++ &class_device_attr_unfailover); ++ class_device_remove_file(&interface_cdev.class_dev, ++ &class_device_attr_force_failover); ++ class_device_remove_file(&interface_cdev.class_dev, ++ &class_device_attr_delete_vnic); ++ ++ class_device_unregister(&interface_cdev.class_dev); ++ wait_for_completion(&interface_cdev.released); + + ib_unregister_client(&vnic_client); + ib_sa_unregister_client(&vnic_sa_client); +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.h ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_ib.h +@@ -109,7 +109,7 @@ struct vnic_ib_device { + struct vnic_ib_port { + struct vnic_ib_device *dev; + u8 port_num; +- struct dev_info pdev_info; ++ struct class_dev_info cdev_info; + struct list_head list; + }; + +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_main.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_main.c ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_main.c +@@ -770,11 +770,11 @@ static void vnic_handle_free_vnic_evt(struct vnic *vnic) + kfree(vnic->mc_list); + } + +- sysfs_remove_group(&vnic->dev_info.dev.kobj, +- &vnic_dev_attr_group); +- vnic_cleanup_stats_files(vnic); +- device_unregister(&vnic->dev_info.dev); +- wait_for_completion(&vnic->dev_info.released); ++ sysfs_remove_group(&vnic->class_dev_info.class_dev.kobj, ++ &vnic_dev_attr_group); ++ vnic_cleanup_stats_files(vnic); ++ class_device_unregister(&vnic->class_dev_info.class_dev); ++ wait_for_completion(&vnic->class_dev_info.released); + free_netdev(vnic->netdevice); + } + +@@ -1092,6 +1092,7 @@ struct vnic *vnic_allocate(struct vnic_config *config) + vnic->state = VNIC_UNINITIALIZED; + vnic->config = config; + ++ + netpath_init(&vnic->primary_path, vnic, 0); + netpath_init(&vnic->secondary_path, vnic, 1); + +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_main.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_main.h ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_main.h +@@ -36,7 +36,6 @@ + #include + #include + #include +-#include + + #include "vnic_config.h" + #include "vnic_netpath.h" +@@ -104,7 +103,7 @@ struct vnic { + int failed_over; + int mac_set; + struct net_device *netdevice; +- struct dev_info dev_info; ++ struct class_dev_info class_dev_info; + struct dev_mc_list *mc_list; + int mc_list_len; + int mc_count; +@@ -130,7 +129,7 @@ struct vnic { + cycles_t carrier_off_time; + u32 carrier_off_num; + } statistics; +- struct dev_info stat_info; ++ struct class_dev_info stat_info; + #endif /* CONFIG_INFINIBAND_QLGC_VNIC_STATS */ + }; + +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_netpath.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_netpath.c ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_netpath.c +@@ -82,10 +82,10 @@ void netpath_free(struct netpath *netpath) + return; + viport_free(netpath->viport); + netpath->viport = NULL; +- sysfs_remove_group(&netpath->dev_info.dev.kobj, ++ sysfs_remove_group(&netpath->class_dev_info.class_dev.kobj, + &vnic_path_attr_group); +- device_unregister(&netpath->dev_info.dev); +- wait_for_completion(&netpath->dev_info.released); ++ class_device_unregister(&netpath->class_dev_info.class_dev); ++ wait_for_completion(&netpath->class_dev_info.released); + } + + void netpath_init(struct netpath *netpath, struct vnic *vnic, +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_netpath.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_netpath.h ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_netpath.h +@@ -57,7 +57,7 @@ struct netpath { + u8 delay_reconnect; + struct timer_list timer; + enum netpath_ts timer_state; +- struct dev_info dev_info; ++ struct class_dev_info class_dev_info; + }; + + void netpath_init(struct netpath *netpath, struct vnic *vnic, +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_stats.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_stats.c ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_stats.c +@@ -43,22 +43,22 @@ cycles_t vnic_recv_ref; + * RDMA times, IOs etc + * + */ +-static ssize_t show_lifetime(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_lifetime(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + cycles_t time = get_cycles() - vnic->statistics.start_time; + + return sprintf(buf, "%llu\n", (unsigned long long)time); + } + +-static DEVICE_ATTR(lifetime, S_IRUGO, show_lifetime, NULL); ++static CLASS_DEVICE_ATTR(lifetime, S_IRUGO, show_lifetime, NULL); + +-static ssize_t show_conntime(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_conntime(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + + if (vnic->statistics.conn_time) +@@ -67,12 +67,12 @@ static ssize_t show_conntime(struct device *dev, + return 0; + } + +-static DEVICE_ATTR(connection_time, S_IRUGO, show_conntime, NULL); ++static CLASS_DEVICE_ATTR(connection_time, S_IRUGO, show_conntime, NULL); + +-static ssize_t show_disconnects(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_disconnects(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + u32 num; + +@@ -84,13 +84,13 @@ static ssize_t show_disconnects(struct device *dev, + return sprintf(buf, "%d\n", num); + } + +-static DEVICE_ATTR(disconnects, S_IRUGO, show_disconnects, NULL); ++static CLASS_DEVICE_ATTR(disconnects, S_IRUGO, show_disconnects, NULL); + +-static ssize_t show_total_disconn_time(struct device *dev, +- struct device_attribute *dev_attr, ++static ssize_t show_total_disconn_time(struct class_device *class_dev, + char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + cycles_t time; + +@@ -103,12 +103,14 @@ static ssize_t show_total_disconn_time(struct device *dev, + return sprintf(buf, "%llu\n", (unsigned long long)time); + } + +-static DEVICE_ATTR(total_disconn_time, S_IRUGO, show_total_disconn_time, NULL); ++static CLASS_DEVICE_ATTR(total_disconn_time, S_IRUGO, ++ show_total_disconn_time, NULL); + +-static ssize_t show_carrier_losses(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_carrier_losses(struct class_device *class_dev, ++ char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + u32 num; + +@@ -120,13 +122,14 @@ static ssize_t show_carrier_losses(struct device *dev, + return sprintf(buf, "%d\n", num); + } + +-static DEVICE_ATTR(carrier_losses, S_IRUGO, show_carrier_losses, NULL); ++static CLASS_DEVICE_ATTR(carrier_losses, S_IRUGO, ++ show_carrier_losses, NULL); + +-static ssize_t show_total_carr_loss_time(struct device *dev, +- struct device_attribute *dev_attr, ++static ssize_t show_total_carr_loss_time(struct class_device *class_dev, + char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + cycles_t time; + +@@ -139,93 +142,94 @@ static ssize_t show_total_carr_loss_time(struct device *dev, + return sprintf(buf, "%llu\n", (unsigned long long)time); + } + +-static DEVICE_ATTR(total_carrier_loss_time, S_IRUGO, ++static CLASS_DEVICE_ATTR(total_carrier_loss_time, S_IRUGO, + show_total_carr_loss_time, NULL); + +-static ssize_t show_total_recv_time(struct device *dev, +- struct device_attribute *dev_attr, ++static ssize_t show_total_recv_time(struct class_device *class_dev, + char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + + return sprintf(buf, "%llu\n", + (unsigned long long)vnic->statistics.recv_time); + } + +-static DEVICE_ATTR(total_recv_time, S_IRUGO, show_total_recv_time, NULL); ++static CLASS_DEVICE_ATTR(total_recv_time, S_IRUGO, ++ show_total_recv_time, NULL); + +-static ssize_t show_recvs(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_recvs(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + + return sprintf(buf, "%d\n", vnic->statistics.recv_num); + } + +-static DEVICE_ATTR(recvs, S_IRUGO, show_recvs, NULL); ++static CLASS_DEVICE_ATTR(recvs, S_IRUGO, show_recvs, NULL); + +-static ssize_t show_multicast_recvs(struct device *dev, +- struct device_attribute *dev_attr, +- char *buf) ++static ssize_t show_multicast_recvs(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + + return sprintf(buf, "%d\n", vnic->statistics.multicast_recv_num); + } + +-static DEVICE_ATTR(multicast_recvs, S_IRUGO, show_multicast_recvs, NULL); ++static CLASS_DEVICE_ATTR(multicast_recvs, S_IRUGO, show_multicast_recvs, NULL); + +-static ssize_t show_total_xmit_time(struct device *dev, +- struct device_attribute *dev_attr, ++static ssize_t show_total_xmit_time(struct class_device *class_dev, + char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + + return sprintf(buf, "%llu\n", + (unsigned long long)vnic->statistics.xmit_time); + } + +-static DEVICE_ATTR(total_xmit_time, S_IRUGO, show_total_xmit_time, NULL); ++static CLASS_DEVICE_ATTR(total_xmit_time, S_IRUGO, ++ show_total_xmit_time, NULL); + +-static ssize_t show_xmits(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_xmits(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + + return sprintf(buf, "%d\n", vnic->statistics.xmit_num); + } + +-static DEVICE_ATTR(xmits, S_IRUGO, show_xmits, NULL); ++static CLASS_DEVICE_ATTR(xmits, S_IRUGO, show_xmits, NULL); + +-static ssize_t show_failed_xmits(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_failed_xmits(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic *vnic = container_of(info, struct vnic, stat_info); + + return sprintf(buf, "%d\n", vnic->statistics.xmit_fail); + } + +-static DEVICE_ATTR(failed_xmits, S_IRUGO, show_failed_xmits, NULL); ++static CLASS_DEVICE_ATTR(failed_xmits, S_IRUGO, show_failed_xmits, NULL); + + static struct attribute *vnic_stats_attrs[] = { +- &dev_attr_lifetime.attr, +- &dev_attr_xmits.attr, +- &dev_attr_total_xmit_time.attr, +- &dev_attr_failed_xmits.attr, +- &dev_attr_recvs.attr, +- &dev_attr_multicast_recvs.attr, +- &dev_attr_total_recv_time.attr, +- &dev_attr_connection_time.attr, +- &dev_attr_disconnects.attr, +- &dev_attr_total_disconn_time.attr, +- &dev_attr_carrier_losses.attr, +- &dev_attr_total_carrier_loss_time.attr, ++ &class_device_attr_lifetime.attr, ++ &class_device_attr_xmits.attr, ++ &class_device_attr_total_xmit_time.attr, ++ &class_device_attr_failed_xmits.attr, ++ &class_device_attr_recvs.attr, ++ &class_device_attr_multicast_recvs.attr, ++ &class_device_attr_total_recv_time.attr, ++ &class_device_attr_connection_time.attr, ++ &class_device_attr_disconnects.attr, ++ &class_device_attr_total_disconn_time.attr, ++ &class_device_attr_carrier_losses.attr, ++ &class_device_attr_total_carrier_loss_time.attr, + NULL + }; + +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_stats.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_stats.h ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_stats.h +@@ -35,7 +35,6 @@ + + #include "vnic_main.h" + #include "vnic_ib.h" +-#include "vnic_sys.h" + + #ifdef CONFIG_INFINIBAND_QLGC_VNIC_STATS + +@@ -113,25 +112,24 @@ static inline void vnic_carrier_loss_stats(struct vnic *vnic) + static inline int vnic_setup_stats_files(struct vnic *vnic) + { + init_completion(&vnic->stat_info.released); +- vnic->stat_info.dev.class = NULL; +- vnic->stat_info.dev.parent = &vnic->dev_info.dev; +- vnic->stat_info.dev.release = vnic_release_dev; +- snprintf(vnic->stat_info.dev.bus_id, BUS_ID_SIZE, ++ vnic->stat_info.class_dev.class = &vnic_class; ++ vnic->stat_info.class_dev.parent = &vnic->class_dev_info.class_dev; ++ snprintf(vnic->stat_info.class_dev.class_id, BUS_ID_SIZE, + "stats"); + +- if (device_register(&vnic->stat_info.dev)) { ++ if (class_device_register(&vnic->stat_info.class_dev)) { + SYS_ERROR("create_vnic: error in registering" + " stat class dev\n"); + goto stats_out; + } + +- if (sysfs_create_group(&vnic->stat_info.dev.kobj, ++ if (sysfs_create_group(&vnic->stat_info.class_dev.kobj, + &vnic_stats_attr_group)) + goto err_stats_file; + + return 0; + err_stats_file: +- device_unregister(&vnic->stat_info.dev); ++ class_device_unregister(&vnic->stat_info.class_dev); + wait_for_completion(&vnic->stat_info.released); + stats_out: + return -1; +@@ -139,9 +137,9 @@ stats_out: + + static inline void vnic_cleanup_stats_files(struct vnic *vnic) + { +- sysfs_remove_group(&vnic->dev_info.dev.kobj, ++ sysfs_remove_group(&vnic->class_dev_info.class_dev.kobj, + &vnic_stats_attr_group); +- device_unregister(&vnic->stat_info.dev); ++ class_device_unregister(&vnic->stat_info.class_dev); + wait_for_completion(&vnic->stat_info.released); + } + +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.c ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.c +@@ -77,21 +77,20 @@ static match_table_t vnic_opt_tokens = { + {VNIC_OPT_ERR, NULL} + }; + +-void vnic_release_dev(struct device *dev) ++static void vnic_release_class_dev(struct class_device *class_dev) + { +- struct dev_info *dev_info = +- container_of(dev, struct dev_info, dev); +- +- complete(&dev_info->released); ++ struct class_dev_info *cdev_info = ++ container_of(class_dev, struct class_dev_info, class_dev); + ++ complete(&cdev_info->released); + } + + struct class vnic_class = { + .name = "infiniband_qlgc_vnic", +- .dev_release = vnic_release_dev ++ .release = vnic_release_class_dev + }; + +-struct dev_info interface_dev; ++struct class_dev_info interface_cdev; + + static int vnic_parse_options(const char *buf, struct path_param *param) + { +@@ -285,11 +284,11 @@ out: + + } + +-static ssize_t show_vnic_state(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_vnic_state(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); +- struct vnic *vnic = container_of(info, struct vnic, dev_info); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); ++ struct vnic *vnic = container_of(info, struct vnic, class_dev_info); + switch (vnic->state) { + case VNIC_UNINITIALIZED: + return sprintf(buf, "VNIC_UNINITIALIZED\n"); +@@ -301,13 +300,13 @@ static ssize_t show_vnic_state(struct device *dev, + + } + +-static DEVICE_ATTR(vnic_state, S_IRUGO, show_vnic_state, NULL); ++static CLASS_DEVICE_ATTR(vnic_state, S_IRUGO, show_vnic_state, NULL); + +-static ssize_t show_rx_csum(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_rx_csum(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); +- struct vnic *vnic = container_of(info, struct vnic, dev_info); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); ++ struct vnic *vnic = container_of(info, struct vnic, class_dev_info); + + if (vnic->config->use_rx_csum) + return sprintf(buf, "true\n"); +@@ -315,13 +314,13 @@ static ssize_t show_rx_csum(struct device *dev, + return sprintf(buf, "false\n"); + } + +-static DEVICE_ATTR(rx_csum, S_IRUGO, show_rx_csum, NULL); ++static CLASS_DEVICE_ATTR(rx_csum, S_IRUGO, show_rx_csum, NULL); + +-static ssize_t show_tx_csum(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_tx_csum(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); +- struct vnic *vnic = container_of(info, struct vnic, dev_info); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); ++ struct vnic *vnic = container_of(info, struct vnic, class_dev_info); + + if (vnic->config->use_tx_csum) + return sprintf(buf, "true\n"); +@@ -329,13 +328,13 @@ static ssize_t show_tx_csum(struct device *dev, + return sprintf(buf, "false\n"); + } + +-static DEVICE_ATTR(tx_csum, S_IRUGO, show_tx_csum, NULL); ++static CLASS_DEVICE_ATTR(tx_csum, S_IRUGO, show_tx_csum, NULL); + +-static ssize_t show_current_path(struct device *dev, +- struct device_attribute *dev_attr, char *buf) +-{ +- struct dev_info *info = container_of(dev, struct dev_info, dev); +- struct vnic *vnic = container_of(info, struct vnic, dev_info); ++static ssize_t show_current_path(struct class_device *class_dev, char *buf) ++ { ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); ++ struct vnic *vnic = container_of(info, struct vnic, class_dev_info); + unsigned long flags; + size_t length; + +@@ -350,13 +349,13 @@ static ssize_t show_current_path(struct device *dev, + return length; + } + +-static DEVICE_ATTR(current_path, S_IRUGO, show_current_path, NULL); ++static CLASS_DEVICE_ATTR(current_path, S_IRUGO, show_current_path, NULL); + + static struct attribute *vnic_dev_attrs[] = { +- &dev_attr_vnic_state.attr, +- &dev_attr_rx_csum.attr, +- &dev_attr_tx_csum.attr, +- &dev_attr_current_path.attr, ++ &class_device_attr_vnic_state.attr, ++ &class_device_attr_rx_csum.attr, ++ &class_device_attr_tx_csum.attr, ++ &class_device_attr_current_path.attr, + NULL + }; + +@@ -513,21 +512,20 @@ static struct vnic *create_vnic(struct path_param *param) + goto free_vnic_config; + } + +- init_completion(&vnic->dev_info.released); ++ init_completion(&vnic->class_dev_info.released); + +- vnic->dev_info.dev.class = NULL; +- vnic->dev_info.dev.parent = &interface_dev.dev; +- vnic->dev_info.dev.release = vnic_release_dev; +- snprintf(vnic->dev_info.dev.bus_id, BUS_ID_SIZE, ++ vnic->class_dev_info.class_dev.class = &vnic_class; ++ vnic->class_dev_info.class_dev.parent = &interface_cdev.class_dev; ++ snprintf(vnic->class_dev_info.class_dev.class_id, BUS_ID_SIZE, + vnic_config->name); + +- if (device_register(&vnic->dev_info.dev)) { ++ if (class_device_register(&vnic->class_dev_info.class_dev)) { + SYS_ERROR("create_vnic: error in registering" + " vnic class dev\n"); + goto free_vnic; + } + +- if (sysfs_create_group(&vnic->dev_info.dev.kobj, ++ if (sysfs_create_group(&vnic->class_dev_info.class_dev.kobj, + &vnic_dev_attr_group)) { + SYS_ERROR("create_vnic: error in creating" + "vnic attr group\n"); +@@ -540,11 +538,11 @@ static struct vnic *create_vnic(struct path_param *param) + + return vnic; + err_stats: +- sysfs_remove_group(&vnic->dev_info.dev.kobj, ++ sysfs_remove_group(&vnic->class_dev_info.class_dev.kobj, + &vnic_dev_attr_group); + err_attr: +- device_unregister(&vnic->dev_info.dev); +- wait_for_completion(&vnic->dev_info.released); ++ class_device_unregister(&vnic->class_dev_info.class_dev); ++ wait_for_completion(&vnic->class_dev_info.released); + free_vnic: + list_del(&vnic->list_ptrs); + kfree(vnic); +@@ -553,9 +551,8 @@ free_vnic_config: + return NULL; + } + +-static ssize_t vnic_sysfs_force_failover(struct device *dev, +- struct device_attribute *dev_attr, const char *buf, +- size_t count) ++static ssize_t vnic_sysfs_force_failover(struct class_device *class_dev, ++ const char *buf, size_t count) + { + struct vnic *vnic; + struct list_head *ptr; +@@ -579,11 +576,10 @@ static ssize_t vnic_sysfs_force_failover(struct device *dev, + return ret; + } + +-DEVICE_ATTR(force_failover, S_IWUSR, NULL, vnic_sysfs_force_failover); ++CLASS_DEVICE_ATTR(force_failover, S_IWUSR, NULL, vnic_sysfs_force_failover); + +-static ssize_t vnic_sysfs_unfailover(struct device *dev, +- struct device_attribute *dev_attr, const char *buf, +- size_t count) ++static ssize_t vnic_sysfs_unfailover(struct class_device *class_dev, ++ const char *buf, size_t count) + { + struct vnic *vnic; + struct list_head *ptr; +@@ -607,9 +603,9 @@ static ssize_t vnic_sysfs_unfailover(struct device *dev, + return ret; + } + +-DEVICE_ATTR(unfailover, S_IWUSR, NULL, vnic_sysfs_unfailover); ++CLASS_DEVICE_ATTR(unfailover, S_IWUSR, NULL, vnic_sysfs_unfailover); + +-static ssize_t vnic_delete(struct device *dev, struct device_attribute *dev_attr, ++static ssize_t vnic_delete(struct class_device *class_dev, + const char *buf, size_t count) + { + struct vnic *vnic; +@@ -634,13 +630,14 @@ static ssize_t vnic_delete(struct device *dev, struct device_attribute *dev_attr + return ret; + } + +-DEVICE_ATTR(delete_vnic, S_IWUSR, NULL, vnic_delete); ++CLASS_DEVICE_ATTR(delete_vnic, S_IWUSR, NULL, vnic_delete); + +-static ssize_t show_viport_state(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_viport_state(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); +- struct netpath *path = container_of(info, struct netpath, dev_info); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); ++ struct netpath *path = ++ container_of(info, struct netpath, class_dev_info); + switch (path->viport->state) { + case VIPORT_DISCONNECTED: + return sprintf(buf, "VIPORT_DISCONNECTED\n"); +@@ -652,13 +649,14 @@ static ssize_t show_viport_state(struct device *dev, + + } + +-static DEVICE_ATTR(viport_state, S_IRUGO, show_viport_state, NULL); ++static CLASS_DEVICE_ATTR(viport_state, S_IRUGO, show_viport_state, NULL); + +-static ssize_t show_link_state(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_link_state(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); +- struct netpath *path = container_of(info, struct netpath, dev_info); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); ++ struct netpath *path = ++ container_of(info, struct netpath, class_dev_info); + + switch (path->viport->link_state) { + case LINK_UNINITIALIZED: +@@ -739,14 +737,15 @@ static ssize_t show_link_state(struct device *dev, + } + + } +-static DEVICE_ATTR(link_state, S_IRUGO, show_link_state, NULL); ++static CLASS_DEVICE_ATTR(link_state, S_IRUGO, show_link_state, NULL); + +-static ssize_t show_heartbeat(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_heartbeat(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + +- struct netpath *path = container_of(info, struct netpath, dev_info); ++ struct netpath *path = ++ container_of(info, struct netpath, class_dev_info); + + /* hb_inteval is in jiffies, convert it back to + * 1/100ths of a second +@@ -755,20 +754,21 @@ static ssize_t show_heartbeat(struct device *dev, + (jiffies_to_msecs(path->viport->config->hb_interval)/10)); + } + +-static DEVICE_ATTR(heartbeat, S_IRUGO, show_heartbeat, NULL); ++static CLASS_DEVICE_ATTR(heartbeat, S_IRUGO, show_heartbeat, NULL); + +-static ssize_t show_ioc_guid(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_ioc_guid(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + +- struct netpath *path = container_of(info, struct netpath, dev_info); ++ struct netpath *path = ++ container_of(info, struct netpath, class_dev_info); + + return sprintf(buf, "%llx\n", + __be64_to_cpu(path->viport->config->ioc_guid)); + } + +-static DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); ++static CLASS_DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); + + static inline void get_dgid_string(u8 *dgid, char *buf) + { +@@ -783,64 +783,68 @@ static inline void get_dgid_string(u8 *dgid, char *buf) + strcat(buf, "\n"); + } + +-static ssize_t show_dgid(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_dgid(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + +- struct netpath *path = container_of(info, struct netpath, dev_info); ++ struct netpath *path = ++ container_of(info, struct netpath, class_dev_info); + + get_dgid_string(path->viport->config->path_info.path.dgid.raw, buf); + + return strlen(buf); + } + +-static DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); ++static CLASS_DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); + +-static ssize_t show_pkey(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_pkey(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + +- struct netpath *path = container_of(info, struct netpath, dev_info); ++ struct netpath *path = ++ container_of(info, struct netpath, class_dev_info); + + return sprintf(buf, "%x\n", path->viport->config->path_info.path.pkey); + } + +-static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); ++static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); + +-static ssize_t show_hca_info(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_hca_info(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + +- struct netpath *path = container_of(info, struct netpath, dev_info); ++ struct netpath *path = ++ container_of(info, struct netpath, class_dev_info); + + return sprintf(buf, "vnic-%s-%d\n", path->viport->config->ibdev->name, + path->viport->config->port); + } + +-static DEVICE_ATTR(hca_info, S_IRUGO, show_hca_info, NULL); ++static CLASS_DEVICE_ATTR(hca_info, S_IRUGO, show_hca_info, NULL); + +-static ssize_t show_ioc_string(struct device *dev, +- struct device_attribute *dev_attr, char *buf) ++static ssize_t show_ioc_string(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + +- struct netpath *path = container_of(info, struct netpath, dev_info); ++ struct netpath *path = ++ container_of(info, struct netpath, class_dev_info); + + return sprintf(buf, "%s\n", path->viport->config->ioc_string); + } + +-static DEVICE_ATTR(ioc_string, S_IRUGO, show_ioc_string, NULL); ++static CLASS_DEVICE_ATTR(ioc_string, S_IRUGO, show_ioc_string, NULL); + +-static ssize_t show_multicast_state(struct device *dev, +- struct device_attribute *dev_attr, +- char *buf) ++static ssize_t show_multicast_state(struct class_device *class_dev, char *buf) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *info = ++ container_of(class_dev, struct class_dev_info, class_dev); + +- struct netpath *path = container_of(info, struct netpath, dev_info); ++ struct netpath *path = ++ container_of(info, struct netpath, class_dev_info); + + if (!(path->viport->features_supported & VNIC_FEAT_INBOUND_IB_MC)) + return sprintf(buf, "feature not enabled\n"); +@@ -871,18 +875,18 @@ static ssize_t show_multicast_state(struct device *dev, + return sprintf(buf, "invalid state\n"); + } + +-static DEVICE_ATTR(multicast_state, S_IRUGO, show_multicast_state, NULL); ++static CLASS_DEVICE_ATTR(multicast_state, S_IRUGO, show_multicast_state, NULL); + + static struct attribute *vnic_path_attrs[] = { +- &dev_attr_viport_state.attr, +- &dev_attr_link_state.attr, +- &dev_attr_heartbeat.attr, +- &dev_attr_ioc_guid.attr, +- &dev_attr_dgid.attr, +- &dev_attr_pkey.attr, +- &dev_attr_hca_info.attr, +- &dev_attr_ioc_string.attr, +- &dev_attr_multicast_state.attr, ++ &class_device_attr_viport_state.attr, ++ &class_device_attr_link_state.attr, ++ &class_device_attr_heartbeat.attr, ++ &class_device_attr_ioc_guid.attr, ++ &class_device_attr_dgid.attr, ++ &class_device_attr_pkey.attr, ++ &class_device_attr_hca_info.attr, ++ &class_device_attr_ioc_string.attr, ++ &class_device_attr_multicast_state.attr, + NULL + }; + +@@ -893,19 +897,20 @@ struct attribute_group vnic_path_attr_group = { + + static int setup_path_class_files(struct netpath *path, char *name) + { +- init_completion(&path->dev_info.released); ++ init_completion(&path->class_dev_info.released); + +- path->dev_info.dev.class = NULL; +- path->dev_info.dev.parent = &path->parent->dev_info.dev; +- path->dev_info.dev.release = vnic_release_dev; +- snprintf(path->dev_info.dev.bus_id, BUS_ID_SIZE, name); ++ path->class_dev_info.class_dev.class = &vnic_class; ++ path->class_dev_info.class_dev.parent = ++ &path->parent->class_dev_info.class_dev; ++ snprintf(path->class_dev_info.class_dev.class_id, ++ BUS_ID_SIZE, name); + +- if (device_register(&path->dev_info.dev)) { ++ if (class_device_register(&path->class_dev_info.class_dev)) { + SYS_ERROR("error in registering path class dev\n"); + goto out; + } + +- if (sysfs_create_group(&path->dev_info.dev.kobj, ++ if (sysfs_create_group(&path->class_dev_info.class_dev.kobj, + &vnic_path_attr_group)) { + SYS_ERROR("error in creating vnic path group attrs"); + goto err_path; +@@ -914,8 +919,8 @@ static int setup_path_class_files(struct netpath *path, char *name) + return 0; + + err_path: +- device_unregister(&path->dev_info.dev); +- wait_for_completion(&path->dev_info.released); ++ class_device_unregister(&path->class_dev_info.class_dev); ++ wait_for_completion(&path->class_dev_info.released); + out: + return -1; + +@@ -1046,13 +1051,13 @@ static ssize_t update_params_and_connect(struct path_param *params, + } + } + +-static ssize_t vnic_create_primary(struct device *dev, +- struct device_attribute *dev_attr, ++static ssize_t vnic_create_primary(struct class_device *class_dev, + const char *buf, size_t count) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *cdev = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic_ib_port *target = +- container_of(info, struct vnic_ib_port, pdev_info); ++ container_of(cdev, struct vnic_ib_port, cdev_info); + + struct path_param param; + int ret = -EINVAL; +@@ -1114,15 +1119,15 @@ out: + return ret; + } + +-DEVICE_ATTR(create_primary, S_IWUSR, NULL, vnic_create_primary); ++CLASS_DEVICE_ATTR(create_primary, S_IWUSR, NULL, vnic_create_primary); + +-static ssize_t vnic_create_secondary(struct device *dev, +- struct device_attribute *dev_attr, ++static ssize_t vnic_create_secondary(struct class_device *class_dev, + const char *buf, size_t count) + { +- struct dev_info *info = container_of(dev, struct dev_info, dev); ++ struct class_dev_info *cdev = ++ container_of(class_dev, struct class_dev_info, class_dev); + struct vnic_ib_port *target = +- container_of(info, struct vnic_ib_port, pdev_info); ++ container_of(cdev, struct vnic_ib_port, cdev_info); + + struct path_param param; + struct vnic *vnic = NULL; +@@ -1186,4 +1191,4 @@ out: + return ret; + } + +-DEVICE_ATTR(create_secondary, S_IWUSR, NULL, vnic_create_secondary); ++CLASS_DEVICE_ATTR(create_secondary, S_IWUSR, NULL, vnic_create_secondary); +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.h ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_sys.h +@@ -33,21 +33,19 @@ + #ifndef VNIC_SYS_H_INCLUDED + #define VNIC_SYS_H_INCLUDED + +-struct dev_info { +- struct device dev; ++struct class_dev_info { ++ struct class_device class_dev; + struct completion released; + }; + + extern struct class vnic_class; +-extern struct dev_info interface_dev; ++extern struct class_dev_info interface_cdev; + extern struct attribute_group vnic_dev_attr_group; + extern struct attribute_group vnic_path_attr_group; +-extern struct device_attribute dev_attr_create_primary; +-extern struct device_attribute dev_attr_create_secondary; +-extern struct device_attribute dev_attr_delete_vnic; +-extern struct device_attribute dev_attr_force_failover; +-extern struct device_attribute dev_attr_unfailover; +- +-extern void vnic_release_dev(struct device *dev); ++extern struct class_device_attribute class_device_attr_create_primary; ++extern struct class_device_attribute class_device_attr_create_secondary; ++extern struct class_device_attribute class_device_attr_delete_vnic; ++extern struct class_device_attribute class_device_attr_force_failover; ++extern struct class_device_attribute class_device_attr_unfailover; + + #endif /*VNIC_SYS_H_INCLUDED*/ diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_02_dev_stats.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_02_dev_stats.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_02_dev_stats.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/qlgc_vnic_02_dev_stats.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,46 @@ +--- + drivers/infiniband/ulp/qlgc_vnic/vnic_main.c | 6 +++--- + drivers/infiniband/ulp/qlgc_vnic/vnic_main.h | 1 + + 2 files changed, 4 insertions(+), 3 deletions(-) + +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_main.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_main.c ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_main.c +@@ -204,13 +204,13 @@ static struct net_device_stats *vnic_get + if (np && np->viport) { + atomic_inc(&np->viport->reference_count); + spin_unlock_irqrestore(&vnic->current_path_lock, flags); +- viport_get_stats(np->viport, &vnic->netdevice->stats); ++ viport_get_stats(np->viport, &vnic->stats); + atomic_dec(&np->viport->reference_count); + wake_up(&np->viport->reference_queue); + } else + spin_unlock_irqrestore(&vnic->current_path_lock, flags); + +- return &vnic->netdevice->stats; ++ return &vnic->stats; + } + + static int vnic_open(struct net_device *device) +@@ -259,7 +259,7 @@ static int vnic_hard_start_xmit(struct s + if (ret) { + vnic_xmit_fail_stats(vnic); + dev_kfree_skb_any(skb); +- vnic->netdevice->stats.tx_dropped++; ++ vnic->stats.tx_dropped++; + goto out; + } + +Index: ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_main.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/qlgc_vnic/vnic_main.h ++++ ofed_kernel/drivers/infiniband/ulp/qlgc_vnic/vnic_main.h +@@ -102,6 +102,7 @@ struct vnic { + int forced_failover; + int failed_over; + int mac_set; ++ struct net_device_stats stats; + struct net_device *netdevice; + struct class_dev_info class_dev_info; + struct dev_mc_list *mc_list; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_23.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_23.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_23.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_23.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,29 @@ +commit e73984bf07f4dc54f9c3274d715b47d8cb5aea34 +Author: Andy Grover +Date: Fri Jul 17 12:37:25 2009 -0700 + + RDS backport patch for pre-2.6.24 + + Signed-off-by: Andy Grover + +diff --git a/net/rds/af_rds.c b/net/rds/af_rds.c +index 20cf16f..2f38de5 100644 +--- a/net/rds/af_rds.c ++++ b/net/rds/af_rds.c +@@ -409,14 +409,14 @@ static int __rds_create(struct socket *sock, struct sock *sk, int protocol) + return 0; + } + +-static int rds_create(struct net *net, struct socket *sock, int protocol) ++static int rds_create(struct socket *sock, int protocol) + { + struct sock *sk; + + if (sock->type != SOCK_SEQPACKET || protocol) + return -ESOCKTNOSUPPORT; + +- sk = sk_alloc(net, AF_RDS, GFP_ATOMIC, &rds_proto); ++ sk = sk_alloc(AF_RDS, GFP_ATOMIC, &rds_proto, 1); + if (!sk) + return -ENOMEM; + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_26.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_26.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_26.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_26.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,18 @@ +--- + net/rds/connection.c | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +Index: ofed_kernel/net/rds/connection.c +=================================================================== +--- ofed_kernel.orig/net/rds/connection.c ++++ ofed_kernel/net/rds/connection.c +@@ -51,8 +51,7 @@ static struct kmem_cache *rds_conn_slab; + static struct hlist_head *rds_conn_bucket(__be32 laddr, __be32 faddr) + { + /* Pass NULL, don't need struct net for hash */ +- unsigned long hash = inet_ehashfn(NULL, +- be32_to_cpu(laddr), 0, ++ unsigned long hash = inet_ehashfn(be32_to_cpu(laddr), 0, + be32_to_cpu(faddr), 0); + return &rds_conn_hash[hash & RDS_CONNECTION_HASH_MASK]; + } diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_27.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_27.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_27.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_27.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,538 @@ +commit 5a43bc90abe8aeca09470f946a16c43616bffac1 +Author: Andy Grover +Date: Tue Feb 23 15:45:50 2010 -0800 + + backport to .27 + +diff --git a/net/rds/bind.c b/net/rds/bind.c +index 5d95fc0..d48528b 100644 +--- a/net/rds/bind.c ++++ b/net/rds/bind.c +@@ -96,7 +96,7 @@ struct rds_sock *rds_find_bound(__be32 addr, __be16 port) + rs = NULL; + spin_unlock_irqrestore(&rds_bind_lock, flags); + +- rdsdebug("returning rs %p for %pI4:%u\n", rs, &addr, ++ rdsdebug("returning rs %p for %u.%u.%u.%u:%u\n", rs, NIPQUAD(addr), + ntohs(port)); + return rs; + } +@@ -133,8 +133,8 @@ static int rds_add_bound(struct rds_sock *rs, __be32 addr, __be16 *port) + rs->rs_bound_port = *port; + rds_sock_addref(rs); + +- rdsdebug("rs %p binding to %pI4:%d\n", +- rs, &addr, (int)ntohs(*port)); ++ rdsdebug("rs %p binding to %u.%u.%u.%u:%d\n", ++ rs, NIPQUAD(addr), (int)ntohs(*port)); + } + + spin_unlock_irqrestore(&rds_bind_lock, flags); +@@ -149,8 +149,8 @@ void rds_remove_bound(struct rds_sock *rs) + spin_lock_irqsave(&rds_bind_lock, flags); + + if (rs->rs_bound_addr) { +- rdsdebug("rs %p unbinding from %pI4:%d\n", +- rs, &rs->rs_bound_addr, ++ rdsdebug("rs %p unbinding from %u.%u.%u.%u:%d\n", ++ rs, NIPQUAD(rs->rs_bound_addr), + ntohs(rs->rs_bound_port)); + + rb_erase(&rs->rs_bound_node, &rds_bind_tree); +diff --git a/net/rds/cong.c b/net/rds/cong.c +index dd2711d..6b24bba 100644 +--- a/net/rds/cong.c ++++ b/net/rds/cong.c +@@ -229,8 +229,8 @@ void rds_cong_queue_updates(struct rds_cong_map *map) + + void rds_cong_map_updated(struct rds_cong_map *map, uint64_t portmask) + { +- rdsdebug("waking map %p for %pI4\n", +- map, &map->m_addr); ++ rdsdebug("waking map %p for %u.%u.%u.%u\n", ++ map, NIPQUAD(map->m_addr)); + rds_stats_inc(s_cong_update_received); + atomic_inc(&rds_cong_generation); + if (waitqueue_active(&map->m_waitq)) +@@ -278,8 +278,8 @@ void rds_cong_set_bit(struct rds_cong_map *map, __be16 port) + unsigned long i; + unsigned long off; + +- rdsdebug("setting congestion for %pI4:%u in map %p\n", +- &map->m_addr, ntohs(port), map); ++ rdsdebug("setting congestion for %u.%u.%u.%u:%u in map %p\n", ++ NIPQUAD(map->m_addr), ntohs(port), map); + + i = be16_to_cpu(port) / RDS_CONG_MAP_PAGE_BITS; + off = be16_to_cpu(port) % RDS_CONG_MAP_PAGE_BITS; +@@ -292,8 +292,8 @@ void rds_cong_clear_bit(struct rds_cong_map *map, __be16 port) + unsigned long i; + unsigned long off; + +- rdsdebug("clearing congestion for %pI4:%u in map %p\n", +- &map->m_addr, ntohs(port), map); ++ rdsdebug("clearing congestion for %u.%u.%u.%u:%u in map %p\n", ++ NIPQUAD(map->m_addr), ntohs(port), map); + + i = be16_to_cpu(port) / RDS_CONG_MAP_PAGE_BITS; + off = be16_to_cpu(port) % RDS_CONG_MAP_PAGE_BITS; +diff --git a/net/rds/connection.c b/net/rds/connection.c +index 159ef57..5988509 100644 +--- a/net/rds/connection.c ++++ b/net/rds/connection.c +@@ -88,8 +88,8 @@ static struct rds_connection *rds_conn_lookup(struct hlist_head *head, + break; + } + } +- rdsdebug("returning conn %p for %pI4 -> %pI4\n", ret, +- &laddr, &faddr); ++ rdsdebug("returning conn %p for %u.%u.%u.%u -> %u.%u.%u.%u\n", ret, ++ NIPQUAD(laddr), NIPQUAD(faddr)); + return ret; + } + +@@ -101,8 +101,8 @@ static struct rds_connection *rds_conn_lookup(struct hlist_head *head, + */ + void rds_conn_reset(struct rds_connection *conn) + { +- rdsdebug("connection %pI4 to %pI4 reset\n", +- &conn->c_laddr, &conn->c_faddr); ++ rdsdebug("connection %u.%u.%u.%u to %u.%u.%u.%u reset\n", ++ NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr)); + + rds_stats_inc(s_conn_reset); + rds_send_reset(conn); +@@ -207,8 +207,8 @@ static struct rds_connection *__rds_conn_create(__be32 laddr, __be32 faddr, + mutex_init(&conn->c_cm_lock); + conn->c_flags = 0; + +- rdsdebug("allocated conn %p for %pI4 -> %pI4 over %s %s\n", +- conn, &laddr, &faddr, ++ rdsdebug("allocated conn %p for %u.%u.%u.%u -> %u.%u.%u.%u over %s %s\n", ++ conn, NIPQUAD(laddr), NIPQUAD(faddr), + trans->t_name ? trans->t_name : "[unknown]", + is_outgoing ? "(outgoing)" : ""); + +@@ -270,9 +270,9 @@ void rds_conn_destroy(struct rds_connection *conn) + { + struct rds_message *rm, *rtmp; + +- rdsdebug("freeing conn %p for %pI4 -> " +- "%pI4\n", conn, &conn->c_laddr, +- &conn->c_faddr); ++ rdsdebug("freeing conn %p for %u.%u.%u.%u -> " ++ "%u.%u.%u.%u\n", conn, NIPQUAD(conn->c_laddr), ++ NIPQUAD(conn->c_faddr)); + + hlist_del_init(&conn->c_hash_node); + +diff --git a/net/rds/ib.c b/net/rds/ib.c +index 6fb8891..8a38556 100644 +--- a/net/rds/ib.c ++++ b/net/rds/ib.c +@@ -238,8 +238,8 @@ static int rds_ib_laddr_check(__be32 addr) + if (ret || cm_id->device->node_type != RDMA_NODE_IB_CA) + ret = -EADDRNOTAVAIL; + +- rdsdebug("addr %pI4 ret %d node type %d\n", +- &addr, ret, ++ rdsdebug("addr %u.%u.%u.%u ret %d node type %d\n", ++ NIPQUAD(addr), ret, + cm_id->device ? cm_id->device->node_type : -1); + + rdma_destroy_id(cm_id); +diff --git a/net/rds/ib_cm.c b/net/rds/ib_cm.c +index 6f3e21c..e51a5f6 100644 +--- a/net/rds/ib_cm.c ++++ b/net/rds/ib_cm.c +@@ -110,8 +110,8 @@ void rds_ib_cm_connect_complete(struct rds_connection *conn, struct rdma_cm_even + } + } + +- printk(KERN_NOTICE "RDS/IB: connected to %pI4 version %u.%u%s\n", +- &conn->c_faddr, ++ printk(KERN_NOTICE "RDS/IB: connected to %u.%u.%u.%u version %u.%u%s\n", ++ NIPQUAD(conn->c_faddr), + RDS_PROTOCOL_MAJOR(conn->c_version), + RDS_PROTOCOL_MINOR(conn->c_version), + ic->i_flowctl ? ", flow control" : ""); +@@ -204,8 +204,8 @@ static void rds_ib_qp_event_handler(struct ib_event *event, void *data) + break; + default: + rdsdebug("Fatal QP Event %u " +- "- connection %pI4->%pI4, reconnecting\n", +- event->event, &conn->c_laddr, &conn->c_faddr); ++ "- connection %u.%u.%u.%u->%u.%u.%u.%u, reconnecting\n", ++ event->event, NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr)); + rds_conn_drop(conn); + break; + } +@@ -390,9 +390,9 @@ static u32 rds_ib_protocol_compatible(struct rdma_cm_event *event) + while ((common >>= 1) != 0) + version++; + } else if (printk_ratelimit()) { +- printk(KERN_NOTICE "RDS: Connection from %pI4 using " ++ printk(KERN_NOTICE "RDS: Connection from %u.%u.%u.%u using " + "incompatible protocol version %u.%u\n", +- &dp->dp_saddr, ++ NIPQUAD(dp->dp_saddr), + dp->dp_protocol_major, + dp->dp_protocol_minor); + } +@@ -417,8 +417,8 @@ int rds_ib_cm_handle_connect(struct rdma_cm_id *cm_id, + if (!version) + goto out; + +- rdsdebug("saddr %pI4 daddr %pI4 RDSv%u.%u lguid 0x%llx fguid " +- "0x%llx\n", &dp->dp_saddr, &dp->dp_daddr, ++ rdsdebug("saddr %u.%u.%u.%u daddr %u.%u.%u.%u RDSv%u.%u lguid 0x%llx fguid " ++ "0x%llx\n", NIPQUAD(dp->dp_saddr), NIPQUAD(dp->dp_daddr), + RDS_PROTOCOL_MAJOR(version), RDS_PROTOCOL_MINOR(version), + (unsigned long long)be64_to_cpu(lguid), + (unsigned long long)be64_to_cpu(fguid)); +diff --git a/net/rds/ib_recv.c b/net/rds/ib_recv.c +index 2421e58..e99593c 100644 +--- a/net/rds/ib_recv.c ++++ b/net/rds/ib_recv.c +@@ -253,8 +253,8 @@ int rds_ib_recv_refill(struct rds_connection *conn, gfp_t kptr_gfp, + (long) recv->r_frag->f_mapped, ret); + if (ret) { + rds_ib_conn_error(conn, "recv post on " +- "%pI4 returned %d, disconnecting and " +- "reconnecting\n", &conn->c_faddr, ++ "%u.%u.%u.%u returned %d, disconnecting and " ++ "reconnecting\n", NIPQUAD(conn->c_faddr), + ret); + ret = -1; + break; +@@ -701,10 +701,10 @@ static void rds_ib_process_recv(struct rds_connection *conn, + + if (data_len < sizeof(struct rds_header)) { + rds_ib_conn_error(conn, "incoming message " +- "from %pI4 didn't inclue a " ++ "from %u.%u.%u.%u didn't inclue a " + "header, disconnecting and " + "reconnecting\n", +- &conn->c_faddr); ++ NIPQUAD(conn->c_faddr)); + return; + } + data_len -= sizeof(struct rds_header); +@@ -714,9 +714,9 @@ static void rds_ib_process_recv(struct rds_connection *conn, + /* Validate the checksum. */ + if (!rds_message_verify_checksum(ihdr)) { + rds_ib_conn_error(conn, "incoming message " +- "from %pI4 has corrupted header - " ++ "from %u.%u.%u.%u has corrupted header - " + "forcing a reconnect\n", +- &conn->c_faddr); ++ NIPQUAD(conn->c_faddr)); + rds_stats_inc(s_recv_drop_bad_checksum); + return; + } +@@ -861,8 +861,8 @@ static inline void rds_poll_cq(struct rds_ib_connection *ic, + rds_ib_process_recv(conn, recv, wc.byte_len, state); + } else { + rds_ib_conn_error(conn, "recv completion on " +- "%pI4 had status %u, disconnecting and " +- "reconnecting\n", &conn->c_faddr, ++ "%u.%u.%u.%u had status %u, disconnecting and " ++ "reconnecting\n", NIPQUAD(conn->c_faddr), + wc.status); + } + } +diff --git a/net/rds/ib_send.c b/net/rds/ib_send.c +index da7bd53..2ea3551 100644 +--- a/net/rds/ib_send.c ++++ b/net/rds/ib_send.c +@@ -259,9 +259,9 @@ void rds_ib_send_cq_comp_handler(struct ib_cq *cq, void *context) + /* We expect errors as the qp is drained during shutdown */ + if (wc.status != IB_WC_SUCCESS && rds_conn_up(conn)) { + rds_ib_conn_error(conn, +- "send completion on %pI4 " ++ "send completion on %u.%u.%u.%u " + "had status %u, disconnecting and reconnecting\n", +- &conn->c_faddr, wc.status); ++ NIPQUAD(conn->c_faddr), wc.status); + } + } + } +@@ -713,8 +713,8 @@ add_header: + first, &first->s_wr, ret, failed_wr); + BUG_ON(failed_wr != &first->s_wr); + if (ret) { +- printk(KERN_WARNING "RDS/IB: ib_post_send to %pI4 " +- "returned %d\n", &conn->c_faddr, ret); ++ printk(KERN_WARNING "RDS/IB: ib_post_send to %u.%u.%u.%u " ++ "returned %d\n", NIPQUAD(conn->c_faddr), ret); + rds_ib_ring_unalloc(&ic->i_send_ring, work_alloc); + if (prev->s_rm) { + ic->i_rm = prev->s_rm; +@@ -854,8 +854,8 @@ int rds_ib_xmit_rdma(struct rds_connection *conn, struct rds_rdma_op *op) + first, &first->s_wr, ret, failed_wr); + BUG_ON(failed_wr != &first->s_wr); + if (ret) { +- printk(KERN_WARNING "RDS/IB: rdma ib_post_send to %pI4 " +- "returned %d\n", &conn->c_faddr, ret); ++ printk(KERN_WARNING "RDS/IB: rdma ib_post_send to %u.%u.%u.%u " ++ "returned %d\n", NIPQUAD(conn->c_faddr), ret); + rds_ib_ring_unalloc(&ic->i_send_ring, work_alloc); + goto out; + } +diff --git a/net/rds/iw.c b/net/rds/iw.c +index 41999cf..d56d3cc 100644 +--- a/net/rds/iw.c ++++ b/net/rds/iw.c +@@ -240,8 +240,8 @@ static int rds_iw_laddr_check(__be32 addr) + if (ret || cm_id->device->node_type != RDMA_NODE_RNIC) + ret = -EADDRNOTAVAIL; + +- rdsdebug("addr %pI4 ret %d node type %d\n", +- &addr, ret, ++ rdsdebug("addr %u.%u.%u.%u ret %d node type %d\n", ++ NIPQUAD(addr), ret, + cm_id->device ? cm_id->device->node_type : -1); + + rdma_destroy_id(cm_id); +diff --git a/net/rds/iw_cm.c b/net/rds/iw_cm.c +index b266632..af28b54 100644 +--- a/net/rds/iw_cm.c ++++ b/net/rds/iw_cm.c +@@ -93,8 +93,8 @@ void rds_iw_cm_connect_complete(struct rds_connection *conn, struct rdma_cm_even + if (dp && dp->dp_ack_seq) + rds_send_drop_acked(conn, be64_to_cpu(dp->dp_ack_seq), NULL); + +- printk(KERN_NOTICE "RDS/IW: connected to %pI4<->%pI4 version %u.%u%s\n", +- &conn->c_laddr, &conn->c_faddr, ++ printk(KERN_NOTICE "RDS/IW: connected to %u.%u.%u.%u<->%u.%u.%u.%u version %u.%u%s\n", ++ NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr), + RDS_PROTOCOL_MAJOR(conn->c_version), + RDS_PROTOCOL_MINOR(conn->c_version), + ic->i_flowctl ? ", flow control" : ""); +@@ -157,9 +157,9 @@ static void rds_iw_qp_event_handler(struct ib_event *event, void *data) + case IB_EVENT_QP_FATAL: + default: + rdsdebug("Fatal QP Event %u " +- "- connection $pI4->%pI4, reconnecting\n", +- event->event, &conn->c_laddr, +- &conn->c_faddr); ++ "- connection %u.%u.%u.%u->%u.%u.%u.%u, reconnecting\n", ++ event->event, NIPQUAD(conn->c_laddr), ++ NIPQUAD(conn->c_faddr)); + rds_conn_drop(conn); + break; + } +@@ -365,9 +365,9 @@ static u32 rds_iw_protocol_compatible(const struct rds_iw_connect_private *dp) + while ((common >>= 1) != 0) + version++; + } else if (printk_ratelimit()) { +- printk(KERN_NOTICE "RDS: Connection from %pI4 using " ++ printk(KERN_NOTICE "RDS: Connection from %u.%u.%u.%u using " + "incompatible protocol version %u.%u\n", +- &dp->dp_saddr, ++ NIPQUAD(dp->dp_saddr), + dp->dp_protocol_major, + dp->dp_protocol_minor); + } +@@ -391,8 +391,8 @@ int rds_iw_cm_handle_connect(struct rdma_cm_id *cm_id, + if (!version) + goto out; + +- rdsdebug("saddr %pI4 daddr %pI4 RDSv%u.%u\n", +- &dp->dp_saddr, &dp->dp_daddr, ++ rdsdebug("saddr %u.%u.%u.%u daddr %u.%u.%u.%u RDSv%u.%u\n", ++ NIPQUAD(dp->dp_saddr), NIPQUAD(dp->dp_daddr), + RDS_PROTOCOL_MAJOR(version), RDS_PROTOCOL_MINOR(version)); + + conn = rds_conn_create(dp->dp_daddr, dp->dp_saddr, &rds_iw_transport, +@@ -537,8 +537,8 @@ int rds_iw_conn_connect(struct rds_connection *conn) + /* First, bind to the local address and device. */ + ret = rdma_bind_addr(ic->i_cm_id, (struct sockaddr *) &src); + if (ret) { +- rdsdebug("rdma_bind_addr(%pI4) failed: %d\n", +- &conn->c_laddr, ret); ++ rdsdebug("rdma_bind_addr(%u.%u.%u.%u) failed: %d\n", ++ NIPQUAD(conn->c_laddr), ret); + rdma_destroy_id(ic->i_cm_id); + ic->i_cm_id = NULL; + goto out; +diff --git a/net/rds/iw_recv.c b/net/rds/iw_recv.c +index b3dca08..7691100 100644 +--- a/net/rds/iw_recv.c ++++ b/net/rds/iw_recv.c +@@ -253,8 +253,8 @@ int rds_iw_recv_refill(struct rds_connection *conn, gfp_t kptr_gfp, + (long) recv->r_frag->f_mapped, ret); + if (ret) { + rds_iw_conn_error(conn, "recv post on " +- "%pI4 returned %d, disconnecting and " +- "reconnecting\n", &conn->c_faddr, ++ "%u.%u.%u.%u returned %d, disconnecting and " ++ "reconnecting\n", NIPQUAD(conn->c_faddr), + ret); + ret = -1; + break; +@@ -660,10 +660,10 @@ static void rds_iw_process_recv(struct rds_connection *conn, + + if (byte_len < sizeof(struct rds_header)) { + rds_iw_conn_error(conn, "incoming message " +- "from %pI4 didn't inclue a " ++ "from %u.%u.%u.%u didn't inclue a " + "header, disconnecting and " + "reconnecting\n", +- &conn->c_faddr); ++ NIPQUAD(conn->c_faddr)); + return; + } + byte_len -= sizeof(struct rds_header); +@@ -673,9 +673,9 @@ static void rds_iw_process_recv(struct rds_connection *conn, + /* Validate the checksum. */ + if (!rds_message_verify_checksum(ihdr)) { + rds_iw_conn_error(conn, "incoming message " +- "from %pI4 has corrupted header - " ++ "from %u.%u.%u.%u has corrupted header - " + "forcing a reconnect\n", +- &conn->c_faddr); ++ NIPQUAD(conn->c_faddr)); + rds_stats_inc(s_recv_drop_bad_checksum); + return; + } +@@ -820,8 +820,8 @@ static inline void rds_poll_cq(struct rds_iw_connection *ic, + rds_iw_process_recv(conn, recv, wc.byte_len, state); + } else { + rds_iw_conn_error(conn, "recv completion on " +- "%pI4 had status %u, disconnecting and " +- "reconnecting\n", &conn->c_faddr, ++ "%u.%u.%u.%u had status %u, disconnecting and " ++ "reconnecting\n", NIPQUAD(conn->c_faddr), + wc.status); + } + } +diff --git a/net/rds/iw_send.c b/net/rds/iw_send.c +index 603262f..fb0473c 100644 +--- a/net/rds/iw_send.c ++++ b/net/rds/iw_send.c +@@ -295,9 +295,9 @@ void rds_iw_send_cq_comp_handler(struct ib_cq *cq, void *context) + /* We expect errors as the qp is drained during shutdown */ + if (wc.status != IB_WC_SUCCESS && rds_conn_up(conn)) { + rds_iw_conn_error(conn, +- "send completion on %pI4 " ++ "send completion on %u.%u.%u.%u " + "had status %u, disconnecting and reconnecting\n", +- &conn->c_faddr, wc.status); ++ NIPQUAD(conn->c_faddr), wc.status); + } + } + } +@@ -749,8 +749,8 @@ add_header: + first, &first->s_wr, ret, failed_wr); + BUG_ON(failed_wr != &first->s_wr); + if (ret) { +- printk(KERN_WARNING "RDS/IW: ib_post_send to %pI4 " +- "returned %d\n", &conn->c_faddr, ret); ++ printk(KERN_WARNING "RDS/IW: ib_post_send to %u.%u.%u.%u " ++ "returned %d\n", NIPQUAD(conn->c_faddr), ret); + rds_iw_ring_unalloc(&ic->i_send_ring, work_alloc); + if (prev->s_rm) { + ic->i_rm = prev->s_rm; +@@ -954,8 +954,8 @@ int rds_iw_xmit_rdma(struct rds_connection *conn, struct rds_rdma_op *op) + first, &first->s_wr, ret, failed_wr); + BUG_ON(failed_wr != &first->s_wr); + if (ret) { +- printk(KERN_WARNING "RDS/IW: rdma ib_post_send to %pI4 " +- "returned %d\n", &conn->c_faddr, ret); ++ printk(KERN_WARNING "RDS/IW: rdma ib_post_send to %u.%u.%u.%u " ++ "returned %d\n", NIPQUAD(conn->c_faddr), ret); + rds_iw_ring_unalloc(&ic->i_send_ring, work_alloc); + goto out; + } +diff --git a/net/rds/rdma_transport.c b/net/rds/rdma_transport.c +index 7154c77..ce77c3a 100644 +--- a/net/rds/rdma_transport.c ++++ b/net/rds/rdma_transport.c +@@ -102,8 +102,8 @@ int rds_rdma_cm_event_handler(struct rdma_cm_id *cm_id, + + case RDMA_CM_EVENT_DISCONNECTED: + rdsdebug("DISCONNECT event - dropping connection " +- "%pI4->%pI4\n", &conn->c_laddr, +- &conn->c_faddr); ++ "%u.%u.%u.%u->%u.%u.%u.%u\n", NIPQUAD(conn->c_laddr), ++ NIPQUAD(conn->c_faddr)); + rds_conn_drop(conn); + break; + +diff --git a/net/rds/recv.c b/net/rds/recv.c +index fdff33c..1584ab7 100644 +--- a/net/rds/recv.c ++++ b/net/rds/recv.c +@@ -78,9 +78,9 @@ static void rds_recv_rcvbuf_delta(struct rds_sock *rs, struct sock *sk, + rs->rs_rcv_bytes += delta; + now_congested = rs->rs_rcv_bytes > rds_sk_rcvbuf(rs); + +- rdsdebug("rs %p (%pI4:%u) recv bytes %d buf %d " ++ rdsdebug("rs %p (%u.%u.%u.%u:%u) recv bytes %d buf %d " + "now_cong %d delta %d\n", +- rs, &rs->rs_bound_addr, ++ rs, NIPQUAD(rs->rs_bound_addr), + ntohs(rs->rs_bound_port), rs->rs_rcv_bytes, + rds_sk_rcvbuf(rs), now_congested, delta); + +@@ -447,8 +447,8 @@ int rds_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, + break; + } + +- rdsdebug("copying inc %p from %pI4:%u to user\n", inc, +- &inc->i_conn->c_faddr, ++ rdsdebug("copying inc %p from %u.%u.%u.%u:%u to user\n", inc, ++ NIPQUAD(inc->i_conn->c_faddr), + ntohs(inc->i_hdr.h_sport)); + ret = inc->i_conn->c_trans->inc_copy_to_user(inc, msg->msg_iov, + size); +diff --git a/net/rds/threads.c b/net/rds/threads.c +index dd7e0ca..562141f 100644 +--- a/net/rds/threads.c ++++ b/net/rds/threads.c +@@ -82,8 +82,8 @@ void rds_connect_complete(struct rds_connection *conn) + return; + } + +- rdsdebug("conn %p for %pI4 to %pI4 complete\n", +- conn, &conn->c_laddr, &conn->c_faddr); ++ rdsdebug("conn %p for %u.%u.%u.%u to %u.%u.%u.%u complete\n", ++ conn, NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr)); + + conn->c_reconnect_jiffies = 0; + set_bit(0, &conn->c_map_queued); +@@ -114,8 +114,8 @@ static void rds_queue_reconnect(struct rds_connection *conn) + { + unsigned long rand; + +- rdsdebug("conn %p for %pI4 to %pI4 reconnect jiffies %lu\n", +- conn, &conn->c_laddr, &conn->c_faddr, ++ rdsdebug("conn %p for %u.%u.%u.%u to %u.%u.%u.%u reconnect jiffies %lu\n", ++ conn, NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr), + conn->c_reconnect_jiffies); + + set_bit(RDS_RECONNECT_PENDING, &conn->c_flags); +@@ -126,9 +126,9 @@ static void rds_queue_reconnect(struct rds_connection *conn) + } + + get_random_bytes(&rand, sizeof(rand)); +- rdsdebug("%lu delay %lu ceil conn %p for %pI4 -> %pI4\n", ++ rdsdebug("%lu delay %lu ceil conn %p for %u.%u.%u.%u -> %u.%u.%u.%u\n", + rand % conn->c_reconnect_jiffies, conn->c_reconnect_jiffies, +- conn, &conn->c_laddr, &conn->c_faddr); ++ conn, NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr)); + queue_delayed_work(rds_wq, &conn->c_conn_w, + rand % conn->c_reconnect_jiffies); + +@@ -144,8 +144,8 @@ void rds_connect_worker(struct work_struct *work) + clear_bit(RDS_RECONNECT_PENDING, &conn->c_flags); + if (rds_conn_transition(conn, RDS_CONN_DOWN, RDS_CONN_CONNECTING)) { + ret = conn->c_trans->conn_connect(conn); +- rdsdebug("conn %p for %pI4 to %pI4 dispatched, ret %d\n", +- conn, &conn->c_laddr, &conn->c_faddr, ret); ++ rdsdebug("conn %p for %u.%u.%u.%u to %u.%u.%u.%u dispatched, ret %d\n", ++ conn, NIPQUAD(conn->c_laddr), NIPQUAD(conn->c_faddr), ret); + + if (ret) { + if (rds_conn_transition(conn, RDS_CONN_CONNECTING, RDS_CONN_DOWN)) diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_28.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_28.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_28.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/rds_to_2_6_28.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,43 @@ +commit 5e2de0589a6002f63f82fa3974c5bc0d4ef31eff +Author: Andy Grover +Date: Fri Jul 17 12:37:48 2009 -0700 + + RDS backport patch for pre-2.6.23 + + Signed-off-by: Andy Grover + +diff --git a/net/rds/rds.h b/net/rds/rds.h +index 7179444..7f23b90 100644 +--- a/net/rds/rds.h ++++ b/net/rds/rds.h +@@ -7,6 +7,7 @@ + #include + #include + #include ++#include + + #include "info.h" + +@@ -638,7 +639,7 @@ struct rds_message *rds_send_get_message(struct rds_connection *, + void rds_rdma_unuse(struct rds_sock *rs, u32 r_key, int force); + + /* stats.c */ +-DECLARE_PER_CPU_SHARED_ALIGNED(struct rds_statistics, rds_stats); ++DECLARE_PER_CPU(struct rds_statistics, rds_stats); + #define rds_stats_inc_which(which, member) do { \ + per_cpu(which, get_cpu()).member++; \ + put_cpu(); \ +diff --git a/net/rds/stats.c b/net/rds/stats.c +index 6371468..758a5df 100644 +--- a/net/rds/stats.c ++++ b/net/rds/stats.c +@@ -36,7 +36,7 @@ + + #include "rds.h" + +-DEFINE_PER_CPU_SHARED_ALIGNED(struct rds_statistics, rds_stats); ++DEFINE_PER_CPU(struct rds_statistics, rds_stats) ____cacheline_aligned; + EXPORT_PER_CPU_SYMBOL_GPL(rds_stats); + + /* :.,$s/unsigned long\>.*\sk_prot->orphan_count); +- percpu_counter_dec(sk->sk_prot->sockets_allocated); ++ atomic_dec(sk->sk_prot->orphan_count); ++ atomic_dec(sk->sk_prot->sockets_allocated); + ssk->destructed_already = 1; + + down_read(&device_removal_lock); +@@ -2591,9 +2591,9 @@ + sk->sk_data_ready(sk, 0); + } + +-static struct percpu_counter *sockets_allocated; ++static atomic_t sockets_allocated; + static atomic_t memory_allocated; +-static struct percpu_counter *orphan_count; ++static atomic_t orphan_count; + static int memory_pressure; + struct proto sdp_proto = { + .close = sdp_close, +@@ -2611,8 +2611,10 @@ + .get_port = sdp_get_port, + /* Wish we had this: .listen = sdp_listen */ + .enter_memory_pressure = sdp_enter_memory_pressure, ++ .sockets_allocated = &sockets_allocated, + .memory_allocated = &memory_allocated, + .memory_pressure = &memory_pressure, ++ .orphan_count = &orphan_count, + .sysctl_mem = sysctl_tcp_mem, + .sysctl_wmem = sysctl_tcp_wmem, + .sysctl_rmem = sysctl_tcp_rmem, +@@ -2699,7 +2701,7 @@ + } + sock_init_data(sock, sk); + sk->sk_protocol = 0x0 /* TODO: inherit tcp socket to use IPPROTO_TCP */; +- percpu_counter_inc(sk->sk_prot->sockets_allocated); ++ atomic_inc(sk->sk_prot->sockets_allocated); + + memset((struct inet_sock *)sk + 1, 0, + sizeof(struct sdp_sock) - sizeof(struct inet_sock)); +@@ -2894,20 +2896,6 @@ + spin_lock_init(&sock_list_lock); + spin_lock_init(&sdp_large_sockets_lock); + +- sockets_allocated = kzalloc(sizeof(*sockets_allocated), GFP_KERNEL); +- if (!sockets_allocated) +- goto no_mem_sockets_allocated; +- +- orphan_count = kzalloc(sizeof(*orphan_count), GFP_KERNEL); +- if (!orphan_count) +- goto no_mem_orphan_count; +- +- percpu_counter_init(sockets_allocated, 0); +- percpu_counter_init(orphan_count, 0); +- +- sdp_proto.sockets_allocated = sockets_allocated; +- sdp_proto.orphan_count = orphan_count; +- + rx_comp_wq = create_workqueue("rx_comp_wq"); + if (!rx_comp_wq) + goto no_mem_rx_wq; +@@ -2960,10 +2948,6 @@ + no_mem_sdp_wq: + destroy_workqueue(rx_comp_wq); + no_mem_rx_wq: +- kfree(orphan_count); +-no_mem_orphan_count: +- kfree(sockets_allocated); +-no_mem_sockets_allocated: + return rc; + } + +@@ -2973,9 +2957,9 @@ + sock_unregister(PF_INET_SDP); + proto_unregister(&sdp_proto); + +- if (percpu_counter_sum(orphan_count)) +- printk(KERN_WARNING "%s: orphan_count %lld\n", __func__, +- percpu_counter_sum(orphan_count)); ++ if (atomic_read(&orphan_count)) ++ printk(KERN_WARNING "%s: orphan_count %d\n", __func__, ++ atomic_read(&orphan_count)); + + destroy_workqueue(rx_comp_wq); + destroy_workqueue(sdp_wq); +@@ -2986,19 +2970,13 @@ + printk(KERN_WARNING "SDP detected memory leak. Memory_allocated: %d\n", + atomic_read(&memory_allocated)); + +- if (percpu_counter_sum(sockets_allocated)) +- printk(KERN_WARNING "%s: sockets_allocated %lld\n", __func__, +- percpu_counter_sum(sockets_allocated)); ++ if (atomic_read(&sockets_allocated)) ++ printk(KERN_WARNING "%s: sockets_allocated %d\n", __func__, ++ atomic_read(&sockets_allocated)); + + sdp_proc_unregister(); + + ib_unregister_client(&sdp_client); +- +- percpu_counter_destroy(orphan_count); +- percpu_counter_destroy(sockets_allocated); +- +- kfree(orphan_count); +- kfree(sockets_allocated); + } + + module_init(sdp_init); +Index: ofed_kernel-2.6.18.8-xen/drivers/infiniband/ulp/sdp/sdp.h +=================================================================== +--- ofed_kernel-2.6.18.8-xen.orig/drivers/infiniband/ulp/sdp/sdp.h 2011-04-26 12:46:15.000000000 +0300 ++++ ofed_kernel-2.6.18.8-xen/drivers/infiniband/ulp/sdp/sdp.h 2011-04-26 13:54:34.000000000 +0300 +@@ -149,7 +149,7 @@ + sdp_dbg(sk, "%s:%d - sock_put(SOCK_REF_ALIVE" \ + ") - refcount = %d from withing sk_common_release\n",\ + __func__, __LINE__, atomic_read(&(sk)->sk_refcnt));\ +- percpu_counter_inc((sk)->sk_prot->orphan_count);\ ++ atomic_inc((sk)->sk_prot->orphan_count);\ + sdp_add_to_history(sk, "sdp_common_release"); \ + _sdp_add_to_history(sk, "SOCK_REF_ALIVE", __func__, __LINE__, \ + 2, SOCK_REF_ALIVE); \ diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0090_revert_to_2_6_24.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0090_revert_to_2_6_24.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0090_revert_to_2_6_24.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0090_revert_to_2_6_24.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,221 @@ +--- + drivers/infiniband/ulp/sdp/sdp.h | 26 -------------------------- + drivers/infiniband/ulp/sdp/sdp_bcopy.c | 24 ++++++++++++------------ + drivers/infiniband/ulp/sdp/sdp_cma.c | 2 -- + drivers/infiniband/ulp/sdp/sdp_main.c | 19 +++++++++---------- + 4 files changed, 21 insertions(+), 50 deletions(-) + +Index: ofed_kernel/drivers/infiniband/ulp/sdp/sdp_main.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/sdp/sdp_main.c 2011-08-01 14:26:04.765216000 +0300 ++++ ofed_kernel/drivers/infiniband/ulp/sdp/sdp_main.c 2011-08-01 14:45:48.157109000 +0300 +@@ -584,7 +584,7 @@ + flush_workqueue(rx_comp_wq); + /* Consider use cancel_work_sync(&ssk->rx_comp_work) */ + +- sk_mem_reclaim(sk); ++ sk_stream_mem_reclaim(sk); + + if (sk->sk_wmem_queued || atomic_read(&sk->sk_rmem_alloc) || sk->sk_forward_alloc) { + sdp_dbg(sk, "wmem_queued: 0x%x rmem_alloc: 0x%x forward: 0x%x " +@@ -753,7 +753,7 @@ + __kfree_skb(skb); + } + +- sk_mem_reclaim(sk); ++ sk_stream_mem_reclaim(sk); + + /* As outlined in draft-ietf-tcpimpl-prob-03.txt, section + * 3.10, we send a RST here because data was lost. To +@@ -1635,8 +1635,7 @@ + void sdp_skb_entail(struct sock *sk, struct sk_buff *skb) + { + __skb_queue_tail(&sk->sk_write_queue, skb); +- sk->sk_wmem_queued += skb->truesize; +- sk_mem_charge(sk, skb->truesize); ++ sk_charge_skb(sk, skb); + if (!sk->sk_send_head) + sk->sk_send_head = skb; + if (sdp_sk(sk)->nonagle & TCP_NAGLE_PUSH) +@@ -1688,7 +1687,7 @@ + if (copy > PAGE_SIZE - off) + copy = PAGE_SIZE - off; + +- if (!sk_wmem_schedule(sk, copy)) ++ if (!sk_stream_wmem_schedule(sk, copy)) + return SDP_DO_WAIT_MEM; + + if (!page) { +@@ -2025,7 +2024,7 @@ + if (sk->sk_send_head == skb) + sk->sk_send_head = NULL; + __skb_unlink(skb, &sk->sk_write_queue); +- sk_wmem_free_skb(sk, skb); ++ sk_stream_free_skb(sk, skb); + } + + do_error: +@@ -2045,7 +2044,7 @@ + } + + +- sk_mem_reclaim(sk); ++ sk_stream_mem_reclaim(sk); + + release_sock(sk); + +@@ -2452,7 +2451,7 @@ + } + + +- sk_mem_reclaim(sk); ++ sk_stream_mem_reclaim(sk); + + release_sock(sk); + sdp_dbg_data(sk, "recvmsg finished. ret = %d\n", err); +Index: ofed_kernel/drivers/infiniband/ulp/sdp/sdp_rx.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/sdp/sdp_rx.c 2011-07-28 17:14:57.000000000 +0300 ++++ ofed_kernel/drivers/infiniband/ulp/sdp/sdp_rx.c 2011-08-01 14:53:20.160618000 +0300 +@@ -139,7 +139,7 @@ + struct sock *sk = skb->sk; + + atomic_sub(skb->truesize, &sk->sk_rmem_alloc); +- sk_mem_uncharge(sk, skb->truesize); ++ sk->sk_forward_alloc += skb->truesize; + } + + static int sdp_post_recv(struct sdp_sock *ssk) +@@ -166,12 +166,12 @@ + /* TODO: allocate from cache */ + + if (unlikely(sk_ssk(ssk)->sk_allocation)) { +- skb = sdp_stream_alloc_skb(sk_ssk(ssk), SDP_SKB_HEAD_SIZE, +- sk_ssk(ssk)->sk_allocation, SK_MEM_RECV); ++ skb = sk_stream_alloc_skb(sk_ssk(ssk), SDP_SKB_HEAD_SIZE, ++ sk_ssk(ssk)->sk_allocation); + gfp_page = sk_ssk(ssk)->sk_allocation | __GFP_HIGHMEM; + } else { +- skb = sdp_stream_alloc_skb(sk_ssk(ssk), SDP_SKB_HEAD_SIZE, +- GFP_KERNEL, SK_MEM_RECV); ++ skb = sk_stream_alloc_skb(sk_ssk(ssk), SDP_SKB_HEAD_SIZE, ++ GFP_KERNEL); + gfp_page = GFP_HIGHUSER; + } + +@@ -200,7 +200,7 @@ + ++skb_shinfo(skb)->nr_frags; + } + skb->truesize += ssk->recv_frags * min(PAGE_SIZE, SDP_MAX_PAYLOAD); +- if (!sk_rmem_schedule(sk, ssk->recv_frags * min(PAGE_SIZE, SDP_MAX_PAYLOAD))) { ++ if (!sk_stream_rmem_schedule(sk, skb)) { + sdp_dbg(sk, "RX couldn't post, rx posted = %d.", + rx_ring_posted(sdp_sk(sk))); + sdp_dbg(sk, "Out of memory\n"); +@@ -445,7 +445,7 @@ + used += skb_shinfo(skb)->frags[i].size; + } + atomic_sub(bytes_reused, &sk->sk_rmem_alloc); +- sk_mem_uncharge(sk, bytes_reused); ++ sk->sk_forward_alloc += bytes_reused; + + } + +@@ -723,7 +723,7 @@ + if (wc_processed) { + sdp_prf(sk_ssk(ssk), NULL, "processed %d", wc_processed); + +- sk_mem_reclaim(sk_ssk(ssk)); ++ sk_stream_mem_reclaim(sk_ssk(ssk)); + + sdp_bzcopy_write_space(ssk); + } +Index: ofed_kernel/drivers/infiniband/ulp/sdp/sdp_tx.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/sdp/sdp_tx.c 2011-07-28 17:14:57.000000000 +0300 ++++ ofed_kernel/drivers/infiniband/ulp/sdp/sdp_tx.c 2011-08-01 14:26:05.182128000 +0300 +@@ -92,8 +92,7 @@ + h->mid != SDP_MID_SRCAVAIL_CANCEL) { + struct sock *sk = sk_ssk(ssk); + +- sk->sk_wmem_queued += skb->truesize; +- sk_mem_charge(sk, skb->truesize); ++ sk_charge_skb(sk, skb); + } + + if (unlikely(h->mid == SDP_MID_SRCAVAIL)) { +@@ -102,7 +101,7 @@ + sdp_dbg_data(sk_ssk(ssk), "SrcAvail cancelled " + "before being sent!\n"); + SDP_WARN_ON(1); +- sk_wmem_free_skb(sk_ssk(ssk), skb); ++ sk_stream_free_skb(sk_ssk(ssk), skb); + return; + } + TX_SRCAVAIL_STATE(skb)->mseq = mseq; +@@ -190,7 +189,7 @@ + return; + + err: +- sk_wmem_free_skb(sk_ssk(ssk), skb); ++ sk_stream_free_skb(sk_ssk(ssk), skb); + } + + static struct sk_buff *sdp_send_completion(struct sdp_sock *ssk, int mseq) +@@ -235,7 +234,7 @@ + + skb = sdp_send_completion(ssk, wc->wr_id); + if (likely(skb)) +- sk_wmem_free_skb(sk, skb); ++ sk_stream_free_skb(&ssk->isk.sk, skb); + } else if (wc->wr_id & SDP_OP_RDMA) { + if (ssk->tx_ring.rdma_inflight && + ssk->tx_ring.rdma_inflight->busy) { +@@ -287,7 +286,7 @@ + sdp_prf1(sk, NULL, "Waking sendmsg. inflight=%d", + (u32) tx_ring_posted(ssk)); + +- sk_mem_reclaim(sk); ++ sk_stream_mem_reclaim(sk); + + sk_stream_write_space(sk_ssk(ssk)); + if (sk->sk_write_pending && +@@ -419,7 +418,7 @@ + skb = sdp_send_completion(ssk, ring_tail(ssk->tx_ring)); + if (!skb) + break; +- sk_wmem_free_skb(sk_ssk(ssk), skb); ++ sk_stream_free_skb(sk_ssk(ssk), skb); + } + } + +Index: ofed_kernel/drivers/infiniband/ulp/sdp/sdp.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/sdp/sdp.h 2011-08-01 14:26:04.822214000 +0300 ++++ ofed_kernel/drivers/infiniband/ulp/sdp/sdp.h 2011-08-01 14:48:40.287938000 +0300 +@@ -627,8 +627,8 @@ + skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp); + if (skb) { + +- if ((kind == SK_MEM_RECV && sk_rmem_schedule(sk, skb->truesize)) || +- (kind == SK_MEM_SEND && sk_wmem_schedule(sk, skb->truesize))) { ++ if ((kind == SK_MEM_RECV && sk_stream_rmem_schedule(sk, skb)) || ++ (kind == SK_MEM_SEND && sk_stream_wmem_schedule(sk, skb->truesize))) { + /* + * Make sure that we have exactly size bytes + * available to the caller, no more, no less. +Index: ofed_kernel/drivers/infiniband/ulp/sdp/sdp_bcopy.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/sdp/sdp_bcopy.c 2011-07-28 17:14:57.000000000 +0300 ++++ ofed_kernel/drivers/infiniband/ulp/sdp/sdp_bcopy.c 2011-08-01 14:26:05.220122000 +0300 +@@ -280,9 +280,7 @@ + if (!skb) + goto no_mem; + +- sk->sk_wmem_queued += skb->truesize; +- sk_mem_charge(sk, skb->truesize); +- ++ sk_charge_skb(sk, skb); + sdp_post_send(ssk, skb); + SDPSTATS_COUNTER_INC(post_send_credits); + post_count++; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0100_revert_to_2_6_23.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0100_revert_to_2_6_23.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0100_revert_to_2_6_23.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0100_revert_to_2_6_23.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,106 @@ +--- + drivers/infiniband/ulp/sdp/sdp_main.c | 12 ++++-------- + 1 file changed, 4 insertions(+), 8 deletions(-) + +Index: ofed_kernel.ipv6.clean/drivers/infiniband/ulp/sdp/sdp_main.c +=================================================================== +--- ofed_kernel.ipv6.clean.orig/drivers/infiniband/ulp/sdp/sdp_main.c ++++ ofed_kernel.ipv6.clean/drivers/infiniband/ulp/sdp/sdp_main.c +@@ -2951,7 +2951,7 @@ static inline struct ipv6_pinfo *inet6_s + } + #endif + +-static int sdp_create_ipvx_socket(struct net *net, struct socket *sock, int protocol, ++static int sdp_create_ipvx_socket(struct socket *sock, int protocol, + struct proto_ops *proto_ops) + { + struct sock *sk; +@@ -2959,9 +2959,6 @@ static int sdp_create_ipvx_socket(struct + + sdp_dbg(NULL, "type %d protocol %d\n", sock->type, protocol); + +- if (net != &init_net) +- return -EAFNOSUPPORT; +- + if (sock->type != SOCK_STREAM) { + sdp_warn(NULL, "SDP: unsupported type %d.\n", sock->type); + return -ESOCKTNOSUPPORT; +@@ -2973,7 +2970,7 @@ static int sdp_create_ipvx_socket(struct + return -EPROTONOSUPPORT; + } + +- sk = sk_alloc(net, PF_INET_SDP, GFP_KERNEL, &sdp_proto); ++ sk = sk_alloc(PF_INET_SDP, GFP_KERNEL, &sdp_proto, 1); + if (!sk) { + sdp_warn(NULL, "SDP: failed to allocate socket.\n"); + return -ENOMEM; +@@ -3008,15 +3005,15 @@ static int sdp_create_ipvx_socket(struct + } + + #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) +-static int sdp_create_v6_socket(struct net *net, struct socket *sock, int protocol) ++static int sdp_create_v6_socket(struct socket *sock, int protocol) + { +- return sdp_create_ipvx_socket(net, sock, protocol, &sdp_ipv6_proto_ops); ++ return sdp_create_ipvx_socket(sock, protocol, &sdp_ipv6_proto_ops); + } + #endif + +-static int sdp_create_v4_socket(struct net *net, struct socket *sock, int protocol) ++static int sdp_create_v4_socket(struct socket *sock, int protocol) + { +- return sdp_create_ipvx_socket(net, sock, protocol, &sdp_ipv4_proto_ops); ++ return sdp_create_ipvx_socket(sock, protocol, &sdp_ipv4_proto_ops); + } + + static void sdp_add_device(struct ib_device *device) +Index: ofed_kernel.ipv6.clean/drivers/infiniband/ulp/sdp/sdp_proc.c +=================================================================== +--- ofed_kernel.ipv6.clean.orig/drivers/infiniband/ulp/sdp/sdp_proc.c ++++ ofed_kernel.ipv6.clean/drivers/infiniband/ulp/sdp/sdp_proc.c +@@ -818,7 +818,7 @@ int __init sdp_proc_init(void) + } + #endif + +- p = proc_net_fops_create(&init_net, sdp_seq_afinfo.name, S_IRUGO, ++ p = proc_net_fops_create(sdp_seq_afinfo.name, S_IRUGO, + sdp_seq_afinfo.seq_fops); + if (p) + p->data = &sdp_seq_afinfo; +@@ -827,7 +827,7 @@ int __init sdp_proc_init(void) + + #ifdef SDPSTATS_ON + +- stats = proc_net_fops_create(&init_net, PROC_SDP_STATS, ++ stats = proc_net_fops_create(PROC_SDP_STATS, + S_IRUGO | S_IWUGO, &sdpstats_fops); + if (!stats) + goto no_mem_stats; +@@ -848,11 +848,11 @@ no_mem_prof: + #endif + + #ifdef SDPSTATS_ON +- proc_net_remove(&init_net, PROC_SDP_STATS); ++ proc_net_remove(PROC_SDP_STATS); + + no_mem_stats: + #endif +- proc_net_remove(&init_net, sdp_seq_afinfo.name); ++ proc_net_remove(sdp_seq_afinfo.name); + + no_mem: + return -ENOMEM; +@@ -860,11 +860,11 @@ no_mem: + + void sdp_proc_unregister(void) + { +- proc_net_remove(&init_net, sdp_seq_afinfo.name); ++ proc_net_remove(sdp_seq_afinfo.name); + memset(sdp_seq_afinfo.seq_fops, 0, sizeof(*sdp_seq_afinfo.seq_fops)); + + #ifdef SDPSTATS_ON +- proc_net_remove(&init_net, PROC_SDP_STATS); ++ proc_net_remove(PROC_SDP_STATS); + #endif + #ifdef SDP_PROFILING + debugfs_remove(sdp_prof_file); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0120_revert_2_6_27_to_2_6_24.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0120_revert_2_6_27_to_2_6_24.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0120_revert_2_6_27_to_2_6_24.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0120_revert_2_6_27_to_2_6_24.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,68 @@ +--- + drivers/infiniband/ulp/sdp/sdp_cma.c | 1 + + drivers/infiniband/ulp/sdp/sdp_main.c | 8 ++++---- + 2 files changed, 5 insertions(+), 4 deletions(-) + +Index: ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check/drivers/infiniband/ulp/sdp/sdp_cma.c +=================================================================== +--- ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check.orig/drivers/infiniband/ulp/sdp/sdp_cma.c 2011-07-05 14:43:02.000000000 +0300 ++++ ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check/drivers/infiniband/ulp/sdp/sdp_cma.c 2011-07-05 15:17:29.000000000 +0300 +@@ -31,6 +31,7 @@ + * + * $Id$ + */ ++#include + #include + #include + #include +Index: ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check/drivers/infiniband/ulp/sdp/sdp_main.c +=================================================================== +--- ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check.orig/drivers/infiniband/ulp/sdp/sdp_main.c 2011-07-05 15:17:26.000000000 +0300 ++++ ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check/drivers/infiniband/ulp/sdp/sdp_main.c 2011-07-05 17:11:31.000000000 +0300 +@@ -767,7 +767,7 @@ + if (data_was_unread || + (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime)) { + /* Unread data was tossed, zap the connection. */ +- NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPABORTONCLOSE); ++ NET_INC_STATS_USER(LINUX_MIB_TCPABORTONCLOSE); + sdp_exch_state(sk, TCPF_CLOSE_WAIT | TCPF_ESTABLISHED, + TCP_TIME_WAIT); + +@@ -2570,9 +2570,9 @@ + return mask; + } + +-static void sdp_enter_memory_pressure(struct sock *sk) ++static void sdp_enter_memory_pressure(void) + { +- sdp_dbg(sk, "%s\n", __func__); ++ sdp_dbg(NULL, "%s\n", __func__); + } + + void sdp_urg(struct sdp_sock *ssk, struct sk_buff *skb) +Index: ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check/drivers/infiniband/ulp/sdp/sdp_dbg.h +=================================================================== +--- ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check.orig/drivers/infiniband/ulp/sdp/sdp_dbg.h 2011-07-05 14:43:02.000000000 +0300 ++++ ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check/drivers/infiniband/ulp/sdp/sdp_dbg.h 2011-07-05 15:17:29.000000000 +0300 +@@ -11,7 +11,7 @@ + #define SDP_PROFILING + #endif + +-#define SDP_WARN_ON(x) WARN_ON(x) ++#define SDP_WARN_ON(x) BUG_TRAP(!(x)) + static inline struct sdp_sock *sdp_sk(const struct sock *sk); + + #define _sdp_printk(func, line, level, sk, format, arg...) do { \ +Index: ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check/drivers/infiniband/ulp/sdp/sdp.h +=================================================================== +--- ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check.orig/drivers/infiniband/ulp/sdp/sdp.h 2011-07-05 17:12:49.000000000 +0300 ++++ ofa_1_5_dev_kernel-20110705-1441_linux-2.6.19_check/drivers/infiniband/ulp/sdp/sdp.h 2011-07-05 17:12:55.000000000 +0300 +@@ -638,7 +638,7 @@ + } + __kfree_skb(skb); + } else { +- sk->sk_prot->enter_memory_pressure(sk); ++ sk->sk_prot->enter_memory_pressure(); + sk_stream_moderate_sndbuf(sk); + } + return NULL; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0140_revert_to_2_6_21.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0140_revert_to_2_6_21.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0140_revert_to_2_6_21.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0140_revert_to_2_6_21.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,28 @@ +Backports: SDP fix rx_comp_work and dreq_wait_timeout cleaning on socket close + +Kernels 2.6.21 and earlier do not have cancel_work_sync(). + +Signed-off-by: Amir Vadai + +Index: ofed_kernel-2.6.21/drivers/infiniband/ulp/sdp/sdp_main.c +=================================================================== +--- ofed_kernel-2.6.21.orig/drivers/infiniband/ulp/sdp/sdp_main.c ++++ ofed_kernel-2.6.21/drivers/infiniband/ulp/sdp/sdp_main.c +@@ -958,7 +958,7 @@ void sdp_cancel_dreq_wait_timeout(struct + sdp_dbg(&ssk->isk.sk, "cancelling dreq wait timeout\n"); + + ssk->dreq_wait_timeout = 0; +- if (cancel_delayed_work_sync(&ssk->dreq_wait_work)) { ++ if (cancel_delayed_work(&ssk->dreq_wait_work)) { + /* The timeout hasn't reached - need to clean ref count */ + sock_put(&ssk->isk.sk, SOCK_REF_DREQ_TO); + } +@@ -978,7 +978,7 @@ static void sdp_destroy_work(struct work + /* Can be sure that rx_comp_work won't be queued from here cause + * ssk->rx_ring.cq is NULL from here + */ +- cancel_work_sync(&ssk->rx_comp_work); ++ flush_workqueue(rx_comp_wq); + + memset((void *)&ssk->id, 0, sizeof(*ssk) - offsetof(typeof(*ssk), id)); + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0180_queue_work_on.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0180_queue_work_on.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0180_queue_work_on.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0180_queue_work_on.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,13 @@ +Index: ofed_kernel/drivers/infiniband/ulp/sdp/sdp_rx.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/sdp/sdp_rx.c ++++ ofed_kernel/drivers/infiniband/ulp/sdp/sdp_rx.c +@@ -837,7 +837,7 @@ static void sdp_rx_irq(struct ib_cq *cq, + wake_up_interruptible(sk->sk_sleep); + SDPSTATS_COUNTER_INC(rx_int_wake_up); + } else { +- if (queue_work_on(ssk->cpu, rx_comp_wq, &ssk->rx_comp_work)) ++ if (queue_work(rx_comp_wq, &ssk->rx_comp_work)) + SDPSTATS_COUNTER_INC(rx_int_queue); + else + SDPSTATS_COUNTER_INC(rx_int_no_op); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0200_dbgfs_rename.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0200_dbgfs_rename.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0200_dbgfs_rename.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/sdp_0200_dbgfs_rename.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,30 @@ +Index: ofed_kernel/drivers/infiniband/ulp/sdp/sdp_proc.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/sdp/sdp_proc.c 2010-11-04 09:45:59.000000000 +0200 ++++ ofed_kernel/drivers/infiniband/ulp/sdp/sdp_proc.c 2010-11-04 09:58:56.411157000 +0200 +@@ -719,19 +719,19 @@ + + int sdp_ssk_hist_rename(struct sock *sk) + { +- char sk_name[256]; + struct dentry *d; ++ int ret = 0; + + if (!sk || !sdp_sk(sk)->hst_dentr) + return 0; + +- sdp_ssk_hist_name(sk_name, sizeof(sk_name), sk); ++ d = sdp_sk(sk)->hst_dentr; + +- d = debugfs_rename(sdp_dbgfs_base, sdp_sk(sk)->hst_dentr, sdp_dbgfs_base, sk_name); +- if (IS_ERR(d)) +- return PTR_ERR(d); ++ ret = sdp_ssk_hist_open(sk); ++ if (!ret) ++ debugfs_remove(d); + +- return 0; ++ return ret; + } + #endif + diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0100_revert_role_to_2_6_23.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0100_revert_role_to_2_6_23.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0100_revert_role_to_2_6_23.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0100_revert_role_to_2_6_23.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,30 @@ +commit aebd5e476ecc8ceb53577b20f2a352ff4ceffd8d +Author: FUJITA Tomonori +Date: Wed Jul 11 15:08:15 2007 +0900 + + [SCSI] transport_srp: add rport roles attribute + + This adds a 'roles' attribute to rport like transport_fc. The role can + be initiator or target. That is, the initiator driver creates target + remote ports and the target driver creates initiator remote ports. + + Signed-off-by: FUJITA Tomonori + Signed-off-by: Mike Christie + Signed-off-by: James Bottomley + +--- + drivers/infiniband/ulp/srp/ib_srp.c | 1 - + 1 file changed, 1 deletion(-) + +Index: ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/srp/ib_srp.c ++++ ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.c +@@ -1741,7 +1741,6 @@ static int srp_add_target(struct srp_hos + + memcpy(ids.port_id, &target->id_ext, 8); + memcpy(ids.port_id + 8, &target->ioc_guid, 8); +- ids.roles = SRP_RPORT_ROLE_TARGET; + rport = srp_rport_add(target->scsi_host, &ids); + if (IS_ERR(rport)) { + scsi_remove_host(target->scsi_host); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0200_revert_srp_transport_to_2.6.23.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0200_revert_srp_transport_to_2.6.23.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0200_revert_srp_transport_to_2.6.23.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0200_revert_srp_transport_to_2.6.23.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,146 @@ +commit 3236822b1c9b67ad10745d965515b528818f1120 +Author: FUJITA Tomonori +Date: Wed Jun 27 16:33:12 2007 +0900 + + [SCSI] ib_srp: convert to use the srp transport class + + This converts ib_srp to use the srp transport class. + + I don't have ib hardware so I've not tested this patch. + + Signed-off-by: FUJITA Tomonori + Cc: Roland Dreier + Signed-off-by: James Bottomley + +--- + drivers/infiniband/ulp/srp/Kconfig | 1 - + drivers/infiniband/ulp/srp/ib_srp.c | 28 ---------------------------- + 2 files changed, 29 deletions(-) + +Index: ofed_kernel/drivers/infiniband/ulp/srp/Kconfig +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/srp/Kconfig ++++ ofed_kernel/drivers/infiniband/ulp/srp/Kconfig +@@ -1,7 +1,6 @@ + config INFINIBAND_SRP + tristate "InfiniBand SCSI RDMA Protocol" + depends on SCSI +- select SCSI_SRP_ATTRS + ---help--- + Support for the SCSI RDMA Protocol over InfiniBand. This + allows you to access storage devices that speak SRP over +Index: ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/srp/ib_srp.c ++++ ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.c +@@ -45,7 +45,6 @@ + #include + #include + #include +-#include + + #include "ib_srp.h" + +@@ -90,8 +89,6 @@ static void srp_remove_one(struct ib_dev + static void srp_completion(struct ib_cq *cq, void *target_ptr); + static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event); + +-static struct scsi_transport_template *ib_srp_transport_template; +- + static struct ib_client srp_client = { + .name = "srp", + .add = srp_add_one, +@@ -447,7 +444,6 @@ static void srp_remove_work(struct work_ + list_del(&target->list); + spin_unlock(&target->srp_host->target_lock); + +- srp_remove_host(target->scsi_host); + scsi_remove_host(target->scsi_host); + ib_destroy_cm_id(target->cm_id); + srp_free_target_ib(target); +@@ -1730,23 +1726,12 @@ static struct scsi_host_template srp_tem + + static int srp_add_target(struct srp_host *host, struct srp_target_port *target) + { +- struct srp_rport_identifiers ids; +- struct srp_rport *rport; +- + sprintf(target->target_name, "SRP.T10:%016llX", + (unsigned long long) be64_to_cpu(target->id_ext)); + + if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device)) + return -ENODEV; + +- memcpy(ids.port_id, &target->id_ext, 8); +- memcpy(ids.port_id + 8, &target->ioc_guid, 8); +- rport = srp_rport_add(target->scsi_host, &ids); +- if (IS_ERR(rport)) { +- scsi_remove_host(target->scsi_host); +- return PTR_ERR(rport); +- } +- + spin_lock(&host->target_lock); + list_add_tail(&target->list, &host->target_list); + spin_unlock(&host->target_lock); +@@ -1973,7 +1958,6 @@ static ssize_t srp_create_target(struct + if (!target_host) + return -ENOMEM; + +- target_host->transportt = ib_srp_transport_template; + target_host->max_lun = SRP_MAX_LUN; + target_host->max_cmd_len = sizeof ((struct srp_cmd *) (void *) 0L)->cdb; + +@@ -2307,7 +2291,6 @@ static void srp_remove_one(struct ib_dev + + list_for_each_entry_safe(target, tmp_target, + &host->target_list, list) { +- srp_remove_host(target->scsi_host); + scsi_remove_host(target->scsi_host); + srp_disconnect_target(target); + ib_destroy_cm_id(target->cm_id); +@@ -2326,9 +2309,6 @@ static void srp_remove_one(struct ib_dev + kfree(srp_dev); + } + +-static struct srp_function_template ib_srp_transport_functions = { +-}; +- + static int __init srp_init_module(void) + { + int ret; +@@ -2338,11 +2318,6 @@ static int __init srp_init_module(void) + srp_sg_tablesize = 255; + } + +- ib_srp_transport_template = +- srp_attach_transport(&ib_srp_transport_functions); +- if (!ib_srp_transport_template) +- return -ENOMEM; +- + srp_template.sg_tablesize = srp_sg_tablesize; + srp_max_iu_len = (sizeof (struct srp_cmd) + + sizeof (struct srp_indirect_buf) + +@@ -2354,7 +2329,6 @@ static int __init srp_init_module(void) + ret = class_register(&srp_class); + if (ret) { + printk(KERN_ERR PFX "couldn't register class infiniband_srp\n"); +- srp_release_transport(ib_srp_transport_template); + return ret; + } + +@@ -2363,7 +2337,6 @@ static int __init srp_init_module(void) + ret = ib_register_client(&srp_client); + if (ret) { + printk(KERN_ERR PFX "couldn't register IB client\n"); +- srp_release_transport(ib_srp_transport_template); + ib_sa_unregister_client(&srp_sa_client); + class_unregister(&srp_class); + return ret; +@@ -2377,7 +2350,6 @@ static void __exit srp_cleanup_module(vo + ib_unregister_client(&srp_client); + ib_sa_unregister_client(&srp_sa_client); + class_unregister(&srp_class); +- srp_release_transport(ib_srp_transport_template); + } + + module_init(srp_init_module); diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0300_dev_set_name_v2_6_25.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0300_dev_set_name_v2_6_25.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0300_dev_set_name_v2_6_25.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0300_dev_set_name_v2_6_25.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,14 @@ +diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c +index 54c8fe2..185bf7a 100644 +--- a/drivers/infiniband/ulp/srp/ib_srp.c ++++ b/drivers/infiniband/ulp/srp/ib_srp.c +@@ -1949,7 +1949,8 @@ static struct srp_host *srp_add_port(struct srp_device *device, u8 port) + + host->dev.class = &srp_class; + host->dev.parent = device->dev->dma_device; +- dev_set_name(&host->dev, "srp-%s-%d", device->dev->name, port); ++ snprintf(host->dev.bus_id, BUS_ID_SIZE, "srp-%s-%d", ++ device->dev->name, port); + + if (device_register(&host->dev)) + goto free_host; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0400_undo_I6_printing_gids.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0400_undo_I6_printing_gids.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0400_undo_I6_printing_gids.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_0400_undo_I6_printing_gids.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,70 @@ +srp: Undo %pI6 for printing gids + +The "%pI6" construct is not valid with kernels earlier than 2.6.29. +This patch just rolls back the change. +Without the patch, you don't get a compilation error -- the %p is +just interpreted as a pointer and the I6 is ignored. + + +Signed-off-by: Jack Morgenstein + +Index: ofed_kernel-fixes/drivers/infiniband/ulp/srp/ib_srp.c +=================================================================== +--- ofed_kernel-fixes.orig/drivers/infiniband/ulp/srp/ib_srp.c 2009-07-20 13:50:08.000000000 +0300 ++++ ofed_kernel-fixes/drivers/infiniband/ulp/srp/ib_srp.c 2009-07-20 13:55:05.000000000 +0300 +@@ -1606,7 +1606,15 @@ static ssize_t show_dgid(struct device * + target->state == SRP_TARGET_REMOVED) + return -ENODEV; + +- return sprintf(buf, "%pI6\n", target->path.dgid.raw); ++ return sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", ++ be16_to_cpu(((__be16 *) target->path.dgid.raw)[0]), ++ be16_to_cpu(((__be16 *) target->path.dgid.raw)[1]), ++ be16_to_cpu(((__be16 *) target->path.dgid.raw)[2]), ++ be16_to_cpu(((__be16 *) target->path.dgid.raw)[3]), ++ be16_to_cpu(((__be16 *) target->path.dgid.raw)[4]), ++ be16_to_cpu(((__be16 *) target->path.dgid.raw)[5]), ++ be16_to_cpu(((__be16 *) target->path.dgid.raw)[6]), ++ be16_to_cpu(((__be16 *) target->path.dgid.raw)[7])); + } + + static ssize_t show_orig_dgid(struct device *dev, +@@ -1618,7 +1626,15 @@ static ssize_t show_orig_dgid(struct dev + target->state == SRP_TARGET_REMOVED) + return -ENODEV; + +- return sprintf(buf, "%pI6\n", target->orig_dgid); ++ return sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", ++ be16_to_cpu(target->orig_dgid[0]), ++ be16_to_cpu(target->orig_dgid[1]), ++ be16_to_cpu(target->orig_dgid[2]), ++ be16_to_cpu(target->orig_dgid[3]), ++ be16_to_cpu(target->orig_dgid[4]), ++ be16_to_cpu(target->orig_dgid[5]), ++ be16_to_cpu(target->orig_dgid[6]), ++ be16_to_cpu(target->orig_dgid[7])); + } + + static ssize_t show_zero_req_lim(struct device *dev, +@@ -2012,12 +2028,19 @@ static ssize_t srp_create_target(struct + + shost_printk(KERN_DEBUG, target->scsi_host, PFX + "new target: id_ext %016llx ioc_guid %016llx pkey %04x " +- "service_id %016llx dgid %pI6\n", ++ "service_id %016llx dgid %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", + (unsigned long long) be64_to_cpu(target->id_ext), + (unsigned long long) be64_to_cpu(target->ioc_guid), + be16_to_cpu(target->path.pkey), + (unsigned long long) be64_to_cpu(target->service_id), +- target->path.dgid.raw); ++ (int) be16_to_cpu(*(__be16 *) &target->path.dgid.raw[0]), ++ (int) be16_to_cpu(*(__be16 *) &target->path.dgid.raw[2]), ++ (int) be16_to_cpu(*(__be16 *) &target->path.dgid.raw[4]), ++ (int) be16_to_cpu(*(__be16 *) &target->path.dgid.raw[6]), ++ (int) be16_to_cpu(*(__be16 *) &target->path.dgid.raw[8]), ++ (int) be16_to_cpu(*(__be16 *) &target->path.dgid.raw[10]), ++ (int) be16_to_cpu(*(__be16 *) &target->path.dgid.raw[12]), ++ (int) be16_to_cpu(*(__be16 *) &target->path.dgid.raw[14])); + + ret = srp_create_target_ib(target); + if (ret) diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_class_device_if.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_class_device_if.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_class_device_if.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_class_device_if.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,333 @@ +--- + drivers/infiniband/ulp/srp/ib_srp.c | 154 ++++++++++++++++-------------------- + drivers/infiniband/ulp/srp/ib_srp.h | 2 + 2 files changed, 72 insertions(+), 84 deletions(-) + +Index: ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/srp/ib_srp.c ++++ ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.c +@@ -1517,10 +1517,9 @@ static int srp_reset_host(struct scsi_cm + return ret; + } + +-static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_id_ext(struct class_device *cdev, char *buf) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + if (target->state == SRP_TARGET_DEAD || + target->state == SRP_TARGET_REMOVED) +@@ -1530,10 +1529,9 @@ static ssize_t show_id_ext(struct device + (unsigned long long) be64_to_cpu(target->id_ext)); + } + +-static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_ioc_guid(struct class_device *cdev, char *buf) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + if (target->state == SRP_TARGET_DEAD || + target->state == SRP_TARGET_REMOVED) +@@ -1543,10 +1541,9 @@ static ssize_t show_ioc_guid(struct devi + (unsigned long long) be64_to_cpu(target->ioc_guid)); + } + +-static ssize_t show_service_id(struct device *dev, +- struct device_attribute *attr, char *buf) ++static ssize_t show_service_id(struct class_device *cdev, char *buf) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + if (target->state == SRP_TARGET_DEAD || + target->state == SRP_TARGET_REMOVED) +@@ -1556,10 +1553,9 @@ static ssize_t show_service_id(struct de + (unsigned long long) be64_to_cpu(target->service_id)); + } + +-static ssize_t show_pkey(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_pkey(struct class_device *cdev, char *buf) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + if (target->state == SRP_TARGET_DEAD || + target->state == SRP_TARGET_REMOVED) +@@ -1568,10 +1564,9 @@ static ssize_t show_pkey(struct device * + return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey)); + } + +-static ssize_t show_dgid(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_dgid(struct class_device *cdev, char *buf) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + if (target->state == SRP_TARGET_DEAD || + target->state == SRP_TARGET_REMOVED) +@@ -1588,10 +1583,9 @@ static ssize_t show_dgid(struct device * + be16_to_cpu(((__be16 *) target->path.dgid.raw)[7])); + } + +-static ssize_t show_orig_dgid(struct device *dev, +- struct device_attribute *attr, char *buf) ++static ssize_t show_orig_dgid(struct class_device *cdev, char *buf) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + if (target->state == SRP_TARGET_DEAD || + target->state == SRP_TARGET_REMOVED) +@@ -1608,10 +1602,9 @@ static ssize_t show_orig_dgid(struct dev + be16_to_cpu(target->orig_dgid[7])); + } + +-static ssize_t show_zero_req_lim(struct device *dev, +- struct device_attribute *attr, char *buf) ++static ssize_t show_zero_req_lim(struct class_device *cdev, char *buf) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + if (target->state == SRP_TARGET_DEAD || + target->state == SRP_TARGET_REMOVED) +@@ -1620,27 +1613,24 @@ static ssize_t show_zero_req_lim(struct + return sprintf(buf, "%d\n", target->zero_req_lim); + } + +-static ssize_t show_local_ib_port(struct device *dev, +- struct device_attribute *attr, char *buf) ++static ssize_t show_local_ib_port(struct class_device *cdev, char *buf) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + return sprintf(buf, "%d\n", target->srp_host->port); + } + +-static ssize_t show_local_ib_device(struct device *dev, +- struct device_attribute *attr, char *buf) ++static ssize_t show_local_ib_device(struct class_device *cdev, char *buf) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name); + } + +-static ssize_t srp_target_oofabric(struct device *dev, +- struct device_attribute *attr, const char *buf, +- size_t count) ++static ssize_t srp_target_oofabric(struct class_device *cdev, ++ const char *buf, size_t count) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + shost_printk(KERN_DEBUG, target->scsi_host, PFX + "Get async_event out-of-fabric at state=%d qp_err=%d\n", +@@ -1657,11 +1647,10 @@ static ssize_t srp_target_oofabric(struc + return count; + } + +-static ssize_t srp_target_infabric(struct device *dev, +- struct device_attribute *attr, const char *buf, +- size_t count) ++static ssize_t srp_target_infabric(struct class_device *cdev, ++ const char *buf, size_t count) + { +- struct srp_target_port *target = host_to_target(class_to_shost(dev)); ++ struct srp_target_port *target = host_to_target(class_to_shost(cdev)); + + shost_printk(KERN_DEBUG, target->scsi_host, PFX + "Get async_event in-fabric at state=%d qp_err=%d\n", +@@ -1681,30 +1670,30 @@ static ssize_t srp_target_infabric(struc + return count; + } + +-static DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL); +-static DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); +-static DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL); +-static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); +-static DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); +-static DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL); +-static DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL); +-static DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL); +-static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL); +-static DEVICE_ATTR(target_oofabric, S_IWUSR, NULL, srp_target_oofabric); +-static DEVICE_ATTR(target_infabric, S_IWUSR, NULL, srp_target_infabric); +- +-static struct device_attribute *srp_host_attrs[] = { +- &dev_attr_id_ext, +- &dev_attr_ioc_guid, +- &dev_attr_service_id, +- &dev_attr_pkey, +- &dev_attr_dgid, +- &dev_attr_orig_dgid, +- &dev_attr_zero_req_lim, +- &dev_attr_local_ib_port, +- &dev_attr_local_ib_device, +- &dev_attr_target_oofabric, +- &dev_attr_target_infabric, ++static CLASS_DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL); ++static CLASS_DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); ++static CLASS_DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL); ++static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); ++static CLASS_DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); ++static CLASS_DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL); ++static CLASS_DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL); ++static CLASS_DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL); ++static CLASS_DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL); ++static CLASS_DEVICE_ATTR(target_oofabric, S_IWUSR, NULL, srp_target_oofabric); ++static CLASS_DEVICE_ATTR(target_infabric, S_IWUSR, NULL, srp_target_infabric); ++ ++static struct class_device_attribute *srp_host_attrs[] = { ++ &class_device_attr_id_ext, ++ &class_device_attr_ioc_guid, ++ &class_device_attr_service_id, ++ &class_device_attr_pkey, ++ &class_device_attr_dgid, ++ &class_device_attr_orig_dgid, ++ &class_device_attr_zero_req_lim, ++ &class_device_attr_local_ib_port, ++ &class_device_attr_local_ib_device, ++ &class_device_attr_target_oofabric, ++ &class_device_attr_target_infabric, + NULL + }; + +@@ -1744,17 +1733,17 @@ static int srp_add_target(struct srp_hos + return 0; + } + +-static void srp_release_dev(struct device *dev) ++static void srp_release_class_dev(struct class_device *class_dev) + { + struct srp_host *host = +- container_of(dev, struct srp_host, dev); ++ container_of(class_dev, struct srp_host, class_dev); + + complete(&host->released); + } + + static struct class srp_class = { + .name = "infiniband_srp", +- .dev_release = srp_release_dev ++ .release = srp_release_class_dev + }; + + /* +@@ -1942,12 +1931,11 @@ out: + return ret; + } + +-static ssize_t srp_create_target(struct device *dev, +- struct device_attribute *attr, ++static ssize_t srp_create_target(struct class_device *class_dev, + const char *buf, size_t count) + { + struct srp_host *host = +- container_of(dev, struct srp_host, dev); ++ container_of(class_dev, struct srp_host, class_dev); + struct Scsi_Host *target_host; + struct srp_target_port *target; + int ret; +@@ -2033,27 +2021,27 @@ err: + return ret; + } + +-static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target); ++static CLASS_DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target); + +-static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_ibdev(struct class_device *class_dev, char *buf) + { +- struct srp_host *host = container_of(dev, struct srp_host, dev); ++ struct srp_host *host = ++ container_of(class_dev, struct srp_host, class_dev); + + return sprintf(buf, "%s\n", host->srp_dev->dev->name); + } + +-static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); ++static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); + +-static ssize_t show_port(struct device *dev, struct device_attribute *attr, +- char *buf) ++static ssize_t show_port(struct class_device *class_dev, char *buf) + { +- struct srp_host *host = container_of(dev, struct srp_host, dev); ++ struct srp_host *host = ++ container_of(class_dev, struct srp_host, class_dev); + + return sprintf(buf, "%d\n", host->port); + } + +-static DEVICE_ATTR(port, S_IRUGO, show_port, NULL); ++static CLASS_DEVICE_ATTR(port, S_IRUGO, show_port, NULL); + + static struct srp_host *srp_add_port(struct srp_device *device, u8 port) + { +@@ -2069,24 +2057,24 @@ static struct srp_host *srp_add_port(str + host->srp_dev = device; + host->port = port; + +- host->dev.class = &srp_class; +- host->dev.parent = device->dev->dma_device; +- snprintf(host->dev.bus_id, BUS_ID_SIZE, "srp-%s-%d", ++ host->class_dev.class = &srp_class; ++ host->class_dev.dev = device->dev->dma_device; ++ snprintf(host->class_dev.class_id, BUS_ID_SIZE, "srp-%s-%d", + device->dev->name, port); + +- if (device_register(&host->dev)) ++ if (class_device_register(&host->class_dev)) + goto free_host; +- if (device_create_file(&host->dev, &dev_attr_add_target)) ++ if (class_device_create_file(&host->class_dev, &class_device_attr_add_target)) + goto err_class; +- if (device_create_file(&host->dev, &dev_attr_ibdev)) ++ if (class_device_create_file(&host->class_dev, &class_device_attr_ibdev)) + goto err_class; +- if (device_create_file(&host->dev, &dev_attr_port)) ++ if (class_device_create_file(&host->class_dev, &class_device_attr_port)) + goto err_class; + + return host; + + err_class: +- device_unregister(&host->dev); ++ class_device_unregister(&host->class_dev); + + free_host: + kfree(host); +@@ -2263,7 +2251,7 @@ static void srp_remove_one(struct ib_dev + ib_unregister_event_handler(&srp_dev->event_handler); + + list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) { +- device_unregister(&host->dev); ++ class_device_unregister(&host->class_dev); + /* + * Wait for the sysfs entry to go away, so that no new + * target ports can be created. +Index: ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/srp/ib_srp.h ++++ ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.h +@@ -98,7 +98,7 @@ struct srp_device { + struct srp_host { + struct srp_device *srp_dev; + u8 port; +- struct device dev; ++ struct class_device class_dev; + struct list_head target_list; + spinlock_t target_lock; + struct completion released; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_cmd_to_2_6_22.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_cmd_to_2_6_22.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_cmd_to_2_6_22.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/srp_cmd_to_2_6_22.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,79 @@ +--- + drivers/infiniband/ulp/srp/ib_srp.c | 33 +++++++++++++++++++++++++++++---- + drivers/infiniband/ulp/srp/ib_srp.h | 5 +++++ + 2 files changed, 34 insertions(+), 4 deletions(-) + +Index: ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/srp/ib_srp.c ++++ ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.c +@@ -510,6 +510,9 @@ static void srp_unmap_data(struct scsi_c + struct srp_target_port *target, + struct srp_request *req) + { ++ struct scatterlist *scat; ++ int nents; ++ + if (!scsi_sglist(scmnd) || + (scmnd->sc_data_direction != DMA_TO_DEVICE && + scmnd->sc_data_direction != DMA_FROM_DEVICE)) +@@ -520,8 +523,20 @@ static void srp_unmap_data(struct scsi_c + req->fmr = NULL; + } + +- ib_dma_unmap_sg(target->srp_host->srp_dev->dev, scsi_sglist(scmnd), +- scsi_sg_count(scmnd), scmnd->sc_data_direction); ++ /* ++ * This handling of non-SG commands can be killed when the ++ * SCSI midlayer no longer generates non-SG commands. ++ */ ++ if (likely(scsi_sg_count(scmnd))) { ++ nents = scsi_sg_count(scmnd); ++ scat = scsi_sglist(scmnd); ++ } else { ++ nents = 1; ++ scat = &req->fake_sg; ++ } ++ ++ ib_dma_unmap_sg(target->srp_host->srp_dev->dev, scat, nents, ++ scmnd->sc_data_direction); + } + + static void srp_remove_req(struct srp_target_port *target, struct srp_request *req) +@@ -721,8 +736,18 @@ static int srp_map_data(struct scsi_cmnd + return -EINVAL; + } + +- nents = scsi_sg_count(scmnd); +- scat = scsi_sglist(scmnd); ++ /* ++ * This handling of non-SG commands can be killed when the ++ * SCSI midlayer no longer generates non-SG commands. ++ */ ++ if (likely(scsi_sg_count(scmnd))) { ++ nents = scsi_sg_count(scmnd); ++ scat = scsi_sglist(scmnd); ++ } else { ++ nents = 1; ++ scat = &req->fake_sg; ++ sg_init_one(scat, scmnd->request_buffer, scmnd->request_bufflen); ++ } + + dev = target->srp_host->srp_dev; + ibdev = dev->dev; +Index: ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.h +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/ulp/srp/ib_srp.h ++++ ofed_kernel/drivers/infiniband/ulp/srp/ib_srp.h +@@ -111,6 +111,11 @@ struct srp_request { + struct srp_iu *cmd; + struct srp_iu *tsk_mgmt; + struct ib_pool_fmr *fmr; ++ /* ++ * Fake scatterlist used when scsi_sg_count(scmnd)==0. Can be killed ++ * when the SCSI midlayer no longer generates non-SG commands. ++ */ ++ struct scatterlist fake_sg; + struct completion done; + short index; + u8 cmd_done; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/uverbs_main_1_to_2_6_24.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/uverbs_main_1_to_2_6_24.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/uverbs_main_1_to_2_6_24.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/uverbs_main_1_to_2_6_24.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,39 @@ +--- + drivers/infiniband/core/uverbs_main.c | 19 ++++++++++++------- + 1 file changed, 12 insertions(+), 7 deletions(-) + +Index: ofed_kernel/drivers/infiniband/core/uverbs_main.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/uverbs_main.c ++++ ofed_kernel/drivers/infiniband/core/uverbs_main.c +@@ -553,18 +553,23 @@ struct file *ib_uverbs_alloc_event_file( + goto err; + } + +- /* +- * fops_get() can't fail here, because we're coming from a +- * system call on a uverbs file, which will already have a +- * module reference. +- */ +- filp = alloc_file(uverbs_event_mnt, dget(uverbs_event_mnt->mnt_root), +- FMODE_READ, fops_get(&uverbs_event_fops)); ++ filp = get_empty_filp(); + if (!filp) { + ret = -ENFILE; + goto err_fd; + } + ++ /* ++ * fops_get() can't fail here, because we're coming from a ++ * system call on a uverbs file, which will already have a ++ * module reference. ++ */ ++ filp->f_op = fops_get(&uverbs_event_fops); ++ filp->f_path.mnt = mntget(uverbs_event_mnt); ++ filp->f_path.dentry = dget(uverbs_event_mnt->mnt_root); ++ filp->f_mapping = filp->f_path.dentry->d_inode->i_mapping; ++ filp->f_flags = O_RDONLY; ++ filp->f_mode = FMODE_READ; + filp->private_data = ev_file; + + return filp; diff -urN prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/uverbs_main_2_to_2_6_19.patch ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/uverbs_main_2_to_2_6_19.patch --- prev-ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/uverbs_main_2_to_2_6_19.patch 1970-01-01 01:00:00.000000000 +0100 +++ ofa_kernel-1.5.4.1/kernel_patches/backport/2.6.18-EL5.8/uverbs_main_2_to_2_6_19.patch 2012-09-27 11:40:20.000000000 +0200 @@ -0,0 +1,70 @@ +--- + drivers/infiniband/core/uverbs_main.c | 6 +++--- + drivers/infiniband/hw/ipath/ipath_file_ops.c | 4 ++-- + drivers/infiniband/hw/ipath/ipath_fs.c | 6 +++--- + 3 files changed, 8 insertions(+), 8 deletions(-) + +Index: ofed_kernel/drivers/infiniband/core/uverbs_main.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/core/uverbs_main.c ++++ ofed_kernel/drivers/infiniband/core/uverbs_main.c +@@ -565,9 +565,9 @@ struct file *ib_uverbs_alloc_event_file( + * module reference. + */ + filp->f_op = fops_get(&uverbs_event_fops); +- filp->f_path.mnt = mntget(uverbs_event_mnt); +- filp->f_path.dentry = dget(uverbs_event_mnt->mnt_root); +- filp->f_mapping = filp->f_path.dentry->d_inode->i_mapping; ++ filp->f_vfsmnt = mntget(uverbs_event_mnt); ++ filp->f_dentry = dget(uverbs_event_mnt->mnt_root); ++ filp->f_mapping = filp->f_dentry->d_inode->i_mapping; + filp->f_flags = O_RDONLY; + filp->f_mode = FMODE_READ; + filp->private_data = ev_file; +Index: ofed_kernel/drivers/infiniband/hw/ipath/ipath_file_ops.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/hw/ipath/ipath_file_ops.c ++++ ofed_kernel/drivers/infiniband/hw/ipath/ipath_file_ops.c +@@ -1868,9 +1868,9 @@ static int ipath_assign_port(struct file + goto done_chk_sdma; + } + +- i_minor = iminor(fp->f_path.dentry->d_inode) - IPATH_USER_MINOR_BASE; ++ i_minor = iminor(fp->f_dentry->d_inode) - IPATH_USER_MINOR_BASE; + ipath_cdbg(VERBOSE, "open on dev %lx (minor %d)\n", +- (long)fp->f_path.dentry->d_inode->i_rdev, i_minor); ++ (long)fp->f_dentry->d_inode->i_rdev, i_minor); + + if (i_minor) + ret = find_free_port(i_minor - 1, fp, uinfo); +Index: ofed_kernel/drivers/infiniband/hw/ipath/ipath_fs.c +=================================================================== +--- ofed_kernel.orig/drivers/infiniband/hw/ipath/ipath_fs.c ++++ ofed_kernel/drivers/infiniband/hw/ipath/ipath_fs.c +@@ -113,7 +113,7 @@ static ssize_t atomic_counters_read(stru + struct infinipath_counters counters; + struct ipath_devdata *dd; + +- dd = file->f_path.dentry->d_inode->i_private; ++ dd = file->f_dentry->d_inode->i_private; + dd->ipath_f_read_counters(dd, &counters); + + return simple_read_from_buffer(buf, count, ppos, &counters, +@@ -153,7 +153,7 @@ static ssize_t flash_read(struct file *f + goto bail; + } + +- dd = file->f_path.dentry->d_inode->i_private; ++ dd = file->f_dentry->d_inode->i_private; + if (ipath_eeprom_read(dd, pos, tmp, count)) { + ipath_dev_err(dd, "failed to read from flash\n"); + ret = -ENXIO; +@@ -206,7 +206,7 @@ static ssize_t flash_write(struct file * + goto bail_tmp; + } + +- dd = file->f_path.dentry->d_inode->i_private; ++ dd = file->f_dentry->d_inode->i_private; + if (ipath_eeprom_write(dd, pos, tmp, count)) { + ret = -ENXIO; + ipath_dev_err(dd, "failed to write to flash\n"); diff -urN prev-ofa_kernel-1.5.4.1/ofed_scripts/get_backport_dir.sh ofa_kernel-1.5.4.1/ofed_scripts/get_backport_dir.sh --- prev-ofa_kernel-1.5.4.1/ofed_scripts/get_backport_dir.sh 2012-09-27 11:27:59.000000000 +0200 +++ ofa_kernel-1.5.4.1/ofed_scripts/get_backport_dir.sh 2012-09-27 11:28:23.000000000 +0200 @@ -96,8 +96,10 @@ echo 2.6.18-EL5.5 elif [ $minor -lt 259 ]; then echo 2.6.18-EL5.6 - else + elif [ $minor -lt 308 ]; then echo 2.6.18-EL5.7 + else + echo 2.6.18-EL5.8 fi ;; 2.6.18-*fc[56]*)