sbp_target.c 59 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * SBP2 target driver (SCSI over IEEE1394 in target mode)
  4. *
  5. * Copyright (C) 2011 Chris Boot <bootc@bootc.net>
  6. */
  7. #define KMSG_COMPONENT "sbp_target"
  8. #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/init.h>
  12. #include <linux/types.h>
  13. #include <linux/string.h>
  14. #include <linux/configfs.h>
  15. #include <linux/ctype.h>
  16. #include <linux/delay.h>
  17. #include <linux/firewire.h>
  18. #include <linux/firewire-constants.h>
  19. #include <scsi/scsi_proto.h>
  20. #include <scsi/scsi_tcq.h>
  21. #include <target/target_core_base.h>
  22. #include <target/target_core_backend.h>
  23. #include <target/target_core_fabric.h>
  24. #include <asm/unaligned.h>
  25. #include "sbp_target.h"
  26. /* FireWire address region for management and command block address handlers */
  27. static const struct fw_address_region sbp_register_region = {
  28. .start = CSR_REGISTER_BASE + 0x10000,
  29. .end = 0x1000000000000ULL,
  30. };
  31. static const u32 sbp_unit_directory_template[] = {
  32. 0x1200609e, /* unit_specifier_id: NCITS/T10 */
  33. 0x13010483, /* unit_sw_version: 1155D Rev 4 */
  34. 0x3800609e, /* command_set_specifier_id: NCITS/T10 */
  35. 0x390104d8, /* command_set: SPC-2 */
  36. 0x3b000000, /* command_set_revision: 0 */
  37. 0x3c000001, /* firmware_revision: 1 */
  38. };
  39. #define SESSION_MAINTENANCE_INTERVAL HZ
  40. static atomic_t login_id = ATOMIC_INIT(0);
  41. static void session_maintenance_work(struct work_struct *);
  42. static int sbp_run_transaction(struct fw_card *, int, int, int, int,
  43. unsigned long long, void *, size_t);
  44. static int read_peer_guid(u64 *guid, const struct sbp_management_request *req)
  45. {
  46. int ret;
  47. __be32 high, low;
  48. ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
  49. req->node_addr, req->generation, req->speed,
  50. (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 3 * 4,
  51. &high, sizeof(high));
  52. if (ret != RCODE_COMPLETE)
  53. return ret;
  54. ret = sbp_run_transaction(req->card, TCODE_READ_QUADLET_REQUEST,
  55. req->node_addr, req->generation, req->speed,
  56. (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + 4 * 4,
  57. &low, sizeof(low));
  58. if (ret != RCODE_COMPLETE)
  59. return ret;
  60. *guid = (u64)be32_to_cpu(high) << 32 | be32_to_cpu(low);
  61. return RCODE_COMPLETE;
  62. }
  63. static struct sbp_session *sbp_session_find_by_guid(
  64. struct sbp_tpg *tpg, u64 guid)
  65. {
  66. struct se_session *se_sess;
  67. struct sbp_session *sess, *found = NULL;
  68. spin_lock_bh(&tpg->se_tpg.session_lock);
  69. list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
  70. sess = se_sess->fabric_sess_ptr;
  71. if (sess->guid == guid)
  72. found = sess;
  73. }
  74. spin_unlock_bh(&tpg->se_tpg.session_lock);
  75. return found;
  76. }
  77. static struct sbp_login_descriptor *sbp_login_find_by_lun(
  78. struct sbp_session *session, u32 unpacked_lun)
  79. {
  80. struct sbp_login_descriptor *login, *found = NULL;
  81. spin_lock_bh(&session->lock);
  82. list_for_each_entry(login, &session->login_list, link) {
  83. if (login->login_lun == unpacked_lun)
  84. found = login;
  85. }
  86. spin_unlock_bh(&session->lock);
  87. return found;
  88. }
  89. static int sbp_login_count_all_by_lun(
  90. struct sbp_tpg *tpg,
  91. u32 unpacked_lun,
  92. int exclusive)
  93. {
  94. struct se_session *se_sess;
  95. struct sbp_session *sess;
  96. struct sbp_login_descriptor *login;
  97. int count = 0;
  98. spin_lock_bh(&tpg->se_tpg.session_lock);
  99. list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
  100. sess = se_sess->fabric_sess_ptr;
  101. spin_lock_bh(&sess->lock);
  102. list_for_each_entry(login, &sess->login_list, link) {
  103. if (login->login_lun != unpacked_lun)
  104. continue;
  105. if (!exclusive || login->exclusive)
  106. count++;
  107. }
  108. spin_unlock_bh(&sess->lock);
  109. }
  110. spin_unlock_bh(&tpg->se_tpg.session_lock);
  111. return count;
  112. }
  113. static struct sbp_login_descriptor *sbp_login_find_by_id(
  114. struct sbp_tpg *tpg, int login_id)
  115. {
  116. struct se_session *se_sess;
  117. struct sbp_session *sess;
  118. struct sbp_login_descriptor *login, *found = NULL;
  119. spin_lock_bh(&tpg->se_tpg.session_lock);
  120. list_for_each_entry(se_sess, &tpg->se_tpg.tpg_sess_list, sess_list) {
  121. sess = se_sess->fabric_sess_ptr;
  122. spin_lock_bh(&sess->lock);
  123. list_for_each_entry(login, &sess->login_list, link) {
  124. if (login->login_id == login_id)
  125. found = login;
  126. }
  127. spin_unlock_bh(&sess->lock);
  128. }
  129. spin_unlock_bh(&tpg->se_tpg.session_lock);
  130. return found;
  131. }
  132. static u32 sbp_get_lun_from_tpg(struct sbp_tpg *tpg, u32 login_lun, int *err)
  133. {
  134. struct se_portal_group *se_tpg = &tpg->se_tpg;
  135. struct se_lun *se_lun;
  136. rcu_read_lock();
  137. hlist_for_each_entry_rcu(se_lun, &se_tpg->tpg_lun_hlist, link) {
  138. if (se_lun->unpacked_lun == login_lun) {
  139. rcu_read_unlock();
  140. *err = 0;
  141. return login_lun;
  142. }
  143. }
  144. rcu_read_unlock();
  145. *err = -ENODEV;
  146. return login_lun;
  147. }
  148. static struct sbp_session *sbp_session_create(
  149. struct sbp_tpg *tpg,
  150. u64 guid)
  151. {
  152. struct sbp_session *sess;
  153. int ret;
  154. char guid_str[17];
  155. snprintf(guid_str, sizeof(guid_str), "%016llx", guid);
  156. sess = kmalloc(sizeof(*sess), GFP_KERNEL);
  157. if (!sess)
  158. return ERR_PTR(-ENOMEM);
  159. spin_lock_init(&sess->lock);
  160. INIT_LIST_HEAD(&sess->login_list);
  161. INIT_DELAYED_WORK(&sess->maint_work, session_maintenance_work);
  162. sess->guid = guid;
  163. sess->se_sess = target_setup_session(&tpg->se_tpg, 128,
  164. sizeof(struct sbp_target_request),
  165. TARGET_PROT_NORMAL, guid_str,
  166. sess, NULL);
  167. if (IS_ERR(sess->se_sess)) {
  168. pr_err("failed to init se_session\n");
  169. ret = PTR_ERR(sess->se_sess);
  170. kfree(sess);
  171. return ERR_PTR(ret);
  172. }
  173. return sess;
  174. }
  175. static void sbp_session_release(struct sbp_session *sess, bool cancel_work)
  176. {
  177. spin_lock_bh(&sess->lock);
  178. if (!list_empty(&sess->login_list)) {
  179. spin_unlock_bh(&sess->lock);
  180. return;
  181. }
  182. spin_unlock_bh(&sess->lock);
  183. if (cancel_work)
  184. cancel_delayed_work_sync(&sess->maint_work);
  185. target_remove_session(sess->se_sess);
  186. if (sess->card)
  187. fw_card_put(sess->card);
  188. kfree(sess);
  189. }
  190. static void sbp_target_agent_unregister(struct sbp_target_agent *);
  191. static void sbp_login_release(struct sbp_login_descriptor *login,
  192. bool cancel_work)
  193. {
  194. struct sbp_session *sess = login->sess;
  195. /* FIXME: abort/wait on tasks */
  196. sbp_target_agent_unregister(login->tgt_agt);
  197. if (sess) {
  198. spin_lock_bh(&sess->lock);
  199. list_del(&login->link);
  200. spin_unlock_bh(&sess->lock);
  201. sbp_session_release(sess, cancel_work);
  202. }
  203. kfree(login);
  204. }
  205. static struct sbp_target_agent *sbp_target_agent_register(
  206. struct sbp_login_descriptor *);
  207. static void sbp_management_request_login(
  208. struct sbp_management_agent *agent, struct sbp_management_request *req,
  209. int *status_data_size)
  210. {
  211. struct sbp_tport *tport = agent->tport;
  212. struct sbp_tpg *tpg = tport->tpg;
  213. struct sbp_session *sess;
  214. struct sbp_login_descriptor *login;
  215. struct sbp_login_response_block *response;
  216. u64 guid;
  217. u32 unpacked_lun;
  218. int login_response_len, ret;
  219. unpacked_lun = sbp_get_lun_from_tpg(tpg,
  220. LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)), &ret);
  221. if (ret) {
  222. pr_notice("login to unknown LUN: %d\n",
  223. LOGIN_ORB_LUN(be32_to_cpu(req->orb.misc)));
  224. req->status.status = cpu_to_be32(
  225. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  226. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LUN_NOTSUPP));
  227. return;
  228. }
  229. ret = read_peer_guid(&guid, req);
  230. if (ret != RCODE_COMPLETE) {
  231. pr_warn("failed to read peer GUID: %d\n", ret);
  232. req->status.status = cpu_to_be32(
  233. STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
  234. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
  235. return;
  236. }
  237. pr_notice("mgt_agent LOGIN to LUN %d from %016llx\n",
  238. unpacked_lun, guid);
  239. sess = sbp_session_find_by_guid(tpg, guid);
  240. if (sess) {
  241. login = sbp_login_find_by_lun(sess, unpacked_lun);
  242. if (login) {
  243. pr_notice("initiator already logged-in\n");
  244. /*
  245. * SBP-2 R4 says we should return access denied, but
  246. * that can confuse initiators. Instead we need to
  247. * treat this like a reconnect, but send the login
  248. * response block like a fresh login.
  249. *
  250. * This is required particularly in the case of Apple
  251. * devices booting off the FireWire target, where
  252. * the firmware has an active login to the target. When
  253. * the OS takes control of the session it issues its own
  254. * LOGIN rather than a RECONNECT. To avoid the machine
  255. * waiting until the reconnect_hold expires, we can skip
  256. * the ACCESS_DENIED errors to speed things up.
  257. */
  258. goto already_logged_in;
  259. }
  260. }
  261. /*
  262. * check exclusive bit in login request
  263. * reject with access_denied if any logins present
  264. */
  265. if (LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc)) &&
  266. sbp_login_count_all_by_lun(tpg, unpacked_lun, 0)) {
  267. pr_warn("refusing exclusive login with other active logins\n");
  268. req->status.status = cpu_to_be32(
  269. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  270. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
  271. return;
  272. }
  273. /*
  274. * check exclusive bit in any existing login descriptor
  275. * reject with access_denied if any exclusive logins present
  276. */
  277. if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 1)) {
  278. pr_warn("refusing login while another exclusive login present\n");
  279. req->status.status = cpu_to_be32(
  280. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  281. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
  282. return;
  283. }
  284. /*
  285. * check we haven't exceeded the number of allowed logins
  286. * reject with resources_unavailable if we have
  287. */
  288. if (sbp_login_count_all_by_lun(tpg, unpacked_lun, 0) >=
  289. tport->max_logins_per_lun) {
  290. pr_warn("max number of logins reached\n");
  291. req->status.status = cpu_to_be32(
  292. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  293. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
  294. return;
  295. }
  296. if (!sess) {
  297. sess = sbp_session_create(tpg, guid);
  298. if (IS_ERR(sess)) {
  299. switch (PTR_ERR(sess)) {
  300. case -EPERM:
  301. ret = SBP_STATUS_ACCESS_DENIED;
  302. break;
  303. default:
  304. ret = SBP_STATUS_RESOURCES_UNAVAIL;
  305. break;
  306. }
  307. req->status.status = cpu_to_be32(
  308. STATUS_BLOCK_RESP(
  309. STATUS_RESP_REQUEST_COMPLETE) |
  310. STATUS_BLOCK_SBP_STATUS(ret));
  311. return;
  312. }
  313. sess->node_id = req->node_addr;
  314. sess->card = fw_card_get(req->card);
  315. sess->generation = req->generation;
  316. sess->speed = req->speed;
  317. schedule_delayed_work(&sess->maint_work,
  318. SESSION_MAINTENANCE_INTERVAL);
  319. }
  320. /* only take the latest reconnect_hold into account */
  321. sess->reconnect_hold = min(
  322. 1 << LOGIN_ORB_RECONNECT(be32_to_cpu(req->orb.misc)),
  323. tport->max_reconnect_timeout) - 1;
  324. login = kmalloc(sizeof(*login), GFP_KERNEL);
  325. if (!login) {
  326. pr_err("failed to allocate login descriptor\n");
  327. sbp_session_release(sess, true);
  328. req->status.status = cpu_to_be32(
  329. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  330. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
  331. return;
  332. }
  333. login->sess = sess;
  334. login->login_lun = unpacked_lun;
  335. login->status_fifo_addr = sbp2_pointer_to_addr(&req->orb.status_fifo);
  336. login->exclusive = LOGIN_ORB_EXCLUSIVE(be32_to_cpu(req->orb.misc));
  337. login->login_id = atomic_inc_return(&login_id);
  338. login->tgt_agt = sbp_target_agent_register(login);
  339. if (IS_ERR(login->tgt_agt)) {
  340. ret = PTR_ERR(login->tgt_agt);
  341. pr_err("failed to map command block handler: %d\n", ret);
  342. sbp_session_release(sess, true);
  343. kfree(login);
  344. req->status.status = cpu_to_be32(
  345. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  346. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
  347. return;
  348. }
  349. spin_lock_bh(&sess->lock);
  350. list_add_tail(&login->link, &sess->login_list);
  351. spin_unlock_bh(&sess->lock);
  352. already_logged_in:
  353. response = kzalloc(sizeof(*response), GFP_KERNEL);
  354. if (!response) {
  355. pr_err("failed to allocate login response block\n");
  356. sbp_login_release(login, true);
  357. req->status.status = cpu_to_be32(
  358. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  359. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_RESOURCES_UNAVAIL));
  360. return;
  361. }
  362. login_response_len = clamp_val(
  363. LOGIN_ORB_RESPONSE_LENGTH(be32_to_cpu(req->orb.length)),
  364. 12, sizeof(*response));
  365. response->misc = cpu_to_be32(
  366. ((login_response_len & 0xffff) << 16) |
  367. (login->login_id & 0xffff));
  368. response->reconnect_hold = cpu_to_be32(sess->reconnect_hold & 0xffff);
  369. addr_to_sbp2_pointer(login->tgt_agt->handler.offset,
  370. &response->command_block_agent);
  371. ret = sbp_run_transaction(sess->card, TCODE_WRITE_BLOCK_REQUEST,
  372. sess->node_id, sess->generation, sess->speed,
  373. sbp2_pointer_to_addr(&req->orb.ptr2), response,
  374. login_response_len);
  375. if (ret != RCODE_COMPLETE) {
  376. pr_debug("failed to write login response block: %x\n", ret);
  377. kfree(response);
  378. sbp_login_release(login, true);
  379. req->status.status = cpu_to_be32(
  380. STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
  381. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
  382. return;
  383. }
  384. kfree(response);
  385. req->status.status = cpu_to_be32(
  386. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  387. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
  388. }
  389. static void sbp_management_request_query_logins(
  390. struct sbp_management_agent *agent, struct sbp_management_request *req,
  391. int *status_data_size)
  392. {
  393. pr_notice("QUERY LOGINS not implemented\n");
  394. /* FIXME: implement */
  395. req->status.status = cpu_to_be32(
  396. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  397. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
  398. }
  399. static void sbp_management_request_reconnect(
  400. struct sbp_management_agent *agent, struct sbp_management_request *req,
  401. int *status_data_size)
  402. {
  403. struct sbp_tport *tport = agent->tport;
  404. struct sbp_tpg *tpg = tport->tpg;
  405. int ret;
  406. u64 guid;
  407. struct sbp_login_descriptor *login;
  408. ret = read_peer_guid(&guid, req);
  409. if (ret != RCODE_COMPLETE) {
  410. pr_warn("failed to read peer GUID: %d\n", ret);
  411. req->status.status = cpu_to_be32(
  412. STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
  413. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
  414. return;
  415. }
  416. pr_notice("mgt_agent RECONNECT from %016llx\n", guid);
  417. login = sbp_login_find_by_id(tpg,
  418. RECONNECT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc)));
  419. if (!login) {
  420. pr_err("mgt_agent RECONNECT unknown login ID\n");
  421. req->status.status = cpu_to_be32(
  422. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  423. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
  424. return;
  425. }
  426. if (login->sess->guid != guid) {
  427. pr_err("mgt_agent RECONNECT login GUID doesn't match\n");
  428. req->status.status = cpu_to_be32(
  429. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  430. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
  431. return;
  432. }
  433. spin_lock_bh(&login->sess->lock);
  434. if (login->sess->card)
  435. fw_card_put(login->sess->card);
  436. /* update the node details */
  437. login->sess->generation = req->generation;
  438. login->sess->node_id = req->node_addr;
  439. login->sess->card = fw_card_get(req->card);
  440. login->sess->speed = req->speed;
  441. spin_unlock_bh(&login->sess->lock);
  442. req->status.status = cpu_to_be32(
  443. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  444. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
  445. }
  446. static void sbp_management_request_logout(
  447. struct sbp_management_agent *agent, struct sbp_management_request *req,
  448. int *status_data_size)
  449. {
  450. struct sbp_tport *tport = agent->tport;
  451. struct sbp_tpg *tpg = tport->tpg;
  452. int id;
  453. struct sbp_login_descriptor *login;
  454. id = LOGOUT_ORB_LOGIN_ID(be32_to_cpu(req->orb.misc));
  455. login = sbp_login_find_by_id(tpg, id);
  456. if (!login) {
  457. pr_warn("cannot find login: %d\n", id);
  458. req->status.status = cpu_to_be32(
  459. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  460. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_LOGIN_ID_UNKNOWN));
  461. return;
  462. }
  463. pr_info("mgt_agent LOGOUT from LUN %d session %d\n",
  464. login->login_lun, login->login_id);
  465. if (req->node_addr != login->sess->node_id) {
  466. pr_warn("logout from different node ID\n");
  467. req->status.status = cpu_to_be32(
  468. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  469. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_ACCESS_DENIED));
  470. return;
  471. }
  472. sbp_login_release(login, true);
  473. req->status.status = cpu_to_be32(
  474. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  475. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
  476. }
  477. static void session_check_for_reset(struct sbp_session *sess)
  478. {
  479. bool card_valid = false;
  480. spin_lock_bh(&sess->lock);
  481. if (sess->card) {
  482. spin_lock_irq(&sess->card->lock);
  483. card_valid = (sess->card->local_node != NULL);
  484. spin_unlock_irq(&sess->card->lock);
  485. if (!card_valid) {
  486. fw_card_put(sess->card);
  487. sess->card = NULL;
  488. }
  489. }
  490. if (!card_valid || (sess->generation != sess->card->generation)) {
  491. pr_info("Waiting for reconnect from node: %016llx\n",
  492. sess->guid);
  493. sess->node_id = -1;
  494. sess->reconnect_expires = get_jiffies_64() +
  495. ((sess->reconnect_hold + 1) * HZ);
  496. }
  497. spin_unlock_bh(&sess->lock);
  498. }
  499. static void session_reconnect_expired(struct sbp_session *sess)
  500. {
  501. struct sbp_login_descriptor *login, *temp;
  502. LIST_HEAD(login_list);
  503. pr_info("Reconnect timer expired for node: %016llx\n", sess->guid);
  504. spin_lock_bh(&sess->lock);
  505. list_for_each_entry_safe(login, temp, &sess->login_list, link) {
  506. login->sess = NULL;
  507. list_move_tail(&login->link, &login_list);
  508. }
  509. spin_unlock_bh(&sess->lock);
  510. list_for_each_entry_safe(login, temp, &login_list, link) {
  511. list_del(&login->link);
  512. sbp_login_release(login, false);
  513. }
  514. sbp_session_release(sess, false);
  515. }
  516. static void session_maintenance_work(struct work_struct *work)
  517. {
  518. struct sbp_session *sess = container_of(work, struct sbp_session,
  519. maint_work.work);
  520. /* could be called while tearing down the session */
  521. spin_lock_bh(&sess->lock);
  522. if (list_empty(&sess->login_list)) {
  523. spin_unlock_bh(&sess->lock);
  524. return;
  525. }
  526. spin_unlock_bh(&sess->lock);
  527. if (sess->node_id != -1) {
  528. /* check for bus reset and make node_id invalid */
  529. session_check_for_reset(sess);
  530. schedule_delayed_work(&sess->maint_work,
  531. SESSION_MAINTENANCE_INTERVAL);
  532. } else if (!time_after64(get_jiffies_64(), sess->reconnect_expires)) {
  533. /* still waiting for reconnect */
  534. schedule_delayed_work(&sess->maint_work,
  535. SESSION_MAINTENANCE_INTERVAL);
  536. } else {
  537. /* reconnect timeout has expired */
  538. session_reconnect_expired(sess);
  539. }
  540. }
  541. static int tgt_agent_rw_agent_state(struct fw_card *card, int tcode, void *data,
  542. struct sbp_target_agent *agent)
  543. {
  544. int state;
  545. switch (tcode) {
  546. case TCODE_READ_QUADLET_REQUEST:
  547. pr_debug("tgt_agent AGENT_STATE READ\n");
  548. spin_lock_bh(&agent->lock);
  549. state = agent->state;
  550. spin_unlock_bh(&agent->lock);
  551. *(__be32 *)data = cpu_to_be32(state);
  552. return RCODE_COMPLETE;
  553. case TCODE_WRITE_QUADLET_REQUEST:
  554. /* ignored */
  555. return RCODE_COMPLETE;
  556. default:
  557. return RCODE_TYPE_ERROR;
  558. }
  559. }
  560. static int tgt_agent_rw_agent_reset(struct fw_card *card, int tcode, void *data,
  561. struct sbp_target_agent *agent)
  562. {
  563. switch (tcode) {
  564. case TCODE_WRITE_QUADLET_REQUEST:
  565. pr_debug("tgt_agent AGENT_RESET\n");
  566. spin_lock_bh(&agent->lock);
  567. agent->state = AGENT_STATE_RESET;
  568. spin_unlock_bh(&agent->lock);
  569. return RCODE_COMPLETE;
  570. default:
  571. return RCODE_TYPE_ERROR;
  572. }
  573. }
  574. static int tgt_agent_rw_orb_pointer(struct fw_card *card, int tcode, void *data,
  575. struct sbp_target_agent *agent)
  576. {
  577. struct sbp2_pointer *ptr = data;
  578. switch (tcode) {
  579. case TCODE_WRITE_BLOCK_REQUEST:
  580. spin_lock_bh(&agent->lock);
  581. if (agent->state != AGENT_STATE_SUSPENDED &&
  582. agent->state != AGENT_STATE_RESET) {
  583. spin_unlock_bh(&agent->lock);
  584. pr_notice("Ignoring ORB_POINTER write while active.\n");
  585. return RCODE_CONFLICT_ERROR;
  586. }
  587. agent->state = AGENT_STATE_ACTIVE;
  588. spin_unlock_bh(&agent->lock);
  589. agent->orb_pointer = sbp2_pointer_to_addr(ptr);
  590. agent->doorbell = false;
  591. pr_debug("tgt_agent ORB_POINTER write: 0x%llx\n",
  592. agent->orb_pointer);
  593. queue_work(system_unbound_wq, &agent->work);
  594. return RCODE_COMPLETE;
  595. case TCODE_READ_BLOCK_REQUEST:
  596. pr_debug("tgt_agent ORB_POINTER READ\n");
  597. spin_lock_bh(&agent->lock);
  598. addr_to_sbp2_pointer(agent->orb_pointer, ptr);
  599. spin_unlock_bh(&agent->lock);
  600. return RCODE_COMPLETE;
  601. default:
  602. return RCODE_TYPE_ERROR;
  603. }
  604. }
  605. static int tgt_agent_rw_doorbell(struct fw_card *card, int tcode, void *data,
  606. struct sbp_target_agent *agent)
  607. {
  608. switch (tcode) {
  609. case TCODE_WRITE_QUADLET_REQUEST:
  610. spin_lock_bh(&agent->lock);
  611. if (agent->state != AGENT_STATE_SUSPENDED) {
  612. spin_unlock_bh(&agent->lock);
  613. pr_debug("Ignoring DOORBELL while active.\n");
  614. return RCODE_CONFLICT_ERROR;
  615. }
  616. agent->state = AGENT_STATE_ACTIVE;
  617. spin_unlock_bh(&agent->lock);
  618. agent->doorbell = true;
  619. pr_debug("tgt_agent DOORBELL\n");
  620. queue_work(system_unbound_wq, &agent->work);
  621. return RCODE_COMPLETE;
  622. case TCODE_READ_QUADLET_REQUEST:
  623. return RCODE_COMPLETE;
  624. default:
  625. return RCODE_TYPE_ERROR;
  626. }
  627. }
  628. static int tgt_agent_rw_unsolicited_status_enable(struct fw_card *card,
  629. int tcode, void *data, struct sbp_target_agent *agent)
  630. {
  631. switch (tcode) {
  632. case TCODE_WRITE_QUADLET_REQUEST:
  633. pr_debug("tgt_agent UNSOLICITED_STATUS_ENABLE\n");
  634. /* ignored as we don't send unsolicited status */
  635. return RCODE_COMPLETE;
  636. case TCODE_READ_QUADLET_REQUEST:
  637. return RCODE_COMPLETE;
  638. default:
  639. return RCODE_TYPE_ERROR;
  640. }
  641. }
  642. static void tgt_agent_rw(struct fw_card *card, struct fw_request *request,
  643. int tcode, int destination, int source, int generation,
  644. unsigned long long offset, void *data, size_t length,
  645. void *callback_data)
  646. {
  647. struct sbp_target_agent *agent = callback_data;
  648. struct sbp_session *sess = agent->login->sess;
  649. int sess_gen, sess_node, rcode;
  650. spin_lock_bh(&sess->lock);
  651. sess_gen = sess->generation;
  652. sess_node = sess->node_id;
  653. spin_unlock_bh(&sess->lock);
  654. if (generation != sess_gen) {
  655. pr_notice("ignoring request with wrong generation\n");
  656. rcode = RCODE_TYPE_ERROR;
  657. goto out;
  658. }
  659. if (source != sess_node) {
  660. pr_notice("ignoring request from foreign node (%x != %x)\n",
  661. source, sess_node);
  662. rcode = RCODE_TYPE_ERROR;
  663. goto out;
  664. }
  665. /* turn offset into the offset from the start of the block */
  666. offset -= agent->handler.offset;
  667. if (offset == 0x00 && length == 4) {
  668. /* AGENT_STATE */
  669. rcode = tgt_agent_rw_agent_state(card, tcode, data, agent);
  670. } else if (offset == 0x04 && length == 4) {
  671. /* AGENT_RESET */
  672. rcode = tgt_agent_rw_agent_reset(card, tcode, data, agent);
  673. } else if (offset == 0x08 && length == 8) {
  674. /* ORB_POINTER */
  675. rcode = tgt_agent_rw_orb_pointer(card, tcode, data, agent);
  676. } else if (offset == 0x10 && length == 4) {
  677. /* DOORBELL */
  678. rcode = tgt_agent_rw_doorbell(card, tcode, data, agent);
  679. } else if (offset == 0x14 && length == 4) {
  680. /* UNSOLICITED_STATUS_ENABLE */
  681. rcode = tgt_agent_rw_unsolicited_status_enable(card, tcode,
  682. data, agent);
  683. } else {
  684. rcode = RCODE_ADDRESS_ERROR;
  685. }
  686. out:
  687. fw_send_response(card, request, rcode);
  688. }
  689. static void sbp_handle_command(struct sbp_target_request *);
  690. static int sbp_send_status(struct sbp_target_request *);
  691. static void sbp_free_request(struct sbp_target_request *);
  692. static void tgt_agent_process_work(struct work_struct *work)
  693. {
  694. struct sbp_target_request *req =
  695. container_of(work, struct sbp_target_request, work);
  696. pr_debug("tgt_orb ptr:0x%llx next_ORB:0x%llx data_descriptor:0x%llx misc:0x%x\n",
  697. req->orb_pointer,
  698. sbp2_pointer_to_addr(&req->orb.next_orb),
  699. sbp2_pointer_to_addr(&req->orb.data_descriptor),
  700. be32_to_cpu(req->orb.misc));
  701. if (req->orb_pointer >> 32)
  702. pr_debug("ORB with high bits set\n");
  703. switch (ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc))) {
  704. case 0:/* Format specified by this standard */
  705. sbp_handle_command(req);
  706. return;
  707. case 1: /* Reserved for future standardization */
  708. case 2: /* Vendor-dependent */
  709. req->status.status |= cpu_to_be32(
  710. STATUS_BLOCK_RESP(
  711. STATUS_RESP_REQUEST_COMPLETE) |
  712. STATUS_BLOCK_DEAD(0) |
  713. STATUS_BLOCK_LEN(1) |
  714. STATUS_BLOCK_SBP_STATUS(
  715. SBP_STATUS_REQ_TYPE_NOTSUPP));
  716. sbp_send_status(req);
  717. return;
  718. case 3: /* Dummy ORB */
  719. req->status.status |= cpu_to_be32(
  720. STATUS_BLOCK_RESP(
  721. STATUS_RESP_REQUEST_COMPLETE) |
  722. STATUS_BLOCK_DEAD(0) |
  723. STATUS_BLOCK_LEN(1) |
  724. STATUS_BLOCK_SBP_STATUS(
  725. SBP_STATUS_DUMMY_ORB_COMPLETE));
  726. sbp_send_status(req);
  727. return;
  728. default:
  729. BUG();
  730. }
  731. }
  732. /* used to double-check we haven't been issued an AGENT_RESET */
  733. static inline bool tgt_agent_check_active(struct sbp_target_agent *agent)
  734. {
  735. bool active;
  736. spin_lock_bh(&agent->lock);
  737. active = (agent->state == AGENT_STATE_ACTIVE);
  738. spin_unlock_bh(&agent->lock);
  739. return active;
  740. }
  741. static struct sbp_target_request *sbp_mgt_get_req(struct sbp_session *sess,
  742. struct fw_card *card, u64 next_orb)
  743. {
  744. struct se_session *se_sess = sess->se_sess;
  745. struct sbp_target_request *req;
  746. int tag, cpu;
  747. tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu);
  748. if (tag < 0)
  749. return ERR_PTR(-ENOMEM);
  750. req = &((struct sbp_target_request *)se_sess->sess_cmd_map)[tag];
  751. memset(req, 0, sizeof(*req));
  752. req->se_cmd.map_tag = tag;
  753. req->se_cmd.map_cpu = cpu;
  754. req->se_cmd.tag = next_orb;
  755. return req;
  756. }
  757. static void tgt_agent_fetch_work(struct work_struct *work)
  758. {
  759. struct sbp_target_agent *agent =
  760. container_of(work, struct sbp_target_agent, work);
  761. struct sbp_session *sess = agent->login->sess;
  762. struct sbp_target_request *req;
  763. int ret;
  764. bool doorbell = agent->doorbell;
  765. u64 next_orb = agent->orb_pointer;
  766. while (next_orb && tgt_agent_check_active(agent)) {
  767. req = sbp_mgt_get_req(sess, sess->card, next_orb);
  768. if (IS_ERR(req)) {
  769. spin_lock_bh(&agent->lock);
  770. agent->state = AGENT_STATE_DEAD;
  771. spin_unlock_bh(&agent->lock);
  772. return;
  773. }
  774. req->login = agent->login;
  775. req->orb_pointer = next_orb;
  776. req->status.status = cpu_to_be32(STATUS_BLOCK_ORB_OFFSET_HIGH(
  777. req->orb_pointer >> 32));
  778. req->status.orb_low = cpu_to_be32(
  779. req->orb_pointer & 0xfffffffc);
  780. /* read in the ORB */
  781. ret = sbp_run_transaction(sess->card, TCODE_READ_BLOCK_REQUEST,
  782. sess->node_id, sess->generation, sess->speed,
  783. req->orb_pointer, &req->orb, sizeof(req->orb));
  784. if (ret != RCODE_COMPLETE) {
  785. pr_debug("tgt_orb fetch failed: %x\n", ret);
  786. req->status.status |= cpu_to_be32(
  787. STATUS_BLOCK_SRC(
  788. STATUS_SRC_ORB_FINISHED) |
  789. STATUS_BLOCK_RESP(
  790. STATUS_RESP_TRANSPORT_FAILURE) |
  791. STATUS_BLOCK_DEAD(1) |
  792. STATUS_BLOCK_LEN(1) |
  793. STATUS_BLOCK_SBP_STATUS(
  794. SBP_STATUS_UNSPECIFIED_ERROR));
  795. spin_lock_bh(&agent->lock);
  796. agent->state = AGENT_STATE_DEAD;
  797. spin_unlock_bh(&agent->lock);
  798. sbp_send_status(req);
  799. return;
  800. }
  801. /* check the next_ORB field */
  802. if (be32_to_cpu(req->orb.next_orb.high) & 0x80000000) {
  803. next_orb = 0;
  804. req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
  805. STATUS_SRC_ORB_FINISHED));
  806. } else {
  807. next_orb = sbp2_pointer_to_addr(&req->orb.next_orb);
  808. req->status.status |= cpu_to_be32(STATUS_BLOCK_SRC(
  809. STATUS_SRC_ORB_CONTINUING));
  810. }
  811. if (tgt_agent_check_active(agent) && !doorbell) {
  812. INIT_WORK(&req->work, tgt_agent_process_work);
  813. queue_work(system_unbound_wq, &req->work);
  814. } else {
  815. /* don't process this request, just check next_ORB */
  816. sbp_free_request(req);
  817. }
  818. spin_lock_bh(&agent->lock);
  819. doorbell = agent->doorbell = false;
  820. /* check if we should carry on processing */
  821. if (next_orb)
  822. agent->orb_pointer = next_orb;
  823. else
  824. agent->state = AGENT_STATE_SUSPENDED;
  825. spin_unlock_bh(&agent->lock);
  826. };
  827. }
  828. static struct sbp_target_agent *sbp_target_agent_register(
  829. struct sbp_login_descriptor *login)
  830. {
  831. struct sbp_target_agent *agent;
  832. int ret;
  833. agent = kmalloc(sizeof(*agent), GFP_KERNEL);
  834. if (!agent)
  835. return ERR_PTR(-ENOMEM);
  836. spin_lock_init(&agent->lock);
  837. agent->handler.length = 0x20;
  838. agent->handler.address_callback = tgt_agent_rw;
  839. agent->handler.callback_data = agent;
  840. agent->login = login;
  841. agent->state = AGENT_STATE_RESET;
  842. INIT_WORK(&agent->work, tgt_agent_fetch_work);
  843. agent->orb_pointer = 0;
  844. agent->doorbell = false;
  845. ret = fw_core_add_address_handler(&agent->handler,
  846. &sbp_register_region);
  847. if (ret < 0) {
  848. kfree(agent);
  849. return ERR_PTR(ret);
  850. }
  851. return agent;
  852. }
  853. static void sbp_target_agent_unregister(struct sbp_target_agent *agent)
  854. {
  855. fw_core_remove_address_handler(&agent->handler);
  856. cancel_work_sync(&agent->work);
  857. kfree(agent);
  858. }
  859. /*
  860. * Simple wrapper around fw_run_transaction that retries the transaction several
  861. * times in case of failure, with an exponential backoff.
  862. */
  863. static int sbp_run_transaction(struct fw_card *card, int tcode, int destination_id,
  864. int generation, int speed, unsigned long long offset,
  865. void *payload, size_t length)
  866. {
  867. int attempt, ret, delay;
  868. for (attempt = 1; attempt <= 5; attempt++) {
  869. ret = fw_run_transaction(card, tcode, destination_id,
  870. generation, speed, offset, payload, length);
  871. switch (ret) {
  872. case RCODE_COMPLETE:
  873. case RCODE_TYPE_ERROR:
  874. case RCODE_ADDRESS_ERROR:
  875. case RCODE_GENERATION:
  876. return ret;
  877. default:
  878. delay = 5 * attempt * attempt;
  879. usleep_range(delay, delay * 2);
  880. }
  881. }
  882. return ret;
  883. }
  884. /*
  885. * Wrapper around sbp_run_transaction that gets the card, destination,
  886. * generation and speed out of the request's session.
  887. */
  888. static int sbp_run_request_transaction(struct sbp_target_request *req,
  889. int tcode, unsigned long long offset, void *payload,
  890. size_t length)
  891. {
  892. struct sbp_login_descriptor *login = req->login;
  893. struct sbp_session *sess = login->sess;
  894. struct fw_card *card;
  895. int node_id, generation, speed, ret;
  896. spin_lock_bh(&sess->lock);
  897. card = fw_card_get(sess->card);
  898. node_id = sess->node_id;
  899. generation = sess->generation;
  900. speed = sess->speed;
  901. spin_unlock_bh(&sess->lock);
  902. ret = sbp_run_transaction(card, tcode, node_id, generation, speed,
  903. offset, payload, length);
  904. fw_card_put(card);
  905. return ret;
  906. }
  907. static int sbp_fetch_command(struct sbp_target_request *req)
  908. {
  909. int ret, cmd_len, copy_len;
  910. cmd_len = scsi_command_size(req->orb.command_block);
  911. req->cmd_buf = kmalloc(cmd_len, GFP_KERNEL);
  912. if (!req->cmd_buf)
  913. return -ENOMEM;
  914. memcpy(req->cmd_buf, req->orb.command_block,
  915. min_t(int, cmd_len, sizeof(req->orb.command_block)));
  916. if (cmd_len > sizeof(req->orb.command_block)) {
  917. pr_debug("sbp_fetch_command: filling in long command\n");
  918. copy_len = cmd_len - sizeof(req->orb.command_block);
  919. ret = sbp_run_request_transaction(req,
  920. TCODE_READ_BLOCK_REQUEST,
  921. req->orb_pointer + sizeof(req->orb),
  922. req->cmd_buf + sizeof(req->orb.command_block),
  923. copy_len);
  924. if (ret != RCODE_COMPLETE)
  925. return -EIO;
  926. }
  927. return 0;
  928. }
  929. static int sbp_fetch_page_table(struct sbp_target_request *req)
  930. {
  931. int pg_tbl_sz, ret;
  932. struct sbp_page_table_entry *pg_tbl;
  933. if (!CMDBLK_ORB_PG_TBL_PRESENT(be32_to_cpu(req->orb.misc)))
  934. return 0;
  935. pg_tbl_sz = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc)) *
  936. sizeof(struct sbp_page_table_entry);
  937. pg_tbl = kmalloc(pg_tbl_sz, GFP_KERNEL);
  938. if (!pg_tbl)
  939. return -ENOMEM;
  940. ret = sbp_run_request_transaction(req, TCODE_READ_BLOCK_REQUEST,
  941. sbp2_pointer_to_addr(&req->orb.data_descriptor),
  942. pg_tbl, pg_tbl_sz);
  943. if (ret != RCODE_COMPLETE) {
  944. kfree(pg_tbl);
  945. return -EIO;
  946. }
  947. req->pg_tbl = pg_tbl;
  948. return 0;
  949. }
  950. static void sbp_calc_data_length_direction(struct sbp_target_request *req,
  951. u32 *data_len, enum dma_data_direction *data_dir)
  952. {
  953. int data_size, direction, idx;
  954. data_size = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
  955. direction = CMDBLK_ORB_DIRECTION(be32_to_cpu(req->orb.misc));
  956. if (!data_size) {
  957. *data_len = 0;
  958. *data_dir = DMA_NONE;
  959. return;
  960. }
  961. *data_dir = direction ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
  962. if (req->pg_tbl) {
  963. *data_len = 0;
  964. for (idx = 0; idx < data_size; idx++) {
  965. *data_len += be16_to_cpu(
  966. req->pg_tbl[idx].segment_length);
  967. }
  968. } else {
  969. *data_len = data_size;
  970. }
  971. }
  972. static void sbp_handle_command(struct sbp_target_request *req)
  973. {
  974. struct sbp_login_descriptor *login = req->login;
  975. struct sbp_session *sess = login->sess;
  976. int ret, unpacked_lun;
  977. u32 data_length;
  978. enum dma_data_direction data_dir;
  979. ret = sbp_fetch_command(req);
  980. if (ret) {
  981. pr_debug("sbp_handle_command: fetch command failed: %d\n", ret);
  982. goto err;
  983. }
  984. ret = sbp_fetch_page_table(req);
  985. if (ret) {
  986. pr_debug("sbp_handle_command: fetch page table failed: %d\n",
  987. ret);
  988. goto err;
  989. }
  990. unpacked_lun = req->login->login_lun;
  991. sbp_calc_data_length_direction(req, &data_length, &data_dir);
  992. pr_debug("sbp_handle_command ORB:0x%llx unpacked_lun:%d data_len:%d data_dir:%d\n",
  993. req->orb_pointer, unpacked_lun, data_length, data_dir);
  994. /* only used for printk until we do TMRs */
  995. req->se_cmd.tag = req->orb_pointer;
  996. if (target_submit_cmd(&req->se_cmd, sess->se_sess, req->cmd_buf,
  997. req->sense_buf, unpacked_lun, data_length,
  998. TCM_SIMPLE_TAG, data_dir, TARGET_SCF_ACK_KREF))
  999. goto err;
  1000. return;
  1001. err:
  1002. req->status.status |= cpu_to_be32(
  1003. STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
  1004. STATUS_BLOCK_DEAD(0) |
  1005. STATUS_BLOCK_LEN(1) |
  1006. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
  1007. sbp_send_status(req);
  1008. }
  1009. /*
  1010. * DMA_TO_DEVICE = read from initiator (SCSI WRITE)
  1011. * DMA_FROM_DEVICE = write to initiator (SCSI READ)
  1012. */
  1013. static int sbp_rw_data(struct sbp_target_request *req)
  1014. {
  1015. struct sbp_session *sess = req->login->sess;
  1016. int tcode, sg_miter_flags, max_payload, pg_size, speed, node_id,
  1017. generation, num_pte, length, tfr_length,
  1018. rcode = RCODE_COMPLETE;
  1019. struct sbp_page_table_entry *pte;
  1020. unsigned long long offset;
  1021. struct fw_card *card;
  1022. struct sg_mapping_iter iter;
  1023. if (req->se_cmd.data_direction == DMA_FROM_DEVICE) {
  1024. tcode = TCODE_WRITE_BLOCK_REQUEST;
  1025. sg_miter_flags = SG_MITER_FROM_SG;
  1026. } else {
  1027. tcode = TCODE_READ_BLOCK_REQUEST;
  1028. sg_miter_flags = SG_MITER_TO_SG;
  1029. }
  1030. max_payload = 4 << CMDBLK_ORB_MAX_PAYLOAD(be32_to_cpu(req->orb.misc));
  1031. speed = CMDBLK_ORB_SPEED(be32_to_cpu(req->orb.misc));
  1032. pg_size = CMDBLK_ORB_PG_SIZE(be32_to_cpu(req->orb.misc));
  1033. if (pg_size) {
  1034. pr_err("sbp_run_transaction: page size ignored\n");
  1035. pg_size = 0x100 << pg_size;
  1036. }
  1037. spin_lock_bh(&sess->lock);
  1038. card = fw_card_get(sess->card);
  1039. node_id = sess->node_id;
  1040. generation = sess->generation;
  1041. spin_unlock_bh(&sess->lock);
  1042. if (req->pg_tbl) {
  1043. pte = req->pg_tbl;
  1044. num_pte = CMDBLK_ORB_DATA_SIZE(be32_to_cpu(req->orb.misc));
  1045. offset = 0;
  1046. length = 0;
  1047. } else {
  1048. pte = NULL;
  1049. num_pte = 0;
  1050. offset = sbp2_pointer_to_addr(&req->orb.data_descriptor);
  1051. length = req->se_cmd.data_length;
  1052. }
  1053. sg_miter_start(&iter, req->se_cmd.t_data_sg, req->se_cmd.t_data_nents,
  1054. sg_miter_flags);
  1055. while (length || num_pte) {
  1056. if (!length) {
  1057. offset = (u64)be16_to_cpu(pte->segment_base_hi) << 32 |
  1058. be32_to_cpu(pte->segment_base_lo);
  1059. length = be16_to_cpu(pte->segment_length);
  1060. pte++;
  1061. num_pte--;
  1062. }
  1063. sg_miter_next(&iter);
  1064. tfr_length = min3(length, max_payload, (int)iter.length);
  1065. /* FIXME: take page_size into account */
  1066. rcode = sbp_run_transaction(card, tcode, node_id,
  1067. generation, speed,
  1068. offset, iter.addr, tfr_length);
  1069. if (rcode != RCODE_COMPLETE)
  1070. break;
  1071. length -= tfr_length;
  1072. offset += tfr_length;
  1073. iter.consumed = tfr_length;
  1074. }
  1075. sg_miter_stop(&iter);
  1076. fw_card_put(card);
  1077. if (rcode == RCODE_COMPLETE) {
  1078. WARN_ON(length != 0);
  1079. return 0;
  1080. } else {
  1081. return -EIO;
  1082. }
  1083. }
  1084. static int sbp_send_status(struct sbp_target_request *req)
  1085. {
  1086. int rc, ret = 0, length;
  1087. struct sbp_login_descriptor *login = req->login;
  1088. length = (((be32_to_cpu(req->status.status) >> 24) & 0x07) + 1) * 4;
  1089. rc = sbp_run_request_transaction(req, TCODE_WRITE_BLOCK_REQUEST,
  1090. login->status_fifo_addr, &req->status, length);
  1091. if (rc != RCODE_COMPLETE) {
  1092. pr_debug("sbp_send_status: write failed: 0x%x\n", rc);
  1093. ret = -EIO;
  1094. goto put_ref;
  1095. }
  1096. pr_debug("sbp_send_status: status write complete for ORB: 0x%llx\n",
  1097. req->orb_pointer);
  1098. /*
  1099. * Drop the extra ACK_KREF reference taken by target_submit_cmd()
  1100. * ahead of sbp_check_stop_free() -> transport_generic_free_cmd()
  1101. * final se_cmd->cmd_kref put.
  1102. */
  1103. put_ref:
  1104. target_put_sess_cmd(&req->se_cmd);
  1105. return ret;
  1106. }
  1107. static void sbp_sense_mangle(struct sbp_target_request *req)
  1108. {
  1109. struct se_cmd *se_cmd = &req->se_cmd;
  1110. u8 *sense = req->sense_buf;
  1111. u8 *status = req->status.data;
  1112. WARN_ON(se_cmd->scsi_sense_length < 18);
  1113. switch (sense[0] & 0x7f) { /* sfmt */
  1114. case 0x70: /* current, fixed */
  1115. status[0] = 0 << 6;
  1116. break;
  1117. case 0x71: /* deferred, fixed */
  1118. status[0] = 1 << 6;
  1119. break;
  1120. case 0x72: /* current, descriptor */
  1121. case 0x73: /* deferred, descriptor */
  1122. default:
  1123. /*
  1124. * TODO: SBP-3 specifies what we should do with descriptor
  1125. * format sense data
  1126. */
  1127. pr_err("sbp_send_sense: unknown sense format: 0x%x\n",
  1128. sense[0]);
  1129. req->status.status |= cpu_to_be32(
  1130. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  1131. STATUS_BLOCK_DEAD(0) |
  1132. STATUS_BLOCK_LEN(1) |
  1133. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQUEST_ABORTED));
  1134. return;
  1135. }
  1136. status[0] |= se_cmd->scsi_status & 0x3f;/* status */
  1137. status[1] =
  1138. (sense[0] & 0x80) | /* valid */
  1139. ((sense[2] & 0xe0) >> 1) | /* mark, eom, ili */
  1140. (sense[2] & 0x0f); /* sense_key */
  1141. status[2] = se_cmd->scsi_asc; /* sense_code */
  1142. status[3] = se_cmd->scsi_ascq; /* sense_qualifier */
  1143. /* information */
  1144. status[4] = sense[3];
  1145. status[5] = sense[4];
  1146. status[6] = sense[5];
  1147. status[7] = sense[6];
  1148. /* CDB-dependent */
  1149. status[8] = sense[8];
  1150. status[9] = sense[9];
  1151. status[10] = sense[10];
  1152. status[11] = sense[11];
  1153. /* fru */
  1154. status[12] = sense[14];
  1155. /* sense_key-dependent */
  1156. status[13] = sense[15];
  1157. status[14] = sense[16];
  1158. status[15] = sense[17];
  1159. req->status.status |= cpu_to_be32(
  1160. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  1161. STATUS_BLOCK_DEAD(0) |
  1162. STATUS_BLOCK_LEN(5) |
  1163. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
  1164. }
  1165. static int sbp_send_sense(struct sbp_target_request *req)
  1166. {
  1167. struct se_cmd *se_cmd = &req->se_cmd;
  1168. if (se_cmd->scsi_sense_length) {
  1169. sbp_sense_mangle(req);
  1170. } else {
  1171. req->status.status |= cpu_to_be32(
  1172. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  1173. STATUS_BLOCK_DEAD(0) |
  1174. STATUS_BLOCK_LEN(1) |
  1175. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_OK));
  1176. }
  1177. return sbp_send_status(req);
  1178. }
  1179. static void sbp_free_request(struct sbp_target_request *req)
  1180. {
  1181. struct se_cmd *se_cmd = &req->se_cmd;
  1182. struct se_session *se_sess = se_cmd->se_sess;
  1183. kfree(req->pg_tbl);
  1184. kfree(req->cmd_buf);
  1185. target_free_tag(se_sess, se_cmd);
  1186. }
  1187. static void sbp_mgt_agent_process(struct work_struct *work)
  1188. {
  1189. struct sbp_management_agent *agent =
  1190. container_of(work, struct sbp_management_agent, work);
  1191. struct sbp_management_request *req = agent->request;
  1192. int ret;
  1193. int status_data_len = 0;
  1194. /* fetch the ORB from the initiator */
  1195. ret = sbp_run_transaction(req->card, TCODE_READ_BLOCK_REQUEST,
  1196. req->node_addr, req->generation, req->speed,
  1197. agent->orb_offset, &req->orb, sizeof(req->orb));
  1198. if (ret != RCODE_COMPLETE) {
  1199. pr_debug("mgt_orb fetch failed: %x\n", ret);
  1200. goto out;
  1201. }
  1202. pr_debug("mgt_orb ptr1:0x%llx ptr2:0x%llx misc:0x%x len:0x%x status_fifo:0x%llx\n",
  1203. sbp2_pointer_to_addr(&req->orb.ptr1),
  1204. sbp2_pointer_to_addr(&req->orb.ptr2),
  1205. be32_to_cpu(req->orb.misc), be32_to_cpu(req->orb.length),
  1206. sbp2_pointer_to_addr(&req->orb.status_fifo));
  1207. if (!ORB_NOTIFY(be32_to_cpu(req->orb.misc)) ||
  1208. ORB_REQUEST_FORMAT(be32_to_cpu(req->orb.misc)) != 0) {
  1209. pr_err("mgt_orb bad request\n");
  1210. goto out;
  1211. }
  1212. switch (MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc))) {
  1213. case MANAGEMENT_ORB_FUNCTION_LOGIN:
  1214. sbp_management_request_login(agent, req, &status_data_len);
  1215. break;
  1216. case MANAGEMENT_ORB_FUNCTION_QUERY_LOGINS:
  1217. sbp_management_request_query_logins(agent, req,
  1218. &status_data_len);
  1219. break;
  1220. case MANAGEMENT_ORB_FUNCTION_RECONNECT:
  1221. sbp_management_request_reconnect(agent, req, &status_data_len);
  1222. break;
  1223. case MANAGEMENT_ORB_FUNCTION_SET_PASSWORD:
  1224. pr_notice("SET PASSWORD not implemented\n");
  1225. req->status.status = cpu_to_be32(
  1226. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  1227. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
  1228. break;
  1229. case MANAGEMENT_ORB_FUNCTION_LOGOUT:
  1230. sbp_management_request_logout(agent, req, &status_data_len);
  1231. break;
  1232. case MANAGEMENT_ORB_FUNCTION_ABORT_TASK:
  1233. pr_notice("ABORT TASK not implemented\n");
  1234. req->status.status = cpu_to_be32(
  1235. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  1236. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
  1237. break;
  1238. case MANAGEMENT_ORB_FUNCTION_ABORT_TASK_SET:
  1239. pr_notice("ABORT TASK SET not implemented\n");
  1240. req->status.status = cpu_to_be32(
  1241. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  1242. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
  1243. break;
  1244. case MANAGEMENT_ORB_FUNCTION_LOGICAL_UNIT_RESET:
  1245. pr_notice("LOGICAL UNIT RESET not implemented\n");
  1246. req->status.status = cpu_to_be32(
  1247. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  1248. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
  1249. break;
  1250. case MANAGEMENT_ORB_FUNCTION_TARGET_RESET:
  1251. pr_notice("TARGET RESET not implemented\n");
  1252. req->status.status = cpu_to_be32(
  1253. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  1254. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
  1255. break;
  1256. default:
  1257. pr_notice("unknown management function 0x%x\n",
  1258. MANAGEMENT_ORB_FUNCTION(be32_to_cpu(req->orb.misc)));
  1259. req->status.status = cpu_to_be32(
  1260. STATUS_BLOCK_RESP(STATUS_RESP_REQUEST_COMPLETE) |
  1261. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_REQ_TYPE_NOTSUPP));
  1262. break;
  1263. }
  1264. req->status.status |= cpu_to_be32(
  1265. STATUS_BLOCK_SRC(1) | /* Response to ORB, next_ORB absent */
  1266. STATUS_BLOCK_LEN(DIV_ROUND_UP(status_data_len, 4) + 1) |
  1267. STATUS_BLOCK_ORB_OFFSET_HIGH(agent->orb_offset >> 32));
  1268. req->status.orb_low = cpu_to_be32(agent->orb_offset);
  1269. /* write the status block back to the initiator */
  1270. ret = sbp_run_transaction(req->card, TCODE_WRITE_BLOCK_REQUEST,
  1271. req->node_addr, req->generation, req->speed,
  1272. sbp2_pointer_to_addr(&req->orb.status_fifo),
  1273. &req->status, 8 + status_data_len);
  1274. if (ret != RCODE_COMPLETE) {
  1275. pr_debug("mgt_orb status write failed: %x\n", ret);
  1276. goto out;
  1277. }
  1278. out:
  1279. fw_card_put(req->card);
  1280. kfree(req);
  1281. spin_lock_bh(&agent->lock);
  1282. agent->state = MANAGEMENT_AGENT_STATE_IDLE;
  1283. spin_unlock_bh(&agent->lock);
  1284. }
  1285. static void sbp_mgt_agent_rw(struct fw_card *card,
  1286. struct fw_request *request, int tcode, int destination, int source,
  1287. int generation, unsigned long long offset, void *data, size_t length,
  1288. void *callback_data)
  1289. {
  1290. struct sbp_management_agent *agent = callback_data;
  1291. struct sbp2_pointer *ptr = data;
  1292. int rcode = RCODE_ADDRESS_ERROR;
  1293. if (!agent->tport->enable)
  1294. goto out;
  1295. if ((offset != agent->handler.offset) || (length != 8))
  1296. goto out;
  1297. if (tcode == TCODE_WRITE_BLOCK_REQUEST) {
  1298. struct sbp_management_request *req;
  1299. int prev_state;
  1300. spin_lock_bh(&agent->lock);
  1301. prev_state = agent->state;
  1302. agent->state = MANAGEMENT_AGENT_STATE_BUSY;
  1303. spin_unlock_bh(&agent->lock);
  1304. if (prev_state == MANAGEMENT_AGENT_STATE_BUSY) {
  1305. pr_notice("ignoring management request while busy\n");
  1306. rcode = RCODE_CONFLICT_ERROR;
  1307. goto out;
  1308. }
  1309. req = kzalloc(sizeof(*req), GFP_ATOMIC);
  1310. if (!req) {
  1311. rcode = RCODE_CONFLICT_ERROR;
  1312. goto out;
  1313. }
  1314. req->card = fw_card_get(card);
  1315. req->generation = generation;
  1316. req->node_addr = source;
  1317. req->speed = fw_get_request_speed(request);
  1318. agent->orb_offset = sbp2_pointer_to_addr(ptr);
  1319. agent->request = req;
  1320. queue_work(system_unbound_wq, &agent->work);
  1321. rcode = RCODE_COMPLETE;
  1322. } else if (tcode == TCODE_READ_BLOCK_REQUEST) {
  1323. addr_to_sbp2_pointer(agent->orb_offset, ptr);
  1324. rcode = RCODE_COMPLETE;
  1325. } else {
  1326. rcode = RCODE_TYPE_ERROR;
  1327. }
  1328. out:
  1329. fw_send_response(card, request, rcode);
  1330. }
  1331. static struct sbp_management_agent *sbp_management_agent_register(
  1332. struct sbp_tport *tport)
  1333. {
  1334. int ret;
  1335. struct sbp_management_agent *agent;
  1336. agent = kmalloc(sizeof(*agent), GFP_KERNEL);
  1337. if (!agent)
  1338. return ERR_PTR(-ENOMEM);
  1339. spin_lock_init(&agent->lock);
  1340. agent->tport = tport;
  1341. agent->handler.length = 0x08;
  1342. agent->handler.address_callback = sbp_mgt_agent_rw;
  1343. agent->handler.callback_data = agent;
  1344. agent->state = MANAGEMENT_AGENT_STATE_IDLE;
  1345. INIT_WORK(&agent->work, sbp_mgt_agent_process);
  1346. agent->orb_offset = 0;
  1347. agent->request = NULL;
  1348. ret = fw_core_add_address_handler(&agent->handler,
  1349. &sbp_register_region);
  1350. if (ret < 0) {
  1351. kfree(agent);
  1352. return ERR_PTR(ret);
  1353. }
  1354. return agent;
  1355. }
  1356. static void sbp_management_agent_unregister(struct sbp_management_agent *agent)
  1357. {
  1358. fw_core_remove_address_handler(&agent->handler);
  1359. cancel_work_sync(&agent->work);
  1360. kfree(agent);
  1361. }
  1362. static int sbp_check_true(struct se_portal_group *se_tpg)
  1363. {
  1364. return 1;
  1365. }
  1366. static int sbp_check_false(struct se_portal_group *se_tpg)
  1367. {
  1368. return 0;
  1369. }
  1370. static char *sbp_get_fabric_wwn(struct se_portal_group *se_tpg)
  1371. {
  1372. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1373. struct sbp_tport *tport = tpg->tport;
  1374. return &tport->tport_name[0];
  1375. }
  1376. static u16 sbp_get_tag(struct se_portal_group *se_tpg)
  1377. {
  1378. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1379. return tpg->tport_tpgt;
  1380. }
  1381. static u32 sbp_tpg_get_inst_index(struct se_portal_group *se_tpg)
  1382. {
  1383. return 1;
  1384. }
  1385. static void sbp_release_cmd(struct se_cmd *se_cmd)
  1386. {
  1387. struct sbp_target_request *req = container_of(se_cmd,
  1388. struct sbp_target_request, se_cmd);
  1389. sbp_free_request(req);
  1390. }
  1391. static u32 sbp_sess_get_index(struct se_session *se_sess)
  1392. {
  1393. return 0;
  1394. }
  1395. static int sbp_write_pending(struct se_cmd *se_cmd)
  1396. {
  1397. struct sbp_target_request *req = container_of(se_cmd,
  1398. struct sbp_target_request, se_cmd);
  1399. int ret;
  1400. ret = sbp_rw_data(req);
  1401. if (ret) {
  1402. req->status.status |= cpu_to_be32(
  1403. STATUS_BLOCK_RESP(
  1404. STATUS_RESP_TRANSPORT_FAILURE) |
  1405. STATUS_BLOCK_DEAD(0) |
  1406. STATUS_BLOCK_LEN(1) |
  1407. STATUS_BLOCK_SBP_STATUS(
  1408. SBP_STATUS_UNSPECIFIED_ERROR));
  1409. sbp_send_status(req);
  1410. return ret;
  1411. }
  1412. target_execute_cmd(se_cmd);
  1413. return 0;
  1414. }
  1415. static void sbp_set_default_node_attrs(struct se_node_acl *nacl)
  1416. {
  1417. return;
  1418. }
  1419. static int sbp_get_cmd_state(struct se_cmd *se_cmd)
  1420. {
  1421. return 0;
  1422. }
  1423. static int sbp_queue_data_in(struct se_cmd *se_cmd)
  1424. {
  1425. struct sbp_target_request *req = container_of(se_cmd,
  1426. struct sbp_target_request, se_cmd);
  1427. int ret;
  1428. ret = sbp_rw_data(req);
  1429. if (ret) {
  1430. req->status.status |= cpu_to_be32(
  1431. STATUS_BLOCK_RESP(STATUS_RESP_TRANSPORT_FAILURE) |
  1432. STATUS_BLOCK_DEAD(0) |
  1433. STATUS_BLOCK_LEN(1) |
  1434. STATUS_BLOCK_SBP_STATUS(SBP_STATUS_UNSPECIFIED_ERROR));
  1435. sbp_send_status(req);
  1436. return ret;
  1437. }
  1438. return sbp_send_sense(req);
  1439. }
  1440. /*
  1441. * Called after command (no data transfer) or after the write (to device)
  1442. * operation is completed
  1443. */
  1444. static int sbp_queue_status(struct se_cmd *se_cmd)
  1445. {
  1446. struct sbp_target_request *req = container_of(se_cmd,
  1447. struct sbp_target_request, se_cmd);
  1448. return sbp_send_sense(req);
  1449. }
  1450. static void sbp_queue_tm_rsp(struct se_cmd *se_cmd)
  1451. {
  1452. }
  1453. static void sbp_aborted_task(struct se_cmd *se_cmd)
  1454. {
  1455. return;
  1456. }
  1457. static int sbp_check_stop_free(struct se_cmd *se_cmd)
  1458. {
  1459. struct sbp_target_request *req = container_of(se_cmd,
  1460. struct sbp_target_request, se_cmd);
  1461. return transport_generic_free_cmd(&req->se_cmd, 0);
  1462. }
  1463. static int sbp_count_se_tpg_luns(struct se_portal_group *tpg)
  1464. {
  1465. struct se_lun *lun;
  1466. int count = 0;
  1467. rcu_read_lock();
  1468. hlist_for_each_entry_rcu(lun, &tpg->tpg_lun_hlist, link)
  1469. count++;
  1470. rcu_read_unlock();
  1471. return count;
  1472. }
  1473. static int sbp_update_unit_directory(struct sbp_tport *tport)
  1474. {
  1475. struct se_lun *lun;
  1476. int num_luns, num_entries, idx = 0, mgt_agt_addr, ret;
  1477. u32 *data;
  1478. if (tport->unit_directory.data) {
  1479. fw_core_remove_descriptor(&tport->unit_directory);
  1480. kfree(tport->unit_directory.data);
  1481. tport->unit_directory.data = NULL;
  1482. }
  1483. if (!tport->enable || !tport->tpg)
  1484. return 0;
  1485. num_luns = sbp_count_se_tpg_luns(&tport->tpg->se_tpg);
  1486. /*
  1487. * Number of entries in the final unit directory:
  1488. * - all of those in the template
  1489. * - management_agent
  1490. * - unit_characteristics
  1491. * - reconnect_timeout
  1492. * - unit unique ID
  1493. * - one for each LUN
  1494. *
  1495. * MUST NOT include leaf or sub-directory entries
  1496. */
  1497. num_entries = ARRAY_SIZE(sbp_unit_directory_template) + 4 + num_luns;
  1498. if (tport->directory_id != -1)
  1499. num_entries++;
  1500. /* allocate num_entries + 4 for the header and unique ID leaf */
  1501. data = kcalloc((num_entries + 4), sizeof(u32), GFP_KERNEL);
  1502. if (!data)
  1503. return -ENOMEM;
  1504. /* directory_length */
  1505. data[idx++] = num_entries << 16;
  1506. /* directory_id */
  1507. if (tport->directory_id != -1)
  1508. data[idx++] = (CSR_DIRECTORY_ID << 24) | tport->directory_id;
  1509. /* unit directory template */
  1510. memcpy(&data[idx], sbp_unit_directory_template,
  1511. sizeof(sbp_unit_directory_template));
  1512. idx += ARRAY_SIZE(sbp_unit_directory_template);
  1513. /* management_agent */
  1514. mgt_agt_addr = (tport->mgt_agt->handler.offset - CSR_REGISTER_BASE) / 4;
  1515. data[idx++] = 0x54000000 | (mgt_agt_addr & 0x00ffffff);
  1516. /* unit_characteristics */
  1517. data[idx++] = 0x3a000000 |
  1518. (((tport->mgt_orb_timeout * 2) << 8) & 0xff00) |
  1519. SBP_ORB_FETCH_SIZE;
  1520. /* reconnect_timeout */
  1521. data[idx++] = 0x3d000000 | (tport->max_reconnect_timeout & 0xffff);
  1522. /* unit unique ID (leaf is just after LUNs) */
  1523. data[idx++] = 0x8d000000 | (num_luns + 1);
  1524. rcu_read_lock();
  1525. hlist_for_each_entry_rcu(lun, &tport->tpg->se_tpg.tpg_lun_hlist, link) {
  1526. struct se_device *dev;
  1527. int type;
  1528. /*
  1529. * rcu_dereference_raw protected by se_lun->lun_group symlink
  1530. * reference to se_device->dev_group.
  1531. */
  1532. dev = rcu_dereference_raw(lun->lun_se_dev);
  1533. type = dev->transport->get_device_type(dev);
  1534. /* logical_unit_number */
  1535. data[idx++] = 0x14000000 |
  1536. ((type << 16) & 0x1f0000) |
  1537. (lun->unpacked_lun & 0xffff);
  1538. }
  1539. rcu_read_unlock();
  1540. /* unit unique ID leaf */
  1541. data[idx++] = 2 << 16;
  1542. data[idx++] = tport->guid >> 32;
  1543. data[idx++] = tport->guid;
  1544. tport->unit_directory.length = idx;
  1545. tport->unit_directory.key = (CSR_DIRECTORY | CSR_UNIT) << 24;
  1546. tport->unit_directory.data = data;
  1547. ret = fw_core_add_descriptor(&tport->unit_directory);
  1548. if (ret < 0) {
  1549. kfree(tport->unit_directory.data);
  1550. tport->unit_directory.data = NULL;
  1551. }
  1552. return ret;
  1553. }
  1554. static ssize_t sbp_parse_wwn(const char *name, u64 *wwn)
  1555. {
  1556. const char *cp;
  1557. char c, nibble;
  1558. int pos = 0, err;
  1559. *wwn = 0;
  1560. for (cp = name; cp < &name[SBP_NAMELEN - 1]; cp++) {
  1561. c = *cp;
  1562. if (c == '\n' && cp[1] == '\0')
  1563. continue;
  1564. if (c == '\0') {
  1565. err = 2;
  1566. if (pos != 16)
  1567. goto fail;
  1568. return cp - name;
  1569. }
  1570. err = 3;
  1571. if (isdigit(c))
  1572. nibble = c - '0';
  1573. else if (isxdigit(c))
  1574. nibble = tolower(c) - 'a' + 10;
  1575. else
  1576. goto fail;
  1577. *wwn = (*wwn << 4) | nibble;
  1578. pos++;
  1579. }
  1580. err = 4;
  1581. fail:
  1582. printk(KERN_INFO "err %u len %zu pos %u\n",
  1583. err, cp - name, pos);
  1584. return -1;
  1585. }
  1586. static ssize_t sbp_format_wwn(char *buf, size_t len, u64 wwn)
  1587. {
  1588. return snprintf(buf, len, "%016llx", wwn);
  1589. }
  1590. static int sbp_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
  1591. {
  1592. u64 guid = 0;
  1593. if (sbp_parse_wwn(name, &guid) < 0)
  1594. return -EINVAL;
  1595. return 0;
  1596. }
  1597. static int sbp_post_link_lun(
  1598. struct se_portal_group *se_tpg,
  1599. struct se_lun *se_lun)
  1600. {
  1601. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1602. return sbp_update_unit_directory(tpg->tport);
  1603. }
  1604. static void sbp_pre_unlink_lun(
  1605. struct se_portal_group *se_tpg,
  1606. struct se_lun *se_lun)
  1607. {
  1608. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1609. struct sbp_tport *tport = tpg->tport;
  1610. int ret;
  1611. if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0)
  1612. tport->enable = 0;
  1613. ret = sbp_update_unit_directory(tport);
  1614. if (ret < 0)
  1615. pr_err("unlink LUN: failed to update unit directory\n");
  1616. }
  1617. static struct se_portal_group *sbp_make_tpg(struct se_wwn *wwn,
  1618. const char *name)
  1619. {
  1620. struct sbp_tport *tport =
  1621. container_of(wwn, struct sbp_tport, tport_wwn);
  1622. struct sbp_tpg *tpg;
  1623. unsigned long tpgt;
  1624. int ret;
  1625. if (strstr(name, "tpgt_") != name)
  1626. return ERR_PTR(-EINVAL);
  1627. if (kstrtoul(name + 5, 10, &tpgt) || tpgt > UINT_MAX)
  1628. return ERR_PTR(-EINVAL);
  1629. if (tport->tpg) {
  1630. pr_err("Only one TPG per Unit is possible.\n");
  1631. return ERR_PTR(-EBUSY);
  1632. }
  1633. tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
  1634. if (!tpg)
  1635. return ERR_PTR(-ENOMEM);
  1636. tpg->tport = tport;
  1637. tpg->tport_tpgt = tpgt;
  1638. tport->tpg = tpg;
  1639. /* default attribute values */
  1640. tport->enable = 0;
  1641. tport->directory_id = -1;
  1642. tport->mgt_orb_timeout = 15;
  1643. tport->max_reconnect_timeout = 5;
  1644. tport->max_logins_per_lun = 1;
  1645. tport->mgt_agt = sbp_management_agent_register(tport);
  1646. if (IS_ERR(tport->mgt_agt)) {
  1647. ret = PTR_ERR(tport->mgt_agt);
  1648. goto out_free_tpg;
  1649. }
  1650. ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_SBP);
  1651. if (ret < 0)
  1652. goto out_unreg_mgt_agt;
  1653. return &tpg->se_tpg;
  1654. out_unreg_mgt_agt:
  1655. sbp_management_agent_unregister(tport->mgt_agt);
  1656. out_free_tpg:
  1657. tport->tpg = NULL;
  1658. kfree(tpg);
  1659. return ERR_PTR(ret);
  1660. }
  1661. static void sbp_drop_tpg(struct se_portal_group *se_tpg)
  1662. {
  1663. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1664. struct sbp_tport *tport = tpg->tport;
  1665. core_tpg_deregister(se_tpg);
  1666. sbp_management_agent_unregister(tport->mgt_agt);
  1667. tport->tpg = NULL;
  1668. kfree(tpg);
  1669. }
  1670. static struct se_wwn *sbp_make_tport(
  1671. struct target_fabric_configfs *tf,
  1672. struct config_group *group,
  1673. const char *name)
  1674. {
  1675. struct sbp_tport *tport;
  1676. u64 guid = 0;
  1677. if (sbp_parse_wwn(name, &guid) < 0)
  1678. return ERR_PTR(-EINVAL);
  1679. tport = kzalloc(sizeof(*tport), GFP_KERNEL);
  1680. if (!tport)
  1681. return ERR_PTR(-ENOMEM);
  1682. tport->guid = guid;
  1683. sbp_format_wwn(tport->tport_name, SBP_NAMELEN, guid);
  1684. return &tport->tport_wwn;
  1685. }
  1686. static void sbp_drop_tport(struct se_wwn *wwn)
  1687. {
  1688. struct sbp_tport *tport =
  1689. container_of(wwn, struct sbp_tport, tport_wwn);
  1690. kfree(tport);
  1691. }
  1692. static ssize_t sbp_wwn_version_show(struct config_item *item, char *page)
  1693. {
  1694. return sprintf(page, "FireWire SBP fabric module %s\n", SBP_VERSION);
  1695. }
  1696. CONFIGFS_ATTR_RO(sbp_wwn_, version);
  1697. static struct configfs_attribute *sbp_wwn_attrs[] = {
  1698. &sbp_wwn_attr_version,
  1699. NULL,
  1700. };
  1701. static ssize_t sbp_tpg_directory_id_show(struct config_item *item, char *page)
  1702. {
  1703. struct se_portal_group *se_tpg = to_tpg(item);
  1704. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1705. struct sbp_tport *tport = tpg->tport;
  1706. if (tport->directory_id == -1)
  1707. return sprintf(page, "implicit\n");
  1708. else
  1709. return sprintf(page, "%06x\n", tport->directory_id);
  1710. }
  1711. static ssize_t sbp_tpg_directory_id_store(struct config_item *item,
  1712. const char *page, size_t count)
  1713. {
  1714. struct se_portal_group *se_tpg = to_tpg(item);
  1715. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1716. struct sbp_tport *tport = tpg->tport;
  1717. unsigned long val;
  1718. if (tport->enable) {
  1719. pr_err("Cannot change the directory_id on an active target.\n");
  1720. return -EBUSY;
  1721. }
  1722. if (strstr(page, "implicit") == page) {
  1723. tport->directory_id = -1;
  1724. } else {
  1725. if (kstrtoul(page, 16, &val) < 0)
  1726. return -EINVAL;
  1727. if (val > 0xffffff)
  1728. return -EINVAL;
  1729. tport->directory_id = val;
  1730. }
  1731. return count;
  1732. }
  1733. static ssize_t sbp_tpg_enable_show(struct config_item *item, char *page)
  1734. {
  1735. struct se_portal_group *se_tpg = to_tpg(item);
  1736. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1737. struct sbp_tport *tport = tpg->tport;
  1738. return sprintf(page, "%d\n", tport->enable);
  1739. }
  1740. static ssize_t sbp_tpg_enable_store(struct config_item *item,
  1741. const char *page, size_t count)
  1742. {
  1743. struct se_portal_group *se_tpg = to_tpg(item);
  1744. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1745. struct sbp_tport *tport = tpg->tport;
  1746. unsigned long val;
  1747. int ret;
  1748. if (kstrtoul(page, 0, &val) < 0)
  1749. return -EINVAL;
  1750. if ((val != 0) && (val != 1))
  1751. return -EINVAL;
  1752. if (tport->enable == val)
  1753. return count;
  1754. if (val) {
  1755. if (sbp_count_se_tpg_luns(&tpg->se_tpg) == 0) {
  1756. pr_err("Cannot enable a target with no LUNs!\n");
  1757. return -EINVAL;
  1758. }
  1759. } else {
  1760. /* XXX: force-shutdown sessions instead? */
  1761. spin_lock_bh(&se_tpg->session_lock);
  1762. if (!list_empty(&se_tpg->tpg_sess_list)) {
  1763. spin_unlock_bh(&se_tpg->session_lock);
  1764. return -EBUSY;
  1765. }
  1766. spin_unlock_bh(&se_tpg->session_lock);
  1767. }
  1768. tport->enable = val;
  1769. ret = sbp_update_unit_directory(tport);
  1770. if (ret < 0) {
  1771. pr_err("Could not update Config ROM\n");
  1772. return ret;
  1773. }
  1774. return count;
  1775. }
  1776. CONFIGFS_ATTR(sbp_tpg_, directory_id);
  1777. CONFIGFS_ATTR(sbp_tpg_, enable);
  1778. static struct configfs_attribute *sbp_tpg_base_attrs[] = {
  1779. &sbp_tpg_attr_directory_id,
  1780. &sbp_tpg_attr_enable,
  1781. NULL,
  1782. };
  1783. static ssize_t sbp_tpg_attrib_mgt_orb_timeout_show(struct config_item *item,
  1784. char *page)
  1785. {
  1786. struct se_portal_group *se_tpg = attrib_to_tpg(item);
  1787. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1788. struct sbp_tport *tport = tpg->tport;
  1789. return sprintf(page, "%d\n", tport->mgt_orb_timeout);
  1790. }
  1791. static ssize_t sbp_tpg_attrib_mgt_orb_timeout_store(struct config_item *item,
  1792. const char *page, size_t count)
  1793. {
  1794. struct se_portal_group *se_tpg = attrib_to_tpg(item);
  1795. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1796. struct sbp_tport *tport = tpg->tport;
  1797. unsigned long val;
  1798. int ret;
  1799. if (kstrtoul(page, 0, &val) < 0)
  1800. return -EINVAL;
  1801. if ((val < 1) || (val > 127))
  1802. return -EINVAL;
  1803. if (tport->mgt_orb_timeout == val)
  1804. return count;
  1805. tport->mgt_orb_timeout = val;
  1806. ret = sbp_update_unit_directory(tport);
  1807. if (ret < 0)
  1808. return ret;
  1809. return count;
  1810. }
  1811. static ssize_t sbp_tpg_attrib_max_reconnect_timeout_show(struct config_item *item,
  1812. char *page)
  1813. {
  1814. struct se_portal_group *se_tpg = attrib_to_tpg(item);
  1815. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1816. struct sbp_tport *tport = tpg->tport;
  1817. return sprintf(page, "%d\n", tport->max_reconnect_timeout);
  1818. }
  1819. static ssize_t sbp_tpg_attrib_max_reconnect_timeout_store(struct config_item *item,
  1820. const char *page, size_t count)
  1821. {
  1822. struct se_portal_group *se_tpg = attrib_to_tpg(item);
  1823. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1824. struct sbp_tport *tport = tpg->tport;
  1825. unsigned long val;
  1826. int ret;
  1827. if (kstrtoul(page, 0, &val) < 0)
  1828. return -EINVAL;
  1829. if ((val < 1) || (val > 32767))
  1830. return -EINVAL;
  1831. if (tport->max_reconnect_timeout == val)
  1832. return count;
  1833. tport->max_reconnect_timeout = val;
  1834. ret = sbp_update_unit_directory(tport);
  1835. if (ret < 0)
  1836. return ret;
  1837. return count;
  1838. }
  1839. static ssize_t sbp_tpg_attrib_max_logins_per_lun_show(struct config_item *item,
  1840. char *page)
  1841. {
  1842. struct se_portal_group *se_tpg = attrib_to_tpg(item);
  1843. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1844. struct sbp_tport *tport = tpg->tport;
  1845. return sprintf(page, "%d\n", tport->max_logins_per_lun);
  1846. }
  1847. static ssize_t sbp_tpg_attrib_max_logins_per_lun_store(struct config_item *item,
  1848. const char *page, size_t count)
  1849. {
  1850. struct se_portal_group *se_tpg = attrib_to_tpg(item);
  1851. struct sbp_tpg *tpg = container_of(se_tpg, struct sbp_tpg, se_tpg);
  1852. struct sbp_tport *tport = tpg->tport;
  1853. unsigned long val;
  1854. if (kstrtoul(page, 0, &val) < 0)
  1855. return -EINVAL;
  1856. if ((val < 1) || (val > 127))
  1857. return -EINVAL;
  1858. /* XXX: also check against current count? */
  1859. tport->max_logins_per_lun = val;
  1860. return count;
  1861. }
  1862. CONFIGFS_ATTR(sbp_tpg_attrib_, mgt_orb_timeout);
  1863. CONFIGFS_ATTR(sbp_tpg_attrib_, max_reconnect_timeout);
  1864. CONFIGFS_ATTR(sbp_tpg_attrib_, max_logins_per_lun);
  1865. static struct configfs_attribute *sbp_tpg_attrib_attrs[] = {
  1866. &sbp_tpg_attrib_attr_mgt_orb_timeout,
  1867. &sbp_tpg_attrib_attr_max_reconnect_timeout,
  1868. &sbp_tpg_attrib_attr_max_logins_per_lun,
  1869. NULL,
  1870. };
  1871. static const struct target_core_fabric_ops sbp_ops = {
  1872. .module = THIS_MODULE,
  1873. .fabric_name = "sbp",
  1874. .tpg_get_wwn = sbp_get_fabric_wwn,
  1875. .tpg_get_tag = sbp_get_tag,
  1876. .tpg_check_demo_mode = sbp_check_true,
  1877. .tpg_check_demo_mode_cache = sbp_check_true,
  1878. .tpg_check_demo_mode_write_protect = sbp_check_false,
  1879. .tpg_check_prod_mode_write_protect = sbp_check_false,
  1880. .tpg_get_inst_index = sbp_tpg_get_inst_index,
  1881. .release_cmd = sbp_release_cmd,
  1882. .sess_get_index = sbp_sess_get_index,
  1883. .write_pending = sbp_write_pending,
  1884. .set_default_node_attributes = sbp_set_default_node_attrs,
  1885. .get_cmd_state = sbp_get_cmd_state,
  1886. .queue_data_in = sbp_queue_data_in,
  1887. .queue_status = sbp_queue_status,
  1888. .queue_tm_rsp = sbp_queue_tm_rsp,
  1889. .aborted_task = sbp_aborted_task,
  1890. .check_stop_free = sbp_check_stop_free,
  1891. .fabric_make_wwn = sbp_make_tport,
  1892. .fabric_drop_wwn = sbp_drop_tport,
  1893. .fabric_make_tpg = sbp_make_tpg,
  1894. .fabric_drop_tpg = sbp_drop_tpg,
  1895. .fabric_post_link = sbp_post_link_lun,
  1896. .fabric_pre_unlink = sbp_pre_unlink_lun,
  1897. .fabric_make_np = NULL,
  1898. .fabric_drop_np = NULL,
  1899. .fabric_init_nodeacl = sbp_init_nodeacl,
  1900. .tfc_wwn_attrs = sbp_wwn_attrs,
  1901. .tfc_tpg_base_attrs = sbp_tpg_base_attrs,
  1902. .tfc_tpg_attrib_attrs = sbp_tpg_attrib_attrs,
  1903. };
  1904. static int __init sbp_init(void)
  1905. {
  1906. return target_register_template(&sbp_ops);
  1907. };
  1908. static void __exit sbp_exit(void)
  1909. {
  1910. target_unregister_template(&sbp_ops);
  1911. };
  1912. MODULE_DESCRIPTION("FireWire SBP fabric driver");
  1913. MODULE_LICENSE("GPL");
  1914. module_init(sbp_init);
  1915. module_exit(sbp_exit);