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