net/smc/smc_cdc.c

30 	struct smc_connection *conn = cdcpend->conn;
35 	sndbuf_desc = conn->sndbuf_desc;
36 	smc = container_of(conn, struct smc_sock, conn);
40 				     &cdcpend->conn->tx_curs_fin,
44 		atomic_add(diff, &cdcpend->conn->sndbuf_space);
47 		smc_curs_copy(&conn->tx_curs_fin, &cdcpend->cursor, conn);
48 		smc_curs_copy(&conn->local_tx_ctrl_fin, &cdcpend->p_cursor,
49 			      conn);
50 		conn->tx_cdc_seq_fin = cdcpend->ctrl_seq;
53 	if (atomic_dec_and_test(&conn->cdc_pend_tx_wr)) {
59 			conn->tx_in_release_sock = true;
61 			smc_tx_pending(conn);
63 		if (unlikely(wq_has_sleeper(&conn->cdc_pend_tx_wq)))
64 			wake_up(&conn->cdc_pend_tx_wq);
66 	WARN_ON(atomic_read(&conn->cdc_pend_tx_wr) < 0);
72 int smc_cdc_get_free_slot(struct smc_connection *conn,
83 	if (conn->killed) {
93 static inline void smc_cdc_add_pending_send(struct smc_connection *conn,
105 	pend->conn = conn;
106 	pend->cursor = conn->tx_curs_sent;
107 	pend->p_cursor = conn->local_tx_ctrl.prod;
108 	pend->ctrl_seq = conn->tx_cdc_seq;
111 int smc_cdc_msg_send(struct smc_connection *conn,
115 	struct smc_link *link = conn->lnk;
119 	smc_cdc_add_pending_send(conn, pend);
121 	conn->tx_cdc_seq++;
122 	conn->local_tx_ctrl.seqno = conn->tx_cdc_seq;
123 	smc_host_msg_to_cdc((struct smc_cdc_msg *)wr_buf, conn, &cfed);
125 	atomic_inc(&conn->cdc_pend_tx_wr);
130 		smc_curs_copy(&conn->rx_curs_confirmed, &cfed, conn);
131 		conn->local_rx_ctrl.prod_flags.cons_curs_upd_req = 0;
133 		conn->tx_cdc_seq--;
134 		conn->local_tx_ctrl.seqno = conn->tx_cdc_seq;
135 		atomic_dec(&conn->cdc_pend_tx_wr);
141 /* send a validation msg indicating the move of a conn to an other QP link */
142 int smcr_cdc_msg_send_validation(struct smc_connection *conn,
146 	struct smc_host_cdc_msg *local = &conn->local_tx_ctrl;
147 	struct smc_link *link = conn->lnk;
154 	peer->seqno = htons(conn->tx_cdc_seq_fin); /* seqno last compl. tx */
158 	/* We need to set pend->conn here to make sure smc_cdc_tx_handler()
161 	smc_cdc_add_pending_send(conn, pend);
163 	atomic_inc(&conn->cdc_pend_tx_wr);
168 		atomic_dec(&conn->cdc_pend_tx_wr);
173 static int smcr_cdc_get_slot_and_msg_send(struct smc_connection *conn)
182 	link = conn->lnk;
185 	rc = smc_cdc_get_free_slot(conn, link, &wr_buf, NULL, &pend);
189 	spin_lock_bh(&conn->send_lock);
190 	if (link != conn->lnk) {
192 		spin_unlock_bh(&conn->send_lock);
201 	rc = smc_cdc_msg_send(conn, wr_buf, pend);
202 	spin_unlock_bh(&conn->send_lock);
208 int smc_cdc_get_slot_and_msg_send(struct smc_connection *conn)
212 	if (!smc_conn_lgr_valid(conn) ||
213 	    (conn->lgr->is_smcd && conn->lgr->peer_shutdown))
216 	if (conn->lgr->is_smcd) {
217 		spin_lock_bh(&conn->send_lock);
218 		rc = smcd_cdc_msg_send(conn);
219 		spin_unlock_bh(&conn->send_lock);
221 		rc = smcr_cdc_get_slot_and_msg_send(conn);
227 void smc_cdc_wait_pend_tx_wr(struct smc_connection *conn)
229 	wait_event(conn->cdc_pend_tx_wq, !atomic_read(&conn->cdc_pend_tx_wr));
236 int smcd_cdc_msg_send(struct smc_connection *conn)
238 	struct smc_sock *smc = container_of(conn, struct smc_sock, conn);
245 	curs.acurs.counter = atomic64_read(&conn->local_tx_ctrl.prod.acurs);
248 	curs.acurs.counter = atomic64_read(&conn->local_tx_ctrl.cons.acurs);
251 	cdc.cons.prod_flags = conn->local_tx_ctrl.prod_flags;
252 	cdc.cons.conn_state_flags = conn->local_tx_ctrl.conn_state_flags;
253 	rc = smcd_tx_ism_write(conn, &cdc, sizeof(cdc), 0, 1);
256 	smc_curs_copy(&conn->rx_curs_confirmed, &curs, conn);
257 	conn->local_rx_ctrl.prod_flags.cons_curs_upd_req = 0;
259 	diff = smc_curs_diff(conn->sndbuf_desc->len, &conn->tx_curs_fin,
260 			     &conn->tx_curs_sent);
263 	atomic_add(diff, &conn->sndbuf_space);
266 	smc_curs_copy(&conn->tx_curs_fin, &conn->tx_curs_sent, conn);
282 	struct smc_connection *conn = &smc->conn;
286 	smc_curs_copy(&conn->urg_curs, &conn->local_rx_ctrl.prod, conn);
287 	conn->urg_state = SMC_URG_VALID;
291 	base = (char *)conn->rmb_desc->cpu_addr + conn->rx_off;
292 	if (conn->urg_curs.count)
293 		conn->urg_rx_byte = *(base + conn->urg_curs.count - 1);
295 		conn->urg_rx_byte = *(base + conn->rmb_desc->len - 1);
302 	struct smc_connection *conn = &smc->conn;
307 	diff = conn->local_rx_ctrl.seqno - recv_seq;
310 		conn->out_of_sync = 1;	/* prevent any further receives */
311 		spin_lock_bh(&conn->send_lock);
312 		conn->local_tx_ctrl.conn_state_flags.peer_conn_abort = 1;
313 		conn->lnk = link;
314 		spin_unlock_bh(&conn->send_lock);
316 		if (!queue_work(smc_close_wq, &conn->abort_work))
325 	struct smc_connection *conn = &smc->conn;
328 	smc_curs_copy(&prod_old, &conn->local_rx_ctrl.prod, conn);
329 	smc_curs_copy(&cons_old, &conn->local_rx_ctrl.cons, conn);
330 	smc_cdc_msg_to_host(&conn->local_rx_ctrl, cdc, conn);
332 	diff_cons = smc_curs_diff(conn->peer_rmbe_size, &cons_old,
333 				  &conn->local_rx_ctrl.cons);
339 		atomic_add(diff_cons, &conn->peer_rmbe_space);
344 	diff_prod = smc_curs_diff(conn->rmb_desc->len, &prod_old,
345 				  &conn->local_rx_ctrl.prod);
347 		if (conn->local_rx_ctrl.prod_flags.urg_data_present)
351 		atomic_add(diff_prod, &conn->bytes_to_rcv);
356 		if (conn->local_rx_ctrl.prod_flags.write_blocked)
358 		if (conn->local_rx_ctrl.prod_flags.urg_data_pending)
359 			conn->urg_state = SMC_URG_NOTYET;
363 	if ((diff_cons && smc_tx_prepared_sends(conn)) ||
364 	    conn->local_rx_ctrl.prod_flags.cons_curs_upd_req ||
365 	    conn->local_rx_ctrl.prod_flags.urg_data_pending) {
367 			smc_tx_pending(conn);
369 			conn->tx_in_release_sock = true;
372 	if (diff_cons && conn->urg_tx_pend &&
373 	    atomic_read(&conn->peer_rmbe_space) == conn->peer_rmbe_size) {
375 		conn->urg_tx_pend = false;
379 	if (conn->local_rx_ctrl.conn_state_flags.peer_conn_abort) {
381 		conn->local_tx_ctrl.conn_state_flags.peer_conn_abort = 1;
383 	if (smc_cdc_rxed_any_close_or_senddone(conn)) {
389 		if (!queue_work(smc_close_wq, &conn->close_work))
412 	struct smc_connection *conn = from_tasklet(conn, t, rx_tsklet);
417 	if (!conn || conn->killed)
420 	data_cdc = (struct smcd_cdc_msg *)conn->rmb_desc->cpu_addr;
421 	smcd_curs_copy(&cdc.prod, &data_cdc->prod, conn);
422 	smcd_curs_copy(&cdc.cons, &data_cdc->cons, conn);
423 	smc = container_of(conn, struct smc_sock, conn);
430 void smcd_cdc_rx_init(struct smc_connection *conn)
432 	tasklet_setup(&conn->rx_tsklet, smcd_cdc_rx_tsklet);
441 	struct smc_connection *conn;
453 	conn = smc_lgr_find_conn(ntohl(cdc->token), lgr);
455 	if (!conn || conn->out_of_sync)
457 	smc = container_of(conn, struct smc_sock, conn);
464 			   conn->local_rx_ctrl.seqno))