scst/iscsi-scst/kernel/isert-scst/iser_datamover.c - backupdr - Git at Google

 /*
  * isert_datamover.c
  *
  * This file is part of iser target kernel module.
  *
  * Copyright (c) 2013 - 2014 Mellanox Technologies. All rights reserved.
  * Copyright (c) 2013 - 2014 Yan Burman (yanb@mellanox.com)
  *
  * 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 <linux/kernel.h>

 #include "isert_dbg.h"
 #include "iser.h"
 #include "iser_datamover.h"

 int isert_datamover_init(void)
 {
 	int err;

 	err = isert_global_init();
 	if (unlikely(err)) {
 		PRINT_ERROR("iser datamover init failed, err:%d", err);
 		return err;
 	}
 	return 0;
 }

 int isert_datamover_cleanup(void)
 {
 	isert_global_cleanup();
 	return 0;
 }

 int isert_get_peer_addr(struct iscsi_conn *iscsi_conn, struct sockaddr *sa,
 			size_t *addr_len)
 {
 	int ret;
 	struct isert_connection *isert_conn = container_of(iscsi_conn,
 						struct isert_connection, iscsi);
 	struct sockaddr *peer_sa = (struct sockaddr *)&isert_conn->peer_addr;

 	ret = isert_get_addr_size(peer_sa, addr_len);
 	if (unlikely(ret))
 		goto out;

 	memcpy(sa, peer_sa, *addr_len);
 out:
 	return ret;
 }

 int isert_get_target_addr(struct iscsi_conn *iscsi_conn, struct sockaddr *sa,
 			  size_t *addr_len)
 {
 	int ret;
 	struct isert_connection *isert_conn = container_of(iscsi_conn,
 						struct isert_connection, iscsi);
 	struct sockaddr *self_sa = (struct sockaddr *)&isert_conn->self_addr;

 	ret = isert_get_addr_size(self_sa, addr_len);
 	if (unlikely(ret))
 		goto out;

 	memcpy(sa, self_sa, *addr_len);
 out:
 	return ret;
 }

 struct isert_portal *isert_portal_add(struct sockaddr *saddr, size_t addr_len)
 {
 	return isert_portal_start(saddr, addr_len);
 }

 int isert_portal_remove(struct isert_portal *portal)
 {
 	isert_portal_release(portal);
 	return 0;
 }

 void isert_free_connection(struct iscsi_conn *iscsi_conn)
 {
 	struct isert_connection *isert_conn = container_of(iscsi_conn,
 						struct isert_connection, iscsi);

 	isert_post_drain(isert_conn);
 	isert_conn_free(isert_conn);
 }

 struct iscsi_cmnd *isert_alloc_login_rsp_pdu(struct iscsi_conn *iscsi_conn)
 {
 	struct isert_connection *isert_conn = container_of(iscsi_conn,
 						struct isert_connection, iscsi);
 	struct isert_cmnd *isert_pdu = isert_conn->login_rsp_pdu;

 	isert_tx_pdu_init(isert_pdu, isert_conn);
 	return &isert_pdu->iscsi;
 }

 static struct iscsi_cmnd *isert_alloc_scsi_pdu(struct iscsi_conn *iscsi_conn,
 					       int fake)
 {
 	struct isert_connection *isert_conn = container_of(iscsi_conn,
 						struct isert_connection, iscsi);
 	struct isert_cmnd *isert_pdu;

 again:
 	spin_lock(&isert_conn->tx_lock);
 	if (list_empty(&isert_conn->tx_free_list)) {
 		spin_unlock(&isert_conn->tx_lock);
 		goto again;
 	}
 	isert_pdu = list_first_entry(&isert_conn->tx_free_list,
 				     struct isert_cmnd, pool_node);
 	list_move(&isert_pdu->pool_node, &isert_conn->tx_busy_list);
 	spin_unlock(&isert_conn->tx_lock);

 	isert_pdu->is_fake_rx = fake;
 	return &isert_pdu->iscsi;
 }

 struct iscsi_cmnd *isert_alloc_scsi_rsp_pdu(struct iscsi_conn *iscsi_conn)
 {
 	return isert_alloc_scsi_pdu(iscsi_conn, 0);
 }

 struct iscsi_cmnd *isert_alloc_scsi_fake_pdu(struct iscsi_conn *iscsi_conn)
 {
 	return isert_alloc_scsi_pdu(iscsi_conn, 1);
 }

 void isert_release_tx_pdu(struct iscsi_cmnd *iscsi_pdu)
 {
 	struct isert_cmnd *isert_pdu = container_of(iscsi_pdu,
 						    struct isert_cmnd, iscsi);
 	struct isert_connection *isert_conn = container_of(iscsi_pdu->conn,
 						struct isert_connection, iscsi);

 	isert_tx_pdu_init_iscsi(isert_pdu);

 	spin_lock(&isert_conn->tx_lock);
 	list_move(&isert_pdu->pool_node, &isert_conn->tx_free_list);
 	spin_unlock(&isert_conn->tx_lock);
 }

 void isert_release_rx_pdu(struct iscsi_cmnd *iscsi_pdu)
 {
 	struct isert_cmnd *isert_pdu = container_of(iscsi_pdu,
 						    struct isert_cmnd, iscsi);

 	isert_rx_pdu_done(isert_pdu);
 }

 /* if last transition into FF (Fully Featured) state */
 int isert_login_rsp_tx(struct iscsi_cmnd *login_rsp, int last, int discovery)
 {
 	struct isert_connection *isert_conn = container_of(login_rsp->conn,
 						struct isert_connection, iscsi);
 	int err;

 	if (last && !discovery) {
 		err = isert_alloc_conn_resources(isert_conn);
 		if (unlikely(err)) {
 			PRINT_ERROR("Failed to init conn resources");
 			return err;
 		}
 		isert_pdu_free(isert_conn->login_req_pdu);
 		isert_conn->login_req_pdu = NULL;
 	} else {
 		err = isert_post_recv(isert_conn,
 					  &isert_conn->login_req_pdu->wr[0],
 					  1);
 		if (unlikely(err)) {
 			PRINT_ERROR("Failed to post recv login req rx buf, err:%d",
 				    err);
 			return err;
 		}
 	}

 	return isert_pdu_tx(login_rsp);
 }

 int isert_set_session_params(struct iscsi_conn *iscsi_conn,
 			     struct iscsi_sess_params *sess_params,
 			     struct iscsi_tgt_params *tgt_params)
 {
 	struct isert_connection *isert_conn = container_of(iscsi_conn,
 						struct isert_connection, iscsi);

 	isert_conn->queue_depth = tgt_params->queued_cmnds;

 	isert_conn->immediate_data = sess_params->immediate_data;
 	isert_conn->target_recv_data_length = sess_params->target_recv_data_length;
 	isert_conn->initial_r2t = sess_params->initial_r2t;
 	isert_conn->first_burst_length = sess_params->first_burst_length;
 	isert_conn->initiator_recv_data_length = sess_params->initiator_recv_data_length;

 	return 0;
 }

 int isert_pdu_tx(struct iscsi_cmnd *iscsi_cmnd)
 {
 	struct isert_cmnd *isert_cmnd = container_of(iscsi_cmnd,
 						    struct isert_cmnd, iscsi);
 	struct isert_connection *isert_conn = container_of(iscsi_cmnd->conn,
 						struct isert_connection, iscsi);
 	int err;

 	isert_tx_pdu_convert_from_iscsi(isert_cmnd, iscsi_cmnd);
 	err = isert_pdu_send(isert_conn, isert_cmnd);

 	return err;
 }

 int isert_request_data_out(struct iscsi_cmnd *iscsi_cmnd)
 {
 	struct isert_cmnd *isert_cmnd = container_of(iscsi_cmnd,
 						    struct isert_cmnd, iscsi);
 	struct isert_connection *isert_conn = container_of(iscsi_cmnd->conn,
 						struct isert_connection, iscsi);
 	int ret;

 	ret = isert_prepare_rdma(isert_cmnd, isert_conn, ISER_WR_RDMA_READ);
 	if (unlikely(ret < 0))
 		return ret;

 	ret = isert_pdu_post_rdma_read(isert_conn, isert_cmnd, ret);

 	return ret;
 }

 int isert_send_data_in(struct iscsi_cmnd *iscsi_cmnd,
 		       struct iscsi_cmnd *iscsi_rsp)
 {
 	struct isert_cmnd *isert_cmnd = container_of(iscsi_cmnd,
 						    struct isert_cmnd, iscsi);
 	struct isert_connection *isert_conn = container_of(iscsi_cmnd->conn,
 						struct isert_connection, iscsi);
 	struct isert_cmnd *isert_rsp = container_of(iscsi_rsp,
 						    struct isert_cmnd, iscsi);
 	int ret;

 	ret = isert_prepare_rdma(isert_cmnd, isert_conn, ISER_WR_RDMA_WRITE);
 	if (unlikely(ret < 0))
 		return ret;

 	isert_tx_pdu_convert_from_iscsi(isert_rsp, iscsi_rsp);
 	ret = isert_pdu_post_rdma_write(isert_conn, isert_cmnd, isert_rsp, ret);

 	return ret;
 }

 int isert_close_connection(struct iscsi_conn *iscsi_conn)
 {
 	struct isert_connection *isert_conn = container_of(iscsi_conn,
 						struct isert_connection, iscsi);

 	isert_conn_disconnect(isert_conn);

 	return 0;
 }

 int isert_task_abort(struct iscsi_cmnd *cmnd)
 {
 	return 0;
 }

 void *isert_get_priv(struct iscsi_conn *iscsi_conn)
 {
 	struct isert_connection *isert_conn = container_of(iscsi_conn,
 						struct isert_connection, iscsi);

 	return isert_conn->priv_data;
 }

 void isert_set_priv(struct iscsi_conn *iscsi_conn, void *priv)
 {
 	struct isert_connection *isert_conn = container_of(iscsi_conn,
 					struct isert_connection, iscsi);

 	isert_conn->priv_data = priv;
 }
	/*
	* isert_datamover.c
	*
	* This file is part of iser target kernel module.
	*
	* Copyright (c) 2013 - 2014 Mellanox Technologies. All rights reserved.
	* Copyright (c) 2013 - 2014 Yan Burman (yanb@mellanox.com)
	*
	* 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 <linux/kernel.h>

	#include "isert_dbg.h"
	#include "iser.h"
	#include "iser_datamover.h"

	int isert_datamover_init(void)
	{
	int err;

	err = isert_global_init();
	if (unlikely(err)) {
	PRINT_ERROR("iser datamover init failed, err:%d", err);
	return err;
	}
	return 0;
	}

	int isert_datamover_cleanup(void)
	{
	isert_global_cleanup();
	return 0;
	}

	int isert_get_peer_addr(struct iscsi_conn iscsi_conn, struct sockaddr sa,
	size_t *addr_len)
	{
	int ret;
	struct isert_connection *isert_conn = container_of(iscsi_conn,
	struct isert_connection, iscsi);
	struct sockaddr peer_sa = (struct sockaddr )&isert_conn->peer_addr;

	ret = isert_get_addr_size(peer_sa, addr_len);
	if (unlikely(ret))
	goto out;

	memcpy(sa, peer_sa, *addr_len);
	out:
	return ret;
	}

	int isert_get_target_addr(struct iscsi_conn iscsi_conn, struct sockaddr sa,
	size_t *addr_len)
	{
	int ret;
	struct isert_connection *isert_conn = container_of(iscsi_conn,
	struct isert_connection, iscsi);
	struct sockaddr self_sa = (struct sockaddr )&isert_conn->self_addr;

	ret = isert_get_addr_size(self_sa, addr_len);
	if (unlikely(ret))
	goto out;

	memcpy(sa, self_sa, *addr_len);
	out:
	return ret;
	}

	struct isert_portal isert_portal_add(struct sockaddr saddr, size_t addr_len)
	{
	return isert_portal_start(saddr, addr_len);
	}

	int isert_portal_remove(struct isert_portal *portal)
	{
	isert_portal_release(portal);
	return 0;
	}

	void isert_free_connection(struct iscsi_conn *iscsi_conn)
	{
	struct isert_connection *isert_conn = container_of(iscsi_conn,
	struct isert_connection, iscsi);

	isert_post_drain(isert_conn);
	isert_conn_free(isert_conn);
	}

	struct iscsi_cmnd isert_alloc_login_rsp_pdu(struct iscsi_conn iscsi_conn)
	{
	struct isert_connection *isert_conn = container_of(iscsi_conn,
	struct isert_connection, iscsi);
	struct isert_cmnd *isert_pdu = isert_conn->login_rsp_pdu;

	isert_tx_pdu_init(isert_pdu, isert_conn);
	return &isert_pdu->iscsi;
	}

	static struct iscsi_cmnd isert_alloc_scsi_pdu(struct iscsi_conn iscsi_conn,
	int fake)
	{
	struct isert_connection *isert_conn = container_of(iscsi_conn,
	struct isert_connection, iscsi);
	struct isert_cmnd *isert_pdu;

	again:
	spin_lock(&isert_conn->tx_lock);
	if (list_empty(&isert_conn->tx_free_list)) {
	spin_unlock(&isert_conn->tx_lock);
	goto again;
	}
	isert_pdu = list_first_entry(&isert_conn->tx_free_list,
	struct isert_cmnd, pool_node);
	list_move(&isert_pdu->pool_node, &isert_conn->tx_busy_list);
	spin_unlock(&isert_conn->tx_lock);

	isert_pdu->is_fake_rx = fake;
	return &isert_pdu->iscsi;
	}

	struct iscsi_cmnd isert_alloc_scsi_rsp_pdu(struct iscsi_conn iscsi_conn)
	{
	return isert_alloc_scsi_pdu(iscsi_conn, 0);
	}

	struct iscsi_cmnd isert_alloc_scsi_fake_pdu(struct iscsi_conn iscsi_conn)
	{
	return isert_alloc_scsi_pdu(iscsi_conn, 1);
	}

	void isert_release_tx_pdu(struct iscsi_cmnd *iscsi_pdu)
	{
	struct isert_cmnd *isert_pdu = container_of(iscsi_pdu,
	struct isert_cmnd, iscsi);
	struct isert_connection *isert_conn = container_of(iscsi_pdu->conn,
	struct isert_connection, iscsi);

	isert_tx_pdu_init_iscsi(isert_pdu);

	spin_lock(&isert_conn->tx_lock);
	list_move(&isert_pdu->pool_node, &isert_conn->tx_free_list);
	spin_unlock(&isert_conn->tx_lock);
	}

	void isert_release_rx_pdu(struct iscsi_cmnd *iscsi_pdu)
	{
	struct isert_cmnd *isert_pdu = container_of(iscsi_pdu,
	struct isert_cmnd, iscsi);

	isert_rx_pdu_done(isert_pdu);
	}

	/* if last transition into FF (Fully Featured) state */
	int isert_login_rsp_tx(struct iscsi_cmnd *login_rsp, int last, int discovery)
	{
	struct isert_connection *isert_conn = container_of(login_rsp->conn,
	struct isert_connection, iscsi);
	int err;

	if (last && !discovery) {
	err = isert_alloc_conn_resources(isert_conn);
	if (unlikely(err)) {
	PRINT_ERROR("Failed to init conn resources");
	return err;
	}
	isert_pdu_free(isert_conn->login_req_pdu);
	isert_conn->login_req_pdu = NULL;
	} else {
	err = isert_post_recv(isert_conn,
	&isert_conn->login_req_pdu->wr[0],
	1);
	if (unlikely(err)) {
	PRINT_ERROR("Failed to post recv login req rx buf, err:%d",
	err);
	return err;
	}
	}

	return isert_pdu_tx(login_rsp);
	}

	int isert_set_session_params(struct iscsi_conn *iscsi_conn,
	struct iscsi_sess_params *sess_params,
	struct iscsi_tgt_params *tgt_params)
	{
	struct isert_connection *isert_conn = container_of(iscsi_conn,
	struct isert_connection, iscsi);

	isert_conn->queue_depth = tgt_params->queued_cmnds;

	isert_conn->immediate_data = sess_params->immediate_data;
	isert_conn->target_recv_data_length = sess_params->target_recv_data_length;
	isert_conn->initial_r2t = sess_params->initial_r2t;
	isert_conn->first_burst_length = sess_params->first_burst_length;
	isert_conn->initiator_recv_data_length = sess_params->initiator_recv_data_length;

	return 0;
	}

	int isert_pdu_tx(struct iscsi_cmnd *iscsi_cmnd)
	{
	struct isert_cmnd *isert_cmnd = container_of(iscsi_cmnd,
	struct isert_cmnd, iscsi);
	struct isert_connection *isert_conn = container_of(iscsi_cmnd->conn,
	struct isert_connection, iscsi);
	int err;

	isert_tx_pdu_convert_from_iscsi(isert_cmnd, iscsi_cmnd);
	err = isert_pdu_send(isert_conn, isert_cmnd);

	return err;
	}

	int isert_request_data_out(struct iscsi_cmnd *iscsi_cmnd)
	{
	struct isert_cmnd *isert_cmnd = container_of(iscsi_cmnd,
	struct isert_cmnd, iscsi);
	struct isert_connection *isert_conn = container_of(iscsi_cmnd->conn,
	struct isert_connection, iscsi);
	int ret;

	ret = isert_prepare_rdma(isert_cmnd, isert_conn, ISER_WR_RDMA_READ);
	if (unlikely(ret < 0))
	return ret;

	ret = isert_pdu_post_rdma_read(isert_conn, isert_cmnd, ret);

	return ret;
	}

	int isert_send_data_in(struct iscsi_cmnd *iscsi_cmnd,
	struct iscsi_cmnd *iscsi_rsp)
	{
	struct isert_cmnd *isert_cmnd = container_of(iscsi_cmnd,
	struct isert_cmnd, iscsi);
	struct isert_connection *isert_conn = container_of(iscsi_cmnd->conn,
	struct isert_connection, iscsi);
	struct isert_cmnd *isert_rsp = container_of(iscsi_rsp,
	struct isert_cmnd, iscsi);
	int ret;

	ret = isert_prepare_rdma(isert_cmnd, isert_conn, ISER_WR_RDMA_WRITE);
	if (unlikely(ret < 0))
	return ret;

	isert_tx_pdu_convert_from_iscsi(isert_rsp, iscsi_rsp);
	ret = isert_pdu_post_rdma_write(isert_conn, isert_cmnd, isert_rsp, ret);

	return ret;
	}

	int isert_close_connection(struct iscsi_conn *iscsi_conn)
	{
	struct isert_connection *isert_conn = container_of(iscsi_conn,
	struct isert_connection, iscsi);

	isert_conn_disconnect(isert_conn);

	return 0;
	}

	int isert_task_abort(struct iscsi_cmnd *cmnd)
	{
	return 0;
	}

	void isert_get_priv(struct iscsi_conn iscsi_conn)
	{
	struct isert_connection *isert_conn = container_of(iscsi_conn,
	struct isert_connection, iscsi);

	return isert_conn->priv_data;
	}

	void isert_set_priv(struct iscsi_conn iscsi_conn, void priv)
	{
	struct isert_connection *isert_conn = container_of(iscsi_conn,
	struct isert_connection, iscsi);

	isert_conn->priv_data = priv;
	}