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

38

#include <scsi/scsi.h>

38

#include <scsi/scsi.h>

39

#include <scsi/scsi_cmnd.h>

39

#include <scsi/scsi_cmnd.h>

40

#include <scsi/scsi_device.h>

40

#include <scsi/scsi_device.h>

41

#include <scsi/scsi_driver.h>

41

#include <scsi/scsi_driver.h>

42

#include <scsi/scsi_devinfo.h>

42

#include <scsi/scsi_devinfo.h>

43

#include <scsi/scsi_host.h>

43

#include <scsi/scsi_host.h>

44

#include <scsi/scsi_transport.h>

44

#include <scsi/scsi_transport.h>

45

#include <scsi/scsi_eh.h>

45

#include <scsi/scsi_eh.h>

46

47

#include "scsi_priv.h"

47

#include "scsi_priv.h"

48

#include "scsi_logging.h"

48

#include "scsi_logging.h"

49

50

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

50

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

51

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

51

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

52

53

/*

53

/*

54

* Default timeout

54

* Default timeout

55

*/

55

*/

56

#define SCSI_TIMEOUT (2*HZ)

56

#define SCSI_TIMEOUT (2*HZ)

57

58

/*

58

/*

59

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

59

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

60

*/

60

*/

61

#define SCSI_UID_SER_NUM 'S'

61

#define SCSI_UID_SER_NUM 'S'

62

#define SCSI_UID_UNKNOWN 'Z'

62

#define SCSI_UID_UNKNOWN 'Z'

63

64

/*

64

/*

65

* Return values of some of the scanning functions.

65

* Return values of some of the scanning functions.

66

*

66

*

67

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

67

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

68

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

68

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

69

*

69

*

70

* SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available

70

* SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available

71

* on the given LUN.

71

* on the given LUN.

72

*

72

*

73

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

73

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

74

* given LUN.

74

* given LUN.

75

*/

75

*/

76

#define SCSI_SCAN_NO_RESPONSE 0

76

#define SCSI_SCAN_NO_RESPONSE 0

77

#define SCSI_SCAN_TARGET_PRESENT 1

77

#define SCSI_SCAN_TARGET_PRESENT 1

78

#define SCSI_SCAN_LUN_PRESENT 2

78

#define SCSI_SCAN_LUN_PRESENT 2

79

80

static const char *scsi_null_device_strs = "nullnullnullnull";

80

static const char *scsi_null_device_strs = "nullnullnullnull";

81

82

#define MAX_SCSI_LUNS 512

82

#define MAX_SCSI_LUNS 512

83

84

static unsigned int max_scsi_luns = MAX_SCSI_LUNS;

84

static unsigned int max_scsi_luns = MAX_SCSI_LUNS;

85

86

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

86

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

87

MODULE_PARM_DESC(max_luns,

87

MODULE_PARM_DESC(max_luns,

88

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

88

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

89

90

#ifdef CONFIG_SCSI_SCAN_ASYNC

90

#ifdef CONFIG_SCSI_SCAN_ASYNC

91

#define SCSI_SCAN_TYPE_DEFAULT "async"

91

#define SCSI_SCAN_TYPE_DEFAULT "async"

92

#else

92

#else

93

#define SCSI_SCAN_TYPE_DEFAULT "sync"

93

#define SCSI_SCAN_TYPE_DEFAULT "sync"

94

#endif

94

#endif

95

96

char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;

96

char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;

97

98

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

98

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

99

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

99

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

100

101

/*

101

/*

102

* max_scsi_report_luns: the maximum number of LUNS that will be

102

* max_scsi_report_luns: the maximum number of LUNS that will be

103

* returned from the REPORT LUNS command. 8 times this value must

103

* returned from the REPORT LUNS command. 8 times this value must

104

* be allocated. In theory this could be up to an 8 byte value, but

104

* be allocated. In theory this could be up to an 8 byte value, but

105

* in practice, the maximum number of LUNs suppored by any device

105

* in practice, the maximum number of LUNs suppored by any device

106

* is about 16k.

106

* is about 16k.

107

*/

107

*/

108

static unsigned int max_scsi_report_luns = 511;

108

static unsigned int max_scsi_report_luns = 511;

109

110

module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);

110

module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);

111

MODULE_PARM_DESC(max_report_luns,

111

MODULE_PARM_DESC(max_report_luns,

112

"REPORT LUNS maximum number of LUNS received (should be"

112

"REPORT LUNS maximum number of LUNS received (should be"

113

" between 1 and 16384)");

113

" between 1 and 16384)");

114

115

static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;

115

static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;

116

117

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

117

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

118

MODULE_PARM_DESC(inq_timeout,

118

MODULE_PARM_DESC(inq_timeout,

119

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

119

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

120

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

120

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

121

122

/* This lock protects only this list */

122

/* This lock protects only this list */

123

static DEFINE_SPINLOCK(async_scan_lock);

123

static DEFINE_SPINLOCK(async_scan_lock);

124

static LIST_HEAD(scanning_hosts);

124

static LIST_HEAD(scanning_hosts);

125

126

struct async_scan_data {

126

struct async_scan_data {

127

struct list_head list;

127

struct list_head list;

128

struct Scsi_Host *shost;

128

struct Scsi_Host *shost;

129

struct completion prev_finished;

129

struct completion prev_finished;

130

};

130

};

131

132

/**

132

/**

133

* scsi_complete_async_scans - Wait for asynchronous scans to complete

133

* scsi_complete_async_scans - Wait for asynchronous scans to complete

134

*

134

*

135

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

135

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

136

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

136

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

137

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

137

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

138

* finished.

138

* finished.

139

*/

139

*/

140

int scsi_complete_async_scans(void)

140

int scsi_complete_async_scans(void)

141

{

141

{

142

struct async_scan_data *data;

142

struct async_scan_data *data;

143

144

do {

144

do {

145

if (list_empty(&scanning_hosts))

145

if (list_empty(&scanning_hosts))

146

return 0;

146

return 0;

147

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

147

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

148

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

148

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

149

* scans will finish eventually.

149

* scans will finish eventually.

150

*/

150

*/

151

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

151

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

152

if (!data)

152

if (!data)

153

msleep(1);

153

msleep(1);

154

} while (!data);

154

} while (!data);

155

156

data->shost = NULL;

156

data->shost = NULL;

157

init_completion(&data->prev_finished);

157

init_completion(&data->prev_finished);

158

159

spin_lock(&async_scan_lock);

159

spin_lock(&async_scan_lock);

160

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

160

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

161

if (list_empty(&scanning_hosts))

161

if (list_empty(&scanning_hosts))

162

goto done;

162

goto done;

163

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

163

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

164

spin_unlock(&async_scan_lock);

164

spin_unlock(&async_scan_lock);

165

166

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

166

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

167

wait_for_completion(&data->prev_finished);

167

wait_for_completion(&data->prev_finished);

168

169

spin_lock(&async_scan_lock);

169

spin_lock(&async_scan_lock);

170

list_del(&data->list);

170

list_del(&data->list);

171

if (!list_empty(&scanning_hosts)) {

171

if (!list_empty(&scanning_hosts)) {

172

struct async_scan_data *next = list_entry(scanning_hosts.next,

172

struct async_scan_data *next = list_entry(scanning_hosts.next,

173

struct async_scan_data, list);

173

struct async_scan_data, list);

174

complete(&next->prev_finished);

174

complete(&next->prev_finished);

175

}

175

}

176

done:

176

done:

177

spin_unlock(&async_scan_lock);

177

spin_unlock(&async_scan_lock);

178

179

kfree(data);

179

kfree(data);

180

return 0;

180

return 0;

181

}

181

}

182

183

/**

183

/**

184

* scsi_unlock_floptical - unlock device via a special MODE SENSE command

184

* scsi_unlock_floptical - unlock device via a special MODE SENSE command

185

* @sdev: scsi device to send command to

185

* @sdev: scsi device to send command to

186

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

186

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

187

*

187

*

188

* Description:

188

* Description:

189

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

189

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

190

* Called for BLIST_KEY devices.

190

* Called for BLIST_KEY devices.

191

**/

191

**/

192

static void scsi_unlock_floptical(struct scsi_device *sdev,

192

static void scsi_unlock_floptical(struct scsi_device *sdev,

193

unsigned char *result)

193

unsigned char *result)

194

{

194

{

195

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

195

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

196

197

printk(KERN_NOTICE "scsi: unlocking floptical drive\n");

197

printk(KERN_NOTICE "scsi: unlocking floptical drive\n");

198

scsi_cmd[0] = MODE_SENSE;

198

scsi_cmd[0] = MODE_SENSE;

199

scsi_cmd[1] = 0;

199

scsi_cmd[1] = 0;

200

scsi_cmd[2] = 0x2e;

200

scsi_cmd[2] = 0x2e;

201

scsi_cmd[3] = 0;

201

scsi_cmd[3] = 0;

202

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

202

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

203

scsi_cmd[5] = 0;

203

scsi_cmd[5] = 0;

204

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

204

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

205

SCSI_TIMEOUT, 3, NULL);

205

SCSI_TIMEOUT, 3, NULL);

206

}

206

}

207

208

/**

208

/**

209

* scsi_alloc_sdev - allocate and setup a scsi_Device

209

* scsi_alloc_sdev - allocate and setup a scsi_Device

210

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

210

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

211

* @lun: which lun

211

* @lun: which lun

212

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

212

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

213

*

213

*

214

* Description:

214

* Description:

215

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

215

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

216

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

216

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

217

* adds scsi_Device to the appropriate list.

217

* adds scsi_Device to the appropriate list.

218

*

218

*

219

* Return value:

219

* Return value:

220

* scsi_Device pointer, or NULL on failure.

220

* scsi_Device pointer, or NULL on failure.

221

**/

221

**/

222

static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,

222

static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,

223

unsigned int lun, void *hostdata)

223

unsigned int lun, void *hostdata)

224

{

224

{

225

struct scsi_device *sdev;

225

struct scsi_device *sdev;

226

int display_failure_msg = 1, ret;

226

int display_failure_msg = 1, ret;

227

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

227

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

228

extern void scsi_evt_thread(struct work_struct *work);

228

extern void scsi_evt_thread(struct work_struct *work);

229

extern void scsi_requeue_run_queue(struct work_struct *work);

229

extern void scsi_requeue_run_queue(struct work_struct *work);

230

231

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

231

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

232

GFP_ATOMIC);

232

GFP_ATOMIC);

233

if (!sdev)

233

if (!sdev)

234

goto out;

234

goto out;

235

236

sdev->vendor = scsi_null_device_strs;

236

sdev->vendor = scsi_null_device_strs;

237

sdev->model = scsi_null_device_strs;

237

sdev->model = scsi_null_device_strs;

238

sdev->rev = scsi_null_device_strs;

238

sdev->rev = scsi_null_device_strs;

239

sdev->host = shost;

239

sdev->host = shost;

240

sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;

240

sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;

241

sdev->id = starget->id;

241

sdev->id = starget->id;

242

sdev->lun = lun;

242

sdev->lun = lun;

243

sdev->channel = starget->channel;

243

sdev->channel = starget->channel;

244

sdev->sdev_state = SDEV_CREATED;

244

sdev->sdev_state = SDEV_CREATED;

245

INIT_LIST_HEAD(&sdev->siblings);

245

INIT_LIST_HEAD(&sdev->siblings);

246

INIT_LIST_HEAD(&sdev->same_target_siblings);

246

INIT_LIST_HEAD(&sdev->same_target_siblings);

247

INIT_LIST_HEAD(&sdev->cmd_list);

247

INIT_LIST_HEAD(&sdev->cmd_list);

248

INIT_LIST_HEAD(&sdev->starved_entry);

248

INIT_LIST_HEAD(&sdev->starved_entry);

249

INIT_LIST_HEAD(&sdev->event_list);

249

INIT_LIST_HEAD(&sdev->event_list);

250

spin_lock_init(&sdev->list_lock);

250

spin_lock_init(&sdev->list_lock);

251

INIT_WORK(&sdev->event_work, scsi_evt_thread);

251

INIT_WORK(&sdev->event_work, scsi_evt_thread);

252

INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);

252

INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);

253

254

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

254

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

255

sdev->sdev_target = starget;

255

sdev->sdev_target = starget;

256

257

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

257

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

258

sdev->hostdata = hostdata;

258

sdev->hostdata = hostdata;

259

260

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

260

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

261

* slave_configure function */

261

* slave_configure function */

262

sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;

262

sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;

263

264

/*

264

/*

265

* Some low level driver could use device->type

265

* Some low level driver could use device->type

266

*/

266

*/

267

sdev->type = -1;

267

sdev->type = -1;

268

269

/*

269

/*

270

* Assume that the device will have handshaking problems,

270

* Assume that the device will have handshaking problems,

271

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

271

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

272

* doesn't

272

* doesn't

273

*/

273

*/

274

sdev->borken = 1;

274

sdev->borken = 1;

275

276

sdev->request_queue = scsi_alloc_queue(sdev);

276

sdev->request_queue = scsi_alloc_queue(sdev);

277

if (!sdev->request_queue) {

277

if (!sdev->request_queue) {

278

/* release fn is set up in scsi_sysfs_device_initialise, so

278

/* release fn is set up in scsi_sysfs_device_initialise, so

279

* have to free and put manually here */

279

* have to free and put manually here */

280

put_device(&starget->dev);

280

put_device(&starget->dev);

281

kfree(sdev);

281

kfree(sdev);

282

goto out;

282

goto out;

283

}

283

}

284

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

284

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

285

sdev->request_queue->queuedata = sdev;

285

sdev->request_queue->queuedata = sdev;

286

scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);

286

scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);

287

288

scsi_sysfs_device_initialize(sdev);

288

scsi_sysfs_device_initialize(sdev);

289

290

if (shost->hostt->slave_alloc) {

290

if (shost->hostt->slave_alloc) {

291

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

291

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

292

if (ret) {

292

if (ret) {

293

/*

293

/*

294

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

294

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

295

* console with alloc failure messages

295

* console with alloc failure messages

296

*/

296

*/

297

if (ret == -ENXIO)

297

if (ret == -ENXIO)

298

display_failure_msg = 0;

298

display_failure_msg = 0;

299

goto out_device_destroy;

299

goto out_device_destroy;

300

}

300

}

301

}

301

}

302

303

return sdev;

303

return sdev;

304

305

out_device_destroy:

305

out_device_destroy:

306

__scsi_remove_device(sdev);

306

__scsi_remove_device(sdev);

307

out:

307

out:

308

if (display_failure_msg)

308

if (display_failure_msg)

309

printk(ALLOC_FAILURE_MSG, __func__);

309

printk(ALLOC_FAILURE_MSG, __func__);

310

return NULL;

310

return NULL;

311

}

311

}

312

313

static void scsi_target_destroy(struct scsi_target *starget)

313

static void scsi_target_destroy(struct scsi_target *starget)

314

{

314

{

315

struct device *dev = &starget->dev;

315

struct device *dev = &starget->dev;

316

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

316

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

317

unsigned long flags;

317

unsigned long flags;

318

319

starget->state = STARGET_DEL;

319

starget->state = STARGET_DEL;

320

transport_destroy_device(dev);

320

transport_destroy_device(dev);

321

spin_lock_irqsave(shost->host_lock, flags);

321

spin_lock_irqsave(shost->host_lock, flags);

322

if (shost->hostt->target_destroy)

322

if (shost->hostt->target_destroy)

323

shost->hostt->target_destroy(starget);

323

shost->hostt->target_destroy(starget);

324

list_del_init(&starget->siblings);

324

list_del_init(&starget->siblings);

325

spin_unlock_irqrestore(shost->host_lock, flags);

325

spin_unlock_irqrestore(shost->host_lock, flags);

326

put_device(dev);

326

put_device(dev);

327

}

327

}

328

329

static void scsi_target_dev_release(struct device *dev)

329

static void scsi_target_dev_release(struct device *dev)

330

{

330

{

331

struct device *parent = dev->parent;

331

struct device *parent = dev->parent;

332

struct scsi_target *starget = to_scsi_target(dev);

332

struct scsi_target *starget = to_scsi_target(dev);

333

334

kfree(starget);

334

kfree(starget);

335

put_device(parent);

335

put_device(parent);

336

}

336

}

337

338

static struct device_type scsi_target_type = {

338

static struct device_type scsi_target_type = {

339

.name = "scsi_target",

339

.name = "scsi_target",

340

.release = scsi_target_dev_release,

340

.release = scsi_target_dev_release,

341

};

341

};

342

343

int scsi_is_target_device(const struct device *dev)

343

int scsi_is_target_device(const struct device *dev)

344

{

344

{

345

return dev->type == &scsi_target_type;

345

return dev->type == &scsi_target_type;

346

}

346

}

347

EXPORT_SYMBOL(scsi_is_target_device);

347

EXPORT_SYMBOL(scsi_is_target_device);

348

349

static struct scsi_target *__scsi_find_target(struct device *parent,

349

static struct scsi_target *__scsi_find_target(struct device *parent,

350

int channel, uint id)

350

int channel, uint id)

351

{

351

{

352

struct scsi_target *starget, *found_starget = NULL;

352

struct scsi_target *starget, *found_starget = NULL;

353

struct Scsi_Host *shost = dev_to_shost(parent);

353

struct Scsi_Host *shost = dev_to_shost(parent);

354

/*

354

/*

355

* Search for an existing target for this sdev.

355

* Search for an existing target for this sdev.

356

*/

356

*/

357

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

357

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

358

if (starget->id == id &&

358

if (starget->id == id &&

359

starget->channel == channel) {

359

starget->channel == channel) {

360

found_starget = starget;

360

found_starget = starget;

361

break;

361

break;

362

}

362

}

363

}

363

}

364

if (found_starget)

364

if (found_starget)

365

get_device(&found_starget->dev);

365

get_device(&found_starget->dev);

366

367

return found_starget;

367

return found_starget;

368

}

368

}

369

370

/**

370

/**

371

* scsi_target_reap_ref_release - remove target from visibility

371

* scsi_target_reap_ref_release - remove target from visibility

372

* @kref: the reap_ref in the target being released

372

* @kref: the reap_ref in the target being released

373

*

373

*

374

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

374

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

375

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

375

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

376

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

376

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

377

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

377

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

378

*/

378

*/

379

static void scsi_target_reap_ref_release(struct kref *kref)

379

static void scsi_target_reap_ref_release(struct kref *kref)

380

{

380

{

381

struct scsi_target *starget

381

struct scsi_target *starget

382

= container_of(kref, struct scsi_target, reap_ref);

382

= container_of(kref, struct scsi_target, reap_ref);

383

384

/*

384

/*

385

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

385

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

386

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

386

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

387

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

387

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

388

*/

388

*/

389

if (starget->state != STARGET_CREATED) {

389

if (starget->state != STARGET_CREATED) {

390

transport_remove_device(&starget->dev);

390

transport_remove_device(&starget->dev);

391

device_del(&starget->dev);

391

device_del(&starget->dev);

392

}

392

}

393

scsi_target_destroy(starget);

393

scsi_target_destroy(starget);

394

}

394

}

395

396

static void scsi_target_reap_ref_put(struct scsi_target *starget)

396

static void scsi_target_reap_ref_put(struct scsi_target *starget)

397

{

397

{

398

kref_put(&starget->reap_ref, scsi_target_reap_ref_release);

398

kref_put(&starget->reap_ref, scsi_target_reap_ref_release);

399

}

399

}

400

401

/**

401

/**

402

* scsi_alloc_target - allocate a new or find an existing target

402

* scsi_alloc_target - allocate a new or find an existing target

403

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

403

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

404

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

404

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

405

* @id: target id number

405

* @id: target id number

406

*

406

*

407

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

407

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

408

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

408

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

409

*

409

*

410

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

410

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

411

* is responsible for both reaping and doing a last put

411

* is responsible for both reaping and doing a last put

412

*/

412

*/

413

static struct scsi_target *scsi_alloc_target(struct device *parent,

413

static struct scsi_target *scsi_alloc_target(struct device *parent,

414

int channel, uint id)

414

int channel, uint id)

415

{

415

{

416

struct Scsi_Host *shost = dev_to_shost(parent);

416

struct Scsi_Host *shost = dev_to_shost(parent);

417

struct device *dev = NULL;

417

struct device *dev = NULL;

418

unsigned long flags;

418

unsigned long flags;

419

const int size = sizeof(struct scsi_target)

419

const int size = sizeof(struct scsi_target)

420

+ shost->transportt->target_size;

420

+ shost->transportt->target_size;

421

struct scsi_target *starget;

421

struct scsi_target *starget;

422

struct scsi_target *found_target;

422

struct scsi_target *found_target;

423

int error, ref_got;

423

int error, ref_got;

424

425

starget = kzalloc(size, GFP_KERNEL);

425

starget = kzalloc(size, GFP_KERNEL);

426

if (!starget) {

426

if (!starget) {

427

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

427

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

428

return NULL;

428

return NULL;

429

}

429

}

430

dev = &starget->dev;

430

dev = &starget->dev;

431

device_initialize(dev);

431

device_initialize(dev);

432

kref_init(&starget->reap_ref);

432

kref_init(&starget->reap_ref);

433

dev->parent = get_device(parent);

433

dev->parent = get_device(parent);

434

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

434

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

435

dev->bus = &scsi_bus_type;

435

dev->bus = &scsi_bus_type;

436

dev->type = &scsi_target_type;

436

dev->type = &scsi_target_type;

437

starget->id = id;

437

starget->id = id;

438

starget->channel = channel;

438

starget->channel = channel;

439

starget->can_queue = 0;

439

starget->can_queue = 0;

440

INIT_LIST_HEAD(&starget->siblings);

440

INIT_LIST_HEAD(&starget->siblings);

441

INIT_LIST_HEAD(&starget->devices);

441

INIT_LIST_HEAD(&starget->devices);

442

starget->state = STARGET_CREATED;

442

starget->state = STARGET_CREATED;

443

starget->scsi_level = SCSI_2;

443

starget->scsi_level = SCSI_2;

444

starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;

444

starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;

445

retry:

445

retry:

446

spin_lock_irqsave(shost->host_lock, flags);

446

spin_lock_irqsave(shost->host_lock, flags);

447

448

found_target = __scsi_find_target(parent, channel, id);

448

found_target = __scsi_find_target(parent, channel, id);

449

if (found_target)

449

if (found_target)

450

goto found;

450

goto found;

451

452

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

452

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

453

spin_unlock_irqrestore(shost->host_lock, flags);

453

spin_unlock_irqrestore(shost->host_lock, flags);

454

/* allocate and add */

454

/* allocate and add */

455

transport_setup_device(dev);

455

transport_setup_device(dev);

456

if (shost->hostt->target_alloc) {

456

if (shost->hostt->target_alloc) {

457

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

457

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

458

459

if(error) {

459

if(error) {

460

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

460

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

461

/* don't want scsi_target_reap to do the final

461

/* don't want scsi_target_reap to do the final

462

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

462

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

463

scsi_target_destroy(starget);

463

scsi_target_destroy(starget);

464

return NULL;

464

return NULL;

465

}

465

}

466

}

466

}

467

get_device(dev);

467

get_device(dev);

468

469

return starget;

469

return starget;

470

471

found:

471

found:

472

/*

472

/*

473

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

473

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

474

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

474

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

475

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

475

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

476

*/

476

*/

477

ref_got = kref_get_unless_zero(&found_target->reap_ref);

477

ref_got = kref_get_unless_zero(&found_target->reap_ref);

478

479

spin_unlock_irqrestore(shost->host_lock, flags);

479

spin_unlock_irqrestore(shost->host_lock, flags);

480

if (ref_got) {

480

if (ref_got) {

481

put_device(dev);

481

put_device(dev);

482

return found_target;

482

return found_target;

483

}

483

}

484

/*

484

/*

485

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

485

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

486

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

486

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

487

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

487

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

488

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

488

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

489

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

489

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

490

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

490

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

491

* an already invisible target.

491

* an already invisible target.

492

*/

492

*/

493

put_device(&found_target->dev);

493

put_device(&found_target->dev);

494

/*

494

/*

495

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

495

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

496

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

496

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

497

*/

497

*/

498

msleep(1);

498

msleep(1);

499

goto retry;

499

goto retry;

500

}

500

}

501

502

/**

502

/**

503

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

503

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

504

* @starget: target to be checked

504

* @starget: target to be checked

505

*

505

*

506

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

506

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

507

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

507

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

508

* it if so.

508

* it if so.

509

*/

509

*/

510

void scsi_target_reap(struct scsi_target *starget)

510

void scsi_target_reap(struct scsi_target *starget)

511

{

511

{

512

/*

512

/*

513

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

513

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

514

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

514

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

515

* on an already released kref

515

* on an already released kref

516

*/

516

*/

517

BUG_ON(starget->state == STARGET_DEL);

517

BUG_ON(starget->state == STARGET_DEL);

518

scsi_target_reap_ref_put(starget);

518

scsi_target_reap_ref_put(starget);

519

}

519

}

520

521

/**

521

/**

522

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

522

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

523

* @s: INQUIRY result string to sanitize

523

* @s: INQUIRY result string to sanitize

524

* @len: length of the string

524

* @len: length of the string

525

*

525

*

526

* Description:

526

* Description:

527

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

527

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

528

* strings must consist entirely of graphic ASCII characters,

528

* strings must consist entirely of graphic ASCII characters,

529

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

529

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

530

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

530

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

531

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

531

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

532

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

532

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

533

* spaces.

533

* spaces.

534

**/

534

**/

535

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

535

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

536

{

536

{

537

int terminated = 0;

537

int terminated = 0;

538

539

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

539

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

540

if (*s == 0)

540

if (*s == 0)

541

terminated = 1;

541

terminated = 1;

542

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

542

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

543

*s = ' ';

543

*s = ' ';

544

}

544

}

545

}

545

}

546

547

/**

547

/**

548

* scsi_probe_lun - probe a single LUN using a SCSI INQUIRY

548

* scsi_probe_lun - probe a single LUN using a SCSI INQUIRY

549

* @sdev: scsi_device to probe

549

* @sdev: scsi_device to probe

550

* @inq_result: area to store the INQUIRY result

550

* @inq_result: area to store the INQUIRY result

551

* @result_len: len of inq_result

551

* @result_len: len of inq_result

552

* @bflags: store any bflags found here

552

* @bflags: store any bflags found here

553

*

553

*

554

* Description:

554

* Description:

555

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

555

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

556

*

556

*

557

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

557

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

558

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

558

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

559

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

559

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

560

**/

560

**/

561

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

561

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

562

int result_len, int *bflags)

562

int result_len, int *bflags)

563

{

563

{

564

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

564

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

565

int first_inquiry_len, try_inquiry_len, next_inquiry_len;

565

int first_inquiry_len, try_inquiry_len, next_inquiry_len;

566

int response_len = 0;

566

int response_len = 0;

567

int pass, count, result;

567

int pass, count, result;

568

struct scsi_sense_hdr sshdr;

568

struct scsi_sense_hdr sshdr;

569

570

*bflags = 0;

570

*bflags = 0;

571

572

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

572

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

573

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

573

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

574

* different value. */

574

* different value. */

575

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

575

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

576

try_inquiry_len = first_inquiry_len;

576

try_inquiry_len = first_inquiry_len;

577

pass = 1;

577

pass = 1;

578

579

next_pass:

579

next_pass:

580

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

580

SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,

581

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

581

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

582

pass, try_inquiry_len));

582

pass, try_inquiry_len));

583

584

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

584

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

585

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

585

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

586

int resid;

586

int resid;

587

588

memset(scsi_cmd, 0, 6);

588

memset(scsi_cmd, 0, 6);

589

scsi_cmd[0] = INQUIRY;

589

scsi_cmd[0] = INQUIRY;

590

scsi_cmd[4] = (unsigned char) try_inquiry_len;

590

scsi_cmd[4] = (unsigned char) try_inquiry_len;

591

592

memset(inq_result, 0, try_inquiry_len);

592

memset(inq_result, 0, try_inquiry_len);

593

594

result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,

594

result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,

595

inq_result, try_inquiry_len, &sshdr,

595

inq_result, try_inquiry_len, &sshdr,

596

HZ / 2 + HZ * scsi_inq_timeout, 3,

596

HZ / 2 + HZ * scsi_inq_timeout, 3,

597

&resid);

597

&resid);

598

599

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: INQUIRY %s "

599

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: INQUIRY %s "

600

"with code 0x%x\n",

600

"with code 0x%x\n",

601

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

601

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

602

603

if (result) {

603

if (result) {

604

/*

604

/*

605

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

605

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

606

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

606

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

607

* INQUIRY should not yield UNIT_ATTENTION

607

* INQUIRY should not yield UNIT_ATTENTION

608

* but many buggy devices do so anyway.

608

* but many buggy devices do so anyway.

609

*/

609

*/

610

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

610

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

611

scsi_sense_valid(&sshdr)) {

611

scsi_sense_valid(&sshdr)) {

612

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

612

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

613

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

613

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

614

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

614

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

615

(sshdr.ascq == 0))

615

(sshdr.ascq == 0))

616

continue;

616

continue;

617

}

617

}

618

} else {

618

} else {

619

/*

619

/*

620

* if nothing was transferred, we try

620

* if nothing was transferred, we try

621

* again. It's a workaround for some USB

621

* again. It's a workaround for some USB

622

* devices.

622

* devices.

623

*/

623

*/

624

if (resid == try_inquiry_len)

624

if (resid == try_inquiry_len)

625

continue;

625

continue;

626

}

626

}

627

break;

627

break;

628

}

628

}

629

630

if (result == 0) {

630

if (result == 0) {

631

sanitize_inquiry_string(&inq_result[8], 8);

631

sanitize_inquiry_string(&inq_result[8], 8);

632

sanitize_inquiry_string(&inq_result[16], 16);

632

sanitize_inquiry_string(&inq_result[16], 16);

633

sanitize_inquiry_string(&inq_result[32], 4);

633

sanitize_inquiry_string(&inq_result[32], 4);

634

635

response_len = inq_result[4] + 5;

635

response_len = inq_result[4] + 5;

636

if (response_len > 255)

636

if (response_len > 255)

637

response_len = first_inquiry_len; /* sanity */

637

response_len = first_inquiry_len; /* sanity */

638

639

/*

639

/*

640

* Get any flags for this device.

640

* Get any flags for this device.

641

*

641

*

642

* XXX add a bflags to scsi_device, and replace the

642

* XXX add a bflags to scsi_device, and replace the

643

* corresponding bit fields in scsi_device, so bflags

643

* corresponding bit fields in scsi_device, so bflags

644

* need not be passed as an argument.

644

* need not be passed as an argument.

645

*/

645

*/

646

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

646

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

647

&inq_result[16]);

647

&inq_result[16]);

648

649

/* When the first pass succeeds we gain information about

649

/* When the first pass succeeds we gain information about

650

* what larger transfer lengths might work. */

650

* what larger transfer lengths might work. */

651

if (pass == 1) {

651

if (pass == 1) {

652

if (BLIST_INQUIRY_36 & *bflags)

652

if (BLIST_INQUIRY_36 & *bflags)

653

next_inquiry_len = 36;

653

next_inquiry_len = 36;

654

else if (BLIST_INQUIRY_58 & *bflags)

654

else if (BLIST_INQUIRY_58 & *bflags)

655

next_inquiry_len = 58;

655

next_inquiry_len = 58;

656

else if (sdev->inquiry_len)

656

else if (sdev->inquiry_len)

657

next_inquiry_len = sdev->inquiry_len;

657

next_inquiry_len = sdev->inquiry_len;

658

else

658

else

659

next_inquiry_len = response_len;

659

next_inquiry_len = response_len;

660

661

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

661

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

662

if (next_inquiry_len > try_inquiry_len) {

662

if (next_inquiry_len > try_inquiry_len) {

663

try_inquiry_len = next_inquiry_len;

663

try_inquiry_len = next_inquiry_len;

664

pass = 2;

664

pass = 2;

665

goto next_pass;

665

goto next_pass;

666

}

666

}

667

}

667

}

668

669

} else if (pass == 2) {

669

} else if (pass == 2) {

670

printk(KERN_INFO "scsi scan: %d byte inquiry failed. "

670

printk(KERN_INFO "scsi scan: %d byte inquiry failed. "

671

"Consider BLIST_INQUIRY_36 for this device\n",

671

"Consider BLIST_INQUIRY_36 for this device\n",

672

try_inquiry_len);

672

try_inquiry_len);

673

674

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

674

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

675

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

675

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

676

try_inquiry_len = first_inquiry_len;

676

try_inquiry_len = first_inquiry_len;

677

pass = 3;

677

pass = 3;

678

goto next_pass;

678

goto next_pass;

679

}

679

}

680

681

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

681

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

682

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

682

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

683

if (result)

683

if (result)

684

return -EIO;

684

return -EIO;

685

686

/* 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 */

687

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

687

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

688

689

/*

689

/*

690

* 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

691

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

691

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

692

* 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

693

* 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,

694

* 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

695

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

695

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

696

* device, including spin up.

696

* device, including spin up.

697

*

697

*

698

* 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

699

* 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

700

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

700

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

701

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

701

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

702

* strings.

702

* strings.

703

*/

703

*/

704

if (sdev->inquiry_len < 36) {

704

if (sdev->inquiry_len < 36) {

705

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

705

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

706

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

706

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

707

sdev->inquiry_len = 36;

707

sdev->inquiry_len = 36;

708

}

708

}

709

710

/*

710

/*

711

* Related to the above issue:

711

* Related to the above issue:

712

*

712

*

713

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

713

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

714

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

714

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

715

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

715

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

716

* a device is initialized.

716

* a device is initialized.

717

*

717

*

718

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

718

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

719

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

719

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

720

* request, and then spun up on request.

720

* request, and then spun up on request.

721

*/

721

*/

722

723

/*

723

/*

724

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

724

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

725

* device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so

725

* device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so

726

* non-zero LUNs can be scanned.

726

* non-zero LUNs can be scanned.

727

*/

727

*/

728

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

728

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

729

if (sdev->scsi_level >= 2 ||

729

if (sdev->scsi_level >= 2 ||

730

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

730

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

731

sdev->scsi_level++;

731

sdev->scsi_level++;

732

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

732

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

733

734

return 0;

734

return 0;

735

}

735

}

736

737

/**

737

/**

738

* scsi_add_lun - allocate and fully initialze a scsi_device

738

* scsi_add_lun - allocate and fully initialze a scsi_device

739

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

739

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

740

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

740

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

741

* @bflags: black/white list flag

741

* @bflags: black/white list flag

742

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

742

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

743

*

743

*

744

* Description:

744

* Description:

745

* Initialize the scsi_device @sdev. Optionally set fields based

745

* Initialize the scsi_device @sdev. Optionally set fields based

746

* on values in *@bflags.

746

* on values in *@bflags.

747

*

747

*

748

* Return:

748

* Return:

749

* SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device

749

* SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device

750

* SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized

750

* SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized

751

**/

751

**/

752

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

752

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

753

int *bflags, int async)

753

int *bflags, int async)

754

{

754

{

755

int ret;

755

int ret;

756

757

/*

757

/*

758

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

758

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

759

* save just vendor/model/rev.

759

* save just vendor/model/rev.

760

*

760

*

761

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

761

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

762

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

762

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

763

* in scsi_probe_lun, let user level programs doing INQUIRY

763

* in scsi_probe_lun, let user level programs doing INQUIRY

764

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

764

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

765

* that can correctly scan.

765

* that can correctly scan.

766

*/

766

*/

767

768

/*

768

/*

769

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

769

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

770

* dereference unallocated memory when accessing the Vendor,

770

* dereference unallocated memory when accessing the Vendor,

771

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

771

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

772

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

772

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

773

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

773

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

774

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

774

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

775

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

775

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

776

*/

776

*/

777

sdev->inquiry = kmemdup(inq_result,

777

sdev->inquiry = kmemdup(inq_result,

778

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

778

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

779

GFP_ATOMIC);

779

GFP_ATOMIC);

780

if (sdev->inquiry == NULL)

780

if (sdev->inquiry == NULL)

781

return SCSI_SCAN_NO_RESPONSE;

781

return SCSI_SCAN_NO_RESPONSE;

782

783

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

783

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

784

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

784

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

785

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

785

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

786

787

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

787

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

788

/*

788

/*

789

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

789

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

790

* the SATL power management specifications which state that

790

* the SATL power management specifications which state that

791

* when the SATL detects the device has gone into standby

791

* when the SATL detects the device has gone into standby

792

* mode, it shall respond with NOT READY.

792

* mode, it shall respond with NOT READY.

793

*/

793

*/

794

sdev->allow_restart = 1;

794

sdev->allow_restart = 1;

795

}

795

}

796

797

if (*bflags & BLIST_ISROM) {

797

if (*bflags & BLIST_ISROM) {

798

sdev->type = TYPE_ROM;

798

sdev->type = TYPE_ROM;

799

sdev->removable = 1;

799

sdev->removable = 1;

800

} else {

800

} else {

801

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

801

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

802

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

802

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

803

}

803

}

804

805

switch (sdev->type) {

805

switch (sdev->type) {

806

case TYPE_RBC:

806

case TYPE_RBC:

807

case TYPE_TAPE:

807

case TYPE_TAPE:

808

case TYPE_DISK:

808

case TYPE_DISK:

809

case TYPE_PRINTER:

809

case TYPE_PRINTER:

810

case TYPE_MOD:

810

case TYPE_MOD:

811

case TYPE_PROCESSOR:

811

case TYPE_PROCESSOR:

812

case TYPE_SCANNER:

812

case TYPE_SCANNER:

813

case TYPE_MEDIUM_CHANGER:

813

case TYPE_MEDIUM_CHANGER:

814

case TYPE_ENCLOSURE:

814

case TYPE_ENCLOSURE:

815

case TYPE_COMM:

815

case TYPE_COMM:

816

case TYPE_RAID:

816

case TYPE_RAID:

817

case TYPE_OSD:

817

case TYPE_OSD:

818

sdev->writeable = 1;

818

sdev->writeable = 1;

819

break;

819

break;

820

case TYPE_ROM:

820

case TYPE_ROM:

821

case TYPE_WORM:

821

case TYPE_WORM:

822

sdev->writeable = 0;

822

sdev->writeable = 0;

823

break;

823

break;

824

default:

824

default:

825

printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type);

825

printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type);

826

}

826

}

827

828

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

828

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

829

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

829

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

830

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

830

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

831

* BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is

831

* BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is

832

* specifically set */

832

* specifically set */

833

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

833

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

834

*bflags |= BLIST_NOREPORTLUN;

834

*bflags |= BLIST_NOREPORTLUN;

835

}

835

}

836

837

/*

837

/*

838

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

838

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

839

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

839

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

840

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

840

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

841

* the physical device is not currently connected to this logical

841

* the physical device is not currently connected to this logical

842

* unit.

842

* unit.

843

*

843

*

844

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

844

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

845

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

845

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

846

* scsi_device for a PQ of 1

846

* scsi_device for a PQ of 1

847

*

847

*

848

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

848

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

849

* level drivers eval the PQ to decide whether they should

849

* level drivers eval the PQ to decide whether they should

850

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

850

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

851

*/

851

*/

852

853

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

853

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

854

sdev->lockable = sdev->removable;

854

sdev->lockable = sdev->removable;

855

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

855

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

856

857

if (sdev->scsi_level >= SCSI_3 ||

857

if (sdev->scsi_level >= SCSI_3 ||

858

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

858

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

859

sdev->ppr = 1;

859

sdev->ppr = 1;

860

if (inq_result[7] & 0x60)

860

if (inq_result[7] & 0x60)

861

sdev->wdtr = 1;

861

sdev->wdtr = 1;

862

if (inq_result[7] & 0x10)

862

if (inq_result[7] & 0x10)

863

sdev->sdtr = 1;

863

sdev->sdtr = 1;

864

865

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

865

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

866

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

866

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

867

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

867

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

868

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

868

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

869

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

869

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

870

871

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

871

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

872

!(*bflags & BLIST_NOTQ))

872

!(*bflags & BLIST_NOTQ))

873

sdev->tagged_supported = 1;

873

sdev->tagged_supported = 1;

874

875

/*

875

/*

876

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

876

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

877

* when used with the Seagate controllers. borken is initialized

877

* when used with the Seagate controllers. borken is initialized

878

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

878

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

879

*/

879

*/

880

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

880

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

881

sdev->borken = 0;

881

sdev->borken = 0;

882

883

if (*bflags & BLIST_NO_ULD_ATTACH)

883

if (*bflags & BLIST_NO_ULD_ATTACH)

884

sdev->no_uld_attach = 1;

884

sdev->no_uld_attach = 1;

885

886

/*

886

/*

887

* Apparently some really broken devices (contrary to the SCSI

887

* Apparently some really broken devices (contrary to the SCSI

888

* standards) need to be selected without asserting ATN

888

* standards) need to be selected without asserting ATN

889

*/

889

*/

890

if (*bflags & BLIST_SELECT_NO_ATN)

890

if (*bflags & BLIST_SELECT_NO_ATN)

891

sdev->select_no_atn = 1;

891

sdev->select_no_atn = 1;

892

893

/*

893

/*

894

* Maximum 512 sector transfer length

894

* Maximum 512 sector transfer length

895

* broken RA4x00 Compaq Disk Array

895

* broken RA4x00 Compaq Disk Array

896

*/

896

*/

897

if (*bflags & BLIST_MAX_512)

897

if (*bflags & BLIST_MAX_512)

898

blk_queue_max_hw_sectors(sdev->request_queue, 512);

898

blk_queue_max_hw_sectors(sdev->request_queue, 512);

899

900

/*

900

/*

901

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

901

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

902

* issued when a device is added.

902

* issued when a device is added.

903

*/

903

*/

904

if (*bflags & BLIST_NOSTARTONADD)

904

if (*bflags & BLIST_NOSTARTONADD)

905

sdev->no_start_on_add = 1;

905

sdev->no_start_on_add = 1;

906

907

if (*bflags & BLIST_SINGLELUN)

907

if (*bflags & BLIST_SINGLELUN)

908

scsi_target(sdev)->single_lun = 1;

908

scsi_target(sdev)->single_lun = 1;

909

910

sdev->use_10_for_rw = 1;

910

sdev->use_10_for_rw = 1;

911

912

if (*bflags & BLIST_MS_SKIP_PAGE_08)

912

if (*bflags & BLIST_MS_SKIP_PAGE_08)

913

sdev->skip_ms_page_8 = 1;

913

sdev->skip_ms_page_8 = 1;

914

915

if (*bflags & BLIST_MS_SKIP_PAGE_3F)

915

if (*bflags & BLIST_MS_SKIP_PAGE_3F)

916

sdev->skip_ms_page_3f = 1;

916

sdev->skip_ms_page_3f = 1;

917

918

if (*bflags & BLIST_USE_10_BYTE_MS)

918

if (*bflags & BLIST_USE_10_BYTE_MS)

919

sdev->use_10_for_ms = 1;

919

sdev->use_10_for_ms = 1;

920

921

/* set the device running here so that slave configure

921

/* set the device running here so that slave configure

922

* may do I/O */

922

* may do I/O */

923

ret = scsi_device_set_state(sdev, SDEV_RUNNING);

923

ret = scsi_device_set_state(sdev, SDEV_RUNNING);

924

if (ret) {

924

if (ret) {

925

ret = scsi_device_set_state(sdev, SDEV_BLOCK);

925

ret = scsi_device_set_state(sdev, SDEV_BLOCK);

926

927

if (ret) {

927

if (ret) {

928

sdev_printk(KERN_ERR, sdev,

928

sdev_printk(KERN_ERR, sdev,

929

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

929

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

930

scsi_device_state_name(sdev->sdev_state));

930

scsi_device_state_name(sdev->sdev_state));

931

return SCSI_SCAN_NO_RESPONSE;

931

return SCSI_SCAN_NO_RESPONSE;

932

}

932

}

933

}

933

}

934

935

if (*bflags & BLIST_MS_192_BYTES_FOR_3F)

935

if (*bflags & BLIST_MS_192_BYTES_FOR_3F)

936

sdev->use_192_bytes_for_3f = 1;

936

sdev->use_192_bytes_for_3f = 1;

937

938

if (*bflags & BLIST_NOT_LOCKABLE)

938

if (*bflags & BLIST_NOT_LOCKABLE)

939

sdev->lockable = 0;

939

sdev->lockable = 0;

940

941

if (*bflags & BLIST_RETRY_HWERROR)

941

if (*bflags & BLIST_RETRY_HWERROR)

942

sdev->retry_hwerror = 1;

942

sdev->retry_hwerror = 1;

943

944

if (*bflags & BLIST_NO_DIF)

944

if (*bflags & BLIST_NO_DIF)

945

sdev->no_dif = 1;

945

sdev->no_dif = 1;

946

947

sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;

947

sdev->eh_timeout = SCSI_DEFAULT_EH_TIMEOUT;

948

949

if (*bflags & BLIST_SKIP_VPD_PAGES)

949

if (*bflags & BLIST_SKIP_VPD_PAGES)

950

sdev->skip_vpd_pages = 1;

950

sdev->skip_vpd_pages = 1;

951

952

transport_configure_device(&sdev->sdev_gendev);

952

transport_configure_device(&sdev->sdev_gendev);

953

954

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

954

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

955

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

955

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

956

if (ret) {

956

if (ret) {

957

/*

957

/*

958

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

958

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

959

* console with alloc failure messages

959

* console with alloc failure messages

960

*/

960

*/

961

if (ret != -ENXIO) {

961

if (ret != -ENXIO) {

962

sdev_printk(KERN_ERR, sdev,

962

sdev_printk(KERN_ERR, sdev,

963

"failed to configure device\n");

963

"failed to configure device\n");

964

}

964

}

965

return SCSI_SCAN_NO_RESPONSE;

965

return SCSI_SCAN_NO_RESPONSE;

966

}

966

}

967

}

967

}

968

969

if (sdev->scsi_level >= SCSI_3)

969

if (sdev->scsi_level >= SCSI_3)

970

scsi_attach_vpd(sdev);

970

scsi_attach_vpd(sdev);

971

972

sdev->max_queue_depth = sdev->queue_depth;

972

sdev->max_queue_depth = sdev->queue_depth;

973

974

/*

974

/*

975

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

975

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

976

* register it and tell the rest of the kernel

976

* register it and tell the rest of the kernel

977

* about it.

977

* about it.

978

*/

978

*/

979

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

979

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

980

return SCSI_SCAN_NO_RESPONSE;

980

return SCSI_SCAN_NO_RESPONSE;

981

982

return SCSI_SCAN_LUN_PRESENT;

982

return SCSI_SCAN_LUN_PRESENT;

983

}

983

}

984

985

#ifdef CONFIG_SCSI_LOGGING

985

#ifdef CONFIG_SCSI_LOGGING

986

/**

986

/**

987

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

987

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

988

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

988

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

989

* @inq: Inquiry buffer (input)

989

* @inq: Inquiry buffer (input)

990

* @first: Offset of string into inq

990

* @first: Offset of string into inq

991

* @end: Index after last character in inq

991

* @end: Index after last character in inq

992

*/

992

*/

993

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

993

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

994

unsigned first, unsigned end)

994

unsigned first, unsigned end)

995

{

995

{

996

unsigned term = 0, idx;

996

unsigned term = 0, idx;

997

998

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

998

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

999

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

999

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

1000

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

1000

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

1001

term = idx+1;

1001

term = idx+1;

1002

} else {

1002

} else {

1003

buf[idx] = ' ';

1003

buf[idx] = ' ';

1004

}

1004

}

1005

}

1005

}

1006

buf[term] = 0;

1006

buf[term] = 0;

1007

return buf;

1007

return buf;

1008

}

1008

}

1009

#endif

1009

#endif

1010

1011

/**

1011

/**

1012

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

1012

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

1013

* @starget: pointer to target device structure

1013

* @starget: pointer to target device structure

1014

* @lun: LUN of target device

1014

* @lun: LUN of target device

1015

* @bflagsp: store bflags here if not NULL

1015

* @bflagsp: store bflags here if not NULL

1016

* @sdevp: probe the LUN corresponding to this scsi_device

1016

* @sdevp: probe the LUN corresponding to this scsi_device

1017

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

1017

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

1018

* @hostdata: passed to scsi_alloc_sdev()

1018

* @hostdata: passed to scsi_alloc_sdev()

1019

*

1019

*

1020

* Description:

1020

* Description:

1021

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

1021

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

1022

* allocate and set it up by calling scsi_add_lun.

1022

* allocate and set it up by calling scsi_add_lun.

1023

*

1023

*

1024

* Return:

1024

* Return:

1025

* SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device

1025

* SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device

1026

* SCSI_SCAN_TARGET_PRESENT: target responded, but no device is

1026

* SCSI_SCAN_TARGET_PRESENT: target responded, but no device is

1027

* attached at the LUN

1027

* attached at the LUN

1028

* SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized

1028

* SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized

1029

**/

1029

**/

1030

static int scsi_probe_and_add_lun(struct scsi_target *starget,

1030

static int scsi_probe_and_add_lun(struct scsi_target *starget,

1031

uint lun, int *bflagsp,

1031

uint lun, int *bflagsp,

1032

struct scsi_device **sdevp, int rescan,

1032

struct scsi_device **sdevp, int rescan,

1033

void *hostdata)

1033

void *hostdata)

1034

{

1034

{

1035

struct scsi_device *sdev;

1035

struct scsi_device *sdev;

1036

unsigned char *result;

1036

unsigned char *result;

1037

int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;

1037

int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;

1038

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

1038

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

1039

1040

/*

1040

/*

1041

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

1041

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

1042

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

1042

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

1043

*/

1043

*/

1044

sdev = scsi_device_lookup_by_target(starget, lun);

1044

sdev = scsi_device_lookup_by_target(starget, lun);

1045

if (sdev) {

1045

if (sdev) {

1046

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

1046

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

1047

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO

1047

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO

1048

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

1048

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

1049

dev_name(&sdev->sdev_gendev)));

1049

dev_name(&sdev->sdev_gendev)));

1050

if (sdevp)

1050

if (sdevp)

1051

*sdevp = sdev;

1051

*sdevp = sdev;

1052

else

1052

else

1053

scsi_device_put(sdev);

1053

scsi_device_put(sdev);

1054

1055

if (bflagsp)

1055

if (bflagsp)

1056

*bflagsp = scsi_get_device_flags(sdev,

1056

*bflagsp = scsi_get_device_flags(sdev,

1057

sdev->vendor,

1057

sdev->vendor,

1058

sdev->model);

1058

sdev->model);

1059

return SCSI_SCAN_LUN_PRESENT;

1059

return SCSI_SCAN_LUN_PRESENT;

1060

}

1060

}

1061

scsi_device_put(sdev);

1061

scsi_device_put(sdev);

1062

} else

1062

} else

1063

sdev = scsi_alloc_sdev(starget, lun, hostdata);

1063

sdev = scsi_alloc_sdev(starget, lun, hostdata);

1064

if (!sdev)

1064

if (!sdev)

1065

goto out;

1065

goto out;

1066

1067

result = kmalloc(result_len, GFP_ATOMIC |

1067

result = kmalloc(result_len, GFP_ATOMIC |

1068

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

1068

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

1069

if (!result)

1069

if (!result)

1070

goto out_free_sdev;

1070

goto out_free_sdev;

1071

1072

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

1072

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

1073

goto out_free_result;

1073

goto out_free_result;

1074

1075

if (bflagsp)

1075

if (bflagsp)

1076

*bflagsp = bflags;

1076

*bflagsp = bflags;

1077

/*

1077

/*

1078

* result contains valid SCSI INQUIRY data.

1078

* result contains valid SCSI INQUIRY data.

1079

*/

1079

*/

1080

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

1080

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

1081

/*

1081

/*

1082

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

1082

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

1083

* spec says: The device server is not capable of

1083

* spec says: The device server is not capable of

1084

* supporting a physical device on this logical

1084

* supporting a physical device on this logical

1085

* unit.

1085

* unit.

1086

*

1086

*

1087

* For disks, this implies that there is no

1087

* For disks, this implies that there is no

1088

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

1088

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

1089

* is a target id responding.

1089

* is a target id responding.

1090

*/

1090

*/

1091

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

1091

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

1092

" peripheral qualifier of 3, device not"

1092

" peripheral qualifier of 3, device not"

1093

" added\n"))

1093

" added\n"))

1094

if (lun == 0) {

1094

if (lun == 0) {

1095

SCSI_LOG_SCAN_BUS(1, {

1095

SCSI_LOG_SCAN_BUS(1, {

1096

unsigned char vend[9];

1096

unsigned char vend[9];

1097

unsigned char mod[17];

1097

unsigned char mod[17];

1098

1099

sdev_printk(KERN_INFO, sdev,

1099

sdev_printk(KERN_INFO, sdev,

1100

"scsi scan: consider passing scsi_mod."

1100

"scsi scan: consider passing scsi_mod."

1101

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

1101

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

1102

scsi_inq_str(vend, result, 8, 16),

1102

scsi_inq_str(vend, result, 8, 16),

1103

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

1103

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

1104

});

1104

});

1105

1106

}

1106

}

1107

1108

res = SCSI_SCAN_TARGET_PRESENT;

1108

res = SCSI_SCAN_TARGET_PRESENT;

1109

goto out_free_result;

1109

goto out_free_result;

1110

}

1110

}

1111

1112

/*

1112

/*

1113

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

1113

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

1114

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

1114

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

1115

* Two specific examples are:

1115

* Two specific examples are:

1116

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

1116

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

1117

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

1117

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

1118

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

1118

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

1119

*

1119

*

1120

* References:

1120

* References:

1121

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

1121

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

1122

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

1122

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

1123

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

1123

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

1124

* device server is capable of supporting the specified peripheral

1124

* device server is capable of supporting the specified peripheral

1125

* device type on this logical unit."

1125

* device type on this logical unit."

1126

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

1126

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

1127

* 2) USB UFI 1.0, p. 20

1127

* 2) USB UFI 1.0, p. 20

1128

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

1128

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

1129

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

1129

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

1130

*/

1130

*/

1131

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

1131

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

1132

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

1132

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

1133

!scsi_is_wlun(lun)) {

1133

!scsi_is_wlun(lun)) {

1134

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO

1134

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO

1135

"scsi scan: peripheral device type"

1135

"scsi scan: peripheral device type"

1136

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

1136

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

1137

res = SCSI_SCAN_TARGET_PRESENT;

1137

res = SCSI_SCAN_TARGET_PRESENT;

1138

goto out_free_result;

1138

goto out_free_result;

1139

}

1139

}

1140

1141

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

1141

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

1142

if (res == SCSI_SCAN_LUN_PRESENT) {

1142

if (res == SCSI_SCAN_LUN_PRESENT) {

1143

if (bflags & BLIST_KEY) {

1143

if (bflags & BLIST_KEY) {

1144

sdev->lockable = 0;

1144

sdev->lockable = 0;

1145

scsi_unlock_floptical(sdev, result);

1145

scsi_unlock_floptical(sdev, result);

1146

}

1146

}

1147

}

1147

}

1148

1149

out_free_result:

1149

out_free_result:

1150

kfree(result);

1150

kfree(result);

1151

out_free_sdev:

1151

out_free_sdev:

1152

if (res == SCSI_SCAN_LUN_PRESENT) {

1152

if (res == SCSI_SCAN_LUN_PRESENT) {

1153

if (sdevp) {

1153

if (sdevp) {

1154

if (scsi_device_get(sdev) == 0) {

1154

if (scsi_device_get(sdev) == 0) {

1155

*sdevp = sdev;

1155

*sdevp = sdev;

1156

} else {

1156

} else {

1157

__scsi_remove_device(sdev);

1157

__scsi_remove_device(sdev);

1158

res = SCSI_SCAN_NO_RESPONSE;

1158

res = SCSI_SCAN_NO_RESPONSE;

1159

}

1159

}

1160

}

1160

}

1161

} else

1161

} else

1162

__scsi_remove_device(sdev);

1162

__scsi_remove_device(sdev);

1163

out:

1163

out:

1164

return res;

1164

return res;

1165

}

1165

}

1166

1167

/**

1167

/**

1168

* scsi_sequential_lun_scan - sequentially scan a SCSI target

1168

* scsi_sequential_lun_scan - sequentially scan a SCSI target

1169

* @starget: pointer to target structure to scan

1169

* @starget: pointer to target structure to scan

1170

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

1170

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

1171

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

1171

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

1172

* @rescan: passed to scsi_probe_add_lun()

1172

* @rescan: passed to scsi_probe_add_lun()

1173

*

1173

*

1174

* Description:

1174

* Description:

1175

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

1175

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

1176

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

1176

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

1177

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

1177

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

1178

*

1178

*

1179

* Modifies sdevscan->lun.

1179

* Modifies sdevscan->lun.

1180

**/

1180

**/

1181

static void scsi_sequential_lun_scan(struct scsi_target *starget,

1181

static void scsi_sequential_lun_scan(struct scsi_target *starget,

1182

int bflags, int scsi_level, int rescan)

1182

int bflags, int scsi_level, int rescan)

1183

{

1183

{

1184

unsigned int sparse_lun, lun, max_dev_lun;

1184

unsigned int sparse_lun, lun, max_dev_lun;

1185

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

1185

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

1186

1187

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of"

1187

SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of"

1188

"%s\n", dev_name(&starget->dev)));

1188

"%s\n", dev_name(&starget->dev)));

1189

1190

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

1190

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

1191

/*

1191

/*

1192

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

1192

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

1193

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

1193

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

1194

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

1194

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

1195

*/

1195

*/

1196

if (bflags & BLIST_SPARSELUN) {

1196

if (bflags & BLIST_SPARSELUN) {

1197

max_dev_lun = shost->max_lun;

1197

max_dev_lun = shost->max_lun;

1198

sparse_lun = 1;

1198

sparse_lun = 1;

1199

} else

1199

} else

1200

sparse_lun = 0;

1200

sparse_lun = 0;

1201

1202

/*

1202

/*

1203

* If less than SCSI_1_CSS, and no special lun scaning, stop

1203

* If less than SCSI_1_CSS, and no special lun scaning, stop

1204

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

1204

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

1205

* (to continue scanning a SCSI_1_CSS device).

1205

* (to continue scanning a SCSI_1_CSS device).

1206

*

1206

*

1207

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

1207

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

1208

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

1208

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

1209

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

1209

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

1210

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

1210

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

1211

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

1211

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

1212

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

1212

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

1213

*

1213

*

1214

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

1214

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

1215

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

1215

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

1216

== 0))

1216

== 0))

1217

return;

1217

return;

1218

*/

1218

*/

1219

/*

1219

/*

1220

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

1220

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

1221

* the other settings, and scan all of them.

1221

* the other settings, and scan all of them.

1222

*/

1222

*/

1223

if (bflags & BLIST_FORCELUN)

1223

if (bflags & BLIST_FORCELUN)

1224

max_dev_lun = shost->max_lun;

1224

max_dev_lun = shost->max_lun;

1225

/*

1225

/*

1226

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

1226

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

1227

*/

1227

*/

1228

if (bflags & BLIST_MAX5LUN)

1228

if (bflags & BLIST_MAX5LUN)

1229

max_dev_lun = min(5U, max_dev_lun);

1229

max_dev_lun = min(5U, max_dev_lun);

1230

/*

1230

/*

1231

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

1231

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

1232

* BLIST_LARGELUN.

1232

* BLIST_LARGELUN.

1233

*/

1233

*/

1234

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

1234

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

1235

max_dev_lun = min(8U, max_dev_lun);

1235

max_dev_lun = min(8U, max_dev_lun);

1236

1237

/*

1237

/*

1238

* Stop scanning at 255 unless BLIST_SCSI3LUN

1239

*/

1240

if (!(bflags & BLIST_SCSI3LUN))

1241

max_dev_lun = min(256U, max_dev_lun);

1242

1243

/*

1238

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

1244

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

1239

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

1245

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

1240

* sparse_lun.

1246

* sparse_lun.

1241

*/

1247

*/

1242

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

1248

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

1243

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

1249

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

1244

NULL) != SCSI_SCAN_LUN_PRESENT) &&

1250

NULL) != SCSI_SCAN_LUN_PRESENT) &&

1245

!sparse_lun)

1251

!sparse_lun)

1246

return;

1252

return;

1247

}

1253

}

1248

1254

1249

/**

1255

/**

1250

* scsilun_to_int - convert a scsi_lun to an int

1256

* scsilun_to_int - convert a scsi_lun to an int

1251

* @scsilun: struct scsi_lun to be converted.

1257

* @scsilun: struct scsi_lun to be converted.

1252

*

1258

*

1253

* Description:

1259

* Description:

1254

* Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered

1260

* Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered

1255

* integer, and return the result. The caller must check for

1261

* integer, and return the result. The caller must check for

1256

* truncation before using this function.

1262

* truncation before using this function.

1257

*

1263

*

1258

* Notes:

1264

* Notes:

1259

* The struct scsi_lun is assumed to be four levels, with each level

1265

* The struct scsi_lun is assumed to be four levels, with each level

1260

* effectively containing a SCSI byte-ordered (big endian) short; the

1266

* effectively containing a SCSI byte-ordered (big endian) short; the

1261

* addressing bits of each level are ignored (the highest two bits).

1267

* addressing bits of each level are ignored (the highest two bits).

1262

* For a description of the LUN format, post SCSI-3 see the SCSI

1268

* For a description of the LUN format, post SCSI-3 see the SCSI

1263

* Architecture Model, for SCSI-3 see the SCSI Controller Commands.

1269

* Architecture Model, for SCSI-3 see the SCSI Controller Commands.

1264

*

1270

*

1265

* Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns

1271

* Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns

1266

* the integer: 0x0b030a04

1272

* the integer: 0x0b030a04

1267

**/

1273

**/

1268

int scsilun_to_int(struct scsi_lun *scsilun)

1274

int scsilun_to_int(struct scsi_lun *scsilun)

1269

{

1275

{

1270

int i;

1276

int i;

1271

unsigned int lun;

1277

unsigned int lun;

1272

1278

1273

lun = 0;

1279

lun = 0;

1274

for (i = 0; i < sizeof(lun); i += 2)

1280

for (i = 0; i < sizeof(lun); i += 2)

1275

lun = lun | (((scsilun->scsi_lun[i] << 8) |

1281

lun = lun | (((scsilun->scsi_lun[i] << 8) |

1276

scsilun->scsi_lun[i + 1]) << (i * 8));

1282

scsilun->scsi_lun[i + 1]) << (i * 8));

1277

return lun;

1283

return lun;

1278

}

1284

}

1279

EXPORT_SYMBOL(scsilun_to_int);

1285

EXPORT_SYMBOL(scsilun_to_int);

1280

1286

1281

/**

1287

/**

1282

* int_to_scsilun - reverts an int into a scsi_lun

1288

* int_to_scsilun - reverts an int into a scsi_lun

1283

* @lun: integer to be reverted

1289

* @lun: integer to be reverted

1284

* @scsilun: struct scsi_lun to be set.

1290

* @scsilun: struct scsi_lun to be set.

1285

*

1291

*

1286

* Description:

1292

* Description:

1287

* Reverts the functionality of the scsilun_to_int, which packed

1293

* Reverts the functionality of the scsilun_to_int, which packed

1288

* an 8-byte lun value into an int. This routine unpacks the int

1294

* an 8-byte lun value into an int. This routine unpacks the int

1289

* back into the lun value.

1295

* back into the lun value.

1290

* Note: the scsilun_to_int() routine does not truly handle all

1296

* Note: the scsilun_to_int() routine does not truly handle all

1291

* 8bytes of the lun value. This functions restores only as much

1297

* 8bytes of the lun value. This functions restores only as much

1292

* as was set by the routine.

1298

* as was set by the routine.

1293

*

1299

*

1294

* Notes:

1300

* Notes:

1295

* Given an integer : 0x0b030a04, this function returns a

1301

* Given an integer : 0x0b030a04, this function returns a

1296

* scsi_lun of : struct scsi_lun of: 0a 04 0b 03 00 00 00 00

1302

* scsi_lun of : struct scsi_lun of: 0a 04 0b 03 00 00 00 00

1297

*

1303

*

1298

**/

1304

**/

1299

void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)

1305

void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)

1300

{

1306

{

1301

int i;

1307

int i;

1302

1308

1303

memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));

1309

memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));

1304

1310

1305

for (i = 0; i < sizeof(lun); i += 2) {

1311

for (i = 0; i < sizeof(lun); i += 2) {

1306

scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;

1312

scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;

1307

scsilun->scsi_lun[i+1] = lun & 0xFF;

1313

scsilun->scsi_lun[i+1] = lun & 0xFF;

1308

lun = lun >> 16;

1314

lun = lun >> 16;

1309

}

1315

}

1310

}

1316

}

1311

EXPORT_SYMBOL(int_to_scsilun);

1317

EXPORT_SYMBOL(int_to_scsilun);

1312

1318

1313

/**

1319

/**

1314

* scsi_report_lun_scan - Scan using SCSI REPORT LUN results

1320

* scsi_report_lun_scan - Scan using SCSI REPORT LUN results

1315

* @starget: which target

1321

* @starget: which target

1316

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

1322

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

1317

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

1323

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

1318

*

1324

*

1319

* Description:

1325

* Description:

1320

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

1326

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

1321

* Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.

1327

* Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.

1322

*

1328

*

1323

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

1329

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

1324

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

1330

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

1325

* If BLIST_NOREPORTLUN is set, return 1 always.

1331

* If BLIST_NOREPORTLUN is set, return 1 always.

1326

* If BLIST_NOLUN is set, return 0 always.

1332

* If BLIST_NOLUN is set, return 0 always.

1327

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

1333

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

1328

*

1334

*

1329

* Return:

1335

* Return:

1330

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

1336

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

1331

* 1: could not scan with REPORT LUN

1337

* 1: could not scan with REPORT LUN

1332

**/

1338

**/

1333

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

1339

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

1334

int rescan)

1340

int rescan)

1335

{

1341

{

1336

char devname[64];

1342

char devname[64];

1337

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

1343

unsigned char scsi_cmd[MAX_COMMAND_SIZE];

1338

unsigned int length;

1344

unsigned int length;

1339

unsigned int lun;

1345

unsigned int lun;

1340

unsigned int num_luns;

1346

unsigned int num_luns;

1341

unsigned int retries;

1347

unsigned int retries;

1342

int result;

1348

int result;

1343

struct scsi_lun *lunp, *lun_data;

1349

struct scsi_lun *lunp, *lun_data;

1344

u8 *data;

1350

u8 *data;

1345

struct scsi_sense_hdr sshdr;

1351

struct scsi_sense_hdr sshdr;

1346

struct scsi_device *sdev;

1352

struct scsi_device *sdev;

1347

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

1353

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

1348

int ret = 0;

1354

int ret = 0;

1349

1355

1350

/*

1356

/*

1351

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

1357

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

1352

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

1358

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

1353

* support more than 8 LUNs.

1359

* support more than 8 LUNs.

1354

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

1360

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

1355

*/

1361

*/

1356

if (bflags & BLIST_NOREPORTLUN)

1362

if (bflags & BLIST_NOREPORTLUN)

1357

return 1;

1363

return 1;

1358

if (starget->scsi_level < SCSI_2 &&

1364

if (starget->scsi_level < SCSI_2 &&

1359

starget->scsi_level != SCSI_UNKNOWN)

1365

starget->scsi_level != SCSI_UNKNOWN)

1360

return 1;

1366

return 1;

1361

if (starget->scsi_level < SCSI_3 &&

1367

if (starget->scsi_level < SCSI_3 &&

1362

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

1368

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

1363

return 1;

1369

return 1;

1364

if (bflags & BLIST_NOLUN)

1370

if (bflags & BLIST_NOLUN)

1365

return 0;

1371

return 0;

1366

if (starget->no_report_luns)

1372

if (starget->no_report_luns)

1367

return 1;

1373

return 1;

1368

1374

1369

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

1375

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

1370

sdev = scsi_alloc_sdev(starget, 0, NULL);

1376

sdev = scsi_alloc_sdev(starget, 0, NULL);

1371

if (!sdev)

1377

if (!sdev)

1372

return 0;

1378

return 0;

1373

if (scsi_device_get(sdev)) {

1379

if (scsi_device_get(sdev)) {

1374

__scsi_remove_device(sdev);

1380

__scsi_remove_device(sdev);

1375

return 0;

1381

return 0;

1376

}

1382

}

1377

}

1383

}

1378

1384

1379

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

1385

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

1380

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

1386

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

1381

1387

1382

/*

1388

/*

1383

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

1389

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

1384

* plus the max number of luns we are requesting.

1390

* plus the max number of luns we are requesting.

1385

*

1391

*

1386

* Reallocating and trying again (with the exact amount we need)

1392

* Reallocating and trying again (with the exact amount we need)

1387

* would be nice, but then we need to somehow limit the size

1393

* would be nice, but then we need to somehow limit the size

1388

* allocated based on the available memory and the limits of

1394

* allocated based on the available memory and the limits of

1389

* kmalloc - we don't want a kmalloc() failure of a huge value to

1395

* kmalloc - we don't want a kmalloc() failure of a huge value to

1390

* prevent us from finding any LUNs on this target.

1396

* prevent us from finding any LUNs on this target.

1391

*/

1397

*/

1392

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

1398

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

1393

lun_data = kmalloc(length, GFP_ATOMIC |

1399

lun_data = kmalloc(length, GFP_ATOMIC |

1394

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

1400

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

1395

if (!lun_data) {

1401

if (!lun_data) {

1396

printk(ALLOC_FAILURE_MSG, __func__);

1402

printk(ALLOC_FAILURE_MSG, __func__);

1397

goto out;

1403

goto out;

1398

}

1404

}

1399

1405

1400

scsi_cmd[0] = REPORT_LUNS;

1406

scsi_cmd[0] = REPORT_LUNS;

1401

1407

1402

/*

1408

/*

1403

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

1409

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

1404

*/

1410

*/

1405

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

1411

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

1406

1412

1407

/*

1413

/*

1408

* bytes 6 - 9: length of the command.

1414

* bytes 6 - 9: length of the command.

1409

*/

1415

*/

1410

scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;

1416

scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;

1411

scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;

1417

scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;

1412

scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;

1418

scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;

1413

scsi_cmd[9] = (unsigned char) length & 0xff;

1419

scsi_cmd[9] = (unsigned char) length & 0xff;

1414

1420

1415

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

1421

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

1416

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

1422

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

1417

1423

1418

/*

1424

/*

1419

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

1425

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

1420

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

1426

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

1421

* Experience shows some combinations of adapter/devices get at

1427

* Experience shows some combinations of adapter/devices get at

1422

* least two power on/resets.

1428

* least two power on/resets.

1423

*

1429

*

1424

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

1430

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

1425

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

1431

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

1426

* a retry.

1432

* a retry.

1427

*/

1433

*/

1428

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

1434

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

1429

SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: Sending"

1435

SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: Sending"

1430

" REPORT LUNS to %s (try %d)\n", devname,

1436

" REPORT LUNS to %s (try %d)\n", devname,

1431

retries));

1437

retries));

1432

1438

1433

result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,

1439

result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,

1434

lun_data, length, &sshdr,

1440

lun_data, length, &sshdr,

1435

SCSI_TIMEOUT + 4 * HZ, 3, NULL);

1441

SCSI_TIMEOUT + 4 * HZ, 3, NULL);

1436

1442

1437

SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS"

1443

SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS"

1438

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

1444

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

1439

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

1445

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

1440

if (result == 0)

1446

if (result == 0)

1441

break;

1447

break;

1442

else if (scsi_sense_valid(&sshdr)) {

1448

else if (scsi_sense_valid(&sshdr)) {

1443

if (sshdr.sense_key != UNIT_ATTENTION)

1449

if (sshdr.sense_key != UNIT_ATTENTION)

1444

break;

1450

break;

1445

}

1451

}

1446

}

1452

}

1447

1453

1448

if (result) {

1454

if (result) {

1449

/*

1455

/*

1450

* The device probably does not support a REPORT LUN command

1456

* The device probably does not support a REPORT LUN command

1451

*/

1457

*/

1452

ret = 1;

1458

ret = 1;

1453

goto out_err;

1459

goto out_err;

1454

}

1460

}

1455

1461

1456

/*

1462

/*

1457

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

1463

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

1458

*/

1464

*/

1459

data = (u8 *) lun_data->scsi_lun;

1465

data = (u8 *) lun_data->scsi_lun;

1460

length = ((data[0] << 24) | (data[1] << 16) |

1466

length = ((data[0] << 24) | (data[1] << 16) |

1461

(data[2] << 8) | (data[3] << 0));

1467

(data[2] << 8) | (data[3] << 0));

1462

1468

1463

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

1469

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

1464

if (num_luns > max_scsi_report_luns) {

1470

if (num_luns > max_scsi_report_luns) {

1465

printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)"

1471

printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)"

1466

" of %d luns reported, try increasing"

1472

" of %d luns reported, try increasing"

1467

" max_scsi_report_luns.\n", devname,

1473

" max_scsi_report_luns.\n", devname,

1468

max_scsi_report_luns, num_luns);

1474

max_scsi_report_luns, num_luns);

1469

num_luns = max_scsi_report_luns;

1475

num_luns = max_scsi_report_luns;

1470

}

1476

}

1471

1477

1472

SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,

1478

SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,

1473

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

1479

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

1474

1480

1475

/*

1481

/*

1476

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

1482

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

1477

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

1483

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

1478

*/

1484

*/

1479

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

1485

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

1480

lun = scsilun_to_int(lunp);

1486

lun = scsilun_to_int(lunp);

1481

1487

1482

/*

1488

/*

1483

* Check if the unused part of lunp is non-zero, and so

1489

* Check if the unused part of lunp is non-zero, and so

1484

* does not fit in lun.

1490

* does not fit in lun.

1485

*/

1491

*/

1486

if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) {

1492

if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) {

1487

int i;

1493

int i;

1488

1494

1489

/*

1495

/*

1490

* Output an error displaying the LUN in byte order,

1496

* Output an error displaying the LUN in byte order,

1491

* this differs from what linux would print for the

1497

* this differs from what linux would print for the

1492

* integer LUN value.

1498

* integer LUN value.

1493

*/

1499

*/

1494

printk(KERN_WARNING "scsi: %s lun 0x", devname);

1500

printk(KERN_WARNING "scsi: %s lun 0x", devname);

1495

data = (char *)lunp->scsi_lun;

1501

data = (char *)lunp->scsi_lun;

1496

for (i = 0; i < sizeof(struct scsi_lun); i++)

1502

for (i = 0; i < sizeof(struct scsi_lun); i++)

1497

printk("%02x", data[i]);

1503

printk("%02x", data[i]);

1498

printk(" has a LUN larger than currently supported.\n");

1504

printk(" has a LUN larger than currently supported.\n");

1499

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

1505

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

1500

printk(KERN_WARNING "scsi: %s lun%d has a LUN larger"

1506

printk(KERN_WARNING "scsi: %s lun%d has a LUN larger"

1501

" than allowed by the host adapter\n",

1507

" than allowed by the host adapter\n",

1502

devname, lun);

1508

devname, lun);

1503

} else {

1509

} else {

1504

int res;

1510

int res;

1505

1511

1506

res = scsi_probe_and_add_lun(starget,

1512

res = scsi_probe_and_add_lun(starget,

1507

lun, NULL, NULL, rescan, NULL);

1513

lun, NULL, NULL, rescan, NULL);

1508

if (res == SCSI_SCAN_NO_RESPONSE) {

1514

if (res == SCSI_SCAN_NO_RESPONSE) {

1509

/*

1515

/*

1510

* Got some results, but now none, abort.

1516

* Got some results, but now none, abort.

1511

*/

1517

*/

1512

sdev_printk(KERN_ERR, sdev,

1518

sdev_printk(KERN_ERR, sdev,

1513

"Unexpected response"

1519

"Unexpected response"

1514

" from lun %d while scanning, scan"

1520

" from lun %d while scanning, scan"

1515

" aborted\n", lun);

1521

" aborted\n", lun);

1516

break;

1522

break;

1517

}

1523

}

1518

}

1524

}

1519

}

1525

}

1520

1526

1521

out_err:

1527

out_err:

1522

kfree(lun_data);

1528

kfree(lun_data);

1523

out:

1529

out:

1524

scsi_device_put(sdev);

1530

scsi_device_put(sdev);

1525

if (scsi_device_created(sdev))

1531

if (scsi_device_created(sdev))

1526

/*

1532

/*

1527

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

1533

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

1528

*/

1534

*/

1529

__scsi_remove_device(sdev);

1535

__scsi_remove_device(sdev);

1530

return ret;

1536

return ret;

1531

}

1537

}

1532

1538

1533

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

1539

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

1534

uint id, uint lun, void *hostdata)

1540

uint id, uint lun, void *hostdata)

1535

{

1541

{

1536

struct scsi_device *sdev = ERR_PTR(-ENODEV);

1542

struct scsi_device *sdev = ERR_PTR(-ENODEV);

1537

struct device *parent = &shost->shost_gendev;

1543

struct device *parent = &shost->shost_gendev;

1538

struct scsi_target *starget;

1544

struct scsi_target *starget;

1539

1545

1540

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

1546

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

1541

return ERR_PTR(-ENODEV);

1547

return ERR_PTR(-ENODEV);

1542

1548

1543

starget = scsi_alloc_target(parent, channel, id);

1549

starget = scsi_alloc_target(parent, channel, id);

1544

if (!starget)

1550

if (!starget)

1545

return ERR_PTR(-ENOMEM);

1551

return ERR_PTR(-ENOMEM);

1546

scsi_autopm_get_target(starget);

1552

scsi_autopm_get_target(starget);

1547

1553

1548

mutex_lock(&shost->scan_mutex);

1554

mutex_lock(&shost->scan_mutex);

1549

if (!shost->async_scan)

1555

if (!shost->async_scan)

1550

scsi_complete_async_scans();

1556

scsi_complete_async_scans();

1551

1557

1552

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

1558

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

1553

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

1559

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

1554

scsi_autopm_put_host(shost);

1560

scsi_autopm_put_host(shost);

1555

}

1561

}

1556

mutex_unlock(&shost->scan_mutex);

1562

mutex_unlock(&shost->scan_mutex);

1557

scsi_autopm_put_target(starget);

1563

scsi_autopm_put_target(starget);

1558

/*

1564

/*

1559

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

1565

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

1560

* scsi_probe_and_add_lun made an underlying device visible

1566

* scsi_probe_and_add_lun made an underlying device visible

1561

*/

1567

*/

1562

scsi_target_reap(starget);

1568

scsi_target_reap(starget);

1563

put_device(&starget->dev);

1569

put_device(&starget->dev);

1564

1570

1565

return sdev;

1571

return sdev;

1566

}

1572

}

1567

EXPORT_SYMBOL(__scsi_add_device);

1573

EXPORT_SYMBOL(__scsi_add_device);

1568

1574

1569

int scsi_add_device(struct Scsi_Host *host, uint channel,

1575

int scsi_add_device(struct Scsi_Host *host, uint channel,

1570

uint target, uint lun)

1576

uint target, uint lun)

1571

{

1577

{

1572

struct scsi_device *sdev =

1578

struct scsi_device *sdev =

1573

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

1579

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

1574

if (IS_ERR(sdev))

1580

if (IS_ERR(sdev))

1575

return PTR_ERR(sdev);

1581

return PTR_ERR(sdev);

1576

1582

1577

scsi_device_put(sdev);

1583

scsi_device_put(sdev);

1578

return 0;

1584

return 0;

1579

}

1585

}

1580

EXPORT_SYMBOL(scsi_add_device);

1586

EXPORT_SYMBOL(scsi_add_device);

1581

1587

1582

void scsi_rescan_device(struct device *dev)

1588

void scsi_rescan_device(struct device *dev)

1583

{

1589

{

1584

struct scsi_driver *drv;

1590

struct scsi_driver *drv;

1585

1591

1586

if (!dev->driver)

1592

if (!dev->driver)

1587

return;

1593

return;

1588

1594

1589

drv = to_scsi_driver(dev->driver);

1595

drv = to_scsi_driver(dev->driver);

1590

if (try_module_get(drv->owner)) {

1596

if (try_module_get(drv->owner)) {

1591

if (drv->rescan)

1597

if (drv->rescan)

1592

drv->rescan(dev);

1598

drv->rescan(dev);

1593

module_put(drv->owner);

1599

module_put(drv->owner);

1594

}

1600

}

1595

}

1601

}

1596

EXPORT_SYMBOL(scsi_rescan_device);

1602

EXPORT_SYMBOL(scsi_rescan_device);

1597

1603

1598

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

1604

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

1599

unsigned int id, unsigned int lun, int rescan)

1605

unsigned int id, unsigned int lun, int rescan)

1600

{

1606

{

1601

struct Scsi_Host *shost = dev_to_shost(parent);

1607

struct Scsi_Host *shost = dev_to_shost(parent);

1602

int bflags = 0;

1608

int bflags = 0;

1603

int res;

1609

int res;

1604

struct scsi_target *starget;

1610

struct scsi_target *starget;

1605

1611

1606

if (shost->this_id == id)

1612

if (shost->this_id == id)

1607

/*

1613

/*

1608

* Don't scan the host adapter

1614

* Don't scan the host adapter

1609

*/

1615

*/

1610

return;

1616

return;

1611

1617

1612

starget = scsi_alloc_target(parent, channel, id);

1618

starget = scsi_alloc_target(parent, channel, id);

1613

if (!starget)

1619

if (!starget)

1614

return;

1620

return;

1615

scsi_autopm_get_target(starget);

1621

scsi_autopm_get_target(starget);

1616

1622

1617

if (lun != SCAN_WILD_CARD) {

1623

if (lun != SCAN_WILD_CARD) {

1618

/*

1624

/*

1619

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

1625

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

1620

*/

1626

*/

1621

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

1627

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

1622

goto out_reap;

1628

goto out_reap;

1623

}

1629

}

1624

1630

1625

/*

1631

/*

1626

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

1632

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

1627

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

1633

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

1628

*/

1634

*/

1629

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

1635

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

1630

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

1636

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

1631

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

1637

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

1632

/*

1638

/*

1633

* The REPORT LUN did not scan the target,

1639

* The REPORT LUN did not scan the target,

1634

* do a sequential scan.

1640

* do a sequential scan.

1635

*/

1641

*/

1636

scsi_sequential_lun_scan(starget, bflags,

1642

scsi_sequential_lun_scan(starget, bflags,

1637

starget->scsi_level, rescan);

1643

starget->scsi_level, rescan);

1638

}

1644

}

1639

1645

1640

out_reap:

1646

out_reap:

1641

scsi_autopm_put_target(starget);

1647

scsi_autopm_put_target(starget);

1642

/*

1648

/*

1643

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

1649

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

1644

* any children at all and if not, nuke it

1650

* any children at all and if not, nuke it

1645

*/

1651

*/

1646

scsi_target_reap(starget);

1652

scsi_target_reap(starget);

1647

1653

1648

put_device(&starget->dev);

1654

put_device(&starget->dev);

1649

}

1655

}

1650

1656

1651

/**

1657

/**

1652

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

1658

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

1653

* @parent: host to scan

1659

* @parent: host to scan

1654

* @channel: channel to scan

1660

* @channel: channel to scan

1655

* @id: target id to scan

1661

* @id: target id to scan

1656

* @lun: Specific LUN to scan or SCAN_WILD_CARD

1662

* @lun: Specific LUN to scan or SCAN_WILD_CARD

1657

* @rescan: passed to LUN scanning routines

1663

* @rescan: passed to LUN scanning routines

1658

*

1664

*

1659

* Description:

1665

* Description:

1660

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

1666

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

1661

* and possibly all LUNs on the target id.

1667

* and possibly all LUNs on the target id.

1662

*

1668

*

1663

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

1669

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

1664

* sequential scan of LUNs on the target id.

1670

* sequential scan of LUNs on the target id.

1665

**/

1671

**/

1666

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

1672

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

1667

unsigned int id, unsigned int lun, int rescan)

1673

unsigned int id, unsigned int lun, int rescan)

1668

{

1674

{

1669

struct Scsi_Host *shost = dev_to_shost(parent);

1675

struct Scsi_Host *shost = dev_to_shost(parent);

1670

1676

1671

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

1677

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

1672

return;

1678

return;

1673

1679

1674

mutex_lock(&shost->scan_mutex);

1680

mutex_lock(&shost->scan_mutex);

1675

if (!shost->async_scan)

1681

if (!shost->async_scan)

1676

scsi_complete_async_scans();

1682

scsi_complete_async_scans();

1677

1683

1678

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

1684

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

1679

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

1685

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

1680

scsi_autopm_put_host(shost);

1686

scsi_autopm_put_host(shost);

1681

}

1687

}

1682

mutex_unlock(&shost->scan_mutex);

1688

mutex_unlock(&shost->scan_mutex);

1683

}

1689

}

1684

EXPORT_SYMBOL(scsi_scan_target);

1690

EXPORT_SYMBOL(scsi_scan_target);

1685

1691

1686

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

1692

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

1687

unsigned int id, unsigned int lun, int rescan)

1693

unsigned int id, unsigned int lun, int rescan)

1688

{

1694

{

1689

uint order_id;

1695

uint order_id;

1690

1696

1691

if (id == SCAN_WILD_CARD)

1697

if (id == SCAN_WILD_CARD)

1692

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

1698

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

1693

/*

1699

/*

1694

* XXX adapter drivers when possible (FCP, iSCSI)

1700

* XXX adapter drivers when possible (FCP, iSCSI)

1695

* could modify max_id to match the current max,

1701

* could modify max_id to match the current max,

1696

* not the absolute max.

1702

* not the absolute max.

1697

*

1703

*

1698

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

1704

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

1699

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

1705

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

1700

* without a huge overhead of sparse id's.

1706

* without a huge overhead of sparse id's.

1701

*/

1707

*/

1702

if (shost->reverse_ordering)

1708

if (shost->reverse_ordering)

1703

/*

1709

/*

1704

* Scan from high to low id.

1710

* Scan from high to low id.

1705

*/

1711

*/

1706

order_id = shost->max_id - id - 1;

1712

order_id = shost->max_id - id - 1;

1707

else

1713

else

1708

order_id = id;

1714

order_id = id;

1709

__scsi_scan_target(&shost->shost_gendev, channel,

1715

__scsi_scan_target(&shost->shost_gendev, channel,

1710

order_id, lun, rescan);

1716

order_id, lun, rescan);

1711

}

1717

}

1712

else

1718

else

1713

__scsi_scan_target(&shost->shost_gendev, channel,

1719

__scsi_scan_target(&shost->shost_gendev, channel,

1714

id, lun, rescan);

1720

id, lun, rescan);

1715

}

1721

}

1716

1722

1717

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

1723

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

1718

unsigned int id, unsigned int lun, int rescan)

1724

unsigned int id, unsigned int lun, int rescan)

1719

{

1725

{

1720

SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,

1726

SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,

1721

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

1727

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

1722

__func__, channel, id, lun));

1728

__func__, channel, id, lun));

1723

1729

1724

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

1730

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

1725

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

1731

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

1726

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

1732

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

1727

return -EINVAL;

1733

return -EINVAL;

1728

1734

1729

mutex_lock(&shost->scan_mutex);

1735

mutex_lock(&shost->scan_mutex);

1730

if (!shost->async_scan)

1736

if (!shost->async_scan)

1731

scsi_complete_async_scans();

1737

scsi_complete_async_scans();

1732

1738

1733

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

1739

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

1734

if (channel == SCAN_WILD_CARD)

1740

if (channel == SCAN_WILD_CARD)

1735

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

1741

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

1736

channel++)

1742

channel++)

1737

scsi_scan_channel(shost, channel, id, lun,

1743

scsi_scan_channel(shost, channel, id, lun,

1738

rescan);

1744

rescan);

1739

else

1745

else

1740

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

1746

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

1741

scsi_autopm_put_host(shost);

1747

scsi_autopm_put_host(shost);

1742

}

1748

}

1743

mutex_unlock(&shost->scan_mutex);

1749

mutex_unlock(&shost->scan_mutex);

1744

1750

1745

return 0;

1751

return 0;

1746

}

1752

}

1747

1753

1748

static void scsi_sysfs_add_devices(struct Scsi_Host *shost)

1754

static void scsi_sysfs_add_devices(struct Scsi_Host *shost)

1749

{

1755

{

1750

struct scsi_device *sdev;

1756

struct scsi_device *sdev;

1751

shost_for_each_device(sdev, shost) {

1757

shost_for_each_device(sdev, shost) {

1752

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

1758

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

1753

if (sdev->sdev_state == SDEV_DEL)

1759

if (sdev->sdev_state == SDEV_DEL)

1754

continue;

1760

continue;

1755

if (!scsi_host_scan_allowed(shost) ||

1761

if (!scsi_host_scan_allowed(shost) ||

1756

scsi_sysfs_add_sdev(sdev) != 0)

1762

scsi_sysfs_add_sdev(sdev) != 0)

1757

__scsi_remove_device(sdev);

1763

__scsi_remove_device(sdev);

1758

}

1764

}

1759

}

1765

}

1760

1766

1761

/**

1767

/**

1762

* scsi_prep_async_scan - prepare for an async scan

1768

* scsi_prep_async_scan - prepare for an async scan

1763

* @shost: the host which will be scanned

1769

* @shost: the host which will be scanned

1764

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

1770

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

1765

*

1771

*

1766

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

1772

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

1767

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

1773

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

1768

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

1774

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

1769

* ordering of the discovered devices.

1775

* ordering of the discovered devices.

1770

*/

1776

*/

1771

static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)

1777

static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)

1772

{

1778

{

1773

struct async_scan_data *data;

1779

struct async_scan_data *data;

1774

unsigned long flags;

1780

unsigned long flags;

1775

1781

1776

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

1782

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

1777

return NULL;

1783

return NULL;

1778

1784

1779

if (shost->async_scan) {

1785

if (shost->async_scan) {

1780

printk("%s called twice for host %d", __func__,

1786

printk("%s called twice for host %d", __func__,

1781

shost->host_no);

1787

shost->host_no);

1782

dump_stack();

1788

dump_stack();

1783

return NULL;

1789

return NULL;

1784

}

1790

}

1785

1791

1786

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

1792

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

1787

if (!data)

1793

if (!data)

1788

goto err;

1794

goto err;

1789

data->shost = scsi_host_get(shost);

1795

data->shost = scsi_host_get(shost);

1790

if (!data->shost)

1796

if (!data->shost)

1791

goto err;

1797

goto err;

1792

init_completion(&data->prev_finished);

1798

init_completion(&data->prev_finished);

1793

1799

1794

mutex_lock(&shost->scan_mutex);

1800

mutex_lock(&shost->scan_mutex);

1795

spin_lock_irqsave(shost->host_lock, flags);

1801

spin_lock_irqsave(shost->host_lock, flags);

1796

shost->async_scan = 1;

1802

shost->async_scan = 1;

1797

spin_unlock_irqrestore(shost->host_lock, flags);

1803

spin_unlock_irqrestore(shost->host_lock, flags);

1798

mutex_unlock(&shost->scan_mutex);

1804

mutex_unlock(&shost->scan_mutex);

1799

1805

1800

spin_lock(&async_scan_lock);

1806

spin_lock(&async_scan_lock);

1801

if (list_empty(&scanning_hosts))

1807

if (list_empty(&scanning_hosts))

1802

complete(&data->prev_finished);

1808

complete(&data->prev_finished);

1803

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

1809

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

1804

spin_unlock(&async_scan_lock);

1810

spin_unlock(&async_scan_lock);

1805

1811

1806

return data;

1812

return data;

1807

1813

1808

err:

1814

err:

1809

kfree(data);

1815

kfree(data);

1810

return NULL;

1816

return NULL;

1811

}

1817

}

1812

1818

1813

/**

1819

/**

1814

* scsi_finish_async_scan - asynchronous scan has finished

1820

* scsi_finish_async_scan - asynchronous scan has finished

1815

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

1821

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

1816

*

1822

*

1817

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

1823

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

1818

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

1824

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

1819

* of the system.

1825

* of the system.

1820

*/

1826

*/

1821

static void scsi_finish_async_scan(struct async_scan_data *data)

1827

static void scsi_finish_async_scan(struct async_scan_data *data)

1822

{

1828

{

1823

struct Scsi_Host *shost;

1829

struct Scsi_Host *shost;

1824

unsigned long flags;

1830

unsigned long flags;

1825

1831

1826

if (!data)

1832

if (!data)

1827

return;

1833

return;

1828

1834

1829

shost = data->shost;

1835

shost = data->shost;

1830

1836

1831

mutex_lock(&shost->scan_mutex);

1837

mutex_lock(&shost->scan_mutex);

1832

1838

1833

if (!shost->async_scan) {

1839

if (!shost->async_scan) {

1834

printk("%s called twice for host %d", __func__,

1840

printk("%s called twice for host %d", __func__,

1835

shost->host_no);

1841

shost->host_no);

1836

dump_stack();

1842

dump_stack();

1837

mutex_unlock(&shost->scan_mutex);

1843

mutex_unlock(&shost->scan_mutex);

1838

return;

1844

return;

1839

}

1845

}

1840

1846

1841

wait_for_completion(&data->prev_finished);

1847

wait_for_completion(&data->prev_finished);

1842

1848

1843

scsi_sysfs_add_devices(shost);

1849

scsi_sysfs_add_devices(shost);

1844

1850

1845

spin_lock_irqsave(shost->host_lock, flags);

1851

spin_lock_irqsave(shost->host_lock, flags);

1846

shost->async_scan = 0;

1852

shost->async_scan = 0;

1847

spin_unlock_irqrestore(shost->host_lock, flags);

1853

spin_unlock_irqrestore(shost->host_lock, flags);

1848

1854

1849

mutex_unlock(&shost->scan_mutex);

1855

mutex_unlock(&shost->scan_mutex);

1850

1856

1851

spin_lock(&async_scan_lock);

1857

spin_lock(&async_scan_lock);

1852

list_del(&data->list);

1858

list_del(&data->list);

1853

if (!list_empty(&scanning_hosts)) {

1859

if (!list_empty(&scanning_hosts)) {

1854

struct async_scan_data *next = list_entry(scanning_hosts.next,

1860

struct async_scan_data *next = list_entry(scanning_hosts.next,

1855

struct async_scan_data, list);

1861

struct async_scan_data, list);

1856

complete(&next->prev_finished);

1862

complete(&next->prev_finished);

1857

}

1863

}

1858

spin_unlock(&async_scan_lock);

1864

spin_unlock(&async_scan_lock);

1859

1865

1860

scsi_autopm_put_host(shost);

1866

scsi_autopm_put_host(shost);

1861

scsi_host_put(shost);

1867

scsi_host_put(shost);

1862

kfree(data);

1868

kfree(data);

1863

}

1869

}

1864

1870

1865

static void do_scsi_scan_host(struct Scsi_Host *shost)

1871

static void do_scsi_scan_host(struct Scsi_Host *shost)

1866

{

1872

{

1867

if (shost->hostt->scan_finished) {

1873

if (shost->hostt->scan_finished) {

1868

unsigned long start = jiffies;

1874

unsigned long start = jiffies;

1869

if (shost->hostt->scan_start)

1875

if (shost->hostt->scan_start)

1870

shost->hostt->scan_start(shost);

1876

shost->hostt->scan_start(shost);

1871

1877

1872

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

1878

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

1873

msleep(10);

1879

msleep(10);

1874

} else {

1880

} else {

1875

scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,

1881

scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,

1876

SCAN_WILD_CARD, 0);

1882

SCAN_WILD_CARD, 0);

1877

}

1883

}

1878

}

1884

}

1879

1885

1880

static void do_scan_async(void *_data, async_cookie_t c)

1886

static void do_scan_async(void *_data, async_cookie_t c)

1881

{

1887

{

1882

struct async_scan_data *data = _data;

1888

struct async_scan_data *data = _data;

1883

struct Scsi_Host *shost = data->shost;

1889

struct Scsi_Host *shost = data->shost;

1884

1890

1885

do_scsi_scan_host(shost);

1891

do_scsi_scan_host(shost);

1886

scsi_finish_async_scan(data);

1892

scsi_finish_async_scan(data);

1887

}

1893

}

1888

1894

1889

/**

1895

/**

1890

* scsi_scan_host - scan the given adapter

1896

* scsi_scan_host - scan the given adapter

1891

* @shost: adapter to scan

1897

* @shost: adapter to scan

1892

**/

1898

**/

1893

void scsi_scan_host(struct Scsi_Host *shost)

1899

void scsi_scan_host(struct Scsi_Host *shost)

1894

{

1900

{

1895

struct async_scan_data *data;

1901

struct async_scan_data *data;

1896

1902

1897

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

1903

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

1898

return;

1904

return;

1899

if (scsi_autopm_get_host(shost) < 0)

1905

if (scsi_autopm_get_host(shost) < 0)

1900

return;

1906

return;

1901

1907

1902

data = scsi_prep_async_scan(shost);

1908

data = scsi_prep_async_scan(shost);

1903

if (!data) {

1909

if (!data) {

1904

do_scsi_scan_host(shost);

1910

do_scsi_scan_host(shost);

1905

scsi_autopm_put_host(shost);

1911

scsi_autopm_put_host(shost);

1906

return;

1912

return;

1907

}

1913

}

1908

1914

1909

/* register with the async subsystem so wait_for_device_probe()

1915

/* register with the async subsystem so wait_for_device_probe()

1910

* will flush this work

1916

* will flush this work

1911

*/

1917

*/

1912

async_schedule(do_scan_async, data);

1918

async_schedule(do_scan_async, data);

1913

1919

1914

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

1920

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

1915

}

1921

}

1916

EXPORT_SYMBOL(scsi_scan_host);

1922

EXPORT_SYMBOL(scsi_scan_host);

1917

1923

1918

void scsi_forget_host(struct Scsi_Host *shost)

1924

void scsi_forget_host(struct Scsi_Host *shost)

1919

{

1925

{

1920

struct scsi_device *sdev;

1926

struct scsi_device *sdev;

1921

unsigned long flags;

1927

unsigned long flags;

1922

1928

1923

restart:

1929

restart:

1924

spin_lock_irqsave(shost->host_lock, flags);

1930

spin_lock_irqsave(shost->host_lock, flags);

1925

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

1931

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

1926

if (sdev->sdev_state == SDEV_DEL)

1932

if (sdev->sdev_state == SDEV_DEL)

1927

continue;

1933

continue;

1928

spin_unlock_irqrestore(shost->host_lock, flags);

1934

spin_unlock_irqrestore(shost->host_lock, flags);

1929

__scsi_remove_device(sdev);

1935

__scsi_remove_device(sdev);

1930

goto restart;

1936

goto restart;

1931

}

1937

}

1932

spin_unlock_irqrestore(shost->host_lock, flags);

1938

spin_unlock_irqrestore(shost->host_lock, flags);

1933

}

1939

}

1934

1940

1935

/**

1941

/**

1936

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

1942

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

1937

* @shost: Host that needs a scsi_device

1943

* @shost: Host that needs a scsi_device

1938

*

1944

*

1939

* Lock status: None assumed.

1945

* Lock status: None assumed.

1940

*

1946

*

1941

* Returns: The scsi_device or NULL

1947

* Returns: The scsi_device or NULL

1942

*

1948

*

1943

* Notes:

1949

* Notes:

1944

* Attach a single scsi_device to the Scsi_Host - this should

1950

* Attach a single scsi_device to the Scsi_Host - this should

1945

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

1951

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

1946

* HA itself.

1952

* HA itself.

1947

*

1953

*

1948

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

1954

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

1949

* drivers (including generics), which is probably not

1955

* drivers (including generics), which is probably not

1950

* optimal. We can add hooks later to attach.

1956

* optimal. We can add hooks later to attach.

1951

*/

1957

*/

1952

struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)

1958

struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)

1953

{

1959

{

1954

struct scsi_device *sdev = NULL;

1960

struct scsi_device *sdev = NULL;

1955

struct scsi_target *starget;

1961

struct scsi_target *starget;

1956

1962

1957

mutex_lock(&shost->scan_mutex);

1963

mutex_lock(&shost->scan_mutex);

1958

if (!scsi_host_scan_allowed(shost))

1964

if (!scsi_host_scan_allowed(shost))

1959

goto out;

1965

goto out;

1960

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

1966

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

1961

if (!starget)

1967

if (!starget)

1962

goto out;

1968

goto out;

1963

1969

1964

sdev = scsi_alloc_sdev(starget, 0, NULL);

1970

sdev = scsi_alloc_sdev(starget, 0, NULL);

1965

if (sdev)

1971

if (sdev)

1966

sdev->borken = 0;

1972

sdev->borken = 0;

1967

else

1973

else

1968

scsi_target_reap(starget);

1974

scsi_target_reap(starget);

1969

put_device(&starget->dev);

1975

put_device(&starget->dev);

1970

out:

1976

out:

1971

mutex_unlock(&shost->scan_mutex);

1977

mutex_unlock(&shost->scan_mutex);

1972

return sdev;

1978

return sdev;

1973

}

1979

}

1974

EXPORT_SYMBOL(scsi_get_host_dev);

1980

EXPORT_SYMBOL(scsi_get_host_dev);

1975

1981

1976

/**

1982

/**

1977

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

1983

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

1978

* @sdev: Host device to be freed

1984

* @sdev: Host device to be freed

1979

*

1985

*

1980

* Lock status: None assumed.

1986

* Lock status: None assumed.

1981

*

1987

*

1982

* Returns: Nothing

1988

* Returns: Nothing

1983

*/

1989

*/

1984

void scsi_free_host_dev(struct scsi_device *sdev)

1990

void scsi_free_host_dev(struct scsi_device *sdev)

1985

{

1991

{

1986

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

1992

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

1987

1993

1988

__scsi_remove_device(sdev);

1994

__scsi_remove_device(sdev);

1989

}

1995

}

1990

EXPORT_SYMBOL(scsi_free_host_dev);

1996

EXPORT_SYMBOL(scsi_free_host_dev);

1991

1997

1992

1998

 #ifndef _SCSI_SCSI_DEVINFO_H
 #define _SCSI_SCSI_DEVINFO_H
 /*
  * Flags for SCSI devices that need special treatment
  */
 #define BLIST_NOLUN     	0x001	/* Only scan LUN 0 */
 #define BLIST_FORCELUN  	0x002	/* Known to have LUNs, force scanning,
 					   deprecated: Use max_luns=N */
 #define BLIST_BORKEN    	0x004	/* Flag for broken handshaking */
 #define BLIST_KEY       	0x008	/* unlock by special command */
 #define BLIST_SINGLELUN 	0x010	/* Do not use LUNs in parallel */
 #define BLIST_NOTQ		0x020	/* Buggy Tagged Command Queuing */
 #define BLIST_SPARSELUN 	0x040	/* Non consecutive LUN numbering */
 #define BLIST_MAX5LUN		0x080	/* Avoid LUNS >= 5 */
 #define BLIST_ISROM     	0x100	/* Treat as (removable) CD-ROM */
 #define BLIST_LARGELUN		0x200	/* LUNs past 7 on a SCSI-2 device */
 #define BLIST_INQUIRY_36	0x400	/* override additional length field */
 #define BLIST_INQUIRY_58	0x800	/* ... for broken inquiry responses */
 #define BLIST_NOSTARTONADD	0x1000	/* do not do automatic start on add */
 #define BLIST_MS_SKIP_PAGE_08	0x2000	/* do not send ms page 0x08 */
 #define BLIST_MS_SKIP_PAGE_3F	0x4000	/* do not send ms page 0x3f */
 #define BLIST_USE_10_BYTE_MS	0x8000	/* use 10 byte ms before 6 byte ms */
 #define BLIST_MS_192_BYTES_FOR_3F	0x10000	/*  192 byte ms page 0x3f request */
 #define BLIST_REPORTLUN2	0x20000	/* try REPORT_LUNS even for SCSI-2 devs
  					   (if HBA supports more than 8 LUNs) */
 #define BLIST_NOREPORTLUN	0x40000	/* don't try REPORT_LUNS scan (SCSI-3 devs) */
 #define BLIST_NOT_LOCKABLE	0x80000	/* don't use PREVENT-ALLOW commands */
 #define BLIST_NO_ULD_ATTACH	0x100000 /* device is actually for RAID config */
 #define BLIST_SELECT_NO_ATN	0x200000 /* select without ATN */
 #define BLIST_RETRY_HWERROR	0x400000 /* retry HARDWARE_ERROR */
 #define BLIST_MAX_512		0x800000 /* maximum 512 sector cdb length */
 #define BLIST_ATTACH_PQ3	0x1000000 /* Scan: Attach to PQ3 devices */
 #define BLIST_NO_DIF		0x2000000 /* Disable T10 PI (DIF) */
 #define BLIST_SKIP_VPD_PAGES	0x4000000 /* Ignore SBC-3 VPD pages */
+#define BLIST_SCSI3LUN		0x8000000 /* Scan more than 256 LUNs
+					     for sequential scan */
 #endif

GITLAB

scsi_scan: Restrict sequential scan to 256 LUNs

 /*
  * 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 <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)
 /*
  * 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 unsigned int max_scsi_luns = MAX_SCSI_LUNS;
 module_param_named(max_luns, max_scsi_luns, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(max_luns,
 		 "last scsi LUN (should be between 1 and 2^32-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");
 /*
  * max_scsi_report_luns: the maximum number of LUNS that will be
  * returned from the REPORT LUNS command. 8 times this value must
  * be allocated. In theory this could be up to an 8 byte value, but
  * in practice, the maximum number of LUNs suppored by any device
  * is about 16k.
  */
 static unsigned int max_scsi_report_luns = 511;
 module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(max_report_luns,
 		 "REPORT LUNS maximum number of LUNS received (should be"
 		 " between 1 and 16384)");
 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];
 	printk(KERN_NOTICE "scsi: 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,
 					   unsigned int 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;
 	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;
 	scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
 	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;
 	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, printk(KERN_INFO "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) {
 		printk(KERN_INFO "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) {
 		printk(KERN_INFO "scsi scan: INQUIRY result too short (%d),"
 				" using 36\n", sdev->inquiry_len);
 		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;
 	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;
 	}
 	switch (sdev->type) {
 	case TYPE_RBC:
 	case TYPE_TAPE:
 	case TYPE_DISK:
 	case TYPE_PRINTER:
 	case TYPE_MOD:
 	case TYPE_PROCESSOR:
 	case TYPE_SCANNER:
 	case TYPE_MEDIUM_CHANGER:
 	case TYPE_ENCLOSURE:
 	case TYPE_COMM:
 	case TYPE_RAID:
 	case TYPE_OSD:
 		sdev->writeable = 1;
 		break;
 	case TYPE_ROM:
 	case TYPE_WORM:
 		sdev->writeable = 0;
 		break;
 	default:
 		printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type);
 	}
 	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;
 	/*
 	 * 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);
 	/*
 	 * 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;
 	/* 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_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,
 				  uint 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, printk(KERN_INFO
 				"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, printk(KERN_INFO
 					"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)
 {
 	unsigned int sparse_lun, lun, max_dev_lun;
 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 	SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of"
 				    "%s\n", dev_name(&starget->dev)));
 	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_CSS, and no special lun scaning, stop
 	 * scanning; this matches 2.4 behaviour, but could just be a bug
 	 * (to continue scanning a SCSI_1_CSS 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;
 }
 /**
  * scsilun_to_int - convert a scsi_lun to an int
  * @scsilun:	struct scsi_lun to be converted.
  *
  * Description:
  *     Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered
  *     integer, and return the result. The caller must check for
  *     truncation before using this function.
  *
  * Notes:
  *     The struct scsi_lun is assumed to be four levels, with each level
  *     effectively containing a SCSI byte-ordered (big endian) short; the
  *     addressing bits of each level are ignored (the highest two bits).
  *     For a description of the LUN format, post SCSI-3 see the SCSI
  *     Architecture Model, for SCSI-3 see the SCSI Controller Commands.
  *
  *     Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns
  *     the integer: 0x0b030a04
  **/
 int scsilun_to_int(struct scsi_lun *scsilun)
 {
 	int i;
 	unsigned int lun;
 	lun = 0;
 	for (i = 0; i < sizeof(lun); i += 2)
 		lun = lun | (((scsilun->scsi_lun[i] << 8) |
 			      scsilun->scsi_lun[i + 1]) << (i * 8));
 	return lun;
 }
 EXPORT_SYMBOL(scsilun_to_int);
 /**
  * int_to_scsilun - reverts an int into a scsi_lun
  * @lun:        integer to be reverted
  * @scsilun:	struct scsi_lun to be set.
  *
  * Description:
  *     Reverts the functionality of the scsilun_to_int, which packed
  *     an 8-byte lun value into an int. This routine unpacks the int
  *     back into the lun value.
  *     Note: the scsilun_to_int() routine does not truly handle all
  *     8bytes of the lun value. This functions restores only as much
  *     as was set by the routine.
  *
  * Notes:
  *     Given an integer : 0x0b030a04,  this function returns a
  *     scsi_lun of : struct scsi_lun of: 0a 04 0b 03 00 00 00 00
  *
  **/
 void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)
 {
 	int i;
 	memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));
 	for (i = 0; i < sizeof(lun); i += 2) {
 		scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
 		scsilun->scsi_lun[i+1] = lun & 0xFF;
 		lun = lun >> 16;
 	}
 }
 EXPORT_SYMBOL(int_to_scsilun);
 /**
  * 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;
 	unsigned int lun;
 	unsigned int num_luns;
 	unsigned int retries;
 	int result;
 	struct scsi_lun *lunp, *lun_data;
 	u8 *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 max number of luns we are requesting.
 	 *
 	 * Reallocating and trying again (with the exact amount we need)
 	 * would be nice, but then we need to somehow limit the size
 	 * allocated based on the available memory and the limits of
 	 * kmalloc - we don't want a kmalloc() failure of a huge value to
 	 * prevent us from finding any LUNs on this target.
 	 */
 	length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun);
 	lun_data = kmalloc(length, GFP_ATOMIC |
 			   (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.
 	 */
 	scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;
 	scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;
 	scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;
 	scsi_cmd[9] = (unsigned char) length & 0xff;
 	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, printk (KERN_INFO "scsi scan: Sending"
 				" REPORT LUNS to %s (try %d)\n", devname,
 				retries));
 		result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
 					  lun_data, length, &sshdr,
 					  SCSI_TIMEOUT + 4 * HZ, 3, NULL);
 		SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "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.
 	 */
 	data = (u8 *) lun_data->scsi_lun;
 	length = ((data[0] << 24) | (data[1] << 16) |
 		  (data[2] << 8) | (data[3] << 0));
 	num_luns = (length / sizeof(struct scsi_lun));
 	if (num_luns > max_scsi_report_luns) {
 		printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)"
 		       " of %d luns reported, try increasing"
 		       " max_scsi_report_luns.\n", devname,
 		       max_scsi_report_luns, num_luns);
 		num_luns = max_scsi_report_luns;
 	}
 	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);
 		/*
 		 * Check if the unused part of lunp is non-zero, and so
 		 * does not fit in lun.
 		 */
 		if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) {
 			int i;
 			/*
 			 * Output an error displaying the LUN in byte order,
 			 * this differs from what linux would print for the
 			 * integer LUN value.
 			 */
 			printk(KERN_WARNING "scsi: %s lun 0x", devname);
 			data = (char *)lunp->scsi_lun;
 			for (i = 0; i < sizeof(struct scsi_lun); i++)
 				printk("%02x", data[i]);
 			printk(" has a LUN larger than currently supported.\n");
 		} else if (lun > sdev->host->max_lun) {
 			printk(KERN_WARNING "scsi: %s lun%d has a LUN larger"
 			       " than allowed by the host adapter\n",
 			       devname, 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 %d while scanning, scan"
 				        " aborted\n", 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, uint 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, uint 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)
 {
 	struct scsi_driver *drv;
 	if (!dev->driver)
 		return;
 	drv = to_scsi_driver(dev->driver);
 	if (try_module_get(drv->owner)) {
 		if (drv->rescan)
 			drv->rescan(dev);
 		module_put(drv->owner);
 	}
 }
 EXPORT_SYMBOL(scsi_rescan_device);
 static void __scsi_scan_target(struct device *parent, unsigned int channel,
 		unsigned int id, unsigned int 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, unsigned int 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, unsigned int 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, unsigned int lun, int rescan)
 {
 	SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
 		"%s: <%u:%u:%u>\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 (!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) {
 		printk("%s called twice for host %d", __func__,
 				shost->host_no);
 		dump_stack();
 		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) {
 		printk("%s called twice for host %d", __func__,
 				shost->host_no);
 		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);