u32 private_data[IB_CM_REQ_PRIVATE_DATA_SIZE / sizeof(u32)];
 
-} __attribute__ ((packed));
+} __packed;
 
 static inline __be32 cm_req_get_local_qpn(struct cm_req_msg *req_msg)
 {
 
        u8 private_data[IB_CM_MRA_PRIVATE_DATA_SIZE];
 
-} __attribute__ ((packed));
+} __packed;
 
 static inline u8 cm_mra_get_msg_mraed(struct cm_mra_msg *mra_msg)
 {
 
        u8 private_data[IB_CM_REJ_PRIVATE_DATA_SIZE];
 
-} __attribute__ ((packed));
+} __packed;
 
 static inline u8 cm_rej_get_msg_rejected(struct cm_rej_msg *rej_msg)
 {
 
        u8 private_data[IB_CM_REP_PRIVATE_DATA_SIZE];
 
-} __attribute__ ((packed));
+} __packed;
 
 static inline __be32 cm_rep_get_local_qpn(struct cm_rep_msg *rep_msg)
 {
 
        u8 private_data[IB_CM_RTU_PRIVATE_DATA_SIZE];
 
-} __attribute__ ((packed));
+} __packed;
 
 struct cm_dreq_msg {
        struct ib_mad_hdr hdr;
 
        u8 private_data[IB_CM_DREQ_PRIVATE_DATA_SIZE];
 
-} __attribute__ ((packed));
+} __packed;
 
 static inline __be32 cm_dreq_get_remote_qpn(struct cm_dreq_msg *dreq_msg)
 {
 
        u8 private_data[IB_CM_DREP_PRIVATE_DATA_SIZE];
 
-} __attribute__ ((packed));
+} __packed;
 
 struct cm_lap_msg {
        struct ib_mad_hdr hdr;
        u8 offset63;
 
        u8 private_data[IB_CM_LAP_PRIVATE_DATA_SIZE];
-} __attribute__  ((packed));
+} __packed;
 
 static inline __be32 cm_lap_get_remote_qpn(struct cm_lap_msg *lap_msg)
 {
        u8 info[IB_CM_APR_INFO_LENGTH];
 
        u8 private_data[IB_CM_APR_PRIVATE_DATA_SIZE];
-} __attribute__ ((packed));
+} __packed;
 
 struct cm_sidr_req_msg {
        struct ib_mad_hdr hdr;
        __be64 service_id;
 
        u32 private_data[IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE / sizeof(u32)];
-} __attribute__ ((packed));
+} __packed;
 
 struct cm_sidr_rep_msg {
        struct ib_mad_hdr hdr;
        u8 info[IB_CM_SIDR_REP_INFO_LENGTH];
 
        u8 private_data[IB_CM_SIDR_REP_PRIVATE_DATA_SIZE];
-} __attribute__ ((packed));
+} __packed;
 
 static inline __be32 cm_sidr_rep_get_qpn(struct cm_sidr_rep_msg *sidr_rep_msg)
 {
 
        struct ib_mad_recv_wc recv_wc;
        struct ib_wc wc;
        u64 mapping;
-} __attribute__ ((packed));
+} __packed;
 
 struct ib_mad_private {
        struct ib_mad_private_header header;
        size_t mad_size;
        struct ib_grh grh;
        u8 mad[0];
-} __attribute__ ((packed));
+} __packed;
 
 struct ib_rmpp_segment {
        struct list_head list;
 
        T3_SOLICITED_EVENT_FLAG = 0x04,
        T3_READ_FENCE_FLAG = 0x08,
        T3_LOCAL_FENCE_FLAG = 0x10
-} __attribute__ ((packed));
+} __packed;
 
 enum t3_wr_opcode {
        T3_WR_BP = FW_WROPCODE_RI_BYPASS,
        T3_WR_INIT = FW_WROPCODE_RI_RDMA_INIT,
        T3_WR_QP_MOD = FW_WROPCODE_RI_MODIFY_QP,
        T3_WR_FASTREG = FW_WROPCODE_RI_FASTREGISTER_MR
-} __attribute__ ((packed));
+} __packed;
 
 enum t3_rdma_opcode {
        T3_RDMA_WRITE,          /* IETF RDMAP v1.0 ... */
        T3_QP_MOD,
        T3_BYPASS,
        T3_RDMA_READ_REQ_WITH_INV,
-} __attribute__ ((packed));
+} __packed;
 
 static inline enum t3_rdma_opcode wr2opcode(enum t3_wr_opcode wrop)
 {
        uP_RI_MPA_TX_MARKER_ENABLE = 0x2,
        uP_RI_MPA_CRC_ENABLE = 0x4,
        uP_RI_MPA_IETF_ENABLE = 0x8
-} __attribute__ ((packed));
+} __packed;
 
 enum t3_qp_caps {
        uP_RI_QP_RDMA_READ_ENABLE = 0x01,
        uP_RI_QP_BIND_ENABLE = 0x04,
        uP_RI_QP_FAST_REGISTER_ENABLE = 0x08,
        uP_RI_QP_STAG0_ENABLE = 0x10
-} __attribute__ ((packed));
+} __packed;
 
 enum rdma_init_rtr_types {
        RTR_READ = 1,
 
        __be32 ci_db;           /* Arbel only */
        __be32 state_db;        /* Arbel only */
        u32    reserved;
-} __attribute__((packed));
+} __packed;
 
 #define MTHCA_CQ_STATUS_OK          ( 0 << 28)
 #define MTHCA_CQ_STATUS_OVERFLOW    ( 9 << 28)
 
        __be32 consumer_index;
        __be32 producer_index;
        u32    reserved3[4];
-} __attribute__((packed));
+} __packed;
 
 #define MTHCA_EQ_STATUS_OK          ( 0 << 28)
 #define MTHCA_EQ_STATUS_OVERFLOW    ( 9 << 28)
                u32 raw[6];
                struct {
                        __be32 cqn;
-               } __attribute__((packed)) comp;
+               } __packed comp;
                struct {
                        u16    reserved1;
                        __be16 token;
                        u8     reserved3[3];
                        u8     status;
                        __be64 out_param;
-               } __attribute__((packed)) cmd;
+               } __packed cmd;
                struct {
                        __be32 qpn;
-               } __attribute__((packed)) qp;
+               } __packed qp;
                struct {
                        __be32 srqn;
-               } __attribute__((packed)) srq;
+               } __packed srq;
                struct {
                        __be32 cqn;
                        u32    reserved1;
                        u8     reserved2[3];
                        u8     syndrome;
-               } __attribute__((packed)) cq_err;
+               } __packed cq_err;
                struct {
                        u32    reserved1[2];
                        __be32 port;
-               } __attribute__((packed)) port_change;
+               } __packed port_change;
        } event;
        u8 reserved3[3];
        u8 owner;
-} __attribute__((packed));
+} __packed;
 
 #define  MTHCA_EQ_ENTRY_OWNER_SW      (0 << 7)
 #define  MTHCA_EQ_ENTRY_OWNER_HW      (1 << 7)
 
        __be64 mtt_seg;
        __be32 mtt_sz;          /* Arbel only */
        u32    reserved[2];
-} __attribute__((packed));
+} __packed;
 
 #define MTHCA_MPT_FLAG_SW_OWNS       (0xfUL << 28)
 #define MTHCA_MPT_FLAG_MIO           (1 << 17)
 
        u8     hop_limit;
        __be32 sl_tclass_flowlabel;
        u8     rgid[16];
-} __attribute__((packed));
+} __packed;
 
 struct mthca_qp_context {
        __be32 flags;
        __be16 rq_wqe_counter;  /* reserved on Tavor */
        __be16 sq_wqe_counter;  /* reserved on Tavor */
        u32    reserved3[18];
-} __attribute__((packed));
+} __packed;
 
 struct mthca_qp_param {
        __be32 opt_param_mask;
        u32    reserved1;
        struct mthca_qp_context context;
        u32    reserved2[62];
-} __attribute__((packed));
+} __packed;
 
 enum {
        MTHCA_QP_OPTPAR_ALT_ADDR_PATH     = 1 << 0,
 
        __be32                  rkey;
        __be64                  swap_add;
        __be64                  comp;
-} __attribute__((__packed__));
+} __packed;
 
 static inline u64 __atmeth_va(void *arg)
 {
 
        u64                          rsp_dma;
        struct ib_sge                sge;
        struct ib_cqe                cqe;
-} __attribute__((packed));
+} __packed;
 
 struct iser_conn;
 struct ib_conn;
 
        __be16                  attr_offset;
        __be16                  reserved;
        ib_sa_comp_mask         comp_mask;
-} __attribute__ ((packed));
+} __packed;
 
 struct ib_mad {
        struct ib_mad_hdr       mad_hdr;
        struct ib_rmpp_hdr      rmpp_hdr;
        struct ib_sa_hdr        sa_hdr;
        u8                      data[IB_MGMT_SA_DATA];
-} __attribute__ ((packed));
+} __packed;
 
 struct ib_vendor_mad {
        struct ib_mad_hdr       mad_hdr;
 
        u8      data[IB_SMP_DATA_SIZE];
        u8      initial_path[IB_SMP_MAX_PATH_HOPS];
        u8      return_path[IB_SMP_MAX_PATH_HOPS];
-} __attribute__ ((packed));
+} __packed;
 
 #define IB_SMP_DIRECTION                       cpu_to_be16(0x8000)
 
 
        u8     local_port_num;
        u8     reserved12;
        u8     reserved13;                       /* was guid_cap */
-} __attribute__ ((packed));
+} __packed;
 
 #endif /* OPA_PORT_INFO_H */
 
 
 struct opa_node_description {
        u8 data[64];
-} __attribute__ ((packed));
+} __packed;
 
 struct opa_node_info {
        u8      base_version;
        __be32  revision;
        u8      local_port_num;
        u8      vendor_id[3];   /* network byte order */
-} __attribute__ ((packed));
+} __packed;
 
 #define OPA_PARTITION_TABLE_BLK_SIZE 32