projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
target: remove the get_fabric_proto_ident method
[linux-2.6-block.git] / drivers / target / target_core_pr.c
CommitLineData
c66ac9db
NB		 1/*******************************************************************************
2 * Filename: target_core_pr.c
3 *
4 * This file contains SPC-3 compliant persistent reservations and
5 * legacy SPC-2 reservations with compatible reservation handling (CRH=1)
6 *
4c76251e 7 * (c) Copyright 2009-2013 Datera, Inc.
c66ac9db
NB		 8 *
9 * Nicholas A. Bellinger <nab@kernel.org>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 *
25 ******************************************************************************/
26
c66ac9db
NB		 27#include <linux/slab.h>
28#include <linux/spinlock.h>
29#include <linux/list.h>
0e9b10a9 30#include <linux/file.h>
c66ac9db
NB		 31#include <scsi/scsi.h>
32#include <scsi/scsi_cmnd.h>
33#include <asm/unaligned.h>
34
35#include <target/target_core_base.h>
c4795fb2
CH		 36#include <target/target_core_backend.h>
37#include <target/target_core_fabric.h>
c66ac9db
NB		 38#include <target/target_core_configfs.h>
39
e26d99ae 40#include "target_core_internal.h"
c66ac9db
NB		 41#include "target_core_pr.h"
42#include "target_core_ua.h"
43
44/*
45 * Used for Specify Initiator Ports Capable Bit (SPEC_I_PT)
46 */
47struct pr_transport_id_holder {
48 int dest_local_nexus;
49 struct t10_pr_registration *dest_pr_reg;
50 struct se_portal_group *dest_tpg;
51 struct se_node_acl *dest_node_acl;
52 struct se_dev_entry *dest_se_deve;
53 struct list_head dest_list;
54};
55
d2843c17 56void core_pr_dump_initiator_port(
c66ac9db
NB		 57 struct t10_pr_registration *pr_reg,
58 char *buf,
59 u32 size)
60{
6708bb27 61 if (!pr_reg->isid_present_at_reg)
d2843c17 62 buf[0] = '\0';
c66ac9db 63
d2843c17 64 snprintf(buf, size, ",i,0x%s", pr_reg->pr_reg_isid);
c66ac9db
NB		 65}
66
33ce6a87
AG		 67enum register_type {
68 REGISTER,
69 REGISTER_AND_IGNORE_EXISTING_KEY,
70 REGISTER_AND_MOVE,
71};
72
73enum preempt_type {
74 PREEMPT,
75 PREEMPT_AND_ABORT,
76};
77
c66ac9db 78static void __core_scsi3_complete_pro_release(struct se_device *, struct se_node_acl *,
6c3c9baa 79 struct t10_pr_registration *, int, int);
c66ac9db 80
e673dc92
IT		 81static int is_reservation_holder(
82 struct t10_pr_registration *pr_res_holder,
83 struct t10_pr_registration *pr_reg)
84{
85 int pr_res_type;
86
87 if (pr_res_holder) {
88 pr_res_type = pr_res_holder->pr_res_type;
89
90 return pr_res_holder == pr_reg ||
91 pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG ||
92 pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG;
93 }
94 return 0;
95}
96
de103c93
CH		 97static sense_reason_t
98target_scsi2_reservation_check(struct se_cmd *cmd)
c66ac9db 99{
d977f437
CH		 100 struct se_device *dev = cmd->se_dev;
101 struct se_session *sess = cmd->se_sess;
102
103 switch (cmd->t_task_cdb[0]) {
c66ac9db
NB		 104 case INQUIRY:
105 case RELEASE:
106 case RELEASE_10:
107 return 0;
108 default:
d977f437 109 break;
c66ac9db
NB		 110 }
111
d977f437 112 if (!dev->dev_reserved_node_acl || !sess)
c66ac9db
NB		 113 return 0;
114
d977f437 115 if (dev->dev_reserved_node_acl != sess->se_node_acl)
de103c93 116 return TCM_RESERVATION_CONFLICT;
d977f437
CH		 117
118 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS_WITH_ISID) {
119 if (dev->dev_res_bin_isid != sess->sess_bin_isid)
de103c93 120 return TCM_RESERVATION_CONFLICT;
c66ac9db 121 }
c66ac9db 122
d977f437 123 return 0;
c66ac9db
NB		 124}
125
eacac00c
CH		 126static struct t10_pr_registration *core_scsi3_locate_pr_reg(struct se_device *,
127 struct se_node_acl *, struct se_session *);
128static void core_scsi3_put_pr_reg(struct t10_pr_registration *);
129
087a03b3 130static int target_check_scsi2_reservation_conflict(struct se_cmd *cmd)
eacac00c
CH		 131{
132 struct se_session *se_sess = cmd->se_sess;
0fd97ccf 133 struct se_device *dev = cmd->se_dev;
eacac00c 134 struct t10_pr_registration *pr_reg;
0fd97ccf 135 struct t10_reservation *pr_tmpl = &dev->t10_pr;
eacac00c
CH		 136 int conflict = 0;
137
eacac00c
CH		 138 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
139 se_sess);
140 if (pr_reg) {
141 /*
142 * From spc4r17 5.7.3 Exceptions to SPC-2 RESERVE and RELEASE
143 * behavior
144 *
145 * A RESERVE(6) or RESERVE(10) command shall complete with GOOD
146 * status, but no reservation shall be established and the
147 * persistent reservation shall not be changed, if the command
148 * is received from a) and b) below.
149 *
150 * A RELEASE(6) or RELEASE(10) command shall complete with GOOD
151 * status, but the persistent reservation shall not be released,
152 * if the command is received from a) and b)
153 *
154 * a) An I_T nexus that is a persistent reservation holder; or
155 * b) An I_T nexus that is registered if a registrants only or
156 * all registrants type persistent reservation is present.
157 *
158 * In all other cases, a RESERVE(6) command, RESERVE(10) command,
159 * RELEASE(6) command, or RELEASE(10) command shall be processed
160 * as defined in SPC-2.
161 */
162 if (pr_reg->pr_res_holder) {
163 core_scsi3_put_pr_reg(pr_reg);
087a03b3 164 return 1;
eacac00c
CH		 165 }
166 if ((pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_REGONLY) ||
167 (pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_REGONLY) ||
168 (pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) ||
169 (pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) {
170 core_scsi3_put_pr_reg(pr_reg);
087a03b3 171 return 1;
eacac00c
CH		 172 }
173 core_scsi3_put_pr_reg(pr_reg);
174 conflict = 1;
175 } else {
176 /*
177 * Following spc2r20 5.5.1 Reservations overview:
178 *
179 * If a logical unit has executed a PERSISTENT RESERVE OUT
180 * command with the REGISTER or the REGISTER AND IGNORE
181 * EXISTING KEY service action and is still registered by any
182 * initiator, all RESERVE commands and all RELEASE commands
183 * regardless of initiator shall conflict and shall terminate
184 * with a RESERVATION CONFLICT status.
185 */
186 spin_lock(&pr_tmpl->registration_lock);
187 conflict = (list_empty(&pr_tmpl->registration_list)) ? 0 : 1;
188 spin_unlock(&pr_tmpl->registration_lock);
189 }
190
191 if (conflict) {
192 pr_err("Received legacy SPC-2 RESERVE/RELEASE"
193 " while active SPC-3 registrations exist,"
194 " returning RESERVATION_CONFLICT\n");
087a03b3 195 return -EBUSY;
eacac00c
CH		 196 }
197
087a03b3 198 return 0;
eacac00c
CH		 199}
200
de103c93
CH		 201sense_reason_t
202target_scsi2_reservation_release(struct se_cmd *cmd)
c66ac9db
NB		 203{
204 struct se_device *dev = cmd->se_dev;
205 struct se_session *sess = cmd->se_sess;
609234e3 206 struct se_portal_group *tpg;
de103c93 207 int rc;
c66ac9db 208
609234e3 209 if (!sess || !sess->se_tpg)
d29a5b6a 210 goto out;
087a03b3
NB		 211 rc = target_check_scsi2_reservation_conflict(cmd);
212 if (rc == 1)
d29a5b6a 213 goto out;
de103c93
CH		 214 if (rc < 0)
215 return TCM_RESERVATION_CONFLICT;
c66ac9db
NB		 216
217 spin_lock(&dev->dev_reservation_lock);
d29a5b6a
CH		 218 if (!dev->dev_reserved_node_acl || !sess)
219 goto out_unlock;
220
221 if (dev->dev_reserved_node_acl != sess->se_node_acl)
222 goto out_unlock;
c66ac9db 223
edc318d9
BK		 224 if (dev->dev_res_bin_isid != sess->sess_bin_isid)
225 goto out_unlock;
226
c66ac9db 227 dev->dev_reserved_node_acl = NULL;
0fd97ccf
CH		 228 dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS;
229 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS_WITH_ISID) {
c66ac9db 230 dev->dev_res_bin_isid = 0;
0fd97ccf 231 dev->dev_reservation_flags &= ~DRF_SPC2_RESERVATIONS_WITH_ISID;
c66ac9db 232 }
609234e3 233 tpg = sess->se_tpg;
6708bb27 234 pr_debug("SCSI-2 Released reservation for %s LUN: %u ->"
e3d6f909
AG		 235 " MAPPED LUN: %u for %s\n", tpg->se_tpg_tfo->get_fabric_name(),
236 cmd->se_lun->unpacked_lun, cmd->se_deve->mapped_lun,
c66ac9db 237 sess->se_node_acl->initiatorname);
c66ac9db 238
d29a5b6a
CH		 239out_unlock:
240 spin_unlock(&dev->dev_reservation_lock);
241out:
de103c93
CH		 242 target_complete_cmd(cmd, GOOD);
243 return 0;
c66ac9db
NB		 244}
245
de103c93
CH		 246sense_reason_t
247target_scsi2_reservation_reserve(struct se_cmd *cmd)
c66ac9db
NB		 248{
249 struct se_device *dev = cmd->se_dev;
250 struct se_session *sess = cmd->se_sess;
609234e3 251 struct se_portal_group *tpg;
de103c93
CH		 252 sense_reason_t ret = 0;
253 int rc;
c66ac9db 254
a1d8b49a
AG		 255 if ((cmd->t_task_cdb[1] & 0x01) &&
256 (cmd->t_task_cdb[1] & 0x02)) {
6708bb27 257 pr_err("LongIO and Obselete Bits set, returning"
c66ac9db 258 " ILLEGAL_REQUEST\n");
de103c93 259 return TCM_UNSUPPORTED_SCSI_OPCODE;
c66ac9db
NB		 260 }
261 /*
262 * This is currently the case for target_core_mod passthrough struct se_cmd
263 * ops
264 */
609234e3 265 if (!sess || !sess->se_tpg)
d29a5b6a 266 goto out;
087a03b3
NB		 267 rc = target_check_scsi2_reservation_conflict(cmd);
268 if (rc == 1)
d29a5b6a 269 goto out;
c66ac9db 270
de103c93
CH		 271 if (rc < 0)
272 return TCM_RESERVATION_CONFLICT;
273
609234e3 274 tpg = sess->se_tpg;
c66ac9db
NB		 275 spin_lock(&dev->dev_reservation_lock);
276 if (dev->dev_reserved_node_acl &&
277 (dev->dev_reserved_node_acl != sess->se_node_acl)) {
6708bb27 278 pr_err("SCSI-2 RESERVATION CONFLIFT for %s fabric\n",
e3d6f909 279 tpg->se_tpg_tfo->get_fabric_name());
6708bb27 280 pr_err("Original reserver LUN: %u %s\n",
e3d6f909 281 cmd->se_lun->unpacked_lun,
c66ac9db 282 dev->dev_reserved_node_acl->initiatorname);
6708bb27 283 pr_err("Current attempt - LUN: %u -> MAPPED LUN: %u"
e3d6f909 284 " from %s \n", cmd->se_lun->unpacked_lun,
c66ac9db
NB		 285 cmd->se_deve->mapped_lun,
286 sess->se_node_acl->initiatorname);
de103c93 287 ret = TCM_RESERVATION_CONFLICT;
d29a5b6a 288 goto out_unlock;
c66ac9db
NB		 289 }
290
291 dev->dev_reserved_node_acl = sess->se_node_acl;
0fd97ccf 292 dev->dev_reservation_flags |= DRF_SPC2_RESERVATIONS;
c66ac9db
NB		 293 if (sess->sess_bin_isid != 0) {
294 dev->dev_res_bin_isid = sess->sess_bin_isid;
0fd97ccf 295 dev->dev_reservation_flags |= DRF_SPC2_RESERVATIONS_WITH_ISID;
c66ac9db 296 }
6708bb27 297 pr_debug("SCSI-2 Reserved %s LUN: %u -> MAPPED LUN: %u"
e3d6f909
AG		 298 " for %s\n", tpg->se_tpg_tfo->get_fabric_name(),
299 cmd->se_lun->unpacked_lun, cmd->se_deve->mapped_lun,
c66ac9db 300 sess->se_node_acl->initiatorname);
c66ac9db 301
d29a5b6a
CH		 302out_unlock:
303 spin_unlock(&dev->dev_reservation_lock);
304out:
6bb35e00
CH		 305 if (!ret)
306 target_complete_cmd(cmd, GOOD);
d29a5b6a 307 return ret;
c66ac9db
NB		 308}
309
c66ac9db
NB		 310
311/*
312 * Begin SPC-3/SPC-4 Persistent Reservations emulation support
313 *
314 * This function is called by those initiator ports who are *NOT*
315 * the active PR reservation holder when a reservation is present.
316 */
317static int core_scsi3_pr_seq_non_holder(
318 struct se_cmd *cmd,
c66ac9db
NB		 319 u32 pr_reg_type)
320{
d977f437 321 unsigned char *cdb = cmd->t_task_cdb;
c66ac9db 322 struct se_dev_entry *se_deve;
e3d6f909 323 struct se_session *se_sess = cmd->se_sess;
c66ac9db
NB		 324 int other_cdb = 0, ignore_reg;
325 int registered_nexus = 0, ret = 1; /* Conflict by default */
326 int all_reg = 0, reg_only = 0; /* ALL_REG, REG_ONLY */
327 int we = 0; /* Write Exclusive */
328 int legacy = 0; /* Act like a legacy device and return
329 * RESERVATION CONFLICT on some CDBs */
c66ac9db 330
f2083241 331 se_deve = se_sess->se_node_acl->device_list[cmd->orig_fe_lun];
c66ac9db
NB		 332 /*
333 * Determine if the registration should be ignored due to
d977f437 334 * non-matching ISIDs in target_scsi3_pr_reservation_check().
c66ac9db
NB		 335 */
336 ignore_reg = (pr_reg_type & 0x80000000);
337 if (ignore_reg)
338 pr_reg_type &= ~0x80000000;
339
340 switch (pr_reg_type) {
341 case PR_TYPE_WRITE_EXCLUSIVE:
342 we = 1;
343 case PR_TYPE_EXCLUSIVE_ACCESS:
344 /*
345 * Some commands are only allowed for the persistent reservation
346 * holder.
347 */
348 if ((se_deve->def_pr_registered) && !(ignore_reg))
349 registered_nexus = 1;
350 break;
351 case PR_TYPE_WRITE_EXCLUSIVE_REGONLY:
352 we = 1;
353 case PR_TYPE_EXCLUSIVE_ACCESS_REGONLY:
354 /*
355 * Some commands are only allowed for registered I_T Nexuses.
356 */
357 reg_only = 1;
358 if ((se_deve->def_pr_registered) && !(ignore_reg))
359 registered_nexus = 1;
360 break;
361 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG:
362 we = 1;
363 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG:
364 /*
365 * Each registered I_T Nexus is a reservation holder.
366 */
367 all_reg = 1;
368 if ((se_deve->def_pr_registered) && !(ignore_reg))
369 registered_nexus = 1;
370 break;
371 default:
e3d6f909 372 return -EINVAL;
c66ac9db
NB		 373 }
374 /*
375 * Referenced from spc4r17 table 45 for *NON* PR holder access
376 */
377 switch (cdb[0]) {
378 case SECURITY_PROTOCOL_IN:
379 if (registered_nexus)
380 return 0;
381 ret = (we) ? 0 : 1;
382 break;
383 case MODE_SENSE:
384 case MODE_SENSE_10:
385 case READ_ATTRIBUTE:
386 case READ_BUFFER:
387 case RECEIVE_DIAGNOSTIC:
388 if (legacy) {
389 ret = 1;
390 break;
391 }
392 if (registered_nexus) {
393 ret = 0;
394 break;
395 }
396 ret = (we) ? 0 : 1; /* Allowed Write Exclusive */
397 break;
398 case PERSISTENT_RESERVE_OUT:
399 /*
400 * This follows PERSISTENT_RESERVE_OUT service actions that
401 * are allowed in the presence of various reservations.
402 * See spc4r17, table 46
403 */
404 switch (cdb[1] & 0x1f) {
405 case PRO_CLEAR:
406 case PRO_PREEMPT:
407 case PRO_PREEMPT_AND_ABORT:
408 ret = (registered_nexus) ? 0 : 1;
409 break;
410 case PRO_REGISTER:
411 case PRO_REGISTER_AND_IGNORE_EXISTING_KEY:
412 ret = 0;
413 break;
414 case PRO_REGISTER_AND_MOVE:
415 case PRO_RESERVE:
416 ret = 1;
417 break;
418 case PRO_RELEASE:
419 ret = (registered_nexus) ? 0 : 1;
420 break;
421 default:
6708bb27 422 pr_err("Unknown PERSISTENT_RESERVE_OUT service"
c66ac9db 423 " action: 0x%02x\n", cdb[1] & 0x1f);
e3d6f909 424 return -EINVAL;
c66ac9db
NB		 425 }
426 break;
427 case RELEASE:
428 case RELEASE_10:
eacac00c 429 /* Handled by CRH=1 in target_scsi2_reservation_release() */
c66ac9db
NB		 430 ret = 0;
431 break;
432 case RESERVE:
433 case RESERVE_10:
eacac00c 434 /* Handled by CRH=1 in target_scsi2_reservation_reserve() */
c66ac9db
NB		 435 ret = 0;
436 break;
437 case TEST_UNIT_READY:
438 ret = (legacy) ? 1 : 0; /* Conflict for legacy */
439 break;
440 case MAINTENANCE_IN:
441 switch (cdb[1] & 0x1f) {
442 case MI_MANAGEMENT_PROTOCOL_IN:
443 if (registered_nexus) {
444 ret = 0;
445 break;
446 }
447 ret = (we) ? 0 : 1; /* Allowed Write Exclusive */
448 break;
449 case MI_REPORT_SUPPORTED_OPERATION_CODES:
450 case MI_REPORT_SUPPORTED_TASK_MANAGEMENT_FUNCTIONS:
451 if (legacy) {
452 ret = 1;
453 break;
454 }
455 if (registered_nexus) {
456 ret = 0;
457 break;
458 }
459 ret = (we) ? 0 : 1; /* Allowed Write Exclusive */
460 break;
461 case MI_REPORT_ALIASES:
462 case MI_REPORT_IDENTIFYING_INFORMATION:
463 case MI_REPORT_PRIORITY:
464 case MI_REPORT_TARGET_PGS:
465 case MI_REPORT_TIMESTAMP:
466 ret = 0; /* Allowed */
467 break;
468 default:
6708bb27 469 pr_err("Unknown MI Service Action: 0x%02x\n",
c66ac9db 470 (cdb[1] & 0x1f));
e3d6f909 471 return -EINVAL;
c66ac9db
NB		 472 }
473 break;
474 case ACCESS_CONTROL_IN:
475 case ACCESS_CONTROL_OUT:
476 case INQUIRY:
477 case LOG_SENSE:
85686f69 478 case SERVICE_ACTION_IN_12:
c66ac9db
NB		 479 case REPORT_LUNS:
480 case REQUEST_SENSE:
6816966a 481 case PERSISTENT_RESERVE_IN:
c66ac9db
NB		 482 ret = 0; /*/ Allowed CDBs */
483 break;
484 default:
485 other_cdb = 1;
486 break;
487 }
488 /*
25985edc 489 * Case where the CDB is explicitly allowed in the above switch
c66ac9db
NB		 490 * statement.
491 */
6708bb27 492 if (!ret && !other_cdb) {
125d0119 493 pr_debug("Allowing explicit CDB: 0x%02x for %s"
c66ac9db
NB		 494 " reservation holder\n", cdb[0],
495 core_scsi3_pr_dump_type(pr_reg_type));
8b1e1244 496
c66ac9db
NB		 497 return ret;
498 }
499 /*
500 * Check if write exclusive initiator ports *NOT* holding the
501 * WRITE_EXCLUSIVE_* reservation.
502 */
ee1b1b9c 503 if (we && !registered_nexus) {
c66ac9db
NB		 504 if (cmd->data_direction == DMA_TO_DEVICE) {
505 /*
506 * Conflict for write exclusive
507 */
6708bb27 508 pr_debug("%s Conflict for unregistered nexus"
c66ac9db
NB		 509 " %s CDB: 0x%02x to %s reservation\n",
510 transport_dump_cmd_direction(cmd),
511 se_sess->se_node_acl->initiatorname, cdb[0],
512 core_scsi3_pr_dump_type(pr_reg_type));
513 return 1;
514 } else {
515 /*
516 * Allow non WRITE CDBs for all Write Exclusive
517 * PR TYPEs to pass for registered and
518 * non-registered_nexuxes NOT holding the reservation.
519 *
520 * We only make noise for the unregisterd nexuses,
521 * as we expect registered non-reservation holding
522 * nexuses to issue CDBs.
523 */
8b1e1244 524
6708bb27 525 if (!registered_nexus) {
125d0119 526 pr_debug("Allowing implicit CDB: 0x%02x"
c66ac9db
NB		 527 " for %s reservation on unregistered"
528 " nexus\n", cdb[0],
529 core_scsi3_pr_dump_type(pr_reg_type));
530 }
8b1e1244 531
c66ac9db
NB		 532 return 0;
533 }
534 } else if ((reg_only) || (all_reg)) {
535 if (registered_nexus) {
536 /*
537 * For PR_*_REG_ONLY and PR_*_ALL_REG reservations,
538 * allow commands from registered nexuses.
539 */
8b1e1244 540
125d0119 541 pr_debug("Allowing implicit CDB: 0x%02x for %s"
c66ac9db
NB		 542 " reservation\n", cdb[0],
543 core_scsi3_pr_dump_type(pr_reg_type));
8b1e1244 544
c66ac9db
NB		 545 return 0;
546 }
1ecc7586
LD		 547 } else if (we && registered_nexus) {
548 /*
549 * Reads are allowed for Write Exclusive locks
550 * from all registrants.
551 */
552 if (cmd->data_direction == DMA_FROM_DEVICE) {
553 pr_debug("Allowing READ CDB: 0x%02x for %s"
554 " reservation\n", cdb[0],
555 core_scsi3_pr_dump_type(pr_reg_type));
556
557 return 0;
558 }
c66ac9db 559 }
6708bb27 560 pr_debug("%s Conflict for %sregistered nexus %s CDB: 0x%2x"
c66ac9db
NB		 561 " for %s reservation\n", transport_dump_cmd_direction(cmd),
562 (registered_nexus) ? "" : "un",
563 se_sess->se_node_acl->initiatorname, cdb[0],
564 core_scsi3_pr_dump_type(pr_reg_type));
565
566 return 1; /* Conflict by default */
567}
568
de103c93
CH		 569static sense_reason_t
570target_scsi3_pr_reservation_check(struct se_cmd *cmd)
d977f437
CH		 571{
572 struct se_device *dev = cmd->se_dev;
573 struct se_session *sess = cmd->se_sess;
574 u32 pr_reg_type;
575
576 if (!dev->dev_pr_res_holder)
577 return 0;
578
579 pr_reg_type = dev->dev_pr_res_holder->pr_res_type;
580 cmd->pr_res_key = dev->dev_pr_res_holder->pr_res_key;
581 if (dev->dev_pr_res_holder->pr_reg_nacl != sess->se_node_acl)
582 goto check_nonholder;
583
584 if (dev->dev_pr_res_holder->isid_present_at_reg) {
585 if (dev->dev_pr_res_holder->pr_reg_bin_isid !=
586 sess->sess_bin_isid) {
587 pr_reg_type |= 0x80000000;
588 goto check_nonholder;
589 }
590 }
591
592 return 0;
593
594check_nonholder:
595 if (core_scsi3_pr_seq_non_holder(cmd, pr_reg_type))
de103c93 596 return TCM_RESERVATION_CONFLICT;
d977f437
CH		 597 return 0;
598}
599
c66ac9db
NB		 600static u32 core_scsi3_pr_generation(struct se_device *dev)
601{
c66ac9db 602 u32 prg;
0fd97ccf 603
c66ac9db
NB		 604 /*
605 * PRGeneration field shall contain the value of a 32-bit wrapping
606 * counter mainted by the device server.
607 *
608 * Note that this is done regardless of Active Persist across
609 * Target PowerLoss (APTPL)
610 *
611 * See spc4r17 section 6.3.12 READ_KEYS service action
612 */
613 spin_lock(&dev->dev_reservation_lock);
0fd97ccf 614 prg = dev->t10_pr.pr_generation++;
c66ac9db
NB		 615 spin_unlock(&dev->dev_reservation_lock);
616
617 return prg;
618}
619
c66ac9db
NB		 620static struct t10_pr_registration *__core_scsi3_do_alloc_registration(
621 struct se_device *dev,
622 struct se_node_acl *nacl,
623 struct se_dev_entry *deve,
624 unsigned char *isid,
625 u64 sa_res_key,
626 int all_tg_pt,
627 int aptpl)
628{
c66ac9db
NB		 629 struct t10_pr_registration *pr_reg;
630
631 pr_reg = kmem_cache_zalloc(t10_pr_reg_cache, GFP_ATOMIC);
6708bb27
AG		 632 if (!pr_reg) {
633 pr_err("Unable to allocate struct t10_pr_registration\n");
c66ac9db
NB		 634 return NULL;
635 }
636
c66ac9db
NB		 637 INIT_LIST_HEAD(&pr_reg->pr_reg_list);
638 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list);
639 INIT_LIST_HEAD(&pr_reg->pr_reg_aptpl_list);
640 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_list);
641 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_mem_list);
642 atomic_set(&pr_reg->pr_res_holders, 0);
643 pr_reg->pr_reg_nacl = nacl;
644 pr_reg->pr_reg_deve = deve;
645 pr_reg->pr_res_mapped_lun = deve->mapped_lun;
646 pr_reg->pr_aptpl_target_lun = deve->se_lun->unpacked_lun;
647 pr_reg->pr_res_key = sa_res_key;
648 pr_reg->pr_reg_all_tg_pt = all_tg_pt;
649 pr_reg->pr_reg_aptpl = aptpl;
650 pr_reg->pr_reg_tg_pt_lun = deve->se_lun;
651 /*
652 * If an ISID value for this SCSI Initiator Port exists,
653 * save it to the registration now.
654 */
655 if (isid != NULL) {
656 pr_reg->pr_reg_bin_isid = get_unaligned_be64(isid);
657 snprintf(pr_reg->pr_reg_isid, PR_REG_ISID_LEN, "%s", isid);
658 pr_reg->isid_present_at_reg = 1;
659 }
660
661 return pr_reg;
662}
663
664static int core_scsi3_lunacl_depend_item(struct se_dev_entry *);
665static void core_scsi3_lunacl_undepend_item(struct se_dev_entry *);
666
667/*
668 * Function used for handling PR registrations for ALL_TG_PT=1 and ALL_TG_PT=0
669 * modes.
670 */
671static struct t10_pr_registration *__core_scsi3_alloc_registration(
672 struct se_device *dev,
673 struct se_node_acl *nacl,
674 struct se_dev_entry *deve,
675 unsigned char *isid,
676 u64 sa_res_key,
677 int all_tg_pt,
678 int aptpl)
679{
680 struct se_dev_entry *deve_tmp;
681 struct se_node_acl *nacl_tmp;
682 struct se_port *port, *port_tmp;
9ac8928e 683 const struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo;
c66ac9db
NB		 684 struct t10_pr_registration *pr_reg, *pr_reg_atp, *pr_reg_tmp, *pr_reg_tmp_safe;
685 int ret;
686 /*
687 * Create a registration for the I_T Nexus upon which the
688 * PROUT REGISTER was received.
689 */
690 pr_reg = __core_scsi3_do_alloc_registration(dev, nacl, deve, isid,
691 sa_res_key, all_tg_pt, aptpl);
6708bb27 692 if (!pr_reg)
c66ac9db
NB		 693 return NULL;
694 /*
695 * Return pointer to pr_reg for ALL_TG_PT=0
696 */
6708bb27 697 if (!all_tg_pt)
c66ac9db
NB		 698 return pr_reg;
699 /*
700 * Create list of matching SCSI Initiator Port registrations
701 * for ALL_TG_PT=1
702 */
703 spin_lock(&dev->se_port_lock);
704 list_for_each_entry_safe(port, port_tmp, &dev->dev_sep_list, sep_list) {
33940d09 705 atomic_inc_mb(&port->sep_tg_pt_ref_cnt);
c66ac9db
NB		 706 spin_unlock(&dev->se_port_lock);
707
708 spin_lock_bh(&port->sep_alua_lock);
709 list_for_each_entry(deve_tmp, &port->sep_alua_list,
710 alua_port_list) {
711 /*
712 * This pointer will be NULL for demo mode MappedLUNs
125d0119 713 * that have not been make explicit via a ConfigFS
c66ac9db
NB		 714 * MappedLUN group for the SCSI Initiator Node ACL.
715 */
6708bb27 716 if (!deve_tmp->se_lun_acl)
c66ac9db
NB		 717 continue;
718
719 nacl_tmp = deve_tmp->se_lun_acl->se_lun_nacl;
720 /*
721 * Skip the matching struct se_node_acl that is allocated
722 * above..
723 */
724 if (nacl == nacl_tmp)
725 continue;
726 /*
727 * Only perform PR registrations for target ports on
728 * the same fabric module as the REGISTER w/ ALL_TG_PT=1
729 * arrived.
730 */
731 if (tfo != nacl_tmp->se_tpg->se_tpg_tfo)
732 continue;
733 /*
734 * Look for a matching Initiator Node ACL in ASCII format
735 */
736 if (strcmp(nacl->initiatorname, nacl_tmp->initiatorname))
737 continue;
738
33940d09 739 atomic_inc_mb(&deve_tmp->pr_ref_count);
c66ac9db
NB		 740 spin_unlock_bh(&port->sep_alua_lock);
741 /*
742 * Grab a configfs group dependency that is released
743 * for the exception path at label out: below, or upon
744 * completion of adding ALL_TG_PT=1 registrations in
745 * __core_scsi3_add_registration()
746 */
747 ret = core_scsi3_lunacl_depend_item(deve_tmp);
748 if (ret < 0) {
6708bb27 749 pr_err("core_scsi3_lunacl_depend"
c66ac9db 750 "_item() failed\n");
33940d09
JE		 751 atomic_dec_mb(&port->sep_tg_pt_ref_cnt);
752 atomic_dec_mb(&deve_tmp->pr_ref_count);
c66ac9db
NB		 753 goto out;
754 }
755 /*
756 * Located a matching SCSI Initiator Port on a different
757 * port, allocate the pr_reg_atp and attach it to the
758 * pr_reg->pr_reg_atp_list that will be processed once
759 * the original *pr_reg is processed in
760 * __core_scsi3_add_registration()
761 */
762 pr_reg_atp = __core_scsi3_do_alloc_registration(dev,
763 nacl_tmp, deve_tmp, NULL,
764 sa_res_key, all_tg_pt, aptpl);
6708bb27 765 if (!pr_reg_atp) {
33940d09
JE		 766 atomic_dec_mb(&port->sep_tg_pt_ref_cnt);
767 atomic_dec_mb(&deve_tmp->pr_ref_count);
c66ac9db
NB		 768 core_scsi3_lunacl_undepend_item(deve_tmp);
769 goto out;
770 }
771
772 list_add_tail(&pr_reg_atp->pr_reg_atp_mem_list,
773 &pr_reg->pr_reg_atp_list);
774 spin_lock_bh(&port->sep_alua_lock);
775 }
776 spin_unlock_bh(&port->sep_alua_lock);
777
778 spin_lock(&dev->se_port_lock);
33940d09 779 atomic_dec_mb(&port->sep_tg_pt_ref_cnt);
c66ac9db
NB		 780 }
781 spin_unlock(&dev->se_port_lock);
782
783 return pr_reg;
784out:
785 list_for_each_entry_safe(pr_reg_tmp, pr_reg_tmp_safe,
786 &pr_reg->pr_reg_atp_list, pr_reg_atp_mem_list) {
787 list_del(&pr_reg_tmp->pr_reg_atp_mem_list);
788 core_scsi3_lunacl_undepend_item(pr_reg_tmp->pr_reg_deve);
789 kmem_cache_free(t10_pr_reg_cache, pr_reg_tmp);
790 }
791 kmem_cache_free(t10_pr_reg_cache, pr_reg);
792 return NULL;
793}
794
795int core_scsi3_alloc_aptpl_registration(
e3d6f909 796 struct t10_reservation *pr_tmpl,
c66ac9db
NB		 797 u64 sa_res_key,
798 unsigned char *i_port,
799 unsigned char *isid,
800 u32 mapped_lun,
801 unsigned char *t_port,
802 u16 tpgt,
803 u32 target_lun,
804 int res_holder,
805 int all_tg_pt,
806 u8 type)
807{
808 struct t10_pr_registration *pr_reg;
809
6708bb27
AG		 810 if (!i_port || !t_port || !sa_res_key) {
811 pr_err("Illegal parameters for APTPL registration\n");
e3d6f909 812 return -EINVAL;
c66ac9db
NB		 813 }
814
815 pr_reg = kmem_cache_zalloc(t10_pr_reg_cache, GFP_KERNEL);
6708bb27
AG		 816 if (!pr_reg) {
817 pr_err("Unable to allocate struct t10_pr_registration\n");
e3d6f909 818 return -ENOMEM;
c66ac9db 819 }
c66ac9db
NB		 820
821 INIT_LIST_HEAD(&pr_reg->pr_reg_list);
822 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list);
823 INIT_LIST_HEAD(&pr_reg->pr_reg_aptpl_list);
824 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_list);
825 INIT_LIST_HEAD(&pr_reg->pr_reg_atp_mem_list);
826 atomic_set(&pr_reg->pr_res_holders, 0);
827 pr_reg->pr_reg_nacl = NULL;
828 pr_reg->pr_reg_deve = NULL;
829 pr_reg->pr_res_mapped_lun = mapped_lun;
830 pr_reg->pr_aptpl_target_lun = target_lun;
831 pr_reg->pr_res_key = sa_res_key;
832 pr_reg->pr_reg_all_tg_pt = all_tg_pt;
833 pr_reg->pr_reg_aptpl = 1;
834 pr_reg->pr_reg_tg_pt_lun = NULL;
835 pr_reg->pr_res_scope = 0; /* Always LUN_SCOPE */
836 pr_reg->pr_res_type = type;
837 /*
838 * If an ISID value had been saved in APTPL metadata for this
839 * SCSI Initiator Port, restore it now.
840 */
841 if (isid != NULL) {
842 pr_reg->pr_reg_bin_isid = get_unaligned_be64(isid);
843 snprintf(pr_reg->pr_reg_isid, PR_REG_ISID_LEN, "%s", isid);
844 pr_reg->isid_present_at_reg = 1;
845 }
846 /*
847 * Copy the i_port and t_port information from caller.
848 */
849 snprintf(pr_reg->pr_iport, PR_APTPL_MAX_IPORT_LEN, "%s", i_port);
850 snprintf(pr_reg->pr_tport, PR_APTPL_MAX_TPORT_LEN, "%s", t_port);
851 pr_reg->pr_reg_tpgt = tpgt;
852 /*
853 * Set pr_res_holder from caller, the pr_reg who is the reservation
854 * holder will get it's pointer set in core_scsi3_aptpl_reserve() once
855 * the Initiator Node LUN ACL from the fabric module is created for
856 * this registration.
857 */
858 pr_reg->pr_res_holder = res_holder;
859
860 list_add_tail(&pr_reg->pr_reg_aptpl_list, &pr_tmpl->aptpl_reg_list);
6708bb27 861 pr_debug("SPC-3 PR APTPL Successfully added registration%s from"
c66ac9db
NB		 862 " metadata\n", (res_holder) ? "+reservation" : "");
863 return 0;
864}
865
866static void core_scsi3_aptpl_reserve(
867 struct se_device *dev,
868 struct se_portal_group *tpg,
869 struct se_node_acl *node_acl,
870 struct t10_pr_registration *pr_reg)
871{
872 char i_buf[PR_REG_ISID_ID_LEN];
c66ac9db
NB		 873
874 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
d2843c17 875 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
c66ac9db
NB		 876
877 spin_lock(&dev->dev_reservation_lock);
878 dev->dev_pr_res_holder = pr_reg;
879 spin_unlock(&dev->dev_reservation_lock);
880
6708bb27 881 pr_debug("SPC-3 PR [%s] Service Action: APTPL RESERVE created"
c66ac9db 882 " new reservation holder TYPE: %s ALL_TG_PT: %d\n",
e3d6f909 883 tpg->se_tpg_tfo->get_fabric_name(),
c66ac9db
NB		 884 core_scsi3_pr_dump_type(pr_reg->pr_res_type),
885 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
6708bb27 886 pr_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n",
e3d6f909 887 tpg->se_tpg_tfo->get_fabric_name(), node_acl->initiatorname,
d2843c17 888 i_buf);
c66ac9db
NB		 889}
890
891static void __core_scsi3_add_registration(struct se_device *, struct se_node_acl *,
33ce6a87 892 struct t10_pr_registration *, enum register_type, int);
c66ac9db
NB		 893
894static int __core_scsi3_check_aptpl_registration(
895 struct se_device *dev,
896 struct se_portal_group *tpg,
897 struct se_lun *lun,
898 u32 target_lun,
899 struct se_node_acl *nacl,
900 struct se_dev_entry *deve)
901{
902 struct t10_pr_registration *pr_reg, *pr_reg_tmp;
0fd97ccf 903 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db
NB		 904 unsigned char i_port[PR_APTPL_MAX_IPORT_LEN];
905 unsigned char t_port[PR_APTPL_MAX_TPORT_LEN];
906 u16 tpgt;
907
908 memset(i_port, 0, PR_APTPL_MAX_IPORT_LEN);
909 memset(t_port, 0, PR_APTPL_MAX_TPORT_LEN);
910 /*
911 * Copy Initiator Port information from struct se_node_acl
912 */
913 snprintf(i_port, PR_APTPL_MAX_IPORT_LEN, "%s", nacl->initiatorname);
914 snprintf(t_port, PR_APTPL_MAX_TPORT_LEN, "%s",
e3d6f909
AG		 915 tpg->se_tpg_tfo->tpg_get_wwn(tpg));
916 tpgt = tpg->se_tpg_tfo->tpg_get_tag(tpg);
c66ac9db
NB		 917 /*
918 * Look for the matching registrations+reservation from those
919 * created from APTPL metadata. Note that multiple registrations
920 * may exist for fabrics that use ISIDs in their SCSI Initiator Port
921 * TransportIDs.
922 */
923 spin_lock(&pr_tmpl->aptpl_reg_lock);
924 list_for_each_entry_safe(pr_reg, pr_reg_tmp, &pr_tmpl->aptpl_reg_list,
925 pr_reg_aptpl_list) {
92404e60 926
6708bb27 927 if (!strcmp(pr_reg->pr_iport, i_port) &&
c66ac9db
NB		 928 (pr_reg->pr_res_mapped_lun == deve->mapped_lun) &&
929 !(strcmp(pr_reg->pr_tport, t_port)) &&
930 (pr_reg->pr_reg_tpgt == tpgt) &&
931 (pr_reg->pr_aptpl_target_lun == target_lun)) {
932
933 pr_reg->pr_reg_nacl = nacl;
934 pr_reg->pr_reg_deve = deve;
935 pr_reg->pr_reg_tg_pt_lun = lun;
936
937 list_del(&pr_reg->pr_reg_aptpl_list);
938 spin_unlock(&pr_tmpl->aptpl_reg_lock);
939 /*
940 * At this point all of the pointers in *pr_reg will
941 * be setup, so go ahead and add the registration.
942 */
943
944 __core_scsi3_add_registration(dev, nacl, pr_reg, 0, 0);
945 /*
946 * If this registration is the reservation holder,
947 * make that happen now..
948 */
949 if (pr_reg->pr_res_holder)
950 core_scsi3_aptpl_reserve(dev, tpg,
951 nacl, pr_reg);
952 /*
953 * Reenable pr_aptpl_active to accept new metadata
954 * updates once the SCSI device is active again..
955 */
956 spin_lock(&pr_tmpl->aptpl_reg_lock);
957 pr_tmpl->pr_aptpl_active = 1;
958 }
959 }
960 spin_unlock(&pr_tmpl->aptpl_reg_lock);
961
962 return 0;
963}
964
965int core_scsi3_check_aptpl_registration(
966 struct se_device *dev,
967 struct se_portal_group *tpg,
968 struct se_lun *lun,
e2480563
NB		 969 struct se_node_acl *nacl,
970 u32 mapped_lun)
c66ac9db 971{
e2480563 972 struct se_dev_entry *deve = nacl->device_list[mapped_lun];
c66ac9db 973
d977f437 974 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
c66ac9db
NB		 975 return 0;
976
977 return __core_scsi3_check_aptpl_registration(dev, tpg, lun,
978 lun->unpacked_lun, nacl, deve);
979}
980
981static void __core_scsi3_dump_registration(
9ac8928e 982 const struct target_core_fabric_ops *tfo,
c66ac9db
NB		 983 struct se_device *dev,
984 struct se_node_acl *nacl,
985 struct t10_pr_registration *pr_reg,
33ce6a87 986 enum register_type register_type)
c66ac9db
NB		 987{
988 struct se_portal_group *se_tpg = nacl->se_tpg;
989 char i_buf[PR_REG_ISID_ID_LEN];
c66ac9db
NB		 990
991 memset(&i_buf[0], 0, PR_REG_ISID_ID_LEN);
d2843c17 992 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
c66ac9db 993
6708bb27 994 pr_debug("SPC-3 PR [%s] Service Action: REGISTER%s Initiator"
33ce6a87
AG		 995 " Node: %s%s\n", tfo->get_fabric_name(), (register_type == REGISTER_AND_MOVE) ?
996 "_AND_MOVE" : (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ?
c66ac9db 997 "_AND_IGNORE_EXISTING_KEY" : "", nacl->initiatorname,
d2843c17 998 i_buf);
6708bb27 999 pr_debug("SPC-3 PR [%s] registration on Target Port: %s,0x%04x\n",
c66ac9db
NB		 1000 tfo->get_fabric_name(), tfo->tpg_get_wwn(se_tpg),
1001 tfo->tpg_get_tag(se_tpg));
6708bb27 1002 pr_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target"
c66ac9db
NB		 1003 " Port(s)\n", tfo->get_fabric_name(),
1004 (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE",
e3d6f909 1005 dev->transport->name);
6708bb27 1006 pr_debug("SPC-3 PR [%s] SA Res Key: 0x%016Lx PRgeneration:"
c66ac9db
NB		 1007 " 0x%08x APTPL: %d\n", tfo->get_fabric_name(),
1008 pr_reg->pr_res_key, pr_reg->pr_res_generation,
1009 pr_reg->pr_reg_aptpl);
1010}
1011
1012/*
1013 * this function can be called with struct se_device->dev_reservation_lock
1014 * when register_move = 1
1015 */
1016static void __core_scsi3_add_registration(
1017 struct se_device *dev,
1018 struct se_node_acl *nacl,
1019 struct t10_pr_registration *pr_reg,
33ce6a87 1020 enum register_type register_type,
c66ac9db
NB		 1021 int register_move)
1022{
9ac8928e 1023 const struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo;
c66ac9db 1024 struct t10_pr_registration *pr_reg_tmp, *pr_reg_tmp_safe;
0fd97ccf 1025 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db
NB		 1026
1027 /*
1028 * Increment PRgeneration counter for struct se_device upon a successful
1029 * REGISTER, see spc4r17 section 6.3.2 READ_KEYS service action
1030 *
1031 * Also, when register_move = 1 for PROUT REGISTER_AND_MOVE service
1032 * action, the struct se_device->dev_reservation_lock will already be held,
1033 * so we do not call core_scsi3_pr_generation() which grabs the lock
1034 * for the REGISTER.
1035 */
1036 pr_reg->pr_res_generation = (register_move) ?
0fd97ccf 1037 dev->t10_pr.pr_generation++ :
c66ac9db
NB		 1038 core_scsi3_pr_generation(dev);
1039
1040 spin_lock(&pr_tmpl->registration_lock);
1041 list_add_tail(&pr_reg->pr_reg_list, &pr_tmpl->registration_list);
1042 pr_reg->pr_reg_deve->def_pr_registered = 1;
1043
1044 __core_scsi3_dump_registration(tfo, dev, nacl, pr_reg, register_type);
1045 spin_unlock(&pr_tmpl->registration_lock);
1046 /*
1047 * Skip extra processing for ALL_TG_PT=0 or REGISTER_AND_MOVE.
1048 */
6708bb27 1049 if (!pr_reg->pr_reg_all_tg_pt || register_move)
c66ac9db
NB		 1050 return;
1051 /*
1052 * Walk pr_reg->pr_reg_atp_list and add registrations for ALL_TG_PT=1
1053 * allocated in __core_scsi3_alloc_registration()
1054 */
1055 list_for_each_entry_safe(pr_reg_tmp, pr_reg_tmp_safe,
1056 &pr_reg->pr_reg_atp_list, pr_reg_atp_mem_list) {
1057 list_del(&pr_reg_tmp->pr_reg_atp_mem_list);
1058
1059 pr_reg_tmp->pr_res_generation = core_scsi3_pr_generation(dev);
1060
1061 spin_lock(&pr_tmpl->registration_lock);
1062 list_add_tail(&pr_reg_tmp->pr_reg_list,
1063 &pr_tmpl->registration_list);
1064 pr_reg_tmp->pr_reg_deve->def_pr_registered = 1;
1065
1066 __core_scsi3_dump_registration(tfo, dev,
1067 pr_reg_tmp->pr_reg_nacl, pr_reg_tmp,
1068 register_type);
1069 spin_unlock(&pr_tmpl->registration_lock);
1070 /*
1071 * Drop configfs group dependency reference from
1072 * __core_scsi3_alloc_registration()
1073 */
1074 core_scsi3_lunacl_undepend_item(pr_reg_tmp->pr_reg_deve);
1075 }
1076}
1077
1078static int core_scsi3_alloc_registration(
1079 struct se_device *dev,
1080 struct se_node_acl *nacl,
1081 struct se_dev_entry *deve,
1082 unsigned char *isid,
1083 u64 sa_res_key,
1084 int all_tg_pt,
1085 int aptpl,
33ce6a87 1086 enum register_type register_type,
c66ac9db
NB		 1087 int register_move)
1088{
1089 struct t10_pr_registration *pr_reg;
1090
1091 pr_reg = __core_scsi3_alloc_registration(dev, nacl, deve, isid,
1092 sa_res_key, all_tg_pt, aptpl);
6708bb27 1093 if (!pr_reg)
e3d6f909 1094 return -EPERM;
c66ac9db
NB		 1095
1096 __core_scsi3_add_registration(dev, nacl, pr_reg,
1097 register_type, register_move);
1098 return 0;
1099}
1100
1101static struct t10_pr_registration *__core_scsi3_locate_pr_reg(
1102 struct se_device *dev,
1103 struct se_node_acl *nacl,
1104 unsigned char *isid)
1105{
0fd97ccf 1106 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db
NB		 1107 struct t10_pr_registration *pr_reg, *pr_reg_tmp;
1108 struct se_portal_group *tpg;
1109
1110 spin_lock(&pr_tmpl->registration_lock);
1111 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
1112 &pr_tmpl->registration_list, pr_reg_list) {
1113 /*
1114 * First look for a matching struct se_node_acl
1115 */
1116 if (pr_reg->pr_reg_nacl != nacl)
1117 continue;
1118
1119 tpg = pr_reg->pr_reg_nacl->se_tpg;
1120 /*
1121 * If this registration does NOT contain a fabric provided
1122 * ISID, then we have found a match.
1123 */
6708bb27 1124 if (!pr_reg->isid_present_at_reg) {
c66ac9db
NB		 1125 /*
1126 * Determine if this SCSI device server requires that
1127 * SCSI Intiatior TransportID w/ ISIDs is enforced
1128 * for fabric modules (iSCSI) requiring them.
1129 */
e3d6f909 1130 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL) {
0fd97ccf 1131 if (dev->dev_attrib.enforce_pr_isids)
c66ac9db
NB		 1132 continue;
1133 }
33940d09 1134 atomic_inc_mb(&pr_reg->pr_res_holders);
c66ac9db
NB		 1135 spin_unlock(&pr_tmpl->registration_lock);
1136 return pr_reg;
1137 }
1138 /*
1139 * If the *pr_reg contains a fabric defined ISID for multi-value
1140 * SCSI Initiator Port TransportIDs, then we expect a valid
1141 * matching ISID to be provided by the local SCSI Initiator Port.
1142 */
6708bb27 1143 if (!isid)
c66ac9db
NB		 1144 continue;
1145 if (strcmp(isid, pr_reg->pr_reg_isid))
1146 continue;
1147
33940d09 1148 atomic_inc_mb(&pr_reg->pr_res_holders);
c66ac9db
NB		 1149 spin_unlock(&pr_tmpl->registration_lock);
1150 return pr_reg;
1151 }
1152 spin_unlock(&pr_tmpl->registration_lock);
1153
1154 return NULL;
1155}
1156
1157static struct t10_pr_registration *core_scsi3_locate_pr_reg(
1158 struct se_device *dev,
1159 struct se_node_acl *nacl,
1160 struct se_session *sess)
1161{
1162 struct se_portal_group *tpg = nacl->se_tpg;
1163 unsigned char buf[PR_REG_ISID_LEN], *isid_ptr = NULL;
1164
e3d6f909 1165 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL) {
c66ac9db 1166 memset(&buf[0], 0, PR_REG_ISID_LEN);
e3d6f909 1167 tpg->se_tpg_tfo->sess_get_initiator_sid(sess, &buf[0],
c66ac9db
NB		 1168 PR_REG_ISID_LEN);
1169 isid_ptr = &buf[0];
1170 }
1171
1172 return __core_scsi3_locate_pr_reg(dev, nacl, isid_ptr);
1173}
1174
1175static void core_scsi3_put_pr_reg(struct t10_pr_registration *pr_reg)
1176{
33940d09 1177 atomic_dec_mb(&pr_reg->pr_res_holders);
c66ac9db
NB		 1178}
1179
125d0119 1180static int core_scsi3_check_implicit_release(
c66ac9db
NB		 1181 struct se_device *dev,
1182 struct t10_pr_registration *pr_reg)
1183{
1184 struct se_node_acl *nacl = pr_reg->pr_reg_nacl;
1185 struct t10_pr_registration *pr_res_holder;
1186 int ret = 0;
1187
1188 spin_lock(&dev->dev_reservation_lock);
1189 pr_res_holder = dev->dev_pr_res_holder;
6708bb27 1190 if (!pr_res_holder) {
c66ac9db
NB		 1191 spin_unlock(&dev->dev_reservation_lock);
1192 return ret;
1193 }
1194 if (pr_res_holder == pr_reg) {
1195 /*
125d0119 1196 * Perform an implicit RELEASE if the registration that
c66ac9db
NB		 1197 * is being released is holding the reservation.
1198 *
1199 * From spc4r17, section 5.7.11.1:
1200 *
1201 * e) If the I_T nexus is the persistent reservation holder
1202 * and the persistent reservation is not an all registrants
1203 * type, then a PERSISTENT RESERVE OUT command with REGISTER
1204 * service action or REGISTER AND IGNORE EXISTING KEY
1205 * service action with the SERVICE ACTION RESERVATION KEY
1206 * field set to zero (see 5.7.11.3).
1207 */
6c3c9baa 1208 __core_scsi3_complete_pro_release(dev, nacl, pr_reg, 0, 1);
c66ac9db
NB		 1209 ret = 1;
1210 /*
1211 * For 'All Registrants' reservation types, all existing
1212 * registrations are still processed as reservation holders
1213 * in core_scsi3_pr_seq_non_holder() after the initial
125d0119 1214 * reservation holder is implicitly released here.
c66ac9db
NB		 1215 */
1216 } else if (pr_reg->pr_reg_all_tg_pt &&
1217 (!strcmp(pr_res_holder->pr_reg_nacl->initiatorname,
1218 pr_reg->pr_reg_nacl->initiatorname)) &&
1219 (pr_res_holder->pr_res_key == pr_reg->pr_res_key)) {
6708bb27 1220 pr_err("SPC-3 PR: Unable to perform ALL_TG_PT=1"
c66ac9db
NB		 1221 " UNREGISTER while existing reservation with matching"
1222 " key 0x%016Lx is present from another SCSI Initiator"
1223 " Port\n", pr_reg->pr_res_key);
e3d6f909 1224 ret = -EPERM;
c66ac9db
NB		 1225 }
1226 spin_unlock(&dev->dev_reservation_lock);
1227
1228 return ret;
1229}
1230
1231/*
e3d6f909 1232 * Called with struct t10_reservation->registration_lock held.
c66ac9db
NB		 1233 */
1234static void __core_scsi3_free_registration(
1235 struct se_device *dev,
1236 struct t10_pr_registration *pr_reg,
1237 struct list_head *preempt_and_abort_list,
1238 int dec_holders)
cb0df4d3
BVA		 1239 __releases(&pr_tmpl->registration_lock)
1240 __acquires(&pr_tmpl->registration_lock)
c66ac9db 1241{
9ac8928e 1242 const struct target_core_fabric_ops *tfo =
c66ac9db 1243 pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo;
0fd97ccf 1244 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db 1245 char i_buf[PR_REG_ISID_ID_LEN];
c66ac9db
NB		 1246
1247 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
d2843c17 1248 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
c66ac9db
NB		 1249
1250 pr_reg->pr_reg_deve->def_pr_registered = 0;
1251 pr_reg->pr_reg_deve->pr_res_key = 0;
6c3c9baa
NB		 1252 if (!list_empty(&pr_reg->pr_reg_list))
1253 list_del(&pr_reg->pr_reg_list);
c66ac9db
NB		 1254 /*
1255 * Caller accessing *pr_reg using core_scsi3_locate_pr_reg(),
1256 * so call core_scsi3_put_pr_reg() to decrement our reference.
1257 */
1258 if (dec_holders)
1259 core_scsi3_put_pr_reg(pr_reg);
1260 /*
1261 * Wait until all reference from any other I_T nexuses for this
1262 * *pr_reg have been released. Because list_del() is called above,
1263 * the last core_scsi3_put_pr_reg(pr_reg) will release this reference
1264 * count back to zero, and we release *pr_reg.
1265 */
1266 while (atomic_read(&pr_reg->pr_res_holders) != 0) {
1267 spin_unlock(&pr_tmpl->registration_lock);
6708bb27 1268 pr_debug("SPC-3 PR [%s] waiting for pr_res_holders\n",
c66ac9db
NB		 1269 tfo->get_fabric_name());
1270 cpu_relax();
1271 spin_lock(&pr_tmpl->registration_lock);
1272 }
1273
6708bb27 1274 pr_debug("SPC-3 PR [%s] Service Action: UNREGISTER Initiator"
c66ac9db
NB		 1275 " Node: %s%s\n", tfo->get_fabric_name(),
1276 pr_reg->pr_reg_nacl->initiatorname,
d2843c17 1277 i_buf);
6708bb27 1278 pr_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target"
c66ac9db
NB		 1279 " Port(s)\n", tfo->get_fabric_name(),
1280 (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE",
e3d6f909 1281 dev->transport->name);
6708bb27 1282 pr_debug("SPC-3 PR [%s] SA Res Key: 0x%016Lx PRgeneration:"
c66ac9db
NB		 1283 " 0x%08x\n", tfo->get_fabric_name(), pr_reg->pr_res_key,
1284 pr_reg->pr_res_generation);
1285
6708bb27 1286 if (!preempt_and_abort_list) {
c66ac9db
NB		 1287 pr_reg->pr_reg_deve = NULL;
1288 pr_reg->pr_reg_nacl = NULL;
c66ac9db
NB		 1289 kmem_cache_free(t10_pr_reg_cache, pr_reg);
1290 return;
1291 }
1292 /*
1293 * For PREEMPT_AND_ABORT, the list of *pr_reg in preempt_and_abort_list
1294 * are released once the ABORT_TASK_SET has completed..
1295 */
1296 list_add_tail(&pr_reg->pr_reg_abort_list, preempt_and_abort_list);
1297}
1298
1299void core_scsi3_free_pr_reg_from_nacl(
1300 struct se_device *dev,
1301 struct se_node_acl *nacl)
1302{
0fd97ccf 1303 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db 1304 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_res_holder;
6c3c9baa 1305 bool free_reg = false;
c66ac9db
NB		 1306 /*
1307 * If the passed se_node_acl matches the reservation holder,
1308 * release the reservation.
1309 */
1310 spin_lock(&dev->dev_reservation_lock);
1311 pr_res_holder = dev->dev_pr_res_holder;
1312 if ((pr_res_holder != NULL) &&
6c3c9baa
NB		 1313 (pr_res_holder->pr_reg_nacl == nacl)) {
1314 __core_scsi3_complete_pro_release(dev, nacl, pr_res_holder, 0, 1);
1315 free_reg = true;
1316 }
c66ac9db
NB		 1317 spin_unlock(&dev->dev_reservation_lock);
1318 /*
1319 * Release any registration associated with the struct se_node_acl.
1320 */
1321 spin_lock(&pr_tmpl->registration_lock);
6c3c9baa
NB		 1322 if (pr_res_holder && free_reg)
1323 __core_scsi3_free_registration(dev, pr_res_holder, NULL, 0);
1324
c66ac9db
NB		 1325 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
1326 &pr_tmpl->registration_list, pr_reg_list) {
1327
1328 if (pr_reg->pr_reg_nacl != nacl)
1329 continue;
1330
1331 __core_scsi3_free_registration(dev, pr_reg, NULL, 0);
1332 }
1333 spin_unlock(&pr_tmpl->registration_lock);
1334}
1335
1336void core_scsi3_free_all_registrations(
1337 struct se_device *dev)
1338{
0fd97ccf 1339 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db
NB		 1340 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_res_holder;
1341
1342 spin_lock(&dev->dev_reservation_lock);
1343 pr_res_holder = dev->dev_pr_res_holder;
1344 if (pr_res_holder != NULL) {
1345 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
1346 __core_scsi3_complete_pro_release(dev, pr_res_nacl,
6c3c9baa 1347 pr_res_holder, 0, 0);
c66ac9db
NB		 1348 }
1349 spin_unlock(&dev->dev_reservation_lock);
1350
1351 spin_lock(&pr_tmpl->registration_lock);
1352 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
1353 &pr_tmpl->registration_list, pr_reg_list) {
1354
1355 __core_scsi3_free_registration(dev, pr_reg, NULL, 0);
1356 }
1357 spin_unlock(&pr_tmpl->registration_lock);
1358
1359 spin_lock(&pr_tmpl->aptpl_reg_lock);
1360 list_for_each_entry_safe(pr_reg, pr_reg_tmp, &pr_tmpl->aptpl_reg_list,
1361 pr_reg_aptpl_list) {
1362 list_del(&pr_reg->pr_reg_aptpl_list);
c66ac9db
NB		 1363 kmem_cache_free(t10_pr_reg_cache, pr_reg);
1364 }
1365 spin_unlock(&pr_tmpl->aptpl_reg_lock);
1366}
1367
1368static int core_scsi3_tpg_depend_item(struct se_portal_group *tpg)
1369{
d588cf8f 1370 return target_depend_item(&tpg->tpg_group.cg_item);
c66ac9db
NB		 1371}
1372
1373static void core_scsi3_tpg_undepend_item(struct se_portal_group *tpg)
1374{
d588cf8f 1375 target_undepend_item(&tpg->tpg_group.cg_item);
33940d09 1376 atomic_dec_mb(&tpg->tpg_pr_ref_count);
c66ac9db
NB		 1377}
1378
1379static int core_scsi3_nodeacl_depend_item(struct se_node_acl *nacl)
1380{
c66ac9db
NB		 1381 if (nacl->dynamic_node_acl)
1382 return 0;
d588cf8f 1383 return target_depend_item(&nacl->acl_group.cg_item);
c66ac9db
NB		 1384}
1385
1386static void core_scsi3_nodeacl_undepend_item(struct se_node_acl *nacl)
1387{
d588cf8f
CH		 1388 if (!nacl->dynamic_node_acl)
1389 target_undepend_item(&nacl->acl_group.cg_item);
33940d09 1390 atomic_dec_mb(&nacl->acl_pr_ref_count);
c66ac9db
NB		 1391}
1392
1393static int core_scsi3_lunacl_depend_item(struct se_dev_entry *se_deve)
1394{
1395 struct se_lun_acl *lun_acl = se_deve->se_lun_acl;
1396 struct se_node_acl *nacl;
1397 struct se_portal_group *tpg;
1398 /*
1399 * For nacl->dynamic_node_acl=1
1400 */
6708bb27 1401 if (!lun_acl)
c66ac9db
NB		 1402 return 0;
1403
1404 nacl = lun_acl->se_lun_nacl;
1405 tpg = nacl->se_tpg;
1406
d588cf8f 1407 return target_depend_item(&lun_acl->se_lun_group.cg_item);
c66ac9db
NB		 1408}
1409
1410static void core_scsi3_lunacl_undepend_item(struct se_dev_entry *se_deve)
1411{
1412 struct se_lun_acl *lun_acl = se_deve->se_lun_acl;
1413 struct se_node_acl *nacl;
1414 struct se_portal_group *tpg;
1415 /*
1416 * For nacl->dynamic_node_acl=1
1417 */
6708bb27 1418 if (!lun_acl) {
33940d09 1419 atomic_dec_mb(&se_deve->pr_ref_count);
c66ac9db
NB		 1420 return;
1421 }
1422 nacl = lun_acl->se_lun_nacl;
1423 tpg = nacl->se_tpg;
1424
d588cf8f 1425 target_undepend_item(&lun_acl->se_lun_group.cg_item);
33940d09 1426 atomic_dec_mb(&se_deve->pr_ref_count);
c66ac9db
NB		 1427}
1428
de103c93
CH		 1429static sense_reason_t
1430core_scsi3_decode_spec_i_port(
c66ac9db
NB		 1431 struct se_cmd *cmd,
1432 struct se_portal_group *tpg,
1433 unsigned char *l_isid,
1434 u64 sa_res_key,
1435 int all_tg_pt,
1436 int aptpl)
1437{
5951146d 1438 struct se_device *dev = cmd->se_dev;
c66ac9db
NB		 1439 struct se_port *tmp_port;
1440 struct se_portal_group *dest_tpg = NULL, *tmp_tpg;
e3d6f909 1441 struct se_session *se_sess = cmd->se_sess;
c66ac9db
NB		 1442 struct se_node_acl *dest_node_acl = NULL;
1443 struct se_dev_entry *dest_se_deve = NULL, *local_se_deve;
1444 struct t10_pr_registration *dest_pr_reg, *local_pr_reg, *pr_reg_e;
1445 struct t10_pr_registration *pr_reg_tmp, *pr_reg_tmp_safe;
d0f474e5 1446 LIST_HEAD(tid_dest_list);
c66ac9db 1447 struct pr_transport_id_holder *tidh_new, *tidh, *tidh_tmp;
9ac8928e 1448 const struct target_core_fabric_ops *tmp_tf_ops;
05d1c7c0 1449 unsigned char *buf;
2aeeafae 1450 unsigned char *ptr, *i_str = NULL, proto_ident;
13ba564c 1451 char *iport_ptr = NULL, i_buf[PR_REG_ISID_ID_LEN];
de103c93 1452 sense_reason_t ret;
c66ac9db 1453 u32 tpdl, tid_len = 0;
d2843c17 1454 int dest_local_nexus;
c66ac9db
NB		 1455 u32 dest_rtpi = 0;
1456
f2083241 1457 local_se_deve = se_sess->se_node_acl->device_list[cmd->orig_fe_lun];
c66ac9db
NB		 1458 /*
1459 * Allocate a struct pr_transport_id_holder and setup the
1460 * local_node_acl and local_se_deve pointers and add to
1461 * struct list_head tid_dest_list for add registration
1462 * processing in the loop of tid_dest_list below.
1463 */
1464 tidh_new = kzalloc(sizeof(struct pr_transport_id_holder), GFP_KERNEL);
6708bb27
AG		 1465 if (!tidh_new) {
1466 pr_err("Unable to allocate tidh_new\n");
de103c93 1467 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 1468 }
1469 INIT_LIST_HEAD(&tidh_new->dest_list);
1470 tidh_new->dest_tpg = tpg;
1471 tidh_new->dest_node_acl = se_sess->se_node_acl;
1472 tidh_new->dest_se_deve = local_se_deve;
1473
5951146d 1474 local_pr_reg = __core_scsi3_alloc_registration(cmd->se_dev,
c66ac9db
NB		 1475 se_sess->se_node_acl, local_se_deve, l_isid,
1476 sa_res_key, all_tg_pt, aptpl);
6708bb27 1477 if (!local_pr_reg) {
c66ac9db 1478 kfree(tidh_new);
de103c93 1479 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 1480 }
1481 tidh_new->dest_pr_reg = local_pr_reg;
1482 /*
1483 * The local I_T nexus does not hold any configfs dependances,
1484 * so we set tid_h->dest_local_nexus=1 to prevent the
1485 * configfs_undepend_item() calls in the tid_dest_list loops below.
1486 */
1487 tidh_new->dest_local_nexus = 1;
1488 list_add_tail(&tidh_new->dest_list, &tid_dest_list);
05d1c7c0 1489
0d7f1299
PB		 1490 if (cmd->data_length < 28) {
1491 pr_warn("SPC-PR: Received PR OUT parameter list"
1492 " length too small: %u\n", cmd->data_length);
de103c93 1493 ret = TCM_INVALID_PARAMETER_LIST;
0d7f1299
PB		 1494 goto out;
1495 }
1496
4949314c 1497 buf = transport_kmap_data_sg(cmd);
de103c93
CH		 1498 if (!buf) {
1499 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1500 goto out;
1501 }
1502
c66ac9db
NB		 1503 /*
1504 * For a PERSISTENT RESERVE OUT specify initiator ports payload,
1505 * first extract TransportID Parameter Data Length, and make sure
1506 * the value matches up to the SCSI expected data transfer length.
1507 */
1508 tpdl = (buf[24] & 0xff) << 24;
1509 tpdl |= (buf[25] & 0xff) << 16;
1510 tpdl |= (buf[26] & 0xff) << 8;
1511 tpdl |= buf[27] & 0xff;
1512
1513 if ((tpdl + 28) != cmd->data_length) {
6708bb27 1514 pr_err("SPC-3 PR: Illegal tpdl: %u + 28 byte header"
c66ac9db
NB		 1515 " does not equal CDB data_length: %u\n", tpdl,
1516 cmd->data_length);
de103c93
CH		 1517 ret = TCM_INVALID_PARAMETER_LIST;
1518 goto out_unmap;
c66ac9db
NB		 1519 }
1520 /*
1521 * Start processing the received transport IDs using the
1522 * receiving I_T Nexus portal's fabric dependent methods to
1523 * obtain the SCSI Initiator Port/Device Identifiers.
1524 */
1525 ptr = &buf[28];
1526
1527 while (tpdl > 0) {
1528 proto_ident = (ptr[0] & 0x0f);
1529 dest_tpg = NULL;
1530
1531 spin_lock(&dev->se_port_lock);
1532 list_for_each_entry(tmp_port, &dev->dev_sep_list, sep_list) {
1533 tmp_tpg = tmp_port->sep_tpg;
6708bb27 1534 if (!tmp_tpg)
c66ac9db 1535 continue;
e3d6f909 1536 tmp_tf_ops = tmp_tpg->se_tpg_tfo;
6708bb27 1537 if (!tmp_tf_ops)
c66ac9db 1538 continue;
2aeeafae 1539 if (!tmp_tf_ops->tpg_parse_pr_out_transport_id)
c66ac9db
NB		 1540 continue;
1541 /*
1542 * Look for the matching proto_ident provided by
1543 * the received TransportID
1544 */
2aeeafae 1545 if (tmp_tpg->proto_id != proto_ident)
c66ac9db
NB		 1546 continue;
1547 dest_rtpi = tmp_port->sep_rtpi;
1548
1549 i_str = tmp_tf_ops->tpg_parse_pr_out_transport_id(
1550 tmp_tpg, (const char *)ptr, &tid_len,
1551 &iport_ptr);
6708bb27 1552 if (!i_str)
c66ac9db
NB		 1553 continue;
1554
33940d09 1555 atomic_inc_mb(&tmp_tpg->tpg_pr_ref_count);
c66ac9db
NB		 1556 spin_unlock(&dev->se_port_lock);
1557
de103c93 1558 if (core_scsi3_tpg_depend_item(tmp_tpg)) {
6708bb27 1559 pr_err(" core_scsi3_tpg_depend_item()"
c66ac9db 1560 " for tmp_tpg\n");
33940d09 1561 atomic_dec_mb(&tmp_tpg->tpg_pr_ref_count);
de103c93
CH		 1562 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1563 goto out_unmap;
c66ac9db
NB		 1564 }
1565 /*
35d1efe8 1566 * Locate the destination initiator ACL to be registered
c66ac9db
NB		 1567 * from the decoded fabric module specific TransportID
1568 * at *i_str.
1569 */
28638887 1570 spin_lock_irq(&tmp_tpg->acl_node_lock);
c66ac9db
NB		 1571 dest_node_acl = __core_tpg_get_initiator_node_acl(
1572 tmp_tpg, i_str);
33940d09
JE		 1573 if (dest_node_acl)
1574 atomic_inc_mb(&dest_node_acl->acl_pr_ref_count);
28638887 1575 spin_unlock_irq(&tmp_tpg->acl_node_lock);
c66ac9db 1576
6708bb27 1577 if (!dest_node_acl) {
c66ac9db
NB		 1578 core_scsi3_tpg_undepend_item(tmp_tpg);
1579 spin_lock(&dev->se_port_lock);
1580 continue;
1581 }
1582
de103c93 1583 if (core_scsi3_nodeacl_depend_item(dest_node_acl)) {
6708bb27 1584 pr_err("configfs_depend_item() failed"
c66ac9db 1585 " for dest_node_acl->acl_group\n");
33940d09 1586 atomic_dec_mb(&dest_node_acl->acl_pr_ref_count);
c66ac9db 1587 core_scsi3_tpg_undepend_item(tmp_tpg);
de103c93
CH		 1588 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1589 goto out_unmap;
c66ac9db
NB		 1590 }
1591
1592 dest_tpg = tmp_tpg;
6708bb27 1593 pr_debug("SPC-3 PR SPEC_I_PT: Located %s Node:"
c66ac9db 1594 " %s Port RTPI: %hu\n",
e3d6f909 1595 dest_tpg->se_tpg_tfo->get_fabric_name(),
c66ac9db
NB		 1596 dest_node_acl->initiatorname, dest_rtpi);
1597
1598 spin_lock(&dev->se_port_lock);
1599 break;
1600 }
1601 spin_unlock(&dev->se_port_lock);
1602
6708bb27
AG		 1603 if (!dest_tpg) {
1604 pr_err("SPC-3 PR SPEC_I_PT: Unable to locate"
c66ac9db 1605 " dest_tpg\n");
de103c93
CH		 1606 ret = TCM_INVALID_PARAMETER_LIST;
1607 goto out_unmap;
c66ac9db 1608 }
8b1e1244 1609
6708bb27 1610 pr_debug("SPC-3 PR SPEC_I_PT: Got %s data_length: %u tpdl: %u"
c66ac9db 1611 " tid_len: %d for %s + %s\n",
e3d6f909 1612 dest_tpg->se_tpg_tfo->get_fabric_name(), cmd->data_length,
c66ac9db 1613 tpdl, tid_len, i_str, iport_ptr);
8b1e1244 1614
c66ac9db 1615 if (tid_len > tpdl) {
6708bb27 1616 pr_err("SPC-3 PR SPEC_I_PT: Illegal tid_len:"
c66ac9db
NB		 1617 " %u for Transport ID: %s\n", tid_len, ptr);
1618 core_scsi3_nodeacl_undepend_item(dest_node_acl);
1619 core_scsi3_tpg_undepend_item(dest_tpg);
de103c93
CH		 1620 ret = TCM_INVALID_PARAMETER_LIST;
1621 goto out_unmap;
c66ac9db
NB		 1622 }
1623 /*
1624 * Locate the desintation struct se_dev_entry pointer for matching
1625 * RELATIVE TARGET PORT IDENTIFIER on the receiving I_T Nexus
1626 * Target Port.
1627 */
1628 dest_se_deve = core_get_se_deve_from_rtpi(dest_node_acl,
1629 dest_rtpi);
6708bb27
AG		 1630 if (!dest_se_deve) {
1631 pr_err("Unable to locate %s dest_se_deve"
c66ac9db 1632 " from destination RTPI: %hu\n",
e3d6f909 1633 dest_tpg->se_tpg_tfo->get_fabric_name(),
c66ac9db
NB		 1634 dest_rtpi);
1635
1636 core_scsi3_nodeacl_undepend_item(dest_node_acl);
1637 core_scsi3_tpg_undepend_item(dest_tpg);
de103c93
CH		 1638 ret = TCM_INVALID_PARAMETER_LIST;
1639 goto out_unmap;
c66ac9db
NB		 1640 }
1641
de103c93 1642 if (core_scsi3_lunacl_depend_item(dest_se_deve)) {
6708bb27 1643 pr_err("core_scsi3_lunacl_depend_item()"
c66ac9db 1644 " failed\n");
33940d09 1645 atomic_dec_mb(&dest_se_deve->pr_ref_count);
c66ac9db
NB		 1646 core_scsi3_nodeacl_undepend_item(dest_node_acl);
1647 core_scsi3_tpg_undepend_item(dest_tpg);
de103c93
CH		 1648 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1649 goto out_unmap;
c66ac9db 1650 }
8b1e1244 1651
6708bb27 1652 pr_debug("SPC-3 PR SPEC_I_PT: Located %s Node: %s"
c66ac9db 1653 " dest_se_deve mapped_lun: %u\n",
e3d6f909 1654 dest_tpg->se_tpg_tfo->get_fabric_name(),
c66ac9db 1655 dest_node_acl->initiatorname, dest_se_deve->mapped_lun);
8b1e1244 1656
c66ac9db
NB		 1657 /*
1658 * Skip any TransportIDs that already have a registration for
1659 * this target port.
1660 */
1661 pr_reg_e = __core_scsi3_locate_pr_reg(dev, dest_node_acl,
1662 iport_ptr);
1663 if (pr_reg_e) {
1664 core_scsi3_put_pr_reg(pr_reg_e);
1665 core_scsi3_lunacl_undepend_item(dest_se_deve);
1666 core_scsi3_nodeacl_undepend_item(dest_node_acl);
1667 core_scsi3_tpg_undepend_item(dest_tpg);
1668 ptr += tid_len;
1669 tpdl -= tid_len;
1670 tid_len = 0;
1671 continue;
1672 }
1673 /*
1674 * Allocate a struct pr_transport_id_holder and setup
1675 * the dest_node_acl and dest_se_deve pointers for the
1676 * loop below.
1677 */
1678 tidh_new = kzalloc(sizeof(struct pr_transport_id_holder),
1679 GFP_KERNEL);
6708bb27
AG		 1680 if (!tidh_new) {
1681 pr_err("Unable to allocate tidh_new\n");
c66ac9db
NB		 1682 core_scsi3_lunacl_undepend_item(dest_se_deve);
1683 core_scsi3_nodeacl_undepend_item(dest_node_acl);
1684 core_scsi3_tpg_undepend_item(dest_tpg);
de103c93
CH		 1685 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1686 goto out_unmap;
c66ac9db
NB		 1687 }
1688 INIT_LIST_HEAD(&tidh_new->dest_list);
1689 tidh_new->dest_tpg = dest_tpg;
1690 tidh_new->dest_node_acl = dest_node_acl;
1691 tidh_new->dest_se_deve = dest_se_deve;
1692
1693 /*
1694 * Allocate, but do NOT add the registration for the
1695 * TransportID referenced SCSI Initiator port. This
1696 * done because of the following from spc4r17 in section
1697 * 6.14.3 wrt SPEC_I_PT:
1698 *
1699 * "If a registration fails for any initiator port (e.g., if th
1700 * logical unit does not have enough resources available to
1701 * hold the registration information), no registrations shall be
1702 * made, and the command shall be terminated with
1703 * CHECK CONDITION status."
1704 *
1705 * That means we call __core_scsi3_alloc_registration() here,
1706 * and then call __core_scsi3_add_registration() in the
1707 * 2nd loop which will never fail.
1708 */
5951146d 1709 dest_pr_reg = __core_scsi3_alloc_registration(cmd->se_dev,
c66ac9db
NB		 1710 dest_node_acl, dest_se_deve, iport_ptr,
1711 sa_res_key, all_tg_pt, aptpl);
6708bb27 1712 if (!dest_pr_reg) {
c66ac9db
NB		 1713 core_scsi3_lunacl_undepend_item(dest_se_deve);
1714 core_scsi3_nodeacl_undepend_item(dest_node_acl);
1715 core_scsi3_tpg_undepend_item(dest_tpg);
1716 kfree(tidh_new);
de103c93
CH		 1717 ret = TCM_INVALID_PARAMETER_LIST;
1718 goto out_unmap;
c66ac9db
NB		 1719 }
1720 tidh_new->dest_pr_reg = dest_pr_reg;
1721 list_add_tail(&tidh_new->dest_list, &tid_dest_list);
1722
1723 ptr += tid_len;
1724 tpdl -= tid_len;
1725 tid_len = 0;
1726
1727 }
05d1c7c0 1728
4949314c 1729 transport_kunmap_data_sg(cmd);
05d1c7c0 1730
c66ac9db
NB		 1731 /*
1732 * Go ahead and create a registrations from tid_dest_list for the
1733 * SPEC_I_PT provided TransportID for the *tidh referenced dest_node_acl
1734 * and dest_se_deve.
1735 *
1736 * The SA Reservation Key from the PROUT is set for the
1737 * registration, and ALL_TG_PT is also passed. ALL_TG_PT=1
1738 * means that the TransportID Initiator port will be
1739 * registered on all of the target ports in the SCSI target device
1740 * ALL_TG_PT=0 means the registration will only be for the
1741 * SCSI target port the PROUT REGISTER with SPEC_I_PT=1
1742 * was received.
1743 */
1744 list_for_each_entry_safe(tidh, tidh_tmp, &tid_dest_list, dest_list) {
1745 dest_tpg = tidh->dest_tpg;
1746 dest_node_acl = tidh->dest_node_acl;
1747 dest_se_deve = tidh->dest_se_deve;
1748 dest_pr_reg = tidh->dest_pr_reg;
1749 dest_local_nexus = tidh->dest_local_nexus;
1750
1751 list_del(&tidh->dest_list);
1752 kfree(tidh);
1753
1754 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
d2843c17 1755 core_pr_dump_initiator_port(dest_pr_reg, i_buf, PR_REG_ISID_ID_LEN);
c66ac9db 1756
5951146d 1757 __core_scsi3_add_registration(cmd->se_dev, dest_node_acl,
c66ac9db
NB		 1758 dest_pr_reg, 0, 0);
1759
6708bb27 1760 pr_debug("SPC-3 PR [%s] SPEC_I_PT: Successfully"
c66ac9db 1761 " registered Transport ID for Node: %s%s Mapped LUN:"
e3d6f909 1762 " %u\n", dest_tpg->se_tpg_tfo->get_fabric_name(),
d2843c17 1763 dest_node_acl->initiatorname, i_buf, dest_se_deve->mapped_lun);
c66ac9db
NB		 1764
1765 if (dest_local_nexus)
1766 continue;
1767
1768 core_scsi3_lunacl_undepend_item(dest_se_deve);
1769 core_scsi3_nodeacl_undepend_item(dest_node_acl);
1770 core_scsi3_tpg_undepend_item(dest_tpg);
1771 }
1772
1773 return 0;
de103c93 1774out_unmap:
4949314c 1775 transport_kunmap_data_sg(cmd);
de103c93 1776out:
c66ac9db
NB		 1777 /*
1778 * For the failure case, release everything from tid_dest_list
1779 * including *dest_pr_reg and the configfs dependances..
1780 */
1781 list_for_each_entry_safe(tidh, tidh_tmp, &tid_dest_list, dest_list) {
1782 dest_tpg = tidh->dest_tpg;
1783 dest_node_acl = tidh->dest_node_acl;
1784 dest_se_deve = tidh->dest_se_deve;
1785 dest_pr_reg = tidh->dest_pr_reg;
1786 dest_local_nexus = tidh->dest_local_nexus;
1787
1788 list_del(&tidh->dest_list);
1789 kfree(tidh);
1790 /*
1791 * Release any extra ALL_TG_PT=1 registrations for
1792 * the SPEC_I_PT=1 case.
1793 */
1794 list_for_each_entry_safe(pr_reg_tmp, pr_reg_tmp_safe,
1795 &dest_pr_reg->pr_reg_atp_list,
1796 pr_reg_atp_mem_list) {
1797 list_del(&pr_reg_tmp->pr_reg_atp_mem_list);
1798 core_scsi3_lunacl_undepend_item(pr_reg_tmp->pr_reg_deve);
1799 kmem_cache_free(t10_pr_reg_cache, pr_reg_tmp);
1800 }
1801
c66ac9db
NB		 1802 kmem_cache_free(t10_pr_reg_cache, dest_pr_reg);
1803
1804 if (dest_local_nexus)
1805 continue;
1806
1807 core_scsi3_lunacl_undepend_item(dest_se_deve);
1808 core_scsi3_nodeacl_undepend_item(dest_node_acl);
1809 core_scsi3_tpg_undepend_item(dest_tpg);
1810 }
1811 return ret;
1812}
1813
3c8a6228 1814static int core_scsi3_update_aptpl_buf(
c66ac9db
NB		 1815 struct se_device *dev,
1816 unsigned char *buf,
0607decd 1817 u32 pr_aptpl_buf_len)
c66ac9db
NB		 1818{
1819 struct se_lun *lun;
1820 struct se_portal_group *tpg;
c66ac9db
NB		 1821 struct t10_pr_registration *pr_reg;
1822 unsigned char tmp[512], isid_buf[32];
1823 ssize_t len = 0;
1824 int reg_count = 0;
3c8a6228 1825 int ret = 0;
c66ac9db 1826
3c8a6228
AG		 1827 spin_lock(&dev->dev_reservation_lock);
1828 spin_lock(&dev->t10_pr.registration_lock);
c66ac9db
NB		 1829 /*
1830 * Walk the registration list..
1831 */
0fd97ccf 1832 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list,
c66ac9db
NB		 1833 pr_reg_list) {
1834
1835 tmp[0] = '\0';
1836 isid_buf[0] = '\0';
1837 tpg = pr_reg->pr_reg_nacl->se_tpg;
1838 lun = pr_reg->pr_reg_tg_pt_lun;
1839 /*
1840 * Write out any ISID value to APTPL metadata that was included
1841 * in the original registration.
1842 */
1843 if (pr_reg->isid_present_at_reg)
1844 snprintf(isid_buf, 32, "initiator_sid=%s\n",
1845 pr_reg->pr_reg_isid);
1846 /*
1847 * Include special metadata if the pr_reg matches the
1848 * reservation holder.
1849 */
1850 if (dev->dev_pr_res_holder == pr_reg) {
1851 snprintf(tmp, 512, "PR_REG_START: %d"
1852 "\ninitiator_fabric=%s\n"
1853 "initiator_node=%s\n%s"
1854 "sa_res_key=%llu\n"
1855 "res_holder=1\nres_type=%02x\n"
1856 "res_scope=%02x\nres_all_tg_pt=%d\n"
1857 "mapped_lun=%u\n", reg_count,
e3d6f909 1858 tpg->se_tpg_tfo->get_fabric_name(),
c66ac9db
NB		 1859 pr_reg->pr_reg_nacl->initiatorname, isid_buf,
1860 pr_reg->pr_res_key, pr_reg->pr_res_type,
1861 pr_reg->pr_res_scope, pr_reg->pr_reg_all_tg_pt,
1862 pr_reg->pr_res_mapped_lun);
1863 } else {
1864 snprintf(tmp, 512, "PR_REG_START: %d\n"
1865 "initiator_fabric=%s\ninitiator_node=%s\n%s"
1866 "sa_res_key=%llu\nres_holder=0\n"
1867 "res_all_tg_pt=%d\nmapped_lun=%u\n",
e3d6f909 1868 reg_count, tpg->se_tpg_tfo->get_fabric_name(),
c66ac9db
NB		 1869 pr_reg->pr_reg_nacl->initiatorname, isid_buf,
1870 pr_reg->pr_res_key, pr_reg->pr_reg_all_tg_pt,
1871 pr_reg->pr_res_mapped_lun);
1872 }
1873
60d645a4 1874 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) {
f161d4b4
NB		 1875 pr_err("Unable to update renaming APTPL metadata,"
1876 " reallocating larger buffer\n");
3c8a6228
AG		 1877 ret = -EMSGSIZE;
1878 goto out;
c66ac9db
NB		 1879 }
1880 len += sprintf(buf+len, "%s", tmp);
1881
1882 /*
1883 * Include information about the associated SCSI target port.
1884 */
1885 snprintf(tmp, 512, "target_fabric=%s\ntarget_node=%s\n"
1886 "tpgt=%hu\nport_rtpi=%hu\ntarget_lun=%u\nPR_REG_END:"
e3d6f909
AG		 1887 " %d\n", tpg->se_tpg_tfo->get_fabric_name(),
1888 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
1889 tpg->se_tpg_tfo->tpg_get_tag(tpg),
c66ac9db
NB		 1890 lun->lun_sep->sep_rtpi, lun->unpacked_lun, reg_count);
1891
60d645a4 1892 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) {
f161d4b4
NB		 1893 pr_err("Unable to update renaming APTPL metadata,"
1894 " reallocating larger buffer\n");
3c8a6228
AG		 1895 ret = -EMSGSIZE;
1896 goto out;
c66ac9db
NB		 1897 }
1898 len += sprintf(buf+len, "%s", tmp);
1899 reg_count++;
1900 }
c66ac9db 1901
6708bb27 1902 if (!reg_count)
c66ac9db
NB		 1903 len += sprintf(buf+len, "No Registrations or Reservations");
1904
3c8a6228
AG		 1905out:
1906 spin_unlock(&dev->t10_pr.registration_lock);
c66ac9db
NB		 1907 spin_unlock(&dev->dev_reservation_lock);
1908
1909 return ret;
1910}
1911
c66ac9db
NB		 1912static int __core_scsi3_write_aptpl_to_file(
1913 struct se_device *dev,
4dee96fb 1914 unsigned char *buf)
c66ac9db 1915{
0fd97ccf 1916 struct t10_wwn *wwn = &dev->t10_wwn;
c66ac9db 1917 struct file *file;
c66ac9db
NB		 1918 int flags = O_RDWR | O_CREAT | O_TRUNC;
1919 char path[512];
4dee96fb 1920 u32 pr_aptpl_buf_len;
c66ac9db
NB		 1921 int ret;
1922
c66ac9db
NB		 1923 memset(path, 0, 512);
1924
60d645a4 1925 if (strlen(&wwn->unit_serial[0]) >= 512) {
6708bb27 1926 pr_err("WWN value for struct se_device does not fit"
c66ac9db 1927 " into path buffer\n");
e3d6f909 1928 return -EMSGSIZE;
c66ac9db
NB		 1929 }
1930
1931 snprintf(path, 512, "/var/target/pr/aptpl_%s", &wwn->unit_serial[0]);
1932 file = filp_open(path, flags, 0600);
0e9b10a9 1933 if (IS_ERR(file)) {
6708bb27 1934 pr_err("filp_open(%s) for APTPL metadata"
c66ac9db 1935 " failed\n", path);
0e9b10a9 1936 return PTR_ERR(file);
c66ac9db
NB		 1937 }
1938
4dee96fb 1939 pr_aptpl_buf_len = (strlen(buf) + 1); /* Add extra for NULL */
c66ac9db 1940
0e9b10a9 1941 ret = kernel_write(file, buf, pr_aptpl_buf_len, 0);
c66ac9db 1942
0e9b10a9 1943 if (ret < 0)
6708bb27 1944 pr_debug("Error writing APTPL metadata file: %s\n", path);
0e9b10a9 1945 fput(file);
c66ac9db 1946
f730f915 1947 return (ret < 0) ? -EIO : 0;
c66ac9db
NB		 1948}
1949
459f213b
AG		 1950/*
1951 * Clear the APTPL metadata if APTPL has been disabled, otherwise
1952 * write out the updated metadata to struct file for this SCSI device.
1953 */
8a391857 1954static sense_reason_t core_scsi3_update_and_write_aptpl(struct se_device *dev, bool aptpl)
c66ac9db 1955{
8a391857 1956 unsigned char *buf;
f161d4b4 1957 int rc, len = PR_APTPL_BUF_LEN;
de103c93 1958
459f213b
AG		 1959 if (!aptpl) {
1960 char *null_buf = "No Registrations or Reservations\n";
1961
8a391857 1962 rc = __core_scsi3_write_aptpl_to_file(dev, null_buf);
459f213b
AG		 1963 dev->t10_pr.pr_aptpl_active = 0;
1964 pr_debug("SPC-3 PR: Set APTPL Bit Deactivated\n");
459f213b 1965
8a391857
NB		 1966 if (rc)
1967 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
459f213b 1968
8a391857
NB		 1969 return 0;
1970 }
f161d4b4
NB		 1971retry:
1972 buf = vzalloc(len);
8a391857
NB		 1973 if (!buf)
1974 return TCM_OUT_OF_RESOURCES;
1975
f161d4b4 1976 rc = core_scsi3_update_aptpl_buf(dev, buf, len);
8a391857 1977 if (rc < 0) {
f161d4b4
NB		 1978 vfree(buf);
1979 len *= 2;
1980 goto retry;
c66ac9db
NB		 1981 }
1982
8a391857
NB		 1983 rc = __core_scsi3_write_aptpl_to_file(dev, buf);
1984 if (rc != 0) {
1985 pr_err("SPC-3 PR: Could not update APTPL\n");
f161d4b4 1986 vfree(buf);
8a391857
NB		 1987 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1988 }
1989 dev->t10_pr.pr_aptpl_active = 1;
f161d4b4 1990 vfree(buf);
8a391857
NB		 1991 pr_debug("SPC-3 PR: Set APTPL Bit Activated\n");
1992 return 0;
c66ac9db
NB		 1993}
1994
de103c93
CH		 1995static sense_reason_t
1996core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
bc118fe4 1997 bool aptpl, bool all_tg_pt, bool spec_i_pt, enum register_type register_type)
c66ac9db 1998{
e3d6f909 1999 struct se_session *se_sess = cmd->se_sess;
5951146d 2000 struct se_device *dev = cmd->se_dev;
c66ac9db 2001 struct se_dev_entry *se_deve;
e3d6f909 2002 struct se_lun *se_lun = cmd->se_lun;
c66ac9db 2003 struct se_portal_group *se_tpg;
bc118fe4 2004 struct t10_pr_registration *pr_reg, *pr_reg_p, *pr_reg_tmp;
0fd97ccf 2005 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db 2006 unsigned char isid_buf[PR_REG_ISID_LEN], *isid_ptr = NULL;
a0d50f62 2007 sense_reason_t ret = TCM_NO_SENSE;
fc09149d 2008 int pr_holder = 0, type;
c66ac9db 2009
6708bb27
AG		 2010 if (!se_sess || !se_lun) {
2011 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n");
de103c93 2012 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 2013 }
2014 se_tpg = se_sess->se_tpg;
f2083241 2015 se_deve = se_sess->se_node_acl->device_list[cmd->orig_fe_lun];
c66ac9db 2016
e3d6f909 2017 if (se_tpg->se_tpg_tfo->sess_get_initiator_sid) {
c66ac9db 2018 memset(&isid_buf[0], 0, PR_REG_ISID_LEN);
e3d6f909 2019 se_tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, &isid_buf[0],
c66ac9db
NB		 2020 PR_REG_ISID_LEN);
2021 isid_ptr = &isid_buf[0];
2022 }
2023 /*
2024 * Follow logic from spc4r17 Section 5.7.7, Register Behaviors Table 47
2025 */
bc118fe4
AG		 2026 pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess);
2027 if (!pr_reg) {
c66ac9db 2028 if (res_key) {
6708bb27 2029 pr_warn("SPC-3 PR: Reservation Key non-zero"
c66ac9db 2030 " for SA REGISTER, returning CONFLICT\n");
de103c93 2031 return TCM_RESERVATION_CONFLICT;
c66ac9db
NB		 2032 }
2033 /*
2034 * Do nothing but return GOOD status.
2035 */
6708bb27 2036 if (!sa_res_key)
03e98c9e 2037 return 0;
c66ac9db 2038
6708bb27 2039 if (!spec_i_pt) {
c66ac9db
NB		 2040 /*
2041 * Perform the Service Action REGISTER on the Initiator
2042 * Port Endpoint that the PRO was received from on the
2043 * Logical Unit of the SCSI device server.
2044 */
de103c93 2045 if (core_scsi3_alloc_registration(cmd->se_dev,
c66ac9db
NB		 2046 se_sess->se_node_acl, se_deve, isid_ptr,
2047 sa_res_key, all_tg_pt, aptpl,
33ce6a87 2048 register_type, 0)) {
6708bb27 2049 pr_err("Unable to allocate"
c66ac9db 2050 " struct t10_pr_registration\n");
de103c93 2051 return TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 2052 }
2053 } else {
2054 /*
2055 * Register both the Initiator port that received
2056 * PROUT SA REGISTER + SPEC_I_PT=1 and extract SCSI
2057 * TransportID from Parameter list and loop through
2058 * fabric dependent parameter list while calling
2059 * logic from of core_scsi3_alloc_registration() for
2060 * each TransportID provided SCSI Initiator Port/Device
2061 */
2062 ret = core_scsi3_decode_spec_i_port(cmd, se_tpg,
2063 isid_ptr, sa_res_key, all_tg_pt, aptpl);
2064 if (ret != 0)
2065 return ret;
2066 }
c66ac9db 2067
459f213b 2068 return core_scsi3_update_and_write_aptpl(dev, aptpl);
de103c93
CH		 2069 }
2070
bc118fe4
AG		 2071 /* ok, existing registration */
2072
2073 if ((register_type == REGISTER) && (res_key != pr_reg->pr_res_key)) {
2074 pr_err("SPC-3 PR REGISTER: Received"
2075 " res_key: 0x%016Lx does not match"
2076 " existing SA REGISTER res_key:"
2077 " 0x%016Lx\n", res_key,
2078 pr_reg->pr_res_key);
2079 ret = TCM_RESERVATION_CONFLICT;
2080 goto out;
de103c93
CH		 2081 }
2082
2083 if (spec_i_pt) {
1f070cc2
AG		 2084 pr_err("SPC-3 PR REGISTER: SPEC_I_PT"
2085 " set on a registered nexus\n");
de103c93 2086 ret = TCM_INVALID_PARAMETER_LIST;
bc118fe4 2087 goto out;
de103c93
CH		 2088 }
2089
2090 /*
2091 * An existing ALL_TG_PT=1 registration being released
2092 * must also set ALL_TG_PT=1 in the incoming PROUT.
2093 */
1f070cc2
AG		 2094 if (pr_reg->pr_reg_all_tg_pt && !all_tg_pt) {
2095 pr_err("SPC-3 PR REGISTER: ALL_TG_PT=1"
de103c93
CH		 2096 " registration exists, but ALL_TG_PT=1 bit not"
2097 " present in received PROUT\n");
2098 ret = TCM_INVALID_CDB_FIELD;
bc118fe4 2099 goto out;
de103c93
CH		 2100 }
2101
de103c93 2102 /*
51d9c41d 2103 * sa_res_key=1 Change Reservation Key for registered I_T Nexus.
de103c93 2104 */
51d9c41d
AG		 2105 if (sa_res_key) {
2106 /*
2107 * Increment PRgeneration counter for struct se_device"
2108 * upon a successful REGISTER, see spc4r17 section 6.3.2
2109 * READ_KEYS service action.
2110 */
2111 pr_reg->pr_res_generation = core_scsi3_pr_generation(cmd->se_dev);
2112 pr_reg->pr_res_key = sa_res_key;
2113 pr_debug("SPC-3 PR [%s] REGISTER%s: Changed Reservation"
2114 " Key for %s to: 0x%016Lx PRgeneration:"
2115 " 0x%08x\n", cmd->se_tfo->get_fabric_name(),
2116 (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ? "_AND_IGNORE_EXISTING_KEY" : "",
2117 pr_reg->pr_reg_nacl->initiatorname,
2118 pr_reg->pr_res_key, pr_reg->pr_res_generation);
2119
2120 } else {
2121 /*
2122 * sa_res_key=0 Unregister Reservation Key for registered I_T Nexus.
2123 */
6c3c9baa
NB		 2124 type = pr_reg->pr_res_type;
2125 pr_holder = core_scsi3_check_implicit_release(cmd->se_dev,
2126 pr_reg);
de103c93 2127 if (pr_holder < 0) {
de103c93 2128 ret = TCM_RESERVATION_CONFLICT;
bc118fe4 2129 goto out;
c66ac9db 2130 }
de103c93
CH		 2131
2132 spin_lock(&pr_tmpl->registration_lock);
c66ac9db 2133 /*
de103c93
CH		 2134 * Release all ALL_TG_PT=1 for the matching SCSI Initiator Port
2135 * and matching pr_res_key.
c66ac9db 2136 */
de103c93
CH		 2137 if (pr_reg->pr_reg_all_tg_pt) {
2138 list_for_each_entry_safe(pr_reg_p, pr_reg_tmp,
2139 &pr_tmpl->registration_list,
2140 pr_reg_list) {
2141
2142 if (!pr_reg_p->pr_reg_all_tg_pt)
2143 continue;
2144 if (pr_reg_p->pr_res_key != res_key)
2145 continue;
2146 if (pr_reg == pr_reg_p)
2147 continue;
2148 if (strcmp(pr_reg->pr_reg_nacl->initiatorname,
2149 pr_reg_p->pr_reg_nacl->initiatorname))
2150 continue;
2151
2152 __core_scsi3_free_registration(dev,
2153 pr_reg_p, NULL, 0);
c66ac9db
NB		 2154 }
2155 }
de103c93 2156
c66ac9db 2157 /*
de103c93 2158 * Release the calling I_T Nexus registration now..
c66ac9db 2159 */
de103c93 2160 __core_scsi3_free_registration(cmd->se_dev, pr_reg, NULL, 1);
fc09149d 2161 pr_reg = NULL;
c66ac9db 2162
de103c93
CH		 2163 /*
2164 * From spc4r17, section 5.7.11.3 Unregistering
2165 *
2166 * If the persistent reservation is a registrants only
2167 * type, the device server shall establish a unit
2168 * attention condition for the initiator port associated
2169 * with every registered I_T nexus except for the I_T
2170 * nexus on which the PERSISTENT RESERVE OUT command was
2171 * received, with the additional sense code set to
2172 * RESERVATIONS RELEASED.
2173 */
2174 if (pr_holder &&
fc09149d
NB		 2175 (type == PR_TYPE_WRITE_EXCLUSIVE_REGONLY ||
2176 type == PR_TYPE_EXCLUSIVE_ACCESS_REGONLY)) {
de103c93
CH		 2177 list_for_each_entry(pr_reg_p,
2178 &pr_tmpl->registration_list,
2179 pr_reg_list) {
2180
2181 core_scsi3_ua_allocate(
2182 pr_reg_p->pr_reg_nacl,
2183 pr_reg_p->pr_res_mapped_lun,
2184 0x2A,
2185 ASCQ_2AH_RESERVATIONS_RELEASED);
c66ac9db 2186 }
de103c93 2187 }
c66ac9db 2188
51d9c41d 2189 spin_unlock(&pr_tmpl->registration_lock);
de103c93 2190 }
c66ac9db 2191
459f213b 2192 ret = core_scsi3_update_and_write_aptpl(dev, aptpl);
de103c93 2193
bc118fe4 2194out:
fc09149d
NB		 2195 if (pr_reg)
2196 core_scsi3_put_pr_reg(pr_reg);
de103c93 2197 return ret;
c66ac9db
NB		 2198}
2199
2200unsigned char *core_scsi3_pr_dump_type(int type)
2201{
2202 switch (type) {
2203 case PR_TYPE_WRITE_EXCLUSIVE:
2204 return "Write Exclusive Access";
2205 case PR_TYPE_EXCLUSIVE_ACCESS:
2206 return "Exclusive Access";
2207 case PR_TYPE_WRITE_EXCLUSIVE_REGONLY:
2208 return "Write Exclusive Access, Registrants Only";
2209 case PR_TYPE_EXCLUSIVE_ACCESS_REGONLY:
2210 return "Exclusive Access, Registrants Only";
2211 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG:
2212 return "Write Exclusive Access, All Registrants";
2213 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG:
2214 return "Exclusive Access, All Registrants";
2215 default:
2216 break;
2217 }
2218
2219 return "Unknown SPC-3 PR Type";
2220}
2221
de103c93
CH		 2222static sense_reason_t
2223core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
c66ac9db 2224{
de103c93 2225 struct se_device *dev = cmd->se_dev;
e3d6f909 2226 struct se_session *se_sess = cmd->se_sess;
e3d6f909 2227 struct se_lun *se_lun = cmd->se_lun;
c66ac9db 2228 struct t10_pr_registration *pr_reg, *pr_res_holder;
0fd97ccf 2229 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db 2230 char i_buf[PR_REG_ISID_ID_LEN];
de103c93 2231 sense_reason_t ret;
c66ac9db
NB		 2232
2233 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
2234
6708bb27
AG		 2235 if (!se_sess || !se_lun) {
2236 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n");
de103c93 2237 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db 2238 }
c66ac9db
NB		 2239 /*
2240 * Locate the existing *pr_reg via struct se_node_acl pointers
2241 */
5951146d 2242 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
c66ac9db 2243 se_sess);
6708bb27
AG		 2244 if (!pr_reg) {
2245 pr_err("SPC-3 PR: Unable to locate"
c66ac9db 2246 " PR_REGISTERED *pr_reg for RESERVE\n");
de103c93 2247 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 2248 }
2249 /*
2250 * From spc4r17 Section 5.7.9: Reserving:
2251 *
2252 * An application client creates a persistent reservation by issuing
2253 * a PERSISTENT RESERVE OUT command with RESERVE service action through
2254 * a registered I_T nexus with the following parameters:
2255 * a) RESERVATION KEY set to the value of the reservation key that is
2256 * registered with the logical unit for the I_T nexus; and
2257 */
2258 if (res_key != pr_reg->pr_res_key) {
6708bb27 2259 pr_err("SPC-3 PR RESERVE: Received res_key: 0x%016Lx"
c66ac9db
NB		 2260 " does not match existing SA REGISTER res_key:"
2261 " 0x%016Lx\n", res_key, pr_reg->pr_res_key);
de103c93
CH		 2262 ret = TCM_RESERVATION_CONFLICT;
2263 goto out_put_pr_reg;
c66ac9db
NB		 2264 }
2265 /*
2266 * From spc4r17 Section 5.7.9: Reserving:
2267 *
2268 * From above:
2269 * b) TYPE field and SCOPE field set to the persistent reservation
2270 * being created.
2271 *
2272 * Only one persistent reservation is allowed at a time per logical unit
2273 * and that persistent reservation has a scope of LU_SCOPE.
2274 */
2275 if (scope != PR_SCOPE_LU_SCOPE) {
6708bb27 2276 pr_err("SPC-3 PR: Illegal SCOPE: 0x%02x\n", scope);
de103c93
CH		 2277 ret = TCM_INVALID_PARAMETER_LIST;
2278 goto out_put_pr_reg;
c66ac9db
NB		 2279 }
2280 /*
2281 * See if we have an existing PR reservation holder pointer at
2282 * struct se_device->dev_pr_res_holder in the form struct t10_pr_registration
2283 * *pr_res_holder.
2284 */
2285 spin_lock(&dev->dev_reservation_lock);
2286 pr_res_holder = dev->dev_pr_res_holder;
ee1b1b9c 2287 if (pr_res_holder) {
c66ac9db
NB		 2288 /*
2289 * From spc4r17 Section 5.7.9: Reserving:
2290 *
2291 * If the device server receives a PERSISTENT RESERVE OUT
2292 * command from an I_T nexus other than a persistent reservation
2293 * holder (see 5.7.10) that attempts to create a persistent
2294 * reservation when a persistent reservation already exists for
2295 * the logical unit, then the command shall be completed with
2296 * RESERVATION CONFLICT status.
2297 */
e673dc92 2298 if (!is_reservation_holder(pr_res_holder, pr_reg)) {
c66ac9db 2299 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
6708bb27 2300 pr_err("SPC-3 PR: Attempted RESERVE from"
c66ac9db
NB		 2301 " [%s]: %s while reservation already held by"
2302 " [%s]: %s, returning RESERVATION_CONFLICT\n",
e3d6f909 2303 cmd->se_tfo->get_fabric_name(),
c66ac9db 2304 se_sess->se_node_acl->initiatorname,
e3d6f909 2305 pr_res_nacl->se_tpg->se_tpg_tfo->get_fabric_name(),
c66ac9db
NB		 2306 pr_res_holder->pr_reg_nacl->initiatorname);
2307
2308 spin_unlock(&dev->dev_reservation_lock);
de103c93
CH		 2309 ret = TCM_RESERVATION_CONFLICT;
2310 goto out_put_pr_reg;
c66ac9db
NB		 2311 }
2312 /*
2313 * From spc4r17 Section 5.7.9: Reserving:
2314 *
2315 * If a persistent reservation holder attempts to modify the
2316 * type or scope of an existing persistent reservation, the
2317 * command shall be completed with RESERVATION CONFLICT status.
2318 */
2319 if ((pr_res_holder->pr_res_type != type) ||
2320 (pr_res_holder->pr_res_scope != scope)) {
2321 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
6708bb27 2322 pr_err("SPC-3 PR: Attempted RESERVE from"
c66ac9db
NB		 2323 " [%s]: %s trying to change TYPE and/or SCOPE,"
2324 " while reservation already held by [%s]: %s,"
2325 " returning RESERVATION_CONFLICT\n",
e3d6f909 2326 cmd->se_tfo->get_fabric_name(),
c66ac9db 2327 se_sess->se_node_acl->initiatorname,
e3d6f909 2328 pr_res_nacl->se_tpg->se_tpg_tfo->get_fabric_name(),
c66ac9db
NB		 2329 pr_res_holder->pr_reg_nacl->initiatorname);
2330
2331 spin_unlock(&dev->dev_reservation_lock);
de103c93
CH		 2332 ret = TCM_RESERVATION_CONFLICT;
2333 goto out_put_pr_reg;
c66ac9db
NB		 2334 }
2335 /*
2336 * From spc4r17 Section 5.7.9: Reserving:
2337 *
2338 * If the device server receives a PERSISTENT RESERVE OUT
2339 * command with RESERVE service action where the TYPE field and
2340 * the SCOPE field contain the same values as the existing type
2341 * and scope from a persistent reservation holder, it shall not
2342 * make any change to the existing persistent reservation and
2343 * shall completethe command with GOOD status.
2344 */
2345 spin_unlock(&dev->dev_reservation_lock);
de103c93
CH		 2346 ret = 0;
2347 goto out_put_pr_reg;
c66ac9db
NB		 2348 }
2349 /*
2350 * Otherwise, our *pr_reg becomes the PR reservation holder for said
2351 * TYPE/SCOPE. Also set the received scope and type in *pr_reg.
2352 */
2353 pr_reg->pr_res_scope = scope;
2354 pr_reg->pr_res_type = type;
2355 pr_reg->pr_res_holder = 1;
2356 dev->dev_pr_res_holder = pr_reg;
d2843c17 2357 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
c66ac9db 2358
6708bb27 2359 pr_debug("SPC-3 PR [%s] Service Action: RESERVE created new"
c66ac9db 2360 " reservation holder TYPE: %s ALL_TG_PT: %d\n",
e3d6f909 2361 cmd->se_tfo->get_fabric_name(), core_scsi3_pr_dump_type(type),
c66ac9db 2362 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
6708bb27 2363 pr_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n",
e3d6f909 2364 cmd->se_tfo->get_fabric_name(),
c66ac9db 2365 se_sess->se_node_acl->initiatorname,
d2843c17 2366 i_buf);
c66ac9db
NB		 2367 spin_unlock(&dev->dev_reservation_lock);
2368
459f213b
AG		 2369 if (pr_tmpl->pr_aptpl_active)
2370 core_scsi3_update_and_write_aptpl(cmd->se_dev, true);
c66ac9db 2371
de103c93
CH		 2372 ret = 0;
2373out_put_pr_reg:
c66ac9db 2374 core_scsi3_put_pr_reg(pr_reg);
de103c93 2375 return ret;
c66ac9db
NB		 2376}
2377
de103c93
CH		 2378static sense_reason_t
2379core_scsi3_emulate_pro_reserve(struct se_cmd *cmd, int type, int scope,
2380 u64 res_key)
c66ac9db 2381{
c66ac9db
NB		 2382 switch (type) {
2383 case PR_TYPE_WRITE_EXCLUSIVE:
2384 case PR_TYPE_EXCLUSIVE_ACCESS:
2385 case PR_TYPE_WRITE_EXCLUSIVE_REGONLY:
2386 case PR_TYPE_EXCLUSIVE_ACCESS_REGONLY:
2387 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG:
2388 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG:
de103c93 2389 return core_scsi3_pro_reserve(cmd, type, scope, res_key);
c66ac9db 2390 default:
6708bb27 2391 pr_err("SPC-3 PR: Unknown Service Action RESERVE Type:"
c66ac9db 2392 " 0x%02x\n", type);
de103c93 2393 return TCM_INVALID_CDB_FIELD;
c66ac9db 2394 }
c66ac9db
NB		 2395}
2396
2397/*
2398 * Called with struct se_device->dev_reservation_lock held.
2399 */
2400static void __core_scsi3_complete_pro_release(
2401 struct se_device *dev,
2402 struct se_node_acl *se_nacl,
2403 struct t10_pr_registration *pr_reg,
6c3c9baa
NB		 2404 int explicit,
2405 int unreg)
c66ac9db 2406{
9ac8928e 2407 const struct target_core_fabric_ops *tfo = se_nacl->se_tpg->se_tpg_tfo;
c66ac9db 2408 char i_buf[PR_REG_ISID_ID_LEN];
6c3c9baa 2409 int pr_res_type = 0, pr_res_scope = 0;
c66ac9db
NB		 2410
2411 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
d2843c17 2412 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
c66ac9db
NB		 2413 /*
2414 * Go ahead and release the current PR reservation holder.
6c3c9baa
NB		 2415 * If an All Registrants reservation is currently active and
2416 * a unregister operation is requested, replace the current
2417 * dev_pr_res_holder with another active registration.
2418 */
2419 if (dev->dev_pr_res_holder) {
2420 pr_res_type = dev->dev_pr_res_holder->pr_res_type;
2421 pr_res_scope = dev->dev_pr_res_holder->pr_res_scope;
2422 dev->dev_pr_res_holder->pr_res_type = 0;
2423 dev->dev_pr_res_holder->pr_res_scope = 0;
2424 dev->dev_pr_res_holder->pr_res_holder = 0;
2425 dev->dev_pr_res_holder = NULL;
2426 }
2427 if (!unreg)
2428 goto out;
c66ac9db 2429
6c3c9baa
NB		 2430 spin_lock(&dev->t10_pr.registration_lock);
2431 list_del_init(&pr_reg->pr_reg_list);
2432 /*
2433 * If the I_T nexus is a reservation holder, the persistent reservation
2434 * is of an all registrants type, and the I_T nexus is the last remaining
2435 * registered I_T nexus, then the device server shall also release the
2436 * persistent reservation.
2437 */
2438 if (!list_empty(&dev->t10_pr.registration_list) &&
2439 ((pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) ||
2440 (pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG))) {
2441 dev->dev_pr_res_holder =
2442 list_entry(dev->t10_pr.registration_list.next,
2443 struct t10_pr_registration, pr_reg_list);
2444 dev->dev_pr_res_holder->pr_res_type = pr_res_type;
2445 dev->dev_pr_res_holder->pr_res_scope = pr_res_scope;
2446 dev->dev_pr_res_holder->pr_res_holder = 1;
2447 }
2448 spin_unlock(&dev->t10_pr.registration_lock);
2449out:
2450 if (!dev->dev_pr_res_holder) {
2451 pr_debug("SPC-3 PR [%s] Service Action: %s RELEASE cleared"
2452 " reservation holder TYPE: %s ALL_TG_PT: %d\n",
2453 tfo->get_fabric_name(), (explicit) ? "explicit" :
2454 "implicit", core_scsi3_pr_dump_type(pr_res_type),
2455 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
2456 }
6708bb27 2457 pr_debug("SPC-3 PR [%s] RELEASE Node: %s%s\n",
c66ac9db 2458 tfo->get_fabric_name(), se_nacl->initiatorname,
d2843c17 2459 i_buf);
c66ac9db
NB		 2460 /*
2461 * Clear TYPE and SCOPE for the next PROUT Service Action: RESERVE
2462 */
2463 pr_reg->pr_res_holder = pr_reg->pr_res_type = pr_reg->pr_res_scope = 0;
2464}
2465
de103c93
CH		 2466static sense_reason_t
2467core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,
2468 u64 res_key)
c66ac9db
NB		 2469{
2470 struct se_device *dev = cmd->se_dev;
e3d6f909
AG		 2471 struct se_session *se_sess = cmd->se_sess;
2472 struct se_lun *se_lun = cmd->se_lun;
c66ac9db 2473 struct t10_pr_registration *pr_reg, *pr_reg_p, *pr_res_holder;
0fd97ccf 2474 struct t10_reservation *pr_tmpl = &dev->t10_pr;
de103c93 2475 sense_reason_t ret = 0;
c66ac9db 2476
6708bb27
AG		 2477 if (!se_sess || !se_lun) {
2478 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n");
de103c93 2479 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 2480 }
2481 /*
2482 * Locate the existing *pr_reg via struct se_node_acl pointers
2483 */
2484 pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess);
6708bb27
AG		 2485 if (!pr_reg) {
2486 pr_err("SPC-3 PR: Unable to locate"
c66ac9db 2487 " PR_REGISTERED *pr_reg for RELEASE\n");
de103c93 2488 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 2489 }
2490 /*
2491 * From spc4r17 Section 5.7.11.2 Releasing:
2492 *
2493 * If there is no persistent reservation or in response to a persistent
2494 * reservation release request from a registered I_T nexus that is not a
2495 * persistent reservation holder (see 5.7.10), the device server shall
2496 * do the following:
2497 *
2498 * a) Not release the persistent reservation, if any;
2499 * b) Not remove any registrations; and
2500 * c) Complete the command with GOOD status.
2501 */
2502 spin_lock(&dev->dev_reservation_lock);
2503 pr_res_holder = dev->dev_pr_res_holder;
6708bb27 2504 if (!pr_res_holder) {
c66ac9db
NB		 2505 /*
2506 * No persistent reservation, return GOOD status.
2507 */
2508 spin_unlock(&dev->dev_reservation_lock);
bb7a8c8e 2509 goto out_put_pr_reg;
c66ac9db 2510 }
c66ac9db 2511
e673dc92 2512 if (!is_reservation_holder(pr_res_holder, pr_reg)) {
c66ac9db 2513 /*
c66ac9db
NB		 2514 * Release request from a registered I_T nexus that is not a
2515 * persistent reservation holder. return GOOD status.
2516 */
2517 spin_unlock(&dev->dev_reservation_lock);
de103c93 2518 goto out_put_pr_reg;
c66ac9db 2519 }
de103c93 2520
c66ac9db
NB		 2521 /*
2522 * From spc4r17 Section 5.7.11.2 Releasing:
2523 *
2524 * Only the persistent reservation holder (see 5.7.10) is allowed to
2525 * release a persistent reservation.
2526 *
2527 * An application client releases the persistent reservation by issuing
2528 * a PERSISTENT RESERVE OUT command with RELEASE service action through
2529 * an I_T nexus that is a persistent reservation holder with the
2530 * following parameters:
2531 *
2532 * a) RESERVATION KEY field set to the value of the reservation key
2533 * that is registered with the logical unit for the I_T nexus;
2534 */
2535 if (res_key != pr_reg->pr_res_key) {
6708bb27 2536 pr_err("SPC-3 PR RELEASE: Received res_key: 0x%016Lx"
c66ac9db
NB		 2537 " does not match existing SA REGISTER res_key:"
2538 " 0x%016Lx\n", res_key, pr_reg->pr_res_key);
2539 spin_unlock(&dev->dev_reservation_lock);
de103c93
CH		 2540 ret = TCM_RESERVATION_CONFLICT;
2541 goto out_put_pr_reg;
c66ac9db
NB		 2542 }
2543 /*
2544 * From spc4r17 Section 5.7.11.2 Releasing and above:
2545 *
2546 * b) TYPE field and SCOPE field set to match the persistent
2547 * reservation being released.
2548 */
2549 if ((pr_res_holder->pr_res_type != type) ||
2550 (pr_res_holder->pr_res_scope != scope)) {
2551 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
6708bb27 2552 pr_err("SPC-3 PR RELEASE: Attempted to release"
c66ac9db
NB		 2553 " reservation from [%s]: %s with different TYPE "
2554 "and/or SCOPE while reservation already held by"
2555 " [%s]: %s, returning RESERVATION_CONFLICT\n",
e3d6f909 2556 cmd->se_tfo->get_fabric_name(),
c66ac9db 2557 se_sess->se_node_acl->initiatorname,
e3d6f909 2558 pr_res_nacl->se_tpg->se_tpg_tfo->get_fabric_name(),
c66ac9db
NB		 2559 pr_res_holder->pr_reg_nacl->initiatorname);
2560
2561 spin_unlock(&dev->dev_reservation_lock);
de103c93
CH		 2562 ret = TCM_RESERVATION_CONFLICT;
2563 goto out_put_pr_reg;
c66ac9db
NB		 2564 }
2565 /*
2566 * In response to a persistent reservation release request from the
2567 * persistent reservation holder the device server shall perform a
2568 * release by doing the following as an uninterrupted series of actions:
2569 * a) Release the persistent reservation;
2570 * b) Not remove any registration(s);
2571 * c) If the released persistent reservation is a registrants only type
2572 * or all registrants type persistent reservation,
2573 * the device server shall establish a unit attention condition for
2574 * the initiator port associated with every regis-
2575 * tered I_T nexus other than I_T nexus on which the PERSISTENT
2576 * RESERVE OUT command with RELEASE service action was received,
2577 * with the additional sense code set to RESERVATIONS RELEASED; and
2578 * d) If the persistent reservation is of any other type, the device
2579 * server shall not establish a unit attention condition.
2580 */
2581 __core_scsi3_complete_pro_release(dev, se_sess->se_node_acl,
6c3c9baa 2582 pr_reg, 1, 0);
c66ac9db
NB		 2583
2584 spin_unlock(&dev->dev_reservation_lock);
2585
2586 if ((type != PR_TYPE_WRITE_EXCLUSIVE_REGONLY) &&
2587 (type != PR_TYPE_EXCLUSIVE_ACCESS_REGONLY) &&
2588 (type != PR_TYPE_WRITE_EXCLUSIVE_ALLREG) &&
2589 (type != PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) {
2590 /*
2591 * If no UNIT ATTENTION conditions will be established for
2592 * PR_TYPE_WRITE_EXCLUSIVE or PR_TYPE_EXCLUSIVE_ACCESS
2593 * go ahead and check for APTPL=1 update+write below
2594 */
2595 goto write_aptpl;
2596 }
2597
2598 spin_lock(&pr_tmpl->registration_lock);
2599 list_for_each_entry(pr_reg_p, &pr_tmpl->registration_list,
2600 pr_reg_list) {
2601 /*
2602 * Do not establish a UNIT ATTENTION condition
2603 * for the calling I_T Nexus
2604 */
2605 if (pr_reg_p == pr_reg)
2606 continue;
2607
2608 core_scsi3_ua_allocate(pr_reg_p->pr_reg_nacl,
2609 pr_reg_p->pr_res_mapped_lun,
2610 0x2A, ASCQ_2AH_RESERVATIONS_RELEASED);
2611 }
2612 spin_unlock(&pr_tmpl->registration_lock);
2613
2614write_aptpl:
459f213b
AG		 2615 if (pr_tmpl->pr_aptpl_active)
2616 core_scsi3_update_and_write_aptpl(cmd->se_dev, true);
2617
de103c93 2618out_put_pr_reg:
c66ac9db 2619 core_scsi3_put_pr_reg(pr_reg);
de103c93 2620 return ret;
c66ac9db
NB		 2621}
2622
de103c93
CH		 2623static sense_reason_t
2624core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)
c66ac9db
NB		 2625{
2626 struct se_device *dev = cmd->se_dev;
2627 struct se_node_acl *pr_reg_nacl;
e3d6f909 2628 struct se_session *se_sess = cmd->se_sess;
0fd97ccf 2629 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db
NB		 2630 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_reg_n, *pr_res_holder;
2631 u32 pr_res_mapped_lun = 0;
2632 int calling_it_nexus = 0;
2633 /*
2634 * Locate the existing *pr_reg via struct se_node_acl pointers
2635 */
5951146d 2636 pr_reg_n = core_scsi3_locate_pr_reg(cmd->se_dev,
c66ac9db 2637 se_sess->se_node_acl, se_sess);
6708bb27
AG		 2638 if (!pr_reg_n) {
2639 pr_err("SPC-3 PR: Unable to locate"
c66ac9db 2640 " PR_REGISTERED *pr_reg for CLEAR\n");
de103c93 2641 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 2642 }
2643 /*
2644 * From spc4r17 section 5.7.11.6, Clearing:
2645 *
2646 * Any application client may release the persistent reservation and
2647 * remove all registrations from a device server by issuing a
2648 * PERSISTENT RESERVE OUT command with CLEAR service action through a
2649 * registered I_T nexus with the following parameter:
2650 *
2651 * a) RESERVATION KEY field set to the value of the reservation key
2652 * that is registered with the logical unit for the I_T nexus.
2653 */
2654 if (res_key != pr_reg_n->pr_res_key) {
6708bb27 2655 pr_err("SPC-3 PR REGISTER: Received"
c66ac9db
NB		 2656 " res_key: 0x%016Lx does not match"
2657 " existing SA REGISTER res_key:"
2658 " 0x%016Lx\n", res_key, pr_reg_n->pr_res_key);
2659 core_scsi3_put_pr_reg(pr_reg_n);
de103c93 2660 return TCM_RESERVATION_CONFLICT;
c66ac9db
NB		 2661 }
2662 /*
2663 * a) Release the persistent reservation, if any;
2664 */
2665 spin_lock(&dev->dev_reservation_lock);
2666 pr_res_holder = dev->dev_pr_res_holder;
2667 if (pr_res_holder) {
2668 struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
2669 __core_scsi3_complete_pro_release(dev, pr_res_nacl,
6c3c9baa 2670 pr_res_holder, 0, 0);
c66ac9db
NB		 2671 }
2672 spin_unlock(&dev->dev_reservation_lock);
2673 /*
2674 * b) Remove all registration(s) (see spc4r17 5.7.7);
2675 */
2676 spin_lock(&pr_tmpl->registration_lock);
2677 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
2678 &pr_tmpl->registration_list, pr_reg_list) {
2679
2680 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2681 pr_reg_nacl = pr_reg->pr_reg_nacl;
2682 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2683 __core_scsi3_free_registration(dev, pr_reg, NULL,
2684 calling_it_nexus);
2685 /*
2686 * e) Establish a unit attention condition for the initiator
2687 * port associated with every registered I_T nexus other
2688 * than the I_T nexus on which the PERSISTENT RESERVE OUT
2689 * command with CLEAR service action was received, with the
2690 * additional sense code set to RESERVATIONS PREEMPTED.
2691 */
6708bb27 2692 if (!calling_it_nexus)
c66ac9db
NB		 2693 core_scsi3_ua_allocate(pr_reg_nacl, pr_res_mapped_lun,
2694 0x2A, ASCQ_2AH_RESERVATIONS_PREEMPTED);
2695 }
2696 spin_unlock(&pr_tmpl->registration_lock);
2697
6708bb27 2698 pr_debug("SPC-3 PR [%s] Service Action: CLEAR complete\n",
e3d6f909 2699 cmd->se_tfo->get_fabric_name());
c66ac9db 2700
459f213b 2701 core_scsi3_update_and_write_aptpl(cmd->se_dev, false);
c66ac9db
NB		 2702
2703 core_scsi3_pr_generation(dev);
2704 return 0;
2705}
2706
2707/*
2708 * Called with struct se_device->dev_reservation_lock held.
2709 */
2710static void __core_scsi3_complete_pro_preempt(
2711 struct se_device *dev,
2712 struct t10_pr_registration *pr_reg,
2713 struct list_head *preempt_and_abort_list,
2714 int type,
2715 int scope,
33ce6a87 2716 enum preempt_type preempt_type)
c66ac9db
NB		 2717{
2718 struct se_node_acl *nacl = pr_reg->pr_reg_nacl;
9ac8928e 2719 const struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo;
c66ac9db 2720 char i_buf[PR_REG_ISID_ID_LEN];
c66ac9db
NB		 2721
2722 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
d2843c17 2723 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
c66ac9db 2724 /*
125d0119 2725 * Do an implicit RELEASE of the existing reservation.
c66ac9db
NB		 2726 */
2727 if (dev->dev_pr_res_holder)
2728 __core_scsi3_complete_pro_release(dev, nacl,
6c3c9baa 2729 dev->dev_pr_res_holder, 0, 0);
c66ac9db
NB		 2730
2731 dev->dev_pr_res_holder = pr_reg;
2732 pr_reg->pr_res_holder = 1;
2733 pr_reg->pr_res_type = type;
2734 pr_reg->pr_res_scope = scope;
2735
6708bb27 2736 pr_debug("SPC-3 PR [%s] Service Action: PREEMPT%s created new"
c66ac9db 2737 " reservation holder TYPE: %s ALL_TG_PT: %d\n",
33ce6a87 2738 tfo->get_fabric_name(), (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "",
c66ac9db
NB		 2739 core_scsi3_pr_dump_type(type),
2740 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
6708bb27 2741 pr_debug("SPC-3 PR [%s] PREEMPT%s from Node: %s%s\n",
33ce6a87 2742 tfo->get_fabric_name(), (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "",
d2843c17 2743 nacl->initiatorname, i_buf);
c66ac9db
NB		 2744 /*
2745 * For PREEMPT_AND_ABORT, add the preempting reservation's
2746 * struct t10_pr_registration to the list that will be compared
2747 * against received CDBs..
2748 */
2749 if (preempt_and_abort_list)
2750 list_add_tail(&pr_reg->pr_reg_abort_list,
2751 preempt_and_abort_list);
2752}
2753
2754static void core_scsi3_release_preempt_and_abort(
2755 struct list_head *preempt_and_abort_list,
2756 struct t10_pr_registration *pr_reg_holder)
2757{
2758 struct t10_pr_registration *pr_reg, *pr_reg_tmp;
2759
2760 list_for_each_entry_safe(pr_reg, pr_reg_tmp, preempt_and_abort_list,
2761 pr_reg_abort_list) {
2762
2763 list_del(&pr_reg->pr_reg_abort_list);
2764 if (pr_reg_holder == pr_reg)
2765 continue;
2766 if (pr_reg->pr_res_holder) {
6708bb27 2767 pr_warn("pr_reg->pr_res_holder still set\n");
c66ac9db
NB		 2768 continue;
2769 }
2770
2771 pr_reg->pr_reg_deve = NULL;
2772 pr_reg->pr_reg_nacl = NULL;
c66ac9db
NB		 2773 kmem_cache_free(t10_pr_reg_cache, pr_reg);
2774 }
2775}
2776
de103c93
CH		 2777static sense_reason_t
2778core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
33ce6a87 2779 u64 sa_res_key, enum preempt_type preempt_type)
c66ac9db 2780{
5951146d 2781 struct se_device *dev = cmd->se_dev;
c66ac9db 2782 struct se_node_acl *pr_reg_nacl;
e3d6f909 2783 struct se_session *se_sess = cmd->se_sess;
d0f474e5 2784 LIST_HEAD(preempt_and_abort_list);
c66ac9db 2785 struct t10_pr_registration *pr_reg, *pr_reg_tmp, *pr_reg_n, *pr_res_holder;
0fd97ccf 2786 struct t10_reservation *pr_tmpl = &dev->t10_pr;
c66ac9db 2787 u32 pr_res_mapped_lun = 0;
b6932ee3
SA		 2788 int all_reg = 0, calling_it_nexus = 0;
2789 bool sa_res_key_unmatched = sa_res_key != 0;
de103c93 2790 int prh_type = 0, prh_scope = 0;
c66ac9db 2791
de103c93
CH		 2792 if (!se_sess)
2793 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db 2794
5951146d 2795 pr_reg_n = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
c66ac9db 2796 se_sess);
6708bb27
AG		 2797 if (!pr_reg_n) {
2798 pr_err("SPC-3 PR: Unable to locate"
c66ac9db 2799 " PR_REGISTERED *pr_reg for PREEMPT%s\n",
33ce6a87 2800 (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "");
de103c93 2801 return TCM_RESERVATION_CONFLICT;
c66ac9db
NB		 2802 }
2803 if (pr_reg_n->pr_res_key != res_key) {
2804 core_scsi3_put_pr_reg(pr_reg_n);
de103c93 2805 return TCM_RESERVATION_CONFLICT;
c66ac9db
NB		 2806 }
2807 if (scope != PR_SCOPE_LU_SCOPE) {
6708bb27 2808 pr_err("SPC-3 PR: Illegal SCOPE: 0x%02x\n", scope);
c66ac9db 2809 core_scsi3_put_pr_reg(pr_reg_n);
de103c93 2810 return TCM_INVALID_PARAMETER_LIST;
c66ac9db 2811 }
c66ac9db
NB		 2812
2813 spin_lock(&dev->dev_reservation_lock);
2814 pr_res_holder = dev->dev_pr_res_holder;
2815 if (pr_res_holder &&
2816 ((pr_res_holder->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) ||
2817 (pr_res_holder->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)))
2818 all_reg = 1;
2819
6708bb27 2820 if (!all_reg && !sa_res_key) {
c66ac9db
NB		 2821 spin_unlock(&dev->dev_reservation_lock);
2822 core_scsi3_put_pr_reg(pr_reg_n);
de103c93 2823 return TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 2824 }
2825 /*
2826 * From spc4r17, section 5.7.11.4.4 Removing Registrations:
2827 *
2828 * If the SERVICE ACTION RESERVATION KEY field does not identify a
2829 * persistent reservation holder or there is no persistent reservation
2830 * holder (i.e., there is no persistent reservation), then the device
2831 * server shall perform a preempt by doing the following in an
2832 * uninterrupted series of actions. (See below..)
2833 */
6708bb27 2834 if (!pr_res_holder || (pr_res_holder->pr_res_key != sa_res_key)) {
c66ac9db
NB		 2835 /*
2836 * No existing or SA Reservation Key matching reservations..
2837 *
2838 * PROUT SA PREEMPT with All Registrant type reservations are
2839 * allowed to be processed without a matching SA Reservation Key
2840 */
2841 spin_lock(&pr_tmpl->registration_lock);
2842 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
2843 &pr_tmpl->registration_list, pr_reg_list) {
2844 /*
2845 * Removing of registrations in non all registrants
2846 * type reservations without a matching SA reservation
2847 * key.
2848 *
2849 * a) Remove the registrations for all I_T nexuses
2850 * specified by the SERVICE ACTION RESERVATION KEY
2851 * field;
2852 * b) Ignore the contents of the SCOPE and TYPE fields;
2853 * c) Process tasks as defined in 5.7.1; and
2854 * d) Establish a unit attention condition for the
2855 * initiator port associated with every I_T nexus
2856 * that lost its registration other than the I_T
2857 * nexus on which the PERSISTENT RESERVE OUT command
2858 * was received, with the additional sense code set
2859 * to REGISTRATIONS PREEMPTED.
2860 */
6708bb27 2861 if (!all_reg) {
c66ac9db
NB		 2862 if (pr_reg->pr_res_key != sa_res_key)
2863 continue;
b6932ee3 2864 sa_res_key_unmatched = false;
c66ac9db
NB		 2865
2866 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2867 pr_reg_nacl = pr_reg->pr_reg_nacl;
2868 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2869 __core_scsi3_free_registration(dev, pr_reg,
33ce6a87 2870 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list :
c66ac9db 2871 NULL, calling_it_nexus);
c66ac9db
NB		 2872 } else {
2873 /*
2874 * Case for any existing all registrants type
2875 * reservation, follow logic in spc4r17 section
2876 * 5.7.11.4 Preempting, Table 52 and Figure 7.
2877 *
2878 * For a ZERO SA Reservation key, release
125d0119 2879 * all other registrations and do an implicit
c66ac9db
NB		 2880 * release of active persistent reservation.
2881 *
2882 * For a non-ZERO SA Reservation key, only
2883 * release the matching reservation key from
2884 * registrations.
2885 */
2886 if ((sa_res_key) &&
2887 (pr_reg->pr_res_key != sa_res_key))
2888 continue;
b6932ee3 2889 sa_res_key_unmatched = false;
c66ac9db
NB		 2890
2891 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2892 if (calling_it_nexus)
2893 continue;
2894
2895 pr_reg_nacl = pr_reg->pr_reg_nacl;
2896 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2897 __core_scsi3_free_registration(dev, pr_reg,
33ce6a87 2898 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list :
c66ac9db 2899 NULL, 0);
c66ac9db 2900 }
6708bb27 2901 if (!calling_it_nexus)
c66ac9db
NB		 2902 core_scsi3_ua_allocate(pr_reg_nacl,
2903 pr_res_mapped_lun, 0x2A,
9e08e34e 2904 ASCQ_2AH_REGISTRATIONS_PREEMPTED);
c66ac9db
NB		 2905 }
2906 spin_unlock(&pr_tmpl->registration_lock);
2907 /*
2908 * If a PERSISTENT RESERVE OUT with a PREEMPT service action or
2909 * a PREEMPT AND ABORT service action sets the SERVICE ACTION
2910 * RESERVATION KEY field to a value that does not match any
2911 * registered reservation key, then the device server shall
2912 * complete the command with RESERVATION CONFLICT status.
2913 */
b6932ee3 2914 if (sa_res_key_unmatched) {
c66ac9db
NB		 2915 spin_unlock(&dev->dev_reservation_lock);
2916 core_scsi3_put_pr_reg(pr_reg_n);
de103c93 2917 return TCM_RESERVATION_CONFLICT;
c66ac9db
NB		 2918 }
2919 /*
2920 * For an existing all registrants type reservation
2921 * with a zero SA rservation key, preempt the existing
2922 * reservation with the new PR type and scope.
2923 */
2924 if (pr_res_holder && all_reg && !(sa_res_key)) {
2925 __core_scsi3_complete_pro_preempt(dev, pr_reg_n,
33ce6a87
AG		 2926 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : NULL,
2927 type, scope, preempt_type);
c66ac9db 2928
33ce6a87 2929 if (preempt_type == PREEMPT_AND_ABORT)
c66ac9db
NB		 2930 core_scsi3_release_preempt_and_abort(
2931 &preempt_and_abort_list, pr_reg_n);
2932 }
2933 spin_unlock(&dev->dev_reservation_lock);
2934
459f213b
AG		 2935 if (pr_tmpl->pr_aptpl_active)
2936 core_scsi3_update_and_write_aptpl(cmd->se_dev, true);
c66ac9db
NB		 2937
2938 core_scsi3_put_pr_reg(pr_reg_n);
5951146d 2939 core_scsi3_pr_generation(cmd->se_dev);
c66ac9db
NB		 2940 return 0;
2941 }
2942 /*
2943 * The PREEMPTing SA reservation key matches that of the
2944 * existing persistent reservation, first, we check if
2945 * we are preempting our own reservation.
2946 * From spc4r17, section 5.7.11.4.3 Preempting
2947 * persistent reservations and registration handling
2948 *
2949 * If an all registrants persistent reservation is not
2950 * present, it is not an error for the persistent
2951 * reservation holder to preempt itself (i.e., a
2952 * PERSISTENT RESERVE OUT with a PREEMPT service action
2953 * or a PREEMPT AND ABORT service action with the
2954 * SERVICE ACTION RESERVATION KEY value equal to the
2955 * persistent reservation holder's reservation key that
2956 * is received from the persistent reservation holder).
2957 * In that case, the device server shall establish the
2958 * new persistent reservation and maintain the
2959 * registration.
2960 */
2961 prh_type = pr_res_holder->pr_res_type;
2962 prh_scope = pr_res_holder->pr_res_scope;
2963 /*
2964 * If the SERVICE ACTION RESERVATION KEY field identifies a
2965 * persistent reservation holder (see 5.7.10), the device
2966 * server shall perform a preempt by doing the following as
2967 * an uninterrupted series of actions:
2968 *
2969 * a) Release the persistent reservation for the holder
2970 * identified by the SERVICE ACTION RESERVATION KEY field;
2971 */
2972 if (pr_reg_n != pr_res_holder)
2973 __core_scsi3_complete_pro_release(dev,
6c3c9baa
NB		 2974 pr_res_holder->pr_reg_nacl,
2975 dev->dev_pr_res_holder, 0, 0);
c66ac9db
NB		 2976 /*
2977 * b) Remove the registrations for all I_T nexuses identified
2978 * by the SERVICE ACTION RESERVATION KEY field, except the
2979 * I_T nexus that is being used for the PERSISTENT RESERVE
2980 * OUT command. If an all registrants persistent reservation
2981 * is present and the SERVICE ACTION RESERVATION KEY field
2982 * is set to zero, then all registrations shall be removed
2983 * except for that of the I_T nexus that is being used for
2984 * the PERSISTENT RESERVE OUT command;
2985 */
2986 spin_lock(&pr_tmpl->registration_lock);
2987 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
2988 &pr_tmpl->registration_list, pr_reg_list) {
2989
2990 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
2991 if (calling_it_nexus)
2992 continue;
2993
2994 if (pr_reg->pr_res_key != sa_res_key)
2995 continue;
2996
2997 pr_reg_nacl = pr_reg->pr_reg_nacl;
2998 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2999 __core_scsi3_free_registration(dev, pr_reg,
33ce6a87 3000 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : NULL,
c66ac9db
NB		 3001 calling_it_nexus);
3002 /*
3003 * e) Establish a unit attention condition for the initiator
3004 * port associated with every I_T nexus that lost its
3005 * persistent reservation and/or registration, with the
3006 * additional sense code set to REGISTRATIONS PREEMPTED;
3007 */
3008 core_scsi3_ua_allocate(pr_reg_nacl, pr_res_mapped_lun, 0x2A,
9e08e34e 3009 ASCQ_2AH_REGISTRATIONS_PREEMPTED);
c66ac9db
NB		 3010 }
3011 spin_unlock(&pr_tmpl->registration_lock);
3012 /*
3013 * c) Establish a persistent reservation for the preempting
3014 * I_T nexus using the contents of the SCOPE and TYPE fields;
3015 */
3016 __core_scsi3_complete_pro_preempt(dev, pr_reg_n,
33ce6a87
AG		 3017 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : NULL,
3018 type, scope, preempt_type);
c66ac9db
NB		 3019 /*
3020 * d) Process tasks as defined in 5.7.1;
3021 * e) See above..
3022 * f) If the type or scope has changed, then for every I_T nexus
3023 * whose reservation key was not removed, except for the I_T
3024 * nexus on which the PERSISTENT RESERVE OUT command was
3025 * received, the device server shall establish a unit
3026 * attention condition for the initiator port associated with
3027 * that I_T nexus, with the additional sense code set to
3028 * RESERVATIONS RELEASED. If the type or scope have not
3029 * changed, then no unit attention condition(s) shall be
3030 * established for this reason.
3031 */
3032 if ((prh_type != type) || (prh_scope != scope)) {
3033 spin_lock(&pr_tmpl->registration_lock);
3034 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
3035 &pr_tmpl->registration_list, pr_reg_list) {
3036
3037 calling_it_nexus = (pr_reg_n == pr_reg) ? 1 : 0;
3038 if (calling_it_nexus)
3039 continue;
3040
3041 core_scsi3_ua_allocate(pr_reg->pr_reg_nacl,
3042 pr_reg->pr_res_mapped_lun, 0x2A,
3043 ASCQ_2AH_RESERVATIONS_RELEASED);
3044 }
3045 spin_unlock(&pr_tmpl->registration_lock);
3046 }
3047 spin_unlock(&dev->dev_reservation_lock);
3048 /*
3049 * Call LUN_RESET logic upon list of struct t10_pr_registration,
3050 * All received CDBs for the matching existing reservation and
3051 * registrations undergo ABORT_TASK logic.
3052 *
3053 * From there, core_scsi3_release_preempt_and_abort() will
3054 * release every registration in the list (which have already
3055 * been removed from the primary pr_reg list), except the
3056 * new persistent reservation holder, the calling Initiator Port.
3057 */
33ce6a87 3058 if (preempt_type == PREEMPT_AND_ABORT) {
c66ac9db
NB		 3059 core_tmr_lun_reset(dev, NULL, &preempt_and_abort_list, cmd);
3060 core_scsi3_release_preempt_and_abort(&preempt_and_abort_list,
3061 pr_reg_n);
3062 }
3063
459f213b
AG		 3064 if (pr_tmpl->pr_aptpl_active)
3065 core_scsi3_update_and_write_aptpl(cmd->se_dev, true);
c66ac9db
NB		 3066
3067 core_scsi3_put_pr_reg(pr_reg_n);
5951146d 3068 core_scsi3_pr_generation(cmd->se_dev);
c66ac9db
NB		 3069 return 0;
3070}
3071
de103c93
CH		 3072static sense_reason_t
3073core_scsi3_emulate_pro_preempt(struct se_cmd *cmd, int type, int scope,
33ce6a87 3074 u64 res_key, u64 sa_res_key, enum preempt_type preempt_type)
c66ac9db 3075{
c66ac9db
NB		 3076 switch (type) {
3077 case PR_TYPE_WRITE_EXCLUSIVE:
3078 case PR_TYPE_EXCLUSIVE_ACCESS:
3079 case PR_TYPE_WRITE_EXCLUSIVE_REGONLY:
3080 case PR_TYPE_EXCLUSIVE_ACCESS_REGONLY:
3081 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG:
3082 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG:
de103c93 3083 return core_scsi3_pro_preempt(cmd, type, scope, res_key,
33ce6a87 3084 sa_res_key, preempt_type);
c66ac9db 3085 default:
6708bb27 3086 pr_err("SPC-3 PR: Unknown Service Action PREEMPT%s"
33ce6a87 3087 " Type: 0x%02x\n", (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "", type);
de103c93 3088 return TCM_INVALID_CDB_FIELD;
c66ac9db 3089 }
c66ac9db
NB		 3090}
3091
3092
de103c93
CH		 3093static sense_reason_t
3094core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
3095 u64 sa_res_key, int aptpl, int unreg)
c66ac9db 3096{
e3d6f909 3097 struct se_session *se_sess = cmd->se_sess;
5951146d 3098 struct se_device *dev = cmd->se_dev;
28168905 3099 struct se_dev_entry *dest_se_deve = NULL;
e3d6f909 3100 struct se_lun *se_lun = cmd->se_lun;
c66ac9db
NB		 3101 struct se_node_acl *pr_res_nacl, *pr_reg_nacl, *dest_node_acl = NULL;
3102 struct se_port *se_port;
3103 struct se_portal_group *se_tpg, *dest_se_tpg = NULL;
9ac8928e 3104 const struct target_core_fabric_ops *dest_tf_ops = NULL, *tf_ops;
c66ac9db 3105 struct t10_pr_registration *pr_reg, *pr_res_holder, *dest_pr_reg;
0fd97ccf 3106 struct t10_reservation *pr_tmpl = &dev->t10_pr;
05d1c7c0 3107 unsigned char *buf;
c66ac9db 3108 unsigned char *initiator_str;
13ba564c 3109 char *iport_ptr = NULL, i_buf[PR_REG_ISID_ID_LEN];
c66ac9db 3110 u32 tid_len, tmp_tid_len;
d2843c17 3111 int new_reg = 0, type, scope, matching_iname;
de103c93 3112 sense_reason_t ret;
c66ac9db
NB		 3113 unsigned short rtpi;
3114 unsigned char proto_ident;
3115
6708bb27
AG		 3116 if (!se_sess || !se_lun) {
3117 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n");
de103c93 3118 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db 3119 }
de103c93 3120
c66ac9db
NB		 3121 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
3122 se_tpg = se_sess->se_tpg;
e3d6f909 3123 tf_ops = se_tpg->se_tpg_tfo;
c66ac9db
NB		 3124 /*
3125 * Follow logic from spc4r17 Section 5.7.8, Table 50 --
3126 * Register behaviors for a REGISTER AND MOVE service action
3127 *
3128 * Locate the existing *pr_reg via struct se_node_acl pointers
3129 */
5951146d 3130 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
c66ac9db 3131 se_sess);
6708bb27
AG		 3132 if (!pr_reg) {
3133 pr_err("SPC-3 PR: Unable to locate PR_REGISTERED"
c66ac9db 3134 " *pr_reg for REGISTER_AND_MOVE\n");
de103c93 3135 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 3136 }
3137 /*
3138 * The provided reservation key much match the existing reservation key
3139 * provided during this initiator's I_T nexus registration.
3140 */
3141 if (res_key != pr_reg->pr_res_key) {
6708bb27 3142 pr_warn("SPC-3 PR REGISTER_AND_MOVE: Received"
c66ac9db
NB		 3143 " res_key: 0x%016Lx does not match existing SA REGISTER"
3144 " res_key: 0x%016Lx\n", res_key, pr_reg->pr_res_key);
de103c93
CH		 3145 ret = TCM_RESERVATION_CONFLICT;
3146 goto out_put_pr_reg;
c66ac9db
NB		 3147 }
3148 /*
3149 * The service active reservation key needs to be non zero
3150 */
6708bb27
AG		 3151 if (!sa_res_key) {
3152 pr_warn("SPC-3 PR REGISTER_AND_MOVE: Received zero"
c66ac9db 3153 " sa_res_key\n");
de103c93
CH		 3154 ret = TCM_INVALID_PARAMETER_LIST;
3155 goto out_put_pr_reg;
c66ac9db 3156 }
05d1c7c0 3157
c66ac9db
NB		 3158 /*
3159 * Determine the Relative Target Port Identifier where the reservation
3160 * will be moved to for the TransportID containing SCSI initiator WWN
3161 * information.
3162 */
4949314c 3163 buf = transport_kmap_data_sg(cmd);
de103c93
CH		 3164 if (!buf) {
3165 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
3166 goto out_put_pr_reg;
3167 }
3168
c66ac9db
NB		 3169 rtpi = (buf[18] & 0xff) << 8;
3170 rtpi |= buf[19] & 0xff;
3171 tid_len = (buf[20] & 0xff) << 24;
3172 tid_len |= (buf[21] & 0xff) << 16;
3173 tid_len |= (buf[22] & 0xff) << 8;
3174 tid_len |= buf[23] & 0xff;
4949314c 3175 transport_kunmap_data_sg(cmd);
05d1c7c0 3176 buf = NULL;
c66ac9db
NB		 3177
3178 if ((tid_len + 24) != cmd->data_length) {
6708bb27 3179 pr_err("SPC-3 PR: Illegal tid_len: %u + 24 byte header"
c66ac9db
NB		 3180 " does not equal CDB data_length: %u\n", tid_len,
3181 cmd->data_length);
de103c93
CH		 3182 ret = TCM_INVALID_PARAMETER_LIST;
3183 goto out_put_pr_reg;
c66ac9db
NB		 3184 }
3185
3186 spin_lock(&dev->se_port_lock);
3187 list_for_each_entry(se_port, &dev->dev_sep_list, sep_list) {
3188 if (se_port->sep_rtpi != rtpi)
3189 continue;
3190 dest_se_tpg = se_port->sep_tpg;
6708bb27 3191 if (!dest_se_tpg)
c66ac9db 3192 continue;
e3d6f909 3193 dest_tf_ops = dest_se_tpg->se_tpg_tfo;
6708bb27 3194 if (!dest_tf_ops)
c66ac9db
NB		 3195 continue;
3196
33940d09 3197 atomic_inc_mb(&dest_se_tpg->tpg_pr_ref_count);
c66ac9db
NB		 3198 spin_unlock(&dev->se_port_lock);
3199
de103c93 3200 if (core_scsi3_tpg_depend_item(dest_se_tpg)) {
6708bb27 3201 pr_err("core_scsi3_tpg_depend_item() failed"
c66ac9db 3202 " for dest_se_tpg\n");
33940d09 3203 atomic_dec_mb(&dest_se_tpg->tpg_pr_ref_count);
de103c93
CH		 3204 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
3205 goto out_put_pr_reg;
c66ac9db
NB		 3206 }
3207
3208 spin_lock(&dev->se_port_lock);
3209 break;
3210 }
3211 spin_unlock(&dev->se_port_lock);
3212
6708bb27
AG		 3213 if (!dest_se_tpg || !dest_tf_ops) {
3214 pr_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate"
c66ac9db
NB		 3215 " fabric ops from Relative Target Port Identifier:"
3216 " %hu\n", rtpi);
de103c93
CH		 3217 ret = TCM_INVALID_PARAMETER_LIST;
3218 goto out_put_pr_reg;
c66ac9db 3219 }
05d1c7c0 3220
4949314c 3221 buf = transport_kmap_data_sg(cmd);
de103c93
CH		 3222 if (!buf) {
3223 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
3224 goto out_put_pr_reg;
3225 }
c66ac9db 3226 proto_ident = (buf[24] & 0x0f);
8b1e1244 3227
6708bb27 3228 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Extracted Protocol Identifier:"
c66ac9db 3229 " 0x%02x\n", proto_ident);
8b1e1244 3230
2aeeafae 3231 if (proto_ident != dest_se_tpg->proto_id) {
6708bb27 3232 pr_err("SPC-3 PR REGISTER_AND_MOVE: Received"
c66ac9db
NB		 3233 " proto_ident: 0x%02x does not match ident: 0x%02x"
3234 " from fabric: %s\n", proto_ident,
2aeeafae 3235 dest_se_tpg->proto_id,
c66ac9db 3236 dest_tf_ops->get_fabric_name());
de103c93 3237 ret = TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 3238 goto out;
3239 }
3240 if (dest_tf_ops->tpg_parse_pr_out_transport_id == NULL) {
6708bb27 3241 pr_err("SPC-3 PR REGISTER_AND_MOVE: Fabric does not"
c66ac9db
NB		 3242 " containg a valid tpg_parse_pr_out_transport_id"
3243 " function pointer\n");
de103c93 3244 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 3245 goto out;
3246 }
3247 initiator_str = dest_tf_ops->tpg_parse_pr_out_transport_id(dest_se_tpg,
3248 (const char *)&buf[24], &tmp_tid_len, &iport_ptr);
6708bb27
AG		 3249 if (!initiator_str) {
3250 pr_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate"
c66ac9db 3251 " initiator_str from Transport ID\n");
de103c93 3252 ret = TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 3253 goto out;
3254 }
3255
4949314c 3256 transport_kunmap_data_sg(cmd);
05d1c7c0
AG		 3257 buf = NULL;
3258
6708bb27 3259 pr_debug("SPC-3 PR [%s] Extracted initiator %s identifier: %s"
c66ac9db
NB		 3260 " %s\n", dest_tf_ops->get_fabric_name(), (iport_ptr != NULL) ?
3261 "port" : "device", initiator_str, (iport_ptr != NULL) ?
3262 iport_ptr : "");
3263 /*
3264 * If a PERSISTENT RESERVE OUT command with a REGISTER AND MOVE service
3265 * action specifies a TransportID that is the same as the initiator port
3266 * of the I_T nexus for the command received, then the command shall
3267 * be terminated with CHECK CONDITION status, with the sense key set to
3268 * ILLEGAL REQUEST, and the additional sense code set to INVALID FIELD
3269 * IN PARAMETER LIST.
3270 */
3271 pr_reg_nacl = pr_reg->pr_reg_nacl;
3272 matching_iname = (!strcmp(initiator_str,
3273 pr_reg_nacl->initiatorname)) ? 1 : 0;
6708bb27 3274 if (!matching_iname)
c66ac9db
NB		 3275 goto after_iport_check;
3276
6708bb27
AG		 3277 if (!iport_ptr || !pr_reg->isid_present_at_reg) {
3278 pr_err("SPC-3 PR REGISTER_AND_MOVE: TransportID: %s"
c66ac9db
NB		 3279 " matches: %s on received I_T Nexus\n", initiator_str,
3280 pr_reg_nacl->initiatorname);
de103c93 3281 ret = TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 3282 goto out;
3283 }
6708bb27
AG		 3284 if (!strcmp(iport_ptr, pr_reg->pr_reg_isid)) {
3285 pr_err("SPC-3 PR REGISTER_AND_MOVE: TransportID: %s %s"
c66ac9db
NB		 3286 " matches: %s %s on received I_T Nexus\n",
3287 initiator_str, iport_ptr, pr_reg_nacl->initiatorname,
3288 pr_reg->pr_reg_isid);
de103c93 3289 ret = TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 3290 goto out;
3291 }
3292after_iport_check:
3293 /*
3294 * Locate the destination struct se_node_acl from the received Transport ID
3295 */
28638887 3296 spin_lock_irq(&dest_se_tpg->acl_node_lock);
c66ac9db
NB		 3297 dest_node_acl = __core_tpg_get_initiator_node_acl(dest_se_tpg,
3298 initiator_str);
33940d09
JE		 3299 if (dest_node_acl)
3300 atomic_inc_mb(&dest_node_acl->acl_pr_ref_count);
28638887 3301 spin_unlock_irq(&dest_se_tpg->acl_node_lock);
c66ac9db 3302
6708bb27
AG		 3303 if (!dest_node_acl) {
3304 pr_err("Unable to locate %s dest_node_acl for"
c66ac9db
NB		 3305 " TransportID%s\n", dest_tf_ops->get_fabric_name(),
3306 initiator_str);
de103c93 3307 ret = TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 3308 goto out;
3309 }
de103c93
CH		 3310
3311 if (core_scsi3_nodeacl_depend_item(dest_node_acl)) {
6708bb27 3312 pr_err("core_scsi3_nodeacl_depend_item() for"
c66ac9db 3313 " dest_node_acl\n");
33940d09 3314 atomic_dec_mb(&dest_node_acl->acl_pr_ref_count);
c66ac9db 3315 dest_node_acl = NULL;
de103c93 3316 ret = TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 3317 goto out;
3318 }
8b1e1244 3319
6708bb27 3320 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Found %s dest_node_acl:"
c66ac9db
NB		 3321 " %s from TransportID\n", dest_tf_ops->get_fabric_name(),
3322 dest_node_acl->initiatorname);
8b1e1244 3323
c66ac9db
NB		 3324 /*
3325 * Locate the struct se_dev_entry pointer for the matching RELATIVE TARGET
3326 * PORT IDENTIFIER.
3327 */
3328 dest_se_deve = core_get_se_deve_from_rtpi(dest_node_acl, rtpi);
6708bb27
AG		 3329 if (!dest_se_deve) {
3330 pr_err("Unable to locate %s dest_se_deve from RTPI:"
c66ac9db 3331 " %hu\n", dest_tf_ops->get_fabric_name(), rtpi);
de103c93 3332 ret = TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 3333 goto out;
3334 }
3335
de103c93 3336 if (core_scsi3_lunacl_depend_item(dest_se_deve)) {
6708bb27 3337 pr_err("core_scsi3_lunacl_depend_item() failed\n");
33940d09 3338 atomic_dec_mb(&dest_se_deve->pr_ref_count);
c66ac9db 3339 dest_se_deve = NULL;
de103c93 3340 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 3341 goto out;
3342 }
8b1e1244 3343
6708bb27 3344 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Located %s node %s LUN"
c66ac9db
NB		 3345 " ACL for dest_se_deve->mapped_lun: %u\n",
3346 dest_tf_ops->get_fabric_name(), dest_node_acl->initiatorname,
3347 dest_se_deve->mapped_lun);
8b1e1244 3348
c66ac9db
NB		 3349 /*
3350 * A persistent reservation needs to already existing in order to
3351 * successfully complete the REGISTER_AND_MOVE service action..
3352 */
3353 spin_lock(&dev->dev_reservation_lock);
3354 pr_res_holder = dev->dev_pr_res_holder;
6708bb27
AG		 3355 if (!pr_res_holder) {
3356 pr_warn("SPC-3 PR REGISTER_AND_MOVE: No reservation"
c66ac9db
NB		 3357 " currently held\n");
3358 spin_unlock(&dev->dev_reservation_lock);
de103c93 3359 ret = TCM_INVALID_CDB_FIELD;
c66ac9db
NB		 3360 goto out;
3361 }
3362 /*
3363 * The received on I_T Nexus must be the reservation holder.
3364 *
3365 * From spc4r17 section 5.7.8 Table 50 --
3366 * Register behaviors for a REGISTER AND MOVE service action
3367 */
e673dc92 3368 if (!is_reservation_holder(pr_res_holder, pr_reg)) {
6708bb27 3369 pr_warn("SPC-3 PR REGISTER_AND_MOVE: Calling I_T"
c66ac9db
NB		 3370 " Nexus is not reservation holder\n");
3371 spin_unlock(&dev->dev_reservation_lock);
de103c93 3372 ret = TCM_RESERVATION_CONFLICT;
c66ac9db
NB		 3373 goto out;
3374 }
3375 /*
3376 * From spc4r17 section 5.7.8: registering and moving reservation
3377 *
3378 * If a PERSISTENT RESERVE OUT command with a REGISTER AND MOVE service
3379 * action is received and the established persistent reservation is a
3380 * Write Exclusive - All Registrants type or Exclusive Access -
3381 * All Registrants type reservation, then the command shall be completed
3382 * with RESERVATION CONFLICT status.
3383 */
3384 if ((pr_res_holder->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) ||
3385 (pr_res_holder->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) {
6708bb27 3386 pr_warn("SPC-3 PR REGISTER_AND_MOVE: Unable to move"
c66ac9db
NB		 3387 " reservation for type: %s\n",
3388 core_scsi3_pr_dump_type(pr_res_holder->pr_res_type));
3389 spin_unlock(&dev->dev_reservation_lock);
de103c93 3390 ret = TCM_RESERVATION_CONFLICT;
c66ac9db
NB		 3391 goto out;
3392 }
3393 pr_res_nacl = pr_res_holder->pr_reg_nacl;
3394 /*
3395 * b) Ignore the contents of the (received) SCOPE and TYPE fields;
3396 */
3397 type = pr_res_holder->pr_res_type;
3398 scope = pr_res_holder->pr_res_type;
3399 /*
3400 * c) Associate the reservation key specified in the SERVICE ACTION
3401 * RESERVATION KEY field with the I_T nexus specified as the
3402 * destination of the register and move, where:
3403 * A) The I_T nexus is specified by the TransportID and the
3404 * RELATIVE TARGET PORT IDENTIFIER field (see 6.14.4); and
3405 * B) Regardless of the TransportID format used, the association for
3406 * the initiator port is based on either the initiator port name
3407 * (see 3.1.71) on SCSI transport protocols where port names are
3408 * required or the initiator port identifier (see 3.1.70) on SCSI
3409 * transport protocols where port names are not required;
3410 * d) Register the reservation key specified in the SERVICE ACTION
3411 * RESERVATION KEY field;
3412 * e) Retain the reservation key specified in the SERVICE ACTION
3413 * RESERVATION KEY field and associated information;
3414 *
3415 * Also, It is not an error for a REGISTER AND MOVE service action to
3416 * register an I_T nexus that is already registered with the same
3417 * reservation key or a different reservation key.
3418 */
3419 dest_pr_reg = __core_scsi3_locate_pr_reg(dev, dest_node_acl,
3420 iport_ptr);
6708bb27 3421 if (!dest_pr_reg) {
de103c93 3422 if (core_scsi3_alloc_registration(cmd->se_dev,
c66ac9db 3423 dest_node_acl, dest_se_deve, iport_ptr,
de103c93 3424 sa_res_key, 0, aptpl, 2, 1)) {
c66ac9db 3425 spin_unlock(&dev->dev_reservation_lock);
de103c93 3426 ret = TCM_INVALID_PARAMETER_LIST;
c66ac9db
NB		 3427 goto out;
3428 }
3429 dest_pr_reg = __core_scsi3_locate_pr_reg(dev, dest_node_acl,
3430 iport_ptr);
3431 new_reg = 1;
3432 }
3433 /*
3434 * f) Release the persistent reservation for the persistent reservation
3435 * holder (i.e., the I_T nexus on which the
3436 */
3437 __core_scsi3_complete_pro_release(dev, pr_res_nacl,
6c3c9baa 3438 dev->dev_pr_res_holder, 0, 0);
c66ac9db
NB		 3439 /*
3440 * g) Move the persistent reservation to the specified I_T nexus using
3441 * the same scope and type as the persistent reservation released in
3442 * item f); and
3443 */
3444 dev->dev_pr_res_holder = dest_pr_reg;
3445 dest_pr_reg->pr_res_holder = 1;
3446 dest_pr_reg->pr_res_type = type;
3447 pr_reg->pr_res_scope = scope;
d2843c17 3448 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
c66ac9db
NB		 3449 /*
3450 * Increment PRGeneration for existing registrations..
3451 */
6708bb27 3452 if (!new_reg)
c66ac9db
NB		 3453 dest_pr_reg->pr_res_generation = pr_tmpl->pr_generation++;
3454 spin_unlock(&dev->dev_reservation_lock);
3455
6708bb27 3456 pr_debug("SPC-3 PR [%s] Service Action: REGISTER_AND_MOVE"
c66ac9db
NB		 3457 " created new reservation holder TYPE: %s on object RTPI:"
3458 " %hu PRGeneration: 0x%08x\n", dest_tf_ops->get_fabric_name(),
3459 core_scsi3_pr_dump_type(type), rtpi,
3460 dest_pr_reg->pr_res_generation);
6708bb27 3461 pr_debug("SPC-3 PR Successfully moved reservation from"
c66ac9db
NB		 3462 " %s Fabric Node: %s%s -> %s Fabric Node: %s %s\n",
3463 tf_ops->get_fabric_name(), pr_reg_nacl->initiatorname,
d2843c17 3464 i_buf, dest_tf_ops->get_fabric_name(),
c66ac9db
NB		 3465 dest_node_acl->initiatorname, (iport_ptr != NULL) ?
3466 iport_ptr : "");
3467 /*
3468 * It is now safe to release configfs group dependencies for destination
3469 * of Transport ID Initiator Device/Port Identifier
3470 */
3471 core_scsi3_lunacl_undepend_item(dest_se_deve);
3472 core_scsi3_nodeacl_undepend_item(dest_node_acl);
3473 core_scsi3_tpg_undepend_item(dest_se_tpg);
3474 /*
3475 * h) If the UNREG bit is set to one, unregister (see 5.7.11.3) the I_T
3476 * nexus on which PERSISTENT RESERVE OUT command was received.
3477 */
3478 if (unreg) {
3479 spin_lock(&pr_tmpl->registration_lock);
3480 __core_scsi3_free_registration(dev, pr_reg, NULL, 1);
3481 spin_unlock(&pr_tmpl->registration_lock);
3482 } else
3483 core_scsi3_put_pr_reg(pr_reg);
3484
459f213b 3485 core_scsi3_update_and_write_aptpl(cmd->se_dev, aptpl);
c66ac9db 3486
4949314c 3487 transport_kunmap_data_sg(cmd);
05d1c7c0 3488
c66ac9db
NB		 3489 core_scsi3_put_pr_reg(dest_pr_reg);
3490 return 0;
3491out:
05d1c7c0 3492 if (buf)
4949314c 3493 transport_kunmap_data_sg(cmd);
c66ac9db
NB		 3494 if (dest_se_deve)
3495 core_scsi3_lunacl_undepend_item(dest_se_deve);
3496 if (dest_node_acl)
3497 core_scsi3_nodeacl_undepend_item(dest_node_acl);
3498 core_scsi3_tpg_undepend_item(dest_se_tpg);
de103c93
CH		 3499
3500out_put_pr_reg:
c66ac9db
NB		 3501 core_scsi3_put_pr_reg(pr_reg);
3502 return ret;
3503}
3504
3505static unsigned long long core_scsi3_extract_reservation_key(unsigned char *cdb)
3506{
3507 unsigned int __v1, __v2;
3508
3509 __v1 = (cdb[0] << 24) | (cdb[1] << 16) | (cdb[2] << 8) | cdb[3];
3510 __v2 = (cdb[4] << 24) | (cdb[5] << 16) | (cdb[6] << 8) | cdb[7];
3511
3512 return ((unsigned long long)__v2) | (unsigned long long)__v1 << 32;
3513}
3514
3515/*
3516 * See spc4r17 section 6.14 Table 170
3517 */
de103c93
CH		 3518sense_reason_t
3519target_scsi3_emulate_pr_out(struct se_cmd *cmd)
c66ac9db 3520{
92404e60 3521 struct se_device *dev = cmd->se_dev;
617c0e06 3522 unsigned char *cdb = &cmd->t_task_cdb[0];
05d1c7c0 3523 unsigned char *buf;
c66ac9db
NB		 3524 u64 res_key, sa_res_key;
3525 int sa, scope, type, aptpl;
3526 int spec_i_pt = 0, all_tg_pt = 0, unreg = 0;
de103c93 3527 sense_reason_t ret;
617c0e06
CH		 3528
3529 /*
3530 * Following spc2r20 5.5.1 Reservations overview:
3531 *
3532 * If a logical unit has been reserved by any RESERVE command and is
3533 * still reserved by any initiator, all PERSISTENT RESERVE IN and all
3534 * PERSISTENT RESERVE OUT commands shall conflict regardless of
3535 * initiator or service action and shall terminate with a RESERVATION
3536 * CONFLICT status.
3537 */
0fd97ccf 3538 if (cmd->se_dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) {
617c0e06
CH		 3539 pr_err("Received PERSISTENT_RESERVE CDB while legacy"
3540 " SPC-2 reservation is held, returning"
3541 " RESERVATION_CONFLICT\n");
de103c93 3542 return TCM_RESERVATION_CONFLICT;
617c0e06
CH		 3543 }
3544
c66ac9db
NB		 3545 /*
3546 * FIXME: A NULL struct se_session pointer means an this is not coming from
3547 * a $FABRIC_MOD's nexus, but from internal passthrough ops.
3548 */
de103c93
CH		 3549 if (!cmd->se_sess)
3550 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
c66ac9db
NB		 3551
3552 if (cmd->data_length < 24) {
6708bb27 3553 pr_warn("SPC-PR: Received PR OUT parameter list"
c66ac9db 3554 " length too small: %u\n", cmd->data_length);
de103c93 3555 return TCM_INVALID_PARAMETER_LIST;
c66ac9db 3556 }
de103c93 3557
c66ac9db
NB		 3558 /*
3559 * From the PERSISTENT_RESERVE_OUT command descriptor block (CDB)
3560 */
3561 sa = (cdb[1] & 0x1f);
3562 scope = (cdb[2] & 0xf0);
3563 type = (cdb[2] & 0x0f);
05d1c7c0 3564
4949314c 3565 buf = transport_kmap_data_sg(cmd);
de103c93
CH		 3566 if (!buf)
3567 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
3568
c66ac9db
NB		 3569 /*
3570 * From PERSISTENT_RESERVE_OUT parameter list (payload)
3571 */
3572 res_key = core_scsi3_extract_reservation_key(&buf[0]);
3573 sa_res_key = core_scsi3_extract_reservation_key(&buf[8]);
3574 /*
3575 * REGISTER_AND_MOVE uses a different SA parameter list containing
3576 * SCSI TransportIDs.
3577 */
3578 if (sa != PRO_REGISTER_AND_MOVE) {
3579 spec_i_pt = (buf[20] & 0x08);
3580 all_tg_pt = (buf[20] & 0x04);
3581 aptpl = (buf[20] & 0x01);
3582 } else {
3583 aptpl = (buf[17] & 0x01);
3584 unreg = (buf[17] & 0x02);
3585 }
92404e60
NB		 3586 /*
3587 * If the backend device has been configured to force APTPL metadata
3588 * write-out, go ahead and propigate aptpl=1 down now.
3589 */
3590 if (dev->dev_attrib.force_pr_aptpl)
3591 aptpl = 1;
3592
4949314c 3593 transport_kunmap_data_sg(cmd);
05d1c7c0
AG		 3594 buf = NULL;
3595
c66ac9db
NB		 3596 /*
3597 * SPEC_I_PT=1 is only valid for Service action: REGISTER
3598 */
de103c93
CH		 3599 if (spec_i_pt && ((cdb[1] & 0x1f) != PRO_REGISTER))
3600 return TCM_INVALID_PARAMETER_LIST;
d29a5b6a 3601
c66ac9db
NB		 3602 /*
3603 * From spc4r17 section 6.14:
3604 *
3605 * If the SPEC_I_PT bit is set to zero, the service action is not
3606 * REGISTER AND MOVE, and the parameter list length is not 24, then
3607 * the command shall be terminated with CHECK CONDITION status, with
3608 * the sense key set to ILLEGAL REQUEST, and the additional sense
3609 * code set to PARAMETER LIST LENGTH ERROR.
3610 */
6708bb27 3611 if (!spec_i_pt && ((cdb[1] & 0x1f) != PRO_REGISTER_AND_MOVE) &&
c66ac9db 3612 (cmd->data_length != 24)) {
6708bb27 3613 pr_warn("SPC-PR: Received PR OUT illegal parameter"
c66ac9db 3614 " list length: %u\n", cmd->data_length);
de103c93 3615 return TCM_INVALID_PARAMETER_LIST;
c66ac9db 3616 }
de103c93 3617
c66ac9db
NB		 3618 /*
3619 * (core_scsi3_emulate_pro_* function parameters
3620 * are defined by spc4r17 Table 174:
3621 * PERSISTENT_RESERVE_OUT service actions and valid parameters.
3622 */
3623 switch (sa) {
3624 case PRO_REGISTER:
d29a5b6a 3625 ret = core_scsi3_emulate_pro_register(cmd,
33ce6a87 3626 res_key, sa_res_key, aptpl, all_tg_pt, spec_i_pt, REGISTER);
d29a5b6a 3627 break;
c66ac9db 3628 case PRO_RESERVE:
d29a5b6a
CH		 3629 ret = core_scsi3_emulate_pro_reserve(cmd, type, scope, res_key);
3630 break;
c66ac9db 3631 case PRO_RELEASE:
d29a5b6a
CH		 3632 ret = core_scsi3_emulate_pro_release(cmd, type, scope, res_key);
3633 break;
c66ac9db 3634 case PRO_CLEAR:
d29a5b6a
CH		 3635 ret = core_scsi3_emulate_pro_clear(cmd, res_key);
3636 break;
c66ac9db 3637 case PRO_PREEMPT:
d29a5b6a 3638 ret = core_scsi3_emulate_pro_preempt(cmd, type, scope,
33ce6a87 3639 res_key, sa_res_key, PREEMPT);
d29a5b6a 3640 break;
c66ac9db 3641 case PRO_PREEMPT_AND_ABORT:
d29a5b6a 3642 ret = core_scsi3_emulate_pro_preempt(cmd, type, scope,
33ce6a87 3643 res_key, sa_res_key, PREEMPT_AND_ABORT);
d29a5b6a 3644 break;
c66ac9db 3645 case PRO_REGISTER_AND_IGNORE_EXISTING_KEY:
d29a5b6a 3646 ret = core_scsi3_emulate_pro_register(cmd,
33ce6a87 3647 0, sa_res_key, aptpl, all_tg_pt, spec_i_pt, REGISTER_AND_IGNORE_EXISTING_KEY);
d29a5b6a 3648 break;
c66ac9db 3649 case PRO_REGISTER_AND_MOVE:
d29a5b6a 3650 ret = core_scsi3_emulate_pro_register_and_move(cmd, res_key,
c66ac9db 3651 sa_res_key, aptpl, unreg);
d29a5b6a 3652 break;
c66ac9db 3653 default:
6708bb27 3654 pr_err("Unknown PERSISTENT_RESERVE_OUT service"
c66ac9db 3655 " action: 0x%02x\n", cdb[1] & 0x1f);
de103c93 3656 return TCM_INVALID_CDB_FIELD;
c66ac9db
NB		 3657 }
3658
6bb35e00
CH		 3659 if (!ret)
3660 target_complete_cmd(cmd, GOOD);
d29a5b6a 3661 return ret;
c66ac9db
NB		 3662}
3663
3664/*
3665 * PERSISTENT_RESERVE_IN Service Action READ_KEYS
3666 *
3667 * See spc4r17 section 5.7.6.2 and section 6.13.2, Table 160
3668 */
de103c93
CH		 3669static sense_reason_t
3670core_scsi3_pri_read_keys(struct se_cmd *cmd)
c66ac9db 3671{
0fd97ccf 3672 struct se_device *dev = cmd->se_dev;
c66ac9db 3673 struct t10_pr_registration *pr_reg;
05d1c7c0 3674 unsigned char *buf;
c66ac9db
NB		 3675 u32 add_len = 0, off = 8;
3676
3677 if (cmd->data_length < 8) {
6708bb27 3678 pr_err("PRIN SA READ_KEYS SCSI Data Length: %u"
c66ac9db 3679 " too small\n", cmd->data_length);
de103c93 3680 return TCM_INVALID_CDB_FIELD;
c66ac9db
NB		 3681 }
3682
4949314c 3683 buf = transport_kmap_data_sg(cmd);
de103c93
CH		 3684 if (!buf)
3685 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
3686
0fd97ccf
CH		 3687 buf[0] = ((dev->t10_pr.pr_generation >> 24) & 0xff);
3688 buf[1] = ((dev->t10_pr.pr_generation >> 16) & 0xff);
3689 buf[2] = ((dev->t10_pr.pr_generation >> 8) & 0xff);
3690 buf[3] = (dev->t10_pr.pr_generation & 0xff);
c66ac9db 3691
0fd97ccf
CH		 3692 spin_lock(&dev->t10_pr.registration_lock);
3693 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list,
c66ac9db
NB		 3694 pr_reg_list) {
3695 /*
3696 * Check for overflow of 8byte PRI READ_KEYS payload and
3697 * next reservation key list descriptor.
3698 */
3699 if ((add_len + 8) > (cmd->data_length - 8))
3700 break;
3701
3702 buf[off++] = ((pr_reg->pr_res_key >> 56) & 0xff);
3703 buf[off++] = ((pr_reg->pr_res_key >> 48) & 0xff);
3704 buf[off++] = ((pr_reg->pr_res_key >> 40) & 0xff);
3705 buf[off++] = ((pr_reg->pr_res_key >> 32) & 0xff);
3706 buf[off++] = ((pr_reg->pr_res_key >> 24) & 0xff);
3707 buf[off++] = ((pr_reg->pr_res_key >> 16) & 0xff);
3708 buf[off++] = ((pr_reg->pr_res_key >> 8) & 0xff);
3709 buf[off++] = (pr_reg->pr_res_key & 0xff);
3710
3711 add_len += 8;
3712 }
0fd97ccf 3713 spin_unlock(&dev->t10_pr.registration_lock);
c66ac9db
NB		 3714
3715 buf[4] = ((add_len >> 24) & 0xff);
3716 buf[5] = ((add_len >> 16) & 0xff);
3717 buf[6] = ((add_len >> 8) & 0xff);
3718 buf[7] = (add_len & 0xff);
3719
4949314c 3720 transport_kunmap_data_sg(cmd);
05d1c7c0 3721
c66ac9db
NB		 3722 return 0;
3723}
3724
3725/*
3726 * PERSISTENT_RESERVE_IN Service Action READ_RESERVATION
3727 *
3728 * See spc4r17 section 5.7.6.3 and section 6.13.3.2 Table 161 and 162
3729 */
de103c93
CH		 3730static sense_reason_t
3731core_scsi3_pri_read_reservation(struct se_cmd *cmd)
c66ac9db 3732{
0fd97ccf 3733 struct se_device *dev = cmd->se_dev;
c66ac9db 3734 struct t10_pr_registration *pr_reg;
05d1c7c0 3735 unsigned char *buf;
c66ac9db
NB		 3736 u64 pr_res_key;
3737 u32 add_len = 16; /* Hardcoded to 16 when a reservation is held. */
3738
3739 if (cmd->data_length < 8) {
6708bb27 3740 pr_err("PRIN SA READ_RESERVATIONS SCSI Data Length: %u"
c66ac9db 3741 " too small\n", cmd->data_length);
de103c93 3742 return TCM_INVALID_CDB_FIELD;
c66ac9db
NB		 3743 }
3744
4949314c 3745 buf = transport_kmap_data_sg(cmd);
de103c93
CH		 3746 if (!buf)
3747 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
3748
0fd97ccf
CH		 3749 buf[0] = ((dev->t10_pr.pr_generation >> 24) & 0xff);
3750 buf[1] = ((dev->t10_pr.pr_generation >> 16) & 0xff);
3751 buf[2] = ((dev->t10_pr.pr_generation >> 8) & 0xff);
3752 buf[3] = (dev->t10_pr.pr_generation & 0xff);
c66ac9db 3753
0fd97ccf
CH		 3754 spin_lock(&dev->dev_reservation_lock);
3755 pr_reg = dev->dev_pr_res_holder;
ee1b1b9c 3756 if (pr_reg) {
c66ac9db
NB		 3757 /*
3758 * Set the hardcoded Additional Length
3759 */
3760 buf[4] = ((add_len >> 24) & 0xff);
3761 buf[5] = ((add_len >> 16) & 0xff);
3762 buf[6] = ((add_len >> 8) & 0xff);
3763 buf[7] = (add_len & 0xff);
3764
05d1c7c0
AG		 3765 if (cmd->data_length < 22)
3766 goto err;
3767
c66ac9db
NB		 3768 /*
3769 * Set the Reservation key.
3770 *
3771 * From spc4r17, section 5.7.10:
3772 * A persistent reservation holder has its reservation key
3773 * returned in the parameter data from a PERSISTENT
3774 * RESERVE IN command with READ RESERVATION service action as
3775 * follows:
3776 * a) For a persistent reservation of the type Write Exclusive
3777 * - All Registrants or Exclusive Access ­ All Regitrants,
3778 * the reservation key shall be set to zero; or
3779 * b) For all other persistent reservation types, the
3780 * reservation key shall be set to the registered
3781 * reservation key for the I_T nexus that holds the
3782 * persistent reservation.
3783 */
3784 if ((pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) ||
3785 (pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG))
3786 pr_res_key = 0;
3787 else
3788 pr_res_key = pr_reg->pr_res_key;
3789
3790 buf[8] = ((pr_res_key >> 56) & 0xff);
3791 buf[9] = ((pr_res_key >> 48) & 0xff);
3792 buf[10] = ((pr_res_key >> 40) & 0xff);
3793 buf[11] = ((pr_res_key >> 32) & 0xff);
3794 buf[12] = ((pr_res_key >> 24) & 0xff);
3795 buf[13] = ((pr_res_key >> 16) & 0xff);
3796 buf[14] = ((pr_res_key >> 8) & 0xff);
3797 buf[15] = (pr_res_key & 0xff);
3798 /*
3799 * Set the SCOPE and TYPE
3800 */
3801 buf[21] = (pr_reg->pr_res_scope & 0xf0) |
3802 (pr_reg->pr_res_type & 0x0f);
3803 }
05d1c7c0
AG		 3804
3805err:
0fd97ccf 3806 spin_unlock(&dev->dev_reservation_lock);
4949314c 3807 transport_kunmap_data_sg(cmd);
c66ac9db
NB		 3808
3809 return 0;
3810}
3811
3812/*
3813 * PERSISTENT_RESERVE_IN Service Action REPORT_CAPABILITIES
3814 *
3815 * See spc4r17 section 6.13.4 Table 165
3816 */
de103c93
CH		 3817static sense_reason_t
3818core_scsi3_pri_report_capabilities(struct se_cmd *cmd)
c66ac9db 3819{
5951146d 3820 struct se_device *dev = cmd->se_dev;
0fd97ccf 3821 struct t10_reservation *pr_tmpl = &dev->t10_pr;
05d1c7c0 3822 unsigned char *buf;
c66ac9db
NB		 3823 u16 add_len = 8; /* Hardcoded to 8. */
3824
3825 if (cmd->data_length < 6) {
6708bb27 3826 pr_err("PRIN SA REPORT_CAPABILITIES SCSI Data Length:"
c66ac9db 3827 " %u too small\n", cmd->data_length);
de103c93 3828 return TCM_INVALID_CDB_FIELD;
c66ac9db
NB		 3829 }
3830
4949314c 3831 buf = transport_kmap_data_sg(cmd);
de103c93
CH		 3832 if (!buf)
3833 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
05d1c7c0 3834
c435285d 3835 buf[0] = ((add_len >> 8) & 0xff);
c66ac9db
NB		 3836 buf[1] = (add_len & 0xff);
3837 buf[2] |= 0x10; /* CRH: Compatible Reservation Hanlding bit. */
3838 buf[2] |= 0x08; /* SIP_C: Specify Initiator Ports Capable bit */
3839 buf[2] |= 0x04; /* ATP_C: All Target Ports Capable bit */
3840 buf[2] |= 0x01; /* PTPL_C: Persistence across Target Power Loss bit */
3841 /*
3842 * We are filling in the PERSISTENT RESERVATION TYPE MASK below, so
3843 * set the TMV: Task Mask Valid bit.
3844 */
3845 buf[3] |= 0x80;
3846 /*
3847 * Change ALLOW COMMANDs to 0x20 or 0x40 later from Table 166
3848 */
3849 buf[3] |= 0x10; /* ALLOW COMMANDs field 001b */
3850 /*
3851 * PTPL_A: Persistence across Target Power Loss Active bit
3852 */
3853 if (pr_tmpl->pr_aptpl_active)
3854 buf[3] |= 0x01;
3855 /*
3856 * Setup the PERSISTENT RESERVATION TYPE MASK from Table 167
3857 */
3858 buf[4] |= 0x80; /* PR_TYPE_EXCLUSIVE_ACCESS_ALLREG */
3859 buf[4] |= 0x40; /* PR_TYPE_EXCLUSIVE_ACCESS_REGONLY */
3860 buf[4] |= 0x20; /* PR_TYPE_WRITE_EXCLUSIVE_REGONLY */
3861 buf[4] |= 0x08; /* PR_TYPE_EXCLUSIVE_ACCESS */
3862 buf[4] |= 0x02; /* PR_TYPE_WRITE_EXCLUSIVE */
3863 buf[5] |= 0x01; /* PR_TYPE_EXCLUSIVE_ACCESS_ALLREG */
3864
4949314c 3865 transport_kunmap_data_sg(cmd);
05d1c7c0 3866
c66ac9db
NB		 3867 return 0;
3868}
3869
3870/*
3871 * PERSISTENT_RESERVE_IN Service Action READ_FULL_STATUS
3872 *
3873 * See spc4r17 section 6.13.5 Table 168 and 169
3874 */
de103c93
CH		 3875static sense_reason_t
3876core_scsi3_pri_read_full_status(struct se_cmd *cmd)
c66ac9db 3877{
0fd97ccf 3878 struct se_device *dev = cmd->se_dev;
c66ac9db 3879 struct se_node_acl *se_nacl;
c66ac9db
NB		 3880 struct se_portal_group *se_tpg;
3881 struct t10_pr_registration *pr_reg, *pr_reg_tmp;
0fd97ccf 3882 struct t10_reservation *pr_tmpl = &dev->t10_pr;
05d1c7c0 3883 unsigned char *buf;
c66ac9db
NB		 3884 u32 add_desc_len = 0, add_len = 0, desc_len, exp_desc_len;
3885 u32 off = 8; /* off into first Full Status descriptor */
d16ca7c5
NB		 3886 int format_code = 0, pr_res_type = 0, pr_res_scope = 0;
3887 bool all_reg = false;
c66ac9db
NB		 3888
3889 if (cmd->data_length < 8) {
6708bb27 3890 pr_err("PRIN SA READ_FULL_STATUS SCSI Data Length: %u"
c66ac9db 3891 " too small\n", cmd->data_length);
de103c93 3892 return TCM_INVALID_CDB_FIELD;
c66ac9db
NB		 3893 }
3894
4949314c 3895 buf = transport_kmap_data_sg(cmd);
de103c93
CH		 3896 if (!buf)
3897 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
05d1c7c0 3898
0fd97ccf
CH		 3899 buf[0] = ((dev->t10_pr.pr_generation >> 24) & 0xff);
3900 buf[1] = ((dev->t10_pr.pr_generation >> 16) & 0xff);
3901 buf[2] = ((dev->t10_pr.pr_generation >> 8) & 0xff);
3902 buf[3] = (dev->t10_pr.pr_generation & 0xff);
c66ac9db 3903
d16ca7c5
NB		 3904 spin_lock(&dev->dev_reservation_lock);
3905 if (dev->dev_pr_res_holder) {
3906 struct t10_pr_registration *pr_holder = dev->dev_pr_res_holder;
3907
3908 if (pr_holder->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG ||
3909 pr_holder->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG) {
3910 all_reg = true;
3911 pr_res_type = pr_holder->pr_res_type;
3912 pr_res_scope = pr_holder->pr_res_scope;
3913 }
3914 }
3915 spin_unlock(&dev->dev_reservation_lock);
3916
c66ac9db
NB		 3917 spin_lock(&pr_tmpl->registration_lock);
3918 list_for_each_entry_safe(pr_reg, pr_reg_tmp,
3919 &pr_tmpl->registration_list, pr_reg_list) {
3920
3921 se_nacl = pr_reg->pr_reg_nacl;
3922 se_tpg = pr_reg->pr_reg_nacl->se_tpg;
3923 add_desc_len = 0;
3924
33940d09 3925 atomic_inc_mb(&pr_reg->pr_res_holders);
c66ac9db
NB		 3926 spin_unlock(&pr_tmpl->registration_lock);
3927 /*
3928 * Determine expected length of $FABRIC_MOD specific
3929 * TransportID full status descriptor..
3930 */
e3d6f909 3931 exp_desc_len = se_tpg->se_tpg_tfo->tpg_get_pr_transport_id_len(
c66ac9db
NB		 3932 se_tpg, se_nacl, pr_reg, &format_code);
3933
3934 if ((exp_desc_len + add_len) > cmd->data_length) {
6708bb27 3935 pr_warn("SPC-3 PRIN READ_FULL_STATUS ran"
c66ac9db
NB		 3936 " out of buffer: %d\n", cmd->data_length);
3937 spin_lock(&pr_tmpl->registration_lock);
33940d09 3938 atomic_dec_mb(&pr_reg->pr_res_holders);
c66ac9db
NB		 3939 break;
3940 }
3941 /*
3942 * Set RESERVATION KEY
3943 */
3944 buf[off++] = ((pr_reg->pr_res_key >> 56) & 0xff);
3945 buf[off++] = ((pr_reg->pr_res_key >> 48) & 0xff);
3946 buf[off++] = ((pr_reg->pr_res_key >> 40) & 0xff);
3947 buf[off++] = ((pr_reg->pr_res_key >> 32) & 0xff);
3948 buf[off++] = ((pr_reg->pr_res_key >> 24) & 0xff);
3949 buf[off++] = ((pr_reg->pr_res_key >> 16) & 0xff);
3950 buf[off++] = ((pr_reg->pr_res_key >> 8) & 0xff);
3951 buf[off++] = (pr_reg->pr_res_key & 0xff);
3952 off += 4; /* Skip Over Reserved area */
3953
3954 /*
3955 * Set ALL_TG_PT bit if PROUT SA REGISTER had this set.
3956 */
3957 if (pr_reg->pr_reg_all_tg_pt)
3958 buf[off] = 0x02;
3959 /*
3960 * The struct se_lun pointer will be present for the
3961 * reservation holder for PR_HOLDER bit.
3962 *
3963 * Also, if this registration is the reservation
d16ca7c5
NB		 3964 * holder or there is an All Registrants reservation
3965 * active, fill in SCOPE and TYPE in the next byte.
c66ac9db
NB		 3966 */
3967 if (pr_reg->pr_res_holder) {
3968 buf[off++] |= 0x01;
3969 buf[off++] = (pr_reg->pr_res_scope & 0xf0) |
3970 (pr_reg->pr_res_type & 0x0f);
d16ca7c5
NB		 3971 } else if (all_reg) {
3972 buf[off++] |= 0x01;
3973 buf[off++] = (pr_res_scope & 0xf0) |
3974 (pr_res_type & 0x0f);
3975 } else {
c66ac9db 3976 off += 2;
d16ca7c5 3977 }
c66ac9db
NB		 3978
3979 off += 4; /* Skip over reserved area */
3980 /*
3981 * From spc4r17 6.3.15:
3982 *
3983 * If the ALL_TG_PT bit set to zero, the RELATIVE TARGET PORT
3984 * IDENTIFIER field contains the relative port identifier (see
3985 * 3.1.120) of the target port that is part of the I_T nexus
3986 * described by this full status descriptor. If the ALL_TG_PT
3987 * bit is set to one, the contents of the RELATIVE TARGET PORT
3988 * IDENTIFIER field are not defined by this standard.
3989 */
6708bb27 3990 if (!pr_reg->pr_reg_all_tg_pt) {
c66ac9db
NB		 3991 struct se_port *port = pr_reg->pr_reg_tg_pt_lun->lun_sep;
3992
3993 buf[off++] = ((port->sep_rtpi >> 8) & 0xff);
3994 buf[off++] = (port->sep_rtpi & 0xff);
3995 } else
35d1efe8 3996 off += 2; /* Skip over RELATIVE TARGET PORT IDENTIFIER */
c66ac9db
NB		 3997
3998 /*
3999 * Now, have the $FABRIC_MOD fill in the protocol identifier
4000 */
e3d6f909 4001 desc_len = se_tpg->se_tpg_tfo->tpg_get_pr_transport_id(se_tpg,
c66ac9db
NB		 4002 se_nacl, pr_reg, &format_code, &buf[off+4]);
4003
4004 spin_lock(&pr_tmpl->registration_lock);
33940d09 4005 atomic_dec_mb(&pr_reg->pr_res_holders);
c66ac9db
NB		 4006 /*
4007 * Set the ADDITIONAL DESCRIPTOR LENGTH
4008 */
4009 buf[off++] = ((desc_len >> 24) & 0xff);
4010 buf[off++] = ((desc_len >> 16) & 0xff);
4011 buf[off++] = ((desc_len >> 8) & 0xff);
4012 buf[off++] = (desc_len & 0xff);
4013 /*
4014 * Size of full desctipor header minus TransportID
4015 * containing $FABRIC_MOD specific) initiator device/port
4016 * WWN information.
4017 *
4018 * See spc4r17 Section 6.13.5 Table 169
4019 */
4020 add_desc_len = (24 + desc_len);
4021
4022 off += desc_len;
4023 add_len += add_desc_len;
4024 }
4025 spin_unlock(&pr_tmpl->registration_lock);
4026 /*
4027 * Set ADDITIONAL_LENGTH
4028 */
4029 buf[4] = ((add_len >> 24) & 0xff);
4030 buf[5] = ((add_len >> 16) & 0xff);
4031 buf[6] = ((add_len >> 8) & 0xff);
4032 buf[7] = (add_len & 0xff);
4033
4949314c 4034 transport_kunmap_data_sg(cmd);
05d1c7c0 4035
c66ac9db
NB		 4036 return 0;
4037}
4038
de103c93
CH		 4039sense_reason_t
4040target_scsi3_emulate_pr_in(struct se_cmd *cmd)
c66ac9db 4041{
de103c93 4042 sense_reason_t ret;
e76a35d6 4043
c66ac9db
NB		 4044 /*
4045 * Following spc2r20 5.5.1 Reservations overview:
4046 *
4047 * If a logical unit has been reserved by any RESERVE command and is
4048 * still reserved by any initiator, all PERSISTENT RESERVE IN and all
4049 * PERSISTENT RESERVE OUT commands shall conflict regardless of
4050 * initiator or service action and shall terminate with a RESERVATION
4051 * CONFLICT status.
4052 */
0fd97ccf 4053 if (cmd->se_dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) {
6708bb27 4054 pr_err("Received PERSISTENT_RESERVE CDB while legacy"
c66ac9db
NB		 4055 " SPC-2 reservation is held, returning"
4056 " RESERVATION_CONFLICT\n");
de103c93 4057 return TCM_RESERVATION_CONFLICT;
c66ac9db
NB		 4058 }
4059
617c0e06
CH		 4060 switch (cmd->t_task_cdb[1] & 0x1f) {
4061 case PRI_READ_KEYS:
d29a5b6a
CH		 4062 ret = core_scsi3_pri_read_keys(cmd);
4063 break;
617c0e06 4064 case PRI_READ_RESERVATION:
d29a5b6a
CH		 4065 ret = core_scsi3_pri_read_reservation(cmd);
4066 break;
617c0e06 4067 case PRI_REPORT_CAPABILITIES:
d29a5b6a
CH		 4068 ret = core_scsi3_pri_report_capabilities(cmd);
4069 break;
617c0e06 4070 case PRI_READ_FULL_STATUS:
d29a5b6a
CH		 4071 ret = core_scsi3_pri_read_full_status(cmd);
4072 break;
617c0e06
CH		 4073 default:
4074 pr_err("Unknown PERSISTENT_RESERVE_IN service"
4075 " action: 0x%02x\n", cmd->t_task_cdb[1] & 0x1f);
de103c93 4076 return TCM_INVALID_CDB_FIELD;
d29a5b6a
CH		 4077 }
4078
6bb35e00
CH		 4079 if (!ret)
4080 target_complete_cmd(cmd, GOOD);
d29a5b6a 4081 return ret;
c66ac9db
NB		 4082}
4083
de103c93
CH		 4084sense_reason_t
4085target_check_reservation(struct se_cmd *cmd)
c66ac9db 4086{
d977f437 4087 struct se_device *dev = cmd->se_dev;
de103c93 4088 sense_reason_t ret;
c66ac9db 4089
d977f437
CH		 4090 if (!cmd->se_sess)
4091 return 0;
4092 if (dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)
4093 return 0;
a3541703 4094 if (dev->transport->transport_flags & TRANSPORT_FLAG_PASSTHROUGH)
d977f437 4095 return 0;
c66ac9db 4096
d977f437
CH		 4097 spin_lock(&dev->dev_reservation_lock);
4098 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
4099 ret = target_scsi2_reservation_check(cmd);
4100 else
4101 ret = target_scsi3_pr_reservation_check(cmd);
4102 spin_unlock(&dev->dev_reservation_lock);
0fd97ccf 4103
d977f437 4104 return ret;
c66ac9db 4105}
Linux 6.x block layer and io_uring tree(s)