]>
Commit | Line | Data |
---|---|---|
2cb7cef9 BS |
1 | From: James Bottomley <james.bottomley@hansenpartnership.com> |
2 | Subject: SCSI misc fixes | |
3 | References: FATE#303485,FATE#303484 | |
4 | ||
5 | This patch pulls in the latest patches from the scsi-misc tree. | |
6 | The functions are required by the various driver updates. | |
7 | ||
8 | Signed-off-by: Hannes Reinecke <hare@suse.de> | |
9 | ||
10 | --- | |
11 | Documentation/scsi/scsi_fc_transport.txt | 36 + | |
12 | drivers/mmc/card/block.c | 10 | |
13 | drivers/scsi/device_handler/scsi_dh_emc.c | 1 | |
14 | drivers/scsi/device_handler/scsi_dh_hp_sw.c | 2 | |
15 | drivers/scsi/device_handler/scsi_dh_rdac.c | 2 | |
16 | drivers/scsi/libiscsi.c | 2 | |
17 | drivers/scsi/scsi.c | 13 | |
18 | drivers/scsi/scsi_lib.c | 39 +- | |
19 | drivers/scsi/scsi_netlink.c | 523 +++++++++++++++++++++++++++- | |
20 | drivers/scsi/scsi_scan.c | 20 - | |
21 | drivers/scsi/scsi_sysfs.c | 1 | |
22 | drivers/scsi/scsi_transport_fc.c | 54 +- | |
23 | drivers/scsi/sd.c | 29 - | |
24 | include/linux/string_helpers.h | 16 | |
25 | include/scsi/scsi_device.h | 21 - | |
26 | include/scsi/scsi_netlink.h | 62 +++ | |
27 | include/scsi/scsi_transport_fc.h | 23 + | |
28 | lib/Makefile | 3 | |
29 | lib/string_helpers.c | 64 +++ | |
30 | 19 files changed, 834 insertions(+), 87 deletions(-) | |
31 | ||
32 | --- a/Documentation/scsi/scsi_fc_transport.txt | |
33 | +++ b/Documentation/scsi/scsi_fc_transport.txt | |
34 | @@ -436,6 +436,42 @@ Other: | |
35 | was updated to remove all vports for the fc_host as well. | |
36 | ||
37 | ||
38 | +Transport supplied functions | |
39 | +---------------------------- | |
40 | + | |
41 | +The following functions are supplied by the FC-transport for use by LLDs. | |
42 | + | |
43 | + fc_vport_create - create a vport | |
44 | + fc_vport_terminate - detach and remove a vport | |
45 | + | |
46 | +Details: | |
47 | + | |
48 | +/** | |
49 | + * fc_vport_create - Admin App or LLDD requests creation of a vport | |
50 | + * @shost: scsi host the virtual port is connected to. | |
51 | + * @ids: The world wide names, FC4 port roles, etc for | |
52 | + * the virtual port. | |
53 | + * | |
54 | + * Notes: | |
55 | + * This routine assumes no locks are held on entry. | |
56 | + */ | |
57 | +struct fc_vport * | |
58 | +fc_vport_create(struct Scsi_Host *shost, struct fc_vport_identifiers *ids) | |
59 | + | |
60 | +/** | |
61 | + * fc_vport_terminate - Admin App or LLDD requests termination of a vport | |
62 | + * @vport: fc_vport to be terminated | |
63 | + * | |
64 | + * Calls the LLDD vport_delete() function, then deallocates and removes | |
65 | + * the vport from the shost and object tree. | |
66 | + * | |
67 | + * Notes: | |
68 | + * This routine assumes no locks are held on entry. | |
69 | + */ | |
70 | +int | |
71 | +fc_vport_terminate(struct fc_vport *vport) | |
72 | + | |
73 | + | |
74 | Credits | |
75 | ======= | |
76 | The following people have contributed to this document: | |
77 | --- a/drivers/mmc/card/block.c | |
78 | +++ b/drivers/mmc/card/block.c | |
79 | @@ -29,6 +29,7 @@ | |
80 | #include <linux/blkdev.h> | |
81 | #include <linux/mutex.h> | |
82 | #include <linux/scatterlist.h> | |
83 | +#include <linux/string_helpers.h> | |
84 | ||
85 | #include <linux/mmc/card.h> | |
86 | #include <linux/mmc/host.h> | |
87 | @@ -532,6 +533,8 @@ static int mmc_blk_probe(struct mmc_card | |
88 | struct mmc_blk_data *md; | |
89 | int err; | |
90 | ||
91 | + char cap_str[10]; | |
92 | + | |
93 | /* | |
94 | * Check that the card supports the command class(es) we need. | |
95 | */ | |
96 | @@ -546,10 +549,11 @@ static int mmc_blk_probe(struct mmc_card | |
97 | if (err) | |
98 | goto out; | |
99 | ||
100 | - printk(KERN_INFO "%s: %s %s %lluKiB %s\n", | |
101 | + string_get_size(get_capacity(md->disk) << 9, STRING_UNITS_2, | |
102 | + cap_str, sizeof(cap_str)); | |
103 | + printk(KERN_INFO "%s: %s %s %s %s\n", | |
104 | md->disk->disk_name, mmc_card_id(card), mmc_card_name(card), | |
105 | - (unsigned long long)(get_capacity(md->disk) >> 1), | |
106 | - md->read_only ? "(ro)" : ""); | |
107 | + cap_str, md->read_only ? "(ro)" : ""); | |
108 | ||
109 | mmc_set_drvdata(card, md); | |
110 | add_disk(md->disk); | |
111 | --- a/drivers/scsi/device_handler/scsi_dh_emc.c | |
112 | +++ b/drivers/scsi/device_handler/scsi_dh_emc.c | |
113 | @@ -278,7 +278,6 @@ static struct request *get_req(struct sc | |
114 | return NULL; | |
115 | } | |
116 | ||
117 | - memset(rq->cmd, 0, BLK_MAX_CDB); | |
118 | rq->cmd_len = COMMAND_SIZE(cmd); | |
119 | rq->cmd[0] = cmd; | |
120 | ||
121 | --- a/drivers/scsi/device_handler/scsi_dh_hp_sw.c | |
122 | +++ b/drivers/scsi/device_handler/scsi_dh_hp_sw.c | |
123 | @@ -114,7 +114,6 @@ static int hp_sw_tur(struct scsi_device | |
124 | req->cmd_type = REQ_TYPE_BLOCK_PC; | |
125 | req->cmd_flags |= REQ_FAILFAST; | |
126 | req->cmd_len = COMMAND_SIZE(TEST_UNIT_READY); | |
127 | - memset(req->cmd, 0, MAX_COMMAND_SIZE); | |
128 | req->cmd[0] = TEST_UNIT_READY; | |
129 | req->timeout = HP_SW_TIMEOUT; | |
130 | req->sense = h->sense; | |
131 | @@ -207,7 +206,6 @@ static int hp_sw_start_stop(struct scsi_ | |
132 | req->cmd_type = REQ_TYPE_BLOCK_PC; | |
133 | req->cmd_flags |= REQ_FAILFAST; | |
134 | req->cmd_len = COMMAND_SIZE(START_STOP); | |
135 | - memset(req->cmd, 0, MAX_COMMAND_SIZE); | |
136 | req->cmd[0] = START_STOP; | |
137 | req->cmd[4] = 1; /* Start spin cycle */ | |
138 | req->timeout = HP_SW_TIMEOUT; | |
139 | --- a/drivers/scsi/device_handler/scsi_dh_rdac.c | |
140 | +++ b/drivers/scsi/device_handler/scsi_dh_rdac.c | |
141 | @@ -225,8 +225,6 @@ static struct request *get_rdac_req(stru | |
142 | return NULL; | |
143 | } | |
144 | ||
145 | - memset(rq->cmd, 0, BLK_MAX_CDB); | |
146 | - | |
147 | rq->cmd_type = REQ_TYPE_BLOCK_PC; | |
148 | rq->cmd_flags |= REQ_FAILFAST | REQ_NOMERGE; | |
149 | rq->retries = RDAC_RETRIES; | |
150 | --- a/drivers/scsi/libiscsi.c | |
151 | +++ b/drivers/scsi/libiscsi.c | |
152 | @@ -1456,7 +1456,7 @@ static void fail_all_commands(struct isc | |
153 | if (lun == task->sc->device->lun || lun == -1) { | |
154 | debug_scsi("failing in progress sc %p itt 0x%x\n", | |
155 | task->sc, task->itt); | |
156 | - fail_command(conn, task, DID_BUS_BUSY << 16); | |
157 | + fail_command(conn, task, error << 16); | |
158 | } | |
159 | } | |
160 | } | |
161 | --- a/drivers/scsi/scsi.c | |
162 | +++ b/drivers/scsi/scsi.c | |
163 | @@ -668,13 +668,14 @@ int scsi_dispatch_cmd(struct scsi_cmnd * | |
164 | goto out; | |
165 | } | |
166 | ||
167 | - /* Check to see if the scsi lld put this device into state SDEV_BLOCK. */ | |
168 | - if (unlikely(cmd->device->sdev_state == SDEV_BLOCK)) { | |
169 | + /* Check to see if the scsi lld made this device blocked. */ | |
170 | + if (unlikely(scsi_device_blocked(cmd->device))) { | |
171 | /* | |
172 | - * in SDEV_BLOCK, the command is just put back on the device | |
173 | - * queue. The suspend state has already blocked the queue so | |
174 | - * future requests should not occur until the device | |
175 | - * transitions out of the suspend state. | |
176 | + * in blocked state, the command is just put back on | |
177 | + * the device queue. The suspend state has already | |
178 | + * blocked the queue so future requests should not | |
179 | + * occur until the device transitions out of the | |
180 | + * suspend state. | |
181 | */ | |
182 | ||
183 | scsi_queue_insert(cmd, SCSI_MLQUEUE_DEVICE_BUSY); | |
184 | --- a/drivers/scsi/scsi_lib.c | |
185 | +++ b/drivers/scsi/scsi_lib.c | |
186 | @@ -1250,6 +1250,7 @@ int scsi_prep_state_check(struct scsi_de | |
187 | break; | |
188 | case SDEV_QUIESCE: | |
189 | case SDEV_BLOCK: | |
190 | + case SDEV_CREATED_BLOCK: | |
191 | /* | |
192 | * If the devices is blocked we defer normal commands. | |
193 | */ | |
194 | @@ -2073,10 +2074,13 @@ scsi_device_set_state(struct scsi_device | |
195 | ||
196 | switch (state) { | |
197 | case SDEV_CREATED: | |
198 | - /* There are no legal states that come back to | |
199 | - * created. This is the manually initialised start | |
200 | - * state */ | |
201 | - goto illegal; | |
202 | + switch (oldstate) { | |
203 | + case SDEV_CREATED_BLOCK: | |
204 | + break; | |
205 | + default: | |
206 | + goto illegal; | |
207 | + } | |
208 | + break; | |
209 | ||
210 | case SDEV_RUNNING: | |
211 | switch (oldstate) { | |
212 | @@ -2114,8 +2118,17 @@ scsi_device_set_state(struct scsi_device | |
213 | ||
214 | case SDEV_BLOCK: | |
215 | switch (oldstate) { | |
216 | - case SDEV_CREATED: | |
217 | case SDEV_RUNNING: | |
218 | + case SDEV_CREATED_BLOCK: | |
219 | + break; | |
220 | + default: | |
221 | + goto illegal; | |
222 | + } | |
223 | + break; | |
224 | + | |
225 | + case SDEV_CREATED_BLOCK: | |
226 | + switch (oldstate) { | |
227 | + case SDEV_CREATED: | |
228 | break; | |
229 | default: | |
230 | goto illegal; | |
231 | @@ -2403,8 +2416,12 @@ scsi_internal_device_block(struct scsi_d | |
232 | int err = 0; | |
233 | ||
234 | err = scsi_device_set_state(sdev, SDEV_BLOCK); | |
235 | - if (err) | |
236 | - return err; | |
237 | + if (err) { | |
238 | + err = scsi_device_set_state(sdev, SDEV_CREATED_BLOCK); | |
239 | + | |
240 | + if (err) | |
241 | + return err; | |
242 | + } | |
243 | ||
244 | /* | |
245 | * The device has transitioned to SDEV_BLOCK. Stop the | |
246 | @@ -2447,8 +2464,12 @@ scsi_internal_device_unblock(struct scsi | |
247 | * and goose the device queue if successful. | |
248 | */ | |
249 | err = scsi_device_set_state(sdev, SDEV_RUNNING); | |
250 | - if (err) | |
251 | - return err; | |
252 | + if (err) { | |
253 | + err = scsi_device_set_state(sdev, SDEV_CREATED); | |
254 | + | |
255 | + if (err) | |
256 | + return err; | |
257 | + } | |
258 | ||
259 | spin_lock_irqsave(q->queue_lock, flags); | |
260 | blk_start_queue(q); | |
261 | --- a/drivers/scsi/scsi_netlink.c | |
262 | +++ b/drivers/scsi/scsi_netlink.c | |
263 | @@ -21,6 +21,7 @@ | |
264 | #include <linux/time.h> | |
265 | #include <linux/jiffies.h> | |
266 | #include <linux/security.h> | |
267 | +#include <linux/delay.h> | |
268 | #include <net/sock.h> | |
269 | #include <net/netlink.h> | |
270 | ||
271 | @@ -30,6 +31,39 @@ | |
272 | struct sock *scsi_nl_sock = NULL; | |
273 | EXPORT_SYMBOL_GPL(scsi_nl_sock); | |
274 | ||
275 | +static DEFINE_SPINLOCK(scsi_nl_lock); | |
276 | +static struct list_head scsi_nl_drivers; | |
277 | + | |
278 | +static u32 scsi_nl_state; | |
279 | +#define STATE_EHANDLER_BSY 0x00000001 | |
280 | + | |
281 | +struct scsi_nl_transport { | |
282 | + int (*msg_handler)(struct sk_buff *); | |
283 | + void (*event_handler)(struct notifier_block *, unsigned long, void *); | |
284 | + unsigned int refcnt; | |
285 | + int flags; | |
286 | +}; | |
287 | + | |
288 | +/* flags values (bit flags) */ | |
289 | +#define HANDLER_DELETING 0x1 | |
290 | + | |
291 | +static struct scsi_nl_transport transports[SCSI_NL_MAX_TRANSPORTS] = | |
292 | + { {NULL, }, }; | |
293 | + | |
294 | + | |
295 | +struct scsi_nl_drvr { | |
296 | + struct list_head next; | |
297 | + int (*dmsg_handler)(struct Scsi_Host *shost, void *payload, | |
298 | + u32 len, u32 pid); | |
299 | + void (*devt_handler)(struct notifier_block *nb, | |
300 | + unsigned long event, void *notify_ptr); | |
301 | + struct scsi_host_template *hostt; | |
302 | + u64 vendor_id; | |
303 | + unsigned int refcnt; | |
304 | + int flags; | |
305 | +}; | |
306 | + | |
307 | + | |
308 | ||
309 | /** | |
310 | * scsi_nl_rcv_msg - Receive message handler. | |
311 | @@ -45,8 +79,9 @@ scsi_nl_rcv_msg(struct sk_buff *skb) | |
312 | { | |
313 | struct nlmsghdr *nlh; | |
314 | struct scsi_nl_hdr *hdr; | |
315 | - uint32_t rlen; | |
316 | - int err; | |
317 | + unsigned long flags; | |
318 | + u32 rlen; | |
319 | + int err, tport; | |
320 | ||
321 | while (skb->len >= NLMSG_SPACE(0)) { | |
322 | err = 0; | |
323 | @@ -65,7 +100,7 @@ scsi_nl_rcv_msg(struct sk_buff *skb) | |
324 | ||
325 | if (nlh->nlmsg_type != SCSI_TRANSPORT_MSG) { | |
326 | err = -EBADMSG; | |
327 | - return; | |
328 | + goto next_msg; | |
329 | } | |
330 | ||
331 | hdr = NLMSG_DATA(nlh); | |
332 | @@ -83,12 +118,27 @@ scsi_nl_rcv_msg(struct sk_buff *skb) | |
333 | if (nlh->nlmsg_len < (sizeof(*nlh) + hdr->msglen)) { | |
334 | printk(KERN_WARNING "%s: discarding partial message\n", | |
335 | __func__); | |
336 | - return; | |
337 | + goto next_msg; | |
338 | } | |
339 | ||
340 | /* | |
341 | - * We currently don't support anyone sending us a message | |
342 | + * Deliver message to the appropriate transport | |
343 | */ | |
344 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
345 | + | |
346 | + tport = hdr->transport; | |
347 | + if ((tport < SCSI_NL_MAX_TRANSPORTS) && | |
348 | + !(transports[tport].flags & HANDLER_DELETING) && | |
349 | + (transports[tport].msg_handler)) { | |
350 | + transports[tport].refcnt++; | |
351 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
352 | + err = transports[tport].msg_handler(skb); | |
353 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
354 | + transports[tport].refcnt--; | |
355 | + } else | |
356 | + err = -ENOENT; | |
357 | + | |
358 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
359 | ||
360 | next_msg: | |
361 | if ((err) || (nlh->nlmsg_flags & NLM_F_ACK)) | |
362 | @@ -110,14 +160,42 @@ static int | |
363 | scsi_nl_rcv_event(struct notifier_block *this, unsigned long event, void *ptr) | |
364 | { | |
365 | struct netlink_notify *n = ptr; | |
366 | + struct scsi_nl_drvr *driver; | |
367 | + unsigned long flags; | |
368 | + int tport; | |
369 | ||
370 | if (n->protocol != NETLINK_SCSITRANSPORT) | |
371 | return NOTIFY_DONE; | |
372 | ||
373 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
374 | + scsi_nl_state |= STATE_EHANDLER_BSY; | |
375 | + | |
376 | + /* | |
377 | + * Pass event on to any transports that may be listening | |
378 | + */ | |
379 | + for (tport = 0; tport < SCSI_NL_MAX_TRANSPORTS; tport++) { | |
380 | + if (!(transports[tport].flags & HANDLER_DELETING) && | |
381 | + (transports[tport].event_handler)) { | |
382 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
383 | + transports[tport].event_handler(this, event, ptr); | |
384 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
385 | + } | |
386 | + } | |
387 | + | |
388 | /* | |
389 | - * Currently, we are not tracking PID's, etc. There is nothing | |
390 | - * to handle. | |
391 | + * Pass event on to any drivers that may be listening | |
392 | */ | |
393 | + list_for_each_entry(driver, &scsi_nl_drivers, next) { | |
394 | + if (!(driver->flags & HANDLER_DELETING) && | |
395 | + (driver->devt_handler)) { | |
396 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
397 | + driver->devt_handler(this, event, ptr); | |
398 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
399 | + } | |
400 | + } | |
401 | + | |
402 | + scsi_nl_state &= ~STATE_EHANDLER_BSY; | |
403 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
404 | ||
405 | return NOTIFY_DONE; | |
406 | } | |
407 | @@ -128,7 +206,281 @@ static struct notifier_block scsi_netlin | |
408 | ||
409 | ||
410 | /** | |
411 | - * scsi_netlink_init - Called by SCSI subsystem to intialize the SCSI transport netlink interface | |
412 | + * GENERIC SCSI transport receive and event handlers | |
413 | + **/ | |
414 | + | |
415 | +/** | |
416 | + * scsi_generic_msg_handler - receive message handler for GENERIC transport | |
417 | + * messages | |
418 | + * | |
419 | + * @skb: socket receive buffer | |
420 | + * | |
421 | + **/ | |
422 | +static int | |
423 | +scsi_generic_msg_handler(struct sk_buff *skb) | |
424 | +{ | |
425 | + struct nlmsghdr *nlh = nlmsg_hdr(skb); | |
426 | + struct scsi_nl_hdr *snlh = NLMSG_DATA(nlh); | |
427 | + struct scsi_nl_drvr *driver; | |
428 | + struct Scsi_Host *shost; | |
429 | + unsigned long flags; | |
430 | + int err = 0, match, pid; | |
431 | + | |
432 | + pid = NETLINK_CREDS(skb)->pid; | |
433 | + | |
434 | + switch (snlh->msgtype) { | |
435 | + case SCSI_NL_SHOST_VENDOR: | |
436 | + { | |
437 | + struct scsi_nl_host_vendor_msg *msg = NLMSG_DATA(nlh); | |
438 | + | |
439 | + /* Locate the driver that corresponds to the message */ | |
440 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
441 | + match = 0; | |
442 | + list_for_each_entry(driver, &scsi_nl_drivers, next) { | |
443 | + if (driver->vendor_id == msg->vendor_id) { | |
444 | + match = 1; | |
445 | + break; | |
446 | + } | |
447 | + } | |
448 | + | |
449 | + if ((!match) || (!driver->dmsg_handler)) { | |
450 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
451 | + err = -ESRCH; | |
452 | + goto rcv_exit; | |
453 | + } | |
454 | + | |
455 | + if (driver->flags & HANDLER_DELETING) { | |
456 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
457 | + err = -ESHUTDOWN; | |
458 | + goto rcv_exit; | |
459 | + } | |
460 | + | |
461 | + driver->refcnt++; | |
462 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
463 | + | |
464 | + | |
465 | + /* if successful, scsi_host_lookup takes a shost reference */ | |
466 | + shost = scsi_host_lookup(msg->host_no); | |
467 | + if (!shost) { | |
468 | + err = -ENODEV; | |
469 | + goto driver_exit; | |
470 | + } | |
471 | + | |
472 | + /* is this host owned by the vendor ? */ | |
473 | + if (shost->hostt != driver->hostt) { | |
474 | + err = -EINVAL; | |
475 | + goto vendormsg_put; | |
476 | + } | |
477 | + | |
478 | + /* pass message on to the driver */ | |
479 | + err = driver->dmsg_handler(shost, (void *)&msg[1], | |
480 | + msg->vmsg_datalen, pid); | |
481 | + | |
482 | +vendormsg_put: | |
483 | + /* release reference by scsi_host_lookup */ | |
484 | + scsi_host_put(shost); | |
485 | + | |
486 | +driver_exit: | |
487 | + /* release our own reference on the registration object */ | |
488 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
489 | + driver->refcnt--; | |
490 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
491 | + break; | |
492 | + } | |
493 | + | |
494 | + default: | |
495 | + err = -EBADR; | |
496 | + break; | |
497 | + } | |
498 | + | |
499 | +rcv_exit: | |
500 | + if (err) | |
501 | + printk(KERN_WARNING "%s: Msgtype %d failed - err %d\n", | |
502 | + __func__, snlh->msgtype, err); | |
503 | + return err; | |
504 | +} | |
505 | + | |
506 | + | |
507 | +/** | |
508 | + * scsi_nl_add_transport - | |
509 | + * Registers message and event handlers for a transport. Enables | |
510 | + * receipt of netlink messages and events to a transport. | |
511 | + * | |
512 | + * @tport: transport registering handlers | |
513 | + * @msg_handler: receive message handler callback | |
514 | + * @event_handler: receive event handler callback | |
515 | + **/ | |
516 | +int | |
517 | +scsi_nl_add_transport(u8 tport, | |
518 | + int (*msg_handler)(struct sk_buff *), | |
519 | + void (*event_handler)(struct notifier_block *, unsigned long, void *)) | |
520 | +{ | |
521 | + unsigned long flags; | |
522 | + int err = 0; | |
523 | + | |
524 | + if (tport >= SCSI_NL_MAX_TRANSPORTS) | |
525 | + return -EINVAL; | |
526 | + | |
527 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
528 | + | |
529 | + if (scsi_nl_state & STATE_EHANDLER_BSY) { | |
530 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
531 | + msleep(1); | |
532 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
533 | + } | |
534 | + | |
535 | + if (transports[tport].msg_handler || transports[tport].event_handler) { | |
536 | + err = -EALREADY; | |
537 | + goto register_out; | |
538 | + } | |
539 | + | |
540 | + transports[tport].msg_handler = msg_handler; | |
541 | + transports[tport].event_handler = event_handler; | |
542 | + transports[tport].flags = 0; | |
543 | + transports[tport].refcnt = 0; | |
544 | + | |
545 | +register_out: | |
546 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
547 | + | |
548 | + return err; | |
549 | +} | |
550 | +EXPORT_SYMBOL_GPL(scsi_nl_add_transport); | |
551 | + | |
552 | + | |
553 | +/** | |
554 | + * scsi_nl_remove_transport - | |
555 | + * Disable transport receiption of messages and events | |
556 | + * | |
557 | + * @tport: transport deregistering handlers | |
558 | + * | |
559 | + **/ | |
560 | +void | |
561 | +scsi_nl_remove_transport(u8 tport) | |
562 | +{ | |
563 | + unsigned long flags; | |
564 | + | |
565 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
566 | + if (scsi_nl_state & STATE_EHANDLER_BSY) { | |
567 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
568 | + msleep(1); | |
569 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
570 | + } | |
571 | + | |
572 | + if (tport < SCSI_NL_MAX_TRANSPORTS) { | |
573 | + transports[tport].flags |= HANDLER_DELETING; | |
574 | + | |
575 | + while (transports[tport].refcnt != 0) { | |
576 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
577 | + schedule_timeout_uninterruptible(HZ/4); | |
578 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
579 | + } | |
580 | + transports[tport].msg_handler = NULL; | |
581 | + transports[tport].event_handler = NULL; | |
582 | + transports[tport].flags = 0; | |
583 | + } | |
584 | + | |
585 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
586 | + | |
587 | + return; | |
588 | +} | |
589 | +EXPORT_SYMBOL_GPL(scsi_nl_remove_transport); | |
590 | + | |
591 | + | |
592 | +/** | |
593 | + * scsi_nl_add_driver - | |
594 | + * A driver is registering its interfaces for SCSI netlink messages | |
595 | + * | |
596 | + * @vendor_id: A unique identification value for the driver. | |
597 | + * @hostt: address of the driver's host template. Used | |
598 | + * to verify an shost is bound to the driver | |
599 | + * @nlmsg_handler: receive message handler callback | |
600 | + * @nlevt_handler: receive event handler callback | |
601 | + * | |
602 | + * Returns: | |
603 | + * 0 on Success | |
604 | + * error result otherwise | |
605 | + **/ | |
606 | +int | |
607 | +scsi_nl_add_driver(u64 vendor_id, struct scsi_host_template *hostt, | |
608 | + int (*nlmsg_handler)(struct Scsi_Host *shost, void *payload, | |
609 | + u32 len, u32 pid), | |
610 | + void (*nlevt_handler)(struct notifier_block *nb, | |
611 | + unsigned long event, void *notify_ptr)) | |
612 | +{ | |
613 | + struct scsi_nl_drvr *driver; | |
614 | + unsigned long flags; | |
615 | + | |
616 | + driver = kzalloc(sizeof(*driver), GFP_KERNEL); | |
617 | + if (unlikely(!driver)) { | |
618 | + printk(KERN_ERR "%s: allocation failure\n", __func__); | |
619 | + return -ENOMEM; | |
620 | + } | |
621 | + | |
622 | + driver->dmsg_handler = nlmsg_handler; | |
623 | + driver->devt_handler = nlevt_handler; | |
624 | + driver->hostt = hostt; | |
625 | + driver->vendor_id = vendor_id; | |
626 | + | |
627 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
628 | + if (scsi_nl_state & STATE_EHANDLER_BSY) { | |
629 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
630 | + msleep(1); | |
631 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
632 | + } | |
633 | + list_add_tail(&driver->next, &scsi_nl_drivers); | |
634 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
635 | + | |
636 | + return 0; | |
637 | +} | |
638 | +EXPORT_SYMBOL_GPL(scsi_nl_add_driver); | |
639 | + | |
640 | + | |
641 | +/** | |
642 | + * scsi_nl_remove_driver - | |
643 | + * An driver is unregistering with the SCSI netlink messages | |
644 | + * | |
645 | + * @vendor_id: The unique identification value for the driver. | |
646 | + **/ | |
647 | +void | |
648 | +scsi_nl_remove_driver(u64 vendor_id) | |
649 | +{ | |
650 | + struct scsi_nl_drvr *driver; | |
651 | + unsigned long flags; | |
652 | + | |
653 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
654 | + if (scsi_nl_state & STATE_EHANDLER_BSY) { | |
655 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
656 | + msleep(1); | |
657 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
658 | + } | |
659 | + | |
660 | + list_for_each_entry(driver, &scsi_nl_drivers, next) { | |
661 | + if (driver->vendor_id == vendor_id) { | |
662 | + driver->flags |= HANDLER_DELETING; | |
663 | + while (driver->refcnt != 0) { | |
664 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
665 | + schedule_timeout_uninterruptible(HZ/4); | |
666 | + spin_lock_irqsave(&scsi_nl_lock, flags); | |
667 | + } | |
668 | + list_del(&driver->next); | |
669 | + kfree(driver); | |
670 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
671 | + return; | |
672 | + } | |
673 | + } | |
674 | + | |
675 | + spin_unlock_irqrestore(&scsi_nl_lock, flags); | |
676 | + | |
677 | + printk(KERN_ERR "%s: removal of driver failed - vendor_id 0x%llx\n", | |
678 | + __func__, (unsigned long long)vendor_id); | |
679 | + return; | |
680 | +} | |
681 | +EXPORT_SYMBOL_GPL(scsi_nl_remove_driver); | |
682 | + | |
683 | + | |
684 | +/** | |
685 | + * scsi_netlink_init - Called by SCSI subsystem to intialize | |
686 | + * the SCSI transport netlink interface | |
687 | * | |
688 | **/ | |
689 | void | |
690 | @@ -136,6 +488,8 @@ scsi_netlink_init(void) | |
691 | { | |
692 | int error; | |
693 | ||
694 | + INIT_LIST_HEAD(&scsi_nl_drivers); | |
695 | + | |
696 | error = netlink_register_notifier(&scsi_netlink_notifier); | |
697 | if (error) { | |
698 | printk(KERN_ERR "%s: register of event handler failed - %d\n", | |
699 | @@ -150,8 +504,15 @@ scsi_netlink_init(void) | |
700 | printk(KERN_ERR "%s: register of recieve handler failed\n", | |
701 | __func__); | |
702 | netlink_unregister_notifier(&scsi_netlink_notifier); | |
703 | + return; | |
704 | } | |
705 | ||
706 | + /* Register the entry points for the generic SCSI transport */ | |
707 | + error = scsi_nl_add_transport(SCSI_NL_TRANSPORT, | |
708 | + scsi_generic_msg_handler, NULL); | |
709 | + if (error) | |
710 | + printk(KERN_ERR "%s: register of GENERIC transport handler" | |
711 | + " failed - %d\n", __func__, error); | |
712 | return; | |
713 | } | |
714 | ||
715 | @@ -163,6 +524,8 @@ scsi_netlink_init(void) | |
716 | void | |
717 | scsi_netlink_exit(void) | |
718 | { | |
719 | + scsi_nl_remove_transport(SCSI_NL_TRANSPORT); | |
720 | + | |
721 | if (scsi_nl_sock) { | |
722 | netlink_kernel_release(scsi_nl_sock); | |
723 | netlink_unregister_notifier(&scsi_netlink_notifier); | |
724 | @@ -172,3 +535,147 @@ scsi_netlink_exit(void) | |
725 | } | |
726 | ||
727 | ||
728 | +/* | |
729 | + * Exported Interfaces | |
730 | + */ | |
731 | + | |
732 | +/** | |
733 | + * scsi_nl_send_transport_msg - | |
734 | + * Generic function to send a single message from a SCSI transport to | |
735 | + * a single process | |
736 | + * | |
737 | + * @pid: receiving pid | |
738 | + * @hdr: message payload | |
739 | + * | |
740 | + **/ | |
741 | +void | |
742 | +scsi_nl_send_transport_msg(u32 pid, struct scsi_nl_hdr *hdr) | |
743 | +{ | |
744 | + struct sk_buff *skb; | |
745 | + struct nlmsghdr *nlh; | |
746 | + const char *fn; | |
747 | + char *datab; | |
748 | + u32 len, skblen; | |
749 | + int err; | |
750 | + | |
751 | + if (!scsi_nl_sock) { | |
752 | + err = -ENOENT; | |
753 | + fn = "netlink socket"; | |
754 | + goto msg_fail; | |
755 | + } | |
756 | + | |
757 | + len = NLMSG_SPACE(hdr->msglen); | |
758 | + skblen = NLMSG_SPACE(len); | |
759 | + | |
760 | + skb = alloc_skb(skblen, GFP_KERNEL); | |
761 | + if (!skb) { | |
762 | + err = -ENOBUFS; | |
763 | + fn = "alloc_skb"; | |
764 | + goto msg_fail; | |
765 | + } | |
766 | + | |
767 | + nlh = nlmsg_put(skb, pid, 0, SCSI_TRANSPORT_MSG, len - sizeof(*nlh), 0); | |
768 | + if (!nlh) { | |
769 | + err = -ENOBUFS; | |
770 | + fn = "nlmsg_put"; | |
771 | + goto msg_fail_skb; | |
772 | + } | |
773 | + datab = NLMSG_DATA(nlh); | |
774 | + memcpy(datab, hdr, hdr->msglen); | |
775 | + | |
776 | + err = nlmsg_unicast(scsi_nl_sock, skb, pid); | |
777 | + if (err < 0) { | |
778 | + fn = "nlmsg_unicast"; | |
779 | + /* nlmsg_unicast already kfree_skb'd */ | |
780 | + goto msg_fail; | |
781 | + } | |
782 | + | |
783 | + return; | |
784 | + | |
785 | +msg_fail_skb: | |
786 | + kfree_skb(skb); | |
787 | +msg_fail: | |
788 | + printk(KERN_WARNING | |
789 | + "%s: Dropped Message : pid %d Transport %d, msgtype x%x, " | |
790 | + "msglen %d: %s : err %d\n", | |
791 | + __func__, pid, hdr->transport, hdr->msgtype, hdr->msglen, | |
792 | + fn, err); | |
793 | + return; | |
794 | +} | |
795 | +EXPORT_SYMBOL_GPL(scsi_nl_send_transport_msg); | |
796 | + | |
797 | + | |
798 | +/** | |
799 | + * scsi_nl_send_vendor_msg - called to send a shost vendor unique message | |
800 | + * to a specific process id. | |
801 | + * | |
802 | + * @pid: process id of the receiver | |
803 | + * @host_no: host # sending the message | |
804 | + * @vendor_id: unique identifier for the driver's vendor | |
805 | + * @data_len: amount, in bytes, of vendor unique payload data | |
806 | + * @data_buf: pointer to vendor unique data buffer | |
807 | + * | |
808 | + * Returns: | |
809 | + * 0 on succesful return | |
810 | + * otherwise, failing error code | |
811 | + * | |
812 | + * Notes: | |
813 | + * This routine assumes no locks are held on entry. | |
814 | + */ | |
815 | +int | |
816 | +scsi_nl_send_vendor_msg(u32 pid, unsigned short host_no, u64 vendor_id, | |
817 | + char *data_buf, u32 data_len) | |
818 | +{ | |
819 | + struct sk_buff *skb; | |
820 | + struct nlmsghdr *nlh; | |
821 | + struct scsi_nl_host_vendor_msg *msg; | |
822 | + u32 len, skblen; | |
823 | + int err; | |
824 | + | |
825 | + if (!scsi_nl_sock) { | |
826 | + err = -ENOENT; | |
827 | + goto send_vendor_fail; | |
828 | + } | |
829 | + | |
830 | + len = SCSI_NL_MSGALIGN(sizeof(*msg) + data_len); | |
831 | + skblen = NLMSG_SPACE(len); | |
832 | + | |
833 | + skb = alloc_skb(skblen, GFP_KERNEL); | |
834 | + if (!skb) { | |
835 | + err = -ENOBUFS; | |
836 | + goto send_vendor_fail; | |
837 | + } | |
838 | + | |
839 | + nlh = nlmsg_put(skb, 0, 0, SCSI_TRANSPORT_MSG, | |
840 | + skblen - sizeof(*nlh), 0); | |
841 | + if (!nlh) { | |
842 | + err = -ENOBUFS; | |
843 | + goto send_vendor_fail_skb; | |
844 | + } | |
845 | + msg = NLMSG_DATA(nlh); | |
846 | + | |
847 | + INIT_SCSI_NL_HDR(&msg->snlh, SCSI_NL_TRANSPORT, | |
848 | + SCSI_NL_SHOST_VENDOR, len); | |
849 | + msg->vendor_id = vendor_id; | |
850 | + msg->host_no = host_no; | |
851 | + msg->vmsg_datalen = data_len; /* bytes */ | |
852 | + memcpy(&msg[1], data_buf, data_len); | |
853 | + | |
854 | + err = nlmsg_unicast(scsi_nl_sock, skb, pid); | |
855 | + if (err) | |
856 | + /* nlmsg_multicast already kfree_skb'd */ | |
857 | + goto send_vendor_fail; | |
858 | + | |
859 | + return 0; | |
860 | + | |
861 | +send_vendor_fail_skb: | |
862 | + kfree_skb(skb); | |
863 | +send_vendor_fail: | |
864 | + printk(KERN_WARNING | |
865 | + "%s: Dropped SCSI Msg : host %d vendor_unique - err %d\n", | |
866 | + __func__, host_no, err); | |
867 | + return err; | |
868 | +} | |
869 | +EXPORT_SYMBOL(scsi_nl_send_vendor_msg); | |
870 | + | |
871 | + | |
872 | --- a/drivers/scsi/scsi_scan.c | |
873 | +++ b/drivers/scsi/scsi_scan.c | |
874 | @@ -730,6 +730,8 @@ static int scsi_probe_lun(struct scsi_de | |
875 | static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result, | |
876 | int *bflags, int async) | |
877 | { | |
878 | + int ret; | |
879 | + | |
880 | /* | |
881 | * XXX do not save the inquiry, since it can change underneath us, | |
882 | * save just vendor/model/rev. | |
883 | @@ -885,7 +887,17 @@ static int scsi_add_lun(struct scsi_devi | |
884 | ||
885 | /* set the device running here so that slave configure | |
886 | * may do I/O */ | |
887 | - scsi_device_set_state(sdev, SDEV_RUNNING); | |
888 | + ret = scsi_device_set_state(sdev, SDEV_RUNNING); | |
889 | + if (ret) { | |
890 | + ret = scsi_device_set_state(sdev, SDEV_BLOCK); | |
891 | + | |
892 | + if (ret) { | |
893 | + sdev_printk(KERN_ERR, sdev, | |
894 | + "in wrong state %s to complete scan\n", | |
895 | + scsi_device_state_name(sdev->sdev_state)); | |
896 | + return SCSI_SCAN_NO_RESPONSE; | |
897 | + } | |
898 | + } | |
899 | ||
900 | if (*bflags & BLIST_MS_192_BYTES_FOR_3F) | |
901 | sdev->use_192_bytes_for_3f = 1; | |
902 | @@ -899,7 +911,7 @@ static int scsi_add_lun(struct scsi_devi | |
903 | transport_configure_device(&sdev->sdev_gendev); | |
904 | ||
905 | if (sdev->host->hostt->slave_configure) { | |
906 | - int ret = sdev->host->hostt->slave_configure(sdev); | |
907 | + ret = sdev->host->hostt->slave_configure(sdev); | |
908 | if (ret) { | |
909 | /* | |
910 | * if LLDD reports slave not present, don't clutter | |
911 | @@ -994,7 +1006,7 @@ static int scsi_probe_and_add_lun(struct | |
912 | */ | |
913 | sdev = scsi_device_lookup_by_target(starget, lun); | |
914 | if (sdev) { | |
915 | - if (rescan || sdev->sdev_state != SDEV_CREATED) { | |
916 | + if (rescan || !scsi_device_created(sdev)) { | |
917 | SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO | |
918 | "scsi scan: device exists on %s\n", | |
919 | sdev->sdev_gendev.bus_id)); | |
920 | @@ -1467,7 +1479,7 @@ static int scsi_report_lun_scan(struct s | |
921 | kfree(lun_data); | |
922 | out: | |
923 | scsi_device_put(sdev); | |
924 | - if (sdev->sdev_state == SDEV_CREATED) | |
925 | + if (scsi_device_created(sdev)) | |
926 | /* | |
927 | * the sdev we used didn't appear in the report luns scan | |
928 | */ | |
929 | --- a/drivers/scsi/scsi_sysfs.c | |
930 | +++ b/drivers/scsi/scsi_sysfs.c | |
931 | @@ -34,6 +34,7 @@ static const struct { | |
932 | { SDEV_QUIESCE, "quiesce" }, | |
933 | { SDEV_OFFLINE, "offline" }, | |
934 | { SDEV_BLOCK, "blocked" }, | |
935 | + { SDEV_CREATED_BLOCK, "created-blocked" }, | |
936 | }; | |
937 | ||
938 | const char *scsi_device_state_name(enum scsi_device_state state) | |
939 | --- a/drivers/scsi/scsi_transport_fc.c | |
940 | +++ b/drivers/scsi/scsi_transport_fc.c | |
941 | @@ -40,31 +40,7 @@ | |
942 | ||
943 | static int fc_queue_work(struct Scsi_Host *, struct work_struct *); | |
944 | static void fc_vport_sched_delete(struct work_struct *work); | |
945 | - | |
946 | -/* | |
947 | - * This is a temporary carrier for creating a vport. It will eventually | |
948 | - * be replaced by a real message definition for sgio or netlink. | |
949 | - * | |
950 | - * fc_vport_identifiers: This set of data contains all elements | |
951 | - * to uniquely identify and instantiate a FC virtual port. | |
952 | - * | |
953 | - * Notes: | |
954 | - * symbolic_name: The driver is to append the symbolic_name string data | |
955 | - * to the symbolic_node_name data that it generates by default. | |
956 | - * the resulting combination should then be registered with the switch. | |
957 | - * It is expected that things like Xen may stuff a VM title into | |
958 | - * this field. | |
959 | - */ | |
960 | -struct fc_vport_identifiers { | |
961 | - u64 node_name; | |
962 | - u64 port_name; | |
963 | - u32 roles; | |
964 | - bool disable; | |
965 | - enum fc_port_type vport_type; /* only FC_PORTTYPE_NPIV allowed */ | |
966 | - char symbolic_name[FC_VPORT_SYMBOLIC_NAMELEN]; | |
967 | -}; | |
968 | - | |
969 | -static int fc_vport_create(struct Scsi_Host *shost, int channel, | |
970 | +static int fc_vport_setup(struct Scsi_Host *shost, int channel, | |
971 | struct device *pdev, struct fc_vport_identifiers *ids, | |
972 | struct fc_vport **vport); | |
973 | ||
974 | @@ -1760,7 +1736,7 @@ store_fc_host_vport_create(struct device | |
975 | vid.disable = false; /* always enabled */ | |
976 | ||
977 | /* we only allow support on Channel 0 !!! */ | |
978 | - stat = fc_vport_create(shost, 0, &shost->shost_gendev, &vid, &vport); | |
979 | + stat = fc_vport_setup(shost, 0, &shost->shost_gendev, &vid, &vport); | |
980 | return stat ? stat : count; | |
981 | } | |
982 | static FC_DEVICE_ATTR(host, vport_create, S_IWUSR, NULL, | |
983 | @@ -3103,7 +3079,7 @@ fc_scsi_scan_rport(struct work_struct *w | |
984 | ||
985 | ||
986 | /** | |
987 | - * fc_vport_create - allocates and creates a FC virtual port. | |
988 | + * fc_vport_setup - allocates and creates a FC virtual port. | |
989 | * @shost: scsi host the virtual port is connected to. | |
990 | * @channel: Channel on shost port connected to. | |
991 | * @pdev: parent device for vport | |
992 | @@ -3118,7 +3094,7 @@ fc_scsi_scan_rport(struct work_struct *w | |
993 | * This routine assumes no locks are held on entry. | |
994 | */ | |
995 | static int | |
996 | -fc_vport_create(struct Scsi_Host *shost, int channel, struct device *pdev, | |
997 | +fc_vport_setup(struct Scsi_Host *shost, int channel, struct device *pdev, | |
998 | struct fc_vport_identifiers *ids, struct fc_vport **ret_vport) | |
999 | { | |
1000 | struct fc_host_attrs *fc_host = shost_to_fc_host(shost); | |
1001 | @@ -3231,6 +3207,28 @@ delete_vport: | |
1002 | return error; | |
1003 | } | |
1004 | ||
1005 | +/** | |
1006 | + * fc_vport_create - Admin App or LLDD requests creation of a vport | |
1007 | + * @shost: scsi host the virtual port is connected to. | |
1008 | + * @channel: channel on shost port connected to. | |
1009 | + * @ids: The world wide names, FC4 port roles, etc for | |
1010 | + * the virtual port. | |
1011 | + * | |
1012 | + * Notes: | |
1013 | + * This routine assumes no locks are held on entry. | |
1014 | + */ | |
1015 | +struct fc_vport * | |
1016 | +fc_vport_create(struct Scsi_Host *shost, int channel, | |
1017 | + struct fc_vport_identifiers *ids) | |
1018 | +{ | |
1019 | + int stat; | |
1020 | + struct fc_vport *vport; | |
1021 | + | |
1022 | + stat = fc_vport_setup(shost, channel, &shost->shost_gendev, | |
1023 | + ids, &vport); | |
1024 | + return stat ? NULL : vport; | |
1025 | +} | |
1026 | +EXPORT_SYMBOL(fc_vport_create); | |
1027 | ||
1028 | /** | |
1029 | * fc_vport_terminate - Admin App or LLDD requests termination of a vport | |
1030 | --- a/drivers/scsi/sd.c | |
1031 | +++ b/drivers/scsi/sd.c | |
1032 | @@ -47,6 +47,7 @@ | |
1033 | #include <linux/blkpg.h> | |
1034 | #include <linux/delay.h> | |
1035 | #include <linux/mutex.h> | |
1036 | +#include <linux/string_helpers.h> | |
1037 | #include <asm/uaccess.h> | |
1038 | ||
1039 | #include <scsi/scsi.h> | |
1040 | @@ -1436,27 +1437,21 @@ got_data: | |
1041 | */ | |
1042 | sector_size = 512; | |
1043 | } | |
1044 | + blk_queue_hardsect_size(sdp->request_queue, sector_size); | |
1045 | + | |
1046 | { | |
1047 | - /* | |
1048 | - * The msdos fs needs to know the hardware sector size | |
1049 | - * So I have created this table. See ll_rw_blk.c | |
1050 | - * Jacques Gelinas (Jacques@solucorp.qc.ca) | |
1051 | - */ | |
1052 | - int hard_sector = sector_size; | |
1053 | - sector_t sz = (sdkp->capacity/2) * (hard_sector/256); | |
1054 | - struct request_queue *queue = sdp->request_queue; | |
1055 | - sector_t mb = sz; | |
1056 | - | |
1057 | - blk_queue_hardsect_size(queue, hard_sector); | |
1058 | - /* avoid 64-bit division on 32-bit platforms */ | |
1059 | - sector_div(sz, 625); | |
1060 | - mb -= sz - 974; | |
1061 | - sector_div(mb, 1950); | |
1062 | + char cap_str_2[10], cap_str_10[10]; | |
1063 | + u64 sz = sdkp->capacity << ffz(~sector_size); | |
1064 | + | |
1065 | + string_get_size(sz, STRING_UNITS_2, cap_str_2, | |
1066 | + sizeof(cap_str_2)); | |
1067 | + string_get_size(sz, STRING_UNITS_10, cap_str_10, | |
1068 | + sizeof(cap_str_10)); | |
1069 | ||
1070 | sd_printk(KERN_NOTICE, sdkp, | |
1071 | - "%llu %d-byte hardware sectors (%llu MB)\n", | |
1072 | + "%llu %d-byte hardware sectors: (%s/%s)\n", | |
1073 | (unsigned long long)sdkp->capacity, | |
1074 | - hard_sector, (unsigned long long)mb); | |
1075 | + sector_size, cap_str_10, cap_str_2); | |
1076 | } | |
1077 | ||
1078 | /* Rescale capacity to 512-byte units */ | |
1079 | --- /dev/null | |
1080 | +++ b/include/linux/string_helpers.h | |
1081 | @@ -0,0 +1,16 @@ | |
1082 | +#ifndef _LINUX_STRING_HELPERS_H_ | |
1083 | +#define _LINUX_STRING_HELPERS_H_ | |
1084 | + | |
1085 | +#include <linux/types.h> | |
1086 | + | |
1087 | +/* Descriptions of the types of units to | |
1088 | + * print in */ | |
1089 | +enum string_size_units { | |
1090 | + STRING_UNITS_10, /* use powers of 10^3 (standard SI) */ | |
1091 | + STRING_UNITS_2, /* use binary powers of 2^10 */ | |
1092 | +}; | |
1093 | + | |
1094 | +int string_get_size(u64 size, enum string_size_units units, | |
1095 | + char *buf, int len); | |
1096 | + | |
1097 | +#endif | |
1098 | --- a/include/scsi/scsi_device.h | |
1099 | +++ b/include/scsi/scsi_device.h | |
1100 | @@ -42,9 +42,11 @@ enum scsi_device_state { | |
1101 | * originate in the mid-layer) */ | |
1102 | SDEV_OFFLINE, /* Device offlined (by error handling or | |
1103 | * user request */ | |
1104 | - SDEV_BLOCK, /* Device blocked by scsi lld. No scsi | |
1105 | - * commands from user or midlayer should be issued | |
1106 | - * to the scsi lld. */ | |
1107 | + SDEV_BLOCK, /* Device blocked by scsi lld. No | |
1108 | + * scsi commands from user or midlayer | |
1109 | + * should be issued to the scsi | |
1110 | + * lld. */ | |
1111 | + SDEV_CREATED_BLOCK, /* same as above but for created devices */ | |
1112 | }; | |
1113 | ||
1114 | enum scsi_device_event { | |
1115 | @@ -384,10 +386,23 @@ static inline unsigned int sdev_id(struc | |
1116 | #define scmd_id(scmd) sdev_id((scmd)->device) | |
1117 | #define scmd_channel(scmd) sdev_channel((scmd)->device) | |
1118 | ||
1119 | +/* | |
1120 | + * checks for positions of the SCSI state machine | |
1121 | + */ | |
1122 | static inline int scsi_device_online(struct scsi_device *sdev) | |
1123 | { | |
1124 | return sdev->sdev_state != SDEV_OFFLINE; | |
1125 | } | |
1126 | +static inline int scsi_device_blocked(struct scsi_device *sdev) | |
1127 | +{ | |
1128 | + return sdev->sdev_state == SDEV_BLOCK || | |
1129 | + sdev->sdev_state == SDEV_CREATED_BLOCK; | |
1130 | +} | |
1131 | +static inline int scsi_device_created(struct scsi_device *sdev) | |
1132 | +{ | |
1133 | + return sdev->sdev_state == SDEV_CREATED || | |
1134 | + sdev->sdev_state == SDEV_CREATED_BLOCK; | |
1135 | +} | |
1136 | ||
1137 | /* accessor functions for the SCSI parameters */ | |
1138 | static inline int scsi_device_sync(struct scsi_device *sdev) | |
1139 | --- a/include/scsi/scsi_netlink.h | |
1140 | +++ b/include/scsi/scsi_netlink.h | |
1141 | @@ -22,6 +22,9 @@ | |
1142 | #ifndef SCSI_NETLINK_H | |
1143 | #define SCSI_NETLINK_H | |
1144 | ||
1145 | +#include <linux/netlink.h> | |
1146 | + | |
1147 | + | |
1148 | /* | |
1149 | * This file intended to be included by both kernel and user space | |
1150 | */ | |
1151 | @@ -55,7 +58,41 @@ struct scsi_nl_hdr { | |
1152 | #define SCSI_NL_TRANSPORT_FC 1 | |
1153 | #define SCSI_NL_MAX_TRANSPORTS 2 | |
1154 | ||
1155 | -/* scsi_nl_hdr->msgtype values are defined in each transport */ | |
1156 | +/* Transport-based scsi_nl_hdr->msgtype values are defined in each transport */ | |
1157 | + | |
1158 | +/* | |
1159 | + * GENERIC SCSI scsi_nl_hdr->msgtype Values | |
1160 | + */ | |
1161 | + /* kernel -> user */ | |
1162 | +#define SCSI_NL_SHOST_VENDOR 0x0001 | |
1163 | + /* user -> kernel */ | |
1164 | +/* SCSI_NL_SHOST_VENDOR msgtype is kernel->user and user->kernel */ | |
1165 | + | |
1166 | + | |
1167 | +/* | |
1168 | + * Message Structures : | |
1169 | + */ | |
1170 | + | |
1171 | +/* macro to round up message lengths to 8byte boundary */ | |
1172 | +#define SCSI_NL_MSGALIGN(len) (((len) + 7) & ~7) | |
1173 | + | |
1174 | + | |
1175 | +/* | |
1176 | + * SCSI HOST Vendor Unique messages : | |
1177 | + * SCSI_NL_SHOST_VENDOR | |
1178 | + * | |
1179 | + * Note: The Vendor Unique message payload will begin directly after | |
1180 | + * this structure, with the length of the payload per vmsg_datalen. | |
1181 | + * | |
1182 | + * Note: When specifying vendor_id, be sure to read the Vendor Type and ID | |
1183 | + * formatting requirements specified below | |
1184 | + */ | |
1185 | +struct scsi_nl_host_vendor_msg { | |
1186 | + struct scsi_nl_hdr snlh; /* must be 1st element ! */ | |
1187 | + uint64_t vendor_id; | |
1188 | + uint16_t host_no; | |
1189 | + uint16_t vmsg_datalen; | |
1190 | +} __attribute__((aligned(sizeof(uint64_t)))); | |
1191 | ||
1192 | ||
1193 | /* | |
1194 | @@ -83,5 +120,28 @@ struct scsi_nl_hdr { | |
1195 | } | |
1196 | ||
1197 | ||
1198 | +#ifdef __KERNEL__ | |
1199 | + | |
1200 | +#include <scsi/scsi_host.h> | |
1201 | + | |
1202 | +/* Exported Kernel Interfaces */ | |
1203 | +int scsi_nl_add_transport(u8 tport, | |
1204 | + int (*msg_handler)(struct sk_buff *), | |
1205 | + void (*event_handler)(struct notifier_block *, unsigned long, void *)); | |
1206 | +void scsi_nl_remove_transport(u8 tport); | |
1207 | + | |
1208 | +int scsi_nl_add_driver(u64 vendor_id, struct scsi_host_template *hostt, | |
1209 | + int (*nlmsg_handler)(struct Scsi_Host *shost, void *payload, | |
1210 | + u32 len, u32 pid), | |
1211 | + void (*nlevt_handler)(struct notifier_block *nb, | |
1212 | + unsigned long event, void *notify_ptr)); | |
1213 | +void scsi_nl_remove_driver(u64 vendor_id); | |
1214 | + | |
1215 | +void scsi_nl_send_transport_msg(u32 pid, struct scsi_nl_hdr *hdr); | |
1216 | +int scsi_nl_send_vendor_msg(u32 pid, unsigned short host_no, u64 vendor_id, | |
1217 | + char *data_buf, u32 data_len); | |
1218 | + | |
1219 | +#endif /* __KERNEL__ */ | |
1220 | + | |
1221 | #endif /* SCSI_NETLINK_H */ | |
1222 | ||
1223 | --- a/include/scsi/scsi_transport_fc.h | |
1224 | +++ b/include/scsi/scsi_transport_fc.h | |
1225 | @@ -167,6 +167,26 @@ enum fc_tgtid_binding_type { | |
1226 | struct device_attribute dev_attr_vport_##_name = \ | |
1227 | __ATTR(_name,_mode,_show,_store) | |
1228 | ||
1229 | +/* | |
1230 | + * fc_vport_identifiers: This set of data contains all elements | |
1231 | + * to uniquely identify and instantiate a FC virtual port. | |
1232 | + * | |
1233 | + * Notes: | |
1234 | + * symbolic_name: The driver is to append the symbolic_name string data | |
1235 | + * to the symbolic_node_name data that it generates by default. | |
1236 | + * the resulting combination should then be registered with the switch. | |
1237 | + * It is expected that things like Xen may stuff a VM title into | |
1238 | + * this field. | |
1239 | + */ | |
1240 | +#define FC_VPORT_SYMBOLIC_NAMELEN 64 | |
1241 | +struct fc_vport_identifiers { | |
1242 | + u64 node_name; | |
1243 | + u64 port_name; | |
1244 | + u32 roles; | |
1245 | + bool disable; | |
1246 | + enum fc_port_type vport_type; /* only FC_PORTTYPE_NPIV allowed */ | |
1247 | + char symbolic_name[FC_VPORT_SYMBOLIC_NAMELEN]; | |
1248 | +}; | |
1249 | ||
1250 | /* | |
1251 | * FC Virtual Port Attributes | |
1252 | @@ -197,7 +217,6 @@ struct device_attribute dev_attr_vport_# | |
1253 | * managed by the transport w/o driver interaction. | |
1254 | */ | |
1255 | ||
1256 | -#define FC_VPORT_SYMBOLIC_NAMELEN 64 | |
1257 | struct fc_vport { | |
1258 | /* Fixed Attributes */ | |
1259 | ||
1260 | @@ -732,6 +751,8 @@ void fc_host_post_vendor_event(struct Sc | |
1261 | * be sure to read the Vendor Type and ID formatting requirements | |
1262 | * specified in scsi_netlink.h | |
1263 | */ | |
1264 | +struct fc_vport *fc_vport_create(struct Scsi_Host *shost, int channel, | |
1265 | + struct fc_vport_identifiers *); | |
1266 | int fc_vport_terminate(struct fc_vport *vport); | |
1267 | ||
1268 | #endif /* SCSI_TRANSPORT_FC_H */ | |
1269 | --- a/lib/Makefile | |
1270 | +++ b/lib/Makefile | |
1271 | @@ -19,7 +19,8 @@ lib-$(CONFIG_SMP) += cpumask.o | |
1272 | lib-y += kobject.o kref.o klist.o | |
1273 | ||
1274 | obj-y += bcd.o div64.o sort.o parser.o halfmd4.o debug_locks.o random32.o \ | |
1275 | - bust_spinlocks.o hexdump.o kasprintf.o bitmap.o scatterlist.o | |
1276 | + bust_spinlocks.o hexdump.o kasprintf.o bitmap.o scatterlist.o \ | |
1277 | + string_helpers.o | |
1278 | ||
1279 | ifeq ($(CONFIG_DEBUG_KOBJECT),y) | |
1280 | CFLAGS_kobject.o += -DDEBUG | |
1281 | --- /dev/null | |
1282 | +++ b/lib/string_helpers.c | |
1283 | @@ -0,0 +1,64 @@ | |
1284 | +/* | |
1285 | + * Helpers for formatting and printing strings | |
1286 | + * | |
1287 | + * Copyright 31 August 2008 James Bottomley | |
1288 | + */ | |
1289 | +#include <linux/kernel.h> | |
1290 | +#include <linux/math64.h> | |
1291 | +#include <linux/module.h> | |
1292 | +#include <linux/string_helpers.h> | |
1293 | + | |
1294 | +/** | |
1295 | + * string_get_size - get the size in the specified units | |
1296 | + * @size: The size to be converted | |
1297 | + * @units: units to use (powers of 1000 or 1024) | |
1298 | + * @buf: buffer to format to | |
1299 | + * @len: length of buffer | |
1300 | + * | |
1301 | + * This function returns a string formatted to 3 significant figures | |
1302 | + * giving the size in the required units. Returns 0 on success or | |
1303 | + * error on failure. @buf is always zero terminated. | |
1304 | + * | |
1305 | + */ | |
1306 | +int string_get_size(u64 size, const enum string_size_units units, | |
1307 | + char *buf, int len) | |
1308 | +{ | |
1309 | + const char *units_10[] = { "B", "KB", "MB", "GB", "TB", "PB", | |
1310 | + "EB", "ZB", "YB", NULL}; | |
1311 | + const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB", | |
1312 | + "EiB", "ZiB", "YiB", NULL }; | |
1313 | + const char **units_str[] = { | |
1314 | + [STRING_UNITS_10] = units_10, | |
1315 | + [STRING_UNITS_2] = units_2, | |
1316 | + }; | |
1317 | + const int divisor[] = { | |
1318 | + [STRING_UNITS_10] = 1000, | |
1319 | + [STRING_UNITS_2] = 1024, | |
1320 | + }; | |
1321 | + int i, j; | |
1322 | + u64 remainder = 0, sf_cap; | |
1323 | + char tmp[8]; | |
1324 | + | |
1325 | + tmp[0] = '\0'; | |
1326 | + | |
1327 | + for (i = 0; size > divisor[units] && units_str[units][i]; i++) | |
1328 | + remainder = do_div(size, divisor[units]); | |
1329 | + | |
1330 | + sf_cap = size; | |
1331 | + for (j = 0; sf_cap*10 < 1000; j++) | |
1332 | + sf_cap *= 10; | |
1333 | + | |
1334 | + if (j) { | |
1335 | + remainder *= 1000; | |
1336 | + do_div(remainder, divisor[units]); | |
1337 | + snprintf(tmp, sizeof(tmp), ".%03lld", | |
1338 | + (unsigned long long)remainder); | |
1339 | + tmp[j+1] = '\0'; | |
1340 | + } | |
1341 | + | |
1342 | + snprintf(buf, len, "%lld%s%s", (unsigned long long)size, | |
1343 | + tmp, units_str[units][i]); | |
1344 | + | |
1345 | + return 0; | |
1346 | +} | |
1347 | +EXPORT_SYMBOL(string_get_size); |