Lines Matching defs:pr_reg
57 struct t10_pr_registration *pr_reg,
61 if (!pr_reg->isid_present_at_reg)
64 snprintf(buf, size, ",i,0x%s", pr_reg->pr_reg_isid);
118 struct t10_pr_registration *pr_reg;
122 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
124 if (pr_reg) {
146 if (pr_reg->pr_res_holder) {
147 core_scsi3_put_pr_reg(pr_reg);
150 if ((pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_REGONLY) ||
151 (pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_REGONLY) ||
152 (pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) ||
153 (pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) {
154 core_scsi3_put_pr_reg(pr_reg);
157 core_scsi3_put_pr_reg(pr_reg);
601 struct t10_pr_registration *pr_reg;
603 pr_reg = kmem_cache_zalloc(t10_pr_reg_cache, GFP_ATOMIC);
604 if (!pr_reg) {
609 INIT_LIST_HEAD(&pr_reg->pr_reg_list);
610 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list);
611 INIT_LIST_HEAD(&pr_reg->pr_reg_aptpl_list);
612 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_list);
613 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_mem_list);
614 atomic_set(&pr_reg->pr_res_holders, 0);
615 pr_reg->pr_reg_nacl = nacl;
616 pr_reg->pr_reg_deve = deve;
617 pr_reg->pr_res_mapped_lun = deve->mapped_lun;
618 pr_reg->pr_aptpl_target_lun = deve->se_lun->unpacked_lun;
619 pr_reg->pr_res_key = sa_res_key;
620 pr_reg->pr_reg_all_tg_pt = all_tg_pt;
621 pr_reg->pr_reg_aptpl = aptpl;
622 pr_reg->pr_reg_tg_pt_lun = deve->se_lun;
628 pr_reg->pr_reg_bin_isid = get_unaligned_be64(isid);
629 snprintf(pr_reg->pr_reg_isid, PR_REG_ISID_LEN, "%s", isid);
630 pr_reg->isid_present_at_reg = 1;
633 return pr_reg;
656 struct t10_pr_registration *pr_reg, *pr_reg_atp, *pr_reg_tmp, *pr_reg_tmp_safe;
662 pr_reg = __core_scsi3_do_alloc_registration(dev, nacl, deve, isid,
664 if (!pr_reg)
667 * Return pointer to pr_reg for ALL_TG_PT=0
670 return pr_reg;
730 * pr_reg->pr_reg_atp_list that will be processed once
731 * the original *pr_reg is processed in
745 &pr_reg->pr_reg_atp_list);
755 return pr_reg;
758 &pr_reg->pr_reg_atp_list, pr_reg_atp_mem_list) {
763 kmem_cache_free(t10_pr_reg_cache, pr_reg);
780 struct t10_pr_registration *pr_reg;
787 pr_reg = kmem_cache_zalloc(t10_pr_reg_cache, GFP_KERNEL);
788 if (!pr_reg) {
793 INIT_LIST_HEAD(&pr_reg->pr_reg_list);
794 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list);
795 INIT_LIST_HEAD(&pr_reg->pr_reg_aptpl_list);
796 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_list);
797 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_mem_list);
798 atomic_set(&pr_reg->pr_res_holders, 0);
799 pr_reg->pr_reg_nacl = NULL;
800 pr_reg->pr_reg_deve = NULL;
801 pr_reg->pr_res_mapped_lun = mapped_lun;
802 pr_reg->pr_aptpl_target_lun = target_lun;
803 pr_reg->pr_res_key = sa_res_key;
804 pr_reg->pr_reg_all_tg_pt = all_tg_pt;
805 pr_reg->pr_reg_aptpl = 1;
806 pr_reg->pr_reg_tg_pt_lun = NULL;
807 pr_reg->pr_res_scope = 0; /* Always LUN_SCOPE */
808 pr_reg->pr_res_type = type;
814 pr_reg->pr_reg_bin_isid = get_unaligned_be64(isid);
815 snprintf(pr_reg->pr_reg_isid, PR_REG_ISID_LEN, "%s", isid);
816 pr_reg->isid_present_at_reg = 1;
821 snprintf(pr_reg->pr_iport, PR_APTPL_MAX_IPORT_LEN, "%s", i_port);
822 snprintf(pr_reg->pr_tport, PR_APTPL_MAX_TPORT_LEN, "%s", t_port);
823 pr_reg->pr_reg_tpgt = tpgt;
825 * Set pr_res_holder from caller, the pr_reg who is the reservation
830 pr_reg->pr_res_holder = res_holder;
832 list_add_tail(&pr_reg->pr_reg_aptpl_list, &pr_tmpl->aptpl_reg_list);
842 struct t10_pr_registration *pr_reg)
847 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
850 dev->dev_pr_res_holder = pr_reg;
856 core_scsi3_pr_dump_type(pr_reg->pr_res_type),
857 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
874 struct t10_pr_registration *pr_reg, *pr_reg_tmp;
896 list_for_each_entry_safe(pr_reg, pr_reg_tmp, &pr_tmpl->aptpl_reg_list,
899 if (!strcmp(pr_reg->pr_iport, i_port) &&
900 (pr_reg->pr_res_mapped_lun == deve->mapped_lun) &&
901 !(strcmp(pr_reg->pr_tport, t_port)) &&
902 (pr_reg->pr_reg_tpgt == tpgt) &&
903 (pr_reg->pr_aptpl_target_lun == target_lun)) {
905 pr_reg->pr_reg_nacl = nacl;
906 pr_reg->pr_reg_deve = deve;
907 pr_reg->pr_reg_tg_pt_lun = lun;
909 list_del(&pr_reg->pr_reg_aptpl_list);
912 * At this point all of the pointers in *pr_reg will
916 __core_scsi3_add_registration(dev, nacl, pr_reg, 0, 0);
921 if (pr_reg->pr_res_holder)
923 nacl, pr_reg);
957 struct t10_pr_registration *pr_reg,
964 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
976 (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE",
980 pr_reg->pr_res_key, pr_reg->pr_res_generation,
981 pr_reg->pr_reg_aptpl);
991 struct t10_pr_registration *pr_reg,
1008 pr_reg->pr_res_generation = (register_move) ?
1013 list_add_tail(&pr_reg->pr_reg_list, &pr_tmpl->registration_list);
1014 pr_reg->pr_reg_deve->def_pr_registered = 1;
1016 __core_scsi3_dump_registration(tfo, dev, nacl, pr_reg, register_type);
1021 if (!pr_reg->pr_reg_all_tg_pt || register_move)
1024 * Walk pr_reg->pr_reg_atp_list and add registrations for ALL_TG_PT=1
1028 &pr_reg->pr_reg_atp_list, pr_reg_atp_mem_list) {
1061 struct t10_pr_registration *pr_reg;
1063 pr_reg = __core_scsi3_alloc_registration(dev, nacl, deve, isid,
1065 if (!pr_reg)
1068 __core_scsi3_add_registration(dev, nacl, pr_reg,
1079 struct t10_pr_registration *pr_reg, *pr_reg_tmp;
1083 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
1088 if (pr_reg->pr_reg_nacl != nacl)
1091 tpg = pr_reg->pr_reg_nacl->se_tpg;
1096 if (!pr_reg->isid_present_at_reg) {
1106 atomic_inc_mb(&pr_reg->pr_res_holders);
1108 return pr_reg;
1111 * If the *pr_reg contains a fabric defined ISID for multi-value
1117 if (strcmp(isid, pr_reg->pr_reg_isid))
1120 atomic_inc_mb(&pr_reg->pr_res_holders);
1122 return pr_reg;
1147 static void core_scsi3_put_pr_reg(struct t10_pr_registration *pr_reg)
1149 atomic_dec_mb(&pr_reg->pr_res_holders);
1154 struct t10_pr_registration *pr_reg)
1156 struct se_node_acl *nacl = pr_reg->pr_reg_nacl;
1166 if (pr_res_holder == pr_reg) {
1180 __core_scsi3_complete_pro_release(dev, nacl, pr_reg, 0);
1188 } else if (pr_reg->pr_reg_all_tg_pt &&
1190 pr_reg->pr_reg_nacl->initiatorname)) &&
1191 (pr_res_holder->pr_res_key == pr_reg->pr_res_key)) {
1195 " Port\n", pr_reg->pr_res_key);
1208 struct t10_pr_registration *pr_reg,
1213 pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo;
1218 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
1220 pr_reg->pr_reg_deve->def_pr_registered = 0;
1221 pr_reg->pr_reg_deve->pr_res_key = 0;
1222 list_del(&pr_reg->pr_reg_list);
1224 * Caller accessing *pr_reg using core_scsi3_locate_pr_reg(),
1228 core_scsi3_put_pr_reg(pr_reg);
1231 * *pr_reg have been released. Because list_del() is called above,
1232 * the last core_scsi3_put_pr_reg(pr_reg) will release this reference
1233 * count back to zero, and we release *pr_reg.
1235 while (atomic_read(&pr_reg->pr_res_holders) != 0) {
1245 pr_reg->pr_reg_nacl->initiatorname,
1249 (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE",
1252 " 0x%08x\n", tfo->get_fabric_name(), pr_reg->pr_res_key,
1253 pr_reg->pr_res_generation);
1256 pr_reg->pr_reg_deve = NULL;
1257 pr_reg->pr_reg_nacl = NULL;
1258 kmem_cache_free(t10_pr_reg_cache, pr_reg);
1262 * For PREEMPT_AND_ABORT, the list of *pr_reg in preempt_and_abort_list
1265 list_add_tail(&pr_reg->pr_reg_abort_list, preempt_and_abort_list);
1273 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_res_holder;
1288 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
1291 if (pr_reg->pr_reg_nacl != nacl)
1294 __core_scsi3_free_registration(dev, pr_reg, NULL, 0);
1303 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_res_holder;
1315 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
1318 __core_scsi3_free_registration(dev, pr_reg, NULL, 0);
1323 list_for_each_entry_safe(pr_reg, pr_reg_tmp, &pr_tmpl->aptpl_reg_list,
1325 list_del(&pr_reg->pr_reg_aptpl_list);
1326 kmem_cache_free(t10_pr_reg_cache, pr_reg);
1806 struct t10_pr_registration *pr_reg;
1817 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list,
1822 tpg = pr_reg->pr_reg_nacl->se_tpg;
1823 lun = pr_reg->pr_reg_tg_pt_lun;
1828 if (pr_reg->isid_present_at_reg)
1830 pr_reg->pr_reg_isid);
1832 * Include special metadata if the pr_reg matches the
1835 if (dev->dev_pr_res_holder == pr_reg) {
1844 pr_reg->pr_reg_nacl->initiatorname, isid_buf,
1845 pr_reg->pr_res_key, pr_reg->pr_res_type,
1846 pr_reg->pr_res_scope, pr_reg->pr_reg_all_tg_pt,
1847 pr_reg->pr_res_mapped_lun);
1854 pr_reg->pr_reg_nacl->initiatorname, isid_buf,
1855 pr_reg->pr_res_key, pr_reg->pr_reg_all_tg_pt,
1856 pr_reg->pr_res_mapped_lun);
1988 struct t10_pr_registration *pr_reg, *pr_reg_p, *pr_reg_tmp;
2010 pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess);
2011 if (!pr_reg) {
2057 if ((register_type == REGISTER) && (res_key != pr_reg->pr_res_key)) {
2062 pr_reg->pr_res_key);
2078 if (pr_reg->pr_reg_all_tg_pt && !all_tg_pt) {
2095 pr_reg->pr_res_generation = core_scsi3_pr_generation(cmd->se_dev);
2096 pr_reg->pr_res_key = sa_res_key;
2101 pr_reg->pr_reg_nacl->initiatorname,
2102 pr_reg->pr_res_key, pr_reg->pr_res_generation);
2109 cmd->se_dev, pr_reg);
2114 type = pr_reg->pr_res_type;
2121 if (pr_reg->pr_reg_all_tg_pt) {
2130 if (pr_reg == pr_reg_p)
2132 if (strcmp(pr_reg->pr_reg_nacl->initiatorname,
2144 __core_scsi3_free_registration(cmd->se_dev, pr_reg, NULL, 1);
2145 pr_reg = NULL;
2179 if (pr_reg)
2180 core_scsi3_put_pr_reg(pr_reg);
2212 struct t10_pr_registration *pr_reg, *pr_res_holder;
2224 * Locate the existing *pr_reg via struct se_node_acl pointers
2226 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
2228 if (!pr_reg) {
2230 " PR_REGISTERED *pr_reg for RESERVE\n");
2242 if (res_key != pr_reg->pr_res_key) {
2245 " 0x%016Lx\n", res_key, pr_reg->pr_res_key);
2282 if (pr_res_holder != pr_reg) {
2334 * Otherwise, our *pr_reg becomes the PR reservation holder for said
2335 * TYPE/SCOPE. Also set the received scope and type in *pr_reg.
2337 pr_reg->pr_res_scope = scope;
2338 pr_reg->pr_res_type = type;
2339 pr_reg->pr_res_holder = 1;
2340 dev->dev_pr_res_holder = pr_reg;
2341 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
2346 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
2358 core_scsi3_put_pr_reg(pr_reg);
2387 struct t10_pr_registration *pr_reg,
2394 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
2403 core_scsi3_pr_dump_type(pr_reg->pr_res_type),
2404 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
2411 pr_reg->pr_res_holder = pr_reg->pr_res_type = pr_reg->pr_res_scope = 0;
2421 struct t10_pr_registration *pr_reg, *pr_reg_p, *pr_res_holder;
2431 * Locate the existing *pr_reg via struct se_node_acl pointers
2433 pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess);
2434 if (!pr_reg) {
2436 " PR_REGISTERED *pr_reg for RELEASE\n");
2464 if ((all_reg == 0) && (pr_res_holder != pr_reg)) {
2488 if (res_key != pr_reg->pr_res_key) {
2491 " 0x%016Lx\n", res_key, pr_reg->pr_res_key);
2535 pr_reg, 1);
2558 if (pr_reg_p == pr_reg)
2572 core_scsi3_put_pr_reg(pr_reg);
2583 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_reg_n, *pr_res_holder;
2587 * Locate the existing *pr_reg via struct se_node_acl pointers
2593 " PR_REGISTERED *pr_reg for CLEAR\n");
2630 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
2633 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2634 pr_reg_nacl = pr_reg->pr_reg_nacl;
2635 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2636 __core_scsi3_free_registration(dev, pr_reg, NULL,
2665 struct t10_pr_registration *pr_reg,
2671 struct se_node_acl *nacl = pr_reg->pr_reg_nacl;
2676 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
2684 dev->dev_pr_res_holder = pr_reg;
2685 pr_reg->pr_res_holder = 1;
2686 pr_reg->pr_res_type = type;
2687 pr_reg->pr_res_scope = scope;
2693 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
2703 list_add_tail(&pr_reg->pr_reg_abort_list,
2711 struct t10_pr_registration *pr_reg, *pr_reg_tmp;
2713 list_for_each_entry_safe(pr_reg, pr_reg_tmp, preempt_and_abort_list,
2716 list_del(&pr_reg->pr_reg_abort_list);
2717 if (pr_reg_holder == pr_reg)
2719 if (pr_reg->pr_res_holder) {
2720 pr_warn("pr_reg->pr_res_holder still set\n");
2724 pr_reg->pr_reg_deve = NULL;
2725 pr_reg->pr_reg_nacl = NULL;
2726 kmem_cache_free(t10_pr_reg_cache, pr_reg);
2738 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_reg_n, *pr_res_holder;
2752 " PR_REGISTERED *pr_reg for PREEMPT%s\n",
2795 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
2815 if (pr_reg->pr_res_key != sa_res_key)
2819 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2820 pr_reg_nacl = pr_reg->pr_reg_nacl;
2821 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2822 __core_scsi3_free_registration(dev, pr_reg,
2840 (pr_reg->pr_res_key != sa_res_key))
2844 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2848 pr_reg_nacl = pr_reg->pr_reg_nacl;
2849 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2850 __core_scsi3_free_registration(dev, pr_reg,
2940 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
2943 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2947 if (pr_reg->pr_res_key != sa_res_key)
2950 pr_reg_nacl = pr_reg->pr_reg_nacl;
2951 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2952 __core_scsi3_free_registration(dev, pr_reg,
2987 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
2990 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2994 core_scsi3_ua_allocate(pr_reg->pr_reg_nacl,
2995 pr_reg->pr_res_mapped_lun, 0x2A,
3008 * been removed from the primary pr_reg list), except the
3058 struct t10_pr_registration *pr_reg, *pr_res_holder, *dest_pr_reg;
3082 * Locate the existing *pr_reg via struct se_node_acl pointers
3084 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
3086 if (!pr_reg) {
3088 " *pr_reg for REGISTER_AND_MOVE\n");
3095 if (res_key != pr_reg->pr_res_key) {
3098 " res_key: 0x%016Lx\n", res_key, pr_reg->pr_res_key);
3225 pr_reg_nacl = pr_reg->pr_reg_nacl;
3231 if (!iport_ptr || !pr_reg->isid_present_at_reg) {
3238 if (!strcmp(iport_ptr, pr_reg->pr_reg_isid)) {
3242 pr_reg->pr_reg_isid);
3322 if (pr_res_holder != pr_reg) {
3401 pr_reg->pr_res_scope = scope;
3402 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
3434 __core_scsi3_free_registration(dev, pr_reg, NULL, 1);
3437 core_scsi3_put_pr_reg(pr_reg);
3455 core_scsi3_put_pr_reg(pr_reg);
3627 struct t10_pr_registration *pr_reg;
3647 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list,
3656 buf[off++] = ((pr_reg->pr_res_key >> 56) & 0xff);
3657 buf[off++] = ((pr_reg->pr_res_key >> 48) & 0xff);
3658 buf[off++] = ((pr_reg->pr_res_key >> 40) & 0xff);
3659 buf[off++] = ((pr_reg->pr_res_key >> 32) & 0xff);
3660 buf[off++] = ((pr_reg->pr_res_key >> 24) & 0xff);
3661 buf[off++] = ((pr_reg->pr_res_key >> 16) & 0xff);
3662 buf[off++] = ((pr_reg->pr_res_key >> 8) & 0xff);
3663 buf[off++] = (pr_reg->pr_res_key & 0xff);
3688 struct t10_pr_registration *pr_reg;
3709 pr_reg = dev->dev_pr_res_holder;
3710 if (pr_reg) {
3738 if ((pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) ||
3739 (pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG))
3742 pr_res_key = pr_reg->pr_res_key;
3755 buf[21] = (pr_reg->pr_res_scope & 0xf0) |
3756 (pr_reg->pr_res_type & 0x0f);
3835 struct t10_pr_registration *pr_reg, *pr_reg_tmp;
3858 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
3861 se_nacl = pr_reg->pr_reg_nacl;
3862 se_tpg = pr_reg->pr_reg_nacl->se_tpg;
3865 atomic_inc_mb(&pr_reg->pr_res_holders);
3872 se_tpg, se_nacl, pr_reg, &format_code);
3878 atomic_dec_mb(&pr_reg->pr_res_holders);
3884 buf[off++] = ((pr_reg->pr_res_key >> 56) & 0xff);
3885 buf[off++] = ((pr_reg->pr_res_key >> 48) & 0xff);
3886 buf[off++] = ((pr_reg->pr_res_key >> 40) & 0xff);
3887 buf[off++] = ((pr_reg->pr_res_key >> 32) & 0xff);
3888 buf[off++] = ((pr_reg->pr_res_key >> 24) & 0xff);
3889 buf[off++] = ((pr_reg->pr_res_key >> 16) & 0xff);
3890 buf[off++] = ((pr_reg->pr_res_key >> 8) & 0xff);
3891 buf[off++] = (pr_reg->pr_res_key & 0xff);
3897 if (pr_reg->pr_reg_all_tg_pt)
3906 if (pr_reg->pr_res_holder) {
3908 buf[off++] = (pr_reg->pr_res_scope & 0xf0) |
3909 (pr_reg->pr_res_type & 0x0f);
3924 if (!pr_reg->pr_reg_all_tg_pt) {
3925 struct se_port *port = pr_reg->pr_reg_tg_pt_lun->lun_sep;
3936 se_nacl, pr_reg, &format_code, &buf[off+4]);
3939 atomic_dec_mb(&pr_reg->pr_res_holders);