ipath - almost-final round of patches for submission
PATCH 1/1 ipath - infiniband RC protocol support
In reply to Bryan O'Sullivandrivers/infiniband/hw/ipath/ipath_rc.c new file +1769 -0
@@ -0,0 +1,1769 @@ +/* +* Copyright (c) 2005, 2006 PathScale, Inc. 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 "ipath_verbs.h" +#include "ips_common.h" + +/* cut down ridiculously long IB macro names */ +#define OP (x) IB_OPCODE_RC_##x + +/** +* ipath_init_restart- initialize the qp->s_sge after a restart +* @qp: the QP who's SGE we're restarting +* @wqe: the work queue to initialize the QP's SGE from +* +* The QP s_lock should be held. +*/ +static void ipath_init_restart (struct ipath_qp *qp,struct ipath_swqe *wqe) +{ +struct ipath_ibdev *dev; +u32 len; + + len = ((qp->s_psn - wqe->psn) &IPS_PSN_MASK ) * +ib_mtu_enum_to_int (qp->path_mtu); + qp->s_sge.sge = wqe->sg_list[0 ]; + qp->s_sge.sg_list = wqe->sg_list +1 ; + qp->s_sge.num_sge = wqe->wr.num_sge; +ipath_skip_sge (&qp->s_sge, len); + qp->s_len = wqe->length - len; + dev =to_idev (qp->ibqp.device); +spin_lock (&dev->pending_lock); +if (qp->timerwait.next ==LIST_POISON1 ) +list_add_tail (&qp->timerwait, + &dev->pending[dev->pending_index]); +spin_unlock (&dev->pending_lock); +} + +/** +* ipath_do_rc_send - perform a send on an RC QP +* @data: contains a pointer to the QP +* +* Process entries in the send work queue until credit or queue is +* exhausted. Only allow one CPU to send a packet per QP (tasklet). +* Otherwise, after we drop the QP s_lock, two threads could send +* packets out of order. +*/ +void ipath_do_rc_send (unsigned long data) +{ +struct ipath_qp *qp = (struct ipath_qp *)data; +struct ipath_ibdev *dev =to_idev (qp->ibqp.device); +struct ipath_swqe *wqe; +struct ipath_sge_state *ss; +unsigned long flags; +u16 lrh0; +u32 hwords; +u32 nwords; +u32 extra_bytes; +u32 bth0; +u32 bth2; +u32 pmtu =ib_mtu_enum_to_int (qp->path_mtu); +u32 len; +struct ipath_other_headers *ohdr; +char newreq; + +if (test_and_set_bit (IPATH_S_BUSY , &qp->s_flags)) +return ; + +if (unlikely (qp->remote_ah_attr.dlid == +ipath_layer_get_lid (dev->dd))) { +struct ib_wc wc; + +/* +* Pass in an uninitialized ib_wc to be consistent with +* other places where ipath_ruc_loopback() is called. +*/ +ipath_ruc_loopback (qp, &wc); +clear_bit (IPATH_S_BUSY , &qp->s_flags); +return ; + } + + ohdr = &qp->s_hdr.u.oth; +if (qp->remote_ah_attr.ah_flags &IB_AH_GRH ) + ohdr = &qp->s_hdr.u.l.oth; + +again: +/* Check for a constructed packet to be sent. */ +if (qp->s_hdrwords !=0 ) { +/* +* If no PIO bufs are available, return. +* An interrupt will call ipath_ib_piobufavail() +* when one is available. +*/ +if (ipath_verbs_send (dev->dd, qp->s_hdrwords, + (u32 *) &qp->s_hdr, + qp->s_cur_size, + qp->s_cur_sge)) { +ipath_no_bufs_available (qp, dev); +return ; + } + dev->n_unicast_xmit++; +/* Record that we sent the packet and s_hdr is empty. */ + qp->s_hdrwords =0 ; + } + + lrh0 =IPS_LRH_BTH ; +/* header size in 32-bit words LRH+BTH = (8+12)/4. */ + hwords =5 ; + +/* +* The lock is needed to synchronize between +* setting qp->s_ack_state, resend timer, and post_send(). +*/ +spin_lock_irqsave (&qp->s_lock, flags); + + bth0 =ipath_layer_get_pkey (dev->dd, qp->s_pkey_index); + +/* Sending responses has higher priority over sending requests. */ +if (qp->s_ack_state !=OP (ACKNOWLEDGE )) { +/* +* Send a response. Note that we are in the responder's +* side of the QP context. +*/ +switch (qp->s_ack_state) { +case OP (RDMA_READ_REQUEST ): + ss = &qp->s_rdma_sge; + len = qp->s_rdma_len; +if (len > pmtu) { + len = pmtu; + qp->s_ack_state = +OP (RDMA_READ_RESPONSE_FIRST ); + }else + qp->s_ack_state = +OP (RDMA_READ_RESPONSE_ONLY ); + qp->s_rdma_len -= len; + bth0 |= qp->s_ack_state <<24 ; + ohdr->u.aeth =ipath_compute_aeth (qp); + hwords++; +break ; + +case OP (RDMA_READ_RESPONSE_FIRST ): + qp->s_ack_state = +OP (RDMA_READ_RESPONSE_MIDDLE ); +/* FALLTHROUGH */ +case OP (RDMA_READ_RESPONSE_MIDDLE ): + ss = &qp->s_rdma_sge; + len = qp->s_rdma_len; +if (len > pmtu) + len = pmtu; +else { + ohdr->u.aeth =ipath_compute_aeth (qp); + hwords++; + qp->s_ack_state = +OP (RDMA_READ_RESPONSE_LAST ); + } + qp->s_rdma_len -= len; + bth0 |= qp->s_ack_state <<24 ; +break ; + +case OP (RDMA_READ_RESPONSE_LAST ): +case OP (RDMA_READ_RESPONSE_ONLY ): +/* +* We have to prevent new requests from changing +* the r_sge state while a ipath_verbs_send() +* is in progress. +* Changing r_state allows the receiver +* to continue processing new packets. +* We do it here now instead of above so +* that we are sure the packet was sent before +* changing the state. +*/ + qp->r_state =OP (RDMA_READ_RESPONSE_LAST ); + qp->s_ack_state =OP (ACKNOWLEDGE ); + goto send_req; + +case OP (COMPARE_SWAP ): +case OP (FETCH_ADD ): + ss =NULL ; + len =0 ; + qp->r_state =OP (SEND_LAST ); + qp->s_ack_state =OP (ACKNOWLEDGE ); + bth0 |=IB_OPCODE_ATOMIC_ACKNOWLEDGE <<24 ; + ohdr->u.at.aeth =ipath_compute_aeth (qp); + ohdr->u.at.atomic_ack_eth = +cpu_to_be64 (qp->s_ack_atomic); + hwords +=sizeof (ohdr->u.at) /4 ; +break ; + +default : +/* Send a regular ACK. */ + ss =NULL ; + len =0 ; + qp->s_ack_state =OP (ACKNOWLEDGE ); + bth0 |= qp->s_ack_state <<24 ; + ohdr->u.aeth =ipath_compute_aeth (qp); + hwords++; + } + bth2 = qp->s_ack_psn++ &IPS_PSN_MASK ; + }else { + send_req: +if (!(ib_ipath_state_ops[qp->state] & +IPATH_PROCESS_SEND_OK ) || qp->s_rnr_timeout) + goto done; + +/* Send a request. */ + wqe =get_swqe_ptr (qp, qp->s_cur); +switch (qp->s_state) { +default : +/* +* Resend an old request or start a new one. +* +* We keep track of the current SWQE so that +* we don't reset the "furthest progress" state +* if we need to back up. +*/ + newreq =0 ; +if (qp->s_cur == qp->s_tail) { +/* Check if send work queue is empty. */ +if (qp->s_tail == qp->s_head) + goto done; + qp->s_psn = wqe->psn = qp->s_next_psn; + newreq =1 ; + } +/* +* Note that we have to be careful not to modify the +* original work request since we may need to resend +* it. +*/ + qp->s_sge.sge = wqe->sg_list[0 ]; + qp->s_sge.sg_list = wqe->sg_list +1 ; + qp->s_sge.num_sge = wqe->wr.num_sge; + qp->s_len = len = wqe->length; + ss = &qp->s_sge; + bth2 =0 ; +switch (wqe->wr.opcode) { +case IB_WR_SEND : +case IB_WR_SEND_WITH_IMM : +/* If no credit, return. */ +if (qp->s_lsn != (u32) -1 && +ipath_cmp24 (wqe->ssn, + qp->s_lsn +1 ) >0 ) + goto done; + wqe->lpsn = wqe->psn; +if (len > pmtu) { + wqe->lpsn += (len -1 ) / pmtu; + qp->s_state = +OP (SEND_FIRST ); + len = pmtu; +break ; + } +if (wqe->wr.opcode ==IB_WR_SEND ) + qp->s_state = +OP (SEND_ONLY ); +else { + qp->s_state = +OP (SEND_ONLY_WITH_IMMEDIATE ); +/* +* Immediate data comes after the +* BTH +*/ + ohdr->u.imm_data = wqe->wr.imm_data; + hwords +=1 ; + } +if (wqe->wr.send_flags &IB_SEND_SOLICITED ) + bth0 |=1 <<23 ; + bth2 =1 <<31 ;/* Request ACK. */ +if (++qp->s_cur == qp->s_size) + qp->s_cur =0 ; +break ; + +case IB_WR_RDMA_WRITE : +if (newreq) + qp->s_lsn++; +/* FALLTHROUGH */ +case IB_WR_RDMA_WRITE_WITH_IMM : +/* If no credit, return. */ +if (qp->s_lsn != (u32) -1 && +ipath_cmp24 (wqe->ssn, + qp->s_lsn +1 ) >0 ) + goto done; + ohdr->u.rc.reth.vaddr = +cpu_to_be64 (wqe->wr.wr.rdma.remote_addr); + ohdr->u.rc.reth.rkey = +cpu_to_be32 (wqe->wr.wr.rdma.rkey); + ohdr->u.rc.reth.length =cpu_to_be32 (len); + hwords +=sizeof (struct ib_reth ) /4 ; + wqe->lpsn = wqe->psn; +if (len > pmtu) { + wqe->lpsn += (len -1 ) / pmtu; + qp->s_state = +OP (RDMA_WRITE_FIRST ); + len = pmtu; +break ; + } +if (wqe->wr.opcode ==IB_WR_RDMA_WRITE ) + qp->s_state = +OP (RDMA_WRITE_ONLY ); +else { + qp->s_state = +OP (RDMA_WRITE_ONLY_WITH_IMMEDIATE ); +/* Immediate data comes +* after RETH */ + ohdr->u.rc.imm_data = + wqe->wr.imm_data; + hwords +=1 ; +if (wqe->wr.send_flags & +IB_SEND_SOLICITED ) + bth0 |=1 <<23 ; + } + bth2 =1 <<31 ;/* Request ACK. */ +if (++qp->s_cur == qp->s_size) + qp->s_cur =0 ; +break ; + +case IB_WR_RDMA_READ : + ohdr->u.rc.reth.vaddr = +cpu_to_be64 (wqe->wr.wr.rdma.remote_addr); + ohdr->u.rc.reth.rkey = +cpu_to_be32 (wqe->wr.wr.rdma.rkey); + ohdr->u.rc.reth.length =cpu_to_be32 (len); + qp->s_state =OP (RDMA_READ_REQUEST ); + hwords +=sizeof (ohdr->u.rc.reth) /4 ; +if (newreq) { + qp->s_lsn++; +/* +* Adjust s_next_psn to count the +* expected number of responses. +*/ +if (len > pmtu) + qp->s_next_psn += + (len -1 ) / pmtu; + wqe->lpsn = qp->s_next_psn++; + } + ss =NULL ; + len =0 ; +if (++qp->s_cur == qp->s_size) + qp->s_cur =0 ; +break ; + +case IB_WR_ATOMIC_CMP_AND_SWP : +case IB_WR_ATOMIC_FETCH_AND_ADD : + qp->s_state = (wqe->wr.opcode == +IB_WR_ATOMIC_CMP_AND_SWP ) + ?OP (COMPARE_SWAP ) + :OP (FETCH_ADD ); + ohdr->u.atomic_eth.vaddr = +cpu_to_be64 (wqe->wr.wr.atomic.remote_addr); + ohdr->u.atomic_eth.rkey = +cpu_to_be32 (wqe->wr.wr.atomic.rkey); + ohdr->u.atomic_eth.swap_data = +cpu_to_be64 (wqe->wr.wr.atomic.swap); + ohdr->u.atomic_eth.compare_data = +cpu_to_be64 (wqe->wr.wr.atomic.compare_add); + hwords +=sizeof (struct ib_atomic_eth ) /4 ; +if (newreq) { + qp->s_lsn++; + wqe->lpsn = wqe->psn; + } +if (++qp->s_cur == qp->s_size) + qp->s_cur =0 ; + ss =NULL ; + len =0 ; +break ; + +default : + goto done; + } +if (newreq) { + qp->s_tail++; +if (qp->s_tail >= qp->s_size) + qp->s_tail =0 ; + } + bth2 |= qp->s_psn++ &IPS_PSN_MASK ; +if ((int )(qp->s_psn - qp->s_next_psn) >0 ) + qp->s_next_psn = qp->s_psn; +spin_lock (&dev->pending_lock); +if (qp->timerwait.next ==LIST_POISON1 ) +list_add_tail (&qp->timerwait, + &dev->pending[dev-> + pending_index]); +spin_unlock (&dev->pending_lock); +break ; + +case OP (RDMA_READ_RESPONSE_FIRST ): +/* +* This case can only happen if a send is +* restarted. See ipath_restart_rc(). +*/ +ipath_init_restart (qp, wqe); +/* FALLTHROUGH */ +case OP (SEND_FIRST ): + qp->s_state =OP (SEND_MIDDLE ); +/* FALLTHROUGH */ +case OP (SEND_MIDDLE ): + bth2 = qp->s_psn++ &IPS_PSN_MASK ; +if ((int )(qp->s_psn - qp->s_next_psn) >0 ) + qp->s_next_psn = qp->s_psn; + ss = &qp->s_sge; + len = qp->s_len; +if (len > pmtu) { +/* +* Request an ACK every 1/2 MB to avoid +* retransmit timeouts. +*/ +if (((wqe->length - len) % + (512 *1024 )) ==0 ) + bth2 |=1 <<31 ; + len = pmtu; +break ; + } +if (wqe->wr.opcode ==IB_WR_SEND ) + qp->s_state =OP (SEND_LAST ); +else { + qp->s_state = +OP (SEND_LAST_WITH_IMMEDIATE ); +/* Immediate data comes after the BTH */ + ohdr->u.imm_data = wqe->wr.imm_data; + hwords +=1 ; + } +if (wqe->wr.send_flags &IB_SEND_SOLICITED ) + bth0 |=1 <<23 ; + bth2 |=1 <<31 ;/* Request ACK. */ + qp->s_cur++; +if (qp->s_cur >= qp->s_size) + qp->s_cur =0 ; +break ; + +case OP (RDMA_READ_RESPONSE_LAST ): +/* +* This case can only happen if a RDMA write is +* restarted. See ipath_restart_rc(). +*/ +ipath_init_restart (qp, wqe); +/* FALLTHROUGH */ +case OP (RDMA_WRITE_FIRST ): + qp->s_state =OP (RDMA_WRITE_MIDDLE ); +/* FALLTHROUGH */ +case OP (RDMA_WRITE_MIDDLE ): + bth2 = qp->s_psn++ &IPS_PSN_MASK ; +if ((int )(qp->s_psn - qp->s_next_psn) >0 ) + qp->s_next_psn = qp->s_psn; + ss = &qp->s_sge; + len = qp->s_len; +if (len > pmtu) { +/* +* Request an ACK every 1/2 MB to avoid +* retransmit timeouts. +*/ +if (((wqe->length - len) % + (512 *1024 )) ==0 ) + bth2 |=1 <<31 ; + len = pmtu; +break ; + } +if (wqe->wr.opcode ==IB_WR_RDMA_WRITE ) + qp->s_state =OP (RDMA_WRITE_LAST ); +else { + qp->s_state = +OP (RDMA_WRITE_LAST_WITH_IMMEDIATE ); +/* Immediate data comes after the BTH */ + ohdr->u.imm_data = wqe->wr.imm_data; + hwords +=1 ; +if (wqe->wr.send_flags &IB_SEND_SOLICITED ) + bth0 |=1 <<23 ; + } + bth2 |=1 <<31 ;/* Request ACK. */ + qp->s_cur++; +if (qp->s_cur >= qp->s_size) + qp->s_cur =0 ; +break ; + +case OP (RDMA_READ_RESPONSE_MIDDLE ): +/* +* This case can only happen if a RDMA read is +* restarted. See ipath_restart_rc(). +*/ +ipath_init_restart (qp, wqe); + len = ((qp->s_psn - wqe->psn) & +IPS_PSN_MASK ) * pmtu; + ohdr->u.rc.reth.vaddr = +cpu_to_be64 (wqe->wr.wr.rdma.remote_addr + + len); + ohdr->u.rc.reth.rkey = +cpu_to_be32 (wqe->wr.wr.rdma.rkey); + ohdr->u.rc.reth.length =cpu_to_be32 (qp->s_len); + qp->s_state =OP (RDMA_READ_REQUEST ); + hwords +=sizeof (ohdr->u.rc.reth) /4 ; + bth2 = qp->s_psn++ &IPS_PSN_MASK ; +if ((int )(qp->s_psn - qp->s_next_psn) >0 ) + qp->s_next_psn = qp->s_psn; + ss =NULL ; + len =0 ; + qp->s_cur++; +if (qp->s_cur == qp->s_size) + qp->s_cur =0 ; +break ; + +case OP (RDMA_READ_REQUEST ): +case OP (COMPARE_SWAP ): +case OP (FETCH_ADD ): +/* +* We shouldn't start anything new until this +* request is finished. The ACK will handle +* rescheduling us. XXX The number of outstanding +* ones is negotiated at connection setup time (see +* pg. 258,289)? XXX Also, if we support multiple +* outstanding requests, we need to check the WQE +* IB_SEND_FENCE flag and not send a new request if +* a RDMA read or atomic is pending. +*/ + goto done; + } + qp->s_len -= len; + bth0 |= qp->s_state <<24 ; +/* XXX queue resend timeout. */ + } +/* Make sure it is non-zero before dropping the lock. */ + qp->s_hdrwords = hwords; +spin_unlock_irqrestore (&qp->s_lock, flags); + +/* Construct the header. */ + extra_bytes = (4 - len) &3 ; + nwords = (len + extra_bytes) >>2 ; +if (unlikely (qp->remote_ah_attr.ah_flags &IB_AH_GRH )) { +/* Header size in 32-bit words. */ + hwords +=10 ; + lrh0 =IPS_LRH_GRH ; + qp->s_hdr.u.l.grh.version_tclass_flow = +cpu_to_be32 ((6 <<28 ) | + (qp->remote_ah_attr.grh.traffic_class + <<20 ) | + qp->remote_ah_attr.grh.flow_label); + qp->s_hdr.u.l.grh.paylen = +cpu_to_be16 (((hwords -12 ) + nwords + +SIZE_OF_CRC ) <<2 ); +/* next_hdr is defined by C8-7 in ch. 8.4.1 */ + qp->s_hdr.u.l.grh.next_hdr =0x1B ; + qp->s_hdr.u.l.grh.hop_limit = + qp->remote_ah_attr.grh.hop_limit; +/* The SGID is 32-bit aligned. */ + qp->s_hdr.u.l.grh.sgid.global.subnet_prefix = + dev->gid_prefix; + qp->s_hdr.u.l.grh.sgid.global.interface_id = +ipath_layer_get_guid (dev->dd); + qp->s_hdr.u.l.grh.dgid = qp->remote_ah_attr.grh.dgid; + qp->s_hdrwords = hwords; + } + qp->s_cur_sge = ss; + qp->s_cur_size = len; + lrh0 |= qp->remote_ah_attr.sl <<4 ; + qp->s_hdr.lrh[0 ] =cpu_to_be16 (lrh0); +/* DEST LID */ + qp->s_hdr.lrh[1 ] =cpu_to_be16 (qp->remote_ah_attr.dlid); + qp->s_hdr.lrh[2 ] =cpu_to_be16 (hwords + nwords +SIZE_OF_CRC ); + qp->s_hdr.lrh[3 ] =cpu_to_be16 (ipath_layer_get_lid (dev->dd)); + bth0 |= extra_bytes <<20 ; + ohdr->bth[0 ] =cpu_to_be32 (bth0); + ohdr->bth[1 ] =cpu_to_be32 (qp->remote_qpn); + ohdr->bth[2 ] =cpu_to_be32 (bth2); + +/* Check for more work to do. */ + goto again; + +done: +spin_unlock_irqrestore (&qp->s_lock, flags); +clear_bit (IPATH_S_BUSY , &qp->s_flags); +} + +static void send_rc_ack (struct ipath_qp *qp) +{ +struct ipath_ibdev *dev =to_idev (qp->ibqp.device); +u16 lrh0; +u32 bth0; +u32 hwords; +struct ipath_other_headers *ohdr; + +/* Construct the header. */ + ohdr = &qp->s_hdr.u.oth; + lrh0 =IPS_LRH_BTH ; +/* header size in 32-bit words LRH+BTH+AETH = (8+12+4)/4. */ + hwords =6 ; +if (unlikely (qp->remote_ah_attr.ah_flags &IB_AH_GRH )) { + ohdr = &qp->s_hdr.u.l.oth; +/* Header size in 32-bit words. */ + hwords +=10 ; + lrh0 =IPS_LRH_GRH ; + qp->s_hdr.u.l.grh.version_tclass_flow = +cpu_to_be32 ( + (6 <<28 ) | + (qp->remote_ah_attr.grh.traffic_class + <<20 ) | + qp->remote_ah_attr.grh.flow_label); + qp->s_hdr.u.l.grh.paylen = +cpu_to_be16 (((hwords -12 ) +SIZE_OF_CRC ) <<2 ); +/* next_hdr is defined by C8-7 in ch. 8.4.1 */ + qp->s_hdr.u.l.grh.next_hdr =0x1B ; + qp->s_hdr.u.l.grh.hop_limit = + qp->remote_ah_attr.grh.hop_limit; +/* The SGID is 32-bit aligned. */ + qp->s_hdr.u.l.grh.sgid.global.subnet_prefix = + dev->gid_prefix; + qp->s_hdr.u.l.grh.sgid.global.interface_id = +ipath_layer_get_guid (dev->dd); + qp->s_hdr.u.l.grh.dgid = qp->remote_ah_attr.grh.dgid; + } + bth0 =ipath_layer_get_pkey (dev->dd, qp->s_pkey_index); + ohdr->u.aeth =ipath_compute_aeth (qp); +if (qp->s_ack_state >=OP (COMPARE_SWAP )) { + bth0 |=IB_OPCODE_ATOMIC_ACKNOWLEDGE <<24 ; + ohdr->u.at.atomic_ack_eth =cpu_to_be64 (qp->s_ack_atomic); + hwords +=sizeof (ohdr->u.at.atomic_ack_eth) /4 ; + } +else + bth0 |=OP (ACKNOWLEDGE ) <<24 ; + lrh0 |= qp->remote_ah_attr.sl <<4 ; + qp->s_hdr.lrh[0 ] =cpu_to_be16 (lrh0); +/* DEST LID */ + qp->s_hdr.lrh[1 ] =cpu_to_be16 (qp->remote_ah_attr.dlid); + qp->s_hdr.lrh[2 ] =cpu_to_be16 (hwords +SIZE_OF_CRC ); + qp->s_hdr.lrh[3 ] =cpu_to_be16 (ipath_layer_get_lid (dev->dd)); + ohdr->bth[0 ] =cpu_to_be32 (bth0); + ohdr->bth[1 ] =cpu_to_be32 (qp->remote_qpn); + ohdr->bth[2 ] =cpu_to_be32 (qp->s_ack_psn &IPS_PSN_MASK ); + +/* +* If we can send the ACK, clear the ACK state. +*/ +if (ipath_verbs_send (dev->dd, hwords, (u32 *) &qp->s_hdr, +0 ,NULL ) ==0 ) { + qp->s_ack_state =OP (ACKNOWLEDGE ); + dev->n_rc_qacks++; + dev->n_unicast_xmit++; + } +} + +/** +* ipath_restart_rc - back up requester to resend the last un-ACKed request +* @qp: the QP to restart +* @psn: packet sequence number for the request +* @wc: the work completion request +* +* The QP s_lock should be held. +*/ +void ipath_restart_rc (struct ipath_qp *qp,u32 psn,struct ib_wc *wc) +{ +struct ipath_swqe *wqe =get_swqe_ptr (qp, qp->s_last); +struct ipath_ibdev *dev; +u32 n; + +/* +* If there are no requests pending, we are done. +*/ +if (ipath_cmp24 (psn, qp->s_next_psn) >=0 || + qp->s_last == qp->s_tail) + goto done; + +if (qp->s_retry ==0 ) { + wc->wr_id = wqe->wr.wr_id; + wc->status =IB_WC_RETRY_EXC_ERR ; + wc->opcode = ib_ipath_wc_opcode[wqe->wr.opcode]; + wc->vendor_err =0 ; + wc->byte_len =0 ; + wc->qp_num = qp->ibqp.qp_num; + wc->src_qp = qp->remote_qpn; + wc->pkey_index =0 ; + wc->slid = qp->remote_ah_attr.dlid; + wc->sl = qp->remote_ah_attr.sl; + wc->dlid_path_bits =0 ; + wc->port_num =0 ; +ipath_sqerror_qp (qp, wc); +return ; + } + qp->s_retry--; + +/* +* Remove the QP from the timeout queue. +* Note: it may already have been removed by ipath_ib_timer(). +*/ + dev =to_idev (qp->ibqp.device); +spin_lock (&dev->pending_lock); +if (qp->timerwait.next !=LIST_POISON1 ) +list_del (&qp->timerwait); +spin_unlock (&dev->pending_lock); + +if (wqe->wr.opcode ==IB_WR_RDMA_READ ) + dev->n_rc_resends++; +else + dev->n_rc_resends += (int )qp->s_psn - (int )psn; + +/* +* If we are starting the request from the beginning, let the +* normal send code handle initialization. +*/ + qp->s_cur = qp->s_last; +if (ipath_cmp24 (psn, wqe->psn) <=0 ) { + qp->s_state =OP (SEND_LAST ); + qp->s_psn = wqe->psn; + }else { + n = qp->s_cur; +for (;;) { +if (++n == qp->s_size) + n =0 ; +if (n == qp->s_tail) { +if (ipath_cmp24 (psn, qp->s_next_psn) >=0 ) { + qp->s_cur = n; + wqe =get_swqe_ptr (qp, n); + } +break ; + } + wqe =get_swqe_ptr (qp, n); +if (ipath_cmp24 (psn, wqe->psn) <0 ) +break ; + qp->s_cur = n; + } + qp->s_psn = psn; + +/* +* Reset the state to restart in the middle of a request. +* Don't change the s_sge, s_cur_sge, or s_cur_size. +* See ipath_do_rc_send(). +*/ +switch (wqe->wr.opcode) { +case IB_WR_SEND : +case IB_WR_SEND_WITH_IMM : + qp->s_state =OP (RDMA_READ_RESPONSE_FIRST ); +break ; + +case IB_WR_RDMA_WRITE : +case IB_WR_RDMA_WRITE_WITH_IMM : + qp->s_state =OP (RDMA_READ_RESPONSE_LAST ); +break ; + +case IB_WR_RDMA_READ : + qp->s_state = +OP (RDMA_READ_RESPONSE_MIDDLE ); +break ; + +default : +/* +* This case shouldn't happen since its only +* one PSN per req. +*/ + qp->s_state =OP (SEND_LAST ); + } + } + +done: +tasklet_hi_schedule (&qp->s_task); +} + +/** +* do_rc_ack - process an incoming RC ACK +* @qp: the QP the ACK came in on +* @psn: the packet sequence number of the ACK +* @opcode: the opcode of the request that resulted in the ACK +* +* This is called from ipath_rc_rcv() to process an incoming RC ACK +* for the given QP. +* Called at interrupt level with the QP s_lock held. +* Returns 1 if OK, 0 if current operation should be aborted (NAK). +*/ +static int do_rc_ack (struct ipath_qp *qp,u32 aeth,u32 psn,int opcode) +{ +struct ipath_ibdev *dev =to_idev (qp->ibqp.device); +struct ib_wc wc; +struct ipath_swqe *wqe; + +/* +* Remove the QP from the timeout queue (or RNR timeout queue). +* If ipath_ib_timer() has already removed it, +* it's OK since we hold the QP s_lock and ipath_restart_rc() +* just won't find anything to restart if we ACK everything. +*/ +spin_lock (&dev->pending_lock); +if (qp->timerwait.next !=LIST_POISON1 ) +list_del (&qp->timerwait); +spin_unlock (&dev->pending_lock); + +/* +* Note that NAKs implicitly ACK outstanding SEND and +* RDMA write requests and implicitly NAK RDMA read and +* atomic requests issued before the NAK'ed request. +* The MSN won't include the NAK'ed request but will include +* an ACK'ed request(s). +*/ + wqe =get_swqe_ptr (qp, qp->s_last); + +/* Nothing is pending to ACK/NAK. */ +if (qp->s_last == qp->s_tail) +return 0 ; + +/* +* The MSN might be for a later WQE than the PSN indicates so +* only complete WQEs that the PSN finishes. +*/ +while (ipath_cmp24 (psn, wqe->lpsn) >=0 ) { +/* If we are ACKing a WQE, the MSN should be >= the SSN. */ +if (ipath_cmp24 (aeth, wqe->ssn) <0 ) +break ; +/* +* If this request is a RDMA read or atomic, and the ACK is +* for a later operation, this ACK NAKs the RDMA read or +* atomic. In other words, only a RDMA_READ_LAST or ONLY +* can ACK a RDMA read and likewise for atomic ops. Note +* that the NAK case can only happen if relaxed ordering is +* used and requests are sent after an RDMA read or atomic +* is sent but before the response is received. +*/ +if ((wqe->wr.opcode ==IB_WR_RDMA_READ && + opcode !=OP (RDMA_READ_RESPONSE_LAST )) || + ((wqe->wr.opcode ==IB_WR_ATOMIC_CMP_AND_SWP || + wqe->wr.opcode ==IB_WR_ATOMIC_FETCH_AND_ADD ) && + (opcode !=OP (ATOMIC_ACKNOWLEDGE ) || +ipath_cmp24 (wqe->psn, psn) !=0 ))) { +/* +* The last valid PSN seen is the previous +* request's. +*/ + qp->s_last_psn = wqe->psn -1 ; +/* Retry this request. */ +ipath_restart_rc (qp, wqe->psn, &wc); +/* +* No need to process the ACK/NAK since we are +* restarting an earlier request. +*/ +return 0 ; + } +/* Post a send completion queue entry if requested. */ +if (!test_bit (IPATH_S_SIGNAL_REQ_WR , &qp->s_flags) || + (wqe->wr.send_flags &IB_SEND_SIGNALED )) { + wc.wr_id = wqe->wr.wr_id; + wc.status =IB_WC_SUCCESS ; + wc.opcode = ib_ipath_wc_opcode[wqe->wr.opcode]; + wc.vendor_err =0 ; + wc.byte_len = wqe->length; + wc.qp_num = qp->ibqp.qp_num; + wc.src_qp = qp->remote_qpn; + wc.pkey_index =0 ; + wc.slid = qp->remote_ah_attr.dlid; + wc.sl = qp->remote_ah_attr.sl; + wc.dlid_path_bits =0 ; + wc.port_num =0 ; +ipath_cq_enter (to_icq (qp->ibqp.send_cq), &wc,0 ); + } + qp->s_retry = qp->s_retry_cnt; +/* +* If we are completing a request which is in the process +* of being resent, we can stop resending it since we know +* the responder has already seen it. +*/ +if (qp->s_last == qp->s_cur) { +if (++qp->s_cur >= qp->s_size) + qp->s_cur =0 ; + wqe =get_swqe_ptr (qp, qp->s_cur); + qp->s_state =OP (SEND_LAST ); + qp->s_psn = wqe->psn; + } +if (++qp->s_last >= qp->s_size) + qp->s_last =0 ; + wqe =get_swqe_ptr (qp, qp->s_last); +if (qp->s_last == qp->s_tail) +break ; + } + +switch (aeth >>29 ) { +case 0 :/* ACK */ + dev->n_rc_acks++; +/* If this is a partial ACK, reset the retransmit timer. */ +if (qp->s_last != qp->s_tail) { +spin_lock (&dev->pending_lock); +list_add_tail (&qp->timerwait, + &dev->pending[dev->pending_index]); +spin_unlock (&dev->pending_lock); + } +ipath_get_credit (qp, aeth); + qp->s_rnr_retry = qp->s_rnr_retry_cnt; + qp->s_retry = qp->s_retry_cnt; + qp->s_last_psn = psn; +return 1 ; + +case 1 :/* RNR NAK */ + dev->n_rnr_naks++; +if (qp->s_rnr_retry ==0 ) { +if (qp->s_last == qp->s_tail) +return 0 ; + + wc.status =IB_WC_RNR_RETRY_EXC_ERR ; + goto class_b; + } +if (qp->s_rnr_retry_cnt <7 ) + qp->s_rnr_retry--; +if (qp->s_last == qp->s_tail) +return 0 ; + +/* The last valid PSN seen is the previous request's. */ + qp->s_last_psn = wqe->psn -1 ; + +/* Restart this request after the RNR timeout. */ + wqe =get_swqe_ptr (qp, qp->s_last); + + dev->n_rc_resends += (int )qp->s_psn - (int )psn; + +/* +* If we are starting the request from the beginning, let +* the normal send code handle initialization. +*/ + qp->s_cur = qp->s_last; +if (ipath_cmp24 (psn, wqe->psn) <=0 ) { + qp->s_state =OP (SEND_LAST ); + qp->s_psn = wqe->psn; + }else { +u32 n; + + n = qp->s_cur; +for (;;) { +if (++n == qp->s_size) + n =0 ; +if (n == qp->s_tail) { +if (ipath_cmp24 (psn, + qp->s_next_psn) + >=0 ) { + qp->s_cur = n; + wqe =get_swqe_ptr (qp, n); + } +break ; + } + wqe =get_swqe_ptr (qp, n); +if (ipath_cmp24 (psn, wqe->psn) <0 ) +break ; + qp->s_cur = n; + } + qp->s_psn = psn; + +/* +* Set the state to restart in the middle of a +* request. Don't change the s_sge, s_cur_sge, or +* s_cur_size. See ipath_do_rc_send(). +*/ +switch (wqe->wr.opcode) { +case IB_WR_SEND : +case IB_WR_SEND_WITH_IMM : + qp->s_state = +OP (RDMA_READ_RESPONSE_FIRST ); +break ; + +case IB_WR_RDMA_WRITE : +case IB_WR_RDMA_WRITE_WITH_IMM : + qp->s_state = +OP (RDMA_READ_RESPONSE_LAST ); +break ; + +case IB_WR_RDMA_READ : + qp->s_state = +OP (RDMA_READ_RESPONSE_MIDDLE ); +break ; + +default : +/* +* This case shouldn't happen since its only +* one PSN per req. +*/ + qp->s_state =OP (SEND_LAST ); + } + } + + qp->s_rnr_timeout = + ib_ipath_rnr_table[(aeth >>IPS_AETH_CREDIT_SHIFT ) & +IPS_AETH_CREDIT_MASK ]; +ipath_insert_rnr_queue (qp); +return 0 ; + +case 3 :/* NAK */ +/* The last valid PSN seen is the previous request's. */ +if (qp->s_last != qp->s_tail) + qp->s_last_psn = wqe->psn -1 ; +switch ((aeth >>IPS_AETH_CREDIT_SHIFT ) & +IPS_AETH_CREDIT_MASK ) { +case 0 :/* PSN sequence error */ + dev->n_seq_naks++; +/* +* Back up to the responder's expected PSN. +* XXX Note that we might get a NAK in the +* middle of an RDMA READ response which +* terminates the RDMA READ. +*/ +if (qp->s_last == qp->s_tail) +break ; + +if (ipath_cmp24 (psn, wqe->psn) <0 ) +break ; + +/* Retry the request. */ +ipath_restart_rc (qp, psn, &wc); +break ; + +case 1 :/* Invalid Request */ + wc.status =IB_WC_REM_INV_REQ_ERR ; + dev->n_other_naks++; + goto class_b; + +case 2 :/* Remote Access Error */ + wc.status =IB_WC_REM_ACCESS_ERR ; + dev->n_other_naks++; + goto class_b; + +case 3 :/* Remote Operation Error */ + wc.status =IB_WC_REM_OP_ERR ; + dev->n_other_naks++; + class_b: + wc.wr_id = wqe->wr.wr_id; + wc.opcode = ib_ipath_wc_opcode[wqe->wr.opcode]; + wc.vendor_err =0 ; + wc.byte_len =0 ; + wc.qp_num = qp->ibqp.qp_num; + wc.src_qp = qp->remote_qpn; + wc.pkey_index =0 ; + wc.slid = qp->remote_ah_attr.dlid; + wc.sl = qp->remote_ah_attr.sl; + wc.dlid_path_bits =0 ; + wc.port_num =0 ; +ipath_sqerror_qp (qp, &wc); +break ; + +default : +/* Ignore other reserved NAK error codes */ + goto reserved; + } + qp->s_rnr_retry = qp->s_rnr_retry_cnt; +return 0 ; + +default :/* 2: reserved */ + reserved: +/* Ignore reserved NAK codes. */ +return 0 ; + } +} + +/** +* ipath_rc_rcv - process an incoming RC packet +* @dev: the device this packet came in on +* @hdr: the header of this packet +* @has_grh: true if the header has a GRH +* @data: the packet data +* @tlen: the packet length +* @qp: the QP for this packet +* +* This is called from ipath_qp_rcv() to process an incoming RC packet +* for the given QP. +* Called at interrupt level. +*/ +void ipath_rc_rcv (struct ipath_ibdev *dev,struct ipath_ib_header *hdr, +int has_grh,void *data,u32 tlen,struct ipath_qp *qp) +{ +struct ipath_other_headers *ohdr; +int opcode; +u32 hdrsize; +u32 psn; +u32 pad; +unsigned long flags; +struct ib_wc wc; +u32 pmtu =ib_mtu_enum_to_int (qp->path_mtu); +int diff; +struct ib_reth *reth; +int header_in_data; + +/* Check for GRH */ +if (!has_grh) { + ohdr = &hdr->u.oth; + hdrsize =8 +12 ;/* LRH + BTH */ + psn =be32_to_cpu (ohdr->bth[2 ]); + header_in_data =0 ; + }else { + ohdr = &hdr->u.l.oth; + hdrsize =8 +40 +12 ;/* LRH + GRH + BTH */ +/* +* The header with GRH is 60 bytes and the +* core driver sets the eager header buffer +* size to 56 bytes so the last 4 bytes of +* the BTH header (PSN) is in the data buffer. +*/ + header_in_data = +ipath_layer_get_rcvhdrentsize (dev->dd) ==16 ; +if (header_in_data) { + psn =be32_to_cpu (((u32 *) data)[0 ]); + data +=sizeof (u32); + }else + psn =be32_to_cpu (ohdr->bth[2 ]); + } +/* +* The opcode is in the low byte when its in network order +* (top byte when in host order). +*/ + opcode =be32_to_cpu (ohdr->bth[0 ]) >>24 ; + +/* +* Process responses (ACKs) before anything else. +* Note that the packet sequence number will be for something +* in the send work queue rather than the expected receive +* packet sequence number. In other words, this QP is the +* requester. +*/ +if (opcode >=OP (RDMA_READ_RESPONSE_FIRST ) && + opcode <=OP (ATOMIC_ACKNOWLEDGE )) { + +spin_lock_irqsave (&qp->s_lock, flags); + +/* Ignore invalid responses. */ +if (ipath_cmp24 (psn, qp->s_next_psn) >=0 ) + goto ack_done; + +/* Ignore duplicate responses. */ + diff =ipath_cmp24 (psn, qp->s_last_psn); +if (unlikely (diff <=0 )) { +/* Update credits for "ghost" ACKs */ +if (diff ==0 && + opcode ==OP (ACKNOWLEDGE )) { +if (!header_in_data) { + pad =be32_to_cpu (ohdr->u.aeth); + }else { + pad =be32_to_cpu ( + ((u32 *) data)[0 ]); + data +=sizeof (u32); + } +if ((pad >>29 ) ==0 ) +ipath_get_credit (qp, pad); + } + goto ack_done; + } + +switch (opcode) { +case OP (ACKNOWLEDGE ): +case OP (ATOMIC_ACKNOWLEDGE ): +case OP (RDMA_READ_RESPONSE_FIRST ): +if (!header_in_data) + pad =be32_to_cpu (ohdr->u.aeth); +else { + pad =be32_to_cpu (((u32 *) data)[0 ]); + data +=sizeof (u32); + } +if (opcode ==OP (ATOMIC_ACKNOWLEDGE )) + *(u64 *) qp->s_sge.sge.vaddr = + *(u64 *) data; +if (!do_rc_ack (qp, pad, psn, opcode) || + opcode !=OP (RDMA_READ_RESPONSE_FIRST )) + goto ack_done; + hdrsize +=4 ; +/* +* do_rc_ack() has already checked the PSN so skip +* the sequence check. +*/ + goto rdma_read; + +case OP (RDMA_READ_RESPONSE_MIDDLE ): +/* no AETH, no ACK */ +if (unlikely (ipath_cmp24 (psn, + qp->s_last_psn +1 ))) { + dev->n_rdma_seq++; +ipath_restart_rc (qp, qp->s_last_psn +1 , + &wc); + goto ack_done; + } + rdma_read: +if (unlikely (qp->s_state != +OP (RDMA_READ_REQUEST ))) + goto ack_done; +if (unlikely (tlen != (hdrsize + pmtu +4 ))) + goto ack_done; +if (unlikely (pmtu >= qp->s_len)) + goto ack_done; +/* We got a response so update the timeout. */ +if (unlikely (qp->s_last == qp->s_tail || +get_swqe_ptr (qp, qp->s_last)->wr.opcode != +IB_WR_RDMA_READ )) + goto ack_done; +spin_lock (&dev->pending_lock); +if (qp->s_rnr_timeout ==0 && + qp->timerwait.next !=LIST_POISON1 ) { +list_move_tail ( + &qp->timerwait, + &dev->pending[dev->pending_index]); + } +spin_unlock (&dev->pending_lock); +/* +* Update the RDMA receive state but do the copy w/o +* holding the locks and blocking interrupts. +* XXX Yet another place that affects relaxed +* RDMA order since we don't want s_sge modified. +*/ + qp->s_len -= pmtu; + qp->s_last_psn = psn; +spin_unlock_irqrestore (&qp->s_lock, flags); +ipath_copy_sge (&qp->s_sge, data, pmtu); +return ; + +case OP (RDMA_READ_RESPONSE_LAST ): +/* ACKs READ req. */ +if (unlikely (ipath_cmp24 (psn, + qp->s_last_psn +1 ))) { + dev->n_rdma_seq++; +ipath_restart_rc (qp, qp->s_last_psn +1 , + &wc); + goto ack_done; + } +/* FALLTHROUGH */ +case OP (RDMA_READ_RESPONSE_ONLY ): +if (unlikely (qp->s_state != +OP (RDMA_READ_REQUEST ))) + goto ack_done; +/* +* Get the number of bytes the message was padded +* by. +*/ + pad = (be32_to_cpu (ohdr->bth[0 ]) >>20 ) &3 ; +/* +* Check that the data size is >= 1 && <= pmtu. +* Remember to account for the AETH header (4) and +* ICRC (4). +*/ +if (unlikely (tlen <= (hdrsize + pad +8 ))) { +/* +* XXX Need to generate an error CQ +* entry. +*/ + goto ack_done; + } + tlen -= hdrsize + pad +8 ; +if (unlikely (tlen != qp->s_len)) { +/* +* XXX Need to generate an error CQ +* entry. +*/ + goto ack_done; + } +if (!header_in_data) { + pad =be32_to_cpu (ohdr->u.aeth); + }else { + pad =be32_to_cpu (((u32 *) data)[0 ]); + data +=sizeof (u32); + } +ipath_copy_sge (&qp->s_sge, data, tlen); +if (do_rc_ack ( + qp, pad, psn, +OP (RDMA_READ_RESPONSE_LAST ))) { +/* +* Change the state so we contimue +* processing new requests. +*/ + qp->s_state =OP (SEND_LAST ); + } + goto ack_done; + } + ack_done: +spin_unlock_irqrestore (&qp->s_lock, flags); +return ; + } + +spin_lock_irqsave (&qp->r_rq.lock, flags); + +/* Compute 24 bits worth of difference. */ + diff =ipath_cmp24 (psn, qp->r_psn); +if (unlikely (diff)) { +if (diff >0 ) { +/* +* Packet sequence error. +* A NAK will ACK earlier sends and RDMA writes. +* Don't queue the NAK if a RDMA read, atomic, or +* NAK is pending though. +*/ +spin_lock (&qp->s_lock); +if ((qp->s_ack_state >= +OP (RDMA_READ_REQUEST ) && + qp->s_ack_state !=IB_OPCODE_ACKNOWLEDGE ) || + qp->s_nak_state !=0 ) { +spin_unlock (&qp->s_lock); + goto done; + } + qp->s_ack_state =OP (SEND_ONLY ); + qp->s_nak_state =IB_NAK_PSN_ERROR ; +/* Use the expected PSN. */ + qp->s_ack_psn = qp->r_psn; + goto resched; + } + +/* +* Handle a duplicate request. Don't re-execute SEND, RDMA +* write or atomic op. Don't NAK errors, just silently drop +* the duplicate request. Note that r_sge, r_len, and +* r_rcv_len may be in use so don't modify them. +* +* We are supposed to ACK the earliest duplicate PSN but we +* can coalesce an outstanding duplicate ACK. We have to +* send the earliest so that RDMA reads can be restarted at +* the requester's expected PSN. +*/ +spin_lock (&qp->s_lock); +if (qp->s_ack_state !=IB_OPCODE_ACKNOWLEDGE && +ipath_cmp24 (psn, qp->s_ack_psn) >=0 ) { +if (qp->s_ack_state <IB_OPCODE_RDMA_READ_REQUEST ) + qp->s_ack_psn = psn; +spin_unlock (&qp->s_lock); + goto done; + } +switch (opcode) { +case OP (RDMA_READ_REQUEST ): +/* +* We have to be careful to not change s_rdma_sge +* while ipath_do_rc_send() is using it and not +* holding the s_lock. +*/ +if (qp->s_ack_state !=OP (ACKNOWLEDGE ) && + qp->s_ack_state >= +IB_OPCODE_RDMA_READ_REQUEST ) { +spin_unlock (&qp->s_lock); + dev->n_rdma_dup_busy++; + goto done; + } +/* RETH comes after BTH */ +if (!header_in_data) + reth = &ohdr->u.rc.reth; +else { + reth = (struct ib_reth *)data; + data +=sizeof (*reth); + } + qp->s_rdma_len =be32_to_cpu (reth->length); +if (qp->s_rdma_len !=0 ) { +u32 rkey =be32_to_cpu (reth->rkey); +u64 vaddr =be64_to_cpu (reth->vaddr); + +/* +* Address range must be a subset of the +* original request and start on pmtu +* boundaries. +*/ +if (unlikely (!ipath_rkey_ok ( + dev, + &qp->s_rdma_sge, + qp->s_rdma_len, + vaddr, rkey, +IB_ACCESS_REMOTE_READ ))) + goto done; + }else { + qp->s_rdma_sge.sg_list =NULL ; + qp->s_rdma_sge.num_sge =0 ; + qp->s_rdma_sge.sge.mr =NULL ; + qp->s_rdma_sge.sge.vaddr =NULL ; + qp->s_rdma_sge.sge.length =0 ; + qp->s_rdma_sge.sge.sge_length =0 ; + } +break ; + +case OP (COMPARE_SWAP ): +case OP (FETCH_ADD ): +/* +* Check for the PSN of the last atomic operations +* performed and resend the result if found. +*/ +if ((psn &IPS_PSN_MASK ) != qp->r_atomic_psn) { +spin_unlock (&qp->s_lock); + goto done; + } + qp->s_ack_atomic = qp->r_atomic_data; +break ; + } + qp->s_ack_state = opcode; + qp->s_nak_state =0 ; + qp->s_ack_psn = psn; + goto resched; + } + +/* Check for opcode sequence errors. */ +switch (qp->r_state) { +case OP (SEND_FIRST ): +case OP (SEND_MIDDLE ): +if (opcode ==OP (SEND_MIDDLE ) || + opcode ==OP (SEND_LAST ) || + opcode ==OP (SEND_LAST_WITH_IMMEDIATE )) +break ; + nack_inv: +/* +* A NAK will ACK earlier sends and RDMA writes. +* Don't queue the NAK if a RDMA read, atomic, or +* NAK is pending though. +*/ +spin_lock (&qp->s_lock); +if (qp->s_ack_state >=OP (RDMA_READ_REQUEST ) && + qp->s_ack_state !=IB_OPCODE_ACKNOWLEDGE ) { +spin_unlock (&qp->s_lock); + goto done; + } +/* XXX Flush WQEs */ + qp->state =IB_QPS_ERR ; + qp->s_ack_state =OP (SEND_ONLY ); + qp->s_nak_state =IB_NAK_INVALID_REQUEST ; + qp->s_ack_psn = qp->r_psn; + goto resched; + +case OP (RDMA_WRITE_FIRST ): +case OP (RDMA_WRITE_MIDDLE ): +if (opcode ==OP (RDMA_WRITE_MIDDLE ) || + opcode ==OP (RDMA_WRITE_LAST ) || + opcode ==OP (RDMA_WRITE_LAST_WITH_IMMEDIATE )) +break ; + goto nack_inv; + +case OP (RDMA_READ_REQUEST ): +case OP (COMPARE_SWAP ): +case OP (FETCH_ADD ): +/* +* Drop all new requests until a response has been sent. +* A new request then ACKs the RDMA response we sent. +* Relaxed ordering would allow new requests to be +* processed but we would need to keep a queue +* of rwqe's for all that are in progress. +* Note that we can't RNR NAK this request since the RDMA +* READ or atomic response is already queued to be sent +* (unless we implement a response send queue). +*/ + goto done; + +default : +if (opcode ==OP (SEND_MIDDLE ) || + opcode ==OP (SEND_LAST ) || + opcode ==OP (SEND_LAST_WITH_IMMEDIATE ) || + opcode ==OP (RDMA_WRITE_MIDDLE ) || + opcode ==OP (RDMA_WRITE_LAST ) || + opcode ==OP (RDMA_WRITE_LAST_WITH_IMMEDIATE )) + goto nack_inv; +break ; + } + + wc.imm_data =0 ; + wc.wc_flags =0 ; + +/* OK, process the packet. */ +switch (opcode) { +case OP (SEND_FIRST ): +if (!ipath_get_rwqe (qp,0 )) { + rnr_nak: +/* +* A RNR NAK will ACK earlier sends and RDMA writes. +* Don't queue the NAK if a RDMA read or atomic +* is pending though. +*/ +spin_lock (&qp->s_lock); +if (qp->s_ack_state >= +OP (RDMA_READ_REQUEST ) && + qp->s_ack_state !=IB_OPCODE_ACKNOWLEDGE ) { +spin_unlock (&qp->s_lock); + goto done; + } + qp->s_ack_state =OP (SEND_ONLY ); + qp->s_nak_state =IB_RNR_NAK | qp->s_min_rnr_timer; + qp->s_ack_psn = qp->r_psn; + goto resched; + } + qp->r_rcv_len =0 ; +/* FALLTHROUGH */ +case OP (SEND_MIDDLE ): +case OP (RDMA_WRITE_MIDDLE ): + send_middle: +/* Check for invalid length PMTU or posted rwqe len. */ +if (unlikely (tlen != (hdrsize + pmtu +4 ))) + goto nack_inv; + qp->r_rcv_len += pmtu; +if (unlikely (qp->r_rcv_len > qp->r_len)) + goto nack_inv; +ipath_copy_sge (&qp->r_sge, data, pmtu); +break ; + +case OP (RDMA_WRITE_LAST_WITH_IMMEDIATE ): +/* consume RWQE */ +if (!ipath_get_rwqe (qp,1 )) + goto rnr_nak; + goto send_last_imm; + +case OP (SEND_ONLY ): +case OP (SEND_ONLY_WITH_IMMEDIATE ): +if (!ipath_get_rwqe (qp,0 )) + goto rnr_nak; + qp->r_rcv_len =0 ; +if (opcode ==OP (SEND_ONLY )) + goto send_last; +/* FALLTHROUGH */ +case OP (SEND_LAST_WITH_IMMEDIATE ): + send_last_imm: +if (header_in_data) { + wc.imm_data = *(u32 *) data; + data +=sizeof (u32); + }else { +/* Immediate data comes after BTH */ + wc.imm_data = ohdr->u.imm_data; + } + hdrsize +=4 ; + wc.wc_flags =IB_WC_WITH_IMM ; +/* FALLTHROUGH */ +case OP (SEND_LAST ): +case OP (RDMA_WRITE_LAST ): + send_last: +/* Get the number of bytes the message was padded by. */ + pad = (be32_to_cpu (ohdr->bth[0 ]) >>20 ) &3 ; +/* Check for invalid length. */ +/* XXX LAST len should be >= 1 */ +if (unlikely (tlen < (hdrsize + pad +4 ))) + goto nack_inv; +/* Don't count the CRC. */ + tlen -= (hdrsize + pad +4 ); + wc.byte_len = tlen + qp->r_rcv_len; +if (unlikely (wc.byte_len > qp->r_len)) { + goto nack_inv; + } +/* XXX Need to free SGEs */ +ipath_copy_sge (&qp->r_sge, data, tlen); +atomic_inc (&qp->msn); +if (opcode ==OP (RDMA_WRITE_LAST ) || + opcode ==OP (RDMA_WRITE_ONLY )) +break ; + wc.wr_id = qp->r_wr_id; + wc.status =IB_WC_SUCCESS ; + wc.opcode =IB_WC_RECV ; + wc.vendor_err =0 ; + wc.qp_num = qp->ibqp.qp_num; + wc.src_qp = qp->remote_qpn; + wc.pkey_index =0 ; + wc.slid = qp->remote_ah_attr.dlid; + wc.sl = qp->remote_ah_attr.sl; + wc.dlid_path_bits =0 ; + wc.port_num =0 ; +/* Signal completion event if the solicited bit is set. */ +ipath_cq_enter (to_icq (qp->ibqp.recv_cq), &wc, + ohdr->bth[0 ] & +__constant_cpu_to_be32 (1 <<23 )); +break ; + +case OP (RDMA_WRITE_FIRST ): +case OP (RDMA_WRITE_ONLY ): +case OP (RDMA_WRITE_ONLY_WITH_IMMEDIATE ): +/* consume RWQE */ +/* RETH comes after BTH */ +if (!header_in_data) + reth = &ohdr->u.rc.reth; +else { + reth = (struct ib_reth *)data; + data +=sizeof (*reth); + } + hdrsize +=sizeof (*reth); + qp->r_len =be32_to_cpu (reth->length); + qp->r_rcv_len =0 ; +if (qp->r_len !=0 ) { +u32 rkey =be32_to_cpu (reth->rkey); +u64 vaddr =be64_to_cpu (reth->vaddr); + +/* Check rkey & NAK */ +if (unlikely (!ipath_rkey_ok ( + dev, &qp->r_sge, + qp->r_len, + vaddr, rkey, +IB_ACCESS_REMOTE_WRITE ))) { + nack_acc: +/* +* A NAK will ACK earlier sends and RDMA +* writes. Don't queue the NAK if a RDMA +* read, atomic, or NAK is pending though. +*/ +spin_lock (&qp->s_lock); +if (qp->s_ack_state >= +OP (RDMA_READ_REQUEST ) && + qp->s_ack_state != +IB_OPCODE_ACKNOWLEDGE ) { +spin_unlock (&qp->s_lock); + goto done; + } +/* XXX Flush WQEs */ + qp->state =IB_QPS_ERR ; + qp->s_ack_state =OP (RDMA_WRITE_ONLY ); + qp->s_nak_state = +IB_NAK_REMOTE_ACCESS_ERROR ; + qp->s_ack_psn = qp->r_psn; + goto resched; + } + }else { + qp->r_sge.sg_list =NULL ; + qp->r_sge.sge.mr =NULL ; + qp->r_sge.sge.vaddr =NULL ; + qp->r_sge.sge.length =0 ; + qp->r_sge.sge.sge_length =0 ; + } +if (unlikely (!(qp->qp_access_flags & +IB_ACCESS_REMOTE_WRITE ))) + goto nack_acc; +if (opcode ==OP (RDMA_WRITE_FIRST )) + goto send_middle; +else if (opcode ==OP (RDMA_WRITE_ONLY )) + goto send_last; +if (!ipath_get_rwqe (qp,1 )) + goto rnr_nak; + goto send_last_imm; + +case OP (RDMA_READ_REQUEST ): +/* RETH comes after BTH */ +if (!header_in_data) + reth = &ohdr->u.rc.reth; +else { + reth = (struct ib_reth *)data; + data +=sizeof (*reth); + } +spin_lock (&qp->s_lock); +if (qp->s_ack_state !=OP (ACKNOWLEDGE ) && + qp->s_ack_state >=IB_OPCODE_RDMA_READ_REQUEST ) { +spin_unlock (&qp->s_lock); + goto done; + } + qp->s_rdma_len =be32_to_cpu (reth->length); +if (qp->s_rdma_len !=0 ) { +u32 rkey =be32_to_cpu (reth->rkey); +u64 vaddr =be64_to_cpu (reth->vaddr); + +/* Check rkey & NAK */ +if (unlikely (!ipath_rkey_ok ( + dev, &qp->s_rdma_sge, + qp->s_rdma_len, + vaddr, rkey, +IB_ACCESS_REMOTE_READ ))) { +spin_unlock (&qp->s_lock); + goto nack_acc; + } +/* +* Update the next expected PSN. We add 1 later +* below, so only add the remainder here. +*/ +if (qp->s_rdma_len > pmtu) + qp->r_psn += (qp->s_rdma_len -1 ) / pmtu; + }else { + qp->s_rdma_sge.sg_list =NULL ; + qp->s_rdma_sge.num_sge =0 ; + qp->s_rdma_sge.sge.mr =NULL ; + qp->s_rdma_sge.sge.vaddr =NULL ; + qp->s_rdma_sge.sge.length =0 ; + qp->s_rdma_sge.sge.sge_length =0 ; + } +if (unlikely (!(qp->qp_access_flags & +IB_ACCESS_REMOTE_READ ))) + goto nack_acc; +/* +* We need to increment the MSN here instead of when we +* finish sending the result since a duplicate request would +* increment it more than once. +*/ +atomic_inc (&qp->msn); + qp->s_ack_state = opcode; + qp->s_nak_state =0 ; + qp->s_ack_psn = psn; + qp->r_psn++; + qp->r_state = opcode; + goto rdmadone; + +case OP (COMPARE_SWAP ): +case OP (FETCH_ADD ):{ +struct ib_atomic_eth *ateth; +u64 vaddr; +u64 sdata; +u32 rkey; + +if (!header_in_data) + ateth = &ohdr->u.atomic_eth; +else { + ateth = (struct ib_atomic_eth *)data; + data +=sizeof (*ateth); + } + vaddr =be64_to_cpu (ateth->vaddr); +if (unlikely (vaddr & (sizeof (u64) -1 ))) + goto nack_inv; + rkey =be32_to_cpu (ateth->rkey); +/* Check rkey & NAK */ +if (unlikely (!ipath_rkey_ok (dev, &qp->r_sge, +sizeof (u64), vaddr, rkey, +IB_ACCESS_REMOTE_ATOMIC ))) + goto nack_acc; +if (unlikely (!(qp->qp_access_flags & +IB_ACCESS_REMOTE_ATOMIC ))) + goto nack_acc; +/* Perform atomic OP and save result. */ + sdata =be64_to_cpu (ateth->swap_data); +spin_lock (&dev->pending_lock); + qp->r_atomic_data = *(u64 *) qp->r_sge.sge.vaddr; +if (opcode ==OP (FETCH_ADD )) + *(u64 *) qp->r_sge.sge.vaddr = + qp->r_atomic_data + sdata; +else if (qp->r_atomic_data == +be64_to_cpu (ateth->compare_data)) + *(u64 *) qp->r_sge.sge.vaddr = sdata; +spin_unlock (&dev->pending_lock); +atomic_inc (&qp->msn); + qp->r_atomic_psn = psn &IPS_PSN_MASK ; + psn |=1 <<31 ; +break ; + } + +default : +/* Drop packet for unknown opcodes. */ +spin_unlock_irqrestore (&qp->r_rq.lock, flags); +return ; + } + qp->r_psn++; + qp->r_state = opcode; +/* Send an ACK if requested or required. */ +if (psn & (1 <<31 )) { +/* +* Coalesce ACKs unless there is a RDMA READ or +* ATOMIC pending. +*/ +spin_lock (&qp->s_lock); +if (qp->s_ack_state ==OP (ACKNOWLEDGE ) || + qp->s_ack_state <IB_OPCODE_RDMA_READ_REQUEST ) { + qp->s_ack_state = opcode; + qp->s_nak_state =0 ; + qp->s_ack_psn = psn; + qp->s_ack_atomic = qp->r_atomic_data; + goto resched; + } +spin_unlock (&qp->s_lock); + } +done: +spin_unlock_irqrestore (&qp->r_rq.lock, flags); +return ; + +resched: +/* +* Try to send ACK right away but not if ipath_do_rc_send() is +* active. +*/ +if (qp->s_hdrwords ==0 && + (qp->s_ack_state <IB_OPCODE_RDMA_READ_REQUEST || + qp->s_ack_state >=IB_OPCODE_COMPARE_SWAP )) +send_rc_ack (qp); + +rdmadone: +spin_unlock (&qp->s_lock); +spin_unlock_irqrestore (&qp->r_rq.lock, flags); + +/* Call ipath_do_rc_send() in another thread. */ +tasklet_hi_schedule (&qp->s_task); +}
Re: [PATCH 10 of 18] ipath - support for userspace apps using core driver
In reply to Bryan O'SullivanQuoted 31 lines · Bryan O'Sullivan
+ /*
+ * This code is present to allow a knowledgeable person to
+ * specify the layout of processes to processors before opening
+ * this driver, and then we'll assign the process to the "closest"
+ * HT-400 to that processor (we assume reasonable connectivity,
+ * for now). This code assumes that if affinity has been set
+ * before this point, that at most one cpu is set; for now this
+ * is reasonable. I check for bothcpus_empty()andcpus_full(),
+ * in case some kernel variant sets none of the bits when no
+ * affinity is set. 2.6.11 and 12 kernels have all present
+ * cpus set. Some day we'll have to fix it up further to handle
+ * a cpu subset. This algorithm fails for two HT-400's connected
+ * in tunnel fashion. Eventually this needs real topology
+ * information. There may be some issues with dual core numbering
+ * as well. This needs more work prior to release.
+ */
+ if (!cpus_empty(current->cpus_allowed) &&
+ !cpus_full(current->cpus_allowed)) {
+ int ncpus =num_online_cpus(), curcpu = -1;
+ for (i = 0; i < ncpus; i++)
+ if (cpu_isset(i, current->cpus_allowed)) {
+ ipath_cdbg(PROC, "%s[%u] affinity set for "
+ "cpu %d\n",current->comm,
+current->pid, i);
+ curcpu = i;
+ }
+ if (curcpu != -1) {
+ if (npresent) {
+ prefunit = curcpu / (ncpus / npresent);
+ ipath_dbg("%s[%u] %d chips, %d cpus, "
Quoted 7 lines
+ "%d cpus/chip, select unit %d\n", + current->comm, current->pid, + npresent, ncpus, ncpus / npresent, + prefunit);+ }
+ }
+ }
CPU topology is available in sysfs - it shouild be possible to push policy decisions like this up to userspace. If the topology info is insufficient, we can add to it.
Re: [PATCH 8 of 18] ipath - sysfs and ipathfs support for core driver
In reply to Bryan O'SullivanQuoted 18 lines · Bryan O'Sullivan
drivers/infiniband/hw/ipath/ipath_sysfs.c new file +18
-0+int ipath_driver_create_group (struct device_driver *drv) +{ +int ret; + +if (!drv->kobj.dentry) { + ret = -ENODEV ; + goto bail; + } + + ret =sysfs_create_group (&drv->kobj, &driver_attr_group); +if (ret) + goto bail; + + ret =sysfs_create_group (&drv->kobj, &driver_stat_attr_group); +if (ret) +sysfs_remove_group (&drv->kobj, &driver_attr_group); + +bail:
drivers/infiniband/hw/ipath/ipath_sysfs.c line 730
Quoted 10 lines
drivers/infiniband/hw/ipath/ipath_sysfs.c new file +10
-0+return ret; +} + +void ipath_driver_remove_group (struct device_driver *drv) +{ +if (drv->kobj.dentry) { +sysfs_remove_group (&drv->kobj, &driver_stat_attr_group); +sysfs_remove_group (&drv->kobj, &driver_attr_group); + } +}
Why are you testing kobj.dentry in these functions? That test would not have been valid in the mainline kernel until a day or so ago, so you couldn't have ever hit that path (dentry being NULL that is.)
Or did you do that because of something odd you saw in sysfs?
Unless you did, I don't think you need these tests.
Oh, and I like your new filesystem, but where do you propose that it be mounted?
Quoted 8 lines
drivers/infiniband/hw/ipath/ipath_sysfs.c new file +8
-0+int ipath_device_create_group (struct device *dev,struct ipath_devdata *dd) +{ +int ret; +char unit[5 ]; + + ret =sysfs_create_group (&dev->kobj, &dev_attr_group); +if (ret) + goto bail;
drivers/infiniband/hw/ipath/ipath_sysfs.c line 749
Quoted 10 lines
drivers/infiniband/hw/ipath/ipath_sysfs.c new file +10
-0+ + ret =sysfs_create_group (&dev->kobj, &dev_counter_attr_group); +if (ret) + goto bail; + +snprintf (unit,sizeof (unit),"%02d" , dd->ipath_unit); + ret =sysfs_create_link (&dev->driver->kobj, &dev->kobj, unit); +bail: +return ret; +}
You leak a group if the second call to sysfs_create_group() fails for some reason.
thanks,
greg k-h
Re: [PATCH 8 of 18] ipath - sysfs and ipathfs support for core driver
In reply to Bryan O'SullivanQuoting r. Bryan O'Sullivan <[email protected]>:
Quoted 8 lines
Subject: [PATCH 8 of 18] ipath - sysfs and ipathfs support for core driver
The ipathfs filesystem contains files that are not appropriate for sysfs, because they contain binary data. The hierarchy is simple; the top-level directory contains driver-wide attribute files, while numbered subdirectories contain per-device attribute files.
Signed-off-by Bryan O'Sullivan <[email protected]>
.....
Quoted 20 lines
drivers/infiniband/hw/ipath/ipath_fs.c new file +20
-0+static ssize_t atomic_node_info_read (struct file *file,char __user *buf, +size_t count,loff_t *ppos) +{ +u32 nodeinfo[10 ]; +struct ipath_devdata *dd; + + dd = file->f_dentry->d_inode->u.generic_ip; + + nodeinfo[0 ] =/* BaseVersion is SMA */ +/* ClassVersion is SMA */ + (1 <<8 )/* NodeType */ + | (1 <<0 );/* NumPorts */ + nodeinfo[1 ] = (u32) (dd->ipath_guid >>32 ); + nodeinfo[2 ] = (u32) (dd->ipath_guid &0xffffffff ); +/* PortGUID == SystemImageGUID for us */ + nodeinfo[3 ] = nodeinfo[1 ]; +/* PortGUID == SystemImageGUID for us */ + nodeinfo[4 ] = nodeinfo[2 ]; +/* PortGUID == NodeGUID for us */ + nodeinfo[5 ] = nodeinfo[3 ];
drivers/infiniband/hw/ipath/ipath_fs.c line 162
Quoted 10 lines
drivers/infiniband/hw/ipath/ipath_fs.c new file +10
-0+/* PortGUID == NodeGUID for us */ + nodeinfo[6 ] = nodeinfo[4 ]; + nodeinfo[7 ] = (4 <<16 )/* we support 4 pkeys */ + | (dd->ipath_deviceid <<0 ); +/* our chip version as 16 bits major, 16 bits minor */ + nodeinfo[8 ] = dd->ipath_minrev | (dd->ipath_majrev <<16 ); + nodeinfo[9 ] = (dd->ipath_unit <<24 ) | (dd->ipath_vendorid <<0 ); + +return simple_read_from_buffer (buf, count, ppos, nodeinfo, +sizeof nodeinfo);
InfiniBand core already exposes these attributes to userspace, see drivers/infiniband/core/sysfs.c
Signature · 2 lines
Michael S. Tsirkin Staff Engineer, Mellanox Technologies
Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
In reply to Bryan O'SullivanQuoting r. Bryan O'Sullivan <[email protected]>:
Quoted 3 lines
The
ipath_sma.cfile supports a lightweight userspace subnet management agent (SMA). This is used in deployments (such as HPC clusters) where a full Infiniband protocol stack is not needed.
Could you please explain why is this useful? Users could not care less - they never have to touch an SMA. The "full" Infiniband stack is very lightweight and already includes an SMA, and it already includes ib_umad module which makes it possible to implement subnet management in userspace should you want to.
Signature · 2 lines
Michael S. Tsirkin Staff Engineer, Mellanox Technologies
Re: [PATCH 10 of 18] ipath - support for userspace apps using core driver
In reply to Andrew MortonQuoted 2 lines · Andrew Morton
CPU topology is available in sysfs - it shouild be possible to push policy decisions like this up to userspace.
We covered this in an earlier round of submission, but I should have updated the inline comments.
While we expose a way for userspace to open an explicit device based on its knowledge of topology, I think we need a "take your best shot" minor number, too, which is what this is.
If we *don't* provide one, userspace can end up with exactly the kinds of messy race situations that used to be seen with ptys before /dev/ptmx and /dev/pts came along.
<b
Re: [PATCH 8 of 18] ipath - sysfs and ipathfs support for core driver
In reply to Greg KHQuoted 1 line · Greg KH
Why are you testing kobj.dentry in these functions?
I think this is a holdover from an earlier version of the driver that didn't clean up properly after driver registration failed. In other words, those tests are no longer needed. Thanks for spotting this.
Quoted 2 lines
Oh, and I like your new filesystem, but where do you propose that it be mounted?
I don't have any good candidates in mind. In our development environment, we're mounting it in /ipath, but that doesn't seem like a good long-term name. Do you have any suggestions?
Quoted 2 lines
You leak a group if the second call to
sysfs_create_group()fails for some reason.
Thanks.
<b
Re: [PATCH 8 of 18] ipath - sysfs and ipathfs support for core driver
In reply to Michael S. TsirkinQuoted 2 lines · Michael S. Tsirkin
InfiniBand core already exposes these attributes to userspace, see
drivers/infiniband/core/sysfs.c
This is needed for cases where the Infiniband stack isn't present.
<b
Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
In reply to Michael S. TsirkinQuoted 2 lines · Michael S. Tsirkin
Could you please explain why is this useful? Users could not care less - they never have to touch an SMA.
We have customers who use our driver who do not want a full IB stack present, for example in embedded environments.
<b
Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
Quoting r. Bryan O'Sullivan <[email protected]>:
Quoted 5 lines
Quoted 2 lines
Could you please explain why is this useful? Users could not care less - they never have to touch an SMA.
We have customers who use our driver who do not want a full IB stack present, for example in embedded environments.
I understand they do, but they could just use the parts of IB stack and never notice. In my experience, embedded systems are typically diskless - why is a userspace SMA better than kernel-level one for them? The advantage would be everyone using a single kernel/user interface, common utilities for management, diagnostics ... I could go on.
So what's your point? Memory usage? Let's take a look:
ib_mad is the IB stack module that includes between other things the kernel-level SMA (BTW, if necessary, you should be able to split it out so that it is only loaded on demand):
I think IB stack is modest, as core modules go. Here's how a loaded IB stack looks like on my system:
Module Size Used by ib_mad 36260 2 ib_ipath,ib_mthca ib_core 46080 3 ib_ipath,ib_mthca,ib_mad
So there are *maximum* 82K code to save. This is a 64-bit system, I think embedded systems are usually 32 bit so there'll be just 41K.
And I don't believe you can save much since as a solution you seem to have re-implemented the full IB stack in your low level driver:
Module Size Used by ib_ipath 79256 0 ipath_core 159764 1 ib_ipath
By contrast, a low-level which doesn't reimplement IB core is just a bit above 100K.
Signature · 2 lines
Michael S. Tsirkin Staff Engineer, Mellanox Technologies
Re: [PATCH 8 of 18] ipath - sysfs and ipathfs support for core driver
In reply to Bryan O'SullivanQuoting r. Bryan O'Sullivan <[email protected]>:
Quoted 4 lines
Quoted 2 lines
InfiniBand core already exposes these attributes to userspace, see
drivers/infiniband/core/sysfs.cThis is needed for cases where the Infiniband stack isn't present.
But re-implementing same thing with a different kernel-user interface and pushing it into a low-level driver does not strike me like a sane solution.
Signature · 2 lines
Michael S. Tsirkin Staff Engineer, Mellanox Technologies
Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
In reply to Michael S. TsirkinQuoted 2 lines · Michael S. Tsirkin
I understand they do, but they could just use the parts of IB stack and never notice.
No, in some cases they want there to not be an IB stack present, which is not the same thing at all as not caring if it's there.
Quoted 1 line
I think IB stack is modest, as core modules go.
I don't understand why you persist on this point. We have a need for an SMA that is not tied to the IB stack. The kernel code to support it is about 500 lines long, about 2% of the driver.
Quoted 2 lines
And I don't believe you can save much since as a solution you seem to have re-implemented the full IB stack in your low level driver:
No, we haven't. The IB protocols are implemented in the ib_ipath module, not the core driver.
<b
Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
Quoting r. Bryan O'Sullivan <[email protected]>:
Quoted 5 lines
Quoted 2 lines
I understand they do, but they could just use the parts of IB stack and never notice.
No, in some cases they want there to not be an IB stack present, which is not the same thing at all as not caring if it's there.
OK. I gather that much. But why? I'm just trying to figure out the motivation. Might this be interesting for our drivers too?
Signature · 2 lines
Michael S. Tsirkin Staff Engineer, Mellanox Technologies
Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
Quoted 1 line · Michael S. Tsirkin
OK. I gather that much. But why? I'm just trying to figure out the motivation.
I don't know for sure, but it's repeated at me in vehement terms when I ask, so someone cares :-) I'll try to find an actual compelling answer when my coworkers are awake.
<b
Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
In reply to Bryan O'SullivanBryan> We have customers who use our driver who do not want a full Bryan> IB stack present, for example in embedded environments.
I think it's fine that your low-level driver can work without ib_core, ib_mad and the rest loaded. But I still (after all this discussion) don't understand why you need to have two SMA implementations to handle this along with the code to switch between the two modes like:
drivers/infiniband/hw/ipath/ipath_sma.c line 152
Quoted 7 lines
drivers/infiniband/hw/ipath/ipath_sma.c new file +7
-0+list_for_each_entry (dd, &ipath_dev_list, ipath_list) { +if (!(dd->ipath_flags &IPATH_INITTED )) +continue ; + *dd->ipath_statusp &= ~IPATH_STATUS_SMA ; +if (ipath_verbs_registered) + *dd->ipath_statusp |=IPATH_STATUS_OIB_SMA ; + }
You also have all the functions like recv_subn_get_nodeinfo() etc. for handling SM queries. Presumably all this is duplicated in the userspace SMA. Why can't you get down to one NodeInfo query handler?
- R.
Re: [PATCH 8 of 18] ipath - sysfs and ipathfs support for core driver
In reply to Bryan O'SullivanQuoted 6 lines
Quoted 2 lines
Oh, and I like your new filesystem, but where do you propose that it be mounted?
I don't have any good candidates in mind. In our development environment, we're mounting it in /ipath, but that doesn't seem like a good long-term name. Do you have any suggestions?
Actually, I've been mounting it on /ipathfs. Not that the difference is terribly important. But if you do have suggestions on where this kind of thing should go, I'd love to hear it.
Regards,
Robert.
Signature · 4 lines
Robert Walsh Email: [email protected] PathScale, Inc. Phone: +1 650 934 8117 2071 Stierlin Court, Suite 200 Fax: +1 650 428 1969 Mountain View, CA 94043.
Re: [PATCH 8 of 18] ipath - sysfs and ipathfs support for core driver
In reply to Bryan O'SullivanQuoted 7 lines · Bryan O'Sullivan
Quoted 2 lines · Greg KH
Oh, and I like your new filesystem, but where do you propose that it be mounted?
I don't have any good candidates in mind. In our development environment, we're mounting it in /ipath, but that doesn't seem like a good long-term name. Do you have any suggestions?
Nope, sorry. At least /ipath is LSB compliant :)
thanks,
greg k-h
Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
In reply to Roland DreierQuoted 3 lines · Roland Dreier
But I still (after all this discussion)
don't understand why you need to have two SMA implementations to handle this along with the code to switch between the two modes like:
I'm a bit confused by your question. We only have one SMA implementation, which is in userspace. The stuff that's in our core driver is purely for supporting it. That same code is also used during diags, too, to let userspace send and receive low-level packets.
The code in ipath_mad.c simply handles requests for ib_mad, if the in-kernel SMA is being used.
Quoted 3 lines
You also have all the functions like
recv_subn_get_nodeinfo()etc. for handling SM queries. Presumably all this is duplicated in the userspace SMA.
Only a very small subset of SMA functionality is present in the userspace SMA.
<b
Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
Bryan> I'm a bit confused by your question. We only have one SMA Bryan> implementation, which is in userspace. The stuff that's in Bryan> our core driver is purely for supporting it. That same Bryan> code is also used during diags, too, to let userspace send Bryan> and receive low-level packets.
We seem to be having a problem with the definition of an SMA. I'm talking about all the kernel code like the following (and similar stuff for guidinfo, nodedescription, portinfo, pkeytable).
You must have nearly identical code in your userspace SMA, since it also has to respond to the same SM queries, right?
I'm trying to understand why you can't get down to one implementation of these functions.
Quoted 49 lines
(quoted diff) +49
-0+struct nodeinfo { + u8 base_version; + u8 class_version; + u8 node_type; + u8 num_ports; + __be64 sys_guid; + __be64 node_guid; + __be64 port_guid; + __be16 partition_cap; + __be16 device_id; + __be32 revision; + u8 local_port_num; + u8 vendor_id[3]; +} __attribute__ ((packed)); + +static inline int recv_subn_get_nodeinfo(struct ib_smp *smp, + struct ib_device *ibdev, u8 port) +{ + struct nodeinfo *nip = (struct nodeinfo *)&smp->data; + struct ipath_devdata *dd = to_idev(ibdev)->dd; + u32 vendor, boardid, majrev, minrev; + + if (smp->attr_mod) + smp->status |= IB_SMP_INVALID_FIELD; + + nip->base_version = 1; + nip->class_version = 1; + nip->node_type = 1; /* channel adapter */ + /* + * XXX The num_ports value will need a layer function to get + * the value if we ever have more than one IB port on a chip. + * We will also need to get the GUID for the port. + */ + nip->num_ports = ibdev->phys_port_cnt; + /* This is already in network order */ + nip->sys_guid = to_idev(ibdev)->sys_image_guid; + nip->node_guid = ipath_layer_get_guid(dd); + nip->port_guid = nip->sys_guid; + nip->partition_cap = cpu_to_be16(ipath_layer_get_npkeys(dd)); + nip->device_id = cpu_to_be16(ipath_layer_get_deviceid(dd)); + ipath_layer_query_device(dd, &vendor, &boardid, &majrev, &minrev); + nip->revision = cpu_to_be32((majrev << 16) | minrev); + nip->local_port_num = port; + nip->vendor_id[0] = 0; + nip->vendor_id[1] = vendor >> 8; + nip->vendor_id[2] = vendor; + + return reply(smp); +}
Re: [openib-general] Re: [PATCH 9 of 18] ipath - char devices for diagnostics and lightweight subnet management
Quoted 9 lines
I'm
talking about all the kernel code like the following (and similar stuff for guidinfo, nodedescription, portinfo, pkeytable).You must have nearly identical code in your userspace SMA, since it also has to respond to the same SM queries, right?
I'm trying to understand why you can't get down to one implementation of these functions.
Why does that make a difference? The way I see it, we handle MAD packets by either diverting them somewhere or passing them through the normal ib_mad channel. We divert them somewhere because we find it convenient to do so: it allows us to provide an SMA to our customers without them having to have the full IB stack running. The SMA we provide for these circumstances runs in userspace. It doesn't make use of the existing ipath_mad.c code because that's tailored to: 1) run in the kernel; and 2) deal with the IB stack. Even if we ripped out the guts of ipath_mad.c and had it pass the requests to the userspace SMA, we'd still have to have the diversion path in there for cases where the IB stack isn't around.
Signature · 4 lines
Robert Walsh Email: [email protected] PathScale, Inc. Phone: +1 650 934 8117 2071 Stierlin Court, Suite 200 Fax: +1 650 428 1969 Mountain View, CA 94043.