Lines Matching +full:cmd +full:- +full:cnt +full:- +full:name
1 // SPDX-License-Identifier: GPL-2.0
29 efct_lio_parse_wwn(const char *name, u64 *wwp, u8 npiv)
35 num = sscanf(name,
40 num = sscanf(name,
47 return -EINVAL;
54 efct_lio_parse_npiv_wwn(const char *name, size_t size, u64 *wwpn, u64 *wwnn)
56 unsigned int cnt = size;
60 if (name[cnt - 1] == '\n' || name[cnt - 1] == 0)
61 cnt--;
64 if ((cnt != (16 + 1 + 16)) || (name[16] != ':'))
65 return -EINVAL;
67 rc = efct_lio_parse_wwn(&name[0], wwpn, 1);
71 rc = efct_lio_parse_wwn(&name[17], wwnn, 1);
85 return snprintf(page, PAGE_SIZE, "%d\n", tpg->enabled);
99 if (!tpg->nport || !tpg->nport->efct) {
101 return -EINVAL;
104 efct = tpg->nport->efct;
105 efc = efct->efcport;
108 return -EINVAL;
113 tpg->enabled = true;
114 efc_log_debug(efct, "enable portal group %d\n", tpg->tpgt);
116 ret = efct_xport_control(efct->xport, EFCT_XPORT_PORT_ONLINE);
118 efct->tgt_efct.lio_nport = NULL;
123 efc_log_debug(efct, "disable portal group %d\n", tpg->tpgt);
125 if (efc->domain && efc->domain->nport)
126 efct_scsi_tgt_del_nport(efc, efc->domain->nport);
128 tpg->enabled = false;
130 return -EINVAL;
143 return snprintf(page, PAGE_SIZE, "%d\n", tpg->enabled);
153 struct efct_lio_vport *lio_vport = tpg->vport;
159 return -EINVAL;
163 return -EINVAL;
166 efct = lio_vport->efct;
167 efc = efct->efcport;
170 tpg->enabled = true;
171 efc_log_debug(efct, "enable portal group %d\n", tpg->tpgt);
173 if (efc->domain) {
176 ret = efc_nport_vport_new(efc->domain,
177 lio_vport->npiv_wwpn,
178 lio_vport->npiv_wwnn,
188 if (!(efc_vport_create_spec(efc, lio_vport->npiv_wwnn,
189 lio_vport->npiv_wwpn, U32_MAX,
191 return -ENOMEM;
194 efc_log_debug(efct, "disable portal group %d\n", tpg->tpgt);
196 tpg->enabled = false;
200 if (efc->domain) {
201 efc_nport_vport_del(efct->efcport, efc->domain,
202 lio_vport->npiv_wwpn,
203 lio_vport->npiv_wwnn);
207 return -EINVAL;
217 return tpg->nport->wwpn_str;
225 return tpg->vport->wwpn_str;
233 return tpg->tpgt;
241 return tpg->tpgt;
259 return tpg->tpg_attrib.demo_mode_write_protect;
268 return tpg->tpg_attrib.demo_mode_write_protect;
276 return tpg->tpg_attrib.prod_mode_write_protect;
285 return tpg->tpg_attrib.prod_mode_write_protect;
291 container_of(se_cmd, struct efct_scsi_tgt_io, cmd);
311 container_of(se_cmd, struct efct_scsi_tgt_io, cmd);
316 if (ocp->rsp_sent)
320 ocp->aborting = true;
321 ocp->err = EFCT_SCSI_STATUS_ABORTED;
329 container_of(se_cmd, struct efct_scsi_tgt_io, cmd);
331 struct efct *efct = io->efct;
336 atomic_sub_return(1, &efct->tgt_efct.ios_in_use);
341 struct efc_node *node = se_sess->fabric_sess_ptr;
353 static int efct_lio_get_cmd_state(struct se_cmd *cmd)
356 container_of(cmd, struct efct_scsi_tgt_io, cmd);
359 return io->tgt_io.state;
365 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
366 struct se_cmd *cmd = &ocp->cmd;
368 ocp->seg_map_cnt = dma_map_sg(&io->efct->pci->dev, cmd->t_data_sg,
369 cmd->t_data_nents, cmd->data_direction);
370 if (ocp->seg_map_cnt == 0)
371 return -EFAULT;
378 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
379 struct se_cmd *cmd = &ocp->cmd;
381 if (WARN_ON(!ocp->seg_map_cnt || !cmd->t_data_sg))
384 dma_unmap_sg(&io->efct->pci->dev, cmd->t_data_sg,
385 cmd->t_data_nents, cmd->data_direction);
386 ocp->seg_map_cnt = 0;
394 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
400 ocp->err = scsi_status;
402 if (ocp->seg_map_cnt)
406 scsi_status, ocp->err, flags, ocp->ddir);
409 transport_generic_free_cmd(&io->tgt_io.cmd, 0);
418 efct_lio_write_pending(struct se_cmd *cmd)
421 container_of(cmd, struct efct_scsi_tgt_io, cmd);
423 struct efct_scsi_sgl *sgl = io->sgl;
425 u32 flags = 0, cnt, curcnt;
430 cmd->transport_state, cmd->se_cmd_flags);
432 if (ocp->seg_cnt == 0) {
433 ocp->seg_cnt = cmd->t_data_nents;
434 ocp->cur_seg = 0;
437 return -EFAULT;
440 curcnt = (ocp->seg_map_cnt - ocp->cur_seg);
441 curcnt = (curcnt < io->sgl_allocated) ? curcnt : io->sgl_allocated;
443 for (cnt = 0, sg = cmd->t_data_sg; cnt < ocp->cur_seg; cnt++,
447 for (cnt = 0; cnt < curcnt; cnt++, sg = sg_next(sg)) {
448 sgl[cnt].addr = sg_dma_address(sg);
449 sgl[cnt].dif_addr = 0;
450 sgl[cnt].len = sg_dma_len(sg);
451 length += sgl[cnt].len;
452 ocp->cur_seg++;
455 if (ocp->cur_seg == ocp->seg_cnt)
463 efct_lio_queue_data_in(struct se_cmd *cmd)
466 container_of(cmd, struct efct_scsi_tgt_io, cmd);
468 struct efct_scsi_sgl *sgl = io->sgl;
470 uint flags = 0, cnt = 0, curcnt = 0;
475 if (ocp->seg_cnt == 0) {
476 if (cmd->data_length) {
477 ocp->seg_cnt = cmd->t_data_nents;
478 ocp->cur_seg = 0;
482 return -EAGAIN;
490 "cmd : %p length 0, send status\n",
491 cmd);
496 curcnt = min(ocp->seg_map_cnt - ocp->cur_seg, io->sgl_allocated);
498 while (cnt < curcnt) {
499 sg = &cmd->t_data_sg[ocp->cur_seg];
500 sgl[cnt].addr = sg_dma_address(sg);
501 sgl[cnt].dif_addr = 0;
502 if (ocp->transferred_len + sg_dma_len(sg) >= cmd->data_length)
503 sgl[cnt].len = cmd->data_length - ocp->transferred_len;
505 sgl[cnt].len = sg_dma_len(sg);
507 ocp->transferred_len += sgl[cnt].len;
508 length += sgl[cnt].len;
509 ocp->cur_seg++;
510 cnt++;
511 if (ocp->transferred_len == cmd->data_length)
515 if (ocp->transferred_len == cmd->data_length) {
517 ocp->seg_cnt = ocp->cur_seg;
521 if (cmd->residual_count)
535 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
536 struct se_cmd *cmd = &io->tgt_io.cmd;
540 ocp->rsp_sent = true;
542 transport_generic_free_cmd(&io->tgt_io.cmd, 0);
548 rsp.scsi_status = cmd->scsi_status;
549 rsp.sense_data = (uint8_t *)io->tgt_io.sense_buffer;
550 rsp.sense_data_length = cmd->scsi_sense_length;
553 if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT)
554 rsp.residual = -cmd->residual_count;
555 else if (cmd->se_cmd_flags & SCF_UNDERFLOW_BIT)
556 rsp.residual = cmd->residual_count;
563 transport_generic_free_cmd(&io->tgt_io.cmd, 0);
565 ocp->rsp_sent = true;
573 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
579 ocp->err = scsi_status;
581 efct_lio_io_printf(io, "seg_map_cnt=%d\n", ocp->seg_map_cnt);
582 if (ocp->seg_map_cnt) {
583 if (ocp->err == EFCT_SCSI_STATUS_GOOD &&
584 ocp->cur_seg < ocp->seg_cnt) {
587 efct_lio_io_printf(io, "continuing cmd at segm=%d\n",
588 ocp->cur_seg);
589 if (ocp->ddir == DMA_TO_DEVICE)
590 rc = efct_lio_write_pending(&ocp->cmd);
592 rc = efct_lio_queue_data_in(&ocp->cmd);
596 ocp->err = EFCT_SCSI_STATUS_ERROR;
602 if (io->tgt_io.aborting) {
607 if (ocp->ddir == DMA_TO_DEVICE) {
609 io->tgt_io.cmd.transport_state);
611 transport_generic_request_failure(&io->tgt_io.cmd,
618 target_execute_cmd(&io->tgt_io.cmd);
630 efct_lio_tmfio_printf(io, "cmd=%p status=%d, flags=0x%x\n",
631 &io->tgt_io.cmd, scsi_status, flags);
634 transport_generic_free_cmd(&io->tgt_io.cmd, 0);
643 efct_lio_tmfio_printf(tmfio, "cmd=%p status=%d, flags=0x%x\n",
644 &tmfio->tgt_io.cmd, scsi_status, flags);
652 efct_lio_queue_status(struct se_cmd *cmd)
656 container_of(cmd, struct efct_scsi_tgt_io, cmd);
663 cmd->scsi_status, cmd->transport_state, cmd->se_cmd_flags,
664 cmd->scsi_sense_length);
667 rsp.scsi_status = cmd->scsi_status;
668 rsp.sense_data = (u8 *)io->tgt_io.sense_buffer;
669 rsp.sense_data_length = cmd->scsi_sense_length;
674 if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT)
675 rsp.residual = -cmd->residual_count;
676 else if (cmd->se_cmd_flags & SCF_UNDERFLOW_BIT)
677 rsp.residual = cmd->residual_count;
682 ocp->rsp_sent = true;
686 static void efct_lio_queue_tm_rsp(struct se_cmd *cmd)
689 container_of(cmd, struct efct_scsi_tgt_io, cmd);
691 struct se_tmr_req *se_tmr = cmd->se_tmr_req;
694 efct_lio_tmfio_printf(tmfio, "cmd=%p function=0x%x tmr->response=%d\n",
695 cmd, se_tmr->function, se_tmr->response);
696 switch (se_tmr->response) {
721 if (wwpn == efct_get_wwpn(&efct->hw))
730 struct config_group *group, const char *name)
737 ret = efct_lio_parse_wwn(name, &wwpn, 0);
743 pr_err("cannot find EFCT for base wwpn %s\n", name);
744 return ERR_PTR(-ENXIO);
749 return ERR_PTR(-ENOMEM);
751 lio_nport->efct = efct;
752 lio_nport->wwpn = wwpn;
753 efct_format_wwn(lio_nport->wwpn_str, sizeof(lio_nport->wwpn_str),
755 efct->tgt_efct.lio_nport = lio_nport;
757 return &lio_nport->nport_wwn;
762 struct config_group *group, const char *name)
774 snprintf(tmp, sizeof(tmp), "%s", name);
781 return ERR_PTR(-EINVAL);
795 pr_err("cannot find EFCT for base wwpn %s\n", name);
796 return ERR_PTR(-ENXIO);
801 return ERR_PTR(-ENOMEM);
803 lio_vport->efct = efct;
804 lio_vport->wwpn = p_wwpn;
805 lio_vport->npiv_wwpn = npiv_wwpn;
806 lio_vport->npiv_wwnn = npiv_wwnn;
808 efct_format_wwn(lio_vport->wwpn_str, sizeof(lio_vport->wwpn_str),
814 return ERR_PTR(-ENOMEM);
817 vport_list->lio_vport = lio_vport;
826 new_fc_vport = fc_vport_create(efct->shost, 0, &vport_id);
831 return ERR_PTR(-ENOMEM);
834 lio_vport->fc_vport = new_fc_vport;
835 spin_lock_irqsave(&efct->tgt_efct.efct_lio_lock, flags);
836 INIT_LIST_HEAD(&vport_list->list_entry);
837 list_add_tail(&vport_list->list_entry, &efct->tgt_efct.vport_list);
838 spin_unlock_irqrestore(&efct->tgt_efct.efct_lio_lock, flags);
840 return &lio_vport->vport_wwn;
848 struct efct *efct = lio_nport->efct;
853 kfree(efct->tgt_efct.lio_nport);
854 efct->tgt_efct.lio_nport = NULL;
863 struct efct *efct = lio_vport->efct;
866 if (lio_vport->fc_vport)
867 fc_vport_terminate(lio_vport->fc_vport);
869 spin_lock_irqsave(&efct->tgt_efct.efct_lio_lock, flags);
871 list_for_each_entry_safe(vport, next_vport, &efct->tgt_efct.vport_list,
873 if (vport->lio_vport == lio_vport) {
874 list_del(&vport->list_entry);
875 kfree(vport->lio_vport);
880 spin_unlock_irqrestore(&efct->tgt_efct.efct_lio_lock, flags);
884 efct_lio_make_tpg(struct se_wwn *wwn, const char *name)
893 if (strstr(name, "tpgt_") != name)
894 return ERR_PTR(-EINVAL);
895 if (kstrtoul(name + 5, 10, &n) || n > USHRT_MAX)
896 return ERR_PTR(-EINVAL);
900 return ERR_PTR(-ENOMEM);
902 tpg->nport = lio_nport;
903 tpg->tpgt = n;
904 tpg->enabled = false;
906 tpg->tpg_attrib.generate_node_acls = 1;
907 tpg->tpg_attrib.demo_mode_write_protect = 1;
908 tpg->tpg_attrib.cache_dynamic_acls = 1;
909 tpg->tpg_attrib.demo_mode_login_only = 1;
910 tpg->tpg_attrib.session_deletion_wait = 1;
912 ret = core_tpg_register(wwn, &tpg->tpg, SCSI_PROTOCOL_FCP);
917 efct = lio_nport->efct;
918 efct->tgt_efct.tpg = tpg;
919 efc_log_debug(efct, "create portal group %d\n", tpg->tpgt);
921 xa_init(&efct->lookup);
922 return &tpg->tpg;
931 struct efct *efct = tpg->nport->efct;
933 efc_log_debug(efct, "drop portal group %d\n", tpg->tpgt);
934 tpg->nport->efct->tgt_efct.tpg = NULL;
936 xa_destroy(&efct->lookup);
941 efct_lio_npiv_make_tpg(struct se_wwn *wwn, const char *name)
950 efct = lio_vport->efct;
951 if (strstr(name, "tpgt_") != name)
952 return ERR_PTR(-EINVAL);
953 if (kstrtoul(name + 5, 10, &n) || n > USHRT_MAX)
954 return ERR_PTR(-EINVAL);
958 return ERR_PTR(-EINVAL);
963 return ERR_PTR(-ENOMEM);
965 tpg->vport = lio_vport;
966 tpg->tpgt = n;
967 tpg->enabled = false;
969 tpg->tpg_attrib.generate_node_acls = 1;
970 tpg->tpg_attrib.demo_mode_write_protect = 1;
971 tpg->tpg_attrib.cache_dynamic_acls = 1;
972 tpg->tpg_attrib.demo_mode_login_only = 1;
973 tpg->tpg_attrib.session_deletion_wait = 1;
975 ret = core_tpg_register(wwn, &tpg->tpg, SCSI_PROTOCOL_FCP);
981 lio_vport->tpg = tpg;
982 efc_log_debug(efct, "create vport portal group %d\n", tpg->tpgt);
984 return &tpg->tpg;
993 efc_log_debug(tpg->vport->efct, "drop npiv portal group %d\n",
994 tpg->tpgt);
1000 efct_lio_init_nodeacl(struct se_node_acl *se_nacl, const char *name)
1005 if (efct_lio_parse_wwn(name, &wwnn, 0) < 0)
1006 return -EINVAL;
1009 nacl->nport_wwnn = wwnn;
1011 efct_format_wwn(nacl->nport_name, sizeof(nacl->nport_name), "", wwnn);
1019 return tpg->tpg_attrib.demo_mode_login_only;
1027 return tpg->tpg_attrib.demo_mode_login_only;
1034 u64 wwpn = node->nport->wwpn;
1040 efct = node->efc->base;
1041 spin_lock_irqsave(&efct->tgt_efct.efct_lio_lock, flags);
1042 list_for_each_entry_safe(vport, next, &efct->tgt_efct.vport_list,
1044 lio_vport = vport->lio_vport;
1045 if (wwpn && lio_vport && lio_vport->npiv_wwpn == wwpn) {
1047 tpg = lio_vport->tpg;
1051 spin_unlock_irqrestore(&efct->tgt_efct.efct_lio_lock, flags);
1059 struct efc_node *node = tgt_node->node;
1061 efc_scsi_del_initiator_complete(node->efc, node);
1070 struct efct *efct = node->efc->base;
1074 return -ENOMEM;
1076 kref_init(&tgt_node->ref);
1077 tgt_node->release = _efct_tgt_node_free;
1079 tgt_node->session = se_sess;
1080 node->tgt_node = tgt_node;
1081 tgt_node->efct = efct;
1083 tgt_node->node = node;
1085 tgt_node->node_fc_id = node->rnode.fc_id;
1086 tgt_node->port_fc_id = node->nport->fc_id;
1087 tgt_node->vpi = node->nport->indicator;
1088 tgt_node->rpi = node->rnode.indicator;
1090 spin_lock_init(&tgt_node->active_ios_lock);
1091 INIT_LIST_HEAD(&tgt_node->active_ios);
1101 efct->tgt_efct.max_sge = sli_get_max_sge(&efct->hw.sli);
1102 efct->tgt_efct.max_sgl = sli_get_max_sgl(&efct->hw.sli);
1105 atomic_set(&efct->tgt_efct.ios_in_use, 0);
1106 total_ios = efct->hw.config.n_io;
1108 efct->tgt_efct.watermark_min =
1110 efct->tgt_efct.watermark_max =
1112 atomic_set(&efct->tgt_efct.io_high_watermark,
1113 efct->tgt_efct.watermark_max);
1114 atomic_set(&efct->tgt_efct.watermark_hit, 0);
1115 atomic_set(&efct->tgt_efct.initiator_count, 0);
1121 return -EIO;
1124 spin_lock_init(&efct->tgt_efct.efct_lio_lock);
1125 INIT_LIST_HEAD(&efct->tgt_efct.vport_list);
1140 struct efct *efct = nport->efc->base;
1142 efc_log_debug(efct, "New SPORT: %s bound to %s\n", nport->display_name,
1143 efct->tgt_efct.lio_nport->wwpn_str);
1151 efc_log_debug(efc, "Del SPORT: %s\n", nport->display_name);
1158 struct efct *efct = wq_data->efct;
1159 struct efc_node *node = wq_data->ptr;
1174 se_tpg = &tpg->tpg;
1175 } else if (efct->tgt_efct.tpg) {
1176 tpg = efct->tgt_efct.tpg;
1177 se_tpg = &tpg->tpg;
1195 efc_scsi_sess_reg_complete(node, -EIO);
1199 tgt_node = node->tgt_node;
1200 id = (u64) tgt_node->port_fc_id << 32 | tgt_node->node_fc_id;
1205 if (xa_err(xa_store(&efct->lookup, id, tgt_node, GFP_KERNEL)))
1211 ini_count = atomic_add_return(1, &efct->tgt_efct.initiator_count);
1212 watermark = efct->tgt_efct.watermark_max -
1214 watermark = (efct->tgt_efct.watermark_min > watermark) ?
1215 efct->tgt_efct.watermark_min : watermark;
1216 atomic_set(&efct->tgt_efct.io_high_watermark, watermark);
1223 struct efct *efct = node->efc->base;
1232 return -ENOMEM;
1234 wq_data->ptr = node;
1235 wq_data->efct = efct;
1236 INIT_WORK(&wq_data->work, efct_lio_setup_session);
1237 queue_work(lio_wq, &wq_data->work);
1245 struct efct *efct = wq_data->efct;
1246 struct efc_node *node = wq_data->ptr;
1250 tgt_node = node->tgt_node;
1252 /* base driver has sent back-to-back requests
1257 efc_scsi_del_initiator_complete(node->efc, node);
1261 se_sess = tgt_node->session;
1271 tgt_node->session = NULL;
1272 node->tgt_node = NULL;
1273 kref_put(&tgt_node->ref, tgt_node->release);
1280 struct efct *efct = node->efc->base;
1281 struct efct_node *tgt_node = node->tgt_node;
1292 return -EIO;
1297 return -ENOMEM;
1299 id = (u64) tgt_node->port_fc_id << 32 | tgt_node->node_fc_id;
1300 xa_erase(&efct->lookup, id);
1302 wq_data->ptr = node;
1303 wq_data->efct = efct;
1304 INIT_WORK(&wq_data->work, efct_lio_remove_session);
1305 queue_work(lio_wq, &wq_data->work);
1310 ini_count = atomic_sub_return(1, &efct->tgt_efct.initiator_count);
1312 watermark = efct->tgt_efct.watermark_max -
1314 watermark = (efct->tgt_efct.watermark_min > watermark) ?
1315 efct->tgt_efct.watermark_min : watermark;
1316 atomic_set(&efct->tgt_efct.io_high_watermark, watermark);
1324 struct efct_scsi_tgt_io *ocp = &io->tgt_io;
1325 struct se_cmd *se_cmd = &io->tgt_io.cmd;
1326 struct efct *efct = io->efct;
1334 atomic_add_return(1, &efct->tgt_efct.ios_in_use);
1337 io->timeout = efct->target_io_timer_sec;
1340 ocp->task_attr = TCM_SIMPLE_TAG;
1342 ocp->task_attr = TCM_HEAD_TAG;
1344 ocp->task_attr = TCM_ORDERED_TAG;
1346 ocp->task_attr = TCM_ACA_TAG;
1351 ocp->ddir = DMA_TO_DEVICE;
1355 ocp->ddir = DMA_FROM_DEVICE;
1359 ocp->ddir = DMA_BIDIRECTIONAL;
1363 ocp->ddir = DMA_NONE;
1367 ocp->lun = lun;
1368 efct_lio_io_printf(io, "new cmd=0x%x ddir=%s dl=%u\n",
1369 cdb[0], ddir, io->exp_xfer_len);
1371 tgt_node = io->node;
1372 se_sess = tgt_node->session;
1375 &ocp->cmd);
1381 rc = target_init_cmd(se_cmd, se_sess, &io->tgt_io.sense_buffer[0],
1382 ocp->lun, io->exp_xfer_len, ocp->task_attr,
1383 ocp->ddir, TARGET_SCF_ACK_KREF);
1385 efc_log_err(efct, "failed to init cmd se_cmd: %p\n", se_cmd);
1398 efct_scsi_recv_tmf(struct efct_io *tmfio, u32 lun, enum efct_scsi_tmf_cmd cmd,
1402 struct efct *efct = tmfio->efct;
1403 struct efct_scsi_tgt_io *ocp = &tmfio->tgt_io;
1410 atomic_add_return(1, &efct->tgt_efct.ios_in_use);
1412 tmfio->display_name, cmd, lun);
1414 switch (cmd) {
1439 tmfio->tgt_io.tmf = tmr_func;
1440 tmfio->tgt_io.lun = lun;
1441 tmfio->tgt_io.io_to_abort = io_to_abort;
1443 tgt_node = tmfio->node;
1445 se_sess = tgt_node->session;
1449 rc = target_submit_tmr(&ocp->cmd, se_sess, NULL, lun, ocp, tmr_func,
1450 GFP_ATOMIC, tmfio->init_task_tag, TARGET_SCF_ACK_KREF);
1466 #define DEF_EFCT_TPG_ATTRIB(name) \
1468 static ssize_t efct_lio_tpg_attrib_##name##_show( \
1475 return sprintf(page, "%u\n", tpg->tpg_attrib.name); \
1478 static ssize_t efct_lio_tpg_attrib_##name##_store( \
1484 struct efct_lio_tpg_attrib *a = &tpg->tpg_attrib; \
1496 return -EINVAL; \
1499 a->name = val; \
1503 CONFIGFS_ATTR(efct_lio_tpg_attrib_, name)
1522 #define DEF_EFCT_NPIV_TPG_ATTRIB(name) \
1524 static ssize_t efct_lio_npiv_tpg_attrib_##name##_show( \
1531 return sprintf(page, "%u\n", tpg->tpg_attrib.name); \
1534 static ssize_t efct_lio_npiv_tpg_attrib_##name##_store( \
1540 struct efct_lio_tpg_attrib *a = &tpg->tpg_attrib; \
1552 return -EINVAL; \
1555 a->name = val; \
1559 CONFIGFS_ATTR(efct_lio_npiv_tpg_attrib_, name)