Eric Lee / smarc-ti-linux-kernel

1

/*******************************************************************************

1

/*******************************************************************************

2

* Filename: target_core_device.c (based on iscsi_target_device.c)

2

* Filename: target_core_device.c (based on iscsi_target_device.c)

3

*

3

*

4

* This file contains the TCM Virtual Device and Disk Transport

4

* This file contains the TCM Virtual Device and Disk Transport

5

* agnostic related functions.

5

* agnostic related functions.

6

*

6

*

7

8

*

8

*

9

* Nicholas A. Bellinger <nab@kernel.org>

9

* Nicholas A. Bellinger <nab@kernel.org>

10

*

10

*

11

* This program is free software; you can redistribute it and/or modify

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

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

13

* the Free Software Foundation; either version 2 of the License, or

14

* (at your option) any later version.

14

* (at your option) any later version.

15

*

15

*

16

* This program is distributed in the hope that it will be useful,

16

* This program is distributed in the hope that it will be useful,

17

* but WITHOUT ANY WARRANTY; without even the implied warranty of

17

* but WITHOUT ANY WARRANTY; without even the implied warranty of

18

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

18

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

19

* GNU General Public License for more details.

19

* GNU General Public License for more details.

20

*

20

*

21

* You should have received a copy of the GNU General Public License

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

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.

23

* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

24

*

24

*

25

******************************************************************************/

25

******************************************************************************/

26

27

#include <linux/net.h>

27

#include <linux/net.h>

28

#include <linux/string.h>

28

#include <linux/string.h>

29

#include <linux/delay.h>

29

#include <linux/delay.h>

30

#include <linux/timer.h>

30

#include <linux/timer.h>

31

#include <linux/slab.h>

31

#include <linux/slab.h>

32

#include <linux/spinlock.h>

32

#include <linux/spinlock.h>

33

#include <linux/kthread.h>

33

#include <linux/kthread.h>

34

#include <linux/in.h>

34

#include <linux/in.h>

35

#include <linux/export.h>

35

#include <linux/export.h>

36

#include <net/sock.h>

36

#include <net/sock.h>

37

#include <net/tcp.h>

37

#include <net/tcp.h>

38

#include <scsi/scsi.h>

38

#include <scsi/scsi.h>

39

#include <scsi/scsi_device.h>

39

#include <scsi/scsi_device.h>

40

41

#include <target/target_core_base.h>

41

#include <target/target_core_base.h>

42

#include <target/target_core_backend.h>

42

#include <target/target_core_backend.h>

43

#include <target/target_core_fabric.h>

43

#include <target/target_core_fabric.h>

44

45

#include "target_core_internal.h"

45

#include "target_core_internal.h"

46

#include "target_core_alua.h"

46

#include "target_core_alua.h"

47

#include "target_core_pr.h"

47

#include "target_core_pr.h"

48

#include "target_core_ua.h"

48

#include "target_core_ua.h"

49

50

DEFINE_MUTEX(g_device_mutex);

50

DEFINE_MUTEX(g_device_mutex);

51

LIST_HEAD(g_device_list);

51

LIST_HEAD(g_device_list);

52

53

static struct se_hba *lun0_hba;

53

static struct se_hba *lun0_hba;

54

/* not static, needed by tpg.c */

54

/* not static, needed by tpg.c */

55

struct se_device *g_lun0_dev;

55

struct se_device *g_lun0_dev;

56

57

sense_reason_t

57

sense_reason_t

58

transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)

58

transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)

59

{

59

{

60

struct se_lun *se_lun = NULL;

60

struct se_lun *se_lun = NULL;

61

struct se_session *se_sess = se_cmd->se_sess;

61

struct se_session *se_sess = se_cmd->se_sess;

62

struct se_device *dev;

62

struct se_device *dev;

63

unsigned long flags;

63

unsigned long flags;

64

65

if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)

65

if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)

66

return TCM_NON_EXISTENT_LUN;

66

return TCM_NON_EXISTENT_LUN;

67

68

spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);

68

spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);

69

se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];

69

se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];

70

if (se_cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {

70

if (se_cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {

71

struct se_dev_entry *deve = se_cmd->se_deve;

71

struct se_dev_entry *deve = se_cmd->se_deve;

72

73

deve->total_cmds++;

73

deve->total_cmds++;

74

75

if ((se_cmd->data_direction == DMA_TO_DEVICE) &&

75

if ((se_cmd->data_direction == DMA_TO_DEVICE) &&

76

(deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)) {

76

(deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)) {

77

pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN"

77

pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN"

78

" Access for 0x%08x\n",

78

" Access for 0x%08x\n",

79

se_cmd->se_tfo->get_fabric_name(),

79

se_cmd->se_tfo->get_fabric_name(),

80

unpacked_lun);

80

unpacked_lun);

81

spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);

81

spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);

82

return TCM_WRITE_PROTECTED;

82

return TCM_WRITE_PROTECTED;

83

}

83

}

84

85

if (se_cmd->data_direction == DMA_TO_DEVICE)

85

if (se_cmd->data_direction == DMA_TO_DEVICE)

86

deve->write_bytes += se_cmd->data_length;

86

deve->write_bytes += se_cmd->data_length;

87

else if (se_cmd->data_direction == DMA_FROM_DEVICE)

87

else if (se_cmd->data_direction == DMA_FROM_DEVICE)

88

deve->read_bytes += se_cmd->data_length;

88

deve->read_bytes += se_cmd->data_length;

89

90

se_lun = deve->se_lun;

90

se_lun = deve->se_lun;

91

se_cmd->se_lun = deve->se_lun;

91

se_cmd->se_lun = deve->se_lun;

92

se_cmd->pr_res_key = deve->pr_res_key;

92

se_cmd->pr_res_key = deve->pr_res_key;

93

se_cmd->orig_fe_lun = unpacked_lun;

93

se_cmd->orig_fe_lun = unpacked_lun;

94

se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;

94

se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;

95

96

percpu_ref_get(&se_lun->lun_ref);

96

percpu_ref_get(&se_lun->lun_ref);

97

se_cmd->lun_ref_active = true;

97

se_cmd->lun_ref_active = true;

98

}

98

}

99

spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);

99

spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);

100

101

if (!se_lun) {

101

if (!se_lun) {

102

/*

102

/*

103

* Use the se_portal_group->tpg_virt_lun0 to allow for

103

* Use the se_portal_group->tpg_virt_lun0 to allow for

104

* REPORT_LUNS, et al to be returned when no active

104

* REPORT_LUNS, et al to be returned when no active

105

* MappedLUN=0 exists for this Initiator Port.

105

* MappedLUN=0 exists for this Initiator Port.

106

*/

106

*/

107

if (unpacked_lun != 0) {

107

if (unpacked_lun != 0) {

108

pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"

108

pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"

109

" Access for 0x%08x\n",

109

" Access for 0x%08x\n",

110

se_cmd->se_tfo->get_fabric_name(),

110

se_cmd->se_tfo->get_fabric_name(),

111

unpacked_lun);

111

unpacked_lun);

112

return TCM_NON_EXISTENT_LUN;

112

return TCM_NON_EXISTENT_LUN;

113

}

113

}

114

/*

114

/*

115

* Force WRITE PROTECT for virtual LUN 0

115

* Force WRITE PROTECT for virtual LUN 0

116

*/

116

*/

117

if ((se_cmd->data_direction != DMA_FROM_DEVICE) &&

117

if ((se_cmd->data_direction != DMA_FROM_DEVICE) &&

118

(se_cmd->data_direction != DMA_NONE))

118

(se_cmd->data_direction != DMA_NONE))

119

return TCM_WRITE_PROTECTED;

119

return TCM_WRITE_PROTECTED;

120

121

se_lun = &se_sess->se_tpg->tpg_virt_lun0;

121

se_lun = &se_sess->se_tpg->tpg_virt_lun0;

122

se_cmd->se_lun = &se_sess->se_tpg->tpg_virt_lun0;

122

se_cmd->se_lun = &se_sess->se_tpg->tpg_virt_lun0;

123

se_cmd->orig_fe_lun = 0;

123

se_cmd->orig_fe_lun = 0;

124

se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;

124

se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;

125

126

percpu_ref_get(&se_lun->lun_ref);

126

percpu_ref_get(&se_lun->lun_ref);

127

se_cmd->lun_ref_active = true;

127

se_cmd->lun_ref_active = true;

128

}

128

}

129

130

/* Directly associate cmd with se_dev */

130

/* Directly associate cmd with se_dev */

131

se_cmd->se_dev = se_lun->lun_se_dev;

131

se_cmd->se_dev = se_lun->lun_se_dev;

132

133

dev = se_lun->lun_se_dev;

133

dev = se_lun->lun_se_dev;

134

atomic_long_inc(&dev->num_cmds);

134

atomic_long_inc(&dev->num_cmds);

135

if (se_cmd->data_direction == DMA_TO_DEVICE)

135

if (se_cmd->data_direction == DMA_TO_DEVICE)

136

atomic_long_add(se_cmd->data_length, &dev->write_bytes);

136

atomic_long_add(se_cmd->data_length, &dev->write_bytes);

137

else if (se_cmd->data_direction == DMA_FROM_DEVICE)

137

else if (se_cmd->data_direction == DMA_FROM_DEVICE)

138

atomic_long_add(se_cmd->data_length, &dev->read_bytes);

138

atomic_long_add(se_cmd->data_length, &dev->read_bytes);

139

140

return 0;

140

return 0;

141

}

141

}

142

EXPORT_SYMBOL(transport_lookup_cmd_lun);

142

EXPORT_SYMBOL(transport_lookup_cmd_lun);

143

144

int transport_lookup_tmr_lun(struct se_cmd *se_cmd, u32 unpacked_lun)

144

int transport_lookup_tmr_lun(struct se_cmd *se_cmd, u32 unpacked_lun)

145

{

145

{

146

struct se_dev_entry *deve;

146

struct se_dev_entry *deve;

147

struct se_lun *se_lun = NULL;

147

struct se_lun *se_lun = NULL;

148

struct se_session *se_sess = se_cmd->se_sess;

148

struct se_session *se_sess = se_cmd->se_sess;

149

struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;

149

struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;

150

unsigned long flags;

150

unsigned long flags;

151

152

if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)

152

if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)

153

return -ENODEV;

153

return -ENODEV;

154

155

spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);

155

spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);

156

se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];

156

se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];

157

deve = se_cmd->se_deve;

157

deve = se_cmd->se_deve;

158

159

if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {

159

if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {

160

se_tmr->tmr_lun = deve->se_lun;

160

se_tmr->tmr_lun = deve->se_lun;

161

se_cmd->se_lun = deve->se_lun;

161

se_cmd->se_lun = deve->se_lun;

162

se_lun = deve->se_lun;

162

se_lun = deve->se_lun;

163

se_cmd->pr_res_key = deve->pr_res_key;

163

se_cmd->pr_res_key = deve->pr_res_key;

164

se_cmd->orig_fe_lun = unpacked_lun;

164

se_cmd->orig_fe_lun = unpacked_lun;

165

}

165

}

166

spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);

166

spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);

167

168

if (!se_lun) {

168

if (!se_lun) {

169

pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"

169

pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"

170

" Access for 0x%08x\n",

170

" Access for 0x%08x\n",

171

se_cmd->se_tfo->get_fabric_name(),

171

se_cmd->se_tfo->get_fabric_name(),

172

unpacked_lun);

172

unpacked_lun);

173

return -ENODEV;

173

return -ENODEV;

174

}

174

}

175

176

/* Directly associate cmd with se_dev */

176

/* Directly associate cmd with se_dev */

177

se_cmd->se_dev = se_lun->lun_se_dev;

177

se_cmd->se_dev = se_lun->lun_se_dev;

178

se_tmr->tmr_dev = se_lun->lun_se_dev;

178

se_tmr->tmr_dev = se_lun->lun_se_dev;

179

180

spin_lock_irqsave(&se_tmr->tmr_dev->se_tmr_lock, flags);

180

spin_lock_irqsave(&se_tmr->tmr_dev->se_tmr_lock, flags);

181

list_add_tail(&se_tmr->tmr_list, &se_tmr->tmr_dev->dev_tmr_list);

181

list_add_tail(&se_tmr->tmr_list, &se_tmr->tmr_dev->dev_tmr_list);

182

spin_unlock_irqrestore(&se_tmr->tmr_dev->se_tmr_lock, flags);

182

spin_unlock_irqrestore(&se_tmr->tmr_dev->se_tmr_lock, flags);

183

184

return 0;

184

return 0;

185

}

185

}

186

EXPORT_SYMBOL(transport_lookup_tmr_lun);

186

EXPORT_SYMBOL(transport_lookup_tmr_lun);

187

188

/*

188

/*

189

* This function is called from core_scsi3_emulate_pro_register_and_move()

189

* This function is called from core_scsi3_emulate_pro_register_and_move()

190

* and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_ref_count

190

* and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_ref_count

191

* when a matching rtpi is found.

191

* when a matching rtpi is found.

192

*/

192

*/

193

struct se_dev_entry *core_get_se_deve_from_rtpi(

193

struct se_dev_entry *core_get_se_deve_from_rtpi(

194

struct se_node_acl *nacl,

194

struct se_node_acl *nacl,

195

u16 rtpi)

195

u16 rtpi)

196

{

196

{

197

struct se_dev_entry *deve;

197

struct se_dev_entry *deve;

198

struct se_lun *lun;

198

struct se_lun *lun;

199

struct se_port *port;

199

struct se_port *port;

200

struct se_portal_group *tpg = nacl->se_tpg;

200

struct se_portal_group *tpg = nacl->se_tpg;

201

u32 i;

201

u32 i;

202

203

spin_lock_irq(&nacl->device_list_lock);

203

spin_lock_irq(&nacl->device_list_lock);

204

for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {

204

for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {

205

deve = nacl->device_list[i];

205

deve = nacl->device_list[i];

206

207

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

207

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

208

continue;

208

continue;

209

210

lun = deve->se_lun;

210

lun = deve->se_lun;

211

if (!lun) {

211

if (!lun) {

212

pr_err("%s device entries device pointer is"

212

pr_err("%s device entries device pointer is"

213

" NULL, but Initiator has access.\n",

213

" NULL, but Initiator has access.\n",

214

tpg->se_tpg_tfo->get_fabric_name());

214

tpg->se_tpg_tfo->get_fabric_name());

215

continue;

215

continue;

216

}

216

}

217

port = lun->lun_sep;

217

port = lun->lun_sep;

218

if (!port) {

218

if (!port) {

219

pr_err("%s device entries device pointer is"

219

pr_err("%s device entries device pointer is"

220

" NULL, but Initiator has access.\n",

220

" NULL, but Initiator has access.\n",

221

tpg->se_tpg_tfo->get_fabric_name());

221

tpg->se_tpg_tfo->get_fabric_name());

222

continue;

222

continue;

223

}

223

}

224

if (port->sep_rtpi != rtpi)

224

if (port->sep_rtpi != rtpi)

225

continue;

225

continue;

226

227

atomic_inc(&deve->pr_ref_count);

227

atomic_inc(&deve->pr_ref_count);

228

smp_mb__after_atomic();

228

smp_mb__after_atomic();

229

spin_unlock_irq(&nacl->device_list_lock);

229

spin_unlock_irq(&nacl->device_list_lock);

230

231

return deve;

231

return deve;

232

}

232

}

233

spin_unlock_irq(&nacl->device_list_lock);

233

spin_unlock_irq(&nacl->device_list_lock);

234

235

return NULL;

235

return NULL;

236

}

236

}

237

238

int core_free_device_list_for_node(

238

int core_free_device_list_for_node(

239

struct se_node_acl *nacl,

239

struct se_node_acl *nacl,

240

struct se_portal_group *tpg)

240

struct se_portal_group *tpg)

241

{

241

{

242

struct se_dev_entry *deve;

242

struct se_dev_entry *deve;

243

struct se_lun *lun;

243

struct se_lun *lun;

244

u32 i;

244

u32 i;

245

246

if (!nacl->device_list)

246

if (!nacl->device_list)

247

return 0;

247

return 0;

248

249

spin_lock_irq(&nacl->device_list_lock);

249

spin_lock_irq(&nacl->device_list_lock);

250

for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {

250

for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {

251

deve = nacl->device_list[i];

251

deve = nacl->device_list[i];

252

253

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

253

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

254

continue;

254

continue;

255

256

if (!deve->se_lun) {

256

if (!deve->se_lun) {

257

pr_err("%s device entries device pointer is"

257

pr_err("%s device entries device pointer is"

258

" NULL, but Initiator has access.\n",

258

" NULL, but Initiator has access.\n",

259

tpg->se_tpg_tfo->get_fabric_name());

259

tpg->se_tpg_tfo->get_fabric_name());

260

continue;

260

continue;

261

}

261

}

262

lun = deve->se_lun;

262

lun = deve->se_lun;

263

264

spin_unlock_irq(&nacl->device_list_lock);

264

spin_unlock_irq(&nacl->device_list_lock);

265

core_disable_device_list_for_node(lun, NULL, deve->mapped_lun,

265

core_disable_device_list_for_node(lun, NULL, deve->mapped_lun,

266

TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);

266

TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);

267

spin_lock_irq(&nacl->device_list_lock);

267

spin_lock_irq(&nacl->device_list_lock);

268

}

268

}

269

spin_unlock_irq(&nacl->device_list_lock);

269

spin_unlock_irq(&nacl->device_list_lock);

270

271

array_free(nacl->device_list, TRANSPORT_MAX_LUNS_PER_TPG);

271

array_free(nacl->device_list, TRANSPORT_MAX_LUNS_PER_TPG);

272

nacl->device_list = NULL;

272

nacl->device_list = NULL;

273

274

return 0;

274

return 0;

275

}

275

}

276

277

void core_update_device_list_access(

277

void core_update_device_list_access(

278

u32 mapped_lun,

278

u32 mapped_lun,

279

u32 lun_access,

279

u32 lun_access,

280

struct se_node_acl *nacl)

280

struct se_node_acl *nacl)

281

{

281

{

282

struct se_dev_entry *deve;

282

struct se_dev_entry *deve;

283

284

spin_lock_irq(&nacl->device_list_lock);

284

spin_lock_irq(&nacl->device_list_lock);

285

deve = nacl->device_list[mapped_lun];

285

deve = nacl->device_list[mapped_lun];

286

if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {

286

if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {

287

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;

287

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;

288

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;

288

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;

289

} else {

289

} else {

290

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;

290

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;

291

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;

291

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;

292

}

292

}

293

spin_unlock_irq(&nacl->device_list_lock);

293

spin_unlock_irq(&nacl->device_list_lock);

294

}

294

}

295

296

/* core_enable_device_list_for_node():

296

/* core_enable_device_list_for_node():

297

*

297

*

298

*

298

*

299

*/

299

*/

300

int core_enable_device_list_for_node(

300

int core_enable_device_list_for_node(

301

struct se_lun *lun,

301

struct se_lun *lun,

302

struct se_lun_acl *lun_acl,

302

struct se_lun_acl *lun_acl,

303

u32 mapped_lun,

303

u32 mapped_lun,

304

u32 lun_access,

304

u32 lun_access,

305

struct se_node_acl *nacl,

305

struct se_node_acl *nacl,

306

struct se_portal_group *tpg)

306

struct se_portal_group *tpg)

307

{

307

{

308

struct se_port *port = lun->lun_sep;

308

struct se_port *port = lun->lun_sep;

309

struct se_dev_entry *deve;

309

struct se_dev_entry *deve;

310

311

spin_lock_irq(&nacl->device_list_lock);

311

spin_lock_irq(&nacl->device_list_lock);

312

313

deve = nacl->device_list[mapped_lun];

313

deve = nacl->device_list[mapped_lun];

314

315

/*

315

/*

316

* Check if the call is handling demo mode -> explicit LUN ACL

316

* Check if the call is handling demo mode -> explicit LUN ACL

317

* transition. This transition must be for the same struct se_lun

317

* transition. This transition must be for the same struct se_lun

318

* + mapped_lun that was setup in demo mode..

318

* + mapped_lun that was setup in demo mode..

319

*/

319

*/

320

if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {

320

if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {

321

if (deve->se_lun_acl != NULL) {

321

if (deve->se_lun_acl != NULL) {

322

pr_err("struct se_dev_entry->se_lun_acl"

322

pr_err("struct se_dev_entry->se_lun_acl"

323

" already set for demo mode -> explicit"

323

" already set for demo mode -> explicit"

324

" LUN ACL transition\n");

324

" LUN ACL transition\n");

325

spin_unlock_irq(&nacl->device_list_lock);

325

spin_unlock_irq(&nacl->device_list_lock);

326

return -EINVAL;

326

return -EINVAL;

327

}

327

}

328

if (deve->se_lun != lun) {

328

if (deve->se_lun != lun) {

329

pr_err("struct se_dev_entry->se_lun does"

329

pr_err("struct se_dev_entry->se_lun does"

330

" match passed struct se_lun for demo mode"

330

" match passed struct se_lun for demo mode"

331

" -> explicit LUN ACL transition\n");

331

" -> explicit LUN ACL transition\n");

332

spin_unlock_irq(&nacl->device_list_lock);

332

spin_unlock_irq(&nacl->device_list_lock);

333

return -EINVAL;

333

return -EINVAL;

334

}

334

}

335

deve->se_lun_acl = lun_acl;

335

deve->se_lun_acl = lun_acl;

336

337

if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {

337

if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {

338

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;

338

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;

339

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;

339

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;

340

} else {

340

} else {

341

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;

341

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;

342

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;

342

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;

343

}

343

}

344

345

spin_unlock_irq(&nacl->device_list_lock);

345

spin_unlock_irq(&nacl->device_list_lock);

346

return 0;

346

return 0;

347

}

347

}

348

349

deve->se_lun = lun;

349

deve->se_lun = lun;

350

deve->se_lun_acl = lun_acl;

350

deve->se_lun_acl = lun_acl;

351

deve->mapped_lun = mapped_lun;

351

deve->mapped_lun = mapped_lun;

352

deve->lun_flags |= TRANSPORT_LUNFLAGS_INITIATOR_ACCESS;

352

deve->lun_flags |= TRANSPORT_LUNFLAGS_INITIATOR_ACCESS;

353

354

if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {

354

if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {

355

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;

355

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;

356

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;

356

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_WRITE;

357

} else {

357

} else {

358

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;

358

deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;

359

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;

359

deve->lun_flags |= TRANSPORT_LUNFLAGS_READ_ONLY;

360

}

360

}

361

362

deve->creation_time = get_jiffies_64();

362

deve->creation_time = get_jiffies_64();

363

deve->attach_count++;

363

deve->attach_count++;

364

spin_unlock_irq(&nacl->device_list_lock);

364

spin_unlock_irq(&nacl->device_list_lock);

365

366

spin_lock_bh(&port->sep_alua_lock);

366

spin_lock_bh(&port->sep_alua_lock);

367

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

367

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

368

spin_unlock_bh(&port->sep_alua_lock);

368

spin_unlock_bh(&port->sep_alua_lock);

369

370

return 0;

370

return 0;

371

}

371

}

372

373

/* core_disable_device_list_for_node():

373

/* core_disable_device_list_for_node():

374

*

374

*

375

*

375

*

376

*/

376

*/

377

int core_disable_device_list_for_node(

377

int core_disable_device_list_for_node(

378

struct se_lun *lun,

378

struct se_lun *lun,

379

struct se_lun_acl *lun_acl,

379

struct se_lun_acl *lun_acl,

380

u32 mapped_lun,

380

u32 mapped_lun,

381

u32 lun_access,

381

u32 lun_access,

382

struct se_node_acl *nacl,

382

struct se_node_acl *nacl,

383

struct se_portal_group *tpg)

383

struct se_portal_group *tpg)

384

{

384

{

385

struct se_port *port = lun->lun_sep;

385

struct se_port *port = lun->lun_sep;

386

struct se_dev_entry *deve = nacl->device_list[mapped_lun];

386

struct se_dev_entry *deve = nacl->device_list[mapped_lun];

387

388

/*

388

/*

389

* If the MappedLUN entry is being disabled, the entry in

389

* If the MappedLUN entry is being disabled, the entry in

390

* port->sep_alua_list must be removed now before clearing the

390

* port->sep_alua_list must be removed now before clearing the

391

* struct se_dev_entry pointers below as logic in

391

* struct se_dev_entry pointers below as logic in

392

* core_alua_do_transition_tg_pt() depends on these being present.

392

* core_alua_do_transition_tg_pt() depends on these being present.

393

*

393

*

394

* deve->se_lun_acl will be NULL for demo-mode created LUNs

394

* deve->se_lun_acl will be NULL for demo-mode created LUNs

395

* that have not been explicitly converted to MappedLUNs ->

395

* that have not been explicitly converted to MappedLUNs ->

396

* struct se_lun_acl, but we remove deve->alua_port_list from

396

* struct se_lun_acl, but we remove deve->alua_port_list from

397

* port->sep_alua_list. This also means that active UAs and

397

* port->sep_alua_list. This also means that active UAs and

398

* NodeACL context specific PR metadata for demo-mode

398

* NodeACL context specific PR metadata for demo-mode

399

* MappedLUN *deve will be released below..

399

* MappedLUN *deve will be released below..

400

*/

400

*/

401

spin_lock_bh(&port->sep_alua_lock);

401

spin_lock_bh(&port->sep_alua_lock);

402

list_del(&deve->alua_port_list);

402

list_del(&deve->alua_port_list);

403

spin_unlock_bh(&port->sep_alua_lock);

403

spin_unlock_bh(&port->sep_alua_lock);

404

/*

404

/*

405

* Wait for any in process SPEC_I_PT=1 or REGISTER_AND_MOVE

405

* Wait for any in process SPEC_I_PT=1 or REGISTER_AND_MOVE

406

* PR operation to complete.

406

* PR operation to complete.

407

*/

407

*/

408

while (atomic_read(&deve->pr_ref_count) != 0)

408

while (atomic_read(&deve->pr_ref_count) != 0)

409

cpu_relax();

409

cpu_relax();

410

411

spin_lock_irq(&nacl->device_list_lock);

411

spin_lock_irq(&nacl->device_list_lock);

412

/*

412

/*

413

* Disable struct se_dev_entry LUN ACL mapping

413

* Disable struct se_dev_entry LUN ACL mapping

414

*/

414

*/

415

core_scsi3_ua_release_all(deve);

415

core_scsi3_ua_release_all(deve);

416

deve->se_lun = NULL;

416

deve->se_lun = NULL;

417

deve->se_lun_acl = NULL;

417

deve->se_lun_acl = NULL;

418

deve->lun_flags = 0;

418

deve->lun_flags = 0;

419

deve->creation_time = 0;

419

deve->creation_time = 0;

420

deve->attach_count--;

420

deve->attach_count--;

421

spin_unlock_irq(&nacl->device_list_lock);

421

spin_unlock_irq(&nacl->device_list_lock);

422

423

core_scsi3_free_pr_reg_from_nacl(lun->lun_se_dev, nacl);

423

core_scsi3_free_pr_reg_from_nacl(lun->lun_se_dev, nacl);

424

return 0;

424

return 0;

425

}

425

}

426

427

/* core_clear_lun_from_tpg():

427

/* core_clear_lun_from_tpg():

428

*

428

*

429

*

429

*

430

*/

430

*/

431

void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)

431

void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)

432

{

432

{

433

struct se_node_acl *nacl;

433

struct se_node_acl *nacl;

434

struct se_dev_entry *deve;

434

struct se_dev_entry *deve;

435

u32 i;

435

u32 i;

436

437

spin_lock_irq(&tpg->acl_node_lock);

437

spin_lock_irq(&tpg->acl_node_lock);

438

list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {

438

list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {

439

spin_unlock_irq(&tpg->acl_node_lock);

439

spin_unlock_irq(&tpg->acl_node_lock);

440

441

spin_lock_irq(&nacl->device_list_lock);

441

spin_lock_irq(&nacl->device_list_lock);

442

for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {

442

for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {

443

deve = nacl->device_list[i];

443

deve = nacl->device_list[i];

444

if (lun != deve->se_lun)

444

if (lun != deve->se_lun)

445

continue;

445

continue;

446

spin_unlock_irq(&nacl->device_list_lock);

446

spin_unlock_irq(&nacl->device_list_lock);

447

448

core_disable_device_list_for_node(lun, NULL,

448

core_disable_device_list_for_node(lun, NULL,

449

deve->mapped_lun, TRANSPORT_LUNFLAGS_NO_ACCESS,

449

deve->mapped_lun, TRANSPORT_LUNFLAGS_NO_ACCESS,

450

nacl, tpg);

450

nacl, tpg);

451

452

spin_lock_irq(&nacl->device_list_lock);

452

spin_lock_irq(&nacl->device_list_lock);

453

}

453

}

454

spin_unlock_irq(&nacl->device_list_lock);

454

spin_unlock_irq(&nacl->device_list_lock);

455

456

spin_lock_irq(&tpg->acl_node_lock);

456

spin_lock_irq(&tpg->acl_node_lock);

457

}

457

}

458

spin_unlock_irq(&tpg->acl_node_lock);

458

spin_unlock_irq(&tpg->acl_node_lock);

459

}

459

}

460

461

static struct se_port *core_alloc_port(struct se_device *dev)

461

static struct se_port *core_alloc_port(struct se_device *dev)

462

{

462

{

463

struct se_port *port, *port_tmp;

463

struct se_port *port, *port_tmp;

464

465

port = kzalloc(sizeof(struct se_port), GFP_KERNEL);

465

port = kzalloc(sizeof(struct se_port), GFP_KERNEL);

466

if (!port) {

466

if (!port) {

467

pr_err("Unable to allocate struct se_port\n");

467

pr_err("Unable to allocate struct se_port\n");

468

return ERR_PTR(-ENOMEM);

468

return ERR_PTR(-ENOMEM);

469

}

469

}

470

INIT_LIST_HEAD(&port->sep_alua_list);

470

INIT_LIST_HEAD(&port->sep_alua_list);

471

INIT_LIST_HEAD(&port->sep_list);

471

INIT_LIST_HEAD(&port->sep_list);

472

atomic_set(&port->sep_tg_pt_secondary_offline, 0);

472

atomic_set(&port->sep_tg_pt_secondary_offline, 0);

473

spin_lock_init(&port->sep_alua_lock);

473

spin_lock_init(&port->sep_alua_lock);

474

mutex_init(&port->sep_tg_pt_md_mutex);

474

mutex_init(&port->sep_tg_pt_md_mutex);

475

476

spin_lock(&dev->se_port_lock);

476

spin_lock(&dev->se_port_lock);

477

if (dev->dev_port_count == 0x0000ffff) {

477

if (dev->dev_port_count == 0x0000ffff) {

478

pr_warn("Reached dev->dev_port_count =="

478

pr_warn("Reached dev->dev_port_count =="

479

" 0x0000ffff\n");

479

" 0x0000ffff\n");

480

spin_unlock(&dev->se_port_lock);

480

spin_unlock(&dev->se_port_lock);

481

return ERR_PTR(-ENOSPC);

481

return ERR_PTR(-ENOSPC);

482

}

482

}

483

again:

483

again:

484

/*

484

/*

485

* Allocate the next RELATIVE TARGET PORT IDENTIFIER for this struct se_device

485

* Allocate the next RELATIVE TARGET PORT IDENTIFIER for this struct se_device

486

* Here is the table from spc4r17 section 7.7.3.8.

486

* Here is the table from spc4r17 section 7.7.3.8.

487

*

487

*

488

* Table 473 -- RELATIVE TARGET PORT IDENTIFIER field

488

* Table 473 -- RELATIVE TARGET PORT IDENTIFIER field

489

*

489

*

490

* Code Description

490

* Code Description

491

* 0h Reserved

491

* 0h Reserved

492

* 1h Relative port 1, historically known as port A

492

* 1h Relative port 1, historically known as port A

493

* 2h Relative port 2, historically known as port B

493

* 2h Relative port 2, historically known as port B

494

* 3h to FFFFh Relative port 3 through 65 535

494

* 3h to FFFFh Relative port 3 through 65 535

495

*/

495

*/

496

port->sep_rtpi = dev->dev_rpti_counter++;

496

port->sep_rtpi = dev->dev_rpti_counter++;

497

if (!port->sep_rtpi)

497

if (!port->sep_rtpi)

498

goto again;

498

goto again;

499

500

list_for_each_entry(port_tmp, &dev->dev_sep_list, sep_list) {

500

list_for_each_entry(port_tmp, &dev->dev_sep_list, sep_list) {

501

/*

501

/*

502

* Make sure RELATIVE TARGET PORT IDENTIFIER is unique

502

* Make sure RELATIVE TARGET PORT IDENTIFIER is unique

503

* for 16-bit wrap..

503

* for 16-bit wrap..

504

*/

504

*/

505

if (port->sep_rtpi == port_tmp->sep_rtpi)

505

if (port->sep_rtpi == port_tmp->sep_rtpi)

506

goto again;

506

goto again;

507

}

507

}

508

spin_unlock(&dev->se_port_lock);

508

spin_unlock(&dev->se_port_lock);

509

510

return port;

510

return port;

511

}

511

}

512

513

static void core_export_port(

513

static void core_export_port(

514

struct se_device *dev,

514

struct se_device *dev,

515

struct se_portal_group *tpg,

515

struct se_portal_group *tpg,

516

struct se_port *port,

516

struct se_port *port,

517

struct se_lun *lun)

517

struct se_lun *lun)

518

{

518

{

519

struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem = NULL;

519

struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem = NULL;

520

521

spin_lock(&dev->se_port_lock);

521

spin_lock(&dev->se_port_lock);

522

spin_lock(&lun->lun_sep_lock);

522

spin_lock(&lun->lun_sep_lock);

523

port->sep_tpg = tpg;

523

port->sep_tpg = tpg;

524

port->sep_lun = lun;

524

port->sep_lun = lun;

525

lun->lun_sep = port;

525

lun->lun_sep = port;

526

spin_unlock(&lun->lun_sep_lock);

526

spin_unlock(&lun->lun_sep_lock);

527

528

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

528

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

529

spin_unlock(&dev->se_port_lock);

529

spin_unlock(&dev->se_port_lock);

530

531

if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV &&

531

if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV &&

532

!(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)) {

532

!(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)) {

533

tg_pt_gp_mem = core_alua_allocate_tg_pt_gp_mem(port);

533

tg_pt_gp_mem = core_alua_allocate_tg_pt_gp_mem(port);

534

if (IS_ERR(tg_pt_gp_mem) || !tg_pt_gp_mem) {

534

if (IS_ERR(tg_pt_gp_mem) || !tg_pt_gp_mem) {

535

pr_err("Unable to allocate t10_alua_tg_pt"

535

pr_err("Unable to allocate t10_alua_tg_pt"

536

"_gp_member_t\n");

536

"_gp_member_t\n");

537

return;

537

return;

538

}

538

}

539

spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);

539

spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);

540

__core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,

540

__core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,

541

dev->t10_alua.default_tg_pt_gp);

541

dev->t10_alua.default_tg_pt_gp);

542

spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);

542

spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);

543

pr_debug("%s/%s: Adding to default ALUA Target Port"

543

pr_debug("%s/%s: Adding to default ALUA Target Port"

544

" Group: alua/default_tg_pt_gp\n",

544

" Group: alua/default_tg_pt_gp\n",

545

dev->transport->name, tpg->se_tpg_tfo->get_fabric_name());

545

dev->transport->name, tpg->se_tpg_tfo->get_fabric_name());

546

}

546

}

547

548

dev->dev_port_count++;

548

dev->dev_port_count++;

549

port->sep_index = port->sep_rtpi; /* RELATIVE TARGET PORT IDENTIFIER */

549

port->sep_index = port->sep_rtpi; /* RELATIVE TARGET PORT IDENTIFIER */

550

}

550

}

551

552

/*

552

/*

553

* Called with struct se_device->se_port_lock spinlock held.

553

* Called with struct se_device->se_port_lock spinlock held.

554

*/

554

*/

555

static void core_release_port(struct se_device *dev, struct se_port *port)

555

static void core_release_port(struct se_device *dev, struct se_port *port)

556

__releases(&dev->se_port_lock) __acquires(&dev->se_port_lock)

556

__releases(&dev->se_port_lock) __acquires(&dev->se_port_lock)

557

{

557

{

558

/*

558

/*

559

* Wait for any port reference for PR ALL_TG_PT=1 operation

559

* Wait for any port reference for PR ALL_TG_PT=1 operation

560

* to complete in __core_scsi3_alloc_registration()

560

* to complete in __core_scsi3_alloc_registration()

561

*/

561

*/

562

spin_unlock(&dev->se_port_lock);

562

spin_unlock(&dev->se_port_lock);

563

if (atomic_read(&port->sep_tg_pt_ref_cnt))

563

if (atomic_read(&port->sep_tg_pt_ref_cnt))

564

cpu_relax();

564

cpu_relax();

565

spin_lock(&dev->se_port_lock);

565

spin_lock(&dev->se_port_lock);

566

567

core_alua_free_tg_pt_gp_mem(port);

567

core_alua_free_tg_pt_gp_mem(port);

568

569

list_del(&port->sep_list);

569

list_del(&port->sep_list);

570

dev->dev_port_count--;

570

dev->dev_port_count--;

571

kfree(port);

571

kfree(port);

572

}

572

}

573

574

int core_dev_export(

574

int core_dev_export(

575

struct se_device *dev,

575

struct se_device *dev,

576

struct se_portal_group *tpg,

576

struct se_portal_group *tpg,

577

struct se_lun *lun)

577

struct se_lun *lun)

578

{

578

{

579

struct se_hba *hba = dev->se_hba;

579

struct se_hba *hba = dev->se_hba;

580

struct se_port *port;

580

struct se_port *port;

581

582

port = core_alloc_port(dev);

582

port = core_alloc_port(dev);

583

if (IS_ERR(port))

583

if (IS_ERR(port))

584

return PTR_ERR(port);

584

return PTR_ERR(port);

585

586

lun->lun_se_dev = dev;

586

lun->lun_se_dev = dev;

587

588

spin_lock(&hba->device_lock);

588

spin_lock(&hba->device_lock);

589

dev->export_count++;

589

dev->export_count++;

590

spin_unlock(&hba->device_lock);

590

spin_unlock(&hba->device_lock);

591

592

core_export_port(dev, tpg, port, lun);

592

core_export_port(dev, tpg, port, lun);

593

return 0;

593

return 0;

594

}

594

}

595

596

void core_dev_unexport(

596

void core_dev_unexport(

597

struct se_device *dev,

597

struct se_device *dev,

598

struct se_portal_group *tpg,

598

struct se_portal_group *tpg,

599

struct se_lun *lun)

599

struct se_lun *lun)

600

{

600

{

601

struct se_hba *hba = dev->se_hba;

601

struct se_hba *hba = dev->se_hba;

602

struct se_port *port = lun->lun_sep;

602

struct se_port *port = lun->lun_sep;

603

604

spin_lock(&lun->lun_sep_lock);

604

spin_lock(&lun->lun_sep_lock);

605

if (lun->lun_se_dev == NULL) {

605

if (lun->lun_se_dev == NULL) {

606

spin_unlock(&lun->lun_sep_lock);

606

spin_unlock(&lun->lun_sep_lock);

607

return;

607

return;

608

}

608

}

609

spin_unlock(&lun->lun_sep_lock);

609

spin_unlock(&lun->lun_sep_lock);

610

611

spin_lock(&dev->se_port_lock);

611

spin_lock(&dev->se_port_lock);

612

core_release_port(dev, port);

612

core_release_port(dev, port);

613

spin_unlock(&dev->se_port_lock);

613

spin_unlock(&dev->se_port_lock);

614

615

spin_lock(&hba->device_lock);

615

spin_lock(&hba->device_lock);

616

dev->export_count--;

616

dev->export_count--;

617

spin_unlock(&hba->device_lock);

617

spin_unlock(&hba->device_lock);

618

619

lun->lun_sep = NULL;

619

lun->lun_se_dev = NULL;

620

lun->lun_se_dev = NULL;

620

}

621

}

621

622

static void se_release_vpd_for_dev(struct se_device *dev)

623

static void se_release_vpd_for_dev(struct se_device *dev)

623

{

624

{

624

struct t10_vpd *vpd, *vpd_tmp;

625

struct t10_vpd *vpd, *vpd_tmp;

625

626

spin_lock(&dev->t10_wwn.t10_vpd_lock);

627

spin_lock(&dev->t10_wwn.t10_vpd_lock);

627

list_for_each_entry_safe(vpd, vpd_tmp,

628

list_for_each_entry_safe(vpd, vpd_tmp,

628

&dev->t10_wwn.t10_vpd_list, vpd_list) {

629

&dev->t10_wwn.t10_vpd_list, vpd_list) {

629

list_del(&vpd->vpd_list);

630

list_del(&vpd->vpd_list);

630

kfree(vpd);

631

kfree(vpd);

631

}

632

}

632

spin_unlock(&dev->t10_wwn.t10_vpd_lock);

633

spin_unlock(&dev->t10_wwn.t10_vpd_lock);

633

}

634

}

634

635

static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)

636

static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)

636

{

637

{

637

u32 aligned_max_sectors;

638

u32 aligned_max_sectors;

638

u32 alignment;

639

u32 alignment;

639

/*

640

/*

640

* Limit max_sectors to a PAGE_SIZE aligned value for modern

641

* Limit max_sectors to a PAGE_SIZE aligned value for modern

641

* transport_allocate_data_tasks() operation.

642

* transport_allocate_data_tasks() operation.

642

*/

643

*/

643

alignment = max(1ul, PAGE_SIZE / block_size);

644

alignment = max(1ul, PAGE_SIZE / block_size);

644

aligned_max_sectors = rounddown(max_sectors, alignment);

645

aligned_max_sectors = rounddown(max_sectors, alignment);

645

646

if (max_sectors != aligned_max_sectors)

647

if (max_sectors != aligned_max_sectors)

647

pr_info("Rounding down aligned max_sectors from %u to %u\n",

648

pr_info("Rounding down aligned max_sectors from %u to %u\n",

648

max_sectors, aligned_max_sectors);

649

max_sectors, aligned_max_sectors);

649

650

return aligned_max_sectors;

651

return aligned_max_sectors;

651

}

652

}

652

653

int se_dev_set_max_unmap_lba_count(

654

int se_dev_set_max_unmap_lba_count(

654

struct se_device *dev,

655

struct se_device *dev,

655

u32 max_unmap_lba_count)

656

u32 max_unmap_lba_count)

656

{

657

{

657

dev->dev_attrib.max_unmap_lba_count = max_unmap_lba_count;

658

dev->dev_attrib.max_unmap_lba_count = max_unmap_lba_count;

658

pr_debug("dev[%p]: Set max_unmap_lba_count: %u\n",

659

pr_debug("dev[%p]: Set max_unmap_lba_count: %u\n",

659

dev, dev->dev_attrib.max_unmap_lba_count);

660

dev, dev->dev_attrib.max_unmap_lba_count);

660

return 0;

661

return 0;

661

}

662

}

662

663

int se_dev_set_max_unmap_block_desc_count(

664

int se_dev_set_max_unmap_block_desc_count(

664

struct se_device *dev,

665

struct se_device *dev,

665

u32 max_unmap_block_desc_count)

666

u32 max_unmap_block_desc_count)

666

{

667

{

667

dev->dev_attrib.max_unmap_block_desc_count =

668

dev->dev_attrib.max_unmap_block_desc_count =

668

max_unmap_block_desc_count;

669

max_unmap_block_desc_count;

669

pr_debug("dev[%p]: Set max_unmap_block_desc_count: %u\n",

670

pr_debug("dev[%p]: Set max_unmap_block_desc_count: %u\n",

670

dev, dev->dev_attrib.max_unmap_block_desc_count);

671

dev, dev->dev_attrib.max_unmap_block_desc_count);

671

return 0;

672

return 0;

672

}

673

}

673

674

int se_dev_set_unmap_granularity(

675

int se_dev_set_unmap_granularity(

675

struct se_device *dev,

676

struct se_device *dev,

676

u32 unmap_granularity)

677

u32 unmap_granularity)

677

{

678

{

678

dev->dev_attrib.unmap_granularity = unmap_granularity;

679

dev->dev_attrib.unmap_granularity = unmap_granularity;

679

pr_debug("dev[%p]: Set unmap_granularity: %u\n",

680

pr_debug("dev[%p]: Set unmap_granularity: %u\n",

680

dev, dev->dev_attrib.unmap_granularity);

681

dev, dev->dev_attrib.unmap_granularity);

681

return 0;

682

return 0;

682

}

683

}

683

684

int se_dev_set_unmap_granularity_alignment(

685

int se_dev_set_unmap_granularity_alignment(

685

struct se_device *dev,

686

struct se_device *dev,

686

u32 unmap_granularity_alignment)

687

u32 unmap_granularity_alignment)

687

{

688

{

688

dev->dev_attrib.unmap_granularity_alignment = unmap_granularity_alignment;

689

dev->dev_attrib.unmap_granularity_alignment = unmap_granularity_alignment;

689

pr_debug("dev[%p]: Set unmap_granularity_alignment: %u\n",

690

pr_debug("dev[%p]: Set unmap_granularity_alignment: %u\n",

690

dev, dev->dev_attrib.unmap_granularity_alignment);

691

dev, dev->dev_attrib.unmap_granularity_alignment);

691

return 0;

692

return 0;

692

}

693

}

693

694

int se_dev_set_max_write_same_len(

695

int se_dev_set_max_write_same_len(

695

struct se_device *dev,

696

struct se_device *dev,

696

u32 max_write_same_len)

697

u32 max_write_same_len)

697

{

698

{

698

dev->dev_attrib.max_write_same_len = max_write_same_len;

699

dev->dev_attrib.max_write_same_len = max_write_same_len;

699

pr_debug("dev[%p]: Set max_write_same_len: %u\n",

700

pr_debug("dev[%p]: Set max_write_same_len: %u\n",

700

dev, dev->dev_attrib.max_write_same_len);

701

dev, dev->dev_attrib.max_write_same_len);

701

return 0;

702

return 0;

702

}

703

}

703

704

static void dev_set_t10_wwn_model_alias(struct se_device *dev)

705

static void dev_set_t10_wwn_model_alias(struct se_device *dev)

705

{

706

{

706

const char *configname;

707

const char *configname;

707

708

configname = config_item_name(&dev->dev_group.cg_item);

709

configname = config_item_name(&dev->dev_group.cg_item);

709

if (strlen(configname) >= 16) {

710

if (strlen(configname) >= 16) {

710

pr_warn("dev[%p]: Backstore name '%s' is too long for "

711

pr_warn("dev[%p]: Backstore name '%s' is too long for "

711

"INQUIRY_MODEL, truncating to 16 bytes\n", dev,

712

"INQUIRY_MODEL, truncating to 16 bytes\n", dev,

712

configname);

713

configname);

713

}

714

}

714

snprintf(&dev->t10_wwn.model[0], 16, "%s", configname);

715

snprintf(&dev->t10_wwn.model[0], 16, "%s", configname);

715

}

716

}

716

717

int se_dev_set_emulate_model_alias(struct se_device *dev, int flag)

718

int se_dev_set_emulate_model_alias(struct se_device *dev, int flag)

718

{

719

{

719

if (dev->export_count) {

720

if (dev->export_count) {

720

pr_err("dev[%p]: Unable to change model alias"

721

pr_err("dev[%p]: Unable to change model alias"

721

" while export_count is %d\n",

722

" while export_count is %d\n",

722

dev, dev->export_count);

723

dev, dev->export_count);

723

return -EINVAL;

724

return -EINVAL;

724

}

725

}

725

726

if (flag != 0 && flag != 1) {

727

if (flag != 0 && flag != 1) {

727

pr_err("Illegal value %d\n", flag);

728

pr_err("Illegal value %d\n", flag);

728

return -EINVAL;

729

return -EINVAL;

729

}

730

}

730

731

if (flag) {

732

if (flag) {

732

dev_set_t10_wwn_model_alias(dev);

733

dev_set_t10_wwn_model_alias(dev);

733

} else {

734

} else {

734

strncpy(&dev->t10_wwn.model[0],

735

strncpy(&dev->t10_wwn.model[0],

735

dev->transport->inquiry_prod, 16);

736

dev->transport->inquiry_prod, 16);

736

}

737

}

737

dev->dev_attrib.emulate_model_alias = flag;

738

dev->dev_attrib.emulate_model_alias = flag;

738

739

return 0;

740

return 0;

740

}

741

}

741

742

int se_dev_set_emulate_dpo(struct se_device *dev, int flag)

743

int se_dev_set_emulate_dpo(struct se_device *dev, int flag)

743

{

744

{

744

if (flag != 0 && flag != 1) {

745

if (flag != 0 && flag != 1) {

745

pr_err("Illegal value %d\n", flag);

746

pr_err("Illegal value %d\n", flag);

746

return -EINVAL;

747

return -EINVAL;

747

}

748

}

748

749

if (flag) {

750

if (flag) {

750

pr_err("dpo_emulated not supported\n");

751

pr_err("dpo_emulated not supported\n");

751

return -EINVAL;

752

return -EINVAL;

752

}

753

}

753

754

return 0;

755

return 0;

755

}

756

}

756

757

int se_dev_set_emulate_fua_write(struct se_device *dev, int flag)

758

int se_dev_set_emulate_fua_write(struct se_device *dev, int flag)

758

{

759

{

759

if (flag != 0 && flag != 1) {

760

if (flag != 0 && flag != 1) {

760

pr_err("Illegal value %d\n", flag);

761

pr_err("Illegal value %d\n", flag);

761

return -EINVAL;

762

return -EINVAL;

762

}

763

}

763

764

if (flag &&

765

if (flag &&

765

dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

766

dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

766

pr_err("emulate_fua_write not supported for pSCSI\n");

767

pr_err("emulate_fua_write not supported for pSCSI\n");

767

return -EINVAL;

768

return -EINVAL;

768

}

769

}

769

dev->dev_attrib.emulate_fua_write = flag;

770

dev->dev_attrib.emulate_fua_write = flag;

770

pr_debug("dev[%p]: SE Device Forced Unit Access WRITEs: %d\n",

771

pr_debug("dev[%p]: SE Device Forced Unit Access WRITEs: %d\n",

771

dev, dev->dev_attrib.emulate_fua_write);

772

dev, dev->dev_attrib.emulate_fua_write);

772

return 0;

773

return 0;

773

}

774

}

774

775

int se_dev_set_emulate_fua_read(struct se_device *dev, int flag)

776

int se_dev_set_emulate_fua_read(struct se_device *dev, int flag)

776

{

777

{

777

if (flag != 0 && flag != 1) {

778

if (flag != 0 && flag != 1) {

778

pr_err("Illegal value %d\n", flag);

779

pr_err("Illegal value %d\n", flag);

779

return -EINVAL;

780

return -EINVAL;

780

}

781

}

781

782

if (flag) {

783

if (flag) {

783

pr_err("ua read emulated not supported\n");

784

pr_err("ua read emulated not supported\n");

784

return -EINVAL;

785

return -EINVAL;

785

}

786

}

786

787

return 0;

788

return 0;

788

}

789

}

789

790

int se_dev_set_emulate_write_cache(struct se_device *dev, int flag)

791

int se_dev_set_emulate_write_cache(struct se_device *dev, int flag)

791

{

792

{

792

if (flag != 0 && flag != 1) {

793

if (flag != 0 && flag != 1) {

793

pr_err("Illegal value %d\n", flag);

794

pr_err("Illegal value %d\n", flag);

794

return -EINVAL;

795

return -EINVAL;

795

}

796

}

796

if (flag &&

797

if (flag &&

797

dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

798

dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

798

pr_err("emulate_write_cache not supported for pSCSI\n");

799

pr_err("emulate_write_cache not supported for pSCSI\n");

799

return -EINVAL;

800

return -EINVAL;

800

}

801

}

801

if (flag &&

802

if (flag &&

802

dev->transport->get_write_cache) {

803

dev->transport->get_write_cache) {

803

pr_err("emulate_write_cache not supported for this device\n");

804

pr_err("emulate_write_cache not supported for this device\n");

804

return -EINVAL;

805

return -EINVAL;

805

}

806

}

806

807

dev->dev_attrib.emulate_write_cache = flag;

808

dev->dev_attrib.emulate_write_cache = flag;

808

pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",

809

pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",

809

dev, dev->dev_attrib.emulate_write_cache);

810

dev, dev->dev_attrib.emulate_write_cache);

810

return 0;

811

return 0;

811

}

812

}

812

813

int se_dev_set_emulate_ua_intlck_ctrl(struct se_device *dev, int flag)

814

int se_dev_set_emulate_ua_intlck_ctrl(struct se_device *dev, int flag)

814

{

815

{

815

if ((flag != 0) && (flag != 1) && (flag != 2)) {

816

if ((flag != 0) && (flag != 1) && (flag != 2)) {

816

pr_err("Illegal value %d\n", flag);

817

pr_err("Illegal value %d\n", flag);

817

return -EINVAL;

818

return -EINVAL;

818

}

819

}

819

820

if (dev->export_count) {

821

if (dev->export_count) {

821

pr_err("dev[%p]: Unable to change SE Device"

822

pr_err("dev[%p]: Unable to change SE Device"

822

" UA_INTRLCK_CTRL while export_count is %d\n",

823

" UA_INTRLCK_CTRL while export_count is %d\n",

823

dev, dev->export_count);

824

dev, dev->export_count);

824

return -EINVAL;

825

return -EINVAL;

825

}

826

}

826

dev->dev_attrib.emulate_ua_intlck_ctrl = flag;

827

dev->dev_attrib.emulate_ua_intlck_ctrl = flag;

827

pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",

828

pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",

828

dev, dev->dev_attrib.emulate_ua_intlck_ctrl);

829

dev, dev->dev_attrib.emulate_ua_intlck_ctrl);

829

830

return 0;

831

return 0;

831

}

832

}

832

833

int se_dev_set_emulate_tas(struct se_device *dev, int flag)

834

int se_dev_set_emulate_tas(struct se_device *dev, int flag)

834

{

835

{

835

if ((flag != 0) && (flag != 1)) {

836

if ((flag != 0) && (flag != 1)) {

836

pr_err("Illegal value %d\n", flag);

837

pr_err("Illegal value %d\n", flag);

837

return -EINVAL;

838

return -EINVAL;

838

}

839

}

839

840

if (dev->export_count) {

841

if (dev->export_count) {

841

pr_err("dev[%p]: Unable to change SE Device TAS while"

842

pr_err("dev[%p]: Unable to change SE Device TAS while"

842

" export_count is %d\n",

843

" export_count is %d\n",

843

dev, dev->export_count);

844

dev, dev->export_count);

844

return -EINVAL;

845

return -EINVAL;

845

}

846

}

846

dev->dev_attrib.emulate_tas = flag;

847

dev->dev_attrib.emulate_tas = flag;

847

pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",

848

pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",

848

dev, (dev->dev_attrib.emulate_tas) ? "Enabled" : "Disabled");

849

dev, (dev->dev_attrib.emulate_tas) ? "Enabled" : "Disabled");

849

850

return 0;

851

return 0;

851

}

852

}

852

853

int se_dev_set_emulate_tpu(struct se_device *dev, int flag)

854

int se_dev_set_emulate_tpu(struct se_device *dev, int flag)

854

{

855

{

855

if ((flag != 0) && (flag != 1)) {

856

if ((flag != 0) && (flag != 1)) {

856

pr_err("Illegal value %d\n", flag);

857

pr_err("Illegal value %d\n", flag);

857

return -EINVAL;

858

return -EINVAL;

858

}

859

}

859

/*

860

/*

860

* We expect this value to be non-zero when generic Block Layer

861

* We expect this value to be non-zero when generic Block Layer

861

* Discard supported is detected iblock_create_virtdevice().

862

* Discard supported is detected iblock_create_virtdevice().

862

*/

863

*/

863

if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {

864

if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {

864

pr_err("Generic Block Discard not supported\n");

865

pr_err("Generic Block Discard not supported\n");

865

return -ENOSYS;

866

return -ENOSYS;

866

}

867

}

867

868

dev->dev_attrib.emulate_tpu = flag;

869

dev->dev_attrib.emulate_tpu = flag;

869

pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",

870

pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",

870

dev, flag);

871

dev, flag);

871

return 0;

872

return 0;

872

}

873

}

873

874

int se_dev_set_emulate_tpws(struct se_device *dev, int flag)

875

int se_dev_set_emulate_tpws(struct se_device *dev, int flag)

875

{

876

{

876

if ((flag != 0) && (flag != 1)) {

877

if ((flag != 0) && (flag != 1)) {

877

pr_err("Illegal value %d\n", flag);

878

pr_err("Illegal value %d\n", flag);

878

return -EINVAL;

879

return -EINVAL;

879

}

880

}

880

/*

881

/*

881

* We expect this value to be non-zero when generic Block Layer

882

* We expect this value to be non-zero when generic Block Layer

882

* Discard supported is detected iblock_create_virtdevice().

883

* Discard supported is detected iblock_create_virtdevice().

883

*/

884

*/

884

if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {

885

if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {

885

pr_err("Generic Block Discard not supported\n");

886

pr_err("Generic Block Discard not supported\n");

886

return -ENOSYS;

887

return -ENOSYS;

887

}

888

}

888

889

dev->dev_attrib.emulate_tpws = flag;

890

dev->dev_attrib.emulate_tpws = flag;

890

pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",

891

pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",

891

dev, flag);

892

dev, flag);

892

return 0;

893

return 0;

893

}

894

}

894

895

int se_dev_set_emulate_caw(struct se_device *dev, int flag)

896

int se_dev_set_emulate_caw(struct se_device *dev, int flag)

896

{

897

{

897

if (flag != 0 && flag != 1) {

898

if (flag != 0 && flag != 1) {

898

pr_err("Illegal value %d\n", flag);

899

pr_err("Illegal value %d\n", flag);

899

return -EINVAL;

900

return -EINVAL;

900

}

901

}

901

dev->dev_attrib.emulate_caw = flag;

902

dev->dev_attrib.emulate_caw = flag;

902

pr_debug("dev[%p]: SE Device CompareAndWrite (AtomicTestandSet): %d\n",

903

pr_debug("dev[%p]: SE Device CompareAndWrite (AtomicTestandSet): %d\n",

903

dev, flag);

904

dev, flag);

904

905

return 0;

906

return 0;

906

}

907

}

907

908

int se_dev_set_emulate_3pc(struct se_device *dev, int flag)

909

int se_dev_set_emulate_3pc(struct se_device *dev, int flag)

909

{

910

{

910

if (flag != 0 && flag != 1) {

911

if (flag != 0 && flag != 1) {

911

pr_err("Illegal value %d\n", flag);

912

pr_err("Illegal value %d\n", flag);

912

return -EINVAL;

913

return -EINVAL;

913

}

914

}

914

dev->dev_attrib.emulate_3pc = flag;

915

dev->dev_attrib.emulate_3pc = flag;

915

pr_debug("dev[%p]: SE Device 3rd Party Copy (EXTENDED_COPY): %d\n",

916

pr_debug("dev[%p]: SE Device 3rd Party Copy (EXTENDED_COPY): %d\n",

916

dev, flag);

917

dev, flag);

917

918

return 0;

919

return 0;

919

}

920

}

920

921

int se_dev_set_pi_prot_type(struct se_device *dev, int flag)

922

int se_dev_set_pi_prot_type(struct se_device *dev, int flag)

922

{

923

{

923

int rc, old_prot = dev->dev_attrib.pi_prot_type;

924

int rc, old_prot = dev->dev_attrib.pi_prot_type;

924

925

if (flag != 0 && flag != 1 && flag != 2 && flag != 3) {

926

if (flag != 0 && flag != 1 && flag != 2 && flag != 3) {

926

pr_err("Illegal value %d for pi_prot_type\n", flag);

927

pr_err("Illegal value %d for pi_prot_type\n", flag);

927

return -EINVAL;

928

return -EINVAL;

928

}

929

}

929

if (flag == 2) {

930

if (flag == 2) {

930

pr_err("DIF TYPE2 protection currently not supported\n");

931

pr_err("DIF TYPE2 protection currently not supported\n");

931

return -ENOSYS;

932

return -ENOSYS;

932

}

933

}

933

if (dev->dev_attrib.hw_pi_prot_type) {

934

if (dev->dev_attrib.hw_pi_prot_type) {

934

pr_warn("DIF protection enabled on underlying hardware,"

935

pr_warn("DIF protection enabled on underlying hardware,"

935

" ignoring\n");

936

" ignoring\n");

936

return 0;

937

return 0;

937

}

938

}

938

if (!dev->transport->init_prot || !dev->transport->free_prot) {

939

if (!dev->transport->init_prot || !dev->transport->free_prot) {

939

/* 0 is only allowed value for non-supporting backends */

940

/* 0 is only allowed value for non-supporting backends */

940

if (flag == 0)

941

if (flag == 0)

941

return 0;

942

return 0;

942

943

pr_err("DIF protection not supported by backend: %s\n",

944

pr_err("DIF protection not supported by backend: %s\n",

944

dev->transport->name);

945

dev->transport->name);

945

return -ENOSYS;

946

return -ENOSYS;

946

}

947

}

947

if (!(dev->dev_flags & DF_CONFIGURED)) {

948

if (!(dev->dev_flags & DF_CONFIGURED)) {

948

pr_err("DIF protection requires device to be configured\n");

949

pr_err("DIF protection requires device to be configured\n");

949

return -ENODEV;

950

return -ENODEV;

950

}

951

}

951

if (dev->export_count) {

952

if (dev->export_count) {

952

pr_err("dev[%p]: Unable to change SE Device PROT type while"

953

pr_err("dev[%p]: Unable to change SE Device PROT type while"

953

" export_count is %d\n", dev, dev->export_count);

954

" export_count is %d\n", dev, dev->export_count);

954

return -EINVAL;

955

return -EINVAL;

955

}

956

}

956

957

dev->dev_attrib.pi_prot_type = flag;

958

dev->dev_attrib.pi_prot_type = flag;

958

959

if (flag && !old_prot) {

960

if (flag && !old_prot) {

960

rc = dev->transport->init_prot(dev);

961

rc = dev->transport->init_prot(dev);

961

if (rc) {

962

if (rc) {

962

dev->dev_attrib.pi_prot_type = old_prot;

963

dev->dev_attrib.pi_prot_type = old_prot;

963

return rc;

964

return rc;

964

}

965

}

965

966

} else if (!flag && old_prot) {

967

} else if (!flag && old_prot) {

967

dev->transport->free_prot(dev);

968

dev->transport->free_prot(dev);

968

}

969

}

969

pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag);

970

pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag);

970

971

return 0;

972

return 0;

972

}

973

}

973

974

int se_dev_set_pi_prot_format(struct se_device *dev, int flag)

975

int se_dev_set_pi_prot_format(struct se_device *dev, int flag)

975

{

976

{

976

int rc;

977

int rc;

977

978

if (!flag)

979

if (!flag)

979

return 0;

980

return 0;

980

981

if (flag != 1) {

982

if (flag != 1) {

982

pr_err("Illegal value %d for pi_prot_format\n", flag);

983

pr_err("Illegal value %d for pi_prot_format\n", flag);

983

return -EINVAL;

984

return -EINVAL;

984

}

985

}

985

if (!dev->transport->format_prot) {

986

if (!dev->transport->format_prot) {

986

pr_err("DIF protection format not supported by backend %s\n",

987

pr_err("DIF protection format not supported by backend %s\n",

987

dev->transport->name);

988

dev->transport->name);

988

return -ENOSYS;

989

return -ENOSYS;

989

}

990

}

990

if (!(dev->dev_flags & DF_CONFIGURED)) {

991

if (!(dev->dev_flags & DF_CONFIGURED)) {

991

pr_err("DIF protection format requires device to be configured\n");

992

pr_err("DIF protection format requires device to be configured\n");

992

return -ENODEV;

993

return -ENODEV;

993

}

994

}

994

if (dev->export_count) {

995

if (dev->export_count) {

995

pr_err("dev[%p]: Unable to format SE Device PROT type while"

996

pr_err("dev[%p]: Unable to format SE Device PROT type while"

996

" export_count is %d\n", dev, dev->export_count);

997

" export_count is %d\n", dev, dev->export_count);

997

return -EINVAL;

998

return -EINVAL;

998

}

999

}

999

1000

rc = dev->transport->format_prot(dev);

1001

rc = dev->transport->format_prot(dev);

1001

if (rc)

1002

if (rc)

1002

return rc;

1003

return rc;

1003

1004

pr_debug("dev[%p]: SE Device Protection Format complete\n", dev);

1005

pr_debug("dev[%p]: SE Device Protection Format complete\n", dev);

1005

1006

return 0;

1007

return 0;

1007

}

1008

}

1008

1009

int se_dev_set_enforce_pr_isids(struct se_device *dev, int flag)

1010

int se_dev_set_enforce_pr_isids(struct se_device *dev, int flag)

1010

{

1011

{

1011

if ((flag != 0) && (flag != 1)) {

1012

if ((flag != 0) && (flag != 1)) {

1012

pr_err("Illegal value %d\n", flag);

1013

pr_err("Illegal value %d\n", flag);

1013

return -EINVAL;

1014

return -EINVAL;

1014

}

1015

}

1015

dev->dev_attrib.enforce_pr_isids = flag;

1016

dev->dev_attrib.enforce_pr_isids = flag;

1016

pr_debug("dev[%p]: SE Device enforce_pr_isids bit: %s\n", dev,

1017

pr_debug("dev[%p]: SE Device enforce_pr_isids bit: %s\n", dev,

1017

(dev->dev_attrib.enforce_pr_isids) ? "Enabled" : "Disabled");

1018

(dev->dev_attrib.enforce_pr_isids) ? "Enabled" : "Disabled");

1018

return 0;

1019

return 0;

1019

}

1020

}

1020

1021

int se_dev_set_is_nonrot(struct se_device *dev, int flag)

1022

int se_dev_set_is_nonrot(struct se_device *dev, int flag)

1022

{

1023

{

1023

if ((flag != 0) && (flag != 1)) {

1024

if ((flag != 0) && (flag != 1)) {

1024

printk(KERN_ERR "Illegal value %d\n", flag);

1025

printk(KERN_ERR "Illegal value %d\n", flag);

1025

return -EINVAL;

1026

return -EINVAL;

1026

}

1027

}

1027

dev->dev_attrib.is_nonrot = flag;

1028

dev->dev_attrib.is_nonrot = flag;

1028

pr_debug("dev[%p]: SE Device is_nonrot bit: %d\n",

1029

pr_debug("dev[%p]: SE Device is_nonrot bit: %d\n",

1029

dev, flag);

1030

dev, flag);

1030

return 0;

1031

return 0;

1031

}

1032

}

1032

1033

int se_dev_set_emulate_rest_reord(struct se_device *dev, int flag)

1034

int se_dev_set_emulate_rest_reord(struct se_device *dev, int flag)

1034

{

1035

{

1035

if (flag != 0) {

1036

if (flag != 0) {

1036

printk(KERN_ERR "dev[%p]: SE Device emulatation of restricted"

1037

printk(KERN_ERR "dev[%p]: SE Device emulatation of restricted"

1037

" reordering not implemented\n", dev);

1038

" reordering not implemented\n", dev);

1038

return -ENOSYS;

1039

return -ENOSYS;

1039

}

1040

}

1040

dev->dev_attrib.emulate_rest_reord = flag;

1041

dev->dev_attrib.emulate_rest_reord = flag;

1041

pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n", dev, flag);

1042

pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n", dev, flag);

1042

return 0;

1043

return 0;

1043

}

1044

}

1044

1045

/*

1046

/*

1046

* Note, this can only be called on unexported SE Device Object.

1047

* Note, this can only be called on unexported SE Device Object.

1047

*/

1048

*/

1048

int se_dev_set_queue_depth(struct se_device *dev, u32 queue_depth)

1049

int se_dev_set_queue_depth(struct se_device *dev, u32 queue_depth)

1049

{

1050

{

1050

if (dev->export_count) {

1051

if (dev->export_count) {

1051

pr_err("dev[%p]: Unable to change SE Device TCQ while"

1052

pr_err("dev[%p]: Unable to change SE Device TCQ while"

1052

" export_count is %d\n",

1053

" export_count is %d\n",

1053

dev, dev->export_count);

1054

dev, dev->export_count);

1054

return -EINVAL;

1055

return -EINVAL;

1055

}

1056

}

1056

if (!queue_depth) {

1057

if (!queue_depth) {

1057

pr_err("dev[%p]: Illegal ZERO value for queue"

1058

pr_err("dev[%p]: Illegal ZERO value for queue"

1058

"_depth\n", dev);

1059

"_depth\n", dev);

1059

return -EINVAL;

1060

return -EINVAL;

1060

}

1061

}

1061

1062

if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

1063

if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

1063

if (queue_depth > dev->dev_attrib.hw_queue_depth) {

1064

if (queue_depth > dev->dev_attrib.hw_queue_depth) {

1064

pr_err("dev[%p]: Passed queue_depth: %u"

1065

pr_err("dev[%p]: Passed queue_depth: %u"

1065

" exceeds TCM/SE_Device TCQ: %u\n",

1066

" exceeds TCM/SE_Device TCQ: %u\n",

1066

dev, queue_depth,

1067

dev, queue_depth,

1067

dev->dev_attrib.hw_queue_depth);

1068

dev->dev_attrib.hw_queue_depth);

1068

return -EINVAL;

1069

return -EINVAL;

1069

}

1070

}

1070

} else {

1071

} else {

1071

if (queue_depth > dev->dev_attrib.queue_depth) {

1072

if (queue_depth > dev->dev_attrib.queue_depth) {

1072

if (queue_depth > dev->dev_attrib.hw_queue_depth) {

1073

if (queue_depth > dev->dev_attrib.hw_queue_depth) {

1073

pr_err("dev[%p]: Passed queue_depth:"

1074

pr_err("dev[%p]: Passed queue_depth:"

1074

" %u exceeds TCM/SE_Device MAX"

1075

" %u exceeds TCM/SE_Device MAX"

1075

" TCQ: %u\n", dev, queue_depth,

1076

" TCQ: %u\n", dev, queue_depth,

1076

dev->dev_attrib.hw_queue_depth);

1077

dev->dev_attrib.hw_queue_depth);

1077

return -EINVAL;

1078

return -EINVAL;

1078

}

1079

}

1079

}

1080

}

1080

}

1081

}

1081

1082

dev->dev_attrib.queue_depth = dev->queue_depth = queue_depth;

1083

dev->dev_attrib.queue_depth = dev->queue_depth = queue_depth;

1083

pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n",

1084

pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n",

1084

dev, queue_depth);

1085

dev, queue_depth);

1085

return 0;

1086

return 0;

1086

}

1087

}

1087

1088

int se_dev_set_fabric_max_sectors(struct se_device *dev, u32 fabric_max_sectors)

1089

int se_dev_set_fabric_max_sectors(struct se_device *dev, u32 fabric_max_sectors)

1089

{

1090

{

1090

int block_size = dev->dev_attrib.block_size;

1091

int block_size = dev->dev_attrib.block_size;

1091

1092

if (dev->export_count) {

1093

if (dev->export_count) {

1093

pr_err("dev[%p]: Unable to change SE Device"

1094

pr_err("dev[%p]: Unable to change SE Device"

1094

" fabric_max_sectors while export_count is %d\n",

1095

" fabric_max_sectors while export_count is %d\n",

1095

dev, dev->export_count);

1096

dev, dev->export_count);

1096

return -EINVAL;

1097

return -EINVAL;

1097

}

1098

}

1098

if (!fabric_max_sectors) {

1099

if (!fabric_max_sectors) {

1099

pr_err("dev[%p]: Illegal ZERO value for"

1100

pr_err("dev[%p]: Illegal ZERO value for"

1100

" fabric_max_sectors\n", dev);

1101

" fabric_max_sectors\n", dev);

1101

return -EINVAL;

1102

return -EINVAL;

1102

}

1103

}

1103

if (fabric_max_sectors < DA_STATUS_MAX_SECTORS_MIN) {

1104

if (fabric_max_sectors < DA_STATUS_MAX_SECTORS_MIN) {

1104

pr_err("dev[%p]: Passed fabric_max_sectors: %u less than"

1105

pr_err("dev[%p]: Passed fabric_max_sectors: %u less than"

1105

" DA_STATUS_MAX_SECTORS_MIN: %u\n", dev, fabric_max_sectors,

1106

" DA_STATUS_MAX_SECTORS_MIN: %u\n", dev, fabric_max_sectors,

1106

DA_STATUS_MAX_SECTORS_MIN);

1107

DA_STATUS_MAX_SECTORS_MIN);

1107

return -EINVAL;

1108

return -EINVAL;

1108

}

1109

}

1109

if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

1110

if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

1110

if (fabric_max_sectors > dev->dev_attrib.hw_max_sectors) {

1111

if (fabric_max_sectors > dev->dev_attrib.hw_max_sectors) {

1111

pr_err("dev[%p]: Passed fabric_max_sectors: %u"

1112

pr_err("dev[%p]: Passed fabric_max_sectors: %u"

1112

" greater than TCM/SE_Device max_sectors:"

1113

" greater than TCM/SE_Device max_sectors:"

1113

" %u\n", dev, fabric_max_sectors,

1114

" %u\n", dev, fabric_max_sectors,

1114

dev->dev_attrib.hw_max_sectors);

1115

dev->dev_attrib.hw_max_sectors);

1115

return -EINVAL;

1116

return -EINVAL;

1116

}

1117

}

1117

} else {

1118

} else {

1118

if (fabric_max_sectors > DA_STATUS_MAX_SECTORS_MAX) {

1119

if (fabric_max_sectors > DA_STATUS_MAX_SECTORS_MAX) {

1119

pr_err("dev[%p]: Passed fabric_max_sectors: %u"

1120

pr_err("dev[%p]: Passed fabric_max_sectors: %u"

1120

" greater than DA_STATUS_MAX_SECTORS_MAX:"

1121

" greater than DA_STATUS_MAX_SECTORS_MAX:"

1121

" %u\n", dev, fabric_max_sectors,

1122

" %u\n", dev, fabric_max_sectors,

1122

DA_STATUS_MAX_SECTORS_MAX);

1123

DA_STATUS_MAX_SECTORS_MAX);

1123

return -EINVAL;

1124

return -EINVAL;

1124

}

1125

}

1125

}

1126

}

1126

/*

1127

/*

1127

* Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()

1128

* Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()

1128

*/

1129

*/

1129

if (!block_size) {

1130

if (!block_size) {

1130

block_size = 512;

1131

block_size = 512;

1131

pr_warn("Defaulting to 512 for zero block_size\n");

1132

pr_warn("Defaulting to 512 for zero block_size\n");

1132

}

1133

}

1133

fabric_max_sectors = se_dev_align_max_sectors(fabric_max_sectors,

1134

fabric_max_sectors = se_dev_align_max_sectors(fabric_max_sectors,

1134

block_size);

1135

block_size);

1135

1136

dev->dev_attrib.fabric_max_sectors = fabric_max_sectors;

1137

dev->dev_attrib.fabric_max_sectors = fabric_max_sectors;

1137

pr_debug("dev[%p]: SE Device max_sectors changed to %u\n",

1138

pr_debug("dev[%p]: SE Device max_sectors changed to %u\n",

1138

dev, fabric_max_sectors);

1139

dev, fabric_max_sectors);

1139

return 0;

1140

return 0;

1140

}

1141

}

1141

1142

int se_dev_set_optimal_sectors(struct se_device *dev, u32 optimal_sectors)

1143

int se_dev_set_optimal_sectors(struct se_device *dev, u32 optimal_sectors)

1143

{

1144

{

1144

if (dev->export_count) {

1145

if (dev->export_count) {

1145

pr_err("dev[%p]: Unable to change SE Device"

1146

pr_err("dev[%p]: Unable to change SE Device"

1146

" optimal_sectors while export_count is %d\n",

1147

" optimal_sectors while export_count is %d\n",

1147

dev, dev->export_count);

1148

dev, dev->export_count);

1148

return -EINVAL;

1149

return -EINVAL;

1149

}

1150

}

1150

if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

1151

if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

1151

pr_err("dev[%p]: Passed optimal_sectors cannot be"

1152

pr_err("dev[%p]: Passed optimal_sectors cannot be"

1152

" changed for TCM/pSCSI\n", dev);

1153

" changed for TCM/pSCSI\n", dev);

1153

return -EINVAL;

1154

return -EINVAL;

1154

}

1155

}

1155

if (optimal_sectors > dev->dev_attrib.fabric_max_sectors) {

1156

if (optimal_sectors > dev->dev_attrib.fabric_max_sectors) {

1156

pr_err("dev[%p]: Passed optimal_sectors %u cannot be"

1157

pr_err("dev[%p]: Passed optimal_sectors %u cannot be"

1157

" greater than fabric_max_sectors: %u\n", dev,

1158

" greater than fabric_max_sectors: %u\n", dev,

1158

optimal_sectors, dev->dev_attrib.fabric_max_sectors);

1159

optimal_sectors, dev->dev_attrib.fabric_max_sectors);

1159

return -EINVAL;

1160

return -EINVAL;

1160

}

1161

}

1161

1162

dev->dev_attrib.optimal_sectors = optimal_sectors;

1163

dev->dev_attrib.optimal_sectors = optimal_sectors;

1163

pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",

1164

pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",

1164

dev, optimal_sectors);

1165

dev, optimal_sectors);

1165

return 0;

1166

return 0;

1166

}

1167

}

1167

1168

int se_dev_set_block_size(struct se_device *dev, u32 block_size)

1169

int se_dev_set_block_size(struct se_device *dev, u32 block_size)

1169

{

1170

{

1170

if (dev->export_count) {

1171

if (dev->export_count) {

1171

pr_err("dev[%p]: Unable to change SE Device block_size"

1172

pr_err("dev[%p]: Unable to change SE Device block_size"

1172

" while export_count is %d\n",

1173

" while export_count is %d\n",

1173

dev, dev->export_count);

1174

dev, dev->export_count);

1174

return -EINVAL;

1175

return -EINVAL;

1175

}

1176

}

1176

1177

if ((block_size != 512) &&

1178

if ((block_size != 512) &&

1178

(block_size != 1024) &&

1179

(block_size != 1024) &&

1179

(block_size != 2048) &&

1180

(block_size != 2048) &&

1180

(block_size != 4096)) {

1181

(block_size != 4096)) {

1181

pr_err("dev[%p]: Illegal value for block_device: %u"

1182

pr_err("dev[%p]: Illegal value for block_device: %u"

1182

" for SE device, must be 512, 1024, 2048 or 4096\n",

1183

" for SE device, must be 512, 1024, 2048 or 4096\n",

1183

dev, block_size);

1184

dev, block_size);

1184

return -EINVAL;

1185

return -EINVAL;

1185

}

1186

}

1186

1187

if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

1188

if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {

1188

pr_err("dev[%p]: Not allowed to change block_size for"

1189

pr_err("dev[%p]: Not allowed to change block_size for"

1189

" Physical Device, use for Linux/SCSI to change"

1190

" Physical Device, use for Linux/SCSI to change"

1190

" block_size for underlying hardware\n", dev);

1191

" block_size for underlying hardware\n", dev);

1191

return -EINVAL;

1192

return -EINVAL;

1192

}

1193

}

1193

1194

dev->dev_attrib.block_size = block_size;

1195

dev->dev_attrib.block_size = block_size;

1195

pr_debug("dev[%p]: SE Device block_size changed to %u\n",

1196

pr_debug("dev[%p]: SE Device block_size changed to %u\n",

1196

dev, block_size);

1197

dev, block_size);

1197

1198

if (dev->dev_attrib.max_bytes_per_io)

1199

if (dev->dev_attrib.max_bytes_per_io)

1199

dev->dev_attrib.hw_max_sectors =

1200

dev->dev_attrib.hw_max_sectors =

1200

dev->dev_attrib.max_bytes_per_io / block_size;

1201

dev->dev_attrib.max_bytes_per_io / block_size;

1201

1202

return 0;

1203

return 0;

1203

}

1204

}

1204

1205

struct se_lun *core_dev_add_lun(

1206

struct se_lun *core_dev_add_lun(

1206

struct se_portal_group *tpg,

1207

struct se_portal_group *tpg,

1207

struct se_device *dev,

1208

struct se_device *dev,

1208

u32 unpacked_lun)

1209

u32 unpacked_lun)

1209

{

1210

{

1210

struct se_lun *lun;

1211

struct se_lun *lun;

1211

int rc;

1212

int rc;

1212

1213

lun = core_tpg_alloc_lun(tpg, unpacked_lun);

1214

lun = core_tpg_alloc_lun(tpg, unpacked_lun);

1214

if (IS_ERR(lun))

1215

if (IS_ERR(lun))

1215

return lun;

1216

return lun;

1216

1217

rc = core_tpg_add_lun(tpg, lun,

1218

rc = core_tpg_add_lun(tpg, lun,

1218

TRANSPORT_LUNFLAGS_READ_WRITE, dev);

1219

TRANSPORT_LUNFLAGS_READ_WRITE, dev);

1219

if (rc < 0)

1220

if (rc < 0)

1220

return ERR_PTR(rc);

1221

return ERR_PTR(rc);

1221

1222

pr_debug("%s_TPG[%u]_LUN[%u] - Activated %s Logical Unit from"

1223

pr_debug("%s_TPG[%u]_LUN[%u] - Activated %s Logical Unit from"

1223

" CORE HBA: %u\n", tpg->se_tpg_tfo->get_fabric_name(),

1224

" CORE HBA: %u\n", tpg->se_tpg_tfo->get_fabric_name(),

1224

tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,

1225

tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,

1225

tpg->se_tpg_tfo->get_fabric_name(), dev->se_hba->hba_id);

1226

tpg->se_tpg_tfo->get_fabric_name(), dev->se_hba->hba_id);

1226

/*

1227

/*

1227

* Update LUN maps for dynamically added initiators when

1228

* Update LUN maps for dynamically added initiators when

1228

* generate_node_acl is enabled.

1229

* generate_node_acl is enabled.

1229

*/

1230

*/

1230

if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) {

1231

if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) {

1231

struct se_node_acl *acl;

1232

struct se_node_acl *acl;

1232

spin_lock_irq(&tpg->acl_node_lock);

1233

spin_lock_irq(&tpg->acl_node_lock);

1233

list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {

1234

list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {

1234

if (acl->dynamic_node_acl &&

1235

if (acl->dynamic_node_acl &&

1235

(!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only ||

1236

(!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only ||

1236

!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) {

1237

!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) {

1237

spin_unlock_irq(&tpg->acl_node_lock);

1238

spin_unlock_irq(&tpg->acl_node_lock);

1238

core_tpg_add_node_to_devs(acl, tpg);

1239

core_tpg_add_node_to_devs(acl, tpg);

1239

spin_lock_irq(&tpg->acl_node_lock);

1240

spin_lock_irq(&tpg->acl_node_lock);

1240

}

1241

}

1241

}

1242

}

1242

spin_unlock_irq(&tpg->acl_node_lock);

1243

spin_unlock_irq(&tpg->acl_node_lock);

1243

}

1244

}

1244

1245

return lun;

1246

return lun;

1246

}

1247

}

1247

1248

/* core_dev_del_lun():

1249

/* core_dev_del_lun():

1249

*

1250

*

1250

*

1251

*

1251

*/

1252

*/

1252

int core_dev_del_lun(

1253

int core_dev_del_lun(

1253

struct se_portal_group *tpg,

1254

struct se_portal_group *tpg,

1254

u32 unpacked_lun)

1255

u32 unpacked_lun)

1255

{

1256

{

1256

struct se_lun *lun;

1257

struct se_lun *lun;

1257

1258

lun = core_tpg_pre_dellun(tpg, unpacked_lun);

1259

lun = core_tpg_pre_dellun(tpg, unpacked_lun);

1259

if (IS_ERR(lun))

1260

if (IS_ERR(lun))

1260

return PTR_ERR(lun);

1261

return PTR_ERR(lun);

1261

1262

core_tpg_post_dellun(tpg, lun);

1263

core_tpg_post_dellun(tpg, lun);

1263

1264

pr_debug("%s_TPG[%u]_LUN[%u] - Deactivated %s Logical Unit from"

1265

pr_debug("%s_TPG[%u]_LUN[%u] - Deactivated %s Logical Unit from"

1265

" device object\n", tpg->se_tpg_tfo->get_fabric_name(),

1266

" device object\n", tpg->se_tpg_tfo->get_fabric_name(),

1266

tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun,

1267

tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun,

1267

tpg->se_tpg_tfo->get_fabric_name());

1268

tpg->se_tpg_tfo->get_fabric_name());

1268

1269

return 0;

1270

return 0;

1270

}

1271

}

1271

1272

struct se_lun *core_get_lun_from_tpg(struct se_portal_group *tpg, u32 unpacked_lun)

1273

struct se_lun *core_get_lun_from_tpg(struct se_portal_group *tpg, u32 unpacked_lun)

1273

{

1274

{

1274

struct se_lun *lun;

1275

struct se_lun *lun;

1275

1276

spin_lock(&tpg->tpg_lun_lock);

1277

spin_lock(&tpg->tpg_lun_lock);

1277

if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {

1278

if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {

1278

pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS"

1279

pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS"

1279

"_PER_TPG-1: %u for Target Portal Group: %hu\n",

1280

"_PER_TPG-1: %u for Target Portal Group: %hu\n",

1280

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1281

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1281

TRANSPORT_MAX_LUNS_PER_TPG-1,

1282

TRANSPORT_MAX_LUNS_PER_TPG-1,

1282

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1283

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1283

spin_unlock(&tpg->tpg_lun_lock);

1284

spin_unlock(&tpg->tpg_lun_lock);

1284

return NULL;

1285

return NULL;

1285

}

1286

}

1286

lun = tpg->tpg_lun_list[unpacked_lun];

1287

lun = tpg->tpg_lun_list[unpacked_lun];

1287

1288

if (lun->lun_status != TRANSPORT_LUN_STATUS_FREE) {

1289

if (lun->lun_status != TRANSPORT_LUN_STATUS_FREE) {

1289

pr_err("%s Logical Unit Number: %u is not free on"

1290

pr_err("%s Logical Unit Number: %u is not free on"

1290

" Target Portal Group: %hu, ignoring request.\n",

1291

" Target Portal Group: %hu, ignoring request.\n",

1291

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1292

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1292

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1293

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1293

spin_unlock(&tpg->tpg_lun_lock);

1294

spin_unlock(&tpg->tpg_lun_lock);

1294

return NULL;

1295

return NULL;

1295

}

1296

}

1296

spin_unlock(&tpg->tpg_lun_lock);

1297

spin_unlock(&tpg->tpg_lun_lock);

1297

1298

return lun;

1299

return lun;

1299

}

1300

}

1300

1301

/* core_dev_get_lun():

1302

/* core_dev_get_lun():

1302

*

1303

*

1303

*

1304

*

1304

*/

1305

*/

1305

static struct se_lun *core_dev_get_lun(struct se_portal_group *tpg, u32 unpacked_lun)

1306

static struct se_lun *core_dev_get_lun(struct se_portal_group *tpg, u32 unpacked_lun)

1306

{

1307

{

1307

struct se_lun *lun;

1308

struct se_lun *lun;

1308

1309

spin_lock(&tpg->tpg_lun_lock);

1310

spin_lock(&tpg->tpg_lun_lock);

1310

if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {

1311

if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {

1311

pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER"

1312

pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER"

1312

"_TPG-1: %u for Target Portal Group: %hu\n",

1313

"_TPG-1: %u for Target Portal Group: %hu\n",

1313

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1314

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1314

TRANSPORT_MAX_LUNS_PER_TPG-1,

1315

TRANSPORT_MAX_LUNS_PER_TPG-1,

1315

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1316

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1316

spin_unlock(&tpg->tpg_lun_lock);

1317

spin_unlock(&tpg->tpg_lun_lock);

1317

return NULL;

1318

return NULL;

1318

}

1319

}

1319

lun = tpg->tpg_lun_list[unpacked_lun];

1320

lun = tpg->tpg_lun_list[unpacked_lun];

1320

1321

if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) {

1322

if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) {

1322

pr_err("%s Logical Unit Number: %u is not active on"

1323

pr_err("%s Logical Unit Number: %u is not active on"

1323

" Target Portal Group: %hu, ignoring request.\n",

1324

" Target Portal Group: %hu, ignoring request.\n",

1324

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1325

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1325

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1326

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1326

spin_unlock(&tpg->tpg_lun_lock);

1327

spin_unlock(&tpg->tpg_lun_lock);

1327

return NULL;

1328

return NULL;

1328

}

1329

}

1329

spin_unlock(&tpg->tpg_lun_lock);

1330

spin_unlock(&tpg->tpg_lun_lock);

1330

1331

return lun;

1332

return lun;

1332

}

1333

}

1333

1334

struct se_lun_acl *core_dev_init_initiator_node_lun_acl(

1335

struct se_lun_acl *core_dev_init_initiator_node_lun_acl(

1335

struct se_portal_group *tpg,

1336

struct se_portal_group *tpg,

1336

struct se_node_acl *nacl,

1337

struct se_node_acl *nacl,

1337

u32 mapped_lun,

1338

u32 mapped_lun,

1338

int *ret)

1339

int *ret)

1339

{

1340

{

1340

struct se_lun_acl *lacl;

1341

struct se_lun_acl *lacl;

1341

1342

if (strlen(nacl->initiatorname) >= TRANSPORT_IQN_LEN) {

1343

if (strlen(nacl->initiatorname) >= TRANSPORT_IQN_LEN) {

1343

pr_err("%s InitiatorName exceeds maximum size.\n",

1344

pr_err("%s InitiatorName exceeds maximum size.\n",

1344

tpg->se_tpg_tfo->get_fabric_name());

1345

tpg->se_tpg_tfo->get_fabric_name());

1345

*ret = -EOVERFLOW;

1346

*ret = -EOVERFLOW;

1346

return NULL;

1347

return NULL;

1347

}

1348

}

1348

lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL);

1349

lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL);

1349

if (!lacl) {

1350

if (!lacl) {

1350

pr_err("Unable to allocate memory for struct se_lun_acl.\n");

1351

pr_err("Unable to allocate memory for struct se_lun_acl.\n");

1351

*ret = -ENOMEM;

1352

*ret = -ENOMEM;

1352

return NULL;

1353

return NULL;

1353

}

1354

}

1354

1355

INIT_LIST_HEAD(&lacl->lacl_list);

1356

INIT_LIST_HEAD(&lacl->lacl_list);

1356

lacl->mapped_lun = mapped_lun;

1357

lacl->mapped_lun = mapped_lun;

1357

lacl->se_lun_nacl = nacl;

1358

lacl->se_lun_nacl = nacl;

1358

snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s",

1359

snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s",

1359

nacl->initiatorname);

1360

nacl->initiatorname);

1360

1361

return lacl;

1362

return lacl;

1362

}

1363

}

1363

1364

int core_dev_add_initiator_node_lun_acl(

1365

int core_dev_add_initiator_node_lun_acl(

1365

struct se_portal_group *tpg,

1366

struct se_portal_group *tpg,

1366

struct se_lun_acl *lacl,

1367

struct se_lun_acl *lacl,

1367

u32 unpacked_lun,

1368

u32 unpacked_lun,

1368

u32 lun_access)

1369

u32 lun_access)

1369

{

1370

{

1370

struct se_lun *lun;

1371

struct se_lun *lun;

1371

struct se_node_acl *nacl;

1372

struct se_node_acl *nacl;

1372

1373

lun = core_dev_get_lun(tpg, unpacked_lun);

1374

lun = core_dev_get_lun(tpg, unpacked_lun);

1374

if (!lun) {

1375

if (!lun) {

1375

pr_err("%s Logical Unit Number: %u is not active on"

1376

pr_err("%s Logical Unit Number: %u is not active on"

1376

" Target Portal Group: %hu, ignoring request.\n",

1377

" Target Portal Group: %hu, ignoring request.\n",

1377

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1378

tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,

1378

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1379

tpg->se_tpg_tfo->tpg_get_tag(tpg));

1379

return -EINVAL;

1380

return -EINVAL;

1380

}

1381

}

1381

1382

nacl = lacl->se_lun_nacl;

1383

nacl = lacl->se_lun_nacl;

1383

if (!nacl)

1384

if (!nacl)

1384

return -EINVAL;

1385

return -EINVAL;

1385

1386

if ((lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) &&

1387

if ((lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) &&

1387

(lun_access & TRANSPORT_LUNFLAGS_READ_WRITE))

1388

(lun_access & TRANSPORT_LUNFLAGS_READ_WRITE))

1388

lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;

1389

lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;

1389

1390

lacl->se_lun = lun;

1391

lacl->se_lun = lun;

1391

1392

if (core_enable_device_list_for_node(lun, lacl, lacl->mapped_lun,

1393

if (core_enable_device_list_for_node(lun, lacl, lacl->mapped_lun,

1393

lun_access, nacl, tpg) < 0)

1394

lun_access, nacl, tpg) < 0)

1394

return -EINVAL;

1395

return -EINVAL;

1395

1396

spin_lock(&lun->lun_acl_lock);

1397

spin_lock(&lun->lun_acl_lock);

1397

list_add_tail(&lacl->lacl_list, &lun->lun_acl_list);

1398

list_add_tail(&lacl->lacl_list, &lun->lun_acl_list);

1398

atomic_inc(&lun->lun_acl_count);

1399

atomic_inc(&lun->lun_acl_count);

1399

smp_mb__after_atomic();

1400

smp_mb__after_atomic();

1400

spin_unlock(&lun->lun_acl_lock);

1401

spin_unlock(&lun->lun_acl_lock);

1401

1402

pr_debug("%s_TPG[%hu]_LUN[%u->%u] - Added %s ACL for "

1403

pr_debug("%s_TPG[%hu]_LUN[%u->%u] - Added %s ACL for "

1403

" InitiatorNode: %s\n", tpg->se_tpg_tfo->get_fabric_name(),

1404

" InitiatorNode: %s\n", tpg->se_tpg_tfo->get_fabric_name(),

1404

tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun, lacl->mapped_lun,

1405

tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun, lacl->mapped_lun,

1405

(lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) ? "RW" : "RO",

1406

(lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) ? "RW" : "RO",

1406

lacl->initiatorname);

1407

lacl->initiatorname);

1407

/*

1408

/*

1408

* Check to see if there are any existing persistent reservation APTPL

1409

* Check to see if there are any existing persistent reservation APTPL

1409

* pre-registrations that need to be enabled for this LUN ACL..

1410

* pre-registrations that need to be enabled for this LUN ACL..

1410

*/

1411

*/

1411

core_scsi3_check_aptpl_registration(lun->lun_se_dev, tpg, lun, lacl);

1412

core_scsi3_check_aptpl_registration(lun->lun_se_dev, tpg, lun, lacl);

1412

return 0;

1413

return 0;

1413

}

1414

}

1414

1415

/* core_dev_del_initiator_node_lun_acl():

1416

/* core_dev_del_initiator_node_lun_acl():

1416

*

1417

*

1417

*

1418

*

1418

*/

1419

*/

1419

int core_dev_del_initiator_node_lun_acl(

1420

int core_dev_del_initiator_node_lun_acl(

1420

struct se_portal_group *tpg,

1421

struct se_portal_group *tpg,

1421

struct se_lun *lun,

1422

struct se_lun *lun,

1422

struct se_lun_acl *lacl)

1423

struct se_lun_acl *lacl)

1423

{

1424

{

1424

struct se_node_acl *nacl;

1425

struct se_node_acl *nacl;

1425

1426

nacl = lacl->se_lun_nacl;

1427

nacl = lacl->se_lun_nacl;

1427

if (!nacl)

1428

if (!nacl)

1428

return -EINVAL;

1429

return -EINVAL;

1429

1430

spin_lock(&lun->lun_acl_lock);

1431

spin_lock(&lun->lun_acl_lock);

1431

list_del(&lacl->lacl_list);

1432

list_del(&lacl->lacl_list);

1432

atomic_dec(&lun->lun_acl_count);

1433

atomic_dec(&lun->lun_acl_count);

1433

smp_mb__after_atomic();

1434

smp_mb__after_atomic();

1434

spin_unlock(&lun->lun_acl_lock);

1435

spin_unlock(&lun->lun_acl_lock);

1435

1436

core_disable_device_list_for_node(lun, NULL, lacl->mapped_lun,

1437

core_disable_device_list_for_node(lun, NULL, lacl->mapped_lun,

1437

TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);

1438

TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);

1438

1439

lacl->se_lun = NULL;

1440

lacl->se_lun = NULL;

1440

1441

pr_debug("%s_TPG[%hu]_LUN[%u] - Removed ACL for"

1442

pr_debug("%s_TPG[%hu]_LUN[%u] - Removed ACL for"

1442

" InitiatorNode: %s Mapped LUN: %u\n",

1443

" InitiatorNode: %s Mapped LUN: %u\n",

1443

tpg->se_tpg_tfo->get_fabric_name(),

1444

tpg->se_tpg_tfo->get_fabric_name(),

1444

tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,

1445

tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,

1445

lacl->initiatorname, lacl->mapped_lun);

1446

lacl->initiatorname, lacl->mapped_lun);

1446

1447

return 0;

1448

return 0;

1448

}

1449

}

1449

1450

void core_dev_free_initiator_node_lun_acl(

1451

void core_dev_free_initiator_node_lun_acl(

1451

struct se_portal_group *tpg,

1452

struct se_portal_group *tpg,

1452

struct se_lun_acl *lacl)

1453

struct se_lun_acl *lacl)

1453

{

1454

{

1454

pr_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s"

1455

pr_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s"

1455

" Mapped LUN: %u\n", tpg->se_tpg_tfo->get_fabric_name(),

1456

" Mapped LUN: %u\n", tpg->se_tpg_tfo->get_fabric_name(),

1456

tpg->se_tpg_tfo->tpg_get_tag(tpg),

1457

tpg->se_tpg_tfo->tpg_get_tag(tpg),

1457

tpg->se_tpg_tfo->get_fabric_name(),

1458

tpg->se_tpg_tfo->get_fabric_name(),

1458

lacl->initiatorname, lacl->mapped_lun);

1459

lacl->initiatorname, lacl->mapped_lun);

1459

1460

kfree(lacl);

1461

kfree(lacl);

1461

}

1462

}

1462

1463

static void scsi_dump_inquiry(struct se_device *dev)

1464

static void scsi_dump_inquiry(struct se_device *dev)

1464

{

1465

{

1465

struct t10_wwn *wwn = &dev->t10_wwn;

1466

struct t10_wwn *wwn = &dev->t10_wwn;

1466

char buf[17];

1467

char buf[17];

1467

int i, device_type;

1468

int i, device_type;

1468

/*

1469

/*

1469

* Print Linux/SCSI style INQUIRY formatting to the kernel ring buffer

1470

* Print Linux/SCSI style INQUIRY formatting to the kernel ring buffer

1470

*/

1471

*/

1471

for (i = 0; i < 8; i++)

1472

for (i = 0; i < 8; i++)

1472

if (wwn->vendor[i] >= 0x20)

1473

if (wwn->vendor[i] >= 0x20)

1473

buf[i] = wwn->vendor[i];

1474

buf[i] = wwn->vendor[i];

1474

else

1475

else

1475

buf[i] = ' ';

1476

buf[i] = ' ';

1476

buf[i] = '\0';

1477

buf[i] = '\0';

1477

pr_debug(" Vendor: %s\n", buf);

1478

pr_debug(" Vendor: %s\n", buf);

1478

1479

for (i = 0; i < 16; i++)

1480

for (i = 0; i < 16; i++)

1480

if (wwn->model[i] >= 0x20)

1481

if (wwn->model[i] >= 0x20)

1481

buf[i] = wwn->model[i];

1482

buf[i] = wwn->model[i];

1482

else

1483

else

1483

buf[i] = ' ';

1484

buf[i] = ' ';

1484

buf[i] = '\0';

1485

buf[i] = '\0';

1485

pr_debug(" Model: %s\n", buf);

1486

pr_debug(" Model: %s\n", buf);

1486

1487

for (i = 0; i < 4; i++)

1488

for (i = 0; i < 4; i++)

1488

if (wwn->revision[i] >= 0x20)

1489

if (wwn->revision[i] >= 0x20)

1489

buf[i] = wwn->revision[i];

1490

buf[i] = wwn->revision[i];

1490

else

1491

else

1491

buf[i] = ' ';

1492

buf[i] = ' ';

1492

buf[i] = '\0';

1493

buf[i] = '\0';

1493

pr_debug(" Revision: %s\n", buf);

1494

pr_debug(" Revision: %s\n", buf);

1494

1495

device_type = dev->transport->get_device_type(dev);

1496

device_type = dev->transport->get_device_type(dev);

1496

pr_debug(" Type: %s ", scsi_device_type(device_type));

1497

pr_debug(" Type: %s ", scsi_device_type(device_type));

1497

}

1498

}

1498

1499

struct se_device *target_alloc_device(struct se_hba *hba, const char *name)

1500

struct se_device *target_alloc_device(struct se_hba *hba, const char *name)

1500

{

1501

{

1501

struct se_device *dev;

1502

struct se_device *dev;

1502

struct se_lun *xcopy_lun;

1503

struct se_lun *xcopy_lun;

1503

1504

dev = hba->transport->alloc_device(hba, name);

1505

dev = hba->transport->alloc_device(hba, name);

1505

if (!dev)

1506

if (!dev)

1506

return NULL;

1507

return NULL;

1507

1508

dev->dev_link_magic = SE_DEV_LINK_MAGIC;

1509

dev->dev_link_magic = SE_DEV_LINK_MAGIC;

1509

dev->se_hba = hba;

1510

dev->se_hba = hba;

1510

dev->transport = hba->transport;

1511

dev->transport = hba->transport;

1511

dev->prot_length = sizeof(struct se_dif_v1_tuple);

1512

dev->prot_length = sizeof(struct se_dif_v1_tuple);

1512

1513

INIT_LIST_HEAD(&dev->dev_list);

1514

INIT_LIST_HEAD(&dev->dev_list);

1514

INIT_LIST_HEAD(&dev->dev_sep_list);

1515

INIT_LIST_HEAD(&dev->dev_sep_list);

1515

INIT_LIST_HEAD(&dev->dev_tmr_list);

1516

INIT_LIST_HEAD(&dev->dev_tmr_list);

1516

INIT_LIST_HEAD(&dev->delayed_cmd_list);

1517

INIT_LIST_HEAD(&dev->delayed_cmd_list);

1517

INIT_LIST_HEAD(&dev->state_list);

1518

INIT_LIST_HEAD(&dev->state_list);

1518

INIT_LIST_HEAD(&dev->qf_cmd_list);

1519

INIT_LIST_HEAD(&dev->qf_cmd_list);

1519

INIT_LIST_HEAD(&dev->g_dev_node);

1520

INIT_LIST_HEAD(&dev->g_dev_node);

1520

spin_lock_init(&dev->execute_task_lock);

1521

spin_lock_init(&dev->execute_task_lock);

1521

spin_lock_init(&dev->delayed_cmd_lock);

1522

spin_lock_init(&dev->delayed_cmd_lock);

1522

spin_lock_init(&dev->dev_reservation_lock);

1523

spin_lock_init(&dev->dev_reservation_lock);

1523

spin_lock_init(&dev->se_port_lock);

1524

spin_lock_init(&dev->se_port_lock);

1524

spin_lock_init(&dev->se_tmr_lock);

1525

spin_lock_init(&dev->se_tmr_lock);

1525

spin_lock_init(&dev->qf_cmd_lock);

1526

spin_lock_init(&dev->qf_cmd_lock);

1526

sema_init(&dev->caw_sem, 1);

1527

sema_init(&dev->caw_sem, 1);

1527

atomic_set(&dev->dev_ordered_id, 0);

1528

atomic_set(&dev->dev_ordered_id, 0);

1528

INIT_LIST_HEAD(&dev->t10_wwn.t10_vpd_list);

1529

INIT_LIST_HEAD(&dev->t10_wwn.t10_vpd_list);

1529

spin_lock_init(&dev->t10_wwn.t10_vpd_lock);

1530

spin_lock_init(&dev->t10_wwn.t10_vpd_lock);

1530

INIT_LIST_HEAD(&dev->t10_pr.registration_list);

1531

INIT_LIST_HEAD(&dev->t10_pr.registration_list);

1531

INIT_LIST_HEAD(&dev->t10_pr.aptpl_reg_list);

1532

INIT_LIST_HEAD(&dev->t10_pr.aptpl_reg_list);

1532

spin_lock_init(&dev->t10_pr.registration_lock);

1533

spin_lock_init(&dev->t10_pr.registration_lock);

1533

spin_lock_init(&dev->t10_pr.aptpl_reg_lock);

1534

spin_lock_init(&dev->t10_pr.aptpl_reg_lock);

1534

INIT_LIST_HEAD(&dev->t10_alua.tg_pt_gps_list);

1535

INIT_LIST_HEAD(&dev->t10_alua.tg_pt_gps_list);

1535

spin_lock_init(&dev->t10_alua.tg_pt_gps_lock);

1536

spin_lock_init(&dev->t10_alua.tg_pt_gps_lock);

1536

INIT_LIST_HEAD(&dev->t10_alua.lba_map_list);

1537

INIT_LIST_HEAD(&dev->t10_alua.lba_map_list);

1537

spin_lock_init(&dev->t10_alua.lba_map_lock);

1538

spin_lock_init(&dev->t10_alua.lba_map_lock);

1538

1539

dev->t10_wwn.t10_dev = dev;

1540

dev->t10_wwn.t10_dev = dev;

1540

dev->t10_alua.t10_dev = dev;

1541

dev->t10_alua.t10_dev = dev;

1541

1542

dev->dev_attrib.da_dev = dev;

1543

dev->dev_attrib.da_dev = dev;

1543

dev->dev_attrib.emulate_model_alias = DA_EMULATE_MODEL_ALIAS;

1544

dev->dev_attrib.emulate_model_alias = DA_EMULATE_MODEL_ALIAS;

1544

dev->dev_attrib.emulate_dpo = DA_EMULATE_DPO;

1545

dev->dev_attrib.emulate_dpo = DA_EMULATE_DPO;

1545

dev->dev_attrib.emulate_fua_write = DA_EMULATE_FUA_WRITE;

1546

dev->dev_attrib.emulate_fua_write = DA_EMULATE_FUA_WRITE;

1546

dev->dev_attrib.emulate_fua_read = DA_EMULATE_FUA_READ;

1547

dev->dev_attrib.emulate_fua_read = DA_EMULATE_FUA_READ;

1547

dev->dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE;

1548

dev->dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE;

1548

dev->dev_attrib.emulate_ua_intlck_ctrl = DA_EMULATE_UA_INTLLCK_CTRL;

1549

dev->dev_attrib.emulate_ua_intlck_ctrl = DA_EMULATE_UA_INTLLCK_CTRL;

1549

dev->dev_attrib.emulate_tas = DA_EMULATE_TAS;

1550

dev->dev_attrib.emulate_tas = DA_EMULATE_TAS;

1550

dev->dev_attrib.emulate_tpu = DA_EMULATE_TPU;

1551

dev->dev_attrib.emulate_tpu = DA_EMULATE_TPU;

1551

dev->dev_attrib.emulate_tpws = DA_EMULATE_TPWS;

1552

dev->dev_attrib.emulate_tpws = DA_EMULATE_TPWS;

1552

dev->dev_attrib.emulate_caw = DA_EMULATE_CAW;

1553

dev->dev_attrib.emulate_caw = DA_EMULATE_CAW;

1553

dev->dev_attrib.emulate_3pc = DA_EMULATE_3PC;

1554

dev->dev_attrib.emulate_3pc = DA_EMULATE_3PC;

1554

dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE0_PROT;

1555

dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE0_PROT;

1555

dev->dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS;

1556

dev->dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS;

1556

dev->dev_attrib.is_nonrot = DA_IS_NONROT;

1557

dev->dev_attrib.is_nonrot = DA_IS_NONROT;

1557

dev->dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD;

1558

dev->dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD;

1558

dev->dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT;

1559

dev->dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT;

1559

dev->dev_attrib.max_unmap_block_desc_count =

1560

dev->dev_attrib.max_unmap_block_desc_count =

1560

DA_MAX_UNMAP_BLOCK_DESC_COUNT;

1561

DA_MAX_UNMAP_BLOCK_DESC_COUNT;

1561

dev->dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT;

1562

dev->dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT;

1562

dev->dev_attrib.unmap_granularity_alignment =

1563

dev->dev_attrib.unmap_granularity_alignment =

1563

DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT;

1564

DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT;

1564

dev->dev_attrib.max_write_same_len = DA_MAX_WRITE_SAME_LEN;

1565

dev->dev_attrib.max_write_same_len = DA_MAX_WRITE_SAME_LEN;

1565

dev->dev_attrib.fabric_max_sectors = DA_FABRIC_MAX_SECTORS;

1566

dev->dev_attrib.fabric_max_sectors = DA_FABRIC_MAX_SECTORS;

1566

dev->dev_attrib.optimal_sectors = DA_FABRIC_MAX_SECTORS;

1567

dev->dev_attrib.optimal_sectors = DA_FABRIC_MAX_SECTORS;

1567

1568

xcopy_lun = &dev->xcopy_lun;

1569

xcopy_lun = &dev->xcopy_lun;

1569

xcopy_lun->lun_se_dev = dev;

1570

xcopy_lun->lun_se_dev = dev;

1570

init_completion(&xcopy_lun->lun_shutdown_comp);

1571

init_completion(&xcopy_lun->lun_shutdown_comp);

1571

INIT_LIST_HEAD(&xcopy_lun->lun_acl_list);

1572

INIT_LIST_HEAD(&xcopy_lun->lun_acl_list);

1572

spin_lock_init(&xcopy_lun->lun_acl_lock);

1573

spin_lock_init(&xcopy_lun->lun_acl_lock);

1573

spin_lock_init(&xcopy_lun->lun_sep_lock);

1574

spin_lock_init(&xcopy_lun->lun_sep_lock);

1574

init_completion(&xcopy_lun->lun_ref_comp);

1575

init_completion(&xcopy_lun->lun_ref_comp);

1575

1576

return dev;

1577

return dev;

1577

}

1578

}

1578

1579

int target_configure_device(struct se_device *dev)

1580

int target_configure_device(struct se_device *dev)

1580

{

1581

{

1581

struct se_hba *hba = dev->se_hba;

1582

struct se_hba *hba = dev->se_hba;

1582

int ret;

1583

int ret;

1583

1584

if (dev->dev_flags & DF_CONFIGURED) {

1585

if (dev->dev_flags & DF_CONFIGURED) {

1585

pr_err("se_dev->se_dev_ptr already set for storage"

1586

pr_err("se_dev->se_dev_ptr already set for storage"

1586

" object\n");

1587

" object\n");

1587

return -EEXIST;

1588

return -EEXIST;

1588

}

1589

}

1589

1590

ret = dev->transport->configure_device(dev);

1591

ret = dev->transport->configure_device(dev);

1591

if (ret)

1592

if (ret)

1592

goto out;

1593

goto out;

1593

dev->dev_flags |= DF_CONFIGURED;

1594

dev->dev_flags |= DF_CONFIGURED;

1594

1595

/*

1596

/*

1596

* XXX: there is not much point to have two different values here..

1597

* XXX: there is not much point to have two different values here..

1597

*/

1598

*/

1598

dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size;

1599

dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size;

1599

dev->dev_attrib.queue_depth = dev->dev_attrib.hw_queue_depth;

1600

dev->dev_attrib.queue_depth = dev->dev_attrib.hw_queue_depth;

1600

1601

/*

1602

/*

1602

* Align max_hw_sectors down to PAGE_SIZE I/O transfers

1603

* Align max_hw_sectors down to PAGE_SIZE I/O transfers

1603

*/

1604

*/

1604

dev->dev_attrib.hw_max_sectors =

1605

dev->dev_attrib.hw_max_sectors =

1605

se_dev_align_max_sectors(dev->dev_attrib.hw_max_sectors,

1606

se_dev_align_max_sectors(dev->dev_attrib.hw_max_sectors,

1606

dev->dev_attrib.hw_block_size);

1607

dev->dev_attrib.hw_block_size);

1607

1608

dev->dev_index = scsi_get_new_index(SCSI_DEVICE_INDEX);

1609

dev->dev_index = scsi_get_new_index(SCSI_DEVICE_INDEX);

1609

dev->creation_time = get_jiffies_64();

1610

dev->creation_time = get_jiffies_64();

1610

1611

ret = core_setup_alua(dev);

1612

ret = core_setup_alua(dev);

1612

if (ret)

1613

if (ret)

1613

goto out;

1614

goto out;

1614

1615

/*

1616

/*

1616

* Startup the struct se_device processing thread

1617

* Startup the struct se_device processing thread

1617

*/

1618

*/

1618

dev->tmr_wq = alloc_workqueue("tmr-%s", WQ_MEM_RECLAIM | WQ_UNBOUND, 1,

1619

dev->tmr_wq = alloc_workqueue("tmr-%s", WQ_MEM_RECLAIM | WQ_UNBOUND, 1,

1619

dev->transport->name);

1620

dev->transport->name);

1620

if (!dev->tmr_wq) {

1621

if (!dev->tmr_wq) {

1621

pr_err("Unable to create tmr workqueue for %s\n",

1622

pr_err("Unable to create tmr workqueue for %s\n",

1622

dev->transport->name);

1623

dev->transport->name);

1623

ret = -ENOMEM;

1624

ret = -ENOMEM;

1624

goto out_free_alua;

1625

goto out_free_alua;

1625

}

1626

}

1626

1627

/*

1628

/*

1628

* Setup work_queue for QUEUE_FULL

1629

* Setup work_queue for QUEUE_FULL

1629

*/

1630

*/

1630

INIT_WORK(&dev->qf_work_queue, target_qf_do_work);

1631

INIT_WORK(&dev->qf_work_queue, target_qf_do_work);

1631

1632

/*

1633

/*

1633

* Preload the initial INQUIRY const values if we are doing

1634

* Preload the initial INQUIRY const values if we are doing

1634

* anything virtual (IBLOCK, FILEIO, RAMDISK), but not for TCM/pSCSI

1635

* anything virtual (IBLOCK, FILEIO, RAMDISK), but not for TCM/pSCSI

1635

* passthrough because this is being provided by the backend LLD.

1636

* passthrough because this is being provided by the backend LLD.

1636

*/

1637

*/

1637

if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV) {

1638

if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV) {

1638

strncpy(&dev->t10_wwn.vendor[0], "LIO-ORG", 8);

1639

strncpy(&dev->t10_wwn.vendor[0], "LIO-ORG", 8);

1639

strncpy(&dev->t10_wwn.model[0],

1640

strncpy(&dev->t10_wwn.model[0],

1640

dev->transport->inquiry_prod, 16);

1641

dev->transport->inquiry_prod, 16);

1641

strncpy(&dev->t10_wwn.revision[0],

1642

strncpy(&dev->t10_wwn.revision[0],

1642

dev->transport->inquiry_rev, 4);

1643

dev->transport->inquiry_rev, 4);

1643

}

1644

}

1644

1645

scsi_dump_inquiry(dev);

1646

scsi_dump_inquiry(dev);

1646

1647

spin_lock(&hba->device_lock);

1648

spin_lock(&hba->device_lock);

1648

hba->dev_count++;

1649

hba->dev_count++;

1649

spin_unlock(&hba->device_lock);

1650

spin_unlock(&hba->device_lock);

1650

1651

mutex_lock(&g_device_mutex);

1652

mutex_lock(&g_device_mutex);

1652

list_add_tail(&dev->g_dev_node, &g_device_list);

1653

list_add_tail(&dev->g_dev_node, &g_device_list);

1653

mutex_unlock(&g_device_mutex);

1654

mutex_unlock(&g_device_mutex);

1654

1655

return 0;

1656

return 0;

1656

1657

out_free_alua:

1658

out_free_alua:

1658

core_alua_free_lu_gp_mem(dev);

1659

core_alua_free_lu_gp_mem(dev);

1659

out:

1660

out:

1660

se_release_vpd_for_dev(dev);

1661

se_release_vpd_for_dev(dev);

1661

return ret;

1662

return ret;

1662

}

1663

}

1663

1664

void target_free_device(struct se_device *dev)

1665

void target_free_device(struct se_device *dev)

1665

{

1666

{

1666

struct se_hba *hba = dev->se_hba;

1667

struct se_hba *hba = dev->se_hba;

1667

1668

WARN_ON(!list_empty(&dev->dev_sep_list));

1669

WARN_ON(!list_empty(&dev->dev_sep_list));

1669

1670

if (dev->dev_flags & DF_CONFIGURED) {

1671

if (dev->dev_flags & DF_CONFIGURED) {

1671

destroy_workqueue(dev->tmr_wq);

1672

destroy_workqueue(dev->tmr_wq);

1672

1673

mutex_lock(&g_device_mutex);

1674

mutex_lock(&g_device_mutex);

1674

list_del(&dev->g_dev_node);

1675

list_del(&dev->g_dev_node);

1675

mutex_unlock(&g_device_mutex);

1676

mutex_unlock(&g_device_mutex);

1676

1677

spin_lock(&hba->device_lock);

1678

spin_lock(&hba->device_lock);

1678

hba->dev_count--;

1679

hba->dev_count--;

1679

spin_unlock(&hba->device_lock);

1680

spin_unlock(&hba->device_lock);

1680

}

1681

}

1681

1682

core_alua_free_lu_gp_mem(dev);

1683

core_alua_free_lu_gp_mem(dev);

1683

core_alua_set_lba_map(dev, NULL, 0, 0);

1684

core_alua_set_lba_map(dev, NULL, 0, 0);

1684

core_scsi3_free_all_registrations(dev);

1685

core_scsi3_free_all_registrations(dev);

1685

se_release_vpd_for_dev(dev);

1686

se_release_vpd_for_dev(dev);

1686

1687

if (dev->transport->free_prot)

1688

if (dev->transport->free_prot)

1688

dev->transport->free_prot(dev);

1689

dev->transport->free_prot(dev);

1689

1690

dev->transport->free_device(dev);

1691

dev->transport->free_device(dev);

1691

}

1692

}

1692

1693

int core_dev_setup_virtual_lun0(void)

1694

int core_dev_setup_virtual_lun0(void)

1694

{

1695

{

1695

struct se_hba *hba;

1696

struct se_hba *hba;

1696

struct se_device *dev;

1697

struct se_device *dev;

1697

char buf[] = "rd_pages=8,rd_nullio=1";

1698

char buf[] = "rd_pages=8,rd_nullio=1";

1698

int ret;

1699

int ret;

1699

1700

hba = core_alloc_hba("rd_mcp", 0, HBA_FLAGS_INTERNAL_USE);

1701

hba = core_alloc_hba("rd_mcp", 0, HBA_FLAGS_INTERNAL_USE);

1701

if (IS_ERR(hba))

1702

if (IS_ERR(hba))

1702

return PTR_ERR(hba);

1703

return PTR_ERR(hba);

1703

1704

dev = target_alloc_device(hba, "virt_lun0");

1705

dev = target_alloc_device(hba, "virt_lun0");

1705

if (!dev) {

1706

if (!dev) {

1706

ret = -ENOMEM;

1707

ret = -ENOMEM;

1707

goto out_free_hba;

1708

goto out_free_hba;

1708

}

1709

}

1709

1710

hba->transport->set_configfs_dev_params(dev, buf, sizeof(buf));

1711

hba->transport->set_configfs_dev_params(dev, buf, sizeof(buf));

1711

1712

ret = target_configure_device(dev);

1713

ret = target_configure_device(dev);

1713

if (ret)

1714

if (ret)

1714

goto out_free_se_dev;

1715

goto out_free_se_dev;

1715

1716

lun0_hba = hba;

1717

lun0_hba = hba;

1717

g_lun0_dev = dev;

1718

g_lun0_dev = dev;

1718

return 0;

1719

return 0;

1719

1720

out_free_se_dev:

1721

out_free_se_dev:

1721

target_free_device(dev);

1722

target_free_device(dev);

1722

out_free_hba:

1723

out_free_hba:

1723

core_delete_hba(hba);

1724

core_delete_hba(hba);

1724

return ret;

1725

return ret;

1725

}

1726

}

1726

1727

1728

void core_dev_release_virtual_lun0(void)

1729

void core_dev_release_virtual_lun0(void)

1729

{

1730

{

1730

struct se_hba *hba = lun0_hba;

1731

struct se_hba *hba = lun0_hba;

1731

1732

if (!hba)

1733

if (!hba)

1733

return;

1734

return;

1734

1735

if (g_lun0_dev)

1736

if (g_lun0_dev)

1736

target_free_device(g_lun0_dev);

1737

target_free_device(g_lun0_dev);

1737

core_delete_hba(hba);

1738

core_delete_hba(hba);

1738

}

1739

}

1739

1740

GITLAB

target: Fix left-over se_lun->lun_sep pointer OOPs

 /*******************************************************************************
  * Filename:  target_core_device.c (based on iscsi_target_device.c)
  *
  * This file contains the TCM Virtual Device and Disk Transport
  * agnostic related functions.
  *
  * (c) Copyright 2003-2013 Datera, Inc.
  *
  * 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 <linux/export.h>
 #include <net/sock.h>
 #include <net/tcp.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
 #include <target/target_core_base.h>
 #include <target/target_core_backend.h>
 #include <target/target_core_fabric.h>
 #include "target_core_internal.h"
 #include "target_core_alua.h"
 #include "target_core_pr.h"
 #include "target_core_ua.h"
 DEFINE_MUTEX(g_device_mutex);
 LIST_HEAD(g_device_list);
 static struct se_hba *lun0_hba;
 /* not static, needed by tpg.c */
 struct se_device *g_lun0_dev;
 sense_reason_t
 transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
 {
 	struct se_lun *se_lun = NULL;
 	struct se_session *se_sess = se_cmd->se_sess;
 	struct se_device *dev;
 	unsigned long flags;
 	if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)
 		return TCM_NON_EXISTENT_LUN;
 	spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
 	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++;
 		if ((se_cmd->data_direction == DMA_TO_DEVICE) &&
 		    (deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)) {
 			pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN"
 				" Access for 0x%08x\n",
 				se_cmd->se_tfo->get_fabric_name(),
 				unpacked_lun);
 			spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
 			return TCM_WRITE_PROTECTED;
 		}
 		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;
 		se_lun = deve->se_lun;
 		se_cmd->se_lun = deve->se_lun;
 		se_cmd->pr_res_key = deve->pr_res_key;
 		se_cmd->orig_fe_lun = unpacked_lun;
 		se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
 		percpu_ref_get(&se_lun->lun_ref);
 		se_cmd->lun_ref_active = true;
 	}
 	spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
 	if (!se_lun) {
 		/*
 		 * 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) {
 			pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
 				" Access for 0x%08x\n",
 				se_cmd->se_tfo->get_fabric_name(),
 				unpacked_lun);
 			return TCM_NON_EXISTENT_LUN;
 		}
 		/*
 		 * Force WRITE PROTECT for virtual LUN 0
 		 */
 		if ((se_cmd->data_direction != DMA_FROM_DEVICE) &&
 		    (se_cmd->data_direction != DMA_NONE))
 			return TCM_WRITE_PROTECTED;
 		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_cmd_flags |= SCF_SE_LUN_CMD;
 		percpu_ref_get(&se_lun->lun_ref);
 		se_cmd->lun_ref_active = true;
 	}
 	/* Directly associate cmd with se_dev */
 	se_cmd->se_dev = se_lun->lun_se_dev;
 	dev = se_lun->lun_se_dev;
 	atomic_long_inc(&dev->num_cmds);
 	if (se_cmd->data_direction == DMA_TO_DEVICE)
 		atomic_long_add(se_cmd->data_length, &dev->write_bytes);
 	else if (se_cmd->data_direction == DMA_FROM_DEVICE)
 		atomic_long_add(se_cmd->data_length, &dev->read_bytes);
 	return 0;
 }
 EXPORT_SYMBOL(transport_lookup_cmd_lun);
 int transport_lookup_tmr_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
 {
 	struct se_dev_entry *deve;
 	struct se_lun *se_lun = NULL;
 	struct se_session *se_sess = se_cmd->se_sess;
 	struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;
 	unsigned long flags;
 	if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG)
 		return -ENODEV;
 	spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
 	se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];
 	deve = se_cmd->se_deve;
 	if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
 		se_tmr->tmr_lun = deve->se_lun;
 		se_cmd->se_lun = deve->se_lun;
 		se_lun = deve->se_lun;
 		se_cmd->pr_res_key = deve->pr_res_key;
 		se_cmd->orig_fe_lun = unpacked_lun;
 	}
 	spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
 	if (!se_lun) {
 		pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
 			" Access for 0x%08x\n",
 			se_cmd->se_tfo->get_fabric_name(),
 			unpacked_lun);
 		return -ENODEV;
 	}
 	/* Directly associate cmd with se_dev */
 	se_cmd->se_dev = se_lun->lun_se_dev;
 	se_tmr->tmr_dev = se_lun->lun_se_dev;
 	spin_lock_irqsave(&se_tmr->tmr_dev->se_tmr_lock, flags);
 	list_add_tail(&se_tmr->tmr_list, &se_tmr->tmr_dev->dev_tmr_list);
 	spin_unlock_irqrestore(&se_tmr->tmr_dev->se_tmr_lock, flags);
 	return 0;
 }
 EXPORT_SYMBOL(transport_lookup_tmr_lun);
 /*
  * 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;
 		if (!lun) {
 			pr_err("%s device entries device pointer is"
 				" NULL, but Initiator has access.\n",
 				tpg->se_tpg_tfo->get_fabric_name());
 			continue;
 		}
 		port = lun->lun_sep;
 		if (!port) {
 			pr_err("%s device entries device pointer is"
 				" NULL, but Initiator has access.\n",
 				tpg->se_tpg_tfo->get_fabric_name());
 			continue;
 		}
 		if (port->sep_rtpi != rtpi)
 			continue;
 		atomic_inc(&deve->pr_ref_count);
 		smp_mb__after_atomic();
 		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) {
 			pr_err("%s device entries device pointer is"
 				" NULL, but Initiator has access.\n",
 				tpg->se_tpg_tfo->get_fabric_name());
 			continue;
 		}
 		lun = deve->se_lun;
 		spin_unlock_irq(&nacl->device_list_lock);
 		core_disable_device_list_for_node(lun, NULL, deve->mapped_lun,
 			TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
 		spin_lock_irq(&nacl->device_list_lock);
 	}
 	spin_unlock_irq(&nacl->device_list_lock);
 	array_free(nacl->device_list, TRANSPORT_MAX_LUNS_PER_TPG);
 	nacl->device_list = NULL;
 	return 0;
 }
 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_enable_device_list_for_node():
  *
  *
  */
 int core_enable_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)
 {
 	struct se_port *port = lun->lun_sep;
 	struct se_dev_entry *deve;
 	spin_lock_irq(&nacl->device_list_lock);
 	deve = nacl->device_list[mapped_lun];
 	/*
 	 * Check if the call is handling demo mode -> explicit 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) {
 			pr_err("struct se_dev_entry->se_lun_acl"
 			       " already set for demo mode -> explicit"
 			       " LUN ACL transition\n");
 			spin_unlock_irq(&nacl->device_list_lock);
 			return -EINVAL;
 		}
 		if (deve->se_lun != lun) {
 			pr_err("struct se_dev_entry->se_lun does"
 			       " match passed struct se_lun for demo mode"
 			       " -> explicit LUN ACL transition\n");
 			spin_unlock_irq(&nacl->device_list_lock);
 			return -EINVAL;
 		}
 		deve->se_lun_acl = lun_acl;
 		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);
 		return 0;
 	}
 	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;
 	}
 	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;
 }
 /*      core_disable_device_list_for_node():
  *
  *
  */
 int core_disable_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)
 {
 	struct se_port *port = lun->lun_sep;
 	struct se_dev_entry *deve = nacl->device_list[mapped_lun];
 	/*
 	 * 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.
 	 *
 	 * deve->se_lun_acl will be NULL for demo-mode created LUNs
 	 * that have not been explicitly converted to MappedLUNs ->
 	 * 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..
 	 */
 	spin_lock_bh(&port->sep_alua_lock);
 	list_del(&deve->alua_port_list);
 	spin_unlock_bh(&port->sep_alua_lock);
 	/*
 	 * Wait for any in process SPEC_I_PT=1 or REGISTER_AND_MOVE
 	 * PR operation to complete.
 	 */
 	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;
 	spin_lock_irq(&tpg->acl_node_lock);
 	list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {
 		spin_unlock_irq(&tpg->acl_node_lock);
 		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_disable_device_list_for_node(lun, NULL,
 				deve->mapped_lun, TRANSPORT_LUNFLAGS_NO_ACCESS,
 				nacl, tpg);
 			spin_lock_irq(&nacl->device_list_lock);
 		}
 		spin_unlock_irq(&nacl->device_list_lock);
 		spin_lock_irq(&tpg->acl_node_lock);
 	}
 	spin_unlock_irq(&tpg->acl_node_lock);
 }
 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);
 	if (!port) {
 		pr_err("Unable to allocate struct se_port\n");
 		return ERR_PTR(-ENOMEM);
 	}
 	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) {
 		pr_warn("Reached dev->dev_port_count =="
 				" 0x0000ffff\n");
 		spin_unlock(&dev->se_port_lock);
 		return ERR_PTR(-ENOSPC);
 	}
 again:
 	/*
 	 * Allocate the next RELATIVE TARGET PORT IDENTIFIER 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++;
 	if (!port->sep_rtpi)
 		goto again;
 	list_for_each_entry(port_tmp, &dev->dev_sep_list, sep_list) {
 		/*
 		 * Make sure RELATIVE TARGET PORT IDENTIFIER 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)
 {
 	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);
 	if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV &&
 	    !(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE)) {
 		tg_pt_gp_mem = core_alua_allocate_tg_pt_gp_mem(port);
 		if (IS_ERR(tg_pt_gp_mem) || !tg_pt_gp_mem) {
 			pr_err("Unable to allocate t10_alua_tg_pt"
 					"_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,
 			dev->t10_alua.default_tg_pt_gp);
 		spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
 		pr_debug("%s/%s: Adding to default ALUA Target Port"
 			" Group: alua/default_tg_pt_gp\n",
 			dev->transport->name, tpg->se_tpg_tfo->get_fabric_name());
 	}
 	dev->dev_port_count++;
 	port->sep_index = port->sep_rtpi; /* RELATIVE TARGET PORT IDENTIFIER */
 }
 /*
  *	Called with struct se_device->se_port_lock spinlock held.
  */
 static void core_release_port(struct se_device *dev, struct se_port *port)
 	__releases(&dev->se_port_lock) __acquires(&dev->se_port_lock)
 {
 	/*
 	 * 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_hba *hba = dev->se_hba;
 	struct se_port *port;
 	port = core_alloc_port(dev);
 	if (IS_ERR(port))
 		return PTR_ERR(port);
 	lun->lun_se_dev = dev;
 	spin_lock(&hba->device_lock);
 	dev->export_count++;
 	spin_unlock(&hba->device_lock);
 	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_hba *hba = dev->se_hba;
 	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);
 	core_release_port(dev, port);
 	spin_unlock(&dev->se_port_lock);
 	spin_lock(&hba->device_lock);
 	dev->export_count--;
 	spin_unlock(&hba->device_lock);
+	lun->lun_sep = NULL;
 	lun->lun_se_dev = NULL;
 }
 static void se_release_vpd_for_dev(struct se_device *dev)
 {
 	struct t10_vpd *vpd, *vpd_tmp;
 	spin_lock(&dev->t10_wwn.t10_vpd_lock);
 	list_for_each_entry_safe(vpd, vpd_tmp,
 			&dev->t10_wwn.t10_vpd_list, vpd_list) {
 		list_del(&vpd->vpd_list);
 		kfree(vpd);
 	}
 	spin_unlock(&dev->t10_wwn.t10_vpd_lock);
 }
 static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
 {
 	u32 aligned_max_sectors;
 	u32 alignment;
 	/*
 	 * Limit max_sectors to a PAGE_SIZE aligned value for modern
 	 * transport_allocate_data_tasks() operation.
 	 */
 	alignment = max(1ul, PAGE_SIZE / block_size);
 	aligned_max_sectors = rounddown(max_sectors, alignment);
 	if (max_sectors != aligned_max_sectors)
 		pr_info("Rounding down aligned max_sectors from %u to %u\n",
 			max_sectors, aligned_max_sectors);
 	return aligned_max_sectors;
 }
 int se_dev_set_max_unmap_lba_count(
 	struct se_device *dev,
 	u32 max_unmap_lba_count)
 {
 	dev->dev_attrib.max_unmap_lba_count = max_unmap_lba_count;
 	pr_debug("dev[%p]: Set max_unmap_lba_count: %u\n",
 			dev, dev->dev_attrib.max_unmap_lba_count);
 	return 0;
 }
 int se_dev_set_max_unmap_block_desc_count(
 	struct se_device *dev,
 	u32 max_unmap_block_desc_count)
 {
 	dev->dev_attrib.max_unmap_block_desc_count =
 		max_unmap_block_desc_count;
 	pr_debug("dev[%p]: Set max_unmap_block_desc_count: %u\n",
 			dev, dev->dev_attrib.max_unmap_block_desc_count);
 	return 0;
 }
 int se_dev_set_unmap_granularity(
 	struct se_device *dev,
 	u32 unmap_granularity)
 {
 	dev->dev_attrib.unmap_granularity = unmap_granularity;
 	pr_debug("dev[%p]: Set unmap_granularity: %u\n",
 			dev, dev->dev_attrib.unmap_granularity);
 	return 0;
 }
 int se_dev_set_unmap_granularity_alignment(
 	struct se_device *dev,
 	u32 unmap_granularity_alignment)
 {
 	dev->dev_attrib.unmap_granularity_alignment = unmap_granularity_alignment;
 	pr_debug("dev[%p]: Set unmap_granularity_alignment: %u\n",
 			dev, dev->dev_attrib.unmap_granularity_alignment);
 	return 0;
 }
 int se_dev_set_max_write_same_len(
 	struct se_device *dev,
 	u32 max_write_same_len)
 {
 	dev->dev_attrib.max_write_same_len = max_write_same_len;
 	pr_debug("dev[%p]: Set max_write_same_len: %u\n",
 			dev, dev->dev_attrib.max_write_same_len);
 	return 0;
 }
 static void dev_set_t10_wwn_model_alias(struct se_device *dev)
 {
 	const char *configname;
 	configname = config_item_name(&dev->dev_group.cg_item);
 	if (strlen(configname) >= 16) {
 		pr_warn("dev[%p]: Backstore name '%s' is too long for "
 			"INQUIRY_MODEL, truncating to 16 bytes\n", dev,
 			configname);
 	}
 	snprintf(&dev->t10_wwn.model[0], 16, "%s", configname);
 }
 int se_dev_set_emulate_model_alias(struct se_device *dev, int flag)
 {
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change model alias"
 			" while export_count is %d\n",
 			dev, dev->export_count);
 			return -EINVAL;
 	}
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (flag) {
 		dev_set_t10_wwn_model_alias(dev);
 	} else {
 		strncpy(&dev->t10_wwn.model[0],
 			dev->transport->inquiry_prod, 16);
 	}
 	dev->dev_attrib.emulate_model_alias = flag;
 	return 0;
 }
 int se_dev_set_emulate_dpo(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (flag) {
 		pr_err("dpo_emulated not supported\n");
 		return -EINVAL;
 	}
 	return 0;
 }
 int se_dev_set_emulate_fua_write(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (flag &&
 	    dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		pr_err("emulate_fua_write not supported for pSCSI\n");
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_fua_write = flag;
 	pr_debug("dev[%p]: SE Device Forced Unit Access WRITEs: %d\n",
 			dev, dev->dev_attrib.emulate_fua_write);
 	return 0;
 }
 int se_dev_set_emulate_fua_read(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (flag) {
 		pr_err("ua read emulated not supported\n");
 		return -EINVAL;
 	}
 	return 0;
 }
 int se_dev_set_emulate_write_cache(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (flag &&
 	    dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		pr_err("emulate_write_cache not supported for pSCSI\n");
 		return -EINVAL;
 	}
 	if (flag &&
 	    dev->transport->get_write_cache) {
 		pr_err("emulate_write_cache not supported for this device\n");
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_write_cache = flag;
 	pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
 			dev, dev->dev_attrib.emulate_write_cache);
 	return 0;
 }
 int se_dev_set_emulate_ua_intlck_ctrl(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1) && (flag != 2)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device"
 			" UA_INTRLCK_CTRL while export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_ua_intlck_ctrl = flag;
 	pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",
 		dev, dev->dev_attrib.emulate_ua_intlck_ctrl);
 	return 0;
 }
 int se_dev_set_emulate_tas(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device TAS while"
 			" export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_tas = flag;
 	pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",
 		dev, (dev->dev_attrib.emulate_tas) ? "Enabled" : "Disabled");
 	return 0;
 }
 int se_dev_set_emulate_tpu(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	/*
 	 * We expect this value to be non-zero when generic Block Layer
 	 * Discard supported is detected iblock_create_virtdevice().
 	 */
 	if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {
 		pr_err("Generic Block Discard not supported\n");
 		return -ENOSYS;
 	}
 	dev->dev_attrib.emulate_tpu = flag;
 	pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",
 				dev, flag);
 	return 0;
 }
 int se_dev_set_emulate_tpws(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	/*
 	 * We expect this value to be non-zero when generic Block Layer
 	 * Discard supported is detected iblock_create_virtdevice().
 	 */
 	if (flag && !dev->dev_attrib.max_unmap_block_desc_count) {
 		pr_err("Generic Block Discard not supported\n");
 		return -ENOSYS;
 	}
 	dev->dev_attrib.emulate_tpws = flag;
 	pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",
 				dev, flag);
 	return 0;
 }
 int se_dev_set_emulate_caw(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_caw = flag;
 	pr_debug("dev[%p]: SE Device CompareAndWrite (AtomicTestandSet): %d\n",
 		 dev, flag);
 	return 0;
 }
 int se_dev_set_emulate_3pc(struct se_device *dev, int flag)
 {
 	if (flag != 0 && flag != 1) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	dev->dev_attrib.emulate_3pc = flag;
 	pr_debug("dev[%p]: SE Device 3rd Party Copy (EXTENDED_COPY): %d\n",
 		dev, flag);
 	return 0;
 }
 int se_dev_set_pi_prot_type(struct se_device *dev, int flag)
 {
 	int rc, old_prot = dev->dev_attrib.pi_prot_type;
 	if (flag != 0 && flag != 1 && flag != 2 && flag != 3) {
 		pr_err("Illegal value %d for pi_prot_type\n", flag);
 		return -EINVAL;
 	}
 	if (flag == 2) {
 		pr_err("DIF TYPE2 protection currently not supported\n");
 		return -ENOSYS;
 	}
 	if (dev->dev_attrib.hw_pi_prot_type) {
 		pr_warn("DIF protection enabled on underlying hardware,"
 			" ignoring\n");
 		return 0;
 	}
 	if (!dev->transport->init_prot || !dev->transport->free_prot) {
 		/* 0 is only allowed value for non-supporting backends */
 		if (flag == 0)
 			return 0;
 		pr_err("DIF protection not supported by backend: %s\n",
 		       dev->transport->name);
 		return -ENOSYS;
 	}
 	if (!(dev->dev_flags & DF_CONFIGURED)) {
 		pr_err("DIF protection requires device to be configured\n");
 		return -ENODEV;
 	}
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device PROT type while"
 		       " export_count is %d\n", dev, dev->export_count);
 		return -EINVAL;
 	}
 	dev->dev_attrib.pi_prot_type = flag;
 	if (flag && !old_prot) {
 		rc = dev->transport->init_prot(dev);
 		if (rc) {
 			dev->dev_attrib.pi_prot_type = old_prot;
 			return rc;
 		}
 	} else if (!flag && old_prot) {
 		dev->transport->free_prot(dev);
 	}
 	pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag);
 	return 0;
 }
 int se_dev_set_pi_prot_format(struct se_device *dev, int flag)
 {
 	int rc;
 	if (!flag)
 		return 0;
 	if (flag != 1) {
 		pr_err("Illegal value %d for pi_prot_format\n", flag);
 		return -EINVAL;
 	}
 	if (!dev->transport->format_prot) {
 		pr_err("DIF protection format not supported by backend %s\n",
 		       dev->transport->name);
 		return -ENOSYS;
 	}
 	if (!(dev->dev_flags & DF_CONFIGURED)) {
 		pr_err("DIF protection format requires device to be configured\n");
 		return -ENODEV;
 	}
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to format SE Device PROT type while"
 		       " export_count is %d\n", dev, dev->export_count);
 		return -EINVAL;
 	}
 	rc = dev->transport->format_prot(dev);
 	if (rc)
 		return rc;
 	pr_debug("dev[%p]: SE Device Protection Format complete\n", dev);
 	return 0;
 }
 int se_dev_set_enforce_pr_isids(struct se_device *dev, int flag)
 {
 	if ((flag != 0) && (flag != 1)) {
 		pr_err("Illegal value %d\n", flag);
 		return -EINVAL;
 	}
 	dev->dev_attrib.enforce_pr_isids = flag;
 	pr_debug("dev[%p]: SE Device enforce_pr_isids bit: %s\n", dev,
 		(dev->dev_attrib.enforce_pr_isids) ? "Enabled" : "Disabled");
 	return 0;
 }
 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->dev_attrib.is_nonrot = flag;
 	pr_debug("dev[%p]: SE Device is_nonrot bit: %d\n",
 	       dev, flag);
 	return 0;
 }
 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->dev_attrib.emulate_rest_reord = flag;
 	pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n", dev, flag);
 	return 0;
 }
 /*
  * Note, this can only be called on unexported SE Device Object.
  */
 int se_dev_set_queue_depth(struct se_device *dev, u32 queue_depth)
 {
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device TCQ while"
 			" export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	if (!queue_depth) {
 		pr_err("dev[%p]: Illegal ZERO value for queue"
 			"_depth\n", dev);
 		return -EINVAL;
 	}
 	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		if (queue_depth > dev->dev_attrib.hw_queue_depth) {
 			pr_err("dev[%p]: Passed queue_depth: %u"
 				" exceeds TCM/SE_Device TCQ: %u\n",
 				dev, queue_depth,
 				dev->dev_attrib.hw_queue_depth);
 			return -EINVAL;
 		}
 	} else {
 		if (queue_depth > dev->dev_attrib.queue_depth) {
 			if (queue_depth > dev->dev_attrib.hw_queue_depth) {
 				pr_err("dev[%p]: Passed queue_depth:"
 					" %u exceeds TCM/SE_Device MAX"
 					" TCQ: %u\n", dev, queue_depth,
 					dev->dev_attrib.hw_queue_depth);
 				return -EINVAL;
 			}
 		}
 	}
 	dev->dev_attrib.queue_depth = dev->queue_depth = queue_depth;
 	pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n",
 			dev, queue_depth);
 	return 0;
 }
 int se_dev_set_fabric_max_sectors(struct se_device *dev, u32 fabric_max_sectors)
 {
 	int block_size = dev->dev_attrib.block_size;
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device"
 			" fabric_max_sectors while export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	if (!fabric_max_sectors) {
 		pr_err("dev[%p]: Illegal ZERO value for"
 			" fabric_max_sectors\n", dev);
 		return -EINVAL;
 	}
 	if (fabric_max_sectors < DA_STATUS_MAX_SECTORS_MIN) {
 		pr_err("dev[%p]: Passed fabric_max_sectors: %u less than"
 			" DA_STATUS_MAX_SECTORS_MIN: %u\n", dev, fabric_max_sectors,
 				DA_STATUS_MAX_SECTORS_MIN);
 		return -EINVAL;
 	}
 	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		if (fabric_max_sectors > dev->dev_attrib.hw_max_sectors) {
 			pr_err("dev[%p]: Passed fabric_max_sectors: %u"
 				" greater than TCM/SE_Device max_sectors:"
 				" %u\n", dev, fabric_max_sectors,
 				dev->dev_attrib.hw_max_sectors);
 			 return -EINVAL;
 		}
 	} else {
 		if (fabric_max_sectors > DA_STATUS_MAX_SECTORS_MAX) {
 			pr_err("dev[%p]: Passed fabric_max_sectors: %u"
 				" greater than DA_STATUS_MAX_SECTORS_MAX:"
 				" %u\n", dev, fabric_max_sectors,
 				DA_STATUS_MAX_SECTORS_MAX);
 			return -EINVAL;
 		}
 	}
 	/*
 	 * Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
 	 */
 	if (!block_size) {
 		block_size = 512;
 		pr_warn("Defaulting to 512 for zero block_size\n");
 	}
 	fabric_max_sectors = se_dev_align_max_sectors(fabric_max_sectors,
 						      block_size);
 	dev->dev_attrib.fabric_max_sectors = fabric_max_sectors;
 	pr_debug("dev[%p]: SE Device max_sectors changed to %u\n",
 			dev, fabric_max_sectors);
 	return 0;
 }
 int se_dev_set_optimal_sectors(struct se_device *dev, u32 optimal_sectors)
 {
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device"
 			" optimal_sectors while export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		pr_err("dev[%p]: Passed optimal_sectors cannot be"
 				" changed for TCM/pSCSI\n", dev);
 		return -EINVAL;
 	}
 	if (optimal_sectors > dev->dev_attrib.fabric_max_sectors) {
 		pr_err("dev[%p]: Passed optimal_sectors %u cannot be"
 			" greater than fabric_max_sectors: %u\n", dev,
 			optimal_sectors, dev->dev_attrib.fabric_max_sectors);
 		return -EINVAL;
 	}
 	dev->dev_attrib.optimal_sectors = optimal_sectors;
 	pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",
 			dev, optimal_sectors);
 	return 0;
 }
 int se_dev_set_block_size(struct se_device *dev, u32 block_size)
 {
 	if (dev->export_count) {
 		pr_err("dev[%p]: Unable to change SE Device block_size"
 			" while export_count is %d\n",
 			dev, dev->export_count);
 		return -EINVAL;
 	}
 	if ((block_size != 512) &&
 	    (block_size != 1024) &&
 	    (block_size != 2048) &&
 	    (block_size != 4096)) {
 		pr_err("dev[%p]: Illegal value for block_device: %u"
 			" for SE device, must be 512, 1024, 2048 or 4096\n",
 			dev, block_size);
 		return -EINVAL;
 	}
 	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
 		pr_err("dev[%p]: Not allowed to change block_size for"
 			" Physical Device, use for Linux/SCSI to change"
 			" block_size for underlying hardware\n", dev);
 		return -EINVAL;
 	}
 	dev->dev_attrib.block_size = block_size;
 	pr_debug("dev[%p]: SE Device block_size changed to %u\n",
 			dev, block_size);
 	if (dev->dev_attrib.max_bytes_per_io)
 		dev->dev_attrib.hw_max_sectors =
 			dev->dev_attrib.max_bytes_per_io / block_size;
 	return 0;
 }
 struct se_lun *core_dev_add_lun(
 	struct se_portal_group *tpg,
 	struct se_device *dev,
 	u32 unpacked_lun)
 {
 	struct se_lun *lun;
 	int rc;
 	lun = core_tpg_alloc_lun(tpg, unpacked_lun);
 	if (IS_ERR(lun))
 		return lun;
 	rc = core_tpg_add_lun(tpg, lun,
 				TRANSPORT_LUNFLAGS_READ_WRITE, dev);
 	if (rc < 0)
 		return ERR_PTR(rc);
 	pr_debug("%s_TPG[%u]_LUN[%u] - Activated %s Logical Unit from"
 		" CORE HBA: %u\n", tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
 		tpg->se_tpg_tfo->get_fabric_name(), dev->se_hba->hba_id);
 	/*
 	 * Update LUN maps for dynamically added initiators when
 	 * generate_node_acl is enabled.
 	 */
 	if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) {
 		struct se_node_acl *acl;
 		spin_lock_irq(&tpg->acl_node_lock);
 		list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
 			if (acl->dynamic_node_acl &&
 			    (!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only ||
 			     !tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) {
 				spin_unlock_irq(&tpg->acl_node_lock);
 				core_tpg_add_node_to_devs(acl, tpg);
 				spin_lock_irq(&tpg->acl_node_lock);
 			}
 		}
 		spin_unlock_irq(&tpg->acl_node_lock);
 	}
 	return lun;
 }
 /*      core_dev_del_lun():
  *
  *
  */
 int core_dev_del_lun(
 	struct se_portal_group *tpg,
 	u32 unpacked_lun)
 {
 	struct se_lun *lun;
 	lun = core_tpg_pre_dellun(tpg, unpacked_lun);
 	if (IS_ERR(lun))
 		return PTR_ERR(lun);
 	core_tpg_post_dellun(tpg, lun);
 	pr_debug("%s_TPG[%u]_LUN[%u] - Deactivated %s Logical Unit from"
 		" device object\n", tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun,
 		tpg->se_tpg_tfo->get_fabric_name());
 	return 0;
 }
 struct se_lun *core_get_lun_from_tpg(struct se_portal_group *tpg, u32 unpacked_lun)
 {
 	struct se_lun *lun;
 	spin_lock(&tpg->tpg_lun_lock);
 	if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
 		pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS"
 			"_PER_TPG-1: %u for Target Portal Group: %hu\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			TRANSPORT_MAX_LUNS_PER_TPG-1,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		spin_unlock(&tpg->tpg_lun_lock);
 		return NULL;
 	}
 	lun = tpg->tpg_lun_list[unpacked_lun];
 	if (lun->lun_status != TRANSPORT_LUN_STATUS_FREE) {
 		pr_err("%s Logical Unit Number: %u is not free on"
 			" Target Portal Group: %hu, ignoring request.\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		spin_unlock(&tpg->tpg_lun_lock);
 		return NULL;
 	}
 	spin_unlock(&tpg->tpg_lun_lock);
 	return lun;
 }
 /*      core_dev_get_lun():
  *
  *
  */
 static struct se_lun *core_dev_get_lun(struct se_portal_group *tpg, u32 unpacked_lun)
 {
 	struct se_lun *lun;
 	spin_lock(&tpg->tpg_lun_lock);
 	if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
 		pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER"
 			"_TPG-1: %u for Target Portal Group: %hu\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			TRANSPORT_MAX_LUNS_PER_TPG-1,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		spin_unlock(&tpg->tpg_lun_lock);
 		return NULL;
 	}
 	lun = tpg->tpg_lun_list[unpacked_lun];
 	if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) {
 		pr_err("%s Logical Unit Number: %u is not active on"
 			" Target Portal Group: %hu, ignoring request.\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		spin_unlock(&tpg->tpg_lun_lock);
 		return NULL;
 	}
 	spin_unlock(&tpg->tpg_lun_lock);
 	return lun;
 }
 struct se_lun_acl *core_dev_init_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_node_acl *nacl,
 	u32 mapped_lun,
 	int *ret)
 {
 	struct se_lun_acl *lacl;
 	if (strlen(nacl->initiatorname) >= TRANSPORT_IQN_LEN) {
 		pr_err("%s InitiatorName exceeds maximum size.\n",
 			tpg->se_tpg_tfo->get_fabric_name());
 		*ret = -EOVERFLOW;
 		return NULL;
 	}
 	lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL);
 	if (!lacl) {
 		pr_err("Unable to allocate memory for struct se_lun_acl.\n");
 		*ret = -ENOMEM;
 		return NULL;
 	}
 	INIT_LIST_HEAD(&lacl->lacl_list);
 	lacl->mapped_lun = mapped_lun;
 	lacl->se_lun_nacl = nacl;
 	snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s",
 		 nacl->initiatorname);
 	return lacl;
 }
 int core_dev_add_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_lun_acl *lacl,
 	u32 unpacked_lun,
 	u32 lun_access)
 {
 	struct se_lun *lun;
 	struct se_node_acl *nacl;
 	lun = core_dev_get_lun(tpg, unpacked_lun);
 	if (!lun) {
 		pr_err("%s Logical Unit Number: %u is not active on"
 			" Target Portal Group: %hu, ignoring request.\n",
 			tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
 			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		return -EINVAL;
 	}
 	nacl = lacl->se_lun_nacl;
 	if (!nacl)
 		return -EINVAL;
 	if ((lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) &&
 	    (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE))
 		lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;
 	lacl->se_lun = lun;
 	if (core_enable_device_list_for_node(lun, lacl, lacl->mapped_lun,
 			lun_access, nacl, tpg) < 0)
 		return -EINVAL;
 	spin_lock(&lun->lun_acl_lock);
 	list_add_tail(&lacl->lacl_list, &lun->lun_acl_list);
 	atomic_inc(&lun->lun_acl_count);
 	smp_mb__after_atomic();
 	spin_unlock(&lun->lun_acl_lock);
 	pr_debug("%s_TPG[%hu]_LUN[%u->%u] - Added %s ACL for "
 		" InitiatorNode: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun, lacl->mapped_lun,
 		(lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) ? "RW" : "RO",
 		lacl->initiatorname);
 	/*
 	 * Check to see if there are any existing persistent reservation APTPL
 	 * pre-registrations that need to be enabled for this LUN ACL..
 	 */
 	core_scsi3_check_aptpl_registration(lun->lun_se_dev, tpg, lun, lacl);
 	return 0;
 }
 /*      core_dev_del_initiator_node_lun_acl():
  *
  *
  */
 int core_dev_del_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_lun *lun,
 	struct se_lun_acl *lacl)
 {
 	struct se_node_acl *nacl;
 	nacl = lacl->se_lun_nacl;
 	if (!nacl)
 		return -EINVAL;
 	spin_lock(&lun->lun_acl_lock);
 	list_del(&lacl->lacl_list);
 	atomic_dec(&lun->lun_acl_count);
 	smp_mb__after_atomic();
 	spin_unlock(&lun->lun_acl_lock);
 	core_disable_device_list_for_node(lun, NULL, lacl->mapped_lun,
 		TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
 	lacl->se_lun = NULL;
 	pr_debug("%s_TPG[%hu]_LUN[%u] - Removed ACL for"
 		" InitiatorNode: %s Mapped LUN: %u\n",
 		tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
 		lacl->initiatorname, lacl->mapped_lun);
 	return 0;
 }
 void core_dev_free_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_lun_acl *lacl)
 {
 	pr_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s"
 		" Mapped LUN: %u\n", tpg->se_tpg_tfo->get_fabric_name(),
 		tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		tpg->se_tpg_tfo->get_fabric_name(),
 		lacl->initiatorname, lacl->mapped_lun);
 	kfree(lacl);
 }
 static void scsi_dump_inquiry(struct se_device *dev)
 {
 	struct t10_wwn *wwn = &dev->t10_wwn;
 	char buf[17];
 	int i, device_type;
 	/*
 	 * Print Linux/SCSI style INQUIRY formatting to the kernel ring buffer
 	 */
 	for (i = 0; i < 8; i++)
 		if (wwn->vendor[i] >= 0x20)
 			buf[i] = wwn->vendor[i];
 		else
 			buf[i] = ' ';
 	buf[i] = '\0';
 	pr_debug("  Vendor: %s\n", buf);
 	for (i = 0; i < 16; i++)
 		if (wwn->model[i] >= 0x20)
 			buf[i] = wwn->model[i];
 		else
 			buf[i] = ' ';
 	buf[i] = '\0';
 	pr_debug("  Model: %s\n", buf);
 	for (i = 0; i < 4; i++)
 		if (wwn->revision[i] >= 0x20)
 			buf[i] = wwn->revision[i];
 		else
 			buf[i] = ' ';
 	buf[i] = '\0';
 	pr_debug("  Revision: %s\n", buf);
 	device_type = dev->transport->get_device_type(dev);
 	pr_debug("  Type:   %s ", scsi_device_type(device_type));
 }
 struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
 {
 	struct se_device *dev;
 	struct se_lun *xcopy_lun;
 	dev = hba->transport->alloc_device(hba, name);
 	if (!dev)
 		return NULL;
 	dev->dev_link_magic = SE_DEV_LINK_MAGIC;
 	dev->se_hba = hba;
 	dev->transport = hba->transport;
 	dev->prot_length = sizeof(struct se_dif_v1_tuple);
 	INIT_LIST_HEAD(&dev->dev_list);
 	INIT_LIST_HEAD(&dev->dev_sep_list);
 	INIT_LIST_HEAD(&dev->dev_tmr_list);
 	INIT_LIST_HEAD(&dev->delayed_cmd_list);
 	INIT_LIST_HEAD(&dev->state_list);
 	INIT_LIST_HEAD(&dev->qf_cmd_list);
 	INIT_LIST_HEAD(&dev->g_dev_node);
 	spin_lock_init(&dev->execute_task_lock);
 	spin_lock_init(&dev->delayed_cmd_lock);
 	spin_lock_init(&dev->dev_reservation_lock);
 	spin_lock_init(&dev->se_port_lock);
 	spin_lock_init(&dev->se_tmr_lock);
 	spin_lock_init(&dev->qf_cmd_lock);
 	sema_init(&dev->caw_sem, 1);
 	atomic_set(&dev->dev_ordered_id, 0);
 	INIT_LIST_HEAD(&dev->t10_wwn.t10_vpd_list);
 	spin_lock_init(&dev->t10_wwn.t10_vpd_lock);
 	INIT_LIST_HEAD(&dev->t10_pr.registration_list);
 	INIT_LIST_HEAD(&dev->t10_pr.aptpl_reg_list);
 	spin_lock_init(&dev->t10_pr.registration_lock);
 	spin_lock_init(&dev->t10_pr.aptpl_reg_lock);
 	INIT_LIST_HEAD(&dev->t10_alua.tg_pt_gps_list);
 	spin_lock_init(&dev->t10_alua.tg_pt_gps_lock);
 	INIT_LIST_HEAD(&dev->t10_alua.lba_map_list);
 	spin_lock_init(&dev->t10_alua.lba_map_lock);
 	dev->t10_wwn.t10_dev = dev;
 	dev->t10_alua.t10_dev = dev;
 	dev->dev_attrib.da_dev = dev;
 	dev->dev_attrib.emulate_model_alias = DA_EMULATE_MODEL_ALIAS;
 	dev->dev_attrib.emulate_dpo = DA_EMULATE_DPO;
 	dev->dev_attrib.emulate_fua_write = DA_EMULATE_FUA_WRITE;
 	dev->dev_attrib.emulate_fua_read = DA_EMULATE_FUA_READ;
 	dev->dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE;
 	dev->dev_attrib.emulate_ua_intlck_ctrl = DA_EMULATE_UA_INTLLCK_CTRL;
 	dev->dev_attrib.emulate_tas = DA_EMULATE_TAS;
 	dev->dev_attrib.emulate_tpu = DA_EMULATE_TPU;
 	dev->dev_attrib.emulate_tpws = DA_EMULATE_TPWS;
 	dev->dev_attrib.emulate_caw = DA_EMULATE_CAW;
 	dev->dev_attrib.emulate_3pc = DA_EMULATE_3PC;
 	dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE0_PROT;
 	dev->dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS;
 	dev->dev_attrib.is_nonrot = DA_IS_NONROT;
 	dev->dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD;
 	dev->dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT;
 	dev->dev_attrib.max_unmap_block_desc_count =
 		DA_MAX_UNMAP_BLOCK_DESC_COUNT;
 	dev->dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT;
 	dev->dev_attrib.unmap_granularity_alignment =
 				DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT;
 	dev->dev_attrib.max_write_same_len = DA_MAX_WRITE_SAME_LEN;
 	dev->dev_attrib.fabric_max_sectors = DA_FABRIC_MAX_SECTORS;
 	dev->dev_attrib.optimal_sectors = DA_FABRIC_MAX_SECTORS;
 	xcopy_lun = &dev->xcopy_lun;
 	xcopy_lun->lun_se_dev = dev;
 	init_completion(&xcopy_lun->lun_shutdown_comp);
 	INIT_LIST_HEAD(&xcopy_lun->lun_acl_list);
 	spin_lock_init(&xcopy_lun->lun_acl_lock);
 	spin_lock_init(&xcopy_lun->lun_sep_lock);
 	init_completion(&xcopy_lun->lun_ref_comp);
 	return dev;
 }
 int target_configure_device(struct se_device *dev)
 {
 	struct se_hba *hba = dev->se_hba;
 	int ret;
 	if (dev->dev_flags & DF_CONFIGURED) {
 		pr_err("se_dev->se_dev_ptr already set for storage"
 				" object\n");
 		return -EEXIST;
 	}
 	ret = dev->transport->configure_device(dev);
 	if (ret)
 		goto out;
 	dev->dev_flags |= DF_CONFIGURED;
 	/*
 	 * XXX: there is not much point to have two different values here..
 	 */
 	dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size;
 	dev->dev_attrib.queue_depth = dev->dev_attrib.hw_queue_depth;
 	/*
 	 * Align max_hw_sectors down to PAGE_SIZE I/O transfers
 	 */
 	dev->dev_attrib.hw_max_sectors =
 		se_dev_align_max_sectors(dev->dev_attrib.hw_max_sectors,
 					 dev->dev_attrib.hw_block_size);
 	dev->dev_index = scsi_get_new_index(SCSI_DEVICE_INDEX);
 	dev->creation_time = get_jiffies_64();
 	ret = core_setup_alua(dev);
 	if (ret)
 		goto out;
 	/*
 	 * Startup the struct se_device processing thread
 	 */
 	dev->tmr_wq = alloc_workqueue("tmr-%s", WQ_MEM_RECLAIM | WQ_UNBOUND, 1,
 				      dev->transport->name);
 	if (!dev->tmr_wq) {
 		pr_err("Unable to create tmr workqueue for %s\n",
 			dev->transport->name);
 		ret = -ENOMEM;
 		goto out_free_alua;
 	}
 	/*
 	 * Setup work_queue for QUEUE_FULL
 	 */
 	INIT_WORK(&dev->qf_work_queue, target_qf_do_work);
 	/*
 	 * Preload the initial INQUIRY const values if we are doing
 	 * anything virtual (IBLOCK, FILEIO, RAMDISK), but not for TCM/pSCSI
 	 * passthrough because this is being provided by the backend LLD.
 	 */
 	if (dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV) {
 		strncpy(&dev->t10_wwn.vendor[0], "LIO-ORG", 8);
 		strncpy(&dev->t10_wwn.model[0],
 			dev->transport->inquiry_prod, 16);
 		strncpy(&dev->t10_wwn.revision[0],
 			dev->transport->inquiry_rev, 4);
 	}
 	scsi_dump_inquiry(dev);
 	spin_lock(&hba->device_lock);
 	hba->dev_count++;
 	spin_unlock(&hba->device_lock);
 	mutex_lock(&g_device_mutex);
 	list_add_tail(&dev->g_dev_node, &g_device_list);
 	mutex_unlock(&g_device_mutex);
 	return 0;
 out_free_alua:
 	core_alua_free_lu_gp_mem(dev);
 out:
 	se_release_vpd_for_dev(dev);
 	return ret;
 }
 void target_free_device(struct se_device *dev)
 {
 	struct se_hba *hba = dev->se_hba;
 	WARN_ON(!list_empty(&dev->dev_sep_list));
 	if (dev->dev_flags & DF_CONFIGURED) {
 		destroy_workqueue(dev->tmr_wq);
 		mutex_lock(&g_device_mutex);
 		list_del(&dev->g_dev_node);
 		mutex_unlock(&g_device_mutex);
 		spin_lock(&hba->device_lock);
 		hba->dev_count--;
 		spin_unlock(&hba->device_lock);
 	}
 	core_alua_free_lu_gp_mem(dev);
 	core_alua_set_lba_map(dev, NULL, 0, 0);
 	core_scsi3_free_all_registrations(dev);
 	se_release_vpd_for_dev(dev);
 	if (dev->transport->free_prot)
 		dev->transport->free_prot(dev);
 	dev->transport->free_device(dev);
 }
 int core_dev_setup_virtual_lun0(void)
 {
 	struct se_hba *hba;
 	struct se_device *dev;
 	char buf[] = "rd_pages=8,rd_nullio=1";
 	int ret;
 	hba = core_alloc_hba("rd_mcp", 0, HBA_FLAGS_INTERNAL_USE);
 	if (IS_ERR(hba))
 		return PTR_ERR(hba);
 	dev = target_alloc_device(hba, "virt_lun0");
 	if (!dev) {
 		ret = -ENOMEM;
 		goto out_free_hba;
 	}
 	hba->transport->set_configfs_dev_params(dev, buf, sizeof(buf));
 	ret = target_configure_device(dev);
 	if (ret)
 		goto out_free_se_dev;
 	lun0_hba = hba;
 	g_lun0_dev = dev;
 	return 0;
 out_free_se_dev:
 	target_free_device(dev);
 out_free_hba:
 	core_delete_hba(hba);
 	return ret;
 }
 void core_dev_release_virtual_lun0(void)
 {
 	struct se_hba *hba = lun0_hba;
 	if (!hba)
 		return;
 	if (g_lun0_dev)
 		target_free_device(g_lun0_dev);
 	core_delete_hba(hba);
 }