I no longer have the time to maintain this subsystem nor the hardware to
test patches with. It also doesn't appear to have any active users so I
doubt anyone will miss it.
Signed-off-by: Chris Boot <[email protected]>
---
MAINTAINERS | 9 -
drivers/target/Kconfig | 1 -
drivers/target/Makefile | 1 -
drivers/target/sbp/Kconfig | 12 -
drivers/target/sbp/Makefile | 2 -
drivers/target/sbp/sbp_target.c | 2350 -------------------------------
drivers/target/sbp/sbp_target.h | 243 ----
7 files changed, 2618 deletions(-)
delete mode 100644 drivers/target/sbp/Kconfig
delete mode 100644 drivers/target/sbp/Makefile
delete mode 100644 drivers/target/sbp/sbp_target.c
delete mode 100644 drivers/target/sbp/sbp_target.h
diff --git a/MAINTAINERS b/MAINTAINERS
index 56d7d27fc114..81b7db7d68a8 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -6669,15 +6669,6 @@ S: Maintained
T: git git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media.git
F: drivers/media/firewire/
-FIREWIRE SBP-2 TARGET
-M: Chris Boot <[email protected]>
-L: [email protected]
-L: [email protected]
-L: [email protected]
-S: Maintained
-T: git git://git.kernel.org/pub/scm/linux/kernel/git/nab/lio-core-2.6.git master
-F: drivers/target/sbp/
-
FIREWIRE SUBSYSTEM
M: Stefan Richter <[email protected]>
L: [email protected]
diff --git a/drivers/target/Kconfig b/drivers/target/Kconfig
index c163b14774d7..4a5682745ada 100644
--- a/drivers/target/Kconfig
+++ b/drivers/target/Kconfig
@@ -46,6 +46,5 @@ config TCM_USER2
source "drivers/target/loopback/Kconfig"
source "drivers/target/tcm_fc/Kconfig"
source "drivers/target/iscsi/Kconfig"
-source "drivers/target/sbp/Kconfig"
endif
diff --git a/drivers/target/Makefile b/drivers/target/Makefile
index 45634747377e..c13da05af2e2 100644
--- a/drivers/target/Makefile
+++ b/drivers/target/Makefile
@@ -29,4 +29,3 @@ obj-$(CONFIG_TCM_USER2) += target_core_user.o
obj-$(CONFIG_LOOPBACK_TARGET) += loopback/
obj-$(CONFIG_TCM_FC) += tcm_fc/
obj-$(CONFIG_ISCSI_TARGET) += iscsi/
-obj-$(CONFIG_SBP_TARGET) += sbp/
diff --git a/drivers/target/sbp/Kconfig b/drivers/target/sbp/Kconfig
deleted file mode 100644
index 53a1c75f5660..000000000000
--- a/drivers/target/sbp/Kconfig
+++ /dev/null
@@ -1,12 +0,0 @@
-# SPDX-License-Identifier: GPL-2.0-only
-config SBP_TARGET
- tristate "FireWire SBP-2 fabric module"
- depends on FIREWIRE
- help
- Say Y or M here to enable SCSI target functionality over FireWire.
- This enables you to expose SCSI devices to other nodes on the FireWire
- bus, for example hard disks. Similar to FireWire Target Disk mode on
- many Apple computers.
-
- To compile this driver as a module, say M here: The module will be
- called sbp-target.
diff --git a/drivers/target/sbp/Makefile b/drivers/target/sbp/Makefile
deleted file mode 100644
index 766f23690013..000000000000
--- a/drivers/target/sbp/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
-# SPDX-License-Identifier: GPL-2.0-only
-obj-$(CONFIG_SBP_TARGET) += sbp_target.o
diff --git a/drivers/target/sbp/sbp_target.c b/drivers/target/sbp/sbp_target.c
deleted file mode 100644
index e4a9b9fe3dfb..000000000000
--- a/drivers/target/sbp/sbp_target.c
+++ /dev/null
@@ -1,2350 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * SBP2 target driver (SCSI over IEEE1394 in target mode)
- *
- * Copyright (C) 2011 Chris Boot <[email protected]>
- */
-
-#define KMSG_COMPONENT "sbp_target"
-#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/types.h>
-#include <linux/string.h>
-#include <linux/configfs.h>
-#include <linux/ctype.h>
-#include <linux/delay.h>
-#include <linux/firewire.h>
-#include <linux/firewire-constants.h>
-#include <scsi/scsi_proto.h>
-#include <scsi/scsi_tcq.h>
-#include <target/target_core_base.h>
-#include <target/target_core_backend.h>
-#include <target/target_core_fabric.h>
-#include <asm/unaligned.h>
-
-#include "sbp_target.h"
-
-/* FireWire address region for management and command block address handlers */
-static const struct fw_address_region sbp_register_region = {
- .start = CSR_REGISTER_BASE + 0x10000,
- .end = 0x1000000000000ULL,
-};
-
-static const u32 sbp_unit_directory_template[] = {
- 0x1200609e, /* unit_specifier_id: NCITS/T10 */
- 0x13010483, /* unit_sw_version: 1155D Rev 4 */
- 0x3800609e, /* command_set_specifier_id: NCITS/T10 */
- 0x390104d8, /* command_set: SPC-2 */
- 0x3b000000, /* command_set_revision: 0 */
- 0x3c000001, /* firmware_revision: 1 */
-};
-
-#define SESSION_MAINTENANCE_INTERVAL HZ
-
-static atomic_t login_id = ATOMIC_INIT(0);
-
-static void session_maintenance_work(struct work_struct *);
-static int sbp_run_transaction(struct fw_card *, int, int, int, int,
- unsigned long long, void *, size_t);
-
-static int read_peer_guid(u64 *guid, const struct sbp_management_request *req)
-{
- int ret;
- __be32 high, low;
-
- ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
- req->node_addr, req->generation, req->speed,
- (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 3 * 4,
- &high, sizeof(high));
- if (ret != RCODE_COMPLETE)
- return ret;
-
- ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
- req->node_addr, req->generation, req->speed,
- (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 4 * 4,
- &low, sizeof(low));
- if (ret != RCODE_COMPLETE)
- return ret;
-
- *guid = (u64)be32_to_cpu(high) << 32 | be32_to_cpu(low);
-
- return RCODE_COMPLETE;
-}
-
-static struct sbp_session *sbp_session_find_by_guid(
- struct sbp_tpg *tpg, u64 guid)
-{
- struct se_session *se_sess;
- struct sbp_session *sess, *found = NULL;
-
- spin_lock_bh(&tpg->se_tpg.session_lock);
- list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
- sess = se_sess->fabric_sess_ptr;
- if (sess->guid == guid)
- found = sess;
- }
- spin_unlock_bh(&tpg->se_tpg.session_lock);
-
- return found;
-}
-
-static struct sbp_login_descriptor *sbp_login_find_by_lun(
- struct sbp_session *session, u32 unpacked_lun)
-{
- struct sbp_login_descriptor *login, *found = NULL;
-
- spin_lock_bh(&session->lock);
- list_for_each_entry(login, &session->login_list, link) {
- if (login->login_lun == unpacked_lun)
- found = login;
- }
- spin_unlock_bh(&session->lock);
-
- return found;
-}
-
-static int sbp_login_count_all_by_lun(
- struct sbp_tpg *tpg,
- u32 unpacked_lun,
- int exclusive)
-{
- struct se_session *se_sess;
- struct sbp_session *sess;
- struct sbp_login_descriptor *login;
- int count = 0;
-
- spin_lock_bh(&tpg->se_tpg.session_lock);
- list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
- sess = se_sess->fabric_sess_ptr;
-
- spin_lock_bh(&sess->lock);
- list_for_each_entry(login, &sess->login_list, link) {
- if (login->login_lun != unpacked_lun)
- continue;
-
- if (!exclusive || login->exclusive)
- count++;
- }
- spin_unlock_bh(&sess->lock);
- }
- spin_unlock_bh(&tpg->se_tpg.session_lock);
-
- return count;
-}
-
-static struct sbp_login_descriptor *sbp_login_find_by_id(
- struct sbp_tpg *tpg, int login_id)
-{
- struct se_session *se_sess;
- struct sbp_session *sess;
- struct sbp_login_descriptor *login, *found = NULL;
-
- spin_lock_bh(&tpg->se_tpg.session_lock);
- list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
- sess = se_sess->fabric_sess_ptr;
-
- spin_lock_bh(&sess->lock);
- list_for_each_entry(login, &sess->login_list, link) {
- if (login->login_id == login_id)
- found = login;
- }
- spin_unlock_bh(&sess->lock);
- }
- spin_unlock_bh(&tpg->se_tpg.session_lock);
-
- return found;
-}
-
-static u32 sbp_get_lun_from_tpg(struct sbp_tpg *tpg, u32 login_lun, int *err)
-{
- struct se_portal_group *se_tpg = &tpg->se_tpg;
- struct se_lun *se_lun;
-
- rcu_read_lock();
- hlist_for_each_entry_rcu(se_lun, &se_tpg->tpg_lun_hlist, link) {
- if (se_lun->unpacked_lun == login_lun) {
- rcu_read_unlock();
- *err = 0;
- return login_lun;
- }
- }
- rcu_read_unlock();
-
- *err = -ENODEV;
- return login_lun;
-}
-
-static struct sbp_session *sbp_session_create(
- struct sbp_tpg *tpg,
- u64 guid)
-{
- struct sbp_session *sess;
- int ret;
- char guid_str[17];
-
- snprintf(guid_str, sizeof(guid_str), "%016llx", guid);
-
- sess = kmalloc(sizeof(*sess), GFP_KERNEL);
- if (!sess)
- return ERR_PTR(-ENOMEM);
-
- spin_lock_init(&sess->lock);
- INIT_LIST_HEAD(&sess->login_list);
- INIT_DELAYED_WORK(&sess->maint_work, session_maintenance_work);
- sess->guid = guid;
-
- sess->se_sess = target_setup_session(&tpg->se_tpg, 128,
- sizeof(struct sbp_target_request),
- TARGET_PROT_NORMAL, guid_str,
- sess, NULL);
- if (IS_ERR(sess->se_sess)) {
- pr_err("failed to init se_session\n");
- ret = PTR_ERR(sess->se_sess);
- kfree(sess);
- return ERR_PTR(ret);
- }
-
- return sess;
-}
-
-static void sbp_session_release(struct sbp_session *sess, bool cancel_work)
-{
- spin_lock_bh(&sess->lock);
- if (!list_empty(&sess->login_list)) {
- spin_unlock_bh(&sess->lock);
- return;
- }
- spin_unlock_bh(&sess->lock);
-
- if (cancel_work)
- cancel_delayed_work_sync(&sess->maint_work);
-
- target_remove_session(sess->se_sess);
-
- if (sess->card)
- fw_card_put(sess->card);
-
- kfree(sess);
-}
-
-static void sbp_target_agent_unregister(struct sbp_target_agent *);
-
-static void sbp_login_release(struct sbp_login_descriptor *login,
- bool cancel_work)
-{
- struct sbp_session *sess = login->sess;
-
- /* FIXME: abort/wait on tasks */
-
- sbp_target_agent_unregister(login->tgt_agt);
-
- if (sess) {
- spin_lock_bh(&sess->lock);
- list_del(&login->link);
- spin_unlock_bh(&sess->lock);
-
- sbp_session_release(sess, cancel_work);
- }
-
- kfree(login);
-}
-
-static struct sbp_target_agent *sbp_target_agent_register(
- struct sbp_login_descriptor *);
-
-static void sbp_management_request_login(
- struct sbp_management_agent *agent, struct sbp_management_request *req,
- int *status_data_size)
-{
- struct sbp_tport *tport = agent->tport;
- struct sbp_tpg *tpg = tport->tpg;
- struct sbp_session *sess;
- struct sbp_login_descriptor *login;
- struct sbp_login_response_block *response;
- u64 guid;
- u32 unpacked_lun;
- int login_response_len, ret;
-
- unpacked_lun = sbp_get_lun_from_tpg(tpg,
- LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)), &ret);
- if (ret) {
- pr_notice("login to unknown LUN: %d\n",
- LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)));
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LUN_NOTSUPP));
- return;
- }
-
- ret = read_peer_guid(&guid, req);
- if (ret != RCODE_COMPLETE) {
- pr_warn("failed to read peer GUID: %d\n", ret);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
- return;
- }
-
- pr_notice("mgt_agent LOGIN to LUN %d from %016llx\n",
- unpacked_lun, guid);
-
- sess = sbp_session_find_by_guid(tpg, guid);
- if (sess) {
- login = sbp_login_find_by_lun(sess, unpacked_lun);
- if (login) {
- pr_notice("initiator already logged-in\n");
-
- /*
- * SBP-2 R4 says we should return access denied, but
- * that can confuse initiators. Instead we need to
- * treat this like a reconnect, but send the login
- * response block like a fresh login.
- *
- * This is required particularly in the case of Apple
- * devices booting off the FireWire target, where
- * the firmware has an active login to the target. When
- * the OS takes control of the session it issues its own
- * LOGIN rather than a RECONNECT. To avoid the machine
- * waiting until the reconnect_hold expires, we can skip
- * the ACCESS_DENIED errors to speed things up.
- */
-
- goto already_logged_in;
- }
- }
-
- /*
- * check exclusive bit in login request
- * reject with access_denied if any logins present
- */
- if (LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc)) &&
- sbp_login_count_all_by_lun(tpg, unpacked_lun, 0)) {
- pr_warn("refusing exclusive login with other active logins\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
- return;
- }
-
- /*
- * check exclusive bit in any existing login descriptor
- * reject with access_denied if any exclusive logins present
- */
- if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 1)) {
- pr_warn("refusing login while another exclusive login present\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
- return;
- }
-
- /*
- * check we haven't exceeded the number of allowed logins
- * reject with resources_unavailable if we have
- */
- if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 0) >=
- tport->max_logins_per_lun) {
- pr_warn("max number of logins reached\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
- return;
- }
-
- if (!sess) {
- sess = sbp_session_create(tpg, guid);
- if (IS_ERR(sess)) {
- switch (PTR_ERR(sess)) {
- case -EPERM:
- ret = SBP_STATUS_ACCESS_DENIED;
- break;
- default:
- ret = SBP_STATUS_RESOURCES_UNAVAIL;
- break;
- }
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(
- STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(ret));
- return;
- }
-
- sess->node_id = req->node_addr;
- sess->card = fw_card_get(req->card);
- sess->generation = req->generation;
- sess->speed = req->speed;
-
- schedule_delayed_work(&sess->maint_work,
- SESSION_MAINTENANCE_INTERVAL);
- }
-
- /* only take the latest reconnect_hold into account */
- sess->reconnect_hold = min(
- 1 << LOGIN_ORB_RECONNECT(be32_to_cpu(req->orb.misc)),
- tport->max_reconnect_timeout) - 1;
-
- login = kmalloc(sizeof(*login), GFP_KERNEL);
- if (!login) {
- pr_err("failed to allocate login descriptor\n");
-
- sbp_session_release(sess, true);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
- return;
- }
-
- login->sess = sess;
- login->login_lun = unpacked_lun;
- login->status_fifo_addr = sbp2_pointer_to_addr(&req->orb.status_fifo);
- login->exclusive = LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc));
- login->login_id = atomic_inc_return(&login_id);
-
- login->tgt_agt = sbp_target_agent_register(login);
- if (IS_ERR(login->tgt_agt)) {
- ret = PTR_ERR(login->tgt_agt);
- pr_err("failed to map command block handler: %d\n", ret);
-
- sbp_session_release(sess, true);
- kfree(login);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
- return;
- }
-
- spin_lock_bh(&sess->lock);
- list_add_tail(&login->link, &sess->login_list);
- spin_unlock_bh(&sess->lock);
-
-already_logged_in:
- response = kzalloc(sizeof(*response), GFP_KERNEL);
- if (!response) {
- pr_err("failed to allocate login response block\n");
-
- sbp_login_release(login, true);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
- return;
- }
-
- login_response_len = clamp_val(
- LOGIN_ORB_RESPONSE_LENGTH(be32_to_cpu(req->orb.length)),
- 12, sizeof(*response));
- response->misc = cpu_to_be32(
- ((login_response_len & 0xffff) << 16) |
- (login->login_id & 0xffff));
- response->reconnect_hold = cpu_to_be32(sess->reconnect_hold & 0xffff);
- addr_to_sbp2_pointer(login->tgt_agt->handler.offset,
- &response->command_block_agent);
-
- ret = sbp_run_transaction(sess->card, TCODE_WRITE_BLOCK_REQUEST,
- sess->node_id, sess->generation, sess->speed,
- sbp2_pointer_to_addr(&req->orb.ptr2), response,
- login_response_len);
- if (ret != RCODE_COMPLETE) {
- pr_debug("failed to write login response block: %x\n", ret);
-
- kfree(response);
- sbp_login_release(login, true);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
- return;
- }
-
- kfree(response);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
-}
-
-static void sbp_management_request_query_logins(
- struct sbp_management_agent *agent, struct sbp_management_request *req,
- int *status_data_size)
-{
- pr_notice("QUERY LOGINS not implemented\n");
- /* FIXME: implement */
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-}
-
-static void sbp_management_request_reconnect(
- struct sbp_management_agent *agent, struct sbp_management_request *req,
- int *status_data_size)
-{
- struct sbp_tport *tport = agent->tport;
- struct sbp_tpg *tpg = tport->tpg;
- int ret;
- u64 guid;
- struct sbp_login_descriptor *login;
-
- ret = read_peer_guid(&guid, req);
- if (ret != RCODE_COMPLETE) {
- pr_warn("failed to read peer GUID: %d\n", ret);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
- return;
- }
-
- pr_notice("mgt_agent RECONNECT from %016llx\n", guid);
-
- login = sbp_login_find_by_id(tpg,
- RECONNECT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc)));
-
- if (!login) {
- pr_err("mgt_agent RECONNECT unknown login ID\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
- return;
- }
-
- if (login->sess->guid != guid) {
- pr_err("mgt_agent RECONNECT login GUID doesn't match\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
- return;
- }
-
- spin_lock_bh(&login->sess->lock);
- if (login->sess->card)
- fw_card_put(login->sess->card);
-
- /* update the node details */
- login->sess->generation = req->generation;
- login->sess->node_id = req->node_addr;
- login->sess->card = fw_card_get(req->card);
- login->sess->speed = req->speed;
- spin_unlock_bh(&login->sess->lock);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
-}
-
-static void sbp_management_request_logout(
- struct sbp_management_agent *agent, struct sbp_management_request *req,
- int *status_data_size)
-{
- struct sbp_tport *tport = agent->tport;
- struct sbp_tpg *tpg = tport->tpg;
- int id;
- struct sbp_login_descriptor *login;
-
- id = LOGOUT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc));
-
- login = sbp_login_find_by_id(tpg, id);
- if (!login) {
- pr_warn("cannot find login: %d\n", id);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LOGIN_ID_UNKNOWN));
- return;
- }
-
- pr_info("mgt_agent LOGOUT from LUN %d session %d\n",
- login->login_lun, login->login_id);
-
- if (req->node_addr != login->sess->node_id) {
- pr_warn("logout from different node ID\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
- return;
- }
-
- sbp_login_release(login, true);
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
-}
-
-static void session_check_for_reset(struct sbp_session *sess)
-{
- bool card_valid = false;
-
- spin_lock_bh(&sess->lock);
-
- if (sess->card) {
- spin_lock_irq(&sess->card->lock);
- card_valid = (sess->card->local_node != NULL);
- spin_unlock_irq(&sess->card->lock);
-
- if (!card_valid) {
- fw_card_put(sess->card);
- sess->card = NULL;
- }
- }
-
- if (!card_valid || (sess->generation != sess->card->generation)) {
- pr_info("Waiting for reconnect from node: %016llx\n",
- sess->guid);
-
- sess->node_id = -1;
- sess->reconnect_expires = get_jiffies_64() +
- ((sess->reconnect_hold + 1) * HZ);
- }
-
- spin_unlock_bh(&sess->lock);
-}
-
-static void session_reconnect_expired(struct sbp_session *sess)
-{
- struct sbp_login_descriptor *login, *temp;
- LIST_HEAD(login_list);
-
- pr_info("Reconnect timer expired for node: %016llx\n", sess->guid);
-
- spin_lock_bh(&sess->lock);
- list_for_each_entry_safe(login, temp, &sess->login_list, link) {
- login->sess = NULL;
- list_move_tail(&login->link, &login_list);
- }
- spin_unlock_bh(&sess->lock);
-
- list_for_each_entry_safe(login, temp, &login_list, link) {
- list_del(&login->link);
- sbp_login_release(login, false);
- }
-
- sbp_session_release(sess, false);
-}
-
-static void session_maintenance_work(struct work_struct *work)
-{
- struct sbp_session *sess = container_of(work, struct sbp_session,
- maint_work.work);
-
- /* could be called while tearing down the session */
- spin_lock_bh(&sess->lock);
- if (list_empty(&sess->login_list)) {
- spin_unlock_bh(&sess->lock);
- return;
- }
- spin_unlock_bh(&sess->lock);
-
- if (sess->node_id != -1) {
- /* check for bus reset and make node_id invalid */
- session_check_for_reset(sess);
-
- schedule_delayed_work(&sess->maint_work,
- SESSION_MAINTENANCE_INTERVAL);
- } else if (!time_after64(get_jiffies_64(), sess->reconnect_expires)) {
- /* still waiting for reconnect */
- schedule_delayed_work(&sess->maint_work,
- SESSION_MAINTENANCE_INTERVAL);
- } else {
- /* reconnect timeout has expired */
- session_reconnect_expired(sess);
- }
-}
-
-static int tgt_agent_rw_agent_state(struct fw_card *card, int tcode, void *data,
- struct sbp_target_agent *agent)
-{
- int state;
-
- switch (tcode) {
- case TCODE_READ_QUADLET_REQUEST:
- pr_debug("tgt_agent AGENT_STATE READ\n");
-
- spin_lock_bh(&agent->lock);
- state = agent->state;
- spin_unlock_bh(&agent->lock);
-
- *(__be32 *)data = cpu_to_be32(state);
-
- return RCODE_COMPLETE;
-
- case TCODE_WRITE_QUADLET_REQUEST:
- /* ignored */
- return RCODE_COMPLETE;
-
- default:
- return RCODE_TYPE_ERROR;
- }
-}
-
-static int tgt_agent_rw_agent_reset(struct fw_card *card, int tcode, void *data,
- struct sbp_target_agent *agent)
-{
- switch (tcode) {
- case TCODE_WRITE_QUADLET_REQUEST:
- pr_debug("tgt_agent AGENT_RESET\n");
- spin_lock_bh(&agent->lock);
- agent->state = AGENT_STATE_RESET;
- spin_unlock_bh(&agent->lock);
- return RCODE_COMPLETE;
-
- default:
- return RCODE_TYPE_ERROR;
- }
-}
-
-static int tgt_agent_rw_orb_pointer(struct fw_card *card, int tcode, void *data,
- struct sbp_target_agent *agent)
-{
- struct sbp2_pointer *ptr = data;
-
- switch (tcode) {
- case TCODE_WRITE_BLOCK_REQUEST:
- spin_lock_bh(&agent->lock);
- if (agent->state != AGENT_STATE_SUSPENDED &&
- agent->state != AGENT_STATE_RESET) {
- spin_unlock_bh(&agent->lock);
- pr_notice("Ignoring ORB_POINTER write while active.\n");
- return RCODE_CONFLICT_ERROR;
- }
- agent->state = AGENT_STATE_ACTIVE;
- spin_unlock_bh(&agent->lock);
-
- agent->orb_pointer = sbp2_pointer_to_addr(ptr);
- agent->doorbell = false;
-
- pr_debug("tgt_agent ORB_POINTER write: 0x%llx\n",
- agent->orb_pointer);
-
- queue_work(system_unbound_wq, &agent->work);
-
- return RCODE_COMPLETE;
-
- case TCODE_READ_BLOCK_REQUEST:
- pr_debug("tgt_agent ORB_POINTER READ\n");
- spin_lock_bh(&agent->lock);
- addr_to_sbp2_pointer(agent->orb_pointer, ptr);
- spin_unlock_bh(&agent->lock);
- return RCODE_COMPLETE;
-
- default:
- return RCODE_TYPE_ERROR;
- }
-}
-
-static int tgt_agent_rw_doorbell(struct fw_card *card, int tcode, void *data,
- struct sbp_target_agent *agent)
-{
- switch (tcode) {
- case TCODE_WRITE_QUADLET_REQUEST:
- spin_lock_bh(&agent->lock);
- if (agent->state != AGENT_STATE_SUSPENDED) {
- spin_unlock_bh(&agent->lock);
- pr_debug("Ignoring DOORBELL while active.\n");
- return RCODE_CONFLICT_ERROR;
- }
- agent->state = AGENT_STATE_ACTIVE;
- spin_unlock_bh(&agent->lock);
-
- agent->doorbell = true;
-
- pr_debug("tgt_agent DOORBELL\n");
-
- queue_work(system_unbound_wq, &agent->work);
-
- return RCODE_COMPLETE;
-
- case TCODE_READ_QUADLET_REQUEST:
- return RCODE_COMPLETE;
-
- default:
- return RCODE_TYPE_ERROR;
- }
-}
-
-static int tgt_agent_rw_unsolicited_status_enable(struct fw_card *card,
- int tcode, void *data, struct sbp_target_agent *agent)
-{
- switch (tcode) {
- case TCODE_WRITE_QUADLET_REQUEST:
- pr_debug("tgt_agent UNSOLICITED_STATUS_ENABLE\n");
- /* ignored as we don't send unsolicited status */
- return RCODE_COMPLETE;
-
- case TCODE_READ_QUADLET_REQUEST:
- return RCODE_COMPLETE;
-
- default:
- return RCODE_TYPE_ERROR;
- }
-}
-
-static void tgt_agent_rw(struct fw_card *card, struct fw_request *request,
- int tcode, int destination, int source, int generation,
- unsigned long long offset, void *data, size_t length,
- void *callback_data)
-{
- struct sbp_target_agent *agent = callback_data;
- struct sbp_session *sess = agent->login->sess;
- int sess_gen, sess_node, rcode;
-
- spin_lock_bh(&sess->lock);
- sess_gen = sess->generation;
- sess_node = sess->node_id;
- spin_unlock_bh(&sess->lock);
-
- if (generation != sess_gen) {
- pr_notice("ignoring request with wrong generation\n");
- rcode = RCODE_TYPE_ERROR;
- goto out;
- }
-
- if (source != sess_node) {
- pr_notice("ignoring request from foreign node (%x != %x)\n",
- source, sess_node);
- rcode = RCODE_TYPE_ERROR;
- goto out;
- }
-
- /* turn offset into the offset from the start of the block */
- offset -= agent->handler.offset;
-
- if (offset == 0x00 && length == 4) {
- /* AGENT_STATE */
- rcode = tgt_agent_rw_agent_state(card, tcode, data, agent);
- } else if (offset == 0x04 && length == 4) {
- /* AGENT_RESET */
- rcode = tgt_agent_rw_agent_reset(card, tcode, data, agent);
- } else if (offset == 0x08 && length == 8) {
- /* ORB_POINTER */
- rcode = tgt_agent_rw_orb_pointer(card, tcode, data, agent);
- } else if (offset == 0x10 && length == 4) {
- /* DOORBELL */
- rcode = tgt_agent_rw_doorbell(card, tcode, data, agent);
- } else if (offset == 0x14 && length == 4) {
- /* UNSOLICITED_STATUS_ENABLE */
- rcode = tgt_agent_rw_unsolicited_status_enable(card, tcode,
- data, agent);
- } else {
- rcode = RCODE_ADDRESS_ERROR;
- }
-
-out:
- fw_send_response(card, request, rcode);
-}
-
-static void sbp_handle_command(struct sbp_target_request *);
-static int sbp_send_status(struct sbp_target_request *);
-static void sbp_free_request(struct sbp_target_request *);
-
-static void tgt_agent_process_work(struct work_struct *work)
-{
- struct sbp_target_request *req =
- container_of(work, struct sbp_target_request, work);
-
- pr_debug("tgt_orb ptr:0x%llx next_ORB:0x%llx data_descriptor:0x%llx misc:0x%x\n",
- req->orb_pointer,
- sbp2_pointer_to_addr(&req->orb.next_orb),
- sbp2_pointer_to_addr(&req->orb.data_descriptor),
- be32_to_cpu(req->orb.misc));
-
- if (req->orb_pointer >> 32)
- pr_debug("ORB with high bits set\n");
-
- switch (ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc))) {
- case 0:/* Format specified by this standard */
- sbp_handle_command(req);
- return;
- case 1: /* Reserved for future standardization */
- case 2: /* Vendor-dependent */
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_RESP(
- STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_DEAD(0) |
- STATUS_BLOCK_LEN(1) |
- STATUS_BLOCK_SBP_STATUS(
- SBP_STATUS_REQ_TYPE_NOTSUPP));
- sbp_send_status(req);
- return;
- case 3: /* Dummy ORB */
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_RESP(
- STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_DEAD(0) |
- STATUS_BLOCK_LEN(1) |
- STATUS_BLOCK_SBP_STATUS(
- SBP_STATUS_DUMMY_ORB_COMPLETE));
- sbp_send_status(req);
- return;
- default:
- BUG();
- }
-}
-
-/* used to double-check we haven't been issued an AGENT_RESET */
-static inline bool tgt_agent_check_active(struct sbp_target_agent *agent)
-{
- bool active;
-
- spin_lock_bh(&agent->lock);
- active = (agent->state == AGENT_STATE_ACTIVE);
- spin_unlock_bh(&agent->lock);
-
- return active;
-}
-
-static struct sbp_target_request *sbp_mgt_get_req(struct sbp_session *sess,
- struct fw_card *card, u64 next_orb)
-{
- struct se_session *se_sess = sess->se_sess;
- struct sbp_target_request *req;
- int tag, cpu;
-
- tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu);
- if (tag < 0)
- return ERR_PTR(-ENOMEM);
-
- req = &((struct sbp_target_request *)se_sess->sess_cmd_map)[tag];
- memset(req, 0, sizeof(*req));
- req->se_cmd.map_tag = tag;
- req->se_cmd.map_cpu = cpu;
- req->se_cmd.tag = next_orb;
-
- return req;
-}
-
-static void tgt_agent_fetch_work(struct work_struct *work)
-{
- struct sbp_target_agent *agent =
- container_of(work, struct sbp_target_agent, work);
- struct sbp_session *sess = agent->login->sess;
- struct sbp_target_request *req;
- int ret;
- bool doorbell = agent->doorbell;
- u64 next_orb = agent->orb_pointer;
-
- while (next_orb && tgt_agent_check_active(agent)) {
- req = sbp_mgt_get_req(sess, sess->card, next_orb);
- if (IS_ERR(req)) {
- spin_lock_bh(&agent->lock);
- agent->state = AGENT_STATE_DEAD;
- spin_unlock_bh(&agent->lock);
- return;
- }
-
- req->login = agent->login;
- req->orb_pointer = next_orb;
-
- req->status.status = cpu_to_be32(STATUS_BLOCK_ORB_OFFSET_HIGH(
- req->orb_pointer >> 32));
- req->status.orb_low = cpu_to_be32(
- req->orb_pointer & 0xfffffffc);
-
- /* read in the ORB */
- ret = sbp_run_transaction(sess->card, TCODE_READ_BLOCK_REQUEST,
- sess->node_id, sess->generation, sess->speed,
- req->orb_pointer, &req->orb, sizeof(req->orb));
- if (ret != RCODE_COMPLETE) {
- pr_debug("tgt_orb fetch failed: %x\n", ret);
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_SRC(
- STATUS_SRC_ORB_FINISHED) |
- STATUS_BLOCK_RESP(
- STATUS_RESP_TRANSPORT_FAILURE) |
- STATUS_BLOCK_DEAD(1) |
- STATUS_BLOCK_LEN(1) |
- STATUS_BLOCK_SBP_STATUS(
- SBP_STATUS_UNSPECIFIED_ERROR));
- spin_lock_bh(&agent->lock);
- agent->state = AGENT_STATE_DEAD;
- spin_unlock_bh(&agent->lock);
-
- sbp_send_status(req);
- return;
- }
-
- /* check the next_ORB field */
- if (be32_to_cpu(req->orb.next_orb.high) & 0x80000000) {
- next_orb = 0;
- req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
- STATUS_SRC_ORB_FINISHED));
- } else {
- next_orb = sbp2_pointer_to_addr(&req->orb.next_orb);
- req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
- STATUS_SRC_ORB_CONTINUING));
- }
-
- if (tgt_agent_check_active(agent) && !doorbell) {
- INIT_WORK(&req->work, tgt_agent_process_work);
- queue_work(system_unbound_wq, &req->work);
- } else {
- /* don't process this request, just check next_ORB */
- sbp_free_request(req);
- }
-
- spin_lock_bh(&agent->lock);
- doorbell = agent->doorbell = false;
-
- /* check if we should carry on processing */
- if (next_orb)
- agent->orb_pointer = next_orb;
- else
- agent->state = AGENT_STATE_SUSPENDED;
-
- spin_unlock_bh(&agent->lock);
- };
-}
-
-static struct sbp_target_agent *sbp_target_agent_register(
- struct sbp_login_descriptor *login)
-{
- struct sbp_target_agent *agent;
- int ret;
-
- agent = kmalloc(sizeof(*agent), GFP_KERNEL);
- if (!agent)
- return ERR_PTR(-ENOMEM);
-
- spin_lock_init(&agent->lock);
-
- agent->handler.length = 0x20;
- agent->handler.address_callback = tgt_agent_rw;
- agent->handler.callback_data = agent;
-
- agent->login = login;
- agent->state = AGENT_STATE_RESET;
- INIT_WORK(&agent->work, tgt_agent_fetch_work);
- agent->orb_pointer = 0;
- agent->doorbell = false;
-
- ret = fw_core_add_address_handler(&agent->handler,
- &sbp_register_region);
- if (ret < 0) {
- kfree(agent);
- return ERR_PTR(ret);
- }
-
- return agent;
-}
-
-static void sbp_target_agent_unregister(struct sbp_target_agent *agent)
-{
- fw_core_remove_address_handler(&agent->handler);
- cancel_work_sync(&agent->work);
- kfree(agent);
-}
-
-/*
- * Simple wrapper around fw_run_transaction that retries the transaction several
- * times in case of failure, with an exponential backoff.
- */
-static int sbp_run_transaction(struct fw_card *card, int tcode, int destination_id,
- int generation, int speed, unsigned long long offset,
- void *payload, size_t length)
-{
- int attempt, ret, delay;
-
- for (attempt = 1; attempt <= 5; attempt++) {
- ret = fw_run_transaction(card, tcode, destination_id,
- generation, speed, offset, payload, length);
-
- switch (ret) {
- case RCODE_COMPLETE:
- case RCODE_TYPE_ERROR:
- case RCODE_ADDRESS_ERROR:
- case RCODE_GENERATION:
- return ret;
-
- default:
- delay = 5 * attempt * attempt;
- usleep_range(delay, delay * 2);
- }
- }
-
- return ret;
-}
-
-/*
- * Wrapper around sbp_run_transaction that gets the card, destination,
- * generation and speed out of the request's session.
- */
-static int sbp_run_request_transaction(struct sbp_target_request *req,
- int tcode, unsigned long long offset, void *payload,
- size_t length)
-{
- struct sbp_login_descriptor *login = req->login;
- struct sbp_session *sess = login->sess;
- struct fw_card *card;
- int node_id, generation, speed, ret;
-
- spin_lock_bh(&sess->lock);
- card = fw_card_get(sess->card);
- node_id = sess->node_id;
- generation = sess->generation;
- speed = sess->speed;
- spin_unlock_bh(&sess->lock);
-
- ret = sbp_run_transaction(card, tcode, node_id, generation, speed,
- offset, payload, length);
-
- fw_card_put(card);
-
- return ret;
-}
-
-static int sbp_fetch_command(struct sbp_target_request *req)
-{
- int ret, cmd_len, copy_len;
-
- cmd_len = scsi_command_size(req->orb.command_block);
-
- req->cmd_buf = kmalloc(cmd_len, GFP_KERNEL);
- if (!req->cmd_buf)
- return -ENOMEM;
-
- memcpy(req->cmd_buf, req->orb.command_block,
- min_t(int, cmd_len, sizeof(req->orb.command_block)));
-
- if (cmd_len > sizeof(req->orb.command_block)) {
- pr_debug("sbp_fetch_command: filling in long command\n");
- copy_len = cmd_len - sizeof(req->orb.command_block);
-
- ret = sbp_run_request_transaction(req,
- TCODE_READ_BLOCK_REQUEST,
- req->orb_pointer + sizeof(req->orb),
- req->cmd_buf + sizeof(req->orb.command_block),
- copy_len);
- if (ret != RCODE_COMPLETE)
- return -EIO;
- }
-
- return 0;
-}
-
-static int sbp_fetch_page_table(struct sbp_target_request *req)
-{
- int pg_tbl_sz, ret;
- struct sbp_page_table_entry *pg_tbl;
-
- if (!CMDBLK_ORB_PG_TBL_PRESENT(be32_to_cpu(req->orb.misc)))
- return 0;
-
- pg_tbl_sz = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc)) *
- sizeof(struct sbp_page_table_entry);
-
- pg_tbl = kmalloc(pg_tbl_sz, GFP_KERNEL);
- if (!pg_tbl)
- return -ENOMEM;
-
- ret = sbp_run_request_transaction(req, TCODE_READ_BLOCK_REQUEST,
- sbp2_pointer_to_addr(&req->orb.data_descriptor),
- pg_tbl, pg_tbl_sz);
- if (ret != RCODE_COMPLETE) {
- kfree(pg_tbl);
- return -EIO;
- }
-
- req->pg_tbl = pg_tbl;
- return 0;
-}
-
-static void sbp_calc_data_length_direction(struct sbp_target_request *req,
- u32 *data_len, enum dma_data_direction *data_dir)
-{
- int data_size, direction, idx;
-
- data_size = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
- direction = CMDBLK_ORB_DIRECTION(be32_to_cpu(req->orb.misc));
-
- if (!data_size) {
- *data_len = 0;
- *data_dir = DMA_NONE;
- return;
- }
-
- *data_dir = direction ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
-
- if (req->pg_tbl) {
- *data_len = 0;
- for (idx = 0; idx < data_size; idx++) {
- *data_len += be16_to_cpu(
- req->pg_tbl[idx].segment_length);
- }
- } else {
- *data_len = data_size;
- }
-}
-
-static void sbp_handle_command(struct sbp_target_request *req)
-{
- struct sbp_login_descriptor *login = req->login;
- struct sbp_session *sess = login->sess;
- int ret, unpacked_lun;
- u32 data_length;
- enum dma_data_direction data_dir;
-
- ret = sbp_fetch_command(req);
- if (ret) {
- pr_debug("sbp_handle_command: fetch command failed: %d\n", ret);
- goto err;
- }
-
- ret = sbp_fetch_page_table(req);
- if (ret) {
- pr_debug("sbp_handle_command: fetch page table failed: %d\n",
- ret);
- goto err;
- }
-
- unpacked_lun = req->login->login_lun;
- sbp_calc_data_length_direction(req, &data_length, &data_dir);
-
- pr_debug("sbp_handle_command ORB:0x%llx unpacked_lun:%d data_len:%d data_dir:%d\n",
- req->orb_pointer, unpacked_lun, data_length, data_dir);
-
- /* only used for printk until we do TMRs */
- req->se_cmd.tag = req->orb_pointer;
- if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
- req->sense_buf, unpacked_lun, data_length,
- TCM_SIMPLE_TAG, data_dir, TARGET_SCF_ACK_KREF))
- goto err;
-
- return;
-
-err:
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
- STATUS_BLOCK_DEAD(0) |
- STATUS_BLOCK_LEN(1) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
- sbp_send_status(req);
-}
-
-/*
- * DMA_TO_DEVICE = read from initiator (SCSI WRITE)
- * DMA_FROM_DEVICE = write to initiator (SCSI READ)
- */
-static int sbp_rw_data(struct sbp_target_request *req)
-{
- struct sbp_session *sess = req->login->sess;
- int tcode, sg_miter_flags, max_payload, pg_size, speed, node_id,
- generation, num_pte, length, tfr_length,
- rcode = RCODE_COMPLETE;
- struct sbp_page_table_entry *pte;
- unsigned long long offset;
- struct fw_card *card;
- struct sg_mapping_iter iter;
-
- if (req->se_cmd.data_direction == DMA_FROM_DEVICE) {
- tcode = TCODE_WRITE_BLOCK_REQUEST;
- sg_miter_flags = SG_MITER_FROM_SG;
- } else {
- tcode = TCODE_READ_BLOCK_REQUEST;
- sg_miter_flags = SG_MITER_TO_SG;
- }
-
- max_payload = 4 << CMDBLK_ORB_MAX_PAYLOAD(be32_to_cpu(req->orb.misc));
- speed = CMDBLK_ORB_SPEED(be32_to_cpu(req->orb.misc));
-
- pg_size = CMDBLK_ORB_PG_SIZE(be32_to_cpu(req->orb.misc));
- if (pg_size) {
- pr_err("sbp_run_transaction: page size ignored\n");
- pg_size = 0x100 << pg_size;
- }
-
- spin_lock_bh(&sess->lock);
- card = fw_card_get(sess->card);
- node_id = sess->node_id;
- generation = sess->generation;
- spin_unlock_bh(&sess->lock);
-
- if (req->pg_tbl) {
- pte = req->pg_tbl;
- num_pte = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
-
- offset = 0;
- length = 0;
- } else {
- pte = NULL;
- num_pte = 0;
-
- offset = sbp2_pointer_to_addr(&req->orb.data_descriptor);
- length = req->se_cmd.data_length;
- }
-
- sg_miter_start(&iter, req->se_cmd.t_data_sg, req->se_cmd.t_data_nents,
- sg_miter_flags);
-
- while (length || num_pte) {
- if (!length) {
- offset = (u64)be16_to_cpu(pte->segment_base_hi) << 32 |
- be32_to_cpu(pte->segment_base_lo);
- length = be16_to_cpu(pte->segment_length);
-
- pte++;
- num_pte--;
- }
-
- sg_miter_next(&iter);
-
- tfr_length = min3(length, max_payload, (int)iter.length);
-
- /* FIXME: take page_size into account */
-
- rcode = sbp_run_transaction(card, tcode, node_id,
- generation, speed,
- offset, iter.addr, tfr_length);
-
- if (rcode != RCODE_COMPLETE)
- break;
-
- length -= tfr_length;
- offset += tfr_length;
- iter.consumed = tfr_length;
- }
-
- sg_miter_stop(&iter);
- fw_card_put(card);
-
- if (rcode == RCODE_COMPLETE) {
- WARN_ON(length != 0);
- return 0;
- } else {
- return -EIO;
- }
-}
-
-static int sbp_send_status(struct sbp_target_request *req)
-{
- int rc, ret = 0, length;
- struct sbp_login_descriptor *login = req->login;
-
- length = (((be32_to_cpu(req->status.status) >> 24) & 0x07) + 1) * 4;
-
- rc = sbp_run_request_transaction(req, TCODE_WRITE_BLOCK_REQUEST,
- login->status_fifo_addr, &req->status, length);
- if (rc != RCODE_COMPLETE) {
- pr_debug("sbp_send_status: write failed: 0x%x\n", rc);
- ret = -EIO;
- goto put_ref;
- }
-
- pr_debug("sbp_send_status: status write complete for ORB: 0x%llx\n",
- req->orb_pointer);
- /*
- * Drop the extra ACK_KREF reference taken by target_submit_cmd()
- * ahead of sbp_check_stop_free() -> transport_generic_free_cmd()
- * final se_cmd->cmd_kref put.
- */
-put_ref:
- target_put_sess_cmd(&req->se_cmd);
- return ret;
-}
-
-static void sbp_sense_mangle(struct sbp_target_request *req)
-{
- struct se_cmd *se_cmd = &req->se_cmd;
- u8 *sense = req->sense_buf;
- u8 *status = req->status.data;
-
- WARN_ON(se_cmd->scsi_sense_length < 18);
-
- switch (sense[0] & 0x7f) { /* sfmt */
- case 0x70: /* current, fixed */
- status[0] = 0 << 6;
- break;
- case 0x71: /* deferred, fixed */
- status[0] = 1 << 6;
- break;
- case 0x72: /* current, descriptor */
- case 0x73: /* deferred, descriptor */
- default:
- /*
- * TODO: SBP-3 specifies what we should do with descriptor
- * format sense data
- */
- pr_err("sbp_send_sense: unknown sense format: 0x%x\n",
- sense[0]);
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_DEAD(0) |
- STATUS_BLOCK_LEN(1) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQUEST_ABORTED));
- return;
- }
-
- status[0] |= se_cmd->scsi_status & 0x3f;/* status */
- status[1] =
- (sense[0] & 0x80) | /* valid */
- ((sense[2] & 0xe0) >> 1) | /* mark, eom, ili */
- (sense[2] & 0x0f); /* sense_key */
- status[2] = se_cmd->scsi_asc; /* sense_code */
- status[3] = se_cmd->scsi_ascq; /* sense_qualifier */
-
- /* information */
- status[4] = sense[3];
- status[5] = sense[4];
- status[6] = sense[5];
- status[7] = sense[6];
-
- /* CDB-dependent */
- status[8] = sense[8];
- status[9] = sense[9];
- status[10] = sense[10];
- status[11] = sense[11];
-
- /* fru */
- status[12] = sense[14];
-
- /* sense_key-dependent */
- status[13] = sense[15];
- status[14] = sense[16];
- status[15] = sense[17];
-
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_DEAD(0) |
- STATUS_BLOCK_LEN(5) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
-}
-
-static int sbp_send_sense(struct sbp_target_request *req)
-{
- struct se_cmd *se_cmd = &req->se_cmd;
-
- if (se_cmd->scsi_sense_length) {
- sbp_sense_mangle(req);
- } else {
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_DEAD(0) |
- STATUS_BLOCK_LEN(1) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
- }
-
- return sbp_send_status(req);
-}
-
-static void sbp_free_request(struct sbp_target_request *req)
-{
- struct se_cmd *se_cmd = &req->se_cmd;
- struct se_session *se_sess = se_cmd->se_sess;
-
- kfree(req->pg_tbl);
- kfree(req->cmd_buf);
-
- target_free_tag(se_sess, se_cmd);
-}
-
-static void sbp_mgt_agent_process(struct work_struct *work)
-{
- struct sbp_management_agent *agent =
- container_of(work, struct sbp_management_agent, work);
- struct sbp_management_request *req = agent->request;
- int ret;
- int status_data_len = 0;
-
- /* fetch the ORB from the initiator */
- ret = sbp_run_transaction(req->card, TCODE_READ_BLOCK_REQUEST,
- req->node_addr, req->generation, req->speed,
- agent->orb_offset, &req->orb, sizeof(req->orb));
- if (ret != RCODE_COMPLETE) {
- pr_debug("mgt_orb fetch failed: %x\n", ret);
- goto out;
- }
-
- pr_debug("mgt_orb ptr1:0x%llx ptr2:0x%llx misc:0x%x len:0x%x status_fifo:0x%llx\n",
- sbp2_pointer_to_addr(&req->orb.ptr1),
- sbp2_pointer_to_addr(&req->orb.ptr2),
- be32_to_cpu(req->orb.misc), be32_to_cpu(req->orb.length),
- sbp2_pointer_to_addr(&req->orb.status_fifo));
-
- if (!ORB_NOTIFY(be32_to_cpu(req->orb.misc)) ||
- ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc)) != 0) {
- pr_err("mgt_orb bad request\n");
- goto out;
- }
-
- switch (MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc))) {
- case MANAGEMENT_ORB_FUNCTION_LOGIN:
- sbp_management_request_login(agent, req, &status_data_len);
- break;
-
- case MANAGEMENT_ORB_FUNCTION_QUERY_LOGINS:
- sbp_management_request_query_logins(agent, req,
- &status_data_len);
- break;
-
- case MANAGEMENT_ORB_FUNCTION_RECONNECT:
- sbp_management_request_reconnect(agent, req, &status_data_len);
- break;
-
- case MANAGEMENT_ORB_FUNCTION_SET_PASSWORD:
- pr_notice("SET PASSWORD not implemented\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
- break;
-
- case MANAGEMENT_ORB_FUNCTION_LOGOUT:
- sbp_management_request_logout(agent, req, &status_data_len);
- break;
-
- case MANAGEMENT_ORB_FUNCTION_ABORT_TASK:
- pr_notice("ABORT TASK not implemented\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
- break;
-
- case MANAGEMENT_ORB_FUNCTION_ABORT_TASK_SET:
- pr_notice("ABORT TASK SET not implemented\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
- break;
-
- case MANAGEMENT_ORB_FUNCTION_LOGICAL_UNIT_RESET:
- pr_notice("LOGICAL UNIT RESET not implemented\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
- break;
-
- case MANAGEMENT_ORB_FUNCTION_TARGET_RESET:
- pr_notice("TARGET RESET not implemented\n");
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
- break;
-
- default:
- pr_notice("unknown management function 0x%x\n",
- MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc)));
-
- req->status.status = cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
-
- break;
- }
-
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_SRC(1) | /* Response to ORB, next_ORB absent */
- STATUS_BLOCK_LEN(DIV_ROUND_UP(status_data_len, 4) + 1) |
- STATUS_BLOCK_ORB_OFFSET_HIGH(agent->orb_offset >> 32));
- req->status.orb_low = cpu_to_be32(agent->orb_offset);
-
- /* write the status block back to the initiator */
- ret = sbp_run_transaction(req->card, TCODE_WRITE_BLOCK_REQUEST,
- req->node_addr, req->generation, req->speed,
- sbp2_pointer_to_addr(&req->orb.status_fifo),
- &req->status, 8 + status_data_len);
- if (ret != RCODE_COMPLETE) {
- pr_debug("mgt_orb status write failed: %x\n", ret);
- goto out;
- }
-
-out:
- fw_card_put(req->card);
- kfree(req);
-
- spin_lock_bh(&agent->lock);
- agent->state = MANAGEMENT_AGENT_STATE_IDLE;
- spin_unlock_bh(&agent->lock);
-}
-
-static void sbp_mgt_agent_rw(struct fw_card *card,
- struct fw_request *request, int tcode, int destination, int source,
- int generation, unsigned long long offset, void *data, size_t length,
- void *callback_data)
-{
- struct sbp_management_agent *agent = callback_data;
- struct sbp2_pointer *ptr = data;
- int rcode = RCODE_ADDRESS_ERROR;
-
- if (!agent->tport->enable)
- goto out;
-
- if ((offset != agent->handler.offset) || (length != 8))
- goto out;
-
- if (tcode == TCODE_WRITE_BLOCK_REQUEST) {
- struct sbp_management_request *req;
- int prev_state;
-
- spin_lock_bh(&agent->lock);
- prev_state = agent->state;
- agent->state = MANAGEMENT_AGENT_STATE_BUSY;
- spin_unlock_bh(&agent->lock);
-
- if (prev_state == MANAGEMENT_AGENT_STATE_BUSY) {
- pr_notice("ignoring management request while busy\n");
- rcode = RCODE_CONFLICT_ERROR;
- goto out;
- }
- req = kzalloc(sizeof(*req), GFP_ATOMIC);
- if (!req) {
- rcode = RCODE_CONFLICT_ERROR;
- goto out;
- }
-
- req->card = fw_card_get(card);
- req->generation = generation;
- req->node_addr = source;
- req->speed = fw_get_request_speed(request);
-
- agent->orb_offset = sbp2_pointer_to_addr(ptr);
- agent->request = req;
-
- queue_work(system_unbound_wq, &agent->work);
- rcode = RCODE_COMPLETE;
- } else if (tcode == TCODE_READ_BLOCK_REQUEST) {
- addr_to_sbp2_pointer(agent->orb_offset, ptr);
- rcode = RCODE_COMPLETE;
- } else {
- rcode = RCODE_TYPE_ERROR;
- }
-
-out:
- fw_send_response(card, request, rcode);
-}
-
-static struct sbp_management_agent *sbp_management_agent_register(
- struct sbp_tport *tport)
-{
- int ret;
- struct sbp_management_agent *agent;
-
- agent = kmalloc(sizeof(*agent), GFP_KERNEL);
- if (!agent)
- return ERR_PTR(-ENOMEM);
-
- spin_lock_init(&agent->lock);
- agent->tport = tport;
- agent->handler.length = 0x08;
- agent->handler.address_callback = sbp_mgt_agent_rw;
- agent->handler.callback_data = agent;
- agent->state = MANAGEMENT_AGENT_STATE_IDLE;
- INIT_WORK(&agent->work, sbp_mgt_agent_process);
- agent->orb_offset = 0;
- agent->request = NULL;
-
- ret = fw_core_add_address_handler(&agent->handler,
- &sbp_register_region);
- if (ret < 0) {
- kfree(agent);
- return ERR_PTR(ret);
- }
-
- return agent;
-}
-
-static void sbp_management_agent_unregister(struct sbp_management_agent *agent)
-{
- fw_core_remove_address_handler(&agent->handler);
- cancel_work_sync(&agent->work);
- kfree(agent);
-}
-
-static int sbp_check_true(struct se_portal_group *se_tpg)
-{
- return 1;
-}
-
-static int sbp_check_false(struct se_portal_group *se_tpg)
-{
- return 0;
-}
-
-static char *sbp_get_fabric_wwn(struct se_portal_group *se_tpg)
-{
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
-
- return &tport->tport_name[0];
-}
-
-static u16 sbp_get_tag(struct se_portal_group *se_tpg)
-{
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- return tpg->tport_tpgt;
-}
-
-static u32 sbp_tpg_get_inst_index(struct se_portal_group *se_tpg)
-{
- return 1;
-}
-
-static void sbp_release_cmd(struct se_cmd *se_cmd)
-{
- struct sbp_target_request *req = container_of(se_cmd,
- struct sbp_target_request, se_cmd);
-
- sbp_free_request(req);
-}
-
-static u32 sbp_sess_get_index(struct se_session *se_sess)
-{
- return 0;
-}
-
-static int sbp_write_pending(struct se_cmd *se_cmd)
-{
- struct sbp_target_request *req = container_of(se_cmd,
- struct sbp_target_request, se_cmd);
- int ret;
-
- ret = sbp_rw_data(req);
- if (ret) {
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_RESP(
- STATUS_RESP_TRANSPORT_FAILURE) |
- STATUS_BLOCK_DEAD(0) |
- STATUS_BLOCK_LEN(1) |
- STATUS_BLOCK_SBP_STATUS(
- SBP_STATUS_UNSPECIFIED_ERROR));
- sbp_send_status(req);
- return ret;
- }
-
- target_execute_cmd(se_cmd);
- return 0;
-}
-
-static void sbp_set_default_node_attrs(struct se_node_acl *nacl)
-{
- return;
-}
-
-static int sbp_get_cmd_state(struct se_cmd *se_cmd)
-{
- return 0;
-}
-
-static int sbp_queue_data_in(struct se_cmd *se_cmd)
-{
- struct sbp_target_request *req = container_of(se_cmd,
- struct sbp_target_request, se_cmd);
- int ret;
-
- ret = sbp_rw_data(req);
- if (ret) {
- req->status.status |= cpu_to_be32(
- STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
- STATUS_BLOCK_DEAD(0) |
- STATUS_BLOCK_LEN(1) |
- STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
- sbp_send_status(req);
- return ret;
- }
-
- return sbp_send_sense(req);
-}
-
-/*
- * Called after command (no data transfer) or after the write (to device)
- * operation is completed
- */
-static int sbp_queue_status(struct se_cmd *se_cmd)
-{
- struct sbp_target_request *req = container_of(se_cmd,
- struct sbp_target_request, se_cmd);
-
- return sbp_send_sense(req);
-}
-
-static void sbp_queue_tm_rsp(struct se_cmd *se_cmd)
-{
-}
-
-static void sbp_aborted_task(struct se_cmd *se_cmd)
-{
- return;
-}
-
-static int sbp_check_stop_free(struct se_cmd *se_cmd)
-{
- struct sbp_target_request *req = container_of(se_cmd,
- struct sbp_target_request, se_cmd);
-
- return transport_generic_free_cmd(&req->se_cmd, 0);
-}
-
-static int sbp_count_se_tpg_luns(struct se_portal_group *tpg)
-{
- struct se_lun *lun;
- int count = 0;
-
- rcu_read_lock();
- hlist_for_each_entry_rcu(lun, &tpg->tpg_lun_hlist, link)
- count++;
- rcu_read_unlock();
-
- return count;
-}
-
-static int sbp_update_unit_directory(struct sbp_tport *tport)
-{
- struct se_lun *lun;
- int num_luns, num_entries, idx = 0, mgt_agt_addr, ret;
- u32 *data;
-
- if (tport->unit_directory.data) {
- fw_core_remove_descriptor(&tport->unit_directory);
- kfree(tport->unit_directory.data);
- tport->unit_directory.data = NULL;
- }
-
- if (!tport->enable || !tport->tpg)
- return 0;
-
- num_luns = sbp_count_se_tpg_luns(&tport->tpg->se_tpg);
-
- /*
- * Number of entries in the final unit directory:
- * - all of those in the template
- * - management_agent
- * - unit_characteristics
- * - reconnect_timeout
- * - unit unique ID
- * - one for each LUN
- *
- * MUST NOT include leaf or sub-directory entries
- */
- num_entries = ARRAY_SIZE(sbp_unit_directory_template) + 4 + num_luns;
-
- if (tport->directory_id != -1)
- num_entries++;
-
- /* allocate num_entries + 4 for the header and unique ID leaf */
- data = kcalloc((num_entries + 4), sizeof(u32), GFP_KERNEL);
- if (!data)
- return -ENOMEM;
-
- /* directory_length */
- data[idx++] = num_entries << 16;
-
- /* directory_id */
- if (tport->directory_id != -1)
- data[idx++] = (CSR_DIRECTORY_ID << 24) | tport->directory_id;
-
- /* unit directory template */
- memcpy(&data[idx], sbp_unit_directory_template,
- sizeof(sbp_unit_directory_template));
- idx += ARRAY_SIZE(sbp_unit_directory_template);
-
- /* management_agent */
- mgt_agt_addr = (tport->mgt_agt->handler.offset - CSR_REGISTER_BASE) / 4;
- data[idx++] = 0x54000000 | (mgt_agt_addr & 0x00ffffff);
-
- /* unit_characteristics */
- data[idx++] = 0x3a000000 |
- (((tport->mgt_orb_timeout * 2) << 8) & 0xff00) |
- SBP_ORB_FETCH_SIZE;
-
- /* reconnect_timeout */
- data[idx++] = 0x3d000000 | (tport->max_reconnect_timeout & 0xffff);
-
- /* unit unique ID (leaf is just after LUNs) */
- data[idx++] = 0x8d000000 | (num_luns + 1);
-
- rcu_read_lock();
- hlist_for_each_entry_rcu(lun, &tport->tpg->se_tpg.tpg_lun_hlist, link) {
- struct se_device *dev;
- int type;
- /*
- * rcu_dereference_raw protected by se_lun->lun_group symlink
- * reference to se_device->dev_group.
- */
- dev = rcu_dereference_raw(lun->lun_se_dev);
- type = dev->transport->get_device_type(dev);
-
- /* logical_unit_number */
- data[idx++] = 0x14000000 |
- ((type << 16) & 0x1f0000) |
- (lun->unpacked_lun & 0xffff);
- }
- rcu_read_unlock();
-
- /* unit unique ID leaf */
- data[idx++] = 2 << 16;
- data[idx++] = tport->guid >> 32;
- data[idx++] = tport->guid;
-
- tport->unit_directory.length = idx;
- tport->unit_directory.key = (CSR_DIRECTORY | CSR_UNIT) << 24;
- tport->unit_directory.data = data;
-
- ret = fw_core_add_descriptor(&tport->unit_directory);
- if (ret < 0) {
- kfree(tport->unit_directory.data);
- tport->unit_directory.data = NULL;
- }
-
- return ret;
-}
-
-static ssize_t sbp_parse_wwn(const char *name, u64 *wwn)
-{
- const char *cp;
- char c, nibble;
- int pos = 0, err;
-
- *wwn = 0;
- for (cp = name; cp < &name[SBP_NAMELEN - 1]; cp++) {
- c = *cp;
- if (c == '\n' && cp[1] == '\0')
- continue;
- if (c == '\0') {
- err = 2;
- if (pos != 16)
- goto fail;
- return cp - name;
- }
- err = 3;
- if (isdigit(c))
- nibble = c - '0';
- else if (isxdigit(c))
- nibble = tolower(c) - 'a' + 10;
- else
- goto fail;
- *wwn = (*wwn << 4) | nibble;
- pos++;
- }
- err = 4;
-fail:
- printk(KERN_INFO "err %u len %zu pos %u\n",
- err, cp - name, pos);
- return -1;
-}
-
-static ssize_t sbp_format_wwn(char *buf, size_t len, u64 wwn)
-{
- return snprintf(buf, len, "%016llx", wwn);
-}
-
-static int sbp_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
-{
- u64 guid = 0;
-
- if (sbp_parse_wwn(name, &guid) < 0)
- return -EINVAL;
- return 0;
-}
-
-static int sbp_post_link_lun(
- struct se_portal_group *se_tpg,
- struct se_lun *se_lun)
-{
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
-
- return sbp_update_unit_directory(tpg->tport);
-}
-
-static void sbp_pre_unlink_lun(
- struct se_portal_group *se_tpg,
- struct se_lun *se_lun)
-{
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- int ret;
-
- if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0)
- tport->enable = 0;
-
- ret = sbp_update_unit_directory(tport);
- if (ret < 0)
- pr_err("unlink LUN: failed to update unit directory\n");
-}
-
-static struct se_portal_group *sbp_make_tpg(struct se_wwn *wwn,
- const char *name)
-{
- struct sbp_tport *tport =
- container_of(wwn, struct sbp_tport, tport_wwn);
-
- struct sbp_tpg *tpg;
- unsigned long tpgt;
- int ret;
-
- if (strstr(name, "tpgt_") != name)
- return ERR_PTR(-EINVAL);
- if (kstrtoul(name + 5, 10, &tpgt) || tpgt > UINT_MAX)
- return ERR_PTR(-EINVAL);
-
- if (tport->tpg) {
- pr_err("Only one TPG per Unit is possible.\n");
- return ERR_PTR(-EBUSY);
- }
-
- tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
- if (!tpg)
- return ERR_PTR(-ENOMEM);
-
- tpg->tport = tport;
- tpg->tport_tpgt = tpgt;
- tport->tpg = tpg;
-
- /* default attribute values */
- tport->enable = 0;
- tport->directory_id = -1;
- tport->mgt_orb_timeout = 15;
- tport->max_reconnect_timeout = 5;
- tport->max_logins_per_lun = 1;
-
- tport->mgt_agt = sbp_management_agent_register(tport);
- if (IS_ERR(tport->mgt_agt)) {
- ret = PTR_ERR(tport->mgt_agt);
- goto out_free_tpg;
- }
-
- ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_SBP);
- if (ret < 0)
- goto out_unreg_mgt_agt;
-
- return &tpg->se_tpg;
-
-out_unreg_mgt_agt:
- sbp_management_agent_unregister(tport->mgt_agt);
-out_free_tpg:
- tport->tpg = NULL;
- kfree(tpg);
- return ERR_PTR(ret);
-}
-
-static void sbp_drop_tpg(struct se_portal_group *se_tpg)
-{
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
-
- core_tpg_deregister(se_tpg);
- sbp_management_agent_unregister(tport->mgt_agt);
- tport->tpg = NULL;
- kfree(tpg);
-}
-
-static struct se_wwn *sbp_make_tport(
- struct target_fabric_configfs *tf,
- struct config_group *group,
- const char *name)
-{
- struct sbp_tport *tport;
- u64 guid = 0;
-
- if (sbp_parse_wwn(name, &guid) < 0)
- return ERR_PTR(-EINVAL);
-
- tport = kzalloc(sizeof(*tport), GFP_KERNEL);
- if (!tport)
- return ERR_PTR(-ENOMEM);
-
- tport->guid = guid;
- sbp_format_wwn(tport->tport_name, SBP_NAMELEN, guid);
-
- return &tport->tport_wwn;
-}
-
-static void sbp_drop_tport(struct se_wwn *wwn)
-{
- struct sbp_tport *tport =
- container_of(wwn, struct sbp_tport, tport_wwn);
-
- kfree(tport);
-}
-
-static ssize_t sbp_wwn_version_show(struct config_item *item, char *page)
-{
- return sprintf(page, "FireWire SBP fabric module %s\n", SBP_VERSION);
-}
-
-CONFIGFS_ATTR_RO(sbp_wwn_, version);
-
-static struct configfs_attribute *sbp_wwn_attrs[] = {
- &sbp_wwn_attr_version,
- NULL,
-};
-
-static ssize_t sbp_tpg_directory_id_show(struct config_item *item, char *page)
-{
- struct se_portal_group *se_tpg = to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
-
- if (tport->directory_id == -1)
- return sprintf(page, "implicit\n");
- else
- return sprintf(page, "%06x\n", tport->directory_id);
-}
-
-static ssize_t sbp_tpg_directory_id_store(struct config_item *item,
- const char *page, size_t count)
-{
- struct se_portal_group *se_tpg = to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- unsigned long val;
-
- if (tport->enable) {
- pr_err("Cannot change the directory_id on an active target.\n");
- return -EBUSY;
- }
-
- if (strstr(page, "implicit") == page) {
- tport->directory_id = -1;
- } else {
- if (kstrtoul(page, 16, &val) < 0)
- return -EINVAL;
- if (val > 0xffffff)
- return -EINVAL;
-
- tport->directory_id = val;
- }
-
- return count;
-}
-
-static ssize_t sbp_tpg_enable_show(struct config_item *item, char *page)
-{
- struct se_portal_group *se_tpg = to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- return sprintf(page, "%d\n", tport->enable);
-}
-
-static ssize_t sbp_tpg_enable_store(struct config_item *item,
- const char *page, size_t count)
-{
- struct se_portal_group *se_tpg = to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- unsigned long val;
- int ret;
-
- if (kstrtoul(page, 0, &val) < 0)
- return -EINVAL;
- if ((val != 0) && (val != 1))
- return -EINVAL;
-
- if (tport->enable == val)
- return count;
-
- if (val) {
- if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0) {
- pr_err("Cannot enable a target with no LUNs!\n");
- return -EINVAL;
- }
- } else {
- /* XXX: force-shutdown sessions instead? */
- spin_lock_bh(&se_tpg->session_lock);
- if (!list_empty(&se_tpg->tpg_sess_list)) {
- spin_unlock_bh(&se_tpg->session_lock);
- return -EBUSY;
- }
- spin_unlock_bh(&se_tpg->session_lock);
- }
-
- tport->enable = val;
-
- ret = sbp_update_unit_directory(tport);
- if (ret < 0) {
- pr_err("Could not update Config ROM\n");
- return ret;
- }
-
- return count;
-}
-
-CONFIGFS_ATTR(sbp_tpg_, directory_id);
-CONFIGFS_ATTR(sbp_tpg_, enable);
-
-static struct configfs_attribute *sbp_tpg_base_attrs[] = {
- &sbp_tpg_attr_directory_id,
- &sbp_tpg_attr_enable,
- NULL,
-};
-
-static ssize_t sbp_tpg_attrib_mgt_orb_timeout_show(struct config_item *item,
- char *page)
-{
- struct se_portal_group *se_tpg = attrib_to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- return sprintf(page, "%d\n", tport->mgt_orb_timeout);
-}
-
-static ssize_t sbp_tpg_attrib_mgt_orb_timeout_store(struct config_item *item,
- const char *page, size_t count)
-{
- struct se_portal_group *se_tpg = attrib_to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- unsigned long val;
- int ret;
-
- if (kstrtoul(page, 0, &val) < 0)
- return -EINVAL;
- if ((val < 1) || (val > 127))
- return -EINVAL;
-
- if (tport->mgt_orb_timeout == val)
- return count;
-
- tport->mgt_orb_timeout = val;
-
- ret = sbp_update_unit_directory(tport);
- if (ret < 0)
- return ret;
-
- return count;
-}
-
-static ssize_t sbp_tpg_attrib_max_reconnect_timeout_show(struct config_item *item,
- char *page)
-{
- struct se_portal_group *se_tpg = attrib_to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- return sprintf(page, "%d\n", tport->max_reconnect_timeout);
-}
-
-static ssize_t sbp_tpg_attrib_max_reconnect_timeout_store(struct config_item *item,
- const char *page, size_t count)
-{
- struct se_portal_group *se_tpg = attrib_to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- unsigned long val;
- int ret;
-
- if (kstrtoul(page, 0, &val) < 0)
- return -EINVAL;
- if ((val < 1) || (val > 32767))
- return -EINVAL;
-
- if (tport->max_reconnect_timeout == val)
- return count;
-
- tport->max_reconnect_timeout = val;
-
- ret = sbp_update_unit_directory(tport);
- if (ret < 0)
- return ret;
-
- return count;
-}
-
-static ssize_t sbp_tpg_attrib_max_logins_per_lun_show(struct config_item *item,
- char *page)
-{
- struct se_portal_group *se_tpg = attrib_to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- return sprintf(page, "%d\n", tport->max_logins_per_lun);
-}
-
-static ssize_t sbp_tpg_attrib_max_logins_per_lun_store(struct config_item *item,
- const char *page, size_t count)
-{
- struct se_portal_group *se_tpg = attrib_to_tpg(item);
- struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
- struct sbp_tport *tport = tpg->tport;
- unsigned long val;
-
- if (kstrtoul(page, 0, &val) < 0)
- return -EINVAL;
- if ((val < 1) || (val > 127))
- return -EINVAL;
-
- /* XXX: also check against current count? */
-
- tport->max_logins_per_lun = val;
-
- return count;
-}
-
-CONFIGFS_ATTR(sbp_tpg_attrib_, mgt_orb_timeout);
-CONFIGFS_ATTR(sbp_tpg_attrib_, max_reconnect_timeout);
-CONFIGFS_ATTR(sbp_tpg_attrib_, max_logins_per_lun);
-
-static struct configfs_attribute *sbp_tpg_attrib_attrs[] = {
- &sbp_tpg_attrib_attr_mgt_orb_timeout,
- &sbp_tpg_attrib_attr_max_reconnect_timeout,
- &sbp_tpg_attrib_attr_max_logins_per_lun,
- NULL,
-};
-
-static const struct target_core_fabric_ops sbp_ops = {
- .module = THIS_MODULE,
- .fabric_name = "sbp",
- .tpg_get_wwn = sbp_get_fabric_wwn,
- .tpg_get_tag = sbp_get_tag,
- .tpg_check_demo_mode = sbp_check_true,
- .tpg_check_demo_mode_cache = sbp_check_true,
- .tpg_check_demo_mode_write_protect = sbp_check_false,
- .tpg_check_prod_mode_write_protect = sbp_check_false,
- .tpg_get_inst_index = sbp_tpg_get_inst_index,
- .release_cmd = sbp_release_cmd,
- .sess_get_index = sbp_sess_get_index,
- .write_pending = sbp_write_pending,
- .set_default_node_attributes = sbp_set_default_node_attrs,
- .get_cmd_state = sbp_get_cmd_state,
- .queue_data_in = sbp_queue_data_in,
- .queue_status = sbp_queue_status,
- .queue_tm_rsp = sbp_queue_tm_rsp,
- .aborted_task = sbp_aborted_task,
- .check_stop_free = sbp_check_stop_free,
-
- .fabric_make_wwn = sbp_make_tport,
- .fabric_drop_wwn = sbp_drop_tport,
- .fabric_make_tpg = sbp_make_tpg,
- .fabric_drop_tpg = sbp_drop_tpg,
- .fabric_post_link = sbp_post_link_lun,
- .fabric_pre_unlink = sbp_pre_unlink_lun,
- .fabric_make_np = NULL,
- .fabric_drop_np = NULL,
- .fabric_init_nodeacl = sbp_init_nodeacl,
-
- .tfc_wwn_attrs = sbp_wwn_attrs,
- .tfc_tpg_base_attrs = sbp_tpg_base_attrs,
- .tfc_tpg_attrib_attrs = sbp_tpg_attrib_attrs,
-};
-
-static int __init sbp_init(void)
-{
- return target_register_template(&sbp_ops);
-};
-
-static void __exit sbp_exit(void)
-{
- target_unregister_template(&sbp_ops);
-};
-
-MODULE_DESCRIPTION("FireWire SBP fabric driver");
-MODULE_LICENSE("GPL");
-module_init(sbp_init);
-module_exit(sbp_exit);
diff --git a/drivers/target/sbp/sbp_target.h b/drivers/target/sbp/sbp_target.h
deleted file mode 100644
index 1d101ac86527..000000000000
--- a/drivers/target/sbp/sbp_target.h
+++ /dev/null
@@ -1,243 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _SBP_BASE_H
-#define _SBP_BASE_H
-
-#include <linux/firewire.h>
-#include <linux/spinlock.h>
-#include <linux/types.h>
-#include <linux/workqueue.h>
-#include <target/target_core_base.h>
-
-#define SBP_VERSION "v0.1"
-#define SBP_NAMELEN 32
-
-#define SBP_ORB_FETCH_SIZE 8
-
-#define MANAGEMENT_AGENT_STATE_IDLE 0
-#define MANAGEMENT_AGENT_STATE_BUSY 1
-
-#define ORB_NOTIFY(v) (((v) >> 31) & 0x01)
-#define ORB_REQUEST_FORMAT(v) (((v) >> 29) & 0x03)
-
-#define MANAGEMENT_ORB_FUNCTION(v) (((v) >> 16) & 0x0f)
-
-#define MANAGEMENT_ORB_FUNCTION_LOGIN 0x0
-#define MANAGEMENT_ORB_FUNCTION_QUERY_LOGINS 0x1
-#define MANAGEMENT_ORB_FUNCTION_RECONNECT 0x3
-#define MANAGEMENT_ORB_FUNCTION_SET_PASSWORD 0x4
-#define MANAGEMENT_ORB_FUNCTION_LOGOUT 0x7
-#define MANAGEMENT_ORB_FUNCTION_ABORT_TASK 0xb
-#define MANAGEMENT_ORB_FUNCTION_ABORT_TASK_SET 0xc
-#define MANAGEMENT_ORB_FUNCTION_LOGICAL_UNIT_RESET 0xe
-#define MANAGEMENT_ORB_FUNCTION_TARGET_RESET 0xf
-
-#define LOGIN_ORB_EXCLUSIVE(v) (((v) >> 28) & 0x01)
-#define LOGIN_ORB_RESERVED(v) (((v) >> 24) & 0x0f)
-#define LOGIN_ORB_RECONNECT(v) (((v) >> 20) & 0x0f)
-#define LOGIN_ORB_LUN(v) (((v) >> 0) & 0xffff)
-#define LOGIN_ORB_PASSWORD_LENGTH(v) (((v) >> 16) & 0xffff)
-#define LOGIN_ORB_RESPONSE_LENGTH(v) (((v) >> 0) & 0xffff)
-
-#define RECONNECT_ORB_LOGIN_ID(v) (((v) >> 0) & 0xffff)
-#define LOGOUT_ORB_LOGIN_ID(v) (((v) >> 0) & 0xffff)
-
-#define CMDBLK_ORB_DIRECTION(v) (((v) >> 27) & 0x01)
-#define CMDBLK_ORB_SPEED(v) (((v) >> 24) & 0x07)
-#define CMDBLK_ORB_MAX_PAYLOAD(v) (((v) >> 20) & 0x0f)
-#define CMDBLK_ORB_PG_TBL_PRESENT(v) (((v) >> 19) & 0x01)
-#define CMDBLK_ORB_PG_SIZE(v) (((v) >> 16) & 0x07)
-#define CMDBLK_ORB_DATA_SIZE(v) (((v) >> 0) & 0xffff)
-
-#define STATUS_BLOCK_SRC(v) (((v) & 0x03) << 30)
-#define STATUS_BLOCK_RESP(v) (((v) & 0x03) << 28)
-#define STATUS_BLOCK_DEAD(v) (((v) ? 1 : 0) << 27)
-#define STATUS_BLOCK_LEN(v) (((v) & 0x07) << 24)
-#define STATUS_BLOCK_SBP_STATUS(v) (((v) & 0xff) << 16)
-#define STATUS_BLOCK_ORB_OFFSET_HIGH(v) (((v) & 0xffff) << 0)
-
-#define STATUS_SRC_ORB_CONTINUING 0
-#define STATUS_SRC_ORB_FINISHED 1
-#define STATUS_SRC_UNSOLICITED 2
-
-#define STATUS_RESP_REQUEST_COMPLETE 0
-#define STATUS_RESP_TRANSPORT_FAILURE 1
-#define STATUS_RESP_ILLEGAL_REQUEST 2
-#define STATUS_RESP_VENDOR_DEPENDENT 3
-
-#define SBP_STATUS_OK 0
-#define SBP_STATUS_REQ_TYPE_NOTSUPP 1
-#define SBP_STATUS_SPEED_NOTSUPP 2
-#define SBP_STATUS_PAGE_SIZE_NOTSUPP 3
-#define SBP_STATUS_ACCESS_DENIED 4
-#define SBP_STATUS_LUN_NOTSUPP 5
-#define SBP_STATUS_PAYLOAD_TOO_SMALL 6
-/* 7 is reserved */
-#define SBP_STATUS_RESOURCES_UNAVAIL 8
-#define SBP_STATUS_FUNCTION_REJECTED 9
-#define SBP_STATUS_LOGIN_ID_UNKNOWN 10
-#define SBP_STATUS_DUMMY_ORB_COMPLETE 11
-#define SBP_STATUS_REQUEST_ABORTED 12
-#define SBP_STATUS_UNSPECIFIED_ERROR 0xff
-
-#define AGENT_STATE_RESET 0
-#define AGENT_STATE_ACTIVE 1
-#define AGENT_STATE_SUSPENDED 2
-#define AGENT_STATE_DEAD 3
-
-struct sbp2_pointer {
- __be32 high;
- __be32 low;
-};
-
-struct sbp_command_block_orb {
- struct sbp2_pointer next_orb;
- struct sbp2_pointer data_descriptor;
- __be32 misc;
- u8 command_block[12];
-};
-
-struct sbp_page_table_entry {
- __be16 segment_length;
- __be16 segment_base_hi;
- __be32 segment_base_lo;
-};
-
-struct sbp_management_orb {
- struct sbp2_pointer ptr1;
- struct sbp2_pointer ptr2;
- __be32 misc;
- __be32 length;
- struct sbp2_pointer status_fifo;
-};
-
-struct sbp_status_block {
- __be32 status;
- __be32 orb_low;
- u8 data[24];
-};
-
-struct sbp_login_response_block {
- __be32 misc;
- struct sbp2_pointer command_block_agent;
- __be32 reconnect_hold;
-};
-
-struct sbp_login_descriptor {
- struct sbp_session *sess;
- struct list_head link;
-
- u32 login_lun;
-
- u64 status_fifo_addr;
- int exclusive;
- u16 login_id;
-
- struct sbp_target_agent *tgt_agt;
-};
-
-struct sbp_session {
- spinlock_t lock;
- struct se_session *se_sess;
- struct list_head login_list;
- struct delayed_work maint_work;
-
- u64 guid; /* login_owner_EUI_64 */
- int node_id; /* login_owner_ID */
-
- struct fw_card *card;
- int generation;
- int speed;
-
- int reconnect_hold;
- u64 reconnect_expires;
-};
-
-struct sbp_tpg {
- /* Target portal group tag for TCM */
- u16 tport_tpgt;
- /* Pointer back to sbp_tport */
- struct sbp_tport *tport;
- /* Returned by sbp_make_tpg() */
- struct se_portal_group se_tpg;
-};
-
-struct sbp_tport {
- /* Target Unit Identifier (EUI-64) */
- u64 guid;
- /* Target port name */
- char tport_name[SBP_NAMELEN];
- /* Returned by sbp_make_tport() */
- struct se_wwn tport_wwn;
-
- struct sbp_tpg *tpg;
-
- /* FireWire unit directory */
- struct fw_descriptor unit_directory;
-
- /* SBP Management Agent */
- struct sbp_management_agent *mgt_agt;
-
- /* Parameters */
- int enable;
- s32 directory_id;
- int mgt_orb_timeout;
- int max_reconnect_timeout;
- int max_logins_per_lun;
-};
-
-static inline u64 sbp2_pointer_to_addr(const struct sbp2_pointer *ptr)
-{
- return (u64)(be32_to_cpu(ptr->high) & 0x0000ffff) << 32 |
- (be32_to_cpu(ptr->low) & 0xfffffffc);
-}
-
-static inline void addr_to_sbp2_pointer(u64 addr, struct sbp2_pointer *ptr)
-{
- ptr->high = cpu_to_be32(addr >> 32);
- ptr->low = cpu_to_be32(addr);
-}
-
-struct sbp_target_agent {
- spinlock_t lock;
- struct fw_address_handler handler;
- struct sbp_login_descriptor *login;
- int state;
- struct work_struct work;
- u64 orb_pointer;
- bool doorbell;
-};
-
-struct sbp_target_request {
- struct sbp_login_descriptor *login;
- u64 orb_pointer;
- struct sbp_command_block_orb orb;
- struct sbp_status_block status;
- struct work_struct work;
-
- struct se_cmd se_cmd;
- struct sbp_page_table_entry *pg_tbl;
- void *cmd_buf;
-
- unsigned char sense_buf[TRANSPORT_SENSE_BUFFER];
-};
-
-struct sbp_management_agent {
- spinlock_t lock;
- struct sbp_tport *tport;
- struct fw_address_handler handler;
- int state;
- struct work_struct work;
- u64 orb_offset;
- struct sbp_management_request *request;
-};
-
-struct sbp_management_request {
- struct sbp_management_orb orb;
- struct sbp_status_block status;
- struct fw_card *card;
- int generation;
- int node_addr;
- int speed;
-};
-
-#endif
--
2.27.0
On Sat, 13 Jun 2020, Chris Boot wrote:
> I no longer have the time to maintain this subsystem nor the hardware to
> test patches with.
Then why not patch MAINTAINERS, and orphan it, as per usual practice?
$ git log --oneline MAINTAINERS | grep -i orphan
> It also doesn't appear to have any active users so I doubt anyone will
> miss it.
>
It's not unusual that any Linux driver written more than 5 years ago
"doesn't appear to have any active users".
If a driver has been orphaned and broken in the past, and no-one stepped
up to fix it within a reasonable period, removal would make sense. But
that's not the case here.
I haven't used this driver for a long time, but I still own PowerMacs with
firewire, and I know I'm not the only one.
> Signed-off-by: Chris Boot <[email protected]>
> ---
> MAINTAINERS | 9 -
> drivers/target/Kconfig | 1 -
> drivers/target/Makefile | 1 -
> drivers/target/sbp/Kconfig | 12 -
> drivers/target/sbp/Makefile | 2 -
> drivers/target/sbp/sbp_target.c | 2350 -------------------------------
> drivers/target/sbp/sbp_target.h | 243 ----
> 7 files changed, 2618 deletions(-)
> delete mode 100644 drivers/target/sbp/Kconfig
> delete mode 100644 drivers/target/sbp/Makefile
> delete mode 100644 drivers/target/sbp/sbp_target.c
> delete mode 100644 drivers/target/sbp/sbp_target.h
>
On 14/06/2020 01:03, Finn Thain wrote:
> On Sat, 13 Jun 2020, Chris Boot wrote:
>
>> I no longer have the time to maintain this subsystem nor the hardware to
>> test patches with.
>
> Then why not patch MAINTAINERS, and orphan it, as per usual practice?
>
> $ git log --oneline MAINTAINERS | grep -i orphan
My patch to remove it was in response to:
https://lore.kernel.org/lkml/[email protected]/
>> It also doesn't appear to have any active users so I doubt anyone will
>> miss it.
>>
>
> It's not unusual that any Linux driver written more than 5 years ago
> "doesn't appear to have any active users".
>
> If a driver has been orphaned and broken in the past, and no-one stepped
> up to fix it within a reasonable period, removal would make sense. But
> that's not the case here.
>
> I haven't used this driver for a long time, but I still own PowerMacs with
> firewire, and I know I'm not the only one.
I expect that if someone finds this useful it can stick around (but
that's not my call). I just don't have the time or inclination or
hardware to be able to maintain it anymore, so someone else would have
to pick it up.
Cheers,
Chris
--
Chris Boot
[email protected]
On Sun, 14 Jun 2020, Chris Boot wrote:
> I expect that if someone finds this useful it can stick around (but
> that's not my call).
Who's call is that? If the patch had said "From: Martin K. Petersen" and
"This driver is being removed because it has the following defects..."
that would be some indication of a good-faith willingness to accept users
as developers in the spirit of the GPL, which is what you seem to be
alluding to (?).
> I just don't have the time or inclination or hardware to be able to
> maintain it anymore, so someone else would have to pick it up.
>
Which is why most drivers get orphaned, right?
On 15/06/2020 00:28, Finn Thain wrote:
> On Sun, 14 Jun 2020, Chris Boot wrote:
>
>> I expect that if someone finds this useful it can stick around (but
>> that's not my call).
>
> Who's call is that? If the patch had said "From: Martin K. Petersen" and
> "This driver is being removed because it has the following defects..."
> that would be some indication of a good-faith willingness to accept users
> as developers in the spirit of the GPL, which is what you seem to be
> alluding to (?).
If you're asking me, I'd say it was martin's call:
> SCSI TARGET SUBSYSTEM
> M: "Martin K. Petersen" <[email protected]>
[...]
> F: drivers/target/
> F: include/target/
>> I just don't have the time or inclination or hardware to be able to
>> maintain it anymore, so someone else would have to pick it up.
>>
>
> Which is why most drivers get orphaned, right?
Sure, but that's not what Martin asked me to do, hence this patch.
--
Chris Boot
[email protected]
On Mon, 15 Jun 2020, Chris Boot wrote:
> On 15/06/2020 00:28, Finn Thain wrote:
> > On Sun, 14 Jun 2020, Chris Boot wrote:
> >
> >> I expect that if someone finds this useful it can stick around (but
> >> that's not my call).
> >
> > Who's call is that? If the patch had said "From: Martin K. Petersen"
> > and "This driver is being removed because it has the following
> > defects..." that would be some indication of a good-faith willingness
> > to accept users as developers in the spirit of the GPL, which is what
> > you seem to be alluding to (?).
>
> If you're asking me, I'd say it was martin's call:
>
> > SCSI TARGET SUBSYSTEM
> > M: "Martin K. Petersen" <[email protected]>
> [...]
> > F: drivers/target/
> > F: include/target/
>
The question I asked you was intended to make you think. I wasn't asking
you to search MAINTAINERS for "drivers/target" (I had already done so).
Chris, you can find my name in that file too. That's because I see my role
as custodian of that particular code. That code lives in the kernel.org
tree because others put it there and because users find it useful -- not
merely because it happens to please the official glorious MAINTAINER of
said code.
If you would ask, "who's call is it to delete drivers/nubus? or
drivers/scsi/NCR5380.c?" my answer is, I have no idea.
> >> I just don't have the time or inclination or hardware to be able to
> >> maintain it anymore, so someone else would have to pick it up.
> >>
> >
> > Which is why most drivers get orphaned, right?
>
> Sure, but that's not what Martin asked me to do, hence this patch.
>
Martin said, "I'd appreciate a patch to remove it"
And Bart said, "do you want to keep this driver in the kernel tree?"
AFAICT both comments are quite ambiguous. I don't see an actionable
request, just an expression of interest from people doing their jobs.
Note well: there is no pay check associated with having a MAINTAINERS file
entry.
On 2020-06-16 02:42, Finn Thain wrote:
> Martin said, "I'd appreciate a patch to remove it"
>
> And Bart said, "do you want to keep this driver in the kernel tree?"
>
> AFAICT both comments are quite ambiguous. I don't see an actionable
> request, just an expression of interest from people doing their jobs.
>
> Note well: there is no pay check associated with having a MAINTAINERS file
> entry.
Hi Finn,
As far as I know the sbp driver only has had one user ever and that user
is no longer user the sbp driver. So why to keep it in the kernel tree?
Restoring a kernel driver can be easy - the first step is a "git revert".
Thanks,
Bart.
On Tue, 16 Jun 2020, Bart Van Assche wrote:
>
> As far as I know the sbp driver only has had one user ever and that user
> is no longer user the sbp driver.
So, you estimate the userbase at zero. Can you give a confidence level?
Actual measurement is hard because when end users encounter breakage, they
look for quick workarounds before they undertake post mortem, log
collection, bug reporting, mailing list discussions, analysis etc.
> So why to keep it in the kernel tree?
Answer: for the same reason it was added to the tree.
Here's a different question: "Why remove it from the kernel tree?"
If maintaining this code is a burden, is it not the kind of tax that all
developers/users pay to all developers/users? Does this driver impose an
unreasonably high burden for some reason?
The growth of a maintenance burden in general has lead to the invention of
design patterns and tooling to minize it. So a good argument for removal
would describe the nature of the problem, because some driver deficiencies
can be fixed automatically, and some tooling deficiencies can compound an
otherwise insignificant or common driver deficiency.
There are spin-off benefits from legacy code besides process improvements.
Building and testing this sort of code has regularly revealed erroneous
corner cases in commits elsewhere like API changes and refactoring.
Also, legacy code is used by new developers get experience in code
modernization. And it provides more training material for neural networks
that need to be taught to recognize patches that raise quality.
Ten or twenty years ago, I doubt that anyone predicted these (and other)
spin-off benefits. If we can't predict the benefit, how will we project
the cost, and use that to justify deletion?
Please see also,
http://www.mac.linux-m68k.org/docs/obsolete.php
Finn,
> I haven't used this driver for a long time, but I still own PowerMacs
> with firewire, and I know I'm not the only one.
I also have old 1394 hardware kicking around in the basement. But having
worked with FireWire shared storage targets in the past, I have zero
desire to ever touch any of that again.
I could understand an objection if we were to entertain removing
sbp2. But really, how many people are setting up FireWire targets?
--
Martin K. Petersen Oracle Linux Engineering
On Tue, 16 Jun 2020, Martin K. Petersen wrote:
> > I haven't used this driver for a long time, but I still own PowerMacs
> > with firewire, and I know I'm not the only one.
>
I need to correct what I wrote above. I recall that years ago, when I
needed to share storage from my Linux box to my PowerBook pismo, I used
ethernet and the globalSAN iSCSI initiator for Mac OS X (which is no
longer freely available AFAICS). When I said that I had used the SBP
target driver before, I misremembered that iSCSI target setup. I've
actually never used the SBP target driver.
> I also have old 1394 hardware kicking around in the basement. But having
> worked with FireWire shared storage targets in the past, I have zero
> desire to ever touch any of that again.
>
> I could understand an objection if we were to entertain removing sbp2.
> But really, how many people are setting up FireWire targets?
>
It's a good question. I don't know the answer.
I have successfully used the Linux sbp2 host driver in the past, and will
probably need to use it again. Likewise, I can see myself using the sbp
target driver in the future because that might interoperate with MacOS 9,
and might provide a bootable device to the PowerMac ROM. iSCSI cannot do
those things.
On 6/16/20 7:07 PM, Finn Thain wrote:
> On Tue, 16 Jun 2020, Bart Van Assche wrote:
>> As far as I know the sbp driver only has had one user ever and that user
>> is no longer user the sbp driver.
>
> So, you estimate the userbase at zero. Can you give a confidence level?
> Actual measurement is hard because when end users encounter breakage, they
> look for quick workarounds before they undertake post mortem, log
> collection, bug reporting, mailing list discussions, analysis etc.
(replying to an e-mail from six months ago)
Hi Finn,
I am confident that my estimate is an accurate estimate since I have not
seen any sbp support requests, sbp bug reports nor any sbp bug fixes since
the sbp target driver has been accepted upstream.
> Here's a different question: "Why remove it from the kernel tree?"
>
> If maintaining this code is a burden, is it not the kind of tax that all
> developers/users pay to all developers/users? Does this driver impose an
> unreasonably high burden for some reason?
Yes. If anyone wants to change the interface between SCSI target core and
SCSI target drivers, all target drivers, including the sbp and FCoE target
driver have to be retested. In other words, keeping unused target drivers
inside the kernel tree involves a significant maintenance burden for anyone
who wants to modify the interface between the SCSI target core and SCSI
target drivers.
Additionally, there is a good alternative available for the sbp driver.
Every system I know of that is equipped with a Firewire port also has an
Ethernet port. So users who want to provide SCSI target functionality on
such systems can use any SCSI transport protocol that is compatible with
Ethernet (iSCSI, iSER over soft-RoCE, SRP over soft-RoCE, ...).
Thanks,
Bart.
On Mon, 4 Jan 2021, Bart Van Assche wrote:
> On 6/16/20 7:07 PM, Finn Thain wrote:
> > On Tue, 16 Jun 2020, Bart Van Assche wrote:
> >> As far as I know the sbp driver only has had one user ever and that
> >> user is no longer user the sbp driver.
> >
> > So, you estimate the userbase at zero. Can you give a confidence
> > level? Actual measurement is hard because when end users encounter
> > breakage, they look for quick workarounds before they undertake post
> > mortem, log collection, bug reporting, mailing list discussions,
> > analysis etc.
>
> (replying to an e-mail from six months ago)
>
> Hi Finn,
>
> I am confident that my estimate is an accurate estimate since I have not
> seen any sbp support requests, sbp bug reports nor any sbp bug fixes
> since the sbp target driver has been accepted upstream.
>
That suggests to me that the code that you're hoping to remove 1) has no
bugs, or 2) has no reported bugs, or 3) has no users at present.
I am confident that your evidence does not support your conclusion (i.e.
the code will never be used again).
Sometimes, users only appear after the unreported bugs get fixed. I've
seen it happen.
> > Here's a different question: "Why remove it from the kernel tree?"
> >
> > If maintaining this code is a burden, is it not the kind of tax that
> > all developers/users pay to all developers/users? Does this driver
> > impose an unreasonably high burden for some reason?
>
> Yes. If anyone wants to change the interface between SCSI target core
> and SCSI target drivers, all target drivers, including the sbp and FCoE
> target driver have to be retested.
I'm unaware of such an obligation. API changes happen often. When they do,
we see good test coverage of commercially viable hardware, some
best-effort testing of common hardware, and some perfunctory build
testing.
But that is missing the point, which was about a particular driver, not
about development process. You have not shown how the target API is
special, to support your claim that this driver imposes an unreasonable
burden.
In the interests of making forward progress in this discussion, shall we
discuss the kind of SCSI Target API changes that you anticipate?
> In other words, keeping unused target drivers inside the kernel tree
> involves a significant maintenance burden for anyone who wants to modify
> the interface between the SCSI target core and SCSI target drivers.
>
Keeping _any_ driver in the kernel involves a maintenance burden. There
are two good ways to address that.
Firstly, by improving the development process. For example, an API change
is mostly mechanical work that lends itself to automated refactoring.
Secondly, by involving all interested parties, so that the burden is
shared.
Of course, there are other ways. E.g. "don't ship code when doing so won't
turn a profit". That, by the way, was the policy that gave us 10 billion
Android devices (or more) that don't function with a mainline kernel.
> Additionally, there is a good alternative available for the sbp driver.
> Every system I know of that is equipped with a Firewire port also has an
> Ethernet port. So users who want to provide SCSI target functionality on
> such systems can use any SCSI transport protocol that is compatible with
> Ethernet (iSCSI, iSER over soft-RoCE, SRP over soft-RoCE, ...).
>
Ethernet is not always an alternative. That was already discussed in this
thread. But let's assume for a moment that you can migrate any and all
users of this driver over to an ethernet driver.
Why would the maintainers of that ethernet driver and its API accept that
plan, if adding users would extend their maintenance and testing
obligations? Do you think those maintainers should pay the "kind of tax
that all developers/users pay to all developers/users?"
> Thanks,
>
> Bart.
>
On 1/4/21 2:50 PM, Finn Thain wrote:
> On Mon, 4 Jan 2021, Bart Van Assche wrote:
>> Additionally, there is a good alternative available for the sbp driver.
>> Every system I know of that is equipped with a Firewire port also has an
>> Ethernet port. So users who want to provide SCSI target functionality on
>> such systems can use any SCSI transport protocol that is compatible with
>> Ethernet (iSCSI, iSER over soft-RoCE, SRP over soft-RoCE, ...).
>
> Ethernet is not always an alternative. That was already discussed in this
> thread. But let's assume for a moment that you can migrate any and all
> users of this driver over to an ethernet driver.
>
> Why would the maintainers of that Ethernet driver and its API accept that
> plan, if adding users would extend their maintenance and testing
> obligations? Do you think those maintainers should pay the "kind of tax
> that all developers/users pay to all developers/users?"
Hi Finn,
I cannot speak in the name of the iSCSI over TCP/IP or iSER driver
maintainers. But since I maintain the SRP initiator and target kernel
drivers myself, I can state that I would be happy to help SBP target users
(if that driver has any users today) to switch from SCSI over Firewire to
SCSI over SRP over RoCE or even NVMEoF over TCP.
Thanks,
Bart.