target_core_device.c 48.1 KB
Newer Older
1 2 3
/*******************************************************************************
 * Filename:  target_core_device.c (based on iscsi_target_device.c)
 *
4
 * This file contains the TCM Virtual Device and Disk Transport
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
 * agnostic related functions.
 *
 * Copyright (c) 2003, 2004, 2005 PyX Technologies, Inc.
 * Copyright (c) 2005-2006 SBE, Inc.  All Rights Reserved.
 * Copyright (c) 2007-2010 Rising Tide Systems
 * Copyright (c) 2008-2010 Linux-iSCSI.org
 *
 * Nicholas A. Bellinger <nab@kernel.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 ******************************************************************************/

#include <linux/net.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/kthread.h>
#include <linux/in.h>
#include <net/sock.h>
#include <net/tcp.h>
#include <scsi/scsi.h>
41
#include <scsi/scsi_device.h>
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

#include <target/target_core_base.h>
#include <target/target_core_device.h>
#include <target/target_core_tpg.h>
#include <target/target_core_transport.h>
#include <target/target_core_fabric_ops.h>

#include "target_core_alua.h"
#include "target_core_hba.h"
#include "target_core_pr.h"
#include "target_core_ua.h"

static void se_dev_start(struct se_device *dev);
static void se_dev_stop(struct se_device *dev);

57 58 59 60 61
static struct se_hba *lun0_hba;
static struct se_subsystem_dev *lun0_su_dev;
/* not static, needed by tpg.c */
struct se_device *g_lun0_dev;

62
int transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
63 64
{
	struct se_lun *se_lun = NULL;
65
	struct se_session *se_sess = se_cmd->se_sess;
66
	struct se_device *dev;
67 68
	unsigned long flags;

69 70 71
	if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG) {
		se_cmd->scsi_sense_reason = TCM_NON_EXISTENT_LUN;
		se_cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
72
		return -ENODEV;
73 74
	}

75
	spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
76 77 78 79 80 81 82 83 84 85 86
	se_cmd->se_deve = &se_sess->se_node_acl->device_list[unpacked_lun];
	if (se_cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
		struct se_dev_entry *deve = se_cmd->se_deve;

		deve->total_cmds++;
		deve->total_bytes += se_cmd->data_length;

		if ((se_cmd->data_direction == DMA_TO_DEVICE) &&
		    (deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)) {
			se_cmd->scsi_sense_reason = TCM_WRITE_PROTECTED;
			se_cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
87
			pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN"
88 89 90
				" Access for 0x%08x\n",
				se_cmd->se_tfo->get_fabric_name(),
				unpacked_lun);
91
			spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
92
			return -EACCES;
93
		}
94 95 96 97 98 99

		if (se_cmd->data_direction == DMA_TO_DEVICE)
			deve->write_bytes += se_cmd->data_length;
		else if (se_cmd->data_direction == DMA_FROM_DEVICE)
			deve->read_bytes += se_cmd->data_length;

100 101
		deve->deve_cmds++;

102 103
		se_lun = deve->se_lun;
		se_cmd->se_lun = deve->se_lun;
104 105
		se_cmd->pr_res_key = deve->pr_res_key;
		se_cmd->orig_fe_lun = unpacked_lun;
106
		se_cmd->se_orig_obj_ptr = se_cmd->se_lun->lun_se_dev;
107 108
		se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
	}
109
	spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
110 111

	if (!se_lun) {
112 113 114 115 116 117 118
		/*
		 * Use the se_portal_group->tpg_virt_lun0 to allow for
		 * REPORT_LUNS, et al to be returned when no active
		 * MappedLUN=0 exists for this Initiator Port.
		 */
		if (unpacked_lun != 0) {
			se_cmd->scsi_sense_reason = TCM_NON_EXISTENT_LUN;
119
			se_cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
120
			pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
121
				" Access for 0x%08x\n",
122
				se_cmd->se_tfo->get_fabric_name(),
123
				unpacked_lun);
124 125 126 127 128 129 130 131 132
			return -ENODEV;
		}
		/*
		 * Force WRITE PROTECT for virtual LUN 0
		 */
		if ((se_cmd->data_direction != DMA_FROM_DEVICE) &&
		    (se_cmd->data_direction != DMA_NONE)) {
			se_cmd->scsi_sense_reason = TCM_WRITE_PROTECTED;
			se_cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
133
			return -EACCES;
134
		}
135 136 137 138 139 140

		se_lun = &se_sess->se_tpg->tpg_virt_lun0;
		se_cmd->se_lun = &se_sess->se_tpg->tpg_virt_lun0;
		se_cmd->orig_fe_lun = 0;
		se_cmd->se_orig_obj_ptr = se_cmd->se_lun->lun_se_dev;
		se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
141 142 143
	}
	/*
	 * Determine if the struct se_lun is online.
144
	 * FIXME: Check for LUN_RESET + UNIT Attention
145 146 147 148
	 */
	if (se_dev_check_online(se_lun->lun_se_dev) != 0) {
		se_cmd->scsi_sense_reason = TCM_NON_EXISTENT_LUN;
		se_cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
149
		return -ENODEV;
150 151
	}

152 153 154 155 156
	/* Directly associate cmd with se_dev */
	se_cmd->se_dev = se_lun->lun_se_dev;

	/* TODO: get rid of this and use atomics for stats */
	dev = se_lun->lun_se_dev;
157
	spin_lock_irqsave(&dev->stats_lock, flags);
158 159 160 161 162
	dev->num_cmds++;
	if (se_cmd->data_direction == DMA_TO_DEVICE)
		dev->write_bytes += se_cmd->data_length;
	else if (se_cmd->data_direction == DMA_FROM_DEVICE)
		dev->read_bytes += se_cmd->data_length;
163
	spin_unlock_irqrestore(&dev->stats_lock, flags);
164 165 166 167 168 169

	/*
	 * Add the iscsi_cmd_t to the struct se_lun's cmd list.  This list is used
	 * for tracking state of struct se_cmds during LUN shutdown events.
	 */
	spin_lock_irqsave(&se_lun->lun_cmd_lock, flags);
170
	list_add_tail(&se_cmd->se_lun_node, &se_lun->lun_cmd_list);
171
	atomic_set(&se_cmd->transport_lun_active, 1);
172 173 174 175
	spin_unlock_irqrestore(&se_lun->lun_cmd_lock, flags);

	return 0;
}
176
EXPORT_SYMBOL(transport_lookup_cmd_lun);
177

178
int transport_lookup_tmr_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
179 180 181
{
	struct se_dev_entry *deve;
	struct se_lun *se_lun = NULL;
182
	struct se_session *se_sess = se_cmd->se_sess;
183
	struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;
184
	unsigned long flags;
185

186 187 188
	if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG) {
		se_cmd->scsi_sense_reason = TCM_NON_EXISTENT_LUN;
		se_cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
189
		return -ENODEV;
190 191
	}

192
	spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
193 194 195
	se_cmd->se_deve = &se_sess->se_node_acl->device_list[unpacked_lun];
	deve = se_cmd->se_deve;

196
	if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
197 198 199
		se_tmr->tmr_lun = deve->se_lun;
		se_cmd->se_lun = deve->se_lun;
		se_lun = deve->se_lun;
200 201
		se_cmd->pr_res_key = deve->pr_res_key;
		se_cmd->orig_fe_lun = unpacked_lun;
202
		se_cmd->se_orig_obj_ptr = se_cmd->se_dev;
203
	}
204
	spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
205 206

	if (!se_lun) {
207
		pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
208
			" Access for 0x%08x\n",
209
			se_cmd->se_tfo->get_fabric_name(),
210 211
			unpacked_lun);
		se_cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
212
		return -ENODEV;
213 214 215
	}
	/*
	 * Determine if the struct se_lun is online.
216
	 * FIXME: Check for LUN_RESET + UNIT Attention
217 218 219
	 */
	if (se_dev_check_online(se_lun->lun_se_dev) != 0) {
		se_cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
220
		return -ENODEV;
221 222
	}

223 224 225 226
	/* Directly associate cmd with se_dev */
	se_cmd->se_dev = se_lun->lun_se_dev;
	se_tmr->tmr_dev = se_lun->lun_se_dev;

227
	spin_lock_irqsave(&se_tmr->tmr_dev->se_tmr_lock, flags);
228
	list_add_tail(&se_tmr->tmr_list, &se_tmr->tmr_dev->dev_tmr_list);
229
	spin_unlock_irqrestore(&se_tmr->tmr_dev->se_tmr_lock, flags);
230 231 232

	return 0;
}
233
EXPORT_SYMBOL(transport_lookup_tmr_lun);
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257

/*
 * This function is called from core_scsi3_emulate_pro_register_and_move()
 * and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_ref_count
 * when a matching rtpi is found.
 */
struct se_dev_entry *core_get_se_deve_from_rtpi(
	struct se_node_acl *nacl,
	u16 rtpi)
{
	struct se_dev_entry *deve;
	struct se_lun *lun;
	struct se_port *port;
	struct se_portal_group *tpg = nacl->se_tpg;
	u32 i;

	spin_lock_irq(&nacl->device_list_lock);
	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
		deve = &nacl->device_list[i];

		if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
			continue;

		lun = deve->se_lun;
258 259
		if (!lun) {
			pr_err("%s device entries device pointer is"
260
				" NULL, but Initiator has access.\n",
261
				tpg->se_tpg_tfo->get_fabric_name());
262 263 264
			continue;
		}
		port = lun->lun_sep;
265 266
		if (!port) {
			pr_err("%s device entries device pointer is"
267
				" NULL, but Initiator has access.\n",
268
				tpg->se_tpg_tfo->get_fabric_name());
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
			continue;
		}
		if (port->sep_rtpi != rtpi)
			continue;

		atomic_inc(&deve->pr_ref_count);
		smp_mb__after_atomic_inc();
		spin_unlock_irq(&nacl->device_list_lock);

		return deve;
	}
	spin_unlock_irq(&nacl->device_list_lock);

	return NULL;
}

int core_free_device_list_for_node(
	struct se_node_acl *nacl,
	struct se_portal_group *tpg)
{
	struct se_dev_entry *deve;
	struct se_lun *lun;
	u32 i;

	if (!nacl->device_list)
		return 0;

	spin_lock_irq(&nacl->device_list_lock);
	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
		deve = &nacl->device_list[i];

		if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
			continue;

		if (!deve->se_lun) {
304
			pr_err("%s device entries device pointer is"
305
				" NULL, but Initiator has access.\n",
306
				tpg->se_tpg_tfo->get_fabric_name());
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
			continue;
		}
		lun = deve->se_lun;

		spin_unlock_irq(&nacl->device_list_lock);
		core_update_device_list_for_node(lun, NULL, deve->mapped_lun,
			TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg, 0);
		spin_lock_irq(&nacl->device_list_lock);
	}
	spin_unlock_irq(&nacl->device_list_lock);

	kfree(nacl->device_list);
	nacl->device_list = NULL;

	return 0;
}

void core_dec_lacl_count(struct se_node_acl *se_nacl, struct se_cmd *se_cmd)
{
	struct se_dev_entry *deve;

	spin_lock_irq(&se_nacl->device_list_lock);
	deve = &se_nacl->device_list[se_cmd->orig_fe_lun];
	deve->deve_cmds--;
	spin_unlock_irq(&se_nacl->device_list_lock);
}

void core_update_device_list_access(
	u32 mapped_lun,
	u32 lun_access,
	struct se_node_acl *nacl)
{
	struct se_dev_entry *deve;

	spin_lock_irq(&nacl->device_list_lock);
	deve = &nacl->device_list[mapped_lun];
	if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
		deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
		deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
	} else {
		deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
		deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
	}
	spin_unlock_irq(&nacl->device_list_lock);
}

/*      core_update_device_list_for_node():
 *
 *
 */
int core_update_device_list_for_node(
	struct se_lun *lun,
	struct se_lun_acl *lun_acl,
	u32 mapped_lun,
	u32 lun_access,
	struct se_node_acl *nacl,
	struct se_portal_group *tpg,
	int enable)
{
	struct se_port *port = lun->lun_sep;
	struct se_dev_entry *deve = &nacl->device_list[mapped_lun];
	int trans = 0;
	/*
	 * If the MappedLUN entry is being disabled, the entry in
	 * port->sep_alua_list must be removed now before clearing the
	 * struct se_dev_entry pointers below as logic in
	 * core_alua_do_transition_tg_pt() depends on these being present.
	 */
375
	if (!enable) {
376 377
		/*
		 * deve->se_lun_acl will be NULL for demo-mode created LUNs
Lucas De Marchi's avatar
Lucas De Marchi committed
378
		 * that have not been explicitly concerted to MappedLUNs ->
379 380 381 382
		 * struct se_lun_acl, but we remove deve->alua_port_list from
		 * port->sep_alua_list. This also means that active UAs and
		 * NodeACL context specific PR metadata for demo-mode
		 * MappedLUN *deve will be released below..
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
		 */
		spin_lock_bh(&port->sep_alua_lock);
		list_del(&deve->alua_port_list);
		spin_unlock_bh(&port->sep_alua_lock);
	}

	spin_lock_irq(&nacl->device_list_lock);
	if (enable) {
		/*
		 * Check if the call is handling demo mode -> explict LUN ACL
		 * transition.  This transition must be for the same struct se_lun
		 * + mapped_lun that was setup in demo mode..
		 */
		if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
			if (deve->se_lun_acl != NULL) {
398
				pr_err("struct se_dev_entry->se_lun_acl"
399 400
					" already set for demo mode -> explict"
					" LUN ACL transition\n");
401
				spin_unlock_irq(&nacl->device_list_lock);
402
				return -EINVAL;
403 404
			}
			if (deve->se_lun != lun) {
405
				pr_err("struct se_dev_entry->se_lun does"
406 407
					" match passed struct se_lun for demo mode"
					" -> explict LUN ACL transition\n");
408
				spin_unlock_irq(&nacl->device_list_lock);
409
				return -EINVAL;
410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
			}
			deve->se_lun_acl = lun_acl;
			trans = 1;
		} else {
			deve->se_lun = lun;
			deve->se_lun_acl = lun_acl;
			deve->mapped_lun = mapped_lun;
			deve->lun_flags |= TRANSPORT_LUNFLAGS_INITIATOR_ACCESS;
		}

		if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
			deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
			deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;
		} else {
			deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
			deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;
		}

		if (trans) {
			spin_unlock_irq(&nacl->device_list_lock);
			return 0;
		}
		deve->creation_time = get_jiffies_64();
		deve->attach_count++;
		spin_unlock_irq(&nacl->device_list_lock);

		spin_lock_bh(&port->sep_alua_lock);
		list_add_tail(&deve->alua_port_list, &port->sep_alua_list);
		spin_unlock_bh(&port->sep_alua_lock);

		return 0;
	}
	/*
	 * Wait for any in process SPEC_I_PT=1 or REGISTER_AND_MOVE
	 * PR operation to complete.
	 */
	spin_unlock_irq(&nacl->device_list_lock);
	while (atomic_read(&deve->pr_ref_count) != 0)
		cpu_relax();
	spin_lock_irq(&nacl->device_list_lock);
	/*
	 * Disable struct se_dev_entry LUN ACL mapping
	 */
	core_scsi3_ua_release_all(deve);
	deve->se_lun = NULL;
	deve->se_lun_acl = NULL;
	deve->lun_flags = 0;
	deve->creation_time = 0;
	deve->attach_count--;
	spin_unlock_irq(&nacl->device_list_lock);

	core_scsi3_free_pr_reg_from_nacl(lun->lun_se_dev, nacl);
	return 0;
}

/*      core_clear_lun_from_tpg():
 *
 *
 */
void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)
{
	struct se_node_acl *nacl;
	struct se_dev_entry *deve;
	u32 i;

475
	spin_lock_irq(&tpg->acl_node_lock);
476
	list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {
477
		spin_unlock_irq(&tpg->acl_node_lock);
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493

		spin_lock_irq(&nacl->device_list_lock);
		for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
			deve = &nacl->device_list[i];
			if (lun != deve->se_lun)
				continue;
			spin_unlock_irq(&nacl->device_list_lock);

			core_update_device_list_for_node(lun, NULL,
				deve->mapped_lun, TRANSPORT_LUNFLAGS_NO_ACCESS,
				nacl, tpg, 0);

			spin_lock_irq(&nacl->device_list_lock);
		}
		spin_unlock_irq(&nacl->device_list_lock);

494
		spin_lock_irq(&tpg->acl_node_lock);
495
	}
496
	spin_unlock_irq(&tpg->acl_node_lock);
497 498 499 500 501 502 503
}

static struct se_port *core_alloc_port(struct se_device *dev)
{
	struct se_port *port, *port_tmp;

	port = kzalloc(sizeof(struct se_port), GFP_KERNEL);
504 505
	if (!port) {
		pr_err("Unable to allocate struct se_port\n");
506
		return ERR_PTR(-ENOMEM);
507 508 509 510 511 512 513 514 515
	}
	INIT_LIST_HEAD(&port->sep_alua_list);
	INIT_LIST_HEAD(&port->sep_list);
	atomic_set(&port->sep_tg_pt_secondary_offline, 0);
	spin_lock_init(&port->sep_alua_lock);
	mutex_init(&port->sep_tg_pt_md_mutex);

	spin_lock(&dev->se_port_lock);
	if (dev->dev_port_count == 0x0000ffff) {
516
		pr_warn("Reached dev->dev_port_count =="
517 518
				" 0x0000ffff\n");
		spin_unlock(&dev->se_port_lock);
519
		return ERR_PTR(-ENOSPC);
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
	}
again:
	/*
	 * Allocate the next RELATIVE TARGET PORT IDENTIFER for this struct se_device
	 * Here is the table from spc4r17 section 7.7.3.8.
	 *
	 *    Table 473 -- RELATIVE TARGET PORT IDENTIFIER field
	 *
	 * Code      Description
	 * 0h        Reserved
	 * 1h        Relative port 1, historically known as port A
	 * 2h        Relative port 2, historically known as port B
	 * 3h to FFFFh    Relative port 3 through 65 535
	 */
	port->sep_rtpi = dev->dev_rpti_counter++;
535
	if (!port->sep_rtpi)
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
		goto again;

	list_for_each_entry(port_tmp, &dev->dev_sep_list, sep_list) {
		/*
		 * Make sure RELATIVE TARGET PORT IDENTIFER is unique
		 * for 16-bit wrap..
		 */
		if (port->sep_rtpi == port_tmp->sep_rtpi)
			goto again;
	}
	spin_unlock(&dev->se_port_lock);

	return port;
}

static void core_export_port(
	struct se_device *dev,
	struct se_portal_group *tpg,
	struct se_port *port,
	struct se_lun *lun)
{
557
	struct se_subsystem_dev *su_dev = dev->se_sub_dev;
558 559 560 561 562 563 564 565 566 567 568 569
	struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem = NULL;

	spin_lock(&dev->se_port_lock);
	spin_lock(&lun->lun_sep_lock);
	port->sep_tpg = tpg;
	port->sep_lun = lun;
	lun->lun_sep = port;
	spin_unlock(&lun->lun_sep_lock);

	list_add_tail(&port->sep_list, &dev->dev_sep_list);
	spin_unlock(&dev->se_port_lock);

570
	if (su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
571 572
		tg_pt_gp_mem = core_alua_allocate_tg_pt_gp_mem(port);
		if (IS_ERR(tg_pt_gp_mem) || !tg_pt_gp_mem) {
573
			pr_err("Unable to allocate t10_alua_tg_pt"
574 575 576 577 578
					"_gp_member_t\n");
			return;
		}
		spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
		__core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,
579
			su_dev->t10_alua.default_tg_pt_gp);
580
		spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
581
		pr_debug("%s/%s: Adding to default ALUA Target Port"
582
			" Group: alua/default_tg_pt_gp\n",
583
			dev->transport->name, tpg->se_tpg_tfo->get_fabric_name());
584 585 586 587 588 589 590 591 592 593
	}

	dev->dev_port_count++;
	port->sep_index = port->sep_rtpi; /* RELATIVE TARGET PORT IDENTIFER */
}

/*
 *	Called with struct se_device->se_port_lock spinlock held.
 */
static void core_release_port(struct se_device *dev, struct se_port *port)
594
	__releases(&dev->se_port_lock) __acquires(&dev->se_port_lock)
595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
{
	/*
	 * Wait for any port reference for PR ALL_TG_PT=1 operation
	 * to complete in __core_scsi3_alloc_registration()
	 */
	spin_unlock(&dev->se_port_lock);
	if (atomic_read(&port->sep_tg_pt_ref_cnt))
		cpu_relax();
	spin_lock(&dev->se_port_lock);

	core_alua_free_tg_pt_gp_mem(port);

	list_del(&port->sep_list);
	dev->dev_port_count--;
	kfree(port);
}

int core_dev_export(
	struct se_device *dev,
	struct se_portal_group *tpg,
	struct se_lun *lun)
{
	struct se_port *port;

	port = core_alloc_port(dev);
620 621
	if (IS_ERR(port))
		return PTR_ERR(port);
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657

	lun->lun_se_dev = dev;
	se_dev_start(dev);

	atomic_inc(&dev->dev_export_obj.obj_access_count);
	core_export_port(dev, tpg, port, lun);
	return 0;
}

void core_dev_unexport(
	struct se_device *dev,
	struct se_portal_group *tpg,
	struct se_lun *lun)
{
	struct se_port *port = lun->lun_sep;

	spin_lock(&lun->lun_sep_lock);
	if (lun->lun_se_dev == NULL) {
		spin_unlock(&lun->lun_sep_lock);
		return;
	}
	spin_unlock(&lun->lun_sep_lock);

	spin_lock(&dev->se_port_lock);
	atomic_dec(&dev->dev_export_obj.obj_access_count);
	core_release_port(dev, port);
	spin_unlock(&dev->se_port_lock);

	se_dev_stop(dev);
	lun->lun_se_dev = NULL;
}

int transport_core_report_lun_response(struct se_cmd *se_cmd)
{
	struct se_dev_entry *deve;
	struct se_lun *se_lun;
658
	struct se_session *se_sess = se_cmd->se_sess;
659
	struct se_task *se_task;
660
	unsigned char *buf;
661
	u32 cdb_offset = 0, lun_count = 0, offset = 8, i;
662

663
	list_for_each_entry(se_task, &se_cmd->t_task_list, t_list)
664 665
		break;

666 667
	if (!se_task) {
		pr_err("Unable to locate struct se_task for struct se_cmd\n");
668 669 670
		return PYX_TRANSPORT_LU_COMM_FAILURE;
	}

671 672
	buf = transport_kmap_first_data_page(se_cmd);

673 674 675 676 677
	/*
	 * If no struct se_session pointer is present, this struct se_cmd is
	 * coming via a target_core_mod PASSTHROUGH op, and not through
	 * a $FABRIC_MOD.  In that case, report LUN=0 only.
	 */
678
	if (!se_sess) {
679
		int_to_scsilun(0, (struct scsi_lun *)&buf[offset]);
680 681 682 683
		lun_count = 1;
		goto done;
	}

684
	spin_lock_irq(&se_sess->se_node_acl->device_list_lock);
685
	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
686
		deve = &se_sess->se_node_acl->device_list[i];
687 688 689 690 691 692 693 694 695 696 697 698
		if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
			continue;
		se_lun = deve->se_lun;
		/*
		 * We determine the correct LUN LIST LENGTH even once we
		 * have reached the initial allocation length.
		 * See SPC2-R20 7.19.
		 */
		lun_count++;
		if ((cdb_offset + 8) >= se_cmd->data_length)
			continue;

699 700
		int_to_scsilun(deve->mapped_lun, (struct scsi_lun *)&buf[offset]);
		offset += 8;
701 702
		cdb_offset += 8;
	}
703
	spin_unlock_irq(&se_sess->se_node_acl->device_list_lock);
704 705 706 707 708

	/*
	 * See SPC3 r07, page 159.
	 */
done:
709
	transport_kunmap_first_data_page(se_cmd);
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
	lun_count *= 8;
	buf[0] = ((lun_count >> 24) & 0xff);
	buf[1] = ((lun_count >> 16) & 0xff);
	buf[2] = ((lun_count >> 8) & 0xff);
	buf[3] = (lun_count & 0xff);

	return PYX_TRANSPORT_SENT_TO_TRANSPORT;
}

/*	se_release_device_for_hba():
 *
 *
 */
void se_release_device_for_hba(struct se_device *dev)
{
	struct se_hba *hba = dev->se_hba;

	if ((dev->dev_status & TRANSPORT_DEVICE_ACTIVATED) ||
	    (dev->dev_status & TRANSPORT_DEVICE_DEACTIVATED) ||
	    (dev->dev_status & TRANSPORT_DEVICE_SHUTDOWN) ||
	    (dev->dev_status & TRANSPORT_DEVICE_OFFLINE_ACTIVATED) ||
	    (dev->dev_status & TRANSPORT_DEVICE_OFFLINE_DEACTIVATED))
		se_dev_stop(dev);

	if (dev->dev_ptr) {
		kthread_stop(dev->process_thread);
		if (dev->transport->free_device)
			dev->transport->free_device(dev->dev_ptr);
	}

	spin_lock(&hba->device_lock);
	list_del(&dev->dev_list);
	hba->dev_count--;
	spin_unlock(&hba->device_lock);

	core_scsi3_free_all_registrations(dev);
	se_release_vpd_for_dev(dev);

	kfree(dev);
}

void se_release_vpd_for_dev(struct se_device *dev)
{
	struct t10_vpd *vpd, *vpd_tmp;

755
	spin_lock(&dev->se_sub_dev->t10_wwn.t10_vpd_lock);
756
	list_for_each_entry_safe(vpd, vpd_tmp,
757
			&dev->se_sub_dev->t10_wwn.t10_vpd_list, vpd_list) {
758 759 760
		list_del(&vpd->vpd_list);
		kfree(vpd);
	}
761
	spin_unlock(&dev->se_sub_dev->t10_wwn.t10_vpd_lock);
762 763 764 765 766 767 768 769
}

/*	se_free_virtual_device():
 *
 *	Used for IBLOCK, RAMDISK, and FILEIO Transport Drivers.
 */
int se_free_virtual_device(struct se_device *dev, struct se_hba *hba)
{
770 771
	if (!list_empty(&dev->dev_sep_list))
		dump_stack();
772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819

	core_alua_free_lu_gp_mem(dev);
	se_release_device_for_hba(dev);

	return 0;
}

static void se_dev_start(struct se_device *dev)
{
	struct se_hba *hba = dev->se_hba;

	spin_lock(&hba->device_lock);
	atomic_inc(&dev->dev_obj.obj_access_count);
	if (atomic_read(&dev->dev_obj.obj_access_count) == 1) {
		if (dev->dev_status & TRANSPORT_DEVICE_DEACTIVATED) {
			dev->dev_status &= ~TRANSPORT_DEVICE_DEACTIVATED;
			dev->dev_status |= TRANSPORT_DEVICE_ACTIVATED;
		} else if (dev->dev_status &
			   TRANSPORT_DEVICE_OFFLINE_DEACTIVATED) {
			dev->dev_status &=
				~TRANSPORT_DEVICE_OFFLINE_DEACTIVATED;
			dev->dev_status |= TRANSPORT_DEVICE_OFFLINE_ACTIVATED;
		}
	}
	spin_unlock(&hba->device_lock);
}

static void se_dev_stop(struct se_device *dev)
{
	struct se_hba *hba = dev->se_hba;

	spin_lock(&hba->device_lock);
	atomic_dec(&dev->dev_obj.obj_access_count);
	if (atomic_read(&dev->dev_obj.obj_access_count) == 0) {
		if (dev->dev_status & TRANSPORT_DEVICE_ACTIVATED) {
			dev->dev_status &= ~TRANSPORT_DEVICE_ACTIVATED;
			dev->dev_status |= TRANSPORT_DEVICE_DEACTIVATED;
		} else if (dev->dev_status &
			   TRANSPORT_DEVICE_OFFLINE_ACTIVATED) {
			dev->dev_status &= ~TRANSPORT_DEVICE_OFFLINE_ACTIVATED;
			dev->dev_status |= TRANSPORT_DEVICE_OFFLINE_DEACTIVATED;
		}
	}
	spin_unlock(&hba->device_lock);
}

int se_dev_check_online(struct se_device *dev)
{
820
	unsigned long flags;
821 822
	int ret;

823
	spin_lock_irqsave(&dev->dev_status_lock, flags);
824 825
	ret = ((dev->dev_status & TRANSPORT_DEVICE_ACTIVATED) ||
	       (dev->dev_status & TRANSPORT_DEVICE_DEACTIVATED)) ? 0 : 1;
826
	spin_unlock_irqrestore(&dev->dev_status_lock, flags);
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841

	return ret;
}

int se_dev_check_shutdown(struct se_device *dev)
{
	int ret;

	spin_lock_irq(&dev->dev_status_lock);
	ret = (dev->dev_status & TRANSPORT_DEVICE_SHUTDOWN);
	spin_unlock_irq(&dev->dev_status_lock);

	return ret;
}

842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859
u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
{
	u32 tmp, aligned_max_sectors;
	/*
	 * Limit max_sectors to a PAGE_SIZE aligned value for modern
	 * transport_allocate_data_tasks() operation.
	 */
	tmp = rounddown((max_sectors * block_size), PAGE_SIZE);
	aligned_max_sectors = (tmp / block_size);
	if (max_sectors != aligned_max_sectors) {
		printk(KERN_INFO "Rounding down aligned max_sectors from %u"
				" to %u\n", max_sectors, aligned_max_sectors);
		return aligned_max_sectors;
	}

	return max_sectors;
}

860 861 862 863 864 865
void se_dev_set_default_attribs(
	struct se_device *dev,
	struct se_dev_limits *dev_limits)
{
	struct queue_limits *limits = &dev_limits->limits;

866 867 868 869 870 871 872 873 874 875 876
	dev->se_sub_dev->se_dev_attrib.emulate_dpo = DA_EMULATE_DPO;
	dev->se_sub_dev->se_dev_attrib.emulate_fua_write = DA_EMULATE_FUA_WRITE;
	dev->se_sub_dev->se_dev_attrib.emulate_fua_read = DA_EMULATE_FUA_READ;
	dev->se_sub_dev->se_dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE;
	dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl = DA_EMULATE_UA_INTLLCK_CTRL;
	dev->se_sub_dev->se_dev_attrib.emulate_tas = DA_EMULATE_TAS;
	dev->se_sub_dev->se_dev_attrib.emulate_tpu = DA_EMULATE_TPU;
	dev->se_sub_dev->se_dev_attrib.emulate_tpws = DA_EMULATE_TPWS;
	dev->se_sub_dev->se_dev_attrib.emulate_reservations = DA_EMULATE_RESERVATIONS;
	dev->se_sub_dev->se_dev_attrib.emulate_alua = DA_EMULATE_ALUA;
	dev->se_sub_dev->se_dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS;
877
	dev->se_sub_dev->se_dev_attrib.is_nonrot = DA_IS_NONROT;
878
	dev->se_sub_dev->se_dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD;
879 880 881 882 883
	/*
	 * The TPU=1 and TPWS=1 settings will be set in TCM/IBLOCK
	 * iblock_create_virtdevice() from struct queue_limits values
	 * if blk_queue_discard()==1
	 */
884 885 886 887 888
	dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT;
	dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count =
		DA_MAX_UNMAP_BLOCK_DESC_COUNT;
	dev->se_sub_dev->se_dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT;
	dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment =
889 890 891 892
				DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT;
	/*
	 * block_size is based on subsystem plugin dependent requirements.
	 */
893 894
	dev->se_sub_dev->se_dev_attrib.hw_block_size = limits->logical_block_size;
	dev->se_sub_dev->se_dev_attrib.block_size = limits->logical_block_size;
895 896 897
	/*
	 * max_sectors is based on subsystem plugin dependent requirements.
	 */
898
	dev->se_sub_dev->se_dev_attrib.hw_max_sectors = limits->max_hw_sectors;
899 900 901 902 903
	/*
	 * Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
	 */
	limits->max_sectors = se_dev_align_max_sectors(limits->max_sectors,
						limits->logical_block_size);
904
	dev->se_sub_dev->se_dev_attrib.max_sectors = limits->max_sectors;
905 906 907 908
	/*
	 * Set optimal_sectors from max_sectors, which can be lowered via
	 * configfs.
	 */
909
	dev->se_sub_dev->se_dev_attrib.optimal_sectors = limits->max_sectors;
910 911 912
	/*
	 * queue_depth is based on subsystem plugin dependent requirements.
	 */
913 914
	dev->se_sub_dev->se_dev_attrib.hw_queue_depth = dev_limits->hw_queue_depth;
	dev->se_sub_dev->se_dev_attrib.queue_depth = dev_limits->queue_depth;
915 916 917 918 919
}

int se_dev_set_task_timeout(struct se_device *dev, u32 task_timeout)
{
	if (task_timeout > DA_TASK_TIMEOUT_MAX) {
920
		pr_err("dev[%p]: Passed task_timeout: %u larger then"
921
			" DA_TASK_TIMEOUT_MAX\n", dev, task_timeout);
922
		return -EINVAL;
923
	} else {
924
		dev->se_sub_dev->se_dev_attrib.task_timeout = task_timeout;
925
		pr_debug("dev[%p]: Set SE Device task_timeout: %u\n",
926 927 928 929 930 931 932 933 934 935
			dev, task_timeout);
	}

	return 0;
}

int se_dev_set_max_unmap_lba_count(
	struct se_device *dev,
	u32 max_unmap_lba_count)
{
936
	dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count = max_unmap_lba_count;
937
	pr_debug("dev[%p]: Set max_unmap_lba_count: %u\n",
938
			dev, dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count);
939 940 941 942 943 944 945
	return 0;
}

int se_dev_set_max_unmap_block_desc_count(
	struct se_device *dev,
	u32 max_unmap_block_desc_count)
{
946 947
	dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count =
		max_unmap_block_desc_count;
948
	pr_debug("dev[%p]: Set max_unmap_block_desc_count: %u\n",
949
			dev, dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count);
950 951 952 953 954 955 956
	return 0;
}

int se_dev_set_unmap_granularity(
	struct se_device *dev,
	u32 unmap_granularity)
{
957
	dev->se_sub_dev->se_dev_attrib.unmap_granularity = unmap_granularity;
958
	pr_debug("dev[%p]: Set unmap_granularity: %u\n",
959
			dev, dev->se_sub_dev->se_dev_attrib.unmap_granularity);
960 961 962 963 964 965 966
	return 0;
}

int se_dev_set_unmap_granularity_alignment(
	struct se_device *dev,
	u32 unmap_granularity_alignment)
{
967
	dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment = unmap_granularity_alignment;
968
	pr_debug("dev[%p]: Set unmap_granularity_alignment: %u\n",
969
			dev, dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment);
970 971 972 973 974 975
	return 0;
}

int se_dev_set_emulate_dpo(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1)) {
976
		pr_err("Illegal value %d\n", flag);
977
		return -EINVAL;
978
	}
979
	if (dev->transport->dpo_emulated == NULL) {
980
		pr_err("dev->transport->dpo_emulated is NULL\n");
981
		return -EINVAL;
982
	}
983
	if (dev->transport->dpo_emulated(dev) == 0) {
984
		pr_err("dev->transport->dpo_emulated not supported\n");
985
		return -EINVAL;
986
	}
987
	dev->se_sub_dev->se_dev_attrib.emulate_dpo = flag;
988
	pr_debug("dev[%p]: SE Device Page Out (DPO) Emulation"
989
			" bit: %d\n", dev, dev->se_sub_dev->se_dev_attrib.emulate_dpo);
990 991 992 993 994 995
	return 0;
}

int se_dev_set_emulate_fua_write(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1)) {
996
		pr_err("Illegal value %d\n", flag);
997
		return -EINVAL;
998
	}
999
	if (dev->transport->fua_write_emulated == NULL) {
1000
		pr_err("dev->transport->fua_write_emulated is NULL\n");
1001
		return -EINVAL;
1002
	}
1003
	if (dev->transport->fua_write_emulated(dev) == 0) {
1004
		pr_err("dev->transport->fua_write_emulated not supported\n");
1005
		return -EINVAL;
1006
	}
1007
	dev->se_sub_dev->se_dev_attrib.emulate_fua_write = flag;
1008
	pr_debug("dev[%p]: SE Device Forced Unit Access WRITEs: %d\n",
1009
			dev, dev->se_sub_dev->se_dev_attrib.emulate_fua_write);
1010 1011 1012 1013 1014 1015
	return 0;
}

int se_dev_set_emulate_fua_read(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1)) {
1016
		pr_err("Illegal value %d\n", flag);
1017
		return -EINVAL;
1018
	}
1019
	if (dev->transport->fua_read_emulated == NULL) {
1020
		pr_err("dev->transport->fua_read_emulated is NULL\n");
1021
		return -EINVAL;
1022
	}
1023
	if (dev->transport->fua_read_emulated(dev) == 0) {
1024
		pr_err("dev->transport->fua_read_emulated not supported\n");
1025
		return -EINVAL;
1026
	}
1027
	dev->se_sub_dev->se_dev_attrib.emulate_fua_read = flag;
1028
	pr_debug("dev[%p]: SE Device Forced Unit Access READs: %d\n",
1029
			dev, dev->se_sub_dev->se_dev_attrib.emulate_fua_read);
1030 1031 1032 1033 1034 1035
	return 0;
}

int se_dev_set_emulate_write_cache(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1)) {
1036
		pr_err("Illegal value %d\n", flag);
1037
		return -EINVAL;
1038
	}
1039
	if (dev->transport->write_cache_emulated == NULL) {
1040
		pr_err("dev->transport->write_cache_emulated is NULL\n");
1041
		return -EINVAL;
1042
	}
1043
	if (dev->transport->write_cache_emulated(dev) == 0) {
1044
		pr_err("dev->transport->write_cache_emulated not supported\n");
1045
		return -EINVAL;
1046
	}
1047
	dev->se_sub_dev->se_dev_attrib.emulate_write_cache = flag;
1048
	pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
1049
			dev, dev->se_sub_dev->se_dev_attrib.emulate_write_cache);
1050 1051 1052 1053 1054 1055
	return 0;
}

int se_dev_set_emulate_ua_intlck_ctrl(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1) && (flag != 2)) {
1056
		pr_err("Illegal value %d\n", flag);
1057
		return -EINVAL;
1058 1059 1060
	}

	if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1061
		pr_err("dev[%p]: Unable to change SE Device"
1062 1063 1064
			" UA_INTRLCK_CTRL while dev_export_obj: %d count"
			" exists\n", dev,
			atomic_read(&dev->dev_export_obj.obj_access_count));
1065
		return -EINVAL;
1066
	}
1067
	dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl = flag;
1068
	pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",
1069
		dev, dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl);
1070 1071 1072 1073 1074 1075 1076

	return 0;
}

int se_dev_set_emulate_tas(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1)) {
1077
		pr_err("Illegal value %d\n", flag);
1078
		return -EINVAL;
1079 1080 1081
	}

	if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1082
		pr_err("dev[%p]: Unable to change SE Device TAS while"
1083 1084
			" dev_export_obj: %d count exists\n", dev,
			atomic_read(&dev->dev_export_obj.obj_access_count));
1085
		return -EINVAL;
1086
	}
1087
	dev->se_sub_dev->se_dev_attrib.emulate_tas = flag;
1088
	pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",
1089
		dev, (dev->se_sub_dev->se_dev_attrib.emulate_tas) ? "Enabled" : "Disabled");
1090 1091 1092 1093 1094 1095 1096

	return 0;
}

int se_dev_set_emulate_tpu(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1)) {
1097
		pr_err("Illegal value %d\n", flag);
1098
		return -EINVAL;
1099 1100 1101 1102 1103
	}
	/*
	 * We expect this value to be non-zero when generic Block Layer
	 * Discard supported is detected iblock_create_virtdevice().
	 */
1104 1105
	if (!dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count) {
		pr_err("Generic Block Discard not supported\n");
1106 1107 1108
		return -ENOSYS;
	}

1109
	dev->se_sub_dev->se_dev_attrib.emulate_tpu = flag;
1110
	pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",
1111 1112 1113 1114 1115 1116 1117
				dev, flag);
	return 0;
}

int se_dev_set_emulate_tpws(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1)) {
1118
		pr_err("Illegal value %d\n", flag);
1119
		return -EINVAL;
1120 1121 1122 1123 1124
	}
	/*
	 * We expect this value to be non-zero when generic Block Layer
	 * Discard supported is detected iblock_create_virtdevice().
	 */
1125 1126
	if (!dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count) {
		pr_err("Generic Block Discard not supported\n");
1127 1128 1129
		return -ENOSYS;
	}

1130
	dev->se_sub_dev->se_dev_attrib.emulate_tpws = flag;
1131
	pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",
1132 1133 1134 1135 1136 1137 1138
				dev, flag);
	return 0;
}

int se_dev_set_enforce_pr_isids(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1)) {
1139
		pr_err("Illegal value %d\n", flag);
1140
		return -EINVAL;
1141
	}
1142
	dev->se_sub_dev->se_dev_attrib.enforce_pr_isids = flag;
1143
	pr_debug("dev[%p]: SE Device enforce_pr_isids bit: %s\n", dev,
1144
		(dev->se_sub_dev->se_dev_attrib.enforce_pr_isids) ? "Enabled" : "Disabled");
1145 1146 1147
	return 0;
}

1148 1149 1150 1151 1152 1153 1154
int se_dev_set_is_nonrot(struct se_device *dev, int flag)
{
	if ((flag != 0) && (flag != 1)) {
		printk(KERN_ERR "Illegal value %d\n", flag);
		return -EINVAL;
	}
	dev->se_sub_dev->se_dev_attrib.is_nonrot = flag;
1155
	pr_debug("dev[%p]: SE Device is_nonrot bit: %d\n",
1156 1157 1158 1159
	       dev, flag);
	return 0;
}

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
int se_dev_set_emulate_rest_reord(struct se_device *dev, int flag)
{
	if (flag != 0) {
		printk(KERN_ERR "dev[%p]: SE Device emulatation of restricted"
			" reordering not implemented\n", dev);
		return -ENOSYS;
	}
	dev->se_sub_dev->se_dev_attrib.emulate_rest_reord = flag;
	pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n", dev, flag);
	return 0;
}

1172 1173 117