Eric Lee / smarc-ti-linux-kernel

1

/*

1

/*

2

* scsi_scan.c

2

* scsi_scan.c

3

*

3

*

4

5

6

*

6

*

7

* The general scanning/probing algorithm is as follows, exceptions are

7

* The general scanning/probing algorithm is as follows, exceptions are

8

* made to it depending on device specific flags, compilation options, and

8

* made to it depending on device specific flags, compilation options, and

9

* global variable (boot or module load time) settings.

9

* global variable (boot or module load time) settings.

10

*

10

*

11

* A specific LUN is scanned via an INQUIRY command; if the LUN has a

11

* A specific LUN is scanned via an INQUIRY command; if the LUN has a

12

* device attached, a scsi_device is allocated and setup for it.

12

* device attached, a scsi_device is allocated and setup for it.

13

*

13

*

14

* For every id of every channel on the given host:

14

* For every id of every channel on the given host:

15

*

15

*

16

* Scan LUN 0; if the target responds to LUN 0 (even if there is no

16

* Scan LUN 0; if the target responds to LUN 0 (even if there is no

17

* device or storage attached to LUN 0):

17

* device or storage attached to LUN 0):

18

*

18

*

19

* If LUN 0 has a device attached, allocate and setup a

19

* If LUN 0 has a device attached, allocate and setup a

20

* scsi_device for it.

20

* scsi_device for it.

21

*

21

*

22

* If target is SCSI-3 or up, issue a REPORT LUN, and scan

22

* If target is SCSI-3 or up, issue a REPORT LUN, and scan

23

* all of the LUNs returned by the REPORT LUN; else,

23

* all of the LUNs returned by the REPORT LUN; else,

24

* sequentially scan LUNs up until some maximum is reached,

24

* sequentially scan LUNs up until some maximum is reached,

25

* or a LUN is seen that cannot have a device attached to it.

25

* or a LUN is seen that cannot have a device attached to it.

26

*/

26

*/

27

28

#include <linux/module.h>

28

#include <linux/module.h>

29

#include <linux/moduleparam.h>

29

#include <linux/moduleparam.h>

30

#include <linux/init.h>

30

#include <linux/init.h>

31

#include <linux/blkdev.h>

31

#include <linux/blkdev.h>

32

#include <linux/delay.h>

32

#include <linux/delay.h>

33

#include <linux/kthread.h>

33

#include <linux/kthread.h>

34

#include <linux/spinlock.h>

34

#include <linux/spinlock.h>

35

#include <linux/async.h>

35

#include <linux/async.h>

36

#include <linux/slab.h>

36

#include <linux/slab.h>

37

#include <asm/unaligned.h>

37

#include <asm/unaligned.h>

38

39

#include <scsi/scsi.h>

39

#include <scsi/scsi.h>

40

#include <scsi/scsi_cmnd.h>

40

#include <scsi/scsi_cmnd.h>

41

#include <scsi/scsi_device.h>

41

#include <scsi/scsi_device.h>

42

#include <scsi/scsi_driver.h>

42

#include <scsi/scsi_driver.h>

43

#include <scsi/scsi_devinfo.h>

43

#include <scsi/scsi_devinfo.h>

44

#include <scsi/scsi_host.h>

44

#include <scsi/scsi_host.h>

45

#include <scsi/scsi_transport.h>

45

#include <scsi/scsi_transport.h>

46

#include <scsi/scsi_eh.h>

46

#include <scsi/scsi_eh.h>

47

48

#include "scsi_priv.h"

48

#include "scsi_priv.h"

49

#include "scsi_logging.h"

49

#include "scsi_logging.h"

50

51

#define ALLOC_FAILURE_MSG KERN_ERR "%s: Allocation failure during" \

51

#define ALLOC_FAILURE_MSG KERN_ERR "%s: Allocation failure during" \

52

" SCSI scanning, some SCSI devices might not be configured\n"

52

" SCSI scanning, some SCSI devices might not be configured\n"

53

54

/*

54

/*

55

* Default timeout

55

* Default timeout

56

*/

56

*/

57

#define SCSI_TIMEOUT (2*HZ)

57

#define SCSI_TIMEOUT (2*HZ)

58

#define SCSI_REPORT_LUNS_TIMEOUT (30*HZ)

58

#define SCSI_REPORT_LUNS_TIMEOUT (30*HZ)

59

60

/*

60

/*

61

* Prefix values for the SCSI id's (stored in sysfs name field)

61

* Prefix values for the SCSI id's (stored in sysfs name field)

62

*/

62

*/

63

#define SCSI_UID_SER_NUM 'S'

63

#define SCSI_UID_SER_NUM 'S'

64

#define SCSI_UID_UNKNOWN 'Z'

64

#define SCSI_UID_UNKNOWN 'Z'

65

66

/*

66

/*

67

* Return values of some of the scanning functions.

67

* Return values of some of the scanning functions.

68

*

68

*

69

* SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this

69

* SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this

70

* includes allocation or general failures preventing IO from being sent.

70

* includes allocation or general failures preventing IO from being sent.

71

*

71

*

72

* SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available

72

* SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available

73

* on the given LUN.

73

* on the given LUN.

74

*

74

*

75

* SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a

75

* SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a

76

* given LUN.

76

* given LUN.

77

*/

77

*/

78

#define SCSI_SCAN_NO_RESPONSE 0

78

#define SCSI_SCAN_NO_RESPONSE 0

79

#define SCSI_SCAN_TARGET_PRESENT 1

79

#define SCSI_SCAN_TARGET_PRESENT 1

80

#define SCSI_SCAN_LUN_PRESENT 2

80

#define SCSI_SCAN_LUN_PRESENT 2

81

82

static const char *scsi_null_device_strs = "nullnullnullnull";

82

static const char *scsi_null_device_strs = "nullnullnullnull";

83

84

#define MAX_SCSI_LUNS 512

84

#define MAX_SCSI_LUNS 512

85

86

static u64 max_scsi_luns = MAX_SCSI_LUNS;

86

static u64 max_scsi_luns = MAX_SCSI_LUNS;

87

88

module_param_named(max_luns, max_scsi_luns, ullong, S_IRUGO|S_IWUSR);

88

module_param_named(max_luns, max_scsi_luns, ullong, S_IRUGO|S_IWUSR);

89

MODULE_PARM_DESC(max_luns,

89

MODULE_PARM_DESC(max_luns,

90

"last scsi LUN (should be between 1 and 2^64-1)");

90

"last scsi LUN (should be between 1 and 2^64-1)");

91

92

#ifdef CONFIG_SCSI_SCAN_ASYNC

92

#ifdef CONFIG_SCSI_SCAN_ASYNC

93

#define SCSI_SCAN_TYPE_DEFAULT "async"

93

#define SCSI_SCAN_TYPE_DEFAULT "async"

94

#else

94

#else

95

#define SCSI_SCAN_TYPE_DEFAULT "sync"

95

#define SCSI_SCAN_TYPE_DEFAULT "sync"

96

#endif

96

#endif

97

98

char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;

98

char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;

99

100

module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);

100

module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);

101

MODULE_PARM_DESC(scan, "sync, async or none");

101

MODULE_PARM_DESC(scan, "sync, async or none");

102

103

static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;

103

static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;

104

105

module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);

105

module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);

106

MODULE_PARM_DESC(inq_timeout,

106

MODULE_PARM_DESC(inq_timeout,

107

"Timeout (in seconds) waiting for devices to answer INQUIRY."

107

"Timeout (in seconds) waiting for devices to answer INQUIRY."

108

" Default is 20. Some devices may need more; most need less.");

108

" Default is 20. Some devices may need more; most need less.");

109

110

/* This lock protects only this list */

110

/* This lock protects only this list */

111

static DEFINE_SPINLOCK(async_scan_lock);

111

static DEFINE_SPINLOCK(async_scan_lock);

112

static LIST_HEAD(scanning_hosts);

112

static LIST_HEAD(scanning_hosts);

113

114

struct async_scan_data {

114

struct async_scan_data {

115

struct list_head list;

115

struct list_head list;

116

struct Scsi_Host *shost;

116

struct Scsi_Host *shost;

117

struct completion prev_finished;

117

struct completion prev_finished;

118

};

118

};

119

120

/**

120

/**

121

* scsi_complete_async_scans - Wait for asynchronous scans to complete

121

* scsi_complete_async_scans - Wait for asynchronous scans to complete

122

*

122

*

123

* When this function returns, any host which started scanning before

123

* When this function returns, any host which started scanning before

124

* this function was called will have finished its scan. Hosts which

124

* this function was called will have finished its scan. Hosts which

125

* started scanning after this function was called may or may not have

125

* started scanning after this function was called may or may not have

126

* finished.

126

* finished.

127

*/

127

*/

128

int scsi_complete_async_scans(void)

128

int scsi_complete_async_scans(void)

129

{

129

{

130

struct async_scan_data *data;

130

struct async_scan_data *data;

131

132

do {

132

do {

133

if (list_empty(&scanning_hosts))

133

if (list_empty(&scanning_hosts))

134

return 0;

134

return 0;

135

/* If we can't get memory immediately, that's OK. Just

135

/* If we can't get memory immediately, that's OK. Just

136

* sleep a little. Even if we never get memory, the async

136

* sleep a little. Even if we never get memory, the async

137

* scans will finish eventually.

137

* scans will finish eventually.

138

*/

138

*/

139

data = kmalloc(sizeof(*data), GFP_KERNEL);

139

data = kmalloc(sizeof(*data), GFP_KERNEL);

140

if (!data)

140

if (!data)

141

msleep(1);

141

msleep(1);

142

} while (!data);

142

} while (!data);

143

144

data->shost = NULL;

144

data->shost = NULL;

145

init_completion(&data->prev_finished);

145

init_completion(&data->prev_finished);

146

147

spin_lock(&async_scan_lock);

147

spin_lock(&async_scan_lock);

148

/* Check that there's still somebody else on the list */

148

/* Check that there's still somebody else on the list */

149

if (list_empty(&scanning_hosts))

149

if (list_empty(&scanning_hosts))

150

goto done;

150

goto done;

151

list_add_tail(&data->list, &scanning_hosts);

151

list_add_tail(&data->list, &scanning_hosts);

152

spin_unlock(&async_scan_lock);

152

spin_unlock(&async_scan_lock);

153

154

printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n");

154

printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n");

155

wait_for_completion(&data->prev_finished);

155

wait_for_completion(&data->prev_finished);

156

157

spin_lock(&async_scan_lock);

157

spin_lock(&async_scan_lock);

158

list_del(&data->list);

158

list_del(&data->list);

159

if (!list_empty(&scanning_hosts)) {

159

if (!list_empty(&scanning_hosts)) {

160

struct async_scan_data *next = list_entry(scanning_hosts.next,

160

struct async_scan_data *next = list_entry(scanning_hosts.next,

161

struct async_scan_data, list);

161

struct async_scan_data, list);

162

complete(&next->prev_finished);

162

complete(&next->prev_finished);

163

}

163

}

164

done:

164

done:

165

spin_unlock(&async_scan_lock);

165

spin_unlock(&async_scan_lock);

166

167

kfree(data);

167

kfree(data);

168

return 0;

168

return 0;

169

}

169

}

170

171

/**

171

/**

172

* scsi_unlock_floptical - unlock device via a special MODE SENSE command

172

* scsi_unlock_floptical - unlock device via a special MODE SENSE command

173

* @sdev: scsi device to send command to

173

* @sdev: scsi device to send command to

174

* @result: area to store the result of the MODE SENSE

174

* @result: area to store the result of the MODE SENSE

175

*

175

*

176

* Description:

176

* Description:

177

* Send a vendor specific MODE SENSE (not a MODE SELECT) command.

177

* Send a vendor specific MODE SENSE (not a MODE SELECT) command.

178

* Called for BLIST_KEY devices.

178

* Called for BLIST_KEY devices.

179

**/

179

**/

180

static void scsi_unlock_floptical(struct scsi_device *sdev,

180

static void scsi_unlock_floptical(struct scsi_device *sdev,

181

unsigned char *result)

181

unsigned char *result)

182

{

182

{

183

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

183

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

184

185

sdev_printk(KERN_NOTICE, sdev, "unlocking floptical drive\n");

185

sdev_printk(KERN_NOTICE, sdev, "unlocking floptical drive\n");

186

scsi_cmd[0] = MODE_SENSE;

186

scsi_cmd[0] = MODE_SENSE;

187

scsi_cmd[1] = 0;

187

scsi_cmd[1] = 0;

188

scsi_cmd[2] = 0x2e;

188

scsi_cmd[2] = 0x2e;

189

scsi_cmd[3] = 0;

189

scsi_cmd[3] = 0;

190

scsi_cmd[4] = 0x2a; /* size */

190

scsi_cmd[4] = 0x2a; /* size */

191

scsi_cmd[5] = 0;

191

scsi_cmd[5] = 0;

192

scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,

192

scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,

193

SCSI_TIMEOUT, 3, NULL);

193

SCSI_TIMEOUT, 3, NULL);

194

}

194

}

195

196

/**

196

/**

197

* scsi_alloc_sdev - allocate and setup a scsi_Device

197

* scsi_alloc_sdev - allocate and setup a scsi_Device

198

* @starget: which target to allocate a &scsi_device for

198

* @starget: which target to allocate a &scsi_device for

199

* @lun: which lun

199

* @lun: which lun

200

* @hostdata: usually NULL and set by ->slave_alloc instead

200

* @hostdata: usually NULL and set by ->slave_alloc instead

201

*

201

*

202

* Description:

202

* Description:

203

* Allocate, initialize for io, and return a pointer to a scsi_Device.

203

* Allocate, initialize for io, and return a pointer to a scsi_Device.

204

* Stores the @shost, @channel, @id, and @lun in the scsi_Device, and

204

* Stores the @shost, @channel, @id, and @lun in the scsi_Device, and

205

* adds scsi_Device to the appropriate list.

205

* adds scsi_Device to the appropriate list.

206

*

206

*

207

* Return value:

207

* Return value:

208

* scsi_Device pointer, or NULL on failure.

208

* scsi_Device pointer, or NULL on failure.

209

**/

209

**/

210

static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,

210

static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,

211

u64 lun, void *hostdata)

211

u64 lun, void *hostdata)

212

{

212

{

213

struct scsi_device *sdev;

213

struct scsi_device *sdev;

214

int display_failure_msg = 1, ret;

214

int display_failure_msg = 1, ret;

215

struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

215

struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

216

extern void scsi_evt_thread(struct work_struct *work);

216

extern void scsi_evt_thread(struct work_struct *work);

217

extern void scsi_requeue_run_queue(struct work_struct *work);

217

extern void scsi_requeue_run_queue(struct work_struct *work);

218

219

sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,

219

sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,

220

GFP_ATOMIC);

220

GFP_ATOMIC);

221

if (!sdev)

221

if (!sdev)

222

goto out;

222

goto out;

223

224

sdev->vendor = scsi_null_device_strs;

224

sdev->vendor = scsi_null_device_strs;

225

sdev->model = scsi_null_device_strs;

225

sdev->model = scsi_null_device_strs;

226

sdev->rev = scsi_null_device_strs;

226

sdev->rev = scsi_null_device_strs;

227

sdev->host = shost;

227

sdev->host = shost;

228

sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;

228

sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;

229

sdev->id = starget->id;

229

sdev->id = starget->id;

230

sdev->lun = lun;

230

sdev->lun = lun;

231

sdev->channel = starget->channel;

231

sdev->channel = starget->channel;

232

sdev->sdev_state = SDEV_CREATED;

232

sdev->sdev_state = SDEV_CREATED;

233

INIT_LIST_HEAD(&sdev->siblings);

233

INIT_LIST_HEAD(&sdev->siblings);

234

INIT_LIST_HEAD(&sdev->same_target_siblings);

234

INIT_LIST_HEAD(&sdev->same_target_siblings);

235

INIT_LIST_HEAD(&sdev->cmd_list);

235

INIT_LIST_HEAD(&sdev->cmd_list);

236

INIT_LIST_HEAD(&sdev->starved_entry);

236

INIT_LIST_HEAD(&sdev->starved_entry);

237

INIT_LIST_HEAD(&sdev->event_list);

237

INIT_LIST_HEAD(&sdev->event_list);

238

spin_lock_init(&sdev->list_lock);

238

spin_lock_init(&sdev->list_lock);

239

INIT_WORK(&sdev->event_work, scsi_evt_thread);

239

INIT_WORK(&sdev->event_work, scsi_evt_thread);

240

INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);

240

INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);

241

242

sdev->sdev_gendev.parent = get_device(&starget->dev);

242

sdev->sdev_gendev.parent = get_device(&starget->dev);

243

sdev->sdev_target = starget;

243

sdev->sdev_target = starget;

244

245

/* usually NULL and set by ->slave_alloc instead */

245

/* usually NULL and set by ->slave_alloc instead */

246

sdev->hostdata = hostdata;

246

sdev->hostdata = hostdata;

247

248

/* if the device needs this changing, it may do so in the

248

/* if the device needs this changing, it may do so in the

249

* slave_configure function */

249

* slave_configure function */

250

sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;

250

sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;

251

252

/*

252

/*

253

* Some low level driver could use device->type

253

* Some low level driver could use device->type

254

*/

254

*/

255

sdev->type = -1;

255

sdev->type = -1;

256

257

/*

257

/*

258

* Assume that the device will have handshaking problems,

258

* Assume that the device will have handshaking problems,

259

* and then fix this field later if it turns out it

259

* and then fix this field later if it turns out it

260

* doesn't

260

* doesn't

261

*/

261

*/

262

sdev->borken = 1;

262

sdev->borken = 1;

263

264

if (shost_use_blk_mq(shost))

264

if (shost_use_blk_mq(shost))

265

sdev->request_queue = scsi_mq_alloc_queue(sdev);

265

sdev->request_queue = scsi_mq_alloc_queue(sdev);

266

else

266

else

267

sdev->request_queue = scsi_alloc_queue(sdev);

267

sdev->request_queue = scsi_alloc_queue(sdev);

268

if (!sdev->request_queue) {

268

if (!sdev->request_queue) {

269

/* release fn is set up in scsi_sysfs_device_initialise, so

269

/* release fn is set up in scsi_sysfs_device_initialise, so

270

* have to free and put manually here */

270

* have to free and put manually here */

271

put_device(&starget->dev);

271

put_device(&starget->dev);

272

kfree(sdev);

272

kfree(sdev);

273

goto out;

273

goto out;

274

}

274

}

275

WARN_ON_ONCE(!blk_get_queue(sdev->request_queue));

275

WARN_ON_ONCE(!blk_get_queue(sdev->request_queue));

276

sdev->request_queue->queuedata = sdev;

276

sdev->request_queue->queuedata = sdev;

277

278

if (!shost_use_blk_mq(sdev->host)) {

278

if (!shost_use_blk_mq(sdev->host)) {

279

blk_queue_init_tags(sdev->request_queue,

279

blk_queue_init_tags(sdev->request_queue,

280

sdev->host->cmd_per_lun, shost->bqt,

280

sdev->host->cmd_per_lun, shost->bqt,

281

shost->hostt->tag_alloc_policy);

281

shost->hostt->tag_alloc_policy);

282

}

282

}

283

scsi_change_queue_depth(sdev, sdev->host->cmd_per_lun ?

283

scsi_change_queue_depth(sdev, sdev->host->cmd_per_lun ?

284

sdev->host->cmd_per_lun : 1);

284

sdev->host->cmd_per_lun : 1);

285

286

scsi_sysfs_device_initialize(sdev);

286

scsi_sysfs_device_initialize(sdev);

287

288

if (shost->hostt->slave_alloc) {

288

if (shost->hostt->slave_alloc) {

289

ret = shost->hostt->slave_alloc(sdev);

289

ret = shost->hostt->slave_alloc(sdev);

290

if (ret) {

290

if (ret) {

291

/*

291

/*

292

* if LLDD reports slave not present, don't clutter

292

* if LLDD reports slave not present, don't clutter

293

* console with alloc failure messages

293

* console with alloc failure messages

294

*/

294

*/

295

if (ret == -ENXIO)

295

if (ret == -ENXIO)

296

display_failure_msg = 0;

296

display_failure_msg = 0;

297

goto out_device_destroy;

297

goto out_device_destroy;

298

}

298

}

299

}

299

}

300

301

return sdev;

301

return sdev;

302

303

out_device_destroy:

303

out_device_destroy:

304

__scsi_remove_device(sdev);

304

__scsi_remove_device(sdev);

305

out:

305

out:

306

if (display_failure_msg)

306

if (display_failure_msg)

307

printk(ALLOC_FAILURE_MSG, __func__);

307

printk(ALLOC_FAILURE_MSG, __func__);

308

return NULL;

308

return NULL;

309

}

309

}

310

311

static void scsi_target_destroy(struct scsi_target *starget)

311

static void scsi_target_destroy(struct scsi_target *starget)

312

{

312

{

313

struct device *dev = &starget->dev;

313

struct device *dev = &starget->dev;

314

struct Scsi_Host *shost = dev_to_shost(dev->parent);

314

struct Scsi_Host *shost = dev_to_shost(dev->parent);

315

unsigned long flags;

315

unsigned long flags;

316

317

BUG_ON(starget->state == STARGET_DEL);

317

starget->state = STARGET_DEL;

318

starget->state = STARGET_DEL;

318

transport_destroy_device(dev);

319

transport_destroy_device(dev);

319

spin_lock_irqsave(shost->host_lock, flags);

320

spin_lock_irqsave(shost->host_lock, flags);

320

if (shost->hostt->target_destroy)

321

if (shost->hostt->target_destroy)

321

shost->hostt->target_destroy(starget);

322

shost->hostt->target_destroy(starget);

322

list_del_init(&starget->siblings);

323

list_del_init(&starget->siblings);

323

spin_unlock_irqrestore(shost->host_lock, flags);

324

spin_unlock_irqrestore(shost->host_lock, flags);

324

put_device(dev);

325

put_device(dev);

325

}

326

}

326

327

static void scsi_target_dev_release(struct device *dev)

328

static void scsi_target_dev_release(struct device *dev)

328

{

329

{

329

struct device *parent = dev->parent;

330

struct device *parent = dev->parent;

330

struct scsi_target *starget = to_scsi_target(dev);

331

struct scsi_target *starget = to_scsi_target(dev);

331

332

kfree(starget);

333

kfree(starget);

333

put_device(parent);

334

put_device(parent);

334

}

335

}

335

336

static struct device_type scsi_target_type = {

337

static struct device_type scsi_target_type = {

337

.name = "scsi_target",

338

.name = "scsi_target",

338

.release = scsi_target_dev_release,

339

.release = scsi_target_dev_release,

339

};

340

};

340

341

int scsi_is_target_device(const struct device *dev)

342

int scsi_is_target_device(const struct device *dev)

342

{

343

{

343

return dev->type == &scsi_target_type;

344

return dev->type == &scsi_target_type;

344

}

345

}

345

EXPORT_SYMBOL(scsi_is_target_device);

346

EXPORT_SYMBOL(scsi_is_target_device);

346

347

static struct scsi_target *__scsi_find_target(struct device *parent,

348

static struct scsi_target *__scsi_find_target(struct device *parent,

348

int channel, uint id)

349

int channel, uint id)

349

{

350

{

350

struct scsi_target *starget, *found_starget = NULL;

351

struct scsi_target *starget, *found_starget = NULL;

351

struct Scsi_Host *shost = dev_to_shost(parent);

352

struct Scsi_Host *shost = dev_to_shost(parent);

352

/*

353

/*

353

* Search for an existing target for this sdev.

354

* Search for an existing target for this sdev.

354

*/

355

*/

355

list_for_each_entry(starget, &shost->__targets, siblings) {

356

list_for_each_entry(starget, &shost->__targets, siblings) {

356

if (starget->id == id &&

357

if (starget->id == id &&

357

starget->channel == channel) {

358

starget->channel == channel) {

358

found_starget = starget;

359

found_starget = starget;

359

break;

360

break;

360

}

361

}

361

}

362

}

362

if (found_starget)

363

if (found_starget)

363

get_device(&found_starget->dev);

364

get_device(&found_starget->dev);

364

365

return found_starget;

366

return found_starget;

366

}

367

}

367

368

/**

369

/**

369

* scsi_target_reap_ref_release - remove target from visibility

370

* scsi_target_reap_ref_release - remove target from visibility

370

* @kref: the reap_ref in the target being released

371

* @kref: the reap_ref in the target being released

371

*

372

*

372

* Called on last put of reap_ref, which is the indication that no device

373

* Called on last put of reap_ref, which is the indication that no device

373

* under this target is visible anymore, so render the target invisible in

374

* under this target is visible anymore, so render the target invisible in

374

* sysfs. Note: we have to be in user context here because the target reaps

375

* sysfs. Note: we have to be in user context here because the target reaps

375

* should be done in places where the scsi device visibility is being removed.

376

* should be done in places where the scsi device visibility is being removed.

376

*/

377

*/

377

static void scsi_target_reap_ref_release(struct kref *kref)

378

static void scsi_target_reap_ref_release(struct kref *kref)

378

{

379

{

379

struct scsi_target *starget

380

struct scsi_target *starget

380

= container_of(kref, struct scsi_target, reap_ref);

381

= container_of(kref, struct scsi_target, reap_ref);

381

382

/*

383

/*

383

* if we get here and the target is still in the CREATED state that

384

* if we get here and the target is still in the CREATED state that

384

* means it was allocated but never made visible (because a scan

385

* means it was allocated but never made visible (because a scan

385

* turned up no LUNs), so don't call device_del() on it.

386

* turned up no LUNs), so don't call device_del() on it.

386

*/

387

*/

387

if (starget->state != STARGET_CREATED) {

388

if (starget->state != STARGET_CREATED) {

388

transport_remove_device(&starget->dev);

389

transport_remove_device(&starget->dev);

389

device_del(&starget->dev);

390

device_del(&starget->dev);

390

}

391

}

391

scsi_target_destroy(starget);

392

scsi_target_destroy(starget);

392

}

393

}

393

394

static void scsi_target_reap_ref_put(struct scsi_target *starget)

395

static void scsi_target_reap_ref_put(struct scsi_target *starget)

395

{

396

{

396

kref_put(&starget->reap_ref, scsi_target_reap_ref_release);

397

kref_put(&starget->reap_ref, scsi_target_reap_ref_release);

397

}

398

}

398

399

/**

400

/**

400

* scsi_alloc_target - allocate a new or find an existing target

401

* scsi_alloc_target - allocate a new or find an existing target

401

* @parent: parent of the target (need not be a scsi host)

402

* @parent: parent of the target (need not be a scsi host)

402

* @channel: target channel number (zero if no channels)

403

* @channel: target channel number (zero if no channels)

403

* @id: target id number

404

* @id: target id number

404

*

405

*

405

* Return an existing target if one exists, provided it hasn't already

406

* Return an existing target if one exists, provided it hasn't already

406

* gone into STARGET_DEL state, otherwise allocate a new target.

407

* gone into STARGET_DEL state, otherwise allocate a new target.

407

*

408

*

408

* The target is returned with an incremented reference, so the caller

409

* The target is returned with an incremented reference, so the caller

409

* is responsible for both reaping and doing a last put

410

* is responsible for both reaping and doing a last put

410

*/

411

*/

411

static struct scsi_target *scsi_alloc_target(struct device *parent,

412

static struct scsi_target *scsi_alloc_target(struct device *parent,

412

int channel, uint id)

413

int channel, uint id)

413

{

414

{

414

struct Scsi_Host *shost = dev_to_shost(parent);

415

struct Scsi_Host *shost = dev_to_shost(parent);

415

struct device *dev = NULL;

416

struct device *dev = NULL;

416

unsigned long flags;

417

unsigned long flags;

417

const int size = sizeof(struct scsi_target)

418

const int size = sizeof(struct scsi_target)

418

+ shost->transportt->target_size;

419

+ shost->transportt->target_size;

419

struct scsi_target *starget;

420

struct scsi_target *starget;

420

struct scsi_target *found_target;

421

struct scsi_target *found_target;

421

int error, ref_got;

422

int error, ref_got;

422

423

starget = kzalloc(size, GFP_KERNEL);

424

starget = kzalloc(size, GFP_KERNEL);

424

if (!starget) {

425

if (!starget) {

425

printk(KERN_ERR "%s: allocation failure\n", __func__);

426

printk(KERN_ERR "%s: allocation failure\n", __func__);

426

return NULL;

427

return NULL;

427

}

428

}

428

dev = &starget->dev;

429

dev = &starget->dev;

429

device_initialize(dev);

430

device_initialize(dev);

430

kref_init(&starget->reap_ref);

431

kref_init(&starget->reap_ref);

431

dev->parent = get_device(parent);

432

dev->parent = get_device(parent);

432

dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);

433

dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);

433

dev->bus = &scsi_bus_type;

434

dev->bus = &scsi_bus_type;

434

dev->type = &scsi_target_type;

435

dev->type = &scsi_target_type;

435

starget->id = id;

436

starget->id = id;

436

starget->channel = channel;

437

starget->channel = channel;

437

starget->can_queue = 0;

438

starget->can_queue = 0;

438

INIT_LIST_HEAD(&starget->siblings);

439

INIT_LIST_HEAD(&starget->siblings);

439

INIT_LIST_HEAD(&starget->devices);

440

INIT_LIST_HEAD(&starget->devices);

440

starget->state = STARGET_CREATED;

441

starget->state = STARGET_CREATED;

441

starget->scsi_level = SCSI_2;

442

starget->scsi_level = SCSI_2;

442

starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;

443

starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;

443

retry:

444

retry:

444

spin_lock_irqsave(shost->host_lock, flags);

445

spin_lock_irqsave(shost->host_lock, flags);

445

446

found_target = __scsi_find_target(parent, channel, id);

447

found_target = __scsi_find_target(parent, channel, id);

447

if (found_target)

448

if (found_target)

448

goto found;

449

goto found;

449

450

list_add_tail(&starget->siblings, &shost->__targets);

451

list_add_tail(&starget->siblings, &shost->__targets);

451

spin_unlock_irqrestore(shost->host_lock, flags);

452

spin_unlock_irqrestore(shost->host_lock, flags);

452

/* allocate and add */

453

/* allocate and add */

453

transport_setup_device(dev);

454

transport_setup_device(dev);

454

if (shost->hostt->target_alloc) {

455

if (shost->hostt->target_alloc) {

455

error = shost->hostt->target_alloc(starget);

456

error = shost->hostt->target_alloc(starget);

456

457

if(error) {

458

if(error) {

458

dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);

459

dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);

459

/* don't want scsi_target_reap to do the final

460

/* don't want scsi_target_reap to do the final

460

* put because it will be under the host lock */

461

* put because it will be under the host lock */

461

scsi_target_destroy(starget);

462

scsi_target_destroy(starget);

462

return NULL;

463

return NULL;

463

}

464

}

464

}

465

}

465

get_device(dev);

466

get_device(dev);

466

467

return starget;

468

return starget;

468

469

found:

470

found:

470

/*

471

/*

471

* release routine already fired if kref is zero, so if we can still

472

* release routine already fired if kref is zero, so if we can still

472

* take the reference, the target must be alive. If we can't, it must

473

* take the reference, the target must be alive. If we can't, it must

473

* be dying and we need to wait for a new target

474

* be dying and we need to wait for a new target

474

*/

475

*/

475

ref_got = kref_get_unless_zero(&found_target->reap_ref);

476

ref_got = kref_get_unless_zero(&found_target->reap_ref);

476

477

spin_unlock_irqrestore(shost->host_lock, flags);

478

spin_unlock_irqrestore(shost->host_lock, flags);

478

if (ref_got) {

479

if (ref_got) {

479

put_device(dev);

480

put_device(dev);

480

return found_target;

481

return found_target;

481

}

482

}

482

/*

483

/*

483

* Unfortunately, we found a dying target; need to wait until it's

484

* Unfortunately, we found a dying target; need to wait until it's

484

* dead before we can get a new one. There is an anomaly here. We

485

* dead before we can get a new one. There is an anomaly here. We

485

* *should* call scsi_target_reap() to balance the kref_get() of the

486

* *should* call scsi_target_reap() to balance the kref_get() of the

486

* reap_ref above. However, since the target being released, it's

487

* reap_ref above. However, since the target being released, it's

487

* already invisible and the reap_ref is irrelevant. If we call

488

* already invisible and the reap_ref is irrelevant. If we call

488

* scsi_target_reap() we might spuriously do another device_del() on

489

* scsi_target_reap() we might spuriously do another device_del() on

489

* an already invisible target.

490

* an already invisible target.

490

*/

491

*/

491

put_device(&found_target->dev);

492

put_device(&found_target->dev);

492

/*

493

/*

493

* length of time is irrelevant here, we just want to yield the CPU

494

* length of time is irrelevant here, we just want to yield the CPU

494

* for a tick to avoid busy waiting for the target to die.

495

* for a tick to avoid busy waiting for the target to die.

495

*/

496

*/

496

msleep(1);

497

msleep(1);

497

goto retry;

498

goto retry;

498

}

499

}

499

500

/**

501

/**

501

* scsi_target_reap - check to see if target is in use and destroy if not

502

* scsi_target_reap - check to see if target is in use and destroy if not

502

* @starget: target to be checked

503

* @starget: target to be checked

503

*

504

*

504

* This is used after removing a LUN or doing a last put of the target

505

* This is used after removing a LUN or doing a last put of the target

505

* it checks atomically that nothing is using the target and removes

506

* it checks atomically that nothing is using the target and removes

506

* it if so.

507

* it if so.

507

*/

508

*/

508

void scsi_target_reap(struct scsi_target *starget)

509

void scsi_target_reap(struct scsi_target *starget)

509

{

510

{

510

/*

511

/*

511

* serious problem if this triggers: STARGET_DEL is only set in the if

512

* serious problem if this triggers: STARGET_DEL is only set in the if

512

* the reap_ref drops to zero, so we're trying to do another final put

513

* the reap_ref drops to zero, so we're trying to do another final put

513

* on an already released kref

514

* on an already released kref

514

*/

515

*/

515

BUG_ON(starget->state == STARGET_DEL);

516

BUG_ON(starget->state == STARGET_DEL);

516

scsi_target_reap_ref_put(starget);

517

scsi_target_reap_ref_put(starget);

517

}

518

}

518

519

/**

520

/**

520

* sanitize_inquiry_string - remove non-graphical chars from an INQUIRY result string

521

* sanitize_inquiry_string - remove non-graphical chars from an INQUIRY result string

521

* @s: INQUIRY result string to sanitize

522

* @s: INQUIRY result string to sanitize

522

* @len: length of the string

523

* @len: length of the string

523

*

524

*

524

* Description:

525

* Description:

525

* The SCSI spec says that INQUIRY vendor, product, and revision

526

* The SCSI spec says that INQUIRY vendor, product, and revision

526

* strings must consist entirely of graphic ASCII characters,

527

* strings must consist entirely of graphic ASCII characters,

527

* padded on the right with spaces. Since not all devices obey

528

* padded on the right with spaces. Since not all devices obey

528

* this rule, we will replace non-graphic or non-ASCII characters

529

* this rule, we will replace non-graphic or non-ASCII characters

529

* with spaces. Exception: a NUL character is interpreted as a

530

* with spaces. Exception: a NUL character is interpreted as a

530

* string terminator, so all the following characters are set to

531

* string terminator, so all the following characters are set to

531

* spaces.

532

* spaces.

532

**/

533

**/

533

static void sanitize_inquiry_string(unsigned char *s, int len)

534

static void sanitize_inquiry_string(unsigned char *s, int len)

534

{

535

{

535

int terminated = 0;

536

int terminated = 0;

536

537

for (; len > 0; (--len, ++s)) {

538

for (; len > 0; (--len, ++s)) {

538

if (*s == 0)

539

if (*s == 0)

539

terminated = 1;

540

terminated = 1;

540

if (terminated || *s < 0x20 || *s > 0x7e)

541

if (terminated || *s < 0x20 || *s > 0x7e)

541

*s = ' ';

542

*s = ' ';

542

}

543

}

543

}

544

}

544

545

/**

546

/**

546

* scsi_probe_lun - probe a single LUN using a SCSI INQUIRY

547

* scsi_probe_lun - probe a single LUN using a SCSI INQUIRY

547

* @sdev: scsi_device to probe

548

* @sdev: scsi_device to probe

548

* @inq_result: area to store the INQUIRY result

549

* @inq_result: area to store the INQUIRY result

549

* @result_len: len of inq_result

550

* @result_len: len of inq_result

550

* @bflags: store any bflags found here

551

* @bflags: store any bflags found here

551

*

552

*

552

* Description:

553

* Description:

553

* Probe the lun associated with @req using a standard SCSI INQUIRY;

554

* Probe the lun associated with @req using a standard SCSI INQUIRY;

554

*

555

*

555

* If the INQUIRY is successful, zero is returned and the

556

* If the INQUIRY is successful, zero is returned and the

556

* INQUIRY data is in @inq_result; the scsi_level and INQUIRY length

557

* INQUIRY data is in @inq_result; the scsi_level and INQUIRY length

557

* are copied to the scsi_device any flags value is stored in *@bflags.

558

* are copied to the scsi_device any flags value is stored in *@bflags.

558

**/

559

**/

559

static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,

560

static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,

560

int result_len, int *bflags)

561

int result_len, int *bflags)

561

{

562

{

562

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

563

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

563

int first_inquiry_len, try_inquiry_len, next_inquiry_len;

564

int first_inquiry_len, try_inquiry_len, next_inquiry_len;

564

int response_len = 0;

565

int response_len = 0;

565

int pass, count, result;

566

int pass, count, result;

566

struct scsi_sense_hdr sshdr;

567

struct scsi_sense_hdr sshdr;

567

568

*bflags = 0;

569

*bflags = 0;

569

570

/* Perform up to 3 passes. The first pass uses a conservative

571

/* Perform up to 3 passes. The first pass uses a conservative

571

* transfer length of 36 unless sdev->inquiry_len specifies a

572

* transfer length of 36 unless sdev->inquiry_len specifies a

572

* different value. */

573

* different value. */

573

first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36;

574

first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36;

574

try_inquiry_len = first_inquiry_len;

575

try_inquiry_len = first_inquiry_len;

575

pass = 1;

576

pass = 1;

576

577

next_pass:

578

next_pass:

578

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

579

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

579

"scsi scan: INQUIRY pass %d length %d\n",

580

"scsi scan: INQUIRY pass %d length %d\n",

580

pass, try_inquiry_len));

581

pass, try_inquiry_len));

581

582

/* Each pass gets up to three chances to ignore Unit Attention */

583

/* Each pass gets up to three chances to ignore Unit Attention */

583

for (count = 0; count < 3; ++count) {

584

for (count = 0; count < 3; ++count) {

584

int resid;

585

int resid;

585

586

memset(scsi_cmd, 0, 6);

587

memset(scsi_cmd, 0, 6);

587

scsi_cmd[0] = INQUIRY;

588

scsi_cmd[0] = INQUIRY;

588

scsi_cmd[4] = (unsigned char) try_inquiry_len;

589

scsi_cmd[4] = (unsigned char) try_inquiry_len;

589

590

memset(inq_result, 0, try_inquiry_len);

591

memset(inq_result, 0, try_inquiry_len);

591

592

result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,

593

result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,

593

inq_result, try_inquiry_len, &sshdr,

594

inq_result, try_inquiry_len, &sshdr,

594

HZ / 2 + HZ * scsi_inq_timeout, 3,

595

HZ / 2 + HZ * scsi_inq_timeout, 3,

595

&resid);

596

&resid);

596

597

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

598

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

598

"scsi scan: INQUIRY %s with code 0x%x\n",

599

"scsi scan: INQUIRY %s with code 0x%x\n",

599

result ? "failed" : "successful", result));

600

result ? "failed" : "successful", result));

600

601

if (result) {

602

if (result) {

602

/*

603

/*

603

* not-ready to ready transition [asc/ascq=0x28/0x0]

604

* not-ready to ready transition [asc/ascq=0x28/0x0]

604

* or power-on, reset [asc/ascq=0x29/0x0], continue.

605

* or power-on, reset [asc/ascq=0x29/0x0], continue.

605

* INQUIRY should not yield UNIT_ATTENTION

606

* INQUIRY should not yield UNIT_ATTENTION

606

* but many buggy devices do so anyway.

607

* but many buggy devices do so anyway.

607

*/

608

*/

608

if ((driver_byte(result) & DRIVER_SENSE) &&

609

if ((driver_byte(result) & DRIVER_SENSE) &&

609

scsi_sense_valid(&sshdr)) {

610

scsi_sense_valid(&sshdr)) {

610

if ((sshdr.sense_key == UNIT_ATTENTION) &&

611

if ((sshdr.sense_key == UNIT_ATTENTION) &&

611

((sshdr.asc == 0x28) ||

612

((sshdr.asc == 0x28) ||

612

(sshdr.asc == 0x29)) &&

613

(sshdr.asc == 0x29)) &&

613

(sshdr.ascq == 0))

614

(sshdr.ascq == 0))

614

continue;

615

continue;

615

}

616

}

616

} else {

617

} else {

617

/*

618

/*

618

* if nothing was transferred, we try

619

* if nothing was transferred, we try

619

* again. It's a workaround for some USB

620

* again. It's a workaround for some USB

620

* devices.

621

* devices.

621

*/

622

*/

622

if (resid == try_inquiry_len)

623

if (resid == try_inquiry_len)

623

continue;

624

continue;

624

}

625

}

625

break;

626

break;

626

}

627

}

627

628

if (result == 0) {

629

if (result == 0) {

629

sanitize_inquiry_string(&inq_result[8], 8);

630

sanitize_inquiry_string(&inq_result[8], 8);

630

sanitize_inquiry_string(&inq_result[16], 16);

631

sanitize_inquiry_string(&inq_result[16], 16);

631

sanitize_inquiry_string(&inq_result[32], 4);

632

sanitize_inquiry_string(&inq_result[32], 4);

632

633

response_len = inq_result[4] + 5;

634

response_len = inq_result[4] + 5;

634

if (response_len > 255)

635

if (response_len > 255)

635

response_len = first_inquiry_len; /* sanity */

636

response_len = first_inquiry_len; /* sanity */

636

637

/*

638

/*

638

* Get any flags for this device.

639

* Get any flags for this device.

639

*

640

*

640

* XXX add a bflags to scsi_device, and replace the

641

* XXX add a bflags to scsi_device, and replace the

641

* corresponding bit fields in scsi_device, so bflags

642

* corresponding bit fields in scsi_device, so bflags

642

* need not be passed as an argument.

643

* need not be passed as an argument.

643

*/

644

*/

644

*bflags = scsi_get_device_flags(sdev, &inq_result[8],

645

*bflags = scsi_get_device_flags(sdev, &inq_result[8],

645

&inq_result[16]);

646

&inq_result[16]);

646

647

/* When the first pass succeeds we gain information about

648

/* When the first pass succeeds we gain information about

648

* what larger transfer lengths might work. */

649

* what larger transfer lengths might work. */

649

if (pass == 1) {

650

if (pass == 1) {

650

if (BLIST_INQUIRY_36 & *bflags)

651

if (BLIST_INQUIRY_36 & *bflags)

651

next_inquiry_len = 36;

652

next_inquiry_len = 36;

652

else if (BLIST_INQUIRY_58 & *bflags)

653

else if (BLIST_INQUIRY_58 & *bflags)

653

next_inquiry_len = 58;

654

next_inquiry_len = 58;

654

else if (sdev->inquiry_len)

655

else if (sdev->inquiry_len)

655

next_inquiry_len = sdev->inquiry_len;

656

next_inquiry_len = sdev->inquiry_len;

656

else

657

else

657

next_inquiry_len = response_len;

658

next_inquiry_len = response_len;

658

659

/* If more data is available perform the second pass */

660

/* If more data is available perform the second pass */

660

if (next_inquiry_len > try_inquiry_len) {

661

if (next_inquiry_len > try_inquiry_len) {

661

try_inquiry_len = next_inquiry_len;

662

try_inquiry_len = next_inquiry_len;

662

pass = 2;

663

pass = 2;

663

goto next_pass;

664

goto next_pass;

664

}

665

}

665

}

666

}

666

667

} else if (pass == 2) {

668

} else if (pass == 2) {

668

sdev_printk(KERN_INFO, sdev,

669

sdev_printk(KERN_INFO, sdev,

669

"scsi scan: %d byte inquiry failed. "

670

"scsi scan: %d byte inquiry failed. "

670

"Consider BLIST_INQUIRY_36 for this device\n",

671

"Consider BLIST_INQUIRY_36 for this device\n",

671

try_inquiry_len);

672

try_inquiry_len);

672

673

/* If this pass failed, the third pass goes back and transfers

674

/* If this pass failed, the third pass goes back and transfers

674

* the same amount as we successfully got in the first pass. */

675

* the same amount as we successfully got in the first pass. */

675

try_inquiry_len = first_inquiry_len;

676

try_inquiry_len = first_inquiry_len;

676

pass = 3;

677

pass = 3;

677

goto next_pass;

678

goto next_pass;

678

}

679

}

679

680

/* If the last transfer attempt got an error, assume the

681

/* If the last transfer attempt got an error, assume the

681

* peripheral doesn't exist or is dead. */

682

* peripheral doesn't exist or is dead. */

682

if (result)

683

if (result)

683

return -EIO;

684

return -EIO;

684

685

/* Don't report any more data than the device says is valid */

686

/* Don't report any more data than the device says is valid */

686

sdev->inquiry_len = min(try_inquiry_len, response_len);

687

sdev->inquiry_len = min(try_inquiry_len, response_len);

687

688

/*

689

/*

689

* XXX Abort if the response length is less than 36? If less than

690

* XXX Abort if the response length is less than 36? If less than

690

* 32, the lookup of the device flags (above) could be invalid,

691

* 32, the lookup of the device flags (above) could be invalid,

691

* and it would be possible to take an incorrect action - we do

692

* and it would be possible to take an incorrect action - we do

692

* not want to hang because of a short INQUIRY. On the flip side,

693

* not want to hang because of a short INQUIRY. On the flip side,

693

* if the device is spun down or becoming ready (and so it gives a

694

* if the device is spun down or becoming ready (and so it gives a

694

* short INQUIRY), an abort here prevents any further use of the

695

* short INQUIRY), an abort here prevents any further use of the

695

* device, including spin up.

696

* device, including spin up.

696

*

697

*

697

* On the whole, the best approach seems to be to assume the first

698

* On the whole, the best approach seems to be to assume the first

698

* 36 bytes are valid no matter what the device says. That's

699

* 36 bytes are valid no matter what the device says. That's

699

* better than copying < 36 bytes to the inquiry-result buffer

700

* better than copying < 36 bytes to the inquiry-result buffer

700

* and displaying garbage for the Vendor, Product, or Revision

701

* and displaying garbage for the Vendor, Product, or Revision

701

* strings.

702

* strings.

702

*/

703

*/

703

if (sdev->inquiry_len < 36) {

704

if (sdev->inquiry_len < 36) {

704

if (!sdev->host->short_inquiry) {

705

if (!sdev->host->short_inquiry) {

705

shost_printk(KERN_INFO, sdev->host,

706

shost_printk(KERN_INFO, sdev->host,

706

"scsi scan: INQUIRY result too short (%d),"

707

"scsi scan: INQUIRY result too short (%d),"

707

" using 36\n", sdev->inquiry_len);

708

" using 36\n", sdev->inquiry_len);

708

sdev->host->short_inquiry = 1;

709

sdev->host->short_inquiry = 1;

709

}

710

}

710

sdev->inquiry_len = 36;

711

sdev->inquiry_len = 36;

711

}

712

}

712

713

/*

714

/*

714

* Related to the above issue:

715

* Related to the above issue:

715

*

716

*

716

* XXX Devices (disk or all?) should be sent a TEST UNIT READY,

717

* XXX Devices (disk or all?) should be sent a TEST UNIT READY,

717

* and if not ready, sent a START_STOP to start (maybe spin up) and

718

* and if not ready, sent a START_STOP to start (maybe spin up) and

718

* then send the INQUIRY again, since the INQUIRY can change after

719

* then send the INQUIRY again, since the INQUIRY can change after

719

* a device is initialized.

720

* a device is initialized.

720

*

721

*

721

* Ideally, start a device if explicitly asked to do so. This

722

* Ideally, start a device if explicitly asked to do so. This

722

* assumes that a device is spun up on power on, spun down on

723

* assumes that a device is spun up on power on, spun down on

723

* request, and then spun up on request.

724

* request, and then spun up on request.

724

*/

725

*/

725

726

/*

727

/*

727

* The scanning code needs to know the scsi_level, even if no

728

* The scanning code needs to know the scsi_level, even if no

728

* device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so

729

* device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so

729

* non-zero LUNs can be scanned.

730

* non-zero LUNs can be scanned.

730

*/

731

*/

731

sdev->scsi_level = inq_result[2] & 0x07;

732

sdev->scsi_level = inq_result[2] & 0x07;

732

if (sdev->scsi_level >= 2 ||

733

if (sdev->scsi_level >= 2 ||

733

(sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))

734

(sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))

734

sdev->scsi_level++;

735

sdev->scsi_level++;

735

sdev->sdev_target->scsi_level = sdev->scsi_level;

736

sdev->sdev_target->scsi_level = sdev->scsi_level;

736

737

/*

738

/*

738

* If SCSI-2 or lower, and if the transport requires it,

739

* If SCSI-2 or lower, and if the transport requires it,

739

* store the LUN value in CDB[1].

740

* store the LUN value in CDB[1].

740

*/

741

*/

741

sdev->lun_in_cdb = 0;

742

sdev->lun_in_cdb = 0;

742

if (sdev->scsi_level <= SCSI_2 &&

743

if (sdev->scsi_level <= SCSI_2 &&

743

sdev->scsi_level != SCSI_UNKNOWN &&

744

sdev->scsi_level != SCSI_UNKNOWN &&

744

!sdev->host->no_scsi2_lun_in_cdb)

745

!sdev->host->no_scsi2_lun_in_cdb)

745

sdev->lun_in_cdb = 1;

746

sdev->lun_in_cdb = 1;

746

747

return 0;

748

return 0;

748

}

749

}

749

750

/**

751

/**

751

* scsi_add_lun - allocate and fully initialze a scsi_device

752

* scsi_add_lun - allocate and fully initialze a scsi_device

752

* @sdev: holds information to be stored in the new scsi_device

753

* @sdev: holds information to be stored in the new scsi_device

753

* @inq_result: holds the result of a previous INQUIRY to the LUN

754

* @inq_result: holds the result of a previous INQUIRY to the LUN

754

* @bflags: black/white list flag

755

* @bflags: black/white list flag

755

* @async: 1 if this device is being scanned asynchronously

756

* @async: 1 if this device is being scanned asynchronously

756

*

757

*

757

* Description:

758

* Description:

758

* Initialize the scsi_device @sdev. Optionally set fields based

759

* Initialize the scsi_device @sdev. Optionally set fields based

759

* on values in *@bflags.

760

* on values in *@bflags.

760

*

761

*

761

* Return:

762

* Return:

762

* SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device

763

* SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device

763

* SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized

764

* SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized

764

**/

765

**/

765

static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,

766

static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,

766

int *bflags, int async)

767

int *bflags, int async)

767

{

768

{

768

int ret;

769

int ret;

769

770

/*

771

/*

771

* XXX do not save the inquiry, since it can change underneath us,

772

* XXX do not save the inquiry, since it can change underneath us,

772

* save just vendor/model/rev.

773

* save just vendor/model/rev.

773

*

774

*

774

* Rather than save it and have an ioctl that retrieves the saved

775

* Rather than save it and have an ioctl that retrieves the saved

775

* value, have an ioctl that executes the same INQUIRY code used

776

* value, have an ioctl that executes the same INQUIRY code used

776

* in scsi_probe_lun, let user level programs doing INQUIRY

777

* in scsi_probe_lun, let user level programs doing INQUIRY

777

* scanning run at their own risk, or supply a user level program

778

* scanning run at their own risk, or supply a user level program

778

* that can correctly scan.

779

* that can correctly scan.

779

*/

780

*/

780

781

/*

782

/*

782

* Copy at least 36 bytes of INQUIRY data, so that we don't

783

* Copy at least 36 bytes of INQUIRY data, so that we don't

783

* dereference unallocated memory when accessing the Vendor,

784

* dereference unallocated memory when accessing the Vendor,

784

* Product, and Revision strings. Badly behaved devices may set

785

* Product, and Revision strings. Badly behaved devices may set

785

* the INQUIRY Additional Length byte to a small value, indicating

786

* the INQUIRY Additional Length byte to a small value, indicating

786

* these strings are invalid, but often they contain plausible data

787

* these strings are invalid, but often they contain plausible data

787

* nonetheless. It doesn't matter if the device sent < 36 bytes

788

* nonetheless. It doesn't matter if the device sent < 36 bytes

788

* total, since scsi_probe_lun() initializes inq_result with 0s.

789

* total, since scsi_probe_lun() initializes inq_result with 0s.

789

*/

790

*/

790

sdev->inquiry = kmemdup(inq_result,

791

sdev->inquiry = kmemdup(inq_result,

791

max_t(size_t, sdev->inquiry_len, 36),

792

max_t(size_t, sdev->inquiry_len, 36),

792

GFP_ATOMIC);

793

GFP_ATOMIC);

793

if (sdev->inquiry == NULL)

794

if (sdev->inquiry == NULL)

794

return SCSI_SCAN_NO_RESPONSE;

795

return SCSI_SCAN_NO_RESPONSE;

795

796

sdev->vendor = (char *) (sdev->inquiry + 8);

797

sdev->vendor = (char *) (sdev->inquiry + 8);

797

sdev->model = (char *) (sdev->inquiry + 16);

798

sdev->model = (char *) (sdev->inquiry + 16);

798

sdev->rev = (char *) (sdev->inquiry + 32);

799

sdev->rev = (char *) (sdev->inquiry + 32);

799

800

if (strncmp(sdev->vendor, "ATA ", 8) == 0) {

801

if (strncmp(sdev->vendor, "ATA ", 8) == 0) {

801

/*

802

/*

802

* sata emulation layer device. This is a hack to work around

803

* sata emulation layer device. This is a hack to work around

803

* the SATL power management specifications which state that

804

* the SATL power management specifications which state that

804

* when the SATL detects the device has gone into standby

805

* when the SATL detects the device has gone into standby

805

* mode, it shall respond with NOT READY.

806

* mode, it shall respond with NOT READY.

806

*/

807

*/

807

sdev->allow_restart = 1;

808

sdev->allow_restart = 1;

808

}

809

}

809

810

if (*bflags & BLIST_ISROM) {

811

if (*bflags & BLIST_ISROM) {

811

sdev->type = TYPE_ROM;

812

sdev->type = TYPE_ROM;

812

sdev->removable = 1;

813

sdev->removable = 1;

813

} else {

814

} else {

814

sdev->type = (inq_result[0] & 0x1f);

815

sdev->type = (inq_result[0] & 0x1f);

815

sdev->removable = (inq_result[1] & 0x80) >> 7;

816

sdev->removable = (inq_result[1] & 0x80) >> 7;

816

817

/*

818

/*

818

* some devices may respond with wrong type for

819

* some devices may respond with wrong type for

819

* well-known logical units. Force well-known type

820

* well-known logical units. Force well-known type

820

* to enumerate them correctly.

821

* to enumerate them correctly.

821

*/

822

*/

822

if (scsi_is_wlun(sdev->lun) && sdev->type != TYPE_WLUN) {

823

if (scsi_is_wlun(sdev->lun) && sdev->type != TYPE_WLUN) {

823

sdev_printk(KERN_WARNING, sdev,

824

sdev_printk(KERN_WARNING, sdev,

824

"%s: correcting incorrect peripheral device type 0x%x for W-LUN 0x%16xhN\n",

825

"%s: correcting incorrect peripheral device type 0x%x for W-LUN 0x%16xhN\n",

825

__func__, sdev->type, (unsigned int)sdev->lun);

826

__func__, sdev->type, (unsigned int)sdev->lun);

826

sdev->type = TYPE_WLUN;

827

sdev->type = TYPE_WLUN;

827

}

828

}

828

829

}

830

}

830

831

if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {

832

if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {

832

/* RBC and MMC devices can return SCSI-3 compliance and yet

833

/* RBC and MMC devices can return SCSI-3 compliance and yet

833

* still not support REPORT LUNS, so make them act as

834

* still not support REPORT LUNS, so make them act as

834

* BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is

835

* BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is

835

* specifically set */

836

* specifically set */

836

if ((*bflags & BLIST_REPORTLUN2) == 0)

837

if ((*bflags & BLIST_REPORTLUN2) == 0)

837

*bflags |= BLIST_NOREPORTLUN;

838

*bflags |= BLIST_NOREPORTLUN;

838

}

839

}

839

840

/*

841

/*

841

* For a peripheral qualifier (PQ) value of 1 (001b), the SCSI

842

* For a peripheral qualifier (PQ) value of 1 (001b), the SCSI

842

* spec says: The device server is capable of supporting the

843

* spec says: The device server is capable of supporting the

843

* specified peripheral device type on this logical unit. However,

844

* specified peripheral device type on this logical unit. However,

844

* the physical device is not currently connected to this logical

845

* the physical device is not currently connected to this logical

845

* unit.

846

* unit.

846

*

847

*

847

* The above is vague, as it implies that we could treat 001 and

848

* The above is vague, as it implies that we could treat 001 and

848

* 011 the same. Stay compatible with previous code, and create a

849

* 011 the same. Stay compatible with previous code, and create a

849

* scsi_device for a PQ of 1

850

* scsi_device for a PQ of 1

850

*

851

*

851

* Don't set the device offline here; rather let the upper

852

* Don't set the device offline here; rather let the upper

852

* level drivers eval the PQ to decide whether they should

853

* level drivers eval the PQ to decide whether they should

853

* attach. So remove ((inq_result[0] >> 5) & 7) == 1 check.

854

* attach. So remove ((inq_result[0] >> 5) & 7) == 1 check.

854

*/

855

*/

855

856

sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;

857

sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;

857

sdev->lockable = sdev->removable;

858

sdev->lockable = sdev->removable;

858

sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);

859

sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);

859

860

if (sdev->scsi_level >= SCSI_3 ||

861

if (sdev->scsi_level >= SCSI_3 ||

861

(sdev->inquiry_len > 56 && inq_result[56] & 0x04))

862

(sdev->inquiry_len > 56 && inq_result[56] & 0x04))

862

sdev->ppr = 1;

863

sdev->ppr = 1;

863

if (inq_result[7] & 0x60)

864

if (inq_result[7] & 0x60)

864

sdev->wdtr = 1;

865

sdev->wdtr = 1;

865

if (inq_result[7] & 0x10)

866

if (inq_result[7] & 0x10)

866

sdev->sdtr = 1;

867

sdev->sdtr = 1;

867

868

sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "

869

sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "

869

"ANSI: %d%s\n", scsi_device_type(sdev->type),

870

"ANSI: %d%s\n", scsi_device_type(sdev->type),

870

sdev->vendor, sdev->model, sdev->rev,

871

sdev->vendor, sdev->model, sdev->rev,

871

sdev->inq_periph_qual, inq_result[2] & 0x07,

872

sdev->inq_periph_qual, inq_result[2] & 0x07,

872

(inq_result[3] & 0x0f) == 1 ? " CCS" : "");

873

(inq_result[3] & 0x0f) == 1 ? " CCS" : "");

873

874

if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&

875

if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&

875

!(*bflags & BLIST_NOTQ)) {

876

!(*bflags & BLIST_NOTQ)) {

876

sdev->tagged_supported = 1;

877

sdev->tagged_supported = 1;

877

sdev->simple_tags = 1;

878

sdev->simple_tags = 1;

878

}

879

}

879

880

/*

881

/*

881

* Some devices (Texel CD ROM drives) have handshaking problems

882

* Some devices (Texel CD ROM drives) have handshaking problems

882

* when used with the Seagate controllers. borken is initialized

883

* when used with the Seagate controllers. borken is initialized

883

* to 1, and then set it to 0 here.

884

* to 1, and then set it to 0 here.

884

*/

885

*/

885

if ((*bflags & BLIST_BORKEN) == 0)

886

if ((*bflags & BLIST_BORKEN) == 0)

886

sdev->borken = 0;

887

sdev->borken = 0;

887

888

if (*bflags & BLIST_NO_ULD_ATTACH)

889

if (*bflags & BLIST_NO_ULD_ATTACH)

889

sdev->no_uld_attach = 1;

890

sdev->no_uld_attach = 1;

890

891

/*

892

/*

892

* Apparently some really broken devices (contrary to the SCSI

893

* Apparently some really broken devices (contrary to the SCSI

893

* standards) need to be selected without asserting ATN

894

* standards) need to be selected without asserting ATN

894

*/

895

*/

895

if (*bflags & BLIST_SELECT_NO_ATN)

896

if (*bflags & BLIST_SELECT_NO_ATN)

896

sdev->select_no_atn = 1;

897

sdev->select_no_atn = 1;

897

898

/*

899

/*

899

* Maximum 512 sector transfer length

900

* Maximum 512 sector transfer length

900

* broken RA4x00 Compaq Disk Array

901

* broken RA4x00 Compaq Disk Array

901

*/

902

*/

902

if (*bflags & BLIST_MAX_512)

903

if (*bflags & BLIST_MAX_512)

903

blk_queue_max_hw_sectors(sdev->request_queue, 512);

904

blk_queue_max_hw_sectors(sdev->request_queue, 512);

904

/*

905

/*

905

* Max 1024 sector transfer length for targets that report incorrect

906

* Max 1024 sector transfer length for targets that report incorrect

906

* max/optimal lengths and relied on the old block layer safe default

907

* max/optimal lengths and relied on the old block layer safe default

907

*/

908

*/

908

else if (*bflags & BLIST_MAX_1024)

909

else if (*bflags & BLIST_MAX_1024)

909

blk_queue_max_hw_sectors(sdev->request_queue, 1024);

910

blk_queue_max_hw_sectors(sdev->request_queue, 1024);

910

911

/*

912

/*

912

* Some devices may not want to have a start command automatically

913

* Some devices may not want to have a start command automatically

913

* issued when a device is added.

914

* issued when a device is added.

914

*/

915

*/

915

if (*bflags & BLIST_NOSTARTONADD)

916

if (*bflags & BLIST_NOSTARTONADD)

916

sdev->no_start_on_add = 1;

917

sdev->no_start_on_add = 1;

917

918

if (*bflags & BLIST_SINGLELUN)

919

if (*bflags & BLIST_SINGLELUN)

919

scsi_target(sdev)->single_lun = 1;

920

scsi_target(sdev)->single_lun = 1;

920

921

sdev->use_10_for_rw = 1;

922

sdev->use_10_for_rw = 1;

922

923

if (*bflags & BLIST_MS_SKIP_PAGE_08)

924

if (*bflags & BLIST_MS_SKIP_PAGE_08)

924

sdev->skip_ms_page_8 = 1;

925

sdev->skip_ms_page_8 = 1;

925

926

if (*bflags & BLIST_MS_SKIP_PAGE_3F)

927

if (*bflags & BLIST_MS_SKIP_PAGE_3F)

927

sdev->skip_ms_page_3f = 1;

928

sdev->skip_ms_page_3f = 1;

928

929

if (*bflags & BLIST_USE_10_BYTE_MS)

930

if (*bflags & BLIST_USE_10_BYTE_MS)

930

sdev->use_10_for_ms = 1;

931

sdev->use_10_for_ms = 1;

931

932

/* some devices don't like REPORT SUPPORTED OPERATION CODES

933

/* some devices don't like REPORT SUPPORTED OPERATION CODES

933

* and will simply timeout causing sd_mod init to take a very

934

* and will simply timeout causing sd_mod init to take a very

934

* very long time */

935

* very long time */

935

if (*bflags & BLIST_NO_RSOC)

936

if (*bflags & BLIST_NO_RSOC)

936

sdev->no_report_opcodes = 1;

937

sdev->no_report_opcodes = 1;

937

938

/* set the device running here so that slave configure

939

/* set the device running here so that slave configure

939

* may do I/O */

940

* may do I/O */

940

ret = scsi_device_set_state(sdev, SDEV_RUNNING);

941

ret = scsi_device_set_state(sdev, SDEV_RUNNING);

941

if (ret) {

942

if (ret) {

942

ret = scsi_device_set_state(sdev, SDEV_BLOCK);

943

ret = scsi_device_set_state(sdev, SDEV_BLOCK);

943

944

if (ret) {

945

if (ret) {

945

sdev_printk(KERN_ERR, sdev,

946

sdev_printk(KERN_ERR, sdev,

946

"in wrong state %s to complete scan\n",

947

"in wrong state %s to complete scan\n",

947

scsi_device_state_name(sdev->sdev_state));

948

scsi_device_state_name(sdev->sdev_state));

948

return SCSI_SCAN_NO_RESPONSE;

949

return SCSI_SCAN_NO_RESPONSE;

949

}

950

}

950

}

951

}

951

952

if (*bflags & BLIST_MS_192_BYTES_FOR_3F)

953

if (*bflags & BLIST_MS_192_BYTES_FOR_3F)

953

sdev->use_192_bytes_for_3f = 1;

954

sdev->use_192_bytes_for_3f = 1;

954

955

if (*bflags & BLIST_NOT_LOCKABLE)

956

if (*bflags & BLIST_NOT_LOCKABLE)

956

sdev->lockable = 0;

957

sdev->lockable = 0;

957

958

if (*bflags & BLIST_RETRY_HWERROR)

959

if (*bflags & BLIST_RETRY_HWERROR)

959

sdev->retry_hwerror = 1;

960

sdev->retry_hwerror = 1;

960

961

if (*bflags & BLIST_NO_DIF)

962

if (*bflags & BLIST_NO_DIF)

962

sdev->no_dif = 1;

963

sdev->no_dif = 1;

963

964

sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;

965

sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;

965

966

if (*bflags & BLIST_TRY_VPD_PAGES)

967

if (*bflags & BLIST_TRY_VPD_PAGES)

967

sdev->try_vpd_pages = 1;

968

sdev->try_vpd_pages = 1;

968

else if (*bflags & BLIST_SKIP_VPD_PAGES)

969

else if (*bflags & BLIST_SKIP_VPD_PAGES)

969

sdev->skip_vpd_pages = 1;

970

sdev->skip_vpd_pages = 1;

970

971

transport_configure_device(&sdev->sdev_gendev);

972

transport_configure_device(&sdev->sdev_gendev);

972

973

if (sdev->host->hostt->slave_configure) {

974

if (sdev->host->hostt->slave_configure) {

974

ret = sdev->host->hostt->slave_configure(sdev);

975

ret = sdev->host->hostt->slave_configure(sdev);

975

if (ret) {

976

if (ret) {

976

/*

977

/*

977

* if LLDD reports slave not present, don't clutter

978

* if LLDD reports slave not present, don't clutter

978

* console with alloc failure messages

979

* console with alloc failure messages

979

*/

980

*/

980

if (ret != -ENXIO) {

981

if (ret != -ENXIO) {

981

sdev_printk(KERN_ERR, sdev,

982

sdev_printk(KERN_ERR, sdev,

982

"failed to configure device\n");

983

"failed to configure device\n");

983

}

984

}

984

return SCSI_SCAN_NO_RESPONSE;

985

return SCSI_SCAN_NO_RESPONSE;

985

}

986

}

986

}

987

}

987

988

if (sdev->scsi_level >= SCSI_3)

989

if (sdev->scsi_level >= SCSI_3)

989

scsi_attach_vpd(sdev);

990

scsi_attach_vpd(sdev);

990

991

sdev->max_queue_depth = sdev->queue_depth;

992

sdev->max_queue_depth = sdev->queue_depth;

992

993

/*

994

/*

994

* Ok, the device is now all set up, we can

995

* Ok, the device is now all set up, we can

995

* register it and tell the rest of the kernel

996

* register it and tell the rest of the kernel

996

* about it.

997

* about it.

997

*/

998

*/

998

if (!async && scsi_sysfs_add_sdev(sdev) != 0)

999

if (!async && scsi_sysfs_add_sdev(sdev) != 0)

999

return SCSI_SCAN_NO_RESPONSE;

1000

return SCSI_SCAN_NO_RESPONSE;

1000

1001

return SCSI_SCAN_LUN_PRESENT;

1002

return SCSI_SCAN_LUN_PRESENT;

1002

}

1003

}

1003

1004

#ifdef CONFIG_SCSI_LOGGING

1005

#ifdef CONFIG_SCSI_LOGGING

1005

/**

1006

/**

1006

* scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace

1007

* scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace

1007

* @buf: Output buffer with at least end-first+1 bytes of space

1008

* @buf: Output buffer with at least end-first+1 bytes of space

1008

* @inq: Inquiry buffer (input)

1009

* @inq: Inquiry buffer (input)

1009

* @first: Offset of string into inq

1010

* @first: Offset of string into inq

1010

* @end: Index after last character in inq

1011

* @end: Index after last character in inq

1011

*/

1012

*/

1012

static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,

1013

static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,

1013

unsigned first, unsigned end)

1014

unsigned first, unsigned end)

1014

{

1015

{

1015

unsigned term = 0, idx;

1016

unsigned term = 0, idx;

1016

1017

for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {

1018

for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {

1018

if (inq[idx+first] > ' ') {

1019

if (inq[idx+first] > ' ') {

1019

buf[idx] = inq[idx+first];

1020

buf[idx] = inq[idx+first];

1020

term = idx+1;

1021

term = idx+1;

1021

} else {

1022

} else {

1022

buf[idx] = ' ';

1023

buf[idx] = ' ';

1023

}

1024

}

1024

}

1025

}

1025

buf[term] = 0;

1026

buf[term] = 0;

1026

return buf;

1027

return buf;

1027

}

1028

}

1028

#endif

1029

#endif

1029

1030

/**

1031

/**

1031

* scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it

1032

* scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it

1032

* @starget: pointer to target device structure

1033

* @starget: pointer to target device structure

1033

* @lun: LUN of target device

1034

* @lun: LUN of target device

1034

* @bflagsp: store bflags here if not NULL

1035

* @bflagsp: store bflags here if not NULL

1035

* @sdevp: probe the LUN corresponding to this scsi_device

1036

* @sdevp: probe the LUN corresponding to this scsi_device

1036

* @rescan: if nonzero skip some code only needed on first scan

1037

* @rescan: if nonzero skip some code only needed on first scan

1037

* @hostdata: passed to scsi_alloc_sdev()

1038

* @hostdata: passed to scsi_alloc_sdev()

1038

*

1039

*

1039

* Description:

1040

* Description:

1040

* Call scsi_probe_lun, if a LUN with an attached device is found,

1041

* Call scsi_probe_lun, if a LUN with an attached device is found,

1041

* allocate and set it up by calling scsi_add_lun.

1042

* allocate and set it up by calling scsi_add_lun.

1042

*

1043

*

1043

* Return:

1044

* Return:

1044

* SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device

1045

* SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device

1045

* SCSI_SCAN_TARGET_PRESENT: target responded, but no device is

1046

* SCSI_SCAN_TARGET_PRESENT: target responded, but no device is

1046

* attached at the LUN

1047

* attached at the LUN

1047

* SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized

1048

* SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized

1048

**/

1049

**/

1049

static int scsi_probe_and_add_lun(struct scsi_target *starget,

1050

static int scsi_probe_and_add_lun(struct scsi_target *starget,

1050

u64 lun, int *bflagsp,

1051

u64 lun, int *bflagsp,

1051

struct scsi_device **sdevp, int rescan,

1052

struct scsi_device **sdevp, int rescan,

1052

void *hostdata)

1053

void *hostdata)

1053

{

1054

{

1054

struct scsi_device *sdev;

1055

struct scsi_device *sdev;

1055

unsigned char *result;

1056

unsigned char *result;

1056

int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;

1057

int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;

1057

struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

1058

struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

1058

1059

/*

1060

/*

1060

* The rescan flag is used as an optimization, the first scan of a

1061

* The rescan flag is used as an optimization, the first scan of a

1061

* host adapter calls into here with rescan == 0.

1062

* host adapter calls into here with rescan == 0.

1062

*/

1063

*/

1063

sdev = scsi_device_lookup_by_target(starget, lun);

1064

sdev = scsi_device_lookup_by_target(starget, lun);

1064

if (sdev) {

1065

if (sdev) {

1065

if (rescan || !scsi_device_created(sdev)) {

1066

if (rescan || !scsi_device_created(sdev)) {

1066

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

1067

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

1067

"scsi scan: device exists on %s\n",

1068

"scsi scan: device exists on %s\n",

1068

dev_name(&sdev->sdev_gendev)));

1069

dev_name(&sdev->sdev_gendev)));

1069

if (sdevp)

1070

if (sdevp)

1070

*sdevp = sdev;

1071

*sdevp = sdev;

1071

else

1072

else

1072

scsi_device_put(sdev);

1073

scsi_device_put(sdev);

1073

1074

if (bflagsp)

1075

if (bflagsp)

1075

*bflagsp = scsi_get_device_flags(sdev,

1076

*bflagsp = scsi_get_device_flags(sdev,

1076

sdev->vendor,

1077

sdev->vendor,

1077

sdev->model);

1078

sdev->model);

1078

return SCSI_SCAN_LUN_PRESENT;

1079

return SCSI_SCAN_LUN_PRESENT;

1079

}

1080

}

1080

scsi_device_put(sdev);

1081

scsi_device_put(sdev);

1081

} else

1082

} else

1082

sdev = scsi_alloc_sdev(starget, lun, hostdata);

1083

sdev = scsi_alloc_sdev(starget, lun, hostdata);

1083

if (!sdev)

1084

if (!sdev)

1084

goto out;

1085

goto out;

1085

1086

result = kmalloc(result_len, GFP_ATOMIC |

1087

result = kmalloc(result_len, GFP_ATOMIC |

1087

((shost->unchecked_isa_dma) ? __GFP_DMA : 0));

1088

((shost->unchecked_isa_dma) ? __GFP_DMA : 0));

1088

if (!result)

1089

if (!result)

1089

goto out_free_sdev;

1090

goto out_free_sdev;

1090

1091

if (scsi_probe_lun(sdev, result, result_len, &bflags))

1092

if (scsi_probe_lun(sdev, result, result_len, &bflags))

1092

goto out_free_result;

1093

goto out_free_result;

1093

1094

if (bflagsp)

1095

if (bflagsp)

1095

*bflagsp = bflags;

1096

*bflagsp = bflags;

1096

/*

1097

/*

1097

* result contains valid SCSI INQUIRY data.

1098

* result contains valid SCSI INQUIRY data.

1098

*/

1099

*/

1099

if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {

1100

if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {

1100

/*

1101

/*

1101

* For a Peripheral qualifier 3 (011b), the SCSI

1102

* For a Peripheral qualifier 3 (011b), the SCSI

1102

* spec says: The device server is not capable of

1103

* spec says: The device server is not capable of

1103

* supporting a physical device on this logical

1104

* supporting a physical device on this logical

1104

* unit.

1105

* unit.

1105

*

1106

*

1106

* For disks, this implies that there is no

1107

* For disks, this implies that there is no

1107

* logical disk configured at sdev->lun, but there

1108

* logical disk configured at sdev->lun, but there

1108

* is a target id responding.

1109

* is a target id responding.

1109

*/

1110

*/

1110

SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"

1111

SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"

1111

" peripheral qualifier of 3, device not"

1112

" peripheral qualifier of 3, device not"

1112

" added\n"))

1113

" added\n"))

1113

if (lun == 0) {

1114

if (lun == 0) {

1114

SCSI_LOG_SCAN_BUS(1, {

1115

SCSI_LOG_SCAN_BUS(1, {

1115

unsigned char vend[9];

1116

unsigned char vend[9];

1116

unsigned char mod[17];

1117

unsigned char mod[17];

1117

1118

sdev_printk(KERN_INFO, sdev,

1119

sdev_printk(KERN_INFO, sdev,

1119

"scsi scan: consider passing scsi_mod."

1120

"scsi scan: consider passing scsi_mod."

1120

"dev_flags=%s:%s:0x240 or 0x1000240\n",

1121

"dev_flags=%s:%s:0x240 or 0x1000240\n",

1121

scsi_inq_str(vend, result, 8, 16),

1122

scsi_inq_str(vend, result, 8, 16),

1122

scsi_inq_str(mod, result, 16, 32));

1123

scsi_inq_str(mod, result, 16, 32));

1123

});

1124

});

1124

1125

}

1126

}

1126

1127

res = SCSI_SCAN_TARGET_PRESENT;

1128

res = SCSI_SCAN_TARGET_PRESENT;

1128

goto out_free_result;

1129

goto out_free_result;

1129

}

1130

}

1130

1131

/*

1132

/*

1132

* Some targets may set slight variations of PQ and PDT to signal

1133

* Some targets may set slight variations of PQ and PDT to signal

1133

* that no LUN is present, so don't add sdev in these cases.

1134

* that no LUN is present, so don't add sdev in these cases.

1134

* Two specific examples are:

1135

* Two specific examples are:

1135

* 1) NetApp targets: return PQ=1, PDT=0x1f

1136

* 1) NetApp targets: return PQ=1, PDT=0x1f

1136

* 2) USB UFI: returns PDT=0x1f, with the PQ bits being "reserved"

1137

* 2) USB UFI: returns PDT=0x1f, with the PQ bits being "reserved"

1137

* in the UFI 1.0 spec (we cannot rely on reserved bits).

1138

* in the UFI 1.0 spec (we cannot rely on reserved bits).

1138

*

1139

*

1139

* References:

1140

* References:

1140

* 1) SCSI SPC-3, pp. 145-146

1141

* 1) SCSI SPC-3, pp. 145-146

1141

* PQ=1: "A peripheral device having the specified peripheral

1142

* PQ=1: "A peripheral device having the specified peripheral

1142

* device type is not connected to this logical unit. However, the

1143

* device type is not connected to this logical unit. However, the

1143

* device server is capable of supporting the specified peripheral

1144

* device server is capable of supporting the specified peripheral

1144

* device type on this logical unit."

1145

* device type on this logical unit."

1145

* PDT=0x1f: "Unknown or no device type"

1146

* PDT=0x1f: "Unknown or no device type"

1146

* 2) USB UFI 1.0, p. 20

1147

* 2) USB UFI 1.0, p. 20

1147

* PDT=00h Direct-access device (floppy)

1148

* PDT=00h Direct-access device (floppy)

1148

* PDT=1Fh none (no FDD connected to the requested logical unit)

1149

* PDT=1Fh none (no FDD connected to the requested logical unit)

1149

*/

1150

*/

1150

if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) &&

1151

if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) &&

1151

(result[0] & 0x1f) == 0x1f &&

1152

(result[0] & 0x1f) == 0x1f &&

1152

!scsi_is_wlun(lun)) {

1153

!scsi_is_wlun(lun)) {

1153

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

1154

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

1154

"scsi scan: peripheral device type"

1155

"scsi scan: peripheral device type"

1155

" of 31, no device added\n"));

1156

" of 31, no device added\n"));

1156

res = SCSI_SCAN_TARGET_PRESENT;

1157

res = SCSI_SCAN_TARGET_PRESENT;

1157

goto out_free_result;

1158

goto out_free_result;

1158

}

1159

}

1159

1160

res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);

1161

res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);

1161

if (res == SCSI_SCAN_LUN_PRESENT) {

1162

if (res == SCSI_SCAN_LUN_PRESENT) {

1162

if (bflags & BLIST_KEY) {

1163

if (bflags & BLIST_KEY) {

1163

sdev->lockable = 0;

1164

sdev->lockable = 0;

1164

scsi_unlock_floptical(sdev, result);

1165

scsi_unlock_floptical(sdev, result);

1165

}

1166

}

1166

}

1167

}

1167

1168

out_free_result:

1169

out_free_result:

1169

kfree(result);

1170

kfree(result);

1170

out_free_sdev:

1171

out_free_sdev:

1171

if (res == SCSI_SCAN_LUN_PRESENT) {

1172

if (res == SCSI_SCAN_LUN_PRESENT) {

1172

if (sdevp) {

1173

if (sdevp) {

1173

if (scsi_device_get(sdev) == 0) {

1174

if (scsi_device_get(sdev) == 0) {

1174

*sdevp = sdev;

1175

*sdevp = sdev;

1175

} else {

1176

} else {

1176

__scsi_remove_device(sdev);

1177

__scsi_remove_device(sdev);

1177

res = SCSI_SCAN_NO_RESPONSE;

1178

res = SCSI_SCAN_NO_RESPONSE;

1178

}

1179

}

1179

}

1180

}

1180

} else

1181

} else

1181

__scsi_remove_device(sdev);

1182

__scsi_remove_device(sdev);

1182

out:

1183

out:

1183

return res;

1184

return res;

1184

}

1185

}

1185

1186

/**

1187

/**

1187

* scsi_sequential_lun_scan - sequentially scan a SCSI target

1188

* scsi_sequential_lun_scan - sequentially scan a SCSI target

1188

* @starget: pointer to target structure to scan

1189

* @starget: pointer to target structure to scan

1189

* @bflags: black/white list flag for LUN 0

1190

* @bflags: black/white list flag for LUN 0

1190

* @scsi_level: Which version of the standard does this device adhere to

1191

* @scsi_level: Which version of the standard does this device adhere to

1191

* @rescan: passed to scsi_probe_add_lun()

1192

* @rescan: passed to scsi_probe_add_lun()

1192

*

1193

*

1193

* Description:

1194

* Description:

1194

* Generally, scan from LUN 1 (LUN 0 is assumed to already have been

1195

* Generally, scan from LUN 1 (LUN 0 is assumed to already have been

1195

* scanned) to some maximum lun until a LUN is found with no device

1196

* scanned) to some maximum lun until a LUN is found with no device

1196

* attached. Use the bflags to figure out any oddities.

1197

* attached. Use the bflags to figure out any oddities.

1197

*

1198

*

1198

* Modifies sdevscan->lun.

1199

* Modifies sdevscan->lun.

1199

**/

1200

**/

1200

static void scsi_sequential_lun_scan(struct scsi_target *starget,

1201

static void scsi_sequential_lun_scan(struct scsi_target *starget,

1201

int bflags, int scsi_level, int rescan)

1202

int bflags, int scsi_level, int rescan)

1202

{

1203

{

1203

uint max_dev_lun;

1204

uint max_dev_lun;

1204

u64 sparse_lun, lun;

1205

u64 sparse_lun, lun;

1205

struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

1206

struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

1206

1207

SCSI_LOG_SCAN_BUS(3, starget_printk(KERN_INFO, starget,

1208

SCSI_LOG_SCAN_BUS(3, starget_printk(KERN_INFO, starget,

1208

"scsi scan: Sequential scan\n"));

1209

"scsi scan: Sequential scan\n"));

1209

1210

max_dev_lun = min(max_scsi_luns, shost->max_lun);

1211

max_dev_lun = min(max_scsi_luns, shost->max_lun);

1211

/*

1212

/*

1212

* If this device is known to support sparse multiple units,

1213

* If this device is known to support sparse multiple units,

1213

* override the other settings, and scan all of them. Normally,

1214

* override the other settings, and scan all of them. Normally,

1214

* SCSI-3 devices should be scanned via the REPORT LUNS.

1215

* SCSI-3 devices should be scanned via the REPORT LUNS.

1215

*/

1216

*/

1216

if (bflags & BLIST_SPARSELUN) {

1217

if (bflags & BLIST_SPARSELUN) {

1217

max_dev_lun = shost->max_lun;

1218

max_dev_lun = shost->max_lun;

1218

sparse_lun = 1;

1219

sparse_lun = 1;

1219

} else

1220

} else

1220

sparse_lun = 0;

1221

sparse_lun = 0;

1221

1222

/*

1223

/*

1223

* If less than SCSI_1_CCS, and no special lun scanning, stop

1224

* If less than SCSI_1_CCS, and no special lun scanning, stop

1224

* scanning; this matches 2.4 behaviour, but could just be a bug

1225

* scanning; this matches 2.4 behaviour, but could just be a bug

1225

* (to continue scanning a SCSI_1_CCS device).

1226

* (to continue scanning a SCSI_1_CCS device).

1226

*

1227

*

1227

* This test is broken. We might not have any device on lun0 for

1228

* This test is broken. We might not have any device on lun0 for

1228

* a sparselun device, and if that's the case then how would we

1229

* a sparselun device, and if that's the case then how would we

1229

* know the real scsi_level, eh? It might make sense to just not

1230

* know the real scsi_level, eh? It might make sense to just not

1230

* scan any SCSI_1 device for non-0 luns, but that check would best

1231

* scan any SCSI_1 device for non-0 luns, but that check would best

1231

* go into scsi_alloc_sdev() and just have it return null when asked

1232

* go into scsi_alloc_sdev() and just have it return null when asked

1232

* to alloc an sdev for lun > 0 on an already found SCSI_1 device.

1233

* to alloc an sdev for lun > 0 on an already found SCSI_1 device.

1233

*

1234

*

1234

if ((sdevscan->scsi_level < SCSI_1_CCS) &&

1235

if ((sdevscan->scsi_level < SCSI_1_CCS) &&

1235

((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN))

1236

((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN))

1236

== 0))

1237

== 0))

1237

return;

1238

return;

1238

*/

1239

*/

1239

/*

1240

/*

1240

* If this device is known to support multiple units, override

1241

* If this device is known to support multiple units, override

1241

* the other settings, and scan all of them.

1242

* the other settings, and scan all of them.

1242

*/

1243

*/

1243

if (bflags & BLIST_FORCELUN)

1244

if (bflags & BLIST_FORCELUN)

1244

max_dev_lun = shost->max_lun;

1245

max_dev_lun = shost->max_lun;

1245

/*

1246

/*

1246

* REGAL CDC-4X: avoid hang after LUN 4

1247

* REGAL CDC-4X: avoid hang after LUN 4

1247

*/

1248

*/

1248

if (bflags & BLIST_MAX5LUN)

1249

if (bflags & BLIST_MAX5LUN)

1249

max_dev_lun = min(5U, max_dev_lun);

1250

max_dev_lun = min(5U, max_dev_lun);

1250

/*

1251

/*

1251

* Do not scan SCSI-2 or lower device past LUN 7, unless

1252

* Do not scan SCSI-2 or lower device past LUN 7, unless

1252

* BLIST_LARGELUN.

1253

* BLIST_LARGELUN.

1253

*/

1254

*/

1254

if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN))

1255

if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN))

1255

max_dev_lun = min(8U, max_dev_lun);

1256

max_dev_lun = min(8U, max_dev_lun);

1256

1257

/*

1258

/*

1258

* Stop scanning at 255 unless BLIST_SCSI3LUN

1259

* Stop scanning at 255 unless BLIST_SCSI3LUN

1259

*/

1260

*/

1260

if (!(bflags & BLIST_SCSI3LUN))

1261

if (!(bflags & BLIST_SCSI3LUN))

1261

max_dev_lun = min(256U, max_dev_lun);

1262

max_dev_lun = min(256U, max_dev_lun);

1262

1263

/*

1264

/*

1264

* We have already scanned LUN 0, so start at LUN 1. Keep scanning

1265

* We have already scanned LUN 0, so start at LUN 1. Keep scanning

1265

* until we reach the max, or no LUN is found and we are not

1266

* until we reach the max, or no LUN is found and we are not

1266

* sparse_lun.

1267

* sparse_lun.

1267

*/

1268

*/

1268

for (lun = 1; lun < max_dev_lun; ++lun)

1269

for (lun = 1; lun < max_dev_lun; ++lun)

1269

if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan,

1270

if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan,

1270

NULL) != SCSI_SCAN_LUN_PRESENT) &&

1271

NULL) != SCSI_SCAN_LUN_PRESENT) &&

1271

!sparse_lun)

1272

!sparse_lun)

1272

return;

1273

return;

1273

}

1274

}

1274

1275

/**

1276

/**

1276

* scsi_report_lun_scan - Scan using SCSI REPORT LUN results

1277

* scsi_report_lun_scan - Scan using SCSI REPORT LUN results

1277

* @starget: which target

1278

* @starget: which target

1278

* @bflags: Zero or a mix of BLIST_NOLUN, BLIST_REPORTLUN2, or BLIST_NOREPORTLUN

1279

* @bflags: Zero or a mix of BLIST_NOLUN, BLIST_REPORTLUN2, or BLIST_NOREPORTLUN

1279

* @rescan: nonzero if we can skip code only needed on first scan

1280

* @rescan: nonzero if we can skip code only needed on first scan

1280

*

1281

*

1281

* Description:

1282

* Description:

1282

* Fast scanning for modern (SCSI-3) devices by sending a REPORT LUN command.

1283

* Fast scanning for modern (SCSI-3) devices by sending a REPORT LUN command.

1283

* Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.

1284

* Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.

1284

*

1285

*

1285

* If BLINK_REPORTLUN2 is set, scan a target that supports more than 8

1286

* If BLINK_REPORTLUN2 is set, scan a target that supports more than 8

1286

* LUNs even if it's older than SCSI-3.

1287

* LUNs even if it's older than SCSI-3.

1287

* If BLIST_NOREPORTLUN is set, return 1 always.

1288

* If BLIST_NOREPORTLUN is set, return 1 always.

1288

* If BLIST_NOLUN is set, return 0 always.

1289

* If BLIST_NOLUN is set, return 0 always.

1289

* If starget->no_report_luns is set, return 1 always.

1290

* If starget->no_report_luns is set, return 1 always.

1290

*

1291

*

1291

* Return:

1292

* Return:

1292

* 0: scan completed (or no memory, so further scanning is futile)

1293

* 0: scan completed (or no memory, so further scanning is futile)

1293

* 1: could not scan with REPORT LUN

1294

* 1: could not scan with REPORT LUN

1294

**/

1295

**/

1295

static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,

1296

static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,

1296

int rescan)

1297

int rescan)

1297

{

1298

{

1298

char devname[64];

1299

char devname[64];

1299

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

1300

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

1300

unsigned int length;

1301

unsigned int length;

1301

u64 lun;

1302

u64 lun;

1302

unsigned int num_luns;

1303

unsigned int num_luns;

1303

unsigned int retries;

1304

unsigned int retries;

1304

int result;

1305

int result;

1305

struct scsi_lun *lunp, *lun_data;

1306

struct scsi_lun *lunp, *lun_data;

1306

struct scsi_sense_hdr sshdr;

1307

struct scsi_sense_hdr sshdr;

1307

struct scsi_device *sdev;

1308

struct scsi_device *sdev;

1308

struct Scsi_Host *shost = dev_to_shost(&starget->dev);

1309

struct Scsi_Host *shost = dev_to_shost(&starget->dev);

1309

int ret = 0;

1310

int ret = 0;

1310

1311

/*

1312

/*

1312

* Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set.

1313

* Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set.

1313

* Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does

1314

* Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does

1314

* support more than 8 LUNs.

1315

* support more than 8 LUNs.

1315

* Don't attempt if the target doesn't support REPORT LUNS.

1316

* Don't attempt if the target doesn't support REPORT LUNS.

1316

*/

1317

*/

1317

if (bflags & BLIST_NOREPORTLUN)

1318

if (bflags & BLIST_NOREPORTLUN)

1318

return 1;

1319

return 1;

1319

if (starget->scsi_level < SCSI_2 &&

1320

if (starget->scsi_level < SCSI_2 &&

1320

starget->scsi_level != SCSI_UNKNOWN)

1321

starget->scsi_level != SCSI_UNKNOWN)

1321

return 1;

1322

return 1;

1322

if (starget->scsi_level < SCSI_3 &&

1323

if (starget->scsi_level < SCSI_3 &&

1323

(!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))

1324

(!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))

1324

return 1;

1325

return 1;

1325

if (bflags & BLIST_NOLUN)

1326

if (bflags & BLIST_NOLUN)

1326

return 0;

1327

return 0;

1327

if (starget->no_report_luns)

1328

if (starget->no_report_luns)

1328

return 1;

1329

return 1;

1329

1330

if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {

1331

if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {

1331

sdev = scsi_alloc_sdev(starget, 0, NULL);

1332

sdev = scsi_alloc_sdev(starget, 0, NULL);

1332

if (!sdev)

1333

if (!sdev)

1333

return 0;

1334

return 0;

1334

if (scsi_device_get(sdev)) {

1335

if (scsi_device_get(sdev)) {

1335

__scsi_remove_device(sdev);

1336

__scsi_remove_device(sdev);

1336

return 0;

1337

return 0;

1337

}

1338

}

1338

}

1339

}

1339

1340

sprintf(devname, "host %d channel %d id %d",

1341

sprintf(devname, "host %d channel %d id %d",

1341

shost->host_no, sdev->channel, sdev->id);

1342

shost->host_no, sdev->channel, sdev->id);

1342

1343

/*

1344

/*

1344

* Allocate enough to hold the header (the same size as one scsi_lun)

1345

* Allocate enough to hold the header (the same size as one scsi_lun)

1345

* plus the number of luns we are requesting. 511 was the default

1346

* plus the number of luns we are requesting. 511 was the default

1346

* value of the now removed max_report_luns parameter.

1347

* value of the now removed max_report_luns parameter.

1347

*/

1348

*/

1348

length = (511 + 1) * sizeof(struct scsi_lun);

1349

length = (511 + 1) * sizeof(struct scsi_lun);

1349

retry:

1350

retry:

1350

lun_data = kmalloc(length, GFP_KERNEL |

1351

lun_data = kmalloc(length, GFP_KERNEL |

1351

(sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));

1352

(sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));

1352

if (!lun_data) {

1353

if (!lun_data) {

1353

printk(ALLOC_FAILURE_MSG, __func__);

1354

printk(ALLOC_FAILURE_MSG, __func__);

1354

goto out;

1355

goto out;

1355

}

1356

}

1356

1357

scsi_cmd[0] = REPORT_LUNS;

1358

scsi_cmd[0] = REPORT_LUNS;

1358

1359

/*

1360

/*

1360

* bytes 1 - 5: reserved, set to zero.

1361

* bytes 1 - 5: reserved, set to zero.

1361

*/

1362

*/

1362

memset(&scsi_cmd[1], 0, 5);

1363

memset(&scsi_cmd[1], 0, 5);

1363

1364

/*

1365

/*

1365

* bytes 6 - 9: length of the command.

1366

* bytes 6 - 9: length of the command.

1366

*/

1367

*/

1367

put_unaligned_be32(length, &scsi_cmd[6]);

1368

put_unaligned_be32(length, &scsi_cmd[6]);

1368

1369

scsi_cmd[10] = 0; /* reserved */

1370

scsi_cmd[10] = 0; /* reserved */

1370

scsi_cmd[11] = 0; /* control */

1371

scsi_cmd[11] = 0; /* control */

1371

1372

/*

1373

/*

1373

* We can get a UNIT ATTENTION, for example a power on/reset, so

1374

* We can get a UNIT ATTENTION, for example a power on/reset, so

1374

* retry a few times (like sd.c does for TEST UNIT READY).

1375

* retry a few times (like sd.c does for TEST UNIT READY).

1375

* Experience shows some combinations of adapter/devices get at

1376

* Experience shows some combinations of adapter/devices get at

1376

* least two power on/resets.

1377

* least two power on/resets.

1377

*

1378

*

1378

* Illegal requests (for devices that do not support REPORT LUNS)

1379

* Illegal requests (for devices that do not support REPORT LUNS)

1379

* should come through as a check condition, and will not generate

1380

* should come through as a check condition, and will not generate

1380

* a retry.

1381

* a retry.

1381

*/

1382

*/

1382

for (retries = 0; retries < 3; retries++) {

1383

for (retries = 0; retries < 3; retries++) {

1383

SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,

1384

SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,

1384

"scsi scan: Sending REPORT LUNS to (try %d)\n",

1385

"scsi scan: Sending REPORT LUNS to (try %d)\n",

1385

retries));

1386

retries));

1386

1387

result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,

1388

result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,

1388

lun_data, length, &sshdr,

1389

lun_data, length, &sshdr,

1389

SCSI_REPORT_LUNS_TIMEOUT, 3, NULL);

1390

SCSI_REPORT_LUNS_TIMEOUT, 3, NULL);

1390

1391

SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,

1392

SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,

1392

"scsi scan: REPORT LUNS"

1393

"scsi scan: REPORT LUNS"

1393

" %s (try %d) result 0x%x\n",

1394

" %s (try %d) result 0x%x\n",

1394

result ? "failed" : "successful",

1395

result ? "failed" : "successful",

1395

retries, result));

1396

retries, result));

1396

if (result == 0)

1397

if (result == 0)

1397

break;

1398

break;

1398

else if (scsi_sense_valid(&sshdr)) {

1399

else if (scsi_sense_valid(&sshdr)) {

1399

if (sshdr.sense_key != UNIT_ATTENTION)

1400

if (sshdr.sense_key != UNIT_ATTENTION)

1400

break;

1401

break;

1401

}

1402

}

1402

}

1403

}

1403

1404

if (result) {

1405

if (result) {

1405

/*

1406

/*

1406

* The device probably does not support a REPORT LUN command

1407

* The device probably does not support a REPORT LUN command

1407

*/

1408

*/

1408

ret = 1;

1409

ret = 1;

1409

goto out_err;

1410

goto out_err;

1410

}

1411

}

1411

1412

/*

1413

/*

1413

* Get the length from the first four bytes of lun_data.

1414

* Get the length from the first four bytes of lun_data.

1414

*/

1415

*/

1415

if (get_unaligned_be32(lun_data->scsi_lun) +

1416

if (get_unaligned_be32(lun_data->scsi_lun) +

1416

sizeof(struct scsi_lun) > length) {

1417

sizeof(struct scsi_lun) > length) {

1417

length = get_unaligned_be32(lun_data->scsi_lun) +

1418

length = get_unaligned_be32(lun_data->scsi_lun) +

1418

sizeof(struct scsi_lun);

1419

sizeof(struct scsi_lun);

1419

kfree(lun_data);

1420

kfree(lun_data);

1420

goto retry;

1421

goto retry;

1421

}

1422

}

1422

length = get_unaligned_be32(lun_data->scsi_lun);

1423

length = get_unaligned_be32(lun_data->scsi_lun);

1423

1424

num_luns = (length / sizeof(struct scsi_lun));

1425

num_luns = (length / sizeof(struct scsi_lun));

1425

1426

SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,

1427

SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,

1427

"scsi scan: REPORT LUN scan\n"));

1428

"scsi scan: REPORT LUN scan\n"));

1428

1429

/*

1430

/*

1430

* Scan the luns in lun_data. The entry at offset 0 is really

1431

* Scan the luns in lun_data. The entry at offset 0 is really

1431

* the header, so start at 1 and go up to and including num_luns.

1432

* the header, so start at 1 and go up to and including num_luns.

1432

*/

1433

*/

1433

for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) {

1434

for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) {

1434

lun = scsilun_to_int(lunp);

1435

lun = scsilun_to_int(lunp);

1435

1436

if (lun > sdev->host->max_lun) {

1437

if (lun > sdev->host->max_lun) {

1437

sdev_printk(KERN_WARNING, sdev,

1438

sdev_printk(KERN_WARNING, sdev,

1438

"lun%llu has a LUN larger than"

1439

"lun%llu has a LUN larger than"

1439

" allowed by the host adapter\n", lun);

1440

" allowed by the host adapter\n", lun);

1440

} else {

1441

} else {

1441

int res;

1442

int res;

1442

1443

res = scsi_probe_and_add_lun(starget,

1444

res = scsi_probe_and_add_lun(starget,

1444

lun, NULL, NULL, rescan, NULL);

1445

lun, NULL, NULL, rescan, NULL);

1445

if (res == SCSI_SCAN_NO_RESPONSE) {

1446

if (res == SCSI_SCAN_NO_RESPONSE) {

1446

/*

1447

/*

1447

* Got some results, but now none, abort.

1448

* Got some results, but now none, abort.

1448

*/

1449

*/

1449

sdev_printk(KERN_ERR, sdev,

1450

sdev_printk(KERN_ERR, sdev,

1450

"Unexpected response"

1451

"Unexpected response"

1451

" from lun %llu while scanning, scan"

1452

" from lun %llu while scanning, scan"

1452

" aborted\n", (unsigned long long)lun);

1453

" aborted\n", (unsigned long long)lun);

1453

break;

1454

break;

1454

}

1455

}

1455

}

1456

}

1456

}

1457

}

1457

1458

out_err:

1459

out_err:

1459

kfree(lun_data);

1460

kfree(lun_data);

1460

out:

1461

out:

1461

scsi_device_put(sdev);

1462

scsi_device_put(sdev);

1462

if (scsi_device_created(sdev))

1463

if (scsi_device_created(sdev))

1463

/*

1464

/*

1464

* the sdev we used didn't appear in the report luns scan

1465

* the sdev we used didn't appear in the report luns scan

1465

*/

1466

*/

1466

__scsi_remove_device(sdev);

1467

__scsi_remove_device(sdev);

1467

return ret;

1468

return ret;

1468

}

1469

}

1469

1470

struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,

1471

struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,

1471

uint id, u64 lun, void *hostdata)

1472

uint id, u64 lun, void *hostdata)

1472

{

1473

{

1473

struct scsi_device *sdev = ERR_PTR(-ENODEV);

1474

struct scsi_device *sdev = ERR_PTR(-ENODEV);

1474

struct device *parent = &shost->shost_gendev;

1475

struct device *parent = &shost->shost_gendev;

1475

struct scsi_target *starget;

1476

struct scsi_target *starget;

1476

1477

if (strncmp(scsi_scan_type, "none", 4) == 0)

1478

if (strncmp(scsi_scan_type, "none", 4) == 0)

1478

return ERR_PTR(-ENODEV);

1479

return ERR_PTR(-ENODEV);

1479

1480

starget = scsi_alloc_target(parent, channel, id);

1481

starget = scsi_alloc_target(parent, channel, id);

1481

if (!starget)

1482

if (!starget)

1482

return ERR_PTR(-ENOMEM);

1483

return ERR_PTR(-ENOMEM);

1483

scsi_autopm_get_target(starget);

1484

scsi_autopm_get_target(starget);

1484

1485

mutex_lock(&shost->scan_mutex);

1486

mutex_lock(&shost->scan_mutex);

1486

if (!shost->async_scan)

1487

if (!shost->async_scan)

1487

scsi_complete_async_scans();

1488

scsi_complete_async_scans();

1488

1489

if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {

1490

if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {

1490

scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);

1491

scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);

1491

scsi_autopm_put_host(shost);

1492

scsi_autopm_put_host(shost);

1492

}

1493

}

1493

mutex_unlock(&shost->scan_mutex);

1494

mutex_unlock(&shost->scan_mutex);

1494

scsi_autopm_put_target(starget);

1495

scsi_autopm_put_target(starget);

1495

/*

1496

/*

1496

* paired with scsi_alloc_target(). Target will be destroyed unless

1497

* paired with scsi_alloc_target(). Target will be destroyed unless

1497

* scsi_probe_and_add_lun made an underlying device visible

1498

* scsi_probe_and_add_lun made an underlying device visible

1498

*/

1499

*/

1499

scsi_target_reap(starget);

1500

scsi_target_reap(starget);

1500

put_device(&starget->dev);

1501

put_device(&starget->dev);

1501

1502

return sdev;

1503

return sdev;

1503

}

1504

}

1504

EXPORT_SYMBOL(__scsi_add_device);

1505

EXPORT_SYMBOL(__scsi_add_device);

1505

1506

int scsi_add_device(struct Scsi_Host *host, uint channel,

1507

int scsi_add_device(struct Scsi_Host *host, uint channel,

1507

uint target, u64 lun)

1508

uint target, u64 lun)

1508

{

1509

{

1509

struct scsi_device *sdev =

1510

struct scsi_device *sdev =

1510

__scsi_add_device(host, channel, target, lun, NULL);

1511

__scsi_add_device(host, channel, target, lun, NULL);

1511

if (IS_ERR(sdev))

1512

if (IS_ERR(sdev))

1512

return PTR_ERR(sdev);

1513

return PTR_ERR(sdev);

1513

1514

scsi_device_put(sdev);

1515

scsi_device_put(sdev);

1515

return 0;

1516

return 0;

1516

}

1517

}

1517

EXPORT_SYMBOL(scsi_add_device);

1518

EXPORT_SYMBOL(scsi_add_device);

1518

1519

void scsi_rescan_device(struct device *dev)

1520

void scsi_rescan_device(struct device *dev)

1520

{

1521

{

1521

device_lock(dev);

1522

device_lock(dev);

1522

if (dev->driver && try_module_get(dev->driver->owner)) {

1523

if (dev->driver && try_module_get(dev->driver->owner)) {

1523

struct scsi_driver *drv = to_scsi_driver(dev->driver);

1524

struct scsi_driver *drv = to_scsi_driver(dev->driver);

1524

1525

if (drv->rescan)

1526

if (drv->rescan)

1526

drv->rescan(dev);

1527

drv->rescan(dev);

1527

module_put(dev->driver->owner);

1528

module_put(dev->driver->owner);

1528

}

1529

}

1529

device_unlock(dev);

1530

device_unlock(dev);

1530

}

1531

}

1531

EXPORT_SYMBOL(scsi_rescan_device);

1532

EXPORT_SYMBOL(scsi_rescan_device);

1532

1533

static void __scsi_scan_target(struct device *parent, unsigned int channel,

1534

static void __scsi_scan_target(struct device *parent, unsigned int channel,

1534

unsigned int id, u64 lun, int rescan)

1535

unsigned int id, u64 lun, int rescan)

1535

{

1536

{

1536

struct Scsi_Host *shost = dev_to_shost(parent);

1537

struct Scsi_Host *shost = dev_to_shost(parent);

1537

int bflags = 0;

1538

int bflags = 0;

1538

int res;

1539

int res;

1539

struct scsi_target *starget;

1540

struct scsi_target *starget;

1540

1541

if (shost->this_id == id)

1542

if (shost->this_id == id)

1542

/*

1543

/*

1543

* Don't scan the host adapter

1544

* Don't scan the host adapter

1544

*/

1545

*/

1545

return;

1546

return;

1546

1547

starget = scsi_alloc_target(parent, channel, id);

1548

starget = scsi_alloc_target(parent, channel, id);

1548

if (!starget)

1549

if (!starget)

1549

return;

1550

return;

1550

scsi_autopm_get_target(starget);

1551

scsi_autopm_get_target(starget);

1551

1552

if (lun != SCAN_WILD_CARD) {

1553

if (lun != SCAN_WILD_CARD) {

1553

/*

1554

/*

1554

* Scan for a specific host/chan/id/lun.

1555

* Scan for a specific host/chan/id/lun.

1555

*/

1556

*/

1556

scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);

1557

scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);

1557

goto out_reap;

1558

goto out_reap;

1558

}

1559

}

1559

1560

/*

1561

/*

1561

* Scan LUN 0, if there is some response, scan further. Ideally, we

1562

* Scan LUN 0, if there is some response, scan further. Ideally, we

1562

* would not configure LUN 0 until all LUNs are scanned.

1563

* would not configure LUN 0 until all LUNs are scanned.

1563

*/

1564

*/

1564

res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);

1565

res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);

1565

if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {

1566

if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {

1566

if (scsi_report_lun_scan(starget, bflags, rescan) != 0)

1567

if (scsi_report_lun_scan(starget, bflags, rescan) != 0)

1567

/*

1568

/*

1568

* The REPORT LUN did not scan the target,

1569

* The REPORT LUN did not scan the target,

1569

* do a sequential scan.

1570

* do a sequential scan.

1570

*/

1571

*/

1571

scsi_sequential_lun_scan(starget, bflags,

1572

scsi_sequential_lun_scan(starget, bflags,

1572

starget->scsi_level, rescan);

1573

starget->scsi_level, rescan);

1573

}

1574

}

1574

1575

out_reap:

1576

out_reap:

1576

scsi_autopm_put_target(starget);

1577

scsi_autopm_put_target(starget);

1577

/*

1578

/*

1578

* paired with scsi_alloc_target(): determine if the target has

1579

* paired with scsi_alloc_target(): determine if the target has

1579

* any children at all and if not, nuke it

1580

* any children at all and if not, nuke it

1580

*/

1581

*/

1581

scsi_target_reap(starget);

1582

scsi_target_reap(starget);

1582

1583

put_device(&starget->dev);

1584

put_device(&starget->dev);

1584

}

1585

}

1585

1586

/**

1587

/**

1587

* scsi_scan_target - scan a target id, possibly including all LUNs on the target.

1588

* scsi_scan_target - scan a target id, possibly including all LUNs on the target.

1588

* @parent: host to scan

1589

* @parent: host to scan

1589

* @channel: channel to scan

1590

* @channel: channel to scan

1590

* @id: target id to scan

1591

* @id: target id to scan

1591

* @lun: Specific LUN to scan or SCAN_WILD_CARD

1592

* @lun: Specific LUN to scan or SCAN_WILD_CARD

1592

* @rescan: passed to LUN scanning routines

1593

* @rescan: passed to LUN scanning routines

1593

*

1594

*

1594

* Description:

1595

* Description:

1595

* Scan the target id on @parent, @channel, and @id. Scan at least LUN 0,

1596

* Scan the target id on @parent, @channel, and @id. Scan at least LUN 0,

1596

* and possibly all LUNs on the target id.

1597

* and possibly all LUNs on the target id.

1597

*

1598

*

1598

* First try a REPORT LUN scan, if that does not scan the target, do a

1599

* First try a REPORT LUN scan, if that does not scan the target, do a

1599

* sequential scan of LUNs on the target id.

1600

* sequential scan of LUNs on the target id.

1600

**/

1601

**/

1601

void scsi_scan_target(struct device *parent, unsigned int channel,

1602

void scsi_scan_target(struct device *parent, unsigned int channel,

1602

unsigned int id, u64 lun, int rescan)

1603

unsigned int id, u64 lun, int rescan)

1603

{

1604

{

1604

struct Scsi_Host *shost = dev_to_shost(parent);

1605

struct Scsi_Host *shost = dev_to_shost(parent);

1605

1606

if (strncmp(scsi_scan_type, "none", 4) == 0)

1607

if (strncmp(scsi_scan_type, "none", 4) == 0)

1607

return;

1608

return;

1608

1609

mutex_lock(&shost->scan_mutex);

1610

mutex_lock(&shost->scan_mutex);

1610

if (!shost->async_scan)

1611

if (!shost->async_scan)

1611

scsi_complete_async_scans();

1612

scsi_complete_async_scans();

1612

1613

if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {

1614

if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {

1614

__scsi_scan_target(parent, channel, id, lun, rescan);

1615

__scsi_scan_target(parent, channel, id, lun, rescan);

1615

scsi_autopm_put_host(shost);

1616

scsi_autopm_put_host(shost);

1616

}

1617

}

1617

mutex_unlock(&shost->scan_mutex);

1618

mutex_unlock(&shost->scan_mutex);

1618

}

1619

}

1619

EXPORT_SYMBOL(scsi_scan_target);

1620

EXPORT_SYMBOL(scsi_scan_target);

1620

1621

static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,

1622

static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,

1622

unsigned int id, u64 lun, int rescan)

1623

unsigned int id, u64 lun, int rescan)

1623

{

1624

{

1624

uint order_id;

1625

uint order_id;

1625

1626

if (id == SCAN_WILD_CARD)

1627

if (id == SCAN_WILD_CARD)

1627

for (id = 0; id < shost->max_id; ++id) {

1628

for (id = 0; id < shost->max_id; ++id) {

1628

/*

1629

/*

1629

* XXX adapter drivers when possible (FCP, iSCSI)

1630

* XXX adapter drivers when possible (FCP, iSCSI)

1630

* could modify max_id to match the current max,

1631

* could modify max_id to match the current max,

1631

* not the absolute max.

1632

* not the absolute max.

1632

*

1633

*

1633

* XXX add a shost id iterator, so for example,

1634

* XXX add a shost id iterator, so for example,

1634

* the FC ID can be the same as a target id

1635

* the FC ID can be the same as a target id

1635

* without a huge overhead of sparse id's.

1636

* without a huge overhead of sparse id's.

1636

*/

1637

*/

1637

if (shost->reverse_ordering)

1638

if (shost->reverse_ordering)

1638

/*

1639

/*

1639

* Scan from high to low id.

1640

* Scan from high to low id.

1640

*/

1641

*/

1641

order_id = shost->max_id - id - 1;

1642

order_id = shost->max_id - id - 1;

1642

else

1643

else

1643

order_id = id;

1644

order_id = id;

1644

__scsi_scan_target(&shost->shost_gendev, channel,

1645

__scsi_scan_target(&shost->shost_gendev, channel,

1645

order_id, lun, rescan);

1646

order_id, lun, rescan);

1646

}

1647

}

1647

else

1648

else

1648

__scsi_scan_target(&shost->shost_gendev, channel,

1649

__scsi_scan_target(&shost->shost_gendev, channel,

1649

id, lun, rescan);

1650

id, lun, rescan);

1650

}

1651

}

1651

1652

int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,

1653

int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,

1653

unsigned int id, u64 lun, int rescan)

1654

unsigned int id, u64 lun, int rescan)

1654

{

1655

{

1655

SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,

1656

SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,

1656

"%s: <%u:%u:%llu>\n",

1657

"%s: <%u:%u:%llu>\n",

1657

__func__, channel, id, lun));

1658

__func__, channel, id, lun));

1658

1659

if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||

1660

if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||

1660

((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||

1661

((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||

1661

((lun != SCAN_WILD_CARD) && (lun >= shost->max_lun)))

1662

((lun != SCAN_WILD_CARD) && (lun >= shost->max_lun)))

1662

return -EINVAL;

1663

return -EINVAL;

1663

1664

mutex_lock(&shost->scan_mutex);

1665

mutex_lock(&shost->scan_mutex);

1665

if (!shost->async_scan)

1666

if (!shost->async_scan)

1666

scsi_complete_async_scans();

1667

scsi_complete_async_scans();

1667

1668

if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {

1669

if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {

1669

if (channel == SCAN_WILD_CARD)

1670

if (channel == SCAN_WILD_CARD)

1670

for (channel = 0; channel <= shost->max_channel;

1671

for (channel = 0; channel <= shost->max_channel;

1671

channel++)

1672

channel++)

1672

scsi_scan_channel(shost, channel, id, lun,

1673

scsi_scan_channel(shost, channel, id, lun,

1673

rescan);

1674

rescan);

1674

else

1675

else

1675

scsi_scan_channel(shost, channel, id, lun, rescan);

1676

scsi_scan_channel(shost, channel, id, lun, rescan);

1676

scsi_autopm_put_host(shost);

1677

scsi_autopm_put_host(shost);

1677

}

1678

}

1678

mutex_unlock(&shost->scan_mutex);

1679

mutex_unlock(&shost->scan_mutex);

1679

1680

return 0;

1681

return 0;

1681

}

1682

}

1682

1683

static void scsi_sysfs_add_devices(struct Scsi_Host *shost)

1684

static void scsi_sysfs_add_devices(struct Scsi_Host *shost)

1684

{

1685

{

1685

struct scsi_device *sdev;

1686

struct scsi_device *sdev;

1686

shost_for_each_device(sdev, shost) {

1687

shost_for_each_device(sdev, shost) {

1687

/* target removed before the device could be added */

1688

/* target removed before the device could be added */

1688

if (sdev->sdev_state == SDEV_DEL)

1689

if (sdev->sdev_state == SDEV_DEL)

1689

continue;

1690

continue;

1690

/* If device is already visible, skip adding it to sysfs */

1691

/* If device is already visible, skip adding it to sysfs */

1691

if (sdev->is_visible)

1692

if (sdev->is_visible)

1692

continue;

1693

continue;

1693

if (!scsi_host_scan_allowed(shost) ||

1694

if (!scsi_host_scan_allowed(shost) ||

1694

scsi_sysfs_add_sdev(sdev) != 0)

1695

scsi_sysfs_add_sdev(sdev) != 0)

1695

__scsi_remove_device(sdev);

1696

__scsi_remove_device(sdev);

1696

}

1697

}

1697

}

1698

}

1698

1699

/**

1700

/**

1700

* scsi_prep_async_scan - prepare for an async scan

1701

* scsi_prep_async_scan - prepare for an async scan

1701

* @shost: the host which will be scanned

1702

* @shost: the host which will be scanned

1702

* Returns: a cookie to be passed to scsi_finish_async_scan()

1703

* Returns: a cookie to be passed to scsi_finish_async_scan()

1703

*

1704

*

1704

* Tells the midlayer this host is going to do an asynchronous scan.

1705

* Tells the midlayer this host is going to do an asynchronous scan.

1705

* It reserves the host's position in the scanning list and ensures

1706

* It reserves the host's position in the scanning list and ensures

1706

* that other asynchronous scans started after this one won't affect the

1707

* that other asynchronous scans started after this one won't affect the

1707

* ordering of the discovered devices.

1708

* ordering of the discovered devices.

1708

*/

1709

*/

1709

static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)

1710

static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)

1710

{

1711

{

1711

struct async_scan_data *data;

1712

struct async_scan_data *data;

1712

unsigned long flags;

1713

unsigned long flags;

1713

1714

if (strncmp(scsi_scan_type, "sync", 4) == 0)

1715

if (strncmp(scsi_scan_type, "sync", 4) == 0)

1715

return NULL;

1716

return NULL;

1716

1717

if (shost->async_scan) {

1718

if (shost->async_scan) {

1718

shost_printk(KERN_DEBUG, shost, "%s called twice\n", __func__);

1719

shost_printk(KERN_DEBUG, shost, "%s called twice\n", __func__);

1719

return NULL;

1720

return NULL;

1720

}

1721

}

1721

1722

data = kmalloc(sizeof(*data), GFP_KERNEL);

1723

data = kmalloc(sizeof(*data), GFP_KERNEL);

1723

if (!data)

1724

if (!data)

1724

goto err;

1725

goto err;

1725

data->shost = scsi_host_get(shost);

1726

data->shost = scsi_host_get(shost);

1726

if (!data->shost)

1727

if (!data->shost)

1727

goto err;

1728

goto err;

1728

init_completion(&data->prev_finished);

1729

init_completion(&data->prev_finished);

1729

1730

mutex_lock(&shost->scan_mutex);

1731

mutex_lock(&shost->scan_mutex);

1731

spin_lock_irqsave(shost->host_lock, flags);

1732

spin_lock_irqsave(shost->host_lock, flags);

1732

shost->async_scan = 1;

1733

shost->async_scan = 1;

1733

spin_unlock_irqrestore(shost->host_lock, flags);

1734

spin_unlock_irqrestore(shost->host_lock, flags);

1734

mutex_unlock(&shost->scan_mutex);

1735

mutex_unlock(&shost->scan_mutex);

1735

1736

spin_lock(&async_scan_lock);

1737

spin_lock(&async_scan_lock);

1737

if (list_empty(&scanning_hosts))

1738

if (list_empty(&scanning_hosts))

1738

complete(&data->prev_finished);

1739

complete(&data->prev_finished);

1739

list_add_tail(&data->list, &scanning_hosts);

1740

list_add_tail(&data->list, &scanning_hosts);

1740

spin_unlock(&async_scan_lock);

1741

spin_unlock(&async_scan_lock);

1741

1742

return data;

1743

return data;

1743

1744

err:

1745

err:

1745

kfree(data);

1746

kfree(data);

1746

return NULL;

1747

return NULL;

1747

}

1748

}

1748

1749

/**

1750

/**

1750

* scsi_finish_async_scan - asynchronous scan has finished

1751

* scsi_finish_async_scan - asynchronous scan has finished

1751

* @data: cookie returned from earlier call to scsi_prep_async_scan()

1752

* @data: cookie returned from earlier call to scsi_prep_async_scan()

1752

*

1753

*

1753

* All the devices currently attached to this host have been found.

1754

* All the devices currently attached to this host have been found.

1754

* This function announces all the devices it has found to the rest

1755

* This function announces all the devices it has found to the rest

1755

* of the system.

1756

* of the system.

1756

*/

1757

*/

1757

static void scsi_finish_async_scan(struct async_scan_data *data)

1758

static void scsi_finish_async_scan(struct async_scan_data *data)

1758

{

1759

{

1759

struct Scsi_Host *shost;

1760

struct Scsi_Host *shost;

1760

unsigned long flags;

1761

unsigned long flags;

1761

1762

if (!data)

1763

if (!data)

1763

return;

1764

return;

1764

1765

shost = data->shost;

1766

shost = data->shost;

1766

1767

mutex_lock(&shost->scan_mutex);

1768

mutex_lock(&shost->scan_mutex);

1768

1769

if (!shost->async_scan) {

1770

if (!shost->async_scan) {

1770

shost_printk(KERN_INFO, shost, "%s called twice\n", __func__);

1771

shost_printk(KERN_INFO, shost, "%s called twice\n", __func__);

1771

dump_stack();

1772

dump_stack();

1772

mutex_unlock(&shost->scan_mutex);

1773

mutex_unlock(&shost->scan_mutex);

1773

return;

1774

return;

1774

}

1775

}

1775

1776

wait_for_completion(&data->prev_finished);

1777

wait_for_completion(&data->prev_finished);

1777

1778

scsi_sysfs_add_devices(shost);

1779

scsi_sysfs_add_devices(shost);

1779

1780

spin_lock_irqsave(shost->host_lock, flags);

1781

spin_lock_irqsave(shost->host_lock, flags);

1781

shost->async_scan = 0;

1782

shost->async_scan = 0;

1782

spin_unlock_irqrestore(shost->host_lock, flags);

1783

spin_unlock_irqrestore(shost->host_lock, flags);

1783

1784

mutex_unlock(&shost->scan_mutex);

1785

mutex_unlock(&shost->scan_mutex);

1785

1786

spin_lock(&async_scan_lock);

1787

spin_lock(&async_scan_lock);

1787

list_del(&data->list);

1788

list_del(&data->list);

1788

if (!list_empty(&scanning_hosts)) {

1789

if (!list_empty(&scanning_hosts)) {

1789

struct async_scan_data *next = list_entry(scanning_hosts.next,

1790

struct async_scan_data *next = list_entry(scanning_hosts.next,

1790

struct async_scan_data, list);

1791

struct async_scan_data, list);

1791

complete(&next->prev_finished);

1792

complete(&next->prev_finished);

1792

}

1793

}

1793

spin_unlock(&async_scan_lock);

1794

spin_unlock(&async_scan_lock);

1794

1795

scsi_autopm_put_host(shost);

1796

scsi_autopm_put_host(shost);

1796

scsi_host_put(shost);

1797

scsi_host_put(shost);

1797

kfree(data);

1798

kfree(data);

1798

}

1799

}

1799

1800

static void do_scsi_scan_host(struct Scsi_Host *shost)

1801

static void do_scsi_scan_host(struct Scsi_Host *shost)

1801

{

1802

{

1802

if (shost->hostt->scan_finished) {

1803

if (shost->hostt->scan_finished) {

1803

unsigned long start = jiffies;

1804

unsigned long start = jiffies;

1804

if (shost->hostt->scan_start)

1805

if (shost->hostt->scan_start)

1805

shost->hostt->scan_start(shost);

1806

shost->hostt->scan_start(shost);

1806

1807

while (!shost->hostt->scan_finished(shost, jiffies - start))

1808

while (!shost->hostt->scan_finished(shost, jiffies - start))

1808

msleep(10);

1809

msleep(10);

1809

} else {

1810

} else {

1810

scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,

1811

scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,

1811

SCAN_WILD_CARD, 0);

1812

SCAN_WILD_CARD, 0);

1812

}

1813

}

1813

}

1814

}

1814

1815

static void do_scan_async(void *_data, async_cookie_t c)

1816

static void do_scan_async(void *_data, async_cookie_t c)

1816

{

1817

{

1817

struct async_scan_data *data = _data;

1818

struct async_scan_data *data = _data;

1818

struct Scsi_Host *shost = data->shost;

1819

struct Scsi_Host *shost = data->shost;

1819

1820

do_scsi_scan_host(shost);

1821

do_scsi_scan_host(shost);

1821

scsi_finish_async_scan(data);

1822

scsi_finish_async_scan(data);

1822

}

1823

}

1823

1824

/**

1825

/**

1825

* scsi_scan_host - scan the given adapter

1826

* scsi_scan_host - scan the given adapter

1826

* @shost: adapter to scan

1827

* @shost: adapter to scan

1827

**/

1828

**/

1828

void scsi_scan_host(struct Scsi_Host *shost)

1829

void scsi_scan_host(struct Scsi_Host *shost)

1829

{

1830

{

1830

struct async_scan_data *data;

1831

struct async_scan_data *data;

1831

1832

if (strncmp(scsi_scan_type, "none", 4) == 0)

1833

if (strncmp(scsi_scan_type, "none", 4) == 0)

1833

return;

1834

return;

1834

if (scsi_autopm_get_host(shost) < 0)

1835

if (scsi_autopm_get_host(shost) < 0)

1835

return;

1836

return;

1836

1837

data = scsi_prep_async_scan(shost);

1838

data = scsi_prep_async_scan(shost);

1838

if (!data) {

1839

if (!data) {

1839

do_scsi_scan_host(shost);

1840

do_scsi_scan_host(shost);

1840

scsi_autopm_put_host(shost);

1841

scsi_autopm_put_host(shost);

1841

return;

1842

return;

1842

}

1843

}

1843

1844

/* register with the async subsystem so wait_for_device_probe()

1845

/* register with the async subsystem so wait_for_device_probe()

1845

* will flush this work

1846

* will flush this work

1846

*/

1847

*/

1847

async_schedule(do_scan_async, data);

1848

async_schedule(do_scan_async, data);

1848

1849

/* scsi_autopm_put_host(shost) is called in scsi_finish_async_scan() */

1850

/* scsi_autopm_put_host(shost) is called in scsi_finish_async_scan() */

1850

}

1851

}

1851

EXPORT_SYMBOL(scsi_scan_host);

1852

EXPORT_SYMBOL(scsi_scan_host);

1852

1853

void scsi_forget_host(struct Scsi_Host *shost)

1854

void scsi_forget_host(struct Scsi_Host *shost)

1854

{

1855

{

1855

struct scsi_device *sdev;

1856

struct scsi_device *sdev;

1856

unsigned long flags;

1857

unsigned long flags;

1857

1858

restart:

1859

restart:

1859

spin_lock_irqsave(shost->host_lock, flags);

1860

spin_lock_irqsave(shost->host_lock, flags);

1860

list_for_each_entry(sdev, &shost->__devices, siblings) {

1861

list_for_each_entry(sdev, &shost->__devices, siblings) {

1861

if (sdev->sdev_state == SDEV_DEL)

1862

if (sdev->sdev_state == SDEV_DEL)

1862

continue;

1863

continue;

1863

spin_unlock_irqrestore(shost->host_lock, flags);

1864

spin_unlock_irqrestore(shost->host_lock, flags);

1864

__scsi_remove_device(sdev);

1865

__scsi_remove_device(sdev);

1865

goto restart;

1866

goto restart;

1866

}

1867

}

1867

spin_unlock_irqrestore(shost->host_lock, flags);

1868

spin_unlock_irqrestore(shost->host_lock, flags);

1868

}

1869

}

1869

1870

/**

1871

/**

1871

* scsi_get_host_dev - Create a scsi_device that points to the host adapter itself

1872

* scsi_get_host_dev - Create a scsi_device that points to the host adapter itself

1872

* @shost: Host that needs a scsi_device

1873

* @shost: Host that needs a scsi_device

1873

*

1874

*

1874

* Lock status: None assumed.

1875

* Lock status: None assumed.

1875

*

1876

*

1876

* Returns: The scsi_device or NULL

1877

* Returns: The scsi_device or NULL

1877

*

1878

*

1878

* Notes:

1879

* Notes:

1879

* Attach a single scsi_device to the Scsi_Host - this should

1880

* Attach a single scsi_device to the Scsi_Host - this should

1880

* be made to look like a "pseudo-device" that points to the

1881

* be made to look like a "pseudo-device" that points to the

1881

* HA itself.

1882

* HA itself.

1882

*

1883

*

1883

* Note - this device is not accessible from any high-level

1884

* Note - this device is not accessible from any high-level

1884

* drivers (including generics), which is probably not

1885

* drivers (including generics), which is probably not

1885

* optimal. We can add hooks later to attach.

1886

* optimal. We can add hooks later to attach.

1886

*/

1887

*/

1887

struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)

1888

struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)

1888

{

1889

{

1889

struct scsi_device *sdev = NULL;

1890

struct scsi_device *sdev = NULL;

1890

struct scsi_target *starget;

1891

struct scsi_target *starget;

1891

1892

mutex_lock(&shost->scan_mutex);

1893

mutex_lock(&shost->scan_mutex);

1893

if (!scsi_host_scan_allowed(shost))

1894

if (!scsi_host_scan_allowed(shost))

1894

goto out;

1895

goto out;

1895

starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);

1896

starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);

1896

if (!starget)

1897

if (!starget)

1897

goto out;

1898

goto out;

1898

1899

sdev = scsi_alloc_sdev(starget, 0, NULL);

1900

sdev = scsi_alloc_sdev(starget, 0, NULL);

1900

if (sdev)

1901

if (sdev)

1901

sdev->borken = 0;

1902

sdev->borken = 0;

1902

else

1903

else

1903

scsi_target_reap(starget);

1904

scsi_target_reap(starget);

1904

put_device(&starget->dev);

1905

put_device(&starget->dev);

1905

out:

1906

out:

1906

mutex_unlock(&shost->scan_mutex);

1907

mutex_unlock(&shost->scan_mutex);

1907

return sdev;

1908

return sdev;

1908

}

1909

}

1909

EXPORT_SYMBOL(scsi_get_host_dev);

1910

EXPORT_SYMBOL(scsi_get_host_dev);

1910

1911

/**

1912

/**

1912

* scsi_free_host_dev - Free a scsi_device that points to the host adapter itself

1913

* scsi_free_host_dev - Free a scsi_device that points to the host adapter itself

1913

* @sdev: Host device to be freed

1914

* @sdev: Host device to be freed

1914

*

1915

*

1915

* Lock status: None assumed.

1916

* Lock status: None assumed.

1916

*

1917

*

1917

* Returns: Nothing

1918

* Returns: Nothing

1918

*/

1919

*/

1919

void scsi_free_host_dev(struct scsi_device *sdev)

1920

void scsi_free_host_dev(struct scsi_device *sdev)

1920

{

1921

{

1921

BUG_ON(sdev->id != sdev->host->this_id);

1922

BUG_ON(sdev->id != sdev->host->this_id);

1922

1923

__scsi_remove_device(sdev);

1924

__scsi_remove_device(sdev);

1924

}

1925

}

1925

EXPORT_SYMBOL(scsi_free_host_dev);

1926

EXPORT_SYMBOL(scsi_free_host_dev);

1926

1927

1928

GITLAB

scsi: Add intermediate STARGET_REMOVE state to scsi_target_state

 /*
  * scsi_scan.c
  *
  * Copyright (C) 2000 Eric Youngdale,
  * Copyright (C) 2002 Patrick Mansfield
  *
  * The general scanning/probing algorithm is as follows, exceptions are
  * made to it depending on device specific flags, compilation options, and
  * global variable (boot or module load time) settings.
  *
  * A specific LUN is scanned via an INQUIRY command; if the LUN has a
  * device attached, a scsi_device is allocated and setup for it.
  *
  * For every id of every channel on the given host:
  *
  * 	Scan LUN 0; if the target responds to LUN 0 (even if there is no
  * 	device or storage attached to LUN 0):
  *
  * 		If LUN 0 has a device attached, allocate and setup a
  * 		scsi_device for it.
  *
  * 		If target is SCSI-3 or up, issue a REPORT LUN, and scan
  * 		all of the LUNs returned by the REPORT LUN; else,
  * 		sequentially scan LUNs up until some maximum is reached,
  * 		or a LUN is seen that cannot have a device attached to it.
  */
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
 #include <linux/spinlock.h>
 #include <linux/async.h>
 #include <linux/slab.h>
 #include <asm/unaligned.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_driver.h>
 #include <scsi/scsi_devinfo.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_eh.h>
 #include "scsi_priv.h"
 #include "scsi_logging.h"
 #define ALLOC_FAILURE_MSG	KERN_ERR "%s: Allocation failure during" \
 	" SCSI scanning, some SCSI devices might not be configured\n"
 /*
  * Default timeout
  */
 #define SCSI_TIMEOUT (2*HZ)
 #define SCSI_REPORT_LUNS_TIMEOUT (30*HZ)
 /*
  * Prefix values for the SCSI id's (stored in sysfs name field)
  */
 #define SCSI_UID_SER_NUM 'S'
 #define SCSI_UID_UNKNOWN 'Z'
 /*
  * Return values of some of the scanning functions.
  *
  * SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this
  * includes allocation or general failures preventing IO from being sent.
  *
  * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available
  * on the given LUN.
  *
  * SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a
  * given LUN.
  */
 #define SCSI_SCAN_NO_RESPONSE		0
 #define SCSI_SCAN_TARGET_PRESENT	1
 #define SCSI_SCAN_LUN_PRESENT		2
 static const char *scsi_null_device_strs = "nullnullnullnull";
 #define MAX_SCSI_LUNS	512
 static u64 max_scsi_luns = MAX_SCSI_LUNS;
 module_param_named(max_luns, max_scsi_luns, ullong, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(max_luns,
 		 "last scsi LUN (should be between 1 and 2^64-1)");
 #ifdef CONFIG_SCSI_SCAN_ASYNC
 #define SCSI_SCAN_TYPE_DEFAULT "async"
 #else
 #define SCSI_SCAN_TYPE_DEFAULT "sync"
 #endif
 char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
 module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);
 MODULE_PARM_DESC(scan, "sync, async or none");
 static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;
 module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(inq_timeout,
 		 "Timeout (in seconds) waiting for devices to answer INQUIRY."
 		 " Default is 20. Some devices may need more; most need less.");
 /* This lock protects only this list */
 static DEFINE_SPINLOCK(async_scan_lock);
 static LIST_HEAD(scanning_hosts);
 struct async_scan_data {
 	struct list_head list;
 	struct Scsi_Host *shost;
 	struct completion prev_finished;
 };
 /**
  * scsi_complete_async_scans - Wait for asynchronous scans to complete
  *
  * When this function returns, any host which started scanning before
  * this function was called will have finished its scan.  Hosts which
  * started scanning after this function was called may or may not have
  * finished.
  */
 int scsi_complete_async_scans(void)
 {
 	struct async_scan_data *data;
 	do {
 		if (list_empty(&scanning_hosts))
 			return 0;
 		/* If we can't get memory immediately, that's OK.  Just
 		 * sleep a little.  Even if we never get memory, the async
 		 * scans will finish eventually.
 		 */
 		data = kmalloc(sizeof(*data), GFP_KERNEL);
 		if (!data)
 			msleep(1);
 	} while (!data);
 	data->shost = NULL;
 	init_completion(&data->prev_finished);
 	spin_lock(&async_scan_lock);
 	/* Check that there's still somebody else on the list */
 	if (list_empty(&scanning_hosts))
 		goto done;
 	list_add_tail(&data->list, &scanning_hosts);
 	spin_unlock(&async_scan_lock);
 	printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n");
 	wait_for_completion(&data->prev_finished);
 	spin_lock(&async_scan_lock);
 	list_del(&data->list);
 	if (!list_empty(&scanning_hosts)) {
 		struct async_scan_data *next = list_entry(scanning_hosts.next,
 				struct async_scan_data, list);
 		complete(&next->prev_finished);
 	}
  done:
 	spin_unlock(&async_scan_lock);
 	kfree(data);
 	return 0;
 }
 /**
  * scsi_unlock_floptical - unlock device via a special MODE SENSE command
  * @sdev:	scsi device to send command to
  * @result:	area to store the result of the MODE SENSE
  *
  * Description:
  *     Send a vendor specific MODE SENSE (not a MODE SELECT) command.
  *     Called for BLIST_KEY devices.
  **/
 static void scsi_unlock_floptical(struct scsi_device *sdev,
 				  unsigned char *result)
 {
 	unsigned char scsi_cmd[MAX_COMMAND_SIZE];
 	sdev_printk(KERN_NOTICE, sdev, "unlocking floptical drive\n");
 	scsi_cmd[0] = MODE_SENSE;
 	scsi_cmd[1] = 0;
 	scsi_cmd[2] = 0x2e;
 	scsi_cmd[3] = 0;
 	scsi_cmd[4] = 0x2a;     /* size */
 	scsi_cmd[5] = 0;
 	scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,
 			 SCSI_TIMEOUT, 3, NULL);
 }
 /**
  * scsi_alloc_sdev - allocate and setup a scsi_Device
  * @starget: which target to allocate a &scsi_device for
  * @lun: which lun
  * @hostdata: usually NULL and set by ->slave_alloc instead
  *
  * Description:
  *     Allocate, initialize for io, and return a pointer to a scsi_Device.
  *     Stores the @shost, @channel, @id, and @lun in the scsi_Device, and
  *     adds scsi_Device to the appropriate list.
  *
  * Return value:
  *     scsi_Device pointer, or NULL on failure.
  **/
 static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
 					   u64 lun, void *hostdata)
 {
 	struct scsi_device *sdev;
 	int display_failure_msg = 1, ret;
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	extern void scsi_evt_thread(struct work_struct *work);
 	extern void scsi_requeue_run_queue(struct work_struct *work);
 	sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
 		       GFP_ATOMIC);
 	if (!sdev)
 		goto out;
 	sdev->vendor = scsi_null_device_strs;
 	sdev->model = scsi_null_device_strs;
 	sdev->rev = scsi_null_device_strs;
 	sdev->host = shost;
 	sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
 	sdev->id = starget->id;
 	sdev->lun = lun;
 	sdev->channel = starget->channel;
 	sdev->sdev_state = SDEV_CREATED;
 	INIT_LIST_HEAD(&sdev->siblings);
 	INIT_LIST_HEAD(&sdev->same_target_siblings);
 	INIT_LIST_HEAD(&sdev->cmd_list);
 	INIT_LIST_HEAD(&sdev->starved_entry);
 	INIT_LIST_HEAD(&sdev->event_list);
 	spin_lock_init(&sdev->list_lock);
 	INIT_WORK(&sdev->event_work, scsi_evt_thread);
 	INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);
 	sdev->sdev_gendev.parent = get_device(&starget->dev);
 	sdev->sdev_target = starget;
 	/* usually NULL and set by ->slave_alloc instead */
 	sdev->hostdata = hostdata;
 	/* if the device needs this changing, it may do so in the
 	 * slave_configure function */
 	sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;
 	/*
 	 * Some low level driver could use device->type
 	 */
 	sdev->type = -1;
 	/*
 	 * Assume that the device will have handshaking problems,
 	 * and then fix this field later if it turns out it
 	 * doesn't
 	 */
 	sdev->borken = 1;
 	if (shost_use_blk_mq(shost))
 		sdev->request_queue = scsi_mq_alloc_queue(sdev);
 	else
 		sdev->request_queue = scsi_alloc_queue(sdev);
 	if (!sdev->request_queue) {
 		/* release fn is set up in scsi_sysfs_device_initialise, so
 		 * have to free and put manually here */
 		put_device(&starget->dev);
 		kfree(sdev);
 		goto out;
 	}
 	WARN_ON_ONCE(!blk_get_queue(sdev->request_queue));
 	sdev->request_queue->queuedata = sdev;
 	if (!shost_use_blk_mq(sdev->host)) {
 		blk_queue_init_tags(sdev->request_queue,
 				    sdev->host->cmd_per_lun, shost->bqt,
 				    shost->hostt->tag_alloc_policy);
 	}
 	scsi_change_queue_depth(sdev, sdev->host->cmd_per_lun ?
 					sdev->host->cmd_per_lun : 1);
 	scsi_sysfs_device_initialize(sdev);
 	if (shost->hostt->slave_alloc) {
 		ret = shost->hostt->slave_alloc(sdev);
 		if (ret) {
 			/*
 			 * if LLDD reports slave not present, don't clutter
 			 * console with alloc failure messages
 			 */
 			if (ret == -ENXIO)
 				display_failure_msg = 0;
 			goto out_device_destroy;
 		}
 	}
 	return sdev;
 out_device_destroy:
 	__scsi_remove_device(sdev);
 out:
 	if (display_failure_msg)
 		printk(ALLOC_FAILURE_MSG, __func__);
 	return NULL;
 }
 static void scsi_target_destroy(struct scsi_target *starget)
 {
 	struct device *dev = &starget->dev;
 	struct Scsi_Host *shost = dev_to_shost(dev->parent);
 	unsigned long flags;
+	BUG_ON(starget->state == STARGET_DEL);
 	starget->state = STARGET_DEL;
 	transport_destroy_device(dev);
 	spin_lock_irqsave(shost->host_lock, flags);
 	if (shost->hostt->target_destroy)
 		shost->hostt->target_destroy(starget);
 	list_del_init(&starget->siblings);
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	put_device(dev);
 }
 static void scsi_target_dev_release(struct device *dev)
 {
 	struct device *parent = dev->parent;
 	struct scsi_target *starget = to_scsi_target(dev);
 	kfree(starget);
 	put_device(parent);
 }
 static struct device_type scsi_target_type = {
 	.name =		"scsi_target",
 	.release =	scsi_target_dev_release,
 };
 int scsi_is_target_device(const struct device *dev)
 {
 	return dev->type == &scsi_target_type;
 }
 EXPORT_SYMBOL(scsi_is_target_device);
 static struct scsi_target *__scsi_find_target(struct device *parent,
 					      int channel, uint id)
 {
 	struct scsi_target *starget, *found_starget = NULL;
 	struct Scsi_Host *shost = dev_to_shost(parent);
 	/*
 	 * Search for an existing target for this sdev.
 	 */
 	list_for_each_entry(starget, &shost->__targets, siblings) {
 		if (starget->id == id &&
 		    starget->channel == channel) {
 			found_starget = starget;
 			break;
 		}
 	}
 	if (found_starget)
 		get_device(&found_starget->dev);
 	return found_starget;
 }
 /**
  * scsi_target_reap_ref_release - remove target from visibility
  * @kref: the reap_ref in the target being released
  *
  * Called on last put of reap_ref, which is the indication that no device
  * under this target is visible anymore, so render the target invisible in
  * sysfs.  Note: we have to be in user context here because the target reaps
  * should be done in places where the scsi device visibility is being removed.
  */
 static void scsi_target_reap_ref_release(struct kref *kref)
 {
 	struct scsi_target *starget
 		= container_of(kref, struct scsi_target, reap_ref);
 	/*
 	 * if we get here and the target is still in the CREATED state that
 	 * means it was allocated but never made visible (because a scan
 	 * turned up no LUNs), so don't call device_del() on it.
 	 */
 	if (starget->state != STARGET_CREATED) {
 		transport_remove_device(&starget->dev);
 		device_del(&starget->dev);
 	}
 	scsi_target_destroy(starget);
 }
 static void scsi_target_reap_ref_put(struct scsi_target *starget)
 {
 	kref_put(&starget->reap_ref, scsi_target_reap_ref_release);
 }
 /**
  * scsi_alloc_target - allocate a new or find an existing target
  * @parent:	parent of the target (need not be a scsi host)
  * @channel:	target channel number (zero if no channels)
  * @id:		target id number
  *
  * Return an existing target if one exists, provided it hasn't already
  * gone into STARGET_DEL state, otherwise allocate a new target.
  *
  * The target is returned with an incremented reference, so the caller
  * is responsible for both reaping and doing a last put
  */
 static struct scsi_target *scsi_alloc_target(struct device *parent,
 					     int channel, uint id)
 {
 	struct Scsi_Host *shost = dev_to_shost(parent);
 	struct device *dev = NULL;
 	unsigned long flags;
 	const int size = sizeof(struct scsi_target)
 		+ shost->transportt->target_size;
 	struct scsi_target *starget;
 	struct scsi_target *found_target;
 	int error, ref_got;
 	starget = kzalloc(size, GFP_KERNEL);
 	if (!starget) {
 		printk(KERN_ERR "%s: allocation failure\n", __func__);
 		return NULL;
 	}
 	dev = &starget->dev;
 	device_initialize(dev);
 	kref_init(&starget->reap_ref);
 	dev->parent = get_device(parent);
 	dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);
 	dev->bus = &scsi_bus_type;
 	dev->type = &scsi_target_type;
 	starget->id = id;
 	starget->channel = channel;
 	starget->can_queue = 0;
 	INIT_LIST_HEAD(&starget->siblings);
 	INIT_LIST_HEAD(&starget->devices);
 	starget->state = STARGET_CREATED;
 	starget->scsi_level = SCSI_2;
 	starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;
  retry:
 	spin_lock_irqsave(shost->host_lock, flags);
 	found_target = __scsi_find_target(parent, channel, id);
 	if (found_target)
 		goto found;
 	list_add_tail(&starget->siblings, &shost->__targets);
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	/* allocate and add */
 	transport_setup_device(dev);
 	if (shost->hostt->target_alloc) {
 		error = shost->hostt->target_alloc(starget);
 		if(error) {
 			dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);
 			/* don't want scsi_target_reap to do the final
 			 * put because it will be under the host lock */
 			scsi_target_destroy(starget);
 			return NULL;
 		}
 	}
 	get_device(dev);
 	return starget;
  found:
 	/*
 	 * release routine already fired if kref is zero, so if we can still
 	 * take the reference, the target must be alive.  If we can't, it must
 	 * be dying and we need to wait for a new target
 	 */
 	ref_got = kref_get_unless_zero(&found_target->reap_ref);
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	if (ref_got) {
 		put_device(dev);
 		return found_target;
 	}
 	/*
 	 * Unfortunately, we found a dying target; need to wait until it's
 	 * dead before we can get a new one.  There is an anomaly here.  We
 	 * *should* call scsi_target_reap() to balance the kref_get() of the
 	 * reap_ref above.  However, since the target being released, it's
 	 * already invisible and the reap_ref is irrelevant.  If we call
 	 * scsi_target_reap() we might spuriously do another device_del() on
 	 * an already invisible target.
 	 */
 	put_device(&found_target->dev);
 	/*
 	 * length of time is irrelevant here, we just want to yield the CPU
 	 * for a tick to avoid busy waiting for the target to die.
 	 */
 	msleep(1);
 	goto retry;
 }
 /**
  * scsi_target_reap - check to see if target is in use and destroy if not
  * @starget: target to be checked
  *
  * This is used after removing a LUN or doing a last put of the target
  * it checks atomically that nothing is using the target and removes
  * it if so.
  */
 void scsi_target_reap(struct scsi_target *starget)
 {
 	/*
 	 * serious problem if this triggers: STARGET_DEL is only set in the if
 	 * the reap_ref drops to zero, so we're trying to do another final put
 	 * on an already released kref
 	 */
 	BUG_ON(starget->state == STARGET_DEL);
 	scsi_target_reap_ref_put(starget);
 }
 /**
  * sanitize_inquiry_string - remove non-graphical chars from an INQUIRY result string
  * @s: INQUIRY result string to sanitize
  * @len: length of the string
  *
  * Description:
  *	The SCSI spec says that INQUIRY vendor, product, and revision
  *	strings must consist entirely of graphic ASCII characters,
  *	padded on the right with spaces.  Since not all devices obey
  *	this rule, we will replace non-graphic or non-ASCII characters
  *	with spaces.  Exception: a NUL character is interpreted as a
  *	string terminator, so all the following characters are set to
  *	spaces.
  **/
 static void sanitize_inquiry_string(unsigned char *s, int len)
 {
 	int terminated = 0;
 	for (; len > 0; (--len, ++s)) {
 		if (*s == 0)
 			terminated = 1;
 		if (terminated || *s < 0x20 || *s > 0x7e)
 			*s = ' ';
 	}
 }
 /**
  * scsi_probe_lun - probe a single LUN using a SCSI INQUIRY
  * @sdev:	scsi_device to probe
  * @inq_result:	area to store the INQUIRY result
  * @result_len: len of inq_result
  * @bflags:	store any bflags found here
  *
  * Description:
  *     Probe the lun associated with @req using a standard SCSI INQUIRY;
  *
  *     If the INQUIRY is successful, zero is returned and the
  *     INQUIRY data is in @inq_result; the scsi_level and INQUIRY length
  *     are copied to the scsi_device any flags value is stored in *@bflags.
  **/
 static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
 			  int result_len, int *bflags)
 {
 	unsigned char scsi_cmd[MAX_COMMAND_SIZE];
 	int first_inquiry_len, try_inquiry_len, next_inquiry_len;
 	int response_len = 0;
 	int pass, count, result;
 	struct scsi_sense_hdr sshdr;
 	*bflags = 0;
 	/* Perform up to 3 passes.  The first pass uses a conservative
 	 * transfer length of 36 unless sdev->inquiry_len specifies a
 	 * different value. */
 	first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36;
 	try_inquiry_len = first_inquiry_len;
 	pass = 1;
  next_pass:
 	SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
 				"scsi scan: INQUIRY pass %d length %d\n",
 				pass, try_inquiry_len));
 	/* Each pass gets up to three chances to ignore Unit Attention */
 	for (count = 0; count < 3; ++count) {
 		int resid;
 		memset(scsi_cmd, 0, 6);
 		scsi_cmd[0] = INQUIRY;
 		scsi_cmd[4] = (unsigned char) try_inquiry_len;
 		memset(inq_result, 0, try_inquiry_len);
 		result = scsi_execute_req(sdev,  scsi_cmd, DMA_FROM_DEVICE,
 					  inq_result, try_inquiry_len, &sshdr,
 					  HZ / 2 + HZ * scsi_inq_timeout, 3,
 					  &resid);
 		SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
 				"scsi scan: INQUIRY %s with code 0x%x\n",
 				result ? "failed" : "successful", result));
 		if (result) {
 			/*
 			 * not-ready to ready transition [asc/ascq=0x28/0x0]
 			 * or power-on, reset [asc/ascq=0x29/0x0], continue.
 			 * INQUIRY should not yield UNIT_ATTENTION
 			 * but many buggy devices do so anyway.
 			 */
 			if ((driver_byte(result) & DRIVER_SENSE) &&
 			    scsi_sense_valid(&sshdr)) {
 				if ((sshdr.sense_key == UNIT_ATTENTION) &&
 				    ((sshdr.asc == 0x28) ||
 				     (sshdr.asc == 0x29)) &&
 				    (sshdr.ascq == 0))
 					continue;
 			}
 		} else {
 			/*
 			 * if nothing was transferred, we try
 			 * again. It's a workaround for some USB
 			 * devices.
 			 */
 			if (resid == try_inquiry_len)
 				continue;
 		}
 		break;
 	}
 	if (result == 0) {
 		sanitize_inquiry_string(&inq_result[8], 8);
 		sanitize_inquiry_string(&inq_result[16], 16);
 		sanitize_inquiry_string(&inq_result[32], 4);
 		response_len = inq_result[4] + 5;
 		if (response_len > 255)
 			response_len = first_inquiry_len;	/* sanity */
 		/*
 		 * Get any flags for this device.
 		 *
 		 * XXX add a bflags to scsi_device, and replace the
 		 * corresponding bit fields in scsi_device, so bflags
 		 * need not be passed as an argument.
 		 */
 		*bflags = scsi_get_device_flags(sdev, &inq_result[8],
 				&inq_result[16]);
 		/* When the first pass succeeds we gain information about
 		 * what larger transfer lengths might work. */
 		if (pass == 1) {
 			if (BLIST_INQUIRY_36 & *bflags)
 				next_inquiry_len = 36;
 			else if (BLIST_INQUIRY_58 & *bflags)
 				next_inquiry_len = 58;
 			else if (sdev->inquiry_len)
 				next_inquiry_len = sdev->inquiry_len;
 			else
 				next_inquiry_len = response_len;
 			/* If more data is available perform the second pass */
 			if (next_inquiry_len > try_inquiry_len) {
 				try_inquiry_len = next_inquiry_len;
 				pass = 2;
 				goto next_pass;
 			}
 		}
 	} else if (pass == 2) {
 		sdev_printk(KERN_INFO, sdev,
 			    "scsi scan: %d byte inquiry failed.  "
 			    "Consider BLIST_INQUIRY_36 for this device\n",
 			    try_inquiry_len);
 		/* If this pass failed, the third pass goes back and transfers
 		 * the same amount as we successfully got in the first pass. */
 		try_inquiry_len = first_inquiry_len;
 		pass = 3;
 		goto next_pass;
 	}
 	/* If the last transfer attempt got an error, assume the
 	 * peripheral doesn't exist or is dead. */
 	if (result)
 		return -EIO;
 	/* Don't report any more data than the device says is valid */
 	sdev->inquiry_len = min(try_inquiry_len, response_len);
 	/*
 	 * XXX Abort if the response length is less than 36? If less than
 	 * 32, the lookup of the device flags (above) could be invalid,
 	 * and it would be possible to take an incorrect action - we do
 	 * not want to hang because of a short INQUIRY. On the flip side,
 	 * if the device is spun down or becoming ready (and so it gives a
 	 * short INQUIRY), an abort here prevents any further use of the
 	 * device, including spin up.
 	 *
 	 * On the whole, the best approach seems to be to assume the first
 	 * 36 bytes are valid no matter what the device says.  That's
 	 * better than copying < 36 bytes to the inquiry-result buffer
 	 * and displaying garbage for the Vendor, Product, or Revision
 	 * strings.
 	 */
 	if (sdev->inquiry_len < 36) {
 		if (!sdev->host->short_inquiry) {
 			shost_printk(KERN_INFO, sdev->host,
 				    "scsi scan: INQUIRY result too short (%d),"
 				    " using 36\n", sdev->inquiry_len);
 			sdev->host->short_inquiry = 1;
 		}
 		sdev->inquiry_len = 36;
 	}
 	/*
 	 * Related to the above issue:
 	 *
 	 * XXX Devices (disk or all?) should be sent a TEST UNIT READY,
 	 * and if not ready, sent a START_STOP to start (maybe spin up) and
 	 * then send the INQUIRY again, since the INQUIRY can change after
 	 * a device is initialized.
 	 *
 	 * Ideally, start a device if explicitly asked to do so.  This
 	 * assumes that a device is spun up on power on, spun down on
 	 * request, and then spun up on request.
 	 */
 	/*
 	 * The scanning code needs to know the scsi_level, even if no
 	 * device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so
 	 * non-zero LUNs can be scanned.
 	 */
 	sdev->scsi_level = inq_result[2] & 0x07;
 	if (sdev->scsi_level >= 2 ||
 	    (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))
 		sdev->scsi_level++;
 	sdev->sdev_target->scsi_level = sdev->scsi_level;
 	/*
 	 * If SCSI-2 or lower, and if the transport requires it,
 	 * store the LUN value in CDB[1].
 	 */
 	sdev->lun_in_cdb = 0;
 	if (sdev->scsi_level <= SCSI_2 &&
 	    sdev->scsi_level != SCSI_UNKNOWN &&
 	    !sdev->host->no_scsi2_lun_in_cdb)
 		sdev->lun_in_cdb = 1;
 	return 0;
 }
 /**
  * scsi_add_lun - allocate and fully initialze a scsi_device
  * @sdev:	holds information to be stored in the new scsi_device
  * @inq_result:	holds the result of a previous INQUIRY to the LUN
  * @bflags:	black/white list flag
  * @async:	1 if this device is being scanned asynchronously
  *
  * Description:
  *     Initialize the scsi_device @sdev.  Optionally set fields based
  *     on values in *@bflags.
  *
  * Return:
  *     SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
  *     SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
  **/
 static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
 		int *bflags, int async)
 {
 	int ret;
 	/*
 	 * XXX do not save the inquiry, since it can change underneath us,
 	 * save just vendor/model/rev.
 	 *
 	 * Rather than save it and have an ioctl that retrieves the saved
 	 * value, have an ioctl that executes the same INQUIRY code used
 	 * in scsi_probe_lun, let user level programs doing INQUIRY
 	 * scanning run at their own risk, or supply a user level program
 	 * that can correctly scan.
 	 */
 	/*
 	 * Copy at least 36 bytes of INQUIRY data, so that we don't
 	 * dereference unallocated memory when accessing the Vendor,
 	 * Product, and Revision strings.  Badly behaved devices may set
 	 * the INQUIRY Additional Length byte to a small value, indicating
 	 * these strings are invalid, but often they contain plausible data
 	 * nonetheless.  It doesn't matter if the device sent < 36 bytes
 	 * total, since scsi_probe_lun() initializes inq_result with 0s.
 	 */
 	sdev->inquiry = kmemdup(inq_result,
 				max_t(size_t, sdev->inquiry_len, 36),
 				GFP_ATOMIC);
 	if (sdev->inquiry == NULL)
 		return SCSI_SCAN_NO_RESPONSE;
 	sdev->vendor = (char *) (sdev->inquiry + 8);
 	sdev->model = (char *) (sdev->inquiry + 16);
 	sdev->rev = (char *) (sdev->inquiry + 32);
 	if (strncmp(sdev->vendor, "ATA     ", 8) == 0) {
 		/*
 		 * sata emulation layer device.  This is a hack to work around
 		 * the SATL power management specifications which state that
 		 * when the SATL detects the device has gone into standby
 		 * mode, it shall respond with NOT READY.
 		 */
 		sdev->allow_restart = 1;
 	}
 	if (*bflags & BLIST_ISROM) {
 		sdev->type = TYPE_ROM;
 		sdev->removable = 1;
 	} else {
 		sdev->type = (inq_result[0] & 0x1f);
 		sdev->removable = (inq_result[1] & 0x80) >> 7;
 		/*
 		 * some devices may respond with wrong type for
 		 * well-known logical units. Force well-known type
 		 * to enumerate them correctly.
 		 */
 		if (scsi_is_wlun(sdev->lun) && sdev->type != TYPE_WLUN) {
 			sdev_printk(KERN_WARNING, sdev,
 				"%s: correcting incorrect peripheral device type 0x%x for W-LUN 0x%16xhN\n",
 				__func__, sdev->type, (unsigned int)sdev->lun);
 			sdev->type = TYPE_WLUN;
 		}
 	}
 	if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {
 		/* RBC and MMC devices can return SCSI-3 compliance and yet
 		 * still not support REPORT LUNS, so make them act as
 		 * BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is
 		 * specifically set */
 		if ((*bflags & BLIST_REPORTLUN2) == 0)
 			*bflags |= BLIST_NOREPORTLUN;
 	}
 	/*
 	 * For a peripheral qualifier (PQ) value of 1 (001b), the SCSI
 	 * spec says: The device server is capable of supporting the
 	 * specified peripheral device type on this logical unit. However,
 	 * the physical device is not currently connected to this logical
 	 * unit.
 	 *
 	 * The above is vague, as it implies that we could treat 001 and
 	 * 011 the same. Stay compatible with previous code, and create a
 	 * scsi_device for a PQ of 1
 	 *
 	 * Don't set the device offline here; rather let the upper
 	 * level drivers eval the PQ to decide whether they should
 	 * attach. So remove ((inq_result[0] >> 5) & 7) == 1 check.
 	 */
 	sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;
 	sdev->lockable = sdev->removable;
 	sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);
 	if (sdev->scsi_level >= SCSI_3 ||
 			(sdev->inquiry_len > 56 && inq_result[56] & 0x04))
 		sdev->ppr = 1;
 	if (inq_result[7] & 0x60)
 		sdev->wdtr = 1;
 	if (inq_result[7] & 0x10)
 		sdev->sdtr = 1;
 	sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "
 			"ANSI: %d%s\n", scsi_device_type(sdev->type),
 			sdev->vendor, sdev->model, sdev->rev,
 			sdev->inq_periph_qual, inq_result[2] & 0x07,
 			(inq_result[3] & 0x0f) == 1 ? " CCS" : "");
 	if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
 	    !(*bflags & BLIST_NOTQ)) {
 		sdev->tagged_supported = 1;
 		sdev->simple_tags = 1;
 	}
 	/*
 	 * Some devices (Texel CD ROM drives) have handshaking problems
 	 * when used with the Seagate controllers. borken is initialized
 	 * to 1, and then set it to 0 here.
 	 */
 	if ((*bflags & BLIST_BORKEN) == 0)
 		sdev->borken = 0;
 	if (*bflags & BLIST_NO_ULD_ATTACH)
 		sdev->no_uld_attach = 1;
 	/*
 	 * Apparently some really broken devices (contrary to the SCSI
 	 * standards) need to be selected without asserting ATN
 	 */
 	if (*bflags & BLIST_SELECT_NO_ATN)
 		sdev->select_no_atn = 1;
 	/*
 	 * Maximum 512 sector transfer length
 	 * broken RA4x00 Compaq Disk Array
 	 */
 	if (*bflags & BLIST_MAX_512)
 		blk_queue_max_hw_sectors(sdev->request_queue, 512);
 	/*
 	 * Max 1024 sector transfer length for targets that report incorrect
 	 * max/optimal lengths and relied on the old block layer safe default
 	 */
 	else if (*bflags & BLIST_MAX_1024)
 		blk_queue_max_hw_sectors(sdev->request_queue, 1024);
 	/*
 	 * Some devices may not want to have a start command automatically
 	 * issued when a device is added.
 	 */
 	if (*bflags & BLIST_NOSTARTONADD)
 		sdev->no_start_on_add = 1;
 	if (*bflags & BLIST_SINGLELUN)
 		scsi_target(sdev)->single_lun = 1;
 	sdev->use_10_for_rw = 1;
 	if (*bflags & BLIST_MS_SKIP_PAGE_08)
 		sdev->skip_ms_page_8 = 1;
 	if (*bflags & BLIST_MS_SKIP_PAGE_3F)
 		sdev->skip_ms_page_3f = 1;
 	if (*bflags & BLIST_USE_10_BYTE_MS)
 		sdev->use_10_for_ms = 1;
 	/* some devices don't like REPORT SUPPORTED OPERATION CODES
 	 * and will simply timeout causing sd_mod init to take a very
 	 * very long time */
 	if (*bflags & BLIST_NO_RSOC)
 		sdev->no_report_opcodes = 1;
 	/* set the device running here so that slave configure
 	 * may do I/O */
 	ret = scsi_device_set_state(sdev, SDEV_RUNNING);
 	if (ret) {
 		ret = scsi_device_set_state(sdev, SDEV_BLOCK);
 		if (ret) {
 			sdev_printk(KERN_ERR, sdev,
 				    "in wrong state %s to complete scan\n",
 				    scsi_device_state_name(sdev->sdev_state));
 			return SCSI_SCAN_NO_RESPONSE;
 		}
 	}
 	if (*bflags & BLIST_MS_192_BYTES_FOR_3F)
 		sdev->use_192_bytes_for_3f = 1;
 	if (*bflags & BLIST_NOT_LOCKABLE)
 		sdev->lockable = 0;
 	if (*bflags & BLIST_RETRY_HWERROR)
 		sdev->retry_hwerror = 1;
 	if (*bflags & BLIST_NO_DIF)
 		sdev->no_dif = 1;
 	sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;
 	if (*bflags & BLIST_TRY_VPD_PAGES)
 		sdev->try_vpd_pages = 1;
 	else if (*bflags & BLIST_SKIP_VPD_PAGES)
 		sdev->skip_vpd_pages = 1;
 	transport_configure_device(&sdev->sdev_gendev);
 	if (sdev->host->hostt->slave_configure) {
 		ret = sdev->host->hostt->slave_configure(sdev);
 		if (ret) {
 			/*
 			 * if LLDD reports slave not present, don't clutter
 			 * console with alloc failure messages
 			 */
 			if (ret != -ENXIO) {
 				sdev_printk(KERN_ERR, sdev,
 					"failed to configure device\n");
 			}
 			return SCSI_SCAN_NO_RESPONSE;
 		}
 	}
 	if (sdev->scsi_level >= SCSI_3)
 		scsi_attach_vpd(sdev);
 	sdev->max_queue_depth = sdev->queue_depth;
 	/*
 	 * Ok, the device is now all set up, we can
 	 * register it and tell the rest of the kernel
 	 * about it.
 	 */
 	if (!async && scsi_sysfs_add_sdev(sdev) != 0)
 		return SCSI_SCAN_NO_RESPONSE;
 	return SCSI_SCAN_LUN_PRESENT;
 }
 #ifdef CONFIG_SCSI_LOGGING
 /**
  * scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace
  * @buf:   Output buffer with at least end-first+1 bytes of space
  * @inq:   Inquiry buffer (input)
  * @first: Offset of string into inq
  * @end:   Index after last character in inq
  */
 static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,
 				   unsigned first, unsigned end)
 {
 	unsigned term = 0, idx;
 	for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {
 		if (inq[idx+first] > ' ') {
 			buf[idx] = inq[idx+first];
 			term = idx+1;
 		} else {
 			buf[idx] = ' ';
 		}
 	}
 	buf[term] = 0;
 	return buf;
 }
 #endif
 /**
  * scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it
  * @starget:	pointer to target device structure
  * @lun:	LUN of target device
  * @bflagsp:	store bflags here if not NULL
  * @sdevp:	probe the LUN corresponding to this scsi_device
  * @rescan:     if nonzero skip some code only needed on first scan
  * @hostdata:	passed to scsi_alloc_sdev()
  *
  * Description:
  *     Call scsi_probe_lun, if a LUN with an attached device is found,
  *     allocate and set it up by calling scsi_add_lun.
  *
  * Return:
  *     SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
  *     SCSI_SCAN_TARGET_PRESENT: target responded, but no device is
  *         attached at the LUN
  *     SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
  **/
 static int scsi_probe_and_add_lun(struct scsi_target *starget,
 				  u64 lun, int *bflagsp,
 				  struct scsi_device **sdevp, int rescan,
 				  void *hostdata)
 {
 	struct scsi_device *sdev;
 	unsigned char *result;
 	int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	/*
 	 * The rescan flag is used as an optimization, the first scan of a
 	 * host adapter calls into here with rescan == 0.
 	 */
 	sdev = scsi_device_lookup_by_target(starget, lun);
 	if (sdev) {
 		if (rescan || !scsi_device_created(sdev)) {
 			SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
 				"scsi scan: device exists on %s\n",
 				dev_name(&sdev->sdev_gendev)));
 			if (sdevp)
 				*sdevp = sdev;
 			else
 				scsi_device_put(sdev);
 			if (bflagsp)
 				*bflagsp = scsi_get_device_flags(sdev,
 								 sdev->vendor,
 								 sdev->model);
 			return SCSI_SCAN_LUN_PRESENT;
 		}
 		scsi_device_put(sdev);
 	} else
 		sdev = scsi_alloc_sdev(starget, lun, hostdata);
 	if (!sdev)
 		goto out;
 	result = kmalloc(result_len, GFP_ATOMIC |
 			((shost->unchecked_isa_dma) ? __GFP_DMA : 0));
 	if (!result)
 		goto out_free_sdev;
 	if (scsi_probe_lun(sdev, result, result_len, &bflags))
 		goto out_free_result;
 	if (bflagsp)
 		*bflagsp = bflags;
 	/*
 	 * result contains valid SCSI INQUIRY data.
 	 */
 	if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {
 		/*
 		 * For a Peripheral qualifier 3 (011b), the SCSI
 		 * spec says: The device server is not capable of
 		 * supporting a physical device on this logical
 		 * unit.
 		 *
 		 * For disks, this implies that there is no
 		 * logical disk configured at sdev->lun, but there
 		 * is a target id responding.
 		 */
 		SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"
 				   " peripheral qualifier of 3, device not"
 				   " added\n"))
 		if (lun == 0) {
 			SCSI_LOG_SCAN_BUS(1, {
 				unsigned char vend[9];
 				unsigned char mod[17];
 				sdev_printk(KERN_INFO, sdev,
 					"scsi scan: consider passing scsi_mod."
 					"dev_flags=%s:%s:0x240 or 0x1000240\n",
 					scsi_inq_str(vend, result, 8, 16),
 					scsi_inq_str(mod, result, 16, 32));
 			});
 		}
 		res = SCSI_SCAN_TARGET_PRESENT;
 		goto out_free_result;
 	}
 	/*
 	 * Some targets may set slight variations of PQ and PDT to signal
 	 * that no LUN is present, so don't add sdev in these cases.
 	 * Two specific examples are:
 	 * 1) NetApp targets: return PQ=1, PDT=0x1f
 	 * 2) USB UFI: returns PDT=0x1f, with the PQ bits being "reserved"
 	 *    in the UFI 1.0 spec (we cannot rely on reserved bits).
 	 *
 	 * References:
 	 * 1) SCSI SPC-3, pp. 145-146
 	 * PQ=1: "A peripheral device having the specified peripheral
 	 * device type is not connected to this logical unit. However, the
 	 * device server is capable of supporting the specified peripheral
 	 * device type on this logical unit."
 	 * PDT=0x1f: "Unknown or no device type"
 	 * 2) USB UFI 1.0, p. 20
 	 * PDT=00h Direct-access device (floppy)
 	 * PDT=1Fh none (no FDD connected to the requested logical unit)
 	 */
 	if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) &&
 	    (result[0] & 0x1f) == 0x1f &&
 	    !scsi_is_wlun(lun)) {
 		SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
 					"scsi scan: peripheral device type"
 					" of 31, no device added\n"));
 		res = SCSI_SCAN_TARGET_PRESENT;
 		goto out_free_result;
 	}
 	res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);
 	if (res == SCSI_SCAN_LUN_PRESENT) {
 		if (bflags & BLIST_KEY) {
 			sdev->lockable = 0;
 			scsi_unlock_floptical(sdev, result);
 		}
 	}
  out_free_result:
 	kfree(result);
  out_free_sdev:
 	if (res == SCSI_SCAN_LUN_PRESENT) {
 		if (sdevp) {
 			if (scsi_device_get(sdev) == 0) {
 				*sdevp = sdev;
 			} else {
 				__scsi_remove_device(sdev);
 				res = SCSI_SCAN_NO_RESPONSE;
 			}
 		}
 	} else
 		__scsi_remove_device(sdev);
  out:
 	return res;
 }
 /**
  * scsi_sequential_lun_scan - sequentially scan a SCSI target
  * @starget:	pointer to target structure to scan
  * @bflags:	black/white list flag for LUN 0
  * @scsi_level: Which version of the standard does this device adhere to
  * @rescan:     passed to scsi_probe_add_lun()
  *
  * Description:
  *     Generally, scan from LUN 1 (LUN 0 is assumed to already have been
  *     scanned) to some maximum lun until a LUN is found with no device
  *     attached. Use the bflags to figure out any oddities.
  *
  *     Modifies sdevscan->lun.
  **/
 static void scsi_sequential_lun_scan(struct scsi_target *starget,
 				     int bflags, int scsi_level, int rescan)
 {
 	uint max_dev_lun;
 	u64 sparse_lun, lun;
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	SCSI_LOG_SCAN_BUS(3, starget_printk(KERN_INFO, starget,
 		"scsi scan: Sequential scan\n"));
 	max_dev_lun = min(max_scsi_luns, shost->max_lun);
 	/*
 	 * If this device is known to support sparse multiple units,
 	 * override the other settings, and scan all of them. Normally,
 	 * SCSI-3 devices should be scanned via the REPORT LUNS.
 	 */
 	if (bflags & BLIST_SPARSELUN) {
 		max_dev_lun = shost->max_lun;
 		sparse_lun = 1;
 	} else
 		sparse_lun = 0;
 	/*
 	 * If less than SCSI_1_CCS, and no special lun scanning, stop
 	 * scanning; this matches 2.4 behaviour, but could just be a bug
 	 * (to continue scanning a SCSI_1_CCS device).
 	 *
 	 * This test is broken.  We might not have any device on lun0 for
 	 * a sparselun device, and if that's the case then how would we
 	 * know the real scsi_level, eh?  It might make sense to just not
 	 * scan any SCSI_1 device for non-0 luns, but that check would best
 	 * go into scsi_alloc_sdev() and just have it return null when asked
 	 * to alloc an sdev for lun > 0 on an already found SCSI_1 device.
 	 *
 	if ((sdevscan->scsi_level < SCSI_1_CCS) &&
 	    ((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN))
 	     == 0))
 		return;
 	 */
 	/*
 	 * If this device is known to support multiple units, override
 	 * the other settings, and scan all of them.
 	 */
 	if (bflags & BLIST_FORCELUN)
 		max_dev_lun = shost->max_lun;
 	/*
 	 * REGAL CDC-4X: avoid hang after LUN 4
 	 */
 	if (bflags & BLIST_MAX5LUN)
 		max_dev_lun = min(5U, max_dev_lun);
 	/*
 	 * Do not scan SCSI-2 or lower device past LUN 7, unless
 	 * BLIST_LARGELUN.
 	 */
 	if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN))
 		max_dev_lun = min(8U, max_dev_lun);
 	/*
 	 * Stop scanning at 255 unless BLIST_SCSI3LUN
 	 */
 	if (!(bflags & BLIST_SCSI3LUN))
 		max_dev_lun = min(256U, max_dev_lun);
 	/*
 	 * We have already scanned LUN 0, so start at LUN 1. Keep scanning
 	 * until we reach the max, or no LUN is found and we are not
 	 * sparse_lun.
 	 */
 	for (lun = 1; lun < max_dev_lun; ++lun)
 		if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan,
 					    NULL) != SCSI_SCAN_LUN_PRESENT) &&
 		    !sparse_lun)
 			return;
 }
 /**
  * scsi_report_lun_scan - Scan using SCSI REPORT LUN results
  * @starget: which target
  * @bflags: Zero or a mix of BLIST_NOLUN, BLIST_REPORTLUN2, or BLIST_NOREPORTLUN
  * @rescan: nonzero if we can skip code only needed on first scan
  *
  * Description:
  *   Fast scanning for modern (SCSI-3) devices by sending a REPORT LUN command.
  *   Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.
  *
  *   If BLINK_REPORTLUN2 is set, scan a target that supports more than 8
  *   LUNs even if it's older than SCSI-3.
  *   If BLIST_NOREPORTLUN is set, return 1 always.
  *   If BLIST_NOLUN is set, return 0 always.
  *   If starget->no_report_luns is set, return 1 always.
  *
  * Return:
  *     0: scan completed (or no memory, so further scanning is futile)
  *     1: could not scan with REPORT LUN
  **/
 static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
 				int rescan)
 {
 	char devname[64];
 	unsigned char scsi_cmd[MAX_COMMAND_SIZE];
 	unsigned int length;
 	u64 lun;
 	unsigned int num_luns;
 	unsigned int retries;
 	int result;
 	struct scsi_lun *lunp, *lun_data;
 	struct scsi_sense_hdr sshdr;
 	struct scsi_device *sdev;
 	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 	int ret = 0;
 	/*
 	 * Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set.
 	 * Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does
 	 * support more than 8 LUNs.
 	 * Don't attempt if the target doesn't support REPORT LUNS.
 	 */
 	if (bflags & BLIST_NOREPORTLUN)
 		return 1;
 	if (starget->scsi_level < SCSI_2 &&
 	    starget->scsi_level != SCSI_UNKNOWN)
 		return 1;
 	if (starget->scsi_level < SCSI_3 &&
 	    (!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))
 		return 1;
 	if (bflags & BLIST_NOLUN)
 		return 0;
 	if (starget->no_report_luns)
 		return 1;
 	if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {
 		sdev = scsi_alloc_sdev(starget, 0, NULL);
 		if (!sdev)
 			return 0;
 		if (scsi_device_get(sdev)) {
 			__scsi_remove_device(sdev);
 			return 0;
 		}
 	}
 	sprintf(devname, "host %d channel %d id %d",
 		shost->host_no, sdev->channel, sdev->id);
 	/*
 	 * Allocate enough to hold the header (the same size as one scsi_lun)
 	 * plus the number of luns we are requesting.  511 was the default
 	 * value of the now removed max_report_luns parameter.
 	 */
 	length = (511 + 1) * sizeof(struct scsi_lun);
 retry:
 	lun_data = kmalloc(length, GFP_KERNEL |
 			   (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
 	if (!lun_data) {
 		printk(ALLOC_FAILURE_MSG, __func__);
 		goto out;
 	}
 	scsi_cmd[0] = REPORT_LUNS;
 	/*
 	 * bytes 1 - 5: reserved, set to zero.
 	 */
 	memset(&scsi_cmd[1], 0, 5);
 	/*
 	 * bytes 6 - 9: length of the command.
 	 */
 	put_unaligned_be32(length, &scsi_cmd[6]);
 	scsi_cmd[10] = 0;	/* reserved */
 	scsi_cmd[11] = 0;	/* control */
 	/*
 	 * We can get a UNIT ATTENTION, for example a power on/reset, so
 	 * retry a few times (like sd.c does for TEST UNIT READY).
 	 * Experience shows some combinations of adapter/devices get at
 	 * least two power on/resets.
 	 *
 	 * Illegal requests (for devices that do not support REPORT LUNS)
 	 * should come through as a check condition, and will not generate
 	 * a retry.
 	 */
 	for (retries = 0; retries < 3; retries++) {
 		SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
 				"scsi scan: Sending REPORT LUNS to (try %d)\n",
 				retries));
 		result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
 					  lun_data, length, &sshdr,
 					  SCSI_REPORT_LUNS_TIMEOUT, 3, NULL);
 		SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
 				"scsi scan: REPORT LUNS"
 				" %s (try %d) result 0x%x\n",
 				result ?  "failed" : "successful",
 				retries, result));
 		if (result == 0)
 			break;
 		else if (scsi_sense_valid(&sshdr)) {
 			if (sshdr.sense_key != UNIT_ATTENTION)
 				break;
 		}
 	}
 	if (result) {
 		/*
 		 * The device probably does not support a REPORT LUN command
 		 */
 		ret = 1;
 		goto out_err;
 	}
 	/*
 	 * Get the length from the first four bytes of lun_data.
 	 */
 	if (get_unaligned_be32(lun_data->scsi_lun) +
 	    sizeof(struct scsi_lun) > length) {
 		length = get_unaligned_be32(lun_data->scsi_lun) +
 			 sizeof(struct scsi_lun);
 		kfree(lun_data);
 		goto retry;
 	}
 	length = get_unaligned_be32(lun_data->scsi_lun);
 	num_luns = (length / sizeof(struct scsi_lun));
 	SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
 		"scsi scan: REPORT LUN scan\n"));
 	/*
 	 * Scan the luns in lun_data. The entry at offset 0 is really
 	 * the header, so start at 1 and go up to and including num_luns.
 	 */
 	for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) {
 		lun = scsilun_to_int(lunp);
 		if (lun > sdev->host->max_lun) {
 			sdev_printk(KERN_WARNING, sdev,
 				    "lun%llu has a LUN larger than"
 				    " allowed by the host adapter\n", lun);
 		} else {
 			int res;
 			res = scsi_probe_and_add_lun(starget,
 				lun, NULL, NULL, rescan, NULL);
 			if (res == SCSI_SCAN_NO_RESPONSE) {
 				/*
 				 * Got some results, but now none, abort.
 				 */
 				sdev_printk(KERN_ERR, sdev,
 					"Unexpected response"
 					" from lun %llu while scanning, scan"
 					" aborted\n", (unsigned long long)lun);
 				break;
 			}
 		}
 	}
  out_err:
 	kfree(lun_data);
  out:
 	scsi_device_put(sdev);
 	if (scsi_device_created(sdev))
 		/*
 		 * the sdev we used didn't appear in the report luns scan
 		 */
 		__scsi_remove_device(sdev);
 	return ret;
 }
 struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
 				      uint id, u64 lun, void *hostdata)
 {
 	struct scsi_device *sdev = ERR_PTR(-ENODEV);
 	struct device *parent = &shost->shost_gendev;
 	struct scsi_target *starget;
 	if (strncmp(scsi_scan_type, "none", 4) == 0)
 		return ERR_PTR(-ENODEV);
 	starget = scsi_alloc_target(parent, channel, id);
 	if (!starget)
 		return ERR_PTR(-ENOMEM);
 	scsi_autopm_get_target(starget);
 	mutex_lock(&shost->scan_mutex);
 	if (!shost->async_scan)
 		scsi_complete_async_scans();
 	if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
 		scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
 		scsi_autopm_put_host(shost);
 	}
 	mutex_unlock(&shost->scan_mutex);
 	scsi_autopm_put_target(starget);
 	/*
 	 * paired with scsi_alloc_target().  Target will be destroyed unless
 	 * scsi_probe_and_add_lun made an underlying device visible
 	 */
 	scsi_target_reap(starget);
 	put_device(&starget->dev);
 	return sdev;
 }
 EXPORT_SYMBOL(__scsi_add_device);
 int scsi_add_device(struct Scsi_Host *host, uint channel,
 		    uint target, u64 lun)
 {
 	struct scsi_device *sdev =
 		__scsi_add_device(host, channel, target, lun, NULL);
 	if (IS_ERR(sdev))
 		return PTR_ERR(sdev);
 	scsi_device_put(sdev);
 	return 0;
 }
 EXPORT_SYMBOL(scsi_add_device);
 void scsi_rescan_device(struct device *dev)
 {
 	device_lock(dev);
 	if (dev->driver && try_module_get(dev->driver->owner)) {
 		struct scsi_driver *drv = to_scsi_driver(dev->driver);
 		if (drv->rescan)
 			drv->rescan(dev);
 		module_put(dev->driver->owner);
 	}
 	device_unlock(dev);
 }
 EXPORT_SYMBOL(scsi_rescan_device);
 static void __scsi_scan_target(struct device *parent, unsigned int channel,
 		unsigned int id, u64 lun, int rescan)
 {
 	struct Scsi_Host *shost = dev_to_shost(parent);
 	int bflags = 0;
 	int res;
 	struct scsi_target *starget;
 	if (shost->this_id == id)
 		/*
 		 * Don't scan the host adapter
 		 */
 		return;
 	starget = scsi_alloc_target(parent, channel, id);
 	if (!starget)
 		return;
 	scsi_autopm_get_target(starget);
 	if (lun != SCAN_WILD_CARD) {
 		/*
 		 * Scan for a specific host/chan/id/lun.
 		 */
 		scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);
 		goto out_reap;
 	}
 	/*
 	 * Scan LUN 0, if there is some response, scan further. Ideally, we
 	 * would not configure LUN 0 until all LUNs are scanned.
 	 */
 	res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);
 	if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {
 		if (scsi_report_lun_scan(starget, bflags, rescan) != 0)
 			/*
 			 * The REPORT LUN did not scan the target,
 			 * do a sequential scan.
 			 */
 			scsi_sequential_lun_scan(starget, bflags,
 						 starget->scsi_level, rescan);
 	}
  out_reap:
 	scsi_autopm_put_target(starget);
 	/*
 	 * paired with scsi_alloc_target(): determine if the target has
 	 * any children at all and if not, nuke it
 	 */
 	scsi_target_reap(starget);
 	put_device(&starget->dev);
 }
 /**
  * scsi_scan_target - scan a target id, possibly including all LUNs on the target.
  * @parent:	host to scan
  * @channel:	channel to scan
  * @id:		target id to scan
  * @lun:	Specific LUN to scan or SCAN_WILD_CARD
  * @rescan:	passed to LUN scanning routines
  *
  * Description:
  *     Scan the target id on @parent, @channel, and @id. Scan at least LUN 0,
  *     and possibly all LUNs on the target id.
  *
  *     First try a REPORT LUN scan, if that does not scan the target, do a
  *     sequential scan of LUNs on the target id.
  **/
 void scsi_scan_target(struct device *parent, unsigned int channel,
 		      unsigned int id, u64 lun, int rescan)
 {
 	struct Scsi_Host *shost = dev_to_shost(parent);
 	if (strncmp(scsi_scan_type, "none", 4) == 0)
 		return;
 	mutex_lock(&shost->scan_mutex);
 	if (!shost->async_scan)
 		scsi_complete_async_scans();
 	if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
 		__scsi_scan_target(parent, channel, id, lun, rescan);
 		scsi_autopm_put_host(shost);
 	}
 	mutex_unlock(&shost->scan_mutex);
 }
 EXPORT_SYMBOL(scsi_scan_target);
 static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,
 			      unsigned int id, u64 lun, int rescan)
 {
 	uint order_id;
 	if (id == SCAN_WILD_CARD)
 		for (id = 0; id < shost->max_id; ++id) {
 			/*
 			 * XXX adapter drivers when possible (FCP, iSCSI)
 			 * could modify max_id to match the current max,
 			 * not the absolute max.
 			 *
 			 * XXX add a shost id iterator, so for example,
 			 * the FC ID can be the same as a target id
 			 * without a huge overhead of sparse id's.
 			 */
 			if (shost->reverse_ordering)
 				/*
 				 * Scan from high to low id.
 				 */
 				order_id = shost->max_id - id - 1;
 			else
 				order_id = id;
 			__scsi_scan_target(&shost->shost_gendev, channel,
 					order_id, lun, rescan);
 		}
 	else
 		__scsi_scan_target(&shost->shost_gendev, channel,
 				id, lun, rescan);
 }
 int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
 			    unsigned int id, u64 lun, int rescan)
 {
 	SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
 		"%s: <%u:%u:%llu>\n",
 		__func__, channel, id, lun));
 	if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
 	    ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
 	    ((lun != SCAN_WILD_CARD) && (lun >= shost->max_lun)))
 		return -EINVAL;
 	mutex_lock(&shost->scan_mutex);
 	if (!shost->async_scan)
 		scsi_complete_async_scans();
 	if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
 		if (channel == SCAN_WILD_CARD)
 			for (channel = 0; channel <= shost->max_channel;
 			     channel++)
 				scsi_scan_channel(shost, channel, id, lun,
 						  rescan);
 		else
 			scsi_scan_channel(shost, channel, id, lun, rescan);
 		scsi_autopm_put_host(shost);
 	}
 	mutex_unlock(&shost->scan_mutex);
 	return 0;
 }
 static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
 {
 	struct scsi_device *sdev;
 	shost_for_each_device(sdev, shost) {
 		/* target removed before the device could be added */
 		if (sdev->sdev_state == SDEV_DEL)
 			continue;
 		/* If device is already visible, skip adding it to sysfs */
 		if (sdev->is_visible)
 			continue;
 		if (!scsi_host_scan_allowed(shost) ||
 		    scsi_sysfs_add_sdev(sdev) != 0)
 			__scsi_remove_device(sdev);
 	}
 }
 /**
  * scsi_prep_async_scan - prepare for an async scan
  * @shost: the host which will be scanned
  * Returns: a cookie to be passed to scsi_finish_async_scan()
  *
  * Tells the midlayer this host is going to do an asynchronous scan.
  * It reserves the host's position in the scanning list and ensures
  * that other asynchronous scans started after this one won't affect the
  * ordering of the discovered devices.
  */
 static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)
 {
 	struct async_scan_data *data;
 	unsigned long flags;
 	if (strncmp(scsi_scan_type, "sync", 4) == 0)
 		return NULL;
 	if (shost->async_scan) {
 		shost_printk(KERN_DEBUG, shost, "%s called twice\n", __func__);
 		return NULL;
 	}
 	data = kmalloc(sizeof(*data), GFP_KERNEL);
 	if (!data)
 		goto err;
 	data->shost = scsi_host_get(shost);
 	if (!data->shost)
 		goto err;
 	init_completion(&data->prev_finished);
 	mutex_lock(&shost->scan_mutex);
 	spin_lock_irqsave(shost->host_lock, flags);
 	shost->async_scan = 1;
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	mutex_unlock(&shost->scan_mutex);
 	spin_lock(&async_scan_lock);
 	if (list_empty(&scanning_hosts))
 		complete(&data->prev_finished);
 	list_add_tail(&data->list, &scanning_hosts);
 	spin_unlock(&async_scan_lock);
 	return data;
  err:
 	kfree(data);
 	return NULL;
 }
 /**
  * scsi_finish_async_scan - asynchronous scan has finished
  * @data: cookie returned from earlier call to scsi_prep_async_scan()
  *
  * All the devices currently attached to this host have been found.
  * This function announces all the devices it has found to the rest
  * of the system.
  */
 static void scsi_finish_async_scan(struct async_scan_data *data)
 {
 	struct Scsi_Host *shost;
 	unsigned long flags;
 	if (!data)
 		return;
 	shost = data->shost;
 	mutex_lock(&shost->scan_mutex);
 	if (!shost->async_scan) {
 		shost_printk(KERN_INFO, shost, "%s called twice\n", __func__);
 		dump_stack();
 		mutex_unlock(&shost->scan_mutex);
 		return;
 	}
 	wait_for_completion(&data->prev_finished);
 	scsi_sysfs_add_devices(shost);
 	spin_lock_irqsave(shost->host_lock, flags);
 	shost->async_scan = 0;
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	mutex_unlock(&shost->scan_mutex);
 	spin_lock(&async_scan_lock);
 	list_del(&data->list);
 	if (!list_empty(&scanning_hosts)) {
 		struct async_scan_data *next = list_entry(scanning_hosts.next,
 				struct async_scan_data, list);
 		complete(&next->prev_finished);
 	}
 	spin_unlock(&async_scan_lock);
 	scsi_autopm_put_host(shost);
 	scsi_host_put(shost);
 	kfree(data);
 }
 static void do_scsi_scan_host(struct Scsi_Host *shost)
 {
 	if (shost->hostt->scan_finished) {
 		unsigned long start = jiffies;
 		if (shost->hostt->scan_start)
 			shost->hostt->scan_start(shost);
 		while (!shost->hostt->scan_finished(shost, jiffies - start))
 			msleep(10);
 	} else {
 		scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,
 				SCAN_WILD_CARD, 0);
 	}
 }
 static void do_scan_async(void *_data, async_cookie_t c)
 {
 	struct async_scan_data *data = _data;
 	struct Scsi_Host *shost = data->shost;
 	do_scsi_scan_host(shost);
 	scsi_finish_async_scan(data);
 }
 /**
  * scsi_scan_host - scan the given adapter
  * @shost:	adapter to scan
  **/
 void scsi_scan_host(struct Scsi_Host *shost)
 {
 	struct async_scan_data *data;
 	if (strncmp(scsi_scan_type, "none", 4) == 0)
 		return;
 	if (scsi_autopm_get_host(shost) < 0)
 		return;
 	data = scsi_prep_async_scan(shost);
 	if (!data) {
 		do_scsi_scan_host(shost);
 		scsi_autopm_put_host(shost);
 		return;
 	}
 	/* register with the async subsystem so wait_for_device_probe()
 	 * will flush this work
 	 */
 	async_schedule(do_scan_async, data);
 	/* scsi_autopm_put_host(shost) is called in scsi_finish_async_scan() */
 }
 EXPORT_SYMBOL(scsi_scan_host);
 void scsi_forget_host(struct Scsi_Host *shost)
 {
 	struct scsi_device *sdev;
 	unsigned long flags;
  restart:
 	spin_lock_irqsave(shost->host_lock, flags);
 	list_for_each_entry(sdev, &shost->__devices, siblings) {
 		if (sdev->sdev_state == SDEV_DEL)
 			continue;
 		spin_unlock_irqrestore(shost->host_lock, flags);
 		__scsi_remove_device(sdev);
 		goto restart;
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 }
 /**
  * scsi_get_host_dev - Create a scsi_device that points to the host adapter itself
  * @shost: Host that needs a scsi_device
  *
  * Lock status: None assumed.
  *
  * Returns:     The scsi_device or NULL
  *
  * Notes:
  *	Attach a single scsi_device to the Scsi_Host - this should
  *	be made to look like a "pseudo-device" that points to the
  *	HA itself.
  *
  *	Note - this device is not accessible from any high-level
  *	drivers (including generics), which is probably not
  *	optimal.  We can add hooks later to attach.
  */
 struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
 {
 	struct scsi_device *sdev = NULL;
 	struct scsi_target *starget;
 	mutex_lock(&shost->scan_mutex);
 	if (!scsi_host_scan_allowed(shost))
 		goto out;
 	starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
 	if (!starget)
 		goto out;
 	sdev = scsi_alloc_sdev(starget, 0, NULL);
 	if (sdev)
 		sdev->borken = 0;
 	else
 		scsi_target_reap(starget);
 	put_device(&starget->dev);
  out:
 	mutex_unlock(&shost->scan_mutex);
 	return sdev;
 }
 EXPORT_SYMBOL(scsi_get_host_dev);
 /**
  * scsi_free_host_dev - Free a scsi_device that points to the host adapter itself
  * @sdev: Host device to be freed
  *
  * Lock status: None assumed.
  *
  * Returns:     Nothing
  */
 void scsi_free_host_dev(struct scsi_device *sdev)
 {
 	BUG_ON(sdev->id != sdev->host->this_id);
 	__scsi_remove_device(sdev);
 }
 EXPORT_SYMBOL(scsi_free_host_dev);

 /*
  * scsi_sysfs.c
  *
  * SCSI sysfs interface routines.
  *
  * Created to pull SCSI mid layer sysfs routines into one file.
  */
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/device.h>
 #include <linux/pm_runtime.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_driver.h>
 #include "scsi_priv.h"
 #include "scsi_logging.h"
 static struct device_type scsi_dev_type;
 static const struct {
 	enum scsi_device_state	value;
 	char			*name;
 } sdev_states[] = {
 	{ SDEV_CREATED, "created" },
 	{ SDEV_RUNNING, "running" },
 	{ SDEV_CANCEL, "cancel" },
 	{ SDEV_DEL, "deleted" },
 	{ SDEV_QUIESCE, "quiesce" },
 	{ SDEV_OFFLINE,	"offline" },
 	{ SDEV_TRANSPORT_OFFLINE, "transport-offline" },
 	{ SDEV_BLOCK,	"blocked" },
 	{ SDEV_CREATED_BLOCK, "created-blocked" },
 };
 const char *scsi_device_state_name(enum scsi_device_state state)
 {
 	int i;
 	char *name = NULL;
 	for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
 		if (sdev_states[i].value == state) {
 			name = sdev_states[i].name;
 			break;
 		}
 	}
 	return name;
 }
 static const struct {
 	enum scsi_host_state	value;
 	char			*name;
 } shost_states[] = {
 	{ SHOST_CREATED, "created" },
 	{ SHOST_RUNNING, "running" },
 	{ SHOST_CANCEL, "cancel" },
 	{ SHOST_DEL, "deleted" },
 	{ SHOST_RECOVERY, "recovery" },
 	{ SHOST_CANCEL_RECOVERY, "cancel/recovery" },
 	{ SHOST_DEL_RECOVERY, "deleted/recovery", },
 };
 const char *scsi_host_state_name(enum scsi_host_state state)
 {
 	int i;
 	char *name = NULL;
 	for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
 		if (shost_states[i].value == state) {
 			name = shost_states[i].name;
 			break;
 		}
 	}
 	return name;
 }
 static int check_set(unsigned long long *val, char *src)
 {
 	char *last;
 	if (strncmp(src, "-", 20) == 0) {
 		*val = SCAN_WILD_CARD;
 	} else {
 		/*
 		 * Doesn't check for int overflow
 		 */
 		*val = simple_strtoull(src, &last, 0);
 		if (*last != '\0')
 			return 1;
 	}
 	return 0;
 }
 static int scsi_scan(struct Scsi_Host *shost, const char *str)
 {
 	char s1[15], s2[15], s3[17], junk;
 	unsigned long long channel, id, lun;
 	int res;
 	res = sscanf(str, "%10s %10s %16s %c", s1, s2, s3, &junk);
 	if (res != 3)
 		return -EINVAL;
 	if (check_set(&channel, s1))
 		return -EINVAL;
 	if (check_set(&id, s2))
 		return -EINVAL;
 	if (check_set(&lun, s3))
 		return -EINVAL;
 	if (shost->transportt->user_scan)
 		res = shost->transportt->user_scan(shost, channel, id, lun);
 	else
 		res = scsi_scan_host_selected(shost, channel, id, lun, 1);
 	return res;
 }
 /*
  * shost_show_function: macro to create an attr function that can be used to
  * show a non-bit field.
  */
 #define shost_show_function(name, field, format_string)			\
 static ssize_t								\
 show_##name (struct device *dev, struct device_attribute *attr, 	\
 	     char *buf)							\
 {									\
 	struct Scsi_Host *shost = class_to_shost(dev);			\
 	return snprintf (buf, 20, format_string, shost->field);		\
 }
 /*
  * shost_rd_attr: macro to create a function and attribute variable for a
  * read only field.
  */
 #define shost_rd_attr2(name, field, format_string)			\
 	shost_show_function(name, field, format_string)			\
 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
 #define shost_rd_attr(field, format_string) \
 shost_rd_attr2(field, field, format_string)
 /*
  * Create the actual show/store functions and data structures.
  */
 static ssize_t
 store_scan(struct device *dev, struct device_attribute *attr,
 	   const char *buf, size_t count)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	int res;
 	res = scsi_scan(shost, buf);
 	if (res == 0)
 		res = count;
 	return res;
 };
 static DEVICE_ATTR(scan, S_IWUSR, NULL, store_scan);
 static ssize_t
 store_shost_state(struct device *dev, struct device_attribute *attr,
 		  const char *buf, size_t count)
 {
 	int i;
 	struct Scsi_Host *shost = class_to_shost(dev);
 	enum scsi_host_state state = 0;
 	for (i = 0; i < ARRAY_SIZE(shost_states); i++) {
 		const int len = strlen(shost_states[i].name);
 		if (strncmp(shost_states[i].name, buf, len) == 0 &&
 		   buf[len] == '\n') {
 			state = shost_states[i].value;
 			break;
 		}
 	}
 	if (!state)
 		return -EINVAL;
 	if (scsi_host_set_state(shost, state))
 		return -EINVAL;
 	return count;
 }
 static ssize_t
 show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	const char *name = scsi_host_state_name(shost->shost_state);
 	if (!name)
 		return -EINVAL;
 	return snprintf(buf, 20, "%s\n", name);
 }
 /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
 struct device_attribute dev_attr_hstate =
 	__ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
 static ssize_t
 show_shost_mode(unsigned int mode, char *buf)
 {
 	ssize_t len = 0;
 	if (mode & MODE_INITIATOR)
 		len = sprintf(buf, "%s", "Initiator");
 	if (mode & MODE_TARGET)
 		len += sprintf(buf + len, "%s%s", len ? ", " : "", "Target");
 	len += sprintf(buf + len, "\n");
 	return len;
 }
 static ssize_t
 show_shost_supported_mode(struct device *dev, struct device_attribute *attr,
 			  char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	unsigned int supported_mode = shost->hostt->supported_mode;
 	if (supported_mode == MODE_UNKNOWN)
 		/* by default this should be initiator */
 		supported_mode = MODE_INITIATOR;
 	return show_shost_mode(supported_mode, buf);
 }
 static DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
 static ssize_t
 show_shost_active_mode(struct device *dev,
 		       struct device_attribute *attr, char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	if (shost->active_mode == MODE_UNKNOWN)
 		return snprintf(buf, 20, "unknown\n");
 	else
 		return show_shost_mode(shost->active_mode, buf);
 }
 static DEVICE_ATTR(active_mode, S_IRUGO | S_IWUSR, show_shost_active_mode, NULL);
 static int check_reset_type(const char *str)
 {
 	if (sysfs_streq(str, "adapter"))
 		return SCSI_ADAPTER_RESET;
 	else if (sysfs_streq(str, "firmware"))
 		return SCSI_FIRMWARE_RESET;
 	else
 		return 0;
 }
 static ssize_t
 store_host_reset(struct device *dev, struct device_attribute *attr,
 		const char *buf, size_t count)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	struct scsi_host_template *sht = shost->hostt;
 	int ret = -EINVAL;
 	int type;
 	type = check_reset_type(buf);
 	if (!type)
 		goto exit_store_host_reset;
 	if (sht->host_reset)
 		ret = sht->host_reset(shost, type);
 exit_store_host_reset:
 	if (ret == 0)
 		ret = count;
 	return ret;
 }
 static DEVICE_ATTR(host_reset, S_IWUSR, NULL, store_host_reset);
 static ssize_t
 show_shost_eh_deadline(struct device *dev,
 		      struct device_attribute *attr, char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	if (shost->eh_deadline == -1)
 		return snprintf(buf, strlen("off") + 2, "off\n");
 	return sprintf(buf, "%u\n", shost->eh_deadline / HZ);
 }
 static ssize_t
 store_shost_eh_deadline(struct device *dev, struct device_attribute *attr,
 		const char *buf, size_t count)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	int ret = -EINVAL;
 	unsigned long deadline, flags;
 	if (shost->transportt &&
 	    (shost->transportt->eh_strategy_handler ||
 	     !shost->hostt->eh_host_reset_handler))
 		return ret;
 	if (!strncmp(buf, "off", strlen("off")))
 		deadline = -1;
 	else {
 		ret = kstrtoul(buf, 10, &deadline);
 		if (ret)
 			return ret;
 		if (deadline * HZ > UINT_MAX)
 			return -EINVAL;
 	}
 	spin_lock_irqsave(shost->host_lock, flags);
 	if (scsi_host_in_recovery(shost))
 		ret = -EBUSY;
 	else {
 		if (deadline == -1)
 			shost->eh_deadline = -1;
 		else
 			shost->eh_deadline = deadline * HZ;
 		ret = count;
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	return ret;
 }
 static DEVICE_ATTR(eh_deadline, S_IRUGO | S_IWUSR, show_shost_eh_deadline, store_shost_eh_deadline);
 shost_rd_attr(use_blk_mq, "%d\n");
 shost_rd_attr(unique_id, "%u\n");
 shost_rd_attr(cmd_per_lun, "%hd\n");
 shost_rd_attr(can_queue, "%hd\n");
 shost_rd_attr(sg_tablesize, "%hu\n");
 shost_rd_attr(sg_prot_tablesize, "%hu\n");
 shost_rd_attr(unchecked_isa_dma, "%d\n");
 shost_rd_attr(prot_capabilities, "%u\n");
 shost_rd_attr(prot_guard_type, "%hd\n");
 shost_rd_attr2(proc_name, hostt->proc_name, "%s\n");
 static ssize_t
 show_host_busy(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct Scsi_Host *shost = class_to_shost(dev);
 	return snprintf(buf, 20, "%d\n", atomic_read(&shost->host_busy));
 }
 static DEVICE_ATTR(host_busy, S_IRUGO, show_host_busy, NULL);
 static struct attribute *scsi_sysfs_shost_attrs[] = {
 	&dev_attr_use_blk_mq.attr,
 	&dev_attr_unique_id.attr,
 	&dev_attr_host_busy.attr,
 	&dev_attr_cmd_per_lun.attr,
 	&dev_attr_can_queue.attr,
 	&dev_attr_sg_tablesize.attr,
 	&dev_attr_sg_prot_tablesize.attr,
 	&dev_attr_unchecked_isa_dma.attr,
 	&dev_attr_proc_name.attr,
 	&dev_attr_scan.attr,
 	&dev_attr_hstate.attr,
 	&dev_attr_supported_mode.attr,
 	&dev_attr_active_mode.attr,
 	&dev_attr_prot_capabilities.attr,
 	&dev_attr_prot_guard_type.attr,
 	&dev_attr_host_reset.attr,
 	&dev_attr_eh_deadline.attr,
 	NULL
 };
 struct attribute_group scsi_shost_attr_group = {
 	.attrs =	scsi_sysfs_shost_attrs,
 };
 const struct attribute_group *scsi_sysfs_shost_attr_groups[] = {
 	&scsi_shost_attr_group,
 	NULL
 };
 static void scsi_device_cls_release(struct device *class_dev)
 {
 	struct scsi_device *sdev;
 	sdev = class_to_sdev(class_dev);
 	put_device(&sdev->sdev_gendev);
 }
 static void scsi_device_dev_release_usercontext(struct work_struct *work)
 {
 	struct scsi_device *sdev;
 	struct device *parent;
 	struct list_head *this, *tmp;
 	unsigned long flags;
 	sdev = container_of(work, struct scsi_device, ew.work);
 	scsi_dh_release_device(sdev);
 	parent = sdev->sdev_gendev.parent;
 	spin_lock_irqsave(sdev->host->host_lock, flags);
 	list_del(&sdev->siblings);
 	list_del(&sdev->same_target_siblings);
 	list_del(&sdev->starved_entry);
 	spin_unlock_irqrestore(sdev->host->host_lock, flags);
 	cancel_work_sync(&sdev->event_work);
 	list_for_each_safe(this, tmp, &sdev->event_list) {
 		struct scsi_event *evt;
 		evt = list_entry(this, struct scsi_event, node);
 		list_del(&evt->node);
 		kfree(evt);
 	}
 	blk_put_queue(sdev->request_queue);
 	/* NULL queue means the device can't be used */
 	sdev->request_queue = NULL;
 	kfree(sdev->vpd_pg83);
 	kfree(sdev->vpd_pg80);
 	kfree(sdev->inquiry);
 	kfree(sdev);
 	if (parent)
 		put_device(parent);
 }
 static void scsi_device_dev_release(struct device *dev)
 {
 	struct scsi_device *sdp = to_scsi_device(dev);
 	execute_in_process_context(scsi_device_dev_release_usercontext,
 				   &sdp->ew);
 }
 static struct class sdev_class = {
 	.name		= "scsi_device",
 	.dev_release	= scsi_device_cls_release,
 };
 /* all probing is done in the individual ->probe routines */
 static int scsi_bus_match(struct device *dev, struct device_driver *gendrv)
 {
 	struct scsi_device *sdp;
 	if (dev->type != &scsi_dev_type)
 		return 0;
 	sdp = to_scsi_device(dev);
 	if (sdp->no_uld_attach)
 		return 0;
 	return (sdp->inq_periph_qual == SCSI_INQ_PQ_CON)? 1: 0;
 }
 static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
 	struct scsi_device *sdev;
 	if (dev->type != &scsi_dev_type)
 		return 0;
 	sdev = to_scsi_device(dev);
 	add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type);
 	return 0;
 }
 struct bus_type scsi_bus_type = {
         .name		= "scsi",
         .match		= scsi_bus_match,
 	.uevent		= scsi_bus_uevent,
 #ifdef CONFIG_PM
 	.pm		= &scsi_bus_pm_ops,
 #endif
 };
 EXPORT_SYMBOL_GPL(scsi_bus_type);
 int scsi_sysfs_register(void)
 {
 	int error;
 	error = bus_register(&scsi_bus_type);
 	if (!error) {
 		error = class_register(&sdev_class);
 		if (error)
 			bus_unregister(&scsi_bus_type);
 	}
 	return error;
 }
 void scsi_sysfs_unregister(void)
 {
 	class_unregister(&sdev_class);
 	bus_unregister(&scsi_bus_type);
 }
 /*
  * sdev_show_function: macro to create an attr function that can be used to
  * show a non-bit field.
  */
 #define sdev_show_function(field, format_string)				\
 static ssize_t								\
 sdev_show_##field (struct device *dev, struct device_attribute *attr,	\
 		   char *buf)						\
 {									\
 	struct scsi_device *sdev;					\
 	sdev = to_scsi_device(dev);					\
 	return snprintf (buf, 20, format_string, sdev->field);		\
 }									\
 /*
  * sdev_rd_attr: macro to create a function and attribute variable for a
  * read only field.
  */
 #define sdev_rd_attr(field, format_string)				\
 	sdev_show_function(field, format_string)			\
 static DEVICE_ATTR(field, S_IRUGO, sdev_show_##field, NULL);
 /*
  * sdev_rw_attr: create a function and attribute variable for a
  * read/write field.
  */
 #define sdev_rw_attr(field, format_string)				\
 	sdev_show_function(field, format_string)				\
 									\
 static ssize_t								\
 sdev_store_##field (struct device *dev, struct device_attribute *attr,	\
 		    const char *buf, size_t count)			\
 {									\
 	struct scsi_device *sdev;					\
 	sdev = to_scsi_device(dev);					\
 	sscanf (buf, format_string, &sdev->field);			\
 	return count;							\
 }									\
 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
 /* Currently we don't export bit fields, but we might in future,
  * so leave this code in */
 #if 0
 /*
  * sdev_rd_attr: create a function and attribute variable for a
  * read/write bit field.
  */
 #define sdev_rw_attr_bit(field)						\
 	sdev_show_function(field, "%d\n")					\
 									\
 static ssize_t								\
 sdev_store_##field (struct device *dev, struct device_attribute *attr,	\
 		    const char *buf, size_t count)			\
 {									\
 	int ret;							\
 	struct scsi_device *sdev;					\
 	ret = scsi_sdev_check_buf_bit(buf);				\
 	if (ret >= 0)	{						\
 		sdev = to_scsi_device(dev);				\
 		sdev->field = ret;					\
 		ret = count;						\
 	}								\
 	return ret;							\
 }									\
 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, sdev_show_##field, sdev_store_##field);
 /*
  * scsi_sdev_check_buf_bit: return 0 if buf is "0", return 1 if buf is "1",
  * else return -EINVAL.
  */
 static int scsi_sdev_check_buf_bit(const char *buf)
 {
 	if ((buf[1] == '\0') || ((buf[1] == '\n') && (buf[2] == '\0'))) {
 		if (buf[0] == '1')
 			return 1;
 		else if (buf[0] == '0')
 			return 0;
 		else
 			return -EINVAL;
 	} else
 		return -EINVAL;
 }
 #endif
 /*
  * Create the actual show/store functions and data structures.
  */
 sdev_rd_attr (type, "%d\n");
 sdev_rd_attr (scsi_level, "%d\n");
 sdev_rd_attr (vendor, "%.8s\n");
 sdev_rd_attr (model, "%.16s\n");
 sdev_rd_attr (rev, "%.4s\n");
 static ssize_t
 sdev_show_device_busy(struct device *dev, struct device_attribute *attr,
 		char *buf)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_busy));
 }
 static DEVICE_ATTR(device_busy, S_IRUGO, sdev_show_device_busy, NULL);
 static ssize_t
 sdev_show_device_blocked(struct device *dev, struct device_attribute *attr,
 		char *buf)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	return snprintf(buf, 20, "%d\n", atomic_read(&sdev->device_blocked));
 }
 static DEVICE_ATTR(device_blocked, S_IRUGO, sdev_show_device_blocked, NULL);
 /*
  * TODO: can we make these symlinks to the block layer ones?
  */
 static ssize_t
 sdev_show_timeout (struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct scsi_device *sdev;
 	sdev = to_scsi_device(dev);
 	return snprintf(buf, 20, "%d\n", sdev->request_queue->rq_timeout / HZ);
 }
 static ssize_t
 sdev_store_timeout (struct device *dev, struct device_attribute *attr,
 		    const char *buf, size_t count)
 {
 	struct scsi_device *sdev;
 	int timeout;
 	sdev = to_scsi_device(dev);
 	sscanf (buf, "%d\n", &timeout);
 	blk_queue_rq_timeout(sdev->request_queue, timeout * HZ);
 	return count;
 }
 static DEVICE_ATTR(timeout, S_IRUGO | S_IWUSR, sdev_show_timeout, sdev_store_timeout);
 static ssize_t
 sdev_show_eh_timeout(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct scsi_device *sdev;
 	sdev = to_scsi_device(dev);
 	return snprintf(buf, 20, "%u\n", sdev->eh_timeout / HZ);
 }
 static ssize_t
 sdev_store_eh_timeout(struct device *dev, struct device_attribute *attr,
 		    const char *buf, size_t count)
 {
 	struct scsi_device *sdev;
 	unsigned int eh_timeout;
 	int err;
 	if (!capable(CAP_SYS_ADMIN))
 		return -EACCES;
 	sdev = to_scsi_device(dev);
 	err = kstrtouint(buf, 10, &eh_timeout);
 	if (err)
 		return err;
 	sdev->eh_timeout = eh_timeout * HZ;
 	return count;
 }
 static DEVICE_ATTR(eh_timeout, S_IRUGO | S_IWUSR, sdev_show_eh_timeout, sdev_store_eh_timeout);
 static ssize_t
 store_rescan_field (struct device *dev, struct device_attribute *attr,
 		    const char *buf, size_t count)
 {
 	scsi_rescan_device(dev);
 	return count;
 }
 static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);
 static ssize_t
 sdev_store_delete(struct device *dev, struct device_attribute *attr,
 		  const char *buf, size_t count)
 {
 	if (device_remove_file_self(dev, attr))
 		scsi_remove_device(to_scsi_device(dev));
 	return count;
 };
 static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);
 static ssize_t
 store_state_field(struct device *dev, struct device_attribute *attr,
 		  const char *buf, size_t count)
 {
 	int i;
 	struct scsi_device *sdev = to_scsi_device(dev);
 	enum scsi_device_state state = 0;
 	for (i = 0; i < ARRAY_SIZE(sdev_states); i++) {
 		const int len = strlen(sdev_states[i].name);
 		if (strncmp(sdev_states[i].name, buf, len) == 0 &&
 		   buf[len] == '\n') {
 			state = sdev_states[i].value;
 			break;
 		}
 	}
 	if (!state)
 		return -EINVAL;
 	if (scsi_device_set_state(sdev, state))
 		return -EINVAL;
 	return count;
 }
 static ssize_t
 show_state_field(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	const char *name = scsi_device_state_name(sdev->sdev_state);
 	if (!name)
 		return -EINVAL;
 	return snprintf(buf, 20, "%s\n", name);
 }
 static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, show_state_field, store_state_field);
 static ssize_t
 show_queue_type_field(struct device *dev, struct device_attribute *attr,
 		      char *buf)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	const char *name = "none";
 	if (sdev->simple_tags)
 		name = "simple";
 	return snprintf(buf, 20, "%s\n", name);
 }
 static ssize_t
 store_queue_type_field(struct device *dev, struct device_attribute *attr,
 		       const char *buf, size_t count)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	if (!sdev->tagged_supported)
 		return -EINVAL;
 	sdev_printk(KERN_INFO, sdev,
 		    "ignoring write to deprecated queue_type attribute");
 	return count;
 }
 static DEVICE_ATTR(queue_type, S_IRUGO | S_IWUSR, show_queue_type_field,
 		   store_queue_type_field);
 #define sdev_vpd_pg_attr(_page)						\
 static ssize_t							\
 show_vpd_##_page(struct file *filp, struct kobject *kobj,	\
 		 struct bin_attribute *bin_attr,			\
 		 char *buf, loff_t off, size_t count)			\
 {									\
 	struct device *dev = container_of(kobj, struct device, kobj);	\
 	struct scsi_device *sdev = to_scsi_device(dev);			\
 	if (!sdev->vpd_##_page)						\
 		return -EINVAL;						\
 	return memory_read_from_buffer(buf, count, &off,		\
 				       sdev->vpd_##_page,		\
 				       sdev->vpd_##_page##_len);	\
 }									\
 static struct bin_attribute dev_attr_vpd_##_page = {		\
 	.attr =	{.name = __stringify(vpd_##_page), .mode = S_IRUGO },	\
 	.size = 0,							\
 	.read = show_vpd_##_page,					\
 };
 sdev_vpd_pg_attr(pg83);
 sdev_vpd_pg_attr(pg80);
 static ssize_t show_inquiry(struct file *filep, struct kobject *kobj,
 			    struct bin_attribute *bin_attr,
 			    char *buf, loff_t off, size_t count)
 {
 	struct device *dev = container_of(kobj, struct device, kobj);
 	struct scsi_device *sdev = to_scsi_device(dev);
 	if (!sdev->inquiry)
 		return -EINVAL;
 	return memory_read_from_buffer(buf, count, &off, sdev->inquiry,
 				       sdev->inquiry_len);
 }
 static struct bin_attribute dev_attr_inquiry = {
 	.attr = {
 		.name = "inquiry",
 		.mode = S_IRUGO,
 	},
 	.size = 0,
 	.read = show_inquiry,
 };
 static ssize_t
 show_iostat_counterbits(struct device *dev, struct device_attribute *attr,
 			char *buf)
 {
 	return snprintf(buf, 20, "%d\n", (int)sizeof(atomic_t) * 8);
 }
 static DEVICE_ATTR(iocounterbits, S_IRUGO, show_iostat_counterbits, NULL);
 #define show_sdev_iostat(field)						\
 static ssize_t								\
 show_iostat_##field(struct device *dev, struct device_attribute *attr,	\
 		    char *buf)						\
 {									\
 	struct scsi_device *sdev = to_scsi_device(dev);			\
 	unsigned long long count = atomic_read(&sdev->field);		\
 	return snprintf(buf, 20, "0x%llx\n", count);			\
 }									\
 static DEVICE_ATTR(field, S_IRUGO, show_iostat_##field, NULL)
 show_sdev_iostat(iorequest_cnt);
 show_sdev_iostat(iodone_cnt);
 show_sdev_iostat(ioerr_cnt);
 static ssize_t
 sdev_show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct scsi_device *sdev;
 	sdev = to_scsi_device(dev);
 	return snprintf (buf, 20, SCSI_DEVICE_MODALIAS_FMT "\n", sdev->type);
 }
 static DEVICE_ATTR(modalias, S_IRUGO, sdev_show_modalias, NULL);
 #define DECLARE_EVT_SHOW(name, Cap_name)				\
 static ssize_t								\
 sdev_show_evt_##name(struct device *dev, struct device_attribute *attr,	\
 		     char *buf)						\
 {									\
 	struct scsi_device *sdev = to_scsi_device(dev);			\
 	int val = test_bit(SDEV_EVT_##Cap_name, sdev->supported_events);\
 	return snprintf(buf, 20, "%d\n", val);				\
 }
 #define DECLARE_EVT_STORE(name, Cap_name)				\
 static ssize_t								\
 sdev_store_evt_##name(struct device *dev, struct device_attribute *attr,\
 		      const char *buf, size_t count)			\
 {									\
 	struct scsi_device *sdev = to_scsi_device(dev);			\
 	int val = simple_strtoul(buf, NULL, 0);				\
 	if (val == 0)							\
 		clear_bit(SDEV_EVT_##Cap_name, sdev->supported_events);	\
 	else if (val == 1)						\
 		set_bit(SDEV_EVT_##Cap_name, sdev->supported_events);	\
 	else								\
 		return -EINVAL;						\
 	return count;							\
 }
 #define DECLARE_EVT(name, Cap_name)					\
 	DECLARE_EVT_SHOW(name, Cap_name)				\
 	DECLARE_EVT_STORE(name, Cap_name)				\
 	static DEVICE_ATTR(evt_##name, S_IRUGO, sdev_show_evt_##name,	\
 			   sdev_store_evt_##name);
 #define REF_EVT(name) &dev_attr_evt_##name.attr
 DECLARE_EVT(media_change, MEDIA_CHANGE)
 DECLARE_EVT(inquiry_change_reported, INQUIRY_CHANGE_REPORTED)
 DECLARE_EVT(capacity_change_reported, CAPACITY_CHANGE_REPORTED)
 DECLARE_EVT(soft_threshold_reached, SOFT_THRESHOLD_REACHED_REPORTED)
 DECLARE_EVT(mode_parameter_change_reported, MODE_PARAMETER_CHANGE_REPORTED)
 DECLARE_EVT(lun_change_reported, LUN_CHANGE_REPORTED)
 static ssize_t
 sdev_store_queue_depth(struct device *dev, struct device_attribute *attr,
 		       const char *buf, size_t count)
 {
 	int depth, retval;
 	struct scsi_device *sdev = to_scsi_device(dev);
 	struct scsi_host_template *sht = sdev->host->hostt;
 	if (!sht->change_queue_depth)
 		return -EINVAL;
 	depth = simple_strtoul(buf, NULL, 0);
 	if (depth < 1 || depth > sdev->host->can_queue)
 		return -EINVAL;
 	retval = sht->change_queue_depth(sdev, depth);
 	if (retval < 0)
 		return retval;
 	sdev->max_queue_depth = sdev->queue_depth;
 	return count;
 }
 sdev_show_function(queue_depth, "%d\n");
 static DEVICE_ATTR(queue_depth, S_IRUGO | S_IWUSR, sdev_show_queue_depth,
 		   sdev_store_queue_depth);
 static ssize_t
 sdev_show_queue_ramp_up_period(struct device *dev,
 			       struct device_attribute *attr,
 			       char *buf)
 {
 	struct scsi_device *sdev;
 	sdev = to_scsi_device(dev);
 	return snprintf(buf, 20, "%u\n",
 			jiffies_to_msecs(sdev->queue_ramp_up_period));
 }
 static ssize_t
 sdev_store_queue_ramp_up_period(struct device *dev,
 				struct device_attribute *attr,
 				const char *buf, size_t count)
 {
 	struct scsi_device *sdev = to_scsi_device(dev);
 	unsigned int period;
 	if (kstrtouint(buf, 10, &period))
 		return -EINVAL;
 	sdev->queue_ramp_up_period = msecs_to_jiffies(period);
 	return count;
 }
 static DEVICE_ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,
 		   sdev_show_queue_ramp_up_period,
 		   sdev_store_queue_ramp_up_period);
 static umode_t scsi_sdev_attr_is_visible(struct kobject *kobj,
 					 struct attribute *attr, int i)
 {
 	struct device *dev = container_of(kobj, struct device, kobj);
 	struct scsi_device *sdev = to_scsi_device(dev);
 	if (attr == &dev_attr_queue_depth.attr &&
 	    !sdev->host->hostt->change_queue_depth)
 		return S_IRUGO;
 	if (attr == &dev_attr_queue_ramp_up_period.attr &&
 	    !sdev->host->hostt->change_queue_depth)
 		return 0;
 	return attr->mode;
 }
 /* Default template for device attributes.  May NOT be modified */
 static struct attribute *scsi_sdev_attrs[] = {
 	&dev_attr_device_blocked.attr,
 	&dev_attr_type.attr,
 	&dev_attr_scsi_level.attr,
 	&dev_attr_device_busy.attr,
 	&dev_attr_vendor.attr,
 	&dev_attr_model.attr,
 	&dev_attr_rev.attr,
 	&dev_attr_rescan.attr,
 	&dev_attr_delete.attr,
 	&dev_attr_state.attr,
 	&dev_attr_timeout.attr,
 	&dev_attr_eh_timeout.attr,
 	&dev_attr_iocounterbits.attr,
 	&dev_attr_iorequest_cnt.attr,
 	&dev_attr_iodone_cnt.attr,
 	&dev_attr_ioerr_cnt.attr,
 	&dev_attr_modalias.attr,
 	&dev_attr_queue_depth.attr,
 	&dev_attr_queue_type.attr,
 	&dev_attr_queue_ramp_up_period.attr,
 	REF_EVT(media_change),
 	REF_EVT(inquiry_change_reported),
 	REF_EVT(capacity_change_reported),
 	REF_EVT(soft_threshold_reached),
 	REF_EVT(mode_parameter_change_reported),
 	REF_EVT(lun_change_reported),
 	NULL
 };
 static struct bin_attribute *scsi_sdev_bin_attrs[] = {
 	&dev_attr_vpd_pg83,
 	&dev_attr_vpd_pg80,
 	&dev_attr_inquiry,
 	NULL
 };
 static struct attribute_group scsi_sdev_attr_group = {
 	.attrs =	scsi_sdev_attrs,
 	.bin_attrs =	scsi_sdev_bin_attrs,
 	.is_visible =	scsi_sdev_attr_is_visible,
 };
 static const struct attribute_group *scsi_sdev_attr_groups[] = {
 	&scsi_sdev_attr_group,
 	NULL
 };
 static int scsi_target_add(struct scsi_target *starget)
 {
 	int error;
 	if (starget->state != STARGET_CREATED)
 		return 0;
 	error = device_add(&starget->dev);
 	if (error) {
 		dev_err(&starget->dev, "target device_add failed, error %d\n", error);
 		return error;
 	}
 	transport_add_device(&starget->dev);
 	starget->state = STARGET_RUNNING;
 	pm_runtime_set_active(&starget->dev);
 	pm_runtime_enable(&starget->dev);
 	device_enable_async_suspend(&starget->dev);
 	return 0;
 }
 /**
  * scsi_sysfs_add_sdev - add scsi device to sysfs
  * @sdev:	scsi_device to add
  *
  * Return value:
  * 	0 on Success / non-zero on Failure
  **/
 int scsi_sysfs_add_sdev(struct scsi_device *sdev)
 {
 	int error, i;
 	struct request_queue *rq = sdev->request_queue;
 	struct scsi_target *starget = sdev->sdev_target;
 	error = scsi_device_set_state(sdev, SDEV_RUNNING);
 	if (error)
 		return error;
 	error = scsi_target_add(starget);
 	if (error)
 		return error;
 	transport_configure_device(&starget->dev);
 	device_enable_async_suspend(&sdev->sdev_gendev);
 	scsi_autopm_get_target(starget);
 	pm_runtime_set_active(&sdev->sdev_gendev);
 	pm_runtime_forbid(&sdev->sdev_gendev);
 	pm_runtime_enable(&sdev->sdev_gendev);
 	scsi_autopm_put_target(starget);
 	scsi_autopm_get_device(sdev);
 	error = device_add(&sdev->sdev_gendev);
 	if (error) {
 		sdev_printk(KERN_INFO, sdev,
 				"failed to add device: %d\n", error);
 		return error;
 	}
 	error = scsi_dh_add_device(sdev);
 	if (error) {
 		sdev_printk(KERN_INFO, sdev,
 				"failed to add device handler: %d\n", error);
 		return error;
 	}
 	device_enable_async_suspend(&sdev->sdev_dev);
 	error = device_add(&sdev->sdev_dev);
 	if (error) {
 		sdev_printk(KERN_INFO, sdev,
 				"failed to add class device: %d\n", error);
 		scsi_dh_remove_device(sdev);
 		device_del(&sdev->sdev_gendev);
 		return error;
 	}
 	transport_add_device(&sdev->sdev_gendev);
 	sdev->is_visible = 1;
 	error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
 	if (error)
 		/* we're treating error on bsg register as non-fatal,
 		 * so pretend nothing went wrong */
 		sdev_printk(KERN_INFO, sdev,
 			    "Failed to register bsg queue, errno=%d\n", error);
 	/* add additional host specific attributes */
 	if (sdev->host->hostt->sdev_attrs) {
 		for (i = 0; sdev->host->hostt->sdev_attrs[i]; i++) {
 			error = device_create_file(&sdev->sdev_gendev,
 					sdev->host->hostt->sdev_attrs[i]);
 			if (error)
 				return error;
 		}
 	}
 	scsi_autopm_put_device(sdev);
 	return error;
 }
 void __scsi_remove_device(struct scsi_device *sdev)
 {
 	struct device *dev = &sdev->sdev_gendev;
 	/*
 	 * This cleanup path is not reentrant and while it is impossible
 	 * to get a new reference with scsi_device_get() someone can still
 	 * hold a previously acquired one.
 	 */
 	if (sdev->sdev_state == SDEV_DEL)
 		return;
 	if (sdev->is_visible) {
 		if (scsi_device_set_state(sdev, SDEV_CANCEL) != 0)
 			return;
 		bsg_unregister_queue(sdev->request_queue);
 		device_unregister(&sdev->sdev_dev);
 		transport_remove_device(dev);
 		scsi_dh_remove_device(sdev);
 		device_del(dev);
 	} else
 		put_device(&sdev->sdev_dev);
 	/*
 	 * Stop accepting new requests and wait until all queuecommand() and
 	 * scsi_run_queue() invocations have finished before tearing down the
 	 * device.
 	 */
 	scsi_device_set_state(sdev, SDEV_DEL);
 	blk_cleanup_queue(sdev->request_queue);
 	cancel_work_sync(&sdev->requeue_work);
 	if (sdev->host->hostt->slave_destroy)
 		sdev->host->hostt->slave_destroy(sdev);
 	transport_destroy_device(dev);
 	/*
 	 * Paired with the kref_get() in scsi_sysfs_initialize().  We have
 	 * remoed sysfs visibility from the device, so make the target
 	 * invisible if this was the last device underneath it.
 	 */
 	scsi_target_reap(scsi_target(sdev));
 	put_device(dev);
 }
 /**
  * scsi_remove_device - unregister a device from the scsi bus
  * @sdev:	scsi_device to unregister
  **/
 void scsi_remove_device(struct scsi_device *sdev)
 {
 	struct Scsi_Host *shost = sdev->host;
 	mutex_lock(&shost->scan_mutex);
 	__scsi_remove_device(sdev);
 	mutex_unlock(&shost->scan_mutex);
 }
 EXPORT_SYMBOL(scsi_remove_device);
 static void __scsi_remove_target(struct scsi_target *starget)
 {
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	unsigned long flags;
 	struct scsi_device *sdev;
 	spin_lock_irqsave(shost->host_lock, flags);
  restart:
 	list_for_each_entry(sdev, &shost->__devices, siblings) {
 		if (sdev->channel != starget->channel ||
 		    sdev->id != starget->id ||
 		    scsi_device_get(sdev))
 			continue;
 		spin_unlock_irqrestore(shost->host_lock, flags);
 		scsi_remove_device(sdev);
 		scsi_device_put(sdev);
 		spin_lock_irqsave(shost->host_lock, flags);
 		goto restart;
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 }
 /**
  * scsi_remove_target - try to remove a target and all its devices
  * @dev: generic starget or parent of generic stargets to be removed
  *
  * Note: This is slightly racy.  It is possible that if the user
  * requests the addition of another device then the target won't be
  * removed.
  */
 void scsi_remove_target(struct device *dev)
 {
 	struct Scsi_Host *shost = dev_to_shost(dev->parent);
 	struct scsi_target *starget, *last_target = NULL;
 	unsigned long flags;
 restart:
 	spin_lock_irqsave(shost->host_lock, flags);
 	list_for_each_entry(starget, &shost->__targets, siblings) {
 		if (starget->state == STARGET_DEL ||
+		    starget->state == STARGET_REMOVE ||
 		    starget == last_target)
 			continue;
 		if (starget->dev.parent == dev || &starget->dev == dev) {
 			kref_get(&starget->reap_ref);
 			last_target = starget;
+			starget->state = STARGET_REMOVE;
 			spin_unlock_irqrestore(shost->host_lock, flags);
 			__scsi_remove_target(starget);
 			scsi_target_reap(starget);
 			goto restart;
 		}
 	}
 	spin_unlock_irqrestore(shost->host_lock, flags);
 }
 EXPORT_SYMBOL(scsi_remove_target);
 int scsi_register_driver(struct device_driver *drv)
 {
 	drv->bus = &scsi_bus_type;
 	return driver_register(drv);
 }
 EXPORT_SYMBOL(scsi_register_driver);
 int scsi_register_interface(struct class_interface *intf)
 {
 	intf->class = &sdev_class;
 	return class_interface_register(intf);
 }
 EXPORT_SYMBOL(scsi_register_interface);
 /**
  * scsi_sysfs_add_host - add scsi host to subsystem
  * @shost:     scsi host struct to add to subsystem
  **/
 int scsi_sysfs_add_host(struct Scsi_Host *shost)
 {
 	int error, i;
 	/* add host specific attributes */
 	if (shost->hostt->shost_attrs) {
 		for (i = 0; shost->hostt->shost_attrs[i]; i++) {
 			error = device_create_file(&shost->shost_dev,
 					shost->hostt->shost_attrs[i]);
 			if (error)
 				return error;
 		}
 	}
 	transport_register_device(&shost->shost_gendev);
 	transport_configure_device(&shost->shost_gendev);
 	return 0;
 }
 static struct device_type scsi_dev_type = {
 	.name =		"scsi_device",
 	.release =	scsi_device_dev_release,
 	.groups =	scsi_sdev_attr_groups,
 };
 void scsi_sysfs_device_initialize(struct scsi_device *sdev)
 {
 	unsigned long flags;
 	struct Scsi_Host *shost = sdev->host;
 	struct scsi_target  *starget = sdev->sdev_target;
 	device_initialize(&sdev->sdev_gendev);
 	sdev->sdev_gendev.bus = &scsi_bus_type;
 	sdev->sdev_gendev.type = &scsi_dev_type;
 	dev_set_name(&sdev->sdev_gendev, "%d:%d:%d:%llu",
 		     sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
 	device_initialize(&sdev->sdev_dev);
 	sdev->sdev_dev.parent = get_device(&sdev->sdev_gendev);
 	sdev->sdev_dev.class = &sdev_class;
 	dev_set_name(&sdev->sdev_dev, "%d:%d:%d:%llu",
 		     sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
 	/*
 	 * Get a default scsi_level from the target (derived from sibling
 	 * devices).  This is the best we can do for guessing how to set
 	 * sdev->lun_in_cdb for the initial INQUIRY command.  For LUN 0 the
 	 * setting doesn't matter, because all the bits are zero anyway.
 	 * But it does matter for higher LUNs.
 	 */
 	sdev->scsi_level = starget->scsi_level;
 	if (sdev->scsi_level <= SCSI_2 &&
 			sdev->scsi_level != SCSI_UNKNOWN &&
 			!shost->no_scsi2_lun_in_cdb)
 		sdev->lun_in_cdb = 1;
 	transport_setup_device(&sdev->sdev_gendev);
 	spin_lock_irqsave(shost->host_lock, flags);
 	list_add_tail(&sdev->same_target_siblings, &starget->devices);
 	list_add_tail(&sdev->siblings, &shost->__devices);
 	spin_unlock_irqrestore(shost->host_lock, flags);
 	/*
 	 * device can now only be removed via __scsi_remove_device() so hold
 	 * the target.  Target will be held in CREATED state until something
 	 * beneath it becomes visible (in which case it moves to RUNNING)
 	 */
 	kref_get(&starget->reap_ref);
 }
 int scsi_is_sdev_device(const struct device *dev)
 {
 	return dev->type == &scsi_dev_type;
 }
 EXPORT_SYMBOL(scsi_is_sdev_device);
 /* A blank transport template that is used in drivers that don't
  * yet implement Transport Attributes */
 struct scsi_transport_template blank_transport_template = { { { {NULL, }, }, }, };

 #ifndef _SCSI_SCSI_DEVICE_H
 #define _SCSI_SCSI_DEVICE_H
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
 #include <linux/blkdev.h>
 #include <scsi/scsi.h>
 #include <linux/atomic.h>
 struct device;
 struct request_queue;
 struct scsi_cmnd;
 struct scsi_lun;
 struct scsi_sense_hdr;
 struct scsi_mode_data {
 	__u32	length;
 	__u16	block_descriptor_length;
 	__u8	medium_type;
 	__u8	device_specific;
 	__u8	header_length;
 	__u8	longlba:1;
 };
 /*
  * sdev state: If you alter this, you also need to alter scsi_sysfs.c
  * (for the ascii descriptions) and the state model enforcer:
  * scsi_lib:scsi_device_set_state().
  */
 enum scsi_device_state {
 	SDEV_CREATED = 1,	/* device created but not added to sysfs
 				 * Only internal commands allowed (for inq) */
 	SDEV_RUNNING,		/* device properly configured
 				 * All commands allowed */
 	SDEV_CANCEL,		/* beginning to delete device
 				 * Only error handler commands allowed */
 	SDEV_DEL,		/* device deleted
 				 * no commands allowed */
 	SDEV_QUIESCE,		/* Device quiescent.  No block commands
 				 * will be accepted, only specials (which
 				 * originate in the mid-layer) */
 	SDEV_OFFLINE,		/* Device offlined (by error handling or
 				 * user request */
 	SDEV_TRANSPORT_OFFLINE,	/* Offlined by transport class error handler */
 	SDEV_BLOCK,		/* Device blocked by scsi lld.  No
 				 * scsi commands from user or midlayer
 				 * should be issued to the scsi
 				 * lld. */
 	SDEV_CREATED_BLOCK,	/* same as above but for created devices */
 };
 enum scsi_device_event {
 	SDEV_EVT_MEDIA_CHANGE	= 1,	/* media has changed */
 	SDEV_EVT_INQUIRY_CHANGE_REPORTED,		/* 3F 03  UA reported */
 	SDEV_EVT_CAPACITY_CHANGE_REPORTED,		/* 2A 09  UA reported */
 	SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED,	/* 38 07  UA reported */
 	SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED,	/* 2A 01  UA reported */
 	SDEV_EVT_LUN_CHANGE_REPORTED,			/* 3F 0E  UA reported */
 	SDEV_EVT_ALUA_STATE_CHANGE_REPORTED,		/* 2A 06  UA reported */
 	SDEV_EVT_FIRST		= SDEV_EVT_MEDIA_CHANGE,
 	SDEV_EVT_LAST		= SDEV_EVT_ALUA_STATE_CHANGE_REPORTED,
 	SDEV_EVT_MAXBITS	= SDEV_EVT_LAST + 1
 };
 struct scsi_event {
 	enum scsi_device_event	evt_type;
 	struct list_head	node;
 	/* put union of data structures, for non-simple event types,
 	 * here
 	 */
 };
 struct scsi_device {
 	struct Scsi_Host *host;
 	struct request_queue *request_queue;
 	/* the next two are protected by the host->host_lock */
 	struct list_head    siblings;   /* list of all devices on this host */
 	struct list_head    same_target_siblings; /* just the devices sharing same target id */
 	atomic_t device_busy;		/* commands actually active on LLDD */
 	atomic_t device_blocked;	/* Device returned QUEUE_FULL. */
 	spinlock_t list_lock;
 	struct list_head cmd_list;	/* queue of in use SCSI Command structures */
 	struct list_head starved_entry;
 	struct scsi_cmnd *current_cmnd;	/* currently active command */
 	unsigned short queue_depth;	/* How deep of a queue we want */
 	unsigned short max_queue_depth;	/* max queue depth */
 	unsigned short last_queue_full_depth; /* These two are used by */
 	unsigned short last_queue_full_count; /* scsi_track_queue_full() */
 	unsigned long last_queue_full_time;	/* last queue full time */
 	unsigned long queue_ramp_up_period;	/* ramp up period in jiffies */
 #define SCSI_DEFAULT_RAMP_UP_PERIOD	(120 * HZ)
 	unsigned long last_queue_ramp_up;	/* last queue ramp up time */
 	unsigned int id, channel;
 	u64 lun;
 	unsigned int manufacturer;	/* Manufacturer of device, for using
 					 * vendor-specific cmd's */
 	unsigned sector_size;	/* size in bytes */
 	void *hostdata;		/* available to low-level driver */
 	char type;
 	char scsi_level;
 	char inq_periph_qual;	/* PQ from INQUIRY data */
 	unsigned char inquiry_len;	/* valid bytes in 'inquiry' */
 	unsigned char * inquiry;	/* INQUIRY response data */
 	const char * vendor;		/* [back_compat] point into 'inquiry' ... */
 	const char * model;		/* ... after scan; point to static string */
 	const char * rev;		/* ... "nullnullnullnull" before scan */
 #define SCSI_VPD_PG_LEN                255
 	int vpd_pg83_len;
 	unsigned char *vpd_pg83;
 	int vpd_pg80_len;
 	unsigned char *vpd_pg80;
 	unsigned char current_tag;	/* current tag */
 	struct scsi_target      *sdev_target;   /* used only for single_lun */
 	unsigned int	sdev_bflags; /* black/white flags as also found in
 				 * scsi_devinfo.[hc]. For now used only to
 				 * pass settings from slave_alloc to scsi
 				 * core. */
 	unsigned int eh_timeout; /* Error handling timeout */
 	unsigned removable:1;
 	unsigned changed:1;	/* Data invalid due to media change */
 	unsigned busy:1;	/* Used to prevent races */
 	unsigned lockable:1;	/* Able to prevent media removal */
 	unsigned locked:1;      /* Media removal disabled */
 	unsigned borken:1;	/* Tell the Seagate driver to be
 				 * painfully slow on this device */
 	unsigned disconnect:1;	/* can disconnect */
 	unsigned soft_reset:1;	/* Uses soft reset option */
 	unsigned sdtr:1;	/* Device supports SDTR messages */
 	unsigned wdtr:1;	/* Device supports WDTR messages */
 	unsigned ppr:1;		/* Device supports PPR messages */
 	unsigned tagged_supported:1;	/* Supports SCSI-II tagged queuing */
 	unsigned simple_tags:1;	/* simple queue tag messages are enabled */
 	unsigned was_reset:1;	/* There was a bus reset on the bus for
 				 * this device */
 	unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN
 				     * because we did a bus reset. */
 	unsigned use_10_for_rw:1; /* first try 10-byte read / write */
 	unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
 	unsigned no_report_opcodes:1;	/* no REPORT SUPPORTED OPERATION CODES */
 	unsigned no_write_same:1;	/* no WRITE SAME command */
 	unsigned use_16_for_rw:1; /* Use read/write(16) over read/write(10) */
 	unsigned skip_ms_page_8:1;	/* do not use MODE SENSE page 0x08 */
 	unsigned skip_ms_page_3f:1;	/* do not use MODE SENSE page 0x3f */
 	unsigned skip_vpd_pages:1;	/* do not read VPD pages */
 	unsigned try_vpd_pages:1;	/* attempt to read VPD pages */
 	unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
 	unsigned no_start_on_add:1;	/* do not issue start on add */
 	unsigned allow_restart:1; /* issue START_UNIT in error handler */
 	unsigned manage_start_stop:1;	/* Let HLD (sd) manage start/stop */
 	unsigned start_stop_pwr_cond:1;	/* Set power cond. in START_STOP_UNIT */
 	unsigned no_uld_attach:1; /* disable connecting to upper level drivers */
 	unsigned select_no_atn:1;
 	unsigned fix_capacity:1;	/* READ_CAPACITY is too high by 1 */
 	unsigned guess_capacity:1;	/* READ_CAPACITY might be too high by 1 */
 	unsigned retry_hwerror:1;	/* Retry HARDWARE_ERROR */
 	unsigned last_sector_bug:1;	/* do not use multisector accesses on
 					   SD_LAST_BUGGY_SECTORS */
 	unsigned no_read_disc_info:1;	/* Avoid READ_DISC_INFO cmds */
 	unsigned no_read_capacity_16:1; /* Avoid READ_CAPACITY_16 cmds */
 	unsigned try_rc_10_first:1;	/* Try READ_CAPACACITY_10 first */
 	unsigned is_visible:1;	/* is the device visible in sysfs */
 	unsigned wce_default_on:1;	/* Cache is ON by default */
 	unsigned no_dif:1;	/* T10 PI (DIF) should be disabled */
 	unsigned broken_fua:1;		/* Don't set FUA bit */
 	unsigned lun_in_cdb:1;		/* Store LUN bits in CDB[1] */
 	atomic_t disk_events_disable_depth; /* disable depth for disk events */
 	DECLARE_BITMAP(supported_events, SDEV_EVT_MAXBITS); /* supported events */
 	DECLARE_BITMAP(pending_events, SDEV_EVT_MAXBITS); /* pending events */
 	struct list_head event_list;	/* asserted events */
 	struct work_struct event_work;
 	unsigned int max_device_blocked; /* what device_blocked counts down from  */
 #define SCSI_DEFAULT_DEVICE_BLOCKED	3
 	atomic_t iorequest_cnt;
 	atomic_t iodone_cnt;
 	atomic_t ioerr_cnt;
 	struct device		sdev_gendev,
 				sdev_dev;
 	struct execute_work	ew; /* used to get process context on put */
 	struct work_struct	requeue_work;
 	struct scsi_device_handler *handler;
 	void			*handler_data;
 	enum scsi_device_state sdev_state;
 	unsigned long		sdev_data[0];
 } __attribute__((aligned(sizeof(unsigned long))));
 #define	to_scsi_device(d)	\
 	container_of(d, struct scsi_device, sdev_gendev)
 #define	class_to_sdev(d)	\
 	container_of(d, struct scsi_device, sdev_dev)
 #define transport_class_to_sdev(class_dev) \
 	to_scsi_device(class_dev->parent)
 #define sdev_dbg(sdev, fmt, a...) \
 	dev_dbg(&(sdev)->sdev_gendev, fmt, ##a)
 /*
  * like scmd_printk, but the device name is passed in
  * as a string pointer
  */
 __printf(4, 5) void
 sdev_prefix_printk(const char *, const struct scsi_device *, const char *,
 		const char *, ...);
 #define sdev_printk(l, sdev, fmt, a...)				\
 	sdev_prefix_printk(l, sdev, NULL, fmt, ##a)
 __printf(3, 4) void
 scmd_printk(const char *, const struct scsi_cmnd *, const char *, ...);
 #define scmd_dbg(scmd, fmt, a...)					   \
 	do {								   \
 		if ((scmd)->request->rq_disk)				   \
 			sdev_dbg((scmd)->device, "[%s] " fmt,		   \
 				 (scmd)->request->rq_disk->disk_name, ##a);\
 		else							   \
 			sdev_dbg((scmd)->device, fmt, ##a);		   \
 	} while (0)
 enum scsi_target_state {
 	STARGET_CREATED = 1,
 	STARGET_RUNNING,
+	STARGET_REMOVE,
 	STARGET_DEL,
 };
 /*
  * scsi_target: representation of a scsi target, for now, this is only
  * used for single_lun devices. If no one has active IO to the target,
  * starget_sdev_user is NULL, else it points to the active sdev.
  */
 struct scsi_target {
 	struct scsi_device	*starget_sdev_user;
 	struct list_head	siblings;
 	struct list_head	devices;
 	struct device		dev;
 	struct kref		reap_ref; /* last put renders target invisible */
 	unsigned int		channel;
 	unsigned int		id; /* target id ... replace
 				     * scsi_device.id eventually */
 	unsigned int		create:1; /* signal that it needs to be added */
 	unsigned int		single_lun:1;	/* Indicates we should only
 						 * allow I/O to one of the luns
 						 * for the device at a time. */
 	unsigned int		pdt_1f_for_no_lun:1;	/* PDT = 0x1f
 						 * means no lun present. */
 	unsigned int		no_report_luns:1;	/* Don't use
 						 * REPORT LUNS for scanning. */
 	unsigned int		expecting_lun_change:1;	/* A device has reported
 						 * a 3F/0E UA, other devices on
 						 * the same target will also. */
 	/* commands actually active on LLD. */
 	atomic_t		target_busy;
 	atomic_t		target_blocked;
 	/*
 	 * LLDs should set this in the slave_alloc host template callout.
 	 * If set to zero then there is not limit.
 	 */
 	unsigned int		can_queue;
 	unsigned int		max_target_blocked;
 #define SCSI_DEFAULT_TARGET_BLOCKED	3
 	char			scsi_level;
 	enum scsi_target_state	state;
 	void 			*hostdata; /* available to low-level driver */
 	unsigned long		starget_data[0]; /* for the transport */
 	/* starget_data must be the last element!!!! */
 } __attribute__((aligned(sizeof(unsigned long))));
 #define to_scsi_target(d)	container_of(d, struct scsi_target, dev)
 static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
 {
 	return to_scsi_target(sdev->sdev_gendev.parent);
 }
 #define transport_class_to_starget(class_dev) \
 	to_scsi_target(class_dev->parent)
 #define starget_printk(prefix, starget, fmt, a...)	\
 	dev_printk(prefix, &(starget)->dev, fmt, ##a)
 extern struct scsi_device *__scsi_add_device(struct Scsi_Host *,
 		uint, uint, u64, void *hostdata);
 extern int scsi_add_device(struct Scsi_Host *host, uint channel,
 			   uint target, u64 lun);
 extern int scsi_register_device_handler(struct scsi_device_handler *scsi_dh);
 extern void scsi_remove_device(struct scsi_device *);
 extern int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh);
 void scsi_attach_vpd(struct scsi_device *sdev);
 extern int scsi_device_get(struct scsi_device *);
 extern void scsi_device_put(struct scsi_device *);
 extern struct scsi_device *scsi_device_lookup(struct Scsi_Host *,
 					      uint, uint, u64);
 extern struct scsi_device *__scsi_device_lookup(struct Scsi_Host *,
 						uint, uint, u64);
 extern struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *,
 							u64);
 extern struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *,
 							  u64);
 extern void starget_for_each_device(struct scsi_target *, void *,
 		     void (*fn)(struct scsi_device *, void *));
 extern void __starget_for_each_device(struct scsi_target *, void *,
 				      void (*fn)(struct scsi_device *,
 						 void *));
 /* only exposed to implement shost_for_each_device */
 extern struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *,
 						  struct scsi_device *);
 /**
  * shost_for_each_device - iterate over all devices of a host
  * @sdev: the &struct scsi_device to use as a cursor
  * @shost: the &struct scsi_host to iterate over
  *
  * Iterator that returns each device attached to @shost.  This loop
  * takes a reference on each device and releases it at the end.  If
  * you break out of the loop, you must call scsi_device_put(sdev).
  */
 #define shost_for_each_device(sdev, shost) \
 	for ((sdev) = __scsi_iterate_devices((shost), NULL); \
 	     (sdev); \
 	     (sdev) = __scsi_iterate_devices((shost), (sdev)))
 /**
  * __shost_for_each_device - iterate over all devices of a host (UNLOCKED)
  * @sdev: the &struct scsi_device to use as a cursor
  * @shost: the &struct scsi_host to iterate over
  *
  * Iterator that returns each device attached to @shost.  It does _not_
  * take a reference on the scsi_device, so the whole loop must be
  * protected by shost->host_lock.
  *
  * Note: The only reason to use this is because you need to access the
  * device list in interrupt context.  Otherwise you really want to use
  * shost_for_each_device instead.
  */
 #define __shost_for_each_device(sdev, shost) \
 	list_for_each_entry((sdev), &((shost)->__devices), siblings)
 extern int scsi_change_queue_depth(struct scsi_device *, int);
 extern int scsi_track_queue_full(struct scsi_device *, int);
 extern int scsi_set_medium_removal(struct scsi_device *, char);
 extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
 			   unsigned char *buffer, int len, int timeout,
 			   int retries, struct scsi_mode_data *data,
 			   struct scsi_sense_hdr *);
 extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
 			    int modepage, unsigned char *buffer, int len,
 			    int timeout, int retries,
 			    struct scsi_mode_data *data,
 			    struct scsi_sense_hdr *);
 extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
 				int retries, struct scsi_sense_hdr *sshdr);
 extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf,
 			     int buf_len);
 extern int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
 			      unsigned int len, unsigned char opcode);
 extern int scsi_device_set_state(struct scsi_device *sdev,
 				 enum scsi_device_state state);
 extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
 					  gfp_t gfpflags);
 extern void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt);
 extern void sdev_evt_send_simple(struct scsi_device *sdev,
 			  enum scsi_device_event evt_type, gfp_t gfpflags);
 extern int scsi_device_quiesce(struct scsi_device *sdev);
 extern void scsi_device_resume(struct scsi_device *sdev);
 extern void scsi_target_quiesce(struct scsi_target *);
 extern void scsi_target_resume(struct scsi_target *);
 extern void scsi_scan_target(struct device *parent, unsigned int channel,
 			     unsigned int id, u64 lun, int rescan);
 extern void scsi_target_reap(struct scsi_target *);
 extern void scsi_target_block(struct device *);
 extern void scsi_target_unblock(struct device *, enum scsi_device_state);
 extern void scsi_remove_target(struct device *);
 extern const char *scsi_device_state_name(enum scsi_device_state);
 extern int scsi_is_sdev_device(const struct device *);
 extern int scsi_is_target_device(const struct device *);
 extern int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
 			int data_direction, void *buffer, unsigned bufflen,
 			unsigned char *sense, int timeout, int retries,
 			u64 flags, int *resid);
 extern int scsi_execute_req_flags(struct scsi_device *sdev,
 	const unsigned char *cmd, int data_direction, void *buffer,
 	unsigned bufflen, struct scsi_sense_hdr *sshdr, int timeout,
 	int retries, int *resid, u64 flags);
 static inline int scsi_execute_req(struct scsi_device *sdev,
 	const unsigned char *cmd, int data_direction, void *buffer,
 	unsigned bufflen, struct scsi_sense_hdr *sshdr, int timeout,
 	int retries, int *resid)
 {
 	return scsi_execute_req_flags(sdev, cmd, data_direction, buffer,
 		bufflen, sshdr, timeout, retries, resid, 0);
 }
 extern void sdev_disable_disk_events(struct scsi_device *sdev);
 extern void sdev_enable_disk_events(struct scsi_device *sdev);
 #ifdef CONFIG_PM
 extern int scsi_autopm_get_device(struct scsi_device *);
 extern void scsi_autopm_put_device(struct scsi_device *);
 #else
 static inline int scsi_autopm_get_device(struct scsi_device *d) { return 0; }
 static inline void scsi_autopm_put_device(struct scsi_device *d) {}
 #endif /* CONFIG_PM */
 static inline int __must_check scsi_device_reprobe(struct scsi_device *sdev)
 {
 	return device_reprobe(&sdev->sdev_gendev);
 }
 static inline unsigned int sdev_channel(struct scsi_device *sdev)
 {
 	return sdev->channel;
 }
 static inline unsigned int sdev_id(struct scsi_device *sdev)
 {
 	return sdev->id;
 }
 #define scmd_id(scmd) sdev_id((scmd)->device)
 #define scmd_channel(scmd) sdev_channel((scmd)->device)
 /*
  * checks for positions of the SCSI state machine
  */
 static inline int scsi_device_online(struct scsi_device *sdev)
 {
 	return (sdev->sdev_state != SDEV_OFFLINE &&
 		sdev->sdev_state != SDEV_TRANSPORT_OFFLINE &&
 		sdev->sdev_state != SDEV_DEL);
 }
 static inline int scsi_device_blocked(struct scsi_device *sdev)
 {
 	return sdev->sdev_state == SDEV_BLOCK ||
 		sdev->sdev_state == SDEV_CREATED_BLOCK;
 }
 static inline int scsi_device_created(struct scsi_device *sdev)
 {
 	return sdev->sdev_state == SDEV_CREATED ||
 		sdev->sdev_state == SDEV_CREATED_BLOCK;
 }
 /* accessor functions for the SCSI parameters */
 static inline int scsi_device_sync(struct scsi_device *sdev)
 {
 	return sdev->sdtr;
 }
 static inline int scsi_device_wide(struct scsi_device *sdev)
 {
 	return sdev->wdtr;
 }
 static inline int scsi_device_dt(struct scsi_device *sdev)
 {
 	return sdev->ppr;
 }
 static inline int scsi_device_dt_only(struct scsi_device *sdev)
 {
 	if (sdev->inquiry_len < 57)
 		return 0;
 	return (sdev->inquiry[56] & 0x0c) == 0x04;
 }
 static inline int scsi_device_ius(struct scsi_device *sdev)
 {
 	if (sdev->inquiry_len < 57)
 		return 0;
 	return sdev->inquiry[56] & 0x01;
 }
 static inline int scsi_device_qas(struct scsi_device *sdev)
 {
 	if (sdev->inquiry_len < 57)
 		return 0;
 	return sdev->inquiry[56] & 0x02;
 }
 static inline int scsi_device_enclosure(struct scsi_device *sdev)
 {
 	return sdev->inquiry ? (sdev->inquiry[6] & (1<<6)) : 1;
 }
 static inline int scsi_device_protection(struct scsi_device *sdev)
 {
 	if (sdev->no_dif)
 		return 0;
 	return sdev->scsi_level > SCSI_2 && sdev->inquiry[5] & (1<<0);
 }
 static inline int scsi_device_tpgs(struct scsi_device *sdev)
 {
 	return sdev->inquiry ? (sdev->inquiry[5] >> 4) & 0x3 : 0;
 }
 #define MODULE_ALIAS_SCSI_DEVICE(type) \
 	MODULE_ALIAS("scsi:t-" __stringify(type) "*")
 #define SCSI_DEVICE_MODALIAS_FMT "scsi:t-0x%02x"
 #endif /* _SCSI_SCSI_DEVICE_H */